Stable Baseline

Per-item: apply a successor's `suggested_start_date`/`suggested_end_date` to its real dates and clear `needs_dependency_review`. For a whole-plan cascade use `applyTaskDependencyCascade`.

Add a comment or activity entry to an improvement.

Add evidence to an improvement. Types: document_section, diagram_node, incident_note, feedback, free_text.

Add a comment or activity entry to a plan. People read a plan's entries on its Activity tab in the app, newest first, and the answer links straight to it. An entry added through an API key or a connected app shows that key's or app's name, marked as an agent. getPlan returns the newest 50 entries.

Add a user to a team as a regular member. Idempotent — returns already_member=true if already on the team. User must be an active organisation member.

Author shapes onto a whiteboard from high-level specs (you do NOT need the full Excalidraw element schema). Appends to the canvas. PLACEMENT ON AN EXISTING BOARD (critical): NEVER guess x/y onto a board that already has content — guessed coordinates land ON TOP of existing shapes and create an unreadable pile. Either (a) OMIT x/y entirely and the server auto-places the new elements together in clear space BELOW the current content, or (b) FIRST call getWhiteboard({ includeElements:true }) to see where existing shapes already are and choose a genuinely EMPTY region. Pass explicit x/y only for a deliberate layout in space you have confirmed is empty. PREFER THE RICHEST FORM THAT FITS, not plain rectangles: for a sticky/post-it note use { type:'sticky', text, backgroundColor } (a first-class note with an auto-fitting bound label — there is NO sticky-note stencil; OMIT x/y and it is auto-placed in clear space below existing content, so it doesn't land on top of the current drawing); for kanban/scrum/story boards, flowcharts, UML/ER, BPMN, org charts, wireframes/mockups, charts or people use a LIBRARY STENCIL in ONE call — { type:'stencil', stencil:'<name e.g. decision>', x, y } fuzzy-matches by name with no prior listWhiteboardStencils call (pass width/height to SCALE the whole stencil and text to fill its single label); for cloud/software-architecture use ICONS — { type:'image', iconPath:'dev/docker.svg', x, y } (paths from listArchitectureIcons); reserve raw rectangles/ellipses for when no standard form fits. Expressive enough to reproduce hand-drawn style templates (sticky-note brainstorm grids, sketchy mind maps, flowcharts). Each spec: { type: 'rectangle'|'ellipse'|'diamond'|'sticky'|'text'|'arrow'|'line'|'freedraw'|'frame'|'image'|'stencil', id?, x, y, width, height, text? (STRONGLY PREFER setting a shape's label via its own `text` — it becomes a centred, auto-WRAPPED bound label fitted to the shape; do NOT drop a separate type:'text' element on top of a shape as its label. Standalone type:'text' is for free-floating titles/notes and now also wraps to its width; Yes/No label on an arrow — emojis are fine, e.g. a warning sign in a 'Risks' label), fontSize?, fontFamily? (1=hand-drawn default, 2=normal, 3=code), textAlign?, backgroundColor? (name 'blue'/'green'/'yellow'/'pink'/'violet'/'orange'/'teal'/… or hex), strokeColor?, fillStyle? ('solid'|'hachure'|'cross-hatch'), strokeStyle? ('solid'|'dashed'|'dotted' — use 'dashed' for grid/category borders), strokeWidth? (1 thin/2 bold/4 extra), roughness? (0 clean, 1 default, 2 very sketchy/hand-drawn — use 2 for organic mind maps), roundness? (number type or null for sharp), opacity?, name? (frame title), frameId? (put a shape inside a frame), start?:{id}, end?:{id} (connect arrows/lines to shapes by id — connectors AUTO-CLIP to the shape edges, never overrun to the centre, AUTO-ROUTE around any shapes in between so a decision's No/loop-back branch never cuts straight through the boxes between source and target, and bound text auto-wraps + centres), routing? ('straight' default | 'elbow' for clean right-angle flowchart/org-chart connectors | 'curved'), startArrowhead?/endArrowhead? (arrowheads are SOLID filled triangles by default — just OMIT them. Pass null for a plain mind-map spoke with no head. Do NOT pass 'arrow': that is the open 'V' head and is auto-upgraded to a solid triangle anyway), points? ([[0,0],[dx,dy]] relative, only for manual geometry — almost never needed; binding by id is better), props? (escape hatch: any other Excalidraw field) }. ARCHITECTURE ICONS: to place a software-architecture icon (AWS/Azure/GCP/Docker/Kubernetes/databases/etc.), first call listArchitectureIcons to find one, then add a spec { type:'image', iconPath:'<relative_url e.g. dev/docker.svg>', x, y, width:96, height:96, text?:'<caption shown below>' } — the icon is stored as a URL reference (never base64). Use imageUrl instead of iconPath for any other public image. Combine icons with labelled boxes + elbow arrows for clean architecture diagrams. LIBRARY STENCILS: for hand-drawn, on-brand elements (scrum/kanban columns, flowchart symbols, UML/ER, BPMN, org-chart nodes, wireframe widgets, stick figures), FIRST call listWhiteboardStencils to find one, then add { type:'stencil', stencilKey:'<key from listWhiteboardStencils>', x, y } (or { type:'stencil', stencil:'<name e.g. decision>', pack?:'<pack>', x, y } to fuzzy-match by name). A stencil is a mini-whiteboard (a collection of elements) of kind 'symbol' or 'template' (listWhiteboardStencils returns the kind + its embedded `labels`). For a SYMBOL (one atomic labelled node — flowchart box, BPMN task, org node), pass id + text + width/height: the label auto-fits its single slot and arrows bind to it via start/end {id}. For a TEMPLATE (a multi-component layout — Alerts, Forms, Tables, Charts), place it WHOLE (no single text); the result returns its `children` (id + text + colour + position) so you retext, recolour, or DELETE specific parts by id via updateWhiteboardScene (cluster children by y to act on a whole row/variant). STRONGLY prefer stencils over plain rectangles for wireframes/mockups, kanban/scrum boards, UML/BPMN, org charts; for dense flowcharts, plain shapes with bound text + elbow arrows are equally reliable. (For a plain sticky/post-it note use type:'sticky', NOT a stencil — there is no sticky-note stencil.) FRAMES: a frame is a NON-DESTRUCTIVE, ANY-SIZE container. To enclose shapes that ALREADY exist, add ONE type:'frame' sized to cover them (a frame automatically captures the elements inside its bounds) or set those shapes' frameId — never recreate or delete-and-redraw content just to frame it. If a frame doesn't fully cover its content, just RESIZE the frame (patch its width/height). Deleting a frame (deleteIds:[frameId]) leaves all its contents intact on the canvas — it only removes the frame border + title. PRESENTATION/SLIDES: when the user wants a presentation or slide deck, create type:'frame' slides sized width:1280,height:720 (16:9), laid out LEFT-TO-RIGHT at the same y (x: 0, then 1440, 2880, 4320, …), each with a `name` (the slide title). Put every slide's shapes/text/images INSIDE its frame by setting their frameId to that frame's id (give the frame an id and reference it). Slides play in order (left-to-right, then top-to-bottom) in the board's Present mode and export to PPTX, so one frame = one slide. FLOWCHART recipe: rectangles (roundness null for sharp process boxes), diamonds for decisions, arrows with routing:'elbow' and Yes/No as the arrow's text. Use type 'sticky' for sticky/post-it notes (a solid-fill note with an auto-fitting bound label — set text + backgroundColor); type 'line' with no arrowheads + roughness:2 for sketchy mind-map spokes. FREEHAND DOODLES: to actually draw/doodle/sketch freehand, use { type:'freedraw', points } where points is a RELATIVE [[x,y],…] path of the stroke (e.g. a squiggle, circling or annotating something, a hand-drawn star/heart/smiley/arrow, an organic blob) — it renders as one smooth freehand stroke. x/y is the origin; omit x/y to auto-place. Chain several freedraw specs for a multi-stroke doodle. NOTE: freehand is always SOLID (strokeStyle is ignored on freedraw) — colour, strokeWidth and opacity DO apply; a freedraw with strokeStyle:'dashed' or 'dotted' is automatically rendered as a smooth dashed/dotted line so the dashes actually show. Give shapes ids and reference them from connectors. Connectors may also bind to shapes ALREADY on the board by their id (get them via getWhiteboard includeElements:true) — you do NOT need to resend existing shapes; the server reads the live scene to bind the arrow and route it around the other boxes. Great for brainstorms, mind maps, flowcharts, org charts, SWOT, retros. PROCESS: for any non-trivial board call getWhiteboardGuide FIRST to plan it; then after adding, ALWAYS call getWhiteboardImage to SEE the result and check layout, labels, spacing, overlaps and how shapes connect — if anything looks off, fix it with updateWhiteboardScene (patch by id) and render again, iterating until it looks right. RESULT: returns `added` (count), `placement` (bounding box {x,y,width,height} of what you just added) and `autoPlaced` (true when you omitted x/y so it was placed in clear space below existing content) — use placement/autoPlaced to tell the user WHERE the new elements landed, never invent a location.

Add an existing organisation member to a workspace with a workspace-level role. Idempotent — returns the existing membership if already a member. Caller must be a workspace owner or admin.

Apply a previously previewed KG scope change. Atomically writes kg_scope rows and dispatches a re-ingest batch (batch_id = token). Databases and tables in the token are applied in the same step: their name keys are built from their own fields (no AI), and switching one off removes them. Idempotent. Rate limit 5/h.

Apply a previously previewed subscription change. Same-tier seat changes update Stripe in place; cross-tier upgrades from Free return a hosted Checkout URL. Refuses target=free (use cancelSubscription) and target=enterprise (sales-led). Rate limit 5/h. Use only AFTER previewSubscriptionChange and after the user confirms the preview's pricing — never call apply without the user seeing the preview first.

Auto-schedule every item in a plan so all FS/SS/FF task-dependencies are respected (topological pass, durations preserved). Returns the before/after diff and logs a comment on every item that moves. Use `forwardOnly: true` to only shift items currently in violation (never pull already-valid items earlier). Use `pinnedItemIds` to keep specific items at their current dates. Pairs with `previewTaskDependencyCascade` (same inputs, dry-run).

Approve or decline a change an agent proposed (a pending approval from askAgent, delegateToAgent or getAgentRun). Only the people it was sent to may decide it (the person who asked for the job; for a duty, its owner and backup approvers), and only while they can read what the job read: anyone else on its list is refused, and an approval they may not review comes without its content (mayReview false). Approving lets the job continue: this call waits up to 20 seconds and answers with the job's outcome and receipt if it settles in time, or its progress to follow with getAgentRun. The change runs as the agent, still within the rights of the person who started the job. Declining cancels the job with your reason. A plan approval (`kind: plan`) approves or declines the whole plan at once; only someone who can see every step's item may decide it, it expires after 24 hours and it is used once. Pass the plan's `digest` (getAgentRun `plan.digest`) to be sure you approve the plan you reviewed: a different digest is refused and nothing is decided.

Ask an organisation agent a question and get its answer with provenance (the documents, plans and items it read). The agent runs under its own scoped credential and acts for you, so it only reaches what it was granted AND what you may reach yourself through this credential. The question starts a background job and this call waits for it for up to `waitSeconds` (default 20, at most 45): an answer that is ready in time comes back with the job's `receipt`; otherwise you get `status: running` (or `queued`), `progress` and `pollAfterSeconds`, and you follow the job with getAgentRun until it settles. Pass the same `idempotencyKey` when you retry, so a retry returns the same job instead of starting another. The run's approval level (`approvalMode`, else the agent's own level) decides which changes wait for a person: a change that must wait pauses the job (`status: awaiting_approval`, `pendingApprovals`, each with a `preview` that also states any fee a tool with its own fee charges when it runs) until approveAgentAction decides it. A job that reaches its budget pauses (`status: paused`, `pauseReason: budget_reached`, a summary of what is done and left); continue it with delegateToAgent `continueRunId`.

Auto-design a complete, visually polished whiteboard from a natural-language goal using the PREMIUM multi-agent pipeline (the same one the in-app assistant uses): it browses the stencil/icon library, composes the WHOLE board, renders it, critiques the rendered image, and refines — far better than hand-placing shapes. This is the one-shot whole-board designer; it is NOT a conversation (for a deck you can chat with and refine turn by turn use designDeckInWhiteboard, and for a refinable illustration use designIllustrationInWhiteboard). COST + APPROVAL: this costs 78 credits per board (a meeting map from a transcript is priced by its length) and needs the user's explicit approval. Call it FIRST without `confirm`: it returns the exact cost, the workspace credit balance and a single-use `quoteToken`, and charges nothing. Show the user the price; only if they agree, call again with the same arguments plus `confirm: true` and that `quoteToken` (it works once, for 10 minutes). A confirmed call without the token, or with arguments that changed since the quote, starts nothing and charges nothing: it returns a fresh quote instead. If they decline (or lack credits), build the board directly with the standard whiteboard tools (addWhiteboardElements / insertWhiteboardDiagram / listWhiteboardStencils) at no extra charge. It runs in the BACKGROUND and returns immediately with a sessionId; the board fills in over 1-3 minutes. The 78 credits are refunded automatically if the design fails on our side. Optional `designProfile: 'branded-executive'` instead builds an ON-BRAND, fully-editable McKinsey-style SLIDE DECK themed by the org's brand kit (palette/fonts) — use it when the user wants polished branded business slides; it builds in-process and the board is ready on return. Optional `designProfile: 'illustrated'` instead builds an editable-illustration board: pick it for illustrated, image-based, picture-style, richly-drawn or educational explainer boards (e.g. illustrate photosynthesis, an illustrated diagram of the water cycle, a textbook-style visual). It generates a rich text-free vector illustration and overlays real, editable text labels with leader lines on top. It is available to every organisation and costs the same flat 78 credits (credits are the only gate). Optional `designProfile: 'image'` instead builds a single, polished, on-brand IMAGE board with all the text baked into the picture (no editable shapes): pick 'image' when the user wants a single finished image, poster or infographic they will refine by AI mask edits rather than by moving editable shapes. It is also available to every organisation at the same flat 78 credits.

Emergency stop for KG ingestion: cancels queued/running build runs, queued/running rebuild batches, demotes still-eager unfinished chunks. Optionally narrowed to one project. Requires can_manage_kg + (project write if project_id supplied). Rate limit 5/min.

Cancel a pending invitation by id. Sets status='revoked'. Server resolves the organisation_id from the invitation row; the credential must match that org AND hold can_manage_members. Idempotent. Rate limit 30/min. Use when the user asks to cancel, revoke, or undo a pending invitation — for example to correct a typo'd email address before re-inviting.

Cancel a single KG rebuild batch. Queued runs flip to 'cancelled' immediately; running runs finish naturally. Requires can_manage_kg. Rate limit 5/min.

Apply a previewed soft cancellation (cancel_at_period_end=true). Customer keeps full access until period end. Rate limit 5/h. Use only AFTER previewSubscriptionCancellation and after the user confirms — never cancel without showing the preview first.

Create a per-org BRAND KIT so Stable Baseline outputs come out fully on-brand. Upload your branding and it is auto-applied: pass a `logoUrl` (as little as your logo, and the vision model AUTO-EXTRACTS your palette and fonts), or an `officeUrl` (an existing .pptx/.docx, from which it extracts theme colours, fonts, logo, watermark and the embedded font files), or explicit `tokens`. The kit themes branded-executive slides AND document exports (PDF, Word, PowerPoint). Auth: can_admin_org. The plan sets how many kits an organisation can have; at that limit the call is refused and says so. Optionally set it as the default at a scope in one call.

Create a database, with its tables and fields in one call. Say where it lives: projectId (one project), workspaceId (every project of a workspace) or organisationId (the whole organisation library). Each table takes a name, fields (each a name and a type, with options for its type) and optionally a row rule. Types: text, long_text, url, email, phone, number, currency, percent, rating, auto_number, single_choice, multiple_choice, status, checkbox, date, datetime, duration, person, team, relation (rows of another table: name a table made in the same call, or give its id), lookup and rollup (values read through a relation), artefact_link (Stable Baseline documents, whiteboards, diagrams, plans, tasks or improvements), attachment, formula. A table with no fields starts with a text field called Name; every table also ends with Created on, Created by, Updated on and Updated by, kept by Stable Baseline. If any part fails, nothing is kept. The organisation's plan limits how many databases it can have, and a project holds one database: when the project already has its database, add tables to that one with updateDatabase instead. To duplicate one, give copyOf and a name: it is copied in the background, into the place given or the original's own. getDatabaseGuide topics structure and fields_and_types.

Create a document from CDMD markdown (standard Markdown plus SB extensions — call getCdmdLanguageGuide if unfamiliar). The body goes in `cdmd` (`content` is accepted as an alias). A leading `---` YAML frontmatter block is stored and preserved: title/exported_at/generator are managed by the platform, and any other key you set (doc_type, authority_state, owner, conforms_to, …) round-trips untouched through reads and later edits. Do not include DIAGRAM/IMAGE markers — insert them after with dedicated tools. Returns the new document's id and versionTimestamp (the optimistic-lock token for subsequent edits). Supports @-mentioning people: embed `<!-- REFERENCE: {"type":"user","id":"<user_uuid>","label":"Name"} -->` to notify a teammate. Use listAssignablePrincipals to look up the user_id from a name; mentions of users outside the project are silently dropped.

Step 2 of file ingest. After the file is uploaded via the PUT URL from createDocumentIngestSession, call this to start the async conversion. Returns { jobId, documentId } immediately — the document is created as a draft and progressively populated as the worker processes the file. Poll getDocumentIngestJob({ jobId }) to track progress. Idempotent: calling twice with the same sessionId returns the same job/document.

Step 1 of file ingest. Mint a single-use PUT upload URL for a large file (PDF, DOCX, plain text, or markdown — up to 150 MB). Returns { sessionId, uploadUrl, expiresAt, maxBytes }. Upload the raw bytes to uploadUrl with PUT, then call createDocumentFromUpload({ sessionId, projectId }) to start the conversion. The file is auto-deleted once the document is created.

Create a folder in a project. Supports nesting via parentId.

Create a PUT upload URL for a document image (max 10MB). Use the returned assetUrl with insertImageInDocument. For a dashboard picture (PNG, JPEG, GIF or WebP) pass databaseId and dashboard instead of documentId, PUT the bytes, then use its pictureId in saveDatabaseDashboard.

Create an improvement item in a project. Requires projectId and title. Auto-assigns friendly ID. Accepts every field updateImprovement accepts, so an item can be created complete in one call rather than create-then-update. Pass parentItemId to create it under its epic or story in the work hierarchy, and linkedRecords to link database rows to it. Pass `fields` (for example ["id", "friendlyId", "versionTimestamp"]) for a short answer instead of the whole improvement.

Create an improvement category or sub-category. Max two levels.

Create a new organisation owned by the calling credential's user. Auth: the server checks that the user may create another organisation (free-tier users may only have one org). Per-credential rate limit 3/day. Slug auto-generated. The new org is OUTSIDE the credential's current scope (credentials are bound to one org); to use the new org from MCP, mint a fresh credential.

Create a plan in a project. Requires projectId and title. Pass `fields` (for example ["id", "versionTimestamp"]) for a short answer instead of the whole plan.

Create a phase in a plan. Position and wbs_code are auto-computed. By default a phase's dates follow its tasks (date_mode 'auto'): once any task in it has dates, the phase runs from the earliest task start to the latest task end and stays in step as tasks change, so there is no need to maintain phase dates by hand. Pass `fields` (for example ["id", "versionTimestamp"]) for a short answer instead of the whole phase.

Create a new project inside a workspace. Mirrors the UI Create Project dialog. Auth: write on workspace + credential's `can_lifecycle` capability. Validates name (1..200) and description (0..2000); icon defaults to a folder emoji if omitted. The plan's project limit is checked on the server. Rate limit 30/min.

Create a task in a plan. Requires planId and title. Accepts every field updateTask accepts, so a task can be created complete in ONE call: no create-then-update, and no window in which other actors read a half-written record. Pass parentItemId to create it under its story, requirement or feature in the work hierarchy (which may be in another plan, or in none), and linkedRecords to link database rows to it. Pass `fields` (for example ["id", "friendlyId", "versionTimestamp"]) for a short answer instead of the whole task.

Create an FS/SS/FF scheduling edge with lag/lead between two items in the same plan (rendered as a Gantt arrow). FS = Finish-to-Start, SS = Start-to-Start, FF = Finish-to-Finish. `lagDays`: positive = lag, negative = lead/overlap. Rejects self-loops, duplicate (pred+succ+type) edges, cross-plan edges, and cycles.

Create a new team inside an organisation. Caller is added as the team's lead. Subject to plan team limit. Rate limit 30/min.

Create a PUT upload URL for a Vega/Vega-Lite data file. Use returned assetUrl in your Vega spec.

Create a whiteboard: an infinite freeform canvas. A whiteboard is a hidden document (it won't appear in listDocuments) that hosts a single freeform canvas, and opens in the immersive whiteboard editor in the app. Returns documentId + diagramId. Author shapes afterwards with addWhiteboardElements (high-level specs) or updateWhiteboardScene. For anything beyond a blank board, call getWhiteboardGuide first to plan the layout (stencils vs architecture icons vs code/BPMN diagrams vs plain shapes), and render with getWhiteboardImage to verify as you go.

Create a new workspace inside the organisation. Auth: ceiling — credential must hold `can_lifecycle` AND user must be org owner/admin. Rate limit 30/min. Slug auto-generated. Caller becomes workspace owner. Plan limits surface as WORKSPACE_LIMIT_REACHED errors.

Render tabular data as an aligned grid of labelled cells on a whiteboard, deterministically. Pass rows (an array of arrays) OR data (an array of objects), with optional headers; the server lays out evenly-spaced cells so you do NOT place each cell by hand. Use this to turn data, CSV, or JSON into a readable table on the board. Returns a compact summary. Auto-places below existing content unless x/y are given.

Hand an organisation agent a brief (a piece of work, big or small) and get its job back. The job runs in the background, in steps, and this call waits for it for up to `waitSeconds` (default 20, at most 45): a job that settles in time comes back with its outcome and, once finished, its `receipt` (a short summary, counts of what changed, links, issues that need a person); otherwise you get `status: running` (or `queued`), `progress` and `pollAfterSeconds`, and you follow it with getAgentRun. Changes that must wait at the run's approval level (`approvalMode`, else the agent's own level) land in the approvals inbox and in `pendingApprovals`; decide them with approveAgentAction. Pass the same `idempotencyKey` when you retry. A job that reaches its budget (model steps, tool calls, tokens or 30 minutes of work) pauses with a summary of what is done and left: continue it, with a fresh budget, by calling delegateToAgent with `continueRunId` (no brief needed). A job whose requester loses access to what it needs pauses as `rights_changed`. Plan mode: with `mode: plan`, or at `confirm` and `confirm_destructive` when the job would make more than five changes or delete anything, the agent first drafts the complete change set (reads run, nothing changes) and the job waits for ONE approval of the whole plan: `pendingApprovals` holds it with the counts, any tool fees and the first steps, and getAgentRun `plan` pages every step with its preview. Approving runs exactly those steps, in order, with no model in between. If an item a step changes was edited after the plan was drafted, the job pauses as `conflict` naming it; continuing the job re-plans the remaining steps as a new plan that needs its own approval. Undo: pass `undoRunId` (no brief needed) to undo a finished job. The undo is a job of its own, acting for you: the agent builds the compensating plan from what the job journaled (restore each edited document to its version before the job, move items back, put fields back, delete what the job created) and it waits for ONE approval like any plan. An item changed since the job is skipped, never overwritten, and the plan lists what cannot be undone (permanent deletes, effects outside Stable Baseline such as a meeting bot, and tool fees already charged, which stay charged). The job's requester, the agent's owner and its managers may undo it; getAgentRun `undo` says whether you may now.

Move a whole database, one of its tables (pass table) or one of its dashboards (pass dashboard) to the trash. It can be restored in the app for 30 days, after which it is gone for good. A database or a table goes with every row in it and needs admin access; a dashboard needs write access. A table that another table links to cannot be deleted until that link is removed. To take a page or a visual out of a dashboard, use saveDatabaseDashboard. getDatabaseGuide topic deleting.

Move rows of a table to the trash: up to 500 by id, or every row that matches. They can be restored in the app for 30 days, after which they are gone for good. Needs delete access: admin, or write access with can delete switched on. Every row that matches: where (or view) previews them with a changeId; mode "apply" deletes them, in the same call or by changeId; undo brings them back. getDatabaseGuide topic deleting.

Delete a diagram: removes the database record AND every reference to it in the document body — the current marker format plus legacy forms (markers without an embedded diagramId, and old plain-text `[Diagram: name]` placeholders). The response's removedFromBody says whether a marker was actually found in the body, and versionTimestamp is the document's fresh lock token.

Delete a document.

Delete a folder recursively, including all nested folders and documents.

Delete an image: removes the stored file, the database record, AND the image from the document body — both the IMAGE marker in the markdown and the image node in the document's rich-text content, so the picture stops appearing on every read. Deleting an image the document still references is the point of this tool; do not hand-edit the marker out with editDocument, which removes the reference but leaves the file and record behind.

Delete an improvement and all associated evidence and activity.

Delete an improvement category. Cannot delete system categories.

Delete a comment from an improvement. Only its author, or an admin of the improvement's project, workspace or organisation, can delete it.

Delete a plan, all its phases, and all tasks/improvements within it. This is a destructive operation that cannot be undone.

Delete a comment from a plan. Only its author, or an admin of the plan's project, workspace or organisation, can delete it.

Delete a plan phase and all tasks/improvements within it. This is a destructive operation that cannot be undone.