commandmate 0.16.0 → 0.18.0

package/dist/server/src/lib/db/verification-db.js

@@ -0,0 +1,290 @@
+"use strict";
+/**
+ * Verification run database operations (Issue #1542, migration v49).
+ *
+ * Persists the outcome of a verification gate run: one `verification_runs` row
+ * per attempt, one `verification_gate_results` row per command inside it.
+ *
+ * Both create* functions open a record in `running` state and both finish*
+ * functions close it. That split is deliberate: a run that crashes mid-flight
+ * leaves a `running` row behind, which is recoverable evidence, whereas a
+ * single write-on-completion would leave nothing at all.
+ *
+ * The timestamps describe the *execution*, not the writes (Issue #1625): a
+ * caller that measured a gate closes the row with the window it measured, so
+ * `finished_at - started_at` equals `duration_ms` instead of the gap between
+ * two adjacent INSERT/UPDATE statements.
+ *
+ * The finish* functions throw when the target row does not exist. A silent
+ * no-op would let a caller believe it recorded a verdict it never recorded —
+ * exactly the failure this table exists to make impossible.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_RUN_HISTORY_DAYS = exports.MAX_RUN_HISTORY_LIMIT = exports.DEFAULT_RUN_HISTORY_LIMIT = exports.VERIFICATION_TRIGGERS = void 0;
+exports.createVerificationRun = createVerificationRun;
+exports.finishVerificationRun = finishVerificationRun;
+exports.createGateResult = createGateResult;
+exports.finishGateResult = finishGateResult;
+exports.getVerificationRun = getVerificationRun;
+exports.getRunningVerificationRun = getRunningVerificationRun;
+exports.listRunningVerificationRuns = listRunningVerificationRuns;
+exports.listVerificationRuns = listVerificationRuns;
+exports.listVerificationRunsForPeriod = listVerificationRunsForPeriod;
+/**
+ * What caused a verification run to start.
+ *
+ * The runtime tuple mirrors the `trigger` CHECK constraint in migration v49 and
+ * is the single source callers validate untrusted input against, so a new
+ * trigger cannot be accepted by an API route and then rejected by SQLite.
+ */
+exports.VERIFICATION_TRIGGERS = ['manual', 'wait', 'api', 'task'];
+const RUN_COLUMNS = `
+  id, worktree_id, instance_id, task_id, trigger, status, base_ref, started_at, finished_at
+`;
+const GATE_COLUMNS = `
+  id, run_id, gate_id, command, status, exit_code, duration_ms, log_tail, started_at, finished_at
+`;
+function mapRunRow(row) {
+    return {
+        id: row.id,
+        worktreeId: row.worktree_id,
+        instanceId: row.instance_id,
+        taskId: row.task_id,
+        trigger: row.trigger,
+        status: row.status,
+        baseRef: row.base_ref,
+        startedAt: new Date(row.started_at),
+        finishedAt: row.finished_at === null ? null : new Date(row.finished_at),
+    };
+}
+function mapGateRow(row) {
+    return {
+        id: row.id,
+        runId: row.run_id,
+        gateId: row.gate_id,
+        command: row.command,
+        status: row.status,
+        exitCode: row.exit_code,
+        durationMs: row.duration_ms,
+        logTail: row.log_tail,
+        startedAt: new Date(row.started_at),
+        finishedAt: row.finished_at === null ? null : new Date(row.finished_at),
+        timingsMeasured: row.finished_at !== null &&
+            row.duration_ms !== null &&
+            row.finished_at - row.started_at === row.duration_ms,
+    };
+}
+/** Open a run in `running` state. */
+function createVerificationRun(db, input) {
+    const now = Date.now();
+    const info = db
+        .prepare(`
+      INSERT INTO verification_runs (
+        worktree_id, instance_id, task_id, trigger, status, base_ref, started_at, finished_at
+      )
+      VALUES (?, ?, ?, ?, 'running', ?, ?, NULL)
+    `)
+        .run(input.worktreeId, input.instanceId ?? null, input.taskId ?? null, input.trigger, input.baseRef ?? null, now);
+    const row = db
+        .prepare(`SELECT ${RUN_COLUMNS} FROM verification_runs WHERE id = ?`)
+        .get(Number(info.lastInsertRowid));
+    if (!row) {
+        throw new Error('Failed to persist verification run');
+    }
+    return mapRunRow(row);
+}
+/** Close a run with its final verdict, stamping `finished_at`. */
+function finishVerificationRun(db, runId, status) {
+    const info = db
+        .prepare('UPDATE verification_runs SET status = ?, finished_at = ? WHERE id = ?')
+        .run(status, Date.now(), runId);
+    if (info.changes === 0) {
+        throw new Error(`Verification run ${runId} not found`);
+    }
+}
+/** Open a gate result under an existing run, in `running` state. */
+function createGateResult(db, runId, input) {
+    const now = Date.now();
+    const info = db
+        .prepare(`
+      INSERT INTO verification_gate_results (
+        run_id, gate_id, command, status, exit_code, duration_ms, log_tail, started_at, finished_at
+      )
+      VALUES (?, ?, ?, 'running', NULL, NULL, NULL, ?, NULL)
+    `)
+        .run(runId, input.gateId, input.command, now);
+    const row = db
+        .prepare(`SELECT ${GATE_COLUMNS} FROM verification_gate_results WHERE id = ?`)
+        .get(Number(info.lastInsertRowid));
+    if (!row) {
+        throw new Error('Failed to persist verification gate result');
+    }
+    return mapGateRow(row);
+}
+/**
+ * Close a gate result with its outcome and the interval it occupied.
+ *
+ * `started_at` is rewritten only when the caller declares an
+ * {@link FinishGateResultPatch.executionWindow}: the value written when the row
+ * was opened is a placeholder for "this gate was entered", and the measured
+ * start is a few milliseconds later — after the insert this call is closing.
+ * Leaving the placeholder would put that gap inside the reported window.
+ */
+function finishGateResult(db, gateResultId, patch) {
+    const info = db
+        .prepare(`
+      UPDATE verification_gate_results
+      SET status = ?, exit_code = ?, duration_ms = ?, log_tail = ?,
+          started_at = COALESCE(?, started_at),
+          finished_at = ?
+      WHERE id = ?
+    `)
+        .run(patch.status, patch.exitCode ?? null, patch.durationMs ?? null, patch.logTail ?? null, patch.executionWindow?.startedAt ?? null, patch.executionWindow?.finishedAt ?? Date.now(), gateResultId);
+    if (info.changes === 0) {
+        throw new Error(`Verification gate result ${gateResultId} not found`);
+    }
+}
+/** Fetch a run with its gate results, or null when the run does not exist. */
+function getVerificationRun(db, runId) {
+    const runRow = db
+        .prepare(`SELECT ${RUN_COLUMNS} FROM verification_runs WHERE id = ?`)
+        .get(runId);
+    if (!runRow) {
+        return null;
+    }
+    const gateRows = db
+        .prepare(`
+      SELECT ${GATE_COLUMNS} FROM verification_gate_results
+      WHERE run_id = ?
+      ORDER BY started_at ASC, id ASC
+    `)
+        .all(runId);
+    return { ...mapRunRow(runRow), gates: gateRows.map(mapGateRow) };
+}
+/**
+ * The open run for a worktree, or null when none is in flight.
+ *
+ * A worktree admits one run at a time: two runs sharing a working tree would
+ * see each other's build output and their exit codes would describe neither.
+ * `id DESC` is a safety net — the invariant says there is at most one row, and
+ * if a bug ever breaks it the newest is the one a caller means.
+ */
+function getRunningVerificationRun(db, worktreeId) {
+    const row = db
+        .prepare(`
+      SELECT ${RUN_COLUMNS} FROM verification_runs
+      WHERE worktree_id = ? AND status = 'running'
+      ORDER BY id DESC
+      LIMIT 1
+    `)
+        .get(worktreeId);
+    return row ? mapRunRow(row) : null;
+}
+/**
+ * Every run still marked `running`, across all worktrees, oldest first.
+ *
+ * Used by startup reconciliation: after a restart no run is actually in flight,
+ * so every row this returns is an orphan whose verdict was lost.
+ */
+function listRunningVerificationRuns(db) {
+    const rows = db
+        .prepare(`
+      SELECT ${RUN_COLUMNS} FROM verification_runs
+      WHERE status = 'running'
+      ORDER BY id ASC
+    `)
+        .all();
+    return rows.map(mapRunRow);
+}
+/**
+ * Most recent runs for a worktree, newest first.
+ *
+ * `id DESC` breaks ties: runs started within the same millisecond are common
+ * enough that without it the "newest first" contract would be unordered.
+ */
+function listVerificationRuns(db, worktreeId, limit = 20) {
+    const rows = db
+        .prepare(`
+      SELECT ${RUN_COLUMNS} FROM verification_runs
+      WHERE worktree_id = ?
+      ORDER BY started_at DESC, id DESC
+      LIMIT ?
+    `)
+        .all(worktreeId, limit);
+    return rows.map(mapRunRow);
+}
+/** Default page size for {@link listVerificationRunsForPeriod}. */
+exports.DEFAULT_RUN_HISTORY_LIMIT = 50;
+/** Largest page {@link listVerificationRunsForPeriod} will return. */
+exports.MAX_RUN_HISTORY_LIMIT = 500;
+/** Longest window {@link listVerificationRunsForPeriod} will look back over. */
+exports.MAX_RUN_HISTORY_DAYS = 90;
+const MS_PER_DAY = 86_400_000;
+/** Clamp to an integer inside [min, max]; non-finite input falls back to `fallback`. */
+function clampInt(value, fallback, min, max) {
+    if (value === undefined || !Number.isFinite(value))
+        return fallback;
+    return Math.min(Math.max(Math.trunc(value), min), max);
+}
+/**
+ * Recent runs across worktrees, newest first, each with its gate verdicts but
+ * no log bodies (Issue #1593).
+ *
+ * `worktreeId` is optional because the advisor that consumes this (#1594) looks
+ * at a repository's trend, not one worktree's. Ordering follows the same
+ * `started_at DESC, id DESC` contract as {@link listVerificationRuns} so both
+ * feeds agree about what "newest" means.
+ *
+ * `days` and `limit` are clamped rather than rejected: this is a read-only feed
+ * and a caller asking for 10000 runs wants as many as it can have, not an
+ * exception. API routes validate before calling so a user typo still 400s.
+ */
+function listVerificationRunsForPeriod(db, opts = {}) {
+    const limit = clampInt(opts.limit, exports.DEFAULT_RUN_HISTORY_LIMIT, 1, exports.MAX_RUN_HISTORY_LIMIT);
+    const conditions = [];
+    const params = [];
+    if (opts.worktreeId !== undefined) {
+        conditions.push('worktree_id = ?');
+        params.push(opts.worktreeId);
+    }
+    if (opts.days !== undefined) {
+        const days = clampInt(opts.days, exports.MAX_RUN_HISTORY_DAYS, 1, exports.MAX_RUN_HISTORY_DAYS);
+        conditions.push('started_at >= ?');
+        params.push(Date.now() - days * MS_PER_DAY);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+    const runRows = db
+        .prepare(`
+      SELECT ${RUN_COLUMNS} FROM verification_runs
+      ${where}
+      ORDER BY started_at DESC, id DESC
+      LIMIT ?
+    `)
+        .all(...params, limit);
+    if (runRows.length === 0)
+        return [];
+    const placeholders = runRows.map(() => '?').join(', ');
+    const gateRows = db
+        .prepare(`
+      SELECT run_id, gate_id, status, exit_code, duration_ms
+      FROM verification_gate_results
+      WHERE run_id IN (${placeholders})
+      ORDER BY started_at ASC, id ASC
+    `)
+        .all(...runRows.map((row) => row.id));
+    const byRun = new Map();
+    for (const row of gateRows) {
+        const summary = {
+            gateId: row.gate_id,
+            status: row.status,
+            exitCode: row.exit_code,
+            durationMs: row.duration_ms,
+        };
+        const bucket = byRun.get(row.run_id);
+        if (bucket)
+            bucket.push(summary);
+        else
+            byRun.set(row.run_id, [summary]);
+    }
+    return runRows.map((row) => ({ ...mapRunRow(row), gates: byRun.get(row.id) ?? [] }));
+}

package/dist/server/src/lib/polling/auto-yes-policy.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * Auto-Yes policy lookup — resolves the `autoYes` block of the execution
+ * contract governing one agent instance (Issue #1547).
+ *
+ * Server-only: reads the database. Kept out of auto-yes-state.ts so that module
+ * stays free of a database dependency, and out of auto-yes-resolver.ts because
+ * that one is bundled into the client.
+ *
+ * The result is cached per composite key with a short TTL. Without it, a prompt
+ * the policy suppresses would be re-read from SQLite on every poll for as long
+ * as it stays on screen: the poller's duplicate guard only remembers prompts it
+ * *answered*, so a suppressed prompt is re-evaluated every POLLING_INTERVAL_MS
+ * indefinitely. The TTL is what bounds staleness — a task that starts or ends is
+ * picked up within it, without this module having to observe task transitions.
+ *
+ * @module lib/polling/auto-yes-policy
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTO_YES_POLICY_CACHE_TTL_MS = void 0;
+exports.getSessionAutoYesPolicy = getSessionAutoYesPolicy;
+exports.invalidateSessionAutoYesPolicy = invalidateSessionAutoYesPolicy;
+exports.clearAutoYesPolicyCache = clearAutoYesPolicyCache;
+const db_1 = require("../../lib/db");
+const db_instance_1 = require("../../lib/db/db-instance");
+const auto_yes_state_1 = require("../../lib/auto-yes-state");
+const logger_1 = require("../../lib/logger");
+const logger = (0, logger_1.createLogger)('auto-yes-policy');
+/** How long a resolved policy is reused before the task is looked up again. */
+exports.AUTO_YES_POLICY_CACHE_TTL_MS = 5000;
+/**
+ * Cache ceiling. Above it, expired entries are dropped on write, so a long-lived
+ * server cannot accumulate one entry per worktree ever polled.
+ */
+const MAX_CACHE_ENTRIES = 200;
+/**
+ * Plain module-level Map rather than the globalThis pattern used for auto-yes
+ * *state*: losing a cache on hot reload costs one database read, while losing
+ * state would silently disable auto-yes.
+ */
+const policyCache = new Map();
+function purgeExpired(now) {
+    for (const [key, entry] of policyCache.entries()) {
+        if (entry.expiresAt <= now) {
+            policyCache.delete(key);
+        }
+    }
+}
+/**
+ * Read the policy from the active task, or null when no contract governs this
+ * instance.
+ *
+ * A database failure yields null — the unconstrained behaviour. Failing closed
+ * here would suppress auto-yes for every user who has no contract at all, which
+ * is the population this feature must not touch; the suppressing decisions
+ * (`off`, deny patterns) are made inside the resolver only once a contract has
+ * actually been read.
+ */
+function readPolicy(worktreeId, cliToolId, instanceId) {
+    try {
+        const task = (0, db_1.getActiveTaskForInstance)((0, db_instance_1.getDbInstance)(), worktreeId, cliToolId, instanceId);
+        if (!task)
+            return null;
+        // Assignment, not a cast: a drift in TaskContractAutoYes fails the build here.
+        const policy = task.contract.autoYes;
+        return policy;
+    }
+    catch (error) {
+        logger.warn('policy-lookup-failed', {
+            worktreeId,
+            cliToolId,
+            instanceId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return null;
+    }
+}
+/**
+ * The auto-answer policy for an agent instance, cached for
+ * {@link AUTO_YES_POLICY_CACHE_TTL_MS}.
+ *
+ * @param worktreeId - Worktree identifier
+ * @param cliToolId - CLI tool being polled
+ * @param instanceId - Agent instance id (defaults to the primary, i.e. cliToolId)
+ * @returns The contract's autoYes block, or null when no contract governs this instance
+ */
+function getSessionAutoYesPolicy(worktreeId, cliToolId, instanceId) {
+    const resolvedInstanceId = instanceId ?? cliToolId;
+    const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, resolvedInstanceId);
+    const now = Date.now();
+    const cached = policyCache.get(key);
+    if (cached && cached.expiresAt > now) {
+        return cached.policy;
+    }
+    const policy = readPolicy(worktreeId, cliToolId, resolvedInstanceId);
+    if (policyCache.size >= MAX_CACHE_ENTRIES) {
+        purgeExpired(now);
+    }
+    policyCache.set(key, { policy, expiresAt: now + exports.AUTO_YES_POLICY_CACHE_TTL_MS });
+    return policy;
+}
+/**
+ * Drop the cached policy for a composite key, so the next lookup re-reads the
+ * task. Called when a poller starts or stops.
+ *
+ * @param compositeKey - Composite key (worktreeId:cliToolId[:instanceId])
+ */
+function invalidateSessionAutoYesPolicy(compositeKey) {
+    policyCache.delete(compositeKey);
+}
+/**
+ * Clear the whole cache.
+ * @internal Exported for testing and worktree teardown.
+ */
+function clearAutoYesPolicyCache() {
+    policyCache.clear();
+}

package/dist/server/src/lib/polling/auto-yes-resolver.js

@@ -2,20 +2,44 @@
 /**
  * Auto Yes Resolver - Determines automatic answer for prompt data
  *
- * Rules:
+ * Base rules (unchanged since Issue #479):
  * - yes/no prompt -> 'y'
  * - multiple_choice with default option -> default option number
  * - multiple_choice without default -> first option number
  * - option requiring text input -> null (skip)
  * - unknown type -> null (skip)
+ *
+ * Issue #1547: an optional {@link AutoYesPolicy} — the `autoYes` block of an
+ * execution contract — can withhold an answer the base rules would have sent.
+ * The policy can only ever suppress: it never turns a null into an answer, and
+ * omitting it (or passing one that states nothing) reproduces the pre-#1547
+ * behaviour exactly, which is what keeps contract-less operation untouched.
+ *
+ * Client-safe: no server-only imports, because a 'use client' hook
+ * (`hooks/useAutoYes.ts`) imports this module.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_DENY_MATCH_TEXT_LENGTH = exports.MAX_DENY_PATTERN_LENGTH = void 0;
+exports.resolveAutoAnswerWithPolicy = resolveAutoAnswerWithPolicy;
 exports.resolveAutoAnswer = resolveAutoAnswer;
+const auto_yes_config_1 = require("../../config/auto-yes-config");
 /**
- * Resolve the automatic answer for a given prompt
- * @returns The answer string to send, or null if auto-answer is not possible
+ * Upper bound on a deny pattern, mirroring MAX_PATTERN_LENGTH in
+ * lib/tasks/contract-parser (asserted equal by the unit tests). Contracts are
+ * validated on load, so this is defence in depth for a contract snapshot that
+ * reached the database some other way.
+ */
+exports.MAX_DENY_PATTERN_LENGTH = 200;
+/**
+ * Upper bound on the text a deny pattern is matched against, per field.
+ *
+ * A prompt question or option label is a few hundred characters; the bound only
+ * exists so a pathological pane cannot make every poll scan megabytes with 32
+ * patterns. Matching is over the head of the field, deterministically.
  */
-function resolveAutoAnswer(promptData) {
+exports.MAX_DENY_MATCH_TEXT_LENGTH = 20_000;
+/** The pre-policy resolution: the rules as they were before Issue #1547. */
+function resolveBaseAnswer(promptData) {
     if (promptData.type === 'yes_no') {
         return 'y';
     }
@@ -32,3 +56,119 @@ function resolveAutoAnswer(promptData) {
     }
     return null;
 }
+/**
+ * Every piece of prompt text a deny pattern is matched against.
+ *
+ * `instructionText` is included because that is where the dangerous part
+ * usually is — Claude's permission prompts put the command being approved in the
+ * lines above the question, not in the question itself.
+ */
+function collectDenyMatchTexts(promptData) {
+    const texts = [promptData.question];
+    if (promptData.instructionText) {
+        texts.push(promptData.instructionText);
+    }
+    if (promptData.type === 'multiple_choice') {
+        for (const option of promptData.options) {
+            texts.push(option.label);
+        }
+    }
+    else {
+        texts.push(...promptData.options);
+    }
+    return texts.map(text => text.length > exports.MAX_DENY_MATCH_TEXT_LENGTH ? text.slice(0, exports.MAX_DENY_MATCH_TEXT_LENGTH) : text);
+}
+/**
+ * Test the prompt against every deny pattern.
+ *
+ * Patterns are screened by {@link validateStopPattern} (length, safe-regex2
+ * catastrophic-backtracking detection, syntax) before execution, which is the
+ * same ReDoS defence the stop-pattern path uses. A pattern that fails screening
+ * — or whose execution throws — is reported as `unusable`, not skipped.
+ */
+function evaluateDenyPatterns(promptData, patterns) {
+    if (patterns.length === 0) {
+        return { outcome: 'no-match' };
+    }
+    const texts = collectDenyMatchTexts(promptData);
+    for (const pattern of patterns) {
+        if (pattern.length > exports.MAX_DENY_PATTERN_LENGTH || !(0, auto_yes_config_1.validateStopPattern)(pattern).valid) {
+            return { outcome: 'unusable', pattern };
+        }
+        const regex = new RegExp(pattern);
+        for (const text of texts) {
+            const matched = (0, auto_yes_config_1.executeRegexWithTimeout)(regex, text);
+            if (matched === null) {
+                return { outcome: 'unusable', pattern };
+            }
+            if (matched) {
+                return { outcome: 'match', pattern };
+            }
+        }
+    }
+    return { outcome: 'no-match' };
+}
+/**
+ * Decide whether the policy forbids answering this prompt.
+ *
+ * Deny patterns are honoured even when `mode` is null: a contract that lists
+ * them has stated a policy, and a listed pattern that quietly did nothing is the
+ * worst failure a contract can have. `mode` null with no deny patterns — what
+ * the parser produces for a contract with no `autoYes` block — reaches none of
+ * these branches and leaves behaviour identical.
+ */
+function evaluatePolicy(promptData, policy) {
+    if (!policy)
+        return null;
+    if (policy.mode === 'off') {
+        return { reason: 'mode-off' };
+    }
+    const deny = evaluateDenyPatterns(promptData, policy.denyPatterns);
+    if (deny.outcome === 'match') {
+        return { reason: 'deny-pattern', pattern: deny.pattern };
+    }
+    if (deny.outcome === 'unusable') {
+        return { reason: 'deny-pattern-unusable', pattern: deny.pattern };
+    }
+    if (policy.mode === 'safe') {
+        return promptData.type === 'yes_no' ? null : { reason: 'type-not-allowed' };
+    }
+    if (policy.mode === 'allow-listed') {
+        return policy.allowPromptTypes.includes(promptData.type)
+            ? null
+            : { reason: 'type-not-allowed' };
+    }
+    return null;
+}
+/**
+ * Resolve the automatic answer, reporting whether a policy withheld it.
+ *
+ * `suppressedBy` is set only when an answer was actually withheld, so the
+ * escalation log records real suppressions and not prompts the base rules were
+ * never going to answer anyway (an empty option list, an option that needs
+ * typing). Those still resolve to null, with `suppressedBy` null.
+ *
+ * @param promptData - Detected prompt
+ * @param policy - Contract auto-answer policy; omit for the unconstrained behaviour
+ */
+function resolveAutoAnswerWithPolicy(promptData, policy) {
+    const answer = resolveBaseAnswer(promptData);
+    if (answer === null) {
+        return { answer: null, suppressedBy: null };
+    }
+    const denial = evaluatePolicy(promptData, policy);
+    if (denial) {
+        return { answer: null, suppressedBy: denial.reason, pattern: denial.pattern };
+    }
+    return { answer, suppressedBy: null };
+}
+/**
+ * Resolve the automatic answer for a given prompt.
+ *
+ * @param promptData - Detected prompt
+ * @param policy - Contract auto-answer policy; omit for the unconstrained behaviour
+ * @returns The answer string to send, or null if auto-answer is not possible
+ */
+function resolveAutoAnswer(promptData, policy) {
+    return resolveAutoAnswerWithPolicy(promptData, policy).answer;
+}

package/dist/server/src/lib/polling/response-checker.js

@@ -27,6 +27,7 @@ const prompt_dedup_1 = require("./prompt-dedup");
 const response_dedup_1 = require("./response-dedup");
 const response_poller_core_1 = require("./response-poller-core");
 const push_1 = require("../../lib/push");
+const task_transition_service_1 = require("../../lib/tasks/task-transition-service");
 /**
  * Creates an incomplete extraction result with empty response.
  * Centralizes the repeated pattern of returning an in-progress/incomplete state.
@@ -420,6 +421,13 @@ async function checkForResponse(worktreeId, cliToolId, instanceId) {
             });
             (0, db_1.updateSessionState)(db, worktreeId, cliToolId, result.lineCount, resolvedInstanceId);
             (0, ws_server_1.broadcastMessage)('message', { worktreeId, message });
+            // Issue #1548: the agent is blocked on input. Raised after the dedup and
+            // save above, so the task log counts prompts the system actually recorded
+            // rather than every poll that saw the same one still on screen. No-ops
+            // when this instance is not running a contract.
+            (0, task_transition_service_1.applyEventToActiveTask)(db, worktreeId, cliToolId, resolvedInstanceId, 'prompt_detected', {
+                promptType: promptDetection.promptData?.type,
+            });
             // Web Push fan-out (Issue #1125): agent is now waiting for a prompt reply.
             // Fire-and-forget — push is advisory and must never block/break the poller.
             void (0, push_1.notifyPushSubscribers)({

package/dist/server/src/lib/session/agent-event-state.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * In-memory record of the last structured "the agent stopped" event (#1549).
+ *
+ * The agent CLI telling us it stopped is a different kind of fact from the
+ * screen-scraped status: it is exact, but it only exists when someone wired a
+ * hook up. So this is kept beside the detector's output rather than folded into
+ * it — `buildCurrentOutput` exposes the timestamp, and nothing in the completion
+ * decision reads it yet. Phase 3-2 is deliberately observation only; swapping
+ * the wait/poller verdict from string matching to hook events before there is
+ * field data on how often hooks actually fire would trade a known failure mode
+ * for an unknown one.
+ *
+ * In-memory and not in SQLite for the same reason `auto-yes-state` is: the value
+ * describes a live tmux session, and a session does not survive a server restart
+ * for the timestamp to still be about.
+ *
+ * @module lib/session/agent-event-state
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordAgentStopEvent = recordAgentStopEvent;
+exports.getLastStopEventAt = getLastStopEventAt;
+exports.clearAgentStopEvents = clearAgentStopEvents;
+const auto_yes_state_1 = require("../../lib/auto-yes-state");
+/** compositeKey -> epoch ms of the most recent stop event. */
+const lastStopEventAt = new Map();
+/**
+ * Record that `instanceId` reported it stopped.
+ *
+ * @param at - Epoch ms; defaults to now. Passed explicitly by callers that need
+ *   the stored value and their own record of the event to agree exactly.
+ */
+function recordAgentStopEvent(worktreeId, cliToolId, instanceId, at = Date.now()) {
+    lastStopEventAt.set((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId), at);
+}
+/**
+ * @returns Epoch ms of the last stop event, or null when none has been received
+ *   — which is the ordinary case for a session whose agent has no hook set up.
+ */
+function getLastStopEventAt(worktreeId, cliToolId, instanceId) {
+    return lastStopEventAt.get((0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId)) ?? null;
+}
+/** Drop every recorded event. Test seam. */
+function clearAgentStopEvents() {
+    lastStopEventAt.clear();
+}

package/dist/server/src/lib/session/current-output-builder.js

@@ -15,6 +15,7 @@ const cli_session_1 = require("../../lib/session/cli-session");
 const status_detector_1 = require("../../lib/detection/status-detector");
 const auto_yes_manager_1 = require("../../lib/polling/auto-yes-manager");
 const status_capture_config_1 = require("../../config/status-capture-config");
+const agent_event_state_1 = require("../../lib/session/agent-event-state");
 /**
  * Build the current-output payload for a worktree session.
  *
@@ -27,6 +28,7 @@ async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId) {
     const resolvedInstanceId = instanceId ?? cliToolId;
     const manager = manager_1.CLIToolManager.getInstance();
     const cliTool = manager.getTool(cliToolId);
+    const stopEventAt = (0, agent_event_state_1.getLastStopEventAt)(worktreeId, cliToolId, instanceId);
     const running = await cliTool.isRunning(worktreeId, instanceId);
     if (!running) {
         return {
@@ -36,6 +38,7 @@ async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId) {
             cliToolId,
             sessionStatus: 'idle',
             sessionStatusReason: 'session_not_running',
+            lastStopEventAt: stopEventAt,
         };
     }
     const sessionState = (0, db_1.getSessionState)(db, worktreeId, resolvedInstanceId);
@@ -91,5 +94,6 @@ async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId) {
         isUnclassifiedActive,
         lastServerResponseTimestamp,
         serverPollerActive: (0, auto_yes_manager_1.isPollerActive)(compositeKey),
+        lastStopEventAt: stopEventAt,
     };
 }