@alan512/experienceengine 0.1.2 → 0.2.0

package/dist/adapters/codex/mcp-server.js

@@ -7,66 +7,40 @@ import { ExperienceInteractionService } from "../../interaction/service.js";
 import { ExperienceOperationalService } from "../../interaction/operational-service.js";
 import { ExperienceOperationalActionsService, } from "../../interaction/operational-actions-service.js";
 import { ExperienceStateArtifactService } from "../../interaction/state-artifact-service.js";
-import { ExperiencePackActionsService } from "../../interaction/pack-actions-service.js";
 import { ExperienceRuntimeService } from "../../runtime/service.js";
 import { fetchLatestGitHubReleaseStatus } from "../../version/remote-release.js";
-const NODE_STATES = ["candidate", "active", "cooling", "retired"];
+import { createCodexActionRegistry } from "./action-registry.js";
+import { createCodexBrokerFacade, executeCodexActionSchema, listCodexActionsSchema, prepareCodexActionSchema } from "./broker-tools.js";
+const NODE_STATES = ["candidate", "priority_candidate", "active", "cooling", "retired"];
 const NODE_TYPES = ["strategy", "warning"];
 const EXPERIENCE_ADAPTERS = ["openclaw", "claude-code", "codex"];
 const HIGH_IMPACT_OPERATIONS = ["install", "repair", "upgrade"];
-const COMPILER_TARGETS = ["agents", "codex", "github", "claude"];
 const buildExperienceCapabilities = () => ({
-    model: "agent-first",
-    principles: [
-        "Users should talk to the host agent instead of memorizing ee CLI commands.",
-        "Low-risk read and preview operations should be direct MCP tools.",
-        "High-risk write operations should use plan -> review -> confirm flows."
+    core_actions: [
+        "experienceengine_lookup_hints",
+        "experienceengine_explain_last_decision",
+        "experienceengine_record_tool_result",
+        "experienceengine_finalize_task",
+        "experienceengine_feedback_last",
+        "experienceengine_get_capabilities",
+        "experienceengine_doctor"
     ],
-    packs: {
-        directTools: [
-            "experienceengine_pack_list",
-            "experienceengine_pack_inspect",
-            "experienceengine_pack_status",
-            "experienceengine_pack_enable",
-            "experienceengine_pack_disable"
-        ],
-        guardedTools: [
-            "experienceengine_plan_pack_publish",
-            "experienceengine_plan_pack_rollback",
-            "experienceengine_execute_planned_pack_operation"
-        ]
-    },
-    compiler: {
-        directTools: [
-            "experienceengine_pack_compile",
-            "experienceengine_pack_deploy_preview"
-        ],
-        guardedTools: [
-            "experienceengine_plan_pack_deploy",
-            "experienceengine_execute_planned_pack_operation"
-        ],
-        targets: [...COMPILER_TARGETS]
-    },
-    prompts: [
-        "experienceengine_review_repo_status",
-        "experienceengine_review_pack_status",
-        "experienceengine_prepare_pack_publish",
-        "experienceengine_prepare_pack_rollback",
-        "experienceengine_prepare_pack_deploy"
-    ],
-    resources: [
+    routine_read_surfaces: [
+        "experienceengine://doctor/{adapter}",
         "experienceengine://capabilities",
-        "experienceengine://repo-summary",
-        "experienceengine://packs",
-        "experienceengine://pack/{id}",
         "experienceengine://last",
-        "experienceengine://learning/summary"
+        "experienceengine://repo-summary"
+    ],
+    advanced_actions: [
+        "brokered admin actions",
+        "brokered maintenance actions",
+        "brokered inspect actions"
     ],
-    cliFallbacks: [
+    high_risk_actions: [
         "install / repair / upgrade",
-        "backup / export / import / rollback",
-        "maintenance commands"
-    ]
+        "backup / export / import / rollback"
+    ],
+    surface_model: "public core loop + public routine reads + brokered long-tail actions"
 });
 const createCodexRuntime = (options = {}) => {
     const paths = resolveExperienceEnginePaths({
@@ -81,7 +55,7 @@ const createCodexRuntime = (options = {}) => {
     }, {
         env: options.env ?? process.env,
         homeDir: options.homeDir
-    }));
+    }), undefined, options.runtimeOptions);
 };
 const createCodexInteractionService = (options = {}) => {
     const paths = resolveExperienceEnginePaths({
@@ -96,9 +70,7 @@ const createCodexInteractionService = (options = {}) => {
     }, {
         env: options.env ?? process.env,
         homeDir: options.homeDir
-    }), {
-        packsDir: paths.packsDir
-    });
+    }));
 };
 const createCodexOperationalService = (options = {}) => {
     if (!options.fetchImpl) {
@@ -117,11 +89,6 @@ const createCodexStateArtifactService = (options = {}) => options.stateArtifactS
         env: options.env ?? process.env,
         homeDir: options.homeDir
     });
