@brainervirus/workit-codex 8.28.0 → 8.28.1

package/.codex-plugin/plugin.json

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

package/dist/launch-mcp.js

@@ -13570,8 +13570,9 @@ function flatOperationJsonSchema(family, options = {}) {
   };
   const properties = { action: { type: "string", enum: actions } };
   const readField = (name) => name === "taskId" || (family === "task" ? READ_TASK_FIELDS.has(name) : family === "policy");
+  const taken = (name) => family === "policy" || actions.some((action) => actionKeys(family, action)?.accepted.has(name));
   for (const [name, field] of Object.entries({ ...COMMON, ...spec.fields }))
-    if (options.readOnly ? readField(name) : !(family === "state" && name === "expectedRevision"))
+    if (options.readOnly ? readField(name) : taken(name))
       properties[name] = property(field);
   return {
     $schema: "https://json-schema.org/draft/2020-12/schema",
@@ -13813,6 +13814,98 @@ function normalizeOperationInput(family, input, host) {
       request[key] = strings(request[key]);
   return request;
 }
+var defOf = (node) => node._zod.def;
+var unwrap = (node) => {
+  let inner = node;
+  while (["optional", "nullable"].includes(defOf(inner).type) && defOf(inner).innerType)
+    inner = defOf(inner).innerType;
+  return inner;
+};
+var FLAT_NAME = {
+  authorityRefs: "refs",
+  contentRefs: "refs",
+  statedChoice: "choice",
+  reviewContext: "reviewSession"
+};
+var NOT_FLAT = new Set(["schemaVersion", "action", "workspaceId"]);
+function actionKeys(family, action) {
+  const options = advertisedOperationSchemas[family].options;
+  const option = options.find((item) => {
+    const literal = defOf(item).shape?.action;
+    return literal._zod.def.values.includes(action);
+  });
+  if (!option)
+    return null;
+  const out = { accepted: new Set, required: [] };
+  const walk = (shape, nested) => {
+    for (const [key, node] of Object.entries(shape)) {
+      if (NOT_FLAT.has(key) || nested && key === "taskId")
+        continue;
+      const inner = unwrap(node);
+      const type = defOf(inner).type;
+      const needed = !["optional", "nullable"].includes(defOf(node).type);
+      if (key === "scope")
+        for (const name of ["scope", "paths", "exclusions"])
+          out.accepted.add(name);
+      else if (type === "object" && key !== "bundle" && !(key in FLAT_NAME)) {
+        out.accepted.add(key);
+        walk(defOf(inner).shape, true);
+      } else {
+        const name = FLAT_NAME[key] ?? key;
+        out.accepted.add(name);
+        if (needed && type !== "array" && type !== "record" && !out.required.includes(name))
+          out.required.push(name);
+      }
+    }
+  };
+  walk(defOf(option).shape, false);
+  return out;
+}
+function exampleOperation(family, action) {
+  const keys = actionKeys(family, action);
+  const example = { action };
+  for (const name of keys?.required ?? [])
+    example[name] = FLAT[family].fields[name]?.enum?.[0] ?? `<${name}>`;
+  if (family === "policy" && !keys?.required.length && action !== "explain")
+    example.riskTier = "normal";
+  return example;
+}
+var oneOf = (values) => values.join(" | ");
+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)}` }]
+    });
+  const own = actionKeys(family, action);
+  const fields = [];
+  const sentence = [];
+  for (const issue of error.issues) {
+    if (issue.code === "unrecognized_keys") {
+      for (const key of issue.keys) {
+        const home = actions.find((other) => other !== action && actionKeys(family, other).accepted.has(key));
+        const reason = home ? `${key} belongs to action: ${home}` : `${key} is not a field of ${family} ${action}; it takes ${[...own.accepted].join(", ")}`;
+        fields.push({ path: key, reason });
+        sentence.push(reason);
+      }
+      continue;
+    }
+    const last = String(issue.path.at(-1) ?? "");
+    const name = Object.entries(FLAT_NAME).find(([contract]) => contract === last)?.[1] ?? last;
+    const missing = issue.code === "invalid_type" && /received undefined/.test(issue.message);
+    const absent = own.required.filter((key) => !(key in request));
+    const needs = missing && issue.path.length === 1 && absent.length ? absent.join(", ") : name;
+    const reason = missing ? `${family} ${action} requires ${needs}` : `${name}: ${issue.message}`;
+    fields.push({ path: issue.path.join("."), reason });
+    sentence.push(reason);
+  }
+  const example = JSON.stringify(exampleOperation(family, action));
+  return failure2("invalid_input", `${[...new Set(sentence)].join("; ")}. Example: ${example}`, {
+    fields
+  });
+}
 function parseAdvertisedOperation(family, input, host) {
   const request = normalizeOperationInput(family, input, host);
   if (isObject2(request) && request.schemaVersion !== SCHEMA_VERSION)
@@ -13820,12 +13913,7 @@ function parseAdvertisedOperation(family, input, host) {
   const parsed = advertisedOperationSchemas[family].safeParse(request);
   if (parsed.success)
     return success(null, null, request);
-  return failure2("invalid_input", "operation input is invalid", {
-    fields: parsed.error.issues.map((issue) => ({
-      path: issue.code === "unrecognized_keys" ? issue.keys.join(".") : issue.path.join("."),
-      reason: issue.message
-    }))
-  });
+  return invalidOperation(family, request, parsed.error);
 }
 // packages/workit-core/src/core/task-store.ts
 import { createHash as createHash8, randomUUID as randomUUID3 } from "node:crypto";

package/dist/{workit-hook-ahdnhfdm.js → workit-hook-0vzd6e1j.js}

@@ -1,4 +1,11 @@
 #!/usr/bin/env node
+import {
+  gitStoreDir2,
+  standingSeenFile2,
+  readStandingRev2,
+  readStandingSeen2,
+  writeStandingSeen2
+} from "./workit-hook-jy7y0gdx.js";
 import {
   CHECKS_FILE,
   repoHeavyCommands,
@@ -6,13 +13,8 @@ import {
   matchesNamedCheck,
   gateCheckNames,
   checkCommand,
-  maybeHeavy,
-  gitStoreDir,
-  standingSeenFile,
-  readStandingRev,
-  readStandingSeen,
-  writeStandingSeen
-} from "./workit-hook-vhz9yrcw.js";
+  maybeHeavy2
+} from "./workit-hook-2m8a4m5j.js";
 // packages/workit-core/src/hooks/descriptor.ts
 var support = (descriptor, axis) => {
   if (axis.startsWith("event:"))
@@ -9599,11 +9601,16 @@ var branchPolicySnapshotFor = (workspaceRoot) => {
     fingerprint
   };
 };
+var rethrowRuntimeBug = (error) => {
+  if (error instanceof TypeError || error instanceof ReferenceError)
+    throw error;
+};
 var validateBranchNameFor = (workspaceRoot, name) => {
   try {
     const resolved = branchPolicySnapshotFor(workspaceRoot);
     return validateBranchNamePolicy(name, resolved.namePolicy, resolved.source);
   } catch (error) {
+    rethrowRuntimeBug(error);
     const correction = "repair or select a valid workspace policy before creating a branch";
     return {
       ok: false,
@@ -15224,6 +15231,7 @@ function normalizeOperationInput(family, input, host) {
       request[key] = strings(request[key]);
   return request;
 }
+var NOT_FLAT = new Set(["schemaVersion", "action", "workspaceId"]);
 
 // packages/workit-core/src/core/policy/judgment.ts
 var isObject6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -20520,7 +20528,7 @@ var rulesFor = (host, cwd, env) => {
 function heavyGate(cwd, command, options) {
   const env = options.env ?? process.env;
   try {
-    if (env.WORKIT_HEAVY_GATE === "0" || !maybeHeavy(command, cwd, env) || !workitOnPath(env))
+    if (env.WORKIT_HEAVY_GATE === "0" || !maybeHeavy2(command, cwd, env) || !workitOnPath(env))
       return { kind: "none" };
     return heavyPlan(command, {
       cwd,
@@ -21899,11 +21907,11 @@ var standingFor = (input, store, rev) => {
   return { rev, orders, rows };
 };
 var located = (input) => {
-  const store = input.session.id ? gitStoreDir(input.cwd) : null;
-  const rev = store ? readStandingRev(store) : null;
+  const store = input.session.id ? gitStoreDir2(input.cwd) : null;
+  const rev = store ? readStandingRev2(store) : null;
   if (!store || rev === null)
     return null;
-  return { store, rev, file: standingSeenFile(store, input.session.id, input.session.agentId) };
+  return { store, rev, file: standingSeenFile2(store, input.session.id, input.session.agentId) };
 };
 var seedStanding = (input) => {
   try {
@@ -21911,7 +21919,7 @@ var seedStanding = (input) => {
     if (!where)
       return;
     const now = standingFor(input, where.store, where.rev);
-    writeStandingSeen(where.file, { rev: where.rev, ids: [...now.orders.keys()] });
+    writeStandingSeen2(where.file, { rev: where.rev, ids: [...now.orders.keys()] });
   } catch {}
 };
 var fanoutOf = (row) => typeof row.fanout === "string" ? row.fanout : "?";
@@ -21938,11 +21946,11 @@ var standingDelta = (input) => {
     const where = located(input);
     if (!where)
       return null;
-    const seen = readStandingSeen(where.file);
+    const seen = readStandingSeen2(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()] });
+    writeStandingSeen2(where.file, { rev: where.rev, ids: [...now.orders.keys()] });
     return changedSince(now, seen.ids);
   } catch {
     return null;

package/dist/workit-hook-27bwpc4a.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import {
+  stateDir2,
+  maybeHeavy2
+} from "./workit-hook-2m8a4m5j.js";
+export {
+  maybeHeavy2 as maybeHeavy,
+  stateDir2 as stateDir
+};

package/dist/{workit-hook-vhz9yrcw.js → workit-hook-2m8a4m5j.js}

@@ -235,7 +235,7 @@ function checkCommand(args, version, onPath = workitAvailable()) {
 // packages/workit-core/src/core/heavy-words.ts
 var HEAVY_WORDS = new Set(("npm npx pnpm pnpx yarn bun bunx deno corepack make gmake docker podman nerdctl " + "python python3 py uv poetry pdm pipenv hatch rye bundle rake nx " + "jest vitest mocha ava tap karma jasmine nyc c8 tsc vue-tsc svelte-check eslint stylelint " + "tslint webpack webpack-cli rollup parcel tsup vite next nuxt nuxi astro ng react-scripts " + "playwright cypress wdio testcafe turbo lerna sonar-scanner sonarless sonarless-mcp go " + "golangci-lint gotestsum staticcheck cargo mvn mvnw gradle gradlew ant sbt bazel bazelisk " + "buck2 dotnet msbuild pytest py.test tox nox mypy pyright pylint coverage maturin pip pip3 " + "rspec rails phpunit pest phpstan psalm composer mix swift xcodebuild flutter dart pod cmake " + "ninja meson ctest scons docker-compose buildah earthly").split(" "));
 var wordsOf = (command) => command.split(/[\s;&|()<>`'"]+/u).map((word) => (word.split(/[\\/]/u).at(-1) ?? "").toLowerCase().replace(/\.(?:exe|cmd|bat)$/u, "")).filter(Boolean);
