@enderfga/claw-orchestrator 7.14.0 → 7.16.0

package/dist/src/session-manager.js

@@ -115,7 +115,7 @@ import { detectRepoLang } from './kernel/repo.js';
 import { RunKernel, runDir as kernelRunDir } from './kernel/engine.js';
 import { registerDefaultExecutors } from './kernel/nodes/index.js';
 import { autoloopStateFromRecord, makeAutoloopExecutor } from './kernel/nodes/autoloop.js';
-import { isValidRunId, loadRun, readNodeOutput } from './kernel/store.js';
+import { isValidRunId, loadRun, readNodeOutput, runExists } from './kernel/store.js';
 import { LEGACY_NODE, joinFindings, toCouncilSession, toFanoutSession, toUltraplanResult, toUltrareviewResult, } from './kernel/projections.js';
 import { legacyCouncilWorkflow, legacyFanoutWorkflow, legacyUltraplanWorkflow, splitAgentSecrets, } from './kernel/templates/index.js';
 import { normalizeContract } from './verify/contract.js';
@@ -131,6 +131,7 @@ import { cloneTranscript, DEFAULT_HANDOFF_CHARS, MIN_HANDOFF_CHARS, newTranscrip
 import { PersistentGeminiSession } from './persistent-gemini-session.js';
 import { PersistentCodexSession } from './persistent-codex-session.js';
 import { PersistentCodexAppServerSession } from './persistent-codex-app-session.js';
+import { ClaudeGoalSession } from './claude-goal-session.js';
 import { PersistentCursorSession } from './persistent-cursor-session.js';
 import { PersistentGrokSession } from './persistent-grok-session.js';
 import { PersistentOpencodeSession } from './persistent-opencode-session.js';
@@ -139,7 +140,7 @@ import { PersistentCustomSession } from './persistent-custom-session.js';
 import { PersistentAcpSession } from './persistent-acp-session.js';
 import { resolveCustomEngine } from './engine-presets.js';
 import { EFFORT_LEVELS, ENGINE_TYPES, overrideModelPricing, ENGINE_BINARY_NAMES, } from './types.js';
-import { resolveAlias, isClaudeModel, lookupModel } from './models.js';
+import { resolveAlias, isClaudeModel, lookupModel, resolveEngineAndModel } from './models.js';
 import { isAgyConversationId } from './agy-conversation.js';
 import { Council } from './council.js';
 import { AutoloopRunner } from './autoloop/runner.js';
@@ -217,6 +218,15 @@ function readStoredAutoloopResumeContext(workspace, runId, originalSendTimeoutMs
     }
     return { effectiveSendTimeoutMs, pendingDispatch };
 }
