@enderfga/claw-orchestrator 7.6.2 → 7.8.0

package/dist/src/session-manager.js

@@ -36,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 {
@@ -53,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 () => {
@@ -117,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';
@@ -327,6 +334,13 @@ function validateAutoloopEffort(role, effort) {
  * engine emits a result event of its own shape, so anything that is not an
  * array of objects naming a tool is ignored rather than trusted.
  */
+/** Images an engine attached to its result event as `generated_images`. */
+function readGeneratedImages(evt) {
+    const raw = evt?.generated_images;
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter((i) => !!i && typeof i === 'object' && typeof i.path === 'string');
+}
 function readPermissionDenials(evt) {
     const raw = evt?.permission_denials;
     if (!Array.isArray(raw))
@@ -392,7 +406,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);
     }
@@ -445,6 +459,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)
@@ -518,6 +536,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 } : {}),
         };
@@ -617,6 +637,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,
@@ -687,6 +721,7 @@ export class SessionManager {
                     // through. The result event was dropped at this line, and it is the
                     // only record of a blocked call: the turn itself still reports success.
                     const permissionDenials = readPermissionDenials(evt);
+                    const images = readGeneratedImages(evt);
                     // The record holds what the caller said, never the replayed history in
                     // front of it — a second handoff would otherwise nest one inside the other.
                     managed.transcript ??= newTranscript();
@@ -701,6 +736,7 @@ export class SessionManager {
                         error: turnError,
                         events: [],
                         ...(permissionDenials.length ? { permissionDenials } : {}),
+                        ...(images.length ? { images } : {}),
                     };
                 }
                 return { output: '', sessionId: this._managedResumeId(managed), events: [] };
@@ -757,6 +793,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,
@@ -813,6 +850,7 @@ export class SessionManager {
             toolCalls: 0,
             toolErrors: 0,
             costUsd: 0,
+            refusalFallbacks: 0,
         };
         try {
             const st = managed.session.getStats();
@@ -825,6 +863,7 @@ export class SessionManager {
                 toolCalls: st.toolCalls || 0,
                 toolErrors: st.toolErrors || 0,
                 costUsd: this._spentUsd(managed),
+                refusalFallbacks: st.refusalFallbacks || 0,
             };
         }
         catch {
@@ -865,12 +904,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)
@@ -1103,8 +1151,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) {
@@ -1505,7 +1553,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) ─────────────────────
     /**
@@ -1940,16 +1988,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,
@@ -1957,6 +2021,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,
@@ -2804,6 +2870,7 @@ export class SessionManager {
             // this inside the startup try makes an append failure follow the same
             // cleanup path as any other failed resume.
             opts._commitTimeoutMigration?.();
+            await this._recoverCommittedCoderIteration(opts.workspace, ledgerDir, runId, runner, dispatcher);
         }
         catch (err) {
             try {
@@ -2819,6 +2886,57 @@ export class SessionManager {
         }
         return { runner, dispatcher, ledgerDir, pushPolicy };
     }
+    /**
+     * If the durable ledger has a committed Coder iteration with no Reviewer
+     * verdict, and HEAD still names that iter, deliver it to Reviewer once.
+     * Git failure or a subject mismatch leaves this resume as a Planner-only boot.
+     */
+    async _recoverCommittedCoderIteration(workspace, ledgerDir, runId, runner, dispatcher) {
+        const iterRoot = path.join(ledgerDir, 'iter');
+        if (!fs.existsSync(iterRoot))
+            return;
+        const iters = fs
+            .readdirSync(iterRoot)
+            .filter((name) => /^\d+$/.test(name))
+            .map((name) => Number(name));
+        if (iters.length === 0)
+            return;
+        const n = Math.max(...iters);
+        const artifacts = ['directive.json', 'eval_output.json', 'coder_summary.txt', 'diff.patch'];
+        const iterDir = path.join(iterRoot, String(n));
+        if (artifacts.some((name) => !fs.existsSync(path.join(iterDir, name))))
+            return;
+        if (fs.existsSync(path.join(iterDir, 'verdict.json')))
+            return;
+        for (let i = 0; i < n; i++) {
+            if (!fs.existsSync(path.join(iterRoot, String(i), 'verdict.json')))
+                return;
+        }
+        let subject;
+        try {
+            subject = execFileSync('git', ['-C', workspace, 'log', '-1', '--format=%s'], {
+                encoding: 'utf8',
+            }).trim();
+        }
+        catch {
+            return;
+        }
+        if (!subject.startsWith(`autoloop/iter-${n}:`))
+            return;
+        this.logger.info?.(`[autoloop/${runId}] recovering committed iter ${n} into Reviewer`);
+        await dispatcher.spawnSubagents();
+        runner.markSubagentsSpawned();
+        runner.state.iter = n;
+        void runner
+            .send(AutoloopMsg.reviewRequest(n, {
+            iter: n,
+            ledger_path: ledgerDir,
+            prior_metrics: runner.state.metric_history.slice(-10),
+        }))
+            .catch((err) => {
+            this.logger.warn?.(`[autoloop/${runId}] recovered review_request failed: ${err instanceof Error ? err.message : String(err)}`);
+        });
+    }
     /**
      * Start a v2 autoloop in chat mode. Creates the Planner persistent session,
      * returns the run handle. Coder/Reviewer are NOT started until S3's
@@ -3233,10 +3351,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
@@ -3286,12 +3403,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