@hone-ai/cli 1.30.0 → 1.32.0

package/hone-cli.js

@@ -5604,10 +5604,13 @@ program
   .option('--kill', 'Kill the latest workflow run for this story')
   .option('--axes <axes>', 'Comma-separated classifier axes for this run (e.g. shared-chokepoint) — composition input (HC-COMM-010 C0)')
   .option('--approve <step>', 'Approve a paused gate (e.g., --approve step_0). Exit codes: 2 = paused at a human gate, 3 = parked for your editor (execution.mode: editor)')
+  .option('--no-verify', 'HC-GF-064: do not run verify-patch automatically when the run pauses at step_4')
   .option('--format <fmt>', 'Output format: pretty or json', 'pretty')
   .option('--poll-interval <s>', 'Poll interval in seconds', '5')
   .option('--story-file <path>', 'HC-GF-010: read the story text from a local file. Skips the GitHub-issue and Hone-roadmap lookups entirely, so a repo with neither can still run the pipeline.')
   .option('--description <text>', 'HC-GF-010: the story text, inline. Same effect as --story-file.')
+  .option('--acknowledge-abort', 'Approve a step the agent ABORTED (HC-GF-069). An abort means the agent found nothing it could review or build, so approving advances past a step that produced no usable result — read the reason first. Exists so a human can override, which is why the refusal is not simply a hard block.')
+  .option('--no-follow', 'With --approve: post the approval and exit immediately instead of following the run to its next decision point (HC-GF-070). The default FOLLOWS, because a caller told to poll does not — which is why HC-GF-064 auto-verify never fired outside a TTY.')
   .option('--include-paths <paths>', 'Comma-separated list of source file paths to bundle into the codebase context (HC-019n-followup-12). Augments auto-detected paths from the issue body.')
   .option('--e2e-specs', 'HC-019n-followup-28: force step_3b (Playwright spec generation) ON for this run (overrides e2e.spec_generation config)')
   .option('--skip-e2e-specs', 'HC-019n-followup-28: force step_3b (Playwright spec generation) OFF for this run (overrides e2e.spec_generation config)')
@@ -5638,6 +5641,132 @@ program
     const storyId = isUuid ? null : storyIdOrRunId;
     const runId = isUuid ? storyIdOrRunId : null;
 
