@voybio/ace-swarm 0.1.0

package/dist/orchestrator-supervisor.js

@@ -0,0 +1,399 @@
+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";
+function parseNumericStepId(stepId) {
+    const numeric = Number(stepId.replace(/^step-/, ""));
+    return Number.isFinite(numeric) && numeric > 0 ? numeric : 0;
+}
+function cloneSteps(steps) {
+    return steps.map((step) => ({ ...step }));
+}
+function nextStepId(steps) {
+    const max = steps.reduce((best, step) => Math.max(best, parseNumericStepId(step.step_id)), 0);
+    return `step-${max + 1}`;
+}
+function appendNewSteps(steps, additions) {
+    const next = [...steps];
+    for (const addition of additions) {
+        next.push({
+            ...addition,
+            step_id: nextStepId(next),
+            status: "planned",
+        });
+    }
+    return next;
+}
+function deriveStepEvidence(result) {
+    return Array.from(new Set(result.tool_calls.map((tool) => tool.tool)));
+}
+function isTaskPlan(value) {
+    return Boolean(value) && typeof value === "object" && Array.isArray(value.steps);
+}
+function extractVcxCursor(payload) {
+    if (!payload || typeof payload !== "object")
+        return undefined;
+    const candidate = payload;
+    const direct = candidate.vcx_cursor ?? candidate.cursor ?? candidate.next_cursor;
+    if (typeof direct === "string" && direct.trim()) {
+        return direct.trim();
+    }
+    const liveSignal = candidate.live_signal;
+    if (liveSignal && typeof liveSignal === "object") {
+        const nested = liveSignal.vcx_cursor;
+        if (typeof nested === "string" && nested.trim()) {
+            return nested.trim();
+        }
+    }
+    return undefined;
+}
+export function deriveTaskPlanStatus(plan) {
+    if (plan.steps.some((step) => step.status === "failed")) {
+        return "failed";
+    }
+    if (plan.steps.some((step) => step.status === "blocked")) {
+        return "blocked";
+    }
+    if (plan.steps.length > 0 && plan.steps.every((step) => step.status === "done" || step.status === "skipped")) {
+        return "done";
+    }
+    if (plan.steps.some((step) => step.status === "running")) {
+        return "executing";
+    }
+    if (plan.steps.every((step) => step.status === "planned")) {
+        return "planning";
+    }
+    if (plan.steps.some((step) => step.status === "done")) {
+        return "reviewing";
+    }
+    return plan.status;
+}
+function withDerivedStatus(plan) {
+    return {
+        ...plan,
+        steps: cloneSteps(plan.steps),
+        status: deriveTaskPlanStatus(plan),
+    };
+}
+export function createTaskPlan(input) {
+    return withDerivedStatus({
+        plan_id: `plan-${randomUUID()}`,
+        task: input.task,
+        steps: input.steps.map((step, index) => ({
+            ...step,
+            step_id: `step-${index + 1}`,
+            status: "planned",
+        })),
+        status: "planning",
+        execution_mode: input.execution_mode ?? "sequential",
+        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,
+        steps: plan.steps.map((step) => step.step_id === stepId
+            ? {
+                ...step,
+                ...patch,
+                status,
+            }
+            : step),
+    });
+}
+export function applyBridgeResultToStep(plan, stepId, result) {
+    const nextStatus = result.status === "completed"
+        ? "done"
+        : result.status === "needs_input" || result.status === "max_turns"
+            ? "blocked"
+            : "failed";
+    return withDerivedStatus({
+        ...plan,
+        steps: plan.steps.map((step) => step.step_id === stepId
+            ? {
+                ...step,
+                status: nextStatus,
+                result_summary: result.summary,
+                evidence_refs: deriveStepEvidence(result),
+                blocked_reason: nextStatus === "blocked" ? result.summary : undefined,
+            }
+            : step),
+    });
+}
+export function amendTaskPlan(plan, amendment) {
+    let steps = cloneSteps(plan.steps);
+    if (Array.isArray(amendment.remove_step_ids) && amendment.remove_step_ids.length > 0) {
+        const removeSet = new Set(amendment.remove_step_ids);
+        steps = steps.filter((step) => !removeSet.has(step.step_id));
+    }
+    if (Array.isArray(amendment.update_steps)) {
+        for (const update of amendment.update_steps) {
+            steps = steps.map((step) => step.step_id === update.step_id
+                ? {
+                    ...step,
+                    ...update.patch,
+                }
+                : step);
+        }
+    }
+    if (Array.isArray(amendment.prepend_steps) && amendment.prepend_steps.length > 0) {
+        const prepended = [];
+        for (const addition of amendment.prepend_steps) {
+            prepended.push({
+                ...addition,
+                step_id: nextStepId([...prepended, ...steps]),
+                status: "planned",
+            });
+        }
+        steps = [...prepended, ...steps];
+    }
+    if (Array.isArray(amendment.steps_to_add) && amendment.steps_to_add.length > 0) {
+        if (amendment.add_after_step_id) {
+            const insertionIndex = steps.findIndex((step) => step.step_id === amendment.add_after_step_id);
+            const injected = [];
+            for (const addition of amendment.steps_to_add) {
+                injected.push({
+                    ...addition,
+                    step_id: nextStepId([...steps, ...injected]),
+                    status: "planned",
+                });
+            }
+            if (insertionIndex >= 0) {
+                steps = [
+                    ...steps.slice(0, insertionIndex + 1),
+                    ...injected,
+                    ...steps.slice(insertionIndex + 1),
+                ];
+            }
+            else {
+                steps = [...steps, ...injected];
+            }
+        }
+        else {
+            steps = appendNewSteps(steps, amendment.steps_to_add);
+        }
+    }
+    if (Array.isArray(amendment.append_steps) && amendment.append_steps.length > 0) {
+        steps = appendNewSteps(steps, amendment.append_steps);
+    }
+    if (Array.isArray(amendment.reorder_step_ids) && amendment.reorder_step_ids.length > 0) {
+        const order = new Map(amendment.reorder_step_ids.map((stepId, index) => [stepId, index]));
+        steps = steps
+            .slice()
+            .sort((left, right) => {
+            const leftRank = order.get(left.step_id);
+            const rightRank = order.get(right.step_id);
+            if (leftRank === undefined && rightRank === undefined) {
+                return parseNumericStepId(left.step_id) - parseNumericStepId(right.step_id);
+            }
+            if (leftRank === undefined)
+                return 1;
+            if (rightRank === undefined)
+                return -1;
+            return leftRank - rightRank;
+        });
+    }
+    return withDerivedStatus({
+        ...plan,
+        steps,
+        execution_mode: amendment.execution_mode ?? plan.execution_mode,
+        vcx_cursor: amendment.vcx_cursor ?? plan.vcx_cursor,
+    });
+}
+export async function promoteParallelGroupToScheduler(plan, parallelGroup, owner = "capability-ops") {
+    const readySteps = getReadyTaskSteps(plan).filter((step) => step.parallel_group === parallelGroup);
+    if (readySteps.length === 0) {
+        return { plan, job_ids: [] };
+    }
+    if (!existsSync(dirname(getJobQueuePath()))) {
+        console.warn(`[orchestrator-supervisor] Scheduler state is not ready under ${dirname(getJobQueuePath())}; skipping promotion for parallel group '${parallelGroup}'.`);
+        return { plan, job_ids: [] };
+    }
+    const jobIds = [];
+    const nextSteps = cloneSteps(plan.steps);
+    for (const step of readySteps) {
+        const enqueued = await enqueueJob({
+            kind: step.role,
+            payload: {
+                task: step.task,
+                tool_scope: step.tool_scope ?? [],
+                plan_id: plan.plan_id,
+                step_id: step.step_id,
+            },
+            priority: "P1",
+            dependencies: step.depends_on?.map((dependency) => ({
+                kind: "handoff",
+                ref: dependency,
+            })) ?? [],
+        });
+        const jobId = enqueued.ack?.job_id;
+        if (!jobId)
+            continue;
+        jobIds.push(jobId);
+        const stepIndex = nextSteps.findIndex((candidate) => candidate.step_id === step.step_id);
+        if (stepIndex >= 0) {
+            nextSteps[stepIndex] = {
+                ...nextSteps[stepIndex],
+                status: "running",
+                job_id: jobId,
+            };
+        }
+    }
+    if (jobIds.length > 0) {
+        const refs = deriveWorkspaceVericifyRunRef({
+            session_id: plan.plan_id,
+            role: "orchestrator",
+        });
+        await dispatchJobs({ owner });
+        await appendVericifyProcessPostSafe({
+            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(", ")}`,
+            tool_refs: ["enqueue_job", "dispatch_jobs"],
+            evidence_refs: jobIds,
+        });
+    }
+    return {
+        plan: withDerivedStatus({
+            ...plan,
+            execution_mode: "scheduled",
+            steps: nextSteps,
+            status: "executing",
+        }),
+        job_ids: jobIds,
+    };
+}
+export async function superviseTaskPlan(inputPlan, hooks) {
+    let plan = withDerivedStatus({
+        ...inputPlan,
+        steps: cloneSteps(inputPlan.steps),
+    });
+    const handoffIds = [];
+    const jobIds = [];
+    if (!plan.vcx_cursor && hooks.getVericifyContext) {
+        const contextPacket = await hooks.getVericifyContext(plan);
+        const vcxCursor = extractVcxCursor(contextPacket);
+        if (vcxCursor) {
+            plan = {
+                ...plan,
+                vcx_cursor: vcxCursor,
+            };
+        }
+    }
+    const maxIterations = Math.max(1, plan.steps.length * 4);
+    for (let iteration = 0; iteration < maxIterations; iteration += 1) {
+        const readySteps = getReadyTaskSteps(plan);
+        if (readySteps.length === 0) {
+            break;
+        }
+        if (plan.execution_mode === "scheduled") {
+            const readyGroup = readySteps.find((step) => step.parallel_group)?.parallel_group;
+            if (readyGroup) {
+                const promoted = await promoteParallelGroupToScheduler(plan, readyGroup);
+                jobIds.push(...promoted.job_ids);
+                plan = promoted.plan;
+                break;
+            }
+        }
+        const currentStep = readySteps[0];
+        plan = markTaskStepStatus(plan, currentStep.step_id, "running");
+        await hooks.emitStatusEvent?.({
+            status: "in_progress",
+            summary: `Running ${currentStep.step_id}: ${currentStep.task}`,
+            step_id: currentStep.step_id,
+        });
+        let handoffId;
+        if (hooks.createHandoff) {
+            const created = await hooks.createHandoff({ step: currentStep, plan });
+            handoffId = created.handoff_id;
+            handoffIds.push(handoffId);
+            plan = amendTaskPlan(plan, {
+                update_steps: [{ step_id: currentStep.step_id, patch: { handoff_id: handoffId } }],
+            });
+            await hooks.ackHandoff?.(handoffId, "accepted", `Started ${currentStep.step_id}`);
+        }
+        const result = await hooks.spawnStep(currentStep, plan);
+        plan = applyBridgeResultToStep(plan, currentStep.step_id, result);
+        if (handoffId) {
+            await hooks.ackHandoff?.(handoffId, result.status === "completed" ? "completed" : "blocked", result.summary);
+        }
+        let vericifyDelta;
+        if (plan.vcx_cursor && hooks.getVericifyDelta) {
+            vericifyDelta = await hooks.getVericifyDelta(plan.vcx_cursor, {
+                plan,
+                step: currentStep,
+                result,
+            });
+            const nextCursor = extractVcxCursor(vericifyDelta);
+            if (nextCursor) {
+                plan = {
+                    ...plan,
+                    vcx_cursor: nextCursor,
+                };
+            }
+        }
+        const amended = await hooks.amendPlan?.({
+            plan,
+            step: plan.steps.find((step) => step.step_id === currentStep.step_id) ?? currentStep,
+            result,
+            vericify_delta: vericifyDelta,
+        });
+        if (amended) {
+            plan = isTaskPlan(amended) ? withDerivedStatus(amended) : amendTaskPlan(plan, amended);
+        }
+        if (result.status === "failed" || result.status === "needs_input" || result.status === "max_turns") {
+            await hooks.openCircuitBreaker?.(result.summary, {
+                plan,
+                step: plan.steps.find((step) => step.step_id === currentStep.step_id) ?? currentStep,
+                result,
+            });
+            return {
+                plan: withDerivedStatus(plan),
+                handoff_ids: handoffIds,
+                job_ids: jobIds,
+                circuit_opened: true,
+            };
+        }
+    }
+    if (plan.steps.length > 0 && plan.steps.every((step) => step.status === "done" || step.status === "skipped")) {
+        const finalGate = await hooks.executeGates?.(plan);
+        await hooks.contextSnapshot?.(plan);
+        await hooks.emitStatusEvent?.({
+            status: "done",
+            summary: `Task plan ${plan.plan_id} completed`,
+        });
+        await hooks.closeCircuitBreaker?.("Task plan completed.", { plan });
+        return {
+            plan: {
+                ...plan,
+                status: "done",
+            },
+            handoff_ids: handoffIds,
+            job_ids: jobIds,
+            circuit_opened: false,
+            final_gate: finalGate,
+        };
+    }
+    return {
+        plan: withDerivedStatus(plan),
+        handoff_ids: handoffIds,
+        job_ids: jobIds,
+        circuit_opened: false,
+    };
+}
+//# sourceMappingURL=orchestrator-supervisor.js.map

package/dist/problem-triage.d.ts

@@ -0,0 +1,23 @@
+import { type SkillCatalogEntry, type SkillCatalogSummary } from "./skill-catalog.js";
+export type ProblemRoute = "existing_skill_fit" | "existing_skill_needs_patch" | "new_skill_warranted" | "missing_tool_or_permission" | "one_off_task";
+export interface SkillMatch {
+    name: string;
+    source: SkillCatalogEntry["source"];
+    score: number;
+    reasons: string[];
+}
+export interface ProblemTriageResult {
+    request: string;
+    route: ProblemRoute;
+    confidence: number;
+    rationale: string[];
+    skill_matches: SkillMatch[];
+    missing_requirements: string[];
+    suggested_next_steps: string[];
+    proposed_skill_name?: string;
+    catalog_summary: SkillCatalogSummary;
+}
+export declare function triageProblemRequest(request: string, entries?: SkillCatalogEntry[]): ProblemTriageResult;
+export declare function renderProblemTriageReport(result: ProblemTriageResult): string;
+export declare function writeProblemTriageReport(result: ProblemTriageResult, targetPath?: string): string;
+//# sourceMappingURL=problem-triage.d.ts.map