@brainervirus/workit-opencode 8.7.0 → 8.8.0

package/dist/plugin.js

@@ -19463,12 +19463,48 @@ function writeGate(cwd, paths) {
     return NONE2;
   }
 }
+// packages/workit-core/src/hooks/stop.ts
+import { spawnSync as spawnSync16 } from "node:child_process";
+
 // packages/workit-core/src/hooks/raw-git.ts
 import { spawnSync as spawnSync15 } from "node:child_process";
+import { createHash as createHash12 } from "node:crypto";
+import fs16 from "node:fs";
+import os4 from "node:os";
+import path23 from "node:path";
+
+// packages/workit-core/src/hooks/session-marker.ts
 import { createHash as createHash11 } from "node:crypto";
 import fs15 from "node:fs";
-import os4 from "node:os";
 import path22 from "node:path";
+var sessionMarkerFile = (input, session, store) => {
+  let dir = store;
+  if (dir === undefined) {
+    const location = resolveStore(input.cwd);
+    if (location instanceof Error || !location.shared)
+      return null;
+    dir = location.dir;
+  }
+  const name = createHash11("sha256").update(`${input.host}\x00${session}`).digest("hex").slice(0, 32);
+  return path22.join(dir, "hooks", `skills-${name}.json`);
+};
+var list2 = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+var readSessionMarker = (file) => {
+  try {
+    const value = JSON.parse(fs15.readFileSync(file, "utf8"));
+    return { nudged: list2(value.nudged), loaded: list2(value.loaded), raw: list2(value.raw) };
+  } catch {
+    return { nudged: [], loaded: [], raw: [] };
+  }
+};
+var writeSessionMarker = (file, marker) => {
+  try {
+    fs15.mkdirSync(path22.dirname(file), { recursive: true });
+    fs15.writeFileSync(file, JSON.stringify(marker));
+  } catch {}
+};
+
+// packages/workit-core/src/hooks/raw-git.ts
 var NONE3 = { kind: "none" };
 var SHELLS = new Set(["sh", "bash", "zsh", "dash", "ksh"]);
 var PREFIXES3 = new Set(["sudo", "command", "env", "nohup", "time", "exec", "nice", "&"]);
@@ -19485,12 +19521,12 @@ var GIT_VALUE_OPTIONS = new Set([
   "--config-env",
   "--super-prefix"
 ]);
