charness 3.5.0 → 3.6.1

package/dist/adapters/claudeJsonStreamAdapter.js

@@ -63,6 +63,9 @@ const claudeProfiles_1 = require("../utils/claudeProfiles");
 const adapterNames_1 = require("./adapterNames");
 const claudeCodeVersion_1 = require("../utils/claudeCodeVersion");
 const sessionLaunchDefaults_1 = require("./sessionLaunchDefaults");
+const jsonStreamPendingWork_1 = require("../utils/jsonStreamPendingWork");
+const lostWork_1 = require("../utils/lostWork");
+const claudeScheduledJobs_1 = require("../utils/claudeScheduledJobs");
 /**
  * In-flight explicit stops, per key — a second stop (or a start's implicit stop)
  * AWAITS the first instead of racing it: the delayed first `tmux kill-session`
@@ -126,9 +129,12 @@ class ClaudeJsonStreamAdapter extends events_1.EventEmitter {
      * conversation at a time whichever lifecycle runs it.
      */
     lifecycle;
+    /** How long the agent's own pending work holds the process after its last turn (`utils/jsonStreamPendingWork.ts`). */
+    pendingWorkHoldMs;
     constructor(options = { lifecycle: 'idle' }) {
         super();
         this.lifecycle = options.lifecycle;
+        this.pendingWorkHoldMs = options.backgroundHoldMs ?? jsonStreamPendingWork_1.pendingWorkHoldDefaultMs;
         this.name = options.lifecycle === 'perTurn' ? adapterNames_1.claudePerTurnAdapterName : adapterNames_1.claudeJsonStreamAdapterName;
         this.label = options.lifecycle === 'perTurn' ? 'Claude Code (per-turn)' : 'Claude Code (stream)';
     }
