@voybio/ace-swarm 2.4.8 → 2.4.10

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,7 +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;
@@ -24,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[];
@@ -34,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;
@@ -137,20 +246,16 @@ 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<{
     plan: TaskPlan;
     job_ids: string[];
+    dispatch?: DispatchJobsResult;
+    blocked_reason?: string;
 }>;
 export declare function superviseTaskPlan(inputPlan: TaskPlan, hooks: SupervisorHooks): Promise<SupervisorRunResult>;
 //# sourceMappingURL=orchestrator-supervisor.d.ts.map

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) {
@@ -281,7 +253,10 @@ export async function promoteParallelGroupToScheduler(plan, parallelGroup, owner
     const jobIds = [];
     const nextSteps = cloneSteps(plan.steps);
     for (const step of readySteps) {
+        // Stable identity also makes retrying the original plan safe after a refused tick.
+        const requestedJobId = step.job_id ?? `PLANJOB-${plan.plan_id}-${step.step_id}`;
         const enqueued = await enqueueJob({
+            job_id: requestedJobId,
             kind: step.role,
             payload: {
                 task: step.task,
@@ -295,7 +270,11 @@ export async function promoteParallelGroupToScheduler(plan, parallelGroup, owner
                 ref: dependency,
             })) ?? [],
         });
-        const jobId = enqueued.ack?.job_id;
+        const existingJob = enqueued.nack?.reason_code === "duplicate_job_id"
+            ? enqueued.queue.jobs.find((job) => job.job_id === requestedJobId &&
+                job.payload.plan_id === plan.plan_id && job.payload.step_id === step.step_id)
+            : undefined;
+        const jobId = enqueued.ack?.job_id ?? existingJob?.job_id;
         if (!jobId)
             continue;
         jobIds.push(jobId);
@@ -303,36 +282,70 @@ export async function promoteParallelGroupToScheduler(plan, parallelGroup, owner
         if (stepIndex >= 0) {
             nextSteps[stepIndex] = {
                 ...nextSteps[stepIndex],
-                status: "running",
                 job_id: jobId,
             };
         }
     }
+    let dispatch;
+    let blockedReason;
     if (jobIds.length > 0) {
         const refs = deriveWorkspaceVericifyRunRef({
             session_id: plan.plan_id,
             role: "orchestrator",
         });
-        await dispatchJobs({ owner });
-        await appendVericifyProcessPostSafe({
+        dispatch = await dispatchJobs({ owner });
+        blockedReason = dispatch.error;
+        const promotedIds = new Set(jobIds);
+        for (const step of nextSteps) {
+            if (!step.job_id || !promotedIds.has(step.job_id))
+                continue;
+            const job = dispatch.queue.jobs.find((candidate) => candidate.job_id === step.job_id);
+            // A recorded assignment is not proof of dispatch. Keep queued steps retryable.
+            switch (job?.status) {
+                case "running":
+                    step.status = "running";
+                    break;
+                case "done":
+                    step.status = "done";
+                    break;
+                case "failed_terminal":
+                    step.status = "failed";
+                    break;
+                case "canceled":
+                    step.status = "skipped";
+                    break;
+                case "unknown_recovery":
+                    step.status = "blocked";
+                    break;
+                default: step.status = "planned";
+            }
+            step.blocked_reason = step.status === "planned" || step.status === "blocked"
+                ? dispatch.error ?? job?.error
+                : undefined;
+        }
+        await appendAutomaticVericifyProcessPostSafe({
             run_id: refs.run_id,
             branch_id: refs.branch_id,
             lane_id: refs.lane_id,
             agent_id: "agent-orchestrator",
-            kind: "progress",
-            summary: `Promoted parallel group '${parallelGroup}' to scheduler: ${jobIds.join(", ")}`,
+            kind: blockedReason ? "blocker" : "progress",
+            summary: blockedReason
+                ? `Parallel group '${parallelGroup}' queued; ${blockedReason}`
+                : `Promoted parallel group '${parallelGroup}' to scheduler: ${jobIds.join(", ")}; running=${nextSteps.filter((step) => step.job_id && promotedIds.has(step.job_id) && step.status === "running").length}`,
             tool_refs: ["enqueue_job", "dispatch_jobs"],
             evidence_refs: jobIds,
         });
     }
+    const promotedPlan = withDerivedStatus({
+        ...plan,
+        execution_mode: "scheduled",
+        steps: nextSteps,
+    });
     return {
-        plan: withDerivedStatus({
-            ...plan,
-            execution_mode: "scheduled",
-            steps: nextSteps,
-            status: "executing",
-        }),
+        plan: blockedReason ? { ...promotedPlan, status: "blocked" } : promotedPlan,
         job_ids: jobIds,
+        dispatch,
+        blocked_reason: blockedReason,
     };
 }
 export async function superviseTaskPlan(inputPlan, hooks) {
@@ -368,6 +381,17 @@ export async function superviseTaskPlan(inputPlan, hooks) {
                 const promoted = await promoteParallelGroupToScheduler(plan, readyGroup);
                 jobIds.push(...promoted.job_ids);
                 plan = promoted.plan;
+                if (promoted.blocked_reason) {
+                    await hooks.emitStatusEvent?.({ status: "blocked", summary: promoted.blocked_reason });
+                    await hooks.contextSnapshot?.(plan);
+                    return {
+                        plan,
+                        handoff_ids: handoffIds,
+                        job_ids: jobIds,
+                        circuit_opened: false,
+                        blocked_reason: promoted.blocked_reason,
+                    };
+                }
                 break;
             }
         }

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;

package/dist/playbook-curator.js

@@ -1,7 +1,7 @@
 import { calculateJaccard, getShingles } from "./semantic-hash.js";
 import { appendStatusEventSafe } from "./status-events.js";
 function scopeEqualOrBroader(candidate, incoming) {
-    return Object.entries(candidate).every(([key, value]) => value === undefined || incoming[key] === value);
+    return Object.entries(candidate).every(([key, value]) => value === undefined || JSON.stringify(incoming[key]) === JSON.stringify(value));
 }
 function mergeEvidence(a, b) {
     return [...new Set([...a, ...b])].slice(0, 5);
@@ -43,7 +43,7 @@ export async function curate(repo, ops, config = {}) {
         }
         const incomingShingles = getShingles(op.content, 3);
         const match = repo
-            .listBullets({ section: op.section, status: "active" })
+            .listBullets({ section: op.section, ...(op.status === "quarantined" ? {} : { status: "active" }) })
             .filter((bullet) => scopeEqualOrBroader(bullet.scope, op.scope))
             .map((bullet) => ({
             bullet,
@@ -55,6 +55,7 @@ export async function curate(repo, ops, config = {}) {
                 ...match.bullet,
                 observed_count: match.bullet.observed_count + 1,
                 evidence_refs: mergeEvidence(match.bullet.evidence_refs, op.evidence_refs),
+                evidence_snapshots: [...new Map([...(match.bullet.evidence_snapshots ?? []), ...(op.evidence_snapshots ?? [])].map(e => [e.id, e])).values()],
             });
             result.merged += 1;
         }
@@ -69,13 +70,14 @@ export async function curate(repo, ops, config = {}) {
     }
     result.pruned += pruneOverflow(repo, config);
     const eventWorkspaceRoot = config.workspaceRoot ?? repo.root;
-    await appendStatusEventSafe({
-        event_type: "PLAYBOOK_CURATED",
-        source_module: "capability-build",
-        status: "done",
-        summary: `Playbook curated: added=${result.added} merged=${result.merged} tagged=${result.tagged} quarantined=${result.quarantined} pruned=${result.pruned}`,
-        payload: { ...result },
-    }, eventWorkspaceRoot ? { workspaceRoot: eventWorkspaceRoot } : {});
+    if (config.emitEvent !== false && Object.values(result).some(n => n > 0))
+        await appendStatusEventSafe({
+            event_type: "PLAYBOOK_CURATED",
+            source_module: "capability-build",
+            status: "done",
+            summary: `Playbook curated: added=${result.added} merged=${result.merged} tagged=${result.tagged} quarantined=${result.quarantined} pruned=${result.pruned}`,
+            payload: { ...result },
+        }, eventWorkspaceRoot ? { workspaceRoot: eventWorkspaceRoot } : {});
     return result;
 }
 function pruneOverflow(repo, config) {

package/dist/process-identity.d.ts

@@ -0,0 +1,8 @@
+export interface ProcessIdentity {
+    pid: number;
+    started_at: string;
+    hostname: string;
+}
+export declare function readProcessIdentity(pid: number): ProcessIdentity | undefined;
+export declare function probeProcess(identity: ProcessIdentity): 'alive' | 'dead' | 'unknown';
+//# sourceMappingURL=process-identity.d.ts.map