@brainervirus/workit-codex 8.32.0 → 8.34.0

package/.codex-plugin/plugin.json

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

package/dist/launch-mcp.js

@@ -13875,10 +13875,11 @@ function invalidOperation(family, input, error) {
   const request = isObject2(input) ? input : {};
   const action = typeof request.action === "string" ? request.action : "";
   const actions = OPERATION_ACTIONS[family];
-  if (!actions.includes(action))
-    return failure2("invalid_input", `${family}: action must be one of ${oneOf(actions)}`, {
-      fields: [{ path: "action", reason: `got ${JSON.stringify(request.action ?? null)}` }]
-    });
+  if (!actions.includes(action)) {
+    const common = actions.find((name) => READ_ONLY_ACTIONS.has(name)) ?? actions[0];
+    const example = JSON.stringify(exampleOperation(family, common));
+    return failure2("invalid_input", `${family}: action must be one of ${oneOf(actions)}. Example: ${example}`, { fields: [{ path: "action", reason: `got ${JSON.stringify(request.action ?? null)}` }] });
+  }
   const own = actionKeys(family, action);
   const fields = [];
   const sentence = [];
@@ -27770,6 +27771,40 @@ class StdioServerTransport {
 
 // packages/workit-mcp/src/server.ts
 import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// packages/workit-core/src/hooks/repeat-failure.ts
+import { createHash as createHash11 } from "node:crypto";
+var SAME_CALL_FAILED = "Same call failed twice:";
+var MAX_SESSIONS = 256;
+var stable = (value) => JSON.stringify(value, (_key, entry) => entry && typeof entry === "object" && !Array.isArray(entry) ? Object.fromEntries(Object.entries(entry).toSorted(([a], [b]) => a.localeCompare(b))) : entry) ?? "null";
+var hashOf = (call) => createHash11("sha256").update(call).digest("hex").slice(0, 32);
+var record3 = (memo, sessionId, call, failed, next) => {
+  const previous = memo.get(sessionId);
+  memo.delete(sessionId);
+  if (!failed)
+    return null;
+  const hash = hashOf(call);
+  memo.set(sessionId, hash);
+  if (memo.size > MAX_SESSIONS)
+    memo.delete(memo.keys().next().value);
+  return previous === hash && next ? `${SAME_CALL_FAILED} ${next}` : null;
+};
+var isFailure = (result) => result !== null && typeof result === "object" && result.ok === false && typeof result.error === "string";
+var correctedPayload = (tool, result) => {
+  const example = /Example: (\{.*\})\s*$/.exec(result.error)?.[1];
+  if (example)
+    return `${tool} ${example}`;
+  const guidance = result.details?.guidance;
+  return typeof guidance === "string" && guidance ? guidance : null;
+};
+var escalateToolFailure = (memo, sessionId, tool, input, result) => {
+  const failed = isFailure(result);
+  const line = record3(memo, sessionId, `tool\x00${tool}\x00${stable(input)}`, failed, failed ? correctedPayload(tool, result) : null);
+  return line && failed ? { ...result, error: `${result.error}
+${line}` } : result;
+};
+
+// packages/workit-mcp/src/server.ts
 class McpCapabilityUnavailableError extends Error {
   capability;
   constructor(capability) {
@@ -27864,8 +27899,8 @@ var sanitizeFailure = (result, workspaceRoot) => {
   };
   return sanitize(result);
 };
-var resultForClient = (result, workspaceRoot) => {
-  const safe = sanitizeFailure(result, workspaceRoot);
+var resultForClient = (result, workspaceRoot, escalate = (safe) => safe) => {
+  const safe = escalate(sanitizeFailure(result, workspaceRoot));
   return {
     content: [{ type: "text", text: JSON.stringify(safe) }],
     structuredContent: safe,
@@ -27902,6 +27937,7 @@ function createMcpServer(host, contextProvider) {
     path23.join(here, "..", "..", "workit-core", "src", "core", "task-engine.ts")
   ].filter((file) => existsSync9(file)));
   let staleWarned = false;
+  const failures = new Map;
   const server = new Server({ name: "workit", version: VERSION }, { capabilities: { tools: {}, resources: {} } });
   server.setRequestHandler(ListToolsRequestSchema, async () => {
     let attested = false;
@@ -28024,9 +28060,10 @@ function createMcpServer(host, contextProvider) {
           details: { operation: family }
         }, workspaceRoot);
       }
+      const escalate = (safe) => escalateToolFailure(failures, context.caller.actor || "mcp", toolName, request.params.arguments, safe);
       const parsed = parseAdvertisedOperation(family, request.params.arguments, host);
       if (!parsed.ok)
-        return resultForClient(parsed, workspaceRoot);
+        return resultForClient(parsed, workspaceRoot, escalate);
       if (context.callerAttested !== true && requiresCallerIdentity(parsed.data))
         return resultForClient({
           ok: false,
@@ -28038,7 +28075,7 @@ function createMcpServer(host, contextProvider) {
       const core = new WorkitCore(new TaskStore(context.root), context);
       const run = core[family];
       const result = run.call(core, parsed.data);
-      return resultForClient(family === "task" && context.callerAttested !== true ? briefInspectResult(parsed.data, result) : result, workspaceRoot);
+      return resultForClient(family === "task" && context.callerAttested !== true ? briefInspectResult(parsed.data, result) : result, workspaceRoot, escalate);
     } catch (error) {
       return thrownResult(toolName, error, workspaceRoot);
     }

package/dist/workit-hook-b9ansxvm.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import {
+  recordHookRun2
+} from "./workit-hook-w6s3hcyz.js";
+import"./workit-hook-eaahdgen.js";
+export {
+  recordHookRun2 as recordHookRun
+};

package/dist/{workit-hook-pmdzgzzk.js → workit-hook-h4ryf1zq.js}

@@ -15,6 +15,9 @@ import {
   checkCommand,
   maybeHeavy2
 } from "./workit-hook-eaahdgen.js";
+import {
+  recordHookRun2
+} from "./workit-hook-w6s3hcyz.js";
 // packages/workit-core/src/hooks/descriptor.ts
 var support = (descriptor, axis) => {
   if (axis.startsWith("event:"))
@@ -17628,7 +17631,14 @@ var sessionMarkerFile = (input, session, store) => {
   return path19.join(dir, "hooks", `skills-${name}.json`);
 };
 var list2 = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
-var EMPTY = { nudged: [], loaded: [], raw: [], stops: [], judges: [] };
+var EMPTY = {
+  nudged: [],
+  loaded: [],
+  raw: [],
+  stops: [],
+  judges: [],
+  model: null
+};
 var readRaw = (file) => {
   try {
     return fs14.readFileSync(file, "utf8");
@@ -17644,7 +17654,8 @@ var parseMarker = (text) => {
       loaded: list2(value.loaded),
       raw: list2(value.raw),
       stops: list2(value.stops),
-      judges: list2(value.judges)
+      judges: list2(value.judges),
+      model: typeof value.model === "string" ? value.model : null
     };
   } catch {
     return { ...EMPTY };
@@ -17689,6 +17700,18 @@ var trackJudge = (input, agentId, running) => {
     return { ...marker, judges: running ? [...rest, agentId] : rest };
   });
 };
+var modelSwitchedOnDisk = (input) => {
+  const session = input.session.id;
+  const model = input.model;
+  const file = session && model ? sessionMarkerFile(input, session) : null;
+  if (!file || !model)
+    return false;
+  const previous = readSessionMarker(file).model;
+  if (previous === model)
+    return false;
+  updateSessionMarker(file, (marker) => ({ ...marker, model }));
+  return previous !== null;
+};
 
 // packages/workit-core/src/hooks/shell-words.ts
 class ShellAnalysisError extends Error {
@@ -22570,7 +22593,9 @@ function decide(input, deps) {
       if (!usable2(descriptor.context.perTurn))
         return NONE6;
       const current = turnContextText(input, descriptor);
-      const text = resendsOnChange(descriptor) ? changedTurnContext(input, current) : current;
+      const turn = resendsOnChange(descriptor) ? changedTurnContext(input, current) : current;
+      const text = input.model && modelSwitchedOnDisk(input) ? [invariantBootstrap(), turn].filter(Boolean).join(`
+`) : turn;
       return withContextLine(text ? { kind: "context", text } : NONE6, promptNudge(input, event.prompt));
     }
     case "shell.pre": {
@@ -23379,6 +23404,7 @@ var codexAdapter = {
         },
         permissionMode: input.permission_mode,
         transcriptPath: input.transcript_path,
+        model: input.model,
         event: protocolEvent(input)
       }
     };
@@ -23707,6 +23733,8 @@ async function runHookProcess(host, stdin, stdout, stderr = process.stderr, env
   } catch {
     raw = undefined;
   }
+  const native = raw?.hook_event_name;
+  recordHookRun2(typeof host === "string" ? host : adapter.descriptor.host, typeof native === "string" ? native : null, env);
   const result = text === null ? skippedHook(adapter, undefined, env, budget, "input") : await dispatchWithin(adapter, raw, env, budget, deadline.dispatch);
   if (result.skipped)
     stderr.write(`[workit] ${result.error}

package/dist/workit-hook-w6s3hcyz.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import {
+  stateDir2
+} from "./workit-hook-eaahdgen.js";
+
+// packages/workit-core/src/hooks/hook-runs.ts
+import { mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+var HOOK_RUNS_DIR = "hook-runs";
+var safe = (part) => part.replace(/[^A-Za-z0-9_.-]/g, "-").slice(0, 64);
+var runFile = (dir, host, event) => path.join(dir, HOOK_RUNS_DIR, `${safe(host)}__${safe(event)}.json`);
+var recordHookRun2 = (host, event, env = process.env, now = Date.now) => {
+  if (!event)
+    return;
+  try {
+    const dir = stateDir2(env);
+    const file = runFile(dir, host, event);
+    let count = 0;
+    try {
+      const previous = JSON.parse(readFileSync(file, "utf8"));
+      if (typeof previous.count === "number" && Number.isFinite(previous.count))
+        count = previous.count;
+    } catch {}
+    const row = {
+      host,
+      event,
+      at: new Date(now()).toISOString(),
+      count: count + 1
+    };
+    try {
+      writeFileSync(file, JSON.stringify(row));
+    } catch {
+      mkdirSync(path.dirname(file), { recursive: true });
+      writeFileSync(file, JSON.stringify(row));
+    }
+  } catch {}
+};
+export { recordHookRun2 };

package/dist/workit-hook.js

@@ -36,6 +36,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 payload = "";
 for await (const chunk of process.stdin)
   payload += String(chunk);
@@ -75,10 +76,12 @@ var quietEvent = () => {
   }
 };
 var quiet = quietEvent();
-if (quiet)
+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-pmdzgzzk.js");
+} else {
+  const { runCodexHook } = await import("./workit-hook-h4ryf1zq.js");
   await runCodexHook([payload]);
 }

package/package.json

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