@enderfga/claw-orchestrator 4.1.2 → 4.4.0

package/dist/src/session-manager.js

@@ -115,6 +115,7 @@ import { PersistentCustomSession } from './persistent-custom-session.js';
 import { overrideModelPricing, } from './types.js';
 import { resolveAlias, isClaudeModel } from './models.js';
 import { Council } from './council.js';
+import { Fanout } from './fanout.js';
 import { AutoloopRunner } from './autoloop/runner.js';
 import { ClaudeAgentDispatcher } from './autoloop/dispatcher.js';
 import { DEFAULT_PUSH_POLICY } from './autoloop/types.js';
@@ -432,6 +433,16 @@ export class SessionManager {
         catch {
             /* prior failure shouldn't block this caller */
         }
+        // The prior-chain await can sleep arbitrarily long. In that window a
+        // concurrent stopSession() may have stopped this session and removed it
+        // from the map. Re-check before writing, so we fail cleanly instead of
+        // calling send() on a detached/stopped session (TOCTOU on the sessions map).
+        if (this.sessions.get(name) !== managed) {
+            releaseChain();
+            if (managed.sendChain === link)
+                managed.sendChain = undefined;
+            throw new Error(`Session '${name}' was stopped while a prior turn was in flight`);
+        }
         try {
             managed.lastActivity = Date.now();
             const sendOpts = {
@@ -443,20 +454,26 @@ export class SessionManager {
             if (options.plan)
                 sendOpts.plan = true;
             if (options.onEvent || options.onChunk) {
+                // A throwing user callback must not corrupt the turn or leave the
+                // sendChain unreleased — isolate each invocation.
+                const safe = (fn) => {
+                    try {
+                        fn();
+                    }
+                    catch (err) {
+                        this.logger.warn?.(`sendMessage stream callback threw: ${err.message}`);
+                    }
+                };
                 sendOpts.callbacks = {
                     onText: (text) => {
-                        if (options.onChunk)
-                            options.onChunk(text);
-                        if (options.onEvent)
-                            options.onEvent({ type: 'text', result: text });
+                        safe(() => options.onChunk?.(text));
+                        safe(() => options.onEvent?.({ type: 'text', result: text }));
                     },
                     onToolUse: (event) => {
-                        if (options.onEvent)
-                            options.onEvent({ type: 'tool_use', ...event });
+                        safe(() => options.onEvent?.({ type: 'tool_use', ...event }));
                     },
                     onToolResult: (event) => {
-                        if (options.onEvent)
-                            options.onEvent({ type: 'tool_result', ...event });
+                        safe(() => options.onEvent?.({ type: 'tool_result', ...event }));
                     },
                 };
             }
@@ -860,6 +877,17 @@ export class SessionManager {
         for (const [, timer] of this.ultrareviewPollers)
             clearInterval(timer);
         this.ultrareviewPollers.clear();
+        // Clear council/fanout cleanup timers — their 30-min closures capture `this`
+        // and would otherwise fire after shutdown (and council timers, before this
+        // fix, were not unref'd so they blocked a clean process exit).
+        for (const [, timer] of this.councilCleanupTimers)
+            clearTimeout(timer);
+        this.councilCleanupTimers.clear();
+        this.councils.clear();
+        for (const [, timer] of this.fanoutCleanupTimers)
+            clearTimeout(timer);
+        this.fanoutCleanupTimers.clear();
+        this.fanouts.clear();
         // Stop autoloops (graceful: dispatch a terminate envelope so each run
         // shuts down its three persistent agents and cleans up the ledger lock).
         for (const [, ctx] of this.autoloops) {
@@ -935,6 +963,47 @@ export class SessionManager {
         }
         return { ok: true, goal: session.goal ?? null };
     }
+    // ─── Codex app-server v2 RPCs (codex-app engine only, Codex 0.137) ────────
+    //
+    // turn/interrupt, turn/steer, thread/fork, thread/rollback, model/list — the
+    // high-value app-server surface beyond /goal. Each requires a `codex-app`
+    // session; the discriminator is the presence of the `interrupt` method.
+    _getCodexAppSession(name, feature) {
+        const managed = this.sessions.get(name);
+        if (!managed)
+            throw new Error(`Session not found: ${name}`);
+        const session = managed.session;
+        if (typeof session.interrupt !== 'function') {
+            const engine = managed.config.engine || 'claude';
+            throw new Error(`Session "${name}" uses engine "${engine}" which does not support ${feature}. ` +
+                `Start a session with engine: "codex-app".`);
+        }
+        return session;
+    }
+    async codexInterrupt(name) {
+        const r = await this._getCodexAppSession(name, 'turn/interrupt').interrupt();
+        return { ok: true, ...r };
+    }
+    async codexSteer(name, text) {
+        const r = await this._getCodexAppSession(name, 'turn/steer').steer(text);
+        return { ok: true, ...r };
+    }
+    async codexForkThread(name) {
+        const r = await this._getCodexAppSession(name, 'thread/fork').forkThread();
+        return { ok: true, ...r };
+    }
+    async codexRollback(name, numTurns) {
+        await this._getCodexAppSession(name, 'thread/rollback').rollback(numTurns);
+        return { ok: true, numTurns };
+    }
+    async codexModels(name) {
+        const models = await this._getCodexAppSession(name, 'model/list').listModels();
+        return { ok: true, models };
+    }
+    async codexThreads(name, opts = {}) {
+        const r = await this._getCodexAppSession(name, 'thread/list').listThreads(opts);
+        return { ok: true, ...r };
+    }
     // ─── Claude /goal helpers (CLI 2.1.139, claude engine only) ────────
     //
     // Claude Code's /goal slash command works in non-interactive stream-json
@@ -984,6 +1053,34 @@ export class SessionManager {
         });
         return { stdout, stderr };
     }
+    /**
+     * Wraps `claude agents --json` — lists Claude Code background agent sessions
+     * (state/model/title/progress). One-shot spawn; not tied to a managed session.
+     * `all` adds `--all` (include completed); `cwd` scopes to a directory.
+     */
+    async claudeAgentsList(opts = {}) {
+        const args = ['agents', '--json'];
+        if (opts.all)
+            args.push('--all');
+        if (opts.cwd)
+            args.push('--cwd', path.resolve(opts.cwd));
+        const { stdout } = await execFileAsync(this.pluginConfig.claudeBin, args, {
+            maxBuffer: 16 * 1024 * 1024,
+            timeout: 30_000,
+        });
+        let agents = [];
+        const trimmed = stdout.trim();
+        if (trimmed) {
+            try {
+                const parsed = JSON.parse(trimmed);
+                agents = Array.isArray(parsed) ? parsed : (parsed.agents ?? []);
+            }
+            catch {
+                throw new Error(`claude agents --json returned non-JSON output: ${trimmed.slice(0, 200)}`);
+            }
+        }
+        return { ok: true, agents };
+    }
     // ─── Codex one-shot wrappers ──────────────────────────────────────────
     _codexBin() {
         return process.env.CODEX_BIN || 'codex';
@@ -1090,6 +1187,16 @@ export class SessionManager {
         if (scopes.length > 1) {
             throw new Error('codexReview: --uncommitted, --base, and --commit are mutually exclusive');
         }
+        // Validate git refs: reject leading-dash (argument injection) and shell/path
+        // metacharacters. args go through execFile (no shell) but a '--flag'-shaped
+        // value could still be misread by codex's parser.
+        const GIT_REF = /^[A-Za-z0-9][A-Za-z0-9._/-]*$/;
+        if (opts.base != null && !GIT_REF.test(opts.base)) {
+            throw new Error(`codexReview: invalid base ref '${opts.base}'`);
+        }
+        if (opts.commit != null && !GIT_REF.test(opts.commit)) {
+            throw new Error(`codexReview: invalid commit ref '${opts.commit}'`);
+        }
         const args = ['review'];
         if (opts.uncommitted)
             args.push('--uncommitted');
@@ -1313,13 +1420,17 @@ export class SessionManager {
     _isKnownCliProcess(pid) {
         // Match known CLI binaries by basename to avoid false positives
         // (e.g., 'agent' must not match 'ssh-agent' or 'gpg-agent')
+        // Anchor each name to executable/path position ((?:^|[/\s])name(?:[\s/]|$))
+        // so a hyphenated lookalike ('vim claude-notes.md', 'ssh-agent') can never
+        // match, while the real binary ('claude', '/usr/local/bin/claude',
+        // 'node /x/claude/cli.js') still does. \b alone treated '-' as a boundary.
         const knownPatterns = [
-            /\bclaude\b/, // claude CLI
-            /\bcodex\b/, // codex CLI
-            /\bgemini\b/, // gemini CLI
-            /\bcursor-agent\b/, // cursor-agent CLI
-            /\bopencode\b/, // opencode CLI (sst/opencode)
-            /(?:^|\/)agent\s/, // 'agent' as standalone command (not ssh-agent etc.)
+            /(?:^|[/\s])claude(?:[\s/]|$)/, // claude CLI
+            /(?:^|[/\s])codex(?:[\s/]|$)/, // codex CLI
+            /(?:^|[/\s])gemini(?:[\s/]|$)/, // gemini CLI
+            /(?:^|[/\s])cursor-agent(?:[\s/]|$)/, // cursor-agent CLI
+            /(?:^|[/\s])opencode(?:[\s/]|$)/, // opencode CLI (sst/opencode)
+            /(?:^|\/)agent(?:[\s/]|$)/, // 'agent' only as executable/after a slash (not ssh-agent)
         ];
         try {
             const cmd = execFileSync('ps', ['-p', String(pid), '-o', 'command='], {
@@ -1402,7 +1513,7 @@ export class SessionManager {
                         /* individual kill failed */
                     }
                     // Give process time to shut down, then SIGKILL
-                    setTimeout(() => {
+                    const orphanSigkill = setTimeout(() => {
                         try {
                             process.kill(pid, 0);
                             process.kill(-pid, 'SIGKILL');
@@ -1418,6 +1529,7 @@ export class SessionManager {
                             /* already dead */
                         }
                     }, STOP_SIGKILL_DELAY_MS);
+                    orphanSigkill.unref(); // force-kill fallback must not keep the loop alive
                 }
                 catch {
                     // Process already dead — nothing to do
@@ -1526,8 +1638,18 @@ export class SessionManager {
             this.councils.delete(id);
             this.councilCleanupTimers.delete(id);
         }, RESULT_TTL_MS);
+        // Don't let a pending 30-min cleanup timer keep the process alive or block shutdown.
+        timer.unref();
         this.councilCleanupTimers.set(id, timer);
     }
+    /** Clear and forget a cleanup timer (used on abort/shutdown so it can't fire late). */
+    _clearCleanupTimer(map, id) {
+        const t = map.get(id);
+        if (t) {
+            clearTimeout(t);
+            map.delete(id);
+        }
+    }
     councilStatus(id) {
         const council = this.councils.get(id);
         return council?.getSession();
@@ -1569,6 +1691,8 @@ export class SessionManager {
             throw new Error(`Council '${id}' not found`);
         council.abort();
         this.councils.delete(id);
+        // Drop the orphaned cleanup timer so it doesn't fire later on a deleted council.
+        this._clearCleanupTimer(this.councilCleanupTimers, id);
     }
     councilInject(id, message) {
         const council = this.councils.get(id);
@@ -1600,6 +1724,55 @@ export class SessionManager {
         this._scheduleCouncilCleanup(id); // reset TTL — council may be restarted
         return result;
     }
+    // ─── Fan-out (parallel multi-engine task, no consensus) ────────────────
+    fanouts = new Map();
+    fanoutCleanupTimers = new Map();
+    /**
+     * Start a fan-out: run the task across N engine/model agents in parallel and
+     * collect their answers (optional synthesis). Runs in the background; poll
+     * with fanoutStatus. Distinct from council — no rounds, votes, or worktrees.
+     */
+    fanoutStart(config) {
+        if (!config.agents?.length)
+            throw new Error('fanoutStart: at least one agent is required');
+        const names = config.agents.map((a) => a.name);
+        if (new Set(names).size !== names.length) {
+            throw new Error('fanoutStart: agent names must be unique (they form session names)');
+        }
+        const fanout = new Fanout(config, this, this.logger);
+        const session = fanout.init();
+        this.fanouts.set(session.id, fanout);
+        fanout
+            .run()
+            .catch((err) => this.logger.error(`Fanout ${session.id} failed:`, err))
+            .finally(() => this._scheduleFanoutCleanup(session.id));
+        return session;
+    }
+    fanoutStatus(id) {
+        const fanout = this.fanouts.get(id);
+        if (!fanout)
+            throw new Error(`Fanout '${id}' not found`);
+        return fanout.getSession();
+    }
+    fanoutAbort(id) {
+        const fanout = this.fanouts.get(id);
+        if (!fanout)
+            throw new Error(`Fanout '${id}' not found`);
+        fanout.abort();
+        this._scheduleFanoutCleanup(id);
+    }
+    _scheduleFanoutCleanup(id) {
+        const existing = this.fanoutCleanupTimers.get(id);
+        if (existing)
+            clearTimeout(existing);
+        const timer = setTimeout(() => {
+            this.fanouts.delete(id);
+            this.fanoutCleanupTimers.delete(id);
+        }, RESULT_TTL_MS);
+        if (typeof timer.unref === 'function')
+            timer.unref();
+        this.fanoutCleanupTimers.set(id, timer);
+    }
     // ─── Inbox (cross-session messaging) — delegated to InboxManager ────
     get _sessionLookup() {
         return {
@@ -1644,7 +1817,7 @@ export class SessionManager {
             this.stopSession(sessionName).catch((err) => {
                 this.logger.error(`Failed to stop ultraplan session '${sessionName}':`, err);
             });
-            setTimeout(() => {
+            const ttlTimer = setTimeout(() => {
                 // Mark as error if still running at TTL expiry
                 const plan = this.ultraplans.get(id);
                 if (plan?.status === 'running') {
@@ -1655,6 +1828,7 @@ export class SessionManager {
                 }
                 this.ultraplans.delete(id);
             }, RESULT_TTL_MS);
+            ttlTimer.unref(); // don't block process exit on a 30-min TTL timer
         });
         return result;
     }
@@ -1805,40 +1979,76 @@ export class SessionManager {
                 persona: 'You are a memory reviewer. Focus on: memory leaks, circular references, large object retention, stream handling.',
             },
         ];
-        const agents = reviewAngles.slice(0, agentCount).map((a) => ({
-            ...a,
-            model: opts?.model,
-        }));
         const maxMinutes = Math.min(25, Math.max(5, opts?.maxDurationMinutes || 10));
         const focus = opts?.focus || 'Find bugs, security issues, and code quality problems';
-        const councilConfig = {
-            name: 'ultrareview',
-            agents,
-            maxRounds: 2, // Review doesn't need many rounds — find bugs, then synthesize
-            projectDir: cwd,
-            agentTimeoutMs: maxMinutes * 60 * 1000,
-            maxTurnsPerAgent: 20,
-        };
-        const councilSession = this.councilStart(`# Code Review Task\n\nReview the codebase in this project. ${focus}.\n\nEach reviewer: examine the code from your specialty angle, report bugs found with file paths and line numbers. Vote [CONSENSUS: YES] when your review is complete.`, councilConfig);
-        result.councilId = councilSession.id;
-        // Poll council for completion (store ref for shutdown cleanup)
+        const reviewInstruction = `# Code Review Task\n\nReview the codebase in this project. ${focus}.\n\n` +
+            `Examine the code from your specialty angle and report bugs found with file paths and line numbers.`;
+        // Cross-engine review: round-robin the requested engines across reviewers
+        // (default claude-only — unchanged behavior). Each reviewer's persona is
+        // its prompt; per-agent failures are isolated by the fan-out runner.
+        const engines = opts?.engines?.length ? opts.engines : ['claude'];
+        const agents = reviewAngles.slice(0, agentCount).map((a, i) => ({
+            name: a.name,
+            engine: engines[i % engines.length],
+            model: opts?.model,
+            prompt: `${a.persona}\n\n${reviewInstruction}`,
+            // Review is read-only: keep reviewers out of edit mode so they analyse and
+            // report without modifying the very code they review. (Unlike council,
+            // fan-out shares the project dir — there is no worktree to sandbox edits.
+            // `plan` constrains the claude engine; non-claude reviewers, which are
+            // opt-in via `engines`, run under their engine's default sandbox.)
+            permissionMode: 'plan',
+        }));
+        let fanoutSession;
+        try {
+            fanoutSession = this.fanoutStart({
+                task: reviewInstruction,
+                projectDir: cwd,
+                agents,
+                synthesize: true,
+                agentTimeoutMs: maxMinutes * 60 * 1000,
+                maxTurnsPerAgent: 20,
+            });
+        }
+        catch (err) {
+            // Fan-out failed to even start (e.g. validation) — surface it on the
+            // stored result instead of leaving it frozen at 'running'.
+            result.status = 'error';
+            result.error = err.message;
+            result.endTime = new Date().toISOString();
+            setTimeout(() => this.ultrareviews.delete(id), RESULT_TTL_MS);
+            return result;
+        }
+        // `councilId` is kept for the UltrareviewResult contract; it now holds the
+        // fan-out id (an opaque run id used only by ultrareview_status).
+        result.councilId = fanoutSession.id;
+        // Poll the fan-out for completion (store ref for shutdown cleanup).
         const pollInterval = setInterval(() => {
             try {
-                const status = this.councilStatus(councilSession.id);
+                const status = this.fanoutStatus(fanoutSession.id);
                 if (!status || status.status === 'running')
                     return;
                 clearInterval(pollInterval);
                 this.ultrareviewPollers.delete(id);
                 result.status = status.status === 'error' ? 'error' : 'completed';
                 result.endTime = new Date().toISOString();
-                // Synthesize findings from all agent responses
-                if (status.responses.length > 0) {
-                    result.findings = status.responses.map((r) => `## ${r.agent}\n\n${r.content}`).join('\n\n---\n\n');
+                // Prefer the synthesis pass; fall back to joining successful results.
+                if (status.synthesis) {
+                    result.findings = status.synthesis;
+                }
+                else if (status.results.length > 0) {
+                    result.findings = status.results
+                        .filter((r) => r.ok)
+                        .map((r) => `## ${r.agent}\n\n${r.output}`)
+                        .join('\n\n---\n\n');
+                }
+                {
+                    const ttlDelete = setTimeout(() => this.ultrareviews.delete(id), RESULT_TTL_MS);
+                    ttlDelete.unref();
                 }
-                setTimeout(() => this.ultrareviews.delete(id), RESULT_TTL_MS);
             }
             catch {
-                // Council may have been cleaned up; stop polling
+                // Fan-out may have been cleaned up; stop polling.
                 clearInterval(pollInterval);
                 this.ultrareviewPollers.delete(id);
             }
@@ -1851,6 +2061,10 @@ export class SessionManager {
     }
     // ─── Autoloop (three-agent architecture) ───────────────────────────
     autoloops = new Map();
+    // runIds currently being torn down by autoloopDelete. Guards against a
+    // concurrent autoloopStart recreating the same id (or autoloopChat using a
+    // dispatcher mid-shutdown) during the async delete window.
+    _deletingAutoloops = new Set();
     /**
      * Start a v2 autoloop in chat mode. Creates the Planner persistent session,
      * returns the run handle. Coder/Reviewer are NOT started until S3's
@@ -1860,6 +2074,9 @@ export class SessionManager {
         if (this.autoloops.has(opts.runId)) {
             throw new Error(`Autoloop with id '${opts.runId}' already exists`);
         }
+        if (this._deletingAutoloops.has(opts.runId)) {
+            throw new Error(`Autoloop with id '${opts.runId}' is being deleted`);
+        }
         const ledgerDir = path.join(opts.workspace, 'tasks', opts.runId);
         if (!fs.existsSync(ledgerDir)) {
             fs.mkdirSync(ledgerDir, { recursive: true });
@@ -1948,7 +2165,7 @@ export class SessionManager {
      */
     async autoloopChat(runId, text) {
         const ctx = this.autoloops.get(runId);
-        if (!ctx)
+        if (!ctx || this._deletingAutoloops.has(runId))
             throw new Error(`Autoloop run '${runId}' not found`);
         let reply = '';
         const onReply = (...args) => {
@@ -2085,6 +2302,16 @@ export class SessionManager {
      * Returns true if anything was removed (in-memory entry OR registry row).
      */
     async autoloopDelete(runId) {
+        // Fence the async teardown so a concurrent start/chat can't race on this id.
+        this._deletingAutoloops.add(runId);
+        try {
+            return await this._autoloopDeleteInner(runId);
+        }
+        finally {
+            this._deletingAutoloops.delete(runId);
+        }
+    }
+    async _autoloopDeleteInner(runId) {
         const ctx = this.autoloops.get(runId);
         let touched = false;
         if (ctx) {