-const createCodexPackActionsService = (options = {}) => options.packActionsService ??
-    new ExperiencePackActionsService({
-        env: options.env ?? process.env,
-        homeDir: options.homeDir
-    });
 const toTextToolResult = (result) => ({
     content: [
         {
@@ -130,6 +97,23 @@ const toTextToolResult = (result) => ({
         }
     ]
 });
+const toNoticeAwareToolResult = (result) => ({
+    content: [
+        ...(result.notice
+            ? [
+                {
+                    type: "text",
+                    text: result.notice
+                }
+            ]
+            : []),
+        {
+            type: "text",
+            text: JSON.stringify(result ?? null, null, 2)
+        }
+    ],
+    structuredContent: result
+});
 const toStructuredToolResult = (result) => ({
     content: [
         {
@@ -148,19 +132,6 @@ const toJsonResourceResult = (uri, result) => ({
         }
     ]
 });
-const parseRecentMode = (value) => {
-    if (value === "all" || value === "injected") {
-        return value;
-    }
-    throw new Error(`Unsupported recent mode: ${value}`);
-};
-const parsePositiveLimit = (value) => {
-    const parsed = Number(value);
-    if (!Number.isInteger(parsed) || parsed <= 0) {
-        throw new Error(`Invalid positive limit: ${value}`);
-    }
-    return parsed;
-};
 const parseNodeState = (value) => {
     if (NODE_STATES.includes(value)) {
         return value;
@@ -186,11 +157,90 @@ const createJsonResourceLink = (uri, name, description) => ({
     mimeType: "application/json",
     description
 });
+const summarizeActionReason = (scorecard) => {
+    if (scorecard.mode === "inject_conservative") {
+        if (scorecard.decisionReason === "ambiguous_same_family_candidate") {
+            return "ExperienceEngine found a promising same-family match and chose conservative injection instead of skipping.";
+        }
+        if (scorecard.decisionReason === "promising_candidate_quality") {
+            return "ExperienceEngine found a credible candidate, but kept the injection conservative until it has stronger runtime proof.";
+        }
+        return "ExperienceEngine chose conservative injection because the best match still needs more runtime evidence.";
+    }
+    if (scorecard.decisionReason === "mature_validated_candidate") {
+        return "A mature validated candidate cleared the fast path, so ExperienceEngine injected it normally.";
+    }
+    if (scorecard.decisionReason === "candidate_quality_positive") {
+        return "Candidate quality was strong enough to justify intervention for this task.";
+    }
+    if (scorecard.mode === "inject") {
+        return "ExperienceEngine injected the best available reusable guidance for this task.";
+    }
+    return undefined;
+};
+const summarizeTrust = (scorecard) => {
+    const primaryNode = scorecard.nodes?.[0];
+    if (!scorecard.riskLevel || !primaryNode?.state) {
+        return undefined;
+    }
+    const confidence = scorecard.confidence ? ` ${scorecard.confidence}-confidence` : "";
+    return `${scorecard.riskLevel}-risk${confidence} ${primaryNode.state} guidance with ${primaryNode.helped ?? 0} helped and ${primaryNode.harmed ?? 0} harmed signal(s).`;
+};
+const summarizeRetrievalNotes = (scorecard) => {
+    const notes = [];
+    if (scorecard.queryRewriteApplied) {
+        notes.push("Query rewrite preserved retrieval intent for this task.");
+    }
+    const rerankSource = scorecard.topCandidates?.[0]?.rerankSource;
+    if (rerankSource === "model") {
+        notes.push("Model reranking participated in the final ordering.");
+    }
+    if (scorecard.fastPathApplied) {
+        notes.push("A strong candidate fast path was used.");
+    }
+    const topCandidate = scorecard.topCandidates?.[0];
+    if (topCandidate?.retrievalReasons?.length) {
+        notes.push(`Top retrieval signals: ${topCandidate.retrievalReasons.slice(0, 2).join(", ")}.`);
+    }
+    if (topCandidate?.policyReasons?.length) {
+        notes.push(`Top policy signals: ${topCandidate.policyReasons.slice(0, 2).join(", ")}.`);
+    }
+    if (scorecard.rejectedCandidates?.length) {
+        notes.push(`Runner-up candidates withheld: ${scorecard.rejectedCandidates.map((candidate) => candidate.id).join(", ")}.`);
+    }
+    return notes;
+};
+const summarizeScorecard = (scorecard) => scorecard
+    ? {
+        mode: scorecard.mode,
+        riskLevel: scorecard.riskLevel,
+        recommendation: scorecard.recommendation,
+        actionReason: summarizeActionReason(scorecard),
+        trustSummary: summarizeTrust(scorecard),
+        retrievalNotes: summarizeRetrievalNotes(scorecard),
+        confidence: scorecard.confidence,
+        budgetClass: scorecard.budgetClass,
+        selectedCandidateIds: scorecard.selectedCandidateIds,
+        rejectedCandidates: scorecard.rejectedCandidates?.slice(0, 3).map((candidate) => ({
+            id: candidate.id,
+            reasonCodes: candidate.reasonCodes
+        })) ?? [],
+        reasons: scorecard.reasons?.slice(0, 2),
+        nodes: scorecard.nodes?.slice(0, 3).map((node) => ({
+            id: node.id,
+            state: node.state,
+            riskLevel: node.riskLevel,
+            helped: node.helped,
+            harmed: node.harmed
+        })) ?? []
+    }
+    : undefined;
 export const createCodexBehaviorLoop = (options = {}) => {
     const runtime = createCodexRuntime(options);
     return {
         async lookupHints(args) {
             const result = await runtime.beforePromptBuild({
+                host: "codex",
                 sessionId: args.sessionId,
                 cwd: args.cwd,
                 userMessage: args.prompt,
@@ -201,7 +251,7 @@ export const createCodexBehaviorLoop = (options = {}) => {
                 text: result.text,
                 notice: result.notice,
                 injectedNodeIds: result.input.injected_node_ids,
-                scorecard: result.scorecard,
+                summary: summarizeScorecard(result.scorecard),
                 deliveryMode: result.deliveryMode,
                 delivered: result.delivered
             };
@@ -217,34 +267,35 @@ export const createCodexBehaviorLoop = (options = {}) => {
                 status: args.status
             });
             return {
+                status: "recorded",
                 toolName: event.tool_name,
-                status: event.status,
-                inputSummary: event.input_summary,
-                outputSummary: event.output_summary,
-                errorSignature: event.error_signature,
+                eventStatus: event.status,
+                hasErrorSignature: Boolean(event.error_signature),
                 exitCode: event.exit_code
             };
         },
         async finalizeTask(args) {
             const input = await runtime.finalizeTask({
+                host: "codex",
                 sessionId: args.sessionId,
                 cwd: args.cwd,
-                userMessage: args.prompt,
+                userMessage: args.prompt ?? "",
                 taskSummary: args.prompt,
                 contextSummary: args.contextSummary
             });
             return {
+                status: "finalized",
                 taskType: input.task_type,
-                taskSummary: input.task_summary,
                 outcomeSignal: input.outcome_signal,
                 injectedNodeIds: input.injected_node_ids,
+                recordedToolEvents: input.tool_events.length,
                 feedbackHint: input.injected_node_ids.length > 0
                     ? "If the injected guidance helped or harmed this task, call experienceengine_quick_feedback."
-                    : undefined,
-                evidence: input.tool_events.map((event) => [event.tool_name, event.status, event.error_signature ?? event.output_summary]
-                    .filter(Boolean)
-                    .join(": "))
+                    : undefined
             };
+        },
+        async waitForBackgroundLearning() {
+            await runtime.waitForBackgroundLearning();
         }
     };
 };
@@ -266,27 +317,6 @@ export const createCodexInteractionSurface = (options = {}) => {
         async inspectNode(args) {
             return interaction.inspectNode(args.nodeId);
         },
-        async listPacks() {
-            return interaction.listPacks();
-        },
-        async inspectPack(args) {
-            return interaction.inspectPack(args.packId);
-        },
-        async enablePack(args) {
-            return interaction.enablePack(args);
-        },
-        async disablePack(args) {
-            return interaction.disablePack(args);
-        },
-        async inspectPackDeploymentStatus(args) {
-            return interaction.inspectPackDeploymentStatus(args);
-        },
-        async compilePack(args) {
-            return interaction.compilePack(args);
-        },
-        async deployPackPreview(args) {
-            return interaction.deployPackPreview(args);
-        },
         async listNodesByState(args) {
             return interaction.listNodesByState(args.state);
         },
@@ -299,6 +329,9 @@ export const createCodexInteractionSurface = (options = {}) => {
         async inspectRepoSummary(args = {}) {
             return interaction.inspectRepoSummary(args.cwd);
         },
+        async explainLastDecision(args) {
+            return interaction.explainLastDecision(args.cwd, args.userMessage);
+        },
         async feedbackLast(args) {
             return interaction.feedbackLast(args.feedback);
         },
@@ -328,11 +361,17 @@ export const createCodexMcpServer = (options = {}) => {
     const interactionSurface = createCodexInteractionSurface(options);
     const operationalSurface = createCodexOperationalService(options);
     const operationalActions = createCodexOperationalActionsService(options);
-    const packActions = createCodexPackActionsService(options);
     const stateArtifacts = createCodexStateArtifactService(options);
+    const actionRegistry = createCodexActionRegistry({
+        interactionSurface,
+        operationalSurface,
+        operationalActions,
+        stateArtifacts
+    });
+    const brokerFacade = createCodexBrokerFacade(actionRegistry);
     const server = new McpServer({
         name: "experienceengine",
-        version: "0.1.2"
+        version: "0.2.0"
     });
     server.registerResource("experienceengine_doctor", new ResourceTemplate("experienceengine://doctor/{adapter}", {
         list: undefined,
@@ -344,437 +383,36 @@ export const createCodexMcpServer = (options = {}) => {
         description: "Structured ExperienceEngine adapter health and installation state.",
         mimeType: "application/json"
     }, async (uri, variables) => toJsonResourceResult(uri.toString(), await operationalSurface.inspectDoctor(parseAdapter(String(variables.adapter)))));
-    server.registerResource("experienceengine_updates_latest", new ResourceTemplate("experienceengine://updates/latest/{adapter}", {
-        list: undefined,
-        complete: {
-            adapter: () => [...EXPERIENCE_ADAPTERS]
-        }
-    }), {
-        title: "ExperienceEngine Latest Update State",
-        description: "Latest release/update status for an ExperienceEngine adapter context.",
-        mimeType: "application/json"
-    }, async (uri, variables) => toJsonResourceResult(uri.toString(), await operationalSurface.checkUpdate(parseAdapter(String(variables.adapter)))));
-    server.registerResource("experienceengine_backups", "experienceengine://backups", {
-        title: "ExperienceEngine Backup Inventory",
-        description: "Managed ExperienceEngine backups available for rollback or export review.",
-        mimeType: "application/json"
-    }, async (uri) => toJsonResourceResult(uri.toString(), stateArtifacts.listBackups()));
     server.registerResource("experienceengine_last", "experienceengine://last", {
         title: "ExperienceEngine Last Interaction",
         description: "The most recent persisted ExperienceEngine input record and any injected nodes.",
         mimeType: "application/json"
     }, async (uri) => toJsonResourceResult(uri.toString(), await interactionSurface.inspectLast()));
-    server.registerResource("experienceengine_recent", new ResourceTemplate("experienceengine://recent/{mode}/{limit}", {
-        list: undefined,
-        complete: {
-            mode: () => ["all", "injected"],
-            limit: () => ["5", "10", "20"]
-        }
-    }), {
-        title: "ExperienceEngine Recent History",
-        description: "Recent ExperienceEngine input records, optionally filtered to injected turns only.",
-        mimeType: "application/json"
-    }, async (uri, variables) => toJsonResourceResult(uri.toString(), await interactionSurface.inspectRecent({
-        mode: parseRecentMode(String(variables.mode ?? "all")),
-        limit: parsePositiveLimit(String(variables.limit ?? "10"))
-    })));
     server.registerResource("experienceengine_capabilities", "experienceengine://capabilities", {
         title: "ExperienceEngine Capabilities",
-        description: "Agent-first overview of ExperienceEngine MCP tools, guarded flows, prompts, and fallback boundaries.",
+        description: "Agent-first overview of ExperienceEngine MCP tools, routine reads, brokered actions, and fallback boundaries.",
         mimeType: "application/json"
     }, async (uri) => toJsonResourceResult(uri.toString(), buildExperienceCapabilities()));
     server.registerResource("experienceengine_repo_summary", "experienceengine://repo-summary", {
         title: "ExperienceEngine Repo Summary",
-        description: "Repo-level ExperienceEngine summary for the current scope, including benchmark, packs, deployment, and next action.",
+        description: "Repo-level ExperienceEngine summary for the current scope, including benchmark and next action.",
         mimeType: "application/json"
     }, async (uri) => toJsonResourceResult(uri.toString(), await interactionSurface.inspectRepoSummary()));
-    server.registerResource("experienceengine_packs", "experienceengine://packs", {
-        title: "ExperienceEngine Packs",
-        description: "Published and draft local Experience Pack assets in the shared registry.",
-        mimeType: "application/json"
-    }, async (uri) => toJsonResourceResult(uri.toString(), await interactionSurface.listPacks()));
-    server.registerResource("experienceengine_pack", new ResourceTemplate("experienceengine://pack/{id}", {
-        list: undefined
-    }), {
-        title: "ExperienceEngine Pack Detail",
-        description: "A single Experience Pack and its current version detail.",
-        mimeType: "application/json"
-    }, async (uri, variables) => toJsonResourceResult(uri.toString(), await interactionSurface.inspectPack({ packId: String(variables.id) })));
-    server.registerResource("experienceengine_learning_summary", "experienceengine://learning/summary", {
-        title: "ExperienceEngine Learning Summary",
-        description: "Candidate, distillation, and formal node counts across the learning pipeline.",
-        mimeType: "application/json"
-    }, async (uri) => toJsonResourceResult(uri.toString(), await interactionSurface.inspectLearningSummary()));
-    server.registerResource("experienceengine_active_nodes", "experienceengine://nodes/active", {
-        title: "ExperienceEngine Active Nodes",
-        description: "All currently active ExperienceEngine nodes.",
-        mimeType: "application/json"
-    }, async (uri) => toJsonResourceResult(uri.toString(), await interactionSurface.listActiveNodes()));
-    server.registerResource("experienceengine_node", new ResourceTemplate("experienceengine://node/{id}", {
-        list: undefined
-    }), {
-        title: "ExperienceEngine Node Detail",
-        description: "A single ExperienceEngine node by id.",
-        mimeType: "application/json"
-    }, async (uri, variables) => toJsonResourceResult(uri.toString(), await interactionSurface.inspectNode({ nodeId: String(variables.id) })));
-    server.registerResource("experienceengine_nodes_by_state", new ResourceTemplate("experienceengine://nodes/state/{state}", {
-        list: undefined,
-        complete: {
-            state: () => [...NODE_STATES]
-        }
-    }), {
-        title: "ExperienceEngine Nodes By State",
-        description: "ExperienceEngine nodes filtered by lifecycle state.",
-        mimeType: "application/json"
-    }, async (uri, variables) => toJsonResourceResult(uri.toString(), await interactionSurface.listNodesByState({
-        state: parseNodeState(String(variables.state))
-    })));
-    server.registerResource("experienceengine_nodes_by_type", new ResourceTemplate("experienceengine://nodes/type/{type}", {
-        list: undefined,
-        complete: {
-            type: () => [...NODE_TYPES]
-        }
-    }), {
-        title: "ExperienceEngine Nodes By Type",
-        description: "ExperienceEngine nodes filtered by node type.",
-        mimeType: "application/json"
-    }, async (uri, variables) => toJsonResourceResult(uri.toString(), await interactionSurface.listNodesByType({
-        nodeType: parseNodeType(String(variables.type))
-    })));
-    server.registerPrompt("experienceengine_review_repo_status", {
-        title: "ExperienceEngine Review Repo Status",
-        description: "Guide the host agent to review the current repo's ExperienceEngine state before deciding what to do next."
-    }, async () => ({
-        messages: [
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text: "First read the experienceengine://repo-summary resource. Then call experienceengine_get_repo_summary if you need the structured form. Summarize the repo benchmark verdict, suggested mode, active packs, deploy status, and the most conservative next action."
-                }
-            }
-        ]
-    }));
-    server.registerPrompt("experienceengine_review_capabilities", {
-        title: "ExperienceEngine Review Capabilities",
-        description: "Guide the host agent to review ExperienceEngine's agent-first MCP surface before operating packs or compiler targets."
-    }, async () => ({
-        messages: [
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text: "First read the experienceengine://capabilities resource. Then summarize which ExperienceEngine operations are direct low-risk tools, which require confirmation, and which CLI fallbacks remain outside the normal host-agent flow."
-                }
-            }
-        ]
-    }));
-    server.registerPrompt("experienceengine_prepare_state_operation", {
-        title: "ExperienceEngine Prepare State Operation",
-        description: "Review a backup, export, import, or rollback plan before execution.",
-        argsSchema: {
-            operation: z.enum(["backup", "export", "import", "rollback"]),
-            backupId: z.string().optional(),
-            importPath: z.string().optional()
-        }
-    }, async ({ operation, backupId, importPath }) => {
-        const planTool = operation === "backup"
-            ? "experienceengine_plan_backup"
-            : operation === "export"
-                ? "experienceengine_plan_export"
-                : operation === "import"
-                    ? "experienceengine_plan_import"
-                    : "experienceengine_plan_rollback";
-        const suffix = operation === "rollback"
-            ? ` with backupId=${backupId ?? "<backup-id>"}`
-            : operation === "import"
-                ? ` with importPath=${importPath ?? "<snapshot-path>"}`
-                : "";
-        return {
-            messages: [
-                {
-                    role: "user",
-                    content: {
-                        type: "text",
-                        text: `First call ${planTool}${suffix}. Review the returned summary, effects, and artifact path with the user. Only if the user explicitly confirms should you call experienceengine_execute_planned_state_operation with the returned planId and confirmationToken.`
-                    }
-                }
-            ]
-        };
-    });
-    server.registerPrompt("experienceengine_prepare_operational_change", {
-        title: "ExperienceEngine Prepare Operational Change",
-        description: "Plan a high-impact ExperienceEngine install, repair, or upgrade before execution.",
-        argsSchema: {
-            adapter: z.enum(EXPERIENCE_ADAPTERS),
-            operation: z.enum(HIGH_IMPACT_OPERATIONS)
-        }
-    }, async ({ adapter, operation }) => ({
-        messages: [
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text: `First call experienceengine_plan_${operation} with adapter=${adapter}. Review the returned summary, effects, and commandHint with the user. Only if the user explicitly confirms should you call experienceengine_execute_planned_operation with the returned planId and confirmationToken.`
-                }
-            }
-        ]
-    }));
-    server.registerPrompt("experienceengine_review_pack_status", {
-        title: "ExperienceEngine Review Pack Status",
-        description: "Guide the agent to inspect one pack, its compile state, and current repo deployment status.",
-        argsSchema: {
-            packId: z.string().min(1),
-            target: z.enum(COMPILER_TARGETS),
-            repoPath: z.string().min(1)
-        }
-    }, async ({ packId, target, repoPath }) => ({
-        messages: [
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text: `Review the Experience Pack ${packId}. First call experienceengine_pack_inspect to inspect the pack itself. Then call experienceengine_pack_status with target=${target} and repoPath=${repoPath} to inspect whether the current repository is missing, up to date, or drifted. Summarize the pack state, compile state, deployment state, and the next recommended action.`
-                }
-            }
-        ]
-    }));
-    server.registerPrompt("experienceengine_prepare_pack_publish", {
-        title: "ExperienceEngine Prepare Pack Publish",
-        description: "Guide the agent through the confirmation flow for publishing an Experience Pack.",
-        argsSchema: {
-            packId: z.string().min(1)
-        }
-    }, async ({ packId }) => ({
-        messages: [
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text: `First call experienceengine_plan_pack_publish with packId=${packId}. Review the returned summary, effects, and commandHint with the user. Only if the user explicitly confirms should you call experienceengine_execute_planned_pack_operation with the returned planId and confirmationToken.`
-                }
-            }
-        ]
-    }));
-    server.registerPrompt("experienceengine_prepare_pack_rollback", {
-        title: "ExperienceEngine Prepare Pack Rollback",
-        description: "Guide the agent through the confirmation flow for rolling an Experience Pack back to a selected version.",
-        argsSchema: {
-            packId: z.string().min(1),
-            version: z.string().min(1)
-        }
-    }, async ({ packId, version }) => ({
-        messages: [
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text: `First call experienceengine_plan_pack_rollback with packId=${packId} and version=${version}. Review the returned summary, effects, and commandHint with the user. Only if the user explicitly confirms should you call experienceengine_execute_planned_pack_operation with the returned planId and confirmationToken.`
-                }
-            }
-        ]
-    }));
-    server.registerPrompt("experienceengine_prepare_pack_deploy", {
-        title: "ExperienceEngine Prepare Pack Deploy",
-        description: "Guide the agent through the confirmation flow for deploying a compiled Experience Pack into a repository.",
-        argsSchema: {
-            packId: z.string().min(1),
-            target: z.enum(COMPILER_TARGETS),
-            repoPath: z.string().min(1)
-        }
-    }, async ({ packId, target, repoPath }) => ({
-        messages: [
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text: `First call experienceengine_plan_pack_deploy with packId=${packId}, target=${target}, and repoPath=${repoPath}. Review the returned summary, effects, and commandHint with the user. Only if the user explicitly confirms should you call experienceengine_execute_planned_pack_operation with the returned planId and confirmationToken.`
-                }
-            }
-        ]
-    }));
-    server.registerPrompt("experienceengine_show_last_intervention", {
-        title: "ExperienceEngine Show Last Intervention",
-        description: "Review the most recent ExperienceEngine interaction and summarize what happened."
-    }, async () => ({
-        messages: [
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text: "Review the latest ExperienceEngine interaction. Summarize whether guidance was injected, which nodes were involved, and what outcome was recorded."
-                }
-            },
-            {
-                role: "user",
-                content: createJsonResourceLink("experienceengine://last", "ExperienceEngine Last Interaction", "The latest persisted ExperienceEngine record and any resolved injected nodes.")
-            }
-        ]
-    }));
-    server.registerPrompt("experienceengine_review_recent_injected", {
-        title: "ExperienceEngine Review Recent Injected",
-        description: "Review recent ExperienceEngine turns that actually injected guidance.",
-        argsSchema: {
-            limit: z.string().optional()
-        }
-    }, async ({ limit }) => {
-        const resolvedLimit = limit ? parsePositiveLimit(limit) : 5;
-        const uri = `experienceengine://recent/injected/${resolvedLimit}`;
-        return {
-            messages: [
-                {
-                    role: "user",
-                    content: {
-                        type: "text",
-                        text: `Review the ${resolvedLimit} most recent ExperienceEngine turns that injected guidance. Summarize recurring successful patterns and any harmful repeats.`
-                    }
-                },
-                {
-                    role: "user",
-                    content: createJsonResourceLink(uri, "ExperienceEngine Recent Injected History", "Recent ExperienceEngine records filtered to injected turns.")
-                }
-            ]
-        };
-    });
-    server.registerPrompt("experienceengine_review_warning_nodes", {
-        title: "ExperienceEngine Review Warning Nodes",
-        description: "Review current warning nodes to assess whether they are still useful or noisy."
-    }, async () => ({
-        messages: [
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text: "Review the current ExperienceEngine warning nodes. Identify noisy or stale warnings, and call out any warning that appears to be over-firing or no longer useful."
-                }
-            },
-            {
-                role: "user",
-                content: createJsonResourceLink("experienceengine://nodes/type/warning", "ExperienceEngine Warning Nodes", "All ExperienceEngine nodes currently classified as warning nodes.")
-            }
-        ]
-    }));
-    server.registerPrompt("experienceengine_pause_current_project", {
-        title: "ExperienceEngine Pause Current Project",
-        description: "Guide the agent to pause ExperienceEngine interventions for the current project.",
-        argsSchema: {
-            cwd: z.string().optional()
-        }
-    }, async ({ cwd }) => ({
-        messages: [
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text: `Pause ExperienceEngine interventions for the current project${cwd ? ` at ${cwd}` : ""}. Confirm this action before calling the experienceengine_disable_scope tool, then summarize which scope was changed.`
-                }
-            }
-        ]
-    }));
-    server.registerPrompt("experienceengine_resume_current_project", {
-        title: "ExperienceEngine Resume Current Project",
-        description: "Guide the agent to resume ExperienceEngine interventions for the current project.",
-        argsSchema: {
-            cwd: z.string().optional()
-        }
-    }, async ({ cwd }) => ({
-        messages: [
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text: `Resume ExperienceEngine interventions for the current project${cwd ? ` at ${cwd}` : ""}. Confirm this action before calling the experienceengine_enable_scope tool, then summarize which scope was changed.`
-                }
-            }
-        ]
-    }));
-    server.registerPrompt("experienceengine_mark_last_experience_helpful", {
-        title: "ExperienceEngine Mark Last Experience Helpful",
-        description: "Guide the agent to mark the last injected experience as helpful."
-    }, async () => ({
-        messages: [
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text: "Mark the last injected ExperienceEngine guidance as helpful. Confirm with the user if needed, then call the experienceengine_feedback_last tool with feedback=helped and summarize which nodes were updated."
-                }
-            }
-        ]
-    }));
-    server.registerPrompt("experienceengine_mark_last_experience_harmful", {
-        title: "ExperienceEngine Mark Last Experience Harmful",
-        description: "Guide the agent to mark the last injected experience as harmful."
-    }, async () => ({
-        messages: [
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text: "Mark the last injected ExperienceEngine guidance as harmful. Confirm with the user if needed, then call the experienceengine_feedback_last tool with feedback=harmed and summarize which nodes were updated."
-                }
-            }
-        ]
-    }));
-    server.registerTool("experienceengine_plan_backup", {
-        title: "ExperienceEngine Plan Backup",
-        description: "Create a structured plan for backing up ExperienceEngine-managed state."
-    }, async () => toStructuredToolResult(stateArtifacts.planOperation({ operation: "backup" })));
-    server.registerTool("experienceengine_plan_export", {
-        title: "ExperienceEngine Plan Export",
-        description: "Create a structured plan for exporting ExperienceEngine-managed state."
-    }, async () => toStructuredToolResult(stateArtifacts.planOperation({ operation: "export" })));
-    server.registerTool("experienceengine_plan_import", {
-        title: "ExperienceEngine Plan Import",
-        description: "Create a structured plan for importing an ExperienceEngine snapshot.",
-        inputSchema: z.object({
-            importPath: z.string().min(1)
-        })
-    }, async ({ importPath }) => toStructuredToolResult(stateArtifacts.planOperation({ operation: "import", importPath })));
-    server.registerTool("experienceengine_plan_rollback", {
-        title: "ExperienceEngine Plan Rollback",
-        description: "Create a structured plan for rolling back ExperienceEngine state to a managed backup.",
-        inputSchema: z.object({
-            backupId: z.string().min(1)
-        })
-    }, async ({ backupId }) => toStructuredToolResult(stateArtifacts.planOperation({ operation: "rollback", backupId })));
-    server.registerTool("experienceengine_execute_planned_state_operation", {
-        title: "ExperienceEngine Execute Planned State Operation",
-        description: "Execute a previously planned ExperienceEngine backup, export, import, or rollback after explicit confirmation.",
-        inputSchema: z.object({
-            planId: z.string().min(1),
-            confirmationToken: z.string().min(1)
-        })
-    }, async ({ planId, confirmationToken }) => toStructuredToolResult(stateArtifacts.executePlannedOperation({ planId, confirmationToken })));
-    server.registerTool("experienceengine_plan_install", {
-        title: "ExperienceEngine Plan Install",
-        description: "Create a structured plan for installing ExperienceEngine on a supported adapter.",
-        inputSchema: z.object({
-            adapter: z.enum(EXPERIENCE_ADAPTERS)
-        })
-    }, async ({ adapter }) => toStructuredToolResult(operationalActions.planOperation({ adapter, operation: "install" })));
-    server.registerTool("experienceengine_plan_repair", {
-        title: "ExperienceEngine Plan Repair",
-        description: "Create a structured plan for repairing ExperienceEngine wiring on a supported adapter.",
-        inputSchema: z.object({
-            adapter: z.enum(EXPERIENCE_ADAPTERS)
-        })
-    }, async ({ adapter }) => toStructuredToolResult(operationalActions.planOperation({ adapter, operation: "repair" })));
-    server.registerTool("experienceengine_plan_upgrade", {
-        title: "ExperienceEngine Plan Upgrade",
-        description: "Create a structured plan for upgrading ExperienceEngine on a supported adapter.",
-        inputSchema: z.object({
-            adapter: z.enum(EXPERIENCE_ADAPTERS)
-        })
-    }, async ({ adapter }) => toStructuredToolResult(operationalActions.planOperation({ adapter, operation: "upgrade" })));
-    server.registerTool("experienceengine_execute_planned_operation", {
-        title: "ExperienceEngine Execute Planned Operation",
-        description: "Execute a previously planned high-impact ExperienceEngine operation after explicit user confirmation.",
-        inputSchema: z.object({
-            planId: z.string().min(1),
-            confirmationToken: z.string().min(1)
-        })
-    }, async ({ planId, confirmationToken }) => toStructuredToolResult(operationalActions.executePlannedOperation({ planId, confirmationToken })));
+    server.registerTool("experienceengine_list_actions", {
+        title: "ExperienceEngine List Actions",
+        description: "List brokered EE long-tail actions without exposing full schemas.",
+        inputSchema: listCodexActionsSchema
+    }, async (args) => toStructuredToolResult(brokerFacade.listActions(args)));
+    server.registerTool("experienceengine_prepare_action", {
+        title: "ExperienceEngine Prepare Action",
+        description: "Read detailed metadata for one brokered EE action.",
+        inputSchema: prepareCodexActionSchema
+    }, async (args) => toStructuredToolResult(brokerFacade.prepareAction(args)));
+    server.registerTool("experienceengine_execute_action", {
+        title: "ExperienceEngine Execute Action",
+        description: "Execute one brokered EE action through the internal action registry.",
+        inputSchema: executeCodexActionSchema
+    }, async (args) => toStructuredToolResult(await brokerFacade.executeAction(args)));
     server.registerTool("experienceengine_doctor", {
         title: "ExperienceEngine Doctor",
         description: "Inspect structured ExperienceEngine adapter health and installation state.",
@@ -786,147 +424,39 @@ export const createCodexMcpServer = (options = {}) => {
             openWorldHint: false
         }
     }, async ({ adapter }) => toTextToolResult(await operationalSurface.inspectDoctor(adapter)));
