@brainervirus/workit-cursor 8.1.0 → 8.3.0

package/dist/cursor-session-start.js

@@ -8572,9 +8572,27 @@ 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);
+}
 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;
+}
 var MAX_BUFFER, GIT_TIMEOUTS, git = (cwd, args, options = {}) => {
   const result = spawnSync("git", args, {
     cwd,
@@ -8603,13 +8621,44 @@ var MAX_BUFFER, GIT_TIMEOUTS, git = (cwd, args, options = {}) => {
   const { atimeNs, mtimeNs } = fs.statSync(from, { bigint: true });
   const seconds = (ns) => (Number(ns / 1000n) - 1) / 1e6;
   fs.utimesSync(to, seconds(atimeNs), seconds(mtimeNs));
-};
+}, config2 = (cwd, key) => line(git(cwd, ["config", "--get", key]));
 var init_rev = __esm(() => {
   MAX_BUFFER = 256 * 1024 * 1024;
   GIT_TIMEOUTS = { local: 20000, worktree: 120000, network: 15000 };
   MAX_UNTRACKED_BYTES = 5 * 1024 * 1024;
 });
 
+// packages/workit-core/src/host-session.ts
+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 };
+}
+var HOST_SESSION_VARS, family = (host) => host?.replace(/_(?:cli|desktop)$/, "") ?? null;
+var init_host_session = __esm(() => {
+  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"
+    ]
+  ];
+});
+
 // packages/workit-core/src/store/paths.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
@@ -8952,6 +9001,74 @@ function ledgerPath(cwd) {
   const root = storeRoot(cwd);
   return root.ok ? { ok: true, value: path3.join(root.value.root, "ledger", "ledger.jsonl") } : root;
 }
