@alan512/experienceengine 0.1.2 → 0.1.3

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

@@ -7,14 +7,12 @@ 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"];
+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: [
@@ -22,43 +20,12 @@ const buildExperienceCapabilities = () => ({
         "Low-risk read and preview operations should be direct MCP tools.",
         "High-risk write operations should use plan -> review -> confirm flows."
     ],
-    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"
+        "experienceengine_review_repo_status"
     ],
     resources: [
         "experienceengine://capabilities",
         "experienceengine://repo-summary",
-        "experienceengine://packs",
-        "experienceengine://pack/{id}",
         "experienceengine://last",
         "experienceengine://learning/summary"
     ],
@@ -96,9 +63,7 @@ const createCodexInteractionService = (options = {}) => {
     }, {
         env: options.env ?? process.env,
         homeDir: options.homeDir
-    }), {
-        packsDir: paths.packsDir
-    });
+    }));
 };
 const createCodexOperationalService = (options = {}) => {
     if (!options.fetchImpl) {
@@ -117,11 +82,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: [
         {
@@ -186,11 +146,72 @@ 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;
+    }
+    return `${scorecard.riskLevel}-risk ${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.");
+    }
+    return notes;
+};
+const summarizeScorecard = (scorecard) => scorecard
+    ? {
+        mode: scorecard.mode,
+        riskLevel: scorecard.riskLevel,
+        recommendation: scorecard.recommendation,
+        actionReason: summarizeActionReason(scorecard),
+        trustSummary: summarizeTrust(scorecard),
+        retrievalNotes: summarizeRetrievalNotes(scorecard),
+        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 +222,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,33 +238,31 @@ 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
             };
         }
     };
@@ -266,27 +285,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);
         },
@@ -328,11 +326,10 @@ 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 server = new McpServer({
         name: "experienceengine",
-        version: "0.1.2"
+        version: "0.1.3"
     });
     server.registerResource("experienceengine_doctor", new ResourceTemplate("experienceengine://doctor/{adapter}", {
         list: undefined,
@@ -385,21 +382,9 @@ export const createCodexMcpServer = (options = {}) => {
     }, 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.",
@@ -450,21 +435,21 @@ export const createCodexMcpServer = (options = {}) => {
                 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."
+                    text: "Read experienceengine://repo-summary first. Summarize the repo verdict, suggested mode, and safest 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."
+        description: "Guide the host agent to review ExperienceEngine's agent-first MCP surface before using advanced ExperienceEngine operations."
     }, 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."
+                    text: "Read experienceengine://capabilities first. Summarize which ExperienceEngine actions are direct tools, which need confirmation, and which stay CLI/operator-only."
                 }
             }
         ]
@@ -496,7 +481,7 @@ export const createCodexMcpServer = (options = {}) => {
                     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.`
+                        text: `Call ${planTool}${suffix} first. Review the summary, effects, and artifact path with the user. Only after explicit confirmation should you call experienceengine_execute_planned_state_operation with the returned planId and confirmationToken.`
                     }
                 }
             ]
@@ -515,80 +500,7 @@ export const createCodexMcpServer = (options = {}) => {
                 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.`
+                    text: `Call experienceengine_plan_${operation} with adapter=${adapter} first. Review the summary, effects, and commandHint with the user. Only after explicit confirmation should you call experienceengine_execute_planned_operation with the returned planId and confirmationToken.`
                 }
             }
         ]
@@ -602,7 +514,7 @@ export const createCodexMcpServer = (options = {}) => {
                 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."
+                    text: "Review the latest ExperienceEngine interaction in this Codex session. Summarize whether guidance was injected, which nodes were involved, and the recorded outcome. Use CLI fallback only if the host surface is unavailable."
                 }
             },
             {
@@ -626,7 +538,7 @@ export const createCodexMcpServer = (options = {}) => {
                     role: "user",
                     content: {
                         type: "text",
-                        text: `Review the ${resolvedLimit} most recent ExperienceEngine turns that injected guidance. Summarize recurring successful patterns and any harmful repeats.`
+                        text: `Review the ${resolvedLimit} most recent ExperienceEngine turns that injected guidance. Summarize recurring wins and harmful repeats.`
                     }
                 },
                 {
@@ -645,7 +557,7 @@ export const createCodexMcpServer = (options = {}) => {
                 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."
+                    text: "Review the current ExperienceEngine warning nodes. Identify stale warnings and any warning that appears noisy or over-firing."
                 }
             },
             {
@@ -666,7 +578,7 @@ export const createCodexMcpServer = (options = {}) => {
                 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.`
+                    text: `Pause ExperienceEngine interventions for the current project${cwd ? ` at ${cwd}` : ""}. Confirm first, then call experienceengine_set_scope_intervention_state with action=disable and summarize the changed scope.`
                 }
             }
         ]
