@brainervirus/workit-cursor 8.4.1 → 8.5.2

package/dist/workit-hook.js

@@ -17273,6 +17273,8 @@ var capabilitiesFor = (descriptor, observed = {}) => descriptor.capabilities.map
   };
 });
 // packages/workit-core/src/hooks/context.ts
+import { createHash as createHash10 } from "node:crypto";
+import fs13 from "node:fs";
 import path16 from "node:path";
 var MIGRATION_PENDING_NOTE = "workit migration pending — run `workit task status`";
 var migrationPending = (result) => !result.ok && result.code === "needs_input" && (result.error ?? "").startsWith(MIGRATION_PENDING);
@@ -17420,8 +17422,77 @@ var turnContextText = (input, descriptor) => {
     return null;
   }
 };
+var TURN_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+var digestOf = (text) => createHash10("sha256").update(text).digest("hex");
+var turnMarker = (input) => {
+  if (!input.session.id)
+    return null;
+  try {
+    const location = resolveStore(input.cwd);
+    if (location instanceof Error)
+      return null;
+    const session = [input.host, input.session.id, input.session.agentId ?? ""].join("\x00");
+    return path16.join(location.dir, "hooks", `turn-${digestOf(session).slice(0, 32)}.json`);
+  } catch {
+    return null;
+  }
+};
+var writeTurnDigest = (file, digest) => {
+  try {
+    fs13.mkdirSync(path16.dirname(file), { recursive: true });
+    fs13.writeFileSync(file, `${JSON.stringify({ digest })}
+`);
+  } catch {}
+};
+var clearTurnDigest = (file) => {
+  try {
+    fs13.rmSync(file, { force: true });
+  } catch {}
+};
+var pruneTurnDigests = (dir, now) => {
+  try {
+    for (const name of fs13.readdirSync(dir)) {
+      if (!name.startsWith("turn-"))
+        continue;
+      const file = path16.join(dir, name);
+      try {
+        if (now - fs13.statSync(file).mtimeMs > TURN_TTL_MS)
+          fs13.rmSync(file, { force: true });
+      } catch {}
+    }
+  } catch {}
+};
+var changedTurnContext = (input, text) => {
+  const file = turnMarker(input);
+  if (!text) {
+    if (file)
+      clearTurnDigest(file);
+    return null;
+  }
+  if (!file)
+    return text;
+  const digest = digestOf(text);
+  try {
+    const previous = JSON.parse(fs13.readFileSync(file, "utf8"));
+    if (previous.digest === digest)
+      return null;
+  } catch {}
+  writeTurnDigest(file, digest);
+  return text;
+};
+var seedTurnContext = (input, descriptor) => {
+  const file = turnMarker(input);
+  if (!file)
+    return;
+  pruneTurnDigests(path16.dirname(file), Date.now());
+  const text = turnContextText(input, descriptor);
+  if (text)
+    writeTurnDigest(file, digestOf(text));
+  else
+    clearTurnDigest(file);
+};
 // packages/workit-core/src/core/branch.ts
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 var withReleaseTracks = (workspaceRoot, policy) => {
   const read = workspaceReleaseTracks(workspaceRoot);
   if (read.error)
@@ -17489,7 +17560,7 @@ var branchPolicySnapshotFor = (workspaceRoot) => {
   const source = resolved.provenance.branchPolicy;
   const allowed = branchPolicy.allowed.map((pattern) => `${pattern.source}/${pattern.flags}`).toSorted();
   const protectedRefs = [...branchPolicy.protected].map((name) => name.toLowerCase()).toSorted();
-  const fingerprint = createHash10("sha256").update(JSON.stringify({ allowed, protectedRefs, source })).digest("hex");
+  const fingerprint = createHash11("sha256").update(JSON.stringify({ allowed, protectedRefs, source })).digest("hex");
   return {
     branchPolicy,
     namePolicy: { allowed: branchPolicy.allowed, protected: branchPolicy.protected },
@@ -17824,7 +17895,7 @@ function writeGate(cwd, paths) {
     const gate = gateFor(cwd);
     if (!gate || gate.blockers.length === 0)
       return NONE2;
-    if (paths && paths.every((file) => exempt(cwd, gate.root, file, gate.plans)))
+    if (paths?.length && paths.every((file) => exempt(cwd, gate.root, file, gate.plans)))
       return NONE2;
     const reasons = gate.blockers.map((item) => `${item.ruleId}: ${item.reason}`).join("; ");
     return {
@@ -17838,8 +17909,8 @@ function writeGate(cwd, paths) {
 }
 // packages/workit-core/src/hooks/raw-git.ts
 import { spawnSync as spawnSync11 } from "node:child_process";
-import { createHash as createHash11 } from "node:crypto";
-import fs13 from "node:fs";
+import { createHash as createHash12 } from "node:crypto";
+import fs14 from "node:fs";
 import os4 from "node:os";
 import path18 from "node:path";
 var NONE3 = { kind: "none" };
@@ -18085,7 +18156,7 @@ var repoAt = (dir) => {
   return { location, dir, branch: resolveTaskKey(dir, location).branch };
 };
 var isWorkitWorkspace = (repo) => {
-  if (fs13.existsSync(repo.location.dir))
+  if (fs14.existsSync(repo.location.dir))
     return true;
   try {
     return resolveRuntimeWorkspaceVcs(repo.location.top ?? repo.dir) !== null;
@@ -18116,7 +18187,7 @@ var headSha2 = (repo) => {
   if (!git || git.reftable)
     return null;
   try {
-    const head = fs13.readFileSync(path18.join(git.gitDir, "HEAD"), "utf8").trim();
+    const head = fs14.readFileSync(path18.join(git.gitDir, "HEAD"), "utf8").trim();
     if (/^[0-9a-f]{40,64}$/.test(head))
       return head;
     const ref = /^ref: (refs\/.+)$/.exec(head)?.[1];
@@ -18124,9 +18195,9 @@ var headSha2 = (repo) => {
       return null;
     const common = path18.dirname(repo.location.dir);
     try {
-      return fs13.readFileSync(path18.join(common, ref), "utf8").trim() || null;
+      return fs14.readFileSync(path18.join(common, ref), "utf8").trim() || null;
     } catch {}
-    const packed = fs13.readFileSync(path18.join(common, "packed-refs"), "utf8");
+    const packed = fs14.readFileSync(path18.join(common, "packed-refs"), "utf8");
     return new RegExp(`^([0-9a-f]{40,64}) ${ref.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`, "m").exec(packed)?.[1] ?? null;
   } catch {
     return null;
@@ -18174,6 +18245,11 @@ var actionsIn = (cwd, command, dialect) => {
   }
   return out;
 };
+var inWorkitWorkspace = (dir) => {
+  const repo = repoAt(dir);
+  return repo !== null && isWorkitWorkspace(repo);
+};
+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) {
@@ -18203,8 +18279,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-${createHash11("sha256").update(`${session}\x00${key}`).digest("hex").slice(0, 32)}.json`);
-var callKey = (toolUseId, command) => toolUseId ?? `cmd:${createHash11("sha256").update(command).digest("hex")}`;
+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")}`;
 function noteRawCommit(input, command, key) {
   try {
     if (!input.session.id || !/\bcommit\b/.test(command))
@@ -18214,8 +18290,8 @@ function noteRawCommit(input, command, key) {
       if (action.kind !== "commit")
         continue;
       const file = markerFile(repo, input.session.id, key);
-      fs13.mkdirSync(path18.dirname(file), { recursive: true });
-      fs13.writeFileSync(file, `${JSON.stringify({ head: headSha2(repo), at })}
+      fs14.mkdirSync(path18.dirname(file), { recursive: true });
+      fs14.writeFileSync(file, `${JSON.stringify({ head: headSha2(repo), at })}
 `);
     }
   } catch {}
@@ -18238,11 +18314,11 @@ var headCommit = (dir) => {
 var settle2 = (input, repo, file) => {
   let marker;
   try {
-    marker = JSON.parse(fs13.readFileSync(file, "utf8"));
+    marker = JSON.parse(fs14.readFileSync(file, "utf8"));
   } catch {
     return;
   }
-  fs13.rmSync(file, { force: true });
+  fs14.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)
@@ -18291,18 +18367,297 @@ function settlePendingCommit(input) {
     if (!repo)
       return;
     const file = markerFile(repo, input.session.id, NEXT_COMMAND);
-    if (fs13.existsSync(file))
+    if (fs14.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/core/skill-manifests.ts
+var WORKIT_METHOD_SKILLS = [
+  "workit-shape",
+  "workit-implement",
+  "workit-review",
+  "workit-debug",
+  "workit-ship",
+  "workit-continue",
+  "workit-bdd",
+  "workit-test-audit",
+  "workit-deslop",
+  "workit-fanout",
+  "workit-verify-app",
+  "workit-retro",
+  "workit-architecture"
+];
+var WORKIT_SKILL_ALIASES = {
+  "wk-shape": "workit-shape",
+  "wk-implement": "workit-implement",
+  "wk-review": "workit-review",
+  "wk-debug": "workit-debug",
+  "wk-ship": "workit-ship",
+  "wk-continue": "workit-continue",
+  "wk-bdd": "workit-bdd",
+  "wk-test-audit": "workit-test-audit",
+  "wk-deslop": "workit-deslop",
+  "wk-fanout": "workit-fanout",
+  "wk-verify-app": "workit-verify-app",
+  "wk-retro": "workit-retro",
+  "wk-architecture": "workit-architecture"
+};
+var skillLoadWording = (host, skill) => {
+  switch (host) {
+    case "claude-code":
+      return `call the Skill tool with \`workit:${skill.replace(/^workit-/, "")}\``;
+    case "opencode":
+      return `call the skill tool with \`${skill}\``;
+    default:
+      return `read the \`${skill}\` skill's SKILL.md and follow it`;
+  }
+};
+if (false) {}
+
+// packages/workit-core/src/hooks/skill-nudge.ts
+var USER_INVOKED = new Set(["workit-retro", "workit-architecture"]);
+var SKILL_HOST = {
+  claude_code: "claude-code",
+  opencode: "opencode",
+  codex_cli: "codex",
+  codex_desktop: "codex",
+  cursor: "cursor",
+  pi: "pi"
+};
+var PROMPT_INTENTS = [
+  [
+    "workit-debug",
+    /\b(flaky|regressed|(?:is|introduced) a regression|regression (?:in|after|since|from)|(?:is|are|got|looks) broken|debug (?:this|it|the|why)|fix (?:the|this|a) bug)\b/i
+  ],
+  [
+    "workit-continue",
+    /\b(pick up where|where (?:were|did) we|resume (?:the|this|my|our|work|where)|hand ?off)\b/i
+  ],
+  [
+    "workit-review",
+    /\b(blast radius|code review|review (?:the|this|my|PR|pr|#\d+|branch|diff|changes))\b/i
+  ],
+  [
+    "workit-ship",
+    /\b(ship (?:it|this|the)|babysit|open (?:a|the) (?:PR|pr|MR|mr)(?=\s*$|\s+(?:for|to|on|with|and|against|into|from|after|once)\b|[.!,;])|merge (?:the|this|my) (?:PR|pr|MR|mr|branch)|(?:get|until|make) CI (?:is )?green)\b/i
+  ],
+  ["workit-bdd", /\b(BDD|TDD|acceptance criteria|Given\/When\/Then)(?![\w/])/],
+  ["workit-test-audit", /\b(test audit|audit the tests|tautolog\w*|weak tests)\b/i],
+  ["workit-deslop", /\b(deslop|slop|dead code)\b/i],
+  [
+    "workit-fanout",
+    /\b(fan(?: |-)?out|parallelize|parallel agents|agent swarm|swarm of agents)\b/i
+  ],
+  ["workit-verify-app", /\b(verify the app|smoke test|prove it works)\b/i],
+  ["workit-retro", /\b((?:a|the) retro(?![-\w]|\.\w)|retrospective)/i],
+  ["workit-architecture", /\b(deepen (?:the )?modules|architecture (?:review|pass|audit))\b/i],
+  [
+    "workit-shape",
+    /\b(brainstorm\w*|grill me|should we|let'?s plan|plan (?:out|how|the|a|for)|(?:write|draft) (?:a|the) spec)\b/i
+  ],
+  [
+    "workit-implement",
+    /\b(implement (?:the|this|a|it)|add (?:a|the) feature|build (?:a|an|the) (?:new )?(?:feature|command|verb|page|endpoint|component|cli|tool))\b/i
+  ]
+];
+var workitSkillOf = (name) => {
+  const bare = name.trim().replace(/^\//, "").toLowerCase();
+  const alias = WORKIT_SKILL_ALIASES[bare];
+  if (alias)
+    return alias;
+  const skill = bare.replace(/^workit:/, "workit-");
+  return WORKIT_METHOD_SKILLS.includes(skill) ? skill : null;
+};
+var promptTrigger = (prompt) => {
+  const text = prompt.replace(/```[\s\S]*?```/g, " ").slice(0, 4000);
+  for (const [skill, pattern] of PROMPT_INTENTS) {
+    const match = pattern.exec(text);
+    if (match)
+      return { skill, trigger: match[1] ?? match[0] };
+  }
+  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;
+  if (!ledger.ok)
+    return loaded;
+  for (const row of ledger.value.rows)
+    if (row.type === "skill.loaded" && row.actor.session === session && typeof row.skill === "string")
+      loaded.add(row.skill);
+  return loaded;
+};
+var SKILL_FILE = /(?:^|[\\/])(workit-[a-z-]+)[\\/]SKILL\.md$/;
+var skillFileIn = (file) => SKILL_FILE.exec(file)?.[1] ?? null;
+var READERS = new Set([
+  "cat",
+  "sed",
+  "head",
+  "tail",
+  "less",
+  "more",
+  "bat",
+  "nl",
+  "get-content",
+  "gc",
+  "type"
+]);
+var skillReadIn = (command, dialect = "posix") => {
+  for (const { words } of segmentsOf(command, dialect)) {
+    if (!READERS.has((words[0]?.split(/[\\/]/).at(-1) ?? "").toLowerCase()))
+      continue;
+    if (words.some((word) => /^(?:-i(?:\.\w+)?|--in-place(?:=.*)?)$/.test(word)))
+      continue;
+    for (const word of words.slice(1)) {
+      const skill = skillFileIn(word);
+      if (skill)
+        return skill;
+    }
+  }
+  return null;
+};
+function recordSkillLoad(input, name, via) {
+  try {
+    const skill = workitSkillOf(name);
+    const session = input.session.id;
+    if (!skill || !session)
+      return;
+    if (!inWorkitWorkspace(input.cwd))
+      return;
+    const file = markerFile2(input, session);
+    if (!file)
+      return;
+    const marker = readMarker(file);
+    if (marker.loaded.includes(skill))
+      return;
+    writeMarker(file, { ...marker, loaded: [...marker.loaded, skill] });
+    if (loadedSkills(input.cwd, session).has(skill))
+      return;
+    appendHookObserved(input.cwd, {
+      type: "skill.loaded",
+      actor: { host: input.host, session, agentId: input.session.agentId },
+      skill,
+      via
+    });
+  } catch {}
+}
+var nudgeOnce = (input, session, skill, line) => {
+  const file = markerFile2(input, session);
+  if (!file)
+    return null;
+  const marker = readMarker(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] });
+  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;
+function promptNudge(input, prompt) {
+  try {
+    const session = input.session.id;
+    if (!prompt || !session || input.session.agentId)
+      return null;
+    const loads = promptLoads(prompt);
+    if (loads) {
+      recordSkillLoad(input, loads, "slash");
+      return null;
+    }
+    const hit = promptTrigger(prompt);
+    if (!hit || !inWorkitWorkspace(input.cwd))
+      return null;
+    return nudgeOnce(input, session, hit.skill, nudgeText(input, hit.skill, `this request ("${hit.trigger}")`));
+  } catch {
+    return null;
+  }
+}
+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 isDeliveryCommand = (cwd, command, dialect = "posix") => rawDelivery(cwd, command, dialect) || runsWorkitDelivery(command, dialect) && inWorkitWorkspace(cwd);
+function shipNudge(input, command) {
+  try {
+    const session = input.session.id;
+    if (!session || input.session.agentId)
+      return null;
+    const dialect = input.event.kind === "shell.pre" ? input.event.dialect ?? "posix" : "posix";
+    if (!isDeliveryCommand(input.cwd, command, dialect))
+      return null;
+    return nudgeOnce(input, session, "workit-ship", nudgeText(input, "workit-ship", "this delivery step"));
+  } catch {
+    return null;
+  }
+}
+var withContextLine = (decision, line) => {
+  if (!line)
+    return decision;
+  if (decision.kind === "none")
+    return { kind: "context", text: line };
+  if (decision.kind === "context")
+    return { kind: "context", text: `${decision.text}
+${line}` };
+  return decision;
+};
 // packages/workit-core/src/hooks/hosts/fields.ts
 import { existsSync as existsSync6, realpathSync as realpathSync6, statSync as statSync2 } from "node:fs";
-import path19 from "node:path";
+import path20 from "node:path";
 var isRecord4 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 var nonEmpty2 = (value) => typeof value === "string" && value.trim() !== "";
 var optionalText = (value) => typeof value === "string" ? value : null;
 var existingDirectory = (value) => {
-  if (!nonEmpty2(value) || !path19.isAbsolute(value) || !existsSync6(value))
+  if (!nonEmpty2(value) || !path20.isAbsolute(value) || !existsSync6(value))
     return null;
   try {
     return statSync2(value).isDirectory() ? realpathSync6(value) : null;
@@ -18310,7 +18665,7 @@ var existingDirectory = (value) => {
     return null;
   }
 };
-var SHELLS2 = new Set(["sh", "bash", "zsh", "dash", "pwsh", "powershell", "cmd"]);
+var SHELLS3 = 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) => {
@@ -18322,7 +18677,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 (SHELLS2.has(shell))
+  if (SHELLS3.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;
@@ -18353,30 +18708,49 @@ var WRITE_TOOLS = new Set([
 ]);
 var isWriteTool = (name) => typeof name === "string" && WRITE_TOOLS.has(name.toLowerCase().replace(/[_-]/g, ""));
 var PATH_KEYS = ["file_path", "filePath", "notebook_path", "path", "target_file", "file"];
+var PATCH_HEADER = /^[ \t]*\*\*\* (?:(?:Add|Update|Delete) File|Move to): (.+)$/gm;
 var writePaths = (input) => {
   if (!isRecord4(input))
     return [];
   const paths = PATH_KEYS.map((key) => input[key]).filter(nonEmpty2);
   for (const value of Object.values(input))
     if (typeof value === "string")
-      for (const match of value.matchAll(/^\*\*\* (?:Add|Update|Delete) File: (.+)$/gm))
+      for (const match of value.matchAll(PATCH_HEADER))
         paths.push(match[1].trim());
   return [...new Set(paths)];
 };
+var writeTargets = (input) => {
+  const paths = writePaths(input);
+  return paths.length > 0 ? paths : null;
+};
 // packages/workit-core/src/hooks/handle.ts
 var usable2 = (value) => value === "native" || value === "partial";
 var NONE4 = { kind: "none" };
+var resendsOnChange = (descriptor) => descriptor.context.turnResend === "on-change" && usable2(descriptor.context.perTurn);
 var offered = new Set;
-var CLAUDE_WORKTREE_IMPLEMENTER = "workit:implementer";
-var CLAUDE_JUDGES = new Set(["workit:verifier", "workit:reviewer"]);
+var ROLES = {
+  implementer: "implementer",
+  verifier: "judge",
+  reviewer: "judge"
+};
+var workitRole = (descriptor, agentType) => {
+  const prefix = descriptor.subagents.agentPrefix;
+  const name = agentType.startsWith(prefix) ? agentType.slice(prefix.length) : "";
+  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 = (host, session, descriptor, event) => {
-  if (host === "claude_code" && event.agentType === CLAUDE_WORKTREE_IMPLEMENTER)
-    return `Workit observed ${descriptor.label} subagent ${event.agentId} (${event.agentType}) working in its own git worktree: it may edit and commit there, within its brief's scope. Before the first commit, switch to a policy-compliant branch with \`workit git branch <branch> --base <base>\` (e.g. feature/<slug>); branch policy hooks still deny protected or non-compliant branches. Never record a verdict on your own work. Never push, open a PR, or merge unless the brief asks for it.`;
-  const readOnly = `Workit observed ${descriptor.label} subagent ${event.agentId} (${event.agentType}) as read-only/agent-guided.`;
-  if (host === "claude_code" && event.agentType && CLAUDE_JUDGES.has(event.agentType) && event.agentId)
-    return `${readOnly} Its own Workit session is ${subagentSession(session, event.agentId)}: record verdicts with \`workit ledger verdict <result> --session ${subagentSession(session, event.agentId)} ...\` so the ledger tells it apart from the author.`;
-  return readOnly;
+var subagentStartText = (session, descriptor, event) => {
+  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 readOnly = `Workit observed ${who} as read-only/agent-guided.`;
+  if (role !== "judge" || !event.agentId)
+    return readOnly;
+  const own = subagentSession(session, event.agentId);
+  return `${readOnly} Its own Workit session is ${own}: record verdicts with \`workit ledger verdict <result> --session ${own} ...\` so the ledger tells it apart from the author.`;
 };
 function handleHook(input, deps) {
   const { descriptor } = deps;
@@ -18392,18 +18766,22 @@ function handleHook(input, deps) {
       const advisory = usable2(descriptor.events["write.pre"].support) ? null : `Workit cannot gate file writes on ${descriptor.label} (no pre-write hook): before-write requirements (an open product choice, a missing plan) are advisory here, so settle them before editing.`;
       const addendum = [deps.addendum, advisory].filter(Boolean).join(`
 `) || null;
-      return {
-        kind: "context",
-        text: sessionContextText(input, descriptor, { offer, addendum })
-      };
+      const text = sessionContextText(input, descriptor, { offer, addendum });
+      if (resendsOnChange(descriptor))
+        seedTurnContext(input, descriptor);
+      return { kind: "context", text };
     }
     case "context.turn": {
       if (!usable2(descriptor.context.perTurn))
         return NONE4;
-      const text = turnContextText(input, descriptor);
-      return text ? { kind: "context", text } : NONE4;
+      const current = turnContextText(input, descriptor);
+      const text = resendsOnChange(descriptor) ? changedTurnContext(input, current) : current;
+      return withContextLine(text ? { kind: "context", text } : NONE4, 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;
       if (policy.kind !== "none")
@@ -18419,7 +18797,7 @@ function handleHook(input, deps) {
       if (gate.kind === "deny")
         return gate;
       noteRawCommit(input, event.command, postTool ? callKey(event.toolUseId, event.command) : NEXT_COMMAND);
-      return raw;
+      return withContextLine(raw, shipNudge(input, event.command));
     }
     case "shell.post":
       if (usable2(descriptor.events["shell.post"].support))
@@ -18430,7 +18808,7 @@ function handleHook(input, deps) {
     case "subagent.start":
       return {
         kind: "context",
-        text: subagentStartText(input.host, input.session.id ?? null, descriptor, event)
+        text: subagentStartText(input.session.id ?? null, descriptor, event)
       };
     case "compact.pre":
       return {
@@ -18438,6 +18816,9 @@ function handleHook(input, deps) {
         userMessage: "Workit context may be stale after compaction; re-run inspection or resume before acting."
       };
     case "tool.pre":
+      if (event.skill)
+        recordSkillLoad(input, event.skill, "tool");
+      return NONE4;
     case "subagent.stop":
     case "prompt.submit":
     case "stop":
@@ -18488,24 +18869,26 @@ var CLAUDE_CODE_DESCRIPTOR = {
     "write.pre": { support: "native", native: "PreToolUse" },
     "shell.post": { support: "native", native: "PostToolUse" },
     "subagent.start": { support: "native", native: "SubagentStart" },
-    "subagent.stop": { support: "native", native: "SubagentStop" },
     "prompt.submit": { support: "native", native: "UserPromptSubmit" },
-    "compact.pre": { support: "partial", native: "PreCompact" },
-    stop: { support: "native", native: "Stop" }
+    "subagent.stop": { support: "none", native: null },
+    "compact.pre": { support: "none", native: null },
+    stop: { support: "none", native: null }
   },
   shellPolicy: { deny: "native", channel: "permissionDecision", failClosed: false },
   context: {
     sessionStart: "native",
     perTurn: "native",
     afterCompact: "native",
-    task: "session-bound"
+    task: "session-bound",
+    turnResend: "every-turn"
   },
   subagents: {
     identity: "native",
     parentBinding: "partial",
     blockStart: "none",
     worktreeIsolation: "native",
-    maxConcurrency: "undocumented"
+    maxConcurrency: "undocumented",
+    agentPrefix: "workit:"
   },
   provenance: { sessionId: "native", agentIdOnTool: "native", postToolObserve: "native" },
   interaction: { questions: "undocumented", writeBoundary: "partial" },
@@ -18523,13 +18906,13 @@ var CLAUDE_CODE_DESCRIPTOR = {
     },
     {
       name: "native_subagents",
-      surface: "SubagentStart/SubagentStop",
-      refs: ["SubagentStart", "SubagentStop"],
-      requires: ["event:subagent.start", "event:subagent.stop"],
-      observed: ["subagent.start", "subagent.stop"],
+      surface: "SubagentStart",
+      refs: ["SubagentStart"],
+      requires: ["event:subagent.start"],
+      observed: ["subagent.start"],
       assurance: "agent_guided",
       reason: "Claude Code reports stable agent identities, but SubagentStart cannot block or bind",
-      unavailableReason: "Claude Code subagent lifecycle hooks are unavailable"
+      unavailableReason: "Claude Code SubagentStart is unavailable"
     },
     {
       name: "fresh-context-review",
@@ -18580,7 +18963,7 @@ var eventOf = (name, value) => {
     case "SessionStart":
       return SOURCES.has(value.source) ? { ok: true, event: { kind: "session.start", source: value.source } } : { ok: false, error: "SessionStart source is required" };
     case "UserPromptSubmit":
-      return { ok: true, event: { kind: "context.turn" } };
+      return { ok: true, event: { kind: "context.turn", prompt: optionalText(value.prompt) } };
     case "PreToolUse": {
       if (!nonEmpty2(value.tool_name))
         return { ok: false, error: "tool_name is required" };
@@ -18590,10 +18973,20 @@ var eventOf = (name, value) => {
           event: {
             kind: "write.pre",
             tool: value.tool_name,
-            paths: writePaths(value.tool_input),
+            paths: writeTargets(value.tool_input),
             toolUseId
           }
         };
+      if (value.tool_name === "Skill")
+        return {
+          ok: true,
+          event: {
+            kind: "tool.pre",
+            tool: value.tool_name,
+            toolUseId,
+            skill: isRecord4(value.tool_input) ? optionalText(value.tool_input.skill) : null
+          }
+        };
       if (!SHELL_TOOLS.has(value.tool_name))
         return { ok: true, event: { kind: "tool.pre", tool: value.tool_name, toolUseId } };
       const command = toolCommand(value);
@@ -18728,39 +19121,40 @@ var claudeCodeAdapter = {
 function detectCodexSurface(env) {
   return env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE === "Codex Desktop" || Boolean(env.CODEX_ELECTRON_RESOURCES_PATH) ? "codex_desktop" : "codex_cli";
 }
-var undocumented = { support: "undocumented", native: null };
 var CODEX_DESCRIPTOR = {
   host: "codex_cli",
   label: "Codex",
-  verifiedAgainst: "codex-cli 0.153.4; Codex Desktop 26.901.20858",
+  verifiedAgainst: "codex-cli 0.160.1 (hook JSON schemas in the binary); Codex Desktop 26.901.20858",
   docs: ["https://developers.openai.com/codex/hooks"],
   transport: "hook-process",
   events: {
     "session.start": { support: "native", native: "SessionStart" },
-    "context.turn": undocumented,
+    "context.turn": { support: "native", native: "UserPromptSubmit" },
     "shell.pre": { support: "native", native: "PreToolUse" },
     "tool.pre": { support: "native", native: "PreToolUse" },
-    "write.pre": { support: "undocumented", native: null },
+    "write.pre": { support: "native", native: "PreToolUse" },
     "shell.post": { support: "native", native: "PostToolUse" },
     "subagent.start": { support: "native", native: "SubagentStart" },
     "subagent.stop": { support: "native", native: "SubagentStop" },
-    "prompt.submit": undocumented,
+    "prompt.submit": { support: "native", native: "UserPromptSubmit" },
     "compact.pre": { support: "none", native: null },
-    stop: undocumented
+    stop: { support: "none", native: null }
   },
   shellPolicy: { deny: "native", channel: "permissionDecision", failClosed: false },
   context: {
     sessionStart: "native",
-    perTurn: "undocumented",
+    perTurn: "native",
     afterCompact: "native",
-    task: "single-active"
+    task: "single-active",
+    turnResend: "on-change"
   },
   subagents: {
     identity: "native",
     parentBinding: "none",
     blockStart: "none",
     worktreeIsolation: "undocumented",
-    maxConcurrency: "undocumented"
+    maxConcurrency: "undocumented",
+    agentPrefix: "workit-"
   },
   provenance: { sessionId: "native", agentIdOnTool: "partial", postToolObserve: "native" },
   interaction: { questions: "none", writeBoundary: "partial" },
@@ -18827,6 +19221,7 @@ var CODEX_DESCRIPTOR = {
 };
 var EVENTS2 = {
   SessionStart: "session.start",
+  UserPromptSubmit: "context.turn",
   PreToolUse: "shell.pre",
   PostToolUse: "shell.post",
   SubagentStart: "subagent.start",
@@ -18834,7 +19229,7 @@ var EVENTS2 = {
 };
 var SHELL_TOOLS2 = new Set(["bash", "unified-exec"]);
 var isShellTool = (name) => SHELL_TOOLS2.has(String(name).toLowerCase());
-var SOURCES2 = new Set(["startup", "resume", "clear", "compact"]);
+var SOURCES2 = new Set(["startup", "resume", "clear", "compact", "fork"]);
 var parseCodexHookInput = (value) => {
   if (!isRecord4(value) || !Object.hasOwn(EVENTS2, String(value.hook_event_name)))
     return { ok: false, error: "hook_event_name is required" };
@@ -18861,6 +19256,7 @@ var parseCodexHookInput = (value) => {
       cwd,
       ...event === "SessionStart" ? { source: SOURCES2.has(String(value.source)) ? value.source : "resume" } : {},
       ...nonEmpty2(value.turn_id) ? { turn_id: value.turn_id } : {},
+      ...event === "UserPromptSubmit" ? { prompt: optionalText(value.prompt) } : {},
       ...nonEmpty2(value.tool_name) ? { tool_name: value.tool_name } : {},
       ...toolEvent ? { tool_input: value.tool_input } : {},
       ...event === "PostToolUse" && typeof value.tool_response === "string" ? { tool_response: value.tool_response } : {},
@@ -18880,13 +19276,20 @@ var protocolEvent = (input) => {
   switch (input.hook_event_name) {
     case "SessionStart":
       return { kind: "session.start", source: input.source };
+    case "UserPromptSubmit":
+      return { kind: "context.turn", prompt: input.prompt ?? null };
     case "PreToolUse": {
       const toolUseId = input.tool_use_id ?? null;
-      return isShellTool(input.tool_name) ? {
-        kind: "shell.pre",
-        command: input.command ?? "",
-        toolUseId
-      } : { kind: "tool.pre", tool: input.tool_name, toolUseId };
+      if (isShellTool(input.tool_name))
+        return { kind: "shell.pre", command: input.command ?? "", toolUseId };
+      if (isWriteTool(input.tool_name))
+        return {
+          kind: "write.pre",
+          tool: input.tool_name,
+          paths: writeTargets(input.tool_input),
+          toolUseId
+        };
+      return { kind: "tool.pre", tool: input.tool_name, toolUseId };
     }
     case "PostToolUse": {
       const toolUseId = input.tool_use_id ?? null;
@@ -18962,12 +19365,12 @@ var codexAdapter = {
     };
   },
   render: render2,
-  addendum: (input) => `<workit-codex-mutations>Codex MCP is read-only: unattested callers cannot mutate. Run workit verbs with the workit CLI on the shell (node_modules/.bin/workit, or npx -y @brainervirus/workit-cli): check, git branch|commit|push, pr, ci, stack, ledger, handoff; task-family mutations take --json${input.session.id ? ` --actor ${input.session.id}` : ""}. workit acts as this thread (CODEX_THREAD_ID${input.session.id ? `=${input.session.id}` : ""}) unless WORKIT_SESSION_ID is set. A verifier or reviewer records workit ledger verdict under a session the lead assigns (WORKIT_HOST=codex_cli WORKIT_SESSION_ID=<lead>-v<n>), never the author's. Merge and release need a workspace grant (workit grant show); a question answer is not host permission.</workit-codex-mutations>`
+  addendum: (input) => `<workit-codex-mutations>Codex MCP is read-only: unattested callers cannot mutate. Run workit verbs with the workit CLI on the shell (node_modules/.bin/workit, or npx -y @brainervirus/workit-cli): check, git branch|commit|push, pr, ci, stack, ledger, handoff; task-family mutations take --json${input.session.id ? ` --actor ${input.session.id}` : ""}. workit acts as this thread (CODEX_THREAD_ID${input.session.id ? `=${input.session.id}` : ""}) unless WORKIT_SESSION_ID is set. A verifier or reviewer records workit ledger verdict under its own session, never the author's: a workit-verifier or workit-reviewer agent uses the --session its SubagentStart context names; any other uses one the lead assigns (WORKIT_HOST=codex_cli WORKIT_SESSION_ID=<lead>-v<n>). Merge and release need a workspace grant (workit grant show); a question answer is not host permission.</workit-codex-mutations>`
 };
 
 // packages/workit-core/src/hooks/hosts/cursor.ts
-import path20 from "node:path";
-var undocumented2 = { support: "undocumented", native: null };
+import path21 from "node:path";
+var undocumented = { support: "undocumented", native: null };
 var none = { support: "none", native: null };
 var CURSOR_DESCRIPTOR = {
   host: "cursor",
@@ -18981,26 +19384,28 @@ var CURSOR_DESCRIPTOR = {
     "shell.pre": { support: "native", native: "beforeShellExecution" },
     "tool.pre": { support: "native", native: "preToolUse" },
     "write.pre": { support: "partial", native: "preToolUse" },
-    "shell.post": undocumented2,
+    "shell.post": undocumented,
     "subagent.start": { support: "native", native: "subagentStart" },
     "subagent.stop": { support: "partial", native: "subagentStop" },
-    "prompt.submit": undocumented2,
+    "prompt.submit": undocumented,
     "compact.pre": { support: "partial", native: "preCompact" },
-    stop: undocumented2
+    stop: none
   },
   shellPolicy: { deny: "native", channel: "exit2+json", failClosed: true },
   context: {
     sessionStart: "native",
     perTurn: "none",
     afterCompact: "partial",
-    task: "single-active"
+    task: "single-active",
+    turnResend: "every-turn"
   },
   subagents: {
     identity: "native",
     parentBinding: "native",
     blockStart: "native",
     worktreeIsolation: "undocumented",
-    maxConcurrency: "undocumented"
+    maxConcurrency: "undocumented",
+    agentPrefix: "workit-"
   },
   provenance: {
     sessionId: "native",
@@ -19125,7 +19530,7 @@ var protocolEvent2 = (input) => {
       return isWriteTool(input.tool_name) ? {
         kind: "write.pre",
         tool: input.tool_name ?? "",
-        paths: writePaths(input.tool_input),
+        paths: writeTargets(input.tool_input),
         toolUseId: null
       } : { kind: "tool.pre", tool: input.tool_name ?? "", toolUseId: null };
     case "subagentStart":
@@ -19147,7 +19552,7 @@ var protocolEvent2 = (input) => {
       return { kind: "compact.pre", trigger: "auto" };
   }
 };
-var within = (root, dir) => dir === root || dir.startsWith(root.endsWith(path20.sep) ? root : `${root}${path20.sep}`);
+var within = (root, dir) => dir === root || dir.startsWith(root.endsWith(path21.sep) ? root : `${root}${path21.sep}`);
 var hookCwd = (input) => {
   const cwd = existingDirectory(input.cwd);
   if (cwd && input.hook_event_name === "beforeShellExecution")