nodebench-mcp 2.70.0 → 3.0.1

package/dist/tools/toolRegistry.js

@@ -10,6 +10,94 @@
  * 3. Build tool chains (recommended sequences for common workflows)
  */
 import { isEmbeddingReady, embeddingSearch } from "./embeddingProvider.js";
+function createFounderEntry(name, tags, nextAction, nextTools, phase, complexity = "low", tip) {
+    return {
+        name,
+        category: "founder",
+        tags: ["founder", ...tags],
+        quickRef: {
+            nextAction,
+            nextTools,
+            methodology: "founder",
+            ...(tip ? { tip } : {}),
+        },
+        phase,
+        complexity,
+    };
+}
+const FOUNDER_PROGRESSION_REGISTRY_ENTRIES = [
+    createFounderEntry("founder_stage_assess", ["stage", "progression", "readiness"], "Use the stage assessment as the current founder baseline, then inspect gaps and next unlocks instead of jumping straight to roadmap work.", ["founder_gaps_detect", "founder_next_unlocks", "founder_readiness_score"], "research"),
+    createFounderEntry("founder_gaps_detect", ["gaps", "foundations", "missing"], "Turn the missing foundations into a materials checklist or a bounded founder issue instead of leaving them as vague weaknesses.", ["founder_materials_check", "founder_ontrack_scorecard", "publish_founder_issue_packet"], "research"),
+    createFounderEntry("founder_next_unlocks", ["unlocks", "stage", "momentum"], "Use the next unlocks to decide the smallest meaningful founder move for this week and what can wait.", ["founder_ontrack_scorecard", "build_slack_onepager", "delegate_founder_issue"], "research"),
+    createFounderEntry("founder_materials_check", ["materials", "checklist", "qualification"], "Use the checklist to prepare investor, banker, or diligence-facing artifacts before you try to share broadly.", ["build_company_packet", "build_investor_packet", "build_slack_onepager"], "research"),
+    createFounderEntry("founder_readiness_score", ["score", "readiness", "qualification"], "Treat the readiness score as a pressure test, then look at the hidden risks and missing materials driving it.", ["founder_gaps_detect", "founder_materials_check", "founder_ontrack_scorecard"], "research"),
+    createFounderEntry("founder_ontrack_scorecard", ["scorecard", "2-week", "3-month"], "Use the scorecard to define what must happen in the next 2 weeks and 3 months, then delegate only the bounded pieces.", ["founder_delegation_boundary_scan", "build_slack_onepager", "record_learning"], "research"),
+    createFounderEntry("founder_delegation_boundary_scan", ["delegation", "founder-only", "team"], "Separate founder-only decisions from delegable work before handing tasks to teammates or agents.", ["delegate_founder_issue", "generate_team_install_plan", "build_company_packet"], "research"),
+    createFounderEntry("founder_company_naming_pack", ["naming", "profile", "starter-company"], "Use the naming pack to make the company legible early, then fold it into the starter profile and one-page report.", ["build_company_profile_starter", "build_slack_onepager", "build_company_packet"], "research"),
+];
+const FOUNDER_OPERATING_MODEL_REGISTRY_ENTRIES = [
+    createFounderEntry("route_founder_packet", ["router", "packet", "execution-order"], "Use the packet router as the single policy decision for packet type, artifact type, export adapter, and next action so surfaces do not fork.", ["detect_company_mode", "get_role_packet_defaults", "get_founder_execution_order"], "research"),
+    createFounderEntry("get_founder_execution_order", ["execution-order", "sequence", "canonical"], "Use the canonical execution order as the forced run sequence before adding more workflow branches.", ["route_founder_packet", "get_founder_job_topology", "build_founder_operating_model"], "research"),
+    createFounderEntry("get_founder_job_topology", ["queue", "jobs", "topology"], "Treat queue topology as the reliability contract for sweeps, packet refresh, export, delegation, and benchmarks.", ["build_founder_operating_model", "get_source_trust_policy", "route_founder_packet"], "research"),
+    createFounderEntry("get_source_trust_policy", ["source-policy", "permissions", "trust"], "Use source trust policy to decide what can be read, stored, summarized, exported, or only referenced before mixing data classes.", ["build_founder_operating_model", "route_founder_packet", "publish_founder_issue_packet"], "research"),
+    createFounderEntry("get_role_packet_defaults", ["role", "packet", "defaults"], "Map each role to its default packet and export shape before adding custom logic in the UI or agents.", ["route_founder_packet", "detect_company_mode", "build_founder_operating_model"], "research"),
+    createFounderEntry("detect_company_mode", ["own-company", "external-company", "mixed"], "Detect whether the query is about the founder's own company, an external entity, or a mixed comparison because the packet behavior should differ.", ["route_founder_packet", "get_role_packet_defaults", "build_company_packet"], "research"),
+    createFounderEntry("get_founder_progression_rubric", ["rubric", "progression", "stages"], "Use the rubric to explain exactly what evidence moves a founder between stages and what keeps them off track.", ["founder_stage_assess", "founder_ontrack_scorecard", "build_founder_operating_model"], "research"),
+    createFounderEntry("get_benchmark_oracles", ["benchmark", "oracles", "validation"], "Benchmark lanes only matter if the oracle definitions are explicit. Use them to separate deterministic checks from judged quality.", ["run_founder_autonomy_benchmark", "build_before_after_memo", "build_founder_operating_model"], "verify"),
+    createFounderEntry("build_founder_operating_model", ["operating-model", "router", "permissions", "oracles"], "Build the full operating model when you need the canonical execution order, queue graph, permission policy, role defaults, and benchmark oracle set in one object.", ["route_founder_packet", "get_founder_job_topology", "get_benchmark_oracles"], "research", "medium"),
+];
+const FOUNDER_OPERATING_REGISTRY_ENTRIES = [
+    createFounderEntry("runway_check", ["runway", "finance", "burn"], "Use runway output to decide whether the current plan is survivable before expanding scope or pricing ambition.", ["burn_rate_sanity", "financial_hygiene_check", "founder_ontrack_scorecard"], "research"),
+    createFounderEntry("burn_rate_sanity", ["burn", "cash", "finance"], "Check burn against runway and hiring plans so the founder packet does not ignore the operating reality.", ["runway_check", "financial_hygiene_check", "build_company_packet"], "research"),
+    createFounderEntry("financial_hygiene_check", ["financial", "hygiene", "discipline"], "Turn financial hygiene findings into concrete operating changes or diligence notes instead of generic caution.", ["runway_check", "build_banking_packet", "founder_gaps_detect"], "research"),
+    createFounderEntry("meeting_notes_extract_decisions", ["meeting-notes", "decisions", "extract"], "Promote the extracted decisions into the packet or the next scorecard so the work compounds instead of disappearing in notes.", ["decision_quality_scan", "team_alignment_check", "build_before_after_memo"], "implement"),
+    createFounderEntry("team_alignment_check", ["team", "alignment", "org"], "Use alignment findings to tighten ownership and reduce founder-only work that should already be delegated.", ["hiring_gap_scan", "founder_delegation_boundary_scan", "founder_ontrack_scorecard"], "research"),
+    createFounderEntry("hiring_gap_scan", ["hiring", "gaps", "team-shape"], "Translate hiring gaps into concrete roles or credibility risks instead of generic statements about team weakness.", ["team_alignment_check", "founder_direction_assessment", "build_company_packet"], "research"),
+    createFounderEntry("decision_quality_scan", ["decisions", "quality", "operating-system"], "Use low-quality decision signals to force explicit rationale, owner, and follow-up in the next packet.", ["meeting_notes_extract_decisions", "build_before_after_memo", "record_learning"], "verify"),
+];
+const FOUNDER_DILIGENCE_REGISTRY_ENTRIES = [
+    createFounderEntry("detect_vertical", ["vertical", "classification", "industry"], "Load the right diligence pack first so the company gets judged against the standards that actually apply to it.", ["detect_subvertical", "load_diligence_pack", "readiness_scan"], "research"),
+    createFounderEntry("detect_subvertical", ["subvertical", "classification", "industry"], "Use the subvertical to tighten the evidence classes and evaluator expectations instead of treating all startups the same.", ["load_diligence_pack", "evidence_gap_scan", "build_diligence_packet"], "research"),
+    createFounderEntry("load_diligence_pack", ["diligence-pack", "requirements", "vertical"], "Use the pack as the requirements contract for fundraising, banking, diligence, and downstream submissions.", ["readiness_scan", "evidence_gap_scan", "build_diligence_packet"], "research"),
+    createFounderEntry("readiness_scan", ["readiness", "diligence", "scan"], "Readiness only matters if it turns into missing evidence and the next collection steps. Use the scan to prioritize that work.", ["evidence_gap_scan", "submission_readiness_score", "build_diligence_packet"], "research"),
+    createFounderEntry("evidence_gap_scan", ["evidence", "gaps", "verification"], "Turn missing evidence into collection tasks or submission blockers instead of letting it stay abstract.", ["claim_verification_scan", "submission_readiness_score", "publish_founder_issue_packet"], "research"),
+    createFounderEntry("claim_verification_scan", ["claims", "verification", "proof"], "Use claim verification to remove weak assertions from the packet before outsiders judge them.", ["extract_patent_claims", "extract_trial_evidence", "extract_publication_metadata"], "verify"),
+    createFounderEntry("submission_readiness_score", ["submission", "readiness", "export"], "Use the submission score to decide whether the company can credibly be sent to banks, investors, or profile platforms yet.", ["build_submission_export", "export_pitchbook_profile", "export_crunchbase_profile"], "research"),
+    createFounderEntry("extract_patent_claims", ["patents", "claims", "ip"], "Patent claims should feed the diligence packet only if they are precise, auditable, and matched to the product story.", ["claim_verification_scan", "build_diligence_packet", "export_pitchbook_profile"], "research"),
+    createFounderEntry("extract_trial_evidence", ["trials", "studies", "clinical"], "Use trial or study evidence to ground life-science claims in verifiable artifacts before fundraising or partnership motions.", ["claim_verification_scan", "build_diligence_packet", "submission_readiness_score"], "research"),
+    createFounderEntry("extract_publication_metadata", ["publications", "papers", "research"], "Fold publication metadata into the diligence pack so scientific or technical credibility is explicit rather than implied.", ["claim_verification_scan", "build_diligence_packet", "export_yc_application_context"], "research"),
+    createFounderEntry("extract_regulatory_artifacts", ["regulatory", "submissions", "approvals"], "Use regulatory artifacts to prove what is real, what is pending, and what still needs submission work.", ["build_diligence_packet", "submission_readiness_score", "export_pitchbook_profile"], "research"),
+];
+const FOUNDER_PACKET_REGISTRY_ENTRIES = [
+    createFounderEntry("build_company_packet", ["packet", "company", "canonical"], "Treat the company packet as the canonical founder object, then export or delegate from it instead of rebuilding the story ad hoc.", ["build_slack_onepager", "build_investor_packet", "share_create_packet_link"], "implement", "medium"),
+    createFounderEntry("build_investor_packet", ["packet", "investor", "memo"], "Use the investor packet only after the readiness scan and major weak angles have been made explicit.", ["build_slack_onepager", "export_pitchbook_profile", "publish_founder_issue_packet"], "implement", "medium"),
+    createFounderEntry("build_banking_packet", ["packet", "banking", "readiness"], "Banking readiness should translate internal company state into the signals a banker actually screens for.", ["financial_hygiene_check", "build_submission_export", "build_slack_onepager"], "implement", "medium"),
+    createFounderEntry("build_diligence_packet", ["packet", "diligence", "requirements"], "Use the diligence packet to centralize all required evidence classes, gaps, and sensitivities before external review.", ["build_submission_export", "share_create_packet_link", "export_yc_application_context"], "implement", "medium"),
+    createFounderEntry("build_submission_export", ["submission", "export", "structured-data"], "Pick the destination adapter explicitly and keep the packet private/workspace-scoped until the founder is ready to disclose it.", ["export_pitchbook_profile", "export_crunchbase_profile", "share_create_packet_link"], "ship", "medium"),
+    createFounderEntry("build_company_profile_starter", ["company-profile", "starter", "public-profile"], "Use the starter profile to make the company legible in one paragraph before you optimize the rest of the packet.", ["founder_company_naming_pack", "build_company_packet", "build_slack_onepager"], "implement"),
+    createFounderEntry("build_slack_onepager", ["slack", "one-page", "artifact"], "Use the Slack one-pager as the first external artifact because it is compact, shareable, and easy to react to.", ["share_create_packet_link", "build_company_packet", "record_learning"], "ship"),
+    createFounderEntry("export_pitchbook_profile", ["pitchbook", "profile", "export"], "PitchBook-style exports should only include evidence-backed fields and must preserve sensitivity and missing-field markers.", ["build_submission_export", "export_crunchbase_profile", "share_create_packet_link"], "ship", "medium"),
+    createFounderEntry("export_crunchbase_profile", ["crunchbase", "profile", "export"], "Use the Crunchbase-like export to make the company legible externally without leaking private founder context by default.", ["build_submission_export", "export_pitchbook_profile", "share_create_packet_link"], "ship", "medium"),
+    createFounderEntry("export_yc_application_context", ["yc", "application", "export"], "Treat the YC context export as a structured answer pack, not just text pasted into a form.", ["build_submission_export", "build_diligence_packet", "share_create_packet_link"], "ship", "medium"),
+];
+const FOUNDER_WORKFLOW_REGISTRY_ENTRIES = [
+    createFounderEntry("compare_workflow_paths", ["workflow", "compare", "before-after"], "Use the compare output to prove whether the shorter path keeps the same quality bar before you operationalize it.", ["validate_shortcut", "shortest_valid_path", "cheapest_valid_path"], "research", "medium"),
+    createFounderEntry("shortest_valid_path", ["workflow", "shortest-path", "optimization"], "Use the shortest path only if the validation checks are explicit and the artifact class still matches the original goal.", ["validate_shortcut", "build_before_after_memo", "run_founder_autonomy_benchmark"], "research", "medium"),
+    createFounderEntry("cheapest_valid_path", ["workflow", "cheapest-path", "cost"], "The cheaper path only matters if it preserves quality and is documented as a reusable operating pattern.", ["validate_shortcut", "build_before_after_memo", "run_founder_autonomy_benchmark"], "research", "medium"),
+    createFounderEntry("validate_shortcut", ["workflow", "shortcut", "validation"], "Treat shortcut validation as the gate before publishing the optimization claim to users or investors.", ["build_before_after_memo", "run_founder_autonomy_benchmark", "record_learning"], "verify", "medium"),
+    createFounderEntry("build_before_after_memo", ["before-after", "memo", "audit"], "Use the memo as the proof artifact: old path, new path, checks, and why the savings are credible.", ["run_founder_autonomy_benchmark", "share_create_packet_link", "record_learning"], "ship", "medium"),
+    createFounderEntry("run_founder_autonomy_benchmark", ["benchmark", "autonomy", "founder"], "Use the benchmark to prove visible business autonomy with receipts, not vague claims about AI agency.", ["run_packet_to_implementation_benchmark", "run_competitor_signal_benchmark", "build_before_after_memo"], "test", "medium"),
+    createFounderEntry("run_packet_to_implementation_benchmark", ["benchmark", "implementation", "packet"], "Use packet-to-implementation runs to prove that the packet actually reduces restatement and implementation drift.", ["build_before_after_memo", "record_learning", "share_create_packet_link"], "test", "medium"),
+    createFounderEntry("run_competitor_signal_benchmark", ["benchmark", "competitor", "response"], "Use this benchmark to show that external signals become concrete product responses, not just interesting research output.", ["build_before_after_memo", "publish_founder_issue_packet", "record_learning"], "test", "medium"),
+    createFounderEntry("run_browserstack_benchmark_lane", ["benchmark", "browserstack", "browser", "proof"], "Use the browser lane as a public proof surface only after the harness, outputs, and judges are stable enough to trust.", ["run_founder_autonomy_benchmark", "build_before_after_memo", "record_learning"], "test", "medium"),
+];
+const FOUNDER_DISTRIBUTION_REGISTRY_ENTRIES = [
+    createFounderEntry("distribution_surface_scan", ["distribution", "surfaces", "trust"], "Audit the distribution surfaces before talking about traction so you know which install and trust loops are actually real.", ["workflow_adoption_scan", "open_core_boundary_advisor", "generate_team_install_plan"], "research"),
+    createFounderEntry("open_core_boundary_advisor", ["open-core", "boundary", "moat"], "Use the open-core boundary to decide what drives trust and adoption versus what stays proprietary and monetizable.", ["partnership_target_map", "gtm_script_builder", "publish_founder_issue_packet"], "research"),
+    createFounderEntry("partnership_target_map", ["partnerships", "channels", "ecosystem"], "Map the first partner surfaces by workflow gravity, not by prestige, so the team stays within 20/80 limits.", ["founder_target_customer_map", "gtm_script_builder", "distribution_surface_scan"], "research"),
+    createFounderEntry("gtm_script_builder", ["gtm", "script", "messaging"], "Use the script to explain the wedge, maturity level, and proof story in one motion instead of listing generic features.", ["founder_target_customer_map", "partnership_target_map", "build_slack_onepager"], "implement"),
+    createFounderEntry("founder_target_customer_map", ["target-customers", "segments", "buyers"], "Turn the customer map into one narrow first wedge instead of trying to sell to every adjacent user class at once.", ["gtm_script_builder", "partnership_target_map", "service_to_dashboard_path"], "research"),
+];
 // ── Registry: every tool mapped with metadata ────────────────────────────
 const REGISTRY_ENTRIES = [
     // ═══ VERIFICATION ═══
@@ -1004,6 +1092,327 @@ const REGISTRY_ENTRIES = [
         },
         phase: "verify",
     },
