@brainervirus/workit-codex 8.20.0 → 8.21.0

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "workit",
-  "version": "8.20.0",
+  "version": "8.21.0",
   "description": "Adaptive engineering workflow rails for Codex",
   "author": {
     "name": "BrainerVirus"

package/dist/launch-mcp.js

@@ -28826,8 +28826,11 @@ var WRITE_TOOLS = new Set([
   "editfile",
   "writefile"
 ]);
+// packages/workit-core/src/hooks/standing.ts
+var sinceStart = new Map;
 // packages/workit-core/src/hooks/handle.ts
 var offered = new Set;
+var PRE_TOOL = new Set(["shell.pre", "write.pre", "tool.pre"]);
 // packages/workit-core/src/hooks/deadline.ts
 var QUIET = new Set([
   "stop",

package/dist/{workit-hook-kg4dxyfv.js → workit-hook-thet0x8m.js}

@@ -290,4 +290,64 @@ function maybeHeavy(command, cwd, env = process.env) {
   }
 }
 
-export { CHECKS_FILE, repoHeavyCommands, loadCheckConfig, matchesNamedCheck, gateCheckNames, checkCommand, stateDir, maybeHeavy };
+// packages/workit-core/src/hooks/standing-signal.ts
+import { createHash } from "node:crypto";
+import fs3 from "node:fs";
+import path3 from "node:path";
+var gitStoreDir = (cwd) => {
+  try {
+    for (let dir = path3.resolve(cwd);; dir = path3.dirname(dir)) {
+      const dotGit = path3.join(dir, ".git");
+      if (fs3.existsSync(dotGit)) {
+        let gitDir = dotGit;
+        if (fs3.statSync(dotGit).isFile()) {
+          const target = /^gitdir:\s*(.+)$/mu.exec(fs3.readFileSync(dotGit, "utf8"))?.[1]?.trim();
+          if (!target)
+            return null;
+          gitDir = path3.resolve(dir, target);
+          const common = path3.join(gitDir, "commondir");
+          if (fs3.existsSync(common))
+            gitDir = path3.resolve(gitDir, fs3.readFileSync(common, "utf8").trim());
+        }
+        return path3.join(gitDir, "workit");
+      }
+      if (path3.dirname(dir) === dir)
+        return null;
+    }
+  } catch {
+    return null;
+  }
+};
+var standingRevFile = (store) => path3.join(store, "standing", "rev");
+var standingSeenFile = (store, session, agentId) => path3.join(store, "standing", "seen", `${createHash("sha256").update(`${session}\x00${agentId ?? ""}`).digest("hex").slice(0, 32)}.json`);
+var readStandingRev = (store) => {
+  try {
+    return fs3.readFileSync(standingRevFile(store), "utf8").trim() || null;
+  } catch {
+    return null;
+  }
+};
+var readStandingSeen = (file) => {
+  try {
+    const value = JSON.parse(fs3.readFileSync(file, "utf8"));
+    return {
+      rev: typeof value.rev === "string" ? value.rev : null,
+      ids: Array.isArray(value.ids) ? value.ids.filter((id) => typeof id === "string") : []
+    };
+  } catch {
+    return { rev: null, ids: [] };
+  }
+};
+var writeStandingSeen = (file, seen) => {
+  try {
+    fs3.mkdirSync(path3.dirname(file), { recursive: true });
+    fs3.writeFileSync(file, JSON.stringify(seen));
+  } catch {}
+};
+var standingPending = (cwd, session, agentId) => {
+  const store = gitStoreDir(cwd);
+  const rev = store ? readStandingRev(store) : null;
+  return rev !== null && readStandingSeen(standingSeenFile(store, session, agentId)).rev !== rev;
+};
+
+export { CHECKS_FILE, repoHeavyCommands, loadCheckConfig, matchesNamedCheck, gateCheckNames, checkCommand, stateDir, maybeHeavy, gitStoreDir, standingSeenFile, readStandingRev, readStandingSeen, writeStandingSeen, standingPending };

package/dist/{workit-hook-00hstm40.js → workit-hook-xhk0gksg.js}

@@ -6,8 +6,13 @@ import {
   matchesNamedCheck,
   gateCheckNames,
   checkCommand,
-  maybeHeavy
-} from "./workit-hook-kg4dxyfv.js";
+  maybeHeavy,
+  gitStoreDir,
+  standingSeenFile,
+  readStandingRev,
+  readStandingSeen,
+  writeStandingSeen
+} from "./workit-hook-thet0x8m.js";
 // packages/workit-core/src/hooks/descriptor.ts
 var support = (descriptor, axis) => {
   if (axis.startsWith("event:"))
@@ -14536,6 +14541,28 @@ function checkVerdicts(cwd, branch, ledgerRows) {
     warnings
   };
 }
+var fromLead = (row, leads) => leads === null || row.actor.session !== null && leads.includes(row.actor.session);
+function activeStanding(rows, fanout, leads = null) {
+  const active = [];
+  for (const row of rows) {
+    if (row.fanout !== fanout || !fromLead(row, leads))
+      continue;
+    if (row.type === "standing" && typeof row.what === "string" && row.what.trim()) {
+      if (!row.superseded)
+        active.push(row);
+    } else if (row.type === "standing.cleared") {
+      const target = str(row.target);
+      if (target === null)
+        active.length = 0;
+      else {
+        const index = active.findIndex((order) => order.id === target);
+        if (index >= 0)
+          active.splice(index, 1);
+      }
+    }
+  }
+  return active;
+}
 var OBSERVED_ONLY = new Set([
   "check",
   "merge.unverified",
@@ -22132,6 +22159,109 @@ var writeTargets = (input) => {
   const paths = writePaths(input);
   return paths.length > 0 ? paths : null;
 };
+// packages/workit-core/src/hooks/standing.ts
+import fs19 from "node:fs";
+import path26 from "node:path";
+var readPlans = (store) => {
+  const dir = path26.join(store, "fanouts");
+  let names;
+  try {
+    names = fs19.readdirSync(dir).filter((name) => name.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const plans = [];
+  for (const name of names) {
+    try {
+      const raw = JSON.parse(fs19.readFileSync(path26.join(dir, name), "utf8"));
+      if (typeof raw.name !== "string" || !Array.isArray(raw.slices))
+        continue;
+      const texts = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string" && item !== "") : [];
+      plans.push({
+        name: raw.name,
+        leads: texts([raw.leadSession, ...texts(raw.formerLeads)]),
+        branches: texts(raw.slices.map((slice) => slice && typeof slice === "object" ? slice.branch : null))
+      });
+    } catch {}
+  }
+  return plans;
+};
+var leadOf2 = (input) => input.session.parentId ?? (input.session.agentId ? input.session.id : null) ?? (input.session.id.includes(":") ? input.session.id.split(":")[0] : null);
+var worksFor = (plan, input, branch) => {
+  const session = input.session.id;
+  if (plan.leads.includes(session) && !input.session.agentId)
+    return false;
+  const lead = leadOf2(input);
+  if (lead && plan.leads.includes(lead))
+    return true;
+  if (plan.leads.some((each) => session.startsWith(`${each}-w-`)))
+    return true;
+  const current = branch();
+  return current !== null && plan.branches.includes(current);
+};
+var standingFor = (input, store, rev) => {
+  const orders = new Map;
+  const ledger = readLedger(input.cwd);
+  const rows = ledger.ok ? ledger.value.rows : [];
+  let branch;
+  const lazyBranch = () => branch === undefined ? branch = currentBranch(input.cwd) : branch;
+  for (const plan of readPlans(store))
+    if (worksFor(plan, input, lazyBranch))
+      for (const row of activeStanding(rows, plan.name, plan.leads.length ? plan.leads : null))
+        orders.set(row.id, row);
+  return { rev, orders, rows };
+};
+var located = (input) => {
+  const store = input.session.id ? gitStoreDir(input.cwd) : null;
+  const rev = store ? readStandingRev(store) : null;
+  if (!store || rev === null)
+    return null;
+  return { store, rev, file: standingSeenFile(store, input.session.id, input.session.agentId) };
+};
+var seedStanding = (input) => {
+  try {
+    const where = located(input);
+    if (!where)
+      return;
+    const now = standingFor(input, where.store, where.rev);
+    writeStandingSeen(where.file, { rev: where.rev, ids: [...now.orders.keys()] });
+  } catch {}
+};
+var fanoutOf = (row) => typeof row.fanout === "string" ? row.fanout : "?";
+var changedSince = (now, ids) => {
+  const known = new Set(ids);
+  const added = [...now.orders.values()].filter((row) => !known.has(row.id));
+  const byId = new Map(now.rows.map((row) => [row.id, row]));
+  const dropped = ids.filter((id) => !now.orders.has(id)).map((id) => byId.get(id)).filter((row) => row !== undefined);
+  if (!added.length && !dropped.length)
+    return null;
+  const fanouts = [...new Set([...added, ...dropped].map(fanoutOf))].join(", ");
+  const lines = [
+    `Workit: the lead changed the standing orders for fanout ${fanouts} while you run. They apply to you now and override your brief's STANDING list.`,
+    ...added.map((row) => `  - new: ${String(row.what)}`),
+    ...dropped.map((row) => `  - no longer in force: ${String(row.what)}${row.stop ? " (the stop is lifted: continue your brief)" : ""}`)
+  ];
+  if (added.some((row) => row.stop === true))
+    lines.push("Stop now: make no further changes, close what you opened, and report to the lead with your branch, head SHA, what is done and what is not.");
+  return lines.join(`
+`);
+};
+var standingDelta = (input) => {
+  try {
+    const where = located(input);
+    if (!where)
+      return null;
+    const seen = readStandingSeen(where.file);
+    if (seen.rev === where.rev)
+      return null;
+    const now = standingFor(input, where.store, where.rev);
+    writeStandingSeen(where.file, { rev: where.rev, ids: [...now.orders.keys()] });
+    return changedSince(now, seen.ids);
+  } catch {
+    return null;
+  }
+};
+var sinceStart = new Map;
 // packages/workit-core/src/hooks/handle.ts
 var usable2 = (value) => value === "native" || value === "partial";
 var NONE5 = { kind: "none" };
@@ -22176,7 +22306,18 @@ ${subagentStartText({ ...input, cwd: "" }, descriptor, event)}`;
   const pick = judge === "verifier" ? ", --kind live when you drove the real surface" : "";
   return `${readOnly} Its own Workit session is ${own}, so the ledger tells its verdicts apart from the author's. Record the verdict with exactly this command (pick the result${pick}, name the candidate branch if it differs, say what you ran): \`${line}\`.${token ? " The token is this subagent's alone: never write it into a report, a file or a commit. --token needs a workit CLI at least as new as this plugin; if the CLI answers that --token is an unknown option, update the workit CLI (workit upgrade --cli) and record again." : ""}`;
 };
+var PRE_TOOL = new Set(["shell.pre", "write.pre", "tool.pre"]);
 function handleHook(input, deps) {
+  const decision = decide(input, deps);
+  if (deps.descriptor.transport !== "hook-process" || !PRE_TOOL.has(input.event.kind) || decision.kind === "deny")
+    return decision;
+  const delta = standingDelta(input);
+  if (!delta)
+    return decision;
+  return decision.kind === "rewrite" ? { ...decision, text: [decision.text, delta].filter(Boolean).join(`
+`) } : withContextLine(decision, delta);
+}
+function decide(input, deps) {
   const { descriptor } = deps;
   const event = input.event;
   switch (event.kind) {
@@ -22253,6 +22394,7 @@ function handleHook(input, deps) {
     case "write.pre":
       return usable2(descriptor.events["write.pre"].support) ? writeGate(input.cwd, event.paths, liveOwner(input, descriptor.transport)) : NONE5;
     case "subagent.start":
+      seedStanding({ ...input, session: { ...input.session, agentId: event.agentId } });
       return {
         kind: "context",
         text: subagentStartText(input, descriptor, event)
@@ -22304,7 +22446,7 @@ var dispatchHook = (adapter, raw, env = process.env) => {
 };
 // packages/workit-core/src/hooks/deadline.ts
 import { appendFileSync, mkdirSync as mkdirSync3 } from "node:fs";
-import path26 from "node:path";
+import path27 from "node:path";
 var HOOK_SKIP_TEXT = "workit context skipped: host under load";
 var HOOK_DEADLINE_MS = 8000;
 var HOST_DEADLINES = {
@@ -22322,7 +22464,7 @@ var hookDeadlineMs = (env, host = "", native) => {
   const row = HOST_DEADLINES[host];
   return override(env) ?? (row ? native === undefined ? Math.min(...Object.values(row)) : row[native] ?? row[""] : HOOK_DEADLINE_MS);
 };
-var skipsFile = (stateDir) => path26.join(stateDir, HOOK_SKIPS_FILE);
+var skipsFile = (stateDir) => path27.join(stateDir, HOOK_SKIPS_FILE);
 var recordHookSkip = (skip, stateDir = resolveStateDir()) => {
   try {
     mkdirSync3(stateDir, { recursive: true });
@@ -22966,8 +23108,8 @@ var codexAdapter = {
 };
 
 // packages/workit-core/src/hooks/hosts/cursor.ts
-import fs19 from "node:fs";
-import path27 from "node:path";
+import fs20 from "node:fs";
+import path28 from "node:path";
 var undocumented = { support: "undocumented", native: null };
 var none = { support: "none", native: null };
 var CURSOR_DESCRIPTOR = {
@@ -23164,17 +23306,17 @@ var protocolEvent2 = (input) => {
 };
 var TRANSCRIPT_TAIL_BYTES = 256 * 1024;
 var lastAssistantText = (file) => {
-  if (!file || !path27.isAbsolute(file))
+  if (!file || !path28.isAbsolute(file))
     return null;
   try {
-    const size = fs19.statSync(file).size;
+    const size = fs20.statSync(file).size;
     const start = Math.max(0, size - TRANSCRIPT_TAIL_BYTES);
     const buffer = Buffer.alloc(size - start);
-    const fd = fs19.openSync(file, "r");
+    const fd = fs20.openSync(file, "r");
     try {
-      fs19.readSync(fd, buffer, 0, buffer.length, start);
+      fs20.readSync(fd, buffer, 0, buffer.length, start);
     } finally {
-      fs19.closeSync(fd);
+      fs20.closeSync(fd);
     }
     const lines = buffer.toString("utf8").split(`
 `);
@@ -23201,7 +23343,7 @@ var lastAssistantText = (file) => {
     return null;
   }
 };
-var within2 = (root, dir) => dir === root || dir.startsWith(root.endsWith(path27.sep) ? root : `${root}${path27.sep}`);
+var within2 = (root, dir) => dir === root || dir.startsWith(root.endsWith(path28.sep) ? root : `${root}${path28.sep}`);
 var hookCwd = (input) => {
   const cwd = existingDirectory(input.cwd);
   if (cwd && input.hook_event_name === "beforeShellExecution")

package/dist/workit-hook.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import {
   stateDir,
-  maybeHeavy
-} from "./workit-hook-kg4dxyfv.js";
+  maybeHeavy,
+  standingPending
+} from "./workit-hook-thet0x8m.js";
 
 // packages/workit-codex/hooks/launcher.ts
 var payload = "";
@@ -22,6 +23,8 @@ var quietEvent = () => {
       return null;
     if (typeof value.cwd !== "string" || typeof value.tool_name !== "string")
       return null;
+    if (event === "PreToolUse" && typeof value.session_id === "string" && standingPending(value.cwd, value.session_id, typeof value.agent_id === "string" && value.agent_id.trim() ? value.agent_id : null))
+      return null;
     const tool = value.tool_name.toLowerCase();
     if (event === "PreToolUse" && WRITE_TOOLS.has(tool.replace(/[_-]/g, "")))
       return null;
@@ -44,6 +47,6 @@ if (quiet)
   process.stdout.write(`${JSON.stringify({ hookSpecificOutput: { hookEventName: quiet } })}
 `);
 else {
-  const { runCodexHook } = await import("./workit-hook-00hstm40.js");
+  const { runCodexHook } = await import("./workit-hook-xhk0gksg.js");
   await runCodexHook([payload]);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-codex",
-  "version": "8.20.0",
+  "version": "8.21.0",
   "private": false,
   "description": "Workit Codex CLI/desktop plugin — shared MCP transport, hooks, method skills, and verifier/reviewer/implementer agents",
   "keywords": [
@@ -39,8 +39,8 @@
     "build": "bun scripts/build.ts"
   },
   "devDependencies": {
-    "@brainervirus/workit-core": "^8.20.0",
-    "@brainervirus/workit-mcp": "^8.20.0"
+    "@brainervirus/workit-core": "^8.21.0",
+    "@brainervirus/workit-mcp": "^8.21.0"
   },
   "engines": {
     "node": ">=24"