@brainervirus/workit-codex 8.6.1 → 8.8.0

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "workit",
-  "version": "8.6.1",
+  "version": "8.8.0",
   "description": "Adaptive engineering workflow rails for Codex",
   "author": {
     "name": "BrainerVirus"

package/README.md

@@ -15,7 +15,14 @@ codex plugin add workit@workflow-toolkit
 Reads run over MCP (`workit-codex-mcp`); mutations run through the `workit`
 CLI because MCP is read-only for unattested callers. Invoke skills as
 `$workit-<name>` or from `/skills`. Codex permissions and sandbox stay
-authoritative. Codex PreToolUse does not see `apply_patch` edits, so the
+authoritative.
+
+The plugin ships the `workit-verifier`, `workit-reviewer` and
+`workit-implementer` custom agents. Codex plugins cannot register agents, so
+the MCP server copies them into `~/.codex/agents/` when it starts, and Codex
+offers them from the next session. Trust the plugin hooks with `/hooks`;
+`workit doctor` warns when hooks are untrusted or the agents are missing, and
+prints the command that fixes it. Codex PreToolUse does not see `apply_patch` edits, so the
 [before-write gate](https://github.com/BrainerVirus/workit/blob/main/docs/guides/verification.md) is advisory here (the session
 context says so). Delivery limits come from the workspace
 [grants](https://github.com/BrainerVirus/workit/blob/main/docs/guides/grants.md).

package/agents/workit-implementer.toml

@@ -0,0 +1,36 @@
+# Generated by Workit from packages/workit-claude-code/agents/implementer.md; edits are overwritten on the next plugin start.
+name = "workit-implementer"
+description = "Implements one scoped workit brief in an isolated git worktree and reports what changed and how it was checked. Use to delegate a well-defined slice (goal, scope, acceptance, verify, forbidden, report) so it can run in parallel with other work."
+developer_instructions = '''You are a workit implementer working in your own git worktree.
+
+Refuse to start without a complete brief. It must state: goal, scope (files
+or areas you may touch), acceptance (observable outcomes), verify (exact
+commands), timebox, forbidden (what you must not touch or do), report (what to
+hand back), standing orders and mode (`new` or `resume`). If a field is
+missing, report which and stop.
+
+1. Your worktree starts on a branch name you did not choose, which may break
+   the repository's branch policy. First command, `MODE: new`:
+   `workit git branch <branch> --base <base>` with the brief's branch and base.
+   `MODE: resume` (you replace a stopped worker): `git switch <branch>` and
+   continue from its head; never `workit git branch`, the branch exists. A hook denies
+   protected or non-compliant names; follow the unblock it prints.
+2. Stay inside the scope. Anything outside it is a follow-up in the report,
+   not a diff. Follow the workit-implement skill (`$workit-implement`).
+3. Decide ambiguities yourself and record them:
+   `workit ledger ruling "<what>" --why "<why>" --cost-if-wrong "<cost>"`.
+   Stop only for an irreversible or security-sensitive action, or a side effect
+   outside your worktree.
+4. Commit in small steps with
+   `workit git commit -m "<conventional message>" -- <paths in scope>`.
+5. Run every verify command as `workit check …` and keep the real exit codes.
+6. Never record a verdict on your own work and never pass `--self`: a separate
+   verifier judges it. Never push, open a PR, rebase or merge unless the brief
+   says so.
+
+Report: branch and head SHA, files changed, each verify command with its exit
+code, each acceptance item met or not, rulings recorded, and any deviation from
+the brief.
+
+Codex does not isolate subagents: the lead creates your worktree with `workit fanout worktree create <slice>` and names it in the brief. Work only there, never in the lead's checkout.
+'''

package/agents/workit-reviewer.toml

@@ -0,0 +1,29 @@
+# Generated by Workit from packages/workit-claude-code/agents/reviewer.md; edits are overwritten on the next plugin start.
+name = "workit-reviewer"
+description = "Fresh-context reviewer for a workit branch or PR - spec fidelity and standards as separate axes, test quality and blast radius - that records findings and a non-author verdict. Use for independent review of a diff, branch or PR."
+sandbox_mode = "read-only"
+developer_instructions = '''You are the workit reviewer. Review the real candidate, never the author's
+description of it. Follow the workit-review skill (`$workit-review`).
+
+1. Pin the candidate: `git rev-parse HEAD`, the base, `git diff <base>...HEAD`;
+   for a PR, `workit pr status --json` for checks and unresolved threads.
+2. Read the intent: brief or acceptance criteria, spec, PR body, and
+   `workit ledger list --type decision`.
+3. Judge two axes separately: spec fidelity (missing, creep, wrong; quote the
+   line) and standards (repo rules first, then smells). Then test quality
+   (`workit test-audit --diff`) and blast radius: one fact plus one proof per
+   touched contract or caller, run with `workit check -- <cmd>`; label anything
+   unproven UNPROVEN.
+4. Each finding: file:line, severity (blocker, major, minor, nit), evidence
+   (hunk, test or command output), concrete fix.
+5. Record the verdict:
+   `workit ledger verdict verified|failed|blocked --kind review --branch <b> --session <id> --how "<what you read and ran>"`,
+   with the session the SubagentStart hook gave you
+   (`verified` with `--kind review`: no blocker or major finding left).
+   Record a design choice you had to make as `workit ledger ruling`.
+
+Stay read-only: read and test commands only, never commits, pushes, merges or
+edits. If the ledger refuses you as an author, report that instead of a verdict.
+
+Codex runs you in a read-only sandbox. `workit check` and `workit ledger verdict` write outside it: run them with escalated permissions (Codex asks the user). If escalation is refused or unavailable, record nothing and report the verdict you would record as blocked.
+'''

package/agents/workit-verifier.toml

@@ -0,0 +1,35 @@
+# Generated by Workit from packages/workit-claude-code/agents/verifier.md; edits are overwritten on the next plugin start.
+name = "workit-verifier"
+description = "Independently verifies a workit candidate (branch, commit or PR) on its real surface and records a SHA-keyed verdict in the ledger. Use after an implementer finishes and before shipping, never on work this session authored."
+sandbox_mode = "read-only"
+developer_instructions = '''You are the workit verifier. You did not write the candidate and you never
+change it: you observe, judge and record. Start from the goal and work
+backward: what must be true, what must exist, what must be wired. The author's
+summary is a claim, not evidence; assume the goal is not met until you observe
+it.
+
+1. Pin the candidate in its own checkout (`cd` into the worker's worktree, or
+   pass `--cwd`): `git rev-parse HEAD` and `git status --short`. A dirty tree
+   or a moving HEAD is itself a finding, and the ledger refuses a verdict on it.
+2. Read the brief: goal, acceptance (Given/When/Then), verify commands.
+3. Run every verify command through the CLI so the result is observed:
+   `workit check <name>` for configured checks, `workit check -- <cmd>` for the
+   rest. Never substitute an easier command.
+4. Drive the real surface with the project's `verify-<app>` skill when it
+   exists (`$workit-verify-app` generates one). Tests alone are unit evidence.
+5. Judge each acceptance line as met, not met, or not verifiable, citing what
+   you observed. Label every claim measured, inferred or guess.
+6. Record the verdict, then report it:
+   `workit ledger verdict verified|tests-verified|type-check-only|failed|blocked --branch <b> --kind live|unit --session <id> --how "<what you ran and saw>"`,
+   with the session the SubagentStart hook gave you (you share the lead's
+   `WORKIT_SESSION_ID`, which authored the work).
+   `verified` means the change was observed working on its real surface
+   (verify-<app>, `--kind live`); `tests-verified` means only tests ran. If the ledger refuses you as an author, report that;
+   never pass `--self` to get around it.
+
+Report: candidate SHA, each check with its exit code, each acceptance line,
+the verdict row you recorded. Do not fix anything you find: a failing check is
+a verdict, not a task.
+
+Codex runs you in a read-only sandbox. `workit check` and `workit ledger verdict` write outside it: run them with escalated permissions (Codex asks the user). If escalation is refused or unavailable, record nothing and report the verdict you would record as blocked.
+'''

package/dist/launch-mcp.js

@@ -6621,8 +6621,9 @@ var require_dist = __commonJS(function(exports, module) {
 });
 
 // packages/workit-codex/scripts/launch-mcp.ts
-import { existsSync as existsSync9, realpathSync as realpathSync7, statSync as statSync3 } from "node:fs";
-import path21 from "node:path";
+import { existsSync as existsSync10, realpathSync as realpathSync7, statSync as statSync3 } from "node:fs";
+import path22 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // packages/workit-core/src/core.ts
 import { spawnSync as spawnSync14 } from "node:child_process";
@@ -27982,6 +27983,19 @@ var GIT_VALUE_OPTIONS = new Set([
   "--config-env",
   "--super-prefix"
 ]);
+var LAUNCHERS = new Set([
+  "npx",
+  "bunx",
+  "pnpx",
+  "-y",
+  "--yes",
+  "pnpm",
+  "dlx",
+  "exec",
+  "env",
+  "sudo",
+  "command"
+]);
 var PUSH_VALUE_OPTIONS = new Set(["-o", "--push-option", "--receive-pack", "--exec", "--repo"]);
 var VALUE_OPTIONS = {
   git: new Set([
@@ -28028,22 +28042,8 @@ var READERS = new Set([
   "gc",
   "type"
 ]);
-var SHELLS2 = new Set(["sh", "bash", "zsh", "dash", "ksh"]);
-var LAUNCHERS = new Set([
-  "npx",
-  "bunx",
-  "pnpx",
-  "-y",
-  "--yes",
-  "pnpm",
-  "dlx",
-  "exec",
-  "env",
-  "sudo",
-  "command"
-]);
 // packages/workit-core/src/hooks/hosts/fields.ts
-var SHELLS3 = 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",
@@ -28097,7 +28097,7 @@ var CODEX_DESCRIPTOR = {
     "subagent.stop": { support: "native", native: "SubagentStop" },
     "prompt.submit": { support: "native", native: "UserPromptSubmit" },
     "compact.pre": { support: "none", native: null },
-    stop: { support: "none", native: null }
+    stop: { support: "native", native: "Stop" }
   },
   shellPolicy: { deny: "native", channel: "permissionDecision", failClosed: false },
   context: {
@@ -28117,7 +28117,7 @@ var CODEX_DESCRIPTOR = {
   },
   provenance: { sessionId: "native", agentIdOnTool: "partial", postToolObserve: "native" },
   interaction: { questions: "none", writeBoundary: "partial" },
-  stopControl: "undocumented",
+  stopControl: "native",
   shellAvailable: "native",
   perEventCost: "low",
   capabilities: [
@@ -28183,6 +28183,7 @@ var SHELL_TOOLS2 = new Set(["bash", "unified-exec"]);
 var SOURCES2 = new Set(["startup", "resume", "clear", "compact", "fork"]);
 
 // packages/workit-core/src/hooks/hosts/cursor.ts
+var TRANSCRIPT_TAIL_BYTES = 256 * 1024;
 var BLOCKING2 = new Set(["preToolUse", "beforeShellExecution", "subagentStart"]);
 
 // packages/workit-core/src/hooks/run.ts
@@ -28197,6 +28198,110 @@ var codexCapabilities = (host, availability = {}) => capabilitiesFor(codexDescri
 if (false)
   ;
 
+// packages/workit-codex/scripts/agents.ts
+import {
+  existsSync as existsSync9,
+  lstatSync as lstatSync3,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync7,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync3
+} from "node:fs";
+import os5 from "node:os";
+import path21 from "node:path";
+var CODEX_AGENT_MARKER = "# Generated by Workit";
+var codexHomeOfInstall = (pluginRoot) => {
+  const parts = path21.resolve(pluginRoot).split(path21.sep);
+  const cache = parts.length - 4;
+  return cache >= 2 && parts[cache] === "cache" && parts[cache - 1] === "plugins" ? parts.slice(0, cache - 1).join(path21.sep) || path21.sep : null;
+};
+var codexHomeFor = (pluginRoot, env) => codexHomeOfInstall(pluginRoot) ?? (env.CODEX_HOME || path21.join(env.HOME || os5.homedir(), ".codex"));
+var MARKER_VERSION = /^# Generated by Workit (\d+\.\d+\.\d+)\b/;
+var agentMarkerVersion = (text) => MARKER_VERSION.exec(text)?.[1] ?? null;
+var stampCodexAgent = (content, version) => version && content.startsWith(CODEX_AGENT_MARKER) && !agentMarkerVersion(content) ? `${CODEX_AGENT_MARKER} ${version}${content.slice(CODEX_AGENT_MARKER.length)}` : content;
+var versionAtLeast = (version, min) => {
+  const a = version.split(".").map(Number);
+  const b = min.split(".").map(Number);
+  for (let i = 0;i < 3; i++)
+    if (a[i] !== b[i])
+      return a[i] > b[i];
+  return true;
+};
+var pluginVersion = (pluginRoot) => {
+  try {
+    const version = JSON.parse(readFileSync7(path21.join(pluginRoot, "package.json"), "utf8")).version;
+    return typeof version === "string" && /^\d+\.\d+\.\d+/.test(version) ? version.match(/^\d+\.\d+\.\d+/)[0] : null;
+  } catch {
+    return null;
+  }
+};
+var lstatOrNull = (file) => {
+  try {
+    return lstatSync3(file);
+  } catch {
+    return null;
+  }
+};
+var installCodexAgents = (pluginRoot, codexHome) => {
+  const source = path21.join(pluginRoot, "agents");
+  if (!existsSync9(source))
+    return [];
+  const version = pluginVersion(pluginRoot);
+  const target = path21.join(codexHome, "agents");
+  const results = [];
+  for (const file of readdirSync5(source).filter((name) => name.endsWith(".toml")).toSorted()) {
+    const content = stampCodexAgent(readFileSync7(path21.join(source, file), "utf8"), version);
+    const dest = path21.join(target, file);
+    const stat = lstatOrNull(dest);
+    if (stat?.isSymbolicLink()) {
+      results.push({ file: dest, action: "skipped-symlink" });
+      continue;
+    }
+    if (!stat) {
+      mkdirSync3(target, { recursive: true });
+      try {
+        writeFileSync3(dest, content, { flag: "wx" });
+        results.push({ file: dest, action: "installed" });
+      } catch (error) {
+        if (error.code !== "EEXIST")
+          throw error;
+        results.push({ file: dest, action: "kept-user-file" });
+      }
+      continue;
+    }
+    if (!stat.isFile()) {
+      results.push({ file: dest, action: "kept-user-file" });
+      continue;
+    }
+    const current = readFileSync7(dest, "utf8");
+    if (current === content) {
+      results.push({ file: dest, action: "current" });
+      continue;
+    }
+    if (!current.startsWith(CODEX_AGENT_MARKER)) {
+      results.push({ file: dest, action: "kept-user-file" });
+      continue;
+    }
+    const written = agentMarkerVersion(current);
+    if (written && (!version || !versionAtLeast(version, written))) {
+      results.push({ file: dest, action: "kept-newer-version" });
+      continue;
+    }
+    const temp = path21.join(target, `.${file}.${process.pid}.${Date.now()}.tmp`);
+    writeFileSync3(temp, content, { flag: "wx" });
+    try {
+      renameSync2(temp, dest);
+    } catch (error) {
+      rmSync2(temp, { force: true });
+      throw error;
+    }
+    results.push({ file: dest, action: "updated" });
+  }
+  return results;
+};
+
 // packages/workit-codex/scripts/launch-mcp.ts
 var codexQualification = (host) => host === "codex_cli" ? { surface: host, cli: SUPPORT_MATRIX.codex.cli } : {
   surface: host,
@@ -28206,8 +28311,8 @@ var codexQualification = (host) => host === "codex_cli" ? { surface: host, cli:
 var resolveCodexWorkspaceRoot = (pluginRoot, env) => {
   const explicit = env.WORKFLOW_WORKSPACE_ROOT;
   const inherited = env.PWD;
-  const candidate = explicit ?? (inherited && path21.resolve(inherited) !== path21.resolve(pluginRoot) ? inherited : undefined);
-  if (!candidate || !path21.isAbsolute(candidate) || !existsSync9(candidate))
+  const candidate = explicit ?? (inherited && path22.resolve(inherited) !== path22.resolve(pluginRoot) ? inherited : undefined);
+  if (!candidate || !path22.isAbsolute(candidate) || !existsSync10(candidate))
     return null;
   try {
     if (!statSync3(candidate).isDirectory())
@@ -28246,10 +28351,33 @@ var codexContextProvider = (host = detectCodexSurface(process.env), root) => ({
     };
   }
 });
-if (__require.main == __require.module)
+var pluginRoot = () => path22.resolve(path22.dirname(fileURLToPath3(import.meta.url)), "..");
+var syncCodexAgents = (root) => {
+  const codexHome = codexHomeOfInstall(root);
+  if (!codexHome)
+    return;
+  try {
+    installCodexAgents(root, codexHome);
+  } catch {}
+};
+if (__require.main == __require.module) {
+  if (process.argv.includes("--install-agents")) {
+    const root = pluginRoot();
+    const results = installCodexAgents(root, codexHomeFor(root, process.env));
+    for (const r of results)
+      process.stdout.write(`${r.action} ${r.file}
+`);
+    if (results.length === 0)
+      process.stdout.write(`no agents bundled in ${root}
+`);
+    process.exit(0);
+  }
+  syncCodexAgents(pluginRoot());
   await runStdioServer(detectCodexSurface(process.env), codexContextProvider());
+}
 export {
   codexContextProvider,
   codexQualification,
-  resolveCodexWorkspaceRoot
+  resolveCodexWorkspaceRoot,
+  syncCodexAgents
 };

package/dist/{workit-hook-86r77dqq.js → workit-hook-aw8j630z.js}

@@ -17906,12 +17906,48 @@ function writeGate(cwd, paths) {
     return NONE2;
   }
 }
+// packages/workit-core/src/hooks/stop.ts
+import { spawnSync as spawnSync12 } from "node:child_process";
+
 // packages/workit-core/src/hooks/raw-git.ts
 import { spawnSync as spawnSync11 } from "node:child_process";
+import { createHash as createHash13 } from "node:crypto";
+import fs15 from "node:fs";
+import os4 from "node:os";
+import path19 from "node:path";
+
+// packages/workit-core/src/hooks/session-marker.ts
 import { createHash as createHash12 } from "node:crypto";
 import fs14 from "node:fs";
-import os4 from "node:os";
 import path18 from "node:path";
+var sessionMarkerFile = (input, session, store) => {
+  let dir = store;
+  if (dir === undefined) {
+    const location = resolveStore(input.cwd);
+    if (location instanceof Error || !location.shared)
+      return null;
+    dir = location.dir;
+  }
+  const name = createHash12("sha256").update(`${input.host}\x00${session}`).digest("hex").slice(0, 32);
+  return path18.join(dir, "hooks", `skills-${name}.json`);
+};
+var list2 = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+var readSessionMarker = (file) => {
+  try {
+    const value = JSON.parse(fs14.readFileSync(file, "utf8"));
+    return { nudged: list2(value.nudged), loaded: list2(value.loaded), raw: list2(value.raw) };
+  } catch {
+    return { nudged: [], loaded: [], raw: [] };
+  }
+};
+var writeSessionMarker = (file, marker) => {
+  try {
+    fs14.mkdirSync(path18.dirname(file), { recursive: true });
+    fs14.writeFileSync(file, JSON.stringify(marker));
+  } catch {}
+};
+
+// packages/workit-core/src/hooks/raw-git.ts
 var NONE3 = { kind: "none" };
 var SHELLS = new Set(["sh", "bash", "zsh", "dash", "ksh"]);
 var PREFIXES3 = new Set(["sudo", "command", "env", "nohup", "time", "exec", "nice", "&"]);
@@ -17928,12 +17964,12 @@ var GIT_VALUE_OPTIONS = new Set([
   "--config-env",
   "--super-prefix"
 ]);
-var isAbsolute = (value) => path18.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
+var isAbsolute = (value) => path19.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("~/") ? path18.join(os4.homedir(), next.slice(1)) : next;
-  return base === null || isAbsolute(expanded) ? expanded : path18.join(base, expanded);
+  const expanded = next === "~" || next.startsWith("~/") ? path19.join(os4.homedir(), next.slice(1)) : next;
+  return base === null || isAbsolute(expanded) ? expanded : path19.join(base, expanded);
 };
 var cdTarget = (words) => {
   const args = words.slice(1);
@@ -18029,6 +18065,37 @@ function rawInvocations(command, dialect = "posix", depth = 0) {
   }
   return found;
 }
+var LAUNCHERS = new Set([
+  "npx",
+  "bunx",
+  "pnpx",
+  "-y",
+  "--yes",
+  "pnpm",
+  "dlx",
+  "exec",
+  "env",
+  "sudo",
+  "command"
+]);
+var WORKIT_BIN = /(?:^|[\\/])workit(?:\.exe)?$|^@brainervirus\/workit-cli$/;
+function workitInvocations(command, dialect = "posix", depth = 0) {
+  const found = [];
+  for (const { words } of segmentsOf(command, dialect)) {
+    const at = words.findIndex((word) => !/^\w+=/.test(word) && !LAUNCHERS.has(word));
+    if (at < 0)
+      continue;
+    if (WORKIT_BIN.test(words[at])) {
+      found.push(words.slice(at + 1));
+      continue;
+    }
+    const shell = SHELLS.has(commandName(words[at]));
+    const script = shell && words[at + 1] === "-c" ? words[at + 2] : undefined;
+    if (depth < 3 && script !== undefined)
+      found.push(...workitInvocations(script, "posix", depth + 1));
+  }
+  return found;
+}
 var PUSH_VALUE_OPTIONS = new Set(["-o", "--push-option", "--receive-pack", "--exec", "--repo"]);
 var pushAction = (args) => {
   let force = false;
@@ -18155,7 +18222,7 @@ var repoAt = (dir) => {
   return { location, dir, branch: resolveTaskKey(dir, location).branch };
 };
 var isWorkitWorkspace = (repo) => {
-  if (fs14.existsSync(repo.location.dir))
+  if (fs15.existsSync(repo.location.dir))
     return true;
   try {
     return resolveRuntimeWorkspaceVcs(repo.location.top ?? repo.dir) !== null;
@@ -18186,17 +18253,17 @@ var headSha2 = (repo) => {
   if (!git || git.reftable)
     return null;
   try {
-    const head = fs14.readFileSync(path18.join(git.gitDir, "HEAD"), "utf8").trim();
+    const head = fs15.readFileSync(path19.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 = path18.dirname(repo.location.dir);
+    const common = path19.dirname(repo.location.dir);
     try {
-      return fs14.readFileSync(path18.join(common, ref), "utf8").trim() || null;
+      return fs15.readFileSync(path19.join(common, ref), "utf8").trim() || null;
     } catch {}
-    const packed = fs14.readFileSync(path18.join(common, "packed-refs"), "utf8");
+    const packed = fs15.readFileSync(path19.join(common, "packed-refs"), "utf8");
     return new RegExp(`^([0-9a-f]{40,64}) ${ref.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`, "m").exec(packed)?.[1] ?? null;
   } catch {
     return null;
@@ -18233,7 +18300,7 @@ var actionsIn = (cwd, command, dialect) => {
     const action = rawAction(invocation);
     if (!action)
       continue;
-    const dir = path18.resolve(cwd, invocation.dir ?? ".");
+    const dir = path19.resolve(cwd, invocation.dir ?? ".");
     if (!repos.has(dir)) {
       const repo = repoAt(dir);
       repos.set(dir, repo && isWorkitWorkspace(repo) ? repo : null);
@@ -18251,12 +18318,31 @@ var inWorkitWorkspace = (dir) => {
 var rawDelivery = (cwd, command, dialect) => mentionsRawTool(command) && actionsIn(cwd, command, dialect).some(({ action }) => action.kind !== "commit" && action.kind !== "pr-read");
 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) {
+var nudgeKind = (action) => action.kind === "commit" && action.amend ? "commit-amend" : action.kind === "push" && action.blindForce ? "push-force" : action.kind;
+var unseenNudges = (input, nudges, store) => {
+  const session = input.session.id;
+  const file = session ? sessionMarkerFile(input, session, store) : null;
+  if (!file)
+    return [...nudges.values()];
+  const marker = readSessionMarker(file);
+  const agent = input.session.agentId ? `${input.session.agentId}:` : "";
+  const fresh = [...nudges.keys()].filter((kind) => !marker.raw.includes(agent + kind));
+  if (fresh.length)
+    writeSessionMarker(file, {
+      ...marker,
+      raw: [...marker.raw, ...fresh.map((kind) => agent + kind)]
+    });
+  return fresh.map((kind) => nudges.get(kind));
+};
+function rawGitPre(input, command, options = {}) {
   try {
     if (!mentionsRawTool(command))
       return NONE3;
-    const nudges = [];
-    for (const { action, repo } of actionsIn(input.cwd, command, dialectOf(input))) {
+    const dialect = dialectOf(input);
+    const nudges = new Map;
+    let store = null;
+    for (const { action, repo } of actionsIn(input.cwd, command, dialect)) {
+      store ??= repo.location.dir;
       if (action.kind === "merge")
         return deny(refusal(action, null));
       if (action.kind === "push")
@@ -18266,10 +18352,15 @@ function rawGitPre(input, command) {
             return deny(refusal(action, branch));
         }
       const nudge = nudgeFor(action, input.host, input.session.id);
-      if (nudge && !nudges.includes(nudge))
-        nudges.push(nudge);
+      if (nudge && !nudges.has(nudgeKind(action)))
+        nudges.set(nudgeKind(action), nudge);
     }
-    return nudges.length ? { kind: "context", text: nudges.join(`
+    if (options.nudge === false || !store || nudges.size === 0)
+      return NONE3;
+    if (workitInvocations(command, dialect).length > 0)
+      return NONE3;
+    const shown = unseenNudges(input, nudges, store);
+    return shown.length ? { kind: "context", text: shown.join(`
 `) } : NONE3;
   } catch {
     return NONE3;
@@ -18278,8 +18369,8 @@ function rawGitPre(input, command) {
 var deny = (reason) => ({ kind: "deny", reason, unblock: null });
 var NEXT_COMMAND = "next";
 var MARKER_TTL_SECONDS = 3600;
-var markerFile = (repo, session, key) => path18.join(repo.location.dir, "hooks", `commit-${createHash12("sha256").update(`${session}\x00${key}`).digest("hex").slice(0, 32)}.json`);
-var callKey = (toolUseId, command) => toolUseId ?? `cmd:${createHash12("sha256").update(command).digest("hex")}`;
+var markerFile = (repo, session, key) => path19.join(repo.location.dir, "hooks", `commit-${createHash13("sha256").update(`${session}\x00${key}`).digest("hex").slice(0, 32)}.json`);
+var callKey = (toolUseId, command) => toolUseId ?? `cmd:${createHash13("sha256").update(command).digest("hex")}`;
 function noteRawCommit(input, command, key) {
   try {
     if (!input.session.id || !/\bcommit\b/.test(command))
@@ -18289,8 +18380,8 @@ function noteRawCommit(input, command, key) {
       if (action.kind !== "commit")
         continue;
       const file = markerFile(repo, input.session.id, key);
-      fs14.mkdirSync(path18.dirname(file), { recursive: true });
-      fs14.writeFileSync(file, `${JSON.stringify({ head: headSha2(repo), at })}
+      fs15.mkdirSync(path19.dirname(file), { recursive: true });
+      fs15.writeFileSync(file, `${JSON.stringify({ head: headSha2(repo), at })}
 `);
     }
   } catch {}
@@ -18313,11 +18404,11 @@ var headCommit = (dir) => {
 var settle2 = (input, repo, file) => {
   let marker;
   try {
-    marker = JSON.parse(fs14.readFileSync(file, "utf8"));
+    marker = JSON.parse(fs15.readFileSync(file, "utf8"));
   } catch {
     return;
   }
-  fs14.rmSync(file, { force: true });
+  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)
@@ -18366,15 +18457,165 @@ function settlePendingCommit(input) {
     if (!repo)
       return;
     const file = markerFile(repo, input.session.id, NEXT_COMMAND);
-    if (fs14.existsSync(file))
+    if (fs15.existsSync(file))
       settle2(input, repo, file);
   } catch {}
 }
-// packages/workit-core/src/hooks/skill-nudge.ts
-import { createHash as createHash13 } from "node:crypto";
-import fs15 from "node:fs";
-import path19 from "node:path";
 
+// packages/workit-core/src/hooks/stop.ts
+var NONE4 = { kind: "none" };
+var QUESTION = /[?？؟](?=[\s*_`"')\]>]*(?:\s|$))|¿/;
+var OFFER = /\b(?:let me know|want me to|should I|shall I|would you like|do you want|if you(?:'d| would) like|may I|can I go ahead)\b/i;
+var YES_NO = /[[(]\s*y(?:es)?\s*\/\s*n(?:o)?\s*[\])]/i;
+var LIST_ITEM = /^\s*(?:[-*+•]|\d+[.)]|[a-z][.)])\s+/i;
+var asksUser = (message) => {
+  if (!message)
+    return false;
+  const paragraphs = message.replace(/```[\s\S]*?(?:```|$)/g, `
+
+`).split(/\n\s*\n/).map((paragraph) => paragraph.trim()).filter(Boolean);
+  while (paragraphs.length > 1 && paragraphs.at(-1).split(`
+`).every((line) => LIST_ITEM.test(line)))
+    paragraphs.pop();
+  const tail = paragraphs.slice(-2).join(`
+`);
+  return QUESTION.test(tail) || OFFER.test(tail) || YES_NO.test(tail);
+};
+var short = (sha) => (sha ?? "?").slice(0, 12);
+var gitList = (cwd, args) => {
+  const run = spawnSync12("git", args, {
+    cwd,
+    encoding: "utf8",
+    timeout: 3000,
+    windowsHide: true,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0", GIT_OPTIONAL_LOCKS: "0", LC_ALL: "C" }
+  });
+  return run.status === 0 ? run.stdout.split(`
+`).filter(Boolean) : null;
+};
+var gitLine = (cwd, args) => gitList(cwd, args)?.[0] ?? null;
+var sessionOf = (row) => (typeof row.session === "string" ? row.session : null) ?? row.actor.session;
+var prState = (row) => typeof row.state === "string" ? row.state : "open";
+var ended = (row) => row.observer === "workit_cli" && (row.type === "pr.merged" || row.type === "pr.status" && prState(row) !== "open");
+var openPr = (rows) => {
+  const seen = rows.findLast((row) => (row.type === "pr.created" || row.type === "pr.status") && row.observer === "workit_cli" && typeof row.pr === "number");
+  if (!seen || ended(seen))
+    return null;
+  const closed = rows.some((row) => ended(row) && row.pr === seen.pr && row.seq > seen.seq);
+  return closed ? null : seen.pr;
+};
+var mergedHeads = (rows) => [
+  ...new Set(rows.filter((row) => row.observer === "workit_cli" && typeof row.head === "string" && (row.type === "pr.merged" || row.type === "pr.status" && prState(row) === "merged")).map((row) => row.head))
+].slice(-3);
+var localCommit = (cwd, sha) => /^[0-9a-f]{7,64}$/.test(sha) && gitList(cwd, ["cat-file", "-e", `${sha}^{commit}`]) !== null;
+var upstreamGone = (cwd, branch) => gitLine(cwd, ["for-each-ref", "--format=%(upstream:track)", `refs/heads/${branch}`]) === "[gone]";
+var landed = (cwd, branch, rows, head, mine) => {
+  if (!head)
+    return false;
+  const merged = mergedHeads(rows);
+  if (merged.length === 0)
+    return upstreamGone(cwd, branch);
+  if (merged.includes(head))
+    return true;
+  if (mine.size === 0)
+    return false;
+  return merged.some((at) => {
+    const after = gitList(cwd, ["rev-list", `--max-count=${UNPUSHED_SCAN}`, "HEAD", "--not", at]);
+    return after !== null && !after.some((sha) => mine.has(sha));
+  });
+};
+var UNPUSHED_SCAN = 500;
+var unpushed = (cwd, branch, endpoint, mine, merged) => {
+  const remote = pushRemoteName(cwd, branch);
+  if (!remote || mine.size === 0)
+    return null;
+  const listed = gitList(cwd, [
+    "rev-list",
+    `--max-count=${UNPUSHED_SCAN}`,
+    "HEAD",
+    "--not",
+    `--remotes=${remote}`,
+    ...merged.filter((sha) => localCommit(cwd, sha))
+  ]);
+  const count = (listed ?? []).filter((sha) => mine.has(sha)).length;
+  if (count === 0)
+    return null;
+  return {
+    kind: "unpushed",
+    reason: `${branch} has ${count} commit(s) of this session not on ${remote}, and this workspace's endpoint is \`${endpoint}\` (\`workit grant show\`): push them with \`workit git push\`${endpoint === "pr" ? ", then open or update the PR (`workit pr create --fill`)" : ""}.`
+  };
+};
+var redChecks = (rows, pr, head, endpoint) => {
+  const status = rows.findLast((row) => row.type === "pr.status" && row.observer === "workit_cli" && row.pr === pr);
+  const state = status && status.head === head && prState(status) === "open" ? status.checks : null;
+  if (state !== "failing" && state !== "pending")
+    return null;
+  return {
+    kind: "checks",
+    reason: `PR #${pr}'s checks were last seen ${state} at ${short(head)}, and this workspace's endpoint is \`${endpoint}\`: run \`workit ci wait --pr ${pr}\`${state === "failing" ? " after fixing the failures `workit pr status` lists (then push)" : ""}.`
+  };
+};
+var unverified = (cwd, branch, all, descriptor) => {
+  const check = checkVerdicts(cwd, branch, all);
+  if (check.accepted.accepted || check.accepted.reasons.includes("failing_verdict"))
+    return null;
+  const has = check.review === "self-reviewed" ? "only a self verdict" : "no current verdict";
+  const verifier = `${descriptor.subagents.agentPrefix}verifier`;
+  return {
+    kind: "verdict",
+    reason: `the head ${short(check.head)} of ${branch}, which this session delivered, has ${has}: if no verifier is already running on it, hand it to a session that did not author it (the ${verifier} agent records \`workit ledger verdict <result> --branch ${branch} --how "<evidence>"\`), or tell the user it is unverified. Never record a verdict on your own work.`
+  };
+};
+function stopObligation(input, descriptor) {
+  try {
+    const session = input.session.id;
+    if (!session || input.session.agentId || !inWorkitWorkspace(input.cwd))
+      return null;
+    const branch = currentBranch(input.cwd);
+    if (!branch || guardedBranch(input.cwd, branch))
+      return null;
+    const ledger = readLedger(input.cwd);
+    if (!ledger.ok)
+      return null;
+    const all = ledger.value.rows;
+    const rows = all.filter((row) => row.branch === branch);
+    const mine = rows.filter((row) => sessionOf(row) === session);
+    const commits = new Set(mine.filter((row) => row.type === "commit.recorded").map((row) => typeof row.sha === "string" ? row.sha : row.head).filter((sha) => typeof sha === "string"));
+    const delivered = mine.some((row) => row.observer === "workit_cli" && (row.type === "pr.created" || row.type === "delivery.verified"));
+    if (commits.size === 0 && !delivered)
+      return null;
+    const head = gitLine(input.cwd, ["rev-parse", "HEAD"]);
+    if (landed(input.cwd, branch, rows, head, commits))
+      return null;
+    const endpoint = resolveAutonomy(input.cwd).effectiveEndpoint;
+    if (endpoint !== "commit") {
+      const left = unpushed(input.cwd, branch, endpoint, commits, mergedHeads(rows));
+      if (left)
+        return left;
+    }
+    const pr = openPr(rows);
+    if ((endpoint === "green" || endpoint === "merged") && pr !== null && head) {
+      const left = redChecks(rows, pr, head, endpoint);
+      if (left)
+        return left;
+    }
+    return delivered ? unverified(input.cwd, branch, all, descriptor) : null;
+  } catch {
+    return null;
+  }
+}
+function stopDecision(input, descriptor) {
+  const event = input.event;
+  if (event.kind !== "stop" || event.stopHookActive)
+    return NONE4;
+  if (!event.lastMessage?.trim() || asksUser(event.lastMessage))
+    return NONE4;
+  const left = stopObligation(input, descriptor);
+  return left ? {
+    kind: "continue",
+    reason: `Workit: before stopping, ${left.reason} If this cannot be done now, say so to the user and stop.`
+  } : NONE4;
+}
 // packages/workit-core/src/core/skill-manifests.ts
 var WORKIT_METHOD_SKILLS = [
   "workit-shape",
@@ -18481,27 +18722,6 @@ var promptTrigger = (prompt) => {
   }
   return null;
 };
-var markerFile2 = (input, session) => {
-  const location = resolveStore(input.cwd);
-  if (location instanceof Error || !location.shared)
-    return null;
-  const name = createHash13("sha256").update(`${input.host}\x00${session}`).digest("hex").slice(0, 32);
-  return path19.join(location.dir, "hooks", `skills-${name}.json`);
-};
-var readMarker = (file) => {
-  try {
-    const value = JSON.parse(fs15.readFileSync(file, "utf8"));
-    return { nudged: value.nudged ?? [], loaded: value.loaded ?? [] };
-  } catch {
-    return { nudged: [], loaded: [] };
-  }
-};
-var writeMarker = (file, marker) => {
-  try {
-    fs15.mkdirSync(path19.dirname(file), { recursive: true });
-    fs15.writeFileSync(file, JSON.stringify(marker));
-  } catch {}
-};
 var loadedSkills = (cwd, session) => {
   const ledger = readLedger(cwd);
   const loaded = new Set;
@@ -18549,13 +18769,13 @@ function recordSkillLoad(input, name, via) {
       return;
     if (!inWorkitWorkspace(input.cwd))
       return;
-    const file = markerFile2(input, session);
+    const file = sessionMarkerFile(input, session);
     if (!file)
       return;
-    const marker = readMarker(file);
+    const marker = readSessionMarker(file);
     if (marker.loaded.includes(skill))
       return;
-    writeMarker(file, { ...marker, loaded: [...marker.loaded, skill] });
+    writeSessionMarker(file, { ...marker, loaded: [...marker.loaded, skill] });
     if (loadedSkills(input.cwd, session).has(skill))
       return;
     appendHookObserved(input.cwd, {
@@ -18567,23 +18787,24 @@ function recordSkillLoad(input, name, via) {
   } catch {}
 }
 var nudgeOnce = (input, session, skill, line) => {
-  const file = markerFile2(input, session);
+  const file = sessionMarkerFile(input, session);
   if (!file)
     return null;
-  const marker = readMarker(file);
+  const marker = readSessionMarker(file);
   if (marker.nudged.includes(skill) || marker.loaded.includes(skill))
     return null;
   if (loadedSkills(input.cwd, session).has(skill))
     return null;
-  writeMarker(file, { ...marker, nudged: [...marker.nudged, skill] });
+  writeSessionMarker(file, { ...marker, nudged: [...marker.nudged, skill] });
   return line;
 };
 var nudgeText = (input, skill, why) => USER_INVOKED.has(skill) ? `Workit: ${why} looks like ${skill} work, which the user starts; offer it (/${skill.replace(/^workit-/, "wk-")}) rather than loading it.` : `Workit: ${why} looks like ${skill} work; if it is, ${skillLoadWording(SKILL_HOST[input.host], skill)} first.`;
 var promptLoads = (prompt) => /^\s*\/(?:skill:)?([\w:-]+)/.exec(prompt)?.[1] ?? /^\s*<skill name="([\w:-]+)"/.exec(prompt)?.[1] ?? /^\s*Load the (workit-[a-z-]+) skill with the skill tool\b/.exec(prompt)?.[1] ?? null;
+var relayedMessage = (prompt) => /^\s*(?:Another Claude session sent a message\b|<agent-message\s+from=|\[SYSTEM NOTIFICATION\b|<task-notification>)/.test(prompt);
 function promptNudge(input, prompt) {
   try {
     const session = input.session.id;
-    if (!prompt || !session || input.session.agentId)
+    if (!prompt || !session || input.session.agentId || relayedMessage(prompt))
       return null;
     const loads = promptLoads(prompt);
     if (loads) {
@@ -18599,32 +18820,7 @@ function promptNudge(input, prompt) {
   }
 }
 var WORKIT_DELIVERY = /^(?:pr (?:create|merge)|ci wait|git push)\b/;
-var SHELLS2 = new Set(["sh", "bash", "zsh", "dash", "ksh"]);
-var LAUNCHERS = new Set([
-  "npx",
-  "bunx",
-  "pnpx",
-  "-y",
-  "--yes",
-  "pnpm",
-  "dlx",
-  "exec",
-  "env",
-  "sudo",
-  "command"
-]);
-var runsWorkitDelivery = (command, dialect, depth = 0) => segmentsOf(command, dialect).some(({ words }) => {
-  const at = words.findIndex((word) => !/^\w+=/.test(word) && !LAUNCHERS.has(word));
-  if (at >= 0 && /(?:^|[\\/])workit(?:\.exe)?$|^@brainervirus\/workit-cli$/.test(words[at])) {
-    const args = words.slice(at + 1);
-    if (args.some((arg) => arg === "--help" || arg === "-h" || arg === "--dry-run"))
-      return false;
-    return WORKIT_DELIVERY.test(args.join(" "));
-  }
-  const shell = SHELLS2.has(words[at]?.split(/[\\/]/).at(-1) ?? "");
-  const script = shell && words[at + 1] === "-c" ? words[at + 2] : undefined;
-  return depth < 3 && script !== undefined && runsWorkitDelivery(script, "posix", depth + 1);
-});
+var runsWorkitDelivery = (command, dialect) => workitInvocations(command, dialect).some((args) => !args.some((arg) => arg === "--help" || arg === "-h" || arg === "--dry-run") && WORKIT_DELIVERY.test(args.join(" ")));
 var isDeliveryCommand = (cwd, command, dialect = "posix") => rawDelivery(cwd, command, dialect) || runsWorkitDelivery(command, dialect) && inWorkitWorkspace(cwd);
 function shipNudge(input, command) {
   try {
@@ -18664,7 +18860,7 @@ var existingDirectory = (value) => {
     return null;
   }
 };
-var SHELLS3 = new Set(["sh", "bash", "zsh", "dash", "pwsh", "powershell", "cmd"]);
+var SHELLS2 = new Set(["sh", "bash", "zsh", "dash", "pwsh", "powershell", "cmd"]);
 var SCRIPT_FLAG2 = /^(?:-\w*c|-command|\/c)$/i;
 var quoteArg = (arg) => /^[\w@%+=:,./-]+$/.test(arg) ? arg : JSON.stringify(arg);
 var commandText = (value) => {
@@ -18676,7 +18872,7 @@ var commandText = (value) => {
   if (!argv.every((arg) => typeof arg === "string"))
     return null;
   const shell = argv[0].split(/[\\/]/).at(-1)?.replace(/\.exe$/i, "").toLowerCase() ?? "";
-  if (SHELLS3.has(shell))
+  if (SHELLS2.has(shell))
     for (let index = 1;index < argv.length - 1; index++) {
       if (SCRIPT_FLAG2.test(argv[index]))
         return nonEmpty2(argv[index + 1]) ? argv[index + 1] : null;
@@ -18724,7 +18920,7 @@ var writeTargets = (input) => {
 };
 // packages/workit-core/src/hooks/handle.ts
 var usable2 = (value) => value === "native" || value === "partial";
-var NONE4 = { kind: "none" };
+var NONE5 = { kind: "none" };
 var resendsOnChange = (descriptor) => descriptor.context.turnResend === "on-change" && usable2(descriptor.context.perTurn);
 var offered = new Set;
 var ROLES = {
@@ -18738,13 +18934,20 @@ var workitRole = (descriptor, agentType) => {
   return Object.hasOwn(ROLES, name) ? ROLES[name] : null;
 };
 var subagentSession = (session, agentId) => [session, agentId].filter((part) => Boolean(part)).join(":").replace(/[^A-Za-z0-9_.:@/+-]/g, "-").slice(0, 128);
-var subagentStartText = (session, descriptor, event) => {
+var CLAUDE_WORKTREE = /[\\/]\.claude[\\/]worktrees[\\/]/;
+var ISOLATED_GIT = 'Run git as plain, separate commands inside your worktree (`git switch -c <branch> <base>`, `git commit --trailer "Workit-Session=<your session>"`, `git push`; `workit doctor --fix` can install a commit-msg hook that adds the trailer), never `workit git …`: Claude Code\'s worktree isolation refuses a command that wraps git and cannot be turned off (https://code.claude.com/docs/en/worktrees#how-claude-code-enforces-isolation). Never dodge that check by renaming or re-wrapping git. Use workit for the non-git verbs (`workit check`, `workit ledger`, `workit pr`).';
+var subagentStartText = (input, descriptor, event) => {
+  const session = input.session.id ?? null;
   const role = workitRole(descriptor, event.agentType);
   const who = `${descriptor.label} subagent ${event.agentId} (${event.agentType})`;
-  if (role === "implementer") {
-    const where = descriptor.subagents.worktreeIsolation === "native" ? "working in its own git worktree: it may edit and commit there" : "as an implementer: it edits and commits only in its own git worktree (the lead makes one with `workit fanout worktree create <slice>`), never in the lead's checkout";
-    return `Workit observed ${who} ${where}, 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 isolated = descriptor.subagents.worktreeIsolation === "native" && (role === "implementer" || CLAUDE_WORKTREE.test(input.cwd));
+  if (role === "implementer" && isolated)
+    return `Workit observed ${who} working in its own git worktree: it may edit and commit there, within its brief's scope. ${ISOLATED_GIT} Use a policy-compliant branch (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.`;
+  if (isolated)
+    return `${ISOLATED_GIT}
+${subagentStartText({ ...input, cwd: "" }, descriptor, event)}`;
+  if (role === "implementer")
+    return `Workit observed ${who} as an implementer: it edits and commits only in its own git worktree (the lead makes one with \`workit fanout worktree create <slice>\`), never in the lead's checkout, 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 ${who} as read-only/agent-guided.`;
   if (role !== "judge" || !event.agentId)
     return readOnly;
@@ -18757,7 +18960,7 @@ function handleHook(input, deps) {
   switch (event.kind) {
     case "session.start": {
       if (!usable2(descriptor.context.sessionStart))
-        return NONE4;
+        return NONE5;
       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)
@@ -18772,42 +18975,44 @@ function handleHook(input, deps) {
     }
     case "context.turn": {
       if (!usable2(descriptor.context.perTurn))
-        return NONE4;
+        return NONE5;
       const current = turnContextText(input, descriptor);
       const text = resendsOnChange(descriptor) ? changedTurnContext(input, current) : current;
-      return withContextLine(text ? { kind: "context", text } : NONE4, promptNudge(input, event.prompt));
+      return withContextLine(text ? { kind: "context", text } : NONE5, promptNudge(input, event.prompt));
     }
     case "shell.pre": {
       const skillRead = skillReadIn(event.command, event.dialect);
       if (skillRead)
         recordSkillLoad(input, skillRead, "read");
       const canDeny = usable2(descriptor.shellPolicy.deny);
-      const policy = canDeny ? shellPolicy(input.cwd, event.command) : NONE4;
+      const policy = canDeny ? shellPolicy(input.cwd, event.command) : NONE5;
       if (policy.kind !== "none")
         return policy;
       const postTool = usable2(descriptor.events["shell.post"].support);
       if (!postTool)
         settlePendingCommit(input);
-      const raw = canDeny ? rawGitPre(input, event.command) : NONE4;
+      const raw = canDeny ? rawGitPre(input, event.command, { nudge: false }) : NONE5;
       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;
+      const gate = writes.writes ? writeGate(input.cwd, writes.targets) : NONE5;
       if (gate.kind === "deny")
         return gate;
       noteRawCommit(input, event.command, postTool ? callKey(event.toolUseId, event.command) : NEXT_COMMAND);
-      return withContextLine(raw, shipNudge(input, event.command));
+      if (descriptor.transport !== "hook-process")
+        return NONE5;
+      return withContextLine(canDeny ? rawGitPre(input, event.command) : NONE5, shipNudge(input, event.command));
     }
     case "shell.post":
       if (usable2(descriptor.events["shell.post"].support))
         rawGitPost(input, event.command, callKey(event.toolUseId, event.command));
-      return NONE4;
+      return NONE5;
     case "write.pre":
-      return usable2(descriptor.events["write.pre"].support) ? writeGate(input.cwd, event.paths) : NONE4;
+      return usable2(descriptor.events["write.pre"].support) ? writeGate(input.cwd, event.paths) : NONE5;
     case "subagent.start":
       return {
         kind: "context",
-        text: subagentStartText(input.session.id ?? null, descriptor, event)
+        text: subagentStartText(input, descriptor, event)
       };
     case "compact.pre":
       return {
@@ -18817,19 +19022,20 @@ function handleHook(input, deps) {
     case "tool.pre":
       if (event.skill)
         recordSkillLoad(input, event.skill, "tool");
-      return NONE4;
+      return NONE5;
+    case "stop":
+      return usable2(descriptor.events.stop.support) ? stopDecision(input, descriptor) : NONE5;
     case "subagent.stop":
     case "prompt.submit":
-    case "stop":
-      return NONE4;
+      return NONE5;
   }
 }
 var failureDecision = (descriptor, event, error) => {
   if (event === "shell.pre" || event === "tool.pre" || event === "write.pre")
-    return descriptor.shellPolicy.failClosed ? { kind: "deny", reason: error, unblock: null } : NONE4;
+    return descriptor.shellPolicy.failClosed ? { kind: "deny", reason: error, unblock: null } : NONE5;
   if (event === "session.start" || event === "subagent.start")
     return { kind: "context", text: `[workit diagnostic: ${error}]` };
-  return NONE4;
+  return NONE5;
 };
 var dispatchHook = (adapter, raw, env = process.env) => {
   const parsed = adapter.parse(raw, env);
@@ -18871,7 +19077,7 @@ var CLAUDE_CODE_DESCRIPTOR = {
     "prompt.submit": { support: "native", native: "UserPromptSubmit" },
     "subagent.stop": { support: "none", native: null },
     "compact.pre": { support: "none", native: null },
-    stop: { support: "none", native: null }
+    stop: { support: "native", native: "Stop" }
   },
   shellPolicy: { deny: "native", channel: "permissionDecision", failClosed: false },
   context: {
@@ -19137,7 +19343,7 @@ var CODEX_DESCRIPTOR = {
     "subagent.stop": { support: "native", native: "SubagentStop" },
     "prompt.submit": { support: "native", native: "UserPromptSubmit" },
     "compact.pre": { support: "none", native: null },
-    stop: { support: "none", native: null }
+    stop: { support: "native", native: "Stop" }
   },
   shellPolicy: { deny: "native", channel: "permissionDecision", failClosed: false },
   context: {
@@ -19157,7 +19363,7 @@ var CODEX_DESCRIPTOR = {
   },
   provenance: { sessionId: "native", agentIdOnTool: "partial", postToolObserve: "native" },
   interaction: { questions: "none", writeBoundary: "partial" },
-  stopControl: "undocumented",
+  stopControl: "native",
   shellAvailable: "native",
   perEventCost: "low",
   capabilities: [
@@ -19224,7 +19430,8 @@ var EVENTS2 = {
   PreToolUse: "shell.pre",
   PostToolUse: "shell.post",
   SubagentStart: "subagent.start",
-  SubagentStop: "subagent.stop"
+  SubagentStop: "subagent.stop",
+  Stop: "stop"
 };
 var SHELL_TOOLS2 = new Set(["bash", "unified-exec"]);
 var isShellTool = (name) => SHELL_TOOLS2.has(String(name).toLowerCase());
@@ -19263,6 +19470,10 @@ var parseCodexHookInput = (value) => {
       ...nonEmpty2(value.tool_use_id) ? { tool_use_id: value.tool_use_id } : {},
       ...nonEmpty2(value.agent_id) ? { agent_id: value.agent_id } : {},
       ...nonEmpty2(value.agent_type) ? { agent_type: value.agent_type } : {},
+      ...event === "Stop" ? {
+        last_assistant_message: optionalText(value.last_assistant_message),
+        stop_hook_active: value.stop_hook_active === true
+      } : {},
       ...event === "SubagentStop" ? {
         agent_transcript_path: optionalText(value.agent_transcript_path),
         last_assistant_message: optionalText(value.last_assistant_message),
@@ -19315,13 +19526,21 @@ var protocolEvent = (input) => {
         lastMessage: input.last_assistant_message ?? null,
         stopHookActive: input.stop_hook_active ?? false
       };
+    case "Stop":
+      return {
+        kind: "stop",
+        lastMessage: input.last_assistant_message ?? null,
+        stopHookActive: input.stop_hook_active ?? false
+      };
   }
 };
 var output = (event, extra = {}) => ({
   hookSpecificOutput: { hookEventName: event, ...extra }
 });
 var render2 = (decision, native) => {
-  if (native === "SubagentStop" || native === null)
+  if (native === "Stop" && decision.kind === "continue")
+    return { json: { decision: "block", reason: decision.reason }, exitCode: 0 };
+  if (native === "SubagentStop" || native === "Stop" || native === null)
     return { json: {}, exitCode: 0 };
   if (decision.kind === "deny")
     return {
@@ -19368,6 +19587,7 @@ var codexAdapter = {
 };
 
 // packages/workit-core/src/hooks/hosts/cursor.ts
+import fs16 from "node:fs";
 import path21 from "node:path";
 var undocumented = { support: "undocumented", native: null };
 var none = { support: "none", native: null };
@@ -19388,7 +19608,7 @@ var CURSOR_DESCRIPTOR = {
     "subagent.stop": { support: "partial", native: "subagentStop" },
     "prompt.submit": undocumented,
     "compact.pre": { support: "partial", native: "preCompact" },
-    stop: none
+    stop: { support: "native", native: "stop" }
   },
   shellPolicy: { deny: "native", channel: "exit2+json", failClosed: true },
   context: {
@@ -19412,7 +19632,7 @@ var CURSOR_DESCRIPTOR = {
     postToolObserve: "undocumented"
   },
   interaction: { questions: "none", writeBoundary: "partial" },
-  stopControl: "undocumented",
+  stopControl: "native",
   shellAvailable: "native",
   perEventCost: "low",
   capabilities: [
@@ -19479,7 +19699,8 @@ var EVENTS3 = {
   beforeShellExecution: "shell.pre",
   subagentStart: "subagent.start",
   subagentStop: "subagent.stop",
-  preCompact: "compact.pre"
+  preCompact: "compact.pre",
+  stop: "stop"
 };
 var parseCursorHookInput = (value) => {
   if (!isRecord4(value) || !Object.hasOwn(EVENTS3, String(value.hook_event_name)))
@@ -19515,7 +19736,12 @@ var parseCursorHookInput = (value) => {
       ...event === "subagentStart" && nonEmpty2(value.subagent_id) ? { subagent_id: value.subagent_id } : {},
       ...event === "subagentStart" && nonEmpty2(value.subagent_type) ? { subagent_type: value.subagent_type } : {},
       ...event === "subagentStart" && nonEmpty2(value.parent_conversation_id) ? { parent_conversation_id: value.parent_conversation_id } : {},
-      ...event === "subagentStart" && nonEmpty2(value.task) ? { task: value.task } : {}
+      ...event === "subagentStart" && nonEmpty2(value.task) ? { task: value.task } : {},
+      ...event === "stop" ? {
+        ...nonEmpty2(value.status) ? { status: value.status } : {},
+        ...typeof value.loop_count === "number" ? { loop_count: value.loop_count } : {},
+        ...nonEmpty2(value.transcript_path) ? { transcript_path: value.transcript_path } : {}
+      } : {}
     }
   };
 };
@@ -19549,6 +19775,51 @@ var protocolEvent2 = (input) => {
       };
     case "preCompact":
       return { kind: "compact.pre", trigger: "auto" };
+    case "stop":
+      return {
+        kind: "stop",
+        lastMessage: (input.status ?? "completed") === "completed" ? lastAssistantText(input.transcript_path) : null,
+        stopHookActive: (input.loop_count ?? 0) > 0
+      };
+  }
+};
+var TRANSCRIPT_TAIL_BYTES = 256 * 1024;
+var lastAssistantText = (file) => {
+  if (!file || !path21.isAbsolute(file))
+    return null;
+  try {
+    const size = fs16.statSync(file).size;
+    const start = Math.max(0, size - TRANSCRIPT_TAIL_BYTES);
+    const buffer = Buffer.alloc(size - start);
+    const fd = fs16.openSync(file, "r");
+    try {
+      fs16.readSync(fd, buffer, 0, buffer.length, start);
+    } finally {
+      fs16.closeSync(fd);
+    }
+    const lines = buffer.toString("utf8").split(`
+`);
+    for (let index = lines.length - 1;index >= 0; index--) {
+      let entry;
+      try {
+        entry = JSON.parse(lines[index]);
+      } catch {
+        continue;
+      }
+      if (!isRecord4(entry) || entry.role !== "assistant")
+        continue;
+      const content = isRecord4(entry.message) ? entry.message.content : entry.content;
+      if (typeof content === "string")
+        return content;
+      if (!Array.isArray(content))
+        return null;
+      const text = content.filter((part) => isRecord4(part) && part.type === "text" && typeof part.text === "string").map((part) => part.text).join(`
+`);
+      return text || null;
+    }
+    return null;
+  } catch {
+    return null;
   }
 };
 var within = (root, dir) => dir === root || dir.startsWith(root.endsWith(path21.sep) ? root : `${root}${path21.sep}`);
@@ -19580,6 +19851,8 @@ var render3 = (decision, native) => {
     return { json: { additional_context: decision.text }, exitCode: 0 };
   if (decision.kind === "notice")
     return { json: { user_message: decision.userMessage }, exitCode: 0 };
+  if (decision.kind === "continue" && native === "stop")
+    return { json: { followup_message: decision.reason }, exitCode: 0 };
   return {
     json: native !== null && BLOCKING2.has(native) ? { permission: "allow" } : {},
     exitCode: 0

package/dist/workit-hook.js

@@ -37,6 +37,6 @@ if (quiet)
   process.stdout.write(`${JSON.stringify({ hookSpecificOutput: { hookEventName: quiet } })}
 `);
 else {
-  const { runCodexHook } = await import("./workit-hook-86r77dqq.js");
+  const { runCodexHook } = await import("./workit-hook-aw8j630z.js");
   await runCodexHook([payload]);
 }

package/hooks/hooks.json

@@ -29,6 +29,13 @@
         "hooks": [{ "type": "command", "command": "node ${PLUGIN_ROOT}/dist/workit-hook.js" }]
       }
     ],
+    "Stop": [
+      {
+        "hooks": [
+          { "type": "command", "command": "node ${PLUGIN_ROOT}/dist/workit-hook.js", "timeout": 10 }
+        ]
+      }
+    ],
     "SubagentStop": [
       {
         "matcher": "*",

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@brainervirus/workit-codex",
-  "version": "8.6.1",
+  "version": "8.8.0",
   "private": false,
-  "description": "Workit Codex CLI/desktop plugin — shared MCP transport, hooks, and sixteen method skills",
+  "description": "Workit Codex CLI/desktop plugin — shared MCP transport, hooks, method skills, and verifier/reviewer/implementer agents",
   "keywords": [
     "agentic-coding",
     "ai-agents",
@@ -27,7 +27,8 @@
     ".codex-plugin/",
     ".mcp.json",
     "hooks/hooks.json",
-    "skills/"
+    "skills/",
+    "agents/"
   ],
   "type": "module",
   "main": "./dist/launch-mcp.js",
@@ -38,8 +39,8 @@
     "build": "bun scripts/build.ts"
   },
   "dependencies": {
-    "@brainervirus/workit-core": "^8.6.1",
-    "@brainervirus/workit-mcp": "^8.6.1"
+    "@brainervirus/workit-core": "^8.8.0",
+    "@brainervirus/workit-mcp": "^8.8.0"
   },
   "engines": {
     "node": ">=24"