@voybio/ace-swarm 2.4.9 → 2.4.10

package/dist/mcp-command-progress.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import type { CommandProgress } from "./progress-command.js";
+/** MCP liveness messages keep opted-in requests alive without claiming output progress. */
+export declare function withMcpCommandProgress<T>(extra: {
+    _meta?: {
+        progressToken?: string | number;
+    };
+    signal?: AbortSignal;
+    sendNotification?: (notification: any) => Promise<unknown>;
+} | undefined, label: string, work: (onProgress: (progress: CommandProgress) => void, signal: AbortSignal) => Promise<T>, connectionIsOpen?: () => boolean): Promise<T>;
+export declare const commandPolicySchema: z.ZodObject<{
+    stall_min: z.ZodOptional<z.ZodNumber>;
+    kill_min: z.ZodOptional<z.ZodNumber>;
+    deadline_min: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+//# sourceMappingURL=mcp-command-progress.d.ts.map

package/dist/mcp-command-progress.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+/** MCP liveness messages keep opted-in requests alive without claiming output progress. */
+export async function withMcpCommandProgress(extra, label, work, connectionIsOpen) {
+    // The SDK cancels a request when its client stops waiting. That cancellation
+    // owns the response channel, not the command's lifetime. Explicit operator
+    // cancellation and ACE's explicitly configured tool deadlines still propagate.
+    const sourceSignal = extra?.signal;
+    const workController = new AbortController();
+    const beganConnected = connectionIsOpen?.() ?? false;
+    const forwardCancellation = () => {
+        const reason = sourceSignal?.reason;
+        const text = String(reason ?? "");
+        const code = reason && typeof reason === "object" && "code" in reason ? reason.code : undefined;
+        const clientWaitExpired = code === -32001 || /(?:McpError|MCP error).*Request timed out/i.test(text);
+        const transportClosed = /(?:connection|transport|stream)(?: was)? closed|\bdisconnected\b|ECONNRESET|EPIPE/i.test(text);
+        if (clientWaitExpired || transportClosed)
+            return;
+        const genericAbort = (reason instanceof Error && reason.name === "AbortError") || /^AbortError:/i.test(text);
+        if (genericAbort && beganConnected) {
+            // SDK _onclose aborts handlers before clearing its transport. Check after
+            // that synchronous close sequence; an operator abort leaves transport open.
+            queueMicrotask(() => {
+                if (connectionIsOpen?.() === false)
+                    return;
+                workController.abort(reason);
+            });
+        }
+        else
+            workController.abort(reason);
+    };
+    if (sourceSignal?.aborted) {
+        forwardCancellation();
+        await Promise.resolve();
+    }
+    else
+        sourceSignal?.addEventListener("abort", forwardCancellation, { once: true });
+    const token = extra?._meta?.progressToken;
+    let sequence = 0;
+    let latest = "running";
+    const notify = () => {
+        if (token === undefined || !extra?.sendNotification)
+            return;
+        try {
+            void Promise.resolve(extra.sendNotification({
+                method: "notifications/progress",
+                params: { progressToken: token, progress: ++sequence, message: `${label}: ${latest}` },
+            })).catch(() => undefined);
+        }
+        catch { /* A closed notification channel must not change command outcomes. */ }
+    };
+    notify();
+    const heartbeat = setInterval(notify, 15_000);
+    heartbeat.unref?.();
+    try {
+        return await work((progress) => {
+            latest = `${progress.status}; running ${Math.floor(progress.elapsed_ms / 1000)}s, last output ${Math.floor(progress.silence_ms / 1000)}s ago`;
+            notify();
+        }, workController.signal);
+    }
+    finally {
+        clearInterval(heartbeat);
+        sourceSignal?.removeEventListener("abort", forwardCancellation);
+    }
+}
+export const commandPolicySchema = z.object({
+    stall_min: z.number().nonnegative().finite().optional().describe("Silence before suspected stall; default 10 minutes, 0 disables stall detection"),
+    kill_min: z.number().nonnegative().finite().optional().describe("Total silence before terminating stalled process group; default 60 minutes"),
+    deadline_min: z.number().positive().finite().optional().describe("Explicit overall deadline in minutes; omitted means no overall deadline"),
+});
+//# sourceMappingURL=mcp-command-progress.js.map

package/dist/model-bridge.d.ts

@@ -10,7 +10,7 @@ export interface BridgeToolResult {
     ok: boolean;
     summary: string;
     isError: boolean;
-    /** Set when a tool fails for a classified reason (e.g. "tool_timeout"). */
+    /** Classified failure or nonterminal state (for example "still_running"). */
     reason_code?: string;
 }
 export interface BridgeUsageTotals {
@@ -83,20 +83,20 @@ export declare function verifyCompletionArtifacts(result: BridgeResult, context:
     requiredEvidenceRefs?: string[];
     forceCompletionVerification?: boolean;
 }): Promise<BridgeResult>;
-/**
- * Per-tool-call deadline (E12). A hung validation/test subprocess must never
- * wedge a turn indefinitely — and under Promise.all one stuck call also holds
- * every parallel sibling's feedback hostage. On timeout we resolve a classified
- * `tool_timeout` failure that then feeds the WS-C doom-loop brake.
- */
-export declare function executeToolWithDeadline(tool: string, args: Record<string, unknown>, sessionId: string, opts: {
-    workspace_path: string;
-}, deadlineMs: number, exec?: (tool: string, args: Record<string, unknown>, sessionId: string, opts: {
+type InternalToolOptions = {
     workspace_path: string;
-}) => Promise<unknown>): Promise<{
+    signal?: AbortSignal;
+};
+type ToolDeadlineOutcome = {
     rawToolResult: unknown;
-    timedOut: boolean;
-}>;
+    timedOut: false;
+    stillRunning?: boolean;
+    operationId?: string;
+};
+/** No implicit cutoff. An explicit deadline requests cancellation; unconfirmed
+ * cancellation is reported as still running. Identical retries collect the same
+ * operation instead of launching a duplicate side effect. */
+export declare function executeToolWithDeadline(tool: string, args: Record<string, unknown>, sessionId: string, opts: InternalToolOptions, deadlineMs?: number, exec?: (tool: string, args: Record<string, unknown>, sessionId: string, opts: InternalToolOptions) => Promise<unknown>): Promise<ToolDeadlineOutcome>;
 export declare class ModelBridge {
     private clients;
     private activeProviderClient;
@@ -108,4 +108,5 @@ export declare class ModelBridge {
     private selectToolScope;
     run(options: ModelBridgeRunOptions): Promise<BridgeResult>;
 }
+export {};
 //# sourceMappingURL=model-bridge.d.ts.map

package/dist/model-bridge.js

@@ -2,7 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, writeFileSync, realpathSync } from "node:fs";
 import { dirname, isAbsolute, resolve, sep } from "node:path";
 import { executeAceInternalTool, listAceInternalToolCatalog, } from "./ace-internal-tools.js";
-import { appendVericifyProcessPostSafe, deriveWorkspaceVericifyRunRef, } from "./vericify-bridge.js";
+import { appendAutomaticVericifyProcessPostSafe, deriveWorkspaceVericifyRunRef, } from "./vericify-bridge.js";
 import { buildToolPlan, renderAceContext } from "./ace-context.js";
 import { appendRunLedgerEntrySafe } from "./run-ledger.js";
 import { appendStatusEventSafe } from "./status-events.js";
@@ -479,7 +479,7 @@ function isRetryableProviderError(error) {
 function formatToolFeedback(results) {
     return [
         "Tool execution results:",
-        ...results.map((result) => `- ${result.tool}: ${result.ok ? "ok" : "error"} — ${result.summary}`),
+        ...results.map((result) => `- ${result.tool}: ${result.reason_code === "still_running" ? "still_running" : result.ok ? "ok" : "error"} — ${result.summary}`),
         "Continue with another JSON response.",
     ].join("\n");
 }
@@ -527,31 +527,67 @@ function withUsageTotals(result, usageTotals) {
 function contextOverflowSuspected(usage, numCtx) {
     return Boolean(usage && usage.prompt_tokens >= Math.floor(numCtx * 0.98));
 }
-const DEFAULT_TOOL_DEADLINE_MS = 120_000;
 function toolDeadlineMs() {
     const raw = Number(process.env.ACE_TOOL_DEADLINE_MS);
-    return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : DEFAULT_TOOL_DEADLINE_MS;
+    return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : undefined;
 }
-/**
- * Per-tool-call deadline (E12). A hung validation/test subprocess must never
- * wedge a turn indefinitely — and under Promise.all one stuck call also holds
- * every parallel sibling's feedback hostage. On timeout we resolve a classified
- * `tool_timeout` failure that then feeds the WS-C doom-loop brake.
- */
+const pendingToolOperations = new Map();
+function canonicalToolInput(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalToolInput);
+    if (value && typeof value === "object")
+        return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => [key, canonicalToolInput(entry)]));
+    return value;
+}
+/** No implicit cutoff. An explicit deadline requests cancellation; unconfirmed
+ * cancellation is reported as still running. Identical retries collect the same
+ * operation instead of launching a duplicate side effect. */
 export async function executeToolWithDeadline(tool, args, sessionId, opts, deadlineMs, exec = executeAceInternalTool) {
+    const key = JSON.stringify([sessionId, opts.workspace_path, tool, canonicalToolInput(args)]);
+    let operation = pendingToolOperations.get(key);
+    const collecting = Boolean(operation);
+    if (!operation) {
+        const controller = new AbortController();
+        const forwardAbort = () => controller.abort(opts.signal?.reason);
+        if (opts.signal?.aborted)
+            forwardAbort();
+        else
+            opts.signal?.addEventListener("abort", forwardAbort, { once: true });
+        const created = { id: randomUUID(), controller, state: "running", promise: Promise.resolve() };
+        created.promise = Promise.resolve().then(() => exec(tool, args, sessionId, { ...opts, signal: controller.signal })).then((value) => { created.state = "done"; return value; }, (error) => { created.state = "failed"; throw error; }).finally(() => opts.signal?.removeEventListener("abort", forwardAbort));
+        // Keep eventual failures observed while an explicit caller has stopped waiting.
+        void created.promise.catch(() => undefined);
+        operation = created;
+        pendingToolOperations.set(key, operation);
+    }
     let timer;
-    const timeout = new Promise((resolve) => {
-        timer = setTimeout(() => resolve({ rawToolResult: undefined, timedOut: true }), deadlineMs);
-        timer.unref?.();
-    });
+    const pending = Symbol("still-running");
     try {
-        return await Promise.race([
-            exec(tool, args, sessionId, opts).then((rawToolResult) => ({
-                rawToolResult,
+        const value = deadlineMs === undefined || deadlineMs <= 0
+            ? await operation.promise
+            : await Promise.race([
+                operation.promise,
+                new Promise((resolve) => { timer = setTimeout(() => resolve(pending), deadlineMs); timer.unref?.(); }),
+            ]);
+        if (value === pending) {
+            operation.controller.abort(new Error(`Explicit tool deadline elapsed after ${deadlineMs}ms`));
+            return {
                 timedOut: false,
-            })),
-            timeout,
-        ]);
+                stillRunning: true,
+                operationId: operation.id,
+                rawToolResult: {
+                    isError: false,
+                    structuredContent: { status: "still_running", operation_id: operation.id, cancellation_requested: true },
+                    content: [{ type: "text", text: `Operation ${operation.id} is still running after its explicit deadline; cancellation was requested but is not yet confirmed. Repeat this same tool call to collect its result without starting duplicate work.` }],
+                },
+            };
+        }
+        pendingToolOperations.delete(key);
+        return { rawToolResult: value, timedOut: false, operationId: collecting ? operation.id : undefined };
+    }
+    catch (error) {
+        pendingToolOperations.delete(key);
+        throw error;
     }
     finally {
         if (timer)
@@ -727,7 +763,7 @@ export class ModelBridge {
             session_id: this.bridgeId,
             role: options.role,
         });
-        await appendVericifyProcessPostSafe({
+        await appendAutomaticVericifyProcessPostSafe({
             run_id: refs.run_id,
             branch_id: refs.branch_id,
             lane_id: refs.lane_id,
@@ -871,7 +907,7 @@ export class ModelBridge {
         // intra-turn runaway is bounded separately by the num_predict output cap.
         const textLoopCounts = new Map();
         try {
-            await appendVericifyProcessPostSafe({
+            await appendAutomaticVericifyProcessPostSafe({
                 run_id: refs.run_id,
                 branch_id: refs.branch_id,
                 lane_id: refs.lane_id,
@@ -881,7 +917,7 @@ export class ModelBridge {
                 tool_refs: aceContext.tools.map((tool) => tool.name),
             });
             noteProgress("process_post", { kind: "intent" });
-            for (let turn = 1; turn <= options.maxTurns; turn += 1) {
+            for (let turn = 1; options.maxTurns === 0 || turn <= options.maxTurns; turn += 1) {
                 const compressed = compressConversationHistory(messages, numCtx);
                 if (compressed.compressed) {
                     messages.splice(0, messages.length, ...compressed.messages);
@@ -936,7 +972,7 @@ export class ModelBridge {
                     }
                     if (textLoopCount >= 4) {
                         const summary = "Bridge blocked after repeating an identical response four times without progress.";
-                        await appendVericifyProcessPostSafe({
+                        await appendAutomaticVericifyProcessPostSafe({
                             run_id: refs.run_id,
                             branch_id: refs.branch_id,
                             lane_id: refs.lane_id,
@@ -1020,7 +1056,7 @@ export class ModelBridge {
                         const summary = rawResponse.trim() || "Bridge completed.";
                         options.onOutput?.(summary);
                         noteProgress("output", { status: "complete", fallback: "plain_text" });
-                        await appendVericifyProcessPostSafe({
+                        await appendAutomaticVericifyProcessPostSafe({
                             run_id: refs.run_id,
                             branch_id: refs.branch_id,
                             lane_id: refs.lane_id,
@@ -1077,7 +1113,7 @@ export class ModelBridge {
                         status: "parse_error",
                         role_contract_violation: isContractViolation,
                     });
-                    await appendVericifyProcessPostSafe({
+                    await appendAutomaticVericifyProcessPostSafe({
                         run_id: refs.run_id,
                         branch_id: refs.branch_id,
                         lane_id: refs.lane_id,
@@ -1146,14 +1182,8 @@ export class ModelBridge {
                         noteProgress("tool_start", { tool: toolCall.tool });
                         const deadlineMs = toolDeadlineMs();
                         const outcome = await executeToolWithDeadline(toolCall.tool, args, sessionId, { workspace_path: options.workspace }, deadlineMs);
-                        const result = outcome.timedOut
-                            ? {
-                                tool: toolCall.tool,
-                                ok: false,
-                                isError: true,
-                                summary: `tool_timeout: ${toolCall.tool} exceeded ${deadlineMs}ms deadline`,
-                                reason_code: "tool_timeout",
-                            }
+                        const result = outcome.stillRunning
+                            ? { tool: toolCall.tool, ok: false, isError: false, summary: summarizeToolText(outcome.rawToolResult), reason_code: "still_running" }
                             : truncateToolResult({
                                 tool: toolCall.tool,
                                 ok: !Boolean(outcome.rawToolResult?.isError),
@@ -1161,7 +1191,7 @@ export class ModelBridge {
                                 summary: summarizeToolText(outcome.rawToolResult),
                             }, options.workspace);
                         options.onToolResult?.(toolCall.tool, result);
-                        noteProgress("tool_finish", { tool: toolCall.tool, ok: result.ok });
+                        noteProgress(result.reason_code === "still_running" ? "thinking" : "tool_finish", { tool: toolCall.tool, ok: result.ok });
                         toolResults.push(result);
                         if (result.ok) {
                             const pathArg = typeof args.path === "string"
@@ -1187,6 +1217,8 @@ export class ModelBridge {
                         toolCalls: executed,
                     });
                     for (const { toolCall, result } of executedPairs) {
+                        if (result.reason_code === "still_running")
+                            continue;
                         const loopKey = toolDoomLoopKey(toolCall, result);
                         const count = (toolDoomLoopCounts.get(loopKey) ?? 0) + 1;
                         toolDoomLoopCounts.set(loopKey, count);
@@ -1205,7 +1237,7 @@ export class ModelBridge {
                         }
                         if (count >= 4) {
                             const summary = `Bridge blocked after repeated identical tool result for ${toolCall.tool}.`;
-                            await appendVericifyProcessPostSafe({
+                            await appendAutomaticVericifyProcessPostSafe({
                                 run_id: refs.run_id,
                                 branch_id: refs.branch_id,
                                 lane_id: refs.lane_id,
@@ -1251,7 +1283,7 @@ export class ModelBridge {
                     const message = readEnvelopeText(envelope.message) || rawResponse.trim();
                     options.onOutput?.(message);
                     noteProgress("output", { status: "message" });
-                    await appendVericifyProcessPostSafe({
+                    await appendAutomaticVericifyProcessPostSafe({
                         run_id: refs.run_id,
                         branch_id: refs.branch_id,
                         lane_id: refs.lane_id,
@@ -1293,7 +1325,7 @@ export class ModelBridge {
                     const message = readEnvelopeText(envelope.message) || "Additional operator input required.";
                     options.onOutput?.(message);
                     noteProgress("output", { status: "need_input" });
-                    await appendVericifyProcessPostSafe({
+                    await appendAutomaticVericifyProcessPostSafe({
                         run_id: refs.run_id,
                         branch_id: refs.branch_id,
                         lane_id: refs.lane_id,
@@ -1348,7 +1380,7 @@ export class ModelBridge {
                         const driftSummary = `[output_drift_violation] ${role}: ${driftViolation}`;
                         options.onOutput?.(driftSummary);
                         noteProgress("output", { status: "output_drift_violation" });
-                        await appendVericifyProcessPostSafe({
+                        await appendAutomaticVericifyProcessPostSafe({
                             run_id: refs.run_id,
                             branch_id: refs.branch_id,
                             lane_id: refs.lane_id,
@@ -1372,7 +1404,7 @@ export class ModelBridge {
                     // Clean output — accept the completion.
                     options.onOutput?.(summary);
                     noteProgress("output", { status: "complete" });
-                    await appendVericifyProcessPostSafe({
+                    await appendAutomaticVericifyProcessPostSafe({
                         run_id: refs.run_id,
                         branch_id: refs.branch_id,
                         lane_id: refs.lane_id,
@@ -1402,7 +1434,7 @@ export class ModelBridge {
                 }
             }
             const summary = "Bridge stopped after reaching max turns.";
-            await appendVericifyProcessPostSafe({
+            await appendAutomaticVericifyProcessPostSafe({
                 run_id: refs.run_id,
                 branch_id: refs.branch_id,
                 lane_id: refs.lane_id,

package/dist/orchestrator-supervisor.d.ts

@@ -1,8 +1,48 @@
+export { getReadyTaskSteps, collectUpstreamOutputs } from "./task-plan-context.js";
 import { type DispatchJobsResult } from "./job-scheduler.js";
 import type { BridgeResult } from "./model-bridge.js";
 import type { LocalModelRuntimeRepository } from "./store/repositories/local-model-runtime-repository.js";
 export type TaskStepStatus = "planned" | "running" | "done" | "failed" | "skipped" | "blocked";
 export type TaskPlanStatus = "planning" | "executing" | "reviewing" | "blocked" | "done" | "failed";
+export interface ObservedRun {
+    record_id: string;
+    attribution: "Linked" | "Inferred" | "Ambiguous" | "Unknown";
+    command: string;
+    cwd?: string;
+    exit_code: number | null;
+    outcome: "ok" | "failed" | "unknown";
+    at: string;
+    output_tail?: string;
+    command_norm: string;
+    paths?: string[];
+    tool_use_id?: string;
+    session_id?: string;
+}
+export interface StepAttempt {
+    attempt: number;
+    status: "done" | "blocked" | "failed";
+    at: string;
+    summary: string;
+    checks?: Array<{
+        command: string;
+        cwd: string;
+        ok: boolean;
+    }>;
+    failure_signature?: string;
+    failure_excerpt?: string;
+    scope_snapshot?: {
+        role: string;
+        paths: string[];
+        task_tags: string[];
+    };
+    served_context?: {
+        items: Array<Pick<import('./learning-serving.js').ServedLearningItem, 'id' | 'kind' | 'scope'>>;
+        rendered_bytes: number;
+    };
+    evidence_refs: string[];
+    served?: string[];
+    observed_runs?: ObservedRun[];
+}
 export interface TaskStep {
     step_id: string;
     role: string;
@@ -25,6 +65,8 @@ export interface TaskStep {
     expected_artifacts?: Array<{
         path: string;
         required?: boolean;
+        /** Required when this step completes, but not a final deliverable. */
+        transient?: boolean;
         evidence_ref_kind?: "artifact" | "diff" | "hash" | "test" | "gate";
     }>;
     allowed_tools?: string[];
@@ -35,6 +77,72 @@ export interface TaskStep {
         reason: string;
         evidence_ref: string;
     };
+    assignee?: string;
+    attempt?: number;
+    started_at?: string;
+    last_ace_call_at?: string;
+    waiting_on?: string;
+    result_digest?: string;
+    result_response?: unknown;
+    attempts_log?: StepAttempt[];
+    served_learning?: import('./learning-serving.js').ServedLearning;
+    learning_feedback?: Array<{
+        id: string;
+        helpful: boolean;
+    }>;
+    loaded_learning?: Array<{
+        id: string;
+        at: string;
+    }>;
+    learning_kind?: "meta" | "graduation";
+    learning_source?: string;
+    learning_trigger?: string;
+    learning_inputs?: import('./learning-input-context.js').LearningInputRefs;
+    learning_scope?: string;
+    learning_opened_at?: string;
+    learning_payload?: import('./learned-artifacts.js').LearnedPayload;
+    learning_result?: import('./learned-artifacts.js').LearningAcceptance;
+    attempt_history?: Array<Pick<TaskStep, 'attempt' | 'assignee' | 'status' | 'result_summary' | 'evidence' | 'artifacts' | 'result_digest' | 'result_response'>>;
+    evidence?: Array<{
+        ref: string;
+        kind: "command" | "artifact" | "diff" | "note";
+        provenance: "host" | "ace";
+        detail?: string;
+        ok?: boolean;
+    }>;
+    artifacts?: string[];
+    todo_id?: string;
+    required_observation?: "action" | "command_pass";
+    observation?: "available" | "pending" | "unavailable";
+    observation_window?: {
+        workspace_id: string;
+        session_id?: string;
+        started_at: string;
+        ended_at?: string;
+    };
+    observation_refs?: Array<{
+        id: string;
+        attribution: "Linked" | "Inferred" | "Ambiguous" | "Unknown";
+        kind: string;
+        result?: string;
+        run?: ObservedRun;
+    }>;
+    /** Additive acceptance metadata; saved result_response and original window remain immutable. */
+    observation_check?: {
+        attempt: number;
+        status: "pending" | "passed" | "unmet" | "unsupported";
+        deadline_at: string;
+        wait_ms: number;
+        poll_ms: number;
+        reason_code?: string;
+    };
+    observation_query?: Record<string, unknown>;
+    observation_coverage?: Record<string, unknown>;
+    verification_failure?: {
+        command: string;
+        output: string;
+        ref: string;
+    };
 }
 export interface TaskPlan {
     plan_id: string;
@@ -138,15 +246,9 @@ export declare function createTaskPlan(input: {
     execution_mode?: TaskPlan["execution_mode"];
     vcx_cursor?: string;
 }): TaskPlan;
-export declare function getReadyTaskSteps(plan: TaskPlan): TaskStep[];
 export declare function markTaskStepStatus(plan: TaskPlan, stepId: string, status: TaskStepStatus, patch?: Partial<Omit<TaskStep, "step_id" | "status">>): TaskPlan;
 export declare function applyBridgeResultToStep(plan: TaskPlan, stepId: string, result: BridgeResult): TaskPlan;
 export declare function amendTaskPlan(plan: TaskPlan, amendment: TaskPlanAmendment): TaskPlan;
-export declare function collectUpstreamOutputs(plan: TaskPlan, step: TaskStep): {
-    step_id: string;
-    result_summary: string;
-    evidence_refs: string[];
-}[];
 export declare function applyBridgeResultToStepWithTransition(plan: TaskPlan, stepId: string, result: BridgeResult, repo?: LocalModelRuntimeRepository): Promise<TaskPlan>;
 export declare function amendTaskPlanWithTransition(plan: TaskPlan, amendment: TaskPlanAmendment, repo?: LocalModelRuntimeRepository, reason?: string, reason_code?: string): Promise<TaskPlan>;
 export declare function promoteParallelGroupToScheduler(plan: TaskPlan, parallelGroup: string, owner?: string): Promise<{

package/dist/orchestrator-supervisor.js

@@ -1,8 +1,10 @@
+import { getReadyTaskSteps, collectUpstreamOutputs } from "./task-plan-context.js";
+export { getReadyTaskSteps, collectUpstreamOutputs } from "./task-plan-context.js";
 import { existsSync } from "node:fs";
 import { dirname } from "node:path";
 import { randomUUID } from "node:crypto";
 import { dispatchJobs, enqueueJob, getJobQueuePath } from "./job-scheduler.js";
-import { appendVericifyProcessPostSafe, deriveWorkspaceVericifyRunRef, } from "./vericify-bridge.js";
+import { appendAutomaticVericifyProcessPostSafe, deriveWorkspaceVericifyRunRef, } from "./vericify-bridge.js";
 function parseNumericStepId(stepId) {
     const numeric = Number(stepId.replace(/^step-/, ""));
     return Number.isFinite(numeric) && numeric > 0 ? numeric : 0;
@@ -90,17 +92,6 @@ export function createTaskPlan(input) {
         vcx_cursor: input.vcx_cursor,
     });
 }
-export function getReadyTaskSteps(plan) {
-    const completed = new Set(plan.steps
-        .filter((step) => step.status === "done" || step.status === "skipped")
-        .map((step) => step.step_id));
-    return plan.steps.filter((step) => {
-        if (step.status !== "planned")
-            return false;
-        const dependencies = step.depends_on ?? [];
-        return dependencies.every((dependency) => completed.has(dependency));
-    });
-}
 export function markTaskStepStatus(plan, stepId, status, patch = {}) {
     return withDerivedStatus({
         ...plan,
@@ -212,25 +203,6 @@ export function amendTaskPlan(plan, amendment) {
         vcx_cursor: amendment.vcx_cursor ?? plan.vcx_cursor,
     });
 }
-export function collectUpstreamOutputs(plan, step) {
-    const dependencyOutputs = (step.depends_on ?? [])
-        .map((depId) => plan.steps.find((s) => s.step_id === depId))
-        .filter((dep) => dep?.status === "done")
-        .map((dep) => ({
-        step_id: dep.step_id,
-        result_summary: dep.result_summary ?? "",
-        evidence_refs: dep.evidence_refs ?? [],
-    }));
-    const carriedOutputs = (step.upstream_outputs ?? []).filter((output) => Boolean(output) &&
-        typeof output.step_id === "string" &&
-        typeof output.result_summary === "string" &&
-        Array.isArray(output.evidence_refs));
-    const merged = new Map();
-    for (const output of [...dependencyOutputs, ...carriedOutputs]) {
-        merged.set(output.step_id, output);
-    }
-    return [...merged.values()];
-}
 export async function applyBridgeResultToStepWithTransition(plan, stepId, result, repo) {
     const updated = applyBridgeResultToStep(plan, stepId, result);
     if (repo && plan.plan_id) {
@@ -351,7 +323,7 @@ export async function promoteParallelGroupToScheduler(plan, parallelGroup, owner
                 ? dispatch.error ?? job?.error
                 : undefined;
         }
-        await appendVericifyProcessPostSafe({
+        await appendAutomaticVericifyProcessPostSafe({
             run_id: refs.run_id,
             branch_id: refs.branch_id,
             lane_id: refs.lane_id,

package/dist/plan-proposal.js

@@ -8,7 +8,7 @@ import { listAceInternalToolCatalog } from "./ace-internal-tools.js";
 import { runLocalModelTask } from "./local-model-runtime.js";
 import { listRuntimeToolSpecs } from "./runtime-tool-specs.js";
 import { resolveWorkspaceRoot, safeRead, safeWriteAsync } from "./helpers.js";
-import { appendVericifyProcessPostSafe } from "./vericify-bridge.js";
+import { appendAutomaticVericifyProcessPostSafe } from "./vericify-bridge.js";
 import { withLocalModelRuntimeRepository } from "./store/repositories/local-model-runtime-repository.js";
 // ── In-memory proposal cache (plan_id → ProposePlanResult) ────────────────
 const _proposalCache = new Map();
@@ -1051,8 +1051,8 @@ export async function validatePlan(input) {
     catch {
         // Non-fatal
     }
-    // Emit Vericify process post
-    await appendVericifyProcessPostSafe({
+    // Optional legacy summary; native Vericify owns observation capture.
+    await appendAutomaticVericifyProcessPostSafe({
         run_id: "workspace:current",
         agent_id: "ace-planner",
         kind: "plan_quality_assessment",

package/dist/playbook-curator.d.ts

@@ -4,6 +4,7 @@ export interface CuratorConfig extends PlaybookConfig {
     quarantine_harmful_min?: number;
     quarantine_retire_after_days?: number;
     workspaceRoot?: string;
+    emitEvent?: boolean;
 }
 export interface CurateResult {
     added: number;