+    {
+        name: "run_self_directed_delivery_loop",
+        category: "flywheel",
+        tags: ["autonomous", "research", "plan", "implement", "dogfood", "judge", "delivery", "loop"],
+        quickRef: {
+            nextAction: "Loop complete. Reopen the durable run to inspect stage receipts, then act on the recommendations before the next pass.",
+            nextTools: ["get_self_directed_delivery_run", "list_self_directed_delivery_runs", "run_mandatory_flywheel"],
+            methodology: "ai_flywheel",
+            tip: "Supply explicit compile, lint, test, and failure-path commands so the loop can prove the full flywheel instead of guessing.",
+        },
+        phase: "ship",
+    },
+    {
+        name: "get_self_directed_delivery_run",
+        category: "flywheel",
+        tags: ["autonomous", "delivery", "run", "history", "receipts", "audit"],
+        quickRef: {
+            nextAction: "Inspect the failed stage, then rerun the loop or repair the specific command or dogfood scenario that blocked completion.",
+            nextTools: ["run_self_directed_delivery_loop", "list_self_directed_delivery_runs"],
+            methodology: "ai_flywheel",
+        },
+        phase: "verify",
+    },
+    {
+        name: "list_self_directed_delivery_runs",
+        category: "flywheel",
+        tags: ["autonomous", "delivery", "runs", "history", "compare"],
+        quickRef: {
+            nextAction: "Pick the most relevant run ID, inspect it, then compare recommendations and outcomes across loops.",
+            nextTools: ["get_self_directed_delivery_run", "run_self_directed_delivery_loop"],
+            methodology: "ai_flywheel",
+        },
+        phase: "verify",
+    },
+    {
+        name: "upsert_durable_object",
+        category: "bridge",
+        tags: ["identity", "durable", "object", "provenance", "offline", "sync"],
+        quickRef: {
+            nextAction: "Object registered. Link it to adjacent objects and record receipts so the run can be replayed instead of rediscovered.",
+            nextTools: ["link_durable_objects", "record_provenance_receipt", "get_sync_bridge_status"],
+            methodology: "ai_flywheel",
+        },
+        phase: "implement",
+    },
+    {
+        name: "link_durable_objects",
+        category: "bridge",
+        tags: ["identity", "graph", "edge", "lineage", "provenance", "sync"],
+        quickRef: {
+            nextAction: "Relationship stored. Attach receipts, artifacts, or outcomes so the path from cause to result is explicit.",
+            nextTools: ["record_provenance_receipt", "record_sync_artifact", "record_sync_outcome"],
+            methodology: "ai_flywheel",
+        },
+        phase: "implement",
+    },
+    {
+        name: "record_provenance_receipt",
+        category: "bridge",
+        tags: ["receipt", "provenance", "trace", "verification", "audit", "sync"],
+        quickRef: {
+            nextAction: "Receipt stored. If this action produced evidence or an outcome, persist those next and then flush approved state to the paired account.",
+            nextTools: ["record_sync_artifact", "record_sync_outcome", "run_sync_bridge_flush"],
+            methodology: "ai_flywheel",
+        },
+        phase: "verify",
+    },
+    {
+        name: "record_sync_artifact",
+        category: "bridge",
+        tags: ["artifact", "offline", "proof", "verification", "sync"],
+        quickRef: {
+            nextAction: "Artifact stored locally. Link it to the run or outcome, then sync it when the account bridge is available.",
+            nextTools: ["link_durable_objects", "run_sync_bridge_flush"],
+            methodology: "ai_flywheel",
+        },
+        phase: "ship",
+    },
+    {
+        name: "record_sync_outcome",
+        category: "bridge",
+        tags: ["outcome", "user-value", "stakeholder", "evidence", "sync"],
+        quickRef: {
+            nextAction: "Outcome stored. Review its evidence and flush it to the account history so operators and stakeholders can inspect the same result.",
+            nextTools: ["run_sync_bridge_flush", "get_sync_bridge_status"],
+            methodology: "ai_flywheel",
+        },
+        phase: "ship",
+    },
+    {
+        name: "bind_local_account",
+        category: "bridge",
+        tags: ["pairing", "device", "account", "offline-first", "permission", "sync"],
+        quickRef: {
+            nextAction: "Binding recorded. Inspect sync status and then flush a small batch before widening scopes.",
+            nextTools: ["get_sync_bridge_status", "list_pending_sync_operations", "run_sync_bridge_flush"],
+            methodology: "autonomous_maintenance",
+        },
+        phase: "implement",
+    },
+    {
+        name: "get_sync_bridge_status",
+        category: "bridge",
+        tags: ["status", "sync", "device", "account", "queue"],
+        quickRef: {
+            nextAction: "Use this snapshot to decide whether to stay local-only, bind an account, or flush the queue.",
+            nextTools: ["bind_local_account", "list_pending_sync_operations", "run_sync_bridge_flush"],
+            methodology: "autonomous_maintenance",
+        },
+        phase: "verify",
+    },
+    {
+        name: "list_pending_sync_operations",
+        category: "bridge",
+        tags: ["sync", "queue", "pending", "operations", "offline"],
+        quickRef: {
+            nextAction: "Inspect what is waiting to leave the device, then flush a bounded batch through the outbound sync bridge.",
+            nextTools: ["run_sync_bridge_flush", "get_sync_bridge_status"],
+            methodology: "autonomous_maintenance",
+        },
+        phase: "verify",
+    },
+    {
+        name: "queue_sync_operation",
+        category: "bridge",
+        tags: ["sync", "queue", "custom", "operation", "replication"],
+        quickRef: {
+            nextAction: "Custom operation queued. Confirm the device binding and flush when appropriate.",
+            nextTools: ["get_sync_bridge_status", "run_sync_bridge_flush"],
+            methodology: "autonomous_maintenance",
+        },
+        phase: "implement",
+    },
+    {
+        name: "run_sync_bridge_flush",
+        category: "bridge",
+        tags: ["sync", "websocket", "pairing", "replication", "account", "offline-first"],
+        quickRef: {
+            nextAction: "Review accepted and rejected operations. Requeue only what is still relevant, and keep the local store as the source of truth.",
+            nextTools: ["get_sync_bridge_status", "list_pending_sync_operations"],
+            methodology: "autonomous_maintenance",
+            tip: "Start with a small batch and conservative scopes before enabling broader artifact or memory sync.",
+        },
+        phase: "ship",
+    },
+    {
+        name: "register_shared_context_peer",
+        category: "bridge",
+        tags: ["peer", "registry", "shared-context", "capabilities", "heartbeat"],
+        quickRef: {
+            nextAction: "Peer registered. Publish a compact summary and then exchange a packet or task instead of ad hoc text.",
+            nextTools: ["heartbeat_shared_context_peer", "publish_shared_context", "list_shared_context_peers"],
+            methodology: "ai_flywheel",
+        },
+        phase: "implement",
+    },
+    {
+        name: "heartbeat_shared_context_peer",
+        category: "bridge",
+        tags: ["peer", "heartbeat", "summary", "liveness", "status"],
+        quickRef: {
+            nextAction: "Heartbeat refreshed. Pull nearby peers or publish an updated packet if your working state changed.",
+            nextTools: ["list_shared_context_peers", "publish_shared_context", "check_peer_messages"],
+            methodology: "autonomous_maintenance",
+        },
+        phase: "verify",
+    },
+    {
+        name: "list_shared_context_peers",
+        category: "bridge",
+        tags: ["peer", "registry", "discovery", "capabilities", "scope"],
+        quickRef: {
+            nextAction: "Choose the best peer by capability and scope, then hand it a packet or task with explicit lineage.",
+            nextTools: ["get_shared_context_peer", "publish_shared_context", "propose_shared_task"],
+            methodology: "ai_flywheel",
+        },
+        phase: "research",
+    },
+    {
+        name: "get_shared_context_peer",
+        category: "bridge",
+        tags: ["peer", "summary", "capabilities", "status", "scope"],
+        quickRef: {
+            nextAction: "Use this peer snapshot to decide whether to send a message, request context, or hand off a task.",
+            nextTools: ["send_peer_message", "publish_shared_context", "propose_shared_task"],
+            methodology: "ai_flywheel",
+        },
+        phase: "research",
+    },
+    {
+        name: "publish_shared_context",
+        category: "bridge",
+        tags: ["packet", "context", "lineage", "freshness", "shared-context"],
+        quickRef: {
+            nextAction: "Packet published. Acknowledge it, invalidate stale predecessors, or attach it to a task handoff.",
+            nextTools: ["ack_shared_context", "invalidate_shared_context", "propose_shared_task"],
+            methodology: "ai_flywheel",
+        },
+        phase: "implement",
+    },
+    {
+        name: "pull_shared_context",
+        category: "bridge",
+        tags: ["packet", "pull", "context", "query", "evidence"],
+        quickRef: {
+            nextAction: "Inspect the returned packets and carry forward only the ones still fresh and in scope.",
+            nextTools: ["ack_shared_context", "invalidate_shared_context", "propose_shared_task"],
+            methodology: "ai_flywheel",
+        },
+        phase: "research",
+    },
+    {
+        name: "ack_shared_context",
+        category: "bridge",
+        tags: ["packet", "ack", "receipt", "delivery", "lineage"],
+        quickRef: {
+            nextAction: "Acknowledgement recorded. If the packet drove work, create a task or emit a response packet next.",
+            nextTools: ["propose_shared_task", "publish_shared_context", "send_peer_message"],
+            methodology: "closed_loop",
+        },
+        phase: "verify",
+    },
+    {
+        name: "invalidate_shared_context",
+        category: "bridge",
+        tags: ["packet", "invalidate", "stale", "freshness", "contradiction"],
+        quickRef: {
+            nextAction: "Stale context is now explicit. Publish the replacement packet or notify affected peers immediately.",
+            nextTools: ["publish_shared_context", "send_peer_message", "get_shared_context_snapshot"],
+            methodology: "autonomous_maintenance",
+        },
+        phase: "verify",
+    },
+    {
+        name: "send_peer_message",
+        category: "bridge",
+        tags: ["message", "peer", "direct", "coordination", "shared-context"],
+        quickRef: {
+            nextAction: "Direct message sent. If the exchange needs durability, follow it with a packet or task record.",
+            nextTools: ["check_peer_messages", "publish_shared_context", "propose_shared_task"],
+            methodology: "ai_flywheel",
+        },
+        phase: "implement",
+    },
+    {
+        name: "check_peer_messages",
+        category: "bridge",
+        tags: ["message", "inbox", "peer", "coordination", "status"],
+        quickRef: {
+            nextAction: "Review unread items and convert any meaningful exchange into an acknowledged packet or explicit task.",
+            nextTools: ["ack_shared_context", "publish_shared_context", "accept_shared_task"],
+            methodology: "closed_loop",
+        },
+        phase: "verify",
+    },
+    {
+        name: "propose_shared_task",
+        category: "bridge",
+        tags: ["task", "handoff", "delegation", "context", "lineage"],
+        quickRef: {
+            nextAction: "Task proposed. Wait for acceptance or revise the spec if the assignee lacks scope or capability.",
+            nextTools: ["accept_shared_task", "reject_shared_task", "get_shared_context_snapshot"],
+            methodology: "ai_flywheel",
+        },
+        phase: "implement",
+    },
+    {
+        name: "accept_shared_task",
+        category: "bridge",
+        tags: ["task", "accept", "handoff", "delegation", "status"],
+        quickRef: {
+            nextAction: "Task accepted. Produce the output packet, then complete the handoff with explicit lineage.",
+            nextTools: ["publish_shared_context", "complete_shared_task", "escalate_shared_task"],
+            methodology: "closed_loop",
+        },
+        phase: "implement",
+    },
+    {
+        name: "reject_shared_task",
+        category: "bridge",
+        tags: ["task", "reject", "handoff", "scope", "capability"],
+        quickRef: {
+            nextAction: "Task rejected. Adjust the scope, pick a different peer, or publish missing context before retrying.",
+            nextTools: ["list_shared_context_peers", "publish_shared_context", "propose_shared_task"],
+            methodology: "closed_loop",
+        },
+        phase: "verify",
+    },
+    {
+        name: "complete_shared_task",
+        category: "bridge",
+        tags: ["task", "complete", "handoff", "output", "packet"],
+        quickRef: {
+            nextAction: "Task completed. Confirm the output packet is linked and invalidate any stale predecessors if needed.",
+            nextTools: ["publish_shared_context", "invalidate_shared_context", "get_shared_context_snapshot"],
+            methodology: "closed_loop",
+        },
+        phase: "ship",
+    },
+    {
+        name: "escalate_shared_task",
+        category: "bridge",
+        tags: ["task", "escalate", "handoff", "repair", "lineage"],
+        quickRef: {
+            nextAction: "Escalation recorded. Notify the proposer and publish the blocking context so the next peer does not re-derive it.",
+            nextTools: ["send_peer_message", "publish_shared_context", "propose_shared_task"],
+            methodology: "ai_flywheel",
+        },
+        phase: "verify",
+    },
+    {
+        name: "get_shared_context_snapshot",
+        category: "bridge",
+        tags: ["snapshot", "peers", "packets", "tasks", "messages"],
+        quickRef: {
+            nextAction: "Use this snapshot to inspect the live protocol state and find stale packets, open handoffs, or unread peer work.",
+            nextTools: ["list_shared_context_peers", "pull_shared_context", "check_peer_messages"],
+            methodology: "autonomous_maintenance",
+        },
+        phase: "verify",
+    },
     {
         name: "run_tests_cli",
         category: "bootstrap",
@@ -1701,6 +2110,17 @@ const REGISTRY_ENTRIES = [
         },
         phase: "meta",
     },