+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}`);
+  }
+}
+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" }, {});
+}
 function supersedeAllowed(by, target) {
   if (by.type !== target.type)
     return `a ${by.type} row cannot supersede a ${target.type} row`;
@@ -9169,7 +9286,7 @@ function checkVerdicts(cwd, branch, rows) {
     authors: [...authors].toSorted()
   };
 }
-var LEDGER_VERSION = 1, PASSING, FAILING, STRONG_RESULTS, PR_ROW_TYPES, err = (code, error, unblock) => ({
+var LEDGER_VERSION = 1, MAX_LINE_BYTES = 4096, PASSING, FAILING, STRONG_RESULTS, PR_ROW_TYPES, err = (code, error, unblock) => ({
   ok: false,
   code,
   error,
@@ -9199,7 +9316,32 @@ var LEDGER_VERSION = 1, PASSING, FAILING, STRONG_RESULTS, PR_ROW_TYPES, err = (c
   const run = gitRun2(cwd, args);
   const value = run.ok ? run.stdout.trim() : "";
   return value ? value : null;
-}, safeRef = (value) => value.length > 0 && !value.startsWith("-"), NETWORK_FS_TYPES, isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value), str = (value) => typeof value === "string" ? value : null, normalizeActor = (value) => {
+}, safeRef = (value) => value.length > 0 && !value.startsWith("-"), newId2 = () => `${Date.now().toString(36)}-${randomBytes(6).toString("hex")}`, NETWORK_FS_TYPES, isNetworkFsType = (type) => NETWORK_FS_TYPES.has(type >>> 0), onNetworkFs = (dir) => {
+  if (process.platform !== "linux")
+    return false;
+  try {
+    return isNetworkFsType(fs3.statfsSync(dir).type);
+  } catch {
+    return false;
+  }
+}, LOCK_WAIT_MS = 5000, LOCK_STALE_MS = 30000, LOCK_OWNER = "owner", lockToken = (lock) => {
+  try {
+    return fs3.readFileSync(path3.join(lock, LOCK_OWNER), "utf8");
+  } catch {
+    return null;
+  }
+}, lockAgeMs = (lock) => {
+  for (const target of [path3.join(lock, LOCK_OWNER), lock]) {
+    try {
+      return Date.now() - fs3.statSync(target).mtimeMs;
+    } catch {}
+  }
+  return null;
+}, ledgerLock, serialize = (row, now) => {
+  const full = { v: LEDGER_VERSION, id: newId2(), at: now.toISOString(), ...row };
+  return { full, line: `${JSON.stringify(full)}
+` };
+}, isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value), str = (value) => typeof value === "string" ? value : null, normalizeActor = (value) => {
   const actor = isRecord(value) ? value : {};
   return {
     host: str(actor.host) ?? "unknown",
@@ -9218,6 +9360,7 @@ var LEDGER_VERSION = 1, PASSING, FAILING, STRONG_RESULTS, PR_ROW_TYPES, err = (c
 }, OBSERVED_ONLY;
 var init_ledger = __esm(() => {
   init_rev();
+  init_host_session();
   init_paths();
   PASSING = new Set(["verified", "tests-verified", "type-check-only"]);
   FAILING = new Set(["failed", "blocked"]);
@@ -9235,6 +9378,57 @@ var init_ledger = __esm(() => {
     1196443219,
     198183888
   ]);
+  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;
+    }
+  };
   OBSERVED_ONLY = new Set(["check", "merge.unverified", ...PR_ROW_TYPES]);
 });
 
@@ -10217,6 +10411,7 @@ var init_branch_policy = __esm(() => {
 });
 
 // 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";
@@ -10336,6 +10531,46 @@ var nonBlank, branchPreset, commitPreset, workspaceBranchPolicySchema, workspace
     };
   }
   return { ok: true };
+}, WorkspaceConfigError, mainCheckouts, 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;
+}, 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;
 }, realpathOf = (p) => {
   const real = realpathSync.native ?? realpathSync;
   try {
@@ -10357,41 +10592,27 @@ var nonBlank, branchPreset, commitPreset, workspaceBranchPolicySchema, workspace
     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];
 }, 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;
 }, 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);
 }, runtimeWorkspacePolicySchema = (kind) => {
   const key = kind === "branch" ? "branchPolicy" : kind === "commit" ? "commitPolicy" : "vcs";
@@ -10409,7 +10630,7 @@ var nonBlank, branchPreset, commitPreset, workspaceBranchPolicySchema, workspace
     profiles: record(nonBlank, profileSchema).optional()
   }).passthrough();
   return entrySchema;
-}, runtimeWorkspaceIndexSchema, matchRuntimeWorkspace = (cwd) => {
+}, resolveRuntimeWorkspaceVcs = (cwd) => resolveRuntimeWorkspaceCandidate(cwd, "vcs"), runtimeWorkspaceIndexSchema, matchRuntimeWorkspace = (cwd) => {
   const file = path6.join(configDir(), "workspaces.json");
   let raw;
   try {
@@ -10417,31 +10638,26 @@ var nonBlank, branchPreset, commitPreset, workspaceBranchPolicySchema, workspace
   } 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;
@@ -10456,7 +10672,7 @@ var nonBlank, branchPreset, commitPreset, workspaceBranchPolicySchema, workspace
   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;
 }, resolveRuntimeWorkspacePolicy = (cwd, kind, requestedProfile) => {
@@ -10466,10 +10682,10 @@ var nonBlank, branchPreset, commitPreset, workspaceBranchPolicySchema, workspace
   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 {
@@ -10600,6 +10816,10 @@ var init_workspaces = __esm(() => {
   });
   UNSUPPORTED_GLOB = /[?[\]{}]/;
   UNSUPPORTED_EXTGLOB = /[@+*]\(|!/;
+  WorkspaceConfigError = class WorkspaceConfigError extends Error {
+    name = "WorkspaceConfigError";
+  };
+  mainCheckouts = new Map;
   runtimeWorkspaceIndexSchema = object({
     workspaces: array(object({ name: nonBlank, glob: nonBlank }).passthrough()).optional()
   }).passthrough();
@@ -11378,7 +11598,7 @@ var packageRoot = () => {
 var init_package_root = () => {};
 
 // 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, FOREIGN_LOCK_TTL_MS, UNREADABLE_LOCK_TTL_MS = 30000, RECLAIM_GUARD_TTL_MS = 30000, defaultLockTimeoutMs = 250, defaultLockTimeout = () => defaultLockTimeoutMs, parseMetadataLock = (raw) => {
@@ -11413,7 +11633,7 @@ var metadataLockSchema, FOREIGN_LOCK_TTL_MS, UNREADABLE_LOCK_TTL_MS = 30000, REC
   }
   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
       });
@@ -13507,14 +13727,16 @@ var MIGRATION_PENDING = "workit migration pending", STORE_FORMAT = 3, STORE_MIN_
     heldInProcess.delete(lock);
 }, 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")
   };
 };
 var init_task_store = __esm(() => {
   init_file_lock();
+  init_host_session();
   init_package_root();
   init_task_contract();
   init_store_lock();
@@ -13535,7 +13757,7 @@ var init_workers = __esm(() => {
 });
 
 // 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";
 function splitCommand(command) {
@@ -13703,7 +13925,7 @@ function checkCommand(args, version, onPath = workitAvailable()) {
   return onPath ? `workit check ${args}` : `npx -y @brainervirus/workit-cli@${version} check ${args}`;
 }
 var SCRIPT_CHECKS, CHECKS_FILE = "workit.checks.json", isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), SHELL_META, git3 = (cwd, args) => {
-  const run = spawnSync6("git", args, {
+  const run = spawnSync7("git", args, {
     cwd,
     encoding: "utf8",
     timeout: 20000,
@@ -13738,7 +13960,7 @@ var init_check_config = __esm(() => {
 // 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";
 function captureCandidate(root, scope, environment = []) {
   let checkout;
@@ -13816,7 +14038,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;
@@ -14189,7 +14411,7 @@ var digestBytes = (value) => createHash8("sha256").update(value).digest("hex"),
   }
   return left.length - right.length;
 }, 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"
   });
@@ -14202,7 +14424,7 @@ var digestBytes = (value) => createHash8("sha256").update(value).digest("hex"),
     };
   }
   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))
@@ -16594,7 +16816,7 @@ var withReleaseTracks = (workspaceRoot, policy) => {
       error: `policy_unavailable: cannot validate branch ${JSON.stringify(name)} because ${error instanceof Error ? error.message : String(error)}; ${correction}`
     };
   }
-};
+}, resolveBranchPolicyFor = (workspaceRoot, profileName) => effectiveWorkspacePolicy(workspaceRoot, "branch", profileName).branchPolicy;
 var init_branch = __esm(() => {
   init_branch_policy();
   init_commit_flavors();
@@ -16632,52 +16854,40 @@ var init_policy = __esm(() => {
   init_route_intent();
 });
 
-// packages/workit-core/src/hooks/write-gate.ts
-import { realpathSync as realpathSync5 } from "node:fs";
-import path16 from "node:path";
-function writeGate(cwd, paths) {
-  try {
-    const gate = gateFor(cwd);
-    if (!gate || gate.blockers.length === 0)
-      return NONE2;
-    if (paths && paths.every((file) => exempt(cwd, gate.root, file, gate.plans)))
-      return NONE2;
-    const reasons = gate.blockers.map((item) => `${item.ruleId}: ${item.reason}`).join("; ");
-    return {
-      kind: "deny",
-      reason: `workit before-write gate: ${reasons}. Markdown, docs/, plans/ and files outside the checkout stay writable.`,
-      unblock: gate.blockers[0].reason
-    };
-  } catch {
-    return NONE2;
-  }
-}
-var NONE2, CASE_INSENSITIVE, 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;
   }
-}, 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);
-}, segmentsOf = (command) => {
+  return -1;
+}, unquote = (body, quote, dialect) => {
+  if (quote === "'")
+    return dialect === "powershell" ? body.replaceAll("''", "'") : body;
+  return dialect === "posix" ? body.replace(/\\(["\\$`])/g, "$1") : body.replace(/`(.)/g, "$1");
+}, 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;
@@ -16701,11 +16911,11 @@ var NONE2, CASE_INSENSITIVE, canonical2 = (file) => {
   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 === `
@@ -16722,7 +16932,14 @@ var NONE2, CASE_INSENSITIVE, canonical2 = (file) => {
       }
     } 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();
