commandmate 0.22.2 → 0.24.0

package/dist/server/src/lib/detection/model-info-extractor.js

@@ -0,0 +1,384 @@
+"use strict";
+/**
+ * Model / reasoning-effort extraction from the terminal frame (Issue #1784).
+ *
+ * Phase 1 (#1783) reads the model off the agents' own structured hook events.
+ * That channel has one hole and one gap:
+ *
+ *  - **No effort, anywhere.** Not one hook payload of any tool carries a
+ *    reasoning-effort field (verified across every fixture under
+ *    `tests/fixtures/hooks/`). The only place the number exists at all is on
+ *    screen, in the TUI's own chrome.
+ *  - **No model after a restart, for Claude.** Claude publishes its model on
+ *    `SessionStart` and on nothing else, so a server that restarts mid-session
+ *    never hears it again for that session. The banner is still in scrollback.
+ *
+ * This module is the screen-scraped half. It is deliberately a *separate* set of
+ * patterns from `cli-patterns.ts`: two of the patterns it would otherwise have
+ * been tempting to extend are load-bearing for behaviour that has nothing to do
+ * with display —
+ *
+ *  - `CODEX_STATUS_BAR_PATTERN` is the footer boundary the Codex running/idle
+ *    decision is windowed on (#1150). Widening it to capture groups risks the
+ *    dot.
+ *  - `CLAUDE_MODEL_OVERLAY_FOOTER_PATTERN` is the guard that stops Auto-Yes from
+ *    Enter-confirming the `/model` picker and rewriting the user's **global
+ *    default model** (#1495).
+ *
+ * So: read-only reuse of `CODEX_STATUS_BAR_PATTERN` to *locate* the footer (one
+ * definition of "which line is the status bar", shared with the detector), new
+ * patterns to read values out of it, and not one byte changed in either file.
+ *
+ * ## Where the values come from (all measured on real TUIs, 2026-08-15)
+ *
+ * | tool        | line                                                             |
+ * |-------------|------------------------------------------------------------------|
+ * | codex       | footer:  `gpt-5.6-sol xhigh · ~/share/work/…`                     |
+ * | claude      | banner:  `▝▜█████▛▘  Opus 5 (1M context) with xhigh effort · Claude Max` |
+ * | antigravity | footer:  `? for shortcuts …               Gemini 3.7 Flash · hig` |
+ * | antigravity | banner:  `    ▀▀▀▀▀▀▀▀      Gemini 3.7 Flash (High)`              |
+ *
+ * Everything is matched **after** `stripAnsi`. The real captures are shot
+ * through with SGR sequences *inside* the value — the Codex footer arrives as
+ * `\x1b[38;2;…mgpt-5.6-sol xhigh\x1b[2m\x1b[39m · …` — so a pattern applied to
+ * the raw bytes matches nothing at all. `tests/fixtures/model-info-captures.ts`
+ * keeps one ANSI-bearing capture precisely so a regression here fails a test
+ * rather than a user's screen.
+ *
+ * ## Not a new capture
+ *
+ * Nothing here issues a `capture-pane`. {@link extractModelInfo} is a pure
+ * function of text the status-detection poll already fetched
+ * (`worktree-status-helper.ts`), so the added load is zero.
+ *
+ * @see Issue #1784, Phase 2 of the model/effort visibility series
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANTIGRAVITY_MODEL_ID_EFFORT_PATTERN = exports.ANTIGRAVITY_BANNER_MODEL_PATTERN = exports.ANTIGRAVITY_STATUS_BAR_HINT_PATTERN = exports.CLAUDE_STARTUP_BANNER_PATTERN = exports.CODEX_FOOTER_MODEL_PATTERN = exports.REASONING_EFFORT_LEVELS = void 0;
+exports.resolveEffortToken = resolveEffortToken;
+exports.extractModelInfo = extractModelInfo;
+exports.deriveEffortFromModelId = deriveEffortFromModelId;
+exports.mergeModelInfo = mergeModelInfo;
+const ansi_1 = require("./ansi");
+const cli_patterns_1 = require("./cli-patterns");
+/**
+ * The reasoning-effort vocabulary these tools actually print.
+ *
+ * `minimal` and `xhigh` are the ends Codex exposes; Claude prints `xhigh` too.
+ * Anything outside this list is treated as "not an effort token", which is what
+ * keeps a stray word at the end of a status bar from being published as one.
+ */
+exports.REASONING_EFFORT_LEVELS = ['minimal', 'low', 'medium', 'high', 'xhigh'];
+/**
+ * Longest string accepted as a model name.
+ *
+ * A bound, not a format check: the point is that a runaway match (a wrapped
+ * conversation line that happened to satisfy the shape) is rejected rather than
+ * pushed into the UI and the API. Real ids are far shorter — the longest
+ * observed is `Opus 5 (1M context)` at 19.
+ */
+const MAX_MODEL_NAME_LENGTH = 64;
+/** An unknown answer. Freshly built each time — callers may keep the object. */
+function unknown() {
+    return { model: null, effort: null };
+}
+/**
+ * Bare model *token* shape — Codex, whose footer prints the raw id.
+ *
+ * No spaces: the Codex footer's model is one token (`gpt-5.6-sol`, `o4-mini`).
+ */
+const MODEL_TOKEN_SHAPE = /^[A-Za-z0-9][A-Za-z0-9._:@/-]*$/;
+/**
+ * Model *label* shape — Claude and Antigravity, which print a display name.
+ *
+ * Spaces, dots and parentheses are in (`Opus 5 (1M context)`, `Gemini 3.7
+ * Flash`); anything else — box glyphs, `?`, `·`, `>` — is out, which is what
+ * rejects a status-bar hint that was mistaken for the model.
+ */
+const MODEL_LABEL_SHAPE = /^[A-Za-z0-9][A-Za-z0-9 .()[\]_:@/-]*$/;
+function isPlausibleModelToken(value) {
+    return value.length > 0 && value.length <= MAX_MODEL_NAME_LENGTH && MODEL_TOKEN_SHAPE.test(value);
+}
+function isPlausibleModelLabel(value) {
+    return value.length > 0 && value.length <= MAX_MODEL_NAME_LENGTH && MODEL_LABEL_SHAPE.test(value);
+}
+/**
+ * Resolve a word to a {@link ReasoningEffort}, or null.
+ *
+ * `allowTruncated` exists for exactly one measured defect: **agy 1.1.13 renders
+ * its right-aligned status bar one column short**, so `high` reaches the pane as
+ * `hig` at every width tested (200 and 120 both produce a 199-/119-column line
+ * whose last glyph is missing). Accepting a one-character-short prefix recovers
+ * it. The prefix must resolve to exactly one level, so nothing ambiguous is ever
+ * promoted — `hig`→`high`, `lo`→`low`, `mediu`→`medium`, `xhig`→`xhigh`, and a
+ * single letter resolves to nothing.
+ *
+ * Off for Codex and Claude: neither truncates, and loosening a matcher that does
+ * not need it only buys false positives.
+ */
+function resolveEffortToken(token, options = {}) {
+    const normalized = token.trim().toLowerCase();
+    if (normalized === '')
+        return null;
+    if (exports.REASONING_EFFORT_LEVELS.includes(normalized))
+        return normalized;
+    if (!options.allowTruncated || normalized.length < 2)
+        return null;
+    const candidates = exports.REASONING_EFFORT_LEVELS.filter((level) => level.length === normalized.length + 1 && level.startsWith(normalized));
+    return candidates.length === 1 ? candidates[0] : null;
+}
+// =============================================================================
+// Codex
+// =============================================================================
+/**
+ * Reads `<model>[ <effort>]` off the head of a Codex status bar (Issue #1784).
+ *
+ * Applied to the segment *before* the first "·", which is what makes one pattern
+ * cover all three footer formats the CLI has shipped:
+ *
+ *   v0.147 / v0.141: `gpt-5.6-sol xhigh · ~/share/work/…`      → head `gpt-5.6-sol xhigh `
+ *   legacy w/ quota: `gpt-5.4 high · 21% left · ~/…`           → head `gpt-5.4 high `
+ *   legacy o4-mini:  `  o4-mini            50% left · /path`   → head `  o4-mini            50% left `
+ *
+ * The last one is why the effort group is optional *and* why it is anchored to a
+ * keyword rather than "the second token": that format's second token is `50%`,
+ * and a positional read would publish "50%" as the reasoning effort.
+ *
+ * No /g flag (stateless `exec`). No nested quantifiers — `[^\s·]+` and the
+ * optional `\s+<keyword>` are adjacent, never nested (ReDoS-safe, same rule
+ * `cli-patterns.ts` documents).
+ */
+exports.CODEX_FOOTER_MODEL_PATTERN = /^\s*([^\s·]+)(?:\s+(minimal|low|medium|high|xhigh)\b)?/i;
+function readCodexFooter(line) {
+    // Same "is this the status bar" question the detector asks, answered by the
+    // same pattern (#1150). Imported read-only: this module must never be the
+    // reason that boundary moves.
+    if (!cli_patterns_1.CODEX_STATUS_BAR_PATTERN.test(line))
+        return null;
+    const separator = line.indexOf('·');
+    if (separator < 0)
+        return null;
+    const match = exports.CODEX_FOOTER_MODEL_PATTERN.exec(line.slice(0, separator));
+    if (!match)
+        return null;
+    const model = match[1];
+    if (!isPlausibleModelToken(model))
+        return null;
+    const effort = match[2] ? resolveEffortToken(match[2]) : null;
+    // `CODEX_STATUS_BAR_PATTERN` is a *boundary* test — "a token, a middle dot, a
+    // trailing path" — and the detector can afford that because it only ever asks
+    // it inside a window it already knows the footer is in. Reading values needs
+    // one more bit of evidence, because a sentence Codex printed about a file
+    // ("Updated · /src/foo.ts") satisfies the boundary shape, and a value read
+    // here LATCHES for the rest of the session. Every Codex model id carries a
+    // version number, so a digit in the token or a recognised effort keyword
+    // beside it is what separates chrome from prose.
+    if (effort === null && !/\d/.test(model))
+        return null;
+    return { model, effort };
+}
+// =============================================================================
+// Claude
+// =============================================================================
+/**
+ * Reads `<model> with <effort> effort` off the Claude startup banner (#1784).
+ *
+ * Measured on claude 2.1.232:
+ *   `▝▜█████▛▘  Opus 5 (1M context) with xhigh effort · Claude Max`
+ *
+ * Three deliberate choices:
+ *
+ *  - **The block/box glyph is required.** `U+2500–U+259F` covers both the ASCII
+ *    art of the plain banner (`▝▜█████▛▘`) and the frame of the boxed welcome
+ *    variant (`│   Opus 4.8 (1M context) with xhigh effort · Claude Max │`,
+ *    `tests/fixtures/claude-model-overlay.ts`). Without it, a *reply* containing
+ *    the words "…with high effort…" would be scraped as a model — Claude's own
+ *    prose shares the pane with its chrome.
+ *  - **The plan suffix is not matched.** `· Claude Max` is one plan of several
+ *    and is not part of the model; the match ends at `effort`.
+ *  - **`(1M context)` is inside the model, not stripped.** It is what
+ *    distinguishes the 1M variant, and #1783 already displays the hook-reported
+ *    id verbatim.
+ *
+ * No /g. No nested quantifiers: the lazy `[^\u2500-\u259F]*?` sits between two
+ * literal-anchored parts, and the greedy prefix class is disjoint from `\S`.
+ */
+exports.CLAUDE_STARTUP_BANNER_PATTERN = /^\s*[\u2500-\u259F][\s\u2500-\u259F]*(\S[^\u2500-\u259F]*?)\s+with\s+(minimal|low|medium|high|xhigh)\s+effort\b/i;
+function readClaudeBanner(line) {
+    const match = exports.CLAUDE_STARTUP_BANNER_PATTERN.exec(line);
+    if (!match)
+        return null;
+    const model = match[1].trim();
+    if (!isPlausibleModelLabel(model))
+        return null;
+    return { model, effort: resolveEffortToken(match[2]) };
+}
+// =============================================================================
+// Antigravity
+// =============================================================================
+/**
+ * The two left-hand hints agy prints on its status bar (#1784).
+ *
+ * `? for shortcuts` when idle and `esc to cancel` while generating — both
+ * measured on agy 1.1.13, and both already documented in
+ * `src/lib/cli-tools/antigravity.ts`. Requiring one of them is what stops a
+ * wrapped answer line that happens to end in `· high` from being read as chrome.
+ */
+exports.ANTIGRAVITY_STATUS_BAR_HINT_PATTERN = /^\s*(?:\?\s+for\s+shortcuts|esc\s+to\s+cancel)\b/i;
+/**
+ * Reads `<model> (<Effort>)` off the agy startup banner (#1784).
+ *
+ * Measured: `    ▀▀▀▀▀▀▀▀      Gemini 3.7 Flash (High)`. Same block-glyph anchor
+ * as the Claude banner, for the same reason. The sibling banner lines are
+ * rejected by the effort keyword — the account line `dev@example.com (Google AI
+ * Pro)` sitting directly above it has the shape but not the vocabulary.
+ *
+ * Used only as the fallback: the status bar survives scrollback eviction and the
+ * banner does not.
+ */
+exports.ANTIGRAVITY_BANNER_MODEL_PATTERN = /^\s*[\u2500-\u259F][\s\u2500-\u259F]*(\S[^\u2500-\u259F]*?)\s+\((minimal|low|medium|high|xhigh)\)\s*$/i;
+function readAntigravityStatusBar(line) {
+    if (!exports.ANTIGRAVITY_STATUS_BAR_HINT_PATTERN.test(line))
+        return null;
+    const separator = line.lastIndexOf('·');
+    if (separator < 0)
+        return null;
+    // agy drops the final column of this line (see `resolveEffortToken`), so the
+    // trailing token is read with truncation tolerance. If it does not resolve,
+    // the whole line is abandoned rather than half-read: a bar with no effort
+    // suffix would otherwise hand back a model name with its last letter shaved
+    // off.
+    const effort = resolveEffortToken(line.slice(separator + 1), { allowTruncated: true });
+    if (!effort)
+        return null;
+    // The bar is `<hint>` … right-aligned `<model>`, so the model is the last
+    // run of text separated from the hint by the alignment padding.
+    const chunks = line.slice(0, separator).trimEnd().split(/\s{2,}/);
+    const model = (chunks[chunks.length - 1] ?? '').trim();
+    return { model: isPlausibleModelLabel(model) ? model : null, effort };
+}
+function readAntigravityBanner(line) {
+    const match = exports.ANTIGRAVITY_BANNER_MODEL_PATTERN.exec(line);
+    if (!match)
+        return null;
+    const model = match[1].trim();
+    if (!isPlausibleModelLabel(model))
+        return null;
+    return { model, effort: resolveEffortToken(match[2]) };
+}
+// =============================================================================
+// Public API
+// =============================================================================
+/**
+ * Scan a capture from the bottom up, returning the first line that reads.
+ *
+ * Bottom-up is the whole rule: the status bar is the last line of the frame, and
+ * for Claude "the last banner wins" is how a mid-session `/model` switch — which
+ * prints a fresh banner — overtakes the one from session start.
+ *
+ * ANSI is stripped per line rather than over the whole blob so a malformed OSC
+ * sequence can never swallow a newline and merge two lines into one.
+ */
+function scanFromEnd(captureText, read) {
+    const lines = captureText.split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const result = read((0, ansi_1.stripAnsi)(lines[i]));
+        if (result)
+            return result;
+    }
+    return null;
+}
+/**
+ * What this capture says the session's model and reasoning effort are (#1784).
+ *
+ * Pure and side-effect free. Never throws, and answers `{ model: null, effort:
+ * null }` for every tool it has no rule for (gemini / copilot / vibe-local /
+ * opencode — out of scope for this Issue) and for every frame that does not show
+ * the chrome it looks for.
+ *
+ * **Answering null is a correct outcome, not a failure.** tmux keeps a
+ * 2000-line `history-limit`; a Claude session that has been talking for hours
+ * has long since scrolled its banner away, and the honest answer then is "the
+ * screen does not say" — the alternative, a stale or guessed value, is the one
+ * thing this must not do. The caller latches the last non-null sighting.
+ *
+ * @param cliToolId - Which TUI the text came from; the rules are per-tool
+ * @param captureText - `capture-pane` output, ANSI-bearing or not
+ */
+function extractModelInfo(cliToolId, captureText) {
+    if (!captureText)
+        return unknown();
+    switch (cliToolId) {
+        case 'codex':
+            return scanFromEnd(captureText, readCodexFooter) ?? unknown();
+        case 'claude':
+            return scanFromEnd(captureText, readClaudeBanner) ?? unknown();
+        case 'antigravity':
+            return (scanFromEnd(captureText, readAntigravityStatusBar) ??
+                scanFromEnd(captureText, readAntigravityBanner) ??
+                unknown());
+        default:
+            return unknown();
+    }
+}
+/**
+ * The effort an Antigravity model id carries in its own name (#1784).
+ *
+ * agy's ids embed the level — `gemini-3.7-flash-high`, `gemini-3.5-flash-low` —
+ * and that id arrives on **every** agy hook payload (`modelName`), which makes
+ * it a strictly better source than the screen for this one tool: no scrollback
+ * dependency, no truncation, no polling delay.
+ *
+ * Ids that carry no suffix (`claude-sonnet-4-6`, `claude-opus-4-6-thinking`)
+ * answer null and fall through to the scraped bar.
+ *
+ * **Measured against the Issue text**: #1784 lists `gpt-oss-120b-medium` as an
+ * id "without a suffix" while also specifying `-low|-medium|-high$` as the rule
+ * — the two contradict each other, because that id ends in `-medium`. The stated
+ * rule is applied as written (it reads `medium`), which is also the reading that
+ * matches what the level means for that model. Nothing is lost either way: the
+ * *model* shown in the UI is the hook-reported id verbatim, so the id is never
+ * rewritten by this function.
+ *
+ * `minimal` / `xhigh` are deliberately not in the suffix vocabulary: no agy id
+ * has been observed with them, and a model genuinely named `…-minimal` would be
+ * misread.
+ */
+exports.ANTIGRAVITY_MODEL_ID_EFFORT_PATTERN = /-(low|medium|high)$/i;
+function deriveEffortFromModelId(modelId) {
+    if (!modelId)
+        return null;
+    const match = exports.ANTIGRAVITY_MODEL_ID_EFFORT_PATTERN.exec(modelId);
+    return match ? match[1].toLowerCase() : null;
+}
+/**
+ * Fold the hook-reported model together with the scraped frame (#1784).
+ *
+ * The precedence, and why:
+ *
+ *  - **model — hooks win.** A hook payload is the agent naming itself; the
+ *    screen is a render of that, abbreviated for display (agy prints `Gemini 3.7
+ *    Flash` for `gemini-3.7-flash-high`). When they disagree the exact one is
+ *    right. Capture only fills the hole: Claude after a server restart, and any
+ *    session that predates this process.
+ *  - **effort — the screen wins for codex/claude**, because it is the *only*
+ *    source: no hook payload of any tool carries an effort field.
+ *  - **effort — the id wins for antigravity**, because agy encodes the level in
+ *    the id it reports on every event, and that beats a bar that is only on
+ *    screen while the session lives.
+ *
+ * The derivation reads the *merged* model rather than the hook value alone:
+ * effort-in-the-id is a property of the id being published, and when no hook has
+ * spoken the merged value is the scraped display name, which carries no suffix
+ * and falls through to the scraped effort anyway. Same answer, one input.
+ *
+ * @param cliToolId - Which tool; only `antigravity` derives effort from the id
+ * @param hooksModel - {@link import('../../lib/session/agent-event-state').getLastKnownAgentModel}
+ * @param captured - {@link extractModelInfo}'s answer, latched by the caller
+ */
+function mergeModelInfo(cliToolId, hooksModel, captured) {
+    const model = (hooksModel || null) ?? captured?.model ?? null;
+    const capturedEffort = captured?.effort ?? null;
+    const effort = cliToolId === 'antigravity' ? (deriveEffortFromModelId(model) ?? capturedEffort) : capturedEffort;
+    return { model, effort };
+}

