Create an atomic SpecNode in the constraint DAG. Every unit of work is represented as a SpecNode with a strict contract (inputs, outputs, invariants) and a surface_type for risk posture mapping. Architect Mode only: do NOT write code, only define constraints.

Update the contract or metadata of an existing SpecNode. Updating a contract triggers automatic subgraph invalidation downstream. Use this when refining specs based on new information or audit results.

Get the full state of a SpecNode: stage, confidence, failure classification. Use to query where a node is in the Manufacturing Line pipeline.

List SpecNodes for a repository, optionally filtered by stage, surface_type, or level. Use stage=failed to find nodes requiring repair. Use surface_type=api_endpoint to build the Risk Posture Map.

Promote an auto-inventoried node from 'observed' → 'proposed' → 'governed'. Proposed nodes require contracts; Governed nodes are actively checked.

Get all SpecNodes whose upstream dependencies are fully verified (ready_queue). The execution loop calls this to determine what the Builder can work on next.

Tester Mode: Generate the full verification suite for a SpecNode from its contract. Translates invariants → property tests, inputs/outputs → unit tests, ambiguous paths → fuzz tests, metrics → performance checks. Do NOT write application code in this mode.

Auditor Mode: Execute the verification suite for a SpecNode and record results. Runs tests, static checks, security scans. Returns structured pass/fail results and automatically updates node confidence score.

Builder/Auditor Mode: Record a SpecNode's current execution stage and confidence. Called by the agent as it moves a node through the Manufacturing Line pipeline: spec_defined → verification_generated → implementing → auditing → verified.

Classify a SpecNode failure deterministically. Do NOT guess. Exactly one classification applies: spec_gap → contract is incomplete or ambiguous → escalate to Architect Mode test_gap → tests don't cover the failure scenario → escalate to Tester Mode implementation_bug → code is wrong, spec and tests are correct → escalate to Builder Mode dependency_failure → upstream node is broken, block this node

Record that a repair action was applied to a failed SpecNode. Resets the node stage so the execution loop re-runs verification. Must be called after the repair action (code patch, test expansion, spec refinement).

THE KILLER FEATURE: Apply a contract change to a SpecNode and trigger automatic downstream invalidation. All dependent nodes in the DAG will have their verification and implementation state reset, placing them back in the ready_queue for automatic regeneration. Use this whenever a requirement changes — the engine guarantees correctness is restored.

Compute the exact blast radius of a SpecNode change: all downstream nodes in the DAG that depend on this node (directly or transitively). Use BEFORE applying a spec change to preview impact on the manufacturing line.

Request human approval for a SpecNode. Only use for: (1) L0/L1 spec approval before system-wide execution, (2) low-confidence nodes (< 0.6) after repair cycles, (3) high-risk surface changes (api_endpoint or security_checks failing). For everything else, the engine runs autonomously.

Get the global control plane state: ready_queue, blocked_queue, failed_nodes, and global confidence metrics. The UI polls this to render the Manufacturing Line and Confidence Score dial.

Ingest a live runtime signal into the constraint graph. Automatically checks the value against contractual Metric thresholds, decays node confidence proportionally if breached, marks the node failed if confidence falls below 0.6, and fully invalidates the node on a regression. Every change is recorded as Evidence so confidence always has a receipt. Call from CI, Sentry, Datadog, or any monitoring source.

Scan an existing project directory and auto-create L2 SpecNodes for each module group. Nodes are created with blank contracts — fill in invariants and metrics progressively. Use dry_run=true first to preview what would be created without writing to the DB. Skips excluded directories (node_modules, .venv, pycache, etc.) automatically.

Provides a prioritized Action Item queue for the IDE Agent. Call this tool to figure out what you should work on next. It returns a list of high-priority gaps in the graph (e.g. missing contracts, broken tests) sorted by blast radius severity.

Syncs the codebase state with the constraint graph. Intended to be called by git webhooks/hooks. Applies a confidence penalty to nodes whose files were modified and propagates the blast radius.

Bidirectional memory sync for a repo via TURINGMIND_API_URL/api/v2/memory/cloud/sync (TURINGMIND_CLOUD_SYNC=1 + TURINGMIND_API_KEY). Pulls cloud tombstones and pushes active/candidate/deprecated memories upstream.

Index codebase using AST parsing to extract code entities (functions, classes, files) and relationships. Enables relationship-aware code review and impact analysis.

Get code entities related to a specific function/class/file. Uses relationship graph to find callers, callees, and imports for impact analysis.

Get comprehensive project structure summary. Returns language distribution, entity type counts, and basic architecture info.

Get or capture developer reasoning for file changes. Extracts intent from commit messages or prompts developer. Supports per-file reasoning. Helps code review understand intent and reduce false positives.

List memory entries with filtering and pagination. Supports filtering by category, status, scope, and security tags.

Get detailed information about a specific memory entry including evidence.

Create or update a memory entry. Supports learned patterns, explicit rules, and session context.

Delete or deprecate a memory entry. Deprecation preserves history, deletion removes completely.

Detect conflicts between memory entries. Identifies contradictions, overlaps, and scope conflicts.

Resolve conflicts between memory entries. Supports priority, scope-narrow, time-bound, and merge strategies.

Get full audit trail for a TDD cycle. Returns complete reasoning, specs, tests, and edits with traceability.

Analyze a git diff and auto-generate an EditPlan. This enables continuous SDD where plans are inferred from changes rather than requiring upfront planning. Returns an auto-generated plan with inferred intent, risk level, and suggested specs.

Apply code changes with MANDATORY reasoning capture. Use this for ALL file edits to ensure intent is documented. The reasoning becomes part of the permanent audit trail.

Log your reasoning/thinking process without making changes. Use this to document your thought process, analysis, and decisions. Creates a permanent record of AI reasoning for audit trails.