commandmate 0.49.3 → 0.50.0

package/dist/server/src/lib/detection/tools/opencode-v2/patterns.js

@@ -4,8 +4,11 @@
  * (Issue #3217 I-3). `cli-patterns.ts` re-exports every public name.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OPENCODE_V2_SKIP_PATTERNS = exports.OPENCODE_V2_THINKING_PATTERN = exports.OPENCODE_V2_FOOTER_PATTERN = exports.OPENCODE_V2_IDLE_COMPOSER_PATTERN = void 0;
+exports.OPENCODE_V2_SKIP_PATTERNS = exports.OPENCODE_V2_FOOTER_ROW_PATTERN = exports.OPENCODE_V2_THINKING_PATTERN = exports.OPENCODE_V2_FOOTER_PATTERN = exports.OPENCODE_V2_IDLE_COMPOSER_PATTERN = void 0;
+exports.findOpencodeV2IdleComposer = findOpencodeV2IdleComposer;
+exports.isOpencodeV2FooterRowAt = isOpencodeV2FooterRowAt;
 exports.isOpencodeV2ComposerVisible = isOpencodeV2ComposerVisible;
+exports.findOpencodeV2ChromeStart = findOpencodeV2ChromeStart;
 const pasted_text_1 = require("../../shared/pasted-text");
 const patterns_1 = require("../opencode/patterns");
 // =============================================================================
@@ -27,8 +30,104 @@ const patterns_1 = require("../opencode/patterns");
  * Measured on 2.0.18 at 80x200 (2026-09-28):
  * `   ┃  Ask anything… "Fix broken tests"`. Match against the ANSI-stripped
  * frame BEFORE `stripBoxDrawing`, which removes the gutter this anchors on.
+ *
+ * Read by position (Issue #4188): the placeholder row, then only gutter rows (the
+ * blank row and the agent/model row), then the composer's bottom border `╹▀▀▀…` —
+ * the box as every frame under `tests/fixtures/opencode-v2*` that draws the
+ * placeholder draws it. The gutter alone does not say "composer": the transcript
+ * echoes each sent message in the same `┃` box, so a message that began with
+ * `Ask anything…` put a placeholder on the pane and an empty input box with it,
+ * for the send path's composer check, the `ready` branch and liveness alike. The
+ * echo block ends in a non-gutter row (the reply, or a blank row), never the border.
+ *
+ * Read by {@link findOpencodeV2IdleComposer}, one pass over the rows: each border
+ * walks up its own run of gutter rows, and the runs do not overlap (a border row is
+ * not a gutter row), so the work is linear in the rows. The multi-line regular
+ * expression it replaces retried from every gutter row, which a pane of `┃  Ask
+ * anything…` rows with no border under them made quadratic (Issue #4188 review).
+ *
+ * Kept a `RegExp` because two readers outside this module take regular
+ * expressions only — liveness's `alivePatterns` (`readonly RegExp[]`,
+ * `src/types/cli-tool-contracts.ts`) and `getCliToolPatterns().promptPattern` — and
+ * they must read the same rule as the send path's composer check and the `ready`
+ * branch. A subclass whose `exec` is that pass gives all three one reader: `test`,
+ * `match` and `replace` go through `exec`. `source` still spells the rule.
+ *
+ * Issue #4209 kept this form rather than having the readers call the function: the
+ * send path's composer check and the `ready` branch already do, but
+ * `getCliToolPatterns().promptPattern` is typed `RegExp` for every tool and read by
+ * the poller (`response-checker-extraction-steps.ts`) and the generic composer
+ * check, so dropping the `RegExp` would change that contract for all tools. What it
+ * guarantees instead, pinned in `tests/unit/detection/tools/opencode-v2/
+ * idle-composer-regexp-contract-4209.test.ts`:
+ *
+ * - **Guaranteed**: `test`, `exec`, and the string methods that go through `exec`
+ *   on a non-global pattern — `String.prototype.match` / `search` / `replace`.
+ * - **Rows are split on LF only.** U+2028 / U+2029 / CR are not row breaks.
+ * - **Not guaranteed**: `split` and `matchAll`, which construct `Symbol.species` —
+ *   the native `RegExp`, so neither the rule's answer nor its linear time carries
+ *   over; and a copy built from `source` and `flags`, whose `^` under the `m` flag
+ *   also starts a line after U+2028 / U+2029 / CR (it answers differently for a row
+ *   such as `x\u2028┃  Ask anything…` over a border) and which retries from every
+ *   gutter row. No production reader copies or splits it (searched for #4209).
+ */
+exports.OPENCODE_V2_IDLE_COMPOSER_PATTERN = new (class OpencodeV2IdleComposerPattern extends RegExp {
+    static get [Symbol.species]() {
+        return RegExp;
+    }
+    constructor() {
+        super('^[^\\S\\n]*[\\u2502\\u2503][^\\S\\n]*Ask anything(?:\\.\\.\\.|\\u2026)[^\\n]*\\n(?:[^\\S\\n]*[\\u2502\\u2503][^\\n]*\\n)*[^\\S\\n]*\\u2579\\u2580{4,}', 'm');
+    }
+    exec(text) {
+        const found = findOpencodeV2IdleComposer(text);
+        if (!found)
+            return null;
+        const match = [text.slice(found.start, found.end)];
+        match.index = found.start;
+        match.input = text;
+        return match;
+    }
+})();
+/** The placeholder at the start of a gutter row (Issue #2934). */
+const IDLE_COMPOSER_PLACEHOLDER_ROW = /^[^\S\n]*[\u2502\u2503][^\S\n]*Ask anything(?:\.\.\.|\u2026)/;
+/** A row of one of the `┃` boxes. */
+const IDLE_COMPOSER_GUTTER_ROW = /^[^\S\n]*[\u2502\u2503]/;
+/** The composer's bottom border, as the match ends on it. */
+const IDLE_COMPOSER_BORDER_ROW = /^[^\S\n]*\u2579\u2580{4,}/;
+/**
+ * The empty composer of {@link OPENCODE_V2_IDLE_COMPOSER_PATTERN}, by position, in
+ * one pass (Issue #4188): the first placeholder row whose gutter run reaches a
+ * bottom border, as character offsets from the placeholder row's start to the end
+ * of the border's `▀` run; or null.
+ *
+ * @param text - ANSI-stripped capture, box drawing intact
+ * @returns The match's `[start, end)` in `text`, or null
  */
-exports.OPENCODE_V2_IDLE_COMPOSER_PATTERN = /^[^\S\n]*[\u2502\u2503][^\S\n]*Ask anything(?:\.\.\.|\u2026)/m;
+function findOpencodeV2IdleComposer(text) {
+    const rows = text.split('\n');
+    const offsets = new Array(rows.length);
+    let offset = 0;
+    for (let i = 0; i < rows.length; i++) {
+        offsets[i] = offset;
+        offset += rows[i].length + 1;
+    }
+    for (let border = 1; border < rows.length; border++) {
+        const borderMatch = IDLE_COMPOSER_BORDER_ROW.exec(rows[border]);
+        if (!borderMatch)
+            continue;
+        // Walk up the gutter run over this border, once; the topmost placeholder
+        // row in it is where the match starts.
+        let placeholder = -1;
+        for (let j = border - 1; j >= 0 && IDLE_COMPOSER_GUTTER_ROW.test(rows[j]); j--) {
+            if (IDLE_COMPOSER_PLACEHOLDER_ROW.test(rows[j]))
+                placeholder = j;
+        }
+        if (placeholder >= 0) {
+            return { start: offsets[placeholder], end: offsets[border] + borderMatch[0].length };
+        }
+    }
+    return null;
+}
 /**
  * OpenCode V2's footer, which ends in `ctrl+p commands` on every frame the
  * TUI draws (before a turn: `<path>:<branch>  shift+tab agents  ctrl+p commands`;
@@ -36,28 +135,113 @@ exports.OPENCODE_V2_IDLE_COMPOSER_PATTERN = /^[^\S\n]*[\u2502\u2503][^\S\n]*Ask
  *
  * Proof that the TUI — and so its composer — is on screen, NOT that it is idle:
  * a running turn keeps the footer.
+ *
+ * Read by position (Issue #4175): the footer is the row right under the composer's
+ * bottom border (`╹▀▀▀…`), on every frame under `tests/fixtures/opencode-v2*` —
+ * pinned to the bottom of a session frame, under the centred composer on the
+ * boot screen (row 106 of 200, with `2.0.18` below it). The words alone were
+ * matched before, so a reply saying `ctrl+p commands` put the composer on a
+ * frame that had none (the approval dialog replaces it) and made a frame with
+ * no footer `ready`. The row ends in the words, or in them and the sidebar's
+ * column two spaces later (`tests/fixtures/opencode-v2-usage-2981/`).
+ *
+ * Match against the ANSI-stripped text with its box drawing intact: the border is
+ * the anchor. For a reader that sees one row at a time, {@link isOpencodeV2FooterRowAt}.
  */
-exports.OPENCODE_V2_FOOTER_PATTERN = /ctrl\+p commands/;
+exports.OPENCODE_V2_FOOTER_PATTERN = /^[^\S\n]*\u2579\u2580{4,}[^\n]*\n[^\n]*ctrl\+p commands(?:[^\S\n]{2}[^\n]*)?[^\S\n]*$/m;
+/** The end of the footer's row: the words, then nothing or the sidebar's column. */
+const FOOTER_ROW_END_PATTERN = /ctrl\+p commands(?:[^\S\n]{2}[^\n]*)?[^\S\n]*$/;
+/**
+ * Whether `rows[index]` is the footer, by {@link OPENCODE_V2_FOOTER_PATTERN}'s rule:
+ * the row under the composer's bottom border, ending as the footer ends.
+ *
+ * @param rows - ANSI-stripped rows, box drawing intact
+ * @param index - The row to ask about
+ */
+function isOpencodeV2FooterRowAt(rows, index) {
+    return (index > 0 &&
+        index < rows.length &&
+        patterns_1.OPENCODE_COMPOSER_BOTTOM_BORDER.test(rows[index - 1]) &&
+        FOOTER_ROW_END_PATTERN.test(rows[index]));
+}
 /**
  * OpenCode V2 working indicator: the footer's `esc interrupt` hint, drawn only
- * while a turn is running (2.0.18).
+ * while a turn is running (2.0.18). After one Esc it reads `esc again to interrupt`
+ * and the reply keeps being written (measured, Issue #4161), as V1's does (#1894).
+ *
+ * Read by position, because a reply can say those words and can even quote the
+ * whole row (Issue #4161): the hint has to be on the LAST non-blank row of the text,
+ * where the TUI pins its footer on a session frame, so no `m` flag. On that row it
+ * is followed by the footer's columns, two spaces apart: `   ⬝⬝⬝⬝■■■■ esc interrupt
+ *     shift+tab agents  ctrl+p commands`. A pane wide enough for the sidebar draws
+ * one more column after `ctrl+p commands` (`tests/fixtures/opencode-v2-usage-2981/`).
+ *
+ * Every reader hands over the bottom of the frame. Not for a reader that sees one row
+ * at a time, where each row is the last one: the extraction cuts the footer off by
+ * position instead ({@link findOpencodeV2ChromeStart}, Issue #4175). Confirmed on the
+ * 80-column footers measured for #4175 (`tests/fixtures/opencode-v2-live-4175/`).
+ */
+exports.OPENCODE_V2_THINKING_PATTERN = /(?:^|\s)esc (?:again to )?interrupt[^\S\n]{2,}(?:[^\n]*[^\S\n]{2})?ctrl\+p commands(?:[^\S\n]{2}[^\n]*)?\s*$/;
+/**
+ * The footer as one row, by its column (Issue #4161): 2.0.18 starts the footer in
+ * column 2 or 3 and a reply's text in column 5 (every frame under
+ * `tests/fixtures/opencode-v2*`).
+ *
+ * Issue #4175: no longer in the skip list. The extraction cuts the footer off with
+ * the rest of the chrome ({@link findOpencodeV2ChromeStart}), so the column is read
+ * only where that finds no composer — and there only on the last row of the frame.
  */
-exports.OPENCODE_V2_THINKING_PATTERN = /esc interrupt/;
+exports.OPENCODE_V2_FOOTER_ROW_PATTERN = /^[^\S\n]{0,4}\S[^\n]*ctrl\+p commands(?:[^\S\n]{2}[^\n]*)?$/;
 /**
  * Whether OpenCode V2's composer is on screen, so a send may type into it
- * (Issue #2934, D6): the gutter-anchored placeholder, or the footer.
+ * (Issue #2934, D6): the gutter-anchored placeholder inside the box over the
+ * composer's border (Issue #4188: not a transcript echo starting with the phrase),
+ * or the footer under that border (Issue #4175: not the words anywhere on the pane).
  *
  * @param text - ANSI-stripped capture, box drawing intact
  */
 function isOpencodeV2ComposerVisible(text) {
-    return exports.OPENCODE_V2_IDLE_COMPOSER_PATTERN.test(text) || exports.OPENCODE_V2_FOOTER_PATTERN.test(text);
+    return findOpencodeV2IdleComposer(text) !== null || exports.OPENCODE_V2_FOOTER_PATTERN.test(text);
 }
-/** OpenCode V2 rows that are chrome, never reply content. */
+/**
+ * Where OpenCode V2's bottom-pinned chrome starts — the composer box (or the dialog
+ * drawn in its place), its border and the footer — or -1 (Issue #4175).
+ *
+ * V1's reader ({@link findOpenCodeChromeStart}): the same toolkit draws the same box,
+ * `┃` gutter rows over a `╹▀▀▀` border with the footer under it, on every frame under
+ * `tests/fixtures/opencode-v2*`, and the approval and question forms run their gutter
+ * to the last row as V1's dialog does. Without it the extraction knew the footer only
+ * by its column ({@link OPENCODE_V2_FOOTER_ROW_PATTERN}) and the composer's rows went
+ * into the reply. When it finds nothing, the footer as the last non-blank row.
+ *
+ * @param lines - ANSI-stripped rows, box drawing intact
+ * @returns Index of the first chrome row, or -1
+ */
+function findOpencodeV2ChromeStart(lines) {
+    const structural = (0, patterns_1.findOpenCodeChromeStart)(lines);
+    if (structural >= 0)
+        return structural;
+    let last = lines.length - 1;
+    while (last >= 0 && lines[last].trim() === '')
+        last--;
+    return last >= 0 && exports.OPENCODE_V2_FOOTER_ROW_PATTERN.test(lines[last]) ? last : -1;
+}
+/**
+ * The composer's placeholder row, on the composer's `┃` gutter (Issue #4175). The
+ * skip list held `/Ask anything(?:\.\.\.|\u2026)/`, which dropped any row of a reply
+ * with those words. One row at a time, so no `m` flag.
+ */
+const OPENCODE_V2_PLACEHOLDER_ROW_PATTERN = /^[^\S\n]*[\u2502\u2503][^\S\n]*Ask anything(?:\.\.\.|\u2026)/;
+/**
+ * OpenCode V2 rows that are chrome, never reply content.
+ *
+ * Issue #4175: the footer and the placeholder are matched on their own rows only —
+ * the chrome is cut off before this list is read ({@link findOpencodeV2ChromeStart}),
+ * so what reaches it is the transcript, where those words are a reply's.
+ */
 exports.OPENCODE_V2_SKIP_PATTERNS = [
     patterns_1.OPENCODE_SEPARATOR_PATTERN,
-    exports.OPENCODE_V2_FOOTER_PATTERN,
-    exports.OPENCODE_V2_THINKING_PATTERN,
-    /Ask anything(?:\.\.\.|\u2026)/,
+    OPENCODE_V2_PLACEHOLDER_ROW_PATTERN,
     /^Build\s+·/,
     pasted_text_1.PASTED_TEXT_PATTERN,
 ];

package/dist/server/src/lib/detection/tools/run-detection.js

@@ -14,7 +14,7 @@
  *  0.x  spec.beforePrompt      tool pickers / pagers / status bars
  *  1    detectPrompt           shared, with spec.isStalePrompt as the #1160 guard
  *  1.5  spec.afterPrompt       tool selection-list footers
- *  2    detectThinking         shared, 5-line window
+ *  2    detectThinking         shared, 5-line window (or spec.readThinking)
  *  2.x  spec.afterThinking     tool running + completion markers
  *  3    promptPattern          shared composer check, gated by D1 evidence
  *  4    staleness heuristic    `no_recent_output`
@@ -118,7 +118,10 @@ function runToolDetection(spec, input, context = {}) {
         return { ...afterPrompt, promptDetection: afterPrompt.promptDetection ?? promptDetection };
     // 2. Thinking indicator detection — THINKING_TAIL_LINE_COUNT window (narrower).
     // CLI tool is actively processing (shows spinner, "Planning...", etc.)
-    if ((0, cli_patterns_1.detectThinking)(spec.tool, frame.thinkingLines)) {
+    const thinking = spec.readThinking
+        ? spec.readThinking(frame)
+        : (0, cli_patterns_1.detectThinking)(spec.tool, frame.thinkingLines);
+    if (thinking) {
         return (0, verdicts_1.positiveVerdictWithPrompt)('running', status_reason_1.STATUS_REASON.THINKING_INDICATOR, promptDetection);
     }
     // 2.x — the tool's own running and completion markers.

package/dist/server/src/lib/detection/tools/verified-against.js

@@ -255,6 +255,22 @@ exports.UNMEASURED_VERIFIED_AGAINST = {
 /**
  * Tool id → the build its rules were measured against.
  *
+ * ## Reviewed by Issue #4146: no stamp moved
+ *
+ * Newer builds have been captured since, but only part of a screen set, and a
+ * stamp moves when the set is re-captured and read (see #2818, #2868, #2773).
+ *
+ *  - codex 0.166.0 (`tests/fixtures/codex-dialogs-0166/`): launch screens and the
+ *    idle composer. 未確認: the command approval, `/model`, and a running turn.
+ *  - opencode 1.18.35 (`tests/fixtures/opencode-live-4134/`): one finished turn.
+ *    未確認: the other four states the canary covers.
+ *  - claude 2.1.318 (`tests/fixtures/claude-auto-default-nudge-4134/`): one dialog.
+ *    未確認: everything else on that build.
+ *  - gemini and vibe-local have measured frames (a trust dialog; four readiness
+ *    screens) but no status rules read off them, so they stay `unmeasured`.
+ *
+ * `tests/unit/detection/tools/verified-against-4146.test.ts` keeps this list honest.
+ *
  * Keyed by the catalog / `CLIToolType` id, not by executable name: antigravity's
  * binary is `agy` (DR2-023), and that mapping belongs to the probe table, not
  * here.

package/dist/server/src/lib/detection/tools/vibe-local/readiness.js

@@ -25,6 +25,7 @@
  * @module lib/detection/tools/vibe-local/readiness
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.readVibeLocalNotReadyScreen = readVibeLocalNotReadyScreen;
 exports.isVibeLocalComposerReady = isVibeLocalComposerReady;
 const ansi_1 = require("../../ansi");
 const status_detector_1 = require("../../status-detector");
@@ -41,6 +42,27 @@ const FOOTER_ROWS = [/^\s*─{3,}\s*$/, /^\s*✦\s.*│/, /^\s*ESC: stop\s*$/];
 function isFooterRow(line) {
     return FOOTER_ROWS.some((pattern) => pattern.test(line));
 }
+/**
+ * Which rows kept {@link isVibeLocalComposerReady} from saying yes. Only for the
+ * refusal `send` reports: it decides nothing, and a turn being generated is the
+ * caller's to have ruled out.
+ *
+ * @param output - Raw `capture-pane` output (ANSI escapes allowed)
+ */
+function readVibeLocalNotReadyScreen(output) {
+    const lines = (0, ansi_1.stripAnsi)(output).split('\n');
+    let promptRow = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (PROMPT_ROW.test(lines[i])) {
+            promptRow = i;
+            break;
+        }
+    }
+    if (promptRow < 0)
+        return 'no-input-row';
+    const outputBelow = lines.slice(promptRow + 1).some((line) => line.trim() !== '' && !isFooterRow(line));
+    return outputBelow ? 'output-below-input-row' : 'input-row-holds-text';
+}
 /**
  * @param output - Raw `capture-pane` output (ANSI escapes allowed)
  * @returns true when the newest prompt row is empty and only the footer is

package/dist/server/src/lib/git/git-common-dir.js

@@ -0,0 +1,192 @@
+"use strict";
+/**
+ * Scan-root identity: *which git repository* does a registered directory belong
+ * to? (Issue #1662)
+ *
+ * `repositories` rows are keyed by directory path, but a git repository can be
+ * checked out at many paths at once — every linked worktree is its own
+ * directory. Registering two of them as separate scan roots makes both scans
+ * enumerate the *same* worktree set, so every sync upserts each worktree twice
+ * and `worktrees.repository_path` flips between the two roots run to run. That
+ * is the configuration behind the #1659 ID churn; #1660 stopped the churn, and
+ * this module is what lets a user SEE the configuration that caused it.
+ *
+ * The identity used is `git rev-parse --git-common-dir`, resolved to a physical
+ * path. All worktrees of one repository share that directory by construction —
+ * `git worktree list` is itself derived from it (the main worktree plus
+ * `<common-dir>/worktrees/*`), which is why comparing common dirs is enough and
+ * the two roots' `git worktree list` output cannot disagree. Verified
+ * empirically on git 2.49 against a repository with 29 worktrees: the listing
+ * taken from a linked worktree and from the main checkout was byte-identical.
+ *
+ * Failure is never fatal here. A path that is not a git repository, a git that
+ * is missing or times out, a directory that has been deleted — all resolve to
+ * `null`, which means "no opinion" and leaves the caller's flow untouched.
+ *
+ * {@link probeGitCommonDir} keeps those apart for the one caller that needs them
+ * (Issue #4134, `agent-roles/resolve`): "not a repository" is an answer, a git that
+ * failed is not.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveGitCommonDir = resolveGitCommonDir;
+exports.probeGitCommonDir = probeGitCommonDir;
+exports.resolveGitCommonDirs = resolveGitCommonDirs;
+exports.findDuplicateScanRoots = findDuplicateScanRoots;
+exports.findScanRootsSharingGitRepository = findScanRootsSharingGitRepository;
+const path_1 = __importDefault(require("path"));
+const promises_1 = require("fs/promises");
+const git_exec_1 = require("./git-exec");
+/**
+ * The physical `.git` common directory shared by every worktree of one
+ * repository, or `null` when the question cannot be answered.
+ *
+ * Two normalizations matter and both are load-bearing:
+ *
+ * 1. `git rev-parse --git-common-dir` prints an ABSOLUTE path from a linked
+ *    worktree but a RELATIVE one (`.git`) from a main checkout — measured, not
+ *    assumed. `path.resolve(repoPath, …)` covers both.
+ * 2. The result is passed through `realpath`, because the two roots being
+ *    compared may reach the same directory through different symlinked
+ *    prefixes. On macOS this is not hypothetical: `/tmp` is a symlink to
+ *    `/private/tmp`, and the very repository pair in #1659 had worktrees under
+ *    it. Lexical comparison would miss that pair.
+ *
+ * Uses {@link execGitCommandCapture} rather than `execGitCommand` on purpose:
+ * "not a git repository" is an EXPECTED answer on this path (the user may be
+ * typing a path into the Add form), and `execGitCommand` would log it at error
+ * level every keystroke.
+ *
+ * @param repoPath - Directory to interrogate. Never interpolated into a shell.
+ * @returns Physical common-dir path, or `null` when git could not answer.
+ */
+async function resolveGitCommonDir(repoPath) {
+    const probe = await probeGitCommonDir(repoPath);
+    return probe.kind === 'repository' ? probe.commonDir : null;
+}
+/**
+ * git's own words for "walked up and found none", in both of its forms.
+ *
+ * Deliberately not the bare `not a git repository`: a linked worktree whose
+ * repository is gone says `not a git repository: <path>`, and that directory WAS
+ * a member of something git can no longer name. A git printing these in another
+ * language reads as `failed`, the safe side (`git-exec` sets no locale).
+ */
+const NOT_A_REPOSITORY_STDERR = /not a git repository \(or any (?:of the parent directories|parent up to mount point)/i;
+/**
+ * {@link resolveGitCommonDir} with the failures told apart (Issue #4134).
+ *
+ * @param repoPath - Directory to interrogate. Never interpolated into a shell.
+ */
+async function probeGitCommonDir(repoPath) {
+    const outcome = await (0, git_exec_1.execGitCommandCapture)(['rev-parse', '--git-common-dir'], repoPath);
+    if (!outcome.ok) {
+        return !outcome.timedOut && NOT_A_REPOSITORY_STDERR.test(outcome.stderr)
+            ? { kind: 'not-repository' }
+            : { kind: 'failed' };
+    }
+    const firstLine = outcome.stdout.split('\n')[0]?.trim();
+    if (!firstLine) {
+        return { kind: 'failed' };
+    }
+    return { kind: 'repository', commonDir: await realpathOrLexical(path_1.default.resolve(repoPath, firstLine)) };
+}
+/**
+ * `realpath` that degrades to the lexical path instead of throwing.
+ *
+ * A common dir that cannot be `realpath`'d (racing deletion, permissions) still
+ * compares usefully against another lexical path, and losing the whole
+ * comparison over it would be worse than comparing slightly too strictly.
+ */
+async function realpathOrLexical(candidate) {
+    try {
+        return await (0, promises_1.realpath)(candidate);
+    }
+    catch {
+        return candidate;
+    }
+}
+/**
+ * Resolve the common dir of every supplied scan root, in parallel.
+ *
+ * Paths whose common dir cannot be resolved are simply absent from the result
+ * (see the module docstring: failure means "no opinion"). Duplicated inputs are
+ * resolved once; the returned map is keyed by the caller's original strings.
+ *
+ * Parallel rather than sequential because the caller is an HTTP handler and
+ * each probe carries the 1s `execGitCommandCapture` timeout — serialized, a
+ * dozen dead scan roots would add a dozen seconds to a page load.
+ */
+async function resolveGitCommonDirs(repoPaths) {
+    const unique = [...new Set(repoPaths)];
+    const resolved = await Promise.all(unique.map((p) => resolveGitCommonDir(p)));
+    const byPath = new Map();
+    unique.forEach((repoPath, index) => {
+        const commonDir = resolved[index];
+        if (commonDir !== null) {
+            byPath.set(repoPath, commonDir);
+        }
+    });
+    return byPath;
+}
+/**
+ * Which of the supplied scan roots are secretly the same repository?
+ *
+ * @param repoPaths - Scan-root paths to compare (typically the ENABLED
+ *   `repositories` rows — a disabled root is not scanned, so it cannot be half
+ *   of a double-scan; see `GET /api/repositories`).
+ * @returns One group per repository that more than one path points at. Empty
+ *   when every path is its own repository, which is the normal case: two
+ *   worktrees of two DIFFERENT repositories have different common dirs and are
+ *   never grouped.
+ */
+async function findDuplicateScanRoots(repoPaths) {
+    const byPath = await resolveGitCommonDirs(repoPaths);
+    const byCommonDir = new Map();
+    for (const [repoPath, commonDir] of byPath) {
+        const members = byCommonDir.get(commonDir);
+        if (members) {
+            members.push(repoPath);
+        }
+        else {
+            byCommonDir.set(commonDir, [repoPath]);
+        }
+    }
+    const groups = [];
+    for (const [commonDir, paths] of byCommonDir) {
+        if (paths.length > 1) {
+            groups.push({ commonDir, paths });
+        }
+    }
+    return groups;
+}
+/**
+ * Which ALREADY-REGISTERED scan roots would a newly registered `candidatePath`
+ * duplicate? (Issue #1662, registration side.)
+ *
+ * Re-registering a path that is already a scan root is deliberately NOT a
+ * duplicate: it is the same root, and reporting it would fire the warning on
+ * every ordinary re-scan — the "does not false-positive" acceptance criterion.
+ * Sameness is decided on physical paths, so a symlinked spelling of an existing
+ * root is recognised as that root rather than reported as a second one.
+ *
+ * @param candidatePath - Path about to be registered.
+ * @param existingPaths - Currently registered scan-root paths.
+ * @returns The existing paths (verbatim) that share the candidate's repository.
+ *   Empty when there is no overlap, when the candidate is not a git repository,
+ *   or when git could not answer — none of which may block registration.
+ */
+async function findScanRootsSharingGitRepository(candidatePath, existingPaths) {
+    const candidateCommonDir = await resolveGitCommonDir(candidatePath);
+    if (candidateCommonDir === null) {
+        return [];
+    }
+    const candidateReal = await realpathOrLexical(path_1.default.resolve(candidatePath));
+    const others = existingPaths.filter((existing) => existing !== candidatePath);
+    const otherReals = await Promise.all(others.map((existing) => realpathOrLexical(path_1.default.resolve(existing))));
+    const distinctRoots = others.filter((_, index) => otherReals[index] !== candidateReal);
+    const byPath = await resolveGitCommonDirs(distinctRoots);
+    return distinctRoots.filter((existing) => byPath.get(existing) === candidateCommonDir);
+}

package/dist/server/src/lib/hooks/hook-settings-generator.js

@@ -255,13 +255,19 @@ function isAuthTokenExpected() {
  * event loop forever rather than throw — the fail-open `try/catch` below is
  * never reached, because the call never returns. Such a value is refused here
  * and the default is used.
+ *
+ * Issue #4191: always absolute. The path is written into `--settings <file>`
+ * and read by claude, which runs in the worktree, not in this process's cwd (the
+ * daemon's is the package root); a relative `CM_AGENT_HOOKS_DIR` named another
+ * file there. It is resolved against this process's cwd, where the file is
+ * written.
  */
 function getHookSettingsDirectory(options = {}) {
     const fallback = (0, path_1.join)((0, os_1.homedir)(), '.commandmate', 'hooks');
     if (options.directory) {
-        return (0, safe_directory_1.resolveSafeDirectory)(options.directory, fallback, 'HookSettingsOptions.directory');
+        return (0, safe_directory_1.resolveSafeAbsoluteDirectory)(options.directory, fallback, 'HookSettingsOptions.directory');
     }
-    return (0, safe_directory_1.resolveSafeDirectory)(process.env.CM_AGENT_HOOKS_DIR, fallback, 'CM_AGENT_HOOKS_DIR');
+    return (0, safe_directory_1.resolveSafeAbsoluteDirectory)(process.env.CM_AGENT_HOOKS_DIR, fallback, 'CM_AGENT_HOOKS_DIR');
 }
 /** The instance this settings file speaks for; primary when unspecified. */
 function resolveTargetInstanceId(target) {

package/dist/server/src/lib/hooks/sources/copilot/hook-settings.js

@@ -242,10 +242,16 @@ exports.COPILOT_EVENT_HOOKS = [
  * Issue #1774: `writeCopilotHookSettings` creates this directory with a
  * recursive mkdir, which does not fail but *hangs* for a path inside `/proc`,
  * `/sys` or `/dev`. Such a value is refused here and `~/.copilot` is used.
+ *
+ * Issue #4210: absolute, because the value leaves this process. A role launch
+ * hands copilot `COPILOT_HOME=<this>` (`agent-roles/adapters.ts`,
+ * `buildRoleLaunchArguments`) and copilot runs in the worktree
+ * (`cli-tools/base.ts` `createLaunchPane`), so a relative value named another
+ * `agents/` directory than the one the definition was written into.
  */
 function getCopilotHomeDirectory() {
     const fallback = (0, path_1.join)((0, os_1.homedir)(), '.copilot');
-    return (0, safe_directory_1.resolveSafeDirectory)(process.env.COPILOT_HOME, fallback, 'COPILOT_HOME');
+    return (0, safe_directory_1.resolveSafeAbsoluteDirectory)(process.env.COPILOT_HOME, fallback, 'COPILOT_HOME');
 }
 /** The one file copilot reads hooks from. */
 function getCopilotSettingsPath() {
@@ -886,8 +892,32 @@ function buildCopilotHookEnvironment(worktreeId, instanceId, options = {}) {
         // one value that has to be *this* server's rather than the last one to
         // write the machine-global settings file.
         [exports.COPILOT_HOOK_PORT_ENV]: String(options.port ?? (0, env_1.getServerPort)()),
+        ...copilotHomePin(options),
     };
 }
+/**
+ * `COPILOT_HOME`, for the one case where copilot would otherwise read another
+ * home than the one {@link writeCopilotHookSettings} just wrote into (Issue #4210).
+ *
+ * A relative `COPILOT_HOME` is resolved against this process's cwd when the
+ * settings file is written (the daemon runs from the package root), while
+ * copilot runs in the worktree (`cli-tools/base.ts` `createLaunchPane`) and
+ * would resolve the same string there — another `settings.json`, or none, and
+ * no events. Pinning the absolute form makes the two the same file, as codex's
+ * launch pins `CODEX_HOME`.
+ *
+ * Only then. Unset or absolute, the environment is what it was before #4210;
+ * and an explicit {@link CopilotHookSettingsOptions.settingsPath} names a file
+ * that is not `<home>/settings.json`, so there is no home to pin.
+ */
+function copilotHomePin(options) {
+    if (options.settingsPath !== undefined)
+        return {};
+    const configured = process.env.COPILOT_HOME;
+    if (!configured || (0, path_1.isAbsolute)(configured))
+        return {};
+    return { COPILOT_HOME: getCopilotHomeDirectory() };
+}
 /**
  * Whether to inject at all.
  *

package/dist/server/src/lib/hooks/sources/launch-command.js

@@ -28,7 +28,7 @@
  * @module lib/hooks/sources/launch-command
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AGENT_LAUNCH_CONFIG_ENV_VARS = exports.SERVER_PORT_ENV_VAR = exports.AGENT_CORRELATION_ENV_VARS = exports.COMMANDMATE_HOOK_ENV_VARS = exports.HOOK_PORT_ENV_VAR = exports.AGENT_EVENT_URL_ENV_VAR = void 0;
+exports.AGENT_LAUNCH_CONDITIONAL_CONFIG_ENV_VARS = exports.AGENT_LAUNCH_CONFIG_ENV_VARS = exports.SERVER_PORT_ENV_VAR = exports.AGENT_CORRELATION_ENV_VARS = exports.COMMANDMATE_HOOK_ENV_VARS = exports.HOOK_PORT_ENV_VAR = exports.AGENT_EVENT_URL_ENV_VAR = void 0;
 exports.resolveAgentLaunchEnv = resolveAgentLaunchEnv;
 exports.renderAgentLaunchCommand = renderAgentLaunchCommand;
 const env_1 = require("../../../lib/env");
@@ -171,13 +171,18 @@ exports.SERVER_PORT_ENV_VAR = 'CM_PORT';
  *    behaviour. `tests/unit/security/child-process-server-port-2403.test.ts`
  *    asserts that with a real child process.
  *
- * **Still not `COPILOT_HOME` or `XDG_CONFIG_HOME`.** #1933's test carried a
- * local allowlist of `CODEX_HOME` / `COPILOT_HOME` / `XDG_CONFIG_HOME`;
- * building the seven plans shows only the first is ever written. `COPILOT_HOME` and `XDG_CONFIG_HOME` are
- * *read* from the ambient environment by `copilot/hook-settings` and the
- * antigravity config writer to decide where a file goes — they never reach
- * `plan.env`. An allowlist wide enough to admit them would wave through a source
- * that started setting one, which is the opposite of what this list is for.
+ * **Not `COPILOT_HOME` here, and never `XDG_CONFIG_HOME`.** #1933's test carried
+ * a local allowlist of `CODEX_HOME` / `COPILOT_HOME` / `XDG_CONFIG_HOME`.
+ * `XDG_CONFIG_HOME` is only ever *read* from the ambient environment to decide
+ * where a file goes and never reaches `plan.env`. `COPILOT_HOME` does since
+ * #4210, but only when the operator configured a *relative* one — copilot's
+ * launch then pins the absolute form so it reads the `settings.json` the server
+ * wrote — so it is declared on its own list,
+ * {@link AGENT_LAUNCH_CONDITIONAL_CONFIG_ENV_VARS}, rather than here: this list
+ * is what every default launch writes, and the drift guard holds a default
+ * launch to it exactly. An allowlist wide enough to admit a name a launch does
+ * not write would wave through a source that started setting one, which is the
+ * opposite of what this list is for.
  *
  * Enumerated for the same reason as the list above: so the drift guard can
  * subtract it and hold the remainder to an exact set.
@@ -186,6 +191,24 @@ exports.AGENT_LAUNCH_CONFIG_ENV_VARS = [
     'CODEX_HOME',
     exports.SERVER_PORT_ENV_VAR,
 ];
+/**
+ * Config a launch line carries only under a configuration, not by default
+ * (Issue #4210).
+ *
+ * `COPILOT_HOME`: written by copilot's launch environment
+ * (`copilot/hook-settings` `buildCopilotHookEnvironment`) only when the
+ * ambient `COPILOT_HOME` is relative, as the absolute path the hooks
+ * `settings.json` was written under — otherwise the server (cwd: package root)
+ * and copilot (cwd: the worktree) would resolve the same string to two homes.
+ * Unset or absolute, nothing is written and the launch line is what it was.
+ *
+ * Same kind as {@link AGENT_LAUNCH_CONFIG_ENV_VARS} — a per-tool config
+ * redirect, not an identity and not a credential, so it is kept for
+ * CommandMate's own children — and listed apart from it only so the drift
+ * guard can hold both cases exactly: the default launch to that list, and the
+ * relative-`COPILOT_HOME` launch to that list plus this one.
+ */
+exports.AGENT_LAUNCH_CONDITIONAL_CONFIG_ENV_VARS = ['COPILOT_HOME'];
 /**
  * The environment a launch line actually carries: the plan's own, plus this
  * server's port (Issue #2403).