@@ -16740,7 +16957,7 @@ var NONE2, CASE_INSENSITIVE, canonical2 = (file) => {
         inWord = true;
       }
       pending = "redirect";
-    } else if (char === "<") {
+    } else if (char === "<" && dialect === "posix") {
       flushWord();
       if (command[index + 1] === "<") {
         index++;
@@ -16756,6 +16973,47 @@ var NONE2, CASE_INSENSITIVE, canonical2 = (file) => {
   }
   flushSegment();
   return segments;
+};
+
+// packages/workit-core/src/hooks/write-gate.ts
+import { realpathSync as realpathSync5 } from "node:fs";
+import path16 from "node:path";
+function writeGate(cwd, paths) {
+  try {
+    const gate = gateFor(cwd);
+    if (!gate || gate.blockers.length === 0)
+      return NONE2;
+    if (paths && paths.every((file) => exempt(cwd, gate.root, file, gate.plans)))
+      return NONE2;
+    const reasons = gate.blockers.map((item) => `${item.ruleId}: ${item.reason}`).join("; ");
+    return {
+      kind: "deny",
+      reason: `workit before-write gate: ${reasons}. Markdown, docs/, plans/ and files outside the checkout stay writable.`,
+      unblock: gate.blockers[0].reason
+    };
+  } catch {
+    return NONE2;
+  }
+}
+var NONE2, CASE_INSENSITIVE, 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);
+    }
+  }
+}, 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);
 }, PREFIXES2, operands = (words) => words.filter((item) => !item.startsWith("-")), editsOf = (input) => {
   let words = input;
   while (words.length && (PREFIXES2.has(words[0]) || /^\w+=/.test(words[0])))
@@ -16893,18 +17151,461 @@ var init_write_gate = __esm(() => {
   cache2 = new Map;
 });
 
+// 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";
+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;
+}
+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;
+}
+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;
+  }
+}
+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 {}
+}
+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 {}
+}
+var NONE3, SHELLS, PREFIXES3, SCRIPT_FLAG, CD, PUSHD, POPD, GIT_VALUE_OPTIONS, isAbsolute = (value) => path17.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\"), 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);
+}, 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;
+}, 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;
+  }
+}, commandName = (word) => (word?.split(/[\\/]/).at(-1) ?? "").toLowerCase().replace(/\.exe$/, ""), PUSH_VALUE_OPTIONS, 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 };
+}, VALUE_OPTIONS, 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;
+}, repoAt = (dir) => {
+  const location = resolveStore(dir);
+  if (location instanceof Error || !location.shared)
+    return null;
+  return { location, dir, branch: resolveTaskKey(dir, location).branch };
+}, isWorkitWorkspace = (repo) => {
+  if (fs12.existsSync(repo.location.dir))
+    return true;
+  try {
+    return resolveRuntimeWorkspaceVcs(repo.location.top ?? repo.dir) !== null;
+  } catch {
+    return false;
+  }
+}, guardedBranch = (dir, branch) => {
+  try {
+    const policy = resolveBranchPolicyFor(dir);
+    return policy.protected.has(branch.toLowerCase()) || policy.defaultTargetBranch.toLowerCase() === branch.toLowerCase();
+  } catch {
+    return false;
+  }
+}, toPushRemote = (repo, remote) => {
+  if (remote === null)
+    return true;
+  try {
+    const pushRemote = pushRemoteName(repo.dir, repo.branch);
+    return pushRemote === null || pushRemote === remote;
+  } catch {
+    return false;
+  }
+}, 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;
+  }
+}, quote = (text) => `\`${text}\``, 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")}.`;
+}, 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;
+  }
+}, 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;
+}, mentionsRawTool = (command) => /\b(?:git|gh|glab)\b/i.test(command), dialectOf = (input) => (input.event.kind === "shell.pre" || input.event.kind === "shell.post" ? input.event.dialect : undefined) ?? "posix", deny = (reason) => ({ kind: "deny", reason, unblock: null }), NEXT_COMMAND = "next", MARKER_TTL_SECONDS = 3600, markerFile = (repo, session, key) => path17.join(repo.location.dir, "hooks", `commit-${createHash10("sha256").update(`${session}\x00${key}`).digest("hex").slice(0, 32)}.json`), callKey = (toolUseId, command) => toolUseId ?? `cmd:${createHash10("sha256").update(command).digest("hex")}`, 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;
+}, 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"
+  });
+};
+var init_raw_git = __esm(() => {
+  init_branch();
+  init_workspaces();
+  init_rev();
+  init_ledger();
+  init_paths();
+  NONE3 = { kind: "none" };
+  SHELLS = new Set(["sh", "bash", "zsh", "dash", "ksh"]);
+  PREFIXES3 = new Set(["sudo", "command", "env", "nohup", "time", "exec", "nice", "&"]);
+  SCRIPT_FLAG = /^-[a-zA-Z]*c[a-zA-Z]*$/;
+  CD = new Set(["cd", "chdir", "set-location", "sl"]);
+  PUSHD = new Set(["pushd", "push-location"]);
+  POPD = new Set(["popd", "pop-location"]);
+  GIT_VALUE_OPTIONS = new Set([
+    "-c",
+    "--git-dir",
+    "--work-tree",
+    "--namespace",
+    "--exec-path",
+    "--config-env",
+    "--super-prefix"
+  ]);
+  PUSH_VALUE_OPTIONS = new Set(["-o", "--push-option", "--receive-pack", "--exec", "--repo"]);
+  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"]))
+  };
+});
+
 // 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), nonEmpty2 = (value) => typeof value === "string" && value.trim() !== "", optionalText = (value) => typeof value === "string" ? value : null, 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;
   } catch {
     return null;
   }