@@ -146,6 +152,12 @@ class ClaudeJsonStreamAdapter extends events_1.EventEmitter {
     claudeConfigDirReader = null;
     /** The stops in flight — the module-level map shared by both lifecycles' instances (see {@link stopsInFlightByKey}). */
     stopsInFlight = stopsInFlightByKey;
+    /** The agent's own pending work each ended process took with it, until the bot takes it ({@link takeLostWork}). */
+    lostWorkByKey = new Map();
+    /** A test instance's shorter pending-work hold (`createAdapter.registerPendingWorkHoldMs`). */
+    setPendingWorkHoldMs(holdMs) {
+        this.pendingWorkHoldMs = holdMs;
+    }
     setDisplayPrefsReader(reader) {
         this.displayPrefsReader = reader;
     }
@@ -337,7 +349,8 @@ class ClaudeJsonStreamAdapter extends events_1.EventEmitter {
             compactionInProgress: false, pendingCompaction: null,
             pendingQuestion: null, apiErrorFired: false, rejectedResetAtMs: null, swallowNextAbortError: false,
             lastWatermarkOffset: -1,
-            backgroundTaskIds: new Set(), claudeCodeVersion: null, applyingChunk: null,
+            backgroundTasks: new Map(), notificationTurnPendingSince: null, lastTurnEndedAt: Date.now(), isCompactionResultPending: false, scheduledJobs: new Map(),
+            claudeCodeVersion: null, applyingChunk: null,
             adoptCatchUpOffset: null, adoptCatchUpResolvers: [],
         };
         this.sessions.set((0, sessionKey_1.keyToString)(key), session);
@@ -518,6 +531,12 @@ class ClaudeJsonStreamAdapter extends events_1.EventEmitter {
         // Only act if this session is still the current one for the key.
         if (this.sessions.get((0, sessionKey_1.keyToString)(key)) !== session)
             return;
+        // An explicit stop (`/quit`, `/new`, a backend switch) releases the conversation and its record: nothing to tell
+        // its agent, nothing to write back — a write after the release would bring back a record the bot dropped.
+        if (!session.isStopping || session.isSuspending) {
+            this.recordLostWork(session);
+            this.clearPendingWorkOfEndedProcess(session);
+        }
         this.clearTimers(session);
         session.isActive = false;
         this.sessions.delete((0, sessionKey_1.keyToString)(key));
@@ -626,6 +645,7 @@ class ClaudeJsonStreamAdapter extends events_1.EventEmitter {
         const exitCode = (0, jsonStreamHost_1.readExitCodeFile)(paths.exitCodeFile);
         if (pid === null || exitCode !== null || !(0, jsonStreamHost_1.checkIsPidAlive)(pid)) {
             console.log(`[ClaudeJson] adopt: ${sessionName} process is dead (pid=${pid} exit=${exitCode}), cleaning up`);
+            this.storeLostWork(key, (0, lostWork_1.getLostWorkFromTailRecord)(persistedTail, claudeSessionId));
             await this.killOrphanTmuxSession(sessionName);
             return false;
         }
@@ -636,7 +656,8 @@ class ClaudeJsonStreamAdapter extends events_1.EventEmitter {
             return false;
         }
         const size = (0, jsonStreamHost_1.getFileSize)(paths.stdoutFile) ?? 0;
-        const { startOffset, backgroundTaskIds, isTurnInFlight, outstandingToolUseIds, claudeCodeVersion } = (0, jsonStreamHost_1.resolveAdoptedTail)(persistedTail, claudeSessionId, size);
+        const adoptedTail = (0, jsonStreamHost_1.resolveAdoptedTail)(persistedTail, claudeSessionId, size);
+        const { startOffset, isTurnInFlight, outstandingToolUseIds, claudeCodeVersion } = adoptedTail;
         console.log(`[ClaudeJson] adopt: re-attaching to ${sessionName} in ${workDir} (pid=${pid}, tail=${startOffset}/${size})`);
         const launchFlags = (0, jsonStreamHost_1.readWrapperScriptLaunchFlags)(paths.wrapperFile);
         const session = {
@@ -659,7 +680,8 @@ class ClaudeJsonStreamAdapter extends events_1.EventEmitter {
             // the topic resolves to now, and a later re-spawn passes them on.
             model: launchFlags.model, reportedModel: null, effort: launchFlags.effort,
             // The account the surviving process runs on is in its own wrapper; the bot compares it with the topic's pick.
-            configDir: (0, jsonStreamHost_1.readWrapperScriptConfigDir)(paths.wrapperFile), isConfigDirSwitchPending: false, startCostUsd: null,
+            // A switch the user picked while the process worked survives the reload: it still applies at the turn's end.
+            configDir: (0, jsonStreamHost_1.readWrapperScriptConfigDir)(paths.wrapperFile), isConfigDirSwitchPending: adoptedTail.isConfigDirSwitchPending, startCostUsd: null,
             currentResponseText: '', emittedLength: 0, outputTimer: null,
             reasoningText: '', reasoningStartedAt: null, reasoningTimer: null, reasoningActive: false,
             toolNamesById: new Map(), questionToolUseIds: new Set(),
@@ -670,8 +692,14 @@ class ClaudeJsonStreamAdapter extends events_1.EventEmitter {
             apiErrorFired: false, rejectedResetAtMs: null, swallowNextAbortError: false,
             lastWatermarkOffset: -1,
             // The frames that built the list and reported the version lie before the
-            // tail offset (not replayed): both come from the persisted record.
-            backgroundTaskIds: new Set(backgroundTaskIds), claudeCodeVersion, applyingChunk: null,
+            // tail offset (not replayed): both come from the persisted record, with the
+            // rest of the pending work (a turn announced, the hold's start, scheduled jobs).
+            backgroundTasks: new Map(adoptedTail.backgroundTasks.map((task) => [task.taskId, task.description])),
+            notificationTurnPendingSince: adoptedTail.notificationTurnPendingSinceMs,
+            lastTurnEndedAt: adoptedTail.lastTurnEndedAtMs ?? Date.now(),
+            isCompactionResultPending: false,
+            scheduledJobs: new Map(adoptedTail.scheduledJobs.map((job) => [job.jobId, job])),
+            claudeCodeVersion, applyingChunk: null,
             // Nothing to catch up on when the tail already sits at EOF.
             adoptCatchUpOffset: startOffset < size ? size : null, adoptCatchUpResolvers: [],
         };
@@ -710,6 +738,9 @@ class ClaudeJsonStreamAdapter extends events_1.EventEmitter {
         const resolvers = session.adoptCatchUpResolvers.splice(0);
         for (const resolve of resolvers)
             resolve();
+        // A switch the user picked before the reload, whose turn ended meanwhile, applies now that the state is current.
+        if (!isSessionGone)
+            this.applyPendingConfigDirSwitch(session);
     }
     /** Restore a pending question persisted by a previous bot life (see
      *  {@link writeQuestionSidecar}). Parse-boundary narrowing; the questions
@@ -841,15 +872,105 @@ class ClaudeJsonStreamAdapter extends events_1.EventEmitter {
             return false;
         return session.isBusy || this.checkHasBackgroundWork(key);
     }
-    /** Background tasks, input not yet taken in, a compaction in flight — "working" minus the turn (L-D2). */
+    /**
+     * The agent's own pending work (background tasks and scheduled jobs within the hold, a finished task's turn on its
+     * way), input not yet taken in, a compaction in flight — "working" minus the turn (L-D2).
+     */
     checkHasBackgroundWork(key) {
         const session = this.sessions.get((0, sessionKey_1.keyToString)(key));
         if (!session?.isActive)
             return false;
-        return session.backgroundTaskIds.size > 0
+        return (0, jsonStreamPendingWork_1.checkHasPendingWork)(this.getPendingWorkInput(session))
             || session.unconsumedInputCount > 0
             || session.compactionInProgress;
     }
+    /**
+     * @description The hold left for the session's background tasks / scheduled jobs (`utils/jsonStreamPendingWork.ts`):
+     * `null` without a live session or with nothing pending, `0` once spent. The idle fire re-checks no later than this.
+     */
+    getPendingWorkHoldRemainingMs(key) {
+        const session = this.sessions.get((0, sessionKey_1.keyToString)(key));
+        return session?.isActive ? (0, jsonStreamPendingWork_1.getPendingWorkHoldRemainingMs)(this.getPendingWorkInput(session)) : null;
+    }
+    /**
+     * @description Read what the process wrote since the last tail poll, so the working judgement is current: a stop
+     * decides on it, and the poll may lag the process by its backoff.
+     */
+    refreshWorkingState(key) {
+        const session = this.sessions.get((0, sessionKey_1.keyToString)(key));
+        if (!session?.isActive)
+            return;
+        try {
+            this.drainStdoutTail(session);
+        }
+        catch (e) {
+            console.warn(`[ClaudeJson] stdout tail read failed for ${(0, sessionKey_1.keyToString)(key)}:`, e instanceof Error ? e.message : e);
+        }
+    }
+    /**
+     * @description The agent's own pending work the conversation's LAST process took with it when it ended — a crash, a
+     * re-spawn, the idle stop after the pending-work hold, a process found gone at the adopt — handed over once (`null`
+     * when nothing was lost or it was already taken). The bot tells the agent (`utils/lostWork.ts`).
+     */
+    takeLostWork(key) {
+        const k = (0, sessionKey_1.keyToString)(key);
+        const lostWork = this.lostWorkByKey.get(k) ?? null;
+        this.lostWorkByKey.delete(k);
+        return lostWork;
+    }
+    /**
+     * @description What the LIVE process holds now that would die with it — read by the bot before it stops the
+     * process itself for a backend switch (an explicit stop records nothing); `null` when nothing is pending.
+     */
+    getPendingWork(key) {
+        const session = this.sessions.get((0, sessionKey_1.keyToString)(key));
+        if (!session?.isActive)
+            return null;
+        const pendingWork = this.describePendingWork(session, { isTurnCutOff: true });
+        return (0, lostWork_1.checkHasLostWork)(pendingWork) ? pendingWork : null;
+    }
+    /**
+     * Keep what a process that ended by itself (or at the idle stop) held. A turn a crash cut off is not counted: the
+     * request core re-posts and wakes an open request (R21); the idle stop never runs mid-turn.
+     */
+    recordLostWork(session) {
+        this.storeLostWork(session.key, this.describePendingWork(session, { isTurnCutOff: false }));
+    }
+    /** The pending work of a process: its background tasks, its scheduled jobs, a finished task's turn not yet run, and — when the bot itself cuts it off — the turn under way. */
+    describePendingWork(session, options) {
+        return {
+            backgroundTasks: [...session.backgroundTasks].map(([taskId, description]) => ({ taskId, description })),
+            scheduledJobCount: session.scheduledJobs.size,
+            hasUnreadTaskResult: (0, jsonStreamPendingWork_1.checkIsNotificationTurnPending)({ now: Date.now(), notificationTurnPendingSince: session.notificationTurnPendingSince }),
+            wasTurnInFlight: options.isTurnCutOff && session.isBusy && !session.compactionInProgress,
+        };
+    }
+    /**
+     * The ended process's pending work is handled here (kept for the bot, or released): the record must not carry it,
+     * or the next boot would read the conversation's process as one that died with work pending.
+     */
+    clearPendingWorkOfEndedProcess(session) {
+        session.backgroundTasks = new Map();
+        session.scheduledJobs = new Map();
+        session.notificationTurnPendingSince = null;
+        this.jsonStreamTailWriter?.(session.key, buildTailRecord(session, session.lastPersistedTailOffset));
+    }
+    storeLostWork(key, lostWork) {
+        if ((0, lostWork_1.checkHasLostWork)(lostWork))
+            this.lostWorkByKey.set((0, sessionKey_1.keyToString)(key), lostWork);
+        else
+            this.lostWorkByKey.delete((0, sessionKey_1.keyToString)(key));
+    }
+    getPendingWorkInput(session) {
+        return {
+            now: Date.now(),
+            backgroundTaskCount: session.backgroundTasks.size,
+            scheduledJobCount: session.scheduledJobs.size,
+            lastTurnEndedAt: session.lastTurnEndedAt,
+            holdMs: this.pendingWorkHoldMs,
+            notificationTurnPendingSince: session.notificationTurnPendingSince,
+        };
+    }
     /** The CLI version the live process reported on `system/init`, `null` until then (L-D10 gate input). */
     getClaudeCodeVersion(key) {
         return this.sessions.get((0, sessionKey_1.keyToString)(key))?.claudeCodeVersion ?? null;
@@ -934,6 +1055,7 @@ class ClaudeJsonStreamAdapter extends events_1.EventEmitter {
             timer.unref?.();
             session.pendingCompaction = { resolve, timer, sawSuccess: false };
             session.compactionInProgress = true;
+            session.isCompactionResultPending = true;
             // Fresh turn: reset the answer cursor + idle-watchdog clock, mark busy.
             session.currentResponseText = '';
             session.emittedLength = 0;
@@ -1186,6 +1308,9 @@ class ClaudeJsonStreamAdapter extends events_1.EventEmitter {
                 case 'backgroundTasks':
                     this.handleBackgroundTasks(session, action);
                     return;
+                case 'taskNotification':
+                    this.handleTaskNotification(session, action);
+                    return;
                 case 'apiRetry':
                     this.maybeEmitApiError(session, action.text);
                     return;
@@ -1205,10 +1330,20 @@ class ClaudeJsonStreamAdapter extends events_1.EventEmitter {
                 // it `/status` and the pinned banner showed no model at all on a default
                 // start / resume / adopt (nothing ever set the `--model` pick).
                 this.handleInit(session, action);
+                // `init` opens every turn: the turn runs from here, not from its first output.
+                this.markTurnStarted(session);
+                return;
+            case 'turnStarted':
+                this.markTurnStarted(session);
+                if (action.wakeupSource !== null)
+                    session.scheduledJobs = (0, claudeScheduledJobs_1.getScheduledJobsAfterFiring)(session.scheduledJobs, action.wakeupSource);
                 return;
             case 'backgroundTasks':
                 this.handleBackgroundTasks(session, action);
                 return;
+            case 'taskNotification':
+                this.handleTaskNotification(session, action);
+                return;
             case 'textDelta':
                 // Mid-turn activity marks the session busy: `sendInput` normally set it,
                 // but an ADOPTED session (bot restart mid-turn) reconstructs the busy
@@ -1274,7 +1409,17 @@ class ClaudeJsonStreamAdapter extends events_1.EventEmitter {
      *  WHOLE on every change, so no diffing). The tail-offset persist that follows
      *  this frame's drain carries the new list to `state.json`. */
     handleBackgroundTasks(session, action) {
-        session.backgroundTaskIds = new Set(action.taskIds);
+        session.backgroundTasks = new Map(action.tasks.map((task) => [task.taskId, task.description]));
+    }
+    /** A background task ended: its own turn is coming — the list empties right after this frame, the turn shows later. */
+    handleTaskNotification(session, action) {
+        if (session.backgroundTasks.has(action.taskId))
+            session.notificationTurnPendingSince = Date.now();
+    }
+    /** A turn began (its `init`, the CLI's running state, a scheduled job firing): busy from here; an announced turn has shown. */
+    markTurnStarted(session) {
+        session.isBusy = true;
+        session.notificationTurnPendingSince = null;
     }
     // — compaction (F3) —
     handleCompactStatus(session, action) {
@@ -1401,11 +1546,25 @@ class ClaudeJsonStreamAdapter extends events_1.EventEmitter {
         if (session.questionToolUseIds.has(action.toolUseId))
             return;
         const tool = session.toolNamesById.get(action.toolUseId) ?? 'tool';
+        this.trackScheduledJob(session, tool, action.output);
         if (!action.output.trim())
             return;
         // Mode-agnostic emit — the bot applies the per-thread `/tool_results` pref.
         this.emit('toolResult', session.key, { tool, output: action.output });
     }
+    /** A `CronCreate` / `CronDelete` / `ScheduleWakeup` result changes the session-only jobs the process holds. */
+    trackScheduledJob(session, tool, output) {
+        if (tool === claudeScheduledJobs_1.cronCreateToolName || tool === claudeScheduledJobs_1.loopWakeupToolName) {
+            const job = tool === claudeScheduledJobs_1.cronCreateToolName ? (0, claudeScheduledJobs_1.getScheduledJobFromCronCreateResult)(output) : (0, claudeScheduledJobs_1.getScheduledJobFromLoopWakeupResult)(output);
+            if (job)
+                session.scheduledJobs.set(job.jobId, job);
+        }
+        else if (tool === claudeScheduledJobs_1.cronDeleteToolName) {
+            const jobId = (0, claudeScheduledJobs_1.getCancelledJobIdFromCronDeleteResult)(output);
+            if (jobId)
+                session.scheduledJobs.delete(jobId);
+        }
+    }
     // — sub-agent (v1) —
     markSubagentActive(session) {
         session.subagentActive = true;
@@ -1469,6 +1628,13 @@ class ClaudeJsonStreamAdapter extends events_1.EventEmitter {
             console.log(`${exports.claudeJsonStreamUsageLogPrefix}${(0, sessionKey_1.keyToString)(session.key)}: input=${inputTokens} cacheRead=${cacheReadTokens} cacheWrite=${cacheWriteTokens} output=${outputTokens}`);
         }
         session.isBusy = false;
+        // The pending-work hold counts from the agent's own last turn: a bot-issued compaction is not one. A task that
+        // finished during the turn is NOT folded into it: its own turn starts right after this `result` (`init` +45 ms,
+        // measured on 2.1.310), so its announcement stays until that turn shows — clearing it here would let the per-turn
+        // stop kill the process in that gap.
+        if (!session.isCompactionResultPending)
+            session.lastTurnEndedAt = Date.now();
+        session.isCompactionResultPending = false;
         // Self-healing accounting: a FAILED turn (usage limit, API error) may never echo the messages that were
         // queued behind it, and a count left above zero would make the session look "working" forever — a pending
         // account switch would never fire. A message still genuinely queued is echoed later (the decrement clamps
@@ -1803,6 +1969,9 @@ class ClaudeJsonStreamAdapter extends events_1.EventEmitter {
         const { key, workDir, sessionId } = session;
         const configDir = change.configDir === undefined ? session.configDir : change.configDir;
         session.isRespawning = true;
+        // The re-spawned process starts with none of the old one's background tasks or jobs, and the turn it cuts off is
+        // re-prompted by nothing else.
+        this.storeLostWork(key, this.describePendingWork(session, { isTurnCutOff: true }));
         this.rejectQuestion(key);
         await session.stdinWriteChain.catch(() => { });
         this.clearTimers(session);
@@ -1843,6 +2012,8 @@ class ClaudeJsonStreamAdapter extends events_1.EventEmitter {
         }
         if (!options.isAfterLimit && this.checkIsWorking(key)) {
             session.isConfigDirSwitchPending = true;
+            // Recorded now: a reload before the turn ends must not drop the user's pick.
+            this.jsonStreamTailWriter?.(key, buildTailRecord(session, session.lastPersistedTailOffset));
             return 'deferred';
         }
         session.isConfigDirSwitchPending = false;
@@ -1900,14 +2071,22 @@ exports.ClaudeJsonStreamAdapter = ClaudeJsonStreamAdapter;
  *  state in force there (task list, turn in flight, outstanding tools) travel together
  *  (see `JsonStreamTailOffset`). */
 function buildTailRecord(session, offsetBytes) {
+    const backgroundTasks = [...session.backgroundTasks].map(([taskId, description]) => ({ taskId, description }));
+    const isWorkPending = session.backgroundTasks.size > 0 || session.scheduledJobs.size > 0;
     return {
         sessionId: session.sessionId,
         offsetBytes,
-        backgroundTaskIds: [...session.backgroundTaskIds],
+        backgroundTaskIds: backgroundTasks.map((task) => task.taskId),
         isTurnInFlight: session.isBusy,
         outstandingToolUseIds: [...session.outstandingToolUseIds],
         // Only once known: the record never claims a version the process did not report.
         ...(session.claudeCodeVersion !== null ? { claudeCodeVersion: session.claudeCodeVersion } : {}),
+        // The pending work only while there is some: an idle record stays as it was.
+        ...(backgroundTasks.length > 0 ? { backgroundTasks } : {}),
+        ...(isWorkPending ? { lastTurnEndedAtMs: session.lastTurnEndedAt } : {}),
+        ...(session.scheduledJobs.size > 0 ? { scheduledJobs: [...session.scheduledJobs.values()] } : {}),
+        ...(session.notificationTurnPendingSince !== null ? { notificationTurnPendingSinceMs: session.notificationTurnPendingSince } : {}),
+        ...(session.isConfigDirSwitchPending ? { isConfigDirSwitchPending: true } : {}),
     };
 }
 /**