@hone-ai/cli 1.24.0 → 1.26.0

package/hone-cli.js

@@ -17,6 +17,7 @@
  */
 
 const { Command } = require('commander');
+const { isEditorParked, editorParkedGuidance, currentStep, EDITOR_PARKED_EXIT_CODE } = require('./lib/editor-park'); // HC-COMM-010-followup-1
 const axios        = require('axios');
 const fs           = require('fs');
 const path         = require('path');
@@ -2377,16 +2378,45 @@ program
         console.log('    Migrate any REPO-SPECIFIC edits then `rm -rf .github/agents/`');
       }
 
+      // HC-COMM-010 P3: in editor-mode repos, EDITOR-side agents sync as thin
+      // stubs — their instructions are composed server-side and delivered
+      // ephemerally at runtime, so the full prompt never persists to disk.
+      // Server-mode repos are UNTOUCHED (full sync — daily editor-chat use of
+      // these agents is a feature, not a leak to close).
+      const { isEditorStubbedAgent, editorStubContent } = require('./lib/editor-stub');
+      const { readExecutionMode } = require('./lib/pipeline-config');
+      const syncExecutionMode = readExecutionMode(process.cwd());
+      // HC-COMM-010-followup-3: in editor mode, register the Hone MCP server for
+      // Claude Code by writing a project-scoped .mcp.json (merge, never clobber).
+      // Replaces the manual `claude mcp add hone -- hone-mcp` runbook step.
+      try {
+        const { ensureClaudeMcpConfig, MCP_FILE, FALLBACK_LINE } = require('./lib/mcp-config');
+        const mcp = ensureClaudeMcpConfig(process.cwd(), { mode: syncExecutionMode });
+        if (mcp.action === 'written' || mcp.action === 'updated') console.log(`  ✓ Registered the Hone MCP server for Claude Code in ${MCP_FILE} (commit it; Claude Code asks once to approve project servers)`);
+        else if (mcp.action === 'skipped' && syncExecutionMode === 'editor') console.log(`  ⚠ ${mcp.reason}`);
+        else if (mcp.action === 'unchanged') console.log(`  ✓ Hone MCP server already registered in ${MCP_FILE}`);
+        void FALLBACK_LINE;
+      } catch (e) {
+        console.log(`  ⚠ MCP registration skipped (non-fatal): ${e.message}`);
+      }
+
       let synced = 0;
       for (const agent of agents) {
         try {
-          const r = await client.get(`/prompts/${agent}`, {
-            responseType: 'text',
-            headers: { Accept: 'text/markdown' },
-          });
+          let content;
+          if (isEditorStubbedAgent(agent, syncExecutionMode)) {
+            content = editorStubContent(agent);
+            console.log(`  → ${agent}: editor mode — syncing runtime stub (full prompt served ephemerally)`);
+          } else {
+            const r = await client.get(`/prompts/${agent}`, {
+              responseType: 'text',
+              headers: { Accept: 'text/markdown' },
+            });
+            content = r.data;
+          }
           const dest = path.join(agentsDir, `${agent}.agent.md`);
           const rel = `.claude/agents/${agent}.agent.md`;
-          const result = safeWrite(dest, rel, r.data);
+          const result = safeWrite(dest, rel, content);
           if (result !== 'skipped') {
             console.log(`  ✓ ${rel}`);
             synced++;
@@ -5518,7 +5548,8 @@ program
   .option('--branch <name>', 'Git branch (default: current)')
   .option('--status', 'Show status of the latest workflow run for this story')
   .option('--kill', 'Kill the latest workflow run for this story')
-  .option('--approve <step>', 'Approve a paused gate (e.g., --approve step_0)')
+  .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('--format <fmt>', 'Output format: pretty or json', 'pretty')
   .option('--poll-interval <s>', 'Poll interval in seconds', '5')
   .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.')
@@ -5552,9 +5583,15 @@ program
         for (const s of (data.steps || [])) {
           const icon = s.status === 'completed' ? '✓' : s.status === 'running' ? '⏳' : s.status === 'failed' ? '✗' : '⬜';
           const gate = s.gateResult ? ` (${s.gateResult})` : '';
-          console.log(`  ${icon} ${s.stepKey}  (${s.agent})  ${s.status}${gate}`);
+          // HC-019n-followup-40: one line per step = its CURRENT state; a retried
+          // step says so instead of listing a stale failed row above a completed one.
+          const tries = (s.attempts || 1) > 1 ? `  [attempt ${s.attempt} of ${s.attempts}]` : '';
+          console.log(`  ${icon} ${s.stepKey}  (${s.agent})  ${s.status}${gate}${tries}`);
         }
-        if (data.awaitingApproval) {
+        if (data.awaitingApproval && isEditorParked(data)) {
+          console.log('');
+          console.log(editorParkedGuidance(data.runId, data.currentStep, currentStep(data)?.agent));
+        } else if (data.awaitingApproval) {
           console.log('');
           console.log(`Awaiting approval at ${data.currentStep}.`);
           console.log(`Approve: hone run-story ${data.runId} --approve ${data.currentStep}`);
@@ -5860,6 +5897,37 @@ program
       console.warn('    Fix: hone run-story <id> --include-paths path/one.js,path/two.js');
     }
 
+    // HC-COMM-010 axes wiring (CLI half): when --axes wasn't given, derive
+    // the DETERMINISTIC axes from the extractors (SC-002) — security labels/
+    // text, cross-repo markers, recently-modified overlap vs the bundled
+    // paths. Judgment axes (shared-chokepoint etc.) come from the groomer at
+    // step_0 and are harvested server-side. Fail-open; explicit --axes wins.
+    if (!opts.axes) {
+      try {
+        const { classifyStory } = require('./lib/story-classifier');
+        const {
+          extractType, extractSecurityImplications, extractCrossRepoDependency, extractRecentlyModifiedOverlap,
+        } = require('./lib/story-classifier-extract');
+        const autoBody = issueBodyForFiles || '';
+        const autoLabels = [];
+        const touched = Array.isArray(orchestrateConfig.codebaseFiles)
+          ? orchestrateConfig.codebaseFiles.map(f => f.path).filter(Boolean)
+          : Object.keys(orchestrateConfig.codebaseFiles || {});
+        const auto = classifyStory({
+          type: extractType(autoLabels, autoBody, String(storyIdOrRunId)),
+          has_security_implications: extractSecurityImplications(autoLabels, autoBody),
+          cross_repo_dependency: extractCrossRepoDependency(autoBody),
+          recently_modified_overlap: extractRecentlyModifiedOverlap(process.cwd(), touched, 14),
+        });
+        if (auto.architect.engage && auto.architect.axes.length > 0) {
+          orchestrateConfig.classifier_axes = auto.architect.axes;
+          console.log(`  → auto-detected classifier axes: ${auto.architect.axes.join(', ')}`);
+        }
+      } catch (e) {
+        console.warn(`  ⚠ axes auto-detection failed (non-fatal): ${(e && e.message || String(e)).split('\n')[0]}`);
+      }
+    }
+
     // HC-101-followup-2: pass the adopter's CI gate config to the
     // orchestrator so step_5c can branch (github / local / both / none).
     // Defaults to gate=github + local_command='make ci' when the config
@@ -5898,6 +5966,28 @@ program
       orchestrateConfig.execution_mode = 'server';
     }
 
+    // HC-COMM-010 C0: composition transports — INERT until C1 reads them.
+    // Overlays: .hone-local/ is adopter disk the server can never read
+    // (the cross-validation finding), so raw texts travel in run config —
+    // the codebaseFiles pattern, size/count-capped, degrade-to-empty.
+    // Axes: explicit --axes flag for now; automated wiring from classify
+    // runs is future work (documented in the sprint plan).
+    try {
+      const { readRuleOverlays } = require('./lib/overlay-transport');
+      const ov = readRuleOverlays(process.cwd());
+      if (ov.overlays.length > 0) {
+        orchestrateConfig.rule_overlays = ov.overlays;
+        console.log(`  → bundled ${ov.overlays.length} rule overlay(s) for server-side composition`);
+      }
+      for (const skip of ov.skipped) console.warn(`  ⚠ overlay skipped: ${skip}`);
+    } catch (e) {
+      console.warn(`  ⚠ overlay read failed (non-fatal): ${(e && e.message || String(e)).split('\n')[0]}`);
+    }
+    if (opts.axes) {
+      const axes = String(opts.axes).split(',').map(a => a.trim().toLowerCase()).filter(Boolean);
+      if (axes.length > 0) orchestrateConfig.classifier_axes = axes;
+    }
+
     // HC-019n-followup-28: resolve the E2E spec-generation mode (step_3b /
     // Playwright). Precedence mirrors ci.gate: per-run flag > .pipeline-config.yml
     // `e2e.spec_generation` > default `auto`. `auto` = the orchestrator runs
@@ -6010,6 +6100,12 @@ program
 
         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

package/lib/editor-park.js

@@ -0,0 +1,43 @@
+'use strict';
+/**
+ * editor-park.js — HC-COMM-010-followup-1: recognize a run that is PARKED FOR
+ * THE EDITOR (execution.mode: editor, step awaiting_editor) and say what to do.
+ *
+ * Why: the run-status endpoint reports an editor-parked run as
+ * `paused` + `awaitingApproval: true` (it IS at a gate, just not one a human
+ * approves) — so run-story's poll loop used to print "--approve" guidance,
+ * which the B4 guard then refuses. Detection keys on the CURRENT step's
+ * status, reliable since HC-019n-followup-40 collapsed steps[] to the latest
+ * attempt. Pure: no I/O, no process access — the CLI decides how to exit.
+ */
+const EDITOR_PARKED_EXIT_CODE = 3; // distinct from 2 (paused at a human gate)
+
+function currentStep(status) {
+  if (!status || !Array.isArray(status.steps)) return null;
+  return status.steps.find(s => s && s.stepKey === status.currentStep) || null;
+}
+
+/** @returns {boolean} true when the run is paused because the editor owes output */
+function isEditorParked(status) {
+  if (!status || status.status !== 'paused') return false;
+  const step = currentStep(status);
+  return !!(step && step.status === 'awaiting_editor');
+}
+
+/**
+ * The parked-state copy (ux-copy pass, 2026-09-05): what happened, where it is,
+ * the two ways forward (editor MCP tools / CLI verbs), and the closing step.
+ */
+function editorParkedGuidance(runId, stepKey, agent) {
+  const a = agent ? ` (${agent})` : '';
+  return [
+    `⏸ Parked for your editor at ${stepKey}${a} — this step runs in your editor AI, not on Hone.`,
+    `  In Claude Code:  call hone_step_instruction, build the step there, then hone_submit_step.`,
+    `  From the CLI:    hone step-instruction ${runId}`,
+    `                   … build … then: hone submit-step ${runId} ${stepKey} --file out.md`,
+    `  When submitted:  hone run-story ${runId} --approve ${stepKey}`,
+    `  Guide: docs/runbooks/editor-mode.md`,
+  ].join('\n');
+}
+
+module.exports = { EDITOR_PARKED_EXIT_CODE, isEditorParked, editorParkedGuidance, currentStep };

package/lib/editor-stub.js

@@ -0,0 +1,44 @@
+'use strict';
+/**
+ * editor-stub.js — HC-COMM-010 P3: thin-stub content for editor-side agents.
+ *
+ * When a repo opts into `execution.mode: editor`, the agents of the server's
+ * EDITOR_SIDE_STEPS are DELIVERED AT RUNTIME (ephemeral, via
+ * `hone step-instruction` / the hone_step_instruction MCP tool) — so `hone
+ * sync` ships a stub instead of persisting the full prompt to disk. This
+ * closes the dominant prompt-exposure leak for editor-mode repos (memo §5 /
+ * analysis G1) WITHOUT touching server-mode repos, whose adopters use the
+ * full synced prompts for daily editor-chat work.
+ *
+ * EDITOR_STUBBED_AGENTS must stay equal to the agents of the server's
+ * EDITOR_SIDE_STEPS (orchestrator.js) — pinned by a regression test that
+ * derives the truth from workflow-dag, since the two packages share no lib.
+ */
+
+const EDITOR_STUBBED_AGENTS = Object.freeze(['code-builder']);
+
+function isEditorStubbedAgent(agent, executionMode) {
+  return executionMode === 'editor' && EDITOR_STUBBED_AGENTS.includes(agent);
+}
+
+function editorStubContent(agent) {
+  return [
+    `# ${agent} — served at runtime by Hone (editor mode)`,
+    '',
+    'This repo runs with `execution.mode: editor`, so this agent\'s pipeline',
+    'instruction is COMPOSED SERVER-SIDE and delivered ephemerally at',
+    'invocation time — it is not stored on disk.',
+    '',
+    'To execute a parked step:',
+    '  1. `hone step-instruction <runId>`   (or the hone_step_instruction MCP tool)',
+    '  2. run the returned instruction in your editor',
+    '  3. `hone submit-step <runId> <stepKey> --file <output>`',
+    '',
+    'Output is judged by real verification (check-patch / verify-patch),',
+    'never taken on trust. Switch `execution.mode` back to `server` and',
+    're-run `hone sync` to restore the full local prompt.',
+    '',
+  ].join('\n');
+}
+
+module.exports = { EDITOR_STUBBED_AGENTS, isEditorStubbedAgent, editorStubContent };

package/lib/mcp-config.js

@@ -0,0 +1,41 @@
+'use strict';
+/**
+ * mcp-config.js — HC-COMM-010-followup-3: register the Hone MCP server for
+ * Claude Code by writing a PROJECT-scoped `.mcp.json` when the repo runs in
+ * editor mode. Replaces the manual `claude mcp add hone -- hone-mcp` step.
+ *
+ * Contract: merge, never clobber. Other servers in an existing `.mcp.json` are
+ * preserved; only the `hone` entry is added/refreshed; a malformed file is left
+ * untouched (fail-open with a reason). Pure over an injected repoRoot.
+ */
+const fs = require('node:fs');
+const path = require('node:path');
+
+const MCP_FILE = '.mcp.json';
+const HONE_SERVER = Object.freeze({ command: 'hone-mcp', args: [] });
+const FALLBACK_LINE = 'claude mcp add hone -- hone-mcp';
+
+function ensureClaudeMcpConfig(repoRoot, { mode } = {}) {
+  if (mode !== 'editor') return { action: 'skipped', reason: 'execution.mode is not editor' };
+  const file = path.join(repoRoot, MCP_FILE);
+  let doc = { mcpServers: {} };
+  if (fs.existsSync(file)) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+      if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error('not an object');
+      doc = parsed;
+      if (!doc.mcpServers || typeof doc.mcpServers !== 'object' || Array.isArray(doc.mcpServers)) doc.mcpServers = {};
+    } catch (e) {
+      return { action: 'skipped', reason: `${MCP_FILE} is not valid JSON (${e.message}); left untouched — register manually: ${FALLBACK_LINE}` };
+    }
+  }
+  const existing = doc.mcpServers.hone;
+  if (existing && existing.command === HONE_SERVER.command && JSON.stringify(existing.args || []) === '[]') {
+    return { action: 'unchanged', file };
+  }
+  doc.mcpServers.hone = { ...HONE_SERVER, args: [] };
+  fs.writeFileSync(file, JSON.stringify(doc, null, 2) + '\n');
+  return { action: existing ? 'updated' : 'written', file };
+}
+
+module.exports = { ensureClaudeMcpConfig, MCP_FILE, HONE_SERVER, FALLBACK_LINE };

package/lib/overlay-transport.js

@@ -0,0 +1,40 @@
+'use strict';
+/**
+ * overlay-transport.js — HC-COMM-010 C0: read adopter rule-overlays for
+ * transport to the server at run creation.
+ *
+ * `.hone-local/rule-overlays/*.md` lives on ADOPTER DISK — the server can
+ * never read it (the cross-validation finding that refuted "merge overlays
+ * server-side" as originally sketched). So the CLI bundles the raw overlay
+ * texts into orchestrateConfig, exactly the codebaseFiles/§12-A3 transport
+ * pattern. Parsing (front-matter, insertion targets) happens SERVER-side in
+ * C1 via the mergeOverlays machinery — this reader stays deliberately dumb:
+ * raw {name, content} pairs, size/count-capped, degrade-to-empty on every
+ * failure path.
+ */
+const fs = require('node:fs');
+const path = require('node:path');
+
+const DEFAULT_MAX_FILES = 10;
+const DEFAULT_MAX_TOTAL_BYTES = 50_000; // mirrors the codebaseFiles budget
+
+function readRuleOverlays(repoRoot, { maxFiles = DEFAULT_MAX_FILES, maxTotalBytes = DEFAULT_MAX_TOTAL_BYTES } = {}) {
+  const result = { overlays: [], skipped: [] };
+  if (!repoRoot || typeof repoRoot !== 'string') return result;
+  const dir = path.join(repoRoot, '.hone-local', 'rule-overlays');
+  let names;
+  try { names = fs.readdirSync(dir).filter(n => n.endsWith('.md')).sort(); } catch { return result; }
+  let total = 0;
+  for (const name of names) {
+    if (result.overlays.length >= maxFiles) { result.skipped.push(`${name} (file cap ${maxFiles})`); continue; }
+    let content;
+    try { content = fs.readFileSync(path.join(dir, name), 'utf8'); } catch { result.skipped.push(`${name} (unreadable)`); continue; }
+    const bytes = Buffer.byteLength(content, 'utf8');
+    if (total + bytes > maxTotalBytes) { result.skipped.push(`${name} (byte budget ${maxTotalBytes})`); continue; }
+    total += bytes;
+    result.overlays.push({ name, content });
+  }
+  return result;
+}
+
+module.exports = { readRuleOverlays, DEFAULT_MAX_FILES, DEFAULT_MAX_TOTAL_BYTES };

package/package.json

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