commandmate 0.46.0 → 0.47.0

package/dist/server/src/lib/auto-yes-shutdown-record.js

@@ -0,0 +1,257 @@
+"use strict";
+/**
+ * What a graceful shutdown released, for the next process to explain
+ * (Issue #3730).
+ *
+ * Auto-Yes grants live in memory (`auto-yes-state`), and the lifecycle table
+ * keeps `server-shutdown` at `state: 'none'` on purpose: a restarted server
+ * starts with every grant OFF. What was missing is the reason. Without it an
+ * instance whose grant the restart took reads exactly like one that was never
+ * armed, and a worker sits at its next permission dialog with nothing anywhere
+ * saying why.
+ *
+ * So the shutdown writes down which grants were live, and the next start seeds
+ * each still in-period one as a DISABLED state with
+ * `stopReason: 'server-restart'` (`seedServerRestartNotice`). This is the
+ * explanation of a release, never a restore: nothing here enables a grant or
+ * starts a poller.
+ *
+ * ## Scope
+ *
+ * - Graceful stops only (SIGINT / SIGTERM through `server.ts`). A SIGKILL, a
+ *   crash or a power loss records nothing; every grant then comes back off with
+ *   no reason, which is the behaviour before this module.
+ * - One record per database: `<CM_DB_PATH>.auto-yes-shutdown.json`. The normal
+ *   server's `cm.db` and an Issue server's `cm-N.db` share a directory, so a
+ *   fixed name would let one server read the other's grants. Two processes on
+ *   ONE database (#1360 calls that a misconfiguration) share the file, and the
+ *   last writer wins.
+ * - `CM_AUTO_YES_SHUTDOWN_RECORD_PATH` overrides the location; `tests/setup.ts`
+ *   points it at a per-worker temp file so no test touches a real one.
+ *
+ * ## Failure
+ *
+ * Every failure is logged and swallowed. A record that cannot be written costs
+ * the next start its explanation and nothing else; one that cannot be read,
+ * parsed or removed leaves every grant off with no reason — the old behaviour —
+ * and the server starts. Shutdown is never held up by this module.
+ *
+ * Writes go to a temp file in the same directory and are renamed over the
+ * record (mode 0600), so a reader sees the old record or the new one, never
+ * half of one.
+ *
+ * ## After the record
+ *
+ * The HTTP drain after the record still answers requests. An enable is refused
+ * from the moment the shutdown begins; an OFF (or a session kill, an instance
+ * removal, a worktree delete) is accepted — refusing an OFF would leave a
+ * worker that was asked to stop answering still armed for the drain — and the
+ * record is rewritten from memory after it, so the next start does not bring
+ * back a notice the user cleared. Withdrawing rather than refusing: the change
+ * only ever narrows the record.
+ *
+ * @module lib/auto-yes-shutdown-record
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTO_YES_SHUTDOWN_RECORD_SUFFIX = exports.AUTO_YES_SHUTDOWN_RECORD_PATH_ENV = void 0;
+exports.resolveAutoYesShutdownRecordPath = resolveAutoYesShutdownRecordPath;
+exports.recordAutoYesShutdown = recordAutoYesShutdown;
+exports.restoreAutoYesShutdownRecord = restoreAutoYesShutdownRecord;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const env_1 = require("../lib/env");
+const logger_1 = require("../lib/logger");
+const types_1 = require("./cli-tools/types");
+const path_validator_1 = require("./security/path-validator");
+const auto_yes_state_1 = require("./auto-yes-state");
+const logger = (0, logger_1.createLogger)('auto-yes-shutdown-record');
+/** Environment variable that overrides where the record lives. */
+exports.AUTO_YES_SHUTDOWN_RECORD_PATH_ENV = 'CM_AUTO_YES_SHUTDOWN_RECORD_PATH';
+/** Appended to the database path to name its record. */
+exports.AUTO_YES_SHUTDOWN_RECORD_SUFFIX = '.auto-yes-shutdown.json';
+/** Version of the on-disk shape. A record of any other version is ignored. */
+const RECORD_VERSION = 1;
+/** Upper bound on entries read back: far above any real server, well below abuse. */
+const MAX_RECORD_ENTRIES = 1000;
+/**
+ * Where this process's record lives: the override, else next to the database.
+ *
+ * @returns The path, or null when neither can be resolved (the record is then skipped)
+ */
+function resolveAutoYesShutdownRecordPath() {
+    const override = (process.env[exports.AUTO_YES_SHUTDOWN_RECORD_PATH_ENV] ?? '').trim();
+    if (override !== '')
+        return override;
+    try {
+        return `${(0, env_1.getEnv)().CM_DB_PATH}${exports.AUTO_YES_SHUTDOWN_RECORD_SUFFIX}`;
+    }
+    catch (error) {
+        logger.warn('record-path-unresolved', { error: error instanceof Error ? error.message : String(error) });
+        return null;
+    }
+}
+/**
+ * Begin the Auto-Yes side of a graceful shutdown and write down what it
+ * releases. Call it before the pollers are stopped.
+ *
+ * Marks the shutdown first (`beginAutoYesShutdown`), so an enable that returns
+ * from an await after this point is refused rather than added behind the
+ * record's back. With nothing to record, a leftover record is removed, so a
+ * file the previous start failed to delete cannot outlive the grants it named.
+ *
+ * Never throws.
+ *
+ * @param options.path - Record path (default: {@link resolveAutoYesShutdownRecordPath})
+ * @param options.now - Clock reading (default: Date.now())
+ */
+function recordAutoYesShutdown(options = {}) {
+    (0, auto_yes_state_1.beginAutoYesShutdown)();
+    const recordPath = options.path === undefined ? resolveAutoYesShutdownRecordPath() : options.path;
+    if (recordPath === null)
+        return { recorded: 0, error: 'record path unresolved' };
+    // Every later change rewrites the record from memory (see "After the record").
+    (0, auto_yes_state_1.setAutoYesChangeAfterShutdownListener)(() => {
+        const rewritten = writeRecord(recordPath, Date.now());
+        if (rewritten.error === undefined)
+            logger.info('record-rewritten', { grants: rewritten.recorded });
+    });
+    const result = writeRecord(recordPath, options.now ?? Date.now());
+    if (result.error === undefined)
+        logger.info('recorded', { grants: result.recorded });
+    return result;
+}
+/**
+ * Write the grants memory holds at `now` to `recordPath`, or remove the record
+ * when there are none. Never throws.
+ */
+function writeRecord(recordPath, now) {
+    try {
+        const grants = (0, auto_yes_state_1.collectReleasedAutoYesGrants)(now);
+        if (grants.length === 0) {
+            fs_1.default.rmSync(recordPath, { force: true });
+            return { recorded: 0 };
+        }
+        const body = { version: RECORD_VERSION, writtenAt: now, grants };
+        const dir = path_1.default.dirname(recordPath);
+        fs_1.default.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        const tempPath = path_1.default.join(dir, `.${path_1.default.basename(recordPath)}.${process.pid}.tmp`);
+        try {
+            fs_1.default.writeFileSync(tempPath, JSON.stringify(body), { mode: 0o600 });
+            fs_1.default.renameSync(tempPath, recordPath);
+        }
+        catch (error) {
+            fs_1.default.rmSync(tempPath, { force: true });
+            throw error;
+        }
+        return { recorded: grants.length };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.warn('record-failed', { error: message });
+        return { recorded: 0, error: message };
+    }
+}
+/** One grant read back, or null when the entry is not one this module wrote. */
+function parseGrant(raw) {
+    if (typeof raw !== 'object' || raw === null)
+        return null;
+    const entry = raw;
+    const { worktreeId, cliToolId, instanceId, enabledAt, expiresAt } = entry;
+    if (typeof worktreeId !== 'string' || !(0, path_validator_1.isValidWorktreeId)(worktreeId))
+        return null;
+    if (typeof cliToolId !== 'string' || !(0, types_1.isCliToolType)(cliToolId))
+        return null;
+    if (typeof instanceId !== 'string' || !(0, types_1.isValidInstanceId)(instanceId))
+        return null;
+    if (typeof enabledAt !== 'number' || !Number.isFinite(enabledAt))
+        return null;
+    if (typeof expiresAt !== 'number' || !Number.isFinite(expiresAt))
+        return null;
+    return { worktreeId, cliToolId, instanceId, enabledAt, expiresAt };
+}
+/** The grants in a record, or null when the record is not one this module wrote. */
+function parseRecord(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== 'object' || parsed === null)
+        return null;
+    const record = parsed;
+    if (record.version !== RECORD_VERSION || !Array.isArray(record.grants))
+        return null;
+    if (record.grants.length > MAX_RECORD_ENTRIES)
+        return null;
+    const grants = [];
+    for (const raw of record.grants) {
+        const grant = parseGrant(raw);
+        // All or nothing: a record with an entry this module did not write is not
+        // its record, and half-trusting it is how a wrong notice gets shown.
+        if (!grant)
+            return null;
+        grants.push(grant);
+    }
+    return grants;
+}
+/**
+ * Read the previous process's record, seed a restart notice for each grant
+ * still in period, and remove the record. Call it before the server answers its
+ * first request: a notice seeded after a request could overwrite what that
+ * request wrote (it does not — {@link seedServerRestartNotice} refuses a key
+ * that has a state — but the first answers would still lack it).
+ *
+ * The record is consumed whether or not it parses: a broken file read twice is
+ * broken twice. A record that cannot be removed is harmless — the next
+ * shutdown overwrites or removes it, and a second read seeds nothing over the
+ * states the first one wrote.
+ *
+ * Never throws; with no record, does nothing.
+ *
+ * @param options.path - Record path (default: {@link resolveAutoYesShutdownRecordPath})
+ * @param options.now - Clock reading (default: Date.now())
+ */
+function restoreAutoYesShutdownRecord(options = {}) {
+    const recordPath = options.path === undefined ? resolveAutoYesShutdownRecordPath() : options.path;
+    if (recordPath === null)
+        return { seeded: 0, skipped: 0 };
+    let text;
+    try {
+        text = fs_1.default.readFileSync(recordPath, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return { seeded: 0, skipped: 0 };
+        const message = error instanceof Error ? error.message : String(error);
+        logger.warn('restore-unreadable', { error: message });
+        return { seeded: 0, skipped: 0, error: message };
+    }
+    let removeError;
+    try {
+        fs_1.default.rmSync(recordPath, { force: true });
+    }
+    catch (error) {
+        removeError = error instanceof Error ? error.message : String(error);
+        logger.warn('restore-remove-failed', { error: removeError });
+    }
+    const grants = parseRecord(text);
+    if (grants === null) {
+        logger.warn('restore-invalid-record');
+        return { seeded: 0, skipped: 0, error: 'invalid record' };
+    }
+    const now = options.now ?? Date.now();
+    let seeded = 0;
+    for (const grant of grants) {
+        if ((0, auto_yes_state_1.seedServerRestartNotice)(grant, now))
+            seeded++;
+    }
+    const skipped = grants.length - seeded;
+    if (seeded > 0 || skipped > 0)
+        logger.info('restored', { seeded, skipped });
+    return removeError === undefined ? { seeded, skipped } : { seeded, skipped, error: removeError };
+}

package/dist/server/src/lib/auto-yes-state.js

@@ -21,6 +21,12 @@ exports.getAutoYesState = getAutoYesState;
 exports.setAutoYesEnabled = setAutoYesEnabled;
 exports.disableAutoYes = disableAutoYes;
 exports.clearAllAutoYesStates = clearAllAutoYesStates;
+exports.setAutoYesChangeAfterShutdownListener = setAutoYesChangeAfterShutdownListener;
+exports.beginAutoYesShutdown = beginAutoYesShutdown;
+exports.isAutoYesShutdownStarted = isAutoYesShutdownStarted;
+exports.resetAutoYesShutdownForTesting = resetAutoYesShutdownForTesting;
+exports.collectReleasedAutoYesGrants = collectReleasedAutoYesGrants;
+exports.seedServerRestartNotice = seedServerRestartNotice;
 exports.truncateToUtf8Bytes = truncateToUtf8Bytes;
 exports.checkStopCondition = checkStopCondition;
 exports.deleteAutoYesState = deleteAutoYesState;
@@ -29,6 +35,7 @@ exports.filterCompositeKeysByWorktree = filterCompositeKeysByWorktree;
 exports.getCompositeKeysByWorktree = getCompositeKeysByWorktree;
 exports.deleteAutoYesStateByWorktree = deleteAutoYesStateByWorktree;
 exports.getEnabledAutoYesByWorktree = getEnabledAutoYesByWorktree;
+exports.getRestartReleasedAutoYesByWorktree = getRestartReleasedAutoYesByWorktree;
 exports.migrateAutoYesStateWorktreeIds = migrateAutoYesStateWorktreeIds;
 exports.calculateBackoffInterval = calculateBackoffInterval;
 const auto_yes_config_1 = require("../config/auto-yes-config");
@@ -156,6 +163,20 @@ function getAutoYesState(worktreeId, cliToolId = 'claude', instanceId) {
     const state = autoYesStates.get(key);
     if (!state)
         return null;
+    // Issue #3730: a restart notice lives until the deadline of the grant it
+    // explains, and then the instance reads as it would have had the notice never
+    // been seeded — no state at all. Rewriting it to `expired` (the branch below)
+    // would claim a countdown ran out on a grant that was not running.
+    if (!state.enabled && state.stopReason === 'server-restart' && isAutoYesExpired(state)) {
+        autoYesStates.delete(key);
+        return null;
+    }
+    // Issue #3753: only a live grant can run out. A disabled state already has
+    // its reason (manual OFF: none; stop pattern; session kill) and rewriting it
+    // to `expired` after the old deadline would claim a countdown ended that was
+    // not running; a key never armed (`expiresAt` 0) would read `expired` at once.
+    if (!state.enabled)
+        return state;
     // Auto-disable if expired (Issue #314: delegate to disableAutoYes)
     if (isAutoYesExpired(state)) {
         return disableAutoYes(worktreeId, cliToolId, 'expired', instanceId);
@@ -188,6 +209,7 @@ function setAutoYesEnabled(worktreeId, cliToolId, enabled, duration, stopPattern
             stopPattern,
         };
         autoYesStates.set(key, state);
+        notifyChangeAfterShutdown();
         return state;
     }
     else {
@@ -223,6 +245,7 @@ function disableAutoYes(worktreeId, cliToolId = 'claude', reason, instanceId, st
         stopMatchedText,
     };
     autoYesStates.set(key, state);
+    notifyChangeAfterShutdown();
     return state;
 }
 /**
@@ -232,6 +255,122 @@ function disableAutoYes(worktreeId, cliToolId = 'claude', reason, instanceId, st
 function clearAllAutoYesStates() {
     autoYesStates.clear();
 }
+const autoYesShutdown = (0, global_state_1.getOrInitGlobal)('__autoYesShutdownStarted', () => ({
+    value: false,
+    onChangeAfterShutdown: null,
+}));
+/**
+ * Who to tell when a state changes after the shutdown began (Issue #3730).
+ *
+ * The shutdown record is taken first, and the HTTP drain that follows still
+ * answers requests: an OFF, a session kill or an instance removal accepted then
+ * changes memory only, and the record would bring back the notice the user just
+ * cleared. The record module registers here when it writes the record and
+ * rewrites it on every later change (an enable is refused by then, so a change
+ * can only withdraw). A listener rather than an import: the record module reads
+ * this one, not the other way round.
+ *
+ * @param listener - Called after each change once the shutdown began; null to clear
+ */
+function setAutoYesChangeAfterShutdownListener(listener) {
+    autoYesShutdown.onChangeAfterShutdown = listener;
+}
+/** Tell the listener, if the shutdown began and one is registered. Never throws. */
+function notifyChangeAfterShutdown() {
+    if (!autoYesShutdown.value)
+        return;
+    const listener = autoYesShutdown.onChangeAfterShutdown;
+    if (!listener)
+        return;
+    try {
+        listener();
+    }
+    catch {
+        // The listener logs its own failures; a write path must not fail on it.
+    }
+}
+/**
+ * Mark the start of a graceful shutdown. From here on no grant may be added:
+ * the shutdown record has been (or is being) taken, and a grant written after
+ * it would be one the next process never hears about. The auto-yes route
+ * refuses an enable that returns from its await after this, and
+ * `startAutoYesPolling` refuses to start.
+ */
+function beginAutoYesShutdown() {
+    autoYesShutdown.value = true;
+}
+/** Whether {@link beginAutoYesShutdown} has run in this process. */
+function isAutoYesShutdownStarted() {
+    return autoYesShutdown.value;
+}
+/**
+ * Undo {@link beginAutoYesShutdown}.
+ * @internal Exported for testing purposes only.
+ */
+function resetAutoYesShutdownForTesting() {
+    autoYesShutdown.value = false;
+    autoYesShutdown.onChangeAfterShutdown = null;
+}
+/**
+ * The grants a shutdown at `now` releases (Issue #3730): every state that is
+ * enabled with time left — read from the state map, not from the pollers, so
+ * a grant whose poller never started (no session yet, the poller cap) is
+ * included — and every restart notice that is itself still in period, so a
+ * second restart inside the window keeps saying why.
+ *
+ * Read raw rather than through {@link getAutoYesState}: this only looks, and
+ * the getter's expiry rewrite is a write.
+ *
+ * @param now - The shutdown's clock reading
+ */
+function collectReleasedAutoYesGrants(now = Date.now()) {
+    const released = [];
+    for (const [key, state] of autoYesStates) {
+        if (!(now < state.expiresAt))
+            continue;
+        const live = state.enabled || state.stopReason === 'server-restart';
+        if (!live)
+            continue;
+        const cliToolId = extractCliToolId(key);
+        if (!cliToolId)
+            continue;
+        released.push({
+            worktreeId: extractWorktreeId(key),
+            cliToolId,
+            instanceId: extractInstanceId(key) ?? cliToolId,
+            enabledAt: state.enabledAt,
+            expiresAt: state.expiresAt,
+        });
+    }
+    return released;
+}
+/**
+ * Seed one restart notice (Issue #3730): a DISABLED state with
+ * `stopReason: 'server-restart'` and the released grant's own deadline. Never
+ * enables anything and starts no poller.
+ *
+ * Refused — returns false — when the instance already has a state (whatever
+ * wrote it is newer than a record from the previous process) or the deadline
+ * has passed (it would be deleted on its first read anyway).
+ *
+ * @param grant - The released grant
+ * @param now - Clock reading to judge the deadline against
+ * @returns Whether a notice was written
+ */
+function seedServerRestartNotice(grant, now = Date.now()) {
+    const key = buildCompositeKey(grant.worktreeId, grant.cliToolId, grant.instanceId);
+    if (autoYesStates.has(key))
+        return false;
+    if (!(now < grant.expiresAt))
+        return false;
+    autoYesStates.set(key, {
+        enabled: false,
+        enabledAt: grant.enabledAt,
+        expiresAt: grant.expiresAt,
+        stopReason: 'server-restart',
+    });
+    return true;
+}
 // =============================================================================
 // Stop Condition (Issue #314)
 // =============================================================================
@@ -417,6 +556,7 @@ function deleteAutoYesState(compositeKey) {
         return false;
     }
     autoYesStates.delete(compositeKey);
+    notifyChangeAfterShutdown();
     return true;
 }
 /**
@@ -463,6 +603,8 @@ function getCompositeKeysByWorktree(worktreeId) {
 function deleteAutoYesStateByWorktree(worktreeId) {
     const keys = getCompositeKeysByWorktree(worktreeId);
     keys.forEach(key => autoYesStates.delete(key));
+    if (keys.length > 0)
+        notifyChangeAfterShutdown();
     return keys.length;
 }
 /**
@@ -480,9 +622,15 @@ function deleteAutoYesStateByWorktree(worktreeId) {
  * and "expired" identically, and the map keeps disabled entries around for
  * inspection long after anyone needs them on the wire.
  *
+ * Issue #3723: `isBlocked`, when given, marks an armed instance whose contract
+ * withholds every answer (`blockedByContract: true`). A callback rather than a
+ * lookup here, because the contract lives in SQLite and this module stays free
+ * of a database dependency; the list route passes the poller's own policy read.
+ *
+ * @param isBlocked - Whether the contract blocks Auto-Yes for one instance
  * @returns worktreeId -> instanceId -> summary; worktrees with nothing armed are absent
  */
-function getEnabledAutoYesByWorktree() {
+function getEnabledAutoYesByWorktree(isBlocked) {
     const byWorktree = new Map();
     // A snapshot of the keys: an expired read below rewrites its own entry.
     for (const key of Array.from(autoYesStates.keys())) {
@@ -495,7 +643,40 @@ function getEnabledAutoYesByWorktree() {
         if (!state?.enabled)
             continue;
         const entries = byWorktree.get(worktreeId) ?? {};
-        entries[instanceId] = { enabled: true, expiresAt: state.expiresAt };
+        const summary = { enabled: true, expiresAt: state.expiresAt };
+        if (isBlocked?.(worktreeId, cliToolId, instanceId))
+            summary.blockedByContract = true;
+        entries[instanceId] = summary;
+        byWorktree.set(worktreeId, entries);
+    }
+    return byWorktree;
+}
+/**
+ * Every restart notice still in period, grouped by worktree and keyed by
+ * instance, for the worktree list (Issue #3730).
+ *
+ * Its own map rather than entries in {@link getEnabledAutoYesByWorktree}'s:
+ * that map is "armed instances", and its readers (the Sessions tile, `ls`'s
+ * idle fallback, the new-task targets) count every entry as armed. Reads go
+ * through {@link getAutoYesState}, so a notice past its deadline is dropped
+ * here, as everywhere.
+ *
+ * @returns worktreeId -> instanceId -> 'server-restart'; worktrees with none are absent
+ */
+function getRestartReleasedAutoYesByWorktree() {
+    const byWorktree = new Map();
+    // A snapshot of the keys: an expired read below deletes its own entry.
+    for (const key of Array.from(autoYesStates.keys())) {
+        const cliToolId = extractCliToolId(key);
+        if (!cliToolId)
+            continue;
+        const worktreeId = extractWorktreeId(key);
+        const instanceId = extractInstanceId(key) ?? cliToolId;
+        const state = getAutoYesState(worktreeId, cliToolId, instanceId);
+        if (!state || state.enabled || state.stopReason !== 'server-restart')
+            continue;
+        const entries = byWorktree.get(worktreeId) ?? {};
+        entries[instanceId] = 'server-restart';
         byWorktree.set(worktreeId, entries);
     }
     return byWorktree;
@@ -559,9 +740,21 @@ function migrateAutoYesStateWorktreeIds(renames) {
     // Two passes so a swap (A→B, B→A) cannot have one half clobber the other.
     for (const move of moves)
         autoYesStates.delete(move.oldKey);
-    for (const move of moves)
+    // Issue #3730: a restart notice is only an explanation, seeded before the
+    // first request; whatever sits under the new key once the sources are gone
+    // was written after it (an enable or a disable made while the start-up ID
+    // move was still awaiting) and is newer. The notice yields and is dropped.
+    // A grant still moves as before — the move exists to keep grants alive.
+    const applied = moves.filter((move) => !((0, auto_yes_config_1.isReleasedByRestart)(move.state) && autoYesStates.has(move.newKey)));
+    for (const move of applied)
         autoYesStates.set(move.newKey, move.state);
-    return moves.map(({ state: _state, ...rest }) => rest);
+    // Issue #3753: the move changes memory without going through a setter, so
+    // after the shutdown record was taken it must be told: the record still
+    // names the old ID, and the next start would bring back a notice (for a state
+    // withdrawn under the new ID) the user had already cleared.
+    if (moves.length > 0)
+        notifyChangeAfterShutdown();
+    return applied.map(({ state: _state, ...rest }) => rest);
 }
 /**
  * Calculate backoff interval based on consecutive errors.

package/dist/server/src/lib/cli-tools/antigravity-startup-trust.js

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * agy's startup folder-trust confirmation that the launch window did not see
+ * (Issue #3757).
+ *
+ * `AntigravityTool.waitForReady` confirms the trust screen with one Enter, but
+ * only inside its ~34 s window, and agy's start-up time varies from about one
+ * second to more than a minute (measured: the screen appeared 61 s after the
+ * launch). A window that ends before agy has drawn anything leaves the screen
+ * unanswered, and the launch still reports success.
+ *
+ * This records that one Enter is still owed to the session, so the next send's
+ * readiness wait can deliver it — exactly once. The claim is synchronous and
+ * removes the record, so two waits racing over one pane cannot both send it,
+ * and a window that already sent its Enter never records one.
+ *
+ * It also knows whether the launch window is still open (review of #3757): a
+ * trust screen inside it is the window's to confirm within a second or two, so
+ * the Auto-Yes poller records no `startup-trust-unhandled` for it.
+ *
+ * And it keeps the owed Enter and the strict `respond` (Issue #3756) from both
+ * answering one trust screen: while a strict answer holds the session
+ * ({@link holdStartupTrust}), the Enter cannot be claimed, and a strict answer
+ * refuses a session whose Enter was claimed moments ago
+ * ({@link wasStartupTrustClaimedWithin}) — the two are serialised per session
+ * name here, where both sides look.
+ *
+ * Keyed by tmux session name. Reached through `globalThis` because the writer
+ * (the launch) and the reader (a send, from another route handler) may be
+ * bundled separately under `next dev` (Issue #1736).
+ *
+ * @module lib/cli-tools/antigravity-startup-trust
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.beginStartupWindow = beginStartupWindow;
+exports.endStartupWindow = endStartupWindow;
+exports.isStartupWindowOpen = isStartupWindowOpen;
+exports.markStartupTrustPending = markStartupTrustPending;
+exports.isStartupTrustPending = isStartupTrustPending;
+exports.claimStartupTrust = claimStartupTrust;
+exports.isStartupTrustHeld = isStartupTrustHeld;
+exports.wasStartupTrustClaimedWithin = wasStartupTrustClaimedWithin;
+exports.holdStartupTrust = holdStartupTrust;
+exports.forgetStartupTrust = forgetStartupTrust;
+exports.clearStartupTrust = clearStartupTrust;
+const global_state_1 = require("../global-state");
+/** sessionName -> epoch ms the launch window ended without confirming trust. */
+const pendingStartupTrust = (0, global_state_1.getOrInitGlobal)('__antigravityStartupTrustPending', () => new Map());
+/**
+ * sessionName -> how many launch windows (launch line typed → `waitForReady`
+ * returned) are open. Counted (Issue #3770): a relaunch racing another must not
+ * have the earlier one's end close the later one's window.
+ */
+const openStartupWindows = (0, global_state_1.getOrInitGlobal)('__antigravityStartupWindows', () => new Map());
+/** Sessions a strict `respond` is answering right now (Issue #3756). */
+const strictAnswerHolds = (0, global_state_1.getOrInitGlobal)('__antigravityStartupTrustHolds', () => new Set());
+/** sessionName -> epoch ms the owed Enter was last claimed. */
+const lastClaims = (0, global_state_1.getOrInitGlobal)('__antigravityStartupTrustClaims', () => new Map());
+/** The launch window opened: the launch confirms any trust screen in it. */
+function beginStartupWindow(sessionName) {
+    openStartupWindows.set(sessionName, (openStartupWindows.get(sessionName) ?? 0) + 1);
+}
+/** The launch window closed, however it ended. */
+function endStartupWindow(sessionName) {
+    const open = openStartupWindows.get(sessionName) ?? 0;
+    if (open <= 1)
+        openStartupWindows.delete(sessionName);
+    else
+        openStartupWindows.set(sessionName, open - 1);
+}
+/**
+ * @returns True while the launch window is open. A session this process never
+ *   launched (a server restart, another launcher) has none open.
+ */
+function isStartupWindowOpen(sessionName) {
+    return openStartupWindows.has(sessionName);
+}
+/** Record that the launch window ended with the trust screen not yet confirmed. */
+function markStartupTrustPending(sessionName, at = Date.now()) {
+    pendingStartupTrust.set(sessionName, at);
+}
+/** @returns True while the launch's trust Enter is still owed to this session. */
+function isStartupTrustPending(sessionName) {
+    return pendingStartupTrust.has(sessionName);
+}
+/**
+ * Take the owed Enter. True at most once per record: the caller that gets true
+ * is the one that sends it. False while a strict `respond` holds the session
+ * (Issue #3756): the record is kept, and is the strict answer's to discard.
+ */
+function claimStartupTrust(sessionName, at = Date.now()) {
+    if (strictAnswerHolds.has(sessionName))
+        return false;
+    const claimed = pendingStartupTrust.delete(sessionName);
+    if (claimed)
+        lastClaims.set(sessionName, at);
+    return claimed;
+}
+/**
+ * Whether a strict `respond` holds the session right now. The launch window's
+ * own Enter checks it too (Issue #3771): a held session is the strict answer's
+ * to key, so the window waits a poll and looks again.
+ */
+function isStartupTrustHeld(sessionName) {
+    return strictAnswerHolds.has(sessionName);
+}
+/**
+ * Whether the owed Enter was claimed within the last `ms` — its Enter may be
+ * on its way, or agy may not have redrawn after it yet (Issue #3756).
+ */
+function wasStartupTrustClaimedWithin(sessionName, ms, now = Date.now()) {
+    const at = lastClaims.get(sessionName);
+    return at !== undefined && now - at < ms;
+}
+/**
+ * Hold the session for a strict `respond` (Issue #3756): until the returned
+ * release is called, {@link claimStartupTrust} answers false for it.
+ */
+function holdStartupTrust(sessionName) {
+    strictAnswerHolds.add(sessionName);
+    return () => {
+        strictAnswerHolds.delete(sessionName);
+    };
+}
+/** Drop the record: the session was relaunched, killed, or reached its prompt. */
+function forgetStartupTrust(sessionName) {
+    pendingStartupTrust.delete(sessionName);
+}
+/** Drop every record. Test seam. */
+function clearStartupTrust() {
+    pendingStartupTrust.clear();
+    openStartupWindows.clear();
+    strictAnswerHolds.clear();
+    lastClaims.clear();
+}