-}, SHELLS, SCRIPT_FLAG, quoteArg = (arg) => /^[\w@%+=:,./-]+$/.test(arg) ? arg : JSON.stringify(arg), commandText = (value) => {
+}, SHELLS2, SCRIPT_FLAG2, quoteArg = (arg) => /^[\w@%+=:,./-]+$/.test(arg) ? arg : JSON.stringify(arg), commandText = (value) => {
   if (nonEmpty2(value))
     return value;
   if (!Array.isArray(value) || value.length === 0)
@@ -16913,9 +17614,9 @@ var isRecord4 = (value) => value !== null && typeof value === "object" && !Array
   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;
@@ -16933,8 +17634,8 @@ var isRecord4 = (value) => value !== null && typeof value === "object" && !Array
   return [...new Set(paths)];
 };
 var init_fields = __esm(() => {
-  SHELLS = new Set(["sh", "bash", "zsh", "dash", "pwsh", "powershell", "cmd"]);
-  SCRIPT_FLAG = /^(?:-\w*c|-command|\/c)$/i;
+  SHELLS2 = new Set(["sh", "bash", "zsh", "dash", "pwsh", "powershell", "cmd"]);
+  SCRIPT_FLAG2 = /^(?:-\w*c|-command|\/c)$/i;
   WRITE_TOOLS = new Set([
     "write",
     "edit",
@@ -16964,7 +17665,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)
@@ -16979,19 +17680,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",
@@ -17003,14 +17719,13 @@ 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 usable2 = (value) => value === "native" || value === "partial", NONE3, offered, CLAUDE_WORKTREE_IMPLEMENTER = "workit:implementer", CLAUDE_JUDGES, subagentSession = (session, agentId) => [session, agentId].filter((part) => Boolean(part)).join(":").replace(/[^A-Za-z0-9_.:@/+-]/g, "-").slice(0, 128), subagentStartText = (host, session, descriptor, event) => {
+var usable2 = (value) => value === "native" || value === "partial", NONE4, offered, CLAUDE_WORKTREE_IMPLEMENTER = "workit:implementer", CLAUDE_JUDGES, subagentSession = (session, agentId) => [session, agentId].filter((part) => Boolean(part)).join(":").replace(/[^A-Za-z0-9_.:@/+-]/g, "-").slice(0, 128), subagentStartText = (host, session, descriptor, event) => {
   if (host === "claude_code" && event.agentType === CLAUDE_WORKTREE_IMPLEMENTER)
     return `Workit observed ${descriptor.label} subagent ${event.agentId} (${event.agentType}) working in its own git worktree: it may edit and commit there, within its brief's scope. Before the first commit, switch to a policy-compliant branch with \`workit git branch <branch> --base <base>\` (e.g. feature/<slug>); branch policy hooks still deny protected or non-compliant branches. Never record a verdict on your own work. Never push, open a PR, or merge unless the brief asks for it.`;
   const readOnly = `Workit observed ${descriptor.label} subagent ${event.agentId} (${event.agentType}) as read-only/agent-guided.`;
@@ -17019,10 +17734,10 @@ var usable2 = (value) => value === "native" || value === "partial", NONE3, offer
   return readOnly;
 }, 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;
 }, dispatchHook = (adapter, raw, env = process.env) => {
   const parsed = adapter.parse(raw, env);
   if (!parsed.ok)
@@ -17048,14 +17763,15 @@ var usable2 = (value) => value === "native" || value === "partial", NONE3, offer
 var init_handle = __esm(() => {
   init_context();
   init_policy();
+  init_raw_git();
   init_write_gate();
-  NONE3 = { kind: "none" };
+  NONE4 = { kind: "none" };
   offered = new Set;
   CLAUDE_JUDGES = new Set(["workit:verifier", "workit:reviewer"]);
 });
 
 // packages/workit-core/src/hooks/hosts/claude-code.ts
-var CLAUDE_CODE_DESCRIPTOR, EVENTS, SOURCES, SHELL_TOOLS, toolCommand = (value) => isRecord4(value.tool_input) ? commandText(value.tool_input.command) : null, eventOf = (name, value) => {
+var CLAUDE_CODE_DESCRIPTOR, EVENTS, SOURCES, SHELL_TOOLS, dialectOf2 = (value) => value.tool_name === "PowerShell" ? "powershell" : "posix", toolCommand = (value) => isRecord4(value.tool_input) ? commandText(value.tool_input.command) : null, eventOf = (name, value) => {
   const toolUseId = optionalText(value.tool_use_id);
   switch (name) {
     case "SessionStart":
@@ -17078,7 +17794,7 @@ var CLAUDE_CODE_DESCRIPTOR, EVENTS, SOURCES, SHELL_TOOLS, toolCommand = (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);
@@ -17092,7 +17808,8 @@ var CLAUDE_CODE_DESCRIPTOR, EVENTS, SOURCES, SHELL_TOOLS, toolCommand = (value)
           command,
           stdout: optionalText(response.stdout) ?? "",
           exitCode: typeof response.exit_code === "number" ? response.exit_code : null,
-          toolUseId
+          toolUseId,
+          dialect: dialectOf2(value)
         }
       };
     }
@@ -17255,7 +17972,13 @@ var init_claude_code = __esm(() => {
   };
   SOURCES = new Set(["startup", "resume", "clear", "compact", "fork"]);
   SHELL_TOOLS = new Set(["Bash", "PowerShell"]);
-  CONTEXT_EVENTS = new Set(["SessionStart", "UserPromptSubmit", "SubagentStart"]);
+  CONTEXT_EVENTS = new Set([
+    "SessionStart",
+    "UserPromptSubmit",
+    "SubagentStart",
+    "PreToolUse",
+    "PostToolUse"
+  ]);
   claudeCodeAdapter = {
     descriptor: CLAUDE_CODE_DESCRIPTOR,
     parse(raw) {
@@ -17309,10 +18032,11 @@ var undocumented, CODEX_DESCRIPTOR, EVENTS2, SHELL_TOOLS2, isShellTool = (name)
   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" };
@@ -17328,7 +18052,8 @@ var undocumented, CODEX_DESCRIPTOR, EVENTS2, SHELL_TOOLS2, isShellTool = (name)
       ...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 } : {},
@@ -17352,6 +18077,16 @@ var undocumented, CODEX_DESCRIPTOR, EVENTS2, SHELL_TOOLS2, isShellTool = (name)
         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",
@@ -17400,7 +18135,7 @@ var init_codex = __esm(() => {
       "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,
@@ -17421,7 +18156,7 @@ var init_codex = __esm(() => {
       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",
@@ -17487,6 +18222,7 @@ var init_codex = __esm(() => {
   EVENTS2 = {
     SessionStart: "session.start",
     PreToolUse: "shell.pre",
+    PostToolUse: "shell.post",
     SubagentStart: "subagent.start",
     SubagentStop: "subagent.stop"
   };
@@ -17521,12 +18257,12 @@ var init_codex = __esm(() => {
       };
     },
     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, none, CURSOR_DESCRIPTOR, EVENTS3, parseCursorHookInput = (value) => {
   if (!isRecord4(value) || !Object.hasOwn(EVENTS3, String(value.hook_event_name)))
     return { ok: false, error: "hook_event_name is required" };
@@ -17595,7 +18331,7 @@ var undocumented2, none, CURSOR_DESCRIPTOR, EVENTS3, parseCursorHookInput = (val
     case "preCompact":
       return { kind: "compact.pre", trigger: "auto" };
   }
-}, within = (root, dir) => dir === root || dir.startsWith(root.endsWith(path18.sep) ? root : `${root}${path18.sep}`), hookCwd = (input) => {
+}, within = (root, dir) => dir === root || dir.startsWith(root.endsWith(path19.sep) ? root : `${root}${path19.sep}`), hookCwd = (input) => {
   const cwd = existingDirectory(input.cwd);
   if (cwd && input.hook_event_name === "beforeShellExecution")
     return cwd;
@@ -17613,6 +18349,8 @@ var undocumented2, none, CURSOR_DESCRIPTOR, EVENTS3, parseCursorHookInput = (val
       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")
@@ -17762,7 +18500,8 @@ var init_cursor = __esm(() => {
         }
       };
     },
-    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
   };
 });
 
@@ -17812,6 +18551,7 @@ var init_hooks = __esm(async () => {
   init_context();
   init_policy();
   init_write_gate();
+  init_raw_git();
   init_fields();
   init_handle();
   init_claude_code();