+    {
+        name: "get_tool_graph",
+        category: "progressive_discovery",
+        tags: ["graph", "relationships", "tool-map", "dependencies", "cooccurrence", "neighbors"],
+        quickRef: {
+            nextAction: "Inspect the graph to see which tools cluster together, then use get_tool_quick_ref or discover_tools to keep moving through the workflow.",
+            nextTools: ["get_tool_quick_ref", "discover_tools"],
+            tip: "Start from a root tool when you want a bounded subgraph. Leave rootTool empty only when you need the broad topology.",
+        },
+        phase: "meta",
+    },
     // ═══ META ═══
     {
         name: "findTools",
@@ -4187,79 +4607,512 @@ const REGISTRY_ENTRIES = [
         phase: "ship",
         complexity: "medium",
     },
-    // ═══ DOGFOOD JUDGE (Phase 13 — compound verification) ═══
     {
-        name: "start_dogfood_session",
-        category: "dogfood_judge",
-        tags: ["dogfood", "session", "start", "loop", "weekly_reset", "pre_delegation", "company_search"],
+        name: "founder_direction_assessment",
+        category: "founder",
+        tags: [
+            "founder",
+            "direction",
+            "pressure-test",
+            "team-fit",
+            "credibility",
+            "ai-tradeoffs",
+            "installability",
+            "maintainability",
+            "claude-code",
+            "adoption",
+            "investor",
+            "subscription",
+            "dashboard",
+            "sellability",
+        ],
         quickRef: {
-            nextAction: "Session started. Use the product for the canonical loop. Record corrections with record_manual_correction and repeated questions with record_repeated_question.",
-            nextTools: ["record_manual_correction", "record_repeated_question", "end_dogfood_session"],
-            methodology: "dogfood_judge",
-            tip: "Always specify loopType — the regression gate checks all 3 canonical loops.",
+            nextAction: "Review the weakest strategic angles first. Publish an issue packet or delegate a bounded follow-up task instead of broadening the roadmap immediately.",
+            nextTools: ["publish_founder_issue_packet", "delegate_founder_issue", "founder_local_synthesize"],
+            methodology: "founder",
+            tip: "Use this before committing to a new wedge. It is strongest when you pass explicit founder skills, constraints, and current user workflows like Claude Code.",
         },
-        phase: "implement",
+        phase: "research",
         complexity: "medium",
     },
+    ...FOUNDER_PROGRESSION_REGISTRY_ENTRIES,
+    ...FOUNDER_OPERATING_MODEL_REGISTRY_ENTRIES,
+    ...FOUNDER_OPERATING_REGISTRY_ENTRIES,
+    ...FOUNDER_DILIGENCE_REGISTRY_ENTRIES,
+    ...FOUNDER_PACKET_REGISTRY_ENTRIES,
+    ...FOUNDER_WORKFLOW_REGISTRY_ENTRIES,
+    ...FOUNDER_DISTRIBUTION_REGISTRY_ENTRIES,
     {
-        name: "end_dogfood_session",
-        category: "dogfood_judge",
-        tags: ["dogfood", "session", "end", "summary", "delegation", "export", "time_to_value"],
+        name: "publish_founder_issue_packet",
+        category: "founder",
+        tags: ["founder", "issue", "packet", "shared-context", "lineage", "delegation", "risk", "direction"],
         quickRef: {
-            nextAction: "Session ended. Now judge it with judge_session (6-dimension scoring) and rate_packet_usefulness.",
-            nextTools: ["judge_session", "rate_packet_usefulness", "get_dogfood_sessions"],
-            methodology: "dogfood_judge",
+            nextAction: "Issue packet published. Delegate it or resolve it explicitly so the weak angle turns into tracked work instead of lingering discussion.",
+            nextTools: ["delegate_founder_issue", "resolve_founder_issue", "get_founder_packet_resource"],
+            methodology: "founder",
+            tip: "Pass a producer peer and workspace so the packet is reusable across the shared-context and sync surfaces.",
         },
         phase: "implement",
         complexity: "medium",
     },
     {
-        name: "record_manual_correction",
-        category: "dogfood_judge",
-        tags: ["dogfood", "correction", "manual", "human", "edit", "factual", "priority", "scope", "tone", "missing"],
+        name: "list_founder_issue_packets",
+        category: "founder",
+        tags: ["founder", "issue", "packet", "list", "shared-context", "snapshot", "triage"],
         quickRef: {
-            nextAction: "Correction recorded. Every correction is a system gap. After session ends, classify root cause with classify_failure.",
-            nextTools: ["classify_failure", "end_dogfood_session", "record_repeated_question"],
-            methodology: "dogfood_judge",
-            tip: "Include beforeValue and afterValue — the delta reveals whether the system was wrong (factual) or incomplete (missing).",
+            nextAction: "Review active founder issues, then resolve, delegate, or inspect the packet resource for the highest-risk angle.",
+            nextTools: ["resolve_founder_issue", "delegate_founder_issue", "get_founder_packet_resource"],
+            methodology: "founder",
         },
-        phase: "implement",
-        complexity: "medium",
+        phase: "research",
+        complexity: "low",
     },
     {
-        name: "record_repeated_question",
-        category: "dogfood_judge",
-        tags: ["dogfood", "repeat", "question", "cognition", "memory", "warm", "cold", "compounding"],
+        name: "resolve_founder_issue",
+        category: "founder",
+        tags: ["founder", "issue", "resolve", "invalidate", "lineage", "shared-context", "state-transition"],
         quickRef: {
-            nextAction: "Repeat question recorded. This is the core failure signal. After session, check get_repeat_cognition_metrics for compound score.",
-            nextTools: ["get_repeat_cognition_metrics", "classify_failure", "end_dogfood_session"],
-            methodology: "dogfood_judge",
-            tip: "If priorSessionId is known, include it — the system calculates time-since-last-asked to measure memory decay.",
+            nextAction: "Issue resolved. Publish the follow-up packet or verify the resolution in the next founder review loop.",
+            nextTools: ["list_founder_issue_packets", "publish_founder_issue_packet", "record_learning"],
+            methodology: "founder",
         },
-        phase: "implement",
+        phase: "ship",
         complexity: "medium",
     },
     {
-        name: "rate_packet_usefulness",
-        category: "dogfood_judge",
-        tags: ["dogfood", "packet", "usefulness", "export", "delegate", "reuse", "abandon", "edits"],
+        name: "delegate_founder_issue",
+        category: "founder",
+        tags: ["founder", "issue", "delegate", "task-handoff", "shared-context", "bounded-work"],
         quickRef: {
-            nextAction: "Packet rated. Check get_repeat_cognition_metrics to see abandonment rate trend. High abandonment = packets aren't useful enough.",
-            nextTools: ["get_repeat_cognition_metrics", "get_dogfood_sessions", "classify_failure"],
-            methodology: "dogfood_judge",
+            nextAction: "Task handoff created. The assignee should return a workflow or verdict packet tied to the original issue context.",
+            nextTools: ["get_founder_packet_resource", "propose_shared_task", "list_founder_issue_packets"],
+            methodology: "founder",
         },
         phase: "implement",
         complexity: "medium",
     },
     {
-        name: "judge_session",
-        category: "dogfood_judge",
-        tags: ["dogfood", "judge", "score", "truth", "compression", "anticipation", "output", "delegation", "trust"],
+        name: "compare_founder_directions",
+        category: "founder",
+        tags: ["founder", "compare", "direction", "wedge", "tradeoffs", "score", "decision"],
         quickRef: {
-            nextAction: "Session judged. If overallScore < 3.5, classify failures with classify_failure. Check get_regression_gate for loop-level pass/fail.",
-            nextTools: ["classify_failure", "get_regression_gate", "get_dogfood_sessions"],
-            methodology: "dogfood_judge",
-            tip: "Be honest — inflated scores defeat the purpose. Score 1-2 for failures, 3 for mediocre, 4-5 for genuinely useful.",
+            nextAction: "Use the recommended direction as the working wedge, then publish its weakest angle as an issue packet before committing roadmap time.",
+            nextTools: ["publish_founder_issue_packet", "workflow_adoption_scan", "service_to_dashboard_path"],
+            methodology: "founder",
+        },
+        phase: "research",
+        complexity: "medium",
+    },
+    {
+        name: "workflow_adoption_scan",
+        category: "founder",
+        tags: ["founder", "workflow", "adoption", "claude-code", "mcp", "install", "maintenance", "distribution"],
+        quickRef: {
+            nextAction: "Use the fit score to tighten the install surface and message. If adoption fit is weak, narrow the wedge before building more features.",
+            nextTools: ["generate_team_install_plan", "service_to_dashboard_path", "founder_direction_assessment"],
+            methodology: "founder",
+        },
+        phase: "research",
+        complexity: "low",
+    },
+    {
+        name: "service_to_dashboard_path",
+        category: "founder",
+        tags: ["founder", "service", "dashboard", "subscription", "commercial", "path", "retention"],
+        quickRef: {
+            nextAction: "Follow the recommended path and milestone order instead of jumping to a dashboard before the repeated workflow exists.",
+            nextTools: ["workflow_adoption_scan", "generate_team_install_plan", "publish_founder_issue_packet"],
+            methodology: "founder",
+        },
+        phase: "research",
+        complexity: "low",
+    },
+    {
+        name: "get_founder_packet_resource",
+        category: "founder",
+        tags: ["founder", "packet", "resource", "uri", "shared-context", "pull", "subscribe"],
+        quickRef: {
+            nextAction: "Use the returned resource and subscription queries to keep agent handoffs tied to the same founder packet over time.",
+            nextTools: ["delegate_founder_issue", "list_founder_issue_packets", "build_shared_context_subscription_manifest"],
+            methodology: "founder",
+        },
+        phase: "research",
+        complexity: "low",
+    },
+    {
+        name: "get_distribution_surfaces",
+        category: "founder",
+        tags: ["distribution", "install", "plugin", "smithery", "claude", "cursor", "surface"],
+        quickRef: {
+            nextAction: "Use this to see which distribution surfaces are actually ready before promising them to users or investors.",
+            nextTools: ["generate_team_install_plan", "check_plugin_update_readiness", "install_nodebench_plugin"],
+            methodology: "founder",
+        },
+        phase: "research",
+        complexity: "low",
+    },
+    {
+        name: "generate_team_install_plan",
+        category: "founder",
+        tags: ["distribution", "install", "team", "rollout", "claude-code", "offline", "preset"],
+        quickRef: {
+            nextAction: "Use the plan as the default rollout path for the target team, then verify the install flow with a real local test before broader rollout.",
+            nextTools: ["install_nodebench_plugin", "check_plugin_update_readiness", "workflow_adoption_scan"],
+            methodology: "founder",
+        },
+        phase: "ship",
+        complexity: "low",
+    },
+    {
+        name: "install_nodebench_plugin",
+        category: "founder",
+        tags: ["distribution", "install", "plugin", "mcp-json", "preset", "local-setup"],
+        quickRef: {
+            nextAction: "Write the starter .mcp.json only after previewing the dry run. Then run the local health check before handing it to a teammate.",
+            nextTools: ["check_plugin_update_readiness", "generate_team_install_plan", "check_mcp_setup"],
+            methodology: "founder",
+        },
+        phase: "implement",
+        complexity: "low",
+    },
+    {
+        name: "check_plugin_update_readiness",
+        category: "founder",
+        tags: ["distribution", "update", "release", "installer", "smithery", "plugin", "readiness"],
+        quickRef: {
+            nextAction: "Fix missing distribution surfaces before cutting the next MCP update so install and upgrade paths stay trustworthy.",
+            nextTools: ["get_distribution_surfaces", "generate_team_install_plan", "install_nodebench_plugin"],
+            methodology: "founder",
+        },
+        phase: "verify",
+        complexity: "low",
+    },
+    {
+        name: "watchlist_add_entity",
+        category: "founder",
+        tags: ["watchlist", "entity", "monitor", "founder", "delta", "alert"],
+        quickRef: {
+            nextAction: "Add the entity, then refresh and convert material changes into shared packets instead of leaving them as isolated alerts.",
+            nextTools: ["watchlist_refresh_entities", "watchlist_get_alerts", "publish_founder_issue_packet"],
+            methodology: "founder",
+        },
+        phase: "implement",
+        complexity: "low",
+    },
+    {
+        name: "watchlist_list_entities",
+        category: "founder",
+        tags: ["watchlist", "entity", "list", "monitor", "founder"],
+        quickRef: {
+            nextAction: "Review the watched entities and prune or refresh them so the watchlist stays tied to current strategic priorities.",
+            nextTools: ["watchlist_refresh_entities", "watchlist_get_alerts", "watchlist_add_entity"],
+            methodology: "founder",
+        },
+        phase: "research",
+        complexity: "low",
+    },
+    {
+        name: "watchlist_refresh_entities",
+        category: "founder",
+        tags: ["watchlist", "refresh", "monitor", "changes", "alerts", "delta"],
+        quickRef: {
+            nextAction: "Refresh only matters when the result becomes a packet, memo, or task. Turn material changes into durable founder context next.",
+            nextTools: ["watchlist_get_alerts", "publish_founder_issue_packet", "delta_diligence"],
+            methodology: "founder",
+        },
+        phase: "implement",
+        complexity: "low",
+    },
+    {
+        name: "watchlist_get_alerts",
+        category: "founder",
+        tags: ["watchlist", "alerts", "changes", "monitor", "triage"],
+        quickRef: {
+            nextAction: "Triage the alerts by strategic value, then publish or delegate the ones that should affect a real decision.",
+            nextTools: ["publish_founder_issue_packet", "delegate_founder_issue", "watchlist_refresh_entities"],
+            methodology: "founder",
+        },
+        phase: "research",
+        complexity: "low",
+    },
+    {
+        name: "share_create_packet_link",
+        category: "founder",
+        tags: ["share", "packet", "url", "memo", "artifact", "founder"],
+        quickRef: {
+            nextAction: "Create the share link only after the packet is ready to be seen outside the current session, then record where it was sent.",
+            nextTools: ["share_get_packet_link", "share_revoke_packet_link", "record_learning"],
+            methodology: "founder",
+        },
+        phase: "ship",
+        complexity: "low",
+    },
+    {
+        name: "share_get_packet_link",
+        category: "founder",
+        tags: ["share", "packet", "url", "lookup", "artifact"],
+        quickRef: {
+            nextAction: "Inspect the link state before sending it again, especially if the packet has since been superseded or revoked.",
+            nextTools: ["share_revoke_packet_link", "share_create_packet_link"],
+            methodology: "founder",
+        },
+        phase: "research",
+        complexity: "low",
+    },
+    {
+        name: "share_revoke_packet_link",
+        category: "founder",
+        tags: ["share", "revoke", "packet", "url", "artifact", "control"],
+        quickRef: {
+            nextAction: "Revoke stale or risky links as soon as the packet changes meaning or should no longer circulate.",
+            nextTools: ["share_get_packet_link", "share_create_packet_link"],
+            methodology: "founder",
+        },
+        phase: "ship",
+        complexity: "low",
+    },
+    {
+        name: "retention_register_connection",
+        category: "founder",
+        tags: ["retention", "qa", "register", "connection", "peer", "monitor"],
+        quickRef: {
+            nextAction: "Once connected, sync findings and keep the QA signal tied to the same founder operating loop instead of a separate silo.",
+            nextTools: ["retention_sync_findings", "retention_get_status", "publish_founder_issue_packet"],
+            methodology: "founder",
+        },
+        phase: "implement",
+        complexity: "low",
+    },
+    {
+        name: "retention_sync_findings",
+        category: "founder",
+        tags: ["retention", "qa", "sync", "findings", "score", "tokens-saved"],
+        quickRef: {
+            nextAction: "Treat the synced findings as operating evidence. Promote material failures into packets or tracked tasks, not just dashboard numbers.",
+            nextTools: ["retention_get_status", "publish_founder_issue_packet", "delegate_founder_issue"],
+            methodology: "founder",
+        },
+        phase: "implement",
+        complexity: "low",
+    },
+    {
+        name: "retention_get_status",
+        category: "founder",
+        tags: ["retention", "qa", "status", "events", "monitor"],
+        quickRef: {
+            nextAction: "Use the status snapshot to decide whether QA findings are current enough to influence the next founder or operator packet.",
+            nextTools: ["retention_sync_findings", "publish_founder_issue_packet"],
+            methodology: "founder",
+        },
+        phase: "research",
+        complexity: "low",
+    },
+    // ═══ DOGFOOD JUDGE (Phase 13 — compound verification) ═══
+    {
+        name: "delta_brief",
+        category: "delta",
+        tags: ["delta", "brief", "what-changed", "daily", "session", "digest"],
+        quickRef: {
+            nextAction: "Use the brief to decide whether to dive deeper, create a memo, or update the watchlist before starting new work.",
+            nextTools: ["delta_diligence", "delta_memo", "delta_watch", "delta_self_dogfood"],
+            methodology: "founder",
+        },
+        phase: "research",
+        complexity: "low",
+    },
+    {
+        name: "delta_diligence",
+        category: "delta",
+        tags: ["delta", "diligence", "entity", "teardown", "competitor", "self-dogfood"],
+        quickRef: {
+            nextAction: "Turn the teardown into a memo, comparison, or watchlist change so the intelligence affects a real decision.",
+            nextTools: ["delta_compare", "delta_memo", "delta_watch", "delta_handoff"],
+            methodology: "founder",
+        },
+        phase: "research",
+        complexity: "medium",
+    },
+    {
+        name: "delta_handoff",
+        category: "delta",
+        tags: ["delta", "handoff", "delegate", "packet", "agent", "context"],
+        quickRef: {
+            nextAction: "Use the handoff packet as the bounded source of truth for the next agent or teammate instead of restating context manually.",
+            nextTools: ["delta_packets", "delta_review", "delta_self_dogfood"],
+            methodology: "founder",
+        },
+        phase: "implement",
+        complexity: "medium",
+    },
+    {
+        name: "delta_watch",
+        category: "delta",
+        tags: ["delta", "watch", "watchlist", "monitor", "alerts", "change-detection"],
+        quickRef: {
+            nextAction: "Keep the watchlist tied to actual strategic entities, then fold material changes back into the brief or a founder issue packet.",
+            nextTools: ["delta_brief", "delta_diligence", "watchlist_get_alerts"],
+            methodology: "founder",
+        },
+        phase: "implement",
+        complexity: "low",
+    },
+    {
+        name: "delta_memo",
+        category: "delta",
+        tags: ["delta", "memo", "decision", "artifact", "evidence", "share"],
+        quickRef: {
+            nextAction: "Promote the memo into a shareable or delegated artifact instead of leaving the recommendation trapped in-session.",
+            nextTools: ["delta_handoff", "share_create_packet_link", "delta_review"],
+            methodology: "founder",
+        },
+        phase: "ship",
+        complexity: "medium",
+    },
+    {
+        name: "delta_scan",
+        category: "delta",
+        tags: ["delta", "scan", "market", "self-diligence", "distribution", "setup", "runtime"],
+        quickRef: {
+            nextAction: "Use the risk register to fix the next runtime or onboarding gap before adding more Delta surface area.",
+            nextTools: ["delta_self_dogfood", "delta_review", "delta_memo", "get_distribution_surfaces"],
+            methodology: "founder",
+        },
+        phase: "verify",
+        complexity: "medium",
+    },
+    {
+        name: "delta_compare",
+        category: "delta",
+        tags: ["delta", "compare", "entities", "side-by-side", "positioning"],
+        quickRef: {
+            nextAction: "Refresh stale diligence first, then use the comparison to tighten the decision memo or next founder packet.",
+            nextTools: ["delta_diligence", "delta_memo", "delta_review"],
+            methodology: "founder",
+        },
+        phase: "research",
+        complexity: "medium",
+    },
+    {
+        name: "delta_review",
+        category: "delta",
+        tags: ["delta", "review", "postmortem", "forecast", "reality", "learning"],
+        quickRef: {
+            nextAction: "Use review packets to feed the next scan, memo, or dogfood loop so the product compounds instead of repeating itself.",
+            nextTools: ["delta_scan", "delta_self_dogfood", "record_learning"],
+            methodology: "founder",
+        },
+        phase: "verify",
+        complexity: "low",
+    },
+    {
+        name: "delta_retain",
+        category: "delta",
+        tags: ["delta", "retain", "memory", "context", "ttl", "session"],
+        quickRef: {
+            nextAction: "Retain only the context that should actually shape later decisions, then verify it shows up in the next brief.",
+            nextTools: ["delta_brief", "delta_packets", "delta_review"],
+            methodology: "founder",
+        },
+        phase: "implement",
+        complexity: "low",
+    },
+    {
+        name: "delta_packets",
+        category: "delta",
+        tags: ["delta", "packets", "history", "lineage", "artifacts"],
+        quickRef: {
+            nextAction: "Use packet history to see whether Delta is learning or just generating more output without closure.",
+            nextTools: ["delta_review", "delta_self_dogfood", "delta_handoff"],
+            methodology: "founder",
+        },
+        phase: "research",
+        complexity: "low",
+    },
+    {
+        name: "delta_self_dogfood",
+        category: "delta",
+        tags: ["delta", "dogfood", "self-check", "runtime", "distribution", "accessibility", "friction"],
+        quickRef: {
+            nextAction: "Fix the first high-severity runtime or distribution issue immediately, then rerun the self-dogfood pass until the risk register is quieter.",
+            nextTools: ["delta_scan", "delta_review", "get_distribution_surfaces", "generate_team_install_plan"],
+            methodology: "founder",
+            tip: "This is the canonical Delta maintenance loop: verify the runtime, verify setup friction, then verify whether people have a reason to come back.",
+        },
+        phase: "verify",
+        complexity: "medium",
+    },
+    {
+        name: "start_dogfood_session",
+        category: "dogfood_judge",
+        tags: ["dogfood", "session", "start", "loop", "weekly_reset", "pre_delegation", "company_search"],
+        quickRef: {
+            nextAction: "Session started. Use the product for the canonical loop. Record corrections with record_manual_correction and repeated questions with record_repeated_question.",
+            nextTools: ["record_manual_correction", "record_repeated_question", "end_dogfood_session"],
+            methodology: "dogfood_judge",
+            tip: "Always specify loopType — the regression gate checks all 3 canonical loops.",
+        },
+        phase: "implement",
+        complexity: "medium",
+    },
+    {
+        name: "end_dogfood_session",
+        category: "dogfood_judge",
+        tags: ["dogfood", "session", "end", "summary", "delegation", "export", "time_to_value"],
+        quickRef: {
+            nextAction: "Session ended. Now judge it with judge_session (6-dimension scoring) and rate_packet_usefulness.",
+            nextTools: ["judge_session", "rate_packet_usefulness", "get_dogfood_sessions"],
+            methodology: "dogfood_judge",
+        },
+        phase: "implement",
+        complexity: "medium",
+    },
+    {
+        name: "record_manual_correction",
+        category: "dogfood_judge",
+        tags: ["dogfood", "correction", "manual", "human", "edit", "factual", "priority", "scope", "tone", "missing"],
+        quickRef: {
+            nextAction: "Correction recorded. Every correction is a system gap. After session ends, classify root cause with classify_failure.",
+            nextTools: ["classify_failure", "end_dogfood_session", "record_repeated_question"],
+            methodology: "dogfood_judge",
+            tip: "Include beforeValue and afterValue — the delta reveals whether the system was wrong (factual) or incomplete (missing).",
+        },
+        phase: "implement",
+        complexity: "medium",
+    },
+    {
+        name: "record_repeated_question",
+        category: "dogfood_judge",
+        tags: ["dogfood", "repeat", "question", "cognition", "memory", "warm", "cold", "compounding"],
+        quickRef: {
+            nextAction: "Repeat question recorded. This is the core failure signal. After session, check get_repeat_cognition_metrics for compound score.",
+            nextTools: ["get_repeat_cognition_metrics", "classify_failure", "end_dogfood_session"],
+            methodology: "dogfood_judge",
+            tip: "If priorSessionId is known, include it — the system calculates time-since-last-asked to measure memory decay.",
+        },
+        phase: "implement",
+        complexity: "medium",
+    },
+    {
+        name: "rate_packet_usefulness",
+        category: "dogfood_judge",
+        tags: ["dogfood", "packet", "usefulness", "export", "delegate", "reuse", "abandon", "edits"],
+        quickRef: {
+            nextAction: "Packet rated. Check get_repeat_cognition_metrics to see abandonment rate trend. High abandonment = packets aren't useful enough.",
+            nextTools: ["get_repeat_cognition_metrics", "get_dogfood_sessions", "classify_failure"],
+            methodology: "dogfood_judge",
+        },
+        phase: "implement",
+        complexity: "medium",
+    },
+    {
+        name: "judge_session",
+        category: "dogfood_judge",
+        tags: ["dogfood", "judge", "score", "truth", "compression", "anticipation", "output", "delegation", "trust"],
+        quickRef: {
+            nextAction: "Session judged. If overallScore < 3.5, classify failures with classify_failure. Check get_regression_gate for loop-level pass/fail.",
+            nextTools: ["classify_failure", "get_regression_gate", "get_dogfood_sessions"],
+            methodology: "dogfood_judge",
+            tip: "Be honest — inflated scores defeat the purpose. Score 1-2 for failures, 3 for mediocre, 4-5 for genuinely useful.",
         },
         phase: "verify",
         complexity: "medium",
@@ -4366,6 +5219,218 @@ const REGISTRY_ENTRIES = [
         phase: "research",
         complexity: "low",
     },
+    // ═══ SCENARIO COMPILER (MiroFish essence) ═══
+    {
+        name: "compile_scenarios",
+        category: "scenario_compiler",
+        tags: ["scenario", "future", "branching", "prediction", "strategy", "mirofish", "simulation", "decision"],
+        quickRef: {
+            nextAction: "Scenarios compiled. Score individual branches for deeper analysis, or compile a decision packet from the results.",
+            nextTools: ["score_scenario_branch", "compile_tension_model", "compile_decision_packet"],
+            methodology: "scenario_compiler",
+            tip: "Use 5 branches for balanced coverage. Add time_horizon='1_year' for strategic planning, '30_days' for tactical decisions.",
+        },
+        phase: "research",
+        complexity: "high",
+    },
+    {
+        name: "score_scenario_branch",
+        category: "scenario_compiler",
+        tags: ["scenario", "scoring", "branch", "evidence", "probability", "update"],
+        quickRef: {
+            nextAction: "Branch scored with updated probability. Feed new evidence to refine, or compile a decision packet with the scored scenarios.",
+            nextTools: ["compile_scenarios", "compile_decision_packet"],
+            methodology: "scenario_compiler",
+        },
+        phase: "verify",
+        complexity: "medium",
+    },
+    {
+        name: "compile_tension_model",
+        category: "scenario_compiler",
+        tags: ["tension", "forces", "tradeoff", "axis", "conflict", "resolution", "strategy"],
+        quickRef: {
+            nextAction: "Tension model built. Use to inform scenario branches, or feed directly into a decision packet for stakeholder communication.",
+            nextTools: ["compile_scenarios", "compile_decision_packet"],
+            methodology: "scenario_compiler",
+            tip: "Explicit tensions replace swarm simulation — model 5-7 axes for most decisions.",
+        },
+        phase: "research",
+        complexity: "medium",
+    },
+    // ═══ PACKET COMPILER ═══
+    {
+        name: "compile_decision_packet",
+        category: "packet_compiler",
+        tags: ["packet", "memo", "html", "spreadsheet", "delegation", "slides", "artifact", "export", "brief", "report"],
+        quickRef: {
+            nextAction: "Decision packet compiled. Share via shareable URL, export to slides, or hand off as delegation packet to an agent.",
+            nextTools: ["compile_environment_spec", "compile_scenarios"],
+            methodology: "packet_compiler",
+            tip: "Format options: memo (markdown), html (briefing page), spreadsheet (CSV), delegation (agent handoff), slides (outline).",
+        },
+        phase: "ship",
+        complexity: "medium",
+    },
+    {
+        name: "compile_environment_spec",
+        category: "packet_compiler",
+        tags: ["environment", "simulation", "clone", "benchmark", "spec", "ontology", "workflow", "seed-data", "mcp", "grader"],
+        quickRef: {
+            nextAction: "Environment spec compiled. Use to build realistic agent training environments, benchmark suites, or product clones.",
+            nextTools: ["compile_decision_packet", "compile_scenarios"],
+            methodology: "packet_compiler",
+            tip: "Scope options: 'full' (entire product), 'workflow' (specific flow), 'minimal' (core only).",
+        },
+        phase: "ship",
+        complexity: "high",
+    },
+    // ═══ PLAN SYNTHESIS ═══
+    {
+        name: "synthesize_feature_plan",
+        category: "plan_synthesis",
+        tags: ["plan", "feature", "implementation", "proposal", "strategy", "phases", "roadmap", "delegation"],
+        quickRef: {
+            nextAction: "Plan synthesized. Review strategic fit and phases, then generate a proposal memo or delegation packet.",
+            nextTools: ["generate_proposal_memo", "generate_plan_delegation_packet", "compile_decision_packet"],
+            methodology: "plan_synthesis",
+            tip: "Plans are context-conditioned: they use your founder profile, initiatives, contradictions, and codebase readiness.",
+        },
+        phase: "research",
+        complexity: "high",
+    },
+    {
+        name: "synthesize_integration_proposal",
+        category: "plan_synthesis",
+        tags: ["integration", "api", "external", "adapter", "compatibility", "migration", "proposal"],
+        quickRef: {
+            nextAction: "Integration proposal ready. Review compatibility assessment, then generate memo or delegate to agent.",
+            nextTools: ["generate_proposal_memo", "generate_plan_delegation_packet", "enrich_entity"],
+            methodology: "plan_synthesis",
+            tip: "For external tool/API/framework integrations. Covers compatibility, adapter, data mapping, and UI surfacing.",
+        },
+        phase: "research",
+        complexity: "high",
+    },
+    {
+        name: "synthesize_extension_plan",
+        category: "plan_synthesis",
+        tags: ["extension", "deepening", "evolution", "improvement", "gap", "audit", "existing"],
+        quickRef: {
+            nextAction: "Extension plan ready. Review gap prioritization, then generate memo or delegate implementation.",
+            nextTools: ["generate_proposal_memo", "generate_plan_delegation_packet", "detect_contradictions"],
+            methodology: "plan_synthesis",
+            tip: "For extending existing features. Starts with current state audit and gap analysis before proposing changes.",
+        },
+        phase: "research",
+        complexity: "medium",
+    },
+    {
+        name: "generate_proposal_memo",
+        category: "plan_synthesis",
+        tags: ["memo", "proposal", "markdown", "html", "export", "document", "brief", "report"],
+        quickRef: {
+            nextAction: "Memo rendered. Share with stakeholders or export as HTML for presentation.",
+            nextTools: ["generate_plan_delegation_packet", "compile_decision_packet"],
+            methodology: "plan_synthesis",
+            tip: "Renders a FeaturePlan as a human-readable memo. Formats: 'memo' (markdown) or 'html'.",
+        },
+        phase: "ship",
+        complexity: "low",
+    },
+    {
+        name: "generate_plan_delegation_packet",
+        category: "plan_synthesis",
+        tags: ["delegation", "agent", "handoff", "task", "packet", "claude", "openclaw", "autonomous"],
+        quickRef: {
+            nextAction: "Delegation packet ready. Send to agent via commandBridge or copy as agent brief.",
+            nextTools: ["compile_decision_packet", "start_delivery_run"],
+            methodology: "plan_synthesis",
+            tip: "Converts plan into OutboundTaskPacket format with scope, constraints, and acceptance criteria.",
+        },
+        phase: "ship",
+        complexity: "low",
+    },
+    // ═══ ENTITY TEMPORAL ═══
+    {
+        name: "track_entity_changes",
+        category: "entity_temporal",
+        tags: ["entity", "changes", "diff", "temporal", "tracking", "staleness", "monitoring", "delta"],
+        quickRef: {
+            nextAction: "Changes tracked. Detect contradictions between old and new state, or compile a decision packet incorporating the changes.",
+            nextTools: ["detect_contradictions", "build_temporal_graph", "compile_decision_packet"],
+            methodology: "entity_temporal",
+            tip: "Track specific fields (valuation, team, product, funding, strategy) or use 'all' for comprehensive diff.",
+        },
+        phase: "research",
+        complexity: "medium",
+    },
+    {
+        name: "detect_contradictions",
+        category: "entity_temporal",
+        tags: ["contradiction", "conflict", "trust", "verification", "claims", "sources", "diligence"],
+        quickRef: {
+            nextAction: "Contradictions detected. Investigate high-severity items, build temporal graph for lineage, or compile into a diligence packet.",
+            nextTools: ["track_entity_changes", "build_temporal_graph", "compile_decision_packet"],
+            methodology: "entity_temporal",
+            tip: "High-severity contradictions require verification before any decision. The resolution_hint suggests where to look.",
+        },
+        phase: "verify",
+        complexity: "medium",
+    },
+    {
+        name: "build_temporal_graph",
+        category: "entity_temporal",
+        tags: ["graph", "temporal", "edges", "relationships", "adjacency", "network", "entity", "evolution", "staleness"],
+        quickRef: {
+            nextAction: "Temporal graph built. Check for stale edges needing refresh, detect contradictions across time, or compile entity intelligence into a packet.",
+            nextTools: ["detect_contradictions", "track_entity_changes", "compile_decision_packet"],
+            methodology: "entity_temporal",
+            tip: "Depth 1 = direct relationships. Depth 2 = relationships of relationships. Depth 3 = full neighborhood. Stale edges (>30 days unverified) flagged automatically.",
+        },
+        phase: "research",
+        complexity: "high",
+    },
+    // ── Claude Code Ingestion ────────────────────────────────────────────
+    {
+        name: "ingest_claude_code_sessions",
+        category: "ingestion",
+        tags: ["claude-code", "jsonl", "transcript", "session", "ingest", "import", "context", "founder"],
+        quickRef: {
+            nextAction: "Sessions scanned. Review summaries, then use ingest_codebase_changes to fingerprint the working directory, or get_ingest_status for full source overview.",
+            nextTools: ["ingest_codebase_changes", "get_ingest_status"],
+            methodology: "founder",
+            tip: "Use projectFilter to scope to a specific project. Use since to only get recent sessions.",
+        },
+        phase: "research",
+        complexity: "low",
+    },
+    {
+        name: "ingest_codebase_changes",
+        category: "ingestion",
+        tags: ["codebase", "fingerprint", "git", "changes", "diff", "ingest", "context", "founder"],
+        quickRef: {
+            nextAction: "Codebase fingerprinted. Compare with previous fingerprint to detect changes, or use ingest_claude_code_sessions to correlate with coding sessions.",
+            nextTools: ["ingest_claude_code_sessions", "get_ingest_status"],
+            methodology: "founder",
+            tip: "Tracks package.json, README, CLAUDE.md, schema files, and recent git commits.",
+        },
+        phase: "research",
+        complexity: "low",
+    },
+    {
+        name: "get_ingest_status",
+        category: "ingestion",
+        tags: ["status", "sources", "claude-code", "codebase", "sync", "health", "founder"],
+        quickRef: {
+            nextAction: "Status checked. If sources are ready, use ingest_claude_code_sessions or ingest_codebase_changes to pull context.",
+            nextTools: ["ingest_claude_code_sessions", "ingest_codebase_changes"],
+            methodology: "founder",
+            tip: "Run this first to see what data sources are available before ingesting.",
+        },
+        phase: "utility",
+        complexity: "low",
+    },
 ];
 // ── Exported lookup structures ───────────────────────────────────────────
 /** Map of tool name → registry entry for O(1) lookup */
@@ -5414,6 +6479,119 @@ export function hybridSearch(query, tools, options) {
 export const SEARCH_MODES = ["hybrid", "fuzzy", "regex", "prefix", "semantic", "exact", "dense", "embedding"];
 /** Pre-built workflow chains for common tasks */
 export const WORKFLOW_CHAINS = {
+    local_account_sync: {
+        name: "Local Account Sync",
+        description: "Pair a local-first device with a web account, inspect the queue, and flush durable state through the outbound sync bridge",
+        steps: [
+            { tool: "upsert_durable_object", action: "Register the local view, screen, run, artifact, or outcome objects that matter before syncing anything" },
+            { tool: "record_provenance_receipt", action: "Emit durable receipts for meaningful actions so sync carries replayable evidence, not just summaries" },
+            { tool: "bind_local_account", action: "Record explicit device -> user/workspace permission and granted scopes" },
+            { tool: "list_pending_sync_operations", action: "Inspect the outbound queue and confirm what will leave the device" },
+            { tool: "run_sync_bridge_flush", action: "Dial out over the outbound websocket and replicate the approved local operations" },
+            { tool: "get_sync_bridge_status", action: "Verify queue health, binding state, and the last acknowledged sync watermark" },
+        ],
+    },
+    shared_context_protocol: {
+        name: "Shared Context Protocol",
+        description: "Register peers, publish versioned context packets, hand off tasks, and inspect the scoped protocol state",
+        steps: [
+            { tool: "register_shared_context_peer", action: "Register a peer with scoped identity, role, surface, capabilities, and summary" },
+            { tool: "publish_shared_context", action: "Publish a structured packet instead of sending ad hoc text" },
+            { tool: "propose_shared_task", action: "Delegate bounded work to another peer with explicit input context IDs" },
+            { tool: "accept_shared_task", action: "Accept the handoff when the assignee has the right scope and tools" },
+            { tool: "complete_shared_task", action: "Return the output packet and close the task with lineage intact" },
+            { tool: "get_shared_context_snapshot", action: "Inspect peers, packets, tasks, and unread messages in one place" },
+        ],
+    },
+    founder_direction_pressure_test: {
+        name: "Founder Direction Pressure Test",
+        description: "Pressure-test a new company direction, turn the weak angles into shared packets, and delegate the follow-up work",
+        steps: [
+            { tool: "founder_local_gather", action: "Pull the latest local project, dogfood, and session-memory context so the assessment uses real evidence" },
+            { tool: "founder_direction_assessment", action: "Score the direction across team shape, AI stance, build speed, installability, adoption, credibility, and commercialization" },
+            { tool: "publish_founder_issue_packet", action: "Publish the weakest founder angle as a durable issue packet with resource URI and lineage" },
+            { tool: "delegate_founder_issue", action: "Delegate a bounded follow-up task tied to the founder issue instead of leaving the risk abstract" },
+            { tool: "record_learning", action: "Capture what changed in the direction thesis after the pressure test" },
+        ],
+    },
+    founder_direction_ops: {
+        name: "Founder Direction Ops",
+        description: "Compare directions, publish the weakest founder issue, scan adoption, plan distribution, and delegate the next bounded follow-up",
+        steps: [
+            { tool: "compare_founder_directions", action: "Compare candidate directions and pick the best wedge with an explicit falsifier" },
+            { tool: "publish_founder_issue_packet", action: "Turn the weakest angle into a founder issue packet with lineage and a reusable resource URI" },
+            { tool: "workflow_adoption_scan", action: "Check whether the wedge matches current high-frequency workflows like Claude Code + MCP" },
+            { tool: "service_to_dashboard_path", action: "Decide whether the business should stay service-first or graduate into a dashboard subscription later" },
+            { tool: "delegate_founder_issue", action: "Delegate the highest-risk founder issue as a bounded shared task instead of broadening the roadmap" },
+        ],
+    },
+    founder_distribution_rollout: {
+        name: "Founder Distribution Rollout",
+        description: "Audit install/update readiness, generate a team install plan, write the starter MCP config, and connect supporting QA signals",
+        steps: [
+            { tool: "get_distribution_surfaces", action: "Inspect which install, plugin, dashboard, and discovery surfaces are actually ready" },
+            { tool: "check_plugin_update_readiness", action: "Verify package version, installer, Claude/Cursor config, and Smithery metadata before release" },
+            { tool: "generate_team_install_plan", action: "Generate the install and rollout path that matches the real team workflow" },
+            { tool: "install_nodebench_plugin", action: "Write or preview the starter .mcp.json for the target directory" },
+            { tool: "retention_register_connection", action: "Connect retention.sh QA if the rollout needs cross-tool QA evidence in the same operating loop" },
+        ],
+    },
+    founder_progression_review: {
+        name: "Founder Progression Review",
+        description: "Assess the founder stage, expose gaps, map next unlocks, and produce the first shareable artifact",
+        steps: [
+            { tool: "founder_stage_assess", action: "Assess the founder/company stage so the rest of the workflow uses a real baseline" },
+            { tool: "founder_gaps_detect", action: "Identify the missing foundations and hidden weaknesses blocking the next stage" },
+            { tool: "founder_materials_check", action: "Convert the weak areas into a concrete materials checklist instead of vague advice" },
+            { tool: "founder_ontrack_scorecard", action: "Define what must happen in the next 2 weeks and 3 months to stay on track" },
+            { tool: "build_slack_onepager", action: "Export the founder one-page report so the result can actually be shared and reused" },
+        ],
+    },
+    founder_operating_model_review: {
+        name: "Founder Operating Model Review",
+        description: "Resolve company mode, packet routing, queue topology, permission policy, and oracle definitions before scaling the workflow",
+        steps: [
+            { tool: "detect_company_mode", action: "Decide whether this is an own-company, external-company, or mixed-comparison run before routing anything else" },
+            { tool: "route_founder_packet", action: "Use the packet router as the canonical policy decision for packet, artifact, export adapter, and next action" },
+            { tool: "get_founder_execution_order", action: "Lock the forced execution order so search, MCP, and UI surfaces follow the same sequence" },
+            { tool: "get_founder_job_topology", action: "Check the async queues that will own sweeps, refreshes, export delivery, delegation, and benchmark runs" },
+            { tool: "get_source_trust_policy", action: "Verify what each source class can be read, stored, summarized, or exported as before mixing sensitive context" },
+            { tool: "get_benchmark_oracles", action: "Load the benchmark oracle set so autonomy claims are backed by explicit deterministic and judged checks" },
+        ],
+    },
+    founder_vertical_diligence: {
+        name: "Founder Vertical Diligence",
+        description: "Classify the company, load the right diligence pack, verify evidence gaps, and prepare a diligence-ready packet",
+        steps: [
+            { tool: "detect_vertical", action: "Classify the company into the correct major diligence lane" },
+            { tool: "detect_subvertical", action: "Tighten the classification so the wrong diligence assumptions do not leak into the packet" },
+            { tool: "load_diligence_pack", action: "Load the evidence classes, evaluator expectations, and readiness definition for that lane" },
+            { tool: "evidence_gap_scan", action: "Identify missing evidence, unverifiable claims, and submission blockers" },
+            { tool: "build_diligence_packet", action: "Compile the evidence, gaps, and sensitivities into one reusable diligence artifact" },
+        ],
+    },
+    founder_workflow_optimization: {
+        name: "Founder Workflow Optimization",
+        description: "Compare current and optimized paths, validate the shortcut, then package the proof as a benchmark-backed memo",
+        steps: [
+            { tool: "compare_workflow_paths", action: "Compare the current workflow with the proposed shorter path" },
+            { tool: "validate_shortcut", action: "Explicitly validate that the shortcut preserves required quality and evidence" },
+            { tool: "shortest_valid_path", action: "Derive the shortest valid path that still produces the same artifact class" },
+            { tool: "cheapest_valid_path", action: "Check whether there is an even cheaper path worth using in production" },
+            { tool: "build_before_after_memo", action: "Package the before/after proof into one memo that people can inspect" },
+            { tool: "run_founder_autonomy_benchmark", action: "Promote the proof into a benchmark lane instead of keeping it as an anecdote" },
+        ],
+    },
+    self_directed_delivery: {
+        name: "Self-Directed Delivery Loop",
+        description: "One durable run across recon, plan, implementation, dogfood, judge, and verification",
+        steps: [
+            { tool: "run_self_directed_delivery_loop", action: "Execute the local-first research -> plan -> implement -> dogfood -> judge loop" },
+            { tool: "get_self_directed_delivery_run", action: "Inspect per-stage receipts, failure reasons, and recommendations" },
+            { tool: "run_mandatory_flywheel", action: "Use the recorded evidence to verify all 6 mandatory steps are explicit and green" },
+            { tool: "record_learning", action: "Bank patterns or regressions discovered during the loop" },
+        ],
+    },
     new_feature: {
         name: "Build a New Feature",
         description: "End-to-end workflow from research to ship",