@jphutchins/code-review 0.1.0-alpha.18 → 0.1.0-alpha.19

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from 'citty';
-import { readFileSync, writeFileSync, readdirSync } from 'fs';
+import { readFileSync, writeFileSync, statSync, readdirSync } from 'fs';
 import { resolve as resolve$1, join, dirname, basename } from 'path';
 import { Eta } from 'eta';
 import parseDiff from 'parse-diff';
@@ -765,7 +765,7 @@ var timeClause = (i) => i.elapsedMs === null ? null : i.wallMs !== null && i.wal
 var directive = (phase, draftPath, isSubagent) => {
   if (isSubagent)
     return phase.kind === "hard" ? `Budget nearly exhausted \u2014 STOP all new investigation now and report the findings you have back to the main agent in your reply. Do not write ${draftPath} yourself; only the main agent writes it.` : `Wind down investigation and report the findings you have back to the main agent in your reply \u2014 do not write ${draftPath} yourself; the main agent writes it, and you may run out of budget otherwise.`;
-  return phase.kind === "hard" ? `Budget nearly exhausted \u2014 STOP all new investigation now. Write your COMPLETE findings to ${draftPath} and run \`code-review validate ${draftPath} --explain\` until it passes (--explain prints the exact schema when the shape is wrong). Other tools are blocked until that draft is written.` : `Wind down investigation and write your COMPLETE findings to ${draftPath} now, then run \`code-review validate ${draftPath} --explain\` (it prints the exact schema if the shape is wrong) \u2014 you may run out of budget before you finish otherwise.`;
+  return phase.kind === "hard" ? `Budget nearly exhausted \u2014 STOP all new investigation now. Do not wait for subagents still running in the background. Write your COMPLETE findings from what you already have to ${draftPath} and run \`code-review validate ${draftPath} --explain\` until it passes (--explain prints the exact schema when the shape is wrong). Other tools are blocked until that draft is written.` : `Wind down investigation and write your COMPLETE findings to ${draftPath} now, then run \`code-review validate ${draftPath} --explain\` (it prints the exact schema if the shape is wrong) \u2014 fold in the subagent reports you already have rather than waiting on stragglers; you may run out of budget before you finish otherwise.`;
 };
 var budgetMessage = (i, phase, draftPath, isSubagent) => {
   const status = [spendClause(i), timeClause(i)].filter((c) => c !== null).join(" \xB7 ");
@@ -804,6 +804,16 @@ var writesToDraft = (toolName, toolInput, draftPath) => {
   return false;
 };
 var singleWriterMessage = (draftPath) => `Only the main agent may write ${draftPath}. When a subagent writes it too, the concurrent writers clobber each other and the review comes out empty. Do NOT write, edit, or redirect into ${draftPath} \u2014 instead, return the findings you discovered in your reply (the field names are in the schema); the main agent collects every subagent's reported findings and writes the draft itself.`;
+var seedMarkerPath = (draftPath) => `${draftPath}.seed`;
+var mainHasWrittenDraft = (draftMtimeMs, seedMarkerMtimeMs) => draftMtimeMs !== null && (seedMarkerMtimeMs === null || draftMtimeMs > seedMarkerMtimeMs);
+var spawnFloorMessage = (draftPath) => `Write your own first-pass findings to ${draftPath} before spawning subagents \u2014 a review must never depend on subagents alone, and a pre-seeded draft does not count until you have revised it yourself this run. Write ${draftPath} from what you have read so far (preliminary findings are fine), run \`code-review validate ${draftPath} --explain\` until it passes, then fan out; your subagents run in the background, so keep refining the draft as their reports arrive.`;
+var forceBackgroundSpawn = (toolInput) => ({
+  hookSpecificOutput: {
+    hookEventName: "PreToolUse",
+    permissionDecision: "allow",
+    updatedInput: { ...asRecord(toolInput) ?? {}, run_in_background: true }
+  }
+});
 var denyPreTool = (reason) => ({
   hookSpecificOutput: {
     hookEventName: "PreToolUse",
@@ -833,11 +843,16 @@ var evaluateBudgetHook = (input, params) => {
       };
     case "PreToolUse": {
       const toolName = rec["tool_name"];
-      if (isSubagent && typeof toolName === "string" && writesToDraft(toolName, rec["tool_input"], params.draftPath))
+      if (typeof toolName !== "string") return {};
+      if (isSubagent && writesToDraft(toolName, rec["tool_input"], params.draftPath))
         return denyPreTool(singleWriterMessage(params.draftPath));
-      if (phase.kind !== "hard") return {};
-      if (typeof toolName === "string" && blockedDuringConvergence(toolName, rec["tool_input"]))
+      if (phase.kind === "hard" && blockedDuringConvergence(toolName, rec["tool_input"]))
         return denyPreTool(budgetMessage(inputs, phase, params.draftPath, isSubagent));
+      if (SPAWN_TOOLS.has(toolName)) {
+        if (!isSubagent && !params.mainDraftWritten)
+          return denyPreTool(spawnFloorMessage(params.draftPath));
+        return forceBackgroundSpawn(rec["tool_input"]);
+      }
       return {};
     }
     default:
@@ -2231,6 +2246,13 @@ var parseBudgetUsd = (raw) => {
   const n = Number.parseFloat(raw);
   return Number.isFinite(n) && n >= 0 ? n : null;
 };
+var mtimeMsOf = (path) => {
+  try {
+    return statSync(path).mtimeMs;
+  } catch {
+    return null;
+  }
+};
 var transcriptPathOf = (input) => {
   const tp = (typeof input === "object" && input !== null ? input : {})["transcript_path"];
   return typeof tp === "string" ? tp : void 0;
@@ -2238,7 +2260,7 @@ var transcriptPathOf = (input) => {
 var budgetHookCmd = defineCommand({
   meta: {
     name: "budget-hook",
-    description: "Self-dispatching Claude Code hook for budget discipline (issue #38): on PostToolBatch, steer the agent to converge once spend or wall-clock enters its soft wind-down reserve; on PreToolUse, inside the hard reserve, deny the budget-burning tools (subagent spawns, arbitrary shell, web) while leaving the draft-delivery path open. Reads the hook payload on stdin, measures spend from its transcript, and decides on $ and/or time. Degrades to a no-op on any error."
+    description: "Self-dispatching Claude Code hook for budget discipline (issue #38): on PostToolBatch, steer the agent to converge once spend or wall-clock enters its soft wind-down reserve; on PreToolUse, inside the hard reserve, deny the budget-burning tools (subagent spawns, arbitrary shell, web) while leaving the draft-delivery path open. At every phase, the main agent's subagent spawns are denied until it has written its own first-pass draft (seed-draft's sidecar marker tells the seed apart), and permitted spawns are rewritten to run in the background so no batch join can block the spawner (issue #73). Reads the hook payload on stdin, measures spend from its transcript, and decides on $ and/or time. Degrades to a no-op on any error."
   },
   args: {
     draft: {
@@ -2301,7 +2323,11 @@ var budgetHookCmd = defineCommand({
           flatUsd: parseBudgetUsd(args["reserve-usd"]) ?? DEFAULT_RESERVE.flatUsd,
           flatMs: args["reserve-wall"] ? parseWallMs(args["reserve-wall"]) ?? DEFAULT_RESERVE.flatMs : DEFAULT_RESERVE.flatMs
         },
-        draftPath
+        draftPath,
+        mainDraftWritten: mainHasWrittenDraft(
+          mtimeMsOf(draftPath),
+          mtimeMsOf(seedMarkerPath(draftPath))
+        )
       });
       process.stdout.write(`${JSON.stringify(output)}
 `);
@@ -2484,7 +2510,7 @@ ${printableSchema(schemaPath)}
 var seedDraftCmd = defineCommand({
   meta: {
     name: "seed-draft",
-    description: "Write a valid findings $DRAFT before the review runs: the decoded findings from a prior review when one exists and still validates (incremental re-review), else an empty-but-valid scaffold \u2014 so a valid draft exists from turn 0 (issues #52, #53). Prints the mode chosen (prior|empty|none \u2014 none when even the scaffold write failed) to stdout; always exits 0"
+    description: "Write a valid findings $DRAFT before the review runs: the decoded findings from a prior review when one exists and still validates (incremental re-review), else an empty-but-valid scaffold \u2014 so a valid draft exists from turn 0 (issues #52, #53). Also drops a sidecar marker beside the seed so the budget hook can tell the untouched seed from a draft the agent wrote itself (issue #73). Prints the mode chosen (prior|empty|none \u2014 none when even the scaffold write failed) to stdout; always exits 0"
   },
   args: {
     prior: {
@@ -2519,10 +2545,21 @@ var seedDraftCmd = defineCommand({
 `
       );
     }
+    const writeSeedMarker = () => {
+      try {
+        writeFileSync(seedMarkerPath(outPath), "code-review seed marker\n");
+      } catch (err) {
+        process.stderr.write(
+          `Warning: could not write the seed marker beside ${outPath} (${err instanceof Error ? err.message : String(err)}) \u2014 the seeded draft will count as agent-written
+`
+        );
+      }
+    };
     const writeEmptyScaffold = () => {
       try {
         writeFileSync(outPath, `${JSON.stringify(noticeFindings(""), null, 2)}
 `);
+        writeSeedMarker();
         process.stderr.write(
           `Seeded ${outPath} with an empty valid scaffold \u2014 no decodable prior findings to build on
 `
@@ -2558,6 +2595,7 @@ var seedDraftCmd = defineCommand({
         if (!validateAgainstSchema(priorFindings, schemaPath).valid) return false;
         writeFileSync(outPath, `${JSON.stringify(priorFindings, null, 2)}
 `);
+        writeSeedMarker();
         return true;
       } catch (err) {
         process.stderr.write(