-var stateDir = (env) => {
+var stateDir2 = (env) => {
   if (env.WORKFLOW_TOOLKIT_STATE)
     return env.WORKFLOW_TOOLKIT_STATE;
   if (env.XDG_STATE_HOME)
@@ -256,7 +256,7 @@ var readJson = (file) => {
 };
 var patternWords = (cwd, env) => {
   const patterns = [];
-  const machine = readJson(path2.join(stateDir(env), "heavy-commands.json"));
+  const machine = readJson(path2.join(stateDir2(env), "heavy-commands.json"));
   if (Array.isArray(machine?.patterns))
     patterns.push(...machine.patterns);
   for (let dir = path2.resolve(cwd);; dir = path2.dirname(dir)) {
@@ -278,7 +278,7 @@ var patternWords = (cwd, env) => {
   }
   return words;
 };
-function maybeHeavy(command, cwd, env = process.env) {
+function maybeHeavy2(command, cwd, env = process.env) {
   try {
     const words = wordsOf(command);
     if (words.some((word) => HEAVY_WORDS.has(word) || /^python[\d.]*$/u.test(word)))
@@ -290,64 +290,4 @@ function maybeHeavy(command, cwd, env = process.env) {
   }
 }
 
-// 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 };
+export { CHECKS_FILE, repoHeavyCommands, loadCheckConfig, matchesNamedCheck, gateCheckNames, checkCommand, stateDir2, maybeHeavy2 };

package/dist/workit-hook-jy7y0gdx.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+// packages/workit-core/src/hooks/standing-signal.ts
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+var gitStoreDir2 = (cwd) => {
+  try {
+    for (let dir = path.resolve(cwd);; dir = path.dirname(dir)) {
+      const dotGit = path.join(dir, ".git");
+      if (fs.existsSync(dotGit)) {
+        let gitDir = dotGit;
+        if (fs.statSync(dotGit).isFile()) {
+          const target = /^gitdir:\s*(.+)$/mu.exec(fs.readFileSync(dotGit, "utf8"))?.[1]?.trim();
+          if (!target)
+            return null;
+          gitDir = path.resolve(dir, target);
+          const common = path.join(gitDir, "commondir");
+          if (fs.existsSync(common))
+            gitDir = path.resolve(gitDir, fs.readFileSync(common, "utf8").trim());
+        }
+        return path.join(gitDir, "workit");
+      }
+      if (path.dirname(dir) === dir)
+        return null;
+    }
+  } catch {
+    return null;
+  }
+};
+var standingRevFile = (store) => path.join(store, "standing", "rev");
+var standingSeenFile2 = (store, session, agentId) => path.join(store, "standing", "seen", `${createHash("sha256").update(`${session}\x00${agentId ?? ""}`).digest("hex").slice(0, 32)}.json`);
+var readStandingRev2 = (store) => {
+  try {
+    return fs.readFileSync(standingRevFile(store), "utf8").trim() || null;
+  } catch {
+    return null;
+  }
+};
+var readStandingSeen2 = (file) => {
+  try {
+    const value = JSON.parse(fs.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 writeStandingSeen2 = (file, seen) => {
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(seen));
+  } catch {}
+};
+var bumpStandingRev2 = (store, rev) => {
+  try {
+    fs.mkdirSync(path.join(store, "standing"), { recursive: true });
+    fs.writeFileSync(standingRevFile(store), `${rev}
+`);
+  } catch {}
+};
+var standingPending2 = (cwd, session, agentId) => {
+  const store = gitStoreDir2(cwd);
+  const rev = store ? readStandingRev2(store) : null;
+  return rev !== null && readStandingSeen2(standingSeenFile2(store, session, agentId)).rev !== rev;
+};
+
+export { gitStoreDir2, standingSeenFile2, readStandingRev2, readStandingSeen2, writeStandingSeen2, bumpStandingRev2, standingPending2 };

package/dist/workit-hook-mk64s4fk.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import {
+  gitStoreDir2,
+  standingSeenFile2,
+  readStandingRev2,
+  readStandingSeen2,
+  writeStandingSeen2,
+  bumpStandingRev2,
+  standingPending2
+} from "./workit-hook-jy7y0gdx.js";
+export {
+  bumpStandingRev2 as bumpStandingRev,
+  gitStoreDir2 as gitStoreDir,
+  readStandingRev2 as readStandingRev,
+  readStandingSeen2 as readStandingSeen,
+  standingPending2 as standingPending,
+  standingSeenFile2 as standingSeenFile,
+  writeStandingSeen2 as writeStandingSeen
+};

package/dist/workit-hook.js

@@ -1,11 +1,41 @@
 #!/usr/bin/env node
-import {
-  stateDir,
-  maybeHeavy,
-  standingPending
-} from "./workit-hook-vhz9yrcw.js";
 
 // packages/workit-codex/hooks/launcher.ts
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var nodeFloorMessage = () => {
+  try {
+    const found = process.env.WORKIT_HOOK_NODE_VERSION || process.versions.node;
+    const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+    const range = JSON.parse(readFileSync(path.join(root, "package.json"), "utf8")).engines?.node;
+    const min = /^>=\s*(\d+)(?:\.(\d+))?(?:\.(\d+))?/.exec(String(range ?? ""));
+    if (!min)
+      return null;
+    const need = [min[1], min[2] ?? 0, min[3] ?? 0].map(Number);
+    const have = String(found).replace(/^v/, "").split(".").map(Number);
+    for (let i = 0;i < 3; i++) {
+      const a = have[i] ?? 0;
+      if (Number.isNaN(a))
+        return null;
+      if (a !== need[i])
+        return a < need[i] ? `needs Node ${range}, found ${found}` : null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+};
+var tooOld = nodeFloorMessage();
+if (tooOld) {
+  process.stderr.write(`[workit] Codex hook unavailable: ${tooOld}
+`);
+  process.stdout.write(`{}
+`);
+  process.exit(0);
+}
+var { maybeHeavy, stateDir } = await import("./workit-hook-27bwpc4a.js");
+var { standingPending } = await import("./workit-hook-mk64s4fk.js");
 var payload = "";
 for await (const chunk of process.stdin)
   payload += String(chunk);
@@ -49,6 +79,6 @@ if (quiet)
   process.stdout.write(`${JSON.stringify({ hookSpecificOutput: { hookEventName: quiet } })}
 `);
 else {
-  const { runCodexHook } = await import("./workit-hook-ahdnhfdm.js");
+  const { runCodexHook } = await import("./workit-hook-0vzd6e1j.js");
   await runCodexHook([payload]);
 }

package/package.json

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