+    // HC-GF-070: ONE poll loop, reachable from BOTH entry points.
+    //
+    // It used to be reachable from exactly one — the initial `run-story <storyId>` — so
+    // `--approve` posted, printed "Poll: ...", and returned. The caller was told to poll
+    // and, exactly as with the verify-patch nag that motivated HC-GF-064 (5 of 22 runs),
+    // nobody did. Every driver written against this re-implemented the loop and each had
+    // a different bug: a paused gate treated as terminal; a no-op approval hot-looping
+    // nine times; a gate advertised by a run whose driver had already exited. Not three
+    // driver bugs — one missing behaviour, three times.
+    //
+    // Its DECISIONS live in cli/lib/poll-decision.js as a pure function, because calling
+    // the same loop from a second place is only safe if what it decides is pinned.
+    const pollUntilDecision = async (pollRunId) => {
+      const { classifyPollState, POLL_OUTCOMES } = require('./lib/poll-decision');
+      const interval = parseInt(opts.pollInterval, 10) * 1000;
+      // HC-GF-064: at most ONE verification per attempt per process. Without this the
+      // advisory path re-verifies on every poll tick, because advisory never advances
+      // the run and the pause it re-observes is the same pause.
+      const _verifiedAttempts = new Set();
+
+      for (;;) {
+        await new Promise(r => setTimeout(r, interval));
+
+        let status;
+        try {
+          const { data: pollData } = await client.get(`/orchestrate/${pollRunId}`);
+          status = pollData;
+        } catch (e) {
+          console.error(`Poll error: ${e.message}`);
+          continue;
+        }
+
+        const d = classifyPollState(status);
+
+        if (d.outcome === POLL_OUTCOMES.COMPLETED) {
+          console.log(`✓ Workflow completed! Total tokens: ${(d.totalTokens || 0).toLocaleString()}`);
+          process.exit(d.exitCode);
+        }
+        if (d.outcome === POLL_OUTCOMES.TERMINAL_FAILURE) {
+          console.error(`✗ Workflow ${d.runStatus}: ${d.errorMessage}`);
+          process.exit(d.exitCode);
+        }
+        if (d.outcome === POLL_OUTCOMES.EDITOR_PARKED) {
+          console.log(editorParkedGuidance(pollRunId, d.stepKey, d.agent));
+          process.exit(d.exitCode);
+        }
+
+        if (d.outcome === POLL_OUTCOMES.HUMAN_GATE) {
+          console.log(`⏳ Step ${d.stepKey} (${d.agent || 'unknown'}) — awaiting approval`);
+
+          // HC-GF-064: verify BEFORE asking anyone to approve. The gate this feeds had
+          // existed since HC-019n-followup-34/35 and never fired, because nothing ever
+          // ran the executing step. Consent is DERIVED: `ci.local_command` being
+          // explicitly set is the adopter's own statement of how to test this repo (see
+          // cli/lib/auto-verify.js and docs/architecture/adr-verification-invocation.md).
+          // Never throws — a failure here must leave the operator exactly where they
+          // were, which is being asked to approve.
+          try {
+            const { decideAutoVerify, announce, shouldRepoll, alreadyVerified } = require('./lib/auto-verify');
+            const decision = decideAutoVerify({
+              stepKey: d.stepKey,
+              repoRoot: process.cwd(),
+              noVerifyFlag: opts.verify === false,
+            });
+            if (decision.run && !alreadyVerified(d.attemptKey, _verifiedAttempts)) {
+              _verifiedAttempts.add(d.attemptKey);
+              console.log(announce(decision, pollRunId));
+              const { spawnSync } = require('child_process');
+              const r = spawnSync(process.execPath,
+                [process.argv[1], 'verify-patch', pollRunId, '--report'],
+                { stdio: 'inherit', env: process.env });
+              // A green verdict under `enforce` AUTO-APPROVES this gate, so the run may
+              // already have moved on. Re-poll rather than prompting for an approval that
+              // is no longer wanted — asking a human to approve something already approved
+              // is how an operator learns to distrust the output.
+              if (shouldRepoll({ gate: decision.gate, verdictOk: r.status === 0,
+                                 attemptKey: d.attemptKey, verifiedAttempts: null })) {
+                console.log('  → verified; enforce may have advanced the run. Re-checking...');
+                continue;
+              }
+              console.log(r.status === 0
+                ? `  → verified and recorded (gate: ${decision.gate}). The gate still needs you.`
+                : '  → verification did not pass; the gate still needs you.');
+            }
+          } catch (e) {
+            console.log(`  (auto-verify skipped: ${e.message})`);
+          }
+
+          if (process.stdin.isTTY) {
+            const readline = require('readline');
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const answer = await new Promise(resolve => rl.question('  Approve? [y/n/kill] ', resolve));
+            rl.close();
+
+            if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
+              try {
+                await client.post(`/orchestrate/${pollRunId}/approve`, { stepKey: d.stepKey });
+                console.log('  Approved — workflow resuming...');
+              } catch (e) {
+                console.error(`  Approve failed: ${e.response?.data?.error || e.message}`);
+              }
+            } else if (answer.toLowerCase() === 'kill') {
+              try {
+                await client.post(`/orchestrate/${pollRunId}/kill`, { reason: 'CLI kill' });
+                console.log('  Workflow killed.');
+                process.exit(0);
+              } catch (e) {
+                console.error(`  Kill failed: ${e.message}`);
+              }
+            } else {
+              console.log(`  Skipped. Resume later: hone run-story ${pollRunId} --status`);
+              process.exit(0);
+            }
+          } else {
+            // Non-interactive (CI): exit 2 (paused, needs approval) — the contract
+            // adopter pipelines already branch on.
+            console.log(`  Non-interactive mode. Approve with: hone run-story ${pollRunId} --approve ${d.stepKey}`);
+            process.exit(d.exitCode);
+          }
+          continue;
+        }
+
+        if (d.stepKey) process.stdout.write(`  Running: ${d.stepKey} (${d.agent})...\r`);
+      }
+    };
+
     // Status mode
     if (opts.status) {
       const statusId = runId || storyIdOrRunId;
@@ -5705,13 +5834,33 @@ program
     if (opts.approve) {
       const approveId = runId || storyIdOrRunId;
       try {
-        const { data } = await client.post(`/orchestrate/${approveId}/approve`, { stepKey: opts.approve });
+        await client.post(`/orchestrate/${approveId}/approve`,
+          { stepKey: opts.approve, acknowledgeAbort: opts.acknowledgeAbort === true });
         console.log(`Gate ${opts.approve} approved. Workflow resuming.`);
-        console.log(`Poll: hone run-story ${approveId} --status`);
       } catch (e) {
         console.error(`Failed: ${e.response?.data?.error || e.message}`);
         process.exit(1);
       }
+      // HC-GF-070: FOLLOW the run to its next decision point instead of returning here.
+      // Returning is what made every automated flow exit blind after each gate, and is
+      // the direct reason HC-GF-064's auto-verify — which lives at the step_4 pause —
+      // never fired outside an interactive terminal. Exit codes are unchanged: 0 done,
+      // 1 failed, 2 next human gate, 3 editor park.
+      if (opts.follow === false) {
+        console.log(`Poll: hone run-story ${approveId} --status`);
+        return;
+      }
+      // The initial invocation runs this inside the start-workflow try/catch; the
+      // approve path has none, and an unhandled rejection here would surface as a bare
+      // stack trace after a successful approval — the approval landed, so the exit code
+      // must say what happened to the RUN, not look like the approve failed.
+      try {
+        await pollUntilDecision(approveId);
+      } catch (e) {
+        console.error(`Approved, but following the run failed: ${e.message}`);
+        console.error(`Poll: hone run-story ${approveId} --status`);
+        process.exit(1);
+      }
       return;
     }
 
@@ -5915,21 +6064,24 @@ program
         // bundler can WINDOW a too-big file around its edit site instead of
         // head-truncating past it (the demo's line 787 sits at char 37K).
         const candidateLines = new Map();
+        // HC-GF-073: hoisted out of the bare-ref branch below, because the sibling tier
+        // needs the same list on stories that contain no bare refs at all — which is most
+        // of them.
+        const { gitEnv } = require('./lib/git-env');
+        let repoFiles = null;
+        const listRepoFiles = () => {
+          if (repoFiles) return repoFiles;
+          try {
+            repoFiles = execSync('git ls-files', {
+              cwd: process.cwd(), env: gitEnv(), encoding: 'utf8', maxBuffer: 64 * 1024 * 1024,
+            }).split('\n').filter(Boolean);
+          } catch { repoFiles = []; }
+          return repoFiles;
+        };
         if (issueBodyForFiles) {
           const { extractBareRefs, resolveBareName, alreadyCovered } = require('./lib/bundle-paths');
-          const { gitEnv } = require('./lib/git-env');
           const bareRefs = extractBareRefs(issueBodyForFiles);
           if (bareRefs.length > 0) {
-            let repoFiles = null;
-            const listRepoFiles = () => {
-              if (repoFiles) return repoFiles;
-              try {
-                repoFiles = execSync('git ls-files', {
-                  cwd: process.cwd(), env: gitEnv(), encoding: 'utf8', maxBuffer: 64 * 1024 * 1024,
-                }).split('\n').filter(Boolean);
-              } catch { repoFiles = []; }
-              return repoFiles;
-            };
             for (const { name, line } of bareRefs) {
               if (alreadyCovered(name, candidates)) continue;
               const r = resolveBareName(name, listRepoFiles());
@@ -5954,9 +6106,32 @@ program
         const MAX_FILES = 30;
         const MAX_TOTAL_CHARS = 150_000;
         const MAX_PER_FILE_CHARS = 25_000;
+        // HC-GF-073: `candidates` is only what the STORY named, and a story names the
+        // files it will CREATE — so on a greenfield repo every one of them fails the
+        // existsSync below and the bundle is EMPTY. Measured across FlowForge's 33 real
+        // stories: 29 extracted zero existing files. The dogfood runs looked fine only
+        // because an operator had typed --include-paths once; 12 of 12 runs then bundled
+        // the same three files across five different stories.
+        //
+        // selectBundle() splits them into what exists, what is pending, and adds two
+        // tiers the story can never name: repo-level signal files (whose ABSENCE is what
+        // a security reviewer must be able to check — HC-GF-063) and existing neighbours
+        // of the pending paths (the conventions a new module has to match). Order is
+        // priority order, because the char cap below truncates from the end.
+        const { selectBundle, auditLines } = require('./lib/bundle-context');
+        const selection = selectBundle({
+          named: [...candidates],
+          repoFiles: listRepoFiles(),
+          exists: (rel) => {
+            if (rel.startsWith('/') || rel.startsWith('~') || rel.includes('..')) return false;
+            const abs = path.resolve(process.cwd(), rel);
+            return abs.startsWith(process.cwd() + path.sep) && fs.existsSync(abs);
+          },
+        });
+        const ordered = [...selection.present, ...selection.signal, ...selection.siblings];
         const codebaseFiles = [];
         let totalChars = 0;
-        for (const candidate of candidates) {
+        for (const candidate of ordered) {
           if (codebaseFiles.length >= MAX_FILES) break;
           if (candidate.startsWith('/') || candidate.startsWith('~') || candidate.includes('..')) continue;
           const abs = path.resolve(process.cwd(), candidate);
@@ -5989,6 +6164,11 @@ program
           totalChars += content.length;
           codebaseFiles.push({ path: candidate, content });
         }
+        // HC-GF-073: the old line printed a COUNT, and a count cannot distinguish three
+        // files the story named from three it did not. That is why 12 consecutive runs
+        // bundled an unrelated module and nothing said so — the "running blind" warning
+        // below fires on an EMPTY bundle, and these were not empty.
+        for (const line of auditLines(selection)) console.log(line);
         if (codebaseFiles.length > 0) {
           orchestrateConfig.codebaseFiles = codebaseFiles;
           console.log(`  → bundled ${codebaseFiles.length} codebase file(s) for step_1/step_4 context (${totalChars} chars)`);
@@ -6231,82 +6411,7 @@ program
       console.log(`Poll: ${data.pollUrl}`);
       console.log('');
 
-      // Poll loop
-      const interval = parseInt(opts.pollInterval, 10) * 1000;
-      while (true) {
-        await new Promise(r => setTimeout(r, interval));
-
-        let status;
-        try {
-          const { data: pollData } = await client.get(`/orchestrate/${data.runId}`);
-          status = pollData;
-        } catch (e) {
-          console.error(`Poll error: ${e.message}`);
-          continue;
-        }
-
-        if (status.status === 'completed') {
-          console.log(`✓ Workflow completed! Total tokens: ${(status.totalTokens || 0).toLocaleString()}`);
-          process.exit(0);
-        }
-
-        if (status.status === 'failed' || status.status === 'killed') {
-          console.error(`✗ Workflow ${status.status}: ${status.errorMessage || 'unknown'}`);
-          process.exit(1);
-        }
-
-        if (status.status === 'paused' && status.awaitingApproval) {
-          const step = status.steps.find(s => s.stepKey === status.currentStep);
-          // HC-COMM-010-followup-1: an editor-parked run is a gate the EDITOR
-          // satisfies, not a human — never offer --approve here (B4 refuses it).
-          if (isEditorParked(status)) {
-            console.log(editorParkedGuidance(data.runId, status.currentStep, step?.agent));
-            process.exit(EDITOR_PARKED_EXIT_CODE);
-          }
-          console.log(`⏳ Step ${status.currentStep} (${step?.agent || 'unknown'}) — awaiting approval`);
-
-          // Interactive prompt
-          if (process.stdin.isTTY) {
-            const readline = require('readline');
-            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-            const answer = await new Promise(resolve => {
-              rl.question('  Approve? [y/n/kill] ', resolve);
-            });
-            rl.close();
-
-            if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
-              try {
-                await client.post(`/orchestrate/${data.runId}/approve`, { stepKey: status.currentStep });
-                console.log('  Approved — workflow resuming...');
-              } catch (e) {
-                console.error(`  Approve failed: ${e.response?.data?.error || e.message}`);
-              }
-            } else if (answer.toLowerCase() === 'kill') {
-              try {
-                await client.post(`/orchestrate/${data.runId}/kill`, { reason: 'CLI kill' });
-                console.log('  Workflow killed.');
-                process.exit(0);
-              } catch (e) {
-                console.error(`  Kill failed: ${e.message}`);
-              }
-            } else {
-              console.log(`  Skipped. Resume later: hone run-story ${data.runId} --status`);
-              process.exit(0);
-            }
-          } else {
-            // Non-interactive (CI): exit with code 2 (paused, needs approval)
-            console.log(`  Non-interactive mode. Approve with: hone run-story ${data.runId} --approve ${status.currentStep}`);
-            process.exit(2);
-          }
-          continue;
-        }
-
-        // Still running
-        const currentStep = status.steps.find(s => s.status === 'running');
-        if (currentStep) {
-          process.stdout.write(`  Running: ${currentStep.stepKey} (${currentStep.agent})...\r`);
-        }
-      }
+      await pollUntilDecision(data.runId);
     } catch (e) {
       if (e.response?.status === 429) {
         console.error(`Max concurrent workflows reached. ${e.response.data.error}`);
@@ -7344,11 +7449,15 @@ showCmd
   .command('step <workflowId> <stepKey>')
   .description('Print the actual LLM output of an orchestrator step (latest attempt by default)')
   .option('--attempt <n>', 'Specific attempt number (default: latest)')
+  .option('--prompt', 'Also print the exact prompt this step sent to the model (HC-GF-055)')
   .action(async (workflowId, stepKey, opts) => {
     const config = getConfig();
     const client = api(config);
     try {
-      const url = `/orchestrate/${workflowId}/step/${stepKey}${opts.attempt ? `?attempt=${opts.attempt}` : ''}`;
+      const q = [];
+      if (opts.attempt) q.push(`attempt=${opts.attempt}`);
+      if (opts.prompt) q.push('prompt=1');
+      const url = `/orchestrate/${workflowId}/step/${stepKey}${q.length ? `?${q.join('&')}` : ''}`;
       const r = await client.get(url);
       const s = r.data;
       console.log(`── step output ──────────────────────────────────────────`);
@@ -7366,6 +7475,21 @@ showCmd
         console.log(`── error_context (retry feedback) ──────────────────────`);
         console.log(s.errorContext);
       }
+      // HC-GF-055: say whether the prompt was recorded, ALWAYS. The rule this repo keeps
+      // relearning is that a stored field nobody surfaces is the same as no field at all —
+      // `input_artifact` sat in the schema with zero writers for months and nobody noticed
+      // because nothing ever mentioned it.
+      console.log(``);
+      if (s.promptChars == null) {
+        console.log(`── prompt ─────────────────────────────────────────────`);
+        console.log(`  (not recorded for this attempt — pre-HC-GF-055 runs have none)`);
+      } else if (s.prompt != null) {
+        console.log(`── prompt SENT to the model (${s.promptChars} chars) ────────`);
+        console.log(s.prompt);
+      } else {
+        console.log(`── prompt ─────────────────────────────────────────────`);
+        console.log(`  ${s.promptChars} chars recorded — re-run with --prompt to print it`);
+      }
       console.log(``);
       console.log(`── output (the LLM's actual response) ──────────────────`);
       console.log(s.output || '(no output recorded — step may not have completed)');
@@ -7727,7 +7851,16 @@ program
           headSha,
           gates: reportGates.length ? reportGates : undefined,
         });
-        if (opts.format !== 'json') console.log(`  → reported verdict '${reportVerdict}' to the server (advisory)`);
+        if (opts.format !== 'json') {
+          // HC-GF-070: name the gate that is actually configured. This said "(advisory)"
+          // unconditionally, and printed it on a run where `enforce` was auto-approving
+          // step_4 on the strength of that very verdict.
+          const { verdictReportLine } = require('./lib/auto-verify');
+          const { readVerificationGateConfig } = require('./lib/pipeline-config');
+          let gate = 'advisory';
+          try { gate = readVerificationGateConfig(process.cwd()) || 'advisory'; } catch { /* label only */ }
+          console.log(verdictReportLine(reportVerdict, gate));
+        }
       } catch (e) {
         if (opts.format !== 'json') console.warn(`  ⚠ verdict report failed (non-fatal): ${e.response?.data?.error || e.message}`);
       }
@@ -7752,7 +7885,12 @@ program
       else console.log(renderReport(report));
       // Exit non-zero when the operator has something to do, so `hone run-report`
       // is usable as a gate in a script and not merely as prose.
-      process.exit(report.needsYou.length ? 1 : 0);
+      //
+      // HC-GF-065: count the GATING items, not every item. An advisory — currently
+      // "verification never ran" — is shown in full but must not flip this exit code:
+      // it fires on every unverified terminal run, and gating on it would turn a
+      // passing adopter CI red the day they upgrade. HC-026c: report before you gate.
+      process.exit((report.gatingCount ?? report.needsYou.length) ? 1 : 0);
     } catch (e) {
       console.error(`run-report failed: ${e.response?.data?.error || e.message}`);
       process.exit(1);

package/lib/auto-verify.js

@@ -0,0 +1,167 @@
+'use strict';
+/**
+ * auto-verify.js — HC-GF-064: decide whether the CLI should run `verify-patch` itself
+ * when a run pauses at the step_4 gate.
+ *
+ * WHY THIS EXISTS. The closed-loop gate has been shipped and integration-tested since
+ * HC-019n-followup-34/35, and had never fired: 22 of 22 runs `advisory`, 5 of 22 with any
+ * verdict recorded at all, and zero automatic invocations. The only prompt was a line
+ * `run-report` prints — "NO verification was reported for this run" — and 5-of-22 is what
+ * that nag is worth. A gate that never receives a verdict is indistinguishable from a gate
+ * that does not exist.
+ *
+ * The value is measured, not assumed. On run 77ed4f1b `verify-patch` found three ruff
+ * errors that BOTH the code-reviewer and the security agent had passed — neither could
+ * have caught them, because no reviewing step executes anything. And on run 6964b87e a
+ * green verdict auto-approved step_4 with no human approval, which is the first time
+ * enforce mode has been demonstrated end to end.
+ *
+ * CONSENT IS DERIVED, NOT REQUESTED. Running an adopter's test suite unasked is a real
+ * intrusion — it provisions dependencies, writes to disk, and costs wall clock. But
+ * `ci.local_command` and `ci.install_command` are ALREADY in their `.pipeline-config.yml`:
+ * an adopter who filled those in has declared, in their own words, how to build and test
+ * this repo locally. Running exactly those commands, in an isolated worktree, at the
+ * moment their pipeline pauses for their approval, is inside what they have sanctioned.
+ * An adopter who has not configured them gets today's behaviour, unchanged.
+ *
+ * So this defaults ON where consent already exists and OFF where it does not — neither a
+ * blanket opt-in (which recreates the 5-of-22 failure this work exists to fix) nor a
+ * blanket opt-out.
+ *
+ * THIS DOES NOT VIOLATE HC-026c's "ships advisory by default" discipline, though it looks
+ * like it might. That rule is about not letting a detector CHANGE FLOW before it has
+ * earned trust. This changes no flow: it produces a verdict. Whether the verdict gates
+ * anything remains `verification.gate`, which stays `advisory` by default and is untouched
+ * here. Running the tests is safe-by-default; ACTING on them stays opt-in.
+ *
+ * Design: docs/architecture/adr-verification-invocation.md
+ */
+
+const { readCIConfigDetails, readVerificationGateConfig } = require('./pipeline-config');
+
+/** The only gate a `verify-patch` verdict can inform (gate_sources default). */
+const VERIFIABLE_STEP = 'step_4';
+
+/**
+ * @returns {{ run: boolean, reason: string, command: string|null, gate: string }}
+ *
+ * `reason` is always populated, including when `run` is true, because the caller ANNOUNCES
+ * it. An adopter discovering their test suite mid-run should be told why it is running and
+ * how to stop it — the surprise is the real cost of this feature, and an unexplained
+ * surprise is the version that gets it reverted.
+ */
+function decideAutoVerify({ stepKey, repoRoot, noVerifyFlag = false, env = process.env } = {}) {
+  const gate = safeGate(repoRoot);
+  const off = (reason) => ({ run: false, reason, command: null, gate });
+
+  if (noVerifyFlag) return off('--no-verify was passed');
+  if (String(env.HONE_NO_AUTO_VERIFY || '') === '1') return off('HONE_NO_AUTO_VERIFY=1');
+
+  // Only step_4. A verdict for any other step has no gate to inform, so running an
+  // adopter's suite there would spend their time for nothing.
+  if (stepKey !== VERIFIABLE_STEP) {
+    return off(`only ${VERIFIABLE_STEP} has a verification gate (paused at ${stepKey})`);
+  }
+
+  const auto = readVerificationAuto(repoRoot);
+  if (auto === false) return off('verification.auto is false in .pipeline-config.yml');
+
+  const ci = safeCi(repoRoot);
+  if (!ci.local_command_explicit) {
+    // The consent gate. NOT an error and NOT a nag — an adopter who has not told us how
+    // to test their repo has not consented to us guessing, and `make ci` is a guess.
+    return off('ci.local_command is not set in .pipeline-config.yml — no consent to run tests');
+  }
+
+  return { run: true, reason: `ci.local_command is configured (${ci.local_command})`, command: ci.local_command, gate };
+}
+
+/** `verification.auto` — true unless explicitly false. Unset means "use the consent rule". */
+function readVerificationAuto(repoRoot) {
+  const block = readYamlBlock(repoRoot, 'verification');
+  if (!block || typeof block !== 'object') return null;
+  if (block.auto === false || String(block.auto).toLowerCase() === 'false') return false;
+  if (block.auto === true || String(block.auto).toLowerCase() === 'true') return true;
+  return null;
+}
+
+function readYamlBlock(repoRoot, key) {
+  if (!repoRoot || typeof repoRoot !== 'string') return null;
+  const fs = require('fs'); const path = require('path');
+  for (const p of [path.join(repoRoot, '.pipeline-config.yml'), path.join(repoRoot, '.github/.pipeline-config.yml')]) {
+    if (!fs.existsSync(p)) continue;
+    try {
+      const parsed = require('js-yaml').load(fs.readFileSync(p, 'utf8'));
+      if (parsed && typeof parsed === 'object' && parsed[key] !== undefined) return parsed[key];
+    } catch { /* a malformed config must not break the run — fall through to null */ }
+  }
+  return null;
+}
+
+function safeCi(repoRoot) {
+  try { return readCIConfigDetails(repoRoot); }
+  catch { return { local_command: null, local_command_explicit: false, install_command: null }; }
+}
+function safeGate(repoRoot) {
+  try { return readVerificationGateConfig(repoRoot) || 'advisory'; }
+  catch { return 'advisory'; }
+}
+
+/** What the operator sees before their test suite starts. */
+function announce(decision, runId) {
+  if (!decision.run) return null;
+  return [
+    `  → verifying step_4 before you approve it: ${decision.command}`,
+    `    (in an isolated worktree; gate mode: ${decision.gate}. Skip with --no-verify.)`,
+  ].join('\n');
+}
+
+
+/**
+ * After a verdict is posted, should the caller RE-POLL (the run may have moved) or fall
+ * through to the normal approve prompt?
+ *
+ * HC-GF-064-followup: the first version always re-polled on a green verdict, which is an
+ * UNBOUNDED LOOP under the default `advisory` mode — advisory only RECORDS the verdict, so
+ * the run stays paused, the caller re-polls, sees the same pause, and runs the adopter's
+ * test suite again, provisioning a worktree every time, once per poll interval, forever.
+ * It was invisible during development because the repo it was built against is set to
+ * `enforce`, where a green verdict really does advance the run. Every adopter on the
+ * DEFAULT config would have hit it.
+ *
+ * Two independent guards, because either alone is thin:
+ *   - only `enforce` can advance a run, so only `enforce` justifies re-polling;
+ *   - an attempt is verified AT MOST ONCE per process regardless of mode, so a
+ *     misconfiguration or a future third mode cannot resurrect the loop.
+ */
+function shouldRepoll({ gate, verdictOk, attemptKey, verifiedAttempts }) {
+  if (!verdictOk) return false;
+  if (gate !== 'enforce') return false;
+  if (verifiedAttempts && verifiedAttempts.has(attemptKey)) return false;
+  return true;
+}
+
+/** Has this exact attempt already been verified by this process? */
+function alreadyVerified(attemptKey, verifiedAttempts) {
+  return Boolean(verifiedAttempts && verifiedAttempts.has(attemptKey));
+}
+
+/**
+ * The line printed after a verdict is posted.
+ *
+ * HC-GF-070: this used to end in a hardcoded `(advisory)`. On the acceptance run for that
+ * story the gate was `enforce` and the verdict AUTO-APPROVED step_4 — the run advanced
+ * with no human involved — while the CLI told the operator the verdict was advisory. A
+ * constant cannot be wrong about the run it is describing, which is the same
+ * cannot-fail shape as a check that never fires, arriving in the output layer: it
+ * understates the one case where the verdict actually changed something.
+ */
+function verdictReportLine(verdict, gate) {
+  const mode = gate === 'enforce' ? 'enforce' : 'advisory';
+  const effect = mode === 'enforce'
+    ? 'enforce — a passing verdict approves this gate'
+    : 'advisory — records only, the gate still needs a human';
+  return `  → reported verdict '${verdict}' to the server (${effect})`;
+}
+
+module.exports = { decideAutoVerify, announce, readVerificationAuto, shouldRepoll, alreadyVerified, verdictReportLine, VERIFIABLE_STEP };

package/lib/bundle-context.js

@@ -0,0 +1,182 @@
+'use strict';
+/**
+ * bundle-context.js — HC-GF-073: decide what source the pipeline actually gets to read.
+ *
+ * WHY THIS EXISTS. The bundler drops every path that fails `existsSync`, which on a
+ * greenfield story is all of them: a story names what it will CREATE. Measured across the
+ * 33 real FlowForge stories, 29 extracted ZERO existing files. The dogfood runs looked
+ * healthy only because an operator had typed `--include-paths` once — 12 of 12 runs then
+ * bundled the same three files across five different stories, none of which named them.
+ *
+ * Three recorded failures trace back here, and none of them looked like a bundling bug:
+ *   HC-GF-063  a HIGH security finding on `.gitignore` "being unverified" — it was never
+ *              bundled; `.gitignore:2` already contained `.env`.
+ *   HC-GF-069  step_5 aborted: "two ACs are blocked on files that have never been bundled".
+ *   HC-GF-072  the builder invented `FLOWFORGE_MODE` while `.env.example`, unbundled,
+ *              already read `MODE=paper`.
+ *
+ * THREE TIERS, in priority order, because the CLI's char budget truncates from the end:
+ *   present  — paths the STORY named that exist. The best context there is.
+ *   signal   — small repo-level files no story ever names but every reviewer needs:
+ *              ignore files, manifests, env TEMPLATES. Their ABSENCE is the finding.
+ *   siblings — existing neighbours of the paths the story will create, taken from the
+ *              nearest ancestor directory that has files. This is the greenfield answer:
+ *              you cannot show the builder a file that does not exist, but you can show
+ *              it how this package writes the ones that do.
+ *
+ * SECRETS ARE REFUSED AT EVERY TIER, including when the story names one outright. `named`
+ * is untrusted input — story prose, or an `--include-paths` flag. `.env.example` is a
+ * template and safe; `.env` holds live broker credentials, and `git ls-files` is no guard
+ * because a misconfigured repo can track one. A refusal is REPORTED, never silent.
+ *
+ * The reporting half is not decoration. Today's "running blind" warning fires on an EMPTY
+ * bundle, so a bundle of three irrelevant files is indistinguishable from a good one and
+ * the operator is told nothing — a check that cannot fail, at the input stage.
+ */
+
+const path = require('path');
+
+/**
+ * Repo-level files worth bundling regardless of what the story says. Deliberately
+ * cross-stack: a list that only knows `pyproject.toml` hands every Node adopter the old
+ * behaviour. Kept to files that are small and that answer "does this repo already handle
+ * X" — the question a reviewer cannot otherwise settle.
+ */
+const SIGNAL_FILES = Object.freeze([
+  '.gitignore', '.dockerignore', '.npmignore',
+  '.env.example', '.env.sample', '.env.template',
+  'package.json', 'pyproject.toml', 'setup.cfg', 'go.mod', 'Cargo.toml',
+  'Gemfile', 'pom.xml', 'build.gradle', 'composer.json',
+]);
+
+/**
+ * A path that must never reach an agent prompt. Matched on the BASENAME so a nested
+ * `config/.env` is caught too. The `.example`/`.sample`/`.template` suffixes are the
+ * documented exception and are handled by testing them first.
+ */
+const SECRET_BASENAMES = [/^\.env($|\.)/i, /^secrets?\./i, /\.pem$/i, /\.p12$/i, /(^|[._-])id_(rsa|dsa|ecdsa|ed25519)$/i];
+const SECRET_EXEMPT = /\.(example|sample|template|dist)$/i;
+
+/** Is this path a credential file? `.env.example` is not; `.env.production` is. */
+function isSecretPath(p) {
+  const base = path.posix.basename(String(p || '').replace(/\\/g, '/'));
+  if (SECRET_EXEMPT.test(base)) return false;
+  return SECRET_BASENAMES.some((re) => re.test(base));
+}
+
+/** Directory of a repo-relative path, '' at the root. */
+const dirOf = (p) => {
+  const d = path.posix.dirname(String(p).replace(/\\/g, '/'));
+  return d === '.' ? '' : d;
+};
+
+/**
+ * Existing files that are DIRECT children of `dir` (not of its subdirectories — a
+ * recursive walk would drag a whole tree in and blow the char budget on the first story
+ * that touches a package root).
+ */
+function directChildren(dir, repoFiles) {
+  return repoFiles.filter((f) => dirOf(f) === dir);
+}
+
+/**
+ * Walk from a pending path's own directory toward the root, stopping at the FIRST
+ * directory that has files. `flowforge/config/settings.py` in a repo with no
+ * `flowforge/config/` yields `flowforge/`'s children; it does not climb to the root and
+ * return the entire repo.
+ */
+function nearestPopulatedAncestor(pendingPath, repoFiles) {
+  let dir = dirOf(pendingPath);
+  for (;;) {
+    const kids = directChildren(dir, repoFiles);
+    if (kids.length > 0) return { dir, kids };
+    if (dir === '') return { dir: '', kids: [] };
+    dir = dirOf(dir);
+  }
+}
+
+/**
+ * @param {object} o
+ * @param {string[]} o.named      paths the story named (or --include-paths supplied)
+ * @param {string[]} o.repoFiles  tracked files, `git ls-files`
+ * @param {(p:string)=>boolean} o.exists  the CLI passes an fs check, so an untracked-but-
+ *                                        present file is not miscounted as pending
+ * @param {number} [o.maxSiblings=6]
+ * @returns {{present:string[], pending:string[], signal:string[], siblings:string[], refused:string[]}}
+ */
+function selectBundle({ named = [], repoFiles = [], exists = () => false, maxSiblings = 6 } = {}) {
+  const present = [], pending = [], refused = [];
+  for (const p of named) {
+    if (isSecretPath(p)) { refused.push(p); continue; }
+    (exists(p) ? present : pending).push(p);
+  }
+
+  const taken = new Set(present);
+  // No isSecretPath() filter here: SIGNAL_FILES is a frozen literal, so the guarantee
+  // belongs to the LIST and is asserted against it directly. A filter here could never
+  // fire, and a guard that cannot fire is indistinguishable from one that is missing.
+  const signal = SIGNAL_FILES.filter((f) => !taken.has(f) && exists(f));
+  signal.forEach((f) => taken.add(f));
+
+  // Prefer a sibling sharing the pending file's extension — the convention a new .py must
+  // match lives in another .py, not in the package's README.
+  const siblings = [];
+  for (const p of pending) {
+    if (siblings.length >= maxSiblings) break;
+    const ext = path.posix.extname(p);
+    const { kids } = nearestPopulatedAncestor(p, repoFiles);
+    const ranked = [...kids].sort((a, b) =>
+      (path.posix.extname(b) === ext) - (path.posix.extname(a) === ext));
+    for (const k of ranked) {
+      if (siblings.length >= maxSiblings) break;
+      if (taken.has(k) || isSecretPath(k)) continue;
+      taken.add(k); siblings.push(k);
+    }
+  }
+
+  return { present, pending, signal, siblings, refused };
+}
+
+/**
+ * What the operator reads before the run starts.
+ *
+ * The load-bearing line is the ratio: `0 of 2 paths this story names`. It is what makes a
+ * bundle that matched nothing distinguishable from one that matched everything — the
+ * distinction the current empty-bundle warning cannot draw. The reason is always given
+ * alongside it, because a create-only story is NORMAL and a warning that reads as a defect
+ * on every greenfield story gets tuned out within a day, taking the real one with it.
+ */
+function auditLines(sel) {
+  const { present = [], pending = [], signal = [], siblings = [], refused = [] } = sel || {};
+  const named = present.length + pending.length;
+  const out = [];
+
+  if (named > 0) {
+    out.push(`  → bundle: ${present.length} of ${named} path${named === 1 ? '' : 's'} this story names`);
+    if (pending.length > 0) {
+      out.push(`    ${pending.length} do not yet exist (to be created): ${pending.join(', ')}`);
+    }
+  } else {
+    // The regression this fix nearly introduced, caught reviewing it before merge. A
+    // story yielding zero paths used to produce an EMPTY bundle, which tripped the
+    // caller's "running blind" warning. The signal tier means the bundle is never empty
+    // again — a .gitignore and a manifest are always there — so that warning would be
+    // silently suppressed on the one condition it exists for. Bundling two config files
+    // is not source context, and saying nothing about it would be this change committing
+    // the defect it was written to fix.
+    out.push('  ⚠ the story named no source paths — step_1 / step_4 will run WITHOUT source context');
+  }
+  if (siblings.length > 0) {
+    out.push(`    + ${siblings.length} existing neighbour(s) for convention: ${siblings.join(', ')}`);
+  }
+  if (signal.length > 0) out.push(`    + ${signal.length} repo-level file(s): ${signal.join(', ')}`);
+  if (refused.length > 0) {
+    out.push(`  ⚠ refused ${refused.length} credential file(s), never bundled: ${refused.join(', ')}`);
+  }
+  if (present.length === 0 && siblings.length === 0 && signal.length === 0) {
+    out.push('  ⚠ nothing to bundle — the code steps will run WITHOUT source context');
+  }
+  return out;
+}
+
+module.exports = { selectBundle, auditLines, isSecretPath, SIGNAL_FILES };

package/lib/poll-decision.js

@@ -0,0 +1,92 @@
+'use strict';
+/**
+ * poll-decision.js — HC-GF-070: what the poll loop should DO about one status payload.
+ *
+ * WHY THIS IS ITS OWN MODULE. The loop had exactly one entry point — the initial
+ * `run-story <storyId>` — and `--approve` returned without polling, so every automated
+ * flow exited blind after each gate. Making `--approve` poll means calling the same loop
+ * from a second place, and the only way to do that safely is for its DECISIONS to be a
+ * pure function of the payload rather than control flow tangled through 130 lines of
+ * printing, prompting and process.exit.
+ *
+ * The ordering of the branches is the load-bearing part, and each ordering below is a
+ * bug a hand-written driver actually shipped in this session:
+ *
+ *   terminal BEFORE gate      a killed run carrying a stale `awaitingApproval` offered a
+ *                             gate to a driver whose run was already dead
+ *   park BEFORE human gate    an editor-parked step is satisfied by the EDITOR; the
+ *                             server refuses `--approve` there, so a driver that read it
+ *                             as a human gate would approve into a rejection forever
+ *   awaitingApproval required a run can be `paused` while the server decides what is
+ *                             next; treating that as a gate approves a step nobody asked
+ *                             for, which is HC-GF-069 in miniature
+ *
+ * Everything unknown classifies as RUNNING. Inventing a terminal state for a status we
+ * have not seen would end a live run; polling one more tick costs an interval.
+ */
+
+const { isEditorParked } = require('./editor-park');
+
+const POLL_OUTCOMES = Object.freeze({
+  COMPLETED: 'completed',
+  TERMINAL_FAILURE: 'terminal_failure',
+  EDITOR_PARKED: 'editor_parked',
+  HUMAN_GATE: 'human_gate',
+  RUNNING: 'running',
+});
+
+/** Exit codes are a CONTRACT with adopter CI: 2 = human gate, 3 = editor park. */
+const EXIT = Object.freeze({
+  [POLL_OUTCOMES.COMPLETED]: 0,
+  [POLL_OUTCOMES.TERMINAL_FAILURE]: 1,
+  [POLL_OUTCOMES.HUMAN_GATE]: 2,
+  [POLL_OUTCOMES.EDITOR_PARKED]: 3,
+  [POLL_OUTCOMES.RUNNING]: null,
+});
+
+const decide = (outcome, extra = {}) => ({ outcome, exitCode: EXIT[outcome], ...extra });
+
+/**
+ * @param {object|null|undefined} status  a `GET /orchestrate/:runId` payload, straight
+ *                                        off the network and therefore not trusted to
+ *                                        have any particular shape
+ * @returns {{outcome:string, exitCode:number|null, stepKey?:string, agent?:string,
+ *            attemptKey?:string, totalTokens?:number, errorMessage?:string}}
+ */
+function classifyPollState(status) {
+  const s = (status && typeof status === 'object') ? status : {};
+  const steps = Array.isArray(s.steps) ? s.steps : [];
+
+  if (s.status === 'completed') {
+    return decide(POLL_OUTCOMES.COMPLETED, { totalTokens: s.totalTokens || 0 });
+  }
+  if (s.status === 'failed' || s.status === 'killed') {
+    return decide(POLL_OUTCOMES.TERMINAL_FAILURE, {
+      errorMessage: s.errorMessage || 'unknown', runStatus: s.status,
+    });
+  }
+
+  if (s.status === 'paused' && s.awaitingApproval) {
+    const step = steps.find((x) => x && x.stepKey === s.currentStep);
+    if (isEditorParked(s)) {
+      return decide(POLL_OUTCOMES.EDITOR_PARKED, {
+        stepKey: s.currentStep, agent: step && step.agent,
+      });
+    }
+    // HC-GF-064 keys its at-most-once verification on the ATTEMPT: a retried step is a
+    // new artifact and deserves a new verdict, while re-verifying the SAME attempt on
+    // every tick is the unbounded advisory loop that story had to fix before merge.
+    const attempt = (step && step.attempt) || 1;
+    return decide(POLL_OUTCOMES.HUMAN_GATE, {
+      stepKey: s.currentStep, agent: step && step.agent,
+      attemptKey: `${s.currentStep}#${attempt}`,
+    });
+  }
+
+  const running = steps.find((x) => x && x.status === 'running');
+  return decide(POLL_OUTCOMES.RUNNING, {
+    stepKey: running && running.stepKey, agent: running && running.agent,
+  });
+}
+
+module.exports = { classifyPollState, POLL_OUTCOMES, EXIT };

package/lib/run-report.js

@@ -48,10 +48,34 @@ function buildReport(run, extra = {}) {
   // ── NEEDS YOU ──────────────────────────────────────────────────────────────
   // 1. The run itself is not finished.
   if (run.status === 'paused' && run.currentStep) {
-    needsYou.push({
-      what: `run is paused at ${run.currentStep} — a gate is waiting on your judgment`,
-      how: `hone run-story ${run.runId} --approve ${run.currentStep}`,
-    });
+    // HC-GF-046: a paused run is not always a gate.
+    //
+    // Run 3dbde316 sat `paused` at step_4 with `MAX_RETRIES_EXCEEDED: step_4 retried 2
+    // times (max 2)`. That LOOKS like an available approval — paused, with a pending gate
+    // — but `checkGuardrails` refuses step_4 before the LLM call, so approving can never
+    // move the run. The line described the run's SHAPE and not its CAUSE, and so invited
+    // the one action the orchestrator had already decided to refuse. A driver looped on
+    // it; a human tried once and had to read the database.
+    //
+    // Matched on the specific messages the guardrail acts on, NOT on "any error_message".
+    // A resumable pause — a local rate-limit window, for instance — is not a refusal, and
+    // silencing a real gate on those would be the over-reach that makes the surface
+    // untrustworthy in the other direction.
+    const blocked = String(run.errorMessage || '')
+      .match(/^(MAX_RETRIES_EXCEEDED|MAX_STEPS_EXCEEDED|BUDGET_EXCEEDED|GARBAGE_OUTPUT)[^\n]*/);
+    if (blocked) {
+      needsYou.push({
+        what: `run CANNOT proceed at ${run.currentStep} — ${blocked[0].slice(0, 160)}. `
+          + 'Approving will be refused by the guardrail, so this is a decision, not a gate',
+        how: `hone run-story ${run.runId} --kill   (or raise guardrails.max_retries_per_step `
+          + 'in .pipeline-config.yml and re-run the story)',
+      });
+    } else {
+      needsYou.push({
+        what: `run is paused at ${run.currentStep} — a gate is waiting on your judgment`,
+        how: `hone run-story ${run.runId} --approve ${run.currentStep}`,
+      });
+    }
   }
   if (run.status === 'failed') {
     needsYou.push({
@@ -59,6 +83,19 @@ function buildReport(run, extra = {}) {
       how: `hone show step ${run.runId} ${run.currentStep || '<stepKey>'}`,
     });
   }
+  // HC-GF-065: a KILLED run needs you too.
+  //
+  // The predicate above is `status === 'failed'`, which `killed` does not match — so nine
+  // terminated runs in the corpus printed `NEEDS YOU (0)` and "nothing outstanding". A run
+  // somebody stopped mid-flight has work outstanding by definition, and the digest told
+  // the operator it did not. This is HC-GF-044's defect one field over, and its own lesson
+  // states the rule: a well-formed "nothing" is only as true as the predicate behind it.
+  if (run.status === 'killed') {
+    needsYou.push({
+      what: `run was KILLED before it finished${run.errorMessage ? `: ${String(run.errorMessage).slice(0, 160)}` : ''}`,
+      how: `hone run-story ${run.runId} --status   (re-run the story, or read the last step)`,
+    });
+  }
 
   // 1b. HC-GF-044: a STEP can be failed while the RUN says completed.
   //
@@ -187,6 +224,32 @@ function buildReport(run, extra = {}) {
     }
   }
 
+  // HC-GF-065: NO verdict at all is itself an item, not a footnote under a zero.
+  //
+  // Measured over the corpus with this very function: 10 of 21 terminal runs printed
+  // "nothing outstanding", and the sentence is false in every one of them. Nothing was
+  // executed against the diff, so the report cannot know whether anything is outstanding
+  // — the two reviewing steps READ, they do not run anything, which is exactly why
+  // HC-GF-064's verdict exists.
+  //
+  // Scoped to terminal runs on purpose. A run still in flight has not reached the point
+  // where a verdict is expected, and flagging it would make the section noise on every
+  // poll — which is how the old nag reached 5-of-22 and got ignored.
+  if (['completed', 'failed', 'killed'].includes(run.status) && !lastVerification) {
+    needsYou.push({
+      what: 'verification never ran for this run — no test, lint or typecheck result was '
+        + 'reported, so nothing here is known to build',
+      how: `hone verify-patch ${run.runId} step_4 --report`,
+      // HC-GF-065: ADVISORY. `hone run-report` exits 1 when needsYou is non-empty, and
+      // the comment at that exit says why — "so run-report is usable as a GATE in a
+      // script". This item fires on every unverified terminal run (15 of 21 in the
+      // corpus, most of them otherwise healthy), so gating on it would turn an adopter's
+      // passing CI red overnight. HC-026c is precisely this rule: a new signal REPORTS
+      // before it GATES. Visible in the report, absent from the exit code.
+      advisory: true,
+    });
+  }
+
   // ── WORTH KNOWING ──────────────────────────────────────────────────────────
   // Retries: the step ran more than once. HC-GF-041(c): this used to append "(its
   // first output was rejected)", which the report never checked and which is often
@@ -236,6 +299,9 @@ function buildReport(run, extra = {}) {
     worthKnowing,
     steps,
     verifications,
+    // HC-GF-065: what the exit code should count. Advisory items are shown but do not
+    // gate, so a new signal cannot silently change the meaning of a script's exit status.
+    gatingCount: needsYou.filter(i => !i.advisory).length,
   };
 }
 
@@ -278,11 +344,13 @@ function renderReport(r) {
       checked.push('verification');
       for (const g of last.gates || []) checked.push(g.name);
     }
+    // HC-GF-065: the empty state is only reachable when something was actually CHECKED.
+    // With no verdict there is nothing executed against the diff, so "nothing outstanding"
+    // asserts knowledge the report does not have — the missing verification is now an
+    // ITEM above rather than a footnote under a zero, and this branch is unreachable in
+    // that case. Kept as a genuine all-clear for a run that WAS verified.
     L.push('NEEDS YOU (0)');
-    L.push(checked.length
-      ? `  nothing — ${checked.join(', ')} all reported and none is failing or unavailable`
-      : '  nothing outstanding, but NO verification was reported for this run — '
-        + 'run `hone verify-patch <runId> step_4 --report` before trusting that');
+    L.push(`  nothing — ${checked.join(', ')} all reported and none is failing or unavailable`);
   }
   L.push('');
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hone-ai/cli",
-  "version": "1.30.0",
+  "version": "1.32.0",
   "description": "Hone AI — Enterprise SDLC Pipeline CLI",
   "main": "hone-cli.js",
   "bin": {