@voybio/ace-swarm 2.4.8 → 2.4.10

package/dist/tools-agent.d.ts

@@ -1,3 +1,4 @@
+export { formatStepTaskForBridge } from "./task-plan-context.js";
 /**
  * Agent, skill, kernel, and task-pack tool registrations.
  */
@@ -6,7 +7,6 @@ import { type BridgeResult } from "./model-bridge.js";
 import { proposePlan as proposePlanImpl, validatePlan as validatePlanImpl, loadAcceptanceTraceContract as loadAcceptanceTraceContractImpl } from "./plan-proposal.js";
 import { type TaskPlan, type TaskStep } from "./orchestrator-supervisor.js";
 export type { TaskPlan, TaskStep } from "./orchestrator-supervisor.js";
-export declare function formatStepTaskForBridge(step: Pick<TaskStep, "task" | "upstream_outputs">): string;
 type IntentVerificationOutcome = "ok" | "revisit_step" | "replan_required";
 type IntentDriftReasonCode = "contract_missing" | "contract_invalid" | "bridge_output_malformed_json" | "role_drift_ui_off_topic" | "coder_artifact_stub" | "qa_rewrote_artifact" | "artifact_mismatch" | "forbidden_pattern" | "required_evidence_missing";
 interface IntentVerificationResult {

package/dist/tools-agent.js

@@ -1,6 +1,5 @@
-/**
- * Agent, skill, kernel, and task-pack tool registrations.
- */
+import { formatStepTaskForBridge } from "./task-plan-context.js";
+export { formatStepTaskForBridge } from "./task-plan-context.js";
 import { z } from "zod";
 import { ALL_AGENTS, COMPOSABLE_AGENTS, SWARM_AGENTS, SWARM_SUBAGENT_MAP, classifyPathSource, getAgentInstructionPath, getAgentManifestPath, getKernelArtifactPath, isSwarmRole, listAvailableSkills, readAgentInstructions, readAgentManifest, readKernelArtifact, readSkillInstructions, readTaskArtifact, resolveWorkspaceRoot, } from "./helpers.js";
 import { loadRuntimeProfile, readRuntimePromptTemplate, readRuntimeProfileState, validateRuntimeProfileContent, } from "./runtime-profile.js";
@@ -79,21 +78,6 @@ function extractHandoffId(text) {
     const lineMatch = text.match(/handoff_id:\s*([A-Z0-9-]+)/i);
     return lineMatch?.[1];
 }
-export function formatStepTaskForBridge(step) {
-    const upstreamOutputs = step.upstream_outputs ?? [];
-    if (upstreamOutputs.length === 0) {
-        return step.task;
-    }
-    const renderedOutputs = upstreamOutputs
-        .map((output) => `- ${output.step_id}: ${output.result_summary || "[no summary]"}${output.evidence_refs.length > 0 ? ` (evidence: ${output.evidence_refs.join(", ")})` : ""}`)
-        .join("\n");
-    return [
-        step.task,
-        "",
-        "Upstream outputs:",
-        renderedOutputs,
-    ].join("\n");
-}
 // ── Re-export plan-proposal API ────────────────────────────────────────────
 export { loadAcceptanceTraceContractImpl as loadAcceptanceTraceContract };
 export { proposePlanImpl as proposePlan, validatePlanImpl as validatePlan };
@@ -658,7 +642,7 @@ export function registerAgentTools(server) {
     server.tool("get_agent_instructions", "Load the full instruction file for a specific ACE agent role", {
         role: ROLE_ENUM.describe("Which agent role to load"),
     }, async ({ role }) => {
-        const content = readAgentInstructions(role);
+        const content = readAgentInstructions(role, { includeLearned: true });
         const sourcePath = getAgentInstructionPath(role);
         const source = classifyPathSource(sourcePath);
         return {
@@ -1046,15 +1030,15 @@ export function registerAgentTools(server) {
         max_turns: z
             .number()
             .int()
-            .positive()
+            .nonnegative()
             .optional()
-            .describe("Optional max-turn override"),
+            .describe("Explicit maximum turn allowance; 0 means unlimited (default)"),
         turn_timeout_ms: z
             .number()
             .int()
-            .positive()
+            .nonnegative()
             .optional()
-            .describe("Optional per-turn timeout override in milliseconds"),
+            .describe("Explicit per-turn deadline in milliseconds; 0 means unlimited (default)"),
         auto_cleanup: z
             .boolean()
             .optional()
@@ -1152,7 +1136,7 @@ export function registerAgentTools(server) {
             ],
         };
     });
-    server.tool("validate_plan", "Run shape checks against a PlanProposal (coverage, verification chain, tool-scope realism, acceptance criteria presence, stop conditions visibility). Returns { ok, score, blocking_findings, soft_findings }. Persists a transition record and Vericify process post.", {
+    server.tool("validate_plan", "Run shape checks against a PlanProposal (coverage, verification chain, tool-scope realism, acceptance criteria presence, stop conditions visibility). Returns { ok, score, blocking_findings, soft_findings }. Persists an ACE transition record; legacy Vericify process posts require explicit opt-in.", {
         plan_id: z.string().optional().describe("ID of a previously proposed plan to validate"),
         proposal: z
             .object({
@@ -1194,9 +1178,9 @@ export function registerAgentTools(server) {
         max_turns: z
             .number()
             .int()
-            .positive()
+            .nonnegative()
             .optional()
-            .describe("Optional max-turn override; defaults by role"),
+            .describe("Explicit turn cap; 0/unset is unlimited for the native bridge. Hermes uses its adapter policy."),
         tier: z
             .enum(["auto", "full", "compressed", "brief"])
             .optional()
@@ -1348,9 +1332,9 @@ export function registerAgentTools(server) {
         max_turns_per_step: z
             .number()
             .int()
-            .positive()
+            .nonnegative()
             .optional()
-            .describe("Optional max-turn limit applied to each child bridge step"),
+            .describe("Explicit child bridge turn cap; 0/unset is unlimited"),
         provider: z
             .string()
             .optional()
@@ -1483,7 +1467,7 @@ export function registerAgentTools(server) {
                         role: step.role,
                         workspace: runtime.workspaceRoot,
                         tier: resolveTier(undefined, runtime.provider, runtime.model, step.role),
-                        maxTurns: max_turns_per_step ?? 6,
+                        maxTurns: max_turns_per_step ?? 0,
                         provider: runtime.provider,
                         model: runtime.model,
                         toolScope: step.tool_scope,
@@ -1549,11 +1533,13 @@ export function registerAgentTools(server) {
             },
             async getVericifyContext() {
                 return tryVericifyPacket(() => getVericifyContextPacket({
+                    mode: "configured",
                     workspaceRoot: effectiveWorkspaceRoot,
                 }), (message) => appendUniqueNote(vericifyWarnings, `Vericify context unavailable for ${plan.plan_id}: ${message}`));
             },
             async getVericifyDelta(since) {
                 return tryVericifyPacket(() => getVericifyDelta({
+                    mode: "configured",
                     since,
                     workspaceRoot: effectiveWorkspaceRoot,
                 }), (message) => appendUniqueNote(vericifyWarnings, `Vericify delta unavailable for ${plan.plan_id}: ${message}`));
@@ -1680,7 +1666,8 @@ export function registerAgentTools(server) {
             ],
         };
     });
-    server.tool("get_vericify_context", "Build a compact Vericify context packet for workspace:current or a specified run", {
+    server.tool("get_vericify_context", "Read configured native Vericify metadata, or explicitly request legacy context compatibility", {
+        mode: z.enum(["configured", "legacy"]).optional().describe("Defaults to configured; legacy explicitly enables historical API discovery"),
         run_id: z
             .string()
             .optional()
@@ -1689,9 +1676,10 @@ export function registerAgentTools(server) {
             .string()
             .optional()
             .describe("Optional workspace root override used to locate the Vericify workspace"),
-    }, async ({ run_id, workspace_root }) => {
+    }, async ({ run_id, workspace_root, mode }) => {
         try {
             const packet = await getVericifyContextPacket({
+                mode: mode ?? "configured",
                 runId: run_id,
                 workspaceRoot: workspace_root,
             });
@@ -1716,7 +1704,8 @@ export function registerAgentTools(server) {
             };
         }
     });
-    server.tool("get_vericify_delta", "Build a compact Vericify delta from a prior vcx cursor or checkpoint reference", {
+    server.tool("get_vericify_delta", "Read a configured native delta, or explicitly request a legacy vcx/checkpoint delta", {
+        mode: z.enum(["configured", "legacy"]).optional().describe("Defaults to configured; legacy explicitly enables historical API discovery"),
         since: z
             .string()
             .describe("Required prior vcx cursor or compatible checkpoint reference"),
@@ -1728,9 +1717,10 @@ export function registerAgentTools(server) {
             .string()
             .optional()
             .describe("Optional workspace root override used to locate the Vericify workspace"),
-    }, async ({ since, run_id, workspace_root }) => {
+    }, async ({ since, run_id, workspace_root, mode }) => {
         try {
             const delta = await getVericifyDelta({
+                mode: mode ?? "configured",
                 since,
                 runId: run_id,
                 workspaceRoot: workspace_root,
@@ -2294,9 +2284,15 @@ export function registerAgentTools(server) {
     });
     server.tool("get_skill_instructions", "Load SKILL.md for a specific ACE skill", {
         name: z.string().describe("Skill name (e.g., codemunch, codesnipe)"),
-    }, async ({ name }) => {
+    }, async ({ name }, extra) => {
         const skills = listAvailableSkills();
         const match = skills.find((skill) => skill.name.toLowerCase() === name.trim().toLowerCase());
+        const { getHostBinding } = await import('./host-work-context.js');
+        const binding = getHostBinding(extra.sessionId);
+        if (match && binding?.goal_id && binding.step_id && binding.attempt) {
+            const { recordSkillUse } = await import('./learning-serving.js');
+            await recordSkillUse(resolveWorkspaceRoot(), { goal_id: binding.goal_id, step_id: binding.step_id, attempt: binding.attempt, agent: binding.agent }, match.name);
+        }
         const prefix = match
             ? `# Skill: ${match.name}\n\nSource: ${match.source} (${match.path})\n\n`
             : `# Skill: ${name}\n\n`;
@@ -2304,7 +2300,7 @@ export function registerAgentTools(server) {
             content: [
                 {
                     type: "text",
-                    text: `${prefix}${readSkillInstructions(name)}`,
+                    text: `${prefix}${readSkillInstructions(name, { includeLearned: true })}`,
                 },
             ],
         };
@@ -2350,33 +2346,13 @@ export function registerAgentTools(server) {
         failure_pattern: z.string().describe("What went wrong"),
         guardrail: z.string().describe("Rule to prevent recurrence"),
         verification_check: z.string().describe("How to verify compliance"),
-    }, async ({ context, failure_pattern, guardrail, verification_check }) => {
-        const knownReasonCodes = [
-            "false_completion_no_evidence",
-            "forward_pacing_incomplete",
-            "bridge_tool_doom_loop",
-            "bridge_text_doom_loop",
-            "context_overflow",
-            "tool_timeout",
-            "role_contract_violation",
-        ];
-        const scope = {};
-        const lowered = failure_pattern.toLowerCase();
-        const reason = knownReasonCodes.find((code) => lowered.includes(code));
-        if (reason)
-            scope.reason_code = reason;
-        const root = resolveWorkspaceRoot();
-        const bullet = new PlaybookRepository(root).createBullet({
-            section: "failure_modes",
-            scope,
-            content: `${guardrail} Verify: ${verification_check}`,
-            evidence_refs: [],
-            provenance: { source: "operator" },
-        });
-        const path = materializePlaybookMarkdown(root);
-        return {
-            content: [{ type: "text", text: `✅ Lesson recorded as ${bullet.bullet_id} (${bullet.status}) in ${path}. Context: ${context}` }],
-        };
+        evidence_refs: z.array(z.string()).optional(),
+        step_ref: z.object({ goal_id: z.string(), step_id: z.string() }).optional(),
+        paths: z.array(z.string()).optional(),
+    }, async ({ context, failure_pattern, guardrail, verification_check, evidence_refs, step_ref, paths }) => {
+        const { addHostLesson } = await import('./host-learning.js');
+        const result = await addHostLesson(resolveWorkspaceRoot(), { context, failure_pattern, guardrail, verification_check, evidence_refs, step_ref, paths });
+        return { content: [{ type: 'text', text: JSON.stringify(result) }], structuredContent: result };
     });
     // ── CLI Work Split ────────────────────────────────────────────────
     server.tool("get_cli_split", "Get the CLI work split contract (Codex vs Gemini routing)", {}, async () => ({

package/dist/tools-files.d.ts

@@ -1,6 +1,3 @@
-/**
- * File operation tool registrations + new safe-edit and diff tools.
- */
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 export interface AstgrepRewriteTargetPlan {
     ok: boolean;

package/dist/tools-files.js

@@ -1,3 +1,5 @@
+import { commandPolicySchema, withMcpCommandProgress } from "./mcp-command-progress.js";
+import { formatKanbanRefresh } from "./kanban.js";
 /**
  * File operation tool registrations + new safe-edit and diff tools.
  */
@@ -1047,13 +1049,16 @@ export function registerFileTools(server) {
         let todoStateSuffix = "";
         if (normalizedPath === `${ACE_TASKS_ROOT_REL}/todo.md`) {
             const synced = await syncTodoStateSafe(content);
-            todoStateSuffix = `\nTODO state synced: ${synced.path}`;
+            todoStateSuffix = `\nTODO state synced: ${synced.path}${synced.import_warnings.map((warning) => `\nImport warning: ${warning}`).join("")}${synced.projection_pending ? "\nTodo markdown refresh pending." : ""}`;
         }
         const storeFallbackKeys = resolveStoreFallbackKeysForPath(normalizedPath);
         const useAsyncStoreAdmission = storeFallbackKeys.length > 0 && workspaceRoot === WORKSPACE_ROOT;
         // Keep the file as a materialized projection after the canonical store update.
         let abs;
-        if (useAsyncStoreAdmission) {
+        if (normalizedPath === `${ACE_TASKS_ROOT_REL}/todo.md`) {
+            abs = targetPath; // The todo owner already committed and projected this import.
+        }
+        else if (useAsyncStoreAdmission) {
             abs = await safeWriteAsync(path, content);
         }
         else if (workspaceRoot === WORKSPACE_ROOT) {
@@ -1068,7 +1073,7 @@ export function registerFileTools(server) {
         const shouldRefreshKanban = shouldAutoRefreshKanbanForPath(normalizedPath);
         if (shouldRefreshKanban) {
             const kanban = refreshKanbanArtifacts(`tool:write_workspace_file:${normalizedPath}`);
-            kanbanSuffix = `\nKanban updated: ${kanban.html_path}\nKanban counts: backlog=${kanban.counts.backlog}, blocked=${kanban.counts.blocked}, in_progress=${kanban.counts.in_progress}, gated=${kanban.counts.gated}, done=${kanban.counts.done}`;
+            kanbanSuffix = `\n${formatKanbanRefresh(kanban)}\nKanban counts: backlog=${kanban.counts.backlog}, blocked=${kanban.counts.blocked}, in_progress=${kanban.counts.in_progress}, gated=${kanban.counts.gated}, done=${kanban.counts.done}`;
         }
         const runLedger = await appendRunLedgerEntrySafe({
             tool: "write_workspace_file",
@@ -1165,6 +1170,7 @@ export function registerFileTools(server) {
             .string()
             .optional()
             .describe("Shell command for tests (e.g. 'npm test')"),
+        command_policy: commandPolicySchema.optional(),
         backup: z
             .boolean()
             .optional()
@@ -1173,15 +1179,16 @@ export function registerFileTools(server) {
             .string()
             .optional()
             .describe("Optional source precondition checked immediately before promotion; prefer full sha256:<hex>"),
-    }, async ({ path, content, validation_command, test_command, backup, expected_base_hash }) => {
-        const result = safeEditFile({
+    }, async ({ path, content, validation_command, test_command, backup, expected_base_hash, command_policy }, extra) => {
+        const result = await withMcpCommandProgress(extra, "safe_edit_file checks", (onProgress, workSignal) => safeEditFile({
             path,
             content,
             expected_base_hash,
             validation_command,
             test_command,
             backup,
-        });
+            command_policy: { ...command_policy, signal: workSignal, onProgress },
+        }), () => Boolean(server.server?.transport));
         const ledger = await appendRunLedgerEntrySafe({
             tool: "safe_edit_file",
             category: result.ok ? "major_update" : "regression",
@@ -1605,8 +1612,9 @@ export function registerFileTools(server) {
         confirm_multi_file: z.boolean().optional().describe("Deprecated; multi-file rewrites are always refused"),
         validation_command: z.string().optional().describe("Shell command to validate the staged rewrite before promotion"),
         test_command: z.string().optional().describe("Shell command to test the staged rewrite before promotion"),
+        command_policy: commandPolicySchema.optional(),
         session_id: z.string().optional().describe("Optional runtime session id for transition-record emission"),
-    }, async ({ plan_id, pattern, rewrite, lang, scope, validation_command, test_command, session_id }) => {
+    }, async ({ plan_id, pattern, rewrite, lang, scope, validation_command, test_command, session_id, command_policy }, extra) => {
         let compiledPlan;
         if (plan_id) {
             compiledPlan = loadStructuralEditPlan(plan_id);
@@ -1700,13 +1708,14 @@ export function registerFileTools(server) {
                 isError: true,
             };
         }
-        const safeResult = safeEditFile({
+        const safeResult = await withMcpCommandProgress(extra, "astgrep_rewrite checks", (onProgress, workSignal) => safeEditFile({
             path: compiledPlan.target.file,
             content: preview.rewritten_content,
             expected_base_hash: compiledPlan.target.file_hash,
             validation_command: validation_command ?? compiledPlan.validation_command,
             test_command: test_command ?? compiledPlan.test_command,
-        });
+            command_policy: { ...command_policy, signal: workSignal, onProgress },
+        }), () => Boolean(server.server?.transport));
         if (!safeResult.ok) {
             await appendAstgrepRewriteTransition(session_id, "failed", `astgrep_rewrite failed before promotion for ${compiledPlan.target.file}: ${safeResult.error ?? "unknown error"}`, [compiledPlan.artifact_path, preview.artifact.artifact_path, compiledPlan.target.file]);
             return {
@@ -1749,13 +1758,14 @@ export function registerFileTools(server) {
         };
     });
     server.tool("apply_patch", "Apply a unified diff patch to a workspace file. Applies the patch to staged content, runs optional validation/tests, and promotes to the target only on success. Cost: moderate.", {
+        command_policy: commandPolicySchema.optional(),
         path: z.string().describe("Workspace-relative file path to patch"),
         patch: z.string().describe("Unified diff patch (output of diff -u or similar)"),
         expected_base_hash: z.string().optional().describe("Optional source precondition checked immediately before promotion; prefer full sha256:<hex>"),
         validation_command: z.string().optional().describe("Shell command to validate after applying (e.g. 'npx tsc --noEmit')"),
         test_command: z.string().optional().describe("Shell command to run tests after applying"),
-    }, async ({ path: relPath, patch, expected_base_hash, validation_command, test_command }) => {
-        const result = applyPatch({ path: relPath, patch, expected_base_hash, validation_command, test_command });
+    }, async ({ path: relPath, patch, expected_base_hash, validation_command, test_command, command_policy }, extra) => {
+        const result = await withMcpCommandProgress(extra, "apply_patch checks", (onProgress, workSignal) => applyPatch({ path: relPath, patch, expected_base_hash, validation_command, test_command, command_policy: { ...command_policy, signal: workSignal, onProgress } }), () => Boolean(server.server?.transport));
         if (!result.ok) {
             return {
                 content: [{ type: "text", text: `apply_patch failed: ${result.error ?? "unknown error"}\n${result.validation_output ?? ""}` }],

package/dist/tools-framework.js

@@ -1,7 +1,5 @@
-/**
- * Framework tool registrations: bootstrap, status, config, routing,
- * plus new run_tests and validate_framework tools.
- */
+import { commandPolicySchema, withMcpCommandProgress } from "./mcp-command-progress.js";
+import { resolveCurrentWork, formatCurrentWork } from "./ace-autonomy.js";
 import { z } from "zod";
 import { bootstrapStoreWorkspace } from "./store/bootstrap-store.js";
 import { ACE_ROOT_REL, ACE_TASKS_ROOT_REL, ALL_MCP_CLIENTS, ALL_LLM_PROVIDERS, ALL_AGENTS, COMPOSABLE_AGENTS, SWARM_AGENTS, SWARM_SUBAGENT_MAP, WORKSPACE_ROOT, classifyPathSource, detectAssetDrift, getAllMcpServerConfigSnippets, getAgentInstructionPath, getAgentManifestPath, getKernelArtifactPath, getMcpClientInstallHint, getMcpServerConfigSnippet, getTaskArtifactPath, isSwarmRole, listAvailableSkills, normalizePathForValidation, resolveWorkspaceRoot, safeRead, safeWriteAsync, withFileLock, wsPath, } from "./helpers.js";
@@ -123,11 +121,11 @@ function hasArtifactEvidence(reference) {
         return !content.startsWith("[FILE NOT FOUND]") && !content.startsWith("[ACCESS DENIED]");
     });
 }
-function evaluateGateTargets(targets) {
+async function evaluateGateTargets(targets, policy = {}) {
     const results = [];
     for (const gate of targets) {
         if (gate.type === "executable" && gate.command.trim().length > 0) {
-            const testResult = runTestSuite(gate.command);
+            const testResult = await runTestSuite(gate.command, policy);
             results.push({
                 id: gate.id,
                 type: gate.type,
@@ -545,7 +543,6 @@ export function registerFrameworkTools(server) {
             structuredContent: {
                 detected_domain: detected,
                 suggested_execution_role: executionRoleForDomain(detected),
-                default_entry_agent: "orchestrator",
                 task_contract_ok: taskContract.ok,
             },
             content: [
@@ -559,11 +556,7 @@ export function registerFrameworkTools(server) {
                         `**Primary Swarm Agent(s):** ${activeRoute.swarm_agents
                             .map((agent) => `ACE-${getRoleTitle(agent)}`)
                             .join(", ")}`,
-                        "**Default Entry Agent:** ACE-Orchestrator",
-                        "**Hierarchy Rule:** Top-level work starts with ACE-Orchestrator. VOS, UI, and Coders are delegated specialists, not peer replacements.",
-                        `**Preflight Owner:** ACE-Orchestrator`,
                         `**Task Contract:** ${taskContract.ok ? "aligned" : "attention required"}`,
-                        `**Composable Subagents (Universal):** ${[...COMPOSABLE_AGENTS].join(", ")}`,
                         `**Recommended Delegated Subagents:** ${[...recommendedSubagents].join(", ")}`,
                         `**Pipeline:** ${activeRoute.pipeline}`,
                         `**Recommended Prompt:** ${activeRoute.prompt}`,
@@ -579,16 +572,9 @@ export function registerFrameworkTools(server) {
                             ]
                             : []),
                         "",
-                        "## Preflight Expectations",
-                        "1. Recall current ACE context from TASK, SCOPE, QUALITY_GATES, STATUS, HANDOFF, and EVIDENCE artifacts.",
-                        "2. Validate the ACE quartet before dispatching substantial work.",
-                        "3. Route ambiguity or contract drift through skeptic/validation before handoff.",
-                        "",
-                        "## Next Steps",
-                        `1. Activate prompt: \`${activeRoute.prompt}\``,
-                        "2. Run `validate_framework` and inspect current ACE state before cross-role dispatch.",
-                        "3. Load shared kernel context with `get_kernel_artifact` (`directive_kernel`, `agent_registry`)",
-                        "4. Generate a structured handoff with `create_handoff` only after preflight clears",
+                        "## Next",
+                        formatCurrentWork(resolveCurrentWork(), "block"),
+                        "Role, pipeline, prompt and skill suggestions above are optional aids for this work.",
                     ]
                         .filter(Boolean)
                         .join("\n"),
@@ -927,12 +913,13 @@ export function registerFrameworkTools(server) {
     });
     // ── Run Tests (new P0 tool) ───────────────────────────────────────
     server.tool("run_tests", "Execute the project test suite and report results", {
+        ...commandPolicySchema.shape,
         command: z
             .string()
             .optional()
             .describe("Custom test command (auto-detected from package.json if omitted)"),
-    }, async ({ command }) => {
-        const result = runTestSuite(command);
+    }, async ({ command, stall_min, kill_min, deadline_min }, extra) => {
+        const result = await withMcpCommandProgress(extra, "run_tests", (onProgress, workSignal) => runTestSuite(command, { stall_min, kill_min, deadline_min, signal: workSignal, onProgress }), () => Boolean(server.server?.transport));
         appendStatusEventSafe({
             source_module: "capability-safety",
             event_type: result.ok ? "TESTS_PASSED" : "TESTS_FAILED",
@@ -956,6 +943,7 @@ export function registerFrameworkTools(server) {
             },
         });
         return {
+            structuredContent: { ...result },
             content: [
                 {
                     type: "text",
@@ -964,6 +952,7 @@ export function registerFrameworkTools(server) {
                         `Command: ${result.command}`,
                         `Exit code: ${result.exit_code}`,
                         `Duration: ${result.duration_ms}ms`,
+                        ...(result.reason_code ? [`Reason: ${result.reason_code}`] : []),
                         `Run ledger: ${ledger.path} (${ledger.entry.id})`,
                         "",
                         "```",
@@ -1444,6 +1433,7 @@ export function registerFrameworkTools(server) {
     });
     // ── Execute Gates (manifest-driven gate runner) ───────────────────
     server.tool("execute_gates", "Run quality gates from agent-state/MODULES/gates/*.json manifests (single source of truth)", {
+        command_policy: commandPolicySchema.optional(),
         gate_ids: z
             .array(z.string())
             .optional()
@@ -1456,7 +1446,7 @@ export function registerFrameworkTools(server) {
             .string()
             .optional()
             .describe("Optional short focus string persisted with skeptic adversarial review evidence."),
-    }, async ({ gate_ids, review_mode, review_focus }) => {
+    }, async ({ gate_ids, review_mode, review_focus, command_policy }, extra) => {
         const gatesDir = wsPath("agent-state", "MODULES", "gates");
         const resolved = resolveGateManifests(gatesDir);
         const allGates = resolved.gates;
@@ -1556,7 +1546,7 @@ export function registerFrameworkTools(server) {
             };
         }
         const gateArtifactRefs = targets.map((gate) => gate.source_ref ?? manifestEvidenceRef);
-        const results = evaluateGateTargets(targets);
+        const results = await withMcpCommandProgress(extra, "execute_gates", (onProgress, workSignal) => evaluateGateTargets(targets, { ...command_policy, signal: workSignal, onProgress }), () => Boolean(server.server?.transport));
         const passed = results.filter((r) => r.ok).length;
         const failed = results.filter((r) => !r.ok).length;
         const review = review_mode === "skeptic_adversarial"
@@ -1646,6 +1636,7 @@ export function registerFrameworkTools(server) {
             },
         });
         return {
+            structuredContent: { ok: allOk, results },
             content: [
                 {
                     type: "text",

package/dist/tools-goal.d.ts

@@ -1,10 +1,8 @@
 /**
  * ACE Goal Engine tool registrations (WS-F).
  *
- * These let a premium host delegate a long-running objective to ACE and poll
- * it. `start_goal`/`resume_goal` never block the MCP server for the life of the
- * goal: they compile/prepare, then hand execution to a detached `ace goal run`
- * child and return immediately. The host polls `get_goal_status`.
+ * Engine goals delegate to the existing detached runner. Host goals return
+ * assignments to the connected participant and never invoke that executor.
  */
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 export declare function registerGoalTools(server: McpServer): void;