ace-swarm 2.2.0 → 2.3.0

package/dist/tools-agent.js

@@ -11,6 +11,11 @@ import { getTrackerAdapter, listTrackerAdapterKinds, loadTrackerSnapshot, valida
 import { refreshTrackerSnapshot } from "./tracker-sync.js";
 import { appendVericifyProcessPost, loadVericifyBridgeSnapshot, loadVericifyProcessPostLog, refreshVericifyBridgeSnapshot, validateVericifyBridgeSnapshotContent, validateVericifyProcessPostLogContent, } from "./vericify-bridge.js";
 import { getRoleTitle, ROLE_ENUM, KERNEL_KEY_ENUM, ROLE_TITLES } from "./shared.js";
+import { createDefaultModelBridgeClients, resolveLocalModelRuntime, runLocalModelTask, } from "./local-model-runtime.js";
+import { executeAceInternalTool } from "./ace-internal-tools.js";
+import { ModelBridge } from "./model-bridge.js";
+import { getVericifyContextPacket, getVericifyDelta } from "./vericify-context.js";
+import { createTaskPlan, superviseTaskPlan, } from "./orchestrator-supervisor.js";
 function parseOptionalJsonObject(raw) {
     if (!raw)
         return {};
@@ -35,6 +40,101 @@ function parseUnknownJson(raw) {
         return { raw };
     }
 }
+function extractToolTextContent(result) {
+    if (!result || typeof result !== "object")
+        return "";
+    const content = Array.isArray(result.content) ? result.content : [];
+    return content
+        .filter((entry) => Boolean(entry) &&
+        typeof entry === "object" &&
+        entry.type === "text")
+        .map((entry) => String(entry.text ?? "").trim())
+        .filter(Boolean)
+        .join("\n");
+}
+function normalizeRoleCandidate(input) {
+    if (!input)
+        return undefined;
+    const normalized = input.trim().toLowerCase().replace(/^ace-/, "").replace(/[^a-z0-9]+/g, "");
+    const candidate = normalized === "coder" ? "coders" : normalized;
+    return ROLE_ENUM.options.includes(candidate)
+        ? candidate
+        : undefined;
+}
+function parseRoleFromRoutingSummary(summary) {
+    const match = summary.match(/\*\*Primary Swarm Agent\(s\):\*\*\s*([^\n]+)/i);
+    if (!match?.[1])
+        return undefined;
+    const firstAgent = match[1]
+        .split(",")
+        .map((entry) => entry.trim())
+        .find(Boolean);
+    return normalizeRoleCandidate(firstAgent);
+}
+function mapRoleToTaskType(role) {
+    switch (role) {
+        case "vos":
+            return "venture";
+        case "ui":
+            return "ux";
+        case "orchestrator":
+            return "mixed";
+        default:
+            return "engineering";
+    }
+}
+function extractHandoffId(text) {
+    const jsonMatch = text.match(/"handoff_id"\s*:\s*"([^"]+)"/);
+    if (jsonMatch?.[1])
+        return jsonMatch[1];
+    const lineMatch = text.match(/handoff_id:\s*([A-Z0-9-]+)/i);
+    return lineMatch?.[1];
+}
+async function buildOrchestratorSteps(task, sessionId) {
+    const routing = await executeAceInternalTool("route_task", { description: task, domain: "unknown" }, sessionId);
+    const routedRole = parseRoleFromRoutingSummary(extractToolTextContent(routing)) ?? "orchestrator";
+    return [{ role: routedRole, task }];
+}
+function appendUniqueNote(target, note) {
+    if (!target.includes(note)) {
+        target.push(note);
+    }
+}
+function buildDefaultOrchestratorAmendment(input) {
+    if (input.result.status !== "completed" || input.step.role !== "coders") {
+        return undefined;
+    }
+    const currentIndex = input.plan.steps.findIndex((step) => step.step_id === input.step.step_id);
+    if (currentIndex < 0) {
+        return undefined;
+    }
+    const downstreamSteps = input.plan.steps.slice(currentIndex + 1);
+    const hasValidationStep = downstreamSteps.some((step) => step.role === "qa" || step.role === "docs");
+    if (hasValidationStep) {
+        return undefined;
+    }
+    return {
+        steps_to_add: [
+            {
+                role: "qa",
+                task: `Validate completed work for ${input.step.step_id}: ${input.step.task}`,
+                depends_on: [input.step.step_id],
+                tool_scope: ["run_tests", "execute_gates", "git_diff"],
+            },
+        ],
+        add_after_step_id: input.step.step_id,
+    };
+}
+async function tryVericifyPacket(factory, onWarning) {
+    try {
+        return await factory();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        onWarning?.(message);
+        return undefined;
+    }
+}
 export function registerAgentTools(server) {
     // ── Agent Instructions & Manifests ────────────────────────────────
     server.tool("get_agent_instructions", "Load the full instruction file for a specific ACE agent role", {
@@ -466,6 +566,361 @@ export function registerAgentTools(server) {
             ],
         };
     });
