commandmate 0.19.0 → 0.20.0

package/dist/server/src/lib/git/worktree-redirect.js

@@ -0,0 +1,155 @@
+"use strict";
+/**
+ * Turning `/worktrees/<historical id>` into a **real** HTTP redirect
+ * (Issue #1621 Phase 2 follow-up, owned by #1645).
+ *
+ * ## Why this exists rather than the layout redirect #1644 shipped
+ *
+ * `src/app/worktrees/[id]/layout.tsx` calls `permanentRedirect`, and measured
+ * against a real server that returns
+ *
+ *     HTTP/1.1 200 OK
+ *     <meta id="__next-page-redirect" http-equiv="refresh" content="0;url=…">
+ *
+ * — not a 301. That is App Router behaviour, not a bug in that layout: an
+ * unconditional `permanentRedirect` as the layout's very first statement
+ * produces the same 200 + meta tag. A redirect thrown while a page's HTML is
+ * already streaming can no longer set a status line, so it ships inside the
+ * document. Only Route Handlers, Server Actions and middleware emit a real 3xx.
+ *
+ * `middleware.ts` is not an option either: it runs on the edge runtime, where
+ * the SQLite lookup this needs is impossible. That leaves the custom
+ * `server.ts`, which sees the request before Next does — hence this module,
+ * which `server.ts` loads lazily and asks about each `/worktrees/…` URL.
+ *
+ * The layout redirect stays as a fallback for anything serving the app without
+ * `server.ts`; when `server.ts` is in front it never sees a historical ID.
+ *
+ * ## Two things the layout could not do, and this does
+ *
+ * 1. **A status code.** A meta refresh is followed by browsers and by nothing
+ *    else — no bookmark rewrite, no non-browser client, no `curl -I`.
+ * 2. **Sub-paths.** A layout cannot see the path below it, so
+ *    `/worktrees/<old>/terminal` landed on the worktree's detail page. Here the
+ *    tail of the path and the query string are carried across verbatim.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKTREE_REDIRECT_CACHE_CONTROL = exports.WORKTREE_REDIRECT_STATUS = void 0;
+exports.parseWorktreeUrl = parseWorktreeUrl;
+exports.resolveWorktreeRedirect = resolveWorktreeRedirect;
+const db_instance_1 = require("../../lib/db/db-instance");
+const worktree_alias_db_1 = require("../../lib/db/worktree-alias-db");
+const path_validator_1 = require("../../lib/security/path-validator");
+/**
+ * Status code used for the redirect.
+ *
+ * 308 rather than 301 because it is the method-preserving permanent redirect:
+ * `/worktrees/<id>` is a page route today, but a Server Action POSTs to the URL
+ * of the page it is on, and 301 historically licenses clients to turn that into
+ * a GET.
+ *
+ * Paired with `Cache-Control: no-store` at the call site — see
+ * {@link WORKTREE_REDIRECT_CACHE_CONTROL}.
+ */
+exports.WORKTREE_REDIRECT_STATUS = 308;
+/**
+ * Cache directive sent with the redirect.
+ *
+ * A permanent redirect is cacheable by default, and here that would be wrong:
+ * "old ID → this worktree" is durable but not eternal. Delete the worktree and
+ * its aliases cascade away; a later directory with the same basename can then
+ * be minted that ID as a **live** one, and live rows beat aliases. A client
+ * holding a cached permanent redirect would never ask again and would keep
+ * landing on the wrong worktree. The status code still says "moved" to anything
+ * reading it; only the caching of that answer is refused.
+ */
+exports.WORKTREE_REDIRECT_CACHE_CONTROL = 'no-store';
+/**
+ * `/worktrees/<id>` optionally followed by more path.
+ *
+ * Anchored at the start so nothing else can match, and the ID segment excludes
+ * `/`, `?` and `#` so the split is unambiguous. `/worktrees` on its own does not
+ * match — there is no such page, and there is no ID to resolve.
+ */
+const WORKTREE_URL_PATTERN = /^\/worktrees\/([^/?#]+)(\/[^?#]*)?/;
+/**
+ * Split a request URL into the parts a redirect has to rebuild.
+ *
+ * Pure and total: returns null for anything that is not a `/worktrees/<id>` URL.
+ *
+ * @param requestUrl - `req.url`, i.e. an origin-form path with optional query
+ */
+function parseWorktreeUrl(requestUrl) {
+    if (!requestUrl)
+        return null;
+    // Fragments never reach a server, but a malformed client could send one.
+    const hashIndex = requestUrl.indexOf('#');
+    const withoutHash = hashIndex === -1 ? requestUrl : requestUrl.slice(0, hashIndex);
+    const queryIndex = withoutHash.indexOf('?');
+    const pathname = queryIndex === -1 ? withoutHash : withoutHash.slice(0, queryIndex);
+    const search = queryIndex === -1 ? '' : withoutHash.slice(queryIndex);
+    const match = WORKTREE_URL_PATTERN.exec(pathname);
+    if (!match)
+        return null;
+    let id;
+    try {
+        id = decodeURIComponent(match[1]);
+    }
+    catch {
+        // Malformed percent-encoding: not a URL we can reason about. Hand it to
+        // Next, which will 404 it as it does today.
+        return null;
+    }
+    return { id, subPath: match[2] ?? '', search };
+}
+/**
+ * Map a worktree ID that may be historical onto the ID that is current.
+ *
+ * Total by construction: any failure — an unmigrated database, an unreadable
+ * one, no alias table — degrades to "no redirect", which is exactly today's
+ * behaviour.
+ */
+function canonicalWorktreeIdFromDb(id) {
+    try {
+        const db = (0, db_instance_1.getDbInstance)();
+        return (0, worktree_alias_db_1.resolveWorktreeIdWithAlias)(db, id) ?? id;
+    }
+    catch {
+        return id;
+    }
+}
+/**
+ * Decide whether a URL names a worktree by a historical ID, and where it should
+ * go instead.
+ *
+ * @param requestUrl - `req.url` verbatim
+ * @param canonicalize - ID resolver; defaults to the alias table. Injectable so
+ *   the unit tests can state the mapping instead of building a database.
+ * @returns The redirect to write, or null to let Next handle the request
+ */
+function resolveWorktreeRedirect(requestUrl, canonicalize = canonicalWorktreeIdFromDb) {
+    const parsed = parseWorktreeUrl(requestUrl);
+    if (!parsed)
+        return null;
+    // An ID that cannot be valid is not a historical ID either; let the route
+    // report what the caller actually sent (Issue #1644's `canonicalWorktreeId`
+    // makes the same choice for the same reason).
+    if (!(0, path_validator_1.isValidWorktreeId)(parsed.id))
+        return null;
+    let canonicalId;
+    try {
+        canonicalId = canonicalize(parsed.id);
+    }
+    catch {
+        return null;
+    }
+    if (!canonicalId || canonicalId === parsed.id)
+        return null;
+    return {
+        statusCode: exports.WORKTREE_REDIRECT_STATUS,
+        // The ID is re-encoded (it is a single segment we just decoded); `subPath`
+        // and `search` are carried across byte-for-byte, because they arrived
+        // already encoded and re-encoding would corrupt them.
+        location: `/worktrees/${encodeURIComponent(canonicalId)}${parsed.subPath}${parsed.search}`,
+    };
+}

package/dist/server/src/lib/git/worktrees.js

@@ -7,11 +7,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveWorktreeId = void 0;
 exports.generateWorktreeId = generateWorktreeId;
 exports.parseWorktreeOutput = parseWorktreeOutput;
 exports.getRepositoryPaths = getRepositoryPaths;
 exports.scanWorktrees = scanWorktrees;
 exports.scanMultipleRepositories = scanMultipleRepositories;
+exports.deriveIdIgnoringOwnHistory = deriveIdIgnoringOwnHistory;
 exports.syncWorktreesToDB = syncWorktreesToDB;
 exports.repositoryExistsOnDisk = repositoryExistsOnDisk;
 exports.pruneStaleRepositoryWorktrees = pruneStaleRepositoryWorktrees;
@@ -19,12 +21,32 @@ const child_process_1 = require("child_process");
 const util_1 = require("util");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const worktree_id_1 = require("./worktree-id");
 const db_1 = require("../../lib/db");
 const logger_1 = require("../../lib/logger");
 const logger = (0, logger_1.createLogger)('worktrees');
+/**
+ * ID minting lives in `worktree-id.ts` — a module that imports nothing but
+ * `crypto` and `path`. A migration has to mint IDs too (the Phase 4 renumbering
+ * in #1645), and importing THIS module from one would close a cycle through
+ * `@/lib/db` and inherit every `vi.mock('@/lib/git/worktrees')` in the suite.
+ * Re-exported here so existing callers are unaffected.
+ */
+var worktree_id_2 = require("./worktree-id");
+Object.defineProperty(exports, "deriveWorktreeId", { enumerable: true, get: function () { return worktree_id_2.deriveWorktreeId; } });
 /**
  * Generate URL-safe ID from repository name and branch name
  *
+ * @deprecated Issue #1621/#1644: worktree IDs are no longer derived from the
+ * branch. A branch-derived ID changes whenever the branch changes, so checking
+ * out a different branch in the *same* directory renamed the worktree's primary
+ * key and broke everything keyed on it outside the DB (tmux session names, open
+ * tabs, bookmarks, poller/Auto-Yes keys). IDs are now derived from the directory
+ * once — see {@link deriveWorktreeId} — and never re-derived.
+ *
+ * Retained only so an out-of-tree caller keeps compiling; nothing in `src/`
+ * calls it any more.
+ *
  * @param branchName - Git branch name (e.g., "feature/foo", "main")
  * @param repositoryName - Repository name (e.g., "MyRepo")
  * @returns URL-safe ID (e.g., "myrepo-feature-foo", "myrepo-main")
@@ -40,14 +62,9 @@ function generateWorktreeId(branchName, repositoryName) {
     if (!branchName) {
         return '';
     }
-    const sanitize = (str) => str
-        .toLowerCase()
-        .replace(/[^a-z0-9-]/g, '-') // Replace non-alphanumeric (except hyphen) with hyphen
-        .replace(/-+/g, '-') // Replace consecutive hyphens with single hyphen
-        .replace(/^-|-$/g, ''); // Remove leading/trailing hyphens
-    const sanitizedBranch = sanitize(branchName);
+    const sanitizedBranch = (0, worktree_id_1.sanitizeIdSegment)(branchName);
     if (repositoryName) {
-        const sanitizedRepo = sanitize(repositoryName);
+        const sanitizedRepo = (0, worktree_id_1.sanitizeIdSegment)(repositoryName);
         return `${sanitizedRepo}-${sanitizedBranch}`;
     }
     return sanitizedBranch;
@@ -132,6 +149,22 @@ function getRepositoryPaths() {
 /**
  * Scan git worktrees in a single repository
  *
+ * Issue #1621: the `id` on each returned object is a **provisional** suggestion,
+ * not the worktree's identity. The scan cannot know which IDs are already taken
+ * (it sees one repository, IDs are global) and — more importantly — it must not
+ * decide the ID of a directory that is already registered. {@link syncWorktreesToDB}
+ * is what confirms an ID: it keeps the existing row's ID when the path is known,
+ * and only falls back to this suggestion (or re-derives) for a new path.
+ *
+ * The field is still populated, rather than dropped from the type, because two
+ * callers outside this change's reach — `POST /api/repositories/scan`,
+ * `POST /api/repositories/restore` and `syncWorktreesAndCleanup`
+ * (`src/lib/session-cleanup.ts`) — are typed on `Worktree[]`.
+ *
+ * `name` is the **display branch name** and is refreshed on every sync; for a
+ * detached HEAD it is `detached-<short sha>` (see {@link parseWorktreeOutput}).
+ * Neither `name` nor `branch` participates in the ID any more.
+ *
  * @param rootDir - Root directory to scan for worktrees
  * @returns Array of Worktree objects
  *
@@ -140,7 +173,7 @@ function getRepositoryPaths() {
  * @example
  * ```typescript
  * const worktrees = await scanWorktrees('/path/to/repo');
- * console.log(worktrees[0].id); // => "main"
+ * console.log(worktrees[0].path); // => "/path/to/repo"
  * ```
  */
 async function scanWorktrees(rootDir) {
@@ -155,16 +188,21 @@ async function scanWorktrees(rootDir) {
         const repositoryName = path_1.default.basename(repositoryPath);
         // Filter and validate worktree paths
         return parsed
-            .map((wt) => ({
-            id: generateWorktreeId(wt.branch, repositoryName),
-            name: wt.branch,
-            // Issue #1003: persist the real branch (sync-time snapshot) so
-            // `ls --branch` can filter on it rather than the derived name/id slug.
-            branch: wt.branch,
-            path: path_1.default.resolve(wt.path),
-            repositoryPath,
-            repositoryName,
-        }))
+            .map((wt) => {
+            const resolvedPath = path_1.default.resolve(wt.path);
+            return {
+                // Provisional only — syncWorktreesToDB decides the real ID (see above).
+                id: (0, worktree_id_1.deriveWorktreeId)(resolvedPath),
+                // Display branch name (Issue #1621): re-read from git on every scan.
+                name: wt.branch,
+                // Issue #1003: persist the real branch (sync-time snapshot) so
+                // `ls --branch` can filter on it rather than the derived name/id slug.
+                branch: wt.branch,
+                path: resolvedPath,
+                repositoryPath,
+                repositoryName,
+            };
+        })
             .filter((wt) => {
             // Git worktrees can be outside the repo root, so we use a more lenient validation
             // Only filter out obviously dangerous system paths
@@ -232,13 +270,50 @@ async function scanMultipleRepositories(repositoryPaths) {
     }
     return allWorktrees;
 }
+/**
+ * Mint an ID for `resolvedPath` without letting the path's **own** history block
+ * it (Issue #1658).
+ *
+ * `takenIds` holds every live ID plus every alias, which is right for a path
+ * nobody has seen before. For a path that IS already registered it is exactly
+ * wrong: its own current ID sits in that set, and so does every ID it has ever
+ * been renamed away from. `deriveWorktreeId` then rejects the basename it should
+ * have produced and walks up the digest ladder — `foo`, `foo-2f4530fe`,
+ * `foo-2f4530fe1cf1f9f8`, … — one rung longer on every call. That is the runaway
+ * this hotfix is about: production reached an 81-character ID whose derived tmux
+ * session name no longer matched the running session.
+ *
+ * Re-derivation for a known path should be reachable only through a bug now that
+ * the lookup is global, so this is a floor rather than a mechanism: excluding
+ * the row's own history makes the derivation converge (it re-mints the ID the
+ * row already has, or a shorter one), instead of growing without bound.
+ *
+ * Exported for the unit tests only: the branch it guards is unreachable through
+ * `syncWorktreesToDB` now that the path lookup is global, and a floor nobody can
+ * exercise is a floor nobody can prove.
+ *
+ * @param resolvedPath - Absolute, `path.resolve()`d worktree directory
+ * @param takenIds - IDs that are unavailable
+ * @param ownIds - IDs this very path already answers to (current ID + aliases)
+ * @internal
+ */
+function deriveIdIgnoringOwnHistory(resolvedPath, takenIds, ownIds) {
+    if (!ownIds || ownIds.size === 0) {
+        return (0, worktree_id_1.deriveWorktreeId)(resolvedPath, takenIds);
+    }
+    const available = new Set(takenIds);
+    for (const ownId of ownIds)
+        available.delete(ownId);
+    return (0, worktree_id_1.deriveWorktreeId)(resolvedPath, available);
+}
 /**
  * Sync scanned worktrees to database
  *
  * This function performs a true sync:
  * 1. Groups worktrees by repository
  * 2. For each repository, removes worktrees that no longer exist
- * 3. Upserts all current worktrees
+ * 3. Resolves each worktree's ID (existing row by path wins — Issue #1621)
+ * 4. Upserts all current worktrees, refreshing the display branch name
  *
  * @param db - Database instance
  * @param worktrees - Array of worktrees to sync
@@ -266,31 +341,102 @@ function syncWorktreesToDB(db, worktrees) {
         }
         worktreesByRepo.get(repoPath).push(worktree);
     }
+    // IDs are a GLOBAL primary key, so collision detection has to look at every
+    // repository, not just the one being synced. `takenIds` also absorbs the IDs
+    // handed out earlier in this same run, so two directories that share a
+    // basename across repositories cannot both claim it (which would violate the
+    // UNIQUE(path) constraint on the second upsert).
+    //
+    // Historical IDs count as taken too (Issue #1621, Phase 2): an alias still
+    // answers requests, so minting a live worktree with an ID some alias redirects
+    // elsewhere would shadow that redirect and silently send old bookmarks to the
+    // wrong worktree.
+    const takenIds = new Set([...(0, db_1.getAllWorktreeIds)(db), ...(0, db_1.getAliasedWorktreeIds)(db)]);
+    // Issue #1621: the ID a path already owns is the ID it keeps.
+    //
+    // Issue #1658: and that lookup is GLOBAL, because `path` is global — the
+    // column is `NOT NULL UNIQUE`, one row per directory for the whole table.
+    // `repository_path` is not an identity at all, it only records which scan root
+    // last upserted the row, and two scan roots can legitimately report the same
+    // directory: registering a repository *and* one of its own linked worktrees in
+    // `WORKTREE_REPOS` makes `git worktree list` return the identical path set
+    // from either one. Scoping this map per repository then found nothing on
+    // whichever pass did not write `repository_path` last, fell through to
+    // re-derivation, collided with the row's own ID and aliases, and appended
+    // another 8 hex digits — every sync, without limit (measured in production:
+    // 81 characters, at which point the tmux session name derived from the ID no
+    // longer matched the running session and the UI lost it).
+    const idByPath = new Map((0, db_1.getAllWorktreePathIds)(db).map(row => [path_1.default.resolve(row.path), row.id]));
+    // Every ID each path still answers to (its current one plus every alias
+    // pointing at it), so a re-derivation cannot be blocked by the path's own
+    // history — see deriveIdIgnoringOwnHistory.
+    const ownIdsByPath = new Map();
+    const pathById = new Map();
+    for (const [resolvedPath, id] of idByPath) {
+        ownIdsByPath.set(resolvedPath, new Set([id]));
+        pathById.set(id, resolvedPath);
+    }
+    for (const alias of (0, db_1.getAllWorktreeAliases)(db)) {
+        const aliasedPath = pathById.get(alias.worktreeId);
+        if (aliasedPath)
+            ownIdsByPath.get(aliasedPath)?.add(alias.oldId);
+    }
+    // Issue #1151: prune by on-disk PATH, not by ID — only a worktree whose PATH
+    // is gone from the scan was genuinely removed. The set is built from the whole
+    // scan rather than one repository's slice (#1658): a directory reported by
+    // *any* scan root is on disk, whatever `repository_path` currently says about
+    // it. Which ROWS a repository may prune is still scoped to that repository, so
+    // a scan root never reaches into another one's rows.
+    const scannedPaths = new Set(worktrees.map(wt => path_1.default.resolve(wt.path)));
     // Process each repository
     for (const [repoPath, repoWorktrees] of worktreesByRepo) {
         if (!repoPath)
             continue;
         // Get current worktree rows (id + path) in DB for this repository
         const existingRows = (0, db_1.getWorktreesByRepository)(db, repoPath);
-        // Issue #1151: prune by on-disk PATH, not by branch-derived ID. A worktree's
-        // ID changes when its branch changes (`generateWorktreeId`), so keying the
-        // "removed" decision on ID mistakes a same-directory branch switch for a
-        // deleted worktree and CASCADE-deletes its chat history and related data.
-        // Only a worktree whose PATH is gone from the scan was genuinely removed.
-        const newPaths = new Set(repoWorktrees.map(wt => path_1.default.resolve(wt.path)));
         // Find worktrees that no longer exist on disk (genuinely deleted)
         const deletedIds = existingRows
-            .filter(row => !newPaths.has(path_1.default.resolve(row.path)))
+            .filter(row => !scannedPaths.has(path_1.default.resolve(row.path)))
             .map(row => row.id);
         // Delete removed worktrees from DB
         if (deletedIds.length > 0) {
             const result = (0, db_1.deleteWorktreesByIds)(db, deletedIds);
             allDeletedIds.push(...deletedIds);
+            // Their IDs are free again (and their alias rows went with them).
+            for (const deletedId of deletedIds) {
+                takenIds.delete(deletedId);
+                const deletedPath = pathById.get(deletedId);
+                if (deletedPath !== undefined) {
+                    idByPath.delete(deletedPath);
+                    ownIdsByPath.delete(deletedPath);
+                }
+            }
             logger.info('worktree:cleanup', { deletedCount: result.deletedCount });
         }
         // Upsert current worktrees
         for (const worktree of repoWorktrees) {
-            (0, db_1.upsertWorktree)(db, worktree);
+            const resolvedPath = path_1.default.resolve(worktree.path);
+            const existingId = idByPath.get(resolvedPath);
+            const suggestedId = worktree.id;
+            const id = existingId ??
+                (suggestedId && !takenIds.has(suggestedId)
+                    ? suggestedId
+                    : deriveIdIgnoringOwnHistory(resolvedPath, takenIds, ownIdsByPath.get(resolvedPath)));
+            takenIds.add(id);
+            // Claim the ID for this path for the rest of the run, so the same
+            // directory seen again through a second scan root resolves to it instead
+            // of minting a second one (#1658 — a brand-new path hits this on its very
+            // first sync, before any row exists to look up).
+            idByPath.set(resolvedPath, id);
+            pathById.set(id, resolvedPath);
+            (0, db_1.upsertWorktree)(db, {
+                ...worktree,
+                id,
+                // Issue #1621: `name` is the display branch name. The branch no longer
+                // feeds the ID, so this is the only place it surfaces — refresh it from
+                // the scan every time (a checkout must move the label, not the key).
+                name: worktree.branch ?? worktree.name,
+            });
             upsertedCount++;
         }
     }

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

@@ -49,8 +49,20 @@ const SENSITIVE_PATTERNS = [
 ];
 /**
  * Sensitive key name patterns
+ *
+ * Issue #1640: `key` used to be listed on its own, which masked field names that
+ * carry no secret at all — `key`, `compositeKey`, `sortKey`, `idempotencyKey`,
+ * `publicKey`, ... — including the `read-mode:ready` log whose entire purpose is
+ * to report which key was bound (`{"key":"[REDACTED]"}` for the value `g`).
+ * Only credential-bearing `*key` compounds are matched now; a bare `key` is not.
+ * This brings the key-name side in line with the value side above, which has
+ * always used `api_key|apikey` rather than a bare `key`.
+ *
+ * Note: `auth` matches as a substring so that `authHeader` / `authorization` are
+ * covered. Do not narrow it with a `(?!or)` lookahead — that would stop matching
+ * `authorization`, which is the most important name in the group.
  */
-const SENSITIVE_KEY_PATTERN = /password|secret|token|key|auth/i;
+const SENSITIVE_KEY_PATTERN = /password|secret|token|auth|(?:api|private|access|session|signing|encryption|ssh|gpg|deploy)[-_]?key/i;
 function sanitize(value) {
     if (typeof value === 'string') {
         let sanitized = value;

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

@@ -11,7 +11,7 @@
  * No `export *` - all exports are explicitly named (Issue #479 constraint).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAnyPollerActiveForWorktree = exports.stopAutoYesPollingByWorktree = exports.getAutoYesPollerCompositeKeys = exports.stopAllAutoYesPolling = exports.stopAutoYesPolling = exports.startAutoYesPolling = exports.detectAndRespondToPrompt = exports.processStopConditionDelta = exports.captureAndCleanOutput = exports.validatePollingContext = exports.isPollerActive = exports.getLastServerResponseTimestamp = exports.clearAllPollerStates = exports.getActivePollerCount = exports.THINKING_CHECK_LINE_COUNT = exports.MAX_CONCURRENT_POLLERS = exports.MAX_CONSECUTIVE_ERRORS = exports.MAX_BACKOFF_MS = exports.DUPLICATE_RETRY_EXPIRY_MS = exports.COOLDOWN_INTERVAL_MS = exports.POLLING_INTERVAL_MS = exports.calculateBackoffInterval = exports.deleteAutoYesStateByWorktree = exports.getCompositeKeysByWorktree = exports.filterCompositeKeysByWorktree = exports.getAutoYesStateCompositeKeys = exports.deleteAutoYesState = exports.checkStopCondition = exports.executeRegexWithTimeout = exports.clearAllAutoYesStates = exports.disableAutoYes = exports.setAutoYesEnabled = exports.getAutoYesState = exports.isAutoYesExpired = exports.extractInstanceId = exports.extractCliToolId = exports.extractWorktreeId = exports.buildCompositeKey = exports.COMPOSITE_KEY_SEPARATOR = void 0;
+exports.isAnyPollerActiveForWorktree = exports.stopAutoYesPollingByWorktree = exports.getAutoYesPollerCompositeKeys = exports.stopAllAutoYesPolling = exports.stopAutoYesPolling = exports.startAutoYesPolling = exports.detectAndRespondToPrompt = exports.processStopConditionDelta = exports.captureAndCleanOutput = exports.validatePollingContext = exports.isPollerActive = exports.getLastServerResponseTimestamp = exports.clearAllPollerStates = exports.getActivePollerCount = exports.THINKING_CHECK_LINE_COUNT = exports.MAX_CONCURRENT_POLLERS = exports.MAX_CONSECUTIVE_ERRORS = exports.MAX_BACKOFF_MS = exports.DUPLICATE_RETRY_EXPIRY_MS = exports.COOLDOWN_INTERVAL_MS = exports.POLLING_INTERVAL_MS = exports.calculateBackoffInterval = exports.migrateAutoYesStateWorktreeIds = exports.deleteAutoYesStateByWorktree = exports.getCompositeKeysByWorktree = exports.filterCompositeKeysByWorktree = exports.getAutoYesStateCompositeKeys = exports.deleteAutoYesState = exports.checkStopCondition = exports.executeRegexWithTimeout = exports.clearAllAutoYesStates = exports.disableAutoYes = exports.setAutoYesEnabled = exports.getAutoYesState = exports.isAutoYesExpired = exports.extractInstanceId = exports.extractCliToolId = exports.extractWorktreeId = exports.buildCompositeKey = exports.COMPOSITE_KEY_SEPARATOR = void 0;
 var auto_yes_state_1 = require("../auto-yes-state");
 // Composite key helpers (Issue #525, #896)
 Object.defineProperty(exports, "COMPOSITE_KEY_SEPARATOR", { enumerable: true, get: function () { return auto_yes_state_1.COMPOSITE_KEY_SEPARATOR; } });
@@ -33,6 +33,8 @@ Object.defineProperty(exports, "getAutoYesStateCompositeKeys", { enumerable: tru
 Object.defineProperty(exports, "filterCompositeKeysByWorktree", { enumerable: true, get: function () { return auto_yes_state_1.filterCompositeKeysByWorktree; } });
 Object.defineProperty(exports, "getCompositeKeysByWorktree", { enumerable: true, get: function () { return auto_yes_state_1.getCompositeKeysByWorktree; } });
 Object.defineProperty(exports, "deleteAutoYesStateByWorktree", { enumerable: true, get: function () { return auto_yes_state_1.deleteAutoYesStateByWorktree; } });
+// Worktree ID migration (Issue #1621 Phase 3)
+Object.defineProperty(exports, "migrateAutoYesStateWorktreeIds", { enumerable: true, get: function () { return auto_yes_state_1.migrateAutoYesStateWorktreeIds; } });
 // Constants
 Object.defineProperty(exports, "calculateBackoffInterval", { enumerable: true, get: function () { return auto_yes_state_1.calculateBackoffInterval; } });
 Object.defineProperty(exports, "POLLING_INTERVAL_MS", { enumerable: true, get: function () { return auto_yes_state_1.POLLING_INTERVAL_MS; } });

package/dist/server/src/lib/polling/prompt-dedup.js

@@ -10,6 +10,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isDuplicatePrompt = isDuplicatePrompt;
 exports.clearPromptHashCache = clearPromptHashCache;
+exports.renamePromptHashCacheKey = renamePromptHashCacheKey;
 exports.normalizePromptForDedup = normalizePromptForDedup;
 const crypto_1 = require("crypto");
 /**
@@ -41,6 +42,27 @@ function isDuplicatePrompt(pollerKey, content) {
 function clearPromptHashCache(pollerKey) {
     promptHashCache.delete(pollerKey);
 }
+/**
+ * Move the cached hash from one pollerKey to another.
+ *
+ * Used when a worktree ID is renamed underneath a running poller
+ * (Issue #1621 Phase 3). Clearing instead of moving would let the poller
+ * re-save the prompt it is currently sitting on as a fresh message, which is
+ * the duplicate this module exists to prevent.
+ *
+ * No-op when nothing is cached under `oldKey`.
+ *
+ * @param oldKey - Poller key the cache entry lives under
+ * @param newKey - Poller key it should live under
+ */
+function renamePromptHashCacheKey(oldKey, newKey) {
+    if (oldKey === newKey)
+        return;
+    const hash = promptHashCache.get(oldKey);
+    promptHashCache.delete(oldKey);
+    if (hash !== undefined)
+        promptHashCache.set(newKey, hash);
+}
 /**
  * Normalize prompt content before deduplication check.
  * For Copilot, replaces cursor position markers at line beginnings