opencode-swarm 7.200.9 → 7.200.11

package/dist/cli/{index-rdyfrdcp.js → index-2n7a184b.js}

@@ -1,13 +1,19 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-4krkevgc.js";
+} from "./index-001tkp0j.js";
+import {
+  assertProjectRoot
+} from "./index-t7hmqgjy.js";
 import {
   canonicalRootKeyFresh
 } from "./index-te9hq2f4.js";
+import {
+  tryAcquireLock
+} from "./index-ejhxgyvm.js";
 import {
   atomicWriteSwarmFileSync
-} from "./index-mn75z39t.js";
+} from "./index-9qy3tzt5.js";
 import {
   advisoryWarn,
   init_git_executable,
@@ -35,7 +41,7 @@ init_constants();
 import * as fs2 from "fs";
 import * as fsPromises from "fs/promises";
 import * as os from "os";
-import * as path from "path";
+import * as path2 from "path";
 
 // src/config/swarm-branch.ts
 init_constants();
@@ -222,12 +228,160 @@ function listLiveLaneOwners(directory) {
 init_warning_buffer();
 init_bun_compat();
 init_git_executable();
+
+// src/worktree/settlement-artifact-lifecycle.ts
+import { lstat, opendir, realpath } from "fs/promises";
+import * as path from "path";
+init_warning_buffer();
+var MAX_INVENTORY_ENTRIES = 200;
+var LIFECYCLE_TARGET = "locks/coder-settlement-artifacts";
+
+class SettlementArtifactLifecycleError extends Error {
+  code;
+  constructor(code, detail) {
+    super(`${code}: ${detail}`);
+    this.code = code;
+    this.name = "SettlementArtifactLifecycleError";
+  }
+}
+function isSettlementArtifactLifecycleError(error) {
+  return error instanceof SettlementArtifactLifecycleError;
+}
+async function readWal(filePath, taskId) {
+  const { readWorkflowWalFile } = await import("./workflow-wal-file-a2c8e920.js");
+  return readWorkflowWalFile("coder-settlement", filePath, taskId);
+}
+async function canonicalizeArtifact(filePath) {
+  if (!path.isAbsolute(filePath))
+    throw uncertain("artifact path is not absolute");
+  let candidate = path.resolve(filePath);
+  const missing = [];
+  for (let depth = 0;depth < 256; depth++) {
+    try {
+      const physical = await _internals2.realpath(candidate);
+      const resolved = path.join(physical, ...missing.reverse());
+      return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+    } catch (error) {
+      if (error.code !== "ENOENT" && error.code !== "ENOTDIR")
+        throw error;
+      const parent = path.dirname(candidate);
+      if (parent === candidate)
+        throw error;
+      missing.push(path.basename(candidate));
+      candidate = parent;
+    }
+  }
+  throw uncertain("artifact ancestry exceeds the identity bound");
+}
 var _internals2 = {
+  tryAcquireLock,
+  opendir,
+  lstat,
+  realpath,
+  readWal,
+  canonicalize: canonicalizeArtifact,
+  assertProjectRoot
+};
+function uncertain(detail) {
+  return new SettlementArtifactLifecycleError("CODER_SETTLEMENT_ARTIFACT_UNCERTAIN", detail);
+}
+async function withSettlementArtifactLifecycle(directory, operation) {
+  let root;
+  let admission;
+  try {
+    _internals2.assertProjectRoot(directory);
+    root = await _internals2.realpath(directory);
+    validateSwarmPath(root, LIFECYCLE_TARGET);
+    admission = await _internals2.tryAcquireLock(root, LIFECYCLE_TARGET, "coder-settlement-artifact-lifecycle", "coder-settlement-artifact-lifecycle");
+  } catch (error) {
+    throw uncertain(`cannot acquire lifecycle admission (${error instanceof Error ? error.message : String(error)})`);
+  }
+  if (!admission.acquired)
+    throw uncertain("lifecycle admission is busy: a concurrent removal or dispatch holds the lifecycle lock; retry once it completes");
+  try {
+    return await operation();
+  } finally {
+    try {
+      await admission.lock._release?.();
+    } catch (error) {
+      advisoryWarn(`[worktree] settlement artifact lifecycle lock release failed (${error instanceof Error ? error.message : String(error)})`);
+    }
+  }
+}
+async function matchesPendingWal(wal, target, targetPath) {
+  if (wal.state !== "DISPATCHED" && wal.state !== "PREPARED")
+    return false;
+  if (target.branch && (wal.worktree?.branchName === target.branch || wal.mergeProvenance?.branchName === target.branch))
+    return true;
+  return Boolean(targetPath && wal.worktree && await _internals2.canonicalize(wal.worktree.worktreePath) === targetPath);
+}
+async function assertSettlementArtifactsRemovable(directory, target) {
+  if (!target.path && !target.branch)
+    throw uncertain("missing artifact identity");
+  let handle;
+  let failure;
+  try {
+    const inventoryPath = validateSwarmPath(directory, "coder-settlements");
+    try {
+      const stat = await _internals2.lstat(inventoryPath);
+      if (stat.isSymbolicLink() || !stat.isDirectory())
+        throw uncertain("settlement inventory is not a direct directory");
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return;
+      throw error;
+    }
+    const targetPath = target.path ? await _internals2.canonicalize(target.path) : undefined;
+    handle = await _internals2.opendir(inventoryPath);
+    let count = 0;
+    while (true) {
+      const entry = await handle.read();
+      if (!entry)
+        break;
+      if (entry.isSymbolicLink())
+        throw uncertain("settlement inventory contains a symbolic entry");
+      if (!entry.name.endsWith(".json"))
+        continue;
+      if (++count > MAX_INVENTORY_ENTRIES)
+        throw uncertain(`settlement inventory exceeds ${MAX_INVENTORY_ENTRIES} records; run \`/swarm close\` to archive settled coder settlements`);
+      const filePath = path.join(inventoryPath, entry.name);
+      const stat = await _internals2.lstat(filePath);
+      if (!stat.isFile() || stat.isSymbolicLink())
+        throw uncertain("settlement record is not a direct regular file");
+      const wal = await _internals2.readWal(filePath, entry.name.slice(0, -5));
+      if (!wal)
+        throw uncertain("settlement record disappeared during inventory");
+      const after = await _internals2.lstat(filePath);
+      if (after.dev !== stat.dev || after.ino !== stat.ino || after.size !== stat.size || after.mtimeMs !== stat.mtimeMs)
+        throw uncertain("settlement record changed during inspection");
+      if (await matchesPendingWal(wal, target, targetPath)) {
+        throw new SettlementArtifactLifecycleError("CODER_SETTLEMENT_ARTIFACT_PROTECTED", `task ${wal.taskId} has a ${wal.state} settlement; preserve its lane artifacts`);
+      }
+    }
+  } catch (error) {
+    failure = isSettlementArtifactLifecycleError(error) ? error : uncertain(`cannot verify settlement inventory (${error instanceof Error ? error.message : String(error)})`);
+  } finally {
+    if (handle) {
+      try {
+        await handle.close();
+      } catch {
+        failure ??= uncertain("cannot close settlement inventory");
+      }
+    }
+  }
+  if (failure)
+    throw failure;
+}
+
+// src/worktree/core.ts
+var _internals3 = {
+  withSettlementArtifactLifecycle,
+  assertSettlementArtifactsRemovable,
   clearLiveLaneOwner,
   bunSpawn,
   resolveGitExecutable,
   platform: process.platform,
-  sleep: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms)),
+  sleep: (ms) => new Promise((resolve3) => setTimeout(resolve3, ms)),
   osTmpdir: () => os.tmpdir(),
   getCoreLongPaths: async (directory) => {
     const result = await runGit(["config", "core.longpaths"], directory);
@@ -244,7 +398,7 @@ var _internals2 = {
     symlinkSync: fs2.symlinkSync
   },
   writeScopeToDisk: async (directory, taskId, files) => {
-    const { writeScopeToDisk: realWrite } = await import("./scope-persistence-xctbs0aj.js");
+    const { writeScopeToDisk: realWrite } = await import("./scope-persistence-4wwmytwh.js");
     return realWrite(directory, taskId, files);
   },
   writeLaneProfileToDisk: async (_worktreePath, _laneIndex, _envOverrides) => {
@@ -273,15 +427,15 @@ async function writeLaneProfileToDiskReal(worktreePath, laneIndex, envOverrides)
   }
   if (lines.length === 0)
     return;
-  const lanesDir = path.join(worktreePath, ".swarm", "lanes");
+  const lanesDir = path2.join(worktreePath, ".swarm", "lanes");
   await fs2.promises.mkdir(lanesDir, { recursive: true });
-  const envPath = path.join(lanesDir, `${laneIndex}.env`);
+  const envPath = path2.join(lanesDir, `${laneIndex}.env`);
   await fs2.promises.writeFile(envPath, `${lines.join(`
 `)}
 `, "utf-8");
 }
 async function removeLaneProfileFromDiskReal(worktreePath, laneIndex) {
-  const envPath = path.join(worktreePath, ".swarm", "lanes", `${laneIndex}.env`);
+  const envPath = path2.join(worktreePath, ".swarm", "lanes", `${laneIndex}.env`);
   try {
     await fs2.promises.unlink(envPath);
   } catch (err) {
@@ -297,7 +451,7 @@ var GIT_SPAWN_FAILURE_EXIT_CODE = 1;
 async function runGit(args, cwd, timeoutMs = WORKTREE_TIMEOUT_MS) {
   let proc;
   try {
-    proc = _internals2.bunSpawn([_internals2.resolveGitExecutable(), ...args], {
+    proc = _internals3.bunSpawn([_internals3.resolveGitExecutable(), ...args], {
       cwd,
       timeout: timeoutMs,
       stdin: "ignore",
@@ -330,19 +484,19 @@ async function runGit(args, cwd, timeoutMs = WORKTREE_TIMEOUT_MS) {
   }
 }
 async function checkPathBudget(worktreeRoot, directory) {
-  if (_internals2.platform !== "win32") {
+  if (_internals3.platform !== "win32") {
     return { ok: true };
   }
   let longPaths;
   try {
-    longPaths = await _internals2.getCoreLongPaths(directory);
+    longPaths = await _internals3.getCoreLongPaths(directory);
   } catch {}
   if (longPaths === "true") {
     return { ok: true };
   }
   let proc;
   try {
-    proc = _internals2.bunSpawn([_internals2.resolveGitExecutable(), "ls-files"], {
+    proc = _internals3.bunSpawn([_internals3.resolveGitExecutable(), "ls-files"], {
       cwd: directory,
       timeout: WORKTREE_TIMEOUT_MS,
       stdin: "ignore",
@@ -384,23 +538,23 @@ async function checkPathBudget(worktreeRoot, directory) {
   }
 }
 function shortenWorktreePath(_directory, sessionId, laneId) {
-  let tmp = _internals2.osTmpdir();
+  let tmp = _internals3.osTmpdir();
   try {
     tmp = fs2.realpathSync(tmp);
   } catch {}
-  return path.join(tmp, "swwt", sessionId, laneId);
+  return path2.join(tmp, "swwt", sessionId, laneId);
 }
 function makeWorktreeBranchName(sessionId, id, options) {
   return buildSwarmBranchName(sessionId, id, options.purpose, options.branchStyle === "legacy-lane" && options.purpose === "lane");
 }
 function resolveWorktreeBaseDir(directory, worktreeDir) {
-  return worktreeDir ? path.resolve(directory, worktreeDir) : path.resolve(directory, SWARM_WORKTREE_DIR_NAME);
+  return worktreeDir ? path2.resolve(directory, worktreeDir) : path2.resolve(directory, SWARM_WORKTREE_DIR_NAME);
 }
 function isPathUnderSwarmWorktreeBase(targetPath, directory, worktreeDirOverrides = []) {
   const caseInsensitive = process.platform === "win32";
   let realTarget;
   try {
-    realTarget = fs2.realpathSync(path.resolve(directory, targetPath));
+    realTarget = fs2.realpathSync(path2.resolve(directory, targetPath));
   } catch {
     return false;
   }
@@ -414,13 +568,13 @@ function isPathUnderSwarmWorktreeBase(targetPath, directory, worktreeDirOverride
     try {
       realBase = fs2.realpathSync(base);
     } catch {
-      realBase = path.resolve(base);
+      realBase = path2.resolve(base);
     }
     const cmpBase = caseInsensitive ? realBase.toLowerCase() : realBase;
     if (cmpTarget === cmpBase)
       return true;
-    const rel = path.relative(cmpBase, cmpTarget);
-    return rel.length > 0 && !rel.startsWith("..") && !path.isAbsolute(rel);
+    const rel = path2.relative(cmpBase, cmpTarget);
+    return rel.length > 0 && !rel.startsWith("..") && !path2.isAbsolute(rel);
   });
 }
 async function provisionWorktree(directory, id, sessionId, options) {
@@ -430,7 +584,7 @@ async function provisionWorktree(directory, id, sessionId, options) {
       error: `Refusing to provision worktree: branch "${branchName}" does not match the swarm lane grammar, so lane permission scoping could not recognise it and the lane would hang on the first external-directory prompt. This is almost always an invalid sessionId ("${sessionId}"); it must look like "ses_" followed by letters/digits, and the execution-unit id ("${id}") must be a single path segment.`
     };
   }
-  let worktreePath = path.resolve(resolveWorktreeBaseDir(directory, options.worktreeDir), sessionId, id);
+  let worktreePath = path2.resolve(resolveWorktreeBaseDir(directory, options.worktreeDir), sessionId, id);
   const budgetResult = await checkPathBudget(worktreePath, directory);
   if (budgetResult.ok === false) {
     if (options.worktreeDir) {
@@ -575,18 +729,18 @@ async function provisionWorktree(directory, id, sessionId, options) {
   }
   const strategy = options.depsStrategy ?? "skip";
   if (strategy !== "skip") {
-    const hostDepDir = path.join(directory, "node_modules");
-    const laneDepDir = path.join(worktreePath, "node_modules");
-    if (_internals2.fs.existsSync(hostDepDir)) {
+    const hostDepDir = path2.join(directory, "node_modules");
+    const laneDepDir = path2.join(worktreePath, "node_modules");
+    if (_internals3.fs.existsSync(hostDepDir)) {
       try {
         if (strategy === "copy") {
-          await _internals2.fs.cp(hostDepDir, laneDepDir, {
+          await _internals3.fs.cp(hostDepDir, laneDepDir, {
             recursive: true,
             force: true
           });
         } else if (strategy === "link") {
-          const isWindows = _internals2.platform === "win32";
-          _internals2.fs.symlinkSync(hostDepDir, laneDepDir, isWindows ? "junction" : "dir");
+          const isWindows = _internals3.platform === "win32";
+          _internals3.fs.symlinkSync(hostDepDir, laneDepDir, isWindows ? "junction" : "dir");
         }
       } catch (e) {
         log(`[swarm] deps_strategy '${strategy}' preparation failed for ${id}: ${e instanceof Error ? e.message : String(e)}`);
@@ -599,12 +753,12 @@ async function provisionWorktree(directory, id, sessionId, options) {
   }
   if (options.scope?.taskId && Array.isArray(options.scope.files)) {
     try {
-      await _internals2.writeScopeToDisk(worktreePath, options.scope.taskId, options.scope.files);
+      await _internals3.writeScopeToDisk(worktreePath, options.scope.taskId, options.scope.files);
     } catch {}
   }
   if (options.laneProfile) {
     try {
-      await _internals2.writeLaneProfileToDisk(worktreePath, options.laneProfile.laneIndex, options.laneProfile.envOverrides);
+      await _internals3.writeLaneProfileToDisk(worktreePath, options.laneProfile.laneIndex, options.laneProfile.envOverrides);
     } catch {}
   }
   return {
@@ -616,14 +770,28 @@ async function provisionWorktree(directory, id, sessionId, options) {
   };
 }
 async function removeWorktree(worktreePath, projectRoot, options) {
-  const isWindows = _internals2.platform === "win32";
+  try {
+    return await _internals3.withSettlementArtifactLifecycle(projectRoot, async () => {
+      await _internals3.assertSettlementArtifactsRemovable(projectRoot, {
+        path: worktreePath
+      });
+      return removeWorktreeUnderLifecycleLock(worktreePath, projectRoot, options);
+    });
+  } catch (error) {
+    return {
+      error: `CODER_SETTLEMENT_ARTIFACT_REMOVAL_REFUSED: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function removeWorktreeUnderLifecycleLock(worktreePath, projectRoot, options) {
+  const isWindows = _internals3.platform === "win32";
   const MAX_RETRIES = 4;
   const RETRY_DELAY_MS = 2000;
   let lastError = "";
   for (let attempt = 0;attempt < MAX_RETRIES; attempt++) {
     const result = await runGit(["worktree", "remove", worktreePath], projectRoot);
     if (result.exitCode === 0) {
-      _internals2.clearLiveLaneOwner(projectRoot, worktreePath);
+      _internals3.clearLiveLaneOwner(projectRoot, worktreePath);
       if (fs2.existsSync(worktreePath)) {
         const trusted = isPathUnderSwarmWorktreeBase(worktreePath, projectRoot, options?.worktreeDir ? [options.worktreeDir] : []);
         if (!trusted) {
@@ -648,13 +816,13 @@ async function removeWorktree(worktreePath, projectRoot, options) {
     }
     lastError = result.stderr.trim() || result.stdout.trim();
     if (isWindows && (lastError.includes("EBUSY") || lastError.includes("EPERM")) && attempt < MAX_RETRIES - 1) {
-      await _internals2.sleep(RETRY_DELAY_MS);
+      await _internals3.sleep(RETRY_DELAY_MS);
       continue;
     }
     if (options?.force && isPathUnderSwarmWorktreeBase(worktreePath, projectRoot, options.worktreeDir ? [options.worktreeDir] : [])) {
       const forced = await runGit(["worktree", "remove", "--force", worktreePath], projectRoot);
       if (forced.exitCode === 0) {
-        _internals2.clearLiveLaneOwner(projectRoot, worktreePath);
+        _internals3.clearLiveLaneOwner(projectRoot, worktreePath);
         if (fs2.existsSync(worktreePath)) {
           try {
             fs2.rmSync(worktreePath, { recursive: true, force: true });
@@ -788,4 +956,4 @@ async function assertCleanWorkingTree(directory) {
   return { clean: true };
 }
 
-export { recordLiveLaneOwner, listLiveLaneOwners, _internals2 as _internals, writeLaneProfileToDiskReal, removeLaneProfileFromDiskReal, checkPathBudget, shortenWorktreePath, makeWorktreeBranchName, resolveWorktreeBaseDir, isPathUnderSwarmWorktreeBase, provisionWorktree, removeWorktree, isCleanWorktree, autoCommitDirty, cleanUntrackedFiles, assertCleanWorkingTree };
+export { recordLiveLaneOwner, listLiveLaneOwners, withSettlementArtifactLifecycle, assertSettlementArtifactsRemovable, _internals3 as _internals, writeLaneProfileToDiskReal, removeLaneProfileFromDiskReal, checkPathBudget, shortenWorktreePath, makeWorktreeBranchName, resolveWorktreeBaseDir, isPathUnderSwarmWorktreeBase, provisionWorktree, removeWorktree, isCleanWorktree, autoCommitDirty, cleanUntrackedFiles, assertCleanWorkingTree };

package/dist/cli/{index-4fr3r8k5.js → index-2vj8d8te.js}

@@ -4,7 +4,7 @@ import {
   readShellAuditTail,
   redactPath,
   redactShellCommand
-} from "./index-hhq5f82z.js";
+} from "./index-5k88v1e7.js";
 
 // src/services/guardrail-log-service.ts
 var BLOCK_TYPES = new Set([

package/dist/cli/{index-hhq5f82z.js → index-5k88v1e7.js}

@@ -1,7 +1,11 @@
 // @bun
 import {
   observeStoreHealth
-} from "./index-8srvdpw6.js";
+} from "./index-8xtdxy91.js";
+import {
+  init_schema,
+  stripKnownSwarmPrefix
+} from "./index-814q5t5s.js";
 import {
   getPathFlavor,
   init_path_identity,
@@ -14,7 +18,7 @@ import {
 } from "./index-9rwhas09.js";
 import {
   telemetry
-} from "./index-c2k7q723.js";
+} from "./index-6cppzd9c.js";
 import {
   init_git_executable,
   resolveGitExecutable
@@ -26,10 +30,6 @@ import {
   init_logger,
   warn
 } from "./index-zgwm4ryv.js";
-import {
-  init_schema,
-  stripKnownSwarmPrefix
-} from "./index-y16v2q1x.js";
 import {
   init_constants
 } from "./index-xfzkq1k4.js";
@@ -277,7 +277,7 @@ var require_scan = __commonJS((exports, module) => {
   var scan = (input, options) => {
     const opts = options || {};
     const length = input.length - 1;
-    const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+    const scanToEnd = opts.parts === true || opts.tokens === true || opts.scanToEnd === true;
     const slashes = [];
     const tokens = [];
     const parts = [];
@@ -384,14 +384,18 @@ var require_scan = __commonJS((exports, module) => {
             negatedExtglob = true;
           }
           if (scanToEnd === true) {
+            let parens = 0;
             while (eos() !== true && (code = advance())) {
               if (code === CHAR_BACKWARD_SLASH) {
                 backslashes = token.backslashes = true;
-                code = advance();
+                advance();
                 continue;
               }
-              if (code === CHAR_RIGHT_PARENTHESES) {
-                isGlob = token.isGlob = true;
+              if (code === CHAR_LEFT_PARENTHESES) {
+                parens++;
+                continue;
+              }
+              if (code === CHAR_RIGHT_PARENTHESES && --parens === 0) {
                 finished = true;
                 break;
               }
@@ -446,13 +450,18 @@ var require_scan = __commonJS((exports, module) => {
       if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
         isGlob = token.isGlob = true;
         if (scanToEnd === true) {
+          let parens = 1;
           while (eos() !== true && (code = advance())) {
-            if (code === CHAR_LEFT_PARENTHESES) {
+            if (code === CHAR_BACKWARD_SLASH) {
               backslashes = token.backslashes = true;
-              code = advance();
+              advance();
               continue;
             }
-            if (code === CHAR_RIGHT_PARENTHESES) {
+            if (code === CHAR_LEFT_PARENTHESES) {
+              parens++;
+              continue;
+            }
+            if (code === CHAR_RIGHT_PARENTHESES && --parens === 0) {
               finished = true;
               break;
             }
@@ -526,32 +535,31 @@ var require_scan = __commonJS((exports, module) => {
     if (opts.parts === true || opts.tokens === true) {
       let prevIndex;
       for (let idx = 0;idx < slashes.length; idx++) {
-        const n = prevIndex ? prevIndex + 1 : start;
+        const n2 = prevIndex !== undefined ? prevIndex + 1 : start;
         const i = slashes[idx];
-        const value = input.slice(n, i);
+        const value2 = input.slice(n2, i);
         if (opts.tokens) {
           if (idx === 0 && start !== 0) {
             tokens[idx].isPrefix = true;
             tokens[idx].value = prefix;
           } else {
-            tokens[idx].value = value;
+            tokens[idx].value = value2;
           }
           depth(tokens[idx]);
           state.maxDepth += tokens[idx].depth;
         }
-        if (idx !== 0 || value !== "") {
-          parts.push(value);
+        if (i >= start) {
+          parts.push(value2);
+          prevIndex = i;
         }
-        prevIndex = i;
       }
-      if (prevIndex && prevIndex + 1 < input.length) {
-        const value = input.slice(prevIndex + 1);
-        parts.push(value);
-        if (opts.tokens) {
-          tokens[tokens.length - 1].value = value;
-          depth(tokens[tokens.length - 1]);
-          state.maxDepth += tokens[tokens.length - 1].depth;
-        }
+      const n = prevIndex !== undefined ? prevIndex + 1 : start;
+      const value = input.slice(n);
+      parts.push(value);
+      if (opts.tokens && prevIndex && prevIndex + 1 < input.length) {
+        tokens[tokens.length - 1].value = value;
+        depth(tokens[tokens.length - 1]);
+        state.maxDepth += tokens[tokens.length - 1].depth;
       }
       state.slashes = slashes;
       state.parts = parts;
@@ -737,7 +745,11 @@ var require_parse = __commonJS((exports, module) => {
       }
     }
   };
-  var getStarExtglobSequenceOutput = (pattern) => {
+  var buildCharClassStar = (chars) => {
+    const source = chars.length === 1 ? utils.escapeRegex(chars[0]) : `[${chars.map((ch) => utils.escapeRegex(ch)).join("")}]`;
+    return `${source}*`;
+  };
+  var getStarExtglobSequenceChars = (pattern) => {
     let index = 0;
     const chars = [];
     while (index < pattern.length) {
@@ -759,8 +771,7 @@ var require_parse = __commonJS((exports, module) => {
     if (chars.length < 1) {
       return;
     }
-    const source = chars.length === 1 ? utils.escapeRegex(chars[0]) : `[${chars.map((ch) => utils.escapeRegex(ch)).join("")}]`;
-    return `${source}*`;
+    return chars;
   };
   var repeatedExtglobRecursion = (pattern) => {
     let depth = 0;
@@ -784,15 +795,29 @@ var require_parse = __commonJS((exports, module) => {
         return { risky: true };
       }
     }
+    const safeChars = [];
+    let sawStarSequence = false;
+    let combinable = true;
     for (const branch of branches) {
-      const safeOutput = getStarExtglobSequenceOutput(branch);
-      if (safeOutput) {
-        return { risky: true, safeOutput };
+      const chars = getStarExtglobSequenceChars(branch);
+      if (chars) {
+        sawStarSequence = true;
+        safeChars.push(...chars);
+        continue;
       }
+      const literal = normalizeSimpleBranch(branch);
+      if (literal && literal.length === 1) {
+        safeChars.push(literal);
+        continue;
+      }
+      combinable = false;
       if (repeatedExtglobRecursion(branch) > max) {
         return { risky: true };
       }
     }
+    if (sawStarSequence) {
+      return combinable ? { risky: true, safeOutput: buildCharClassStar([...new Set(safeChars)]) } : { risky: true };
+    }
     return { risky: false };
   };
   var parse = (input, options) => {
@@ -1376,6 +1401,7 @@ var require_parse = __commonJS((exports, module) => {
           rest = rest.slice(3);
           consume("/**", 3);
         }
+        const isEnd = eos() || state.parens > 0 && rest === ")".repeat(state.parens) && !extglobs.some((extglob) => extglob.type === "negate");
         if (prior.type === "bos" && eos()) {
           prev.type = "globstar";
           prev.value += value;
@@ -1385,7 +1411,7 @@ var require_parse = __commonJS((exports, module) => {
           consume(value);
           continue;
         }
-        if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
+        if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && isEnd) {
           state.output = state.output.slice(0, -(prior.output + prev.output).length);
           prior.output = `(?:${prior.output}`;
           prev.type = "globstar";
@@ -1648,9 +1674,9 @@ var require_picomatch = __commonJS((exports, module) => {
     }
     return { isMatch: Boolean(match), match, output };
   };
-  picomatch.matchBase = (input, glob, options) => {
+  picomatch.matchBase = (input, glob, options, posix = options && options.windows) => {
     const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
-    return regex.test(utils.basename(input));
+    return regex.test(utils.basename(input, { windows: posix }));
   };
   picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
   picomatch.parse = (pattern, options) => {
@@ -2977,6 +3003,7 @@ var SHELL_AUDIT_LIMITS = {
   maxLineBytes: 64 * 1024,
   maxCommandChars: 4096,
   maxReasonChars: 1024,
+  maxPathChars: 320,
   migrationMaxBytes: 8 * 1024 * 1024
 };
 function decisionClassOf(event) {
@@ -3637,10 +3664,21 @@ var SHELL_AUDIT_FIELD_CLASSES = Object.freeze({
   resolvedScope: "redacted-path",
   declaredScope: "redacted-path",
   action: "enum",
+  operator: "free-text-redacted",
   destructiveCategory: "enum",
   executorMechanism: "enum",
   skipReason: "enum"
 });
+function truncateUtf8Safe(text, maxChars) {
+  if (text.length <= maxChars)
+    return text;
+  const cut = text.slice(0, maxChars);
+  const last = cut.charCodeAt(cut.length - 1);
+  if (last >= 55296 && last <= 56319) {
+    return `${cut.slice(0, -1)}\u2026[truncated]`;
+  }
+  return `${cut}\u2026[truncated]`;
+}
 function hashRedactedCommand(redacted) {
   return createHash("sha256").update(redacted, "utf-8").digest("hex").slice(0, 16);
 }
@@ -3707,6 +3745,13 @@ function redactDecisionLineForArchive(line) {
       changed = true;
     }
   }
+  if (typeof record.operator === "string") {
+    const redacted = truncateUtf8Safe(redactEmbeddedPaths(record.operator), 32);
+    if (redacted !== record.operator) {
+      record.operator = redacted;
+      changed = true;
+    }
+  }
   for (const field of ["declaredScope", "resolvedScope"]) {
     if (typeof record[field] === "string") {
       const redacted = redactPath(record[field]);

package/dist/cli/{index-c2k7q723.js → index-6cppzd9c.js}

@@ -408,7 +408,7 @@ var CATALOG_SOURCE = [
       category: "gate",
       severity: "info",
       privacyClass: "pseudonymous",
-      producer: "src/pr-review/legacy-transcript-adapter.ts:1032",
+      producer: "src/pr-review/legacy-transcript-adapter.ts:1063",
       consumers: NO_CONSUMERS,
       futureOwnerIssue: ISSUE_SINK,
       retentionOwnerIssue: ISSUE_LIFECYCLE_RETENTION