@hone-ai/cli 1.34.0 → 1.35.1

package/lib/promote-payload.js

@@ -0,0 +1,77 @@
+'use strict';
+/**
+ * promote-payload.js — what `hone promote-learnings` sends to `POST /learnings/promote`.
+ *
+ * Extracted by HC-GF-143's batch because HC-GF-136's gate found all seven fields computed inline
+ * and asserted by nothing: deleting any of them broke no test.
+ *
+ * This mapping is an IP BOUNDARY, which is why it is the one to extract first. A learning carries
+ * BOTH `local_summary` (this repo's specifics — paths, story ids, internal detail) and
+ * `enterprise_summary` (the generalised rule). Only the second may leave the machine. A rename, a
+ * copy-paste, or a spread of the whole object would ship the first, and nothing would have noticed.
+ */
+
+/** Fields that may cross to the server. Anything not named here does not leave. */
+const PROMOTED_FIELDS = Object.freeze([
+  'id', 'repo_name', 'type', 'agent', 'target_skill', 'target_kind', 'enterprise_summary',
+  'proposed_fix',
+]);
+
+/** A path that looks like a pipeline script, named in prose. */
+// HC-GF-161: `tests` added. A learning whose fix is "extend this regression test" names a real,
+// editable target in exactly the same way a script does, and 3 learnings were unroutable only
+// because this list omitted it. The backticks and the extension list are NOT relaxed: the
+// backticks are what stop this matching prose that merely mentions a file, and the extensions
+// are what stop it claiming a doc, for which there is no kind.
+const SCRIPT_PATH = /`((?:scripts|cli|server|tests|\.github)\/[\w./-]+\.(?:js|mjs|cjs|sh))`/;
+
+/**
+ * HC-GF-159a: WHAT a learning would change, and what it is called.
+ *
+ * A learning is not always about a skill. It can change a skill, an agent's PROMPT, or a pipeline
+ * SCRIPT — and sending only a field named `target_skill` is why all 418 promoted learnings routed
+ * to the server's `|| 'general'` fallback. The kind travels with the name so the far side can tell
+ * "change pipeline-integrity" from "change the code-reviewer prompt" from "change mutate-check.js".
+ *
+ * Order matters: a learning that names a skill targets the skill even when an agent captured it —
+ * `agent:` records WHO noticed, which is not the same as what should change.
+ *
+ * An unroutable learning says `unrouted` rather than borrowing a default. 'general' is a claim that
+ * the lesson belongs everywhere, which is how 418 of them became indistinguishable.
+ */
+function targetOf(l) {
+  // An explicitly-set `target_skill` is the most specific statement of intent there is — a caller
+  // that already decided. Deriving over the top of it silently overrode the decision, which the
+  // HC-GF-143b suite caught when its fixture's `target_skill` was replaced by the agent name.
+  if (l.target_skill) return { kind: 'skill', name: l.target_skill };
+  if (l.referenced_skill) return { kind: 'skill', name: l.referenced_skill };
+  if (l.agent) return { kind: 'prompt', name: l.agent };
+  const m = SCRIPT_PATH.exec(String(l.proposed_fix || ''));
+  if (m) return { kind: 'script', name: m[1] };
+  return { kind: 'unrouted', name: null };
+}
+
+/**
+ * @param {Array<object>} eligible learnings selected for promotion
+ * @returns {Array<object>} one payload row per learning
+ */
+function promotePayload(eligible) {
+  return (eligible || []).map((l) => {
+    const target = targetOf(l);
+    return {
+      id: l.id || l._file,
+      repo_name: l.repo_name,
+      // HC-GF-159a: `type` and `agent` come from the parser now. They were mapped here from names
+      // the parser never emitted, so JSON.stringify dropped them and the server saw `unknown`.
+      type: l.type || null,
+      agent: l.agent || null,
+      // The NAME the far side routes on, whatever kind of thing it is.
+      target_skill: target.name,
+      target_kind: target.kind,
+      enterprise_summary: l.enterprise_summary,
+      proposed_fix: l.proposed_fix || l.absorbed_into || null,
+    };
+  });
+}
+
+module.exports = { promotePayload, PROMOTED_FIELDS, targetOf };

package/lib/refresh-knowledge.js

@@ -24,9 +24,12 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const crypto = require('node:crypto');
-const { execSync } = require('node:child_process');
+const { execFileSync } = require('node:child_process');
 const { gitEnv } = require('./git-env');
 
+// A backup of the knowledge dirs is seconds of work; this only stops a stuck tar holding the run.
+const TAR_TIMEOUT_MS = 2 * 60 * 1000;
+
 // HC-019y (2026-05-29): removed `.github/agents` from refresh paths.
 // Agents live exclusively at `.claude/agents/` (Claude Code's read path)
 // after the install-time mirror was eliminated. `.github/agents/` is now
