@qduc/term2 0.11.0 → 0.12.0

package/dist/services/subagents/subagent-async-registry.js

@@ -1,6 +1,15 @@
 import { randomUUID } from 'node:crypto';
+import { createCodenameRunId } from './codename-run-id.js';
+import { addTokenUsage } from '../../utils/ai/token-usage.js';
+import { SubagentRunControl } from './subagent-run-control.js';
 import { SubagentSession } from './subagent-session.js';
-import { isAbortLike, safeEmit } from './utils.js';
+import { isAbortLike, safeEmit, truncatePreview } from './utils.js';
+export const SUBAGENT_RUN_NAME_PATTERN = /^[a-z][a-z0-9_-]{0,31}$/;
+const MAX_STEERING_GUIDANCE_CHARACTERS = 2_000;
+/** Defensive retry bound before accepting a (vanishingly unlikely) id collision. */
+const MAX_RUN_ID_ATTEMPTS = 16;
+const MAX_TURN_HISTORY = 5;
+const TURN_TEXT_CHAR_LIMIT = 200;
 export class SubagentRegistryError extends Error {
     code;
     constructor(code, message) {
@@ -15,11 +24,14 @@ export class SubagentAsyncRegistry {
     #run;
     #onEvent;
     #runs = new Map();
+    #activeNameToRunId = new Map();
     #sessions = new Map();
     #evicted = new Set();
     #now;
     #ttlMs;
     #messageCap;
+    #createRunId;
+    #sessionContextService;
     #sessionCap = 50;
     #sessionForRole;
     #timer;
@@ -32,6 +44,8 @@ export class SubagentAsyncRegistry {
         this.#now = deps.now ?? Date.now;
         this.#ttlMs = deps.ttlMs ?? 30 * 60 * 1000;
         this.#messageCap = deps.messageCap ?? 50;
+        this.#createRunId = deps.createRunId ?? createCodenameRunId;
+        this.#sessionContextService = deps.sessionContextService;
         this.#sessionForRole = deps.sessionForRole;
         this.#clearInterval = deps.clearInterval ?? clearInterval;
         this.#timer = (deps.setInterval ?? setInterval)(() => this.#evictExpired(), Math.max(1000, Math.min(this.#ttlMs, 60_000)));
@@ -41,11 +55,19 @@ export class SubagentAsyncRegistry {
         if (this.#disposed)
             throw new Error('Subagent async registry is disposed');
         const role = request.role;
-        if (!['explorer', 'worker', 'researcher', 'mentor', 'librarian'].includes(role)) {
+        if (!['explorer', 'worker', 'mentor', 'librarian'].includes(role)) {
             throw new SubagentRegistryError('not_continuable', `Unknown subagent role: ${role}`);
         }
+        const name = request.name;
+        if (name !== undefined && !SUBAGENT_RUN_NAME_PATTERN.test(name)) {
+            throw new SubagentRegistryError('invalid_name', `Invalid async subagent name: ${name}`);
+        }
+        if (name !== undefined && this.#activeNameToRunId.has(name)) {
+            throw new SubagentRegistryError('name_in_use', `Async subagent name is already active: ${name}`);
+        }
         const continuation = request.continueRunId;
         let session;
+        let trafficContext;
         if (continuation) {
             const previous = this.#runs.get(continuation);
             if (!previous) {
@@ -53,14 +75,17 @@ export class SubagentAsyncRegistry {
             }
             if (previous.role !== role)
                 throw new SubagentRegistryError('role_mismatch', `Run ${continuation} belongs to role ${previous.role}, not ${role}`);
-            if (previous.status === 'running')
+            if (isActiveStatus(previous.status))
                 throw new SubagentRegistryError('already_active', `Async subagent run ${continuation} is already active`);
+            if (previous.status !== 'completed')
+                throw new SubagentRegistryError('not_continuable', `Async subagent run ${continuation} cannot be continued from status ${previous.status}`);
             if (role === 'worker')
                 throw new SubagentRegistryError('worker_blocked', 'Worker runs cannot be continued asynchronously');
-            if (role !== 'mentor' && role !== 'librarian' && role !== 'explorer' && role !== 'researcher') {
+            if (role !== 'mentor' && role !== 'librarian' && role !== 'explorer') {
                 throw new SubagentRegistryError('not_continuable', `Role ${role} cannot be continued`);
             }
             session = previous.session;
+            trafficContext = previous.trafficContext;
         }
         else {
             const reuseDefault = role === 'mentor' || role === 'librarian';
@@ -69,27 +94,43 @@ export class SubagentAsyncRegistry {
             this.#sessions.set(key, session);
         }
         for (const active of this.#runs.values()) {
-            if (active.status === 'running' && active.session === session) {
+            if (isActiveStatus(active.status) && active.session === session) {
                 throw new SubagentRegistryError('already_active', `Session for role ${role} is already active`);
             }
         }
         this.#evictToSessionCap();
-        const runId = continuation ?? randomUUID();
-        const controller = new AbortController();
+        const runId = continuation ?? this.#allocateRunId();
+        trafficContext ??= this.#deriveTrafficContext(runId);
+        const control = new SubagentRunControl();
         let resolve;
         const promise = new Promise((r) => (resolve = r));
         const stored = {
             runId,
             role,
             task: request.task,
+            ...(name !== undefined ? { name } : {}),
             session,
             status: 'running',
-            abortController: controller,
+            control,
+            evidence: {
+                filesChanged: new Set(),
+                toolsUsed: new Map(),
+                diffStat: new Map(),
+            },
             lastUsedAt: this.#now(),
             resolve,
             promise,
             settled: false,
+            startedAt: this.#now(),
+            toolCounts: new Map(),
+            turnHistory: [],
+            pendingToolCounts: new Map(),
+            currentText: '',
+            ...(trafficContext ? { trafficContext } : {}),
         };
+        this.#runs.set(runId, stored);
+        if (name !== undefined)
+            this.#activeNameToRunId.set(name, runId);
         const parentSignal = request.signal ?? _legacyParentSignal;
         if (parentSignal) {
             const onAbort = () => this.#cancelRun(stored);
@@ -98,20 +139,192 @@ export class SubagentAsyncRegistry {
             if (parentSignal.aborted)
                 onAbort();
         }
-        this.#runs.set(runId, stored);
         safeEmit(this.#logger, this.#onEvent, {
             type: 'subagent_started',
             agentId: runId,
+            ...(name !== undefined ? { name } : {}),
             role,
             task: request.task,
-            parentTool: request.parentTool ?? 'run_subagent_async',
+            parentTool: request.parentTool ?? 'run_subagent',
             async: true,
         });
-        void this.#execute(stored, request);
-        return { runId, role, status: 'running', task: request.task };
+        this.#startSegment(stored, request, request.task);
+        return { runId, role, ...(name !== undefined ? { name } : {}), status: 'running', task: request.task };
+    }
+    /**
+     * Atomically publishes an already-running foreground child. Unlike
+     * startRun this never constructs a session runner or dispatches provider
+     * work; the supplied lease retains the exact live execution.
+     */
+    adoptForegroundLease(lease, request) {
+        if (this.#disposed)
+            throw new Error('Subagent async registry is disposed');
+        if (lease.adopted || lease.settled)
+            throw new Error(`Foreground subagent lease ${lease.runId} is not adoptable.`);
+        if (this.#runs.has(lease.runId) || this.#evicted.has(lease.runId)) {
+            throw new Error(`Async subagent run id ${lease.runId} is already retained.`);
+        }
+        if (!['explorer', 'worker', 'mentor', 'librarian'].includes(request.role)) {
+            throw new SubagentRegistryError('not_continuable', `Unknown subagent role: ${request.role}`);
+        }
+        if (request.name !== undefined &&
+            (this.#activeNameToRunId.has(request.name) || !SUBAGENT_RUN_NAME_PATTERN.test(request.name))) {
+            throw new SubagentRegistryError(this.#activeNameToRunId.has(request.name) ? 'name_in_use' : 'invalid_name', `Invalid or active async subagent name: ${request.name}`);
+        }
+        // Validate every possible rejection before changing foreground ownership.
+        this.#evictToSessionCap();
+        const session = this.#sessionForRole?.(request.role) ?? new SubagentSession(lease.runId, request.role);
+        for (const active of this.#runs.values()) {
+            if (isActiveStatus(active.status) && active.session === session) {
+                throw new SubagentRegistryError('already_active', `Session for role ${request.role} is already active`);
+            }
+        }
+        let resolve;
+        const promise = new Promise((r) => (resolve = r));
+        const stored = {
+            runId: lease.runId,
+            role: request.role,
+            task: request.task,
+            ...(request.name !== undefined ? { name: request.name } : {}),
+            session,
+            status: 'running',
+            control: new SubagentRunControl(),
+            evidence: { filesChanged: new Set(), toolsUsed: new Map(), diffStat: new Map() },
+            lastUsedAt: this.#now(),
+            resolve,
+            promise,
+            settled: false,
+            startedAt: this.#now(),
+            toolCounts: new Map(),
+            turnHistory: [],
+            pendingToolCounts: new Map(),
+            currentText: '',
+            lease,
+        };
+        this.#runs.set(lease.runId, stored);
+        if (request.name !== undefined)
+            this.#activeNameToRunId.set(request.name, lease.runId);
+        try {
+            lease.adopt();
+        }
+        catch (error) {
+            this.#runs.delete(lease.runId);
+            if (request.name !== undefined)
+                this.#activeNameToRunId.delete(request.name);
+            throw error;
+        }
+        safeEmit(this.#logger, this.#onEvent, {
+            type: 'subagent_started',
+            agentId: lease.runId,
+            role: request.role,
+            task: request.task,
+            parentTool: request.parentTool ?? 'run_subagent',
+            async: true,
+        });
+        return { runId: lease.runId, role: request.role, status: 'running', task: request.task };
     }
     hasActiveRunForRole(role) {
-        return [...this.#runs.values()].some((run) => run.role === role && run.status === 'running');
+        return [...this.#runs.values()].some((run) => run.role === role && isActiveStatus(run.status));
+    }
+    /**
+     * Non-blocking progress snapshot for one run, or all non-evicted runs when
+     * `runId` is omitted. Never awaits a run promise and never carries
+     * completion detail — that stays on `get_subagent_result`.
+     */
+    getRunStatus(runId) {
+        if (runId !== undefined) {
+            const run = this.#runs.get(runId);
+            if (!run)
+                return {
+                    runId,
+                    role: '',
+                    status: 'not_found',
+                    task: '',
+                    taskPreview: '',
+                    startedAt: 0,
+                    elapsedMs: 0,
+                    toolCounts: {},
+                };
+            return this.#snapshot(run);
+        }
+        // Live runs first, then settled; neither carries finalText.
+        const live = [...this.#runs.values()].filter((run) => isActiveStatus(run.status));
+        const settled = [...this.#runs.values()].filter((run) => !isActiveStatus(run.status));
+        return [...live, ...settled].map((run) => this.#snapshot(run));
+    }
+    #snapshot(run) {
+        const counts = mapToRecord(run.toolCounts);
+        const pendingToolCounts = mapToRecord(run.pendingToolCounts);
+        return {
+            runId: run.runId,
+            ...(run.name !== undefined ? { name: run.name } : {}),
+            role: run.role,
+            status: run.lease?.getPendingApproval() ? 'awaiting_approval' : run.status,
+            task: run.task,
+            taskPreview: truncatePreview(run.task),
+            startedAt: run.startedAt,
+            elapsedMs: this.#now() - run.startedAt,
+            ...(run.lastToolName !== undefined ? { lastToolName: run.lastToolName } : {}),
+            ...(run.lastToolAt !== undefined ? { lastToolAt: run.lastToolAt } : {}),
+            toolCounts: counts,
+            ...(run.turnHistory.length > 0
+                ? {
+                    turnHistory: run.turnHistory.map((turn) => ({
+                        text: turn.text,
+                        precedingToolCounts: { ...turn.precedingToolCounts },
+                        truncated: turn.truncated,
+                    })),
+                }
+                : {}),
+            ...(run.currentText.trim() ? { currentText: run.currentText } : {}),
+            ...(Object.keys(pendingToolCounts).length > 0 ? { pendingToolCounts } : {}),
+        };
+    }
+    /**
+     * Receive a conversation event and update the owning run's peek progress.
+     * No-op for events whose `agentId` is not a run this registry owns (sync /
+     * nested subagent events are ignored here). This is the only path by which
+     * the registry learns `subagent_tool_started` mid-run.
+     */
+    handleSubagentEvent(event) {
+        if (event.type === 'subagent_completed') {
+            const run = this.#runs.get(event.result.agentId);
+            if (run?.lease && !run.settled) {
+                this.#accumulateEvidence(run.evidence, event.result);
+                this.#settle(run, this.#assembleTerminalResult(run, event.result), false);
+            }
+            return;
+        }
+        if (event.type !== 'subagent_tool_started' &&
+            event.type !== 'subagent_text_turn' &&
+            event.type !== 'subagent_streaming_text')
+            return;
+        const run = this.#runs.get(event.agentId);
+        if (!run || !isActiveStatus(run.status))
+            return;
+        if (event.type === 'subagent_streaming_text') {
+            run.currentText = event.text;
+            return;
+        }
+        if (event.type === 'subagent_text_turn') {
+            run.turnHistory.push({
+                text: event.text.slice(0, TURN_TEXT_CHAR_LIMIT),
+                precedingToolCounts: mapToRecord(run.pendingToolCounts),
+                truncated: event.text.length > TURN_TEXT_CHAR_LIMIT,
+            });
+            if (run.turnHistory.length > MAX_TURN_HISTORY)
+                run.turnHistory.shift();
+            run.pendingToolCounts.clear();
+            run.currentText = '';
+            return;
+        }
+        const name = event.toolName;
+        if (!name)
+            return;
+        run.toolCounts.set(name, (run.toolCounts.get(name) ?? 0) + 1);
+        run.pendingToolCounts.set(name, (run.pendingToolCounts.get(name) ?? 0) + 1);
+        run.lastToolName = name;
+        run.lastToolAt = this.#now();
     }
     getResult(runId, signal) {
         const run = this.#runs.get(runId);
@@ -126,41 +339,86 @@ export class SubagentAsyncRegistry {
     }
     abortRun(runId) {
         const run = this.#runs.get(runId);
-        if (run?.status === 'running')
+        if (run && isActiveStatus(run.status))
             this.#cancelRun(run);
     }
+    /**
+     * Non-blocking public cancellation addressed by canonical runId first, then
+     * its active name. `abortRun` remains the internal user-stop compatibility API.
+     */
+    cancelRun(target) {
+        const run = this.#resolveActiveTarget(target);
+        if (!run)
+            return { ok: false, code: 'not_active', target };
+        this.#cancelRun(run);
+        return { ok: true, runId: run.runId, status: 'cancelling' };
+    }
+    /**
+     * Queue bounded steering for an active execution run without awaiting its result.
+     * Canonical active run ids are resolved before active names.
+     */
+    sendMessage(target, guidance, replyToParam) {
+        // OpenAI strict tool schemas turn optional params into nullable-with-null-default,
+        // so an absent reply_to arrives as null. Treat it as absent, not as an answer.
+        const replyTo = replyToParam ?? undefined;
+        const run = this.#resolveActiveTarget(target);
+        if (!run)
+            return { ok: false, code: 'not_active', target };
+        // An adopted nested loop has no steering segment consumer. Do not accept
+        // guidance that cannot be delivered; a later lease control port may add
+        // that capability explicitly.
+        if (run.lease)
+            return { ok: false, code: 'unsupported_control', target };
+        if (run.role === 'mentor')
+            return { ok: false, code: 'unsupported_control', target };
+        const message = guidance.trim();
+        if (message.length === 0 || message.length > MAX_STEERING_GUIDANCE_CHARACTERS) {
+            return { ok: false, code: 'invalid_guidance', target };
+        }
+        if (run.status === 'cancelling') {
+            return replyTo === undefined
+                ? { ok: false, code: 'not_active', target }
+                : { ok: false, code: 'question_not_pending', target };
+        }
+        if (replyTo !== undefined) {
+            const pending = run.control.pendingQuestion;
+            if (!pending)
+                return { ok: false, code: 'question_not_pending', target };
+            if (pending.messageId !== replyTo)
+                return { ok: false, code: 'question_mismatch', target };
+            if (!run.control.answer(replyTo, message))
+                return { ok: false, code: 'question_not_pending', target };
+            run.status = 'running';
+            return { ok: true, runId: run.runId, status: 'running', delivery: 'answered' };
+        }
+        // Steering cannot reach a waiting `ask_orchestrator` call: it is queued behind a
+        // tool that only an answer resumes. Refusing it keeps the blocker visible instead
+        // of stranding the run on an acknowledgement the orchestrator reads as handled.
+        if (run.control.pendingQuestion)
+            return { ok: false, code: 'question_pending', target };
+        if (!run.control.canStartContinuation())
+            return { ok: false, code: 'steer_limit_reached', target };
+        run.control.enqueueSteering(message);
+        return { ok: true, runId: run.runId, status: 'running', delivery: 'queued' };
+    }
     cancelAllRuns() {
         for (const run of this.#runs.values())
-            if (run.status === 'running')
+            if (isActiveStatus(run.status))
                 this.#cancelRun(run);
     }
     #cancelRun(run) {
-        if (run.status !== 'running')
+        if (run.status !== 'running' && run.status !== 'waiting_for_answer')
             return;
-        run.abortController.abort();
-        const result = {
-            agentId: run.runId,
-            role: run.role,
-            status: 'cancelled',
-            finalText: '',
-            filesChanged: [],
-            toolsUsed: [],
-            error: 'The subagent run was aborted.',
-        };
-        run.status = 'cancelled';
-        run.result = result;
-        run.lastUsedAt = this.#now();
-        run.settled = true;
-        run.removeParentAbortListener?.();
-        run.resolve(result);
-        safeEmit(this.#logger, this.#onEvent, { type: 'subagent_completed', result, async: true });
+        run.status = 'cancelling';
+        run.lease?.cancel();
+        run.control.requestCancellation();
     }
     reset() {
-        for (const run of this.#runs.values())
-            if (run.status === 'running')
-                run.abortController.abort();
         this.cancelAllRuns();
-        this.#runs.clear();
+        for (const [runId, run] of this.#runs) {
+            if (!isActiveStatus(run.status))
+                this.#runs.delete(runId);
+        }
         this.#sessions.clear();
         this.#evicted.clear();
     }
@@ -171,10 +429,22 @@ export class SubagentAsyncRegistry {
         this.#clearInterval(this.#timer);
         this.reset();
     }
+    /**
+     * Cancels retained adopted leases and waits for their terminal settlement.
+     * Session composition owns sink detachment and calls this before disconnecting
+     * its durable background-event and approval-pause consumers.
+     */
+    async disposeAndWaitForAdoptedLeases() {
+        const adoptedSettlements = [...this.#runs.values()]
+            .filter((run) => run.lease && !run.settled)
+            .map((run) => run.promise);
+        this.dispose();
+        await Promise.all(adoptedSettlements);
+    }
     #evictToSessionCap() {
         while (this.#sessions.size > this.#sessionCap) {
             const candidate = [...this.#runs.values()]
-                .filter((run) => run.status !== 'running')
+                .filter((run) => !isActiveStatus(run.status))
                 .sort((a, b) => a.lastUsedAt - b.lastUsedAt)[0];
             if (!candidate)
                 return;
@@ -193,21 +463,79 @@ export class SubagentAsyncRegistry {
     #evictExpired() {
         const cutoff = this.#now() - this.#ttlMs;
         for (const [id, run] of this.#runs) {
-            if (run.status !== 'running' && run.lastUsedAt <= cutoff) {
+            if (!isActiveStatus(run.status) && run.lastUsedAt <= cutoff) {
                 this.#runs.delete(id);
                 this.#evicted.add(id);
             }
         }
     }
-    async #execute(run, request) {
+    /**
+     * Allocate a fresh run id, retrying the factory against an active, settled, or
+     * evicted id. A collision would silently overwrite a stored run, so even the
+     * vanishingly unlikely codename collision is defended here rather than
+     * relying on the factory's entropy alone.
+     */
+    /**
+     * Scopes the run's provider traffic to the run, under whichever context
+     * launched it — so a background subagent started by another subagent nests
+     * beneath its parent instead of flattening back onto the conversation.
+     */
+    #deriveTrafficContext(runId) {
+        const launchContext = this.#sessionContextService?.getContext();
+        if (!launchContext)
+            return undefined;
+        const parentKey = launchContext.providerHistoryKey ?? launchContext.sessionId;
+        return { ...launchContext, providerHistoryKey: `${parentKey}:subagent:${runId}` };
+    }
+    #allocateRunId() {
+        for (let attempt = 0; attempt < MAX_RUN_ID_ATTEMPTS; attempt++) {
+            const candidate = this.#createRunId();
+            if (!this.#runs.has(candidate) && !this.#evicted.has(candidate))
+                return candidate;
+        }
+        return this.#createRunId();
+    }
+    #resolveActiveTarget(target) {
+        const byRunId = this.#runs.get(target);
+        if (byRunId && isActiveStatus(byRunId.status))
+            return byRunId;
+        const byName = this.#activeNameToRunId.get(target);
+        if (!byName)
+            return undefined;
+        const run = this.#runs.get(byName);
+        return run && isActiveStatus(run.status) ? run : undefined;
+    }
+    #startSegment(run, request, input) {
+        if (run.settled)
+            return;
+        const controller = run.control.beginSegment();
+        void this.#executeSegment(run, request, input, controller);
+    }
+    async #executeSegment(run, request, input, controller) {
         let result;
         try {
-            result = await this.#run({ request, runId: run.runId, session: run.session, signal: run.abortController.signal });
+            const runSegment = () => this.#run({
+                request,
+                runId: run.runId,
+                session: run.session,
+                signal: controller.signal,
+                input,
+                control: {
+                    onToolStart: () => run.control.onToolStart(),
+                    onToolComplete: () => run.control.onToolComplete(),
+                    askOrchestrator: (question) => this.#askOrchestrator(run, question),
+                },
+            });
+            // Every segment — first launch, `continue_run_id`, steering continuation —
+            // runs under the run's own context, so they share one provider-side session.
+            result = await (run.trafficContext && this.#sessionContextService
+                ? this.#sessionContextService.runWithContext(run.trafficContext, runSegment)
+                : runSegment());
             run.session.trimHistory(this.#messageCap);
             result = { ...result, agentId: run.runId };
         }
         catch (error) {
-            const cancelled = isAbortLike(error?.message, error) || run.abortController.signal.aborted;
+            const cancelled = isAbortLike(error?.message, error) || controller.signal.aborted;
             result = {
                 agentId: run.runId,
                 role: run.role,
@@ -218,16 +546,107 @@ export class SubagentAsyncRegistry {
                 error: error?.message ?? String(error),
             };
         }
-        // Explicit cancellation is terminal and wins over a late executor result.
+        run.control.endSegment(controller);
+        this.#accumulateEvidence(run.evidence, result);
+        if (run.control.cancellationRequested) {
+            this.#settle(run, this.#assembleTerminalResult(run, result));
+            return;
+        }
+        const guidance = run.control.consumeSteering();
+        if (guidance !== undefined && run.control.startContinuation()) {
+            this.#startSegment(run, request, buildContinuationInput(guidance));
+            return;
+        }
+        this.#settle(run, this.#assembleTerminalResult(run, result));
+    }
+    #settle(run, result, emit = true) {
         if (run.settled)
             return;
         run.status = result.status;
         run.result = result;
         run.lastUsedAt = this.#now();
         run.settled = true;
+        if (run.name !== undefined && this.#activeNameToRunId.get(run.name) === run.runId) {
+            this.#activeNameToRunId.delete(run.name);
+        }
+        run.control.settle();
+        run.lease?.settle();
         run.removeParentAbortListener?.();
         run.resolve(result);
-        safeEmit(this.#logger, this.#onEvent, { type: 'subagent_completed', result, async: true });
+        if (emit && !this.#disposed)
+            safeEmit(this.#logger, this.#onEvent, { type: 'subagent_completed', result, async: true });
+    }
+    #askOrchestrator(run, question) {
+        if (run.status !== 'running')
+            return Promise.reject(new Error('The subagent run is no longer accepting questions.'));
+        const asked = run.control.ask(question);
+        run.status = 'waiting_for_answer';
+        safeEmit(this.#logger, this.#onEvent, {
+            type: 'subagent_question',
+            async: true,
+            messageId: asked.messageId,
+            runId: run.runId,
+            ...(run.name !== undefined ? { name: run.name } : {}),
+            role: run.role,
+            question: asked.question,
+        });
+        return asked.answer;
+    }
+    #assembleTerminalResult(run, segment) {
+        const status = run.control.cancellationRequested ? 'cancelled' : segment.status;
+        const error = status === 'cancelled'
+            ? segment.status === 'cancelled' && segment.error
+                ? segment.error
+                : 'The subagent run was aborted.'
+            : segment.error;
+        const usage = run.evidence.usage;
+        const diffStat = [...run.evidence.diffStat.values()];
+        return {
+            agentId: run.runId,
+            ...(run.name !== undefined ? { name: run.name } : {}),
+            role: run.role,
+            status,
+            finalText: status === 'completed' ? segment.finalText : '',
+            filesChanged: [...run.evidence.filesChanged],
+            toolsUsed: [...run.evidence.toolsUsed].map(([toolName, count]) => ({ toolName, count })),
+            ...(error ? { error } : {}),
+            ...(usage ? { usage } : {}),
+            ...(diffStat.length > 0 ? { diffStat } : {}),
+            ...(run.evidence.validation ? { validation: run.evidence.validation } : {}),
+        };
     }
+    #accumulateEvidence(evidence, result) {
+        for (const path of result.filesChanged)
+            evidence.filesChanged.add(path);
+        for (const { toolName, count } of result.toolsUsed) {
+            evidence.toolsUsed.set(toolName, (evidence.toolsUsed.get(toolName) ?? 0) + count);
+        }
+        for (const entry of result.diffStat ?? []) {
+            const existing = evidence.diffStat.get(entry.path);
+            evidence.diffStat.set(entry.path, {
+                path: entry.path,
+                added: (existing?.added ?? 0) + entry.added,
+                deleted: (existing?.deleted ?? 0) + entry.deleted,
+            });
+        }
+        if (result.validation)
+            evidence.validation = result.validation;
+        if (result.usage)
+            evidence.usage = addTokenUsage(evidence.usage, result.usage);
+    }
+}
+function isActiveStatus(status) {
+    return status === 'running' || status === 'waiting_for_answer' || status === 'cancelling';
+}
+function mapToRecord(counts) {
+    return Object.fromEntries(counts);
+}
+function buildContinuationInput(guidance) {
+    return [
+        'Your prior segment was interrupted. Completed side effects may remain.',
+        'Before following this guidance, inspect and reconcile current work and any partial results.',
+        'Coalesced steering guidance:',
+        guidance,
+    ].join('\n\n');
 }
 //# sourceMappingURL=subagent-async-registry.js.map