Marks an agent session offline. The vertex is preserved so the next register call can refresh it; the live presence record is removed.

Fetches a single agent session by RID, with live_present indicating live MCP connection state.

Refreshes an agent session's heartbeat. Bumps last_heartbeat_at to keep the agent marked online. Call periodically (~30s) to avoid being swept offline.

Lists agent sessions owned by the current user. Each entry includes a live_present flag indicating whether the agent has a live ETS frame (i.e., currently connected via MCP).

Registers an MCP agent session. Upserts on (user_id, machine_id, alias) — reconnects update the existing row. Returns the agent_session_id used by other tools.

Cancels a pending work item (pending → cancelled). Cannot cancel items that are already processing.

Atomically claims a pending work item and completes it. Use this when the agent already knows the result and doesn't need a separate processing step — collapses the (claim → complete) two-call sequence into one. Idempotent: if the item is already in 'processing', skips the claim and just completes. Items in terminal states (completed/failed/cancelled) return an error.

Claims a pending work item for processing (pending → processing). Call this before starting to process a work item.

Marks a work item as completed with optional result and output. If output_item_type was configured, creates the output item. Triggers connected sentry if configured. Item must be in 'processing' status — call ai-claim_work_item first, or use ai-claim_and_complete_work_item to do both atomically.

Gets the count of pending AI work items. Useful for checking if there's work available.

Marks a work item as failed with an error message.

Gets a specific AI work item with full details including prompt, input_items, and configuration.

Lists AI work items. By default returns pending items sorted by priority. Use this to find work for AI agents to process.

Generates a PDF invoice and stores it as a file item in the specified case.

Generates a LaTeX invoice document and stores it as a file item in the specified case.

Gets or creates the main calendar

Gets or creates a calendar day (also creates month if needed)

Adds a documentation entry to a case following the CMMN tCmmnElement pattern. Returns the updated case with all documentation entries.

Adds a tag to a case for categorization

Creates a new CMMN case

Deletes a case

Gets a specific case by ID

Gets the parent case of a sub-case (if any)

Lists all cases

Lists all documentation entries for a case. Returns array of {id, text, textFormat, created_at, created_by}.

Lists all cases in a workspace

Lists all sub-cases of a parent case (CaseTask pattern)

Loads a case's full context in ONE call: case metadata, all items with content, and sub-cases recursively. Use this instead of multiple cases-get + items-list + items-get calls when the user says 'load this case into context' or similar.

Removes a documentation entry from a case by its ID.

Removes a tag from a case

Updates a case name, description, and/or parent case

Updates a case's lifecycle status with CMMN transition validation. Automatically sets timestamps. Valid transitions: active → completed|terminated|suspended|failed, suspended → active|terminated, completed → active|closed, terminated → closed, failed → closed, closed → active.

Creates a new client (billing entity)

Deletes a client

Gets a client by ID

Gets a client by name

Lists all clients

Updates a client

Achieves a milestone (transitions from available to completed). Sets achieved_at timestamp.

Activates an event listener (available -> active). For timers, calculates and schedules the next trigger time.

Adds a discretionary item to a running case by instantiating from a PlanItemDefinition. The definition must be marked as discretionary.

Adds items from a Case Plan Model to an existing case. Creates a 'model' container item that holds all model items as children, allowing the entire workflow to be managed as a unit. Returns model_item_id for the container.

Checks if a single condition is satisfied without updating any sentry. Useful for AI to preview conditions.

