@brainervirus/workit-opencode 8.4.1 → 8.5.2

package/assets/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.

package/dist/plugin.js

@@ -19157,6 +19157,7 @@ function entryCompactContext(store, entry, session, context) {
     cache.delete(cache.keys().next().value);
   return compact.data;
 }
+var TURN_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 // packages/workit-core/src/hooks/policy.ts
 var shellPolicy = (cwd, command) => {
   const policy = shellBranchPolicyViolation(cwd, command);
@@ -19450,7 +19451,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 {
@@ -19800,6 +19801,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) {
@@ -19908,8 +19914,274 @@ function rawGitPost(input, command, key) {
         settle2(input, repo, markerFile(repo, input.session.id, key));
   } catch {}
 }
+// packages/workit-core/src/hooks/skill-nudge.ts
+import { createHash as createHash12 } from "node:crypto";
+import fs16 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`;
+  }
+};
+var SKILL_REFERENCE = /\((workit-[a-z-]+)\)/g;
+var renderSkillText = (text, host) => text.replace(SKILL_REFERENCE, (match, name) => WORKIT_METHOD_SKILLS.includes(name) ? `(${skillLoadWording(host, name)})` : match);
+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 = createHash12("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(fs16.readFileSync(file, "utf8"));
+    return { nudged: value.nudged ?? [], loaded: value.loaded ?? [] };
+  } catch {
+    return { nudged: [], loaded: [] };
+  }
+};
+var writeMarker = (file, marker) => {
+  try {
+    fs16.mkdirSync(path23.dirname(file), { recursive: true });
+    fs16.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 READERS = new Set([
+  "cat",
+  "sed",
+  "head",
+  "tail",
+  "less",
+  "more",
+  "bat",
+  "nl",
+  "get-content",
+  "gc",
+  "type"
+]);
+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 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",
@@ -19931,7 +20203,6 @@ var WRITE_TOOLS = new Set([
 ]);
 // packages/workit-core/src/hooks/handle.ts
 var offered = new Set;
-var CLAUDE_JUDGES = new Set(["workit:verifier", "workit:reviewer"]);
 // packages/workit-core/src/hooks/hosts/claude-code.ts
 var SOURCES = new Set(["startup", "resume", "clear", "compact", "fork"]);
 var SHELL_TOOLS = new Set(["Bash", "PowerShell"]);
@@ -19945,7 +20216,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"]);
@@ -19970,21 +20241,23 @@ var OPENCODE_DESCRIPTOR = {
     "subagent.stop": { support: "native", native: 'tool.hook("execute.after") subagent' },
     "prompt.submit": { support: "undocumented", native: null },
     "compact.pre": { support: "native", native: 'session.hook("compaction")' },
-    stop: { support: "partial", native: "session.idle" }
+    stop: { support: "none", native: null }
   },
   shellPolicy: { deny: "native", channel: "effect", failClosed: false },
   context: {
     sessionStart: "none",
     perTurn: "native",
     afterCompact: "native",
-    task: "session-bound"
+    task: "session-bound",
+    turnResend: "every-turn"
   },
   subagents: {
     identity: "native",
     parentBinding: "native",
     blockStart: "native",
     worktreeIsolation: "undocumented",
-    maxConcurrency: "undocumented"
+    maxConcurrency: "undocumented",
+    agentPrefix: "workit-"
   },
   provenance: { sessionId: "native", agentIdOnTool: "native", postToolObserve: "native" },
   interaction: { questions: "native", writeBoundary: "partial" },
@@ -20019,11 +20292,11 @@ var OPENCODE_DESCRIPTOR = {
   ]
 };
 // packages/workit-opencode/src/shared/init-apply.ts
-import path27 from "node:path";
+import path28 from "node:path";
 
 // packages/workit-core/src/core/gitignore.ts
 import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
-import path23 from "node:path";
+import path24 from "node:path";
 var GITIGNORE_ENTRIES = [
   "# workit: SDD working state (never commit)",
   "docs/*/sdd/",
@@ -20043,7 +20316,7 @@ var GITIGNORE_ENTRIES = [
 var ensureProjectGitignore = (workspaceRoot, confirmed) => {
   if (!confirmed)
     return { ok: false, error: "confirmed: true required" };
-  const file = path23.join(workspaceRoot, ".gitignore");
+  const file = path24.join(workspaceRoot, ".gitignore");
   const existing = existsSync8(file) ? readFileSync6(file, "utf8") : "";
   const existingLines = new Set(existing.split(`
 `).map((l) => l.trim()).filter(Boolean));
@@ -20071,25 +20344,25 @@ var ensureProjectGitignore = (workspaceRoot, confirmed) => {
 
 // packages/workit-core/src/core/hygiene.ts
 import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
-import path24 from "node:path";
+import path25 from "node:path";
 var repoRoot3 = assetRoot();
-var templatesDir = () => path24.join(repoRoot3, "templates", "hygiene");
+var templatesDir = () => path25.join(repoRoot3, "templates", "hygiene");
 var packageJson = (root) => {
-  if (!existsSync9(path24.join(root, "package.json")))
+  if (!existsSync9(path25.join(root, "package.json")))
     return null;
   try {
-    return JSON.parse(readFileSync7(path24.join(root, "package.json"), "utf8"));
+    return JSON.parse(readFileSync7(path25.join(root, "package.json"), "utf8"));
   } catch {
     return null;
   }
 };
 var isOpenSource = (root) => {
-  if (existsSync9(path24.join(root, "LICENSE")))
+  if (existsSync9(path25.join(root, "LICENSE")))
     return true;
   const pkg = packageJson(root);
   if (pkg && !pkg.private)
     return true;
-  return path24.basename(root) === "workflow-toolkit";
+  return path25.basename(root) === "workflow-toolkit";
 };
 var licenseHolder = (root) => {
   const pkg = packageJson(root);
@@ -20112,13 +20385,13 @@ var planHygieneFiles = (root, opts = {}) => {
     files.push("LICENSE", "CONTRIBUTING.md");
   const planned = [];
   for (const file of files) {
-    if (existsSync9(path24.join(root, file)))
+    if (existsSync9(path25.join(root, file)))
       continue;
-    const tpl = path24.join(templatesDir(), file);
+    const tpl = path25.join(templatesDir(), file);
     if (!existsSync9(tpl))
       continue;
-    const content = readFileSync7(tpl, "utf8").replace(/<PROJECT>/g, path24.basename(root)).replace(/<YEAR>/g, String(new Date().getFullYear())).replace(/<HOLDER>\s*/g, licenseHolder(root));
-    planned.push({ path: path24.join(root, file), content });
+    const content = readFileSync7(tpl, "utf8").replace(/<PROJECT>/g, path25.basename(root)).replace(/<YEAR>/g, String(new Date().getFullYear())).replace(/<HOLDER>\s*/g, licenseHolder(root));
+    planned.push({ path: path25.join(root, file), content });
   }
   return planned;
 };
@@ -20128,19 +20401,19 @@ var ensureHygieneFiles = (root, opts) => {
   const created = [];
   for (const planned of planHygieneFiles(root, opts)) {
     writeFileSync5(planned.path, planned.content, "utf8");
-    created.push(path24.basename(planned.path));
+    created.push(path25.basename(planned.path));
   }
   return { ok: true, created };
 };
 
 // packages/workit-core/src/core/init.ts
-import fs16 from "node:fs";
-import path26 from "node:path";
+import fs17 from "node:fs";
+import path27 from "node:path";
 import { spawnSync as spawnSync16 } from "node:child_process";
 
 // packages/workit-core/src/core/workspace-branch-policy.ts
 import { mkdirSync as mkdirSync4, readFileSync as readFileSync8, renameSync as renameSync3, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import path25 from "node:path";
+import path26 from "node:path";
 import { isDeepStrictEqual } from "node:util";
 var readFileSafe = (p) => {
   try {
@@ -20151,7 +20424,7 @@ var readFileSafe = (p) => {
 };
 function applyWorkspaceBranchPolicy(opts) {
   const { workspace_root, env = process.env } = opts;
-  const dir = path25.join(env.WORKFLOW_TOOLKIT_CONFIG ?? configDir());
+  const dir = path26.join(env.WORKFLOW_TOOLKIT_CONFIG ?? configDir());
   const {
     status,
     path: wsPath,
@@ -20163,7 +20436,7 @@ function applyWorkspaceBranchPolicy(opts) {
   if (status === "malformed" || status === "invalid")
     return { ok: false, error: workspacesError ?? `invalid workspaces.json: ${wsPath}` };
   const detection = detectBranchPolicy(workspace_root);
-  const name = String(env.WORKFLOW_BP_NAME ?? path25.basename(workspace_root));
+  const name = String(env.WORKFLOW_BP_NAME ?? path26.basename(workspace_root));
   const integration = env.WORKFLOW_BP_INTEGRATION ?? detection.integration;
   const policy = {
     preset: detection.preset,
@@ -20212,7 +20485,7 @@ function applyWorkspaceBranchPolicy(opts) {
       ok: false,
       error: `workspaces.json changed while applying the branch policy: ${wsPath}`
     };
-  mkdirSync4(path25.dirname(wsPath), { recursive: true });
+  mkdirSync4(path26.dirname(wsPath), { recursive: true });
   const tmp = `${wsPath}.${process.pid}.tmp`;
   try {
     writeFileSync6(tmp, JSON.stringify({ ...document, workspaces: next }, null, 2) + `
@@ -20247,7 +20520,7 @@ function applyWorkspaceBranchPolicy(opts) {
 var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE";
 var readJson = (p) => {
   try {
-    const parsed = JSON.parse(fs16.readFileSync(p, "utf8"));
+    const parsed = JSON.parse(fs17.readFileSync(p, "utf8"));
     return isConfigObject(parsed) ? parsed : null;
   } catch {
     return null;
@@ -20277,7 +20550,7 @@ var youtrackJsonContent = (dir) => {
   const meetingIssue = process.env.WORKFLOW_YT_MEETING_ISSUE;
   return {
     baseUrl: process.env.WORKFLOW_YT_BASE_URL ?? "https://youtrack.example.com",
-    tokenFile: process.env.WORKFLOW_YT_TOKEN_FILE ?? path26.join(dir, "youtrack.token"),
+    tokenFile: process.env.WORKFLOW_YT_TOKEN_FILE ?? path27.join(dir, "youtrack.token"),
     ...meetingIssue ? {
       meetingIssue,
       meetingIssues: { general: { issue: meetingIssue, label: "General meetings" } }
@@ -20307,19 +20580,19 @@ var vcsJsonContent = () => {
 };
 function initApplyData(action, env = process.env) {
   const dir = String(env.WORKFLOW_TOOLKIT_CONFIG ?? configDir());
-  fs16.mkdirSync(dir, { recursive: true });
+  fs17.mkdirSync(dir, { recursive: true });
   switch (action) {
     case "youtrack_json": {
-      const out = path26.join(dir, "youtrack.json");
-      fs16.writeFileSync(out, JSON.stringify(youtrackJsonContent(dir), null, 2) + `
+      const out = path27.join(dir, "youtrack.json");
+      fs17.writeFileSync(out, JSON.stringify(youtrackJsonContent(dir), null, 2) + `
 `, "utf8");
       return { action, ok: true, path: out };
     }
     case "youtrack_token_placeholder": {
-      const p = path26.join(dir, "youtrack.token");
+      const p = path27.join(dir, "youtrack.token");
       const preserved = writeFileExclusive(p, TOKEN_PLACEHOLDER2 + `
 `, 384) === "preserved";
-      const abs = path26.resolve(p);
+      const abs = path27.resolve(p);
       return {
         action,
         ok: true,
@@ -20331,14 +20604,14 @@ function initApplyData(action, env = process.env) {
       };
     }
     case "youtrack_scaffold": {
-      const jsonOut = path26.join(dir, "youtrack.json");
-      const tokenOut = path26.join(dir, "youtrack.token");
-      fs16.writeFileSync(jsonOut, JSON.stringify(youtrackJsonContent(dir), null, 2) + `
+      const jsonOut = path27.join(dir, "youtrack.json");
+      const tokenOut = path27.join(dir, "youtrack.token");
+      fs17.writeFileSync(jsonOut, JSON.stringify(youtrackJsonContent(dir), null, 2) + `
 `, "utf8");
       const preserved = writeFileExclusive(tokenOut, TOKEN_PLACEHOLDER2 + `
 `, 384) === "preserved";
-      const configPath = path26.resolve(jsonOut);
-      const tokenPath = path26.resolve(tokenOut);
+      const configPath = path27.resolve(jsonOut);
+      const tokenPath = path27.resolve(tokenOut);
       const prev = process.env.WORKFLOW_YOUTRACK_CONFIG;
       process.env.WORKFLOW_YOUTRACK_CONFIG = configPath;
       let tokenCreate = {};
@@ -20390,10 +20663,10 @@ function initApplyData(action, env = process.env) {
       }
     }
     case "vcs_scaffold": {
-      const jsonOut = path26.join(dir, "vcs.json");
-      fs16.writeFileSync(jsonOut, JSON.stringify(vcsJsonContent(), null, 2) + `
+      const jsonOut = path27.join(dir, "vcs.json");
+      fs17.writeFileSync(jsonOut, JSON.stringify(vcsJsonContent(), null, 2) + `
 `, "utf8");
-      const configPath = path26.resolve(jsonOut);
+      const configPath = path27.resolve(jsonOut);
       const prev = process.env.WORKFLOW_VCS_CONFIG;
       process.env.WORKFLOW_VCS_CONFIG = configPath;
       try {
@@ -20512,7 +20785,7 @@ var executeInitApply = (args, directory, runtime) => {
       protectedNames: args.branch_policy_protected
     }, current);
     writeConfig(next);
-    return output(ok({ action: "config", path: path27.join(configDir(), "config.json"), ...next }));
+    return output(ok({ action: "config", path: path28.join(configDir(), "config.json"), ...next }));
   }
   const env = Object.fromEntries(Object.entries({
     WORKFLOW_YT_BASE_URL: args.base_url,
@@ -20529,14 +20802,14 @@ var executeInitApply = (args, directory, runtime) => {
 
 // packages/workit-opencode/src/shared/session.ts
 import { realpathSync as realpathSync7 } from "node:fs";
-import path28 from "node:path";
+import path29 from "node:path";
 var sameWorkspace = (expected, observed) => {
   if (typeof observed !== "string" || !observed)
     return false;
   try {
     return realpathSync7(expected) === realpathSync7(observed);
   } catch {
-    return path28.resolve(expected) === path28.resolve(observed);
+    return path29.resolve(expected) === path29.resolve(observed);
   }
 };
 
@@ -20608,7 +20881,7 @@ var workitFamilyOf = (toolName) => {
 
 // packages/workit-opencode/src/tools/context.ts
 import { realpathSync as realpathSync8 } from "node:fs";
-import path29 from "node:path";
+import path30 from "node:path";
 var createContextTool = () => ({
   description: "Read Git, pull request, YouTrack, issue, changelog, release, or affected-file context.",
   execute: async (args, context) => {
@@ -20618,7 +20891,7 @@ var createContextTool = () => ({
     let root;
     try {
       const cwd = parsed.data.cwd;
-      root = realpathSync8(cwd ? path29.resolve(context.directory, cwd) : context.directory);
+      root = realpathSync8(cwd ? path30.resolve(context.directory, cwd) : context.directory);
     } catch {
       return JSON.stringify(failure2("invalid_input", "context target directory cannot be resolved"), null, 2);
     }
@@ -21180,7 +21453,7 @@ var evaluateShellPermission = (root, event, workdirs = new Map) => {
 };
 
 // packages/workit-opencode/src/v2/shell.ts
-import path30 from "node:path";
+import path31 from "node:path";
 var commandOf = (input) => {
   if (input === null || typeof input !== "object")
     return null;
@@ -21189,7 +21462,7 @@ var commandOf = (input) => {
 };
 var hookInput = (root, sessionID, id, shell) => ({
   host: "opencode",
-  cwd: shell.workdir ? path30.resolve(root, shell.workdir) : root,
+  cwd: shell.workdir ? path31.resolve(root, shell.workdir) : root,
   session: { id: sessionID, agentId: null, agentType: null, parentId: null },
   permissionMode: null,
   transcriptPath: null,
@@ -21219,7 +21492,7 @@ var observeShellResult = (root, event) => {
       return;
     const input = hookInput(root, String(event.sessionID), String(event.id), shell);
     rawGitPost(input, shell.command, callKey(String(event.id), shell.command));
-    const nudge = rawGitPre(input, shell.command);
+    const nudge = shellNudge(input, shell.command);
     const result = event.result;
     if (nudge.kind !== "context" || !result)
       return;
@@ -21235,84 +21508,78 @@ ${nudge.text}` };
   } catch {}
 };
 
-// packages/workit-opencode/src/v2/registry.ts
-import { existsSync as existsSync11, readFileSync as readFileSync9 } from "node:fs";
-import path32 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"
+// packages/workit-opencode/src/v2/skills.ts
+var hookInput2 = (root, sessionID, subagent) => ({
+  host: "opencode",
+  cwd: root,
+  session: {
+    id: sessionID,
+    agentId: subagent ? sessionID : null,
+    agentType: null,
+    parentId: null
+  },
+  permissionMode: null,
+  transcriptPath: null,
+  event: { kind: "context.turn" }
+});
+var observeSkillLoad = (root, event) => {
+  const input = event.input;
+  if (typeof input?.name === "string")
+    recordSkillLoad(hookInput2(root, String(event.sessionID), false), input.name, "tool");
+};
+var newUserPrompt = (messages) => {
+  const last = messages.at(-1);
+  if (last?.role !== "user")
+    return null;
+  if (typeof last.content === "string")
+    return last.content;
+  if (!Array.isArray(last.content))
+    return null;
+  const text = last.content.filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text).join(`
+`);
+  return text || null;
 };
-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`;
-  }
+var injectSkillNudge = (root, session, messages, system) => {
+  try {
+    const nudge = promptNudge(hookInput2(root, session.id, session.parentID !== undefined), newUserPrompt(messages));
+    if (nudge)
+      system.push({ type: "text", text: nudge });
+  } catch {}
 };
-var SKILL_REFERENCE = /\((workit-[a-z-]+)\)/g;
-var renderSkillText = (text, host) => text.replace(SKILL_REFERENCE, (match, name) => WORKIT_METHOD_SKILLS.includes(name) ? `(${skillLoadWording(host, name)})` : match);
-if (false) {}
+
+// packages/workit-opencode/src/v2/registry.ts
+import { existsSync as existsSync11, readFileSync as readFileSync9 } from "node:fs";
+import path33 from "node:path";
 
 // packages/workit-opencode/src/shared/assets.ts
 import { existsSync as existsSync10, realpathSync as realpathSync9 } from "node:fs";
-import path31 from "node:path";
+import path32 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var moduleDir = () => {
   try {
-    return realpathSync9(path31.dirname(fileURLToPath2(import.meta.url)));
+    return realpathSync9(path32.dirname(fileURLToPath2(import.meta.url)));
   } catch {
-    return path31.dirname(fileURLToPath2(import.meta.url));
+    return path32.dirname(fileURLToPath2(import.meta.url));
   }
 };
 var packageRoot2 = () => {
   const dir = moduleDir();
   for (const candidate of [
-    path31.resolve(dir, ".."),
-    path31.resolve(dir, "..", ".."),
-    path31.resolve(dir, "..", "..", "..")
+    path32.resolve(dir, ".."),
+    path32.resolve(dir, "..", ".."),
+    path32.resolve(dir, "..", "..", "..")
   ]) {
-    if (existsSync10(path31.join(candidate, "package.json")))
+    if (existsSync10(path32.join(candidate, "package.json")))
       return candidate;
   }
-  return path31.resolve(dir, "..");
+  return path32.resolve(dir, "..");
 };
 var skillsRoot = () => {
   const root = packageRoot2();
-  const canonical = path31.resolve(root, "..", "workit-core", "skills");
-  if (existsSync10(path31.join(root, "src")) && existsSync10(canonical))
+  const canonical = path32.resolve(root, "..", "workit-core", "skills");
+  if (existsSync10(path32.join(root, "src")) && existsSync10(canonical))
     return canonical;
-  return path31.join(root, "assets", "skills");
+  return path32.join(root, "assets", "skills");
 };
 
 // packages/workit-opencode/src/v2/registry.ts
@@ -21339,11 +21606,11 @@ var registerSkills = async (ctx) => {
   if (!existsSync11(skillsDir))
     return new Set;
   const listed = await ctx.skill.list().catch(() => ({ data: [] }));
-  const own = (skill) => typeof skill.path === "string" && path32.resolve(skill.path).startsWith(skillsDir + path32.sep);
+  const own = (skill) => typeof skill.path === "string" && path33.resolve(skill.path).startsWith(skillsDir + path33.sep);
   const userSkills = new Set((listed?.data ?? []).filter((skill) => !own(skill)).map((skill) => skill.id));
   const packaged = new Map;
   for (const id of WORKIT_METHOD_SKILLS) {
-    const file = path32.join(skillsDir, id, "SKILL.md");
+    const file = path33.join(skillsDir, id, "SKILL.md");
     if (!userSkills.has(id) && existsSync11(file))
       packaged.set(id, file);
   }
@@ -21391,22 +21658,22 @@ var registerCommands = async (ctx, registeredSkills) => {
 
 // packages/workit-opencode/src/stale-sources.ts
 import { existsSync as existsSync12, readdirSync as readdirSync5 } from "node:fs";
-import path33 from "node:path";
+import path34 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var typescriptFiles = (directory) => {
   if (!existsSync12(directory))
     return [];
   return readdirSync5(directory, { withFileTypes: true }).flatMap((entry) => {
-    const file = path33.join(directory, entry.name);
+    const file = path34.join(directory, entry.name);
     return entry.isDirectory() ? typescriptFiles(file) : entry.isFile() && file.endsWith(".ts") ? [file] : [];
   });
 };
 var pluginSourceFiles = [
   ...new Set([
     fileURLToPath3(import.meta.url),
-    ...typescriptFiles(path33.join(packageRoot2(), "src")),
-    path33.join(packageRoot2(), "..", "workit-core", "src", "core.ts"),
-    ...typescriptFiles(path33.join(packageRoot2(), "..", "workit-core", "src", "core"))
+    ...typescriptFiles(path34.join(packageRoot2(), "src")),
+    path34.join(packageRoot2(), "..", "workit-core", "src", "core.ts"),
+    ...typescriptFiles(path34.join(packageRoot2(), "..", "workit-core", "src", "core"))
   ])
 ].filter((file) => existsSync12(file)).toSorted();
 
@@ -21511,6 +21778,8 @@ var setup = async (ctx) => {
   await ctx.tool.hook("execute.before", async (event) => {
     if (event.tool === "shell")
       return observeShellBefore(root, event, shellWorkdirs);
+    if (event.tool === "skill")
+      return observeSkillLoad(root, event);
     if (event.tool !== "subagent")
       return;
     await lifecycle.executeBefore({
@@ -21540,6 +21809,8 @@ var setup = async (ctx) => {
     const session = await sessionFacts(ctx, String(event.sessionID));
     injectAgentContext(root, session, lifecycle.directChildren, event.system);
     injectHistoryOffer(root, session, historyOfferSessions, event.system);
+    if (session)
+      injectSkillNudge(root, session, event.messages, event.system);
     if (!staleSourcesWarned) {
       const changed = changedSourcesSinceLoad(sourceMarker);
       if (changed.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-opencode",
-  "version": "8.4.1",
+  "version": "8.5.2",
   "private": false,
   "description": "Workit OpenCode plugin — native tools, adaptive policy, and sixteen method skills",
   "keywords": [
@@ -39,7 +39,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@brainervirus/workit-core": "^8.4.1"
+    "@brainervirus/workit-core": "^8.5.2"
   },
   "devDependencies": {
     "@opencode/plugin": "2.0.18"