-    server.registerTool("experienceengine_check_update", {
-        title: "ExperienceEngine Check Update",
-        description: "Check structured ExperienceEngine release/update state for an adapter context.",
-        inputSchema: z.object({
-            adapter: z.enum(EXPERIENCE_ADAPTERS)
-        }),
-        annotations: {
-            readOnlyHint: true,
-            openWorldHint: true
-        }
-    }, async ({ adapter }) => toTextToolResult(await operationalSurface.checkUpdate(adapter)));
-    server.registerTool("experienceengine_plan_pack_publish", {
-        title: "ExperienceEngine Plan Pack Publish",
-        description: "Create a structured confirmation plan for publishing an Experience Pack.",
-        inputSchema: z.object({
-            packId: z.string().min(1)
-        })
-    }, async ({ packId }) => toStructuredToolResult(packActions.planPublish(packId)));
-    server.registerTool("experienceengine_plan_pack_rollback", {
-        title: "ExperienceEngine Plan Pack Rollback",
-        description: "Create a structured confirmation plan for rolling an Experience Pack back to an earlier version.",
-        inputSchema: z.object({
-            packId: z.string().min(1),
-            version: z.string().min(1)
-        })
-    }, async ({ packId, version }) => toStructuredToolResult(packActions.planRollback(packId, version)));
-    server.registerTool("experienceengine_plan_pack_deploy", {
-        title: "ExperienceEngine Plan Pack Deploy",
-        description: "Create a structured confirmation plan for deploying a compiled Experience Pack into a repository.",
-        inputSchema: z.object({
-            packId: z.string().min(1),
-            version: z.string().optional(),
-            target: z.enum(COMPILER_TARGETS),
-            repoPath: z.string().min(1)
-        })
-    }, async ({ packId, version, target, repoPath }) => toStructuredToolResult(packActions.planDeploy(packId, target, repoPath, version)));
-    server.registerTool("experienceengine_execute_planned_pack_operation", {
-        title: "ExperienceEngine Execute Planned Pack Operation",
-        description: "Execute a previously planned pack publish, rollback, or deploy after explicit confirmation.",
-        inputSchema: z.object({
-            planId: z.string().min(1),
-            confirmationToken: z.string().min(1)
-        })
-    }, async ({ planId, confirmationToken }) => toStructuredToolResult(packActions.executePlannedOperation({ planId, confirmationToken })));
-    server.registerTool("experienceengine_pack_list", {
-        title: "ExperienceEngine Pack List",
-        description: "List local Experience Packs available in the shared registry.",
+    server.registerTool("experienceengine_get_capabilities", {
+        title: "ExperienceEngine Capabilities",
+        description: "Read the current ExperienceEngine MCP capabilities, including direct tools, routine reads, brokered actions, and CLI-only fallbacks.",
         inputSchema: z.object({}),
         annotations: {
             readOnlyHint: true,
             openWorldHint: false
         }
-    }, async () => toStructuredToolResult({ packs: await interactionSurface.listPacks() }));
-    server.registerTool("experienceengine_pack_inspect", {
-        title: "ExperienceEngine Pack Inspect",
-        description: "Inspect one Experience Pack, including its current version, nodes, activations, and compiled artifacts.",
-        inputSchema: z.object({
-            packId: z.string().min(1)
-        }),
-        annotations: {
-            readOnlyHint: true,
-            openWorldHint: false
-        }
-    }, async ({ packId }) => toStructuredToolResult(await interactionSurface.inspectPack({ packId })));
-    server.registerTool("experienceengine_pack_enable", {
-        title: "ExperienceEngine Pack Enable",
-        description: "Enable an Experience Pack for the current repository scope.",
-        inputSchema: z.object({
-            packId: z.string().min(1),
-            cwd: z.string().optional()
-        })
-    }, async ({ packId, cwd }) => toStructuredToolResult(await interactionSurface.enablePack({ packId, cwd })));
-    server.registerTool("experienceengine_pack_disable", {
-        title: "ExperienceEngine Pack Disable",
-        description: "Disable an Experience Pack for the current repository scope.",
-        inputSchema: z.object({
-            packId: z.string().min(1),
-            cwd: z.string().optional()
-        })
-    }, async ({ packId, cwd }) => toStructuredToolResult(await interactionSurface.disablePack({ packId, cwd })));
-    server.registerTool("experienceengine_pack_status", {
-        title: "ExperienceEngine Pack Status",
-        description: "Inspect whether a compiled Experience Pack target is missing, up to date, or drifted in a repository.",
+    }, async () => toStructuredToolResult(buildExperienceCapabilities()));
+    server.registerTool("experienceengine_explain_last_decision", {
+        title: "ExperienceEngine Explain Last Decision",
+        description: "Explain why the latest ExperienceEngine intervention matched or stayed quiet for the current workspace.",
         inputSchema: z.object({
-            packId: z.string().min(1),
-            version: z.string().optional(),
-            target: z.enum(COMPILER_TARGETS),
-            repoPath: z.string().min(1)
+            cwd: z.string().optional(),
+            userMessage: z.string().min(1)
         }),
         annotations: {
             readOnlyHint: true,
             openWorldHint: false
         }
-    }, async ({ packId, version, target, repoPath }) => toStructuredToolResult(await interactionSurface.inspectPackDeploymentStatus({ packId, version, target, repoPath })));
-    server.registerTool("experienceengine_pack_compile", {
-        title: "ExperienceEngine Pack Compile",
-        description: "Compile a published Experience Pack into a host-friendly artifact without deploying it.",
-        inputSchema: z.object({
-            packId: z.string().min(1),
-            version: z.string().optional(),
-            target: z.enum(COMPILER_TARGETS)
-        })
-    }, async ({ packId, version, target }) => toStructuredToolResult(await interactionSurface.compilePack({ packId, version, target })));
-    server.registerTool("experienceengine_pack_deploy_preview", {
-        title: "ExperienceEngine Pack Deploy Preview",
-        description: "Preview where a compiled Experience Pack artifact would deploy and whether it would overwrite drifted content.",
-        inputSchema: z.object({
-            packId: z.string().min(1),
-            version: z.string().optional(),
-            target: z.enum(COMPILER_TARGETS),
-            repoPath: z.string().min(1)
-        })
-    }, async ({ packId, version, target, repoPath }) => toStructuredToolResult(await interactionSurface.deployPackPreview({ packId, version, target, repoPath })));
-    server.registerTool("experienceengine_get_repo_summary", {
-        title: "ExperienceEngine Get Repo Summary",
-        description: "Read the current repo-level ExperienceEngine summary for the active or specified cwd.",
-        inputSchema: {
-            cwd: z.string().optional()
-        }
-    }, async ({ cwd }) => toStructuredToolResult(await interactionSurface.inspectRepoSummary({ cwd })));
-    server.registerTool("experienceengine_get_capabilities", {
-        title: "ExperienceEngine Capabilities",
-        description: "Read the current ExperienceEngine MCP capabilities, including direct tools, guarded flows, prompts, and CLI-only fallbacks.",
-        inputSchema: z.object({}),
-        annotations: {
-            readOnlyHint: true,
-            openWorldHint: false
-        }
-    }, async () => toStructuredToolResult(buildExperienceCapabilities()));
+    }, async ({ cwd, userMessage }) => toTextToolResult(await interactionSurface.explainLastDecision({ cwd, userMessage })));
     server.registerTool("experienceengine_lookup_hints", {
         title: "ExperienceEngine Lookup Hints",
-        description: "Look up concise prior experience hints for the current coding task without assuming host lifecycle hooks.",
+        description: "Use once at task start for a real coding or debugging task to check whether ExperienceEngine has relevant prior guidance.",
         inputSchema: z.object({
             cwd: z.string().optional(),
             prompt: z.string().min(1),
             sessionId: z.string().optional()
         })
-    }, async ({ cwd, prompt, sessionId }) => toTextToolResult(await behaviorLoop.lookupHints({ cwd, prompt, sessionId })));
+    }, async ({ cwd, prompt, sessionId }) => toNoticeAwareToolResult(await behaviorLoop.lookupHints({ cwd, prompt, sessionId })));
     server.registerTool("experienceengine_record_tool_result", {
         title: "ExperienceEngine Record Tool Result",
-        description: "Record a Codex tool result into the active ExperienceEngine session before finalization.",
+        description: "Record only important tool outcomes that changed the task direction, especially notable shell, test, build, or edit results, before finalization.",
         inputSchema: z.object({
             sessionId: z.string().min(1),
             toolName: z.string().min(1),
@@ -939,31 +469,17 @@ export const createCodexMcpServer = (options = {}) => {
     }, async (args) => toTextToolResult(await behaviorLoop.recordToolResult(args)));
     server.registerTool("experienceengine_finalize_task", {
         title: "ExperienceEngine Finalize Task",
-        description: "Finalize a Codex task after hint lookup and optional tool-result recording to persist outcomes and feedback.",
+        description: "Call at task end after hint lookup and any important tool-result recording to persist the learning loop outcome. Omit prompt when the task is unchanged from the earlier lookup in the same session.",
         inputSchema: z.object({
             sessionId: z.string().min(1),
             cwd: z.string().optional(),
-            prompt: z.string().min(1),
+            prompt: z.string().min(1).optional(),
             contextSummary: z.string().optional()
         })
     }, async (args) => toTextToolResult(await behaviorLoop.finalizeTask(args)));
-    server.registerTool("experienceengine_quick_feedback", {
-        title: "ExperienceEngine Quick Feedback",
-        description: "Record helped or harmed feedback for the last injected ExperienceEngine guidance using the shortest possible interaction path.",
-        inputSchema: z.object({
-            feedback: z.enum(["helped", "harmed"])
-        }),
-        outputSchema: z.object({
-            status: z.enum(["updated", "not_found"]),
-            feedback: z.enum(["helped", "harmed"]).optional(),
-            nodeIds: z.array(z.string()).optional(),
-            reason: z.enum(["last_injected_missing", "node_missing"]).optional(),
-            nodeId: z.string().optional()
-        })
-    }, async ({ feedback }) => toStructuredToolResult(await interactionSurface.feedbackLast({ feedback })));
     server.registerTool("experienceengine_feedback_last", {
         title: "ExperienceEngine Feedback Last",
-        description: "Record helped or harmed feedback for the last injected ExperienceEngine node set.",
+        description: "Record helped or harmed feedback after injected guidance for the last injected ExperienceEngine node set.",
         inputSchema: z.object({
             feedback: z.enum(["helped", "harmed"])
         }),
@@ -975,73 +491,6 @@ export const createCodexMcpServer = (options = {}) => {
             nodeId: z.string().optional()
         })
     }, async ({ feedback }) => toStructuredToolResult(await interactionSurface.feedbackLast({ feedback })));
-    server.registerTool("experienceengine_feedback_node", {
-        title: "ExperienceEngine Feedback Node",
-        description: "Record helped or harmed feedback for a specific ExperienceEngine node.",
-        inputSchema: z.object({
-            nodeId: z.string().min(1),
-            feedback: z.enum(["helped", "harmed"])
-        }),
-        outputSchema: z.object({
-            status: z.enum(["updated", "not_found"]),
-            feedback: z.enum(["helped", "harmed"]).optional(),
-            nodeIds: z.array(z.string()).optional(),
-            reason: z.enum(["last_injected_missing", "node_missing"]).optional(),
-            nodeId: z.string().optional()
-        })
-    }, async ({ nodeId, feedback }) => toStructuredToolResult(await interactionSurface.feedbackNode({ nodeId, feedback })));
-    server.registerTool("experienceengine_disable_scope", {
-        title: "ExperienceEngine Disable Scope",
-        description: "Disable ExperienceEngine interventions for the provided working directory scope.",
-        inputSchema: z.object({
-            cwd: z.string().optional()
-        }),
-        outputSchema: z.object({
-            scopeId: z.string(),
-            scopeName: z.string(),
-            rootPath: z.string().optional(),
-            isDisabled: z.boolean(),
-            changed: z.boolean()
-        })
-    }, async ({ cwd }) => toStructuredToolResult(await interactionSurface.disableScope({ cwd })));
-    server.registerTool("experienceengine_enable_scope", {
-        title: "ExperienceEngine Enable Scope",
-        description: "Enable ExperienceEngine interventions for the provided working directory scope.",
-        inputSchema: z.object({
-            cwd: z.string().optional()
-        }),
-        outputSchema: z.object({
-            scopeId: z.string(),
-            scopeName: z.string(),
-            rootPath: z.string().optional(),
-            isDisabled: z.boolean(),
-            changed: z.boolean()
-        })
-    }, async ({ cwd }) => toStructuredToolResult(await interactionSurface.enableScope({ cwd })));
-    server.registerTool("experienceengine_cool_node", {
-        title: "ExperienceEngine Cool Node",
-        description: "Move a specific ExperienceEngine node into cooling state.",
-        inputSchema: z.object({
-            nodeId: z.string().min(1)
-        }),
-        outputSchema: z.object({
-            status: z.enum(["updated", "not_found"]),
-            nodeId: z.string(),
-            state: z.enum(["candidate", "active", "cooling", "retired"]).optional()
-        })
-    }, async ({ nodeId }) => toStructuredToolResult(await interactionSurface.coolNode({ nodeId })));
-    server.registerTool("experienceengine_retire_node", {
-        title: "ExperienceEngine Retire Node",
-        description: "Retire a specific ExperienceEngine node so it is no longer injected.",
-        inputSchema: z.object({
-            nodeId: z.string().min(1)
-        }),
-        outputSchema: z.object({
-            status: z.enum(["updated", "not_found"]),
-            nodeId: z.string(),
-            state: z.enum(["candidate", "active", "cooling", "retired"]).optional()
-        })
-    }, async ({ nodeId }) => toStructuredToolResult(await interactionSurface.retireNode({ nodeId })));
     return server;
 };
 export const runCodexMcpServer = async () => {