@voybio/ace-swarm 2.4.0 → 2.4.1

package/dist/orchestrator-supervisor.js

@@ -213,9 +213,7 @@ export function amendTaskPlan(plan, amendment) {
     });
 }
 export function collectUpstreamOutputs(plan, step) {
-    if (!step.depends_on || step.depends_on.length === 0)
-        return [];
-    return step.depends_on
+    const dependencyOutputs = (step.depends_on ?? [])
         .map((depId) => plan.steps.find((s) => s.step_id === depId))
         .filter((dep) => dep?.status === "done")
         .map((dep) => ({
@@ -223,6 +221,15 @@ export function collectUpstreamOutputs(plan, step) {
         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);
@@ -335,6 +342,10 @@ export async function superviseTaskPlan(inputPlan, hooks) {
     });
     const handoffIds = [];
     const jobIds = [];
+    // Intent verification loop counters (Task 7)
+    let replanCount = 0;
+    const stepRetryCount = new Map();
+    let intentContract = undefined;
     if (!plan.vcx_cursor && hooks.getVericifyContext) {
         const contextPacket = await hooks.getVericifyContext(plan);
         const vcxCursor = extractVcxCursor(contextPacket);
@@ -400,6 +411,102 @@ export async function superviseTaskPlan(inputPlan, hooks) {
                 };
             }
         }
+        // ── Intent verification loop (Task 7) ────────────────────────────────
+        if (hooks.verifyIntent) {
+            const verificationStep = plan.steps.find((s) => s.step_id === currentStep.step_id) ?? currentStep;
+            const verification = await hooks.verifyIntent({
+                plan,
+                step: verificationStep,
+                result,
+                intent_contract: intentContract,
+                vericify_delta: vericifyDelta,
+            });
+            if (verification.outcome === "revisit_step") {
+                const retries = stepRetryCount.get(currentStep.step_id) ?? 0;
+                if (retries < 1) {
+                    stepRetryCount.set(currentStep.step_id, retries + 1);
+                    await hooks.recordIntentVerificationFailure?.({
+                        plan,
+                        step: verificationStep,
+                        result,
+                        verification,
+                        from: verificationStep.status,
+                        to: "planned",
+                    });
+                    // Re-queue the step by resetting it to planned with failure context as upstream
+                    const retryContext = {
+                        step_id: `${currentStep.step_id}-retry-context`,
+                        result_summary: `Intent verification requested revisit: ${verification.reason}`,
+                        evidence_refs: verification.uncovered_clauses ?? [],
+                    };
+                    plan = amendTaskPlan(plan, {
+                        update_steps: [{
+                                step_id: currentStep.step_id,
+                                patch: {
+                                    status: "planned",
+                                    result_summary: undefined,
+                                    upstream_outputs: [
+                                        ...(verificationStep.upstream_outputs ?? []),
+                                        retryContext,
+                                    ],
+                                },
+                            }],
+                    });
+                    // Do not call amendPlan this iteration — continue to next loop pass
+                    continue;
+                }
+                else {
+                    await hooks.recordIntentVerificationFailure?.({
+                        plan,
+                        step: verificationStep,
+                        result,
+                        verification,
+                        from: verificationStep.status,
+                        to: "blocked",
+                    });
+                    plan = amendTaskPlan(plan, {
+                        update_steps: [{
+                                step_id: currentStep.step_id,
+                                patch: {
+                                    status: "blocked",
+                                    blocked_reason: verification.reason_code
+                                        ? `Intent verification failed (${verification.reason_code}): ${verification.reason}`
+                                        : `Intent verification failed: ${verification.reason}`,
+                                },
+                            }],
+                    });
+                }
+            }
+            else if (verification.outcome === "replan_required") {
+                await hooks.recordIntentVerificationFailure?.({
+                    plan,
+                    step: verificationStep,
+                    result,
+                    verification,
+                    from: verificationStep.status,
+                    to: "planned",
+                });
+                if (replanCount >= 2) {
+                    const blockedPlan = { ...plan, status: "blocked" };
+                    return {
+                        plan: withDerivedStatus(blockedPlan),
+                        handoff_ids: handoffIds,
+                        job_ids: jobIds,
+                        circuit_opened: false,
+                        blocked_reason: "intent_drift_unresolvable",
+                    };
+                }
+                replanCount += 1;
+                const uncovered = verification.uncovered_clauses ?? [];
+                if (hooks.replanForClauses && uncovered.length > 0) {
+                    const replanAmendment = await hooks.replanForClauses({ plan, uncovered_clauses: uncovered });
+                    if (replanAmendment) {
+                        plan = amendTaskPlan(plan, replanAmendment);
+                    }
+                }
+            }
+        }
+        // ── End intent verification loop ─────────────────────────────────────
         const amended = await hooks.amendPlan?.({
             plan,
             step: plan.steps.find((step) => step.step_id === currentStep.step_id) ?? currentStep,

package/dist/plan-proposal.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Workstream J — Planner contract: propose_plan, validate_plan, loadAcceptanceTraceContract.
+ * Extracted to its own module so both tools-agent.ts and runtime-executor.ts can import without
+ * a circular dependency (tools-agent already imports from runtime-executor).
+ */
+export type OrchestratorPlanSource = "explicit_steps" | "orchestrator_default_step" | "planner_model" | "deterministic_fallback";
+export type ExpectedOutputClass = "plain_text_plan" | "tool_envelope" | "code_artifact" | "structural_edit_plan" | "qa_verdict";
+export interface ContractArtifactExpectation {
+    path: string;
+    required?: boolean;
+    evidence_ref_kind?: "artifact" | "diff" | "hash" | "test" | "gate";
+}
+export interface PlanProposalStep {
+    role: string;
+    task: string;
+    depends_on?: string[];
+    tool_scope?: string[];
+    acceptance_criteria: string[];
+    stop_condition?: string[];
+    expected_output_class?: ExpectedOutputClass;
+    expected_artifacts?: ContractArtifactExpectation[];
+    allowed_tools?: string[];
+    forbidden_patterns?: string[];
+    required_evidence_refs?: string[];
+    structural_edit_plan_required?: boolean;
+    structural_edit_waiver?: {
+        reason: string;
+        evidence_ref: string;
+    };
+}
+export interface PlanProposal {
+    intent_summary: string;
+    success_criteria: string[];
+    steps: PlanProposalStep[];
+}
+export interface PlanValidationVerdict {
+    ok: boolean;
+    score: number;
+    blocking_findings: string[];
+    soft_findings: string[];
+}
+export interface ProposePlanResult {
+    plan_id: string;
+    status: "planning";
+    intent_summary: string;
+    success_criteria: string[];
+    steps: PlanProposalStep[];
+    plan_source: OrchestratorPlanSource;
+}
+export interface AcceptanceTraceContractStep {
+    step_id: string;
+    role: string;
+    task: string;
+    depends_on: string[];
+    tool_scope: string[];
+    verification_role: string | null;
+    acceptance_criteria?: string[];
+    stop_condition?: string[];
+    expected_output_class?: ExpectedOutputClass;
+    expected_artifacts?: ContractArtifactExpectation[];
+    allowed_tools?: string[];
+    forbidden_patterns?: string[];
+    required_evidence_refs?: string[];
+    structural_edit_plan_required?: boolean;
+    structural_edit_waiver?: {
+        reason: string;
+        evidence_ref: string;
+    };
+}
+export interface AcceptanceTraceContract {
+    version: number;
+    generated_at: string;
+    plan_id: string;
+    task: string;
+    plan_source: string;
+    intent_summary?: string;
+    success_criteria?: string[];
+    validation_verdict?: PlanValidationVerdict;
+    policies: {
+        inserted_research_before_spec: boolean;
+        ship_fanout_enabled: boolean;
+    };
+    steps: AcceptanceTraceContractStep[];
+}
+export declare function lookupProposal(plan_id: string): ProposePlanResult | undefined;
+export declare function inferExpectedOutputClass(step: Pick<PlanProposalStep, "role" | "tool_scope">): ExpectedOutputClass;
+/**
+ * Lightweight synchronous variant used in runtime preflights.
+ * Skips the model bridge call entirely and returns the deterministic goal scaffold.
+ * This keeps the preflight free of network I/O that could delay session startup.
+ */
+export declare function proposePlanDeterministic(task: string): ProposePlanResult;
+export declare function proposePlan(task: string, sessionId?: string): Promise<ProposePlanResult>;
+export declare function validatePlan(input: {
+    plan_id?: string;
+    proposal?: ProposePlanResult;
+    sessionId?: string;
+}): Promise<PlanValidationVerdict & {
+    plan_id: string;
+}>;
+export declare function loadAcceptanceTraceContract(plan_id: string): AcceptanceTraceContract | undefined;
+export declare function persistAcceptanceTraceMapWithContract(input: {
+    plan_id: string;
+    task: string;
+    plan_source: string;
+    intent_summary?: string;
+    success_criteria?: string[];
+    validation_verdict?: PlanValidationVerdict;
+    policies: {
+        inserted_research_before_spec: boolean;
+        ship_fanout_enabled: boolean;
+    };
+    steps: AcceptanceTraceContractStep[];
+}): Promise<string>;
+//# sourceMappingURL=plan-proposal.d.ts.map