@brainervirus/workit-cursor 8.4.1 → 8.5.2

package/dist/cursor-session-start.js

@@ -17240,6 +17240,8 @@ var support = (descriptor, axis) => {
 });
 
 // packages/workit-core/src/hooks/context.ts
+import { createHash as createHash10 } from "node:crypto";
+import fs13 from "node:fs";
 import path16 from "node:path";
 function sessionCompactContext(store, session, context, selection = "session-bound") {
   const listed = store.listTaskIndex();
@@ -17368,9 +17370,71 @@ ${options.addendum}` : ""}
   } catch {
     return null;
   }
+}, TURN_TTL_MS, digestOf = (text) => createHash10("sha256").update(text).digest("hex"), 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;
+  }
+}, writeTurnDigest = (file, digest) => {
+  try {
+    fs13.mkdirSync(path16.dirname(file), { recursive: true });
+    fs13.writeFileSync(file, `${JSON.stringify({ digest })}
+`);
+  } catch {}
+}, clearTurnDigest = (file) => {
+  try {
+    fs13.rmSync(file, { force: true });
+  } catch {}
+}, 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 {}
+}, 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;
+}, 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);
 };
 var init_context = __esm(() => {
   init_methods();
+  init_paths();
   init_task_contract();
   init_task_evaluation();
   init_rev();
@@ -17378,6 +17442,7 @@ var init_context = __esm(() => {
   init_task_store();
   signals = new Map;
   cache = new Map;
+  TURN_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 });
 
 // packages/workit-core/src/core/commit-flavors.ts
@@ -17387,7 +17452,7 @@ var init_commit_flavors = () => {};
 var init_git = () => {};
 
 // packages/workit-core/src/core/branch.ts
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 function effectiveWorkspacePolicy(workspaceRoot, kind, profileName) {
   const selected = resolveRuntimeWorkspacePolicy(workspaceRoot, kind, profileName?.trim() || process.env.WORKFLOW_PROFILE?.trim() || undefined);
   const config = readConfig();
@@ -17453,7 +17518,7 @@ var withReleaseTracks = (workspaceRoot, policy) => {
   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 },
@@ -17642,7 +17707,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 {
@@ -17812,8 +17877,8 @@ var init_write_gate = __esm(() => {
 
 // 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";
 function rawInvocations(command, dialect = "posix", depth = 0) {
@@ -17938,8 +18003,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 {}
@@ -17961,7 +18026,7 @@ 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 {}
 }
@@ -18067,7 +18132,7 @@ var NONE3, SHELLS, PREFIXES3, SCRIPT_FLAG, CD, PUSHD, POPD, GIT_VALUE_OPTIONS, i
     return null;
   return { location, dir, branch: resolveTaskKey(dir, location).branch };
 }, 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;
@@ -18095,7 +18160,7 @@ var NONE3, SHELLS, PREFIXES3, SCRIPT_FLAG, CD, PUSHD, POPD, GIT_VALUE_OPTIONS, i
   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];
@@ -18103,9 +18168,9 @@ var NONE3, SHELLS, PREFIXES3, SCRIPT_FLAG, CD, PUSHD, POPD, GIT_VALUE_OPTIONS, i
       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;
@@ -18148,7 +18213,10 @@ var NONE3, SHELLS, PREFIXES3, SCRIPT_FLAG, CD, PUSHD, POPD, GIT_VALUE_OPTIONS, i
       out.push({ action, repo });
   }
   return out;
-}, mentionsRawTool = (command) => /\b(?:git|gh|glab)\b/i.test(command), dialectOf = (input) => (input.event.kind === "shell.pre" || input.event.kind === "shell.post" ? input.event.dialect : undefined) ?? "posix", deny = (reason) => ({ kind: "deny", reason, unblock: null }), NEXT_COMMAND = "next", MARKER_TTL_SECONDS = 3600, markerFile = (repo, session, key) => path18.join(repo.location.dir, "hooks", `commit-${createHash11("sha256").update(`${session}\x00${key}`).digest("hex").slice(0, 32)}.json`), callKey = (toolUseId, command) => toolUseId ?? `cmd:${createHash11("sha256").update(command).digest("hex")}`, headCommit = (dir) => {
+}, inWorkitWorkspace = (dir) => {
+  const repo = repoAt(dir);
+  return repo !== null && isWorkitWorkspace(repo);
+}, rawDelivery = (cwd, command, dialect) => mentionsRawTool(command) && actionsIn(cwd, command, dialect).some(({ action }) => action.kind !== "commit" && action.kind !== "pr-read"), mentionsRawTool = (command) => /\b(?:git|gh|glab)\b/i.test(command), dialectOf = (input) => (input.event.kind === "shell.pre" || input.event.kind === "shell.post" ? input.event.dialect : undefined) ?? "posix", deny = (reason) => ({ kind: "deny", reason, unblock: null }), NEXT_COMMAND = "next", MARKER_TTL_SECONDS = 3600, markerFile = (repo, session, key) => path18.join(repo.location.dir, "hooks", `commit-${createHash12("sha256").update(`${session}\x00${key}`).digest("hex").slice(0, 32)}.json`), callKey = (toolUseId, command) => toolUseId ?? `cmd:${createHash12("sha256").update(command).digest("hex")}`, headCommit = (dir) => {
   const run = spawnSync11("git", [
     "log",
     "-1",
@@ -18165,11 +18233,11 @@ var NONE3, SHELLS, PREFIXES3, SCRIPT_FLAG, CD, PUSHD, POPD, GIT_VALUE_OPTIONS, i
 }, 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)
@@ -18253,18 +18321,291 @@ var init_raw_git = __esm(() => {
   };
 });
 
+// packages/workit-core/src/core/skill-manifests.ts
+var WORKIT_METHOD_SKILLS, WORKIT_SKILL_ALIASES, 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`;
+  }
+};
+var init_skill_manifests = __esm(() => {
+  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"
+  ];
+  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"
+  };
+  if (false) {}
+});
+
+// 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";
+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 {}
+}
+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;
+  }
+}
+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 USER_INVOKED, SKILL_HOST, PROMPT_INTENTS, 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;
+}, 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;
+}, 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`);
+}, readMarker = (file) => {
+  try {
+    const value = JSON.parse(fs15.readFileSync(file, "utf8"));
+    return { nudged: value.nudged ?? [], loaded: value.loaded ?? [] };
+  } catch {
+    return { nudged: [], loaded: [] };
+  }
+}, writeMarker = (file, marker) => {
+  try {
+    fs15.mkdirSync(path19.dirname(file), { recursive: true });
+    fs15.writeFileSync(file, JSON.stringify(marker));
+  } catch {}
+}, 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;
+}, SKILL_FILE, skillFileIn = (file) => SKILL_FILE.exec(file)?.[1] ?? null, READERS, 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;
+}, 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;
+}, 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.`, 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, WORKIT_DELIVERY, SHELLS2, LAUNCHERS, 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);
+}), isDeliveryCommand = (cwd, command, dialect = "posix") => rawDelivery(cwd, command, dialect) || runsWorkitDelivery(command, dialect) && inWorkitWorkspace(cwd), 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;
+};
+var init_skill_nudge = __esm(() => {
+  init_skill_manifests();
+  init_ledger();
+  init_paths();
+  init_raw_git();
+  USER_INVOKED = new Set(["workit-retro", "workit-architecture"]);
+  SKILL_HOST = {
+    claude_code: "claude-code",
+    opencode: "opencode",
+    codex_cli: "codex",
+    codex_desktop: "codex",
+    cursor: "cursor",
+    pi: "pi"
+  };
+  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
+    ]
+  ];
+  SKILL_FILE = /(?:^|[\\/])(workit-[a-z-]+)[\\/]SKILL\.md$/;
+  READERS = new Set([
+    "cat",
+    "sed",
+    "head",
+    "tail",
+    "less",
+    "more",
+    "bat",
+    "nl",
+    "get-content",
+    "gc",
+    "type"
+  ]);
+  WORKIT_DELIVERY = /^(?:pr (?:create|merge)|ci wait|git push)\b/;
+  SHELLS2 = new Set(["sh", "bash", "zsh", "dash", "ksh"]);
+  LAUNCHERS = new Set([
+    "npx",
+    "bunx",
+    "pnpx",
+    "-y",
+    "--yes",
+    "pnpm",
+    "dlx",
+    "exec",
+    "env",
+    "sudo",
+    "command"
+  ]);
+});
+
 // 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), nonEmpty2 = (value) => typeof value === "string" && value.trim() !== "", optionalText = (value) => typeof value === "string" ? value : null, 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;
   } catch {
     return null;
   }