@@ -683,7 +595,7 @@ export const createCodexMcpServer = (options = {}) => {
                 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.`
+                    text: `Resume ExperienceEngine interventions for the current project${cwd ? ` at ${cwd}` : ""}. Confirm first, then call experienceengine_set_scope_intervention_state with action=enable and summarize the changed scope.`
                 }
             }
         ]
@@ -697,7 +609,7 @@ export const createCodexMcpServer = (options = {}) => {
                 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."
+                    text: "Mark the last injected ExperienceEngine guidance as helpful in this Codex session. If needed, confirm first, call experienceengine_feedback_last with feedback=helped, and summarize updated nodes. Use CLI fallback only if the host path is unavailable."
                 }
             }
         ]
@@ -711,7 +623,7 @@ export const createCodexMcpServer = (options = {}) => {
                 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."
+                    text: "Mark the last injected ExperienceEngine guidance as harmful in this Codex session. If needed, confirm first, call experienceengine_feedback_last with feedback=harmed, and summarize updated nodes. Use CLI fallback only if the host path is unavailable."
                 }
             }
         ]
@@ -797,115 +709,6 @@ export const createCodexMcpServer = (options = {}) => {
             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.",
-        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.",
-        inputSchema: z.object({
-            packId: z.string().min(1),
-            version: z.string().optional(),
-            target: z.enum(COMPILER_TARGETS),
-            repoPath: 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.",
@@ -917,7 +720,7 @@ export const createCodexMcpServer = (options = {}) => {
     }, async () => toStructuredToolResult(buildExperienceCapabilities()));
     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),
@@ -926,7 +729,7 @@ export const createCodexMcpServer = (options = {}) => {
     }, async ({ cwd, prompt, sessionId }) => toTextToolResult(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 +742,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"])
         }),
@@ -990,24 +779,11 @@ export const createCodexMcpServer = (options = {}) => {
             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.",
+    server.registerTool("experienceengine_set_scope_intervention_state", {
+        title: "ExperienceEngine Set Scope Intervention State",
+        description: "Enable or disable ExperienceEngine interventions for the provided working directory scope.",
         inputSchema: z.object({
+            action: z.enum(["enable", "disable"]),
             cwd: z.string().optional()
         }),
         outputSchema: z.object({
@@ -1017,31 +793,24 @@ export const createCodexMcpServer = (options = {}) => {
             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.",
+    }, async ({ action, cwd }) => toStructuredToolResult(action === "disable"
+        ? await interactionSurface.disableScope({ cwd })
+        : await interactionSurface.enableScope({ cwd })));
+    server.registerTool("experienceengine_set_node_lifecycle", {
+        title: "ExperienceEngine Set Node Lifecycle",
+        description: "Move a specific ExperienceEngine node into cooling or retired lifecycle state.",
         inputSchema: z.object({
+            action: z.enum(["cool", "retire"]),
             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()
+            state: z.enum(["candidate", "priority_candidate", "active", "cooling", "retired"]).optional()
         })
-    }, async ({ nodeId }) => toStructuredToolResult(await interactionSurface.retireNode({ nodeId })));
+    }, async ({ action, nodeId }) => toStructuredToolResult(action === "cool"
+        ? await interactionSurface.coolNode({ nodeId })
+        : await interactionSurface.retireNode({ nodeId })));
     return server;
 };
 export const runCodexMcpServer = async () => {