+/** A process's command line as `ps` prints it, or undefined when it cannot be read. */
+function processCommand(pid) {
+    try {
+        return execFileSync('ps', ['-p', String(pid), '-o', 'command='], { encoding: 'utf8', timeout: 3_000 }).trim();
+    }
+    catch {
+        return undefined;
+    }
+}
 function validateSendTimeoutIncrease(value, current) {
     validateAutoloopTimeoutConfig({ sendTimeoutMs: value });
     if (value <= current) {
@@ -319,8 +329,24 @@ function validateAutoloopRole(role, engine, customEngine) {
             throw new Error(`${label} custom engine config is required`);
         validateAutoloopCustomEngine(role, customEngine);
     }
+    // An Autoloop role is configured by engine name alone and has no field for the
+    // agent an `acp` engine starts, so the session could only fail later.
+    if (resolved === 'acp')
+        throw new Error(`${label} engine 'acp' is not supported by Autoloop`);
     return resolved;
 }
+/**
+ * The plugin's `defaultModel` for a session on `engine` that names no model, or
+ * undefined to let the engine run its own default. Engines do not share a model
+ * namespace, so the default goes only to an engine that runs it; the claude
+ * engine takes any model, proxying a non-Claude one to the gateway.
+ */
+function defaultModelFor(engine, defaultModel) {
+    if (!defaultModel || engine === 'claude')
+        return defaultModel;
+    const owner = resolveEngineAndModel(defaultModel).engine;
+    return owner === (engine === 'codex-app' ? 'codex' : engine) ? defaultModel : undefined;
+}
 function validateAutoloopEffort(role, effort) {
     if (effort === undefined)
         return;
@@ -772,6 +798,8 @@ function readClosedLedgerRestore(ledgerDir) {
 }
 export class SessionManager {
     sessions = new Map();
+    /** Goal adapters over `claude` sessions, by session name; dropped when the session stops. */
+    _claudeGoals = new Map();
     _pendingSessions = new Map();
     /**
      * Starts that passed the capacity check and are not in `sessions` yet. The
@@ -789,6 +817,12 @@ export class SessionManager {
     /** In-flight proxy startup, so concurrent callers share one server. */
     _proxyStartPromise = null;
     _activePids = new Map();
+    /**
+     * Each recorded pid's command line when it was recorded. An orphan is killed
+     * only if it is still that process: this is what lets cleanup recognise an
+     * ACP agent or a custom engine, whose binary is no fixed name.
+     */
+    _pidCommands = new Map();
     _circuitBreaker = new CircuitBreaker();
     _inbox = new InboxManager();
     /** cwd → detected language, so the manifest probe runs once per directory. */
@@ -929,6 +963,7 @@ export class SessionManager {
         const persisted = skipPersist ? undefined : this.persistedSessions.get(name);
         // Unified: only use resumeSessionId (claudeResumeId is an internal alias, not exposed)
         const resumeId = config.resumeSessionId ?? persisted?.claudeSessionId;
+        const engine = config.engine || persisted?.engine || 'claude';
         // ORDER IS LOAD-BEARING — do not "fix" it by moving `...config` up.
         //
         // Object spread copies own keys even when their value is `undefined`, so any
@@ -944,7 +979,7 @@ export class SessionManager {
             cwd: config.cwd || persisted?.cwd || process.cwd(),
             permissionMode: config.permissionMode || this.pluginConfig.defaultPermissionMode,
             effort: config.effort || this.pluginConfig.defaultEffort,
-            model: config.model || persisted?.model || this.pluginConfig.defaultModel,
+            model: config.model || persisted?.model || defaultModelFor(engine, this.pluginConfig.defaultModel),
             sandboxMode: config.sandboxMode ?? persisted?.sandboxMode,
             autoCompactPercent: config.autoCompactPercent ?? persisted?.autoCompactPercent,
             chrome: config.chrome ?? persisted?.chrome,
@@ -955,16 +990,15 @@ export class SessionManager {
         if (fullConfig.model) {
             fullConfig.resolvedModel = this._resolveModel(fullConfig.model, fullConfig.modelOverrides);
         }
-        // Auto-inject proxy baseUrl for non-Claude models on the claude engine.
-        // Starts a local proxy server that converts Anthropic → OpenAI format
-        // and forwards to the OpenClaw gateway. Zero config required.
-        const engine = fullConfig.engine || persisted?.engine || 'claude';
         // Write the resolved engine back so downstream consumers of the managed
         // config (agy resume-id lookups, _persistSession's registry entry) see the
         // real engine even when it came from the persisted registry.
         fullConfig.engine = engine;
         // Circuit breaker — reject early if engine is in backoff
         this._circuitBreaker.check(engine);
+        // Auto-inject proxy baseUrl for non-Claude models on the claude engine.
+        // Starts a local proxy server that converts Anthropic → OpenAI format
+        // and forwards to the OpenClaw gateway. Zero config required.
         if (engine === 'claude' && fullConfig.resolvedModel && !fullConfig.baseUrl) {
             if (!isClaudeModel(fullConfig.resolvedModel)) {
                 const proxyPort = await this._ensureProxyServer();
@@ -987,6 +1021,9 @@ export class SessionManager {
         // Track child process PID for orphan cleanup
         if (session.pid) {
             this._activePids.set(name, session.pid);
+            const command = processCommand(session.pid);
+            if (command)
+                this._pidCommands.set(session.pid, command);
             this._savePids();
         }
         const managed = {
@@ -1008,6 +1045,10 @@ export class SessionManager {
         return this._toSessionInfo(name, managed);
     }
     async sendMessage(name, message, options = {}) {
+        return this._sendTurn(name, message, options);
+    }
+    /** `onDispatch` fires once the turn has passed every check and is handed to the engine. */
+    async _sendTurn(name, message, options, onDispatch) {
         const managed = this._getSession(name);
         // Per-session serialization. Two concurrent sendMessage() calls on the
         // same session previously raced on PersistentClaudeSession._streamCallbacks
@@ -1103,7 +1144,14 @@ export class SessionManager {
                 // A session handed off from another engine carries that conversation in
                 // front of its first message; after that the engine holds it itself.
                 const outgoing = managed.pendingHandoff ? `${managed.pendingHandoff}\n\n${message}` : message;
+                onDispatch?.();
                 const result = await managed.session.send(outgoing, sendOpts);
+                const after = this._statsSnapshot(managed);
+                const usage = {
+                    tokensIn: Math.max(0, after.tokensIn - ledgerBefore.tokensIn),
+                    tokensOut: Math.max(0, after.tokensOut - ledgerBefore.tokensOut),
+                    costUsd: Math.max(0, after.costUsd - ledgerBefore.costUsd),
+                };
                 // Update the resume-capable session ID if available (skip disk persist
                 // for ephemeral sessions that were started with skipPersistence)
                 const resumableId = this._managedResumeId(managed);
@@ -1145,11 +1193,12 @@ export class SessionManager {
                         sessionId: this._managedResumeId(managed),
                         error: turnError,
                         events: [],
+                        usage,
                         ...(permissionDenials.length ? { permissionDenials } : {}),
                         ...(images.length ? { images } : {}),
                     };
                 }
-                return { output: '', sessionId: this._managedResumeId(managed), events: [] };
+                return { output: '', sessionId: this._managedResumeId(managed), events: [], usage };
             }
             catch (err) {
                 turnError = err.message;
@@ -1219,6 +1268,7 @@ export class SessionManager {
             engine: opts.engine,
             ...(opts.model ? { model: opts.model } : {}),
             ...(opts.customEngine ? { customEngine: opts.customEngine } : {}),
+            ...(opts.acpAgent ? { acpAgent: opts.acpAgent } : {}),
         });
         const target = this._getSession(targetName);
         // The new session's record starts as the source's, so a second handoff from
@@ -1534,6 +1584,11 @@ export class SessionManager {
         if (!contract)
             throw new Error('verifyRun requires a contract with at least one recognised check');
         const runId = args.label || `verify-${Date.now().toString(36)}`;
+        // The bundle goes under the run store, keyed by the label. A label naming a
+        // workflow run would plant this evidence in that run's directory.
+        if (runExists(runId)) {
+            throw new Error(`verify_run label '${runId}' names an existing workflow run; choose another label`);
+        }
         const dir = kernelRunDir(runId);
         const evidenceId = 'verify-01';
         const { results, rounds } = await runContract(contract, {
@@ -1558,9 +1613,9 @@ export class SessionManager {
     async stopSession(name, opts = {}) {
         const managed = this._getSession(name);
         managed.session.stop();
-        this.sessions.delete(name);
+        this._removeSession(name);
         // Remove PID tracking
-        this._activePids.delete(name);
+        this._forgetPid(name);
         this._savePids();
         if (!opts.keepPersisted) {
             // Explicit stop = user intent to end session — remove from disk too.
@@ -1569,6 +1624,9 @@ export class SessionManager {
             // Claude conversation) pass keepPersisted: true.
             this._forgetPersisted(name);
             this._savePersisted();
+            // Its unread mail was for this conversation; a later session that takes
+            // the name is a different one and must not receive it.
+            this._inbox.clear(name);
         }
     }
     hasSession(name) {
@@ -1655,7 +1713,7 @@ export class SessionManager {
         }
         const oldConfig = { ...managed.config };
         managed.session.stop();
-        this.sessions.delete(name);
+        this._removeSession(name);
         try {
             return await this.startSession({
                 ...oldConfig,
@@ -1720,7 +1778,7 @@ export class SessionManager {
                 newDisallowed = newDisallowed.filter((t) => !removeSet.has(t));
         }
         managed.session.stop();
-        this.sessions.delete(name);
+        this._removeSession(name);
         try {
             return await this.startSession({
                 ...oldConfig,
@@ -1959,8 +2017,12 @@ export class SessionManager {
             this.logger.info(`Stopped session: ${name}`);
         }
         this.sessions.clear();
+        for (const adapter of this._claudeGoals.values())
+            adapter.detach();
+        this._claudeGoals.clear();
         // Clear PID tracking
         this._activePids.clear();
+        this._pidCommands.clear();
         this._savePids();
         // Stop proxy server
         if (this._proxyServer) {
@@ -1977,6 +2039,29 @@ export class SessionManager {
         const session = this.sessions.get(name)?.session;
         return session instanceof PersistentCodexAppServerSession ? session : undefined;
     }
+    /**
+     * The goal surface of the session behind `name`: a `codex-app` session as it
+     * is, a `claude` session through `ClaudeGoalSession` (one per session, made on
+     * first use with what the node knows of the thread). Other engines have none.
+     */
+    goalSession(name, open) {
+        const session = this.sessions.get(name)?.session;
+        if (session instanceof PersistentCodexAppServerSession)
+            return session;
+        if (!(session instanceof PersistentClaudeSession))
+            return undefined;
+        let adapter = this._claudeGoals.get(name);
+        // A session replaced under the same name (model switch, tool update) gets a new adapter.
+        if (adapter && adapter.host !== session) {
+            adapter.detach();
+            adapter = undefined;
+        }
+        if (!adapter) {
+            adapter = new ClaudeGoalSession(session, open);
+            this._claudeGoals.set(name, adapter);
+        }
+        return adapter;
+    }
     /**
      * Act on a `codex-app` session's goal through the app-server's
      * `thread/goal/*` RPCs. Used by the `codex_goal_*` tools; `get` asks the
@@ -2436,6 +2521,18 @@ export class SessionManager {
     }
     // ─── PID Tracking ──────────────────────────────────────────────────────
     static PID_FILE = path.join(os.homedir(), '.openclaw', 'session-pids.json');
+    /** Take a session out of memory, with the goal adapter listening to it. */
+    _removeSession(name) {
+        this._claudeGoals.get(name)?.detach();
+        this._claudeGoals.delete(name);
+        this.sessions.delete(name);
+    }
+    _forgetPid(name) {
+        const pid = this._activePids.get(name);
+        if (pid !== undefined)
+            this._pidCommands.delete(pid);
+        this._activePids.delete(name);
+    }
     _savePids() {
         try {
             const dir = path.dirname(SessionManager.PID_FILE);
@@ -2479,11 +2576,13 @@ export class SessionManager {
                     pid: entry.pid,
                     ownerPid: entry.ownerPid,
                     since: entry.since ?? now,
+                    ...(typeof entry.command === 'string' ? { command: entry.command } : {}),
                 };
             }
             // Add OUR current entries
             for (const [name, pid] of this._activePids) {
-                merged[name] = { pid, ownerPid: process.pid, since: now };
+                const command = this._pidCommands.get(pid);
+                merged[name] = { pid, ownerPid: process.pid, since: now, ...(command ? { command } : {}) };
             }
             fs.writeFileSync(SessionManager.PID_FILE, JSON.stringify(merged));
         }
@@ -2495,7 +2594,7 @@ export class SessionManager {
      * Verify that a PID belongs to a known coding CLI before killing it.
      * Prevents killing unrelated processes if the OS recycled the PID.
      */
-    _isKnownCliProcess(pid) {
+    _isKnownCliProcess(pid, recordedCommand) {
         // 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/]|$))
@@ -2510,16 +2609,14 @@ export class SessionManager {
             ...ENGINE_BINARY_NAMES.map((bin) => new RegExp(`(?:^|[/\\s])${bin}(?:[\\s/]|$)`)),
             /(?:^|\/)agent(?:[\s/]|$)/, // 'agent' only as executable/after a slash (not ssh-agent)
         ];
-        try {
-            const cmd = execFileSync('ps', ['-p', String(pid), '-o', 'command='], {
-                encoding: 'utf8',
-                timeout: 3_000,
-            }).trim();
-            return knownPatterns.some((pattern) => pattern.test(cmd));
-        }
-        catch {
+        const cmd = processCommand(pid);
+        if (cmd === undefined)
             return false; // ps failed — process likely dead or not accessible
-        }
+        // The same command line as when it was recorded: the process itself, not a
+        // recycled pid — whatever binary it runs.
+        if (recordedCommand && cmd === recordedCommand)
+            return true;
+        return knownPatterns.some((pattern) => pattern.test(cmd));
     }
     _cleanupOrphanedPids() {
         try {
@@ -2530,6 +2627,7 @@ export class SessionManager {
                 // Resolve entry shape: legacy = number; current = { pid, ownerPid, since }.
                 let pid;
                 let ownerPid;
+                let recordedCommand;
                 if (typeof raw === 'number') {
                     pid = raw;
                     ownerPid = null; // unknown owner — treat conservatively (skip kill)
@@ -2540,6 +2638,7 @@ export class SessionManager {
                         continue;
                     pid = e.pid;
                     ownerPid = typeof e.ownerPid === 'number' ? e.ownerPid : null;
+                    recordedCommand = typeof e.command === 'string' ? e.command : undefined;
                 }
                 else {
                     continue;
@@ -2572,7 +2671,7 @@ export class SessionManager {
                 try {
                     process.kill(pid, 0); // check if alive
                     // Alive — but verify it's actually a coding CLI, not a recycled PID
-                    if (!this._isKnownCliProcess(pid)) {
+                    if (!this._isKnownCliProcess(pid, recordedCommand)) {
                         this.logger.info(`PID ${pid} (session: ${name}) is alive but not a known CLI — skipping kill`);
                         continue;
                     }
@@ -2804,12 +2903,26 @@ export class SessionManager {
             throw new Error(`Council '${id}' not found`);
         throw new Error(`Council '${id}' is ${record.state} and not running in this process — its record is readable, but there is no live round to act on`);
     }
+    /**
+     * Abort a council running in this process. One that is not — finished, or
+     * running elsewhere — is left alone and the result says so: its worktrees are
+     * either awaiting accept/reject or in use by the process that runs it.
+     */
     councilAbort(id) {
         // Cancel the run first so the kernel stops advancing, then abort the engine
         // so the current round tears down its worktrees.
-        if (!this.kernel.cancel(id) && !loadRun(id))
+        if (this.kernel.cancel(id)) {
+            this.kernel.handle(id, LEGACY_NODE)?.abort();
+            return { aborted: true };
+        }
+        const record = loadRun(id);
+        if (!record)
             throw new Error(`Council '${id}' not found`);
-        this.kernel.handle(id, LEGACY_NODE)?.abort();
+        return {
+            aborted: false,
+            state: record.state,
+            reason: `Council '${id}' is ${record.state} and not running in this process — nothing was aborted`,
+        };
     }
     councilInject(id, message) {
         this._liveCouncil(id).injectMessage(message);
@@ -2818,10 +2931,34 @@ export class SessionManager {
         return this._councilForPostProcessing(id).review();
     }
     async councilAccept(id) {
-        return this._councilForPostProcessing(id).accept();
+        const result = await this._councilForPostProcessing(id).accept();
+        this._recordCouncilDecision(id, 'accepted');
+        return result;
     }
     async councilReject(id, feedback) {
-        return this._councilForPostProcessing(id).reject(feedback);
+        const result = await this._councilForPostProcessing(id).reject(feedback);
+        this._recordCouncilDecision(id, 'rejected');
+        return result;
+    }
+    /**
+     * Write the decision onto the run, which is where `council_status` reads it.
+     * The `Council` that took it is usually rebuilt from the record and dropped,
+     * so its own status would go nowhere.
+     */
+    _recordCouncilDecision(id, status) {
+        // A council live in this process carries the status on its own session.
+        if (this.kernel.handle(id, LEGACY_NODE))
+            return;
+        let recorded = false;
+        let why = 'the run has not finished';
+        try {
+            recorded = this.kernel.amendFinishedNode(id, LEGACY_NODE, { councilStatus: status }, `council ${status}`);
+        }
+        catch (err) {
+            why = err.message;
+        }
+        if (!recorded)
+            this.logger.warn(`[council] ${id}: ${status}, but the status could not be recorded (${why})`);
     }
     /**
      * A `Council` for review / accept / reject.
@@ -2870,6 +3007,7 @@ export class SessionManager {
             synthesize: config.synthesize,
             synthesisEngine: config.synthesisEngine,
             synthesisModel: config.synthesisModel,
+            synthesisAcpAgent: config.synthesisAcpAgent,
             synthesisPermissionMode: config.synthesisPermissionMode,
             maxTurnsPerAgent: config.maxTurnsPerAgent,
             maxBudgetUsd: config.maxBudgetUsd,
@@ -2895,8 +3033,30 @@ export class SessionManager {
             getSession: (name) => this.sessions.get(name),
             exists: (name) => this.sessions.has(name),
             allNames: () => this.sessions.keys(),
+            deliver: (name, text) => this._deliverInboxTurn(name, text),
         };
     }
+    /**
+     * An inbox delivery is a turn like any other — capped, written to the run
+     * ledger and kept in the handoff record — that its sender does not wait on.
+     * Resolves once the turn reaches the engine; a refusal before that (spend cap,
+     * session stopped) rejects so the inbox queues the message instead. A failure
+     * after it belongs to the turn and is recorded with it.
+     */
+    _deliverInboxTurn(name, text) {
+        return new Promise((resolve, reject) => {
+            let dispatched = false;
+            this._sendTurn(name, text, {}, () => {
+                dispatched = true;
+                resolve();
+            }).then(() => resolve(), (err) => {
+                if (!dispatched)
+                    reject(err);
+                else
+                    this.logger.warn(`[SessionManager] inbox turn on '${name}' failed: ${err.message}`);
+            });
+        });
+    }
     async sessionSendTo(from, to, message, summary) {
         return this._inbox.sendTo(from, to, message, this._sessionLookup, summary, (name, err) => {
             this.logger.error(`Broadcast delivery to '${name}' failed:`, err.message);
@@ -2972,10 +3132,14 @@ export class SessionManager {
         // Every reviewer runs read-only (see below). A custom reviewer has no config
         // to start from, so it is turned away here instead of failing one reviewer
         // at a time. (grok was turned away too until its read-only mode moved onto
-        // grok's OS sandbox.)
+        // grok's OS sandbox.) An ACP agent cannot be held read-only at all: its tools
+        // run inside the agent, so the session would refuse to start.
         if ((opts?.engines ?? []).includes('custom')) {
             throw new Error('ultrareview cannot use custom: reviewers run read-only, which a custom engine cannot be configured for here');
         }
+        if ((opts?.engines ?? []).includes('acp')) {
+            throw new Error('ultrareview cannot use acp: reviewers run read-only, which an ACP agent cannot be held to');
+        }
         const id = `ultrareview-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
         const agentCount = Math.min(20, Math.max(1, opts?.agentCount || 5));
         const result = {
@@ -3104,9 +3268,10 @@ export class SessionManager {
             // Review is read-only: reviewers analyse and report without modifying the
             // very code they review. Unlike council, fan-out shares the project dir —
             // there is no worktree to contain an edit — so this has to hold on every
-            // engine. `plan` constrains Claude only; `sandboxMode: 'read-only'` is the
-            // engine-agnostic setting, which codex, agy and opencode map to their own
-            // read-only modes. Before it was set, a codex reviewer ran workspace-write.
+            // engine. `plan` reaches only the engines with a plan mode (Claude, Grok);
+            // `sandboxMode: 'read-only'` is the engine-agnostic setting, which codex,
+            // agy and opencode map to their own read-only modes. Before it was set, a
+            // codex reviewer ran workspace-write.
             permissionMode: 'plan',
             sandboxMode: 'read-only',
         }));
@@ -3860,14 +4025,14 @@ export class SessionManager {
                 catch {
                     // Best-effort — session may already be dead; must not block TTL cleanup
                 }
-                this.sessions.delete(name);
+                this._removeSession(name);
                 // The child is gone, so its PID must go too — `stopSession` does this
                 // and the TTL path did not, so `_activePids` only ever grew and the
                 // next `_savePids()` rewrote those dead PIDs to disk under the current
                 // owner. After an unclean exit `_cleanupOrphanedPids()` reads them back
                 // and probes each one; a PID the OS has since recycled to a
                 // coding-CLI-shaped process gets killed.
-                this._activePids.delete(name);
+                this._forgetPid(name);
                 pidsChanged = true;
                 // NOTE: do NOT delete from persistedSessions — idle cleanup is
                 // in-memory only. Persisted entries survive for PERSIST_DISK_TTL_MS