-}, SHELLS2, SCRIPT_FLAG2, quoteArg = (arg) => /^[\w@%+=:,./-]+$/.test(arg) ? arg : JSON.stringify(arg), commandText = (value) => {
+}, SHELLS3, SCRIPT_FLAG2, quoteArg = (arg) => /^[\w@%+=:,./-]+$/.test(arg) ? arg : JSON.stringify(arg), commandText = (value) => {
   if (nonEmpty2(value))
     return value;
   if (!Array.isArray(value) || value.length === 0)
@@ -18273,7 +18614,7 @@ var isRecord4 = (value) => value !== null && typeof value === "object" && !Array
   if (!argv.every((arg) => typeof arg === "string"))
     return null;
   const shell = argv[0].split(/[\\/]/).at(-1)?.replace(/\.exe$/i, "").toLowerCase() ?? "";
-  if (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;
@@ -18282,18 +18623,21 @@ var isRecord4 = (value) => value !== null && typeof value === "object" && !Array
     }
   const joined = argv.map(quoteArg).join(" ");
   return nonEmpty2(joined) ? joined : null;
-}, WRITE_TOOLS, isWriteTool = (name) => typeof name === "string" && WRITE_TOOLS.has(name.toLowerCase().replace(/[_-]/g, "")), PATH_KEYS, writePaths = (input) => {
+}, WRITE_TOOLS, isWriteTool = (name) => typeof name === "string" && WRITE_TOOLS.has(name.toLowerCase().replace(/[_-]/g, "")), PATH_KEYS, PATCH_HEADER, 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)];
+}, writeTargets = (input) => {
+  const paths = writePaths(input);
+  return paths.length > 0 ? paths : null;
 };
 var init_fields = __esm(() => {
-  SHELLS2 = new Set(["sh", "bash", "zsh", "dash", "pwsh", "powershell", "cmd"]);
+  SHELLS3 = new Set(["sh", "bash", "zsh", "dash", "pwsh", "powershell", "cmd"]);
   SCRIPT_FLAG2 = /^(?:-\w*c|-command|\/c)$/i;
   WRITE_TOOLS = new Set([
     "write",
@@ -18315,6 +18659,7 @@ var init_fields = __esm(() => {
     "writefile"
   ]);
   PATH_KEYS = ["file_path", "filePath", "notebook_path", "path", "target_file", "file"];
+  PATCH_HEADER = /^[ \t]*\*\*\* (?:(?:Add|Update|Delete) File|Move to): (.+)$/gm;
 });
 
 // packages/workit-core/src/hooks/handle.ts
@@ -18332,18 +18677,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")
@@ -18359,7 +18708,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))
@@ -18370,7 +18719,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 {
@@ -18378,19 +18727,31 @@ 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":
       return NONE4;
   }
 }