Judge-layer task completion (case #1:4264 phase 3). Evaluates the task's acceptance_criteria against the supplied evidence. On satisfied: completes the task. On not_satisfied: returns a judge_rejected halt with per-criterion verdicts. On uncertain (manual criteria present): returns user_review_required (phase 4 will introduce LLM judging). Tasks with no acceptance_criteria fall through to cmmn-complete_task semantics.

Phase 7 — stage analogue of cmmn-claim_complete_with_evidence. Evaluates the stage's acceptance_criteria against evidence; on satisfied, transitions the stage to completed. Otherwise returns a judge_rejected or judge_uncertain halt.

Completes a task. Stores result in task.data.result, sets status to completed, and evaluates sentries. Pre-flight gates: human tasks require confirm_human=true; tasks in 'available' state with unsatisfied entry sentries return 'blocked_by'; tasks with acceptance_criteria require the judge-layer evidence path — call cmmn-claim_complete_with_evidence instead, OR use force=true here to bypass. Use force=true to bypass any gate when the user has explicitly confirmed.

Creates a CMMN Event Listener - timer, user, or generic event that can trigger sentries.

Creates a CMMN Milestone - an achievable target that marks important progress (no work, just achievement).

Creates a Planning Table that defines which discretionary items can be added at runtime to a stage or case.

Creates a CMMN Sentry with optional CMMN 1.1 enhancements (multiple conditions, evaluation modes).

Creates a CMMN Stage for grouping related plan items (tasks, milestones, other stages).

Creates a CMMN-aligned task with lifecycle state management

Evaluates a sentry's conditions and updates its satisfied status. Returns detailed results for each condition.

Executes a stage by traversing its task tree depth-first. Human tasks pause execution. IMPORTANT: When the result contains next_actions with action_required='llm_execute', YOU (the calling LLM) MUST process each prompt immediately. Read the 'prompt' field, execute the work it describes, then call cmmn-complete_task with the task_id and your result. Do NOT just report these back to the user — you are the executor. The stage is not complete until all llm_execute actions have been processed and their tasks completed.

Executes a single task directly. Process/decision/case tasks execute automatically. Human tasks return an error (use update_task_status instead). IMPORTANT: When the result contains action_required='llm_execute' or a 'prompt' field, YOU (the calling LLM) MUST execute the prompt immediately, then call cmmn-complete_task with the task_id and your result. You are the executor — do the work, don't just report it.

Returns the judge-layer acceptance criteria + required_evidence for a task. Each criterion has id, text, verifier. verifier is a registered automated check name (e.g. schema_check, file_exists) or 'manual' (deferred to LLM judge). Backwards-compatible: if only legacy data.exit_criteria strings exist, they're normalized to manual criteria with auto-generated ids. Phase 1 of case #1:4264.

Gets the execution flow for a case by traversing OnPart and Guards edges. Returns workflow connections showing which items trigger sentries (OnPart) and which items are guarded by sentries (Guards). Useful for visualizing CMMN workflow dependencies.

Preview execution order for a stage without executing. Shows which items are blocked by sentries and execution dependencies.

Gets the next task to execute in a case workflow. Returns the task with gathered context (from context_sources), prompt, and result_schema. For human tasks, this is what to present to the user. For process tasks, includes execution instructions.

Gets context for AI to resume work on a case. Returns active/suspended/enabled tasks, recent completions, and summary.

Lists all models that have been added to a case (via add_model_to_case or instantiate).

Lists all discretionary items available for a stage or case. Returns planning tables and their available PlanItemDefinitions.

Lists CMMN plan items for a case. Filter by type (task/stage/milestone/event_listener/sentry) and/or status.

Lists all sentries (entry and exit criteria) that guard an item.

Marks a specific condition/part of a sentry as satisfied (for onPart evaluation mode).

Marks a sentry as satisfied. Sets satisfied=true and records timestamp.

Resets a sentry to unsatisfied state, clearing all satisfied_parts. Used when re-evaluation is needed.

Resets a completed stage to active state for re-execution. The stage executor can then re-process its child tasks. Use cascade=true to also reset all downstream items.

Resets a task to allow re-execution. Returns reset_items audit listing every item touched (id, name, type, from_status, to_status). With cascade=true, walks the sentry graph forward and resets all downstream items so cmmn-execute_stage will re-run them rather than skipping completed work. With dry_run=true, returns the same audit without applying. Existing result data and child items are kept.

Sets the judge-layer acceptance criteria on a task. The runtime judge (case #1:4264 phase 3) will evaluate these when the agent claims completion via cmmn-claim_complete_with_evidence. Workflow authors call this to attach verification recipes — schema_check for SQL migrations, command_runs_clean for build steps, manual for natural-language assertions.

Terminates an event listener (cancels any scheduled timer jobs).

Manually triggers an event listener (marks as completed). Use for user events or testing.

Updates a sentry's fields after creation. If guards_item or source_ref change, the corresponding graph edges (Guards/OnPart) are automatically deleted and recreated.

Updates a stage's status with CMMN transition validation. Automatically sets timestamps. Valid transitions: available → enabled|disabled, enabled → active|disabled, disabled → enabled, active → completed|terminated|failed|suspended, suspended → active|terminated. Note: Stages with acceptance_criteria require cmmn-claim_stage_complete_with_evidence when transitioning to 'completed' (or pass force=true).

Updates a task's status with CMMN transition validation. Automatically sets timestamps. Valid transitions: available → enabled|disabled, enabled → active|disabled, disabled → enabled, active → completed|terminated|failed|suspended, suspended → active|terminated. Tip: To complete a task from any startable state (available/enabled/active), use cmmn-complete_task instead — it auto-transitions through intermediate states.

Validates a timer expression without creating anything. Returns parsed details (seconds for duration, datetime for date, next_trigger for cron) or an error message. Use before creating timer event listeners to catch expression errors early.

Verifies sentry JSON data matches graph edges. Returns count of matching sentries and any mismatches where source_ref or guards_item JSON fields don't match OnPart/Guards edges. Useful for data integrity checks.

Finds a file by name within a case. Returns the file item if found, null if not.

Lists all versions of a file, including current version info and version history

Reads file content from storage. Images (PNG, JPEG, GIF, WebP, SVG) are returned as native MCP image content blocks that LLMs can view directly. Non-image files return base64-encoded content by default, or plain text if encoding='text'.

Gets all items linked from a vertex. Optionally filter by link_type (e.g., 'context').

Creates a LinkedTo edge between any two vertices. Use link_type='context' to link a case as a context source.

Removes a LinkedTo edge between two vertices

Creates a standalone Invoice vertex with a BillTo edge to the specified client.

Deletes an invoice

Gets an invoice by ID

Gets the client for an invoice via BillTo edge. Returns the Client details.

Gets all durations linked to an invoice

Gets all expenses linked to an invoice

Links a duration or expense to an invoice

Lists invoices, optionally filtered by client, billing period, or status

Lists all durations not yet linked to any invoice

Lists all expenses not yet linked to any invoice

Unlinks a duration or expense from an invoice

Updates an invoice

Adds an existing item as a child of another item

Adds a documentation entry to a CaseFileItem following the CMMN tCmmnElement pattern. Documentation is stored in data.documentation array.

Converts a CaseFileItem from one type to another. Supported conversions among todo, note, task, and checkbox (todo<->note, todo<->task, note<->task, todo<->checkbox, note<->checkbox). Previous data is preserved for recovery.

Creates a case file item. Set 'type' to choose the item type. Common params: case_id, name/title, parent_id, tags, description. Type-specific: note(content), bookmark(url,title), todo(title,status,priority,due_date), duration(start_time,end_time,billable), expense(description,amount,date), invoice(invoice_number,amount,client_id), file(filename), folder(name), checkbox(label,checked), journal_entry(content,mood), sms(body,to), directory(path), desktop(name).

Deletes a case file item. If it's a file, also removes the stored file (unless referenced by other items)