@enderfga/claw-orchestrator 7.6.1 → 7.7.0

package/dist/src/session-manager.js

@@ -10,6 +10,7 @@ import * as os from 'node:os';
 import { execFile, execFileSync } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { promisify } from 'node:util';
+import { execEngine } from './engine-spawn.js';
 const execFileAsync = promisify(execFile);
 import * as http from 'node:http';
 import { createRequire } from 'node:module';
@@ -35,7 +36,8 @@ function getPluginVersion() {
     return 'unknown';
 }
 // ─── Persistence ─────────────────────────────────────────────────────────────
-const PERSIST_DIR = path.join(os.homedir(), '.openclaw');
+// CLAWO_SESSIONS_DIR relocates the file, so tests never touch the real one.
+const PERSIST_DIR = process.env.CLAWO_SESSIONS_DIR || path.join(os.homedir(), '.openclaw');
 const PERSIST_FILE = path.join(PERSIST_DIR, 'claude-sessions.json');
 function loadPersistedSessions() {
     try {
@@ -52,45 +54,50 @@ function loadPersistedSessions() {
         return new Map();
     }
 }
-// Atomic write: write to .tmp then rename to avoid corrupt reads on crash
-function savePersistedSessions(sessions, logger) {
+/**
+ * Write this process's changes into the shared session file.
+ *
+ * Several processes share the file — the server, the OpenClaw plugin, every
+ * `clawo-mcp` and `clawo acp` a host starts. Each used to write its whole
+ * in-memory map back, so the last writer erased whatever the others had added
+ * since it loaded: a long-lived session's resume record could vanish because an
+ * unrelated process exited. Now only the names this process changed (`dirty`,
+ * set or deleted) are merged into what is on disk, under a lock, and the merged
+ * map is returned so the caller sees the other processes' sessions too.
+ *
+ * Returns undefined when the lock stays busy; `dirty` is left as it was, so
+ * the changes go out with the next save instead of being lost.
+ */
+function savePersistedSessions(mine, dirty, logger) {
+    const log = logger || createConsoleLogger('SessionManager');
     try {
         fs.mkdirSync(PERSIST_DIR, { recursive: true });
-        const arr = Array.from(sessions.values());
-        const tmp = PERSIST_FILE + '.tmp';
-        fs.writeFileSync(tmp, JSON.stringify(arr, null, 2));
-        fs.renameSync(tmp, PERSIST_FILE);
+        const result = withFileLock(`${PERSIST_FILE}.lock`, () => {
+            const merged = loadPersistedSessions();
+            for (const name of dirty) {
+                const entry = mine.get(name);
+                if (entry)
+                    merged.set(name, entry);
+                else
+                    merged.delete(name);
+            }
+            const tmp = `${PERSIST_FILE}.${process.pid}.tmp`;
+            fs.writeFileSync(tmp, JSON.stringify(Array.from(merged.values()), null, 2));
+            fs.renameSync(tmp, PERSIST_FILE);
+            return merged;
+        });
+        if (!result.ok) {
+            log.warn('Session file busy; changes kept for the next save');
+            return undefined;
+        }
+        dirty.clear();
+        return result.value;
     }
     catch (err) {
-        (logger || createConsoleLogger('SessionManager')).warn('Failed to persist sessions:', err.message);
+        log.warn('Failed to persist sessions:', err.message);
+        return undefined;
     }
 }
-// Async version for hot-path (sendMessage, TTL cleanup)
-function savePersistedSessionsAsync(sessions, logger) {
-    const log = logger || createConsoleLogger('SessionManager');
-    const arr = Array.from(sessions.values());
-    const tmp = PERSIST_FILE + '.tmp';
-    fs.mkdir(PERSIST_DIR, { recursive: true }, (mkdirErr) => {
-        if (mkdirErr) {
-            log.error('Failed to create persist dir:', mkdirErr.message);
-            return;
-        }
-        fs.writeFile(tmp, JSON.stringify(arr, null, 2), (writeErr) => {
-            if (writeErr) {
-                log.error('Failed to write session file:', writeErr.message);
-                return;
-            }
-            fs.rename(tmp, PERSIST_FILE, (renameErr) => {
-                if (renameErr) {
-                    log.error('Failed to rename session file:', renameErr.message);
-                    // Clean up orphan tmp file
-                    fs.unlink(tmp, () => { });
-                }
-            });
-        });
-    });
-}
-// Debounce helper — coalesces rapid writes into one
 function makeDebounced(fn, ms) {
     let timer = null;
     return () => {
@@ -116,6 +123,7 @@ import { runContract } from './verify/runner.js';
 import { evidenceDir, listEvidence, readEvidence, writeEvidence } from './verify/evidence.js';
 import { annotateVerdicts, appendRunRow, readRunLedger, summarizeRuns, } from './run-ledger.js';
 import { checkBudget, isBudgetExceeded } from './budget.js';
+import { withFileLock } from './kernel/file-lock.js';
 import { InboxManager } from './inbox-manager.js';
 import { sanitizeCwd, validateName } from './validation.js';
 import { PersistentClaudeSession } from './persistent-session.js';
@@ -391,7 +399,7 @@ export class SessionManager {
         // Clean up orphaned child processes from a previous unclean exit
         this._cleanupOrphanedPids();
         // Debounced async writer — at most one write per 5 seconds on hot paths
-        this._debouncedSave = makeDebounced(() => savePersistedSessionsAsync(this.persistedSessions, this.logger), DEBOUNCED_SAVE_MS);
+        this._debouncedSave = makeDebounced(() => this._savePersisted(), DEBOUNCED_SAVE_MS);
         // Start TTL cleanup timer
         this.cleanupTimer = setInterval(() => this._cleanupIdleSessions(), CLEANUP_INTERVAL_MS);
     }
@@ -444,6 +452,10 @@ export class SessionManager {
     // ─── Session Lifecycle ─────────────────────────────────────────────────
     async startSession(config) {
         const name = config.name || `session-${Date.now()}`;
+        const compactAt = config.autoCompactPercent;
+        if (compactAt !== undefined && !(Number.isFinite(compactAt) && compactAt >= 1 && compactAt <= 99)) {
+            throw new Error('autoCompactPercent must be a number from 1 to 99');
+        }
         // Check pending first — a concurrent caller may have already started creation
         const pending = this._pendingSessions.get(name);
         if (pending)
@@ -517,6 +529,8 @@ export class SessionManager {
             effort: config.effort || this.pluginConfig.defaultEffort,
             model: config.model || persisted?.model || this.pluginConfig.defaultModel,
             sandboxMode: config.sandboxMode ?? persisted?.sandboxMode,
+            autoCompactPercent: config.autoCompactPercent ?? persisted?.autoCompactPercent,
+            chrome: config.chrome ?? persisted?.chrome,
             ...config,
             ...(resumeId ? { resumeSessionId: resumeId } : {}),
         };
@@ -616,6 +630,20 @@ export class SessionManager {
                 session: name,
                 engine: managed.config.engine || 'claude',
             });
+            // Compact before the send rather than after the previous reply, so the
+            // caller is never kept waiting for it, and inside the send chain, so no
+            // other send can interleave. Best effort: a failed or unsupported compact
+            // must not cost the caller their turn.
+            const compactAt = managed.config.autoCompactPercent;
+            if (compactAt && managed.session.getStats().contextPercent >= compactAt) {
+                try {
+                    await managed.session.compact();
+                    this.logger.info(`[SessionManager] ${name}: context at or above ${compactAt}% — compacted before send`);
+                }
+                catch (err) {
+                    this.logger.warn(`[SessionManager] ${name}: auto-compact failed: ${err.message}`);
+                }
+            }
             const sendOpts = {
                 waitForComplete: true,
                 timeout: options.timeout || TURN_TIMEOUT_MS,
@@ -756,6 +784,7 @@ export class SessionManager {
             sandboxMode: source.config.sandboxMode,
             effort: source.config.effort,
             maxBudgetUsd: source.config.maxBudgetUsd,
+            autoCompactPercent: source.config.autoCompactPercent,
             systemPrompt: source.config.systemPrompt,
             appendSystemPrompt: source.config.appendSystemPrompt,
             addDir: source.config.addDir,
@@ -812,6 +841,7 @@ export class SessionManager {
             toolCalls: 0,
             toolErrors: 0,
             costUsd: 0,
+            refusalFallbacks: 0,
         };
         try {
             const st = managed.session.getStats();
@@ -824,6 +854,7 @@ export class SessionManager {
                 toolCalls: st.toolCalls || 0,
                 toolErrors: st.toolErrors || 0,
                 costUsd: this._spentUsd(managed),
+                refusalFallbacks: st.refusalFallbacks || 0,
             };
         }
         catch {
@@ -864,12 +895,21 @@ export class SessionManager {
             ok: !error && (after.turns > before.turns ? after.turnsSucceeded > before.turnsSucceeded : true),
         };
         // Fall back to the engine's own reported model, so a session started
-        // without an explicit `model` still records what actually answered.
-        const model = managed.config.resolvedModel || managed.config.model || this._reportedModel(managed);
+        // without an explicit `model` still records what actually answered. An
+        // alias (`opus[1m]`) is the CLI's to resolve, so what it reports wins there.
+        const configured = managed.config.resolvedModel || managed.config.model;
+        const bare = configured?.replace(/\[1m\]$/i, '');
+        const isAlias = !!bare && resolveAlias(bare) !== bare;
+        const model = (isAlias ? this._reportedModel(managed) : undefined) || configured || this._reportedModel(managed);
         if (model)
             row.model = model;
         if (error)
             row.error = error.slice(0, 500);
+        if (after.refusalFallbacks > before.refusalFallbacks) {
+            const fallback = managed.session.getStats().lastRefusalFallback;
+            if (fallback)
+                row.refusalFallback = fallback;
+        }
         if (parent)
             row.parent = parent;
         if (dims.nodeKind)
@@ -1102,8 +1142,8 @@ export class SessionManager {
             // Callers that want the session resumable (autoloop terminate that
             // should still allow /autoloop/<id>/resume to reattach the Planner's
             // Claude conversation) pass keepPersisted: true.
-            this.persistedSessions.delete(name);
-            savePersistedSessions(this.persistedSessions, this.logger);
+            this._forgetPersisted(name);
+            this._savePersisted();
         }
     }
     hasSession(name) {
@@ -1504,7 +1544,7 @@ export class SessionManager {
             this._proxyPort = null;
         }
         // Persist final state (TTL-expired sessions already removed by cleanup)
-        savePersistedSessions(this.persistedSessions, this.logger);
+        this._savePersisted();
     }
     // ─── Codex /goal helpers (codex-app engine only) ─────────────────────
     /**
@@ -1745,7 +1785,7 @@ export class SessionManager {
         if (opts.model)
             args.push('--model', opts.model);
         args.push(opts.message);
-        const { stdout } = await execFileAsync(this._codexBin(), args, {
+        const { stdout } = await execEngine(this._codexBin(), args, {
             cwd: opts.cwd ? path.resolve(opts.cwd) : undefined,
             maxBuffer: 32 * 1024 * 1024,
             timeout: opts.timeout || 300_000,
@@ -1794,7 +1834,7 @@ export class SessionManager {
             args.push('-c', `model="${opts.model}"`);
         if (opts.prompt)
             args.push(opts.prompt);
-        const { stdout, stderr } = await execFileAsync(this._codexBin(), args, {
+        const { stdout, stderr } = await execEngine(this._codexBin(), args, {
             cwd: opts.cwd ? path.resolve(opts.cwd) : undefined,
             maxBuffer: 16 * 1024 * 1024,
             timeout: opts.timeout || 600_000,
@@ -1939,16 +1979,32 @@ export class SessionManager {
         });
     }
     // ─── Private ───────────────────────────────────────────────────────────
+    /** Names this process has set or deleted since its last save; see savePersistedSessions. */
+    _persistDirty = new Set();
+    _forgetPersisted(name) {
+        this.persistedSessions.delete(name);
+        this._persistDirty.add(name);
+    }
+    /** Merge this process's changes into the shared file and adopt the merged view. */
+    _savePersisted() {
+        if (this._persistDirty.size === 0)
+            return;
+        const merged = savePersistedSessions(this.persistedSessions, this._persistDirty, this.logger);
+        if (merged)
+            this.persistedSessions = merged;
+    }
     _persistSession(name, managed) {
         const resumeSessionId = this._managedResumeId(managed);
         if (!resumeSessionId) {
-            if (managed.config.engine === 'agy' && this.persistedSessions.delete(name)) {
+            if (managed.config.engine === 'agy' && this.persistedSessions.has(name)) {
+                this._forgetPersisted(name);
                 this._debouncedSave();
             }
             return;
         }
         managed.claudeSessionId = resumeSessionId;
         const existing = this.persistedSessions.get(name);
+        this._persistDirty.add(name);
         this.persistedSessions.set(name, {
             name,
             claudeSessionId: resumeSessionId,
@@ -1956,6 +2012,8 @@ export class SessionManager {
             model: managed.config.resolvedModel || managed.config.model,
             engine: managed.config.engine,
             sandboxMode: managed.config.sandboxMode,
+            autoCompactPercent: managed.config.autoCompactPercent,
+            chrome: managed.config.chrome,
             originalCreated: existing?.originalCreated || managed.created,
             lastResumed: new Date().toISOString(),
             lastActivity: managed.lastActivity,
@@ -3232,10 +3290,9 @@ export class SessionManager {
             catch {
                 /* session not in memory — fine */
             }
-            this.persistedSessions.delete(`autoloop-${runId}-planner`);
-            this.persistedSessions.delete(`autoloop-${runId}-coder`);
-            this.persistedSessions.delete(`autoloop-${runId}-reviewer`);
-            savePersistedSessions(this.persistedSessions, this.logger);
+            for (const role of ['planner', 'coder', 'reviewer'])
+                this._forgetPersisted(`autoloop-${runId}-${role}`);
+            this._savePersisted();
         }
         // No registry to scrub: the run record IS the registry, and removing it is
         // the delete. The ledger directory under tasks/<runId>/ is deliberately left
@@ -3285,12 +3342,12 @@ export class SessionManager {
         let pruned = false;
         for (const [name, entry] of this.persistedSessions) {
             if (now - entry.lastActivity > PERSIST_DISK_TTL_MS) {
-                this.persistedSessions.delete(name);
+                this._forgetPersisted(name);
                 pruned = true;
             }
         }
         if (pruned)
-            savePersistedSessionsAsync(this.persistedSessions);
+            this._debouncedSave();
     }
 }
 //# sourceMappingURL=session-manager.js.map