awb-agent-manager 1.0.0

package/dist/lib/subagent-manager.js

@@ -0,0 +1,793 @@
+import { promises as fsp } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { createInterface } from 'node:readline';
+import { spawn } from 'node:child_process';
+import { SUBAGENTS_BASE_DIR, SUBAGENTS_PERSIST_PATH, TTL_SWEEP_INTERVAL_MS, SIGTERM_GRACE_MS, STOP_GRACE_MS, } from './constants.js';
+import { log } from './logging.js';
+import { createAdapter } from './cli-adapters/index.js';
+import { ADAPTER_CAPABILITIES, describeHarness, partitionHarness, selectEffortSlice, } from './cli-adapters/base.js';
+import { CircuitBreaker } from './circuit-breaker.js';
+import { classifyCliError } from './cli-error-signatures.js';
+import { summarizeCliJsonLine } from './cli-output-summary.js';
+import { fireAndForgetTool } from './mcp-client.js';
+import { postChatRoomMessage, postSilentExitSystemComment, } from './rest.js';
+const { NATIVE_MCP } = ADAPTER_CAPABILITIES;
+const TAIL_RING_MAX_LINES = 100;
+const SILENT_EXIT_TAIL_MAX_CHARS = 4096;
+const TICKET_COMMENT_TOOL_SUFFIXES = [
+    'add_comment',
+    'ask_question',
+    'answer_question',
+    'record_decision',
+    'handoff_to_agent',
+];
+export function findDuplicateSpawn(records, spec) {
+    const specRole = spec.role || '';
+    const specAgent = spec.agentId || '';
+    for (const rec of records) {
+        if (spec.triggerId && rec.trigger_id === spec.triggerId) {
+            return 'duplicate_trigger';
+        }
+        if (spec.chatRequestId && rec.chat_request_id === spec.chatRequestId) {
+            return 'duplicate_chat';
+        }
+        if (spec.kind === 'trigger' &&
+            !(spec.triggerId || '').startsWith('mention:') &&
+            spec.ticketId &&
+            rec.ticket_id === spec.ticketId &&
+            (rec.role || '') === specRole &&
+            (!specAgent || !(rec.agent_id || '') || (rec.agent_id || '') === specAgent)) {
+            return 'duplicate_trigger';
+        }
+    }
+    return false;
+}
+export function mentionTriggerId(commentId, agentId) {
+    return `mention:${commentId}:${agentId || ''}`;
+}
+export class SubagentManager {
+    #map = new Map();
+    #config;
+    #adapters = new Map();
+    #sweepTimer = null;
+    #reservationCounter = 0;
+    #persistPath;
+    #pidDir;
+    #initialized = false;
+    #monitor = null;
+    circuitBreaker;
+    onExit;
+    constructor(config, circuitBreaker) {
+        this.#config = config;
+        this.#persistPath = SUBAGENTS_PERSIST_PATH;
+        this.#pidDir = SUBAGENTS_BASE_DIR;
+        this.circuitBreaker = circuitBreaker ?? new CircuitBreaker();
+    }
+    setMonitor(monitor) {
+        this.#monitor = monitor;
+    }
+    async init() {
+        if (this.#initialized)
+            return;
+        this.#initialized = true;
+        try {
+            await fsp.mkdir(this.#pidDir, { recursive: true, mode: 0o700 });
+        }
+        catch (err) {
+            log(`SubagentManager: mkdir failed: ${err?.message ?? err}`);
+        }
+        await this.#reconcileOnStart();
+        await this.#sweepOrphanCfgs();
+        this.#sweepTimer = setInterval(() => this.#sweep(), TTL_SWEEP_INTERVAL_MS);
+        this.#sweepTimer.unref?.();
+        log(`SubagentManager initialized (per-agent cli, pidDir=${this.#pidDir}, cap=${this.#config.delegation.maxConcurrent}, ttl=${this.#config.delegation.ttlMinutes}min)`);
+    }
+    #adapterFor(cli) {
+        const t = String(cli || 'claude').toLowerCase();
+        let a = this.#adapters.get(t);
+        if (!a) {
+            a = createAdapter(t);
+            this.#adapters.set(t, a);
+        }
+        return a;
+    }
+    get adapter() {
+        return this.#adapterFor('claude');
+    }
+    async #sweepOrphanCfgs() {
+        let files;
+        try {
+            files = await fsp.readdir(this.#pidDir);
+        }
+        catch (err) {
+            log(`Orphan cfg sweep: readdir failed: ${err?.message ?? err}`);
+            return;
+        }
+        const liveCfgs = new Set();
+        for (const rec of this.#map.values()) {
+            if (rec.kind !== 'reservation' && rec.config_path)
+                liveCfgs.add(rec.config_path);
+        }
+        try {
+            const procEntries = await fsp.readdir('/proc');
+            for (const entry of procEntries) {
+                if (!/^\d+$/.test(entry))
+                    continue;
+                try {
+                    const cmdline = await fsp.readFile(`/proc/${entry}/cmdline`, 'utf8');
+                    const parts = cmdline.split('\0');
+                    const idx = parts.indexOf('--mcp-config');
+                    if (idx >= 0 && parts[idx + 1])
+                        liveCfgs.add(parts[idx + 1]);
+                }
+                catch {
+                }
+            }
+        }
+        catch {
+        }
+        let purged = 0;
+        for (const f of files) {
+            if (!f.startsWith('cfg-') || !f.endsWith('.json'))
+                continue;
+            const path = join(this.#pidDir, f);
+            if (liveCfgs.has(path))
+                continue;
+            try {
+                await fsp.unlink(path);
+                purged++;
+            }
+            catch {
+            }
+        }
+        if (purged > 0)
+            log(`Orphan cfg sweep: purged ${purged} stale config file(s)`);
+    }
+    canSpawn() {
+        const active = this.#activeCount();
+        return active < (this.#config.delegation.maxConcurrent ?? 5);
+    }
+    #activeCount() {
+        let n = 0;
+        for (const _ of this.#map.values())
+            n++;
+        return n;
+    }
+    async spawn(spec) {
+        const dup = findDuplicateSpawn(this.#map.values(), spec);
+        if (dup) {
+            return { spawned: false, reason: dup };
+        }
+        if (spec.kind === 'trigger' && spec.ticketId && spec.agentId) {
+            const cbKey = CircuitBreaker.key(spec.agentId, spec.ticketId, spec.role || '');
+            const blockReason = this.circuitBreaker.shouldBlock(cbKey);
+            if (blockReason) {
+                log(`[subagent] spawn blocked by circuit-breaker: ticket=${spec.ticketId.slice(0, 8)} ` +
+                    `role=${spec.role || '_'} agent=${spec.agentId.slice(0, 8)} — ${blockReason}`);
+                return { spawned: false, reason: 'circuit_breaker_open' };
+            }
+        }
+        if (!this.canSpawn()) {
+            return { spawned: false, reason: 'cap_reached' };
+        }
+        const reservationId = -(++this.#reservationCounter);
+        this.#map.set(reservationId, {
+            kind: 'reservation',
+            started_at: Date.now(),
+            trigger_id: spec.triggerId || null,
+            chat_request_id: spec.chatRequestId || null,
+            ticket_id: spec.ticketId || null,
+            role: spec.role || null,
+            agent_id: spec.agentId || null,
+        });
+        const ctx = spec.agentContext;
+        const adapter = this.#adapterFor(ctx?.cli);
+        const effectiveApiKey = ctx?.api_key || this.#config.apiKey;
+        const effectiveCwd = ctx?.cwd || undefined;
+        const { applied: harness, skipped: harnessSkipped } = partitionHarness(adapter, spec.harness);
+        if (harnessSkipped.length > 0) {
+            log(`[subagent] harness keys skipped (cli=${adapter.cliType} can't express them): ${harnessSkipped.join(', ')}`);
+        }
+        if (harness) {
+            log(`[subagent] harness applied: ticket=${spec.ticketId.slice(0, 8) || '-'} cli=${adapter.cliType} ${describeHarness(harness)}`);
+        }
+        const slice = selectEffortSlice(adapter.cliType, spec.effortPreset);
+        const effectiveModel = slice?.model ?? harness?.model ?? ctx?.model ?? null;
+        const effortFlag = slice?.effort ?? null;
+        const ultracode = !!slice?.ultracode;
+        if (slice && (effortFlag || ultracode || slice.model)) {
+            log(`[subagent] effort applied: ticket=${spec.ticketId.slice(0, 8) || '-'} cli=${adapter.cliType} ` +
+                `effort=${effortFlag ?? '-'} ultracode=${ultracode} model=${slice.model ?? '-'}`);
+        }
+        let configPath = null;
+        let configPathIsTemp = false;
+        try {
+            const descriptor = adapter.buildOneshotSpawn({
+                rolePrompt: spec.rolePrompt || '',
+                taskText: spec.taskText,
+                mcpConfigPath: null,
+                model: effectiveModel,
+                harness,
+                effort: effortFlag,
+                ultracode,
+            });
+            if (descriptor.needsMcpConfig) {
+                const needsSessionPin = !!(spec.ticketId && spec.role);
+                if (ctx?.mcp_config_path && !needsSessionPin) {
+                    configPath = ctx.mcp_config_path;
+                    configPathIsTemp = false;
+                }
+                else {
+                    configPath = join(this.#pidDir, `cfg-${Date.now()}-${Math.random().toString(36).slice(2)}.json`);
+                    configPathIsTemp = true;
+                    await fsp.mkdir(dirname(configPath), { recursive: true, mode: 0o700 });
+                    const headers = {
+                        Authorization: `Bearer ${effectiveApiKey}`,
+                        'X-AWB-Client-Type': ctx ? 'managed-subagent' : 'subagent',
+                    };
+                    if (spec.ticketId)
+                        headers['X-AWB-Subagent-Ticket-Id'] = spec.ticketId;
+                    if (spec.role)
+                        headers['X-AWB-Subagent-Role'] = spec.role;
+                    if (spec.triggerSource)
+                        headers['X-AWB-Subagent-Trigger-Source'] = spec.triggerSource;
+                    const mcpConfig = {
+                        mcpServers: {
+                            awb: {
+                                type: 'http',
+                                url: `${this.#config.url.replace(/\/$/, '')}/mcp`,
+                                headers,
+                            },
+                        },
+                    };
+                    await fsp.writeFile(configPath, JSON.stringify(mcpConfig), { mode: 0o600 });
+                }
+                Object.assign(descriptor, adapter.buildOneshotSpawn({
+                    rolePrompt: spec.rolePrompt || '',
+                    taskText: spec.taskText,
+                    mcpConfigPath: configPath,
+                    model: effectiveModel,
+                    harness,
+                    effort: effortFlag,
+                    ultracode,
+                }));
+            }
+            const binOverride = adapter.cliType === 'claude' ? this.#config.delegation.claudeBin : null;
+            const resolvedBin = adapter.resolveBin(binOverride);
+            const cliHomeEnvKey = adapter.configDirEnv();
+            const cliHomeEnv = cliHomeEnvKey && ctx?.cli_home_dir
+                ? { [cliHomeEnvKey]: ctx.cli_home_dir }
+                : {};
+            const credentialEnv = ctx?.extra_env ?? {};
+            const baseEnv = { ...process.env };
+            if (ctx?.credential_provider) {
+                const stripped = [];
+                for (const k of adapter.authEnvKeys()) {
+                    if (k in baseEnv) {
+                        delete baseEnv[k];
+                        stripped.push(k);
+                    }
+                }
+                if (stripped.length > 0) {
+                    log(`Subagent env strip: agent=${ctx.agent_id.slice(0, 8)} provider=${ctx.credential_provider} ` +
+                        `removed=${stripped.join(',')} (operator-inherited auth would have overridden per-agent credential)`);
+                }
+            }
+            const child = spawn(resolvedBin, descriptor.args, {
+                stdio: descriptor.stdio || ['ignore', 'pipe', 'pipe'],
+                detached: process.platform !== 'win32',
+                windowsHide: true,
+                cwd: effectiveCwd,
+                env: {
+                    ...baseEnv,
+                    ...(spec.envVars ?? {}),
+                    AWB_API_KEY: effectiveApiKey,
+                    ...cliHomeEnv,
+                    ...credentialEnv,
+                    ...adapter.harnessEnv(harness),
+                },
+                shell: descriptor.shell ?? /\.(cmd|bat|ps1)$/i.test(resolvedBin),
+            });
+            child.once('error', (err) => {
+                log(`Subagent spawn error: code=${err?.code || ''} cli=${adapter.cliType} bin=${resolvedBin} msg=${err?.message}`);
+            });
+            child.unref();
+            const pid = child.pid;
+            if (!pid) {
+                if (configPath)
+                    await fsp.unlink(configPath).catch(() => { });
+                this.#map.delete(reservationId);
+                return { spawned: false, reason: 'spawn_failed' };
+            }
+            if (typeof descriptor.writePrompt === 'function') {
+                try {
+                    descriptor.writePrompt(child);
+                }
+                catch (err) {
+                    log(`Subagent writePrompt failed: ${err?.message ?? err}`);
+                }
+            }
+            const record = {
+                pid,
+                kind: spec.kind,
+                cli_type: adapter.cliType,
+                trigger_id: spec.triggerId || null,
+                chat_request_id: spec.chatRequestId || null,
+                ticket_id: spec.ticketId || null,
+                agent_id: spec.agentId || null,
+                role: spec.role || null,
+                room_id: spec.roomId || null,
+                started_at: Date.now(),
+                expected_completion_at: Date.now() + (this.#config.delegation.ttlMinutes ?? 15) * 60_000,
+                config_path: configPath,
+                config_path_is_temp: configPathIsTemp,
+                process_handle: child,
+                captureOutput: !adapter.has(NATIVE_MCP),
+                outLines: [],
+                tailLines: [],
+                commentSent: false,
+                tap: null,
+            };
+            record.tap =
+                this.#monitor?.register({
+                    kind: 'oneshot',
+                    sessionKey: spec.triggerId
+                        ? `oneshot:trigger:${spec.triggerId}`
+                        : spec.chatRequestId
+                            ? `oneshot:chat:${spec.chatRequestId}`
+                            : `oneshot:${pid}`,
+                    pid,
+                    apiKey: ctx?.api_key,
+                }) || null;
+            this.#map.delete(reservationId);
+            this.#map.set(pid, record);
+            this.#persist();
+            this.#wireExitHandler(child, pid);
+            this.#wireStdioCapture(child, pid);
+            log(`Subagent spawned: pid=${pid} cli=${adapter.cliType} kind=${spec.kind} ticket=${spec.ticketId || '-'}`);
+            return { spawned: true, pid };
+        }
+        catch (err) {
+            this.#map.delete(reservationId);
+            if (configPath && configPathIsTemp) {
+                await fsp.unlink(configPath).catch(() => { });
+            }
+            log(`Subagent spawn error: ${err?.message ?? err}`);
+            return { spawned: false, reason: 'exception' };
+        }
+    }
+    #wireExitHandler(child, pid) {
+        child.once('exit', async (code, signal) => {
+            const record = this.#map.get(pid);
+            if (!record || record.kind === 'reservation')
+                return;
+            const durationSec = Math.round((Date.now() - record.started_at) / 1000);
+            this.#map.delete(pid);
+            this.#persist();
+            if (record.config_path && record.config_path_is_temp) {
+                try {
+                    await fsp.unlink(record.config_path);
+                }
+                catch {
+                }
+            }
+            record.tap?.end({ exit_code: code, signal });
+            await this._handleOneshotExit(record, code);
+            record.tailLines = [];
+            log(`Subagent exit: pid=${pid} cli=${record.cli_type || '-'} kind=${record.kind} code=${code} signal=${signal || '-'} duration=${durationSec}s`);
+            if (typeof this.onExit === 'function') {
+                try {
+                    this.onExit({ pid, record, code, signal, durationSec });
+                }
+                catch {
+                }
+            }
+        });
+        child.once('error', (err) => {
+            log(`Subagent spawn error pid=${pid}: ${err?.message ?? err}`);
+        });
+    }
+    async _handleOneshotExit(record, code) {
+        const pid = record.pid;
+        let errClass = classifyCliError(null);
+        if (record.captureOutput && (record.ticket_id || record.room_id)) {
+            try {
+                const answer = this.#adapterFor(record.cli_type).collectOneshotResult(record.outLines);
+                errClass = classifyCliError(answer, { exitCode: code });
+                if (record.room_id) {
+                    if (answer) {
+                        await this.#postOneshotChatAnswer(record, answer);
+                    }
+                    else if (code !== 0) {
+                        await this.#postOneshotChatAnswer(record, `⚠️ Agent가 응답하지 못했습니다 (exit code ${code ?? 'unknown'}).`);
+                    }
+                }
+                else if (answer) {
+                    if (code === 0 && !errClass.isFatal) {
+                        await this.#postOneshotAnswer(record, answer);
+                    }
+                    else {
+                        log(`Subagent one-shot result NOT posted as agent answer: ticket=${(record.ticket_id || '').slice(0, 8)} ` +
+                            `cli=${record.cli_type} code=${code} reason=${errClass.reason || (code !== 0 ? `nonzero_exit_${code}` : 'unknown')} ` +
+                            `— routing to system silent-exit fallback`);
+                    }
+                }
+            }
+            catch (err) {
+                log(`Subagent post-answer failed pid=${pid}: ${err?.message ?? err}`);
+            }
+        }
+        if (record.kind === 'trigger' && record.ticket_id && record.agent_id) {
+            const role = record.role || '';
+            const cbKey = CircuitBreaker.key(record.agent_id, record.ticket_id, role);
+            if (record.commentSent && code === 0) {
+                this.circuitBreaker.reset(cbKey);
+            }
+            else if (!CircuitBreaker.isTransientExit(code) || errClass.nonRetryable) {
+                const tail = this.#collectTail(record);
+                const { justOpened, entry } = this.circuitBreaker.record(cbKey, code, tail, {
+                    forceOpen: errClass.nonRetryable,
+                });
+                if (justOpened) {
+                    const exitDesc = errClass.reason
+                        ? errClass.reason
+                        : code === 0
+                            ? 'clean exit with no comment'
+                            : `exit code ${code}`;
+                    const reason = `Agent failed ${entry.consecutiveFailures} consecutive time(s) (${exitDesc}). ` +
+                        `Last output: ${entry.lastExitTail || '(none)'}. ` +
+                        `Check agent CLI config/credentials and unpend when fixed.`;
+                    await fireAndForgetTool(this.#config, 'pend_ticket', {
+                        ticket_id: record.ticket_id,
+                        reason,
+                    });
+                }
+            }
+        }
+        if (record.ticket_id && (!record.commentSent || code !== 0)) {
+            try {
+                await this.#postSilentExitFallback(record, code);
+            }
+            catch (err) {
+                log(`Subagent silent-exit fallback failed pid=${pid}: ${err?.message ?? err}`);
+            }
+        }
+    }
+    #wireStdioCapture(child, pid) {
+        const tagFor = (record) => {
+            if (record && record.agent_id) {
+                return `[subagent:${pid}][agent:${record.agent_id.slice(0, 8)}]`;
+            }
+            return `[subagent:${pid}]`;
+        };
+        if (child.stdout) {
+            const rlOut = createInterface({ input: child.stdout });
+            rlOut.on('line', (line) => {
+                const rec = this.#map.get(pid);
+                const record = rec && rec.kind !== 'reservation' ? rec : undefined;
+                if (record) {
+                    record.tap?.outLine(line);
+                    if (record.captureOutput) {
+                        if (record.outLines.length < 10000)
+                            record.outLines.push(line);
+                    }
+                    this.#bufferTail(record, line);
+                    this.#scanForCommentTool(record, line);
+                }
+                log(`${tagFor(record)} ${line}`);
+            });
+        }
+        if (child.stderr) {
+            const rlErr = createInterface({ input: child.stderr });
+            rlErr.on('line', (line) => {
+                const rec = this.#map.get(pid);
+                const record = rec && rec.kind !== 'reservation' ? rec : undefined;
+                if (record)
+                    this.#bufferTail(record, line);
+                log(`${tagFor(record)}[err] ${line}`);
+            });
+        }
+    }
+    #bufferTail(record, line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        let entry = trimmed;
+        if (trimmed.startsWith('{')) {
+            entry = summarizeCliJsonLine(trimmed);
+            if (!entry)
+                return;
+        }
+        record.tailLines.push(entry);
+        while (record.tailLines.length > TAIL_RING_MAX_LINES)
+            record.tailLines.shift();
+    }
+    #scanForCommentTool(record, line) {
+        if (record.commentSent)
+            return;
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('{'))
+            return;
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            return;
+        }
+        if (parsed?.type !== 'assistant')
+            return;
+        const content = parsed?.message?.content;
+        if (!Array.isArray(content))
+            return;
+        for (const block of content) {
+            if (block?.type !== 'tool_use' || typeof block.name !== 'string')
+                continue;
+            for (const suffix of TICKET_COMMENT_TOOL_SUFFIXES) {
+                if (block.name.endsWith(suffix)) {
+                    record.commentSent = true;
+                    return;
+                }
+            }
+        }
+    }
+    async #postOneshotAnswer(record, answer) {
+        const MAX = 60_000;
+        const trimmed = answer.length > MAX ? answer.slice(0, MAX) + '\n\n…[truncated]' : answer;
+        await fireAndForgetTool(this.#config, 'add_comment', {
+            ticket_id: record.ticket_id,
+            content: trimmed,
+            type: 'note',
+        });
+        record.commentSent = true;
+        log(`Subagent posted answer to ticket=${record.ticket_id} (cli=${record.cli_type}, ${trimmed.length} chars)`);
+    }
+    async #postSilentExitFallback(record, code) {
+        const ticketId = record.ticket_id || '';
+        if (!ticketId)
+            return;
+        const tail = this.#collectTail(record);
+        const exitLabel = code === null ? 'null' : String(code);
+        const reasonLabel = code === 0
+            ? 'no audit-trail comments + clean exit'
+            : `non-zero exit code ${exitLabel}`;
+        const triggerId = record.trigger_id || '';
+        const header = `⚠️ Subagent exited without leaving a ticket comment (${reasonLabel}).`;
+        const metaParts = [];
+        metaParts.push(`cli=${record.cli_type}`);
+        metaParts.push(`exit_code=${exitLabel}`);
+        const classified = classifyCliError(tail, { exitCode: code });
+        if (classified.isFatal && classified.reason)
+            metaParts.push(`reason=${classified.reason}`);
+        if (triggerId)
+            metaParts.push(`trigger=${triggerId}`);
+        const metaLine = `_${metaParts.join(' · ')}_`;
+        const body = tail
+            ? `${header}\n\n${metaLine}\n\nLast CLI output:\n\`\`\`\n${tail}\n\`\`\``
+            : `${header}\n\n${metaLine}\n\n(no buffered CLI output captured)`;
+        log(`Subagent silent-exit fallback dispatched ticket=${ticketId.slice(0, 8)} pid=${record.pid} ` +
+            `cli=${record.cli_type} exit=${exitLabel} trigger=${triggerId.slice(0, 8) || '-'} outputLen=${tail.length}`);
+        await postSilentExitSystemComment(this.#config, ticketId, {
+            content: body,
+            exit_code: code,
+            cycle_trigger_id: triggerId,
+            actor_name: 'agent-manager',
+        });
+    }
+    #collectTail(record) {
+        if (!record.tailLines.length)
+            return '';
+        let body = record.tailLines.join('\n').trim();
+        if (body.length > SILENT_EXIT_TAIL_MAX_CHARS) {
+            body = '…' + body.slice(-SILENT_EXIT_TAIL_MAX_CHARS);
+        }
+        return body;
+    }
+    async #postOneshotChatAnswer(record, answer) {
+        const MAX = 60_000;
+        const trimmed = answer.length > MAX ? answer.slice(0, MAX) + '\n\n…[truncated]' : answer;
+        const agentId = record.agent_id || '';
+        await postChatRoomMessage(this.#config, record.room_id, agentId, trimmed);
+        log(`Subagent posted chat answer to room=${record.room_id} agent=${agentId.slice(0, 8)} (cli=${record.cli_type}, ${trimmed.length} chars)`);
+    }
+    #sweep() {
+        const now = Date.now();
+        for (const [pid, record] of this.#map.entries()) {
+            if (record.kind === 'reservation')
+                continue;
+            try {
+                process.kill(pid, 0);
+            }
+            catch (err) {
+                if (err?.code === 'ESRCH' || err?.code === 'EPERM') {
+                    log(`Sweep: pid=${pid} no longer alive, removing record`);
+                    this.#map.delete(pid);
+                    if (record.config_path && record.config_path_is_temp) {
+                        fsp.rm(dirname(record.config_path), { recursive: true, force: true }).catch(() => { });
+                    }
+                    continue;
+                }
+            }
+            if (now >= record.expected_completion_at) {
+                log(`Sweep: pid=${pid} exceeded TTL, sending SIGTERM`);
+                try {
+                    process.kill(pid, 'SIGTERM');
+                }
+                catch {
+                }
+                setTimeout(() => {
+                    try {
+                        process.kill(pid, 0);
+                        log(`Sweep: pid=${pid} still alive after SIGTERM grace, sending SIGKILL`);
+                        try {
+                            process.kill(pid, 'SIGKILL');
+                        }
+                        catch {
+                        }
+                    }
+                    catch {
+                    }
+                }, SIGTERM_GRACE_MS);
+            }
+        }
+        this.#persist();
+    }
+    async #reconcileOnStart() {
+        let raw;
+        try {
+            raw = await fsp.readFile(this.#persistPath, 'utf8');
+        }
+        catch {
+            return;
+        }
+        let persisted;
+        try {
+            persisted = JSON.parse(raw).pids || [];
+        }
+        catch {
+            return;
+        }
+        let revived = 0, dropped = 0;
+        for (const rec of persisted) {
+            if (!rec || !rec.pid)
+                continue;
+            try {
+                process.kill(rec.pid, 0);
+                this.#map.set(rec.pid, {
+                    ...rec,
+                    role: rec.role ?? null,
+                    config_path_is_temp: rec.config_path_is_temp ?? true,
+                    process_handle: null,
+                    outLines: rec.outLines || [],
+                    tailLines: [],
+                    commentSent: rec.commentSent ?? false,
+                });
+                revived++;
+            }
+            catch (err) {
+                if (err?.code === 'ESRCH' || err?.code === 'EPERM')
+                    dropped++;
+            }
+        }
+        if (revived || dropped) {
+            log(`SubagentManager reconciled: revived=${revived} dropped=${dropped}`);
+        }
+        this.#persist();
+    }
+    #persist() {
+        const pids = [];
+        for (const rec of this.#map.values()) {
+            if (rec.kind === 'reservation')
+                continue;
+            const { process_handle, outLines, tailLines, tap, ...serializable } = rec;
+            void process_handle;
+            void outLines;
+            void tailLines;
+            void tap;
+            pids.push(serializable);
+        }
+        fsp
+            .writeFile(this.#persistPath, JSON.stringify({ pids }, null, 2))
+            .catch((err) => log(`SubagentManager persist failed: ${err?.message ?? err}`));
+    }
+    async stopForAgent(agentId) {
+        if (!agentId)
+            return { count: 0, inflight: [] };
+        const victims = [];
+        for (const [pid, rec] of this.#map.entries()) {
+            if (rec.kind === 'reservation')
+                continue;
+            if (rec.agent_id !== agentId)
+                continue;
+            victims.push(rec);
+            this.#map.delete(pid);
+        }
+        if (victims.length === 0)
+            return { count: 0, inflight: [] };
+        for (const rec of victims) {
+            try {
+                process.kill(rec.pid, 'SIGTERM');
+            }
+            catch {
+            }
+        }
+        log(`SubagentManager stopForAgent: agent=${agentId.slice(0, 8)} signalled ${victims.length} one-shot subagent(s) — SIGTERM`);
+        setTimeout(() => {
+            for (const rec of victims) {
+                try {
+                    process.kill(rec.pid, 0);
+                    try {
+                        process.kill(rec.pid, 'SIGKILL');
+                    }
+                    catch {
+                    }
+                }
+                catch {
+                }
+                if (rec.config_path && rec.config_path_is_temp) {
+                    fsp.unlink(rec.config_path).catch(() => { });
+                }
+            }
+        }, STOP_GRACE_MS).unref?.();
+        this.#persist();
+        return {
+            count: victims.length,
+            inflight: victims.map((rec) => ({
+                ticket_id: rec.ticket_id,
+                role: rec.role,
+                room_id: rec.room_id,
+            })),
+        };
+    }
+    async stop() {
+        if (this.#sweepTimer) {
+            clearInterval(this.#sweepTimer);
+            this.#sweepTimer = null;
+        }
+        const pids = [];
+        for (const [pid, rec] of this.#map.entries()) {
+            if (rec.kind === 'reservation')
+                continue;
+            pids.push(pid);
+            try {
+                process.kill(pid, 'SIGTERM');
+            }
+            catch {
+            }
+        }
+        if (pids.length === 0) {
+            this.#map.clear();
+            return;
+        }
+        await new Promise((r) => setTimeout(r, STOP_GRACE_MS));
+        for (const pid of pids) {
+            try {
+                process.kill(pid, 'SIGKILL');
+            }
+            catch {
+            }
+        }
+        this.#map.clear();
+        try {
+            await fsp.writeFile(this.#persistPath, JSON.stringify({ pids: [] }, null, 2));
+        }
+        catch {
+        }
+        log(`SubagentManager stopped (terminated ${pids.length} children)`);
+    }
+    _snapshot() {
+        const out = [];
+        for (const rec of this.#map.values()) {
+            if (rec.kind === 'reservation')
+                continue;
+            const { process_handle, outLines, tailLines, tap, ...serializable } = rec;
+            void process_handle;
+            void outLines;
+            void tailLines;
+            void tap;
+            out.push(serializable);
+        }
+        return out;
+    }
+}
+//# sourceMappingURL=subagent-manager.js.map