@brainervirus/workit-pi 8.4.1 → 8.5.2

package/dist/workit.js

@@ -18965,6 +18965,8 @@ var capabilitiesFor = (descriptor, observed = {}) => descriptor.capabilities.map
   };
 });
 // packages/workit-core/src/hooks/context.ts
+import { createHash as createHash11 } from "node:crypto";
+import fs15 from "node:fs";
 import path20 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);
@@ -19112,6 +19114,75 @@ var turnContextText = (input, descriptor) => {
     return null;
   }
 };
+var TURN_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+var digestOf = (text) => createHash11("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 path20.join(location.dir, "hooks", `turn-${digestOf(session).slice(0, 32)}.json`);
+  } catch {
+    return null;
+  }
+};
+var writeTurnDigest = (file, digest) => {
+  try {
+    fs15.mkdirSync(path20.dirname(file), { recursive: true });
+    fs15.writeFileSync(file, `${JSON.stringify({ digest })}
+`);
+  } catch {}
+};
+var clearTurnDigest = (file) => {
+  try {
+    fs15.rmSync(file, { force: true });
+  } catch {}
+};
+var pruneTurnDigests = (dir, now) => {
+  try {
+    for (const name of fs15.readdirSync(dir)) {
+      if (!name.startsWith("turn-"))
+        continue;
+      const file = path20.join(dir, name);
+      try {
+        if (now - fs15.statSync(file).mtimeMs > TURN_TTL_MS)
+          fs15.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(fs15.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(path20.dirname(file), Date.now());
+  const text = turnContextText(input, descriptor);
+  if (text)
+    writeTurnDigest(file, digestOf(text));
+  else
+    clearTurnDigest(file);
+};
 // packages/workit-core/src/hooks/policy.ts
 var shellPolicy = (cwd, command) => {
   const policy = shellBranchPolicyViolation(cwd, command);
@@ -19405,7 +19476,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 {
@@ -19419,8 +19490,8 @@ function writeGate(cwd, paths) {
 }
 // packages/workit-core/src/hooks/raw-git.ts
 import { spawnSync as spawnSync15 } from "node:child_process";
-import { createHash as createHash11 } from "node:crypto";
-import fs15 from "node:fs";
+import { createHash as createHash12 } from "node:crypto";
+import fs16 from "node:fs";
 import os4 from "node:os";
 import path22 from "node:path";
 var NONE3 = { kind: "none" };
@@ -19666,7 +19737,7 @@ var repoAt = (dir) => {
   return { location, dir, branch: resolveTaskKey(dir, location).branch };
 };
 var isWorkitWorkspace = (repo) => {
-  if (fs15.existsSync(repo.location.dir))
+  if (fs16.existsSync(repo.location.dir))
     return true;
   try {
     return resolveRuntimeWorkspaceVcs(repo.location.top ?? repo.dir) !== null;
@@ -19697,7 +19768,7 @@ var headSha2 = (repo) => {
   if (!git || git.reftable)
     return null;
   try {
-    const head = fs15.readFileSync(path22.join(git.gitDir, "HEAD"), "utf8").trim();
+    const head = fs16.readFileSync(path22.join(git.gitDir, "HEAD"), "utf8").trim();
     if (/^[0-9a-f]{40,64}$/.test(head))
       return head;
     const ref = /^ref: (refs\/.+)$/.exec(head)?.[1];
@@ -19705,9 +19776,9 @@ var headSha2 = (repo) => {
       return null;
     const common = path22.dirname(repo.location.dir);
     try {
-      return fs15.readFileSync(path22.join(common, ref), "utf8").trim() || null;
+      return fs16.readFileSync(path22.join(common, ref), "utf8").trim() || null;
     } catch {}
-    const packed = fs15.readFileSync(path22.join(common, "packed-refs"), "utf8");
+    const packed = fs16.readFileSync(path22.join(common, "packed-refs"), "utf8");
     return new RegExp(`^([0-9a-f]{40,64}) ${ref.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`, "m").exec(packed)?.[1] ?? null;
   } catch {
     return null;
@@ -19755,6 +19826,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) {
@@ -19784,8 +19860,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) => path22.join(repo.location.dir, "hooks", `commit-${createHash11("sha256").update(`${session}\x00${key}`).digest("hex").slice(0, 32)}.json`);
-var callKey = (toolUseId, command) => toolUseId ?? `cmd:${createHash11("sha256").update(command).digest("hex")}`;
+var markerFile = (repo, session, key) => path22.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))
@@ -19795,8 +19871,8 @@ function noteRawCommit(input, command, key) {
       if (action.kind !== "commit")
         continue;
       const file = markerFile(repo, input.session.id, key);
-      fs15.mkdirSync(path22.dirname(file), { recursive: true });
-      fs15.writeFileSync(file, `${JSON.stringify({ head: headSha2(repo), at })}
+      fs16.mkdirSync(path22.dirname(file), { recursive: true });
+      fs16.writeFileSync(file, `${JSON.stringify({ head: headSha2(repo), at })}
 `);
     }
   } catch {}
@@ -19819,11 +19895,11 @@ var headCommit = (dir) => {
 var settle2 = (input, repo, file) => {
   let marker;
   try {
-    marker = JSON.parse(fs15.readFileSync(file, "utf8"));
+    marker = JSON.parse(fs16.readFileSync(file, "utf8"));
   } catch {
     return;
   }
-  fs15.rmSync(file, { force: true });
+  fs16.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)
@@ -19872,14 +19948,294 @@ function settlePendingCommit(input) {
     if (!repo)
       return;
     const file = markerFile(repo, input.session.id, NEXT_COMMAND);
-    if (fs15.existsSync(file))
+    if (fs16.existsSync(file))
       settle2(input, repo, file);
   } catch {}
 }
+// packages/workit-core/src/hooks/skill-nudge.ts
+import { createHash as createHash13 } from "node:crypto";
+import fs17 from "node:fs";
+import path23 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 path23.join(location.dir, "hooks", `skills-${name}.json`);
+};
+var readMarker = (file) => {
+  try {
+    const value = JSON.parse(fs17.readFileSync(file, "utf8"));
+    return { nudged: value.nudged ?? [], loaded: value.loaded ?? [] };
+  } catch {
+    return { nudged: [], loaded: [] };
+  }
+};
+var writeMarker = (file, marker) => {
+  try {
+    fs17.mkdirSync(path23.dirname(file), { recursive: true });
+    fs17.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;
+};
+var shellNudge = (input, command) => withContextLine(rawGitPre(input, command), shipNudge(input, command));
 // packages/workit-core/src/hooks/hosts/fields.ts
 var isRecord4 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 var nonEmpty2 = (value) => typeof value === "string" && value.trim() !== "";
-var SHELLS2 = new Set(["sh", "bash", "zsh", "dash", "pwsh", "powershell", "cmd"]);
+var SHELLS3 = new Set(["sh", "bash", "zsh", "dash", "pwsh", "powershell", "cmd"]);
 var WRITE_TOOLS = new Set([
   "write",
   "edit",
@@ -19900,30 +20256,45 @@ var WRITE_TOOLS = new Set([
   "writefile"
 ]);
 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)];
 };
 // 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;
@@ -19939,18 +20310,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")
@@ -19966,7 +20341,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))
@@ -19977,7 +20352,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 {
@@ -19985,6 +20360,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":
@@ -20004,7 +20382,7 @@ var CONTEXT_EVENTS = new Set([
 
 // packages/workit-core/src/hooks/hosts/codex.ts
 var SHELL_TOOLS2 = new Set(["bash", "unified-exec"]);
-var SOURCES2 = new Set(["startup", "resume", "clear", "compact"]);
+var SOURCES2 = new Set(["startup", "resume", "clear", "compact", "fork"]);
 
 // packages/workit-core/src/hooks/hosts/cursor.ts
 var BLOCKING2 = new Set(["preToolUse", "beforeShellExecution", "subagentStart"]);
@@ -20034,16 +20412,18 @@ var PI_DESCRIPTOR = {
   shellPolicy: { deny: "native", channel: "block", failClosed: false },
   context: {
     sessionStart: "native",
-    perTurn: "native",
+    perTurn: "partial",
     afterCompact: "native",
-    task: "session-bound"
+    task: "session-bound",
+    turnResend: "per-session"
   },
   subagents: {
     identity: "none",
     parentBinding: "none",
     blockStart: "none",
     worktreeIsolation: "none",
-    maxConcurrency: "undocumented"
+    maxConcurrency: "undocumented",
+    agentPrefix: "workit-"
   },
   provenance: { sessionId: "native", agentIdOnTool: "none", postToolObserve: "native" },
   interaction: { questions: "native", writeBoundary: "native" },
@@ -20120,24 +20500,6 @@ var unfinishedTaskOffer2 = (ctx) => {
   }
 };
 
-// packages/workit-core/src/core/skill-manifests.ts
-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"
-};
-if (false) {}
-
 // packages/workit-pi/src/tools.ts
 var readOnlyActions = new Set(["list", "inspect", "preview", "explain", "export"]);
 var output = (result) => ({
@@ -20227,6 +20589,13 @@ var enforceToolPolicy = (event, ctx) => {
     const command = event.input?.command;
     return typeof command === "string" ? gate({ kind: "shell.pre", command, toolUseId: event.toolCallId ?? null }) : undefined;
   }
+  if (event.toolName === "read") {
+    const file = event.input?.path;
+    const skill = typeof file === "string" ? skillFileIn(file) : null;
+    if (skill)
+      recordSkillLoad(hookInput(ctx, { kind: "tool.pre", tool: "read", toolUseId: null }), skill, "read");
+    return;
+  }
   if (event.toolName !== "write" && event.toolName !== "edit")
     return;
   if (!ctx.isProjectTrusted())
@@ -20253,22 +20622,23 @@ var observeToolResult = (event, ctx) => {
       toolUseId: event.toolCallId
     });
     handleHook(post, { descriptor: PI_DESCRIPTOR, addendum: null });
-    const nudge = rawGitPre(post, command);
+    const nudge = process.env.WORKIT_PI_WORKER_SESSION ? rawGitPre(post, command) : shellNudge(post, command);
     return nudge.kind === "context" ? { content: [...event.content, { type: "text", text: nudge.text }] } : undefined;
   } catch {
     return;
   }
 };
+var skillPromptNudge = (prompt, ctx) => process.env.WORKIT_PI_WORKER_SESSION ? null : promptNudge(hookInput(ctx, { kind: "context.turn", prompt }), prompt);
 
 // packages/workit-pi/src/launches.ts
 import { mkdirSync as mkdirSync3, readFileSync as readFileSync6, readdirSync as readdirSync5, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
 import os5 from "node:os";
-import path23 from "node:path";
+import path24 from "node:path";
 var launchDir = (root) => {
   const location = resolveStore(root);
-  return location instanceof Error ? null : path23.join(location.dir, "pi-launches");
+  return location instanceof Error ? null : path24.join(location.dir, "pi-launches");
 };
-var fileFor = (dir, workerId) => path23.join(dir, `${workerId.replace(/[^A-Za-z0-9-]/g, "_")}.json`);
+var fileFor = (dir, workerId) => path24.join(dir, `${workerId.replace(/[^A-Za-z0-9-]/g, "_")}.json`);
 var recordLaunch = (root, attempt) => {
   const dir = launchDir(root);
   if (!dir)
@@ -20314,7 +20684,7 @@ var abandonedLaunches = (root) => {
   const found = [];
   for (const name of names) {
     try {
-      const attempt = JSON.parse(readFileSync6(path23.join(dir, name), "utf8"));
+      const attempt = JSON.parse(readFileSync6(path24.join(dir, name), "utf8"));
       if (typeof attempt.workerId === "string" && typeof attempt.session === "string") {
         if (!alive(attempt))
           found.push(attempt);
@@ -21142,14 +21512,18 @@ function extension(pi) {
     sessions.delete(ctx.sessionManager.getSessionId());
     reconcileLostWorkers(ctx);
   });
-  pi.on("before_agent_start", (_event, ctx) => {
+  pi.on("before_agent_start", (event, ctx) => {
+    const nudge = skillPromptNudge(event.prompt, ctx);
     const id = ctx.sessionManager.getSessionId();
     if (sessions.has(id))
-      return;
+      return nudge ? { message: { customType: "workit-skill", content: nudge, display: false } } : undefined;
     sessions.add(id);
     const offer = historyOfferSessions.has(id) ? null : unfinishedTaskOffer2(ctx);
     historyOfferSessions.add(id);
-    return { message: contextMessage(ctx, offer) };
+    const message = contextMessage(ctx, offer);
+    return { message: nudge ? { ...message, content: `${message.content}
+
+${nudge}` } : message };
   });
   pi.on("session_before_compact", () => {
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-pi",
-  "version": "8.4.1",
+  "version": "8.5.2",
   "description": "Workit native extension for Pi — tools, method skills, and session continuity",
   "keywords": [
     "agentic-coding",

package/skills/workit-retro/SKILL.md

@@ -15,8 +15,8 @@ proposes and stops. Nothing changes until the user approves.
    `retro:` row in `workit ledger list --type decision`), else the last ~10
    sessions. State the window in one line.
 2. **Read through workit, cheapest first.** Every finding cites these:
-   - `workit ledger list --last 200`: rulings (ambiguities the agent had to
-     settle), failed or self verdicts, handoffs, check runs, CI reruns.
+   - `workit ledger list --last 200`: rulings, failed/self verdicts, handoffs,
+     check runs, CI reruns, `skill.loaded` rows (skipped skills: routing).
    - `workit pr status --pr <n>` for each recent PR: threads, failing checks.
    - `git log --oneline -50`, plus reverts and fixups after review.
    - `workit knowledge lint`: today's AGENTS.md and need-based files.