+    server.tool("run_local_model", "Offload a governed ACE subtask to a local model bridge and return the result", {
+        task: z.string().describe("Task to execute with the local ACE model bridge"),
+        role: ROLE_ENUM.optional().describe("Optional ACE role; defaults to route_task"),
+        max_turns: z
+            .number()
+            .int()
+            .positive()
+            .optional()
+            .describe("Optional max-turn override; defaults by role"),
+        tier: z
+            .enum(["auto", "full", "compressed", "brief"])
+            .optional()
+            .describe("Prompt packing tier; default auto-detects from role and model"),
+        provider: z
+            .string()
+            .optional()
+            .describe("Optional provider override; otherwise discovered from local runtime context"),
+        model: z
+            .string()
+            .optional()
+            .describe("Optional model override; otherwise discovered from local runtime context"),
+        ollama_url: z
+            .string()
+            .optional()
+            .describe("Optional Ollama base URL override"),
+        tool_scope: z
+            .array(z.string())
+            .optional()
+            .describe("Optional explicit ACE tool allowlist for the delegated run"),
+        workspace_root: z
+            .string()
+            .optional()
+            .describe("Optional workspace root override; defaults to the active workspace"),
+    }, async ({ task, role, max_turns, tier, provider, model, ollama_url, tool_scope, workspace_root, }) => {
+        const delegated = await runLocalModelTask({
+            task,
+            role,
+            workspaceRoot: workspace_root,
+            provider,
+            model,
+            ollamaUrl: ollama_url,
+            maxTurns: max_turns,
+            tier,
+            toolScope: tool_scope,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        "## Local Model Run",
+                        `- role: ${delegated.role}`,
+                        `- provider: ${delegated.runtime.provider}`,
+                        `- model: ${delegated.runtime.model}`,
+                        `- workspace: ${delegated.runtime.workspaceRoot}`,
+                        `- status: ${delegated.result.status}`,
+                        `- turns: ${delegated.result.turns}`,
+                        delegated.routingSummary
+                            ? ["", "### Routing", delegated.routingSummary].join("\n")
+                            : "",
+                        delegated.runtime.notes.length > 0
+                            ? [
+                                "",
+                                "### Discovery Notes",
+                                ...delegated.runtime.notes.map((note) => `- ${note}`),
+                            ].join("\n")
+                            : "",
+                        "",
+                        "### Result",
+                        delegated.result.summary,
+                        delegated.result.tool_calls.length > 0
+                            ? [
+                                "",
+                                "### Tool Calls",
+                                ...delegated.result.tool_calls.map((tool) => `- ${tool.tool}: ${tool.ok ? "ok" : "error"} — ${tool.summary}`),
+                            ].join("\n")
+                            : "",
+                    ]
+                        .filter(Boolean)
+                        .join("\n"),
+                },
+            ],
+        };
+    });
+    server.tool("run_orchestrator", "Execute a supervised plan via model bridge child runs; when steps are omitted, auto-planning falls back to a single route_task-derived step", {
+        task: z.string().describe("The task to decompose and execute"),
+        steps: z
+            .array(z.object({
+            role: ROLE_ENUM.describe("ACE role assigned to the step"),
+            task: z.string().describe("Task directive for the step"),
+            depends_on: z
+                .array(z.string())
+                .optional()
+                .describe("Optional step ids that must complete first"),
+            parallel_group: z
+                .string()
+                .optional()
+                .describe("Optional parallel execution group"),
+            tool_scope: z
+                .array(z.string())
+                .optional()
+                .describe("Optional ACE tool allowlist for the step"),
+        }))
+            .optional()
+            .describe("Pre-defined steps; if omitted, the orchestrator derives a single routed step"),
+        execution_mode: z
+            .enum(["sequential", "scheduled"])
+            .optional()
+            .describe("Execution mode for the task plan"),
+        max_turns_per_step: z
+            .number()
+            .int()
+            .positive()
+            .optional()
+            .describe("Optional max-turn limit applied to each child bridge step"),
+        provider: z
+            .string()
+            .optional()
+            .describe("Optional provider override; otherwise discovered from local runtime context"),
+        model: z
+            .string()
+            .optional()
+            .describe("Optional model override; otherwise discovered from local runtime context"),
+        ollama_url: z
+            .string()
+            .optional()
+            .describe("Optional Ollama base URL override"),
+        workspace_root: z
+            .string()
+            .optional()
+            .describe("Optional workspace root override; defaults to the active workspace"),
+    }, async ({ task, steps, execution_mode, max_turns_per_step, provider, model, ollama_url, workspace_root }, extra) => {
+        const runtime = resolveLocalModelRuntime({
+            workspaceRoot: workspace_root,
+            provider,
+            model,
+            ollamaUrl: ollama_url,
+        });
+        const sessionId = typeof extra?.sessionId === "string" ? extra.sessionId : undefined;
+        const planSource = Array.isArray(steps) && steps.length > 0 ? "explicit_steps" : "route_task_single_step";
+        const planSteps = Array.isArray(steps) && steps.length > 0
+            ? steps
+            : await buildOrchestratorSteps(task, sessionId);
+        const plan = createTaskPlan({
+            task,
+            steps: planSteps,
+            execution_mode: execution_mode ?? "sequential",
+        });
+        const bridge = new ModelBridge(createDefaultModelBridgeClients(runtime.ollamaUrl));
+        const fallbackHandoffPrefix = `LOCAL-${plan.plan_id}-`;
+        const vericifyWarnings = [];
+        const supervised = await superviseTaskPlan(plan, {
+            async spawnStep(step) {
+                return bridge.spawn({
+                    task: step.task,
+                    role: step.role,
+                    workspace: runtime.workspaceRoot,
+                    maxTurns: max_turns_per_step ?? 6,
+                    provider: runtime.provider,
+                    model: runtime.model,
+                    toolScope: step.tool_scope,
+                });
+            },
+            async createHandoff({ step, plan: activePlan }) {
+                const created = await executeAceInternalTool("create_handoff", {
+                    from: "orchestrator",
+                    to: step.role,
+                    title: `${activePlan.plan_id}:${step.step_id} ${step.task}`.slice(0, 120),
+                    task_type: mapRoleToTaskType(step.role),
+                    priority: "P1",
+                    directive: step.task,
+                    acceptance_criteria: [`Complete ${step.step_id}: ${step.task}`],
+                    context_pointers: {
+                        engineering_constraint: `plan=${activePlan.plan_id}; step=${step.step_id}`,
+                    },
+                }, sessionId);
+                const handoffId = extractHandoffId(extractToolTextContent(created));
+                return {
+                    handoff_id: handoffId ?? `${fallbackHandoffPrefix}${step.step_id}`,
+                };
+            },
+            async ackHandoff(handoffId, status, note) {
+                if (handoffId.startsWith(fallbackHandoffPrefix)) {
+                    return;
+                }
+                await executeAceInternalTool("ack_handoff", {
+                    handoff_id: handoffId,
+                    status,
+                    note,
+                }, sessionId);
+            },
+            amendPlan({ plan: activePlan, step, result }) {
+                return buildDefaultOrchestratorAmendment({
+                    plan: activePlan,
+                    step,
+                    result,
+                });
+            },
+            async getVericifyContext() {
+                return tryVericifyPacket(() => getVericifyContextPacket({
+                    workspaceRoot: runtime.workspaceRoot,
+                }), (message) => appendUniqueNote(vericifyWarnings, `Vericify context unavailable for ${plan.plan_id}: ${message}`));
+            },
+            async getVericifyDelta(since) {
+                return tryVericifyPacket(() => getVericifyDelta({
+                    since,
+                    workspaceRoot: runtime.workspaceRoot,
+                }), (message) => appendUniqueNote(vericifyWarnings, `Vericify delta unavailable for ${plan.plan_id}: ${message}`));
+            },
+            async openCircuitBreaker(reason) {
+                await executeAceInternalTool("open_circuit_breaker", {
+                    reason,
+                    owner: "capability-ops",
+                }, sessionId);
+            },
+            async closeCircuitBreaker(reason) {
+                await executeAceInternalTool("close_circuit_breaker", {
+                    reason,
+                }, sessionId);
+            },
+            async executeGates() {
+                const result = await executeAceInternalTool("execute_gates", {}, sessionId);
+                return {
+                    ok: !Boolean(result?.isError),
+                    summary: extractToolTextContent(result),
+                };
+            },
+            async contextSnapshot(activePlan) {
+                await executeAceInternalTool("context_snapshot", {
+                    name: `${activePlan.plan_id}-final`,
+                    summary: `Orchestrator plan ${activePlan.plan_id} finished with status ${activePlan.status}`,
+                    artifacts: activePlan.steps.map((step) => `${step.step_id}:${step.role}`),
+                    decisions: activePlan.steps
+                        .filter((step) => typeof step.result_summary === "string" && step.result_summary.trim())
+                        .map((step) => `${step.step_id}: ${step.result_summary}`),
+                }, sessionId);
+            },
+            async emitStatusEvent(event) {
+                await executeAceInternalTool("emit_status_event", {
+                    source_module: "capability-ops",
+                    event_type: "ORCHESTRATOR_STEP",
+                    status: event.status === "done" ? "done" : event.status === "blocked" ? "blocked" : "in_progress",
+                    summary: event.summary,
+                    payload_json: JSON.stringify(event.step_id ? { step_id: event.step_id, plan_id: plan.plan_id } : { plan_id: plan.plan_id }),
+                }, sessionId);
+            },
+        });
+        const step_summaries = supervised.plan.steps.map((step) => ({
+            step_id: step.step_id,
+            role: step.role,
+            task: step.task,
+            status: step.status,
+            result_summary: step.result_summary ?? "",
+            handoff_id: step.handoff_id ?? null,
+            job_id: step.job_id ?? null,
+            blocked_reason: step.blocked_reason ?? null,
+        }));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        runtime,
+                        plan_source: planSource,
+                        planning_note: planSource === "route_task_single_step"
+                            ? "Auto-planning currently falls back to a single route_task-derived step. Pass explicit steps for multi-step orchestration."
+                            : null,
+                        plan: supervised.plan,
+                        step_summaries,
+                        handoff_ids: supervised.handoff_ids,
+                        job_ids: supervised.job_ids,
+                        circuit_opened: supervised.circuit_opened,
+                        final_gate: supervised.final_gate ?? null,
+                        vericify_warnings: vericifyWarnings,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("get_vericify_context", "Build a compact Vericify context packet for workspace:current or a specified run", {
+        run_id: z
+            .string()
+            .optional()
+            .describe("Optional Vericify run id; defaults to workspace:current"),
+        workspace_root: z
+            .string()
+            .optional()
+            .describe("Optional workspace root override used to locate the Vericify workspace"),
+    }, async ({ run_id, workspace_root }) => {
+        try {
+            const packet = await getVericifyContextPacket({
+                runId: run_id,
+                workspaceRoot: workspace_root,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(packet, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ Vericify context failed: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("get_vericify_delta", "Build a compact Vericify delta from a prior vcx cursor or checkpoint reference", {
+        since: z
+            .string()
+            .describe("Required prior vcx cursor or compatible checkpoint reference"),
+        run_id: z
+            .string()
+            .optional()
+            .describe("Optional Vericify run id; defaults to workspace:current"),
+        workspace_root: z
+            .string()
+            .optional()
+            .describe("Optional workspace root override used to locate the Vericify workspace"),
+    }, async ({ since, run_id, workspace_root }) => {
+        try {
+            const delta = await getVericifyDelta({
+                since,
+                runId: run_id,
+                workspaceRoot: workspace_root,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(delta, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ Vericify delta failed: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
     server.tool("get_vericify_bridge", "Load the optional Vericify sidecar bridge snapshot derived from ACE runtime artifacts", {}, async () => {
         const result = loadVericifyBridgeSnapshot();
         return {
@@ -563,7 +1018,7 @@ export function registerAgentTools(server) {
         lane_id: z.string().optional().describe("Optional Vericify lane id"),
         agent_id: z.string().describe("Posting agent/module id"),
         kind: z
-            .enum(["intent", "progress", "blocker", "handoff_note", "completion"])
+            .enum(["intent", "progress", "blocker", "handoff_note", "stale_ack", "completion"])
             .describe("Structured process post kind"),
         summary: z.string().describe("Short operator-facing summary"),
         tool_refs: z