@askexenow/exe-os 0.9.340 → 0.9.342

package/dist/cto-delegation-gate-JWWOJPNC.js

@@ -0,0 +1,669 @@
+import {
+  sessionScopeFilter
+} from "./chunk-UP75Z5X7.js";
+import "./chunk-L2R3LN2P.js";
+import "./chunk-I26FWCSP.js";
+import "./chunk-EV46QTD3.js";
+import "./chunk-E23LNUWJ.js";
+import "./chunk-4JERP7NT.js";
+import "./chunk-EIKATSE4.js";
+import "./chunk-KGWRTRKC.js";
+import "./chunk-AD2VCHSS.js";
+import "./chunk-WOYADZF5.js";
+import "./chunk-SKGMF2SO.js";
+import "./chunk-2WAVZ5UJ.js";
+import "./chunk-HA5R6USD.js";
+import "./chunk-AM7S2TY6.js";
+import "./chunk-JGIPOUIK.js";
+import "./chunk-GWDSB25T.js";
+import "./chunk-CVYC6DUW.js";
+import "./chunk-JLZ4RYSD.js";
+import "./chunk-H7I47RS5.js";
+import "./chunk-OPU3NYOO.js";
+import "./chunk-G4RGKBCA.js";
+import "./chunk-AFNRE2RV.js";
+import "./chunk-X2Q5NLUL.js";
+import "./chunk-NLEW62VC.js";
+import "./chunk-HYZV25LY.js";
+import "./chunk-GJV3WDWM.js";
+import "./chunk-MP2AFCGL.js";
+import {
+  getClient,
+  getEmployeeByRole,
+  loadEmployeesSync
+} from "./chunk-AOHXREB7.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-OLMQ4UOF.js";
+import "./chunk-PNQDP3OA.js";
+import "./chunk-H73TUI4Y.js";
+import "./chunk-7HLWBYH7.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-NGP6LSV2.js";
+import "./chunk-PQIDGXSG.js";
+import "./chunk-K7KFGDWF.js";
+import "./chunk-WZHZCDDO.js";
+import "./chunk-BYTDMAGB.js";
+import "./chunk-MLKGABMK.js";
+
+// src/lib/cto-delegation-gate.ts
+import os from "os";
+import path from "path";
+import { existsSync, readFileSync, realpathSync, statSync } from "fs";
+var GATED_ROLE = "CTO";
+function resolveGatedAgent() {
+  try {
+    const employees = loadEmployeesSync();
+    const cto = getEmployeeByRole(employees, GATED_ROLE);
+    return cto?.name ?? "";
+  } catch {
+    return "";
+  }
+}
+var GATED_AGENT = resolveGatedAgent();
+function getGatedAgent() {
+  return resolveGatedAgent() || GATED_AGENT;
+}
+var BLOCKED_PATH_PREFIXES = [
+  "src/",
+  "tests/",
+  "scripts/",
+  "bin/",
+  ".github/workflows/",
+  ".claude/skills/"
+];
+var BLOCKED_FILENAMES = [
+  "package.json",
+  "tsconfig.json",
+  "docker-compose.yml"
+];
+var BLOCKED_DOCKERFILE_PREFIX = "Dockerfile";
+var BLOCKED_EXTENSIONS = [
+  ".ts",
+  ".js",
+  ".tsx",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".rs",
+  ".py",
+  ".go",
+  ".sh",
+  ".yaml",
+  ".yml",
+  ".prisma",
+  ".sql",
+  ".ipynb"
+];
+var EXEMPT_MD_DIR_PREFIXES = [
+  ".planning/",
+  "exe/output/",
+  "exe/",
+  "docs/"
+];
+var RECENT_DISPATCH_WINDOW_MS = 5 * 60 * 1e3;
+var SCRATCHPAD_MAX_AGE_MS = 10 * 60 * 1e3;
+var MAX_ESCAPE_SCAN_BYTES = 1e6;
+var SCRATCHPAD_ESCAPE_PATTERN = /^ENGINEER-CAPABLE:\s*NO\s*(?:—|–|-)\s*reason:\s*\S+/m;
+var INLINE_ESCAPE_MAX_LINES = 10;
+function hasInlineEscape(content) {
+  if (!content) return false;
+  const bounded = content.length > MAX_ESCAPE_SCAN_BYTES ? content.slice(0, MAX_ESCAPE_SCAN_BYTES) : content;
+  const head = bounded.split(/\r?\n/, INLINE_ESCAPE_MAX_LINES).join("\n");
+  return SCRATCHPAD_ESCAPE_PATTERN.test(head);
+}
+function hasAnyInlineEscape(content) {
+  if (!content) return false;
+  if (Array.isArray(content)) return content.some((c) => hasInlineEscape(c));
+  return hasInlineEscape(content);
+}
+function toWorkspaceRelative(filePath, cwd = process.cwd()) {
+  const normalized = path.normalize(filePath);
+  if (normalized.startsWith(cwd + path.sep)) {
+    return normalized.slice(cwd.length + 1);
+  }
+  if (path.isAbsolute(normalized)) {
+    return path.basename(normalized);
+  }
+  return normalized;
+}
+function isDockerfile(basename) {
+  return basename === BLOCKED_DOCKERFILE_PREFIX || basename.startsWith(`${BLOCKED_DOCKERFILE_PREFIX}.`);
+}
+function classifyPath(filePath, cwd) {
+  const rel = toWorkspaceRelative(filePath, cwd);
+  const basename = path.basename(rel);
+  const ext = path.extname(rel).toLowerCase();
+  if (ext === ".md") {
+    for (const prefix of EXEMPT_MD_DIR_PREFIXES) {
+      if (rel.startsWith(prefix)) return "exempt";
+    }
+    if (!BLOCKED_PATH_PREFIXES.some((p) => rel.startsWith(p))) return "exempt";
+    return "code";
+  }
+  if (BLOCKED_FILENAMES.includes(basename)) return "code";
+  if (isDockerfile(basename)) return "code";
+  if (BLOCKED_EXTENSIONS.includes(ext)) return "code";
+  if (ext === "" && BLOCKED_PATH_PREFIXES.some((p) => rel.startsWith(p))) return "code";
+  return "exempt";
+}
+function buildPathTokens(filePath) {
+  const GENERIC_SEGMENTS = /* @__PURE__ */ new Set([
+    "src",
+    "app",
+    "api",
+    "lib",
+    "bin",
+    "tests",
+    "test",
+    "scripts",
+    "dist",
+    "build",
+    "out",
+    "pages",
+    "routes",
+    "components",
+    "utils",
+    "helpers",
+    "types",
+    "models"
+  ]);
+  const normalized = path.normalize(filePath).replace(/\\/g, "/");
+  const segments = normalized.split("/").filter(Boolean);
+  const tokens = /* @__PURE__ */ new Set();
+  const basename = segments[segments.length - 1] ?? "";
+  if (basename) tokens.add(basename);
+  const parentDir = segments[segments.length - 2];
+  if (parentDir && parentDir.length >= 5 && !GENERIC_SEGMENTS.has(parentDir)) {
+    tokens.add(parentDir);
+    tokens.add(`${parentDir}/${basename}`);
+  }
+  for (let depth = 2; depth <= Math.min(4, segments.length); depth++) {
+    const suffix = segments.slice(segments.length - depth).join("/");
+    const leadSegment = segments[segments.length - depth] ?? "";
+    if (GENERIC_SEGMENTS.has(leadSegment)) continue;
+    tokens.add(suffix);
+  }
+  return [...tokens].filter((t) => t.length > 0);
+}
+async function isFileInTaskSpec(filePath, agentId) {
+  try {
+    const client = getClient();
+    const scope = sessionScopeFilter();
+    const result = await client.execute({
+      sql: `SELECT title, context FROM tasks
+            WHERE assigned_to = ? AND status = 'in_progress'${scope.sql}`,
+      args: [agentId, ...scope.args]
+    });
+    if (result.rows.length === 0) return false;
+    const tokens = buildPathTokens(filePath);
+    if (tokens.length === 0) return false;
+    for (const row of result.rows) {
+      const haystack = [
+        String(row.title ?? ""),
+        String(row.context ?? "")
+      ].join(" ").toLowerCase();
+      for (const token of tokens) {
+        if (haystack.includes(token.toLowerCase())) {
+          return true;
+        }
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function hasRecentEngineerDispatch(now = Date.now()) {
+  try {
+    const client = getClient();
+    const engineers = loadEmployeesSync().filter(
+      (e) => e.role.toLowerCase() === "principal engineer"
+    );
+    const engineerNames = engineers.map((e) => e.name);
+    const gatedAgent = getGatedAgent();
+    if (!gatedAgent) return false;
+    if (engineerNames.length === 0) return false;
+    const placeholders = engineerNames.map(() => "?").join(",");
+    const ydScope = sessionScopeFilter();
+    const result = await client.execute({
+      sql: `SELECT MAX(created_at) AS last_dispatch
+            FROM tasks
+            WHERE assigned_by = ? AND assigned_to IN (${placeholders})${ydScope.sql}`,
+      args: [gatedAgent, ...engineerNames, ...ydScope.args]
+    });
+    const raw = result.rows[0]?.last_dispatch;
+    if (raw === null || raw === void 0) return false;
+    const parsed = Date.parse(String(raw));
+    if (Number.isNaN(parsed)) return false;
+    return now - parsed <= RECENT_DISPATCH_WINDOW_MS;
+  } catch {
+    return false;
+  }
+}
+function scratchpadPath(sessionId, homeDir = os.homedir()) {
+  return path.join(
+    homeDir,
+    ".exe-os",
+    "session-cache",
+    `cto-scratchpad-${sessionId}.txt`
+  );
+}
+function hasValidScratchpadEscape(sessionId, now = Date.now(), homeDir = os.homedir()) {
+  const paths = [scratchpadPath(sessionId, homeDir)];
+  for (const filePath of paths) {
+    if (!existsSync(filePath)) continue;
+    try {
+      const stat = statSync(filePath);
+      if (now - stat.mtimeMs > SCRATCHPAD_MAX_AGE_MS) continue;
+      const body = readFileSync(filePath, "utf-8");
+      if (SCRATCHPAD_ESCAPE_PATTERN.test(body)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+var INLINE_ESCAPE_EXAMPLE = "ENGINEER-CAPABLE: NO \u2014 reason: <why an engineer cannot do this>";
+function GATE_BLOCK_MESSAGE(sessionId, homeDir = os.homedir(), surface = "Write/Edit/MultiEdit/NotebookEdit/Bash-write") {
+  const isBash = /bash/i.test(surface);
+  return [
+    `ACTION BLOCKED by CTO delegation gate. Your ${surface} was DENIED \u2014 it did NOT execute.`,
+    ...isBash ? ["(The Bash write-detector is BEST-EFFORT and heuristic \u2014 a workflow nudge, not a complete interceptor.)"] : [],
+    "This edit looks implementable by an engineer. To proceed you MUST do ONE of:",
+    "  1. Dispatch create_task to an engineer (preferred), OR",
+    `  2. INLINE ESCAPE: put this exact line within the FIRST ${INLINE_ESCAPE_MAX_LINES} lines of the file content you are writing:`,
+    `       ${INLINE_ESCAPE_EXAMPLE}`,
+    "     (the 'reason:' clause is required \u2014 a bare 'ENGINEER-CAPABLE: NO' does NOT work; a marker further down the file is ignored), OR",
+    "  3. SCRATCHPAD ESCAPE: write that same line to this exact file, then retry:",
+    `       ${scratchpadPath(sessionId, homeDir)}`,
+    "Do NOT report this action as successful. It was blocked. No file was changed.",
+    "If you are a sub-agent, report this FAILURE to your parent agent."
+  ].join("\n");
+}
+var STRUCTURED_GATED_TOOLS = /^(Write|Edit|MultiEdit|NotebookEdit)$/;
+async function decidePathGate(opts) {
+  if (classifyPath(opts.filePath, opts.cwd) === "exempt") {
+    return { outcome: "allow", reason: "exempt_path" };
+  }
+  if (await isFileInTaskSpec(opts.filePath, opts.agentId)) {
+    return { outcome: "allow", reason: "task_spec_authorized" };
+  }
+  if (await hasRecentEngineerDispatch(opts.now)) {
+    return { outcome: "allow", reason: "recent_engineer_dispatch" };
+  }
+  if (hasAnyInlineEscape(opts.content)) {
+    return { outcome: "allow", reason: "inline_escape" };
+  }
+  if (hasValidScratchpadEscape(opts.sessionId, opts.now, opts.homeDir)) {
+    return { outcome: "allow", reason: "scratchpad_escape" };
+  }
+  return { outcome: "block", reason: "no_delegation_no_escape" };
+}
+async function evaluateDelegationGate(opts) {
+  const gatedAgent = getGatedAgent();
+  if (!gatedAgent || opts.agentId !== gatedAgent) {
+    return { outcome: "allow", reason: "agent_not_gated" };
+  }
+  if (!STRUCTURED_GATED_TOOLS.test(opts.toolName)) {
+    return { outcome: "allow", reason: "tool_not_gated" };
+  }
+  return decidePathGate({
+    agentId: opts.agentId,
+    filePath: opts.filePath,
+    sessionId: opts.sessionId,
+    content: opts.content,
+    now: opts.now,
+    cwd: opts.cwd,
+    homeDir: opts.homeDir
+  });
+}
+var BASH_SOURCE_EXT_RE = /\.(?:ts|tsx|js|jsx|mjs|cjs|rs|py|go|sh|ya?ml|prisma|sql|ipynb)$/i;
+function stripHeredocBodies(command) {
+  const lines = command.split("\n");
+  const kept = [];
+  let delim = null;
+  for (const line of lines) {
+    if (delim !== null) {
+      if (line.trim() === delim) delim = null;
+      continue;
+    }
+    kept.push(line);
+    const hd = line.match(/<<-?\s*(["']?)([A-Za-z_][A-Za-z0-9_]*)\1/);
+    if (hd) delim = hd[2];
+  }
+  return kept.join("\n");
+}
+var REDIR_FILE_OPS = /* @__PURE__ */ new Set([">", ">>", ">|", "&>", "&>>"]);
+var REDIR_ANY_OPS = /* @__PURE__ */ new Set([
+  ">",
+  ">>",
+  ">|",
+  "&>",
+  "&>>",
+  ">&",
+  "fd>",
+  "fd>>",
+  "<",
+  "<<",
+  "<<-"
+]);
+var CONTROL_OPS = /* @__PURE__ */ new Set(["|", "||", "&&", "&", ";", "(", ")"]);
+function tokenizeShell(input) {
+  const toks = [];
+  let word = "";
+  let quoted = false;
+  let has = false;
+  const flush = () => {
+    if (has) toks.push({ kind: "word", value: word, quoted });
+    word = "";
+    quoted = false;
+    has = false;
+  };
+  const n = input.length;
+  let i = 0;
+  while (i < n) {
+    const c = input[i];
+    if (c === " " || c === "	" || c === "\n" || c === "\r") {
+      flush();
+      i++;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      has = true;
+      quoted = true;
+      const close = input.indexOf(c, i + 1);
+      if (close === -1) {
+        word += input.slice(i + 1);
+        i = n;
+      } else {
+        word += input.slice(i + 1, close);
+        i = close + 1;
+      }
+      continue;
+    }
+    if (c === "\\" && i + 1 < n) {
+      has = true;
+      word += input[i + 1];
+      i += 2;
+      continue;
+    }
+    if (c === ">" || c === "<" || c === "|" || c === "&" || c === ";" || c === "(" || c === ")") {
+      if (c === ">" && has && /^[0-9]+$/.test(word)) {
+        word = "";
+        quoted = false;
+        has = false;
+        if (input[i + 1] === ">") {
+          toks.push({ kind: "op", op: "fd>>" });
+          i += 2;
+        } else {
+          toks.push({ kind: "op", op: "fd>" });
+          i += 1;
+        }
+        continue;
+      }
+      flush();
+      const three = input.slice(i, i + 3);
+      if (three === "&>>" || three === "<<-") {
+        toks.push({ kind: "op", op: three });
+        i += 3;
+        continue;
+      }
+      const two = input.slice(i, i + 2);
+      if ([">>", ">|", "&>", ">&", "<<", "||", "&&"].includes(two)) {
+        toks.push({ kind: "op", op: two });
+        i += 2;
+        continue;
+      }
+      toks.push({ kind: "op", op: c });
+      i += 1;
+      continue;
+    }
+    has = true;
+    word += c;
+    i++;
+  }
+  flush();
+  return toks;
+}
+function toSimpleCommands(toks) {
+  const cmds = [];
+  let words = [];
+  let skipNextWord = false;
+  const push = () => {
+    let idx = 0;
+    while (idx < words.length && /^[A-Za-z_]\w*=/.test(words[idx])) idx++;
+    if (idx < words.length) {
+      cmds.push({ name: path.basename(words[idx]), args: words.slice(idx + 1) });
+    }
+    words = [];
+  };
+  for (const t of toks) {
+    if (t.kind === "op") {
+      if (CONTROL_OPS.has(t.op)) {
+        push();
+        skipNextWord = false;
+      } else if (REDIR_ANY_OPS.has(t.op)) skipNextWord = true;
+      continue;
+    }
+    if (skipNextWord) {
+      skipNextWord = false;
+      continue;
+    }
+    words.push(t.value);
+  }
+  push();
+  return cmds;
+}
+function realpathDeep(p) {
+  let cur = path.resolve(p);
+  const tail = [];
+  for (let d = 0; d < 64; d++) {
+    try {
+      const real = realpathSync(cur);
+      return tail.length ? path.join(real, ...tail.slice().reverse()) : real;
+    } catch {
+      tail.push(path.basename(cur));
+      const parent = path.dirname(cur);
+      if (parent === cur) break;
+      cur = parent;
+    }
+  }
+  return path.resolve(p);
+}
+function isRealpathInside(candidate, root) {
+  const rc = realpathDeep(candidate);
+  const rr = realpathDeep(root);
+  if (rc === rr) return true;
+  const prefix = rr.endsWith(path.sep) ? rr : rr + path.sep;
+  return rc.startsWith(prefix);
+}
+function resolveInsideRepo(token, cwd) {
+  if (!token) return null;
+  if (token.startsWith("/dev/")) return null;
+  let p = token;
+  if (p === "~") return null;
+  if (p.startsWith("~/")) p = path.join(os.homedir(), p.slice(2));
+  const abs = path.resolve(cwd, p);
+  if (realpathDeep(abs) === realpathDeep(cwd)) return null;
+  if (!isRealpathInside(abs, cwd)) return null;
+  return abs;
+}
+function isDirectoryDest(destToken, cwd) {
+  if (destToken.endsWith("/")) return true;
+  let p = destToken;
+  if (p.startsWith("~/")) p = path.join(os.homedir(), p.slice(2));
+  const abs = path.resolve(cwd, p);
+  try {
+    return statSync(abs).isDirectory();
+  } catch {
+    return false;
+  }
+}
+var INTERP_WRITE_RES = [
+  // python builtin: open('p', 'w'|'a'|'x')
+  /\bopen\s*\(\s*['"]([^'"]+)['"]\s*,\s*['"][wax]/g,
+  // python pathlib: Path('p').write_text(…) / .write_bytes(…)
+  /\bPath\s*\(\s*['"]([^'"]+)['"]\s*\)\s*\.\s*(?:write_text|write_bytes)\b/g,
+  // python pathlib: Path('p').open('w'|'a'|'x')
+  /\bPath\s*\(\s*['"]([^'"]+)['"]\s*\)\s*\.\s*open\s*\(\s*['"][wax]/g,
+  // node sync + streams: writeFileSync / appendFileSync / createWriteStream
+  /\b(?:writeFileSync|appendFileSync|createWriteStream)\s*\(\s*['"]([^'"]+)['"]/g,
+  // node async (any receiver: fs.promises.writeFile, fsp.writeFile, a
+  // require-of-fs .writeFile, or plain writeFile): writeFile / appendFile
+  /\b(?:writeFile|appendFile)\s*\(\s*['"]([^'"]+)['"]/g
+];
+function extractHeredocBodies(command) {
+  const lines = command.split("\n");
+  const bodies = [];
+  let delim = null;
+  for (const line of lines) {
+    if (delim !== null) {
+      if (line.trim() === delim) {
+        delim = null;
+        continue;
+      }
+      bodies.push(line);
+      continue;
+    }
+    const hd = line.match(/<<-?\s*(["']?)([A-Za-z_][A-Za-z0-9_]*)\1/);
+    if (hd) delim = hd[2];
+  }
+  return bodies.join("\n");
+}
+function heredocStdinInterpreter(command) {
+  const INTERP = /^(?:python[0-9.]*|python|node|nodejs|ruby|perl|deno|bun)$/;
+  for (const line of command.split("\n")) {
+    const hi = line.indexOf("<<");
+    if (hi === -1) continue;
+    if (!/<<-?\s*(["']?)[A-Za-z_][A-Za-z0-9_]*\1/.test(line)) continue;
+    const before = line.slice(0, hi).trim();
+    const toks = before.split(/\s+/).filter(Boolean);
+    const idx = toks.findIndex((t) => INTERP.test(path.basename(t)));
+    if (idx === -1) continue;
+    const rest = toks.slice(idx + 1);
+    if (rest.every((t) => t === "-" || t.startsWith("-"))) return true;
+  }
+  return false;
+}
+function detectBashSourceWrites(command, cwd = process.cwd()) {
+  if (!command) return [];
+  const toks = tokenizeShell(stripHeredocBodies(command));
+  const candidates = /* @__PURE__ */ new Set();
+  for (let k = 0; k < toks.length; k++) {
+    const t = toks[k];
+    if (t.kind === "op" && REDIR_FILE_OPS.has(t.op)) {
+      const nxt = toks[k + 1];
+      if (nxt && nxt.kind === "word" && nxt.value) candidates.add(nxt.value);
+    }
+  }
+  const cmds = toSimpleCommands(toks);
+  for (const { name, args } of cmds) {
+    if (name === "tee") {
+      for (const a of args) if (a && !a.startsWith("-")) candidates.add(a);
+    }
+    const sedInplace = name === "sed" && args.some((a) => /^-i/.test(a) || /^--in-place(=|$)/.test(a));
+    const perlInplace = name === "perl" && args.some((a) => /^-[A-Za-z]*i/.test(a));
+    if (sedInplace || perlInplace) {
+      for (const a of args) {
+        if (!a.startsWith("-") && BASH_SOURCE_EXT_RE.test(a)) candidates.add(a);
+      }
+    }
+    if (["cp", "mv", "rsync", "install"].includes(name)) {
+      let targetDir = null;
+      const operands = [];
+      for (let j = 0; j < args.length; j++) {
+        const a = args[j];
+        if (a === "-t" || a === "--target-directory") {
+          targetDir = args[j + 1] ?? null;
+          j++;
+          continue;
+        }
+        const m = a.match(/^--target-directory=(.+)$/);
+        if (m) {
+          targetDir = m[1];
+          continue;
+        }
+        if (a.startsWith("-")) continue;
+        operands.push(a);
+      }
+      if (targetDir !== null) {
+        for (const src of operands) candidates.add(path.join(targetDir, path.basename(src)));
+      } else if (operands.length >= 2) {
+        const dest = operands[operands.length - 1];
+        const sources = operands.slice(0, -1);
+        if (isDirectoryDest(dest, cwd)) {
+          for (const src of sources) candidates.add(path.join(dest, path.basename(src)));
+        } else {
+          candidates.add(dest);
+        }
+      }
+    }
+  }
+  {
+    const stripped = stripHeredocBodies(command);
+    const inlineInterp = /\b(?:python[0-9.]*|node|nodejs|deno|bun)\b[^\n]*?\s-(?:e|c)\b/.test(stripped);
+    if (inlineInterp) {
+      for (const re of INTERP_WRITE_RES) {
+        for (const m of command.matchAll(re)) if (m[1]) candidates.add(m[1]);
+      }
+    }
+    if (heredocStdinInterpreter(command)) {
+      const body = extractHeredocBodies(command);
+      for (const re of INTERP_WRITE_RES) {
+        for (const m of body.matchAll(re)) if (m[1]) candidates.add(m[1]);
+      }
+    }
+  }
+  const targets = /* @__PURE__ */ new Set();
+  for (const cand of candidates) {
+    const abs = resolveInsideRepo(cand, cwd);
+    if (!abs) continue;
+    if (classifyPath(abs, cwd) !== "code") continue;
+    targets.add(abs);
+  }
+  return [...targets];
+}
+async function evaluateBashWriteGate(opts) {
+  const gatedAgent = getGatedAgent();
+  if (!gatedAgent || opts.agentId !== gatedAgent) {
+    return { outcome: "allow", reason: "agent_not_gated" };
+  }
+  const cwd = opts.cwd ?? process.cwd();
+  const targets = detectBashSourceWrites(opts.command, cwd);
+  if (targets.length === 0) {
+    return { outcome: "allow", reason: "no_source_write" };
+  }
+  let last = { outcome: "allow", reason: "bash_write_authorized" };
+  for (const target of targets) {
+    last = await decidePathGate({
+      agentId: opts.agentId,
+      filePath: target,
+      sessionId: opts.sessionId,
+      content: opts.command,
+      now: opts.now,
+      cwd,
+      homeDir: opts.homeDir
+    });
+    if (last.outcome === "block") {
+      return { ...last, targets };
+    }
+  }
+  return { ...last, targets };
+}
+export {
+  GATED_AGENT,
+  GATED_ROLE,
+  GATE_BLOCK_MESSAGE,
+  INLINE_ESCAPE_EXAMPLE,
+  buildPathTokens,
+  classifyPath,
+  detectBashSourceWrites,
+  evaluateBashWriteGate,
+  evaluateDelegationGate,
+  getGatedAgent,
+  hasAnyInlineEscape,
+  hasInlineEscape,
+  hasRecentEngineerDispatch,
+  hasValidScratchpadEscape,
+  isFileInTaskSpec,
+  scratchpadPath
+};

package/dist/{daemon-auth-7IFSV5FG.js → daemon-auth-3FEAHFWC.js}

@@ -1,15 +1,17 @@
 import {
   DAEMON_TOKEN_PATH,
+  assessInitialBindIdentity,
   ensureDaemonToken,
   readDaemonToken,
   reconcileSessionAgentIdentity,
   shouldEnforceSessionIdentity
-} from "./chunk-3NGZ4PL7.js";
-import "./chunk-7Y5UDEVM.js";
-import "./chunk-SHIICYJW.js";
+} from "./chunk-X2Q5NLUL.js";
+import "./chunk-WZHZCDDO.js";
+import "./chunk-BYTDMAGB.js";
 import "./chunk-MLKGABMK.js";
 export {
   DAEMON_TOKEN_PATH,
+  assessInitialBindIdentity,
   ensureDaemonToken,
   readDaemonToken,
   reconcileSessionAgentIdentity,