@brainervirus/workit-codex 8.29.0 → 8.29.1

package/.codex-plugin/plugin.json

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

package/agents/workit-reviewer.toml

@@ -17,9 +17,8 @@ description of it. Follow the workit-review skill (`$workit-review`).
 4. Each finding: file:line, severity (blocker, major, minor, nit), evidence
    (hunk, test or command output), concrete fix.
 5. Record the verdict:
-   start from the exact verdict command the SubagentStart hook put in your context (it
-   carries your session and `--token=<token>`; the token is yours alone: never put it in a report); it already names `--kind review`:
-   `workit ledger verdict verified|failed|blocked --kind review --branch <b> --session <id> --token=<token> --how "<what you read and ran>"`
+   start from the exact verdict command the SubagentStart hook put in your context (it names no --session or --token: your shell already acts as your own session); it already names `--kind review`:
+   `workit ledger verdict verified|failed|blocked --kind review --branch <b> --how "<what you read and ran>"`
    (`verified` with `--kind review`: no blocker or major finding left).
    Record a design choice you had to make as `workit ledger ruling`.
 

package/agents/workit-verifier.toml

@@ -20,10 +20,8 @@ it.
 5. Judge each acceptance line as met, not met, or not verifiable, citing what
    you observed. Label every claim measured, inferred or guess.
 6. Record the verdict, then report it:
-   start from the exact verdict command the SubagentStart hook put in your context (it
-   carries your session and `--token=<token>`; you share the lead's
-   `WORKIT_SESSION_ID`, which authored the work) and pick its `--kind <live|unit>`:
-   `workit ledger verdict verified|tests-verified|type-check-only|failed|blocked --kind <live|unit> --branch <b> --session <id> --token=<token> --how "<what you ran and saw>"`.
+   start from the exact verdict command the SubagentStart hook put in your context (it names no --session or --token: your shell already acts as your own session, never set WORKIT_SESSION_ID) and pick its `--kind <live|unit>`:
+   `workit ledger verdict verified|tests-verified|type-check-only|failed|blocked --kind <live|unit> --branch <b> --how "<what you ran and saw>"`.
    `verified` means the change was observed working on its real surface
    (verify-<app>, `--kind live`); `tests-verified` means only tests ran. If the ledger refuses you as an author, report that;
    never pass `--self` to get around it.

package/dist/launch-mcp.js

@@ -22221,6 +22221,7 @@ var LAUNCHERS = new Set([
   "command"
 ]);
 var PACKAGE_RUNNERS = new Set(["npx", "bunx", "pnpx"]);
