@brainervirus/workit-opencode 8.1.0 → 8.3.0

package/dist/plugin.js

@@ -4,7 +4,7 @@ function define(plugin) {
 }
 
 // packages/workit-core/src/core.ts
-import { spawnSync as spawnSync13 } from "node:child_process";
+import { spawnSync as spawnSync14 } from "node:child_process";
 import { existsSync as existsSync7, realpathSync as realpathSync5 } from "node:fs";
 import path19 from "node:path";
 
@@ -9597,6 +9597,35 @@ function acquireFileLockSync(targetPath, options) {
     }
   }
 }
+// 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/core/package-root.ts
 import { existsSync } from "node:fs";
 import path3 from "node:path";
@@ -10561,9 +10590,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")
   };
 };
@@ -12487,6 +12517,7 @@ import { createHash as createHash6, randomBytes as randomBytes2 } from "node:cry
 import fs10 from "node:fs";
 import path9 from "node:path";
 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"]);
@@ -12586,6 +12617,7 @@ function ledgerPath(cwd) {
   const root = storeRoot(cwd);
   return root.ok ? { ok: true, value: path9.join(root.value.root, "ledger", "ledger.jsonl") } : root;
 }
+var newId2 = () => `${Date.now().toString(36)}-${randomBytes2(6).toString("hex")}`;
 var NETWORK_FS_TYPES = new Set([
   26985,
   20859,
@@ -12598,6 +12630,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(fs10.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 fs10.readFileSync(path9.join(lock, LOCK_OWNER), "utf8");
+  } catch {
+    return null;
+  }
+};
+var lockAgeMs = (lock) => {
+  for (const target of [path9.join(lock, LOCK_OWNER), lock]) {
+    try {
+      return Date.now() - fs10.statSync(target).mtimeMs;
+    } catch {}
+  }
+  return null;
+};
+var ledgerLock = {
+  acquire(lock) {
+    try {
+      fs10.mkdirSync(lock);
+    } catch (error) {
+      if (error.code === "EEXIST")
+        return null;
+      throw error;
+    }
+    const token = `${process.pid}-${randomBytes2(8).toString("hex")}`;
+    fs10.writeFileSync(path9.join(lock, LOCK_OWNER), token);
+    return token;
+  },
+  release(lock, token) {
+    if (lockToken(lock) !== token)
+      return false;
+    const tomb = `${lock}.release-${randomBytes2(6).toString("hex")}`;
+    try {
+      fs10.renameSync(lock, tomb);
+    } catch {
+      return false;
+    }
+    if (lockToken(tomb) !== token) {
+      try {
+        fs10.renameSync(tomb, lock);
+      } catch {}
+      return false;
+    }
+    fs10.rmSync(tomb, { recursive: true, force: true });
+    return true;
+  },
+  token: lockToken,
+  reap(lock, observed) {
+    const tomb = `${lock}.reap-${randomBytes2(6).toString("hex")}`;
+    try {
+      fs10.renameSync(lock, tomb);
+    } catch {
+      return false;
+    }
+    if (lockToken(tomb) === observed) {
+      fs10.rmSync(tomb, { recursive: true, force: true });
+      return true;
+    }
+    try {
+      fs10.renameSync(tomb, lock);
+    } catch {
+      fs10.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 = fs10.openSync(file, "a+");
+    try {
+      const size = fs10.fstatSync(fd).size;
+      let fence = "";
+      if (size > 0) {
+        const last = Buffer.alloc(1);
+        fs10.readSync(fd, last, 0, 1, size - 1);
+        if (last[0] !== 10)
+          fence = `
+`;
+      }
+      const bytes = Buffer.from(fence + line);
+      const written = fs10.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 {
+      fs10.closeSync(fd);
+    }
+  };
+  try {
+    fs10.mkdirSync(path9.dirname(file), { recursive: true });
+    if (!options.forceLock && !onNetworkFs(path9.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 isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var str2 = (value) => typeof value === "string" ? value : null;
 var normalizeActor = (value) => {
@@ -14291,6 +14475,7 @@ var gitContext = (workspaceRoot, paths = []) => {
 };
 
 // packages/workit-core/src/core/workspaces.ts
+import { spawnSync as spawnSync8 } from "node:child_process";
 import { createHash as createHash8 } from "node:crypto";
 import { readFileSync as readFileSync4, realpathSync as realpathSync3 } from "node:fs";
 import path13 from "node:path";
@@ -14535,6 +14720,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 = spawnSync8("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 && path13.resolve(gitDir) !== path13.resolve(common)) {
+    const listed = /^worktree (.+)$/mu.exec(git(["worktree", "list", "--porcelain"]) ?? "")?.[1];
+    main = listed?.trim() || (path13.basename(common) === ".git" ? path13.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 = realpathSync3.native ?? realpathSync3;
   try {
@@ -14559,43 +14791,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) => {
@@ -14627,31 +14845,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;
@@ -14668,7 +14881,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;
 };
@@ -14679,10 +14892,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 {
@@ -14702,11 +14915,11 @@ function workspaceDefaultTarget(cwd, globalDefault) {
 // packages/workit-core/src/core/vcs-config.ts
 import fs12 from "node:fs";
 import path14 from "node:path";
-import { spawnSync as spawnSync9 } from "node:child_process";
+import { spawnSync as spawnSync10 } from "node:child_process";
 
 // packages/workit-core/src/core/release-tracks.ts
 import { createHash as createHash9 } from "node:crypto";
-import { spawnSync as spawnSync8 } from "node:child_process";
+import { spawnSync as spawnSync9 } from "node:child_process";
 class ReleaseTrackError extends Error {
 }
 var KNOWN_FIELDS = new Set([
@@ -14991,7 +15204,7 @@ function resolveReleaseTrack(input) {
   return fallback(`${branch} has the same or unrelated fork points with ${[...new Set(newest.map((fork) => `${fork.ref} (${fork.track.name === IMPLICIT ? "workspace default" : fork.track.name})`))].join(" and ")}`);
 }
 var git4 = (cwd, args) => {
-  const run = spawnSync8("git", args, {
+  const run = spawnSync9("git", args, {
     cwd,
     encoding: "utf8",
     timeout: 20000,
@@ -15106,7 +15319,7 @@ function resolveTrackFor(cwd, options) {
 var workspacesPath = () => path14.join(configDir(), "workspaces.json");
 var vcsCwd = (cwd) => cwd ?? process.env.WORKFLOW_WORKSPACE_ROOT ?? process.cwd();
 var remoteProvider = (cwd) => {
-  const r = spawnSync9("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
+  const r = spawnSync10("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
   if (r.status !== 0)
     return null;
   const url = (r.stdout ?? "").trim();
@@ -15143,7 +15356,7 @@ var remoteEndpoint = (remote) => {
 var configuredSshEndpoint = (host) => {
   if (host.startsWith("-"))
     return null;
-  const resolved = spawnSync9("ssh", ["-G", host], {
+  const resolved = spawnSync10("ssh", ["-G", host], {
     encoding: "utf8",
     timeout: 5000,
     maxBuffer: 1024 * 1024,
@@ -15316,7 +15529,7 @@ function mergedPrStyle(limit = 6, cwd) {
 `).filter((l) => l.startsWith("## ")).map((l) => l.trim()),
     descriptionPreview: desc.slice(0, 600)
   });
-  const remoteResult = spawnSync9("git", ["remote", "get-url", "--push", "--all", "origin"], {
+  const remoteResult = spawnSync10("git", ["remote", "get-url", "--push", "--all", "origin"], {
     cwd,
     encoding: "utf8"
   });
@@ -15332,7 +15545,7 @@ function mergedPrStyle(limit = 6, cwd) {
   if (!hostingApiHostMatches(remote, host))
     return { ok: false, error: "PR style target does not match the provider host" };
   if (provider === "gitlab") {
-    const run = (args) => spawnSync9("glab", ["api", ...args], {
+    const run = (args) => spawnSync10("glab", ["api", ...args], {
       cwd,
       encoding: "utf8",
       env
@@ -15352,7 +15565,7 @@ function mergedPrStyle(limit = 6, cwd) {
       });
     }
   } else if (provider === "github") {
-    const r = spawnSync9("gh", [
+    const r = spawnSync10("gh", [
       "pr",
       "list",
       "--repo",
@@ -15476,6 +15689,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) => {
@@ -17423,7 +17637,7 @@ class WorkitCore {
   }
 }
 // packages/workit-core/src/core/repo-context.ts
-import { spawnSync as spawnSync10 } from "node:child_process";
+import { spawnSync as spawnSync11 } from "node:child_process";
 import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync4 } from "node:fs";
 import path16 from "node:path";
 var isSafeContextRange = (value) => value.length <= 4096 && (() => {
@@ -17452,7 +17666,7 @@ var invalidRange = (cwd) => ({
   cwd
 });
 var runGit = (cwd, args) => {
-  const result = spawnSync10("git", args, { cwd, encoding: "utf8" });
+  const result = spawnSync11("git", args, { cwd, encoding: "utf8" });
   return {
     stdout: (result.stdout ?? "").trimEnd(),
     stderr: (result.stderr ?? "").trimEnd(),
@@ -17893,12 +18107,12 @@ function releaseNotesContext(root, rangeOrTag) {
 }
 
 // packages/workit-core/src/core/tracker-issues.ts
-import { spawnSync as spawnSync12 } from "node:child_process";
+import { spawnSync as spawnSync13 } from "node:child_process";
 
 // packages/workit-core/src/core/pr-create.ts
 import fs13 from "node:fs";
 import path17 from "node:path";
-import { spawnSync as spawnSync11 } from "node:child_process";
+import { spawnSync as spawnSync12 } from "node:child_process";
 // packages/workit-core/src/forge/pr-body.ts
 function parseGhIssue(value) {
   const m = /issues\/(\d+)/.exec(value);
@@ -17923,7 +18137,7 @@ function whichOnPath(tool) {
 }
 var hostingCliAvailable = (provider) => whichOnPath(provider === "gitlab" ? "glab" : "gh") !== null;
 var pushRemote = (cwd) => {
-  const result = spawnSync11("git", ["remote", "get-url", "--push", "--all", "origin"], {
+  const result = spawnSync12("git", ["remote", "get-url", "--push", "--all", "origin"], {
     cwd,
     encoding: "utf8"
   });
@@ -17954,7 +18168,7 @@ var defaultCli = (bin, available) => {
   if (!available)
     return null;
   return (args, root) => {
-    const out = spawnSync12(bin, args, {
+    const out = spawnSync13(bin, args, {
       cwd: root,
       encoding: "utf8",
       env: { ...process.env, PATH: process.env.PATH ?? "" }
@@ -18530,7 +18744,7 @@ function resolveInside(root, candidate) {
 }
 function run2(root, executable, args, env = {}) {
   const cwd = realpathSync5(root);
-  const result = spawnSync13(executable, args, {
+  const result = spawnSync14(executable, args, {
     cwd,
     encoding: "utf8",
     env: { ...process.env, ...env }
@@ -18671,36 +18885,43 @@ var shellPolicy = (cwd, command) => {
 // packages/workit-core/src/hooks/write-gate.ts
 import { realpathSync as realpathSync6 } from "node:fs";
 import path21 from "node:path";
-var NONE2 = { kind: "none" };
-var CASE_INSENSITIVE = process.platform === "darwin" || process.platform === "win32";
-var canonical2 = (file) => {
-  let rest = "";
-  for (let dir = path21.resolve(file);; dir = path21.dirname(dir)) {
-    try {
-      return path21.join(realpathSync6(dir), rest);
-    } catch {
-      if (path21.dirname(dir) === dir)
-        return path21.resolve(file);
-      rest = rest ? path21.join(path21.basename(dir), rest) : path21.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 = path21.relative(fold(canonical2(root)), fold(canonical2(path21.resolve(cwd, file))));
-  if (relative.startsWith("..") || path21.isAbsolute(relative))
-    return true;
-  const posix = relative.split(path21.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;
@@ -18724,11 +18945,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 === `
@@ -18745,7 +18966,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();
@@ -18763,7 +18991,7 @@ var segmentsOf = (command) => {
         inWord = true;
       }
       pending = "redirect";
-    } else if (char === "<") {
+    } else if (char === "<" && dialect === "posix") {
       flushWord();
       if (command[index + 1] === "<") {
         index++;
@@ -18780,6 +19008,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 = path21.resolve(file);; dir = path21.dirname(dir)) {
+    try {
+      return path21.join(realpathSync6(dir), rest);
+    } catch {
+      if (path21.dirname(dir) === dir)
+        return path21.resolve(file);
+      rest = rest ? path21.join(path21.basename(dir), rest) : path21.basename(dir);
+    }
+  }
+};
+var exempt = (cwd, root, file, plans) => {
+  const fold = (value) => CASE_INSENSITIVE ? value.toLowerCase() : value;
+  const relative = path21.relative(fold(canonical2(root)), fold(canonical2(path21.resolve(cwd, file))));
+  if (relative.startsWith("..") || path21.isAbsolute(relative))
+    return true;
+  const posix = relative.split(path21.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) => {
@@ -18929,8 +19182,454 @@ function writeGate(cwd, paths) {
     return NONE2;
   }
 }
+// packages/workit-core/src/hooks/raw-git.ts
+import { spawnSync as spawnSync15 } from "node:child_process";
+import { createHash as createHash11 } from "node:crypto";
+import fs15 from "node:fs";
+import os4 from "node:os";
+import path22 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) => path22.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("~/") ? path22.join(os4.homedir(), next.slice(1)) : next;
+  return base === null || isAbsolute(expanded) ? expanded : path22.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 (fs15.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 = fs15.readFileSync(path22.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 = path22.dirname(repo.location.dir);
+    try {
+      return fs15.readFileSync(path22.join(common, ref), "utf8").trim() || null;
+    } catch {}
+    const packed = fs15.readFileSync(path22.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 = path22.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 MARKER_TTL_SECONDS = 3600;
+var markerFile = (repo, session, key) => path22.join(repo.location.dir, "hooks", `commit-${createHash11("sha256").update(`${session}\x00${key}`).digest("hex").slice(0, 32)}.json`);
+var callKey = (toolUseId, command) => toolUseId ?? `cmd:${createHash11("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);
+      fs15.mkdirSync(path22.dirname(file), { recursive: true });
+      fs15.writeFileSync(file, `${JSON.stringify({ head: headSha2(repo), at })}
+`);
+    }
+  } catch {}
+}
+var headCommit = (dir) => {
+  const run = spawnSync15("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(fs15.readFileSync(file, "utf8"));
+  } catch {
+    return;
+  }
+  fs15.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 {}
+}
 // packages/workit-core/src/hooks/hosts/fields.ts
-var SHELLS = new Set(["sh", "bash", "zsh", "dash", "pwsh", "powershell", "cmd"]);
+var SHELLS2 = new Set(["sh", "bash", "zsh", "dash", "pwsh", "powershell", "cmd"]);
 var WRITE_TOOLS = new Set([
   "write",
   "edit",
@@ -18956,7 +19655,13 @@ var CLAUDE_JUDGES = new Set(["workit:verifier", "workit:reviewer"]);
 // packages/workit-core/src/hooks/hosts/claude-code.ts
 var SOURCES = new Set(["startup", "resume", "clear", "compact", "fork"]);
 var SHELL_TOOLS = new Set(["Bash", "PowerShell"]);
-var CONTEXT_EVENTS = new Set(["SessionStart", "UserPromptSubmit", "SubagentStart"]);
+var CONTEXT_EVENTS = new Set([
+  "SessionStart",
+  "UserPromptSubmit",
+  "SubagentStart",
+  "PreToolUse",
+  "PostToolUse"
+]);
 
 // packages/workit-core/src/hooks/hosts/codex.ts
 var SHELL_TOOLS2 = new Set(["bash", "unified-exec"]);
@@ -19034,11 +19739,11 @@ var OPENCODE_DESCRIPTOR = {
   ]
 };
 // packages/workit-opencode/src/shared/init-apply.ts
-import path26 from "node:path";
+import path27 from "node:path";
 
 // packages/workit-core/src/core/gitignore.ts
 import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
-import path22 from "node:path";
+import path23 from "node:path";
 var GITIGNORE_ENTRIES = [
   "# workit: SDD working state (never commit)",
   "docs/*/sdd/",
@@ -19058,7 +19763,7 @@ var GITIGNORE_ENTRIES = [
 var ensureProjectGitignore = (workspaceRoot, confirmed) => {
   if (!confirmed)
     return { ok: false, error: "confirmed: true required" };
-  const file = path22.join(workspaceRoot, ".gitignore");
+  const file = path23.join(workspaceRoot, ".gitignore");
   const existing = existsSync8(file) ? readFileSync6(file, "utf8") : "";
   const existingLines = new Set(existing.split(`
 `).map((l) => l.trim()).filter(Boolean));
@@ -19086,25 +19791,25 @@ var ensureProjectGitignore = (workspaceRoot, confirmed) => {
 
 // packages/workit-core/src/core/hygiene.ts
 import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
-import path23 from "node:path";
+import path24 from "node:path";
 var repoRoot3 = assetRoot();
-var templatesDir = () => path23.join(repoRoot3, "templates", "hygiene");
+var templatesDir = () => path24.join(repoRoot3, "templates", "hygiene");
 var packageJson = (root) => {
-  if (!existsSync9(path23.join(root, "package.json")))
+  if (!existsSync9(path24.join(root, "package.json")))
     return null;
   try {
-    return JSON.parse(readFileSync7(path23.join(root, "package.json"), "utf8"));
+    return JSON.parse(readFileSync7(path24.join(root, "package.json"), "utf8"));
   } catch {
     return null;
   }
 };
 var isOpenSource = (root) => {
-  if (existsSync9(path23.join(root, "LICENSE")))
+  if (existsSync9(path24.join(root, "LICENSE")))
     return true;
   const pkg = packageJson(root);
   if (pkg && !pkg.private)
     return true;
-  return path23.basename(root) === "workflow-toolkit";
+  return path24.basename(root) === "workflow-toolkit";
 };
 var licenseHolder = (root) => {
   const pkg = packageJson(root);
@@ -19127,13 +19832,13 @@ var planHygieneFiles = (root, opts = {}) => {
     files.push("LICENSE", "CONTRIBUTING.md");
   const planned = [];
   for (const file of files) {
-    if (existsSync9(path23.join(root, file)))
+    if (existsSync9(path24.join(root, file)))
       continue;
-    const tpl = path23.join(templatesDir(), file);
+    const tpl = path24.join(templatesDir(), file);
     if (!existsSync9(tpl))
       continue;
-    const content = readFileSync7(tpl, "utf8").replace(/<PROJECT>/g, path23.basename(root)).replace(/<YEAR>/g, String(new Date().getFullYear())).replace(/<HOLDER>\s*/g, licenseHolder(root));
-    planned.push({ path: path23.join(root, file), content });
+    const content = readFileSync7(tpl, "utf8").replace(/<PROJECT>/g, path24.basename(root)).replace(/<YEAR>/g, String(new Date().getFullYear())).replace(/<HOLDER>\s*/g, licenseHolder(root));
+    planned.push({ path: path24.join(root, file), content });
   }
   return planned;
 };
@@ -19143,19 +19848,19 @@ var ensureHygieneFiles = (root, opts) => {
   const created = [];
   for (const planned of planHygieneFiles(root, opts)) {
     writeFileSync5(planned.path, planned.content, "utf8");
-    created.push(path23.basename(planned.path));
+    created.push(path24.basename(planned.path));
   }
   return { ok: true, created };
 };
 
 // packages/workit-core/src/core/init.ts
-import fs15 from "node:fs";
-import path25 from "node:path";
-import { spawnSync as spawnSync14 } from "node:child_process";
+import fs16 from "node:fs";
+import path26 from "node:path";
+import { spawnSync as spawnSync16 } from "node:child_process";
 
 // packages/workit-core/src/core/workspace-branch-policy.ts
 import { mkdirSync as mkdirSync4, readFileSync as readFileSync8, renameSync as renameSync3, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import path24 from "node:path";
+import path25 from "node:path";
 import { isDeepStrictEqual } from "node:util";
 var readFileSafe = (p) => {
   try {
@@ -19166,7 +19871,7 @@ var readFileSafe = (p) => {
 };
 function applyWorkspaceBranchPolicy(opts) {
   const { workspace_root, env = process.env } = opts;
-  const dir = path24.join(env.WORKFLOW_TOOLKIT_CONFIG ?? configDir());
+  const dir = path25.join(env.WORKFLOW_TOOLKIT_CONFIG ?? configDir());
   const {
     status,
     path: wsPath,
@@ -19178,7 +19883,7 @@ function applyWorkspaceBranchPolicy(opts) {
   if (status === "malformed" || status === "invalid")
     return { ok: false, error: workspacesError ?? `invalid workspaces.json: ${wsPath}` };
   const detection = detectBranchPolicy(workspace_root);
-  const name = String(env.WORKFLOW_BP_NAME ?? path24.basename(workspace_root));
+  const name = String(env.WORKFLOW_BP_NAME ?? path25.basename(workspace_root));
   const integration = env.WORKFLOW_BP_INTEGRATION ?? detection.integration;
   const policy = {
     preset: detection.preset,
@@ -19227,7 +19932,7 @@ function applyWorkspaceBranchPolicy(opts) {
       ok: false,
       error: `workspaces.json changed while applying the branch policy: ${wsPath}`
     };
-  mkdirSync4(path24.dirname(wsPath), { recursive: true });
+  mkdirSync4(path25.dirname(wsPath), { recursive: true });
   const tmp = `${wsPath}.${process.pid}.tmp`;
   try {
     writeFileSync6(tmp, JSON.stringify({ ...document, workspaces: next }, null, 2) + `
@@ -19262,7 +19967,7 @@ function applyWorkspaceBranchPolicy(opts) {
 var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE";
 var readJson = (p) => {
   try {
-    const parsed = JSON.parse(fs15.readFileSync(p, "utf8"));
+    const parsed = JSON.parse(fs16.readFileSync(p, "utf8"));
     return isConfigObject(parsed) ? parsed : null;
   } catch {
     return null;
@@ -19274,7 +19979,7 @@ var resolveInitProvider = (cwd) => {
     return env.toLowerCase();
   const root = cwd ?? process.env.WORKFLOW_WORKSPACE_ROOT ?? process.cwd();
   try {
-    const out = spawnSync14("git", ["remote", "get-url", "origin"], {
+    const out = spawnSync16("git", ["remote", "get-url", "origin"], {
       cwd: root,
       encoding: "utf8"
     });
@@ -19292,7 +19997,7 @@ var youtrackJsonContent = (dir) => {
   const meetingIssue = process.env.WORKFLOW_YT_MEETING_ISSUE;
   return {
     baseUrl: process.env.WORKFLOW_YT_BASE_URL ?? "https://youtrack.example.com",
-    tokenFile: process.env.WORKFLOW_YT_TOKEN_FILE ?? path25.join(dir, "youtrack.token"),
+    tokenFile: process.env.WORKFLOW_YT_TOKEN_FILE ?? path26.join(dir, "youtrack.token"),
     ...meetingIssue ? {
       meetingIssue,
       meetingIssues: { general: { issue: meetingIssue, label: "General meetings" } }
@@ -19322,19 +20027,19 @@ var vcsJsonContent = () => {
 };
 function initApplyData(action, env = process.env) {
   const dir = String(env.WORKFLOW_TOOLKIT_CONFIG ?? configDir());
-  fs15.mkdirSync(dir, { recursive: true });
+  fs16.mkdirSync(dir, { recursive: true });
   switch (action) {
     case "youtrack_json": {
-      const out = path25.join(dir, "youtrack.json");
-      fs15.writeFileSync(out, JSON.stringify(youtrackJsonContent(dir), null, 2) + `
+      const out = path26.join(dir, "youtrack.json");
+      fs16.writeFileSync(out, JSON.stringify(youtrackJsonContent(dir), null, 2) + `
 `, "utf8");
       return { action, ok: true, path: out };
     }
     case "youtrack_token_placeholder": {
-      const p = path25.join(dir, "youtrack.token");
+      const p = path26.join(dir, "youtrack.token");
       const preserved = writeFileExclusive(p, TOKEN_PLACEHOLDER2 + `
 `, 384) === "preserved";
-      const abs = path25.resolve(p);
+      const abs = path26.resolve(p);
       return {
         action,
         ok: true,
@@ -19346,14 +20051,14 @@ function initApplyData(action, env = process.env) {
       };
     }
     case "youtrack_scaffold": {
-      const jsonOut = path25.join(dir, "youtrack.json");
-      const tokenOut = path25.join(dir, "youtrack.token");
-      fs15.writeFileSync(jsonOut, JSON.stringify(youtrackJsonContent(dir), null, 2) + `
+      const jsonOut = path26.join(dir, "youtrack.json");
+      const tokenOut = path26.join(dir, "youtrack.token");
+      fs16.writeFileSync(jsonOut, JSON.stringify(youtrackJsonContent(dir), null, 2) + `
 `, "utf8");
       const preserved = writeFileExclusive(tokenOut, TOKEN_PLACEHOLDER2 + `
 `, 384) === "preserved";
-      const configPath = path25.resolve(jsonOut);
-      const tokenPath = path25.resolve(tokenOut);
+      const configPath = path26.resolve(jsonOut);
+      const tokenPath = path26.resolve(tokenOut);
       const prev = process.env.WORKFLOW_YOUTRACK_CONFIG;
       process.env.WORKFLOW_YOUTRACK_CONFIG = configPath;
       let tokenCreate = {};
@@ -19405,10 +20110,10 @@ function initApplyData(action, env = process.env) {
       }
     }
     case "vcs_scaffold": {
-      const jsonOut = path25.join(dir, "vcs.json");
-      fs15.writeFileSync(jsonOut, JSON.stringify(vcsJsonContent(), null, 2) + `
+      const jsonOut = path26.join(dir, "vcs.json");
+      fs16.writeFileSync(jsonOut, JSON.stringify(vcsJsonContent(), null, 2) + `
 `, "utf8");
-      const configPath = path25.resolve(jsonOut);
+      const configPath = path26.resolve(jsonOut);
       const prev = process.env.WORKFLOW_VCS_CONFIG;
       process.env.WORKFLOW_VCS_CONFIG = configPath;
       try {
@@ -19527,7 +20232,7 @@ var executeInitApply = (args, directory, runtime) => {
       protectedNames: args.branch_policy_protected
     }, current);
     writeConfig(next);
-    return output(ok({ action: "config", path: path26.join(configDir(), "config.json"), ...next }));
+    return output(ok({ action: "config", path: path27.join(configDir(), "config.json"), ...next }));
   }
   const env = Object.fromEntries(Object.entries({
     WORKFLOW_YT_BASE_URL: args.base_url,
@@ -19544,14 +20249,14 @@ var executeInitApply = (args, directory, runtime) => {
 
 // packages/workit-opencode/src/shared/session.ts
 import { realpathSync as realpathSync7 } from "node:fs";
-import path27 from "node:path";
+import path28 from "node:path";
 var sameWorkspace = (expected, observed) => {
   if (typeof observed !== "string" || !observed)
     return false;
   try {
     return realpathSync7(expected) === realpathSync7(observed);
   } catch {
-    return path27.resolve(expected) === path27.resolve(observed);
+    return path28.resolve(expected) === path28.resolve(observed);
   }
 };
 
@@ -19623,7 +20328,7 @@ var workitFamilyOf = (toolName) => {
 
 // packages/workit-opencode/src/tools/context.ts
 import { realpathSync as realpathSync8 } from "node:fs";
-import path28 from "node:path";
+import path29 from "node:path";
 var createContextTool = () => ({
   description: "Read Git, pull request, YouTrack, issue, changelog, release, or affected-file context.",
   execute: async (args, context) => {
@@ -19633,7 +20338,7 @@ var createContextTool = () => ({
     let root;
     try {
       const cwd = parsed.data.cwd;
-      root = realpathSync8(cwd ? path28.resolve(context.directory, cwd) : context.directory);
+      root = realpathSync8(cwd ? path29.resolve(context.directory, cwd) : context.directory);
     } catch {
       return JSON.stringify(failure2("invalid_input", "context target directory cannot be resolved"), null, 2);
     }
@@ -20156,7 +20861,7 @@ var injectCompactionContext = (root, sessionID, system) => {
 
 // packages/workit-opencode/src/v2/permissions.ts
 var WRITE_ACTIONS = new Set(["edit", "write", "patch"]);
-var evaluateShellPermission = (root, event) => {
+var evaluateShellPermission = (root, event, workdirs = new Map) => {
   if (event.effect === "deny")
     return;
   const deny = (reason) => {
@@ -20176,6 +20881,17 @@ var evaluateShellPermission = (root, event) => {
     const decision = shellPolicy(root, resource);
     if (decision.kind === "deny")
       return deny(decision.reason);
+    const cwd = event.sessionID && workdirs.get(event.sessionID) || root;
+    const raw = rawGitPre({
+      host: "opencode",
+      cwd,
+      session: { id: event.sessionID ?? "", agentId: null, agentType: null, parentId: null },
+      permissionMode: null,
+      transcriptPath: null,
+      event: { kind: "shell.pre", command: resource, toolUseId: null }
+    }, resource);
+    if (raw.kind === "deny")
+      return deny(raw.reason);
     const writes = shellWrites(resource);
     const gated = writes.writes ? writeGate(root, writes.targets) : null;
     if (gated?.kind === "deny")
@@ -20183,9 +20899,65 @@ var evaluateShellPermission = (root, event) => {
   }
 };
 
+// packages/workit-opencode/src/v2/shell.ts
+import path30 from "node:path";
+var commandOf = (input) => {
+  if (input === null || typeof input !== "object")
+    return null;
+  const { command, workdir } = input;
+  return typeof command === "string" && command.trim() ? { command, workdir: typeof workdir === "string" && workdir.trim() ? workdir : null } : null;
+};
+var hookInput = (root, sessionID, id, shell) => ({
+  host: "opencode",
+  cwd: shell.workdir ? path30.resolve(root, shell.workdir) : root,
+  session: { id: sessionID, agentId: null, agentType: null, parentId: null },
+  permissionMode: null,
+  transcriptPath: null,
+  event: { kind: "shell.pre", command: shell.command, toolUseId: id }
+});
+var observeShellBefore = (root, event, workdirs) => {
+  try {
+    if (event.tool !== "shell")
+      return;
+    const shell = commandOf(event.input);
+    if (!shell)
+      return;
+    const sessionID = String(event.sessionID);
+    const input = hookInput(root, sessionID, String(event.id), shell);
+    workdirs.set(sessionID, input.cwd);
+    if (workdirs.size > 256)
+      workdirs.delete(workdirs.keys().next().value);
+    noteRawCommit(input, shell.command, callKey(String(event.id), shell.command));
+  } catch {}
+};
+var observeShellResult = (root, event) => {
+  try {
+    if (event.tool !== "shell" || event.status !== "completed")
+      return;
+    const shell = commandOf(event.input);
+    if (!shell)
+      return;
+    const input = hookInput(root, String(event.sessionID), String(event.id), shell);
+    rawGitPost(input, shell.command, callKey(String(event.id), shell.command));
+    const nudge = rawGitPre(input, shell.command);
+    const result = event.result;
+    if (nudge.kind !== "context" || !result)
+      return;
+    if (typeof result.content === "string")
+      event.result = { ...result, content: `${result.content}
+
+${nudge.text}` };
+    else if (Array.isArray(result.content))
+      event.result = {
+        ...result,
+        content: [...result.content, { type: "text", text: nudge.text }]
+      };
+  } catch {}
+};
+
 // packages/workit-opencode/src/v2/registry.ts
 import { existsSync as existsSync11, readFileSync as readFileSync9 } from "node:fs";
-import path30 from "node:path";
+import path32 from "node:path";
 
 // packages/workit-core/src/core/skill-manifests.ts
 var WORKIT_METHOD_SKILLS = [
@@ -20234,33 +21006,33 @@ if (false) {}
 
 // packages/workit-opencode/src/shared/assets.ts
 import { existsSync as existsSync10, realpathSync as realpathSync9 } from "node:fs";
-import path29 from "node:path";
+import path31 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var moduleDir = () => {
   try {
-    return realpathSync9(path29.dirname(fileURLToPath2(import.meta.url)));
+    return realpathSync9(path31.dirname(fileURLToPath2(import.meta.url)));
   } catch {
-    return path29.dirname(fileURLToPath2(import.meta.url));
+    return path31.dirname(fileURLToPath2(import.meta.url));
   }
 };
 var packageRoot2 = () => {
   const dir = moduleDir();
   for (const candidate of [
-    path29.resolve(dir, ".."),
-    path29.resolve(dir, "..", ".."),
-    path29.resolve(dir, "..", "..", "..")
+    path31.resolve(dir, ".."),
+    path31.resolve(dir, "..", ".."),
+    path31.resolve(dir, "..", "..", "..")
   ]) {
-    if (existsSync10(path29.join(candidate, "package.json")))
+    if (existsSync10(path31.join(candidate, "package.json")))
       return candidate;
   }
-  return path29.resolve(dir, "..");
+  return path31.resolve(dir, "..");
 };
 var skillsRoot = () => {
   const root = packageRoot2();
-  const canonical = path29.resolve(root, "..", "workit-core", "skills");
-  if (existsSync10(path29.join(root, "src")) && existsSync10(canonical))
+  const canonical = path31.resolve(root, "..", "workit-core", "skills");
+  if (existsSync10(path31.join(root, "src")) && existsSync10(canonical))
     return canonical;
-  return path29.join(root, "assets", "skills");
+  return path31.join(root, "assets", "skills");
 };
 
 // packages/workit-opencode/src/v2/registry.ts
@@ -20287,11 +21059,11 @@ var registerSkills = async (ctx) => {
   if (!existsSync11(skillsDir))
     return new Set;
   const listed = await ctx.skill.list().catch(() => ({ data: [] }));
-  const own = (skill) => typeof skill.path === "string" && path30.resolve(skill.path).startsWith(skillsDir + path30.sep);
+  const own = (skill) => typeof skill.path === "string" && path32.resolve(skill.path).startsWith(skillsDir + path32.sep);
   const userSkills = new Set((listed?.data ?? []).filter((skill) => !own(skill)).map((skill) => skill.id));
   const packaged = new Map;
   for (const id of WORKIT_METHOD_SKILLS) {
-    const file = path30.join(skillsDir, id, "SKILL.md");
+    const file = path32.join(skillsDir, id, "SKILL.md");
     if (!userSkills.has(id) && existsSync11(file))
       packaged.set(id, file);
   }
@@ -20339,22 +21111,22 @@ var registerCommands = async (ctx, registeredSkills) => {
 
 // packages/workit-opencode/src/stale-sources.ts
 import { existsSync as existsSync12, readdirSync as readdirSync5 } from "node:fs";
-import path31 from "node:path";
+import path33 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var typescriptFiles = (directory) => {
   if (!existsSync12(directory))
     return [];
   return readdirSync5(directory, { withFileTypes: true }).flatMap((entry) => {
-    const file = path31.join(directory, entry.name);
+    const file = path33.join(directory, entry.name);
     return entry.isDirectory() ? typescriptFiles(file) : entry.isFile() && file.endsWith(".ts") ? [file] : [];
   });
 };
 var pluginSourceFiles = [
   ...new Set([
     fileURLToPath3(import.meta.url),
-    ...typescriptFiles(path31.join(packageRoot2(), "src")),
-    path31.join(packageRoot2(), "..", "workit-core", "src", "core.ts"),
-    ...typescriptFiles(path31.join(packageRoot2(), "..", "workit-core", "src", "core"))
+    ...typescriptFiles(path33.join(packageRoot2(), "src")),
+    path33.join(packageRoot2(), "..", "workit-core", "src", "core.ts"),
+    ...typescriptFiles(path33.join(packageRoot2(), "..", "workit-core", "src", "core"))
   ])
 ].filter((file) => existsSync12(file)).toSorted();
 
@@ -20455,7 +21227,10 @@ var setup = async (ctx) => {
       });
     }
   });
+  const shellWorkdirs = new Map;
   await ctx.tool.hook("execute.before", async (event) => {
+    if (event.tool === "shell")
+      return observeShellBefore(root, event, shellWorkdirs);
     if (event.tool !== "subagent")
       return;
     await lifecycle.executeBefore({
@@ -20466,6 +21241,8 @@ var setup = async (ctx) => {
     });
   });
   await ctx.tool.hook("execute.after", async (event) => {
+    if (event.tool === "shell")
+      return observeShellResult(root, event);
     if (event.tool !== "subagent")
       return;
     await lifecycle.executeAfter({
@@ -20477,7 +21254,7 @@ var setup = async (ctx) => {
     });
   });
   await ctx.permission.hook("evaluate", (event) => {
-    evaluateShellPermission(root, event);
+    evaluateShellPermission(root, event, shellWorkdirs);
   });
   await ctx.session.hook("context", async (event) => {
     const session = await sessionFacts(ctx, String(event.sessionID));