-var isAbsolute = (value) => path22.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
+var isAbsolute = (value) => path23.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
 var joinDir = (base, next) => {
   if (base === undefined || /[$`*?]/.test(next) || next === "-")
     return;
-  const expanded = next === "~" || next.startsWith("~/") ? path22.join(os4.homedir(), next.slice(1)) : next;
-  return base === null || isAbsolute(expanded) ? expanded : path22.join(base, expanded);
+  const expanded = next === "~" || next.startsWith("~/") ? path23.join(os4.homedir(), next.slice(1)) : next;
+  return base === null || isAbsolute(expanded) ? expanded : path23.join(base, expanded);
 };
 var cdTarget = (words) => {
   const args = words.slice(1);
@@ -19586,6 +19622,37 @@ function rawInvocations(command, dialect = "posix", depth = 0) {
   }
   return found;
 }
+var LAUNCHERS = new Set([
+  "npx",
+  "bunx",
+  "pnpx",
+  "-y",
+  "--yes",
+  "pnpm",
+  "dlx",
+  "exec",
+  "env",
+  "sudo",
+  "command"
+]);
+var WORKIT_BIN = /(?:^|[\\/])workit(?:\.exe)?$|^@brainervirus\/workit-cli$/;
+function workitInvocations(command, dialect = "posix", depth = 0) {
+  const found = [];
+  for (const { words } of segmentsOf(command, dialect)) {
+    const at = words.findIndex((word) => !/^\w+=/.test(word) && !LAUNCHERS.has(word));
+    if (at < 0)
+      continue;
+    if (WORKIT_BIN.test(words[at])) {
+      found.push(words.slice(at + 1));
+      continue;
+    }
+    const shell = SHELLS.has(commandName(words[at]));
+    const script = shell && words[at + 1] === "-c" ? words[at + 2] : undefined;
+    if (depth < 3 && script !== undefined)
+      found.push(...workitInvocations(script, "posix", depth + 1));
+  }
+  return found;
+}
 var PUSH_VALUE_OPTIONS = new Set(["-o", "--push-option", "--receive-pack", "--exec", "--repo"]);
 var pushAction = (args) => {
   let force = false;
@@ -19712,7 +19779,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;
@@ -19743,17 +19810,17 @@ 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(path23.join(git.gitDir, "HEAD"), "utf8").trim();
     if (/^[0-9a-f]{40,64}$/.test(head))
       return head;
     const ref = /^ref: (refs\/.+)$/.exec(head)?.[1];
     if (!ref)
       return null;
-    const common = path22.dirname(repo.location.dir);
+    const common = path23.dirname(repo.location.dir);
     try {
-      return fs15.readFileSync(path22.join(common, ref), "utf8").trim() || null;
+      return fs16.readFileSync(path23.join(common, ref), "utf8").trim() || null;
     } catch {}
-    const packed = fs15.readFileSync(path22.join(common, "packed-refs"), "utf8");
+    const packed = fs16.readFileSync(path23.join(common, "packed-refs"), "utf8");
     return new RegExp(`^([0-9a-f]{40,64}) ${ref.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`, "m").exec(packed)?.[1] ?? null;
   } catch {
     return null;
@@ -19790,7 +19857,7 @@ var actionsIn = (cwd, command, dialect) => {
     const action = rawAction(invocation);
     if (!action)
       continue;
-    const dir = path22.resolve(cwd, invocation.dir ?? ".");
+    const dir = path23.resolve(cwd, invocation.dir ?? ".");
     if (!repos.has(dir)) {
       const repo = repoAt(dir);
       repos.set(dir, repo && isWorkitWorkspace(repo) ? repo : null);
@@ -19808,12 +19875,31 @@ var inWorkitWorkspace = (dir) => {
 var rawDelivery = (cwd, command, dialect) => mentionsRawTool(command) && actionsIn(cwd, command, dialect).some(({ action }) => action.kind !== "commit" && action.kind !== "pr-read");
 var mentionsRawTool = (command) => /\b(?:git|gh|glab)\b/i.test(command);
 var dialectOf = (input) => (input.event.kind === "shell.pre" || input.event.kind === "shell.post" ? input.event.dialect : undefined) ?? "posix";
-function rawGitPre(input, command) {
+var nudgeKind = (action) => action.kind === "commit" && action.amend ? "commit-amend" : action.kind === "push" && action.blindForce ? "push-force" : action.kind;
+var unseenNudges = (input, nudges, store) => {
+  const session = input.session.id;
+  const file = session ? sessionMarkerFile(input, session, store) : null;
+  if (!file)
+    return [...nudges.values()];
+  const marker = readSessionMarker(file);
+  const agent = input.session.agentId ? `${input.session.agentId}:` : "";
+  const fresh = [...nudges.keys()].filter((kind) => !marker.raw.includes(agent + kind));
+  if (fresh.length)
+    writeSessionMarker(file, {
+      ...marker,
+      raw: [...marker.raw, ...fresh.map((kind) => agent + kind)]
+    });
+  return fresh.map((kind) => nudges.get(kind));
+};
+function rawGitPre(input, command, options = {}) {
   try {
     if (!mentionsRawTool(command))
       return NONE3;
-    const nudges = [];
-    for (const { action, repo } of actionsIn(input.cwd, command, dialectOf(input))) {
+    const dialect = dialectOf(input);
+    const nudges = new Map;
+    let store = null;
+    for (const { action, repo } of actionsIn(input.cwd, command, dialect)) {
+      store ??= repo.location.dir;
       if (action.kind === "merge")
         return deny(refusal(action, null));
       if (action.kind === "push")
@@ -19823,10 +19909,15 @@ function rawGitPre(input, command) {
             return deny(refusal(action, branch));
         }
       const nudge = nudgeFor(action, input.host, input.session.id);
-      if (nudge && !nudges.includes(nudge))
-        nudges.push(nudge);
+      if (nudge && !nudges.has(nudgeKind(action)))
+        nudges.set(nudgeKind(action), nudge);
     }
-    return nudges.length ? { kind: "context", text: nudges.join(`
+    if (options.nudge === false || !store || nudges.size === 0)
+      return NONE3;
+    if (workitInvocations(command, dialect).length > 0)
+      return NONE3;
+    const shown = unseenNudges(input, nudges, store);
+    return shown.length ? { kind: "context", text: shown.join(`
 `) } : NONE3;
   } catch {
     return NONE3;
@@ -19834,8 +19925,8 @@ function rawGitPre(input, command) {
 }
 var deny = (reason) => ({ kind: "deny", reason, unblock: null });
 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) => path23.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))
@@ -19845,8 +19936,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(path23.dirname(file), { recursive: true });
+      fs16.writeFileSync(file, `${JSON.stringify({ head: headSha2(repo), at })}
 `);
     }
   } catch {}
@@ -19869,11 +19960,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)
@@ -19914,11 +20005,161 @@ 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/hooks/stop.ts
+var NONE4 = { kind: "none" };
+var QUESTION = /[?？؟](?=[\s*_`"')\]>]*(?:\s|$))|¿/;
+var OFFER = /\b(?:let me know|want me to|should I|shall I|would you like|do you want|if you(?:'d| would) like|may I|can I go ahead)\b/i;
+var YES_NO = /[[(]\s*y(?:es)?\s*\/\s*n(?:o)?\s*[\])]/i;
+var LIST_ITEM = /^\s*(?:[-*+•]|\d+[.)]|[a-z][.)])\s+/i;
+var asksUser = (message) => {
+  if (!message)
+    return false;
+  const paragraphs = message.replace(/```[\s\S]*?(?:```|$)/g, `
+
+`).split(/\n\s*\n/).map((paragraph) => paragraph.trim()).filter(Boolean);
+  while (paragraphs.length > 1 && paragraphs.at(-1).split(`
+`).every((line) => LIST_ITEM.test(line)))
+    paragraphs.pop();
+  const tail = paragraphs.slice(-2).join(`
+`);
+  return QUESTION.test(tail) || OFFER.test(tail) || YES_NO.test(tail);
+};
+var short = (sha) => (sha ?? "?").slice(0, 12);
+var gitList = (cwd, args) => {
+  const run = spawnSync16("git", args, {
+    cwd,
+    encoding: "utf8",
+    timeout: 3000,
+    windowsHide: true,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0", GIT_OPTIONAL_LOCKS: "0", LC_ALL: "C" }
+  });
+  return run.status === 0 ? run.stdout.split(`
+`).filter(Boolean) : null;
+};
+var gitLine = (cwd, args) => gitList(cwd, args)?.[0] ?? null;
+var sessionOf = (row) => (typeof row.session === "string" ? row.session : null) ?? row.actor.session;
+var prState = (row) => typeof row.state === "string" ? row.state : "open";
+var ended = (row) => row.observer === "workit_cli" && (row.type === "pr.merged" || row.type === "pr.status" && prState(row) !== "open");
+var openPr = (rows) => {
+  const seen = rows.findLast((row) => (row.type === "pr.created" || row.type === "pr.status") && row.observer === "workit_cli" && typeof row.pr === "number");
+  if (!seen || ended(seen))
+    return null;
+  const closed = rows.some((row) => ended(row) && row.pr === seen.pr && row.seq > seen.seq);
+  return closed ? null : seen.pr;
+};
+var mergedHeads = (rows) => [
+  ...new Set(rows.filter((row) => row.observer === "workit_cli" && typeof row.head === "string" && (row.type === "pr.merged" || row.type === "pr.status" && prState(row) === "merged")).map((row) => row.head))
+].slice(-3);
+var localCommit = (cwd, sha) => /^[0-9a-f]{7,64}$/.test(sha) && gitList(cwd, ["cat-file", "-e", `${sha}^{commit}`]) !== null;
+var upstreamGone = (cwd, branch) => gitLine(cwd, ["for-each-ref", "--format=%(upstream:track)", `refs/heads/${branch}`]) === "[gone]";
+var landed = (cwd, branch, rows, head, mine) => {
+  if (!head)
+    return false;
+  const merged = mergedHeads(rows);
+  if (merged.length === 0)
+    return upstreamGone(cwd, branch);
+  if (merged.includes(head))
+    return true;
+  if (mine.size === 0)
+    return false;
+  return merged.some((at) => {
+    const after = gitList(cwd, ["rev-list", `--max-count=${UNPUSHED_SCAN}`, "HEAD", "--not", at]);
+    return after !== null && !after.some((sha) => mine.has(sha));
+  });
+};
+var UNPUSHED_SCAN = 500;
+var unpushed = (cwd, branch, endpoint, mine, merged) => {
+  const remote = pushRemoteName(cwd, branch);
+  if (!remote || mine.size === 0)
+    return null;
+  const listed = gitList(cwd, [
+    "rev-list",
+    `--max-count=${UNPUSHED_SCAN}`,
+    "HEAD",
+    "--not",
+    `--remotes=${remote}`,
+    ...merged.filter((sha) => localCommit(cwd, sha))
+  ]);
+  const count = (listed ?? []).filter((sha) => mine.has(sha)).length;
+  if (count === 0)
+    return null;
+  return {
+    kind: "unpushed",
+    reason: `${branch} has ${count} commit(s) of this session not on ${remote}, and this workspace's endpoint is \`${endpoint}\` (\`workit grant show\`): push them with \`workit git push\`${endpoint === "pr" ? ", then open or update the PR (`workit pr create --fill`)" : ""}.`
+  };
+};
+var redChecks = (rows, pr, head, endpoint) => {
+  const status = rows.findLast((row) => row.type === "pr.status" && row.observer === "workit_cli" && row.pr === pr);
+  const state = status && status.head === head && prState(status) === "open" ? status.checks : null;
+  if (state !== "failing" && state !== "pending")
+    return null;
+  return {
+    kind: "checks",
+    reason: `PR #${pr}'s checks were last seen ${state} at ${short(head)}, and this workspace's endpoint is \`${endpoint}\`: run \`workit ci wait --pr ${pr}\`${state === "failing" ? " after fixing the failures `workit pr status` lists (then push)" : ""}.`
+  };
+};
+var unverified = (cwd, branch, all, descriptor) => {
+  const check = checkVerdicts(cwd, branch, all);
+  if (check.accepted.accepted || check.accepted.reasons.includes("failing_verdict"))
+    return null;
+  const has = check.review === "self-reviewed" ? "only a self verdict" : "no current verdict";
+  const verifier = `${descriptor.subagents.agentPrefix}verifier`;
+  return {
+    kind: "verdict",
+    reason: `the head ${short(check.head)} of ${branch}, which this session delivered, has ${has}: if no verifier is already running on it, hand it to a session that did not author it (the ${verifier} agent records \`workit ledger verdict <result> --branch ${branch} --how "<evidence>"\`), or tell the user it is unverified. Never record a verdict on your own work.`
+  };
+};
+function stopObligation(input, descriptor) {
+  try {
+    const session = input.session.id;
+    if (!session || input.session.agentId || !inWorkitWorkspace(input.cwd))
+      return null;
+    const branch = currentBranch(input.cwd);
+    if (!branch || guardedBranch(input.cwd, branch))
+      return null;
+    const ledger = readLedger(input.cwd);
+    if (!ledger.ok)
+      return null;
+    const all = ledger.value.rows;
+    const rows = all.filter((row) => row.branch === branch);
+    const mine = rows.filter((row) => sessionOf(row) === session);
+    const commits = new Set(mine.filter((row) => row.type === "commit.recorded").map((row) => typeof row.sha === "string" ? row.sha : row.head).filter((sha) => typeof sha === "string"));
+    const delivered = mine.some((row) => row.observer === "workit_cli" && (row.type === "pr.created" || row.type === "delivery.verified"));
+    if (commits.size === 0 && !delivered)
+      return null;
+    const head = gitLine(input.cwd, ["rev-parse", "HEAD"]);
+    if (landed(input.cwd, branch, rows, head, commits))
+      return null;
+    const endpoint = resolveAutonomy(input.cwd).effectiveEndpoint;
+    if (endpoint !== "commit") {
+      const left = unpushed(input.cwd, branch, endpoint, commits, mergedHeads(rows));
+      if (left)
+        return left;
+    }
+    const pr = openPr(rows);
+    if ((endpoint === "green" || endpoint === "merged") && pr !== null && head) {
+      const left = redChecks(rows, pr, head, endpoint);
+      if (left)
+        return left;
+    }
+    return delivered ? unverified(input.cwd, branch, all, descriptor) : null;
+  } catch {
+    return null;
+  }
+}
+function stopDecision(input, descriptor) {
+  const event = input.event;
+  if (event.kind !== "stop" || event.stopHookActive)
+    return NONE4;
+  if (!event.lastMessage?.trim() || asksUser(event.lastMessage))
+    return NONE4;
+  const left = stopObligation(input, descriptor);
+  return left ? {
+    kind: "continue",
+    reason: `Workit: before stopping, ${left.reason} If this cannot be done now, say so to the user and stop.`
+  } : NONE4;
+}
 // packages/workit-core/src/core/skill-manifests.ts
 var WORKIT_METHOD_SKILLS = [
   "workit-shape",
@@ -20027,27 +20268,6 @@ var promptTrigger = (prompt) => {
   }
   return null;
 };
-var markerFile2 = (input, session) => {
-  const location = resolveStore(input.cwd);
-  if (location instanceof Error || !location.shared)
-    return null;
-  const name = 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;
@@ -20079,13 +20299,13 @@ function recordSkillLoad(input, name, via) {
       return;
     if (!inWorkitWorkspace(input.cwd))
       return;
-    const file = markerFile2(input, session);
+    const file = sessionMarkerFile(input, session);
     if (!file)
       return;
-    const marker = readMarker(file);
+    const marker = readSessionMarker(file);
     if (marker.loaded.includes(skill))
       return;
-    writeMarker(file, { ...marker, loaded: [...marker.loaded, skill] });
+    writeSessionMarker(file, { ...marker, loaded: [...marker.loaded, skill] });
     if (loadedSkills(input.cwd, session).has(skill))
       return;
     appendHookObserved(input.cwd, {
@@ -20097,23 +20317,24 @@ function recordSkillLoad(input, name, via) {
   } catch {}
 }
 var nudgeOnce = (input, session, skill, line) => {
-  const file = markerFile2(input, session);
+  const file = sessionMarkerFile(input, session);
   if (!file)
     return null;
-  const marker = readMarker(file);
+  const marker = readSessionMarker(file);
   if (marker.nudged.includes(skill) || marker.loaded.includes(skill))
     return null;
   if (loadedSkills(input.cwd, session).has(skill))
     return null;
-  writeMarker(file, { ...marker, nudged: [...marker.nudged, skill] });
+  writeSessionMarker(file, { ...marker, nudged: [...marker.nudged, skill] });
   return line;
 };
 var nudgeText = (input, skill, why) => USER_INVOKED.has(skill) ? `Workit: ${why} looks like ${skill} work, which the user starts; offer it (/${skill.replace(/^workit-/, "wk-")}) rather than loading it.` : `Workit: ${why} looks like ${skill} work; if it is, ${skillLoadWording(SKILL_HOST[input.host], skill)} first.`;
 var promptLoads = (prompt) => /^\s*\/(?:skill:)?([\w:-]+)/.exec(prompt)?.[1] ?? /^\s*<skill name="([\w:-]+)"/.exec(prompt)?.[1] ?? /^\s*Load the (workit-[a-z-]+) skill with the skill tool\b/.exec(prompt)?.[1] ?? null;
+var relayedMessage = (prompt) => /^\s*(?:Another Claude session sent a message\b|<agent-message\s+from=|\[SYSTEM NOTIFICATION\b|<task-notification>)/.test(prompt);
 function promptNudge(input, prompt) {
   try {
     const session = input.session.id;
-    if (!prompt || !session || input.session.agentId)
+    if (!prompt || !session || input.session.agentId || relayedMessage(prompt))
       return null;
     const loads = promptLoads(prompt);
     if (loads) {
@@ -20129,32 +20350,7 @@ function promptNudge(input, prompt) {
   }
 }
 var WORKIT_DELIVERY = /^(?:pr (?:create|merge)|ci wait|git push)\b/;
-var SHELLS2 = new Set(["sh", "bash", "zsh", "dash", "ksh"]);
-var LAUNCHERS = new Set([
-  "npx",
-  "bunx",
-  "pnpx",
-  "-y",
-  "--yes",
-  "pnpm",
-  "dlx",
-  "exec",
-  "env",
-  "sudo",
-  "command"
-]);
-var runsWorkitDelivery = (command, dialect, depth = 0) => segmentsOf(command, dialect).some(({ words }) => {
-  const at = words.findIndex((word) => !/^\w+=/.test(word) && !LAUNCHERS.has(word));
-  if (at >= 0 && /(?:^|[\\/])workit(?:\.exe)?$|^@brainervirus\/workit-cli$/.test(words[at])) {
-    const args = words.slice(at + 1);
-    if (args.some((arg) => arg === "--help" || arg === "-h" || arg === "--dry-run"))
-      return false;
-    return WORKIT_DELIVERY.test(args.join(" "));
-  }
-  const shell = SHELLS2.has(words[at]?.split(/[\\/]/).at(-1) ?? "");
-  const script = shell && words[at + 1] === "-c" ? words[at + 2] : undefined;
-  return depth < 3 && script !== undefined && runsWorkitDelivery(script, "posix", depth + 1);
-});
+var runsWorkitDelivery = (command, dialect) => workitInvocations(command, dialect).some((args) => !args.some((arg) => arg === "--help" || arg === "-h" || arg === "--dry-run") && WORKIT_DELIVERY.test(args.join(" ")));
 var isDeliveryCommand = (cwd, command, dialect = "posix") => rawDelivery(cwd, command, dialect) || runsWorkitDelivery(command, dialect) && inWorkitWorkspace(cwd);
 function shipNudge(input, command) {
   try {
@@ -20181,7 +20377,7 @@ ${line}` };
 };
 var shellNudge = (input, command) => withContextLine(rawGitPre(input, command), shipNudge(input, command));
 // packages/workit-core/src/hooks/hosts/fields.ts
-var SHELLS3 = new Set(["sh", "bash", "zsh", "dash", "pwsh", "powershell", "cmd"]);
+var SHELLS2 = new Set(["sh", "bash", "zsh", "dash", "pwsh", "powershell", "cmd"]);
 var WRITE_TOOLS = new Set([
   "write",
   "edit",
@@ -20219,6 +20415,7 @@ var SHELL_TOOLS2 = new Set(["bash", "unified-exec"]);
 var SOURCES2 = new Set(["startup", "resume", "clear", "compact", "fork"]);
 
 // packages/workit-core/src/hooks/hosts/cursor.ts
+var TRANSCRIPT_TAIL_BYTES = 256 * 1024;
 var BLOCKING2 = new Set(["preToolUse", "beforeShellExecution", "subagentStart"]);
 
 // packages/workit-core/src/hooks/run.ts
@@ -20241,7 +20438,7 @@ 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: "none", native: null }
+    stop: { support: "partial", native: 'event("session.idle")' }
   },
   shellPolicy: { deny: "native", channel: "effect", failClosed: false },
   context: {
@@ -20409,7 +20606,7 @@ var ensureHygieneFiles = (root, opts) => {
 // packages/workit-core/src/core/init.ts
 import fs17 from "node:fs";
 import path27 from "node:path";
-import { spawnSync as spawnSync16 } from "node:child_process";
+import { spawnSync as spawnSync17 } 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";
@@ -20532,7 +20729,7 @@ var resolveInitProvider = (cwd) => {
     return env.toLowerCase();
   const root = cwd ?? process.env.WORKFLOW_WORKSPACE_ROOT ?? process.cwd();
   try {
-    const out = spawnSync16("git", ["remote", "get-url", "origin"], {
+    const out = spawnSync17("git", ["remote", "get-url", "origin"], {
       cwd: root,
       encoding: "utf8"
     });
@@ -21442,7 +21639,7 @@ var evaluateShellPermission = (root, event, workdirs = new Map) => {
       permissionMode: null,
       transcriptPath: null,
       event: { kind: "shell.pre", command: resource, toolUseId: null }
-    }, resource);
+    }, resource, { nudge: false });
     if (raw.kind === "deny")
       return deny(raw.reason);
     const writes = shellWrites(resource);
@@ -21547,6 +21744,56 @@ var injectSkillNudge = (root, session, messages, system) => {
   } catch {}
 };
 
+// packages/workit-opencode/src/v2/stop.ts
+var record3 = (value) => typeof value === "object" && value !== null ? value : {};
+var lastAssistantText = (messages) => {
+  for (const message of messages.toReversed()) {
+    if (record3(message).type !== "assistant")
+      continue;
+    const content = record3(message).content;
+    if (!Array.isArray(content))
+      return null;
+    const text = content.filter((part) => record3(part).type === "text" && typeof record3(part).text === "string").map((part) => record3(part).text).join(`
+`);
+    return text || null;
+  }
+  return null;
+};
+var createStopControl = (root, port) => {
+  const continued = new Set;
+  return {
+    onIdle: async (sessionID) => {
+      try {
+        if (continued.delete(sessionID))
+          return false;
+        const session = await port.getSession(sessionID);
+        if (!session || session.parentID !== undefined)
+          return false;
+        if (session.outcome !== "succeeded")
+          return false;
+        if (!sameWorkspace(root, session.directory))
+          return false;
+        const lastMessage = lastAssistantText(await port.messages(sessionID));
+        const decision = stopDecision({
+          host: "opencode",
+          cwd: root,
+          session: { id: sessionID, agentId: null, agentType: null, parentId: null },
+          permissionMode: null,
+          transcriptPath: null,
+          event: { kind: "stop", lastMessage, stopHookActive: false }
+        }, OPENCODE_DESCRIPTOR);
+        if (decision.kind !== "continue")
+          return false;
+        continued.add(sessionID);
+        await port.resume(sessionID, decision.reason);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+};
+
 // packages/workit-opencode/src/v2/registry.ts
 import { existsSync as existsSync11, readFileSync as readFileSync9 } from "node:fs";
 import path33 from "node:path";
@@ -21827,11 +22074,18 @@ var setup = async (ctx) => {
   });
   const registeredSkills = await registerSkills(ctx);
   await registerCommands(ctx, registeredSkills);
+  const stopControl = createStopControl(root, {
+    getSession: (sessionID) => sessionFacts(ctx, sessionID),
+    messages: async (sessionID) => await ctx.session.context({ sessionID }),
+    resume: (sessionID, text) => ctx.session.synthetic({ sessionID, text, delivery: "queue", resume: true })
+  });
   const subscription = new AbortController;
   (async () => {
     try {
       for await (const event of ctx.event.subscribe({ signal: subscription.signal })) {
         await lifecycle.handleEvent(event);
+        if (event.type === "session.idle")
+          stopControl.onIdle(String(event.data.sessionID));
       }
     } catch {}
   })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-opencode",
-  "version": "8.7.0",
+  "version": "8.8.0",
   "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.7.0"
+    "@brainervirus/workit-core": "^8.8.0"
   },
   "devDependencies": {
     "@opencode/plugin": "2.0.18"