@voybio/ace-swarm 2.4.0 → 2.4.1

package/dist/runtime-executor.d.ts

@@ -66,6 +66,8 @@ export interface UnattendedSessionRecord {
     workspace_cleanup_status: "pending" | "removed" | "archived" | "failed";
     output_policy?: TurnOutputPolicy;
     turns: UnattendedTurnRecord[];
+    /** Set after propose_plan + validate_plan succeed in the before_run preflight. */
+    validated_plan_id?: string;
 }
 export interface UnattendedSessionRegistry {
     version: 1;
@@ -108,11 +110,14 @@ export interface WaitForUnattendedSessionResult {
     session?: UnattendedSessionRecord;
     error?: string;
 }
+export interface WaitForUnattendedSessionOptions {
+    flush_sidecars?: boolean;
+}
 export declare function validateRuntimeExecutorSessionRegistryContent(raw: string): ValidationResult;
 export declare function listUnattendedSessions(): UnattendedSessionRegistry;
 export declare function getUnattendedSession(sessionId: string): UnattendedSessionRecord | undefined;
 export declare function getRuntimeExecutorSessionRegistryPath(): string;
 export declare function startUnattendedSession(input: StartUnattendedSessionInput): Promise<StartUnattendedSessionResult>;
-export declare function waitForUnattendedSession(sessionId: string, timeoutMs?: number): Promise<WaitForUnattendedSessionResult>;
+export declare function waitForUnattendedSession(sessionId: string, timeoutMsOrOptions?: number | WaitForUnattendedSessionOptions, options?: WaitForUnattendedSessionOptions): Promise<WaitForUnattendedSessionResult>;
 export declare function stopUnattendedSession(sessionId: string): Promise<StopUnattendedSessionResult>;
 //# sourceMappingURL=runtime-executor.d.ts.map

package/dist/runtime-executor.js

@@ -7,6 +7,7 @@ import { resolveWorkspaceArtifactPath as resolveWorkspaceArtifactPathHelper, res
 import { appendRunLedgerEntrySafe } from "./run-ledger.js";
 import { runShellCommand } from "./runtime-command.js";
 import { loadRuntimeProfile, resolveEffectiveSurgicalReadBudget, renderRuntimePromptFromSnapshot, getLivenessDefaults, } from "./runtime-profile.js";
+import { resolveLocalModelExecutionPolicy } from "./local-model-policy.js";
 import { renderAceContinuityPromptBlock, renderAceRecallPromptBlock, renderAceSnapshotPromptBlock, } from "./ace-context.js";
 import { executeRuntimeTool, buildFilteredToolCatalog, SMALL_LOCAL_PRIORITY_TOOL_NAMES, } from "./runtime-tool-specs.js";
 import { validateRuntimeExecutorSessionRegistryPayload, } from "./schemas.js";
@@ -19,6 +20,7 @@ import { getWorkspaceStorePath, storeExistsSync, } from "./store/store-snapshot.
 import { operationalArtifactVirtualPath } from "./store/store-artifacts.js";
 import { withStoreWriteCoordinator } from "./store/write-coordinator.js";
 import { LocalModelRuntimeRepository, withLocalModelRuntimeRepository, } from "./store/repositories/local-model-runtime-repository.js";
+import { proposePlanDeterministic, validatePlan } from "./plan-proposal.js";
 export const RUNTIME_EXECUTOR_SESSION_REGISTRY_REL_PATH = "agent-state/runtime-executor-sessions.json";
 export const RUNTIME_EXECUTOR_SESSION_SCHEMA_REL_PATH = "agent-state/MODULES/schemas/RUNTIME_EXECUTOR_SESSION_REGISTRY.schema.json";
 export const RUNTIME_EXECUTOR_SESSION_SCHEMA_NAME = "runtime-executor-session-registry@1.0.0";
@@ -93,6 +95,20 @@ async function waitForSessionSidecars(sessionId) {
         return;
     await state.chain.catch(() => undefined);
 }
+async function delaySessionCompletedSidecarIfRequested(sessionId) {
+    const rawDelayMs = process.env.ACE_RUNTIME_EXECUTOR_TEST_SIDECAR_DELAY_MS;
+    if (!rawDelayMs)
+        return;
+    const delayMs = Number(rawDelayMs);
+    if (!Number.isFinite(delayMs) || delayMs <= 0)
+        return;
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+    const markerDir = process.env.ACE_RUNTIME_EXECUTOR_TEST_SIDECAR_MARKER_DIR;
+    if (markerDir && markerDir.trim().length > 0) {
+        mkdirSync(markerDir, { recursive: true });
+        writeFileSync(join(markerDir, `${sessionId}.done`), new Date().toISOString(), "utf-8");
+    }
+}
 function setSessionPhase(sessionId, phase, checkpoint) {
     const active = activeSessions.get(sessionId);
     if (active) {
@@ -567,6 +583,31 @@ async function runSessionLoop(sessionId, context, autoCleanup, runtimeProfileSna
             }
             return;
         }
+        // ── Plan validation preflight (Task 6) ───────────────────────────────
+        {
+            const currentValidatedPlanId = registryStart.validated_plan_id;
+            if (!currentValidatedPlanId) {
+                const task = registryStart.current_task || registryStart.task;
+                try {
+                    const proposal = proposePlanDeterministic(task);
+                    const verdict = await validatePlan({ proposal, sessionId });
+                    if (verdict.ok) {
+                        // Persist validated_plan_id opportunistically. This is a readiness hint,
+                        // not a hard gate on unattended execution.
+                        await mutateRegistry((registry) => {
+                            const session = findSession(registry, sessionId);
+                            if (session)
+                                session.validated_plan_id = verdict.plan_id;
+                        }).catch(() => undefined);
+                    }
+                }
+                catch {
+                    // Preflight validation is best-effort. Unattended runtime should still run
+                    // even when the planner/model path or trace lookup is unavailable.
+                }
+            }
+        }
+        // ── End plan validation preflight ────────────────────────────────────
         setSessionPhase(sessionId, "workspace_before_run");
         const beforeRun = await runWorkspaceSessionHook({
             session_id: registryStart.workspace_session_id,
@@ -592,7 +633,14 @@ async function runSessionLoop(sessionId, context, autoCleanup, runtimeProfileSna
         const runtimeStatus = storeExistsSync(workspaceRoot())
             ? await withLocalModelRuntimeRepository(workspaceRoot(), async (repo) => repo.getRuntimeStatus(sessionId))
             : undefined;
-        const effectiveModelClass = runtimeStatus?.model_class ?? "frontier";
+        const executionPolicy = resolveLocalModelExecutionPolicy({
+            provider: "",
+            model: "",
+            role: "orchestrator",
+            task: currentTask,
+            requested_model_class: runtimeStatus?.model_class,
+        });
+        const effectiveModelClass = executionPolicy.model_class;
         // Stall restart state — session-level, reset on successful turn.
         // Seeded runtime status is authoritative when present.
         let consecutiveStallRestarts = runtimeStatus?.stall_restart_count ?? 0;
@@ -681,7 +729,7 @@ async function runSessionLoop(sessionId, context, autoCleanup, runtimeProfileSna
             const taskWithStallHint = isStallRestart
                 ? `${stallRestartContext}\n\nOriginal task: ${currentTask}`
                 : currentTask;
-            const prompt = renderRuntimePromptFromSnapshot(runtimeProfileSnapshot, {
+            let prompt = renderRuntimePromptFromSnapshot(runtimeProfileSnapshot, {
                 task: taskWithStallHint,
                 session_id: sessionId,
                 turn_number: turnNumber,
@@ -695,6 +743,16 @@ async function runSessionLoop(sessionId, context, autoCleanup, runtimeProfileSna
                 ace_continuity_packet_md: renderAceContinuityPromptBlock(turnContinuity),
                 ace_context_snapshot_md: renderAceSnapshotPromptBlock(turnRecall),
             });
+            if (effectiveModelClass === "small_local") {
+                prompt += [
+                    "",
+                    "## ACE-Owned Preflight Packet",
+                    `- status: ${preflight.ok ? "passed" : "blocked"}`,
+                    `- summary: ${preflight.summary}`,
+                    `- evidence_refs: agent-state/TASK.md, agent-state/STATUS.md, agent-state/QUALITY_GATES.md`,
+                    "- model_visible_tools: route_task or run_orchestrator only when delegation is needed; ACE owns recall_context, validate_framework, and get_framework_status.",
+                ].join("\n");
+            }
             const requestPayload = {
                 session_id: sessionId,
                 turn_number: turnNumber,
@@ -1157,6 +1215,7 @@ async function runSessionLoop(sessionId, context, autoCleanup, runtimeProfileSna
             // Critical: finalize session status immediately so waitForUnattendedSession resolves correctly.
             const completed = await finalizeSession(sessionId, "completed", normalizedSummary);
             scheduleRuntimeSidecar(sessionId, "session-completed-events", async () => {
+                await delaySessionCompletedSidecarIfRequested(sessionId);
                 await emitExecutorEvent("RUNTIME_EXECUTOR_SESSION_COMPLETED", "done", capturedNormalizedSummary, {
                     session_id: sessionId,
                     turn_number: capturedTurnNumber,
@@ -1398,8 +1457,12 @@ export async function startUnattendedSession(input) {
         workspace: workspace.session,
     };
 }
-export async function waitForUnattendedSession(sessionId, timeoutMs = 30_000) {
+export async function waitForUnattendedSession(sessionId, timeoutMsOrOptions = 30_000, options) {
     const registryPathValue = registryPath();
+    const timeoutMs = typeof timeoutMsOrOptions === "number" ? timeoutMsOrOptions : 30_000;
+    const flushSidecars = typeof timeoutMsOrOptions === "number"
+        ? options?.flush_sidecars !== false
+        : timeoutMsOrOptions.flush_sidecars !== false;
     const active = activeSessions.get(sessionId);
     if (!active?.completion) {
         const session = getUnattendedSession(sessionId);
@@ -1412,7 +1475,9 @@ export async function waitForUnattendedSession(sessionId, timeoutMs = 30_000) {
             };
         }
         if (terminalStatus(session.status)) {
-            await waitForSessionSidecars(sessionId);
+            if (flushSidecars) {
+                await waitForSessionSidecars(sessionId);
+            }
             const freshSession = getUnattendedSession(sessionId);
             return {
                 ok: terminalStatus(freshSession?.status ?? session.status),
@@ -1447,7 +1512,9 @@ export async function waitForUnattendedSession(sessionId, timeoutMs = 30_000) {
             error: `Timed out waiting for unattended session ${sessionId}${phaseInfo}`,
         };
     }
-    await waitForSessionSidecars(sessionId);
+    if (flushSidecars) {
+        await waitForSessionSidecars(sessionId);
+    }
     const completedSession = getUnattendedSession(sessionId);
     return {
         ok: !!completedSession && terminalStatus(completedSession.status),

package/dist/runtime-tool-specs.d.ts

@@ -22,6 +22,14 @@ export interface RuntimeToolExecutorConfig {
     timeout_ms?: number;
     env?: Record<string, string>;
 }
+export interface RuntimeToolMcpServerConfig {
+    transport: "stdio" | "http";
+    command?: string;
+    args?: string[];
+    url?: string;
+    env?: Record<string, string>;
+    tool_allowlist?: string[];
+}
 export interface RuntimeToolSpec {
     name: string;
     description: string;
@@ -29,6 +37,7 @@ export interface RuntimeToolSpec {
     success_schema?: RuntimeToolSchema;
     failure_schema?: RuntimeToolSchema;
     executor: RuntimeToolExecutorConfig;
+    mcp_server?: RuntimeToolMcpServerConfig;
 }
 export interface RuntimeToolSpecRegistry {
     version: 1;
@@ -60,6 +69,15 @@ export interface RuntimeToolExecutionResult {
     error?: unknown;
     validation_errors?: string[];
 }
+export declare function buildRuntimeToolEnvironment(input: {
+    base_env?: NodeJS.ProcessEnv;
+    spec_env?: Record<string, string>;
+    injected_env: Record<string, string>;
+}): NodeJS.ProcessEnv;
+export declare function persistRuntimeToolInvocationArtifacts(callId: string, requestContent: string, responseContent: string): Promise<{
+    requestPath: string;
+    responsePath: string;
+}>;
 export declare function validateRuntimeToolRegistryContent(raw: string): ValidationResult;
 export declare function loadRuntimeToolRegistry(explicitPath?: string): RuntimeToolSpecRegistryResult;
 export declare function readRuntimeToolRegistry(): RuntimeToolSpecRegistry;
@@ -67,7 +85,7 @@ export declare function listRuntimeToolSpecs(): RuntimeToolSpec[];
 export declare function getRuntimeToolRegistryPath(): string;
 export declare function executeRuntimeTool(name: string, input: unknown, context?: RuntimeToolExecutionContext): Promise<RuntimeToolExecutionResult>;
 export type ModelClass = RuntimeModelClass;
-export declare const SMALL_LOCAL_PRIORITY_TOOL_NAMES: readonly ["outline_file", "astgrep_query", "list_workspace", "read_file_lines", "recall_context", "validate_framework", "run_orchestrator"];
+export declare const SMALL_LOCAL_PRIORITY_TOOL_NAMES: readonly ["outline_file", "astgrep_query", "astgrep_locate", "read_file_lines", "compile_structural_edit", "preview_structural_edit", "list_workspace", "recall_context", "validate_framework", "run_orchestrator"];
 export interface FilteredToolCatalogEntry {
     name: string;
     description: string;

package/dist/runtime-tool-specs.js

@@ -13,6 +13,7 @@ import { openStore } from "./store/ace-packed-store.js";
 import { getWorkspaceStorePath, readStoreBlobSync, storeExistsSync, toVirtualStorePath, } from "./store/store-snapshot.js";
 import { operationalArtifactKey, } from "./store/store-artifacts.js";
 import { withStoreWriteCoordinator } from "./store/write-coordinator.js";
+import { parseJsonLikeText } from "./json-sanitizer.js";
 export const RUNTIME_TOOL_SPEC_REGISTRY_REL_PATH = "agent-state/runtime-tool-specs.json";
 export const RUNTIME_TOOL_SPEC_SCHEMA_REL_PATH = "agent-state/MODULES/schemas/RUNTIME_TOOL_SPEC_REGISTRY.schema.json";
 export const RUNTIME_TOOL_SPEC_SCHEMA_NAME = "runtime-tool-spec-registry@1.0.0";
@@ -96,13 +97,46 @@ function buildTempToolPaths(callId) {
         responsePath: join(tempDir, "response.json"),
     };
 }
+const SAFE_RUNTIME_ENV_KEYS = new Set([
+    "PATH",
+    "HOME",
+    "TMPDIR",
+    "TEMP",
+    "TMP",
+    "USER",
+    "LANG",
+    "LC_ALL",
+    "SHELL",
+    "NODE_PATH",
+]);
+function isSecretEnvKey(key) {
+    return /(SECRET|TOKEN|KEY|PASSWORD|PASS|CREDENTIAL|AUTH|COOKIE|SESSION)/i.test(key);
+}
+export function buildRuntimeToolEnvironment(input) {
+    const base = input.base_env ?? process.env;
+    const env = {};
+    for (const key of SAFE_RUNTIME_ENV_KEYS) {
+        const value = base[key];
+        if (typeof value === "string")
+            env[key] = value;
+    }
+    for (const [key, value] of Object.entries(input.spec_env ?? {})) {
+        if (isSecretEnvKey(key))
+            continue;
+        env[key] = value;
+    }
+    for (const [key, value] of Object.entries(input.injected_env)) {
+        env[key] = value;
+    }
+    return env;
+}
 function runtimeToolArtifactKey(callId, kind) {
     return `state/runtime/tools/invocations/${callId}/${kind}.json`;
 }
 function runtimeToolArtifactVirtualPath(callId, kind) {
     return toVirtualStorePath(getWorkspaceStorePath(resolveWorkspaceRoot()), runtimeToolArtifactKey(callId, kind));
 }
-async function persistToolInvocationArtifacts(callId, requestContent, responseContent) {
+export async function persistRuntimeToolInvocationArtifacts(callId, requestContent, responseContent) {
     const workspaceRoot = resolveWorkspaceRoot();
     if (!storeExistsSync(workspaceRoot)) {
         const requestPath = resolveWorkspaceArtifactPath(`.ace-runtime/tools/${callId}.request.json`);
@@ -130,18 +164,18 @@ async function persistToolInvocationArtifacts(callId, requestContent, responseCo
     };
 }
 function parseRuntimeToolRegistry(raw) {
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
+    const parsed = parseJsonLikeText(raw);
+    if (!parsed.ok) {
+        throw new Error(`Runtime tool registry contains invalid JSON: ${parsed.error}`);
     }
-    catch (error) {
-        throw new Error(`Runtime tool registry contains invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    if (parsed.sanitized.removed_control_bytes > 0) {
+        throw new Error(`Runtime tool registry contains control-byte corruption: control_bytes_removed=${parsed.sanitized.removed_control_bytes}`);
     }
-    const validation = validateRuntimeToolSpecRegistryPayload(parsed);
+    const validation = validateRuntimeToolSpecRegistryPayload(parsed.value);
     if (!validation.ok) {
         throw new Error(`Runtime tool registry failed validation (${validation.schema}): ${validation.errors.join("; ")}`);
     }
-    return parsed;
+    return parsed.value;
 }
 function ensureToolSpec(spec, name) {
     if (spec)
@@ -258,17 +292,20 @@ export function loadRuntimeToolRegistry(explicitPath) {
         };
     }
     catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const controlBytesRemoved = Number(errorMessage.match(/control_bytes_removed=(\d+)/)?.[1] ?? 0);
         void emitRuntimeToolEvent("RUNTIME_TOOL_REGISTRY_INVALID", `Runtime tool registry validation failed for ${target.path}`, {
             path: target.path,
             source: target.source,
-            errors: [error instanceof Error ? error.message : String(error)],
+            ...(controlBytesRemoved > 0 ? { control_bytes_removed: controlBytesRemoved } : {}),
+            errors: [errorMessage],
         });
         return {
             ok: false,
             schema: RUNTIME_TOOL_SPEC_SCHEMA_NAME,
             path: target.path,
             source: target.source,
-            errors: [error instanceof Error ? error.message : String(error)],
+            errors: [errorMessage],
         };
     }
 }
@@ -317,7 +354,7 @@ export async function executeRuntimeTool(name, input, context = {}) {
             },
             validation_errors: inputErrors,
         }, null, 2);
-        ({ requestPath, responsePath } = await persistToolInvocationArtifacts(callId, validationRequest, validationResponse));
+        ({ requestPath, responsePath } = await persistRuntimeToolInvocationArtifacts(callId, validationRequest, validationResponse));
         rmSync(tempPaths.tempDir, { recursive: true, force: true });
         const result = {
             ok: false,
@@ -368,16 +405,17 @@ export async function executeRuntimeTool(name, input, context = {}) {
         : workspacePath;
     const shellResult = await runShellCommand(spec.executor.command, {
         cwd: cwdBase,
-        env: {
-            ...process.env,
-            ...(spec.executor.env ?? {}),
-            ACE_RUNTIME_TOOL_NAME: spec.name,
-            ACE_RUNTIME_TOOL_REQUEST_FILE: tempPaths.requestPath,
-            ACE_RUNTIME_TOOL_RESPONSE_FILE: tempPaths.responsePath,
-            ACE_RUNTIME_SESSION_ID: context.session_id ?? "",
-            ACE_RUNTIME_TURN: context.turn_number ? String(context.turn_number) : "",
-            ACE_RUNTIME_WORKSPACE_PATH: workspacePath,
-        },
+        env: buildRuntimeToolEnvironment({
+            spec_env: spec.executor.env,
+            injected_env: {
+                ACE_RUNTIME_TOOL_NAME: spec.name,
+                ACE_RUNTIME_TOOL_REQUEST_FILE: tempPaths.requestPath,
+                ACE_RUNTIME_TOOL_RESPONSE_FILE: tempPaths.responsePath,
+                ACE_RUNTIME_SESSION_ID: context.session_id ?? "",
+                ACE_RUNTIME_TURN: context.turn_number ? String(context.turn_number) : "",
+                ACE_RUNTIME_WORKSPACE_PATH: workspacePath,
+            },
+        }),
         timeout_ms: spec.executor.timeout_ms ?? 60_000,
     });
     let responseRaw;
@@ -386,7 +424,7 @@ export async function executeRuntimeTool(name, input, context = {}) {
     }
     if (!responseRaw) {
         const summary = `Runtime tool '${name}' did not produce a response payload`;
-        ({ requestPath, responsePath } = await persistToolInvocationArtifacts(callId, requestRaw, JSON.stringify({
+        ({ requestPath, responsePath } = await persistRuntimeToolInvocationArtifacts(callId, requestRaw, JSON.stringify({
             ok: false,
             summary,
             error: {
@@ -436,7 +474,7 @@ export async function executeRuntimeTool(name, input, context = {}) {
     }
     catch (error) {
         const summary = `Runtime tool '${name}' returned invalid JSON`;
-        ({ requestPath, responsePath } = await persistToolInvocationArtifacts(callId, requestRaw, responseRaw));
+        ({ requestPath, responsePath } = await persistRuntimeToolInvocationArtifacts(callId, requestRaw, responseRaw));
         await emitRuntimeToolEvent("RUNTIME_TOOL_FAILED", summary, {
             tool_name: name,
             error: error instanceof Error ? error.message : String(error),
@@ -458,7 +496,7 @@ export async function executeRuntimeTool(name, input, context = {}) {
     const envelope = runtimeToolResponseSchema.safeParse(parsed);
     if (!envelope.success) {
         const summary = `Runtime tool '${name}' returned an invalid response envelope`;
-        ({ requestPath, responsePath } = await persistToolInvocationArtifacts(callId, requestRaw, responseRaw));
+        ({ requestPath, responsePath } = await persistRuntimeToolInvocationArtifacts(callId, requestRaw, responseRaw));
         rmSync(tempPaths.tempDir, { recursive: true, force: true });
         return {
             ok: false,
@@ -483,7 +521,7 @@ export async function executeRuntimeTool(name, input, context = {}) {
     const success = envelope.data.ok && validationErrors.length === 0;
     const summary = envelope.data.summary ??
         (success ? `Runtime tool '${name}' executed successfully` : `Runtime tool '${name}' failed`);
-    ({ requestPath, responsePath } = await persistToolInvocationArtifacts(callId, requestRaw, responseRaw));
+    ({ requestPath, responsePath } = await persistRuntimeToolInvocationArtifacts(callId, requestRaw, responseRaw));
     rmSync(tempPaths.tempDir, { recursive: true, force: true });
     const result = {
         ok: success,
@@ -527,8 +565,11 @@ export async function executeRuntimeTool(name, input, context = {}) {
 export const SMALL_LOCAL_PRIORITY_TOOL_NAMES = [
     "outline_file",
     "astgrep_query",
-    "list_workspace",
+    "astgrep_locate",
     "read_file_lines",
+    "compile_structural_edit",
+    "preview_structural_edit",
+    "list_workspace",
     "recall_context",
     "validate_framework",
     "run_orchestrator",

package/dist/schemas.js

@@ -294,6 +294,32 @@ const runtimeToolExecutorSchema = z
     env: z.record(z.string(), z.string()).optional(),
 })
     .strict();
+const runtimeToolMcpServerSchema = z
+    .object({
+    transport: z.enum(["stdio", "http"]),
+    command: z.string().optional(),
+    args: z.array(z.string()).optional(),
+    url: z.string().url().optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    tool_allowlist: z.array(z.string()).optional(),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (value.transport === "stdio" && !value.command?.trim()) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["command"],
+            message: "stdio MCP servers require command",
+        });
+    }
+    if (value.transport === "http" && !value.url?.trim()) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["url"],
+            message: "http MCP servers require url",
+        });
+    }
+});
 const runtimeToolSpecSchema = z
     .object({
     name: NON_EMPTY,
@@ -302,6 +328,7 @@ const runtimeToolSpecSchema = z
     success_schema: runtimeToolSchemaNodeSchema.optional(),
     failure_schema: runtimeToolSchemaNodeSchema.optional(),
     executor: runtimeToolExecutorSchema,
+    mcp_server: runtimeToolMcpServerSchema.optional(),
 })
     .strict();
 const runtimeToolSpecRegistrySchema = z
@@ -388,6 +415,7 @@ const runtimeExecutorSessionRecordSchema = z
     last_error: z.string().optional(),
     cleanup_error: z.string().optional(),
     workspace_cleanup_status: z.enum(["pending", "removed", "archived", "failed"]),
+    validated_plan_id: z.string().optional(),
     output_policy: runtimeOutputPolicySchema.optional(),
     turns: z.array(unattendedTurnRecordSchema),
 })
@@ -406,7 +434,7 @@ const vericifyProcessPostSchema = z
     branch_id: z.string().optional(),
     lane_id: z.string().optional(),
     agent_id: NON_EMPTY,
-    kind: z.enum(["intent", "progress", "blocker", "handoff_note", "stale_ack", "completion"]),
+    kind: z.enum(["intent", "progress", "blocker", "handoff_note", "stale_ack", "completion", "plan_proposal", "plan_quality_assessment"]),
     summary: NON_EMPTY,
     tool_refs: z.array(z.string()),
     evidence_refs: z.array(z.string()),

package/dist/server.js

@@ -1,7 +1,11 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { buildServerInstructions, installAceToolGovernance, } from "./ace-server-instructions.js";
 import { resolveWorkspaceRoot } from "./helpers.js";
+import { openStore } from "./store/ace-packed-store.js";
+import { getWorkspaceStorePath } from "./store/store-snapshot.js";
 import { registerPrompts } from "./prompts.js";
 import { registerResources } from "./resources.js";
 import { registerTools } from "./tools.js";
@@ -24,7 +28,54 @@ export function createAceServer(options = {}) {
     registerTools(server);
     return server;
 }
+function appendEmergencyMcpStatusEvent(workspaceRoot, message) {
+    const event = {
+        schema_version: "1.0.0",
+        event_id: `evt-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+        trace_id: `trace-${Date.now()}`,
+        timestamp: new Date().toISOString(),
+        source_module: "capability-ops",
+        event_type: "MCP_BINARY_PARSE_ERROR",
+        status: "blocked",
+        objective_id: "mcp-stdio-startup",
+        payload: {
+            reason_code: "mcp_binary_parse_error",
+            summary: message,
+        },
+    };
+    const target = join(workspaceRoot, "agent-state", "STATUS_EVENTS.ndjson");
+    mkdirSync(dirname(target), { recursive: true });
+    writeFileSync(target, `${JSON.stringify(event)}\n`, { flag: "a" });
+}
+async function verifyMcpStoreStartup(workspaceRoot, logStartup) {
+    const canonicalStore = getWorkspaceStorePath(workspaceRoot);
+    const legacyStore = join(workspaceRoot, ".agents", "ACE", "ace-state.ace");
+    const candidates = [canonicalStore, legacyStore].filter((storePath, index, all) => existsSync(storePath) && all.indexOf(storePath) === index);
+    if (candidates.length === 0)
+        return true;
+    const errors = [];
+    for (const storePath of candidates) {
+        try {
+            const store = await openStore(storePath, { readOnly: true });
+            await store.close();
+            return true;
+        }
+        catch (error) {
+            errors.push(`${storePath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const message = `ACE MCP startup could not open ace-state.ace as ACEPACK; refusing stdio startup without crashing. ` +
+        `reason_code=mcp_binary_parse_error. ${errors.join(" | ")}`;
+    appendEmergencyMcpStatusEvent(workspaceRoot, message);
+    if (logStartup)
+        console.error(message);
+    return false;
+}
 export async function startStdioServer(logStartup = true) {
+    const workspaceRoot = resolveWorkspaceRoot();
+    if (!(await verifyMcpStoreStartup(workspaceRoot, logStartup))) {
+        return;
+    }
     try {
         const backfill = await backfillHandoffsIntoScheduler();
         if (logStartup && backfill.scanned > 0) {

package/dist/shared.d.ts

@@ -43,6 +43,7 @@ export declare const ROLE_ENUM: z.ZodEnum<{
     observability: "observability";
     eval: "eval";
     release: "release";
+    planner: "planner";
 }>;
 export declare const HANDOFF_VALIDATION_MODE: z.ZodOptional<z.ZodEnum<{
     "agent-state": "agent-state";

package/dist/shared.js

@@ -57,6 +57,7 @@ export const ROLE_TITLES = {
     observability: "Observability",
     eval: "Eval",
     release: "Release",
+    planner: "Planner",
 };
 export function getRoleTitle(role) {
     return ROLE_TITLES[role] ?? role.toUpperCase();
@@ -89,6 +90,7 @@ export const ROLE_ENUM = z.enum([
     "observability",
     "eval",
     "release",
+    "planner",
 ]);
 export const HANDOFF_VALIDATION_MODE = z
     .enum(["auto", "swarm", "agent-state"])

package/dist/store/bootstrap-store.d.ts

@@ -26,6 +26,7 @@ export interface BootstrapOptions {
     model?: string;
     baseUrl?: string;
     ollamaUrl?: string;
+    launcherCommand?: string;
 }
 export interface BootstrapResult {
     storePath: string;

package/dist/store/bootstrap-store.js

@@ -43,13 +43,19 @@ async function applyLlmRuntimeConfig(store, opts) {
     if (!opts.llm)
         return;
     const provider = normalizeProvider(opts.llm) ?? opts.llm;
-    const configuredModel = opts.model ?? defaultModelForProvider(provider);
+    const configuredModel = opts.model?.trim() ||
+        (provider === "ollama" ? defaultModelForProvider(provider) : undefined);
     const configuredBaseUrl = normalizeLocalBaseUrl(opts.baseUrl ?? opts.ollamaUrl);
     const profilePayload = {
         provider,
-        model: configuredModel,
         generated_at: new Date().toISOString(),
     };
+    if (configuredModel) {
+        profilePayload.model = configuredModel;
+    }
+    if (opts.launcherCommand) {
+        profilePayload.launch_command = opts.launcherCommand;
+    }
     if (configuredBaseUrl) {
         profilePayload.base_url = configuredBaseUrl;
         if (provider === "ollama") {

package/dist/store/repositories/local-model-runtime-repository.d.ts

@@ -101,7 +101,7 @@ export interface AceArchivedChatRecord {
 export interface TransitionRecord {
     transition_id: string;
     session_id?: string;
-    subject_kind: "runtime_status" | "continuity" | "plan_step" | "nudge" | "capability" | "workspace_session" | "turn" | "activation";
+    subject_kind: "runtime_status" | "continuity" | "plan_step" | "plan_proposal" | "nudge" | "capability" | "workspace_session" | "turn" | "activation";
     subject_id: string;
     from?: string;
     to: string;

package/dist/store/repositories/local-model-runtime-repository.js

@@ -255,7 +255,7 @@ export class LocalModelRuntimeRepository {
                 deduped.set(record.transition_id, record);
             }
             const kinds = [
-                "runtime_status", "continuity", "turn", "plan_step", "capability", "workspace_session", "nudge", "activation",
+                "runtime_status", "continuity", "turn", "plan_step", "plan_proposal", "capability", "workspace_session", "nudge", "activation",
             ];
             for (const kind of kinds) {
                 const records = await this.store.getJSON(this.transitionLogKey(kind, sessionId)) ?? [];

package/dist/store/repositories/vericify-repository.d.ts

@@ -9,7 +9,7 @@ export interface VericifyPost {
     id: string;
     run_id: string;
     agent_id: string;
-    kind: "intent" | "progress" | "completion" | "blocker" | "handoff_note" | "stale_ack";
+    kind: "intent" | "progress" | "completion" | "blocker" | "handoff_note" | "stale_ack" | "plan_proposal" | "plan_quality_assessment";
     summary: string;
     ts: number;
     metadata?: Record<string, unknown>;

package/dist/tools-agent.d.ts

@@ -2,6 +2,26 @@
  * Agent, skill, kernel, and task-pack tool registrations.
  */
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+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 {
+    outcome: IntentVerificationOutcome;
+    reason: string;
+    reason_code?: IntentDriftReasonCode;
+    uncovered_clauses?: string[];
+}
+export { loadAcceptanceTraceContractImpl as loadAcceptanceTraceContract };
+export { proposePlanImpl as proposePlan, validatePlanImpl as validatePlan };
+export declare function verifyIntentAgainstContract(input: {
+    plan: TaskPlan;
+    step: TaskStep;
+    result: BridgeResult;
+    intent_contract: unknown;
+}): IntentVerificationResult;
 export declare function registerAgentTools(server: McpServer): void;
 //# sourceMappingURL=tools-agent.d.ts.map