@brainervirus/workit-cursor 8.1.0 → 8.3.0

package/dist/workit-hook.js

@@ -8527,9 +8527,28 @@ function patchId(cwd, base, head) {
   const id = git(cwd, ["patch-id", "--stable"], { input: diff.stdout });
   return line(id)?.split(/\s+/u)[0] ?? null;
 }
+function remoteNames(cwd) {
+  return (git(cwd, ["remote"]).stdout ?? "").split(/\r?\n/u).map((value) => value.trim()).filter(Boolean);
+}
+var config2 = (cwd, key) => line(git(cwd, ["config", "--get", key]));
 function currentBranch(cwd) {
   return line(git(cwd, ["symbolic-ref", "--short", "-q", "HEAD"]));
 }
+function pushRemoteName(cwd, branch) {
+  const name = branch ?? currentBranch(cwd);
+  const remotes = remoteNames(cwd);
+  const candidates = [
+    name ? config2(cwd, `branch.${name}.pushRemote`) : null,
+    config2(cwd, "remote.pushDefault"),
+    name ? config2(cwd, `branch.${name}.remote`) : null
+  ];
+  for (const candidate of candidates)
+    if (candidate && candidate !== "." && remotes.includes(candidate))
+      return candidate;
+  if (remotes.includes("origin"))
+    return "origin";
+  return remotes.length === 1 ? remotes[0] : null;
+}
 
 // packages/workit-core/src/ledger.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
@@ -8537,6 +8556,35 @@ import { createHash as createHash4, randomBytes } from "node:crypto";
 import fs3 from "node:fs";
 import path3 from "node:path";
 
+// packages/workit-core/src/host-session.ts
+var HOST_SESSION_VARS = [
+  ["OPENCODE_SESSION_ID", () => "opencode"],
+  ["PI_SESSION_ID", () => "pi"],
+  [
+    "CODEX_THREAD_ID",
+    (env) => env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE === "Codex Desktop" || env.CODEX_ELECTRON_RESOURCES_PATH ? "codex_desktop" : "codex_cli"
+  ]
+];
+var family = (host) => host?.replace(/_(?:cli|desktop)$/, "") ?? null;
+function hostSessionFromEnv(env) {
+  const value = (key) => env[key]?.trim() || null;
+  let inner = null;
+  for (const [key, host] of HOST_SESSION_VARS) {
+    const session = value(key);
+    if (session) {
+      inner = { host: host(env), session };
+      break;
+    }
+  }
+  const declared = value("WORKIT_HOST");
+  if (env.WORKIT_SESSION_ID !== undefined) {
+    const inherited = inner !== null && declared !== null && family(declared) !== family(inner.host);
+    if (!inherited)
+      return { host: declared, session: value("WORKIT_SESSION_ID") };
+  }
+  return inner ? { host: inner.host, session: inner.session } : { host: declared, session: null };
+}
+
 // packages/workit-core/src/store/paths.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