@@ -42,7 +45,7 @@ const ENTERPRISE_MANAGED_END_RE = /<!--\s*END ENTERPRISE-MANAGED\s*-->/;
 const FRONTMATTER_MANAGED_RE = /^---[\s\S]*?managed_by:\s*\S+[\s\S]*?---/m;
 
 /**
- * Default channel runner — invokes `hone <name>` via execSync.
+ * Default channel runner — invokes `hone <name>` via execFileSync (argv, no shell).
  * Tests inject a fake runner; real CLI uses this default.
  */
 function defaultRunChannel(name, repoRoot) {
@@ -53,7 +56,9 @@ function defaultRunChannel(name, repoRoot) {
     // down an ambient GIT_DIR — under a hook, `rebase -x`, or
     // `submodule foreach` — the child would resolve those against the OUTER
     // repo while we intended repoRoot. Sanitize at the boundary instead.
-    const out = execSync(`node "${cliPath}" ${name}`, {
+    // HC-GF-097-followup-2: argv, not a shell string — double quotes around a path do not
+    // stop `$(...)` or backticks, and a channel name is one argument, not a command line.
+    const out = execFileSync('node', [cliPath, name], {
       cwd: repoRoot,
       env: gitEnv(),
       encoding: 'utf8',
@@ -319,11 +324,14 @@ function createBackup({ repoRoot, backupDir, knowledgeFiles, now }) {
 
   if (relPaths.length === 0) return null;
 
-  // Use system tar for portability
+  // Use system tar for portability. HC-GF-097-followup-2: argv, not a shell string. These are
+  // the adopter repo's own file names, and a double-quoted `$(...)` in one runs as a command.
+  // Every relPath starts with a KNOWLEDGE_DIRS entry, so none can be read as a tar option.
   try {
-    execSync(`tar -czf "${backupPath}" ${relPaths.map(p => `"${p}"`).join(' ')}`, {
+    execFileSync('tar', ['-czf', backupPath, ...relPaths], {
       cwd: repoRoot,
       stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: TAR_TIMEOUT_MS,
     });
   } catch (e) {
     throw new Error(`tar failed: ${e.message}`);
@@ -333,9 +341,10 @@ function createBackup({ repoRoot, backupDir, knowledgeFiles, now }) {
 }
 
 function restoreFromBackup({ repoRoot, backupPath }) {
-  execSync(`tar -xzf "${backupPath}"`, {
+  execFileSync('tar', ['-xzf', backupPath], {
     cwd: repoRoot,
     stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: TAR_TIMEOUT_MS,
   });
 }
 

package/lib/repo-tree.js

@@ -88,6 +88,16 @@ function renderTree(paths, { maxEntries = DEFAULT_MAX_ENTRIES, maxBytes = DEFAUL
 
 const MAX_TRANSPORT_PATHS = 5000;
 const MAX_TRANSPORT_DIRS = 3000;
+// HC-GF-097: a BYTE bound on the two lists, because the count caps alone bound nothing a request
+// body limit can be derived from — 5000 paths can be any length. Sized so the count caps are what
+// normally decides: 8000 entries at 64 bytes each. This repo transports 2,452 paths + 227 dirs in
+// 116,634 bytes (~44 bytes an entry, measured 2026-09-24), well inside it; a 64 KB cap would have
+// dropped both lists here and switched off the server's `## Files` guard on every run. Over the
+// cap the lists are omitted exactly as over the count caps: the server reads v1 and skips the guard.
+const MAX_TRANSPORT_BYTES = (MAX_TRANSPORT_PATHS + MAX_TRANSPORT_DIRS) * 64;
+// The whole transported tree: both lists, the rendered `text`, and the scalar and detected-dir
+// fields (a few hundred bytes on a real repo; 16 KB leaves room for a pathological layout).
+const MAX_TREE_TRANSPORT_BYTES = MAX_TRANSPORT_BYTES + DEFAULT_MAX_BYTES + 16 * 1024;
 
 /**
  * HC-019n-followup-43: every tracked directory repo-wide (minus generated/dependency dirs),
@@ -111,7 +121,7 @@ function allDirs(allPaths) {
  * from v1 (prompt bytes stable). Both lists are capped; over the cap they are omitted and
  * the server treats the tree as v1 (guard skipped, never a false rejection).
  */
-function buildRepoTree(allPaths, { sourceDirs = [], testDirs = [], maxEntries, maxBytes } = {}) {
+function buildRepoTree(allPaths, { sourceDirs = [], testDirs = [], maxEntries, maxBytes, maxTransportBytes = Infinity } = {}) {
   const selected = selectPaths(allPaths, { sourceDirs, testDirs });
   const r = renderTree(selected, { maxEntries, maxBytes });
   const dirs = allDirs(allPaths);
@@ -130,7 +140,13 @@ function buildRepoTree(allPaths, { sourceDirs = [], testDirs = [], maxEntries, m
     shown: r.shown,
     text: r.text,
   };
-  if (selected.length <= MAX_TRANSPORT_PATHS && dirs.length <= MAX_TRANSPORT_DIRS) {
+  // The BYTE cap applies only when the caller passes one: `hone queue-stories`, whose request
+  // limit is derived from it. `hone run-story` sends one story and keeps the count caps alone, as
+  // before HC-GF-097 — review of #1100 found a 4,900-path repository (under both count caps) that
+  // the byte cap would have stripped of its lists, switching off the `## Files` guard on single runs.
+  if (selected.length <= MAX_TRANSPORT_PATHS && dirs.length <= MAX_TRANSPORT_DIRS
+      && (maxTransportBytes === Infinity
+        || Buffer.byteLength(JSON.stringify({ paths: selected, dirs }), 'utf8') <= maxTransportBytes)) {
     tree.paths = selected; tree.dirs = dirs;
   }
   try {
@@ -145,4 +161,7 @@ function buildRepoTree(allPaths, { sourceDirs = [], testDirs = [], maxEntries, m
   return tree;
 }
 
-module.exports = { selectPaths, renderTree, buildRepoTree, allDirs, DEFAULT_MAX_ENTRIES, DEFAULT_MAX_BYTES, MAX_TRANSPORT_PATHS, MAX_TRANSPORT_DIRS };
+module.exports = {
+  selectPaths, renderTree, buildRepoTree, allDirs, DEFAULT_MAX_ENTRIES, DEFAULT_MAX_BYTES,
+  MAX_TRANSPORT_PATHS, MAX_TRANSPORT_DIRS, MAX_TRANSPORT_BYTES, MAX_TREE_TRANSPORT_BYTES,
+};