package/dist/server/src/lib/git/git-default-branch.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Repository default-branch resolution (origin/HEAD).
+ * Issue #921: extracted from git-utils.ts (god-module split, P1-a).
+ *
+ * Shared by reset / deleteBranch / push protection (Issue #783, DR1-001).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BRANCH_UNRESOLVED = void 0;
+exports.getDefaultBranch = getDefaultBranch;
+exports.resolveDefaultBranchName = resolveDefaultBranchName;
+const git_exec_1 = require("./git-exec");
+/**
+ * Sentinel returned by getDefaultBranch when origin/HEAD is UNRESOLVED (the
+ * `symbolic-ref` read returned null). DISTINCT from `null` (which means
+ * symbolic-ref resolved to a value that is NOT an `origin/` ref). Issue #783,
+ * DR1-002: callers must distinguish "unresolved" from "resolved-but-non-origin/"
+ * so the reset fallback only fires on TRUE unresolution.
+ */
+exports.DEFAULT_BRANCH_UNRESOLVED = Symbol('default-branch-unresolved');
+/**
+ * Resolve the repository default branch name via origin/HEAD (Issue #783,
+ * shared by reset / deleteBranch / push protection — DR1-001).
+ *
+ * Returns THREE distinguishable outcomes (DR1-002 — required for reset's
+ * byte-invariance):
+ *   - string                    : origin/<name> resolved; returns <name> (e.g. "main")
+ *   - DEFAULT_BRANCH_UNRESOLVED : symbolic-ref returned null (origin/HEAD unresolved)
+ *   - null                      : symbolic-ref returned a value that is NOT an
+ *                                 `origin/` ref (unexpected value)
+ *
+ * Keeping "unresolved" and "resolved-but-non-origin/" separate lets
+ * isDefaultBranchForReset's main/master fallback fire ONLY when truly unresolved,
+ * preserving the original behavior (a naive `startsWith ? slice : null` would
+ * collapse the non-origin/ case into null and wrongly trigger the fallback).
+ */
+async function getDefaultBranch(worktreePath) {
+    // DR2-006: execGitCommand returns an already-trimmed string on success / null
+    // on failure, so out is trimmed; the out.trim() below is an idempotent (harmless)
+    // double-trim. The "trimmed string / null" pair maps cleanly onto the 3 values:
+    //   UNRESOLVED (out===null) / resolved name (startsWith 'origin/') / non-origin/ (else -> null).
+    // Empty-string edge: if symbolic-ref returned '' (non-null), v='' -> startsWith
+    // false -> null, matching the original isDefaultBranchForReset behavior.
+    const out = await (0, git_exec_1.execGitCommand)(['symbolic-ref', 'refs/remotes/origin/HEAD', '--short'], worktreePath);
+    if (out === null)
+        return exports.DEFAULT_BRANCH_UNRESOLVED;
+    const v = out.trim();
+    return v.startsWith('origin/') ? v.slice('origin/'.length) : null;
+}
+/**
+ * Thin wrapper for callers that only want "the resolved default name, or null
+ * when unknown" (Issue #783, DR1-001). Collapses both DEFAULT_BRANCH_UNRESOLVED
+ * and the non-origin/ `null` into `null` (= default name unknown). Used by
+ * deleteBranch (no fallback) and push protection (null = unprotected).
+ */
+async function resolveDefaultBranchName(worktreePath) {
+    const r = await getDefaultBranch(worktreePath);
+    return typeof r === 'string' ? r : null;
+}

package/dist/server/src/lib/hooks/agent-event-service.js

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * Effects of a structured agent event (Issue #1549, Phase 3-2).
+ *
+ * The agent CLI is the only party that knows for certain that it finished a
+ * turn. Everything else in this codebase infers it by reading the terminal
+ * frame. This module is the first-class path: an event the agent itself sent,
+ * turned into a `task_events` row and — when the contract asks for it — a
+ * verification run.
+ *
+ * It does not replace the string analysis. `detectSessionStatus` keeps running
+ * and keeps deciding, because a hook only exists when a human wired one up and
+ * a completion mechanism that silently does nothing on an unconfigured machine
+ * is worse than one that is merely imprecise everywhere.
+ *
+ * Server-only: touches the filesystem (realpath) and the database.
+ *
+ * @module lib/hooks/agent-event-service
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_CWD_LENGTH = exports.isAgentEventType = exports.AGENT_EVENT_TYPES = void 0;
+exports.validateHookCwd = validateHookCwd;
+exports.resolveWorktreeByCwd = resolveWorktreeByCwd;
+exports.applyAgentStopEvent = applyAgentStopEvent;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const db_1 = require("../../lib/db");
+const tasks_db_1 = require("../../lib/db/tasks-db");
+const path_validator_1 = require("../../lib/security/path-validator");
+const task_transition_service_1 = require("../../lib/tasks/task-transition-service");
+const gate_runner_1 = require("../../lib/verification/gate-runner");
+const agent_event_state_1 = require("../../lib/session/agent-event-state");
+const logger_1 = require("../../lib/logger");
+const logger = (0, logger_1.createLogger)('lib/hooks/agent-event-service');
+/**
+ * The event vocabulary lives in `agent-event-types` (Issue #1722) so the
+ * settings generator and the in-memory state can use it without importing this
+ * module's database and verification dependencies. Re-exported here because
+ * this is where callers have always found it.
+ *
+ * The Claude-specific mapping helpers that used to be re-exported alongside
+ * them are gone (Issue #1759): a tool's spellings now belong to that tool's
+ * `AgentEventSource`, and re-exporting one tool's from the generic service
+ * would have made this module the next place a Phase 4-x implementer reached
+ * for. Ask `getAgentEventSource(cliToolId).normalizeEvent()` instead.
+ *
+ * Every kind but `stop` is accepted, recorded and exposed without changing any
+ * state: the receiver has to exist before agents can be told to send them, and
+ * rejecting them would make every hook config a two-step rollout.
+ */
+var agent_event_types_1 = require("../../lib/hooks/agent-event-types");
+Object.defineProperty(exports, "AGENT_EVENT_TYPES", { enumerable: true, get: function () { return agent_event_types_1.AGENT_EVENT_TYPES; } });
+Object.defineProperty(exports, "isAgentEventType", { enumerable: true, get: function () { return agent_event_types_1.isAgentEventType; } });
+/** Bound on the accepted `cwd`, comfortably above PATH_MAX on every supported platform. */
+exports.MAX_CWD_LENGTH = 4096;
+/**
+ * Reject a `cwd` that cannot be a legitimate agent working directory.
+ *
+ * A hook posts the directory the agent is running in, so the only shapes worth
+ * accepting are absolute, traversal-free paths. `..` is refused rather than
+ * normalised away: `resolve()` would happily turn `/repos/a/../../etc` into a
+ * path that looks nothing like what the caller sent, and a value that changes
+ * meaning between validation and use is exactly how traversal checks get
+ * defeated. Percent-encoding is decoded first, so `%2e%2e%2f` cannot smuggle a
+ * `..` past a raw string scan.
+ */
+function validateHookCwd(raw) {
+    if (typeof raw !== 'string' || raw.trim() === '') {
+        return { ok: false, reason: 'empty' };
+    }
+    if (raw.length > exports.MAX_CWD_LENGTH) {
+        return { ok: false, reason: 'too_long' };
+    }
+    let decoded = raw;
+    try {
+        decoded = decodeURIComponent(raw);
+    }
+    catch {
+        // Not valid percent-encoding; the raw string is the only interpretation.
+        decoded = raw;
+    }
+    if (raw.includes('\0') || decoded.includes('\0')) {
+        return { ok: false, reason: 'nul_byte' };
+    }
+    if (!(0, path_1.isAbsolute)(raw)) {
+        return { ok: false, reason: 'not_absolute' };
+    }
+    if (hasTraversalSegment(raw) || hasTraversalSegment(decoded)) {
+        return { ok: false, reason: 'traversal' };
+    }
+    return { ok: true, cwd: raw };
+}
+/** True when any path segment is `..`, under either separator convention. */
+function hasTraversalSegment(value) {
+    return value
+        .split(path_1.sep === '\\' ? /[\\/]/ : '/')
+        .some((segment) => segment === '..');
+}
+/**
+ * The registered worktree an agent's `cwd` belongs to, or null.
+ *
+ * Both sides are resolved through `realpath` before comparison because the two
+ * ends disagree routinely and harmlessly: macOS hands agents `/var/...` for a
+ * worktree stored as `/private/var/...`, and worktree roots are often symlinked.
+ *
+ * A descendant matches its worktree — agents commonly run from a subdirectory —
+ * and the longest match wins, so a worktree nested inside another resolves to
+ * the inner one rather than to whichever row the database returned first.
+ *
+ * @param cwd - Already through {@link validateHookCwd}
+ * @returns null when the path does not exist or belongs to no worktree; the
+ *   caller must not distinguish those two cases to the client
+ */
+function resolveWorktreeByCwd(db, cwd) {
+    const resolvedCwd = safeRealpath(cwd);
+    if (resolvedCwd === null) {
+        return null;
+    }
+    let best = null;
+    let bestLength = -1;
+    for (const worktree of (0, db_1.getWorktrees)(db)) {
+        const resolvedWorktree = safeRealpath(worktree.path);
+        if (resolvedWorktree === null)
+            continue;
+        if (!(0, path_validator_1.isWithinRoot)(resolvedCwd, resolvedWorktree))
+            continue;
+        if (resolvedWorktree.length > bestLength) {
+            best = worktree;
+            bestLength = resolvedWorktree.length;
+        }
+    }
+    return best;
+}
+/** realpath, or null when the path does not exist / is unreadable. */
+function safeRealpath(target) {
+    try {
+        return (0, fs_1.realpathSync)(target);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Apply a `stop` event to whatever the worktree is currently doing.
+ *
+ * The no-op is the load-bearing case. Sessions with no contract, and therefore
+ * no task, are the overwhelming majority; for them this records the timestamp
+ * and returns. Nothing about the existing completion path changes.
+ *
+ * Never throws. A hook is fire-and-forget from a CLI's stop handler, and a
+ * failure here must not become the agent's problem.
+ */
+async function applyAgentStopEvent(db, worktree, cliToolId, instanceId) {
+    (0, agent_event_state_1.recordAgentStopEvent)(worktree.id, cliToolId, instanceId);
+    let task;
+    try {
+        task = (0, tasks_db_1.getActiveTaskForInstance)(db, worktree.id, cliToolId, instanceId);
+    }
+    catch (error) {
+        logger.warn('agent-stop-task-lookup-failed', {
+            worktreeId: worktree.id,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return { taskId: null, taskEventApplied: false, verificationRunId: null };
+    }
+    if (!task) {
+        return { taskId: null, taskEventApplied: false, verificationRunId: null };
+    }
+    let taskEventApplied = false;
+    try {
+        const result = (0, task_transition_service_1.applyTaskEvent)(db, task.id, 'agent_idle', { source: 'hook' });
+        taskEventApplied = result !== null && result.toStatus !== null;
+    }
+    catch (error) {
+        logger.warn('agent-stop-event-failed', {
+            taskId: task.id,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+    if (!task.contract.success.autoVerifyOnStop) {
+        return { taskId: task.id, taskEventApplied, verificationRunId: null };
+    }
+    let verificationRunId = null;
+    try {
+        const { runId } = await (0, gate_runner_1.startVerification)({
+            worktreeId: worktree.id,
+            worktreePath: worktree.path,
+            instanceId,
+            taskId: task.id,
+            trigger: 'task',
+        });
+        verificationRunId = runId;
+    }
+    catch (error) {
+        // A run already in flight is the expected collision, not a fault: the agent
+        // stopping twice while gates execute is ordinary.
+        if (!(error instanceof gate_runner_1.VerificationConflictError)) {
+            logger.error('agent-stop-auto-verify-failed', {
+                taskId: task.id,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return { taskId: task.id, taskEventApplied, verificationRunId };
+}