@voybio/ace-swarm 0.1.0

package/dist/model-bridge.js

@@ -0,0 +1,587 @@
+import { randomUUID } from "node:crypto";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { executeAceInternalTool, listAceInternalToolCatalog, } from "./ace-internal-tools.js";
+import { appendVericifyProcessPostSafe, deriveWorkspaceVericifyRunRef, } from "./vericify-bridge.js";
+import { buildToolPlan, renderAceContext } from "./ace-context.js";
+function resolveProviderClient(input) {
+    const display = input.trim() || "ollama";
+    const normalized = display.toLowerCase();
+    return normalized === "ollama"
+        ? { display, client: "ollama" }
+        : { display, client: "openai-compatible" };
+}
+function extractJsonEnvelope(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+        return trimmed;
+    }
+    const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    if (fenced?.[1]) {
+        return fenced[1].trim();
+    }
+    const firstBrace = trimmed.indexOf("{");
+    if (firstBrace < 0) {
+        return trimmed;
+    }
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    for (let index = firstBrace; index < trimmed.length; index += 1) {
+        const ch = trimmed[index];
+        if (escape) {
+            escape = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escape = true;
+            continue;
+        }
+        if (ch === '"') {
+            inString = !inString;
+            continue;
+        }
+        if (inString)
+            continue;
+        if (ch === "{")
+            depth += 1;
+        if (ch === "}") {
+            depth -= 1;
+            if (depth === 0) {
+                return trimmed.slice(firstBrace, index + 1);
+            }
+        }
+    }
+    return trimmed;
+}
+function parseEnvelope(raw) {
+    const candidate = extractJsonEnvelope(raw);
+    try {
+        const parsed = JSON.parse(candidate);
+        if (!parsed || typeof parsed !== "object") {
+            throw new Error("response is not an object");
+        }
+        if (!parsed.status) {
+            throw new Error("missing status");
+        }
+        return parsed;
+    }
+    catch {
+        return {
+            status: "message",
+            message: raw.trim(),
+        };
+    }
+}
+function parseToolPlan(raw, catalog) {
+    const candidate = extractJsonEnvelope(raw);
+    const allowedTools = new Set(catalog.map((tool) => tool.name));
+    try {
+        const parsed = JSON.parse(candidate);
+        const selectedSource = parsed.selected_tools ?? parsed.tool_scope ?? parsed.tools;
+        const selected = Array.isArray(selectedSource)
+            ? selectedSource
+                .filter((entry) => typeof entry === "string")
+                .map((entry) => entry.trim())
+                .filter((entry) => entry.length > 0 && allowedTools.has(entry))
+            : [];
+        return {
+            selected_tools: Array.from(new Set(selected)),
+            reasoning: typeof parsed.reasoning === "string" ? parsed.reasoning.trim() : undefined,
+        };
+    }
+    catch {
+        return { selected_tools: [] };
+    }
+}
+function summarizeToolText(result) {
+    if (!result || typeof result !== "object")
+        return "Tool returned no structured result.";
+    const textParts = Array.isArray(result.content)
+        ? result.content
+            .filter((entry) => Boolean(entry) && typeof entry === "object" && entry.type === "text")
+            .map((entry) => String(entry.text ?? "").trim())
+            .filter(Boolean)
+        : [];
+    if (textParts.length > 0) {
+        return textParts.join("\n");
+    }
+    return String(result.summary ?? "Tool completed.");
+}
+function estimateTokenCount(text) {
+    return Math.max(1, Math.ceil(text.length / 4));
+}
+function messageText(message) {
+    return typeof message.content === "string" ? message.content : "";
+}
+function estimateMessageTokens(messages) {
+    return messages.reduce((total, message) => total + estimateTokenCount(`${message.role}: ${messageText(message)}`), 0);
+}
+function calculateContextBudget(numCtx) {
+    const reserve = Math.max(256, Math.min(2048, Math.floor(numCtx * 0.25)));
+    return Math.max(384, numCtx - reserve);
+}
+function summarizeSnippet(text, maxChars = 240) {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    if (normalized.length <= maxChars)
+        return normalized;
+    return `${normalized.slice(0, Math.max(0, maxChars - 1)).trimEnd()}…`;
+}
+function buildHistorySummary(messages, maxChars) {
+    const lines = messages.slice(-8).map((message) => {
+        const content = summarizeSnippet(messageText(message).replace(/^Conversation summary:\s*/i, ""), 220);
+        return `- ${message.role}: ${content || "[empty]"}`;
+    });
+    const summary = [
+        "Conversation summary:",
+        ...lines,
+        "Use the recent turns below as the source of truth for the next action.",
+    ].join("\n");
+    if (summary.length <= maxChars)
+        return summary;
+    return `${summary.slice(0, Math.max(0, maxChars - 1)).trimEnd()}…`;
+}
+function compressConversationHistory(messages, numCtx) {
+    const promptTokens = estimateMessageTokens(messages);
+    const budget = calculateContextBudget(numCtx);
+    if (promptTokens <= budget || messages.length <= 3) {
+        return { messages, promptTokens, compressed: false };
+    }
+    const systemMessage = messages[0];
+    if (!systemMessage) {
+        return { messages, promptTokens, compressed: false };
+    }
+    let recentMessages = messages.slice(-2);
+    const olderMessages = messages.slice(1, -recentMessages.length);
+    if (olderMessages.length === 0) {
+        return { messages, promptTokens, compressed: false };
+    }
+    let summaryChars = Math.max(320, Math.min(1400, Math.floor((budget * 4) * 0.35)));
+    let summaryMessage = {
+        role: "system",
+        content: buildHistorySummary(olderMessages, summaryChars),
+    };
+    let compressed = [systemMessage, summaryMessage, ...recentMessages];
+    while (estimateMessageTokens(compressed) > budget && summaryChars > 240) {
+        summaryChars = Math.max(240, Math.floor(summaryChars * 0.75));
+        summaryMessage = {
+            role: "system",
+            content: buildHistorySummary(olderMessages, summaryChars),
+        };
+        compressed = [systemMessage, summaryMessage, ...recentMessages];
+        if (estimateMessageTokens(compressed) <= budget)
+            break;
+        if (recentMessages.length > 2) {
+            recentMessages = recentMessages.slice(-2);
+            compressed = [systemMessage, summaryMessage, ...recentMessages];
+        }
+    }
+    return {
+        messages: compressed,
+        promptTokens: estimateMessageTokens(compressed),
+        compressed: true,
+    };
+}
+function buildTierFallbackOrder(tier) {
+    if (tier === "full")
+        return ["full", "compressed", "brief"];
+    if (tier === "compressed")
+        return ["compressed", "brief"];
+    return ["brief"];
+}
+function sanitizeToolName(tool) {
+    const normalized = tool.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-");
+    return normalized.length > 0 ? normalized.slice(0, 48) : "tool";
+}
+function truncateToolResult(result, workspace, maxChars = 3000) {
+    if (result.summary.length <= maxChars) {
+        return result;
+    }
+    const relativePath = `agent-state/bridge-results/${sanitizeToolName(result.tool)}-${Date.now()}.txt`;
+    const absolutePath = resolve(workspace, relativePath);
+    mkdirSync(dirname(absolutePath), { recursive: true });
+    writeFileSync(absolutePath, result.summary, "utf-8");
+    return {
+        ...result,
+        summary: `${result.summary.slice(0, maxChars).trimEnd()}\n[truncated — full output: ${relativePath}]`,
+    };
+}
+function formatErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isRetryableProviderError(error) {
+    const message = formatErrorMessage(error).toLowerCase();
+    return !/(abort|aborted|cancelled|canceled|interrupted)/.test(message);
+}
+function formatToolFeedback(results) {
+    return [
+        "Tool execution results:",
+        ...results.map((result) => `- ${result.tool}: ${result.ok ? "ok" : "error"} — ${result.summary}`),
+        "Continue with another JSON response.",
+    ].join("\n");
+}
+async function collectOllamaResponse(client, model, messages, options) {
+    let combined = "";
+    for await (const chunk of client.chat({
+        model,
+        messages,
+        stream: true,
+        options: {
+            temperature: 0.2,
+            top_p: 0.9,
+            num_ctx: options?.num_ctx ?? 8192,
+        },
+    })) {
+        combined += chunk.message?.content ?? "";
+        if (chunk.done)
+            break;
+    }
+    return combined;
+}
+async function collectOpenAiCompatibleResponse(client, provider, model, messages) {
+    let combined = "";
+    for await (const chunk of client.chat({
+        provider,
+        model,
+        messages,
+        temperature: 0.2,
+        topP: 0.9,
+    })) {
+        combined += chunk.text;
+        if (chunk.done)
+            break;
+    }
+    return combined;
+}
+async function collectProviderResponse(clients, provider, options) {
+    return provider.client === "ollama"
+        ? collectOllamaResponse(clients.ollama, options.model, options.messages, {
+            num_ctx: options.numCtx,
+        })
+        : collectOpenAiCompatibleResponse(clients.openai, provider.display, options.model, options.messages);
+}
+async function collectProviderResponseWithRetry(clients, provider, options, onThinking) {
+    try {
+        return await collectProviderResponse(clients, provider, options);
+    }
+    catch (error) {
+        if (!isRetryableProviderError(error)) {
+            throw error;
+        }
+        onThinking?.(`Provider error, retrying once: ${formatErrorMessage(error)}`);
+        return collectProviderResponse(clients, provider, options);
+    }
+}
+export class ModelBridge {
+    clients;
+    activeProviderClient = null;
+    bridgeId = randomUUID();
+    currentRunChildResults = null;
+    constructor(clients) {
+        this.clients = clients;
+    }
+    interrupt() {
+        if (this.activeProviderClient === "ollama") {
+            this.clients.ollama.abort();
+        }
+        else if (this.activeProviderClient) {
+            this.clients.openai.abort();
+        }
+        this.activeProviderClient = null;
+    }
+    async spawn(options) {
+        const refs = deriveWorkspaceVericifyRunRef({
+            session_id: this.bridgeId,
+            role: options.role,
+        });
+        await appendVericifyProcessPostSafe({
+            run_id: refs.run_id,
+            branch_id: refs.branch_id,
+            lane_id: refs.lane_id,
+            agent_id: `agent-${options.role}`,
+            kind: "handoff_note",
+            summary: `Spawned child bridge for ${options.role}: ${options.task}`,
+            tool_refs: [],
+        });
+        const child = new ModelBridge(this.clients);
+        const result = await child.run({
+            ...options,
+            parentBridge: this.bridgeId,
+        });
+        if (this.currentRunChildResults) {
+            this.currentRunChildResults.push(result);
+        }
+        return result;
+    }
+    async selectToolScope(input) {
+        const plan = buildToolPlan({
+            task: input.task,
+            role: input.role,
+            workspace: "",
+            tier: input.tier,
+        });
+        if (plan.catalog.length === 0)
+            return undefined;
+        const selectionMessages = [
+            { role: "system", content: plan.prompt },
+            { role: "user", content: input.task },
+        ];
+        try {
+            this.activeProviderClient = input.provider.client;
+            const rawSelection = await collectProviderResponse(this.clients, input.provider, {
+                model: input.model,
+                messages: selectionMessages,
+                numCtx: Math.min(input.numCtx, 8192),
+            });
+            const parsed = parseToolPlan(rawSelection, plan.catalog);
+            const scoped = parsed.selected_tools.slice(0, plan.selection_limit);
+            if (scoped.length === 0)
+                return undefined;
+            const thinking = parsed.reasoning?.trim();
+            input.onThinking?.(thinking
+                ? `Tool plan: ${scoped.join(", ")}. ${thinking}`
+                : `Tool plan: ${scoped.join(", ")}`);
+            return scoped;
+        }
+        finally {
+            this.activeProviderClient = null;
+        }
+    }
+    async run(options) {
+        const role = options.role.trim().toLowerCase().replace(/^agent-/, "");
+        const requestedTier = options.tier ?? "compressed";
+        const provider = resolveProviderClient(options.provider);
+        const numCtx = options.numCtx ??
+            (requestedTier === "brief" ? 4096 : requestedTier === "compressed" ? 8192 : 16384);
+        const explicitToolScope = options.toolScope?.map((tool) => tool.trim()).filter((tool) => tool.length > 0) ?? [];
+        const toolScopeLocked = explicitToolScope.length > 0;
+        const selectedToolScope = explicitToolScope.length > 0
+            ? explicitToolScope
+            : await this.selectToolScope({
+                task: options.task,
+                role,
+                tier: requestedTier,
+                model: options.model,
+                numCtx,
+                provider,
+                onThinking: options.onThinking,
+            });
+        let aceContext = renderAceContext({
+            task: options.task,
+            role,
+            workspace: options.workspace,
+            tier: requestedTier,
+            tools: selectedToolScope,
+        });
+        const promptBudget = calculateContextBudget(numCtx);
+        for (const candidateTier of buildTierFallbackOrder(requestedTier)) {
+            const candidateContext = renderAceContext({
+                task: options.task,
+                role,
+                workspace: options.workspace,
+                tier: candidateTier,
+                tools: selectedToolScope,
+            });
+            aceContext = candidateContext;
+            if (candidateContext.tokenEstimate <= promptBudget || candidateTier === "brief") {
+                break;
+            }
+        }
+        if (aceContext.tier !== requestedTier) {
+            options.onThinking?.(`Context tier fallback: ${requestedTier} -> ${aceContext.tier} (budget ~${promptBudget} tokens)`);
+        }
+        const messages = [
+            { role: "system", content: aceContext.systemPrompt },
+            { role: "user", content: options.task },
+        ];
+        const toolResults = [];
+        const childResults = [];
+        const sessionId = this.bridgeId;
+        const refs = deriveWorkspaceVericifyRunRef({
+            session_id: this.bridgeId,
+            role,
+        });
+        const availableTools = new Set(listAceInternalToolCatalog().map((tool) => tool.name));
+        const allowedTools = new Set(aceContext.tools.map((tool) => tool.name));
+        this.currentRunChildResults = childResults;
+        try {
+            await appendVericifyProcessPostSafe({
+                run_id: refs.run_id,
+                branch_id: refs.branch_id,
+                lane_id: refs.lane_id,
+                agent_id: `agent-${role}`,
+                kind: "intent",
+                summary: `Bridge started for ${role} via ${provider.display}: ${options.task}`,
+                tool_refs: aceContext.tools.map((tool) => tool.name),
+            });
+            for (let turn = 1; turn <= options.maxTurns; turn += 1) {
+                const compressed = compressConversationHistory(messages, numCtx);
+                if (compressed.compressed) {
+                    messages.splice(0, messages.length, ...compressed.messages);
+                    options.onThinking?.(`Context window compressed to ~${compressed.promptTokens} tokens.`);
+                }
+                this.activeProviderClient = provider.client;
+                const rawResponse = await collectProviderResponseWithRetry(this.clients, provider, {
+                    model: options.model,
+                    messages,
+                    numCtx,
+                }, options.onThinking);
+                this.activeProviderClient = null;
+                const envelope = parseEnvelope(rawResponse);
+                if (envelope.thinking) {
+                    options.onThinking?.(envelope.thinking);
+                }
+                messages.push({ role: "assistant", content: rawResponse });
+                if (envelope.status === "tool" &&
+                    Array.isArray(envelope.tool_calls) &&
+                    envelope.tool_calls.length > 0) {
+                    const requestedOutsideScope = envelope.tool_calls.filter((toolCall) => !allowedTools.has(toolCall.tool));
+                    const amendedTools = [];
+                    if (requestedOutsideScope.length > 0 && !toolScopeLocked) {
+                        for (const toolCall of requestedOutsideScope) {
+                            if (availableTools.has(toolCall.tool) && !allowedTools.has(toolCall.tool)) {
+                                allowedTools.add(toolCall.tool);
+                                amendedTools.push(toolCall.tool);
+                            }
+                        }
+                        if (amendedTools.length > 0) {
+                            options.onThinking?.(`Tool scope amended: ${amendedTools.join(", ")}`);
+                        }
+                    }
+                    const blockedToolCalls = envelope.tool_calls.filter((toolCall) => !allowedTools.has(toolCall.tool));
+                    if (blockedToolCalls.length > 0) {
+                        const blockedResults = blockedToolCalls.map((toolCall) => {
+                            const result = {
+                                tool: toolCall.tool,
+                                ok: false,
+                                isError: true,
+                                summary: toolScopeLocked
+                                    ? `Tool '${toolCall.tool}' is outside the locked scope.`
+                                    : `Tool '${toolCall.tool}' is not available in the active ACE catalog.`,
+                            };
+                            options.onToolResult?.(toolCall.tool, result);
+                            toolResults.push(result);
+                            return result;
+                        });
+                        messages.push({
+                            role: "user",
+                            content: formatToolFeedback(blockedResults),
+                        });
+                        continue;
+                    }
+                    const executed = await Promise.all(envelope.tool_calls.map(async (toolCall) => {
+                        const args = toolCall.input ?? {};
+                        options.onToolCall?.(toolCall.tool, args);
+                        const rawToolResult = await executeAceInternalTool(toolCall.tool, args, sessionId);
+                        const result = truncateToolResult({
+                            tool: toolCall.tool,
+                            ok: !Boolean(rawToolResult?.isError),
+                            isError: Boolean(rawToolResult?.isError),
+                            summary: summarizeToolText(rawToolResult),
+                        }, options.workspace);
+                        options.onToolResult?.(toolCall.tool, result);
+                        toolResults.push(result);
+                        return result;
+                    }));
+                    messages.push({
+                        role: "user",
+                        content: amendedTools.length > 0
+                            ? `Tool scope amended to include: ${amendedTools.join(", ")}.\n${formatToolFeedback(executed)}`
+                            : formatToolFeedback(executed),
+                    });
+                    continue;
+                }
+                if (envelope.status === "message") {
+                    const message = envelope.message?.trim() || rawResponse.trim();
+                    options.onOutput?.(message);
+                    await appendVericifyProcessPostSafe({
+                        run_id: refs.run_id,
+                        branch_id: refs.branch_id,
+                        lane_id: refs.lane_id,
+                        agent_id: `agent-${role}`,
+                        kind: "progress",
+                        summary: message,
+                        tool_refs: [],
+                    });
+                    return {
+                        bridge_id: this.bridgeId,
+                        role,
+                        status: "completed",
+                        summary: message,
+                        turns: turn,
+                        tool_calls: toolResults,
+                        child_results: childResults,
+                    };
+                }
+                if (envelope.status === "need_input") {
+                    const message = envelope.message?.trim() || "Additional operator input required.";
+                    options.onOutput?.(message);
+                    await appendVericifyProcessPostSafe({
+                        run_id: refs.run_id,
+                        branch_id: refs.branch_id,
+                        lane_id: refs.lane_id,
+                        agent_id: `agent-${role}`,
+                        kind: "blocker",
+                        summary: message,
+                        tool_refs: [],
+                    });
+                    return {
+                        bridge_id: this.bridgeId,
+                        role,
+                        status: "needs_input",
+                        summary: message,
+                        turns: turn,
+                        tool_calls: toolResults,
+                        child_results: childResults,
+                    };
+                }
+                if (envelope.status === "complete") {
+                    const summary = envelope.summary?.trim() || "Bridge completed.";
+                    options.onOutput?.(summary);
+                    await appendVericifyProcessPostSafe({
+                        run_id: refs.run_id,
+                        branch_id: refs.branch_id,
+                        lane_id: refs.lane_id,
+                        agent_id: `agent-${role}`,
+                        kind: "completion",
+                        summary,
+                        tool_refs: toolResults.map((entry) => entry.tool),
+                    });
+                    return {
+                        bridge_id: this.bridgeId,
+                        role,
+                        status: "completed",
+                        summary,
+                        turns: turn,
+                        tool_calls: toolResults,
+                        child_results: childResults,
+                    };
+                }
+            }
+            const summary = "Bridge stopped after reaching max turns.";
+            await appendVericifyProcessPostSafe({
+                run_id: refs.run_id,
+                branch_id: refs.branch_id,
+                lane_id: refs.lane_id,
+                agent_id: `agent-${role}`,
+                kind: "blocker",
+                summary,
+                tool_refs: toolResults.map((entry) => entry.tool),
+            });
+            return {
+                bridge_id: this.bridgeId,
+                role,
+                status: "max_turns",
+                summary,
+                turns: options.maxTurns,
+                tool_calls: toolResults,
+                child_results: childResults,
+            };
+        }
+        finally {
+            this.activeProviderClient = null;
+            this.currentRunChildResults = null;
+        }
+    }
+}
+//# sourceMappingURL=model-bridge.js.map

