@brainervirus/workit-codex 8.32.0 → 8.33.0

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "workit",
-  "version": "8.32.0",
+  "version": "8.33.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-pmdzgzzk.js → workit-hook-kcvskw9d.js}

@@ -17628,7 +17628,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 +17651,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 +17697,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 +22590,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 +23401,7 @@ var codexAdapter = {
         },
         permissionMode: input.permission_mode,
         transcriptPath: input.transcript_path,
+        model: input.model,
         event: protocolEvent(input)
       }
     };

package/dist/workit-hook.js

@@ -79,6 +79,6 @@ if (quiet)
   process.stdout.write(`${JSON.stringify({ hookSpecificOutput: { hookEventName: quiet } })}
 `);
 else {
-  const { runCodexHook } = await import("./workit-hook-pmdzgzzk.js");
+  const { runCodexHook } = await import("./workit-hook-kcvskw9d.js");
   await runCodexHook([payload]);
 }

package/package.json

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