-var usable2 = (value) => value === "native" || value === "partial", NONE4, offered, CLAUDE_WORKTREE_IMPLEMENTER = "workit:implementer", CLAUDE_JUDGES, subagentSession = (session, agentId) => [session, agentId].filter((part) => Boolean(part)).join(":").replace(/[^A-Za-z0-9_.:@/+-]/g, "-").slice(0, 128), subagentStartText = (host, session, descriptor, event) => {
-  if (host === "claude_code" && event.agentType === CLAUDE_WORKTREE_IMPLEMENTER)
-    return `Workit observed ${descriptor.label} subagent ${event.agentId} (${event.agentType}) working in its own git worktree: it may edit and commit there, within its brief's scope. Before the first commit, switch to a policy-compliant branch with \`workit git branch <branch> --base <base>\` (e.g. feature/<slug>); branch policy hooks still deny protected or non-compliant branches. Never record a verdict on your own work. Never push, open a PR, or merge unless the brief asks for it.`;
-  const readOnly = `Workit observed ${descriptor.label} subagent ${event.agentId} (${event.agentType}) as read-only/agent-guided.`;
-  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 usable2 = (value) => value === "native" || value === "partial", NONE4, resendsOnChange = (descriptor) => descriptor.context.turnResend === "on-change" && usable2(descriptor.context.perTurn), offered, ROLES, 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;
+}, subagentSession = (session, agentId) => [session, agentId].filter((part) => Boolean(part)).join(":").replace(/[^A-Za-z0-9_.:@/+-]/g, "-").slice(0, 128), 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.`;
 }, 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;
@@ -18423,10 +18784,15 @@ var init_handle = __esm(() => {
   init_context();
   init_policy();
   init_raw_git();
+  init_skill_nudge();
   init_write_gate();
   NONE4 = { kind: "none" };
   offered = new Set;
-  CLAUDE_JUDGES = new Set(["workit:verifier", "workit:reviewer"]);
+  ROLES = {
+    implementer: "implementer",
+    verifier: "judge",
+    reviewer: "judge"
+  };
 });
 
 // packages/workit-core/src/hooks/hosts/claude-code.ts
@@ -18436,7 +18802,7 @@ var CLAUDE_CODE_DESCRIPTOR, EVENTS, SOURCES, SHELL_TOOLS, dialectOf2 = (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" };
@@ -18446,10 +18812,20 @@ var CLAUDE_CODE_DESCRIPTOR, EVENTS, SOURCES, SHELL_TOOLS, dialectOf2 = (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);
@@ -18547,24 +18923,26 @@ var init_claude_code = __esm(() => {
       "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" },
@@ -18582,13 +18960,13 @@ var init_claude_code = __esm(() => {
       },
       {
         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",
@@ -18684,7 +19062,7 @@ var init_claude_code = __esm(() => {
 function detectCodexSurface(env) {
   return env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE === "Codex Desktop" || Boolean(env.CODEX_ELECTRON_RESOURCES_PATH) ? "codex_desktop" : "codex_cli";
 }
-var undocumented, CODEX_DESCRIPTOR, EVENTS2, SHELL_TOOLS2, isShellTool = (name) => SHELL_TOOLS2.has(String(name).toLowerCase()), SOURCES2, parseCodexHookInput = (value) => {
+var CODEX_DESCRIPTOR, EVENTS2, SHELL_TOOLS2, isShellTool = (name) => SHELL_TOOLS2.has(String(name).toLowerCase()), SOURCES2, parseCodexHookInput = (value) => {
   if (!isRecord4(value) || !Object.hasOwn(EVENTS2, String(value.hook_event_name)))
     return { ok: false, error: "hook_event_name is required" };
   const event = value.hook_event_name;
@@ -18710,6 +19088,7 @@ var undocumented, CODEX_DESCRIPTOR, EVENTS2, SHELL_TOOLS2, isShellTool = (name)
       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 } : {},
@@ -18728,13 +19107,20 @@ var undocumented, CODEX_DESCRIPTOR, EVENTS2, SHELL_TOOLS2, isShellTool = (name)
   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;
@@ -18781,39 +19167,40 @@ var undocumented, CODEX_DESCRIPTOR, EVENTS2, SHELL_TOOLS2, isShellTool = (name)
 }, codexAdapter;
 var init_codex = __esm(() => {
   init_fields();
-  undocumented = { support: "undocumented", native: null };
   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" },
@@ -18880,13 +19267,14 @@ var init_codex = __esm(() => {
   };
   EVENTS2 = {
     SessionStart: "session.start",
+    UserPromptSubmit: "context.turn",
     PreToolUse: "shell.pre",
     PostToolUse: "shell.post",
     SubagentStart: "subagent.start",
     SubagentStop: "subagent.stop"
   };
   SHELL_TOOLS2 = new Set(["bash", "unified-exec"]);
-  SOURCES2 = new Set(["startup", "resume", "clear", "compact"]);
+  SOURCES2 = new Set(["startup", "resume", "clear", "compact", "fork"]);
   codexAdapter = {
     descriptor: CODEX_DESCRIPTOR,
     parse(raw, env) {
@@ -18916,13 +19304,13 @@ var init_codex = __esm(() => {
       };
     },
     render: render2,
-    addendum: (input) => `<workit-codex-mutations>Codex MCP is read-only: unattested callers cannot mutate. Run workit verbs with the workit CLI on the shell (node_modules/.bin/workit, or npx -y @brainervirus/workit-cli): check, git branch|commit|push, pr, ci, stack, ledger, handoff; task-family mutations take --json${input.session.id ? ` --actor ${input.session.id}` : ""}. 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, none, CURSOR_DESCRIPTOR, EVENTS3, parseCursorHookInput = (value) => {
+import path21 from "node:path";
+var undocumented, none, CURSOR_DESCRIPTOR, EVENTS3, parseCursorHookInput = (value) => {
   if (!isRecord4(value) || !Object.hasOwn(EVENTS3, String(value.hook_event_name)))
     return { ok: false, error: "hook_event_name is required" };
   const roots = value.workspace_roots;
@@ -18969,7 +19357,7 @@ var undocumented2, none, CURSOR_DESCRIPTOR, EVENTS3, parseCursorHookInput = (val
       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":
@@ -18990,7 +19378,7 @@ var undocumented2, none, CURSOR_DESCRIPTOR, EVENTS3, parseCursorHookInput = (val
     case "preCompact":
       return { kind: "compact.pre", trigger: "auto" };
   }
-}, within = (root, dir) => dir === root || dir.startsWith(root.endsWith(path20.sep) ? root : `${root}${path20.sep}`), hookCwd = (input) => {
+}, within = (root, dir) => dir === root || dir.startsWith(root.endsWith(path21.sep) ? root : `${root}${path21.sep}`), hookCwd = (input) => {
   const cwd = existingDirectory(input.cwd);
   if (cwd && input.hook_event_name === "beforeShellExecution")
     return cwd;
@@ -19021,7 +19409,7 @@ var undocumented2, none, CURSOR_DESCRIPTOR, EVENTS3, parseCursorHookInput = (val
 }, cursorAdapter;
 var init_cursor = __esm(() => {
   init_fields();
-  undocumented2 = { support: "undocumented", native: null };
+  undocumented = { support: "undocumented", native: null };
   none = { support: "none", native: null };
   CURSOR_DESCRIPTOR = {
     host: "cursor",
@@ -19035,26 +19423,28 @@ var init_cursor = __esm(() => {
       "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",
@@ -19211,6 +19601,7 @@ var init_hooks = __esm(async () => {
   init_policy();
   init_write_gate();
   init_raw_git();
+  init_skill_nudge();
   init_fields();
   init_handle();
   init_claude_code();