commandmate 0.46.1 → 0.47.0

package/dist/server/src/lib/session/send-user-message.js

@@ -29,6 +29,10 @@
  *   8. clearInProgressMessageId
  *   9. startPolling                  — record the assistant response afterwards
  *
+ * Every attempt that reaches the ownership check also records how it ended —
+ * not-sent / sent / indeterminate — for `prompt --json`'s `lastSend` (Issue
+ * #3759, `./send-attempt-state`). Nothing is resent on any outcome.
+ *
  * Out of scope (kept in the HTTP layer / caller): request/body validation,
  * content trimming/size limits, imagePath validation, CLI-tool availability
  * and session-start (running) checks. The caller passes already-validated input.
@@ -48,6 +52,10 @@ const worktree_session_ownership_1 = require("../../lib/cli-tools/worktree-sessi
 const session_name_1 = require("../../lib/cli-tools/session-name");
 const prompt_waiting_guard_1 = require("../../lib/session/prompt-waiting-guard");
 const session_start_error_1 = require("../../lib/session/session-start-error");
+const cli_session_1 = require("../../lib/session/cli-session");
+const send_attempt_state_1 = require("../../lib/session/send-attempt-state");
+const composer_text_1 = require("../../lib/detection/composer-text");
+const status_capture_config_1 = require("../../config/status-capture-config");
 const opencode_1 = require("../../lib/cli-tools/opencode");
 const logger = (0, logger_1.createLogger)('session/send-user-message');
 function getErrorMessage(error) {
@@ -92,6 +100,28 @@ async function waitForPreviousTurnRecorded(worktreeId, resolvedInstanceId) {
     }
     return true;
 }
+/**
+ * Whether the composer still shows the message after a send whose submit was
+ * never confirmed (Issue #3759) — evidence that it is typed but unsent.
+ *
+ * Only for the composers `extractComposerText` has measured; any other tool,
+ * and any read that fails, answers false and the state stays
+ * `submit-unconfirmed`. Either way the state is `indeterminate`: a message in
+ * the composer is not one to type again.
+ */
+async function composerStillHolds(worktreeId, cliToolId, instanceId, content) {
+    if (!composer_text_1.SUPPORTED_COMPOSER_TOOLS.has(cliToolId))
+        return false;
+    try {
+        const output = await (0, cli_session_1.captureSessionOutputFresh)(worktreeId, cliToolId, status_capture_config_1.STATUS_CAPTURE_LINES, instanceId);
+        const read = (0, composer_text_1.extractComposerText)(output, cliToolId);
+        return read.state === 'content' && (0, send_attempt_state_1.composerHoldsMessage)(read.text, content);
+    }
+    catch (error) {
+        logger.warn('send-composer-residue-read-failed', { error: getErrorMessage(error) });
+        return false;
+    }
+}
 /**
  * Send a validated user message to the CLI tool and record it in history.
  *
@@ -111,6 +141,12 @@ async function sendUserMessage(db, params) {
      */
     const resolvedInstanceId = instanceId ?? cliToolId;
     const cliTool = manager_1.CLIToolManager.getInstance().getTool(cliToolId);
+    // Issue #3759: how this attempt left the message, kept for `lastSend` (and
+    // read back by the send route for its error). The result's shape is
+    // unchanged; recording never throws.
+    const settle = (state, reason) => {
+        (0, send_attempt_state_1.recordSendAttempt)({ worktreeId, cliToolId, instanceId: resolvedInstanceId }, { state, reason, content });
+    };
     // Issue #2865: the send route checks ownership itself, but the timer manager
     // and relay delivery reach tmux only through here. A session under this
     // worktree's name that was created in another directory belongs to another
@@ -119,6 +155,7 @@ async function sendUserMessage(db, params) {
     const sessionName = (0, session_name_1.resolveSessionName)(cliToolId, worktreeId, instanceId);
     const ownership = await (0, worktree_session_ownership_1.checkWorktreeSessionOwnership)(worktreeId, sessionName, db);
     if (ownership === null || ownership.verdict === 'foreign') {
+        settle('not-sent', 'foreign-session');
         logger.warn('send-refused-foreign-session', {
             worktreeId,
             cliToolId,
@@ -157,6 +194,7 @@ async function sendUserMessage(db, params) {
         ignoreStructured: params.ignoreStructuredPromptGuard,
     });
     if (promptGuard.waiting) {
+        settle('not-sent', 'prompt-waiting');
         logger.info('send-refused-prompt-waiting', {
             worktreeId,
             cliToolId,
@@ -194,6 +232,7 @@ async function sendUserMessage(db, params) {
         }
         catch (error) {
             logger.error('failed-to-send-model-command:', { error: getErrorMessage(error) });
+            settle('not-sent', 'model-switch-failed');
             return { ok: false, stage: 'model', error: getErrorMessage(error) };
         }
         // Issue #2630: copilot is idle now, and if the previous turn ended during the
@@ -314,11 +353,18 @@ async function sendUserMessage(db, params) {
     }
     catch (error) {
         logger.error('failed-to-send-message-to:', { error: getErrorMessage(error) });
+        // Issue #3759: not-sent only when the error says the body was never typed.
+        let failure = (0, send_attempt_state_1.classifySendFailure)(error);
+        if (failure.reason === 'submit-unconfirmed' && (await composerStillHolds(worktreeId, cliToolId, instanceId, content))) {
+            failure = { state: 'indeterminate', reason: 'composer-residue' };
+        }
+        settle(failure.state, failure.reason);
         if ((0, session_start_error_1.isSessionStartTimeoutError)(error)) {
             return { ok: false, stage: 'send', error: error.message, code: session_start_error_1.SESSION_STARTING_CODE };
         }
         return { ok: false, stage: 'send', error: getErrorMessage(error) };
     }
+    settle('sent', 'submitted');
     // 5. Create user message in database (History source: chat_messages).
     const message = (0, db_1.createMessage)(db, {
         worktreeId,

package/dist/server/src/lib/session/worktree-session-reconcile.js

@@ -533,7 +533,8 @@ function migrateRuntimeState(db, renames, result) {
         if (!runningAutoYesPollers.has(move.oldKey))
             continue;
         try {
-            (0, auto_yes_manager_1.stopAutoYesPolling)(move.oldKey);
+            // Issue #3730: a move, not a release — the grant goes on under newKey.
+            (0, auto_yes_manager_1.stopAutoYesPolling)(move.oldKey, 'worktree-id-migrated');
             restarts.push(move);
         }
         catch (error) {

package/dist/server/src/lib/tmux/session-created-signal.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * "A tmux session of this name was just created" (Issue #3796).
+ *
+ * The Auto-Yes poller that found no session waits `MAX_BACKOFF_MS` for its next
+ * tick, and the push gate holds a prompt wait until that tick (#3791), so a
+ * session created right after the poller looked was answered — or its human
+ * notified — up to about 64 s late. {@link createSession} reports every session
+ * it creates here, and a waiting poller listens for its own session's name and
+ * ticks early.
+ *
+ * Synchronous and dependency-free on purpose: `tmux.ts` is the lowest layer and
+ * must not import the poller (it would be a cycle). A listener that throws is
+ * isolated from the others and from the session creation that fired it.
+ *
+ * @module lib/tmux/session-created-signal
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onTmuxSessionCreated = onTmuxSessionCreated;
+exports.notifyTmuxSessionCreated = notifyTmuxSessionCreated;
+exports.countTmuxSessionCreatedListeners = countTmuxSessionCreatedListeners;
+exports.clearTmuxSessionCreatedListeners = clearTmuxSessionCreatedListeners;
+const global_state_1 = require("../global-state");
+/**
+ * sessionName -> listeners. globalThis for the reason every shared in-memory
+ * state is (#1736): the creator (a route bundle) and the poller (the server's)
+ * can hold separate copies of this module.
+ */
+const listeners = (0, global_state_1.getOrInitGlobal)('__tmuxSessionCreatedListeners', () => new Map());
+/**
+ * Call `listener` the next time a session named `sessionName` is created.
+ *
+ * @returns Unsubscribe; calling it more than once does nothing
+ */
+function onTmuxSessionCreated(sessionName, listener) {
+    let set = listeners.get(sessionName);
+    if (set === undefined) {
+        set = new Set();
+        listeners.set(sessionName, set);
+    }
+    set.add(listener);
+    return () => {
+        const current = listeners.get(sessionName);
+        if (current === undefined)
+            return;
+        current.delete(listener);
+        if (current.size === 0)
+            listeners.delete(sessionName);
+    };
+}
+/** Tell the listeners of `sessionName` that it was created. Each one is called once and dropped. */
+function notifyTmuxSessionCreated(sessionName) {
+    const set = listeners.get(sessionName);
+    if (set === undefined)
+        return;
+    listeners.delete(sessionName);
+    for (const listener of set) {
+        try {
+            listener();
+        }
+        catch {
+            // A listener's failure must not fail the session creation that fired it.
+        }
+    }
+}
+/** Number of sessions someone is waiting for. Test seam. */
+function countTmuxSessionCreatedListeners() {
+    let n = 0;
+    for (const set of listeners.values())
+        n += set.size;
+    return n;
+}
+/** Drop every listener. Test seam. */
+function clearTmuxSessionCreatedListeners() {
+    listeners.clear();
+}

package/dist/server/src/lib/tmux/tmux-capture-cache.js

@@ -21,6 +21,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CACHE_MAX_CAPTURE_LINES = exports.CACHE_MAX_ENTRIES = exports.CACHE_TTL_MS = void 0;
 exports.isCaptureWindowSaturated = isCaptureWindowSaturated;
+exports.getCaptureGeneration = getCaptureGeneration;
+exports.isCaptureGenerationCurrent = isCaptureGenerationCurrent;
 exports.sliceOutput = sliceOutput;
 exports.getCachedCapture = getCachedCapture;
 exports.setCachedCapture = setCachedCapture;
@@ -85,6 +87,37 @@ function getCache() {
 function getInflight() {
     return (0, global_state_1.getOrInitGlobal)('__tmuxCaptureCacheInflight', () => new Map());
 }
+function getGenerationState() {
+    return (0, global_state_1.getOrInitGlobal)('__tmuxCaptureCacheGeneration', () => ({ global: 0, sessions: new Map() }));
+}
+// =========================================================================
+// getCaptureGeneration() / isCaptureGenerationCurrent()
+// =========================================================================
+/**
+ * Take the invalidation generation for a session before starting a capture
+ * (Issue #3734). Pass it to isCaptureGenerationCurrent() after the await.
+ *
+ * @param sessionName - tmux session name
+ * @returns Generation snapshot
+ */
+function getCaptureGeneration(sessionName) {
+    const state = getGenerationState();
+    return { global: state.global, session: state.sessions.get(sessionName) ?? 0 };
+}
+/**
+ * Whether no invalidateCache(sessionName) / clearAllCache() ran since the
+ * snapshot was taken (Issue #3734). A capture that started before the
+ * invalidation may show the screen from before a send, so it must not be
+ * written back to the cache.
+ *
+ * @param sessionName - tmux session name
+ * @param generation - Snapshot from getCaptureGeneration()
+ * @returns True when the capture may be written back
+ */
+function isCaptureGenerationCurrent(sessionName, generation) {
+    const current = getCaptureGeneration(sessionName);
+    return current.global === generation.global && current.session === generation.session;
+}
 // =========================================================================
 // sliceOutput()
 // =========================================================================
@@ -183,6 +216,9 @@ function setCachedCapture(sessionName, output, capturedLines) {
 // =========================================================================
 /**
  * Invalidate cache for a specific session.
+ * Issue #3734: also advances the session's generation and drops its inflight
+ * entry, so a capture started before the invalidation is neither written back
+ * nor joined by callers that arrive after it (they start a fresh capture).
  * [SEC4-006] Logs debug message with session name for troubleshooting.
  *
  * @param sessionName - tmux session name to invalidate
@@ -190,6 +226,9 @@ function setCachedCapture(sessionName, output, capturedLines) {
 function invalidateCache(sessionName) {
     const cache = getCache();
     cache.delete(sessionName);
+    const generations = getGenerationState().sessions;
+    generations.set(sessionName, (generations.get(sessionName) ?? 0) + 1);
+    getInflight().delete(sessionName);
     // [SEC4-006] Debug log for cache invalidation chain tracking
     logger.debug('cache:invalidate', { sessionName });
 }
@@ -197,14 +236,20 @@ function invalidateCache(sessionName) {
 // clearAllCache()
 // =========================================================================
 /**
- * Clear all cache entries and inflight requests.
- * Used for graceful shutdown.
+ * Clear all cache entries and inflight requests for every session.
+ * Called at the start of a worktree's session cleanup (session-cleanup.ts).
+ * Issue #3734: advances the global generation so captures started before the
+ * clear are not written back. Per-session counts are dropped here because the
+ * global generation alone already tells every older snapshot apart.
  */
 function clearAllCache() {
     const cache = getCache();
     cache.clear();
     const inflight = getInflight();
     inflight.clear();
+    const state = getGenerationState();
+    state.global += 1;
+    state.sessions.clear();
 }
 // =========================================================================
 // resetCacheForTesting()
@@ -216,6 +261,7 @@ function clearAllCache() {
 function resetCacheForTesting() {
     globalThis.__tmuxCaptureCache = undefined;
     globalThis.__tmuxCaptureCacheInflight = undefined;
+    globalThis.__tmuxCaptureCacheGeneration = undefined;
 }
 // =========================================================================
 // getOrFetchCapture() - singleflight pattern
@@ -247,18 +293,24 @@ async function getOrFetchCapture(sessionName, requestedLines, fetchFn) {
         return sliceOutput(result, requestedLines);
     }
     // 3. Create new fetch promise
+    // Issue #3734: snapshot the generation before fetchFn() starts
+    const generation = getCaptureGeneration(sessionName);
     const fetchPromise = fetchFn();
     inflight.set(sessionName, fetchPromise);
     try {
         const output = await fetchPromise;
-        // Cache non-empty results only [SEC4-007]
-        if (output.length > 0) {
+        // Cache non-empty results only [SEC4-007], and only when no invalidation
+        // happened while waiting (Issue #3734)
+        if (output.length > 0 && isCaptureGenerationCurrent(sessionName, generation)) {
             setCachedCapture(sessionName, output, exports.CACHE_MAX_CAPTURE_LINES);
         }
         return sliceOutput(output, requestedLines);
     }
     finally {
-        // Clean up inflight entry
-        inflight.delete(sessionName);
+        // Clean up inflight entry, unless an invalidation already replaced it
+        // with a newer fetch (Issue #3734)
+        if (inflight.get(sessionName) === fetchPromise) {
+            inflight.delete(sessionName);
+        }
     }
 }

package/dist/server/src/lib/tmux/tmux.js

@@ -31,6 +31,7 @@ const util_1 = require("util");
 const tmux_capture_cache_1 = require("./tmux-capture-cache");
 const geometry_delegation_1 = require("./geometry-delegation");
 const legacy_session_alias_1 = require("./legacy-session-alias");
+const session_created_signal_1 = require("./session-created-signal");
 const validation_1 = require("../../lib/cli-tools/validation");
 const tmux_pane_config_1 = require("../../config/tmux-pane-config");
 const logger_1 = require("../../lib/logger");
@@ -449,6 +450,9 @@ async function createSession(sessionNameOrOptions, cwd) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         throw new Error(`Failed to create tmux session: ${errorMessage}`);
     }
+    // Issue #3796: an Auto-Yes poller waiting for this session ticks now rather
+    // than a backoff later. Outside the try: a listener cannot fail the creation.
+    (0, session_created_signal_1.notifyTmuxSessionCreated)(sessionName);
 }
 /**
  * Send keys to a tmux session

package/dist/server/src/lib/verification/scope-gate-format.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * `log_tail` formatting for the built-in `scope` gate (Issue #3647: split out of
+ * scope-gate.ts, which re-exports everything public here).
+ *
+ * @module lib/verification/scope-gate-format
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCOPE_PATTERN_ARROW = exports.MAX_REPORTED_VIOLATIONS = void 0;
+exports.formatPatterns = formatPatterns;
+exports.formatDecidedPath = formatDecidedPath;
+exports.formatAdmitted = formatAdmitted;
+exports.formatAgentStateExcluded = formatAgentStateExcluded;
+exports.formatOrchestratorExcluded = formatOrchestratorExcluded;
+/**
+ * Violations listed in `log_tail` before the rest are summarised as a count.
+ *
+ * A worker that ran in the wrong directory can put thousands of paths out of
+ * scope, and log_tail is stored per gate in SQLite.
+ */
+exports.MAX_REPORTED_VIOLATIONS = 100;
+/**
+ * Separator between a reported path and the pattern that decided it (#1841).
+ *
+ * Mirrored by the CLI's scope-evidence parser (`src/cli/commands/verify.ts`,
+ * SCOPE_PATTERN_ARROW): the gate's report is the only carrier for this evidence
+ * — `verification_gate_results` has columns for a status, an exit code and a log
+ * body, and nothing else — so the two constants have to agree. A round-trip
+ * test feeds a real `evaluateScope` report through that parser rather than
+ * trusting the two copies to be edited together.
+ *
+ * A path containing this exact three-character sequence would split wrongly on
+ * the way back. Nothing prevents such a filename; it is accepted because the
+ * alternative — encoding paths in a log a human reads first — costs every
+ * reader something to protect against a file no repository has.
+ */
+exports.SCOPE_PATTERN_ARROW = '  \u2190 ';
+function formatPatterns(patterns) {
+    return patterns.length > 0 ? patterns.join(', ') : '(none)';
+}
+/**
+ * One reported path, optionally naming the rule that decided it (#1841).
+ *
+ * Admitted paths lead with `+` rather than `-` so the two sections cannot be
+ * confused by a reader — or by a grep — that has only one line in front of it.
+ */
+function formatDecidedPath(marker, path, pattern) {
+    if (pattern === null)
+        return `  ${marker} ${path}`;
+    return `  ${marker} ${path}${exports.SCOPE_PATTERN_ARROW}${pattern}`;
+}
+/**
+ * The `admitted:` section: what this run was allowed to change, and by which
+ * rule (#1841).
+ *
+ * With an `allow` of exact paths the pattern *is* the file and this adds
+ * nothing, but #1546 made globs legal, and `src/**` leaves no record of what it
+ * actually covered on the day it ran. The contract is the claim; this is the
+ * evidence for it, and it has to survive in `log_tail` because the run's own
+ * working tree will have moved on by the time anyone asks.
+ *
+ * Capped by the same rule as the violations, for the same reason (log_tail is
+ * stored per gate in SQLite), and the truncation is stated rather than silent —
+ * a list that stops at 100 with no marker reads as a complete one.
+ */
+function formatAdmitted(admitted) {
+    if (admitted.length === 0)
+        return [];
+    const listed = admitted.slice(0, exports.MAX_REPORTED_VIOLATIONS);
+    const remainder = admitted.length - listed.length;
+    return [
+        'admitted:',
+        ...listed.map((entry) => formatDecidedPath('+', entry.path, entry.pattern)),
+        // Worded `(+N more)` rather than the violations' `... and N more`: the two
+        // sections are capped independently and a reader scanning a truncated
+        // report should not have to work out which count belongs to which list.
+        ...(remainder > 0 ? [`  ... (+${remainder} more)`] : []),
+    ];
+}
+/** The `excluded:` section naming agent-managed state files left out (#3126). */
+function formatAgentStateExcluded(excluded) {
+    if (excluded.length === 0)
+        return [];
+    const listed = excluded.slice(0, exports.MAX_REPORTED_VIOLATIONS);
+    const remainder = excluded.length - listed.length;
+    return [
+        'excluded (agent-managed state files, not counted as change):',
+        ...listed.map((path) => `  ~ ${path}`),
+        ...(remainder > 0 ? [`  ... (+${remainder} more)`] : []),
+    ];
+}
+/** The `excluded:` section naming orchestrator-only committed paths (#3588). */
+function formatOrchestratorExcluded(excluded) {
+    if (excluded.length === 0)
+        return [];
+    return [
+        'excluded (changed only by orchestrator commits, not counted as change):',
+        ...excluded.map((path) => `  ~ ${path}`),
+    ];
+}

package/dist/server/src/lib/verification/scope-gate-glob.js

@@ -0,0 +1,185 @@
+"use strict";
+/**
+ * Scope glob matching for the built-in `scope` gate (Issue #3647: split out of
+ * scope-gate.ts, which re-exports everything public here).
+ *
+ * @module lib/verification/scope-gate-glob
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScopeMatcher = exports.SCOPE_EXEMPT_CONTRACT_PATH = exports.SCOPE_EXEMPT_ALWAYS_ALLOWED = exports.ALWAYS_ALLOWED_PREFIX = void 0;
+/**
+ * Paths that are in scope no matter what the contract says.
+ *
+ * The contract file lives here, so a contract whose own `allow` list forgot to
+ * mention `.commandmate/` would fail the moment it was committed — the scope
+ * declaration would make its own storage a violation. The exemption covers the
+ * `allow` requirement only; an explicit `deny` still applies, because a deny is
+ * a deliberate prohibition and silently ignoring one is worse than the accident
+ * this exemption prevents.
+ */
+exports.ALWAYS_ALLOWED_PREFIX = '.commandmate/';
+/**
+ * Stand-ins for the two ways a path is admitted without matching `allow`.
+ *
+ * Parenthesised so they cannot be mistaken for a pattern the contract declared:
+ * a reader who greps the contract for `(exempt: .commandmate/)` should find
+ * nothing, because nothing there put it in scope.
+ */
+exports.SCOPE_EXEMPT_ALWAYS_ALLOWED = `(exempt: ${exports.ALWAYS_ALLOWED_PREFIX})`;
+exports.SCOPE_EXEMPT_CONTRACT_PATH = '(exempt: contract path)';
+// =============================================================================
+// Glob matching
+// =============================================================================
+/**
+ * Translate a scope glob into an anchored regular expression.
+ *
+ * Deliberately a small, documented subset rather than a glob library. The
+ * semantics are fixed in docs/design/task-contract.md §2.2:
+ *
+ * - `**` as a whole path segment crosses directory boundaries, including zero of
+ *   them: `a/**` matches `a/b` and `a/b/c`, `**\/*.ts` matches `x.ts`.
+ * - `*` and `?` never cross `/`. Leading dots are ordinary characters, so
+ *   `.github/**` and `*.md` behave the way they read.
+ * - `{a,b}` is alternation, nestable. Unbalanced braces are literal, as in a
+ *   shell — `src/{a` is a path with a brace in it, not a syntax error.
+ * - `[` and `]` are **literal**. This repository routes through
+ *   `src/app/proxy/[...path]/`, and treating those as character classes would
+ *   make the pattern that names them match nothing at all — a silent no-match is
+ *   the failure mode this gate exists to avoid.
+ * - A pattern that matches a directory also matches everything beneath it, so
+ *   `src/lib`, `src/lib/` and `src/lib/**` all mean the same thing. Without this
+ *   rule, `allow: ["src/lib/verification"]` — the way people write a directory —
+ *   would put every file inside it out of scope.
+ */
+function globToRegExp(rawPattern) {
+    // A trailing slash carries no information once the rule above applies.
+    const pattern = rawPattern.replace(/\/+$/, '');
+    const bracesBalanced = hasBalancedBraces(pattern);
+    let source = '';
+    let depth = 0;
+    let i = 0;
+    while (i < pattern.length) {
+        const char = pattern[i];
+        if (char === '*') {
+            let end = i;
+            while (pattern[end] === '*')
+                end += 1;
+            const isGlobstar = end - i > 1;
+            const atSegmentStart = i === 0 || pattern[i - 1] === '/';
+            if (isGlobstar && atSegmentStart && pattern[end] === '/') {
+                // Consume the following slash too: `a/**/b` has to match `a/b`.
+                source += '(?:[^/]*/)*';
+                i = end + 1;
+                continue;
+            }
+            if (isGlobstar && atSegmentStart && end === pattern.length) {
+                source += '.*';
+                i = end;
+                continue;
+            }
+            // `**` that is not a whole segment (`a**b`) cannot mean "cross
+            // directories" without also matching `a/x/b`, which the pattern does not
+            // say. Collapse it to a single-segment wildcard.
+            source += '[^/]*';
+            i = end;
+            continue;
+        }
+        if (char === '?') {
+            source += '[^/]';
+            i += 1;
+            continue;
+        }
+        if (bracesBalanced && char === '{') {
+            depth += 1;
+            source += '(?:';
+            i += 1;
+            continue;
+        }
+        if (bracesBalanced && char === '}' && depth > 0) {
+            depth -= 1;
+            source += ')';
+            i += 1;
+            continue;
+        }
+        if (bracesBalanced && char === ',' && depth > 0) {
+            source += '|';
+            i += 1;
+            continue;
+        }
+        source += char.replace(/[.*+?^${}()|[\]\\]/, '\\$&');
+        i += 1;
+    }
+    return new RegExp(`^${source}(?:/.*)?$`);
+}
+function hasBalancedBraces(pattern) {
+    let depth = 0;
+    for (const char of pattern) {
+        if (char === '{')
+            depth += 1;
+        else if (char === '}') {
+            depth -= 1;
+            if (depth < 0)
+                return false;
+        }
+    }
+    return depth === 0;
+}
+function compilePattern(pattern) {
+    return { pattern, regexp: globToRegExp(pattern) };
+}
+/**
+ * A scope declaration compiled once per run.
+ *
+ * Compiling per pattern per file would rebuild the same regexes for every one of
+ * potentially thousands of changed paths.
+ */
+class ScopeMatcher {
+    contractPath;
+    allow;
+    deny;
+    /**
+     * @param contractPath the contract's own path, exempted alongside
+     *        {@link ALWAYS_ALLOWED_PREFIX} for contracts kept outside `.commandmate/`
+     */
+    constructor(scope, contractPath = null) {
+        this.contractPath = contractPath;
+        this.allow = scope.allow.map(compilePattern);
+        this.deny = scope.deny.map(compilePattern);
+    }
+    /**
+     * Which declared rule decided `path`, and which way (#1841).
+     *
+     * The **first** matching pattern is reported, in the contract's declaration
+     * order, on both sides. Reporting the last would name a rule the reader
+     * cannot use: `allow: ["src/**", "src/lib/**"]` admits `src/lib/a.ts` under
+     * the first entry, and deleting the second changes nothing about the verdict.
+     *
+     * `path` is a repository-root-relative POSIX path as git reports it.
+     */
+    classify(path) {
+        const denied = this.deny.find((entry) => entry.regexp.test(path));
+        if (denied)
+            return { admitted: false, pattern: denied.pattern };
+        if (path.startsWith(exports.ALWAYS_ALLOWED_PREFIX)) {
+            return { admitted: true, pattern: exports.SCOPE_EXEMPT_ALWAYS_ALLOWED };
+        }
+        if (path === this.contractPath) {
+            return { admitted: true, pattern: exports.SCOPE_EXEMPT_CONTRACT_PATH };
+        }
+        const allowed = this.allow.find((entry) => entry.regexp.test(path));
+        return allowed
+            ? { admitted: true, pattern: allowed.pattern }
+            : { admitted: false, pattern: null };
+    }
+    /**
+     * Whether `path` is a scope violation.
+     *
+     * Delegates to {@link classify} rather than repeating the rules: the verdict
+     * and the evidence for it must never be able to disagree, and two copies of
+     * "deny wins, then the exemptions, then allow" is exactly how they would.
+     */
+    isViolation(path) {
+        return !this.classify(path).admitted;
+    }
+}
+exports.ScopeMatcher = ScopeMatcher;