+var OUTPUT_FILTERS = new Set(["tail", "head", "grep"]);
 var PUSH_VALUE_OPTIONS = new Set(["-o", "--push-option", "--receive-pack", "--exec", "--repo"]);
 var VALUE_OPTIONS = {
   git: new Set([

package/dist/{workit-hook-y685rj7k.js → workit-hook-q91d0376.js}

@@ -18675,17 +18675,22 @@ function workitCheckTail(words) {
     return null;
   return args.slice(0, split).includes("--shell") ? { script: tail.join(" "), cwd } : { argv: tail, cwd };
 }
-function simpleCommand(command, dialect = "posix", depth = 0) {
+var OUTPUT_FILTERS = new Set(["tail", "head", "grep"]);
+function simpleCommand(command, dialect = "posix", depth = 0, shaped = false) {
   let segments;
   try {
     segments = segmentsOf(command, dialect);
   } catch {
     return null;
   }
-  if (segments.length !== 1)
+  const filter = shaped && segments.length === 2 ? segments[1] : null;
+  if (filter) {
+    if (!segments[0].pipe || !OUTPUT_FILTERS.has(commandName(filter.words[0])) || filter.group || filter.pipe || filter.unanalyzable || filter.subs?.length || filter.stdin?.length)
+      return null;
+  } else if (segments.length !== 1)
     return null;
   const [segment] = segments;
-  if (segment.group || segment.pipe || segment.unanalyzable || segment.redirects.length || segment.subs?.length || segment.stdin?.length)
+  if (segment.group || segment.pipe && !filter || segment.unanalyzable || segment.redirects.length && !shaped || segment.subs?.length || segment.stdin?.length)
     return null;
   const { words } = stripPrefixes(segment.words);
   const name = commandName(words[0]);
@@ -20460,7 +20465,7 @@ function heavyPlan(command, options) {
   const heavy = heavyLines(lines, options);
   if (!heavy.length)
     return { kind: "none" };
-  const simple = simpleCommand(command, dialect);
+  const simple = simpleCommand(command, dialect, 0, true);
   const single = simple && !WORKIT.test(baseName2(simple[0])) && heavyLines([simple], options)[0];
   const judged = single ? [{ words: lines.flat(), text: command }] : heavy.map((match) => ({
     words: match.line,
@@ -20472,7 +20477,7 @@ function heavyPlan(command, options) {
       if (!verdict.ok)
         return {
           kind: "passthrough",
-          note: `workit: \`${command.trim()}\` is heavy but runs outside the heavy-check lease because a host permission rule names it (or \`workit\` is allowlisted); the host decides.`
+          note: ""
         };
     }
   if (single) {
@@ -20482,7 +20487,7 @@ function heavyPlan(command, options) {
   const parts = heavy.map((match) => leaseCommand(match.line));
   return {
     kind: "split",
-    reason: `heavy_command: \`${command.trim()}\` chains heavy work (${heavy.map((match) => match.reason).join("; ")}) with other commands, and a chain cannot run under the machine-wide heavy-check lease. Run each heavy part alone as \`workit check --heavy -- <segment>\` (here: ${parts.map((part) => `\`${part}\``).join("; ")}); run the other parts as their own commands.`,
+    reason: `heavy_command: \`${command.trim()}\` chains heavy work (${heavy.map((match) => match.reason).join("; ")}) with other commands, and a chain cannot run under the machine-wide heavy-check lease. Run the heavy part alone, now: \`${parts[0]}\`; then run the other parts as their own commands${parts.length > 1 ? ", each heavy one the same way" : ""}.`,
     unblock: parts[0] ?? null
   };
 }
@@ -22431,12 +22436,15 @@ ${subagentStartText({ ...input, cwd: "" }, descriptor, event)}`;
     return readOnly;
   const own = subagentSession(session, event.agentId);
   const cwd = input.cwd || process.cwd();
+  const judge = event.agentType.endsWith("reviewer") ? "reviewer" : "verifier";
+  const pick = judge === "verifier" ? ", --kind live when you drove the real surface" : "";
+  const branch = judgeBranch(cwd);
+  if (descriptor.host === "codex_cli" || descriptor.host === "codex_desktop")
+    return `${readOnly} Its shell already acts as its own Workit session, 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): \`${verdictCommand({ branch, judge })}\`. Add no session or token option to it, and never set WORKIT_SESSION_ID by hand.`;
   const token = session ? recordIssuedSession(cwd, session, own) : null;
   if (session && !token)
     return `${readOnly} ${own} was already issued to an earlier subagent, so no token is handed out again and a verdict under it would be refused (unbound_session). Record no verdict as ${own}: spawn a fresh verifier or reviewer, which gets its own session and token.`;
-  const judge = event.agentType.endsWith("reviewer") ? "reviewer" : "verifier";
-  const line = verdictCommand({ branch: judgeBranch(cwd), judge, session: own, token });
-  const pick = judge === "verifier" ? ", --kind live when you drove the real surface" : "";
+  const line = verdictCommand({ branch, judge, session: own, token });
   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"]);

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-y685rj7k.js");
+  const { runCodexHook } = await import("./workit-hook-q91d0376.js");
   await runCodexHook([payload]);
 }

package/package.json

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