package/dist/orchestrator-supervisor.d.ts

@@ -0,0 +1,100 @@
+import type { BridgeResult } from "./model-bridge.js";
+export type TaskStepStatus = "planned" | "running" | "done" | "failed" | "skipped" | "blocked";
+export type TaskPlanStatus = "planning" | "executing" | "reviewing" | "blocked" | "done" | "failed";
+export interface TaskStep {
+    step_id: string;
+    role: string;
+    task: string;
+    depends_on?: string[];
+    parallel_group?: string;
+    status: TaskStepStatus;
+    result_summary?: string;
+    evidence_refs?: string[];
+    tool_scope?: string[];
+    job_id?: string;
+    handoff_id?: string;
+    blocked_reason?: string;
+}
+export interface TaskPlan {
+    plan_id: string;
+    task: string;
+    steps: TaskStep[];
+    status: TaskPlanStatus;
+    execution_mode: "sequential" | "scheduled";
+    vcx_cursor?: string;
+}
+export interface TaskPlanAmendment {
+    steps_to_add?: Array<Omit<TaskStep, "step_id" | "status">>;
+    add_after_step_id?: string;
+    append_steps?: Array<Omit<TaskStep, "step_id" | "status">>;
+    prepend_steps?: Array<Omit<TaskStep, "step_id" | "status">>;
+    remove_step_ids?: string[];
+    update_steps?: Array<{
+        step_id: string;
+        patch: Partial<Omit<TaskStep, "step_id">>;
+    }>;
+    reorder_step_ids?: string[];
+    execution_mode?: TaskPlan["execution_mode"];
+    vcx_cursor?: string;
+}
+export interface SupervisorHooks {
+    spawnStep: (step: TaskStep, plan: TaskPlan) => Promise<BridgeResult>;
+    createHandoff?: (input: {
+        step: TaskStep;
+        plan: TaskPlan;
+    }) => Promise<{
+        handoff_id: string;
+    }>;
+    ackHandoff?: (handoffId: string, status: "accepted" | "blocked" | "completed", note?: string) => Promise<void>;
+    getVericifyContext?: (plan: TaskPlan) => Promise<unknown>;
+    getVericifyDelta?: (since: string, context: {
+        plan: TaskPlan;
+        step: TaskStep;
+        result: BridgeResult;
+    }) => Promise<unknown>;
+    amendPlan?: (input: {
+        plan: TaskPlan;
+        step: TaskStep;
+        result: BridgeResult;
+        vericify_delta?: unknown;
+    }) => Promise<TaskPlan | TaskPlanAmendment | undefined> | TaskPlan | TaskPlanAmendment | undefined;
+    openCircuitBreaker?: (reason: string, context: {
+        plan: TaskPlan;
+        step: TaskStep;
+        result: BridgeResult;
+    }) => Promise<void>;
+    closeCircuitBreaker?: (reason: string, context: {
+        plan: TaskPlan;
+    }) => Promise<void>;
+    executeGates?: (plan: TaskPlan) => Promise<unknown>;
+    contextSnapshot?: (plan: TaskPlan) => Promise<void>;
+    emitStatusEvent?: (input: {
+        status: string;
+        summary: string;
+        step_id?: string;
+    }) => Promise<void>;
+}
+export interface SupervisorRunResult {
+    plan: TaskPlan;
+    handoff_ids: string[];
+    job_ids: string[];
+    circuit_opened: boolean;
+    final_gate?: unknown;
+}
+export declare function deriveTaskPlanStatus(plan: TaskPlan): TaskPlanStatus;
+export declare function createTaskPlan(input: {
+    task: string;
+    steps: Array<Omit<TaskStep, "step_id" | "status">>;
+    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 promoteParallelGroupToScheduler(plan: TaskPlan, parallelGroup: string, owner?: string): Promise<{
+    plan: TaskPlan;
+    job_ids: string[];
+}>;
+export declare function superviseTaskPlan(inputPlan: TaskPlan, hooks: SupervisorHooks): Promise<SupervisorRunResult>;
+//# sourceMappingURL=orchestrator-supervisor.d.ts.map