@@ -8819,6 +8867,7 @@ var checkoutSlug = (root) => {
 
 // packages/workit-core/src/ledger.ts
 var LEDGER_VERSION = 1;
+var MAX_LINE_BYTES = 4096;
 var PASSING = new Set(["verified", "tests-verified", "type-check-only"]);
 var FAILING = new Set(["failed", "blocked"]);
 var STRONG_RESULTS = new Set(["verified", "tests-verified"]);
@@ -8918,6 +8967,7 @@ function ledgerPath(cwd) {
   const root = storeRoot(cwd);
   return root.ok ? { ok: true, value: path3.join(root.value.root, "ledger", "ledger.jsonl") } : root;
 }
+var newId2 = () => `${Date.now().toString(36)}-${randomBytes(6).toString("hex")}`;
 var NETWORK_FS_TYPES = new Set([
   26985,
   20859,
@@ -8930,6 +8980,158 @@ var NETWORK_FS_TYPES = new Set([
   1196443219,
   198183888
 ]);
+var isNetworkFsType = (type) => NETWORK_FS_TYPES.has(type >>> 0);
+var onNetworkFs = (dir) => {
+  if (process.platform !== "linux")
+    return false;
+  try {
+    return isNetworkFsType(fs3.statfsSync(dir).type);
+  } catch {
+    return false;
+  }
+};
+var LOCK_WAIT_MS = 5000;
+var LOCK_STALE_MS = 30000;
+var LOCK_OWNER = "owner";
+var lockToken = (lock) => {
+  try {
+    return fs3.readFileSync(path3.join(lock, LOCK_OWNER), "utf8");
+  } catch {
+    return null;
+  }
+};
+var lockAgeMs = (lock) => {
+  for (const target of [path3.join(lock, LOCK_OWNER), lock]) {
+    try {
+      return Date.now() - fs3.statSync(target).mtimeMs;
+    } catch {}
+  }
+  return null;
+};
+var ledgerLock = {
+  acquire(lock) {
+    try {
+      fs3.mkdirSync(lock);
+    } catch (error) {
+      if (error.code === "EEXIST")
+        return null;
+      throw error;
+    }
+    const token = `${process.pid}-${randomBytes(8).toString("hex")}`;
+    fs3.writeFileSync(path3.join(lock, LOCK_OWNER), token);
+    return token;
+  },
+  release(lock, token) {
+    if (lockToken(lock) !== token)
+      return false;
+    const tomb = `${lock}.release-${randomBytes(6).toString("hex")}`;
+    try {
+      fs3.renameSync(lock, tomb);
+    } catch {
+      return false;
+    }
+    if (lockToken(tomb) !== token) {
+      try {
+        fs3.renameSync(tomb, lock);
+      } catch {}
+      return false;
+    }
+    fs3.rmSync(tomb, { recursive: true, force: true });
+    return true;
+  },
+  token: lockToken,
+  reap(lock, observed) {
+    const tomb = `${lock}.reap-${randomBytes(6).toString("hex")}`;
+    try {
+      fs3.renameSync(lock, tomb);
+    } catch {
+      return false;
+    }
+    if (lockToken(tomb) === observed) {
+      fs3.rmSync(tomb, { recursive: true, force: true });
+      return true;
+    }
+    try {
+      fs3.renameSync(tomb, lock);
+    } catch {
+      fs3.rmSync(tomb, { recursive: true, force: true });
+    }
+    return false;
+  }
+};
+function withLedgerLock(file, fn, waitMs = LOCK_WAIT_MS) {
+  const lock = `${file}.lock`;
+  const deadline = Date.now() + waitMs;
+  let token = null;
+  for (;; ) {
+    token = ledgerLock.acquire(lock);
+    if (token)
+      break;
+    const observed = lockToken(lock);
+    const age = lockAgeMs(lock);
+    if (age !== null && age > LOCK_STALE_MS && ledgerLock.reap(lock, observed))
+      continue;
+    if (Date.now() >= deadline)
+      return null;
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+  }
+  try {
+    return fn();
+  } finally {
+    ledgerLock.release(lock, token);
+  }
+}
+function appendLine(file, line, options) {
+  const write = () => {
+    const fd = fs3.openSync(file, "a+");
+    try {
+      const size = fs3.fstatSync(fd).size;
+      let fence = "";
+      if (size > 0) {
+        const last = Buffer.alloc(1);
+        fs3.readSync(fd, last, 0, 1, size - 1);
+        if (last[0] !== 10)
+          fence = `
+`;
+      }
+      const bytes = Buffer.from(fence + line);
+      const written = fs3.writeSync(fd, bytes);
+      if (written !== bytes.length)
+        return err("unavailable", `short write to ${file}: ${written} of ${bytes.length} bytes; the row is torn and will be skipped`);
+      return { ok: true, value: undefined };
+    } finally {
+      fs3.closeSync(fd);
+    }
+  };
+  try {
+    fs3.mkdirSync(path3.dirname(file), { recursive: true });
+    if (!options.forceLock && !onNetworkFs(path3.dirname(file)))
+      return write();
+    const locked = withLedgerLock(file, write);
+    return locked ?? err("busy", `ledger lock ${file}.lock is held`, "retry; remove the .lock directory if no workit process is running");
+  } catch (error) {
+    return err("unavailable", `cannot append to ${file}: ${error.message}`);
+  }
+}
+var serialize = (row, now) => {
+  const full = { v: LEDGER_VERSION, id: newId2(), at: now.toISOString(), ...row };
+  return { full, line: `${JSON.stringify(full)}
+` };
+};
+function appendRaw(cwd, row, options) {
+  const { full, line } = serialize(row, options.now ?? new Date);
+  const bytes = Buffer.byteLength(line);
+  if (bytes > MAX_LINE_BYTES)
+    return err("invalid_input", `ledger row is ${bytes} bytes; the limit is ${MAX_LINE_BYTES}. Shorten the text and pass details by --ref <path|url>`);
+  const file = ledgerPath(cwd);
+  if (!file.ok)
+    return file;
+  const written = appendLine(file.value, line, options);
+  return written.ok ? { ok: true, value: full } : written;
+}
+function appendHookObserved(cwd, row) {
+  return appendRaw(cwd, { ...row, observer: "host_hook" }, {});
+}
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var str = (value) => typeof value === "string" ? value : null;
 var normalizeActor = (value) => {
@@ -10099,6 +10301,7 @@ var resolveCommitPolicy = (config, workspace) => {
 };
 
 // packages/workit-core/src/core/workspaces.ts
+import { spawnSync as spawnSync5 } from "node:child_process";
 import { createHash as createHash5 } from "node:crypto";
 import { readFileSync as readFileSync2, realpathSync } from "node:fs";
 import path6 from "node:path";
@@ -10410,6 +10613,53 @@ var validateWorkspaceGlob = (glob) => {
   }
   return { ok: true };
 };
+
+class WorkspaceConfigError extends Error {
+  name = "WorkspaceConfigError";
+}
+var mainCheckouts = new Map;
+var mainCheckoutOf = (cwd) => {
+  const cached = mainCheckouts.get(cwd);
+  if (cached !== undefined)
+    return cached;
+  const env = { ...process.env };
+  for (const name of ["GIT_DIR", "GIT_WORK_TREE", "GIT_COMMON_DIR", "GIT_INDEX_FILE"])
+    delete env[name];
+  const git = (args) => {
+    const run = spawnSync5("git", args, {
+      cwd,
+      env,
+      encoding: "utf8",
+      timeout: 5000,
+      windowsHide: true
+    });
+    return run.status === 0 ? run.stdout : null;
+  };
+  let main = null;
+  const dirs = git(["rev-parse", "--path-format=absolute", "--git-dir", "--git-common-dir"]);
+  const [gitDir, common] = (dirs ?? "").trim().split(/\r?\n/u);
+  if (gitDir && common && path6.resolve(gitDir) !== path6.resolve(common)) {
+    const listed = /^worktree (.+)$/mu.exec(git(["worktree", "list", "--porcelain"]) ?? "")?.[1];
+    main = listed?.trim() || (path6.basename(common) === ".git" ? path6.dirname(common) : common);
+  }
+  mainCheckouts.set(cwd, main);
+  return main;
+};
+var matchingEntries = (cwd, entries) => {
+  const match = (where) => {
+    const targets = [where, realpathOf(where)].map((value) => value.replaceAll("\\", "/"));
+    return entries.filter((entry) => {
+      const glob = entry.glob.replaceAll("\\", "/");
+      const canonical = canonicalGlob(glob);
+      return targets.some((target) => matchWorkspace(glob, target) || canonical !== glob && matchWorkspace(canonical, target));
+    });
+  };
+  const direct = match(cwd);
+  if (direct.length)
+    return direct;
+  const main = mainCheckoutOf(cwd);
+  return main ? match(main) : direct;
+};
 var realpathOf = (p) => {
   const real = realpathSync.native ?? realpathSync;
   try {
@@ -10434,43 +10684,29 @@ var selectWorkspaceMatch = (matches, cwd, workspaceName) => {
     if (named.length === 1)
       return named[0];
     if (named.length > 1)
-      throw new Error(`ambiguous workspace ${JSON.stringify(workspaceName)} for ${cwd}`);
+      throw new WorkspaceConfigError(`ambiguous workspace ${JSON.stringify(workspaceName)} for ${cwd}`);
     if (matches.length > 0) {
-      throw new Error(`workspace ${JSON.stringify(workspaceName)} does not match ${cwd}; matching choices: ${matches.map((entry) => entry.name).join(", ")}`);
+      throw new WorkspaceConfigError(`workspace ${JSON.stringify(workspaceName)} does not match ${cwd}; matching choices: ${matches.map((entry) => entry.name).join(", ")}`);
     }
-    throw new Error(`workspace ${JSON.stringify(workspaceName)} does not match ${cwd}`);
+    throw new WorkspaceConfigError(`workspace ${JSON.stringify(workspaceName)} does not match ${cwd}`);
   }
   if (matches.length < 2)
     return matches[0];
   const highestSpecificity = Math.max(...matches.map((entry) => globSpecificity(entry.glob)));
   const mostSpecific = matches.filter((entry) => globSpecificity(entry.glob) === highestSpecificity);
   if (mostSpecific.length > 1) {
-    throw new Error(`ambiguous workspace for ${cwd}; choose one of: ${mostSpecific.map((entry) => entry.name).join(", ")}`);
+    throw new WorkspaceConfigError(`ambiguous workspace for ${cwd}; choose one of: ${mostSpecific.map((entry) => entry.name).join(", ")}`);
   }
   return mostSpecific[0];
 };
 var resolveWorkspaceFromEntries = (cwd, entries, workspaceName) => {
-  const targets = [cwd, realpathOf(cwd)].map((p) => p.replaceAll("\\", "/"));
-  const matches = [];
-  for (const ws of entries) {
-    const glob = ws.glob.replaceAll("\\", "/");
-    const canonical = canonicalGlob(glob);
-    let matched = false;
-    for (const target of targets) {
-      if (matchWorkspace(glob, target) || canonical !== glob && matchWorkspace(canonical, target)) {
-        matched = true;
-        break;
-      }
-    }
-    if (matched)
-      matches.push(ws);
-  }
+  const matches = matchingEntries(cwd, entries);
   return selectWorkspaceMatch(matches, cwd, workspaceName) ?? null;
 };
 var resolveWorkspaceFrom = (cwd, dir, workspaceName) => {
   const result = readWorkspacesResult(dir);
   if (result.status === "malformed" || result.status === "invalid")
-    throw new Error(result.error);
+    throw new WorkspaceConfigError(result.error);
   return resolveWorkspaceFromEntries(cwd, result.entries, workspaceName);
 };
 var runtimeWorkspacePolicySchema = (kind) => {
@@ -10490,6 +10726,7 @@ var runtimeWorkspacePolicySchema = (kind) => {
   }).passthrough();
   return entrySchema;
 };
+var resolveRuntimeWorkspaceVcs = (cwd) => resolveRuntimeWorkspaceCandidate(cwd, "vcs");
 var runtimeWorkspaceIndexSchema = object({
   workspaces: array(object({ name: nonBlank, glob: nonBlank }).passthrough()).optional()
 }).passthrough();
@@ -10501,31 +10738,26 @@ var matchRuntimeWorkspace = (cwd) => {
   } catch (error) {
     if (error.code === "ENOENT")
       return null;
-    throw new Error(`${file} could not be read: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    throw new WorkspaceConfigError(`${file} could not be read: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
   }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch {
-    throw new Error(`${file} is not valid JSON`);
+    throw new WorkspaceConfigError(`${file} is not valid JSON`);
   }
   const validated = runtimeWorkspaceIndexSchema.safeParse(parsed);
   if (!validated.success) {
     const detail = validated.error.issues.map((issue) => `${issue.path.map(String).join(".") || "workspaces"}: ${issue.message}`).join("; ");
-    throw new Error(`${file} has invalid workspace matching data: ${detail}`);
+    throw new WorkspaceConfigError(`${file} has invalid workspace matching data: ${detail}`);
   }
   const entries = validated.data.workspaces;
   for (const entry of entries ?? []) {
     const glob = validateWorkspaceGlob(entry.glob);
     if (!glob.ok)
-      throw new Error(`${file} workspace ${entry.name}: ${glob.error}`);
+      throw new WorkspaceConfigError(`${file} workspace ${entry.name}: ${glob.error}`);
   }
-  const targets = [cwd, realpathOf(cwd)].map((value) => value.replaceAll("\\", "/"));
-  const matches = (entries ?? []).filter((entry) => {
-    const glob = entry.glob.replaceAll("\\", "/");
-    const canonical = canonicalGlob(glob);
-    return targets.some((target) => matchWorkspace(glob, target) || canonical !== glob && matchWorkspace(canonical, target));
-  });
+  const matches = matchingEntries(cwd, entries ?? []);
   const workspaceName = process.env.WORKFLOW_WORKSPACE_NAME?.trim() || undefined;
   const selected = selectWorkspaceMatch(matches, cwd, workspaceName);
   return selected ? { file, selected } : null;
@@ -10542,7 +10774,7 @@ var resolveRuntimeWorkspaceCandidate = (cwd, kind) => {
   const policy = runtimeWorkspacePolicySchema(kind).safeParse(selected);
   if (!policy.success) {
     const detail = policy.error.issues.map((issue) => `${issue.path.map(String).join(".") || "workspace"}: ${issue.message}`).join("; ");
-    throw new Error(`${file} has invalid ${kind} policy configuration: ${detail}`);
+    throw new WorkspaceConfigError(`${file} has invalid ${kind} policy configuration: ${detail}`);
   }
   return policy.data;
 };
@@ -10553,10 +10785,10 @@ var resolveRuntimeWorkspacePolicy = (cwd, kind, requestedProfile) => {
   const key = kind === "branch" ? "branchPolicy" : "commitPolicy";
   const profileName = requestedProfile?.trim() || candidate.defaultProfile;
   if (candidate.defaultProfile && !Object.hasOwn(candidate.profiles ?? {}, candidate.defaultProfile))
-    throw new Error(`workspace ${JSON.stringify(candidate.name)} has no profile ${JSON.stringify(candidate.defaultProfile)}`);
+    throw new WorkspaceConfigError(`workspace ${JSON.stringify(candidate.name)} has no profile ${JSON.stringify(candidate.defaultProfile)}`);
   const profile = profileName ? candidate.profiles?.[profileName] : undefined;
   if (profileName && !profile)
-    throw new Error(`workspace ${JSON.stringify(candidate.name)} has no profile ${JSON.stringify(profileName)}`);
+    throw new WorkspaceConfigError(`workspace ${JSON.stringify(candidate.name)} has no profile ${JSON.stringify(profileName)}`);
   const profilePolicy = profile?.[key];
   const workspacePolicy = candidate[key];
   return {
@@ -11321,7 +11553,7 @@ var packageRoot = () => {
 };
 
 // packages/workit-core/src/core/store-lock.ts
-import { spawnSync as spawnSync5 } from "node:child_process";
+import { spawnSync as spawnSync6 } from "node:child_process";
 import fs7 from "node:fs";
 import { hostname } from "node:os";
 var metadataLockSchema = object({
@@ -11371,7 +11603,7 @@ var processStartOf = (pid) => {
   }
   if (process.platform === "darwin" || process.platform === "freebsd") {
     try {
-      const run = spawnSync5("ps", ["-o", "lstart=", "-p", String(pid)], {
+      const run = spawnSync6("ps", ["-o", "lstart=", "-p", String(pid)], {
         encoding: "utf8",
         timeout: 1000
       });
@@ -11983,9 +12215,10 @@ var drop = (lock) => {
 };
 var envActor = () => {
   const value = (key) => process.env[key]?.trim() || null;
+  const acting = hostSessionFromEnv(process.env);
   return {
-    host: value("WORKIT_HOST") ?? "runtime",
-    session: value("WORKIT_SESSION_ID"),
+    host: acting.host ?? "runtime",
+    session: acting.session,
     agentId: value("WORKIT_AGENT_ID")
   };
 };
@@ -13511,11 +13744,11 @@ var workerBlocksTransition = (transition, state) => transition === "pause" ? fal
 // packages/workit-core/src/core/task-evaluation.ts
 import { createHash as createHash8 } from "node:crypto";
 import * as fs11 from "node:fs";
-import { spawnSync as spawnSync7 } from "node:child_process";
+import { spawnSync as spawnSync8 } from "node:child_process";
 import path14 from "node:path";
 
 // packages/workit-core/src/check-config.ts
-import { spawnSync as spawnSync6 } from "node:child_process";
+import { spawnSync as spawnSync7 } from "node:child_process";
 import fs10 from "node:fs";
 import path13 from "node:path";
 var SCRIPT_CHECKS = ["test", "lint", "typecheck", "check"];
@@ -13559,7 +13792,7 @@ function splitCommand(command) {
   return argv.length ? argv : new Error("empty command");
 }
 var git3 = (cwd, args) => {
-  const run = spawnSync6("git", args, {
+  const run = spawnSync7("git", args, {
     cwd,
     encoding: "utf8",
     timeout: 20000,
@@ -13764,7 +13997,7 @@ var compareCodeUnits3 = (left, right) => {
   return left.length - right.length;
 };
 var gitPaths = (root) => {
-  const result = spawnSync7("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+  const result = spawnSync8("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
     cwd: root,
     encoding: "buffer"
   });
@@ -13777,7 +14010,7 @@ var gitPaths = (root) => {
     };
   }
   const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path14.sep).join("/")) : [];
-  const stagedDeleted = spawnSync7("git", ["diff", "--cached", "--name-only", "--diff-filter=D", "-z"], { cwd: root, encoding: "buffer" });
+  const stagedDeleted = spawnSync8("git", ["diff", "--cached", "--name-only", "--diff-filter=D", "-z"], { cwd: root, encoding: "buffer" });
   if (stagedDeleted.status !== 0) {
     const stderr = stagedDeleted.stderr?.toString("utf8") ?? "";
     if (!/not a git repository/i.test(stderr))
@@ -13908,7 +14141,7 @@ function captureCandidate(root, scope, environment = []) {
   const values = supplied.toSorted((left, right) => compareCodeUnits3(left.name, right.name)).map(({ name, value }) => ({ name, value, refs: [] }));
   if (values.some(({ value }) => value === null))
     completeness = "uncertain";
-  const headResult = spawnSync7("git", ["rev-parse", "HEAD"], { cwd: checkout, encoding: "utf8" });
+  const headResult = spawnSync8("git", ["rev-parse", "HEAD"], { cwd: checkout, encoding: "utf8" });
   if (headResult.status !== 0 && !/not a git repository/i.test(headResult.stderr ?? ""))
     completeness = "uncertain";
   const head = headResult.status === 0 ? headResult.stdout.trim() : null;
@@ -16599,6 +16832,7 @@ var validateBranchNameFor = (workspaceRoot, name) => {
     };
   }
 };
+var resolveBranchPolicyFor = (workspaceRoot, profileName) => effectiveWorkspacePolicy(workspaceRoot, "branch", profileName).branchPolicy;
 
 // packages/workit-core/src/core/route-intent.ts
 var shellBranchTarget = (command) => {
@@ -16624,36 +16858,43 @@ var shellPolicy = (cwd, command) => {
 // packages/workit-core/src/hooks/write-gate.ts
 import { realpathSync as realpathSync5 } from "node:fs";
 import path16 from "node:path";
-var NONE2 = { kind: "none" };
-var CASE_INSENSITIVE = process.platform === "darwin" || process.platform === "win32";
-var canonical2 = (file) => {
-  let rest = "";
-  for (let dir = path16.resolve(file);; dir = path16.dirname(dir)) {
-    try {
-      return path16.join(realpathSync5(dir), rest);
-    } catch {
-      if (path16.dirname(dir) === dir)
-        return path16.resolve(file);
-      rest = rest ? path16.join(path16.basename(dir), rest) : path16.basename(dir);
+
+// packages/workit-core/src/hooks/shell-words.ts
+var closingQuote = (command, start, dialect) => {
+  const quote = command[start];
+  for (let index = start + 1;index < command.length; index++) {
+    const char = command[index];
+    if (quote === "'") {
+      if (char !== "'")
+        continue;
+      if (dialect === "powershell" && command[index + 1] === "'") {
+        index++;
+        continue;
+      }
+      return index;
+    }
+    if (dialect === "posix" && char === "\\" || dialect === "powershell" && char === "`") {
+      index++;
+      continue;
     }
+    if (char === '"')
+      return index;
   }
+  return -1;
 };
-var exempt = (cwd, root, file, plans) => {
-  const fold = (value) => CASE_INSENSITIVE ? value.toLowerCase() : value;
-  const relative = path16.relative(fold(canonical2(root)), fold(canonical2(path16.resolve(cwd, file))));
-  if (relative.startsWith("..") || path16.isAbsolute(relative))
-    return true;
-  const posix = relative.split(path16.sep).join("/");
-  const segments = posix.split("/");
-  return /\.mdx?$/i.test(posix) || segments[0] === "docs" || segments.includes("plans") || [...plans].some((plan) => fold(plan) === posix);
+var unquote = (body, quote, dialect) => {
+  if (quote === "'")
+    return dialect === "powershell" ? body.replaceAll("''", "'") : body;
+  return dialect === "posix" ? body.replace(/\\(["\\$`])/g, "$1") : body.replace(/`(.)/g, "$1");
 };
-var segmentsOf = (command) => {
+var segmentsOf = (command, dialect = "posix") => {
   const segments = [];
   let current = { words: [], redirects: [] };
   let word = "";
   let inWord = false;
   let pending = null;
   const heredocs = [];
+  const escape = dialect === "posix" ? "\\" : "`";
   const flushWord = () => {
     if (!inWord)
       return;
@@ -16677,11 +16918,11 @@ var segmentsOf = (command) => {
   for (let index = 0;index < command.length; index++) {
     const char = command[index];
     if (char === "'" || char === '"') {
-      const end = command.indexOf(char, index + 1);
-      word += command.slice(index + 1, end < 0 ? undefined : end);
+      const end = closingQuote(command, index, dialect);
+      word += unquote(command.slice(index + 1, end < 0 ? undefined : end), char, dialect);
       inWord = true;
       index = end < 0 ? command.length : end;
-    } else if (char === "\\" && index + 1 < command.length) {
+    } else if (char === escape && index + 1 < command.length) {
       word += command[++index];
       inWord = true;
     } else if (char === `
@@ -16698,7 +16939,14 @@ var segmentsOf = (command) => {
       }
     } else if (/\s/.test(char))
       flushWord();
-    else if (";&|()".includes(char)) {
+    else if (char === "(" || char === ")") {
+      if (char === "(" && inWord && word.endsWith("$")) {
+        word = word.slice(0, -1);
+        inWord = word !== "";
+      }
+      flushSegment();
+      segments.push({ words: [], redirects: [], group: char === "(" ? "open" : "close" });
+    } else if (";&|".includes(char)) {
       if (char === "&" && command[index + 1] === ">")
         continue;
       flushSegment();
@@ -16716,7 +16964,7 @@ var segmentsOf = (command) => {
         inWord = true;
       }
       pending = "redirect";
-    } else if (char === "<") {
+    } else if (char === "<" && dialect === "posix") {
       flushWord();
       if (command[index + 1] === "<") {
         index++;
@@ -16733,6 +16981,31 @@ var segmentsOf = (command) => {
   flushSegment();
   return segments;
 };
+
+// packages/workit-core/src/hooks/write-gate.ts
+var NONE2 = { kind: "none" };
+var CASE_INSENSITIVE = process.platform === "darwin" || process.platform === "win32";
+var canonical2 = (file) => {
+  let rest = "";
+  for (let dir = path16.resolve(file);; dir = path16.dirname(dir)) {
+    try {
+      return path16.join(realpathSync5(dir), rest);
+    } catch {
+      if (path16.dirname(dir) === dir)
+        return path16.resolve(file);
+      rest = rest ? path16.join(path16.basename(dir), rest) : path16.basename(dir);
+    }
+  }
+};
+var exempt = (cwd, root, file, plans) => {
+  const fold = (value) => CASE_INSENSITIVE ? value.toLowerCase() : value;
+  const relative = path16.relative(fold(canonical2(root)), fold(canonical2(path16.resolve(cwd, file))));
+  if (relative.startsWith("..") || path16.isAbsolute(relative))
+    return true;
+  const posix = relative.split(path16.sep).join("/");
+  const segments = posix.split("/");
+  return /\.mdx?$/i.test(posix) || segments[0] === "docs" || segments.includes("plans") || [...plans].some((plan) => fold(plan) === posix);
+};
 var PREFIXES2 = new Set(["sudo", "command", "env", "nohup", "time", "exec", "xargs"]);
 var operands = (words) => words.filter((item) => !item.startsWith("-"));
 var editsOf = (input) => {
@@ -16882,14 +17155,473 @@ function writeGate(cwd, paths) {
     return NONE2;
   }
 }
+// packages/workit-core/src/hooks/raw-git.ts
+import { spawnSync as spawnSync9 } from "node:child_process";
+import { createHash as createHash10 } from "node:crypto";
+import fs12 from "node:fs";
+import os4 from "node:os";
+import path17 from "node:path";
+var NONE3 = { kind: "none" };
+var SHELLS = new Set(["sh", "bash", "zsh", "dash", "ksh"]);
+var PREFIXES3 = new Set(["sudo", "command", "env", "nohup", "time", "exec", "nice", "&"]);
+var SCRIPT_FLAG = /^-[a-zA-Z]*c[a-zA-Z]*$/;
+var CD = new Set(["cd", "chdir", "set-location", "sl"]);
+var PUSHD = new Set(["pushd", "push-location"]);
+var POPD = new Set(["popd", "pop-location"]);
+var GIT_VALUE_OPTIONS = new Set([
+  "-c",
+  "--git-dir",
+  "--work-tree",
+  "--namespace",
+  "--exec-path",
+  "--config-env",
+  "--super-prefix"
+]);
+var isAbsolute = (value) => path17.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
+var joinDir = (base, next) => {
+  if (base === undefined || /[$`*?]/.test(next) || next === "-")
+    return;
+  const expanded = next === "~" || next.startsWith("~/") ? path17.join(os4.homedir(), next.slice(1)) : next;
+  return base === null || isAbsolute(expanded) ? expanded : path17.join(base, expanded);
+};
+var cdTarget = (words) => {
+  const args = words.slice(1);
+  const flag = args.findIndex((word) => /^-(?:literal)?path$/i.test(word));
+  if (flag >= 0)
+    return args[flag + 1] ?? null;
+  return args.find((word) => word === "-" || !word.startsWith("-")) ?? null;
+};
+var stripPrefixes = (input) => {
+  let words = input;
+  for (;; ) {
+    const first = words[0];
+    if (first === undefined)
+      return words;
+    if (/^\w+=/.test(first))
+      words = words.slice(1);
+    else if (PREFIXES3.has(first)) {
+      words = words.slice(1);
+      while (words[0]?.startsWith("-"))
+        words = words.slice(words[0] === "-u" ? 2 : 1);
+    } else if (first === "timeout") {
+      words = words.slice(1);
+      while (words[0]?.startsWith("-"))
+        words = words.slice(1);
+      words = words.slice(1);
+    } else
+      return words;
+  }
+};
+var commandName = (word) => (word?.split(/[\\/]/).at(-1) ?? "").toLowerCase().replace(/\.exe$/, "");
+function rawInvocations(command, dialect = "posix", depth = 0) {
+  const found = [];
+  let dir = null;
+  const groups = [];
+  let stack = [];
+  for (const segment of segmentsOf(command, dialect)) {
+    if (segment.group === "open") {
+      groups.push({ dir, stack: [...stack] });
+      continue;
+    }
+    if (segment.group === "close") {
+      const saved = groups.pop();
+      if (saved)
+        ({ dir, stack } = saved);
+      continue;
+    }
+    const words = stripPrefixes(segment.words);
+    const name = commandName(words[0]);
+    if (CD.has(name)) {
+      const target = cdTarget(words);
+      dir = target === null ? os4.homedir() : joinDir(dir, target);
+      continue;
+    }
+    if (PUSHD.has(name)) {
+      const target = cdTarget(words);
+      stack.push(dir);
+      dir = target === null || target === "-" ? undefined : joinDir(dir, target);
+      continue;
+    }
+    if (POPD.has(name)) {
+      dir = stack.length ? stack.pop() : undefined;
+      continue;
+    }
+    if (SHELLS.has(name) && depth < 3) {
+      const flag = words.findIndex((word, index) => index > 0 && SCRIPT_FLAG.test(word));
+      const script = flag > 0 ? words[flag + 1] : undefined;
+      if (script)
+        for (const inner of rawInvocations(script, "posix", depth + 1))
+          found.push({
+            ...inner,
+            dir: inner.dir === null ? dir : inner.dir === undefined ? undefined : joinDir(dir, inner.dir)
+          });
+      continue;
+    }
+    if (name === "gh" || name === "glab") {
+      found.push({ tool: name, dir, args: words.slice(1) });
+      continue;
+    }
+    if (name !== "git")
+      continue;
+    let here = dir;
+    let index = 1;
+    for (;index < words.length; index++) {
+      const word = words[index];
+      if (word === "-C")
+        here = words[index + 1] ? joinDir(here, words[++index]) : here;
+      else if (GIT_VALUE_OPTIONS.has(word))
+        index++;
+      else if (!word.startsWith("-"))
+        break;
+    }
+    found.push({ tool: "git", dir: here, args: words.slice(index) });
+  }
+  return found;
+}
+var PUSH_VALUE_OPTIONS = new Set(["-o", "--push-option", "--receive-pack", "--exec", "--repo"]);
+var pushAction = (args) => {
+  let force = false;
+  let lease = false;
+  let wholesale = false;
+  let remote = null;
+  const positionals = [];
+  for (let index = 1;index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--") {
+      positionals.push(...args.slice(index + 1));
+      break;
+    }
+    if (arg === "--dry-run" || /^-[a-zA-Z]*n[a-zA-Z]*$/.test(arg))
+      return null;
+    if (arg === "--repo")
+      remote = args[++index] ?? null;
+    else if (arg.startsWith("--repo="))
+      remote = arg.slice("--repo=".length);
+    else if (PUSH_VALUE_OPTIONS.has(arg))
+      index++;
+    else if (arg === "--force" || /^-[a-zA-Z]*f[a-zA-Z]*$/.test(arg))
+      force = true;
+    else if (arg.startsWith("--force-with-lease") || arg === "--force-if-includes")
+      lease = true;
+    else if (["--all", "--mirror", "--branches", "--tags"].includes(arg))
+      wholesale = true;
+    else if (!arg.startsWith("-"))
+      positionals.push(arg);
+  }
+  const specs = remote === null ? positionals.slice(1) : positionals;
+  remote ??= positionals[0] ?? null;
+  const targets = [];
+  for (const raw of specs) {
+    if (raw.startsWith("+"))
+      force = true;
+    const spec = raw.replace(/^\+/, "");
+    const colon = spec.indexOf(":");
+    const destination = colon >= 0 ? spec.slice(colon + 1) : spec;
+    if (!destination)
+      continue;
+    if (destination === "HEAD")
+      targets.push(null);
+    else if (destination.startsWith("refs/heads/"))
+      targets.push(destination.slice(11));
+    else if (!destination.startsWith("refs/"))
+      targets.push(destination);
+  }
+  if (specs.length === 0 && !wholesale)
+    targets.push(null);
+  return { kind: "push", targets, blindForce: force && !lease, remote };
+};
+var VALUE_OPTIONS = {
+  git: new Set([
+    "-m",
+    "--message",
+    "-F",
+    "--file",
+    "-C",
+    "-c",
+    "--reuse-message",
+    "--reedit-message",
+    "--author",
+    "--date",
+    "--trailer",
+    "-t",
+    "--template",
+    "--cleanup",
+    "--fixup",
+    "--squash",
+    "-o",
+    "--push-option",
+    "--repo",
+    "--receive-pack",
+    "--exec"
+  ]),
+  gh: new Set(["-b", "--body", "-F", "--body-file", "-t", "--title", "--subject", "-A", "--author-email"].concat(["-B", "--base", "-H", "--head", "-l", "--label", "-a", "--assignee"]).concat(["-r", "--reviewer", "-m", "--milestone", "-p", "--project", "-T", "--template"]).concat(["--match-head-commit", "-R", "--repo"])),
+  glab: new Set(["-m", "--message", "--squash-message", "--sha", "-t", "--title", "-d", "--description"].concat(["-b", "--target-branch", "-s", "--source-branch", "-l", "--label"]).concat(["-a", "--assignee", "--reviewer", "-R", "--repo"]))
+};
+var asksHelp = (invocation) => {
+  const { tool, args } = invocation;
+  if (args[0] === "help" || tool !== "git" && args[1] === "help")
+    return true;
+  const values = VALUE_OPTIONS[tool];
+  for (let index = 0;index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--")
+      return false;
+    if (arg === "--help" || arg === "-h")
+      return true;
+    if (values.has(arg))
+      index++;
+  }
+  return false;
+};
+function rawAction(invocation) {
+  const args = invocation.args;
+  if (asksHelp(invocation))
+    return null;
+  const [first, second] = args;
+  if (invocation.tool === "git") {
+    if (first === "commit")
+      return args.includes("--dry-run") ? null : { kind: "commit", amend: args.includes("--amend") };
+    if (first === "push")
+      return pushAction(args);
+    return null;
+  }
+  const forge = invocation.tool;
+  const noun = forge === "gh" ? "pr" : "mr";
+  if (first !== noun)
+    return null;
+  if (second === "merge")
+    return { kind: "merge", forge };
+  if (second === "create")
+    return { kind: "pr-create", forge };
+  if (["view", "checks", "status", "ci", "list"].includes(second ?? ""))
+    return { kind: "pr-read", forge };
+  return null;
+}
+var repoAt = (dir) => {
+  const location = resolveStore(dir);
+  if (location instanceof Error || !location.shared)
+    return null;
+  return { location, dir, branch: resolveTaskKey(dir, location).branch };
+};
+var isWorkitWorkspace = (repo) => {
+  if (fs12.existsSync(repo.location.dir))
+    return true;
+  try {
+    return resolveRuntimeWorkspaceVcs(repo.location.top ?? repo.dir) !== null;
+  } catch {
+    return false;
+  }
+};
+var guardedBranch = (dir, branch) => {
+  try {
+    const policy = resolveBranchPolicyFor(dir);
+    return policy.protected.has(branch.toLowerCase()) || policy.defaultTargetBranch.toLowerCase() === branch.toLowerCase();
+  } catch {
+    return false;
+  }
+};
+var toPushRemote = (repo, remote) => {
+  if (remote === null)
+    return true;
+  try {
+    const pushRemote = pushRemoteName(repo.dir, repo.branch);
+    return pushRemote === null || pushRemote === remote;
+  } catch {
+    return false;
+  }
+};
+var headSha2 = (repo) => {
+  const git = repo.location.git;
+  if (!git || git.reftable)
+    return null;
+  try {
+    const head = fs12.readFileSync(path17.join(git.gitDir, "HEAD"), "utf8").trim();
+    if (/^[0-9a-f]{40,64}$/.test(head))
+      return head;
+    const ref = /^ref: (refs\/.+)$/.exec(head)?.[1];
+    if (!ref)
+      return null;
+    const common = path17.dirname(repo.location.dir);
+    try {
+      return fs12.readFileSync(path17.join(common, ref), "utf8").trim() || null;
+    } catch {}
+    const packed = fs12.readFileSync(path17.join(common, "packed-refs"), "utf8");
+    return new RegExp(`^([0-9a-f]{40,64}) ${ref.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`, "m").exec(packed)?.[1] ?? null;
+  } catch {
+    return null;
+  }
+};
+var quote = (text) => `\`${text}\``;
+var refusal = (action, branch) => {
+  if (action.kind === "merge")
+    return `workit: raw ${quote(action.forge === "gh" ? "gh pr merge" : "glab mr merge")} bypasses the merge grant and the verdict gate. Run ${quote("workit pr merge")} instead (it checks both; ${quote("workit help pr")}).`;
+  return `workit: raw ${quote("git push")}${action.kind === "push" && action.blindForce ? " --force" : ""} onto ${branch}, a protected branch or the default target, bypasses workit's protected-branch check. Push your feature branch with ${quote("workit git push")} (${quote("workit git push --force-with-lease")} to rewrite it) and land it with ${quote("workit pr merge")}.`;
+};
+var nudgeFor = (action, host, session) => {
+  switch (action.kind) {
+    case "commit": {
+      const prefix = host === "cursor" && session ? `WORKIT_SESSION_ID=${session} ` : "";
+      return action.amend ? `workit: raw ${quote("git commit --amend")} is recorded for this session; for new commits prefer ${quote(`${prefix}workit git commit -m '<msg>'`)} (adds the Workit-Session trailer and checks branch and commit policy).` : `workit: prefer ${quote(`${prefix}workit git commit -m '<msg>' [--all | -- <paths>]`)}: it adds the Workit-Session trailer and checks branch and commit policy.`;
+    }
+    case "push":
+      return action.blindForce ? `workit: ${quote("git push --force")} overwrites without a lease; use ${quote("workit git push --force-with-lease")}.` : `workit: prefer ${quote("workit git push")}: it refuses protected branches and verifies the remote tip.`;
+    case "pr-create":
+      return `workit: prefer ${quote("workit pr create --fill")} (or --title/--body): it records the PR the merge gate checks.`;
+    case "pr-read":
+      return `workit: ${quote("workit pr status")} shows the PR, its checks and the verdict state; ${quote("workit ci wait")} waits for checks.`;
+    case "merge":
+      return null;
+  }
+};
+var actionsIn = (cwd, command, dialect) => {
+  const out = [];
+  const repos = new Map;
+  for (const invocation of rawInvocations(command, dialect)) {
+    if (invocation.dir === undefined)
+      continue;
+    const action = rawAction(invocation);
+    if (!action)
+      continue;
+    const dir = path17.resolve(cwd, invocation.dir ?? ".");
+    if (!repos.has(dir)) {
+      const repo = repoAt(dir);
+      repos.set(dir, repo && isWorkitWorkspace(repo) ? repo : null);
+    }
+    const repo = repos.get(dir);
+    if (repo)
+      out.push({ action, repo });
+  }
+  return out;
+};
+var mentionsRawTool = (command) => /\b(?:git|gh|glab)\b/i.test(command);
+var dialectOf = (input) => (input.event.kind === "shell.pre" || input.event.kind === "shell.post" ? input.event.dialect : undefined) ?? "posix";
+function rawGitPre(input, command) {
+  try {
+    if (!mentionsRawTool(command))
+      return NONE3;
+    const nudges = [];
+    for (const { action, repo } of actionsIn(input.cwd, command, dialectOf(input))) {
+      if (action.kind === "merge")
+        return deny(refusal(action, null));
+      if (action.kind === "push")
+        for (const target of action.targets) {
+          const branch = target ?? repo.branch;
+          if (branch && guardedBranch(repo.dir, branch) && toPushRemote(repo, action.remote))
+            return deny(refusal(action, branch));
+        }
+      const nudge = nudgeFor(action, input.host, input.session.id);
+      if (nudge && !nudges.includes(nudge))
+        nudges.push(nudge);
+    }
+    return nudges.length ? { kind: "context", text: nudges.join(`
+`) } : NONE3;
+  } catch {
+    return NONE3;
+  }
+}
+var deny = (reason) => ({ kind: "deny", reason, unblock: null });
+var NEXT_COMMAND = "next";
+var MARKER_TTL_SECONDS = 3600;
+var markerFile = (repo, session, key) => path17.join(repo.location.dir, "hooks", `commit-${createHash10("sha256").update(`${session}\x00${key}`).digest("hex").slice(0, 32)}.json`);
+var callKey = (toolUseId, command) => toolUseId ?? `cmd:${createHash10("sha256").update(command).digest("hex")}`;
+function noteRawCommit(input, command, key) {
+  try {
+    if (!input.session.id || !/\bcommit\b/.test(command))
+      return;
+    const at = Math.floor(Date.now() / 1000);
+    for (const { action, repo } of actionsIn(input.cwd, command, dialectOf(input))) {
+      if (action.kind !== "commit")
+        continue;
+      const file = markerFile(repo, input.session.id, key);
+      fs12.mkdirSync(path17.dirname(file), { recursive: true });
+      fs12.writeFileSync(file, `${JSON.stringify({ head: headSha2(repo), at })}
+`);
+    }
+  } catch {}
+}
+var headCommit = (dir) => {
+  const run = spawnSync9("git", [
+    "log",
+    "-1",
+    "--format=%H%x1f%ct%x1f%s%x1f%(trailers:key=Workit-Session,valueonly,separator=%x2c)"
+  ], {
+    cwd: dir,
+    encoding: "utf8",
+    timeout: 5000,
+    windowsHide: true,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0", GIT_OPTIONAL_LOCKS: "0", LC_ALL: "C" }
+  });
+  const [sha, committed, subject = "", trailer = ""] = (run.status === 0 ? run.stdout.trim() : "").split("\x1F");
+  return sha && /^[0-9a-f]{40,64}$/.test(sha) ? { sha, committed: Number(committed), subject, trailer: trailer.trim() || null } : null;
+};
+var settle2 = (input, repo, file) => {
+  let marker;
+  try {
+    marker = JSON.parse(fs12.readFileSync(file, "utf8"));
+  } catch {
+    return;
+  }
+  fs12.rmSync(file, { force: true });
+  const session = input.session.id;
+  const now = Date.now() / 1000;
+  if (typeof marker.at !== "number" || now - marker.at > MARKER_TTL_SECONDS)
+    return;
+  if (!session || !repo.branch)
+    return;
+  const head = headCommit(repo.dir);
+  if (!head || head.sha === marker.head || head.committed < marker.at)
+    return;
+  if (head.trailer && head.trailer !== session)
+    return;
+  const ledger = readLedger(repo.dir);
+  if (!ledger.ok)
+    return;
+  const claimed = ledger.value.rows.some((row) => row.type === "commit.recorded" && (row.sha === head.sha || row.head === head.sha));
+  if (claimed)
+    return;
+  appendHookObserved(repo.dir, {
+    type: "commit.recorded",
+    actor: { host: input.host, session, agentId: input.session.agentId },
+    branch: repo.branch,
+    head: head.sha,
+    sha: head.sha,
+    session,
+    agentId: input.session.agentId,
+    subject: head.subject.slice(0, 200),
+    files: [],
+    fileCount: null,
+    via: "raw_shell"
+  });
+};
+function rawGitPost(input, command, key) {
+  try {
+    if (!input.session.id || !/\bcommit\b/.test(command))
+      return;
+    for (const { action, repo } of actionsIn(input.cwd, command, dialectOf(input)))
+      if (action.kind === "commit")
+        settle2(input, repo, markerFile(repo, input.session.id, key));
+  } catch {}
+}
+function settlePendingCommit(input) {
+  try {
+    if (!input.session.id)
+      return;
+    const repo = repoAt(input.cwd);
+    if (!repo)
+      return;
+    const file = markerFile(repo, input.session.id, NEXT_COMMAND);
+    if (fs12.existsSync(file))
+      settle2(input, repo, file);
+  } catch {}
+}
 // packages/workit-core/src/hooks/hosts/fields.ts
 import { existsSync as existsSync6, realpathSync as realpathSync6, statSync as statSync2 } from "node:fs";
-import path17 from "node:path";
+import path18 from "node:path";
 var isRecord4 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 var nonEmpty2 = (value) => typeof value === "string" && value.trim() !== "";
 var optionalText = (value) => typeof value === "string" ? value : null;
 var existingDirectory = (value) => {
-  if (!nonEmpty2(value) || !path17.isAbsolute(value) || !existsSync6(value))
+  if (!nonEmpty2(value) || !path18.isAbsolute(value) || !existsSync6(value))
     return null;
   try {
     return statSync2(value).isDirectory() ? realpathSync6(value) : null;
@@ -16897,8 +17629,8 @@ var existingDirectory = (value) => {
     return null;
   }
 };
-var SHELLS = new Set(["sh", "bash", "zsh", "dash", "pwsh", "powershell", "cmd"]);
-var SCRIPT_FLAG = /^(?:-\w*c|-command|\/c)$/i;
+var SHELLS2 = new Set(["sh", "bash", "zsh", "dash", "pwsh", "powershell", "cmd"]);
+var SCRIPT_FLAG2 = /^(?:-\w*c|-command|\/c)$/i;
 var quoteArg = (arg) => /^[\w@%+=:,./-]+$/.test(arg) ? arg : JSON.stringify(arg);
 var commandText = (value) => {
   if (nonEmpty2(value))
@@ -16909,9 +17641,9 @@ var commandText = (value) => {
   if (!argv.every((arg) => typeof arg === "string"))
     return null;
   const shell = argv[0].split(/[\\/]/).at(-1)?.replace(/\.exe$/i, "").toLowerCase() ?? "";
-  if (SHELLS.has(shell))
+  if (SHELLS2.has(shell))
     for (let index = 1;index < argv.length - 1; index++) {
-      if (SCRIPT_FLAG.test(argv[index]))
+      if (SCRIPT_FLAG2.test(argv[index]))
         return nonEmpty2(argv[index + 1]) ? argv[index + 1] : null;
       if (!/^[-/]/.test(argv[index]))
         break;
@@ -16952,7 +17684,7 @@ var writePaths = (input) => {
 };
 // packages/workit-core/src/hooks/handle.ts
 var usable2 = (value) => value === "native" || value === "partial";
-var NONE3 = { kind: "none" };
+var NONE4 = { kind: "none" };
 var offered = new Set;
 var CLAUDE_WORKTREE_IMPLEMENTER = "workit:implementer";
 var CLAUDE_JUDGES = new Set(["workit:verifier", "workit:reviewer"]);
@@ -16971,7 +17703,7 @@ function handleHook(input, deps) {
   switch (event.kind) {
     case "session.start": {
       if (!usable2(descriptor.context.sessionStart))
-        return NONE3;
+        return NONE4;
       const key = input.session.id ? `${input.host}\x00${input.session.id}` : null;
       const offer = event.source === "startup" && (key === null || !offered.has(key));
       if (offer && key !== null)
@@ -16986,19 +17718,34 @@ function handleHook(input, deps) {
     }
     case "context.turn": {
       if (!usable2(descriptor.context.perTurn))
-        return NONE3;
+        return NONE4;
       const text = turnContextText(input, descriptor);
-      return text ? { kind: "context", text } : NONE3;
+      return text ? { kind: "context", text } : NONE4;
     }
     case "shell.pre": {
-      const policy = usable2(descriptor.shellPolicy.deny) ? shellPolicy(input.cwd, event.command) : NONE3;
-      if (policy.kind !== "none" || !usable2(descriptor.events["write.pre"].support))
+      const canDeny = usable2(descriptor.shellPolicy.deny);
+      const policy = canDeny ? shellPolicy(input.cwd, event.command) : NONE4;
+      if (policy.kind !== "none")
         return policy;
-      const writes = shellWrites(event.command);
-      return writes.writes ? writeGate(input.cwd, writes.targets) : NONE3;
+      const postTool = usable2(descriptor.events["shell.post"].support);
+      if (!postTool)
+        settlePendingCommit(input);
+      const raw = canDeny ? rawGitPre(input, event.command) : NONE4;
+      if (raw.kind === "deny")
+        return raw;
+      const writes = usable2(descriptor.events["write.pre"].support) ? shellWrites(event.command) : { writes: false, targets: null };
+      const gate = writes.writes ? writeGate(input.cwd, writes.targets) : NONE4;
+      if (gate.kind === "deny")
+        return gate;
+      noteRawCommit(input, event.command, postTool ? callKey(event.toolUseId, event.command) : NEXT_COMMAND);
+      return raw;
     }
+    case "shell.post":
+      if (usable2(descriptor.events["shell.post"].support))
+        rawGitPost(input, event.command, callKey(event.toolUseId, event.command));
+      return NONE4;
     case "write.pre":
-      return usable2(descriptor.events["write.pre"].support) ? writeGate(input.cwd, event.paths) : NONE3;
+      return usable2(descriptor.events["write.pre"].support) ? writeGate(input.cwd, event.paths) : NONE4;
     case "subagent.start":
       return {
         kind: "context",
@@ -17010,19 +17757,18 @@ function handleHook(input, deps) {
         userMessage: "Workit context may be stale after compaction; re-run inspection or resume before acting."
       };
     case "tool.pre":
-    case "shell.post":
     case "subagent.stop":
     case "prompt.submit":
     case "stop":
-      return NONE3;
+      return NONE4;
   }
 }
 var failureDecision = (descriptor, event, error) => {
   if (event === "shell.pre" || event === "tool.pre" || event === "write.pre")
-    return descriptor.shellPolicy.failClosed ? { kind: "deny", reason: error, unblock: null } : NONE3;
+    return descriptor.shellPolicy.failClosed ? { kind: "deny", reason: error, unblock: null } : NONE4;
   if (event === "session.start" || event === "subagent.start")
     return { kind: "context", text: `[workit diagnostic: ${error}]` };
-  return NONE3;
+  return NONE4;
 };
 var dispatchHook = (adapter, raw, env = process.env) => {
   const parsed = adapter.parse(raw, env);
@@ -17145,6 +17891,7 @@ var EVENTS = {
 };
 var SOURCES = new Set(["startup", "resume", "clear", "compact", "fork"]);
 var SHELL_TOOLS = new Set(["Bash", "PowerShell"]);
+var dialectOf2 = (value) => value.tool_name === "PowerShell" ? "powershell" : "posix";
 var toolCommand = (value) => isRecord4(value.tool_input) ? commandText(value.tool_input.command) : null;
 var eventOf = (name, value) => {
   const toolUseId = optionalText(value.tool_use_id);
@@ -17169,7 +17916,7 @@ var eventOf = (name, value) => {
       if (!SHELL_TOOLS.has(value.tool_name))
         return { ok: true, event: { kind: "tool.pre", tool: value.tool_name, toolUseId } };
       const command = toolCommand(value);
-      return command ? { ok: true, event: { kind: "shell.pre", command, toolUseId } } : { ok: false, error: `tool_input.command is required for ${value.tool_name}` };
+      return command ? { ok: true, event: { kind: "shell.pre", command, toolUseId, dialect: dialectOf2(value) } } : { ok: false, error: `tool_input.command is required for ${value.tool_name}` };
     }
     case "PostToolUse": {
       const command = toolCommand(value);
@@ -17183,7 +17930,8 @@ var eventOf = (name, value) => {
           command,
           stdout: optionalText(response.stdout) ?? "",
           exitCode: typeof response.exit_code === "number" ? response.exit_code : null,
-          toolUseId
+          toolUseId,
+          dialect: dialectOf2(value)
         }
       };
     }
@@ -17224,7 +17972,13 @@ var eventOf = (name, value) => {
       };
   }
 };
-var CONTEXT_EVENTS = new Set(["SessionStart", "UserPromptSubmit", "SubagentStart"]);
+var CONTEXT_EVENTS = new Set([
+  "SessionStart",
+  "UserPromptSubmit",
+  "SubagentStart",
+  "PreToolUse",
+  "PostToolUse"
+]);
 var render = (decision, native) => {
   if (decision.kind === "deny" && native === "PreToolUse")
     return {
@@ -17306,7 +18060,7 @@ var CODEX_DESCRIPTOR = {
     "shell.pre": { support: "native", native: "PreToolUse" },
     "tool.pre": { support: "native", native: "PreToolUse" },
     "write.pre": { support: "undocumented", native: null },
-    "shell.post": undocumented,
+    "shell.post": { support: "native", native: "PostToolUse" },
     "subagent.start": { support: "native", native: "SubagentStart" },
     "subagent.stop": { support: "native", native: "SubagentStop" },
     "prompt.submit": undocumented,
@@ -17327,7 +18081,7 @@ var CODEX_DESCRIPTOR = {
     worktreeIsolation: "undocumented",
     maxConcurrency: "undocumented"
   },
-  provenance: { sessionId: "native", agentIdOnTool: "partial", postToolObserve: "undocumented" },
+  provenance: { sessionId: "native", agentIdOnTool: "partial", postToolObserve: "native" },
   interaction: { questions: "none", writeBoundary: "partial" },
   stopControl: "undocumented",
   shellAvailable: "native",
@@ -17393,6 +18147,7 @@ var CODEX_DESCRIPTOR = {
 var EVENTS2 = {
   SessionStart: "session.start",
   PreToolUse: "shell.pre",
+  PostToolUse: "shell.post",
   SubagentStart: "subagent.start",
   SubagentStop: "subagent.stop"
 };
@@ -17406,10 +18161,11 @@ var parseCodexHookInput = (value) => {
   const cwd = existingDirectory(value.cwd);
   if (!cwd)
     return { ok: false, error: "cwd must be an existing absolute directory" };
-  if (event === "PreToolUse" && !nonEmpty2(value.tool_name))
+  const toolEvent = event === "PreToolUse" || event === "PostToolUse";
+  if (toolEvent && !nonEmpty2(value.tool_name))
     return { ok: false, error: "tool_name is required" };
   const command = isRecord4(value.tool_input) ? commandText(value.tool_input.command) : null;
-  if (event === "PreToolUse" && isShellTool(value.tool_name) && !command)
+  if (toolEvent && isShellTool(value.tool_name) && !command)
     return { ok: false, error: "tool_input.command is required for shell tools" };
   if (event === "SubagentStart" && !nonEmpty2(value.agent_id))
     return { ok: false, error: "agent_id is required" };
@@ -17425,7 +18181,8 @@ var parseCodexHookInput = (value) => {
       ...event === "SessionStart" ? { source: SOURCES2.has(String(value.source)) ? value.source : "resume" } : {},
       ...nonEmpty2(value.turn_id) ? { turn_id: value.turn_id } : {},
       ...nonEmpty2(value.tool_name) ? { tool_name: value.tool_name } : {},
-      ...event === "PreToolUse" ? { tool_input: value.tool_input } : {},
+      ...toolEvent ? { tool_input: value.tool_input } : {},
+      ...event === "PostToolUse" && typeof value.tool_response === "string" ? { tool_response: value.tool_response } : {},
       ...command ? { command } : {},
       ...nonEmpty2(value.tool_use_id) ? { tool_use_id: value.tool_use_id } : {},
       ...nonEmpty2(value.agent_id) ? { agent_id: value.agent_id } : {},
@@ -17450,6 +18207,16 @@ var protocolEvent = (input) => {
         toolUseId
       } : { kind: "tool.pre", tool: input.tool_name, toolUseId };
     }
+    case "PostToolUse": {
+      const toolUseId = input.tool_use_id ?? null;
+      return isShellTool(input.tool_name) ? {
+        kind: "shell.post",
+        command: input.command ?? "",
+        stdout: input.tool_response ?? "",
+        exitCode: null,
+        toolUseId
+      } : { kind: "tool.pre", tool: input.tool_name, toolUseId };
+    }
     case "SubagentStart":
       return {
         kind: "subagent.start",
@@ -17514,11 +18281,11 @@ var codexAdapter = {
     };
   },
   render: render2,
-  addendum: (input) => `<workit-codex-mutations>Codex MCP is read-only: unattested callers cannot mutate. Run workit verbs with the workit CLI on the shell (node_modules/.bin/workit, or npx -y @brainervirus/workit-cli): check, git branch|commit|push, pr, ci, stack, ledger, handoff; task-family mutations take --json${input.session.id ? ` --actor ${input.session.id}` : ""}. A verifier or reviewer records workit ledger verdict under a session the lead assigns (WORKIT_SESSION_ID=<lead>-v<n>), never the author's. Merge and release need a workspace grant (workit grant show); a question answer is not host permission.</workit-codex-mutations>`
+  addendum: (input) => `<workit-codex-mutations>Codex MCP is read-only: unattested callers cannot mutate. Run workit verbs with the workit CLI on the shell (node_modules/.bin/workit, or npx -y @brainervirus/workit-cli): check, git branch|commit|push, pr, ci, stack, ledger, handoff; task-family mutations take --json${input.session.id ? ` --actor ${input.session.id}` : ""}. workit acts as this thread (CODEX_THREAD_ID${input.session.id ? `=${input.session.id}` : ""}) unless WORKIT_SESSION_ID is set. A verifier or reviewer records workit ledger verdict under a session the lead assigns (WORKIT_HOST=codex_cli WORKIT_SESSION_ID=<lead>-v<n>), never the author's. Merge and release need a workspace grant (workit grant show); a question answer is not host permission.</workit-codex-mutations>`
 };
 
 // packages/workit-core/src/hooks/hosts/cursor.ts
-import path18 from "node:path";
+import path19 from "node:path";
 var undocumented2 = { support: "undocumented", native: null };
 var none = { support: "none", native: null };
 var CURSOR_DESCRIPTOR = {
@@ -17699,7 +18466,7 @@ var protocolEvent2 = (input) => {
       return { kind: "compact.pre", trigger: "auto" };
   }
 };
-var within = (root, dir) => dir === root || dir.startsWith(root.endsWith(path18.sep) ? root : `${root}${path18.sep}`);
+var within = (root, dir) => dir === root || dir.startsWith(root.endsWith(path19.sep) ? root : `${root}${path19.sep}`);
 var hookCwd = (input) => {
   const cwd = existingDirectory(input.cwd);
   if (cwd && input.hook_event_name === "beforeShellExecution")
@@ -17722,6 +18489,8 @@ var render3 = (decision, native) => {
       json: cursorDeny(decision.reason),
       exitCode: native !== null && BLOCKING.has(native) ? 2 : 0
     };
+  if (decision.kind === "context" && native === "beforeShellExecution")
+    return { json: { permission: "allow", agent_message: decision.text }, exitCode: 0 };
   if (decision.kind === "context")
     return { json: { additional_context: decision.text }, exitCode: 0 };
   if (decision.kind === "notice")
@@ -17758,7 +18527,8 @@ var cursorAdapter = {
       }
     };
   },
-  render: render3
+  render: render3,
+  addendum: (input) => input.session.id ? `<workit-session>Cursor puts no session id in the shell: prefix workit commands that record authorship with WORKIT_SESSION_ID=${input.session.id} (e.g. \`WORKIT_SESSION_ID=${input.session.id} workit git commit -m …\`). A verifier uses its own id, never this one.</workit-session>` : null
 };
 
 // packages/workit-core/src/hooks/run.ts