aicodeman 1.42.0 → 1.44.0

package/dist/session.js

@@ -49,6 +49,7 @@ import { DEFAULT_TMUX_HISTORY_LIMIT } from './config/terminal-history.js';
 import { EXEC_TIMEOUT_MS } from './config/exec-timeout.js';
 import { getCli } from './config/cli-registry/registry.js';
 import { SubmitVerifier } from './session-submit-verifier.js';
+import { KEEP_WARM_NUDGE } from './prompt-cache-keepwarm.js';
 import { compileVersionRegex } from './config/cli-registry/patterns.js';
 import { resolveSessionCliVersion } from './utils/cli-resolver.js';
 import { buildInteractiveArgs, buildPromptArgs, buildClaudeEnv, buildMuxAttachEnv, buildShellEnv, } from './session-cli-builder.js';
@@ -297,6 +298,14 @@ export function resolveMuxAttachCwd(workingDir, remote, docker) {
     // wrapper pane never needs the workspace as its cwd, so launch it in /tmp.
     return remote || docker ? '/tmp' : workingDir;
 }
+/**
+ * Whether a programmatic write leaves the keep-alive turn running: the nudge itself, or a bare
+ * Enter (which submits nothing new). Anything else carrying an Enter starts a turn of its own.
+ */
+function isKeepAliveWrite(data) {
+    const text = data.replace(/[\r\n]/g, '').trim();
+    return text === '' || text === KEEP_WARM_NUDGE;
+}
 /**
  * Event signatures emitted by the Session class.
  * Subscribe using `session.on('eventName', handler)`.
@@ -341,6 +350,8 @@ export class Session extends EventEmitter {
     _taskCache = new SessionTaskCache();
     _name;
     _nameSource;
+    /** `pinCliSessionName` as of the last spawn (see {@link _refreshCliNamePin}). */
+    _pinEveryCliName = false;
     /**
      * Reconstructs the composer draft from USER keystrokes so the first real
      * prompt can name the tab. Fed only when a write says `fromUser`, and never
@@ -434,6 +445,16 @@ export class Session extends EventEmitter {
     _watching = null;
     /** Last `prompt_cache` report from the statusline exporter; null until Claude sends one. */
     _promptCache = null;
+    /** Prompt-cache keep-warm opt-in; undefined = follow the app-wide default. Persisted. */
+    _keepWarmEnabled;
+    /** Last status the keep-warm service published for this session; ephemeral. */
+    _keepWarm = null;
+    /** Until when the current turn counts as Codeman's own keep-alive (hooks open pre-acknowledged). */
+    _keepAliveTurnUntil = 0;
+    /** Last keystroke a person sent through a `fromUser` write. */
+    _lastHumanInputAt = 0;
+    /** Last submit that was not the keep-alive's own; the keep-warm cap's clock. Persisted. */
+    _lastRealPromptAt = 0;
     /** Lazily compiled `capabilities.workDetect.workingLine`. See _workingLinePattern(). */
     _workingLineRe = undefined;
     /** Lazily compiled `capabilities.workDetect.watchingLine`. See _watchingLinePattern(). */
@@ -573,6 +594,8 @@ export class Session extends EventEmitter {
     _piConfig;
     // Grok configuration (only for mode === 'grok')
     _grokConfig;
+    // GitHub Copilot configuration (only for mode === 'copilot')
+    _copilotConfig;
     // DeepSeek Harness configuration (only for mode === 'deepseek')
     _deepSeekConfig;
     // OMP configuration (only for mode === 'omp')
@@ -613,7 +636,7 @@ export class Session extends EventEmitter {
     _owner;
     // The session that spawned this one (tab lineage lines). Resolved by the create
     // route before it reaches here, so this is always either an id that existed at
-    // create time or undefined. Decoration only — see SessionState.parentSessionId.
+    // create time or undefined. Decoration only (plus the keep-warm default); see SessionState.parentSessionId.
     _parentSessionId;
     // Session color for visual differentiation
     _color = 'default';
@@ -683,6 +706,10 @@ export class Session extends EventEmitter {
         // response viewer re-derive the live conversation without waiting for the
         // user to type again.
         this._lastSubmitAt = config.lastSubmitAt ?? 0;
+        // Restored so a restart neither reopens the keep-warm window nor drops the choice. A state.json
+        // from before the field has only `lastSubmitAt`, and every submit then was a real one.
+        this._lastRealPromptAt = config.lastRealPromptAt ?? config.lastSubmitAt ?? 0;
+        this._keepWarmEnabled = config.keepWarmEnabled;
         // Restored chain: its tail is the conversation the CLI was actually on when
         // the server stopped, which outranks the launch id seeded just above. The
         // FIRST-HAND flag is deliberately NOT restored — a persisted claim is not a
@@ -741,6 +768,10 @@ export class Session extends EventEmitter {
         if (config.grokConfig) {
             this._grokConfig = config.grokConfig;
         }
+        // Apply GitHub Copilot configuration
+        if (config.copilotConfig) {
+            this._copilotConfig = config.copilotConfig;
+        }
         // Apply env overrides (exported at spawn, not persisted to disk).
         // Legacy migration: pre-0.7.2 carried effort as the CLAUDE_CODE_EFFORT_LEVEL env var,
         // which hard-locks /effort switching. Extract it into _effort (--settings soft default)
@@ -1137,11 +1168,15 @@ export class Session extends EventEmitter {
      * report. It rides `toState()` for the Session Options readout and is restored on a
      * Codeman restart (constructor `promptCache`) so the row is not blank until the pane's
      * next render; the readout is time-aware, so a value whose `expiresAt` has passed renders
-     * as cold rather than as a stale warm.
+     * as cold rather than as a stale warm, and a future one lets the keep-warm re-arm without a turn.
      */
     get promptCache() {
         return this._promptCache;
     }
+    /** Whether the current launch carries the statusLine exporter (`MuxSession.statusLine`); undefined when unknown. */
+    get statusLineExporter() {
+        return this._muxSession?.statusLine;
+    }
     /**
      * Replace the prompt-cache report; true when it differs from the previous one. Stamps
      * `compactedAt` when this report ENTERS the window in which Claude Code reads
@@ -1170,6 +1205,56 @@ export class Session extends EventEmitter {
         this._promptCache = next;
         return changed;
     }
+    /** Prompt-cache keep-warm opt-in; undefined means the app-wide default applies. */
+    get keepWarmEnabled() {
+        return this._keepWarmEnabled;
+    }
+    setKeepWarmEnabled(enabled) {
+        this._keepWarmEnabled = enabled;
+    }
+    /** What the keep-warm service last published for this session, or null before its first evaluation. */
+    get keepWarm() {
+        return this._keepWarm;
+    }
+    /** Replace the keep-warm status; true when it differs from the previous one. */
+    setKeepWarmStatus(status) {
+        const changed = JSON.stringify(status) !== JSON.stringify(this._keepWarm);
+        this._keepWarm = status;
+        return changed;
+    }
+    /**
+     * True while the running turn is Codeman's own keep-alive nudge: its stop hook and idle
+     * prompt open pre-acknowledged, and its submit moves `lastSubmitAt` (it IS a submit, and the
+     * response viewer's conversation correlation needs it) but not `lastRealPromptAt`. The turn's
+     * own idle prompt ends it (`endKeepAliveTurn()`), and so does any other submit: a `fromUser`
+     * write, a programmatic write of anything but the nudge, or a `prompt_submitted` hook for
+     * another prompt, so a prompt right after a nudge counts and alerts normally.
+     */
+    get keepAliveTurnActive() {
+        return Date.now() < this._keepAliveTurnUntil;
+    }
+    beginKeepAliveTurn(windowMs) {
+        this._keepAliveTurnUntil = Date.now() + windowMs;
+    }
+    endKeepAliveTurn() {
+        this._keepAliveTurnUntil = 0;
+    }
+    /** Last keystroke a person sent (`fromUser` write), epoch ms; 0 when none this process. */
+    get lastHumanInputAt() {
+        return this._lastHumanInputAt;
+    }
+    /**
+     * Last submit that was not the keep-alive's own, from any writer or the UserPromptSubmit hook
+     * (a person typing in an attached tmux client reaches Codeman only through the hook); epoch
+     * ms, 0 if none. The keep-warm cap counts from it; persisted so a restart keeps it.
+     */
+    get lastRealPromptAt() {
+        return this._lastRealPromptAt;
+    }
+    /** Whether this launch carries `idleCompaction: false` (`MuxSession.idleCompactionOff`). */
+    get idleCompactionOptOut() {
+        return this._muxSession?.idleCompactionOff === true;
+    }
     /**
      * Check if the session's process tree has active child processes beyond Claude itself.
      * Detects running bash tools, test suites, builds, servers, etc. that Claude spawned.
@@ -1434,16 +1519,31 @@ export class Session extends EventEmitter {
         return this._nameSource;
     }
     /**
-     * The name to pin on the Claude CLI as `--name`, or undefined to let Claude
-     * title the conversation itself. `--name` is the prompt-box label, the
-     * `/resume` picker entry and the terminal title all at once, and a pinned
-     * title stops Claude generating its own, so only a name the user chose is
-     * worth pinning. Pinning the `w1-myapp` placeholder gave every conversation
-     * in a case the same `/resume` entry; an auto name is a cut of the first
-     * prompt, which Claude's own generated title already beats.
+     * The name to pin on the Claude CLI as `--name`, or undefined to let Claude title the
+     * conversation itself. `--name` is the prompt-box label, the `/resume` picker entry and the
+     * terminal title all at once, and a pinned title stops Claude generating its own.
+     *
+     * By default only a name the user chose is pinned. Pinning the `w1-myapp` placeholder gave
+     * every conversation in a case the same `/resume` entry (the tab number restarts once a
+     * case's tabs are closed), and an auto name is a cut of the first prompt, which Claude's
+     * own generated title already beats.
+     *
+     * With the opt-in `pinCliSessionName` setting every non-blank tab name is pinned, so the
+     * CLI's labels read the same as the tabs, at the cost of those generated titles. A rename
+     * in Codeman then holds only until the next turn: a process started with `--name`
+     * re-appends its in-memory title (see claude-session-title.ts). The setting is re-read
+     * at each spawn and respawn by {@link _refreshCliNamePin}.
      */
     get cliPinnedName() {
-        return this._nameSource === 'manual' ? this._name : undefined;
+        if (!this._pinEveryCliName)
+            return this._nameSource === 'manual' ? this._name : undefined;
+        return this._name.trim() ? this._name : undefined;
+    }
+    /** Re-read `pinCliSessionName` so `cliPinnedName` decides per launch, with no server restart. */
+    async _refreshCliNamePin() {
+        // Dynamic: hooks-config -> route-helpers imports Session, so a static import would be a cycle.
+        const { readPinCliSessionNameEnabled } = await import('./hooks-config.js');
+        this._pinEveryCliName = await readPinCliSessionNameEnabled();
     }
     setAutoClear(enabled, threshold) {
         this._autoOps.setAutoClear(enabled, threshold);
@@ -1585,7 +1685,9 @@ export class Session extends EventEmitter {
             autoResumeEnabled: this._autoOps.autoResumeEnabled,
             autoResumeAt: this._autoOps.autoResumeAt ?? undefined,
             promptCache: this._promptCache ?? undefined,
-            statusLineExporter: this._muxSession?.statusLine,
+            statusLineExporter: this.statusLineExporter,
+            keepWarmEnabled: this._keepWarmEnabled,
+            keepWarm: this._keepWarm ?? undefined,
             imageWatcherEnabled: this._imageWatcherEnabled,
             pinned: this._pinned || undefined,
             pinnedAt: this._pinned ? (this._pinnedAt ?? undefined) : undefined,
@@ -1612,6 +1714,7 @@ export class Session extends EventEmitter {
             antigravityConfig: this._antigravityConfig,
             piConfig: this._piConfig,
             grokConfig: this._grokConfig,
+            copilotConfig: this._copilotConfig,
             deepSeekConfig: this._deepSeekConfig,
             ompConfig: this._ompConfig,
             resumeSessionId: this._resumeSessionId,
@@ -1633,6 +1736,7 @@ export class Session extends EventEmitter {
             paneExit: this._paneExit ?? undefined,
             attachmentHistory: this.attachmentHistory.length > 0 ? this.attachmentHistory : undefined,
             lastSubmitAt: this._lastSubmitAt || undefined,
+            lastRealPromptAt: this._lastRealPromptAt || undefined,
             // Only a chain the CLI's own hooks vouched for is persisted, and only when
             // the pane actually moved conversation. Its LAST entry is the live one, so
             // it is also what restores `claudeSessionId` across a restart — `start()`
@@ -1963,6 +2067,7 @@ export class Session extends EventEmitter {
             antigravityConfig: this._antigravityConfig,
             piConfig: this._piConfig,
             grokConfig: this._grokConfig,
+            copilotConfig: this._copilotConfig,
             deepSeekConfig: this._deepSeekConfig,
             // OMP resolution/pinning does NOT happen here. This object is built
             // EAGERLY — including on every boot-recovery reattach, before anyone
@@ -1979,6 +2084,8 @@ export class Session extends EventEmitter {
             unsetEnvKeys: this._pendingEnvUnsets.size > 0 ? [...this._pendingEnvUnsets] : undefined,
             effort: this._effort,
             advisorModel: this._advisorModel,
+            keepWarm: this._keepWarmEnabled,
+            spawnedByAgent: !!this._parentSessionId,
             historyLimit: this._tmuxHistoryLimit,
             remote: this._remote,
             docker: this._docker,
@@ -2056,6 +2163,7 @@ export class Session extends EventEmitter {
      * still inside it and renders no local `--session-id` to collide.
      */
     async _buildRespawnPaneOptionsWithResumePin() {
+        await this._refreshCliNamePin();
         const options = this._buildRespawnPaneOptions();
         if (this._remote || this._docker)
             return options;
@@ -2320,6 +2428,7 @@ export class Session extends EventEmitter {
         if (this._closing) {
             throw new Error('Session is being closed');
         }
+        await this._refreshCliNamePin();
         // Bounds the workspace-trust scan (see _maybeAcceptTrustDialog). Stamped here
         // rather than at PTY spawn so a slow mux attach still counts as startup.
         this._interactiveStartedAt = Date.now();
@@ -2439,12 +2548,15 @@ export class Session extends EventEmitter {
                         antigravityConfig: this._antigravityConfig,
                         piConfig: this._piConfig,
                         grokConfig: this._grokConfig,
+                        copilotConfig: this._copilotConfig,
                         deepSeekConfig: this._deepSeekConfig,
                         ompConfig: this._ompConfig,
                         resumeSessionId: this._resumeSessionId,
                         envOverrides: this._envOverrides,
                         effort: this._effort,
                         advisorModel: this._advisorModel,
+                        keepWarm: this._keepWarmEnabled,
+                        spawnedByAgent: !!this._parentSessionId,
                         historyLimit: this._tmuxHistoryLimit,
                         remote: this._remote,
                         docker: this._docker,
@@ -2977,6 +3089,7 @@ export class Session extends EventEmitter {
             antigravityConfig: this._antigravityConfig,
             piConfig: this._piConfig,
             grokConfig: this._grokConfig,
+            copilotConfig: this._copilotConfig,
             deepSeekConfig: this._deepSeekConfig,
             ompConfig: this._ompConfig,
         };
@@ -4064,9 +4177,18 @@ export class Session extends EventEmitter {
      */
     _trackSubmit(data, options) {
         const submitted = options.fromUser && this._acceptsPrompts ? this._submittedPromptTracker.feed(data) : [];
-        if (data.includes('\r') || data.includes('\n')) {
-            this._lastSubmitAt = Date.now();
-        }
+        const hasEnter = data.includes('\r') || data.includes('\n');
+        if (options.fromUser) {
+            this._lastHumanInputAt = Date.now();
+            // A person is here: whatever turn follows is theirs, not the keep-alive's.
+            this._keepAliveTurnUntil = 0;
+        }
+        else if (hasEnter && !isKeepAliveWrite(data)) {
+            // Anything else submitted (an agent, respawn, auto-resume) starts a turn of its own.
+            this._keepAliveTurnUntil = 0;
+        }
+        if (hasEnter)
+            this._stampSubmit();
         return submitted;
     }
     /**
@@ -4090,9 +4212,21 @@ export class Session extends EventEmitter {
      * `_trackSubmit` only sees input that flows through Codeman's write path, so
      * a pane the user drives by attaching to tmux directly never stamped this and
      * `lastSubmitAt` stayed 0 for its whole life.
+     *
+     * `prompt` is the hook's own prompt text: anything but the keep-alive's ends the keep-alive
+     * window, because a person typing in an attached tmux client reaches Codeman only here, and
+     * their prompt must count as real and alert normally.
      */
-    markPromptSubmitted() {
+    markPromptSubmitted(prompt) {
+        if (prompt !== undefined && prompt.trim() !== KEEP_WARM_NUDGE)
+            this._keepAliveTurnUntil = 0;
+        this._stampSubmit();
+    }
+    /** Every submit moves `lastSubmitAt`; only one outside a keep-alive turn moves `lastRealPromptAt`. */
+    _stampSubmit() {
         this._lastSubmitAt = Date.now();
+        if (!this.keepAliveTurnActive)
+            this._lastRealPromptAt = this._lastSubmitAt;
     }
     /**
      * Per-client highest-applied input sequence, for exactly-once input delivery.
@@ -4222,7 +4356,7 @@ export class Session extends EventEmitter {
                 : this._mux.capturePaneText?.(this._muxSession.muxName),
             sendEnter: () => this._mux?.sendInput(this.id, '\r'),
             // ⚠ NO fallback glyph here, unlike the screen-reading probe elsewhere in this file.
-            // Only claude, codex, pi, opencode, omp and gemini declare a promptGlyph; the other modes would fall back
+            // Only claude, codex, pi, opencode, omp, gemini and antigravity declare a promptGlyph; the other modes would fall back
             // to claude's `❯`, which is ALSO starship's default shell prompt (and pure's, and
             // spaceship's, and p10k lean's). On a shell session the line `❯ npm run build` sits
             // on screen for as long as the command runs, promptStillInComposer() reads that as