@brainervirus/workit-codex 8.36.0 → 8.37.1

package/dist/workit-hook-3g6cv3hd.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import {
+  observeHookBudget2,
+  budgetHooks2
+} from "./workit-hook-b8nrcfzr.js";
+import"./workit-hook-jy7y0gdx.js";
+export {
+  budgetHooks2 as budgetHooks,
+  observeHookBudget2 as observeHookBudget
+};

package/dist/{workit-hook-7dqgrrwd.js → workit-hook-4hyzn1m0.js}

@@ -18,6 +18,9 @@ import {
 import {
   recordHookRun2
 } from "./workit-hook-w6s3hcyz.js";
+import {
+  budgetHooks2
+} from "./workit-hook-b8nrcfzr.js";
 // packages/workit-core/src/hooks/descriptor.ts
 var support = (descriptor, axis) => {
   if (axis.startsWith("event:"))
@@ -22620,7 +22623,8 @@ function handleHook(input, deps) {
   const decision = decide(input, deps);
   if (deps.descriptor.transport !== "hook-process" || !PRE_TOOL.has(input.event.kind) || decision.kind === "deny" || decision.kind === "ask")
     return decision;
-  const delta = standingDelta(input);
+  const delta = [standingDelta(input), deps.budget?.line(input) ?? null].filter(Boolean).join(`
+`) || null;
   if (!delta)
     return decision;
   return decision.kind === "rewrite" || decision.kind === "update-input" ? { ...decision, text: [decision.text, delta].filter(Boolean).join(`
@@ -22730,7 +22734,11 @@ function decide(input, deps) {
     case "subagent.start":
       if (workitRole(descriptor, event.agentType) === "judge")
         trackJudge(input, event.agentId, true);
-      seedStanding({ ...input, session: { ...input.session, agentId: event.agentId } });
+      seedStanding({
+        ...input,
+        session: { ...input.session, agentId: event.agentId }
+      });
+      deps.budget?.start(input, event.agentId, event.agentType);
       return {
         kind: "context",
         text: subagentStartText(input, descriptor, event)
@@ -22743,13 +22751,19 @@ function decide(input, deps) {
     case "tool.pre":
       if (event.skill)
         recordSkillLoad(input, event.skill, "tool");
-      if (event.agentInput && input.host === "claude_code")
-        return spawnDecision(descriptor, input.cwd, event.agentInput);
+      if (event.agentInput && input.host === "claude_code") {
+        const spawn = spawnDecision(descriptor, input.cwd, event.agentInput);
+        if (spawn.kind !== "deny")
+          deps.budget?.spawn(input, event.agentInput);
+        return spawn;
+      }
       return NONE6;
     case "stop":
       return usable2(descriptor.events.stop.support) ? stopDecision(input, descriptor) : NONE6;
     case "subagent.stop":
       trackJudge(input, event.agentId, false);
+      if (event.agentId)
+        deps.budget?.stop(input, event.agentId);
       return NONE6;
     case "prompt.submit":
       return NONE6;
@@ -22773,7 +22787,8 @@ var dispatchHook = (adapter, raw, env = process.env) => {
   try {
     const decision = handleHook(parsed.input, {
       descriptor,
-      addendum: adapter.addendum?.(parsed.input) ?? null
+      addendum: adapter.addendum?.(parsed.input) ?? null,
+      budget: adapter.budget
     });
     return { ...adapter.render(decision, parsed.native), error: null };
   } catch (error) {
@@ -22906,7 +22921,7 @@ var CLAUDE_CODE_DESCRIPTOR = {
     "shell.post": { support: "native", native: "PostToolUse" },
     "subagent.start": { support: "native", native: "SubagentStart" },
     "prompt.submit": { support: "native", native: "UserPromptSubmit" },
-    "subagent.stop": { support: "none", native: null },
+    "subagent.stop": { support: "native", native: "SubagentStop" },
     "compact.pre": { support: "none", native: null },
     stop: { support: "native", native: "Stop" }
   },
@@ -23810,9 +23825,10 @@ function warnOnSurfaceFallback(env = process.env) {
     process.stderr.write(`[workit] unrecognized CODEX_INTERNAL_ORIGINATOR_OVERRIDE=${JSON.stringify(override)} — treating surface as codex_cli
 `);
 }
+var adapter = { ...codexAdapter, budget: budgetHooks2 };
 var runCodexHook = async (stdin = process.stdin) => {
   warnOnSurfaceFallback();
-  process.exitCode = await runHookProcess(detectCodexSurface(process.env), stdin, process.stdout, process.stderr, process.env, { startedAt: PROCESS_START });
+  process.exitCode = await runHookProcess(adapter, stdin, process.stdout, process.stderr, process.env, { startedAt: PROCESS_START });
 };
 if (false)
   ;

package/dist/workit-hook-b8nrcfzr.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+import {
+  gitStoreDir2
+} from "./workit-hook-jy7y0gdx.js";
+
+// packages/workit-core/src/hooks/budget-signal.ts
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+var hash = (text) => createHash("sha256").update(text).digest("hex").slice(0, 32);
+var budgetDir = (store) => path.join(store, "budget");
+var agentBase = (store, session, agentId) => path.join(budgetDir(store), hash(`${session}\x00${agentId ?? ""}`));
+var spawnsFile = (store, session) => path.join(budgetDir(store), `spawns-${hash(session)}.jsonl`);
+var spawnBudget = (prompt) => {
+  const found = /^TIMEBOX:[^\n]*?\b(\d+)\s+tool calls\b/mu.exec(prompt);
+  const n = found ? Number(found[1]) : NaN;
+  return Number.isInteger(n) && n > 0 ? n : null;
+};
+var noteSpawnBudget = (cwd, session, type, prompt) => {
+  try {
+    const store = session ? gitStoreDir2(cwd) : null;
+    if (!store)
+      return;
+    fs.mkdirSync(budgetDir(store), { recursive: true });
+    fs.appendFileSync(spawnsFile(store, session), `${JSON.stringify({ type: type ?? "", n: spawnBudget(prompt) })}
+`);
+  } catch {}
+};
+var readBudget = (file) => {
+  try {
+    const { limit, told } = JSON.parse(fs.readFileSync(file, "utf8"));
+    return typeof limit === "number" && limit > 0 ? { limit, told: Number(told) || 0 } : null;
+  } catch {
+    return null;
+  }
+};
+var claimSpawnBudget = (cwd, session, agentId, agentType) => {
+  try {
+    const store = session ? gitStoreDir2(cwd) : null;
+    if (!store)
+      return null;
+    const file = spawnsFile(store, session);
+    const entries = fs.readFileSync(file, "utf8").split(`
+`).filter(Boolean).map((line) => JSON.parse(line));
+    const at = entries.findIndex((entry) => entry.type === (agentType ?? ""));
+    if (at < 0)
+      return null;
+    const [{ n }] = entries.splice(at, 1);
+    fs.writeFileSync(file, entries.map((entry) => `${JSON.stringify(entry)}
+`).join(""));
+    if (typeof n !== "number" || n <= 0)
+      return null;
+    startBudget(store, session, agentId, n);
+    return n;
+  } catch {
+    return null;
+  }
+};
+var startBudget = (store, session, agentId, n) => {
+  const dir = budgetDir(store);
+  fs.mkdirSync(dir, { recursive: true });
+  const cutoff = Date.now() - 604800000;
+  for (const name of fs.readdirSync(dir))
+    try {
+      if (fs.statSync(path.join(dir, name)).mtimeMs < cutoff)
+        fs.rmSync(path.join(dir, name));
+    } catch {}
+  const base = agentBase(store, session, agentId);
+  fs.writeFileSync(`${base}.json`, JSON.stringify({ limit: n, told: 0 }));
+  fs.rmSync(`${base}.calls`, { force: true });
+};
+var tickBudget = (cwd, session, agentId) => {
+  try {
+    const store = session ? gitStoreDir2(cwd) : null;
+    if (!store)
+      return false;
+    const base = agentBase(store, session, agentId);
+    const budget = readBudget(`${base}.json`);
+    if (!budget)
+      return false;
+    fs.appendFileSync(`${base}.calls`, ".");
+    return fs.statSync(`${base}.calls`).size >= budget.limit * (budget.told + 1);
+  } catch {
+    return false;
+  }
+};
+var lineFor = (calls) => `Tool-call budget reached (${calls}): commit your work, write your report, stop.`;
+var reachedOf = (cwd, session, agentId) => {
+  const store = session ? gitStoreDir2(cwd) : null;
+  const base = store && agentBase(store, session, agentId);
+  const budget = base && readBudget(`${base}.json`);
+  if (!budget)
+    return null;
+  return { base, budget, reached: Math.floor(fs.statSync(`${base}.calls`).size / budget.limit) };
+};
+var dropBudget = (cwd, session, agentId) => {
+  const store = session ? gitStoreDir2(cwd) : null;
+  if (store)
+    for (const ext of [".json", ".calls"])
+      fs.rmSync(agentBase(store, session, agentId) + ext, { force: true });
+};
+var budgetLine = (cwd, session, agentId) => {
+  try {
+    const at = reachedOf(cwd, session, agentId);
+    if (!at || at.reached <= at.budget.told)
+      return null;
+    fs.writeFileSync(`${at.base}.json`, JSON.stringify({ ...at.budget, told: at.reached }));
+    return lineFor(at.budget.limit * at.reached);
+  } catch {
+    return null;
+  }
+};
+var CODEX_GATED = new Set(["bash", "unifiedexec", "shell", "applypatch", "edit", "write"]);
+var observeHookBudget2 = (payload) => {
+  try {
+    const value = JSON.parse(payload);
+    if (value.hook_event_name !== "PreToolUse" || typeof value.session_id !== "string")
+      return false;
+    const cwd = typeof value.cwd === "string" ? value.cwd : ".";
+    const agentId = typeof value.agent_id === "string" && value.agent_id.trim() ? value.agent_id : null;
+    if (agentId)
+      return tickBudget(cwd, value.session_id, agentId);
+    const tool = typeof value.tool_name === "string" ? value.tool_name : "";
+    const spawn = value.tool_input;
+    if (CODEX_GATED.has(tool.toLowerCase().replace(/[_-]/g, "")) || !spawn || typeof spawn !== "object")
+      return false;
+    const fields = spawn;
+    const prompt = Object.values(fields).find((field) => typeof field === "string" && field.includes("TIMEBOX:"));
+    const type = [fields.agent_type, fields.subagent_type].find((field) => typeof field === "string");
+    if (prompt !== undefined || type !== undefined)
+      noteSpawnBudget(cwd, value.session_id, type ?? null, prompt ?? "");
+    return false;
+  } catch {
+    return false;
+  }
+};
+var budgetHooks2 = {
+  line: (input) => budgetLine(input.cwd, input.session.id ?? "", input.session.agentId),
+  start: (input, agentId, agentType) => void claimSpawnBudget(input.cwd, input.session.id ?? "", agentId, agentType),
+  spawn: (input, spawn) => {
+    if (!input.session.agentId)
+      noteSpawnBudget(input.cwd, input.session.id ?? "", String(spawn.subagent_type || "general-purpose"), String(spawn.prompt ?? ""));
+  },
+  stop: (input, agentId) => {
+    try {
+      dropBudget(input.cwd, input.session.id ?? "", agentId);
+    } catch {}
+  }
+};
+
+export { observeHookBudget2, budgetHooks2 };

package/dist/workit-hook.js

@@ -37,6 +37,7 @@ if (tooOld) {
 var { maybeHeavy, stateDir } = await import("./workit-hook-9pq84bdw.js");
 var { standingPending } = await import("./workit-hook-mk64s4fk.js");
 var { recordHookRun } = await import("./workit-hook-b9ansxvm.js");
+var { observeHookBudget } = await import("./workit-hook-3g6cv3hd.js");
 var payload = "";
 for await (const chunk of process.stdin)
   payload += String(chunk);
@@ -75,13 +76,13 @@ var quietEvent = () => {
     return null;
   }
 };
-var quiet = quietEvent();
+var quiet = observeHookBudget(payload) ? null : quietEvent();
 if (quiet) {
   if (quiet === "PreToolUse")
     recordHookRun(process.env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE === "Codex Desktop" || process.env.CODEX_ELECTRON_RESOURCES_PATH ? "codex_desktop" : "codex_cli", quiet);
   process.stdout.write(`${JSON.stringify({ hookSpecificOutput: { hookEventName: quiet } })}
 `);
 } else {
-  const { runCodexHook } = await import("./workit-hook-7dqgrrwd.js");
+  const { runCodexHook } = await import("./workit-hook-4hyzn1m0.js");
   await runCodexHook([payload]);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-codex",
-  "version": "8.36.0",
+  "version": "8.37.1",
   "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.36.0",
-    "@brainervirus/workit-mcp": "^8.36.0"
+    "@brainervirus/workit-core": "^8.37.1",
+    "@brainervirus/workit-mcp": "^8.37.1"
   },
   "engines": {
     "node": ">=24"