Create a new node in the workflow graph (e.g. task, decision, artifact, plan, blocker, milestone, observation).

Update properties of an existing node in the workflow graph.

Get a single node by its unique ID, including all its connected inbound and outbound edges.

Delete a node from the workflow graph. Connected relationships (edges) are cascade deleted automatically.

Create a relationship/edge between two nodes. Cycles are rejected for depends_on, blocks, and child_of.

Delete a specific relationship between two nodes.

List nodes with filtering by type, status, tags, and git branch.

Search nodes using full-text search (FTS5) or local TF-IDF vector similarity across title, metadata, and tags.

Retrieve a node and its N-hop neighborhood (nodes and connecting edges).

Trace dependency chains upstream (what depends_on or blocks) or downstream (what is blocked/depended on).

List active blockers and the nodes they block, either project-wide or for a specific node.

Semantic TF-IDF search over solved blockers and observations to discover past resolution patterns.

Automatically transition inactive in_progress tasks idle for longer than a specified threshold.

Retrieve a high-level project summary: counts, status breakdowns, progress, decisions, and blockers.

Trace the full chain of decisions that led to a given state: what was decided, what it updated/superseded, and what it contradicts.

Compute the longest dependency chain to a milestone — the minimum set of tasks that must complete.

Calculate downstream affected nodes if a target node is modified or deleted.

Scan for contradictions (tasks marked done but blocked, accepted contradicting decisions).

Export project nodes and edges in JSON, DOT, Mermaid, or interactive HTML format.

Bulk import nodes and edges (replaces existing project data, requires force parameter if data exists).

Run safe, read-only SELECT SQL queries against the graph database.

Query state graph using natural language free-text ("what is blocking auth?", "decisions led here").

Post an ephemeral message or state update to the multi-agent blackboard.

Read recent messages from the multi-agent blackboard.

Atomically create a feature plan, optional milestone, subtasks, and dependency edges in a single turn.

Analyze an agent session event log and generate a post-mortem observation and report artifact.

Reconstruct historical state memory (nodes and edges) as it existed at a specific ISO timestamp.

Roll back state graph memory to a historical point in time, removing subsequent nodes and edges.

Validate cross-memory references to external file paths and code symbols, optionally auto-healing broken links.

Calculate velocity analytics, task completion rate, average cycle time, and daily throughput breakdown.

Generate burndown chart time-series data, remaining scope, and estimated completion date.

Export tasks and blockers as external issue tracker JSON payloads (GitHub Issues / Jira).

Import external issue tracker issues (GitHub Issues / Jira) into state graph memory.

Analyze state memory nodes created or modified on the current git branch vs a target branch.

Simulate or resolve state memory graph conflicts when merging Git branches.

Rebuild database indexes, prune orphaned edges, and reclaim unused SQLite disk storage.

Flag completed tasks updated before a specified cutoff threshold as archived.

Run system health diagnostics, check schema integrity, WAL status, orphaned edge counts, and generate recommendations.

Observe recent state graph mutations and event log entries since a timestamp or session.

Backup the project's sqlite database file to a target destination.

Restore the project's sqlite database from a backup file (destructively overwrites current project database).

Audit the project's database for physical integrity, foreign key violations, orphaned edges, circular dependencies, and contradictions.

Merge an external sqlite database file into the existing project database, resolving conflicts by keeping the newer updated_at nodes.

Get a comprehensive high-level context snapshot combining summary, active blockers, and immediate pending tasks.

Find all decisions that affected a given artifact (either directly produces it or decided_in a milestone that produces it).

List all tasks that are currently blocked by a given decision node (either directly or transitively).

Scaffold standard feature (fdd) or decision (rfc) workflow templates into the project graph.

Retrieve ROI and productivity health metrics for a project (e.g. estimated time and tokens saved, graph health).

Start a new tracked session with agent identity and metadata.

End an active tracked session.

List active and completed sessions for a project.

Query the project event log with filters.

Mathematically verify the cryptographic SHA-256 event audit chain for non-repudiable tamper resistance.

Subscribe to Context-Aware Shared Context Store (CA-MCP) state reactor triggers for constant O(1) LLM coordination.

Reset task execution state back to a prior validated node when downstream test/verification fails.

Calculate Intrinsic (ICL) and Extraneous (ECL) cognitive load metrics for the active task graph.

Get the full chronological mutation history of a specific node.

Revert the last recorded mutation for a specific node.

Save a persistent context snapshot of the current graph state.

List saved snapshots for the project.

Compare two snapshots and return semantic node/edge changes.

Export event transition logs in JSONL format for fine-tuning models.

Update the status, metadata, or tags of multiple nodes in a single atomic transaction. Max 100 IDs.

Get the next unblocked runnable tasks, ordered by blocking impact and age.

Retrieve a structured diff of all graph changes since a timestamp or session start.

Find nodes of a given status/type that have not been updated for a specified duration.

Check the graph for logical issues (blocked done tasks, circular dependencies, empty milestones, orphan nodes, dangling edges).

Prune old event log entries older than a specified duration, preserving the latest event for each entity.

Attach a quick developer note or observation to a node or the project.

Single-turn session initialization combining start_session, context snapshot, and next unblocked tasks.

Single-turn task completion: updates task status to done, optionally creates an artifact node, and links them via a produces relationship.

Atomically create multiple nodes in a single transaction with FTS5 search index synchronization.

Atomically add multiple edges with cycle detection and complete transaction rollback on failure.

Parse and ingest a Markdown PRD, OpenSpec, or Gherkin BDD specification file into graph nodes.

Export a graph-managed specification node and child requirements back to clean Markdown or Gherkin text.

Calculate real-time Spec Compliance matrix, requirement coverage ratio, and unfulfilled criteria.

Scaffold a standard feature specification template in .specs/ and ingest it into memory.

Mark an acceptance criterion as verified, failing, or skipped, optionally linking a test observation.

Link a task or artifact to a visual memory state ID via renders_state, blocked_by_visual_state, or verifies_visual_state edge.

Export unified, interleaved event and visual observation trajectories correlated by session ID for agent training.

Get combined dual-memory metrics: token savings, UI task verification ratio, and visual blocker health.