@oni.bot/core 0.8.0 → 1.0.0

package/dist/oni-code/swarm-runner.js

@@ -0,0 +1,873 @@
+/**
+ * DefaultSwarmRunner — bridges the oni-code Conductor to ONI swarm primitives.
+ *
+ * Replaces NOOP_SWARM_RUNNER to make spawn_swarm actually dispatch real
+ * multi-agent work. Uses SwarmGraph topology factories, ONIHarness for
+ * agent creation, and returns summarized results to the conductor.
+ */
+import { StateGraph } from "../graph.js";
+import { START, END } from "../types.js";
+import { ONIHarness } from "../harness/harness.js";
+import { SwarmGraph, baseSwarmChannels, } from "../swarm/graph.js";
+import { makeCodingTools } from "./tools/coding.js";
+import { makeWebTools } from "./tools/web.js";
+import { makeSpawnSwarmTool } from "./tools/spawn-swarm.js";
+import { ChangeTracker } from "./workspace/change-tracker.js";
+import { ConflictDetector } from "./workspace/conflict-detector.js";
+import { extractFileChange } from "./change-tracking.js";
+import { generateCheckpointId, } from "./swarm-checkpoint.js";
+// ── Config ───────────────────────────────────────────────────
+/** Default total token budget for an entire swarm (16K per agent is reasonable) */
+const DEFAULT_SWARM_MAX_TOKENS = 65536;
+// ── Supported topologies ─────────────────────────────────────
+const SUPPORTED_TOPOLOGIES = new Set([
+    "debate",
+    "fanOut",
+    "pipeline",
+    "hierarchical",
+    "mapReduce",
+]);
+// ── DefaultSwarmRunner ───────────────────────────────────────
+// ── Tool tracking ────────────────────────────────────────────
+/**
+ * Wraps an array of tools so that mutating tool calls (edit_file, write_file)
+ * automatically record changes to a ChangeTracker.
+ */
+function wrapToolsWithTracking(tools, tracker) {
+    return tools.map((tool) => ({
+        ...tool,
+        execute: async (input, ctx) => {
+            const result = await tool.execute(input, ctx);
+            const change = extractFileChange(tool.name, input, result);
+            if (change) {
+                tracker.recordChange(change.file, change.type);
+            }
+            return result;
+        },
+    }));
+}
+/**
+ * Single-pass dual tracking — wraps tools so file changes are recorded
+ * in BOTH the per-agent tracker and the shared (swarm-wide) tracker
+ * with a single async wrapper instead of two nested wrappers.
+ */
+function wrapToolsWithDualTracking(tools, agentTracker, sharedTracker) {
+    return tools.map((tool) => ({
+        ...tool,
+        execute: async (input, ctx) => {
+            const result = await tool.execute(input, ctx);
+            const change = extractFileChange(tool.name, input, result);
+            if (change) {
+                agentTracker.recordChange(change.file, change.type);
+                sharedTracker.recordChange(change.file, change.type);
+            }
+            return result;
+        },
+    }));
+}
+/**
+ * Filter tools to only those whose names appear in the allowed list.
+ * If the allowed list is empty, returns all tools (no restriction).
+ */
+function filterToolsByName(tools, allowedNames) {
+    if (allowedNames.length === 0)
+        return tools;
+    const nameSet = new Set(allowedNames);
+    return tools.filter((t) => nameSet.has(t.name));
+}
+export class DefaultSwarmRunner {
+    model;
+    fastModel;
+    rootDir;
+    conductorTracker;
+    maxTokens;
+    onProgress;
+    cacheTtlMs;
+    maxDepth;
+    currentDepth;
+    cache = new Map();
+    checkpointStore;
+    perAgentMaxTurns;
+    agentTimeout;
+    maxConcurrency;
+    eventBus;
+    /** Cached base tools — built once in constructor, reused across all run() calls */
+    baseTools;
+    swarmIdCounter = 0;
+    constructor(config) {
+        this.model = config.model;
+        this.fastModel = config.fastModel;
+        this.rootDir = config.rootDir;
+        this.conductorTracker = config.changeTracker;
+        this.maxTokens = config.maxTokens ?? DEFAULT_SWARM_MAX_TOKENS;
+        this.onProgress = config.onProgress;
+        this.cacheTtlMs = config.cacheTtlMs ?? 0;
+        this.maxDepth = config.maxDepth ?? 1;
+        this.currentDepth = config.currentDepth ?? 0;
+        this.checkpointStore = config.checkpointStore;
+        this.perAgentMaxTurns = config.perAgentMaxTurns ?? 5;
+        this.agentTimeout = config.agentTimeout ?? 300_000;
+        this.maxConcurrency = config.maxConcurrency;
+        this.eventBus = config.eventBus;
+        // Build base tools once — rootDir is immutable, factories are pure
+        this.baseTools = [...makeCodingTools(this.rootDir), ...makeWebTools()];
+    }
+    /**
+     * Returns the tool names that agents in this runner would receive.
+     * Useful for testing nesting configuration.
+     * @param _index — reserved for future per-agent scoping (currently unused)
+     */
+    getAgentToolNames(_index) {
+        const names = this.baseTools.map((t) => t.name);
+        if (this.currentDepth + 1 < this.maxDepth) {
+            names.push("spawn_swarm");
+        }
+        return names;
+    }
+    /** Emit a progress event if a listener is registered, and bridge to EventBus */
+    emit(event) {
+        if (this.onProgress) {
+            this.onProgress(event);
+        }
+        // Bridge SwarmProgressEvent → EventBus lifecycle events
+        if (this.eventBus) {
+            const swarmId = event.swarmId ?? `swarm_${this.swarmIdCounter}`;
+            switch (event.type) {
+                case "swarm:start":
+                    this.eventBus.emit({
+                        type: "swarm.started",
+                        swarmId,
+                        topology: event.topology,
+                        agentCount: event.agentCount,
+                        timestamp: event.timestamp,
+                    });
+                    break;
+                case "swarm:complete":
+                    this.eventBus.emit({
+                        type: "swarm.completed",
+                        swarmId,
+                        topology: event.topology,
+                        agentCount: event.agentCount,
+                        duration: event.duration,
+                        durationMs: (event.duration ?? 0) * 1000,
+                        outcome: event.detail,
+                        timestamp: event.timestamp,
+                    });
+                    break;
+                case "swarm:error":
+                    this.eventBus.emit({
+                        type: "swarm.completed",
+                        swarmId,
+                        topology: event.topology,
+                        agentCount: event.agentCount,
+                        duration: event.duration,
+                        durationMs: (event.duration ?? 0) * 1000,
+                        outcome: event.detail ? `ERROR: ${event.detail}` : "ERROR: swarm failed",
+                        agentResults: event.detail ? { error: event.detail } : { error: "Swarm failed" },
+                        timestamp: event.timestamp,
+                    });
+                    break;
+                case "agent:start":
+                    this.eventBus.emit({
+                        type: "swarm.agent.started",
+                        swarmId,
+                        agentName: event.agentId ?? "unknown",
+                        agentRole: event.agentRole,
+                        timestamp: event.timestamp,
+                    });
+                    break;
+                case "agent:complete":
+                    this.eventBus.emit({
+                        type: "swarm.agent.completed",
+                        swarmId,
+                        agentName: event.agentId ?? "unknown",
+                        agentRole: event.agentRole,
+                        durationMs: (event.duration ?? 0) * 1000,
+                        timestamp: event.timestamp,
+                    });
+                    break;
+                case "agent:error":
+                    this.eventBus.emit({
+                        type: "swarm.agent.failed",
+                        swarmId,
+                        agentName: event.agentId ?? "unknown",
+                        agentRole: event.agentRole,
+                        error: event.detail ?? "Unknown error",
+                        timestamp: event.timestamp,
+                    });
+                    break;
+            }
+        }
+    }
+    /** Build a deterministic cache key from topology + task + agent IDs */
+    cacheKey(config) {
+        const agentKey = config.agents.map((a) => a.id).sort().join(",");
+        return `${config.topology}::${config.task}::${agentKey}`;
+    }
+    /** Look up a cached result. Returns undefined on miss or expiry. */
+    getCached(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return undefined;
+        if (Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            return undefined;
+        }
+        return entry.result;
+    }
+    async run(config, perCallProgress, opts) {
+        // Save original onProgress to restore after this call
+        const originalOnProgress = this.onProgress;
+        if (perCallProgress) {
+            // Per-call callback takes priority; chain with constructor callback
+            this.onProgress = (event) => {
+                perCallProgress(event);
+                if (originalOnProgress)
+                    originalOnProgress(event);
+            };
+        }
+        try {
+            return await this._runImpl(config, opts?.signal);
+        }
+        finally {
+            this.onProgress = originalOnProgress;
+        }
+    }
+    async _runImpl(config, signal) {
+        this.swarmIdCounter++;
+        const startTime = Date.now();
+        const swarmId = `swarm_${startTime.toString(36)}_${this.swarmIdCounter.toString(36)}`;
+        // ── Early abort check ────────────────────────────────────
+        if (signal?.aborted) {
+            return {
+                outcome: "Swarm aborted before start.",
+                agentSummaries: [],
+                filesModified: [],
+                duration: (Date.now() - startTime) / 1000,
+            };
+        }
+        // ── Cache lookup ──────────────────────────────────────────
+        if (this.cacheTtlMs > 0) {
+            const cached = this.getCached(this.cacheKey(config));
+            if (cached)
+                return cached;
+        }
+        const agentIds = config.agents.map((a) => a.id);
+        this.emit({
+            type: "swarm:start",
+            timestamp: Date.now(),
+            swarmId,
+            topology: config.topology,
+            agentCount: config.agents.length,
+            agentIds,
+        });
+        try {
+            if (!SUPPORTED_TOPOLOGIES.has(config.topology)) {
+                this.emit({
+                    type: "swarm:complete",
+                    timestamp: Date.now(),
+                    swarmId,
+                    duration: (Date.now() - startTime) / 1000,
+                    topology: config.topology,
+                    agentCount: config.agents.length,
+                    detail: `Unsupported topology: ${config.topology}`,
+                });
+                return {
+                    outcome: `Topology "${config.topology}" requires manual configuration (handoffs/teams) that cannot be auto-generated. Supported auto-topologies: ${[...SUPPORTED_TOPOLOGIES].join(", ")}`,
+                    agentSummaries: [],
+                    filesModified: [],
+                    duration: (Date.now() - startTime) / 1000,
+                };
+            }
+            this.emit({
+                type: "swarm:topology-resolved",
+                timestamp: Date.now(),
+                swarmId,
+                topology: config.topology,
+            });
+            // Compute per-agent token budget
+            const agentCount = config.agents.length;
+            const perAgentTokens = Math.floor(this.maxTokens / Math.max(agentCount, 1));
+            // Build per-agent change trackers for file modification tracking
+            const perAgentTrackers = new Map();
+            const sharedTracker = new ChangeTracker();
+            // Use cached base tools — spread to allow per-run additions (e.g. spawn_swarm)
+            const allTools = [...this.baseTools];
+            // If nesting is allowed, add spawn_swarm backed by a child runner
+            if (this.currentDepth + 1 < this.maxDepth) {
+                const childRunner = new DefaultSwarmRunner({
+                    model: this.model,
+                    fastModel: this.fastModel,
+                    rootDir: this.rootDir,
+                    changeTracker: this.conductorTracker,
+                    maxTokens: Math.floor(this.maxTokens / 2), // child gets half the budget
+                    maxDepth: this.maxDepth,
+                    currentDepth: this.currentDepth + 1,
+                    perAgentMaxTurns: this.perAgentMaxTurns,
+                    agentTimeout: this.agentTimeout,
+                    maxConcurrency: this.maxConcurrency,
+                    eventBus: this.eventBus,
+                });
+                allTools.push(makeSpawnSwarmTool(childRunner));
+            }
+            const agentDefs = config.agents.map((input) => {
+                const agentTracker = new ChangeTracker();
+                perAgentTrackers.set(input.id, agentTracker);
+                // Per-agent tool scoping: use agent-level tools if set, else swarm-level
+                const allowedNames = input.tools ?? config.tools;
+                const scopedTools = filterToolsByName(allTools, allowedNames);
+                // Single-pass wrapper: records file changes in both per-agent and shared trackers
+                const trackedTools = wrapToolsWithDualTracking(scopedTools, agentTracker, sharedTracker);
+                return this.buildAgentDef(input, trackedTools, config.maxTurns, perAgentTokens, swarmId);
+            });
+            this.emit({
+                type: "swarm:agents-built",
+                timestamp: Date.now(),
+                swarmId,
+                topology: config.topology,
+                agentCount: agentDefs.length,
+                agentIds: agentDefs.map((a) => a.id),
+            });
+            // ── Abort check before graph compilation ──────────────────
+            if (signal?.aborted) {
+                return {
+                    outcome: "Swarm aborted before graph compilation.",
+                    agentSummaries: [],
+                    filesModified: [],
+                    duration: (Date.now() - startTime) / 1000,
+                };
+            }
+            // Build and compile the swarm graph
+            const swarmGraph = this.buildTopology(config, agentDefs);
+            const skeleton = swarmGraph.compile();
+            // Invoke with initial state, enforcing agentTimeout + abort signal as deadline
+            const invokePromise = skeleton.invoke({
+                task: config.task,
+                context: {},
+                agentResults: {},
+                messages: [],
+                swarmMessages: [],
+                supervisorRound: 0,
+                currentAgent: null,
+                done: false,
+                handoffHistory: [],
+            });
+            // Build race competitors: invoke vs timeout vs abort signal
+            const raceCompetitors = [invokePromise];
+            if (this.agentTimeout > 0) {
+                raceCompetitors.push(new Promise((_, reject) => {
+                    const timer = setTimeout(() => reject(new Error(`Swarm timed out after ${this.agentTimeout}ms`)), this.agentTimeout);
+                    if (typeof timer === "object" && "unref" in timer)
+                        timer.unref();
+                }));
+            }
+            if (signal && !signal.aborted) {
+                raceCompetitors.push(new Promise((_, reject) => {
+                    signal.addEventListener("abort", () => {
+                        reject(new Error("Swarm aborted by user"));
+                    }, { once: true });
+                }));
+            }
+            const finalState = await Promise.race(raceCompetitors);
+            const duration = (Date.now() - startTime) / 1000;
+            // Detect conflicts: multiple agents modifying the same file
+            const conflicts = this.detectConflicts(perAgentTrackers);
+            // Merge tracked changes into conductor's tracker
+            this.mergeIntoConductorTracker(sharedTracker);
+            const result = this.extractResults(finalState, config, duration, sharedTracker.getChangedFiles(), conflicts);
+            this.emit({
+                type: "swarm:complete",
+                timestamp: Date.now(),
+                swarmId,
+                duration,
+                topology: config.topology,
+                agentCount: config.agents.length,
+            });
+            // ── Cache store (clean successes only) ───────────────────
+            // Don't cache results with error indicators — retries may succeed
+            const hasErrors = this.resultHasErrors(result);
+            if (this.cacheTtlMs > 0 && !hasErrors) {
+                this.cache.set(this.cacheKey(config), {
+                    result,
+                    expiresAt: Date.now() + this.cacheTtlMs,
+                });
+            }
+            // ── Checkpoint degraded results ───────────────────────────
+            // If the swarm "completed" but all agents produced empty/error output,
+            // store a checkpoint so the conductor can offer to resume.
+            if (hasErrors && this.checkpointStore) {
+                const checkpointId = generateCheckpointId();
+                const checkpoint = {
+                    id: checkpointId,
+                    topology: config.topology,
+                    task: config.task,
+                    completedResults: this.extractCompletedResults(result),
+                    pendingAgents: this.extractPendingAgents(config, result),
+                    timestamp: Date.now(),
+                    config,
+                };
+                this.checkpointStore.save(checkpoint);
+                this.emit({
+                    type: "swarm:checkpoint-created",
+                    timestamp: Date.now(),
+                    swarmId,
+                    detail: checkpointId,
+                    topology: config.topology,
+                });
+                return { ...result, checkpointId };
+            }
+            return result;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const duration = (Date.now() - startTime) / 1000;
+            this.emit({
+                type: "swarm:error",
+                timestamp: Date.now(),
+                swarmId,
+                duration,
+                topology: config.topology,
+                agentCount: config.agents.length,
+                detail: message,
+            });
+            // Create checkpoint for resumption if a store is configured
+            let checkpointId;
+            if (this.checkpointStore) {
+                checkpointId = generateCheckpointId();
+                const checkpoint = {
+                    id: checkpointId,
+                    topology: config.topology,
+                    task: config.task,
+                    completedResults: {},
+                    pendingAgents: config.agents,
+                    timestamp: Date.now(),
+                    config,
+                };
+                this.checkpointStore.save(checkpoint);
+                this.emit({
+                    type: "swarm:checkpoint-created",
+                    timestamp: Date.now(),
+                    swarmId,
+                    detail: checkpointId,
+                    topology: config.topology,
+                });
+            }
+            return {
+                outcome: `ERROR: Swarm execution failed: ${message}`,
+                agentSummaries: [],
+                filesModified: [],
+                duration,
+                checkpointId,
+            };
+        }
+    }
+    // ── Resume from checkpoint ──────────────────────────────────
+    /**
+     * Resume a previously failed swarm from its checkpoint.
+     * Re-runs the swarm using the stored config. On success, the checkpoint
+     * is deleted. On failure, a new checkpoint is stored (or the existing
+     * one is preserved).
+     *
+     * @param checkpointId — the ID returned in the failed run's result
+     * @throws if no checkpoint store is configured or the checkpoint is not found
+     */
+    async resume(checkpointId) {
+        if (!this.checkpointStore) {
+            throw new Error("Checkpoint store not configured — cannot resume swarm. " +
+                "Pass a SwarmCheckpointStore in the runner config.");
+        }
+        const checkpoint = this.checkpointStore.get(checkpointId);
+        if (!checkpoint) {
+            throw new Error(`Checkpoint "${checkpointId}" not found (it may have expired or been deleted).`);
+        }
+        // Delete the old checkpoint — run() will create a new one if it fails again
+        this.checkpointStore.delete(checkpointId);
+        // Re-run the swarm with the stored config
+        return this.run(checkpoint.config);
+    }
+    // ── Build a SwarmAgentDef from SwarmAgentInput ──────────────
+    buildAgentDef(input, tools, maxTurns, maxTokens, swarmId) {
+        const harness = ONIHarness.create({
+            model: this.model,
+            fastModel: this.fastModel,
+            sharedTools: tools,
+            maxTokens,
+        });
+        // asNode returns (state) => Promise<Partial<state>> that reads state.task
+        // and writes to state.agentResults[agentName]
+        const nodeFunc = harness.asNode({
+            name: input.id,
+            soul: input.systemPrompt,
+            maxTurns: Math.min(maxTurns, this.perAgentMaxTurns),
+        });
+        // Wrap in a single-node graph to produce a skeleton
+        const g = new StateGraph({
+            channels: baseSwarmChannels,
+        });
+        g.addNode("work", nodeFunc);
+        g.addEdge(START, "work");
+        g.addEdge("work", END);
+        // Build lifecycle hooks that emit agent-level progress events
+        const hooks = this.buildAgentHooks(input.id, input.role, swarmId);
+        return {
+            id: input.id,
+            role: input.role,
+            capabilities: [{ name: "work", description: input.systemPrompt }],
+            skeleton: g.compile(),
+            hooks,
+        };
+    }
+    // ── Agent lifecycle hooks for observability ────────────────
+    /**
+     * Create AgentLifecycleHooks that emit agent-level progress events
+     * (agent:start, agent:complete, agent:error) through the onProgress callback.
+     */
+    buildAgentHooks(agentId, agentRole, swarmId) {
+        // Capture the start timestamp per agent to compute duration on complete
+        let startTime = 0;
+        return {
+            onStart: (_id) => {
+                startTime = Date.now();
+                this.emit({
+                    type: "agent:start",
+                    timestamp: Date.now(),
+                    swarmId,
+                    agentId,
+                    agentRole,
+                });
+            },
+            onComplete: (_id, result) => {
+                const duration = startTime > 0
+                    ? (Date.now() - startTime) / 1000
+                    : 0;
+                // Detect if the harness returned an empty/error result
+                // (model errors are caught internally by the harness and produce empty output)
+                const isEmptyResult = this.isAgentResultEmpty(agentId, result);
+                if (isEmptyResult) {
+                    this.emit({
+                        type: "agent:error",
+                        timestamp: Date.now(),
+                        swarmId,
+                        agentId,
+                        agentRole,
+                        duration,
+                        detail: "Agent produced empty result (model may have failed)",
+                    });
+                }
+                else {
+                    this.emit({
+                        type: "agent:complete",
+                        timestamp: Date.now(),
+                        swarmId,
+                        agentId,
+                        agentRole,
+                        duration,
+                    });
+                }
+            },
+            onError: (_id, error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                this.emit({
+                    type: "agent:error",
+                    timestamp: Date.now(),
+                    swarmId,
+                    agentId,
+                    agentRole,
+                    detail: message,
+                });
+            },
+        };
+    }
+    /**
+     * Check if an agent result is empty/error.
+     * The harness catches model errors internally and returns an empty string
+     * as the agent result, so we detect that condition here.
+     */
+    isAgentResultEmpty(agentId, result) {
+        if (result == null)
+            return true;
+        if (typeof result !== "object")
+            return false;
+        const obj = result;
+        const agentResults = obj.agentResults;
+        if (!agentResults)
+            return false;
+        const agentOutput = agentResults[agentId];
+        if (agentOutput == null)
+            return true;
+        if (typeof agentOutput === "string" && agentOutput.trim() === "")
+            return true;
+        return false;
+    }
+    // ── Topology selection ─────────────────────────────────────
+    buildTopology(config, agents) {
+        switch (config.topology) {
+            case "debate":
+                return this.buildDebate(config, agents);
+            case "fanOut":
+                return this.buildFanOut(agents, this.maxConcurrency);
+            case "pipeline":
+                return this.buildPipeline(agents);
+            case "hierarchical":
+                return this.buildHierarchical(config, agents);
+            case "mapReduce":
+                return this.buildMapReduce(config, agents);
+            default:
+                throw new Error(`Unsupported topology: ${config.topology}`);
+        }
+    }
+    // ── Debate ─────────────────────────────────────────────────
+    buildDebate(config, agents) {
+        const judgeModel = this.fastModel ?? this.model;
+        const maxRounds = config.judge?.maxRounds ?? 3;
+        const consensusKeyword = config.judge?.consensusKeyword ?? "CONSENSUS";
+        return SwarmGraph.debate({
+            debaters: agents,
+            judge: {
+                model: judgeModel,
+                maxRounds,
+                consensusKeyword,
+                systemPrompt: "You are a debate judge. Evaluate the arguments and determine if consensus has been reached.",
+            },
+            topic: "task",
+        });
+    }
+    // ── FanOut ─────────────────────────────────────────────────
+    buildFanOut(agents, maxConcurrency) {
+        return SwarmGraph.fanOut({
+            agents,
+            maxConcurrency,
+            reducer: (agentResults) => {
+                // Default reducer: merge all results into a combined outcome
+                const summaries = Object.entries(agentResults)
+                    .map(([id, result]) => {
+                    const text = typeof result === "string" ? result : this.extractAgentText(result, id);
+                    return `[${id}]: ${text}`;
+                })
+                    .join("\n\n");
+                return {
+                    context: { combinedResults: summaries },
+                };
+            },
+        });
+    }
+    // ── Pipeline ───────────────────────────────────────────────
+    buildPipeline(agents) {
+        return SwarmGraph.pipeline({
+            stages: agents,
+        });
+    }
+    // ── Hierarchical ───────────────────────────────────────────
+    buildHierarchical(config, agents) {
+        const supervisorModel = this.fastModel ?? this.model;
+        return SwarmGraph.hierarchical({
+            supervisor: {
+                model: supervisorModel,
+                strategy: "llm",
+                maxRounds: config.maxTurns,
+                systemPrompt: "You are a supervisor coordinating worker agents. Route tasks to the most appropriate agent based on their capabilities. Respond with just the agent ID, or DONE when the task is complete.",
+            },
+            agents,
+        });
+    }
+    // ── MapReduce ──────────────────────────────────────────────
+    buildMapReduce(config, agents) {
+        // Use first agent as the mapper template, pool across all agents
+        const mapper = agents[0];
+        return SwarmGraph.mapReduce({
+            mapper,
+            poolSize: agents.length,
+            inputField: "task",
+            reducer: (agentResults) => {
+                const combined = Object.entries(agentResults)
+                    .map(([id, result]) => {
+                    const text = typeof result === "string" ? result : this.extractAgentText(result, id);
+                    return `[${id}]: ${text}`;
+                })
+                    .join("\n\n");
+                return {
+                    context: { reducedResult: combined },
+                };
+            },
+        });
+    }
+    // ── Conflict detection ──────────────────────────────────────
+    detectConflicts(perAgentTrackers) {
+        const detector = new ConflictDetector();
+        const estimates = [...perAgentTrackers.entries()].map(([agentId, tracker]) => ({
+            id: agentId,
+            estimatedFiles: tracker.getChangedFiles(),
+        }));
+        return detector.findConflicts(estimates);
+    }
+    // ── Merge into conductor tracker ───────────────────────────
+    mergeIntoConductorTracker(swarmTracker) {
+        if (!this.conductorTracker)
+            return;
+        for (const file of swarmTracker.getChangedFiles()) {
+            const type = swarmTracker.getChangeType(file);
+            if (type) {
+                this.conductorTracker.recordChange(file, type);
+            }
+        }
+    }
+    // ── Result extraction ──────────────────────────────────────
+    /**
+     * Extract meaningful text from an agent result.
+     * Agent results can be strings (simple), or full BaseSwarmState objects
+     * (pipeline/hierarchical), which contain nested agentResults, messages, etc.
+     * We dig through the layers to find actual text content.
+     */
+    extractAgentText(result, agentId) {
+        if (typeof result === "string")
+            return result;
+        if (result == null)
+            return "";
+        const obj = result;
+        // 0. Error marker objects: { _error: true, error: "..." }
+        if (obj._error) {
+            return typeof obj.error === "string" ? obj.error : JSON.stringify(result);
+        }
+        // 1. Check nested agentResults for the agent's own text output
+        if (obj.agentResults && typeof obj.agentResults === "object") {
+            const nested = obj.agentResults;
+            // Try the agent's own ID first
+            if (agentId && nested[agentId] != null) {
+                const inner = this.extractAgentText(nested[agentId], agentId);
+                if (inner)
+                    return inner;
+            }
+            // Otherwise, collect all agent result texts
+            const texts = Object.entries(nested)
+                .map(([id, val]) => {
+                const text = this.extractAgentText(val, id);
+                return text ? `[${id}]: ${text}` : null;
+            })
+                .filter(Boolean);
+            if (texts.length > 0)
+                return texts.join("\n\n");
+        }
+        // 2. Check messages for the last assistant message
+        if (Array.isArray(obj.messages) && obj.messages.length > 0) {
+            const lastAssistant = [...obj.messages]
+                .reverse()
+                .find((m) => m.role === "assistant");
+            if (lastAssistant && typeof lastAssistant.content === "string") {
+                const content = lastAssistant.content;
+                if (content.trim())
+                    return content;
+            }
+        }
+        // 3. Check context for combined/reduced results
+        if (obj.context && typeof obj.context === "object") {
+            const ctx = obj.context;
+            if (typeof ctx.combinedResults === "string")
+                return ctx.combinedResults;
+            if (typeof ctx.reducedResult === "string")
+                return ctx.reducedResult;
+        }
+        // 4. If this looks like a swarm state (has task, done, agentResults fields)
+        //    but no meaningful content was found above, return empty
+        if ("task" in obj && "done" in obj)
+            return "";
+        // 5. Last resort: stringify the object
+        return JSON.stringify(result);
+    }
+    extractResults(finalState, config, duration, filesModified = [], conflicts = []) {
+        // Extract outcome from final state
+        const agentResults = finalState.agentResults ?? {};
+        const messages = finalState.messages ?? [];
+        // Build outcome: prefer judge verdict (debate) or combined results
+        let outcome;
+        const lastJudgeMessage = [...messages]
+            .reverse()
+            .find((m) => m.role === "system" &&
+            (m.content.includes("[Judge") || m.content.includes("VERDICT")));
+        if (lastJudgeMessage) {
+            outcome = lastJudgeMessage.content;
+        }
+        else if (Object.keys(agentResults).length > 0) {
+            outcome = Object.entries(agentResults)
+                .map(([id, result]) => {
+                const text = this.extractAgentText(result, id);
+                return `[${id}]: ${text}`;
+            })
+                .join("\n\n");
+        }
+        else {
+            outcome = "Swarm completed with no agent results.";
+        }
+        // Append conflict warnings to outcome
+        if (conflicts.length > 0) {
+            const conflictLines = conflicts.map((c) => `  ⚠ ${c.file} — modified by: ${c.tasks.join(", ")}`);
+            outcome +=
+                "\n\nFILE CONFLICTS DETECTED:\n" + conflictLines.join("\n");
+        }
+        // Truncate outcome to prevent context blowout
+        if (outcome.length > 2000) {
+            outcome = outcome.slice(0, 1997) + "...";
+        }
+        // Build per-agent summaries
+        const agentSummaries = config.agents.map((agent) => {
+            const result = agentResults[agent.id];
+            const text = this.extractAgentText(result, agent.id);
+            const summary = text ? text.slice(0, 200) : "No output";
+            return { id: agent.id, summary };
+        });
+        return {
+            outcome,
+            agentSummaries,
+            filesModified,
+            duration,
+        };
+    }
+    // ── Error detection ────────────────────────────────────────
+    /**
+     * Detect whether a run result contains error indicators.
+     * Used to decide whether to cache (no) and whether to checkpoint (yes).
+     */
+    resultHasErrors(result) {
+        // Explicit error markers in outcome (case-insensitive for robustness)
+        const outcomeLower = result.outcome.toLowerCase();
+        if (outcomeLower.includes("error") ||
+            outcomeLower.includes("execution failed") ||
+            outcomeLower.includes("swarm execution failed") ||
+            outcomeLower.includes("_error")) {
+            return true;
+        }
+        // All agents produced empty/no output — likely a total failure
+        if (result.agentSummaries.length > 0 &&
+            result.agentSummaries.every((s) => s.summary === "No output" || s.summary.trim() === "")) {
+            return true;
+        }
+        return false;
+    }
+    // ── Checkpoint helpers ─────────────────────────────────────
+    /**
+     * Extract completed agent results from a (possibly partial) swarm result.
+     * Agents with non-trivial summaries are considered "completed".
+     */
+    extractCompletedResults(result) {
+        const completed = {};
+        for (const agent of result.agentSummaries) {
+            if (agent.summary !== "No output" && agent.summary.trim() !== "") {
+                completed[agent.id] = agent.summary;
+            }
+        }
+        return completed;
+    }
+    /**
+     * Determine which agents still need to run based on their result summaries.
+     * Agents with "No output" or empty summaries are considered pending.
+     */
+    extractPendingAgents(config, result) {
+        const completedIds = new Set();
+        for (const agent of result.agentSummaries) {
+            if (agent.summary !== "No output" && agent.summary.trim() !== "") {
+                completedIds.add(agent.id);
+            }
+        }
+        return config.agents.filter((a) => !completedIds.has(a.id));
+    }
+}
+//# sourceMappingURL=swarm-runner.js.map