@event4u/agent-config 16.2.0 → 16.3.0

package/dist/cli/registry.js

@@ -94,7 +94,7 @@ export const REGISTRY = [
     { name: 'memory:hash', disposition: 'delegate', synopsis: 'Hash a memory entry (YAML or JSON stdin).' },
     { name: 'memory:check', disposition: 'delegate', synopsis: 'Validate memory YAML schema + staleness.' },
     { name: 'memory:check-proposal', disposition: 'delegate', synopsis: 'Run the admission gate on a memory proposal.' },
-    { name: 'memory:learn', disposition: 'delegate', synopsis: 'Aggregate memory intake signals into the local learning sidecar (read-only; --write to emit).' },
+    { name: 'memory:learn', disposition: 'delegate', synopsis: 'Aggregate memory intake signals into the local learning sidecar (read-only; --write to emit, --format status for the one-screen view).' },
     { name: 'analytics', disposition: 'delegate', synopsis: 'Local-only workspace analytics: emit|show|prune|migrate (never leaves the machine).' },
     { name: 'knowledge', disposition: 'delegate', synopsis: 'Global knowledge-card store: list|show|trace|forget|promote|validate|lead-check|purge.' },
     { name: 'proposal:check', disposition: 'delegate', synopsis: 'Validate a learning/skill/rule proposal markdown.' },

package/dist/cli-delegate/archive_completed_roadmaps.js

@@ -1,10 +1,16 @@
 #!/usr/bin/env tsx
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  BLOCK_END_RE,
+  DEFERRED_RESOLUTION_RE,
+  DEFERRED_STEP_RE,
+  planCarry
+} from "./chunk-7IQE3D5S.js";
 import {
   blocker_is_resolved,
   collect,
   parse_blockers
-} from "./chunk-QAJS5YWY.js";
+} from "./chunk-PHD7OOLE.js";
 import "./chunk-ULET4BYS.js";
 import {
   isCliEntry
@@ -199,9 +205,6 @@ function _fs_grep_files(root, needle) {
   walk(root);
   return hits;
 }
-var DEFERRED_RESOLUTION_RE = /<!--\s*deferred-resolution:\s*(carried-to|merged-into)\s*=\s*([A-Za-z0-9._-]+)\s*-->/;
-var DEFERRED_STEP_RE = /^[ \t]*[-*][ \t]+\[~\][ \t]*(.*)$/;
-var BLOCK_END_RE = /^[ \t]*[-*][ \t]+\[[ xX~-]\]|^#{1,6}[ \t]/;
 function _escapeRe(v) {
   return v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -292,6 +295,7 @@ function deferralProblems(root, rel, text, alsoArchiving = /* @__PURE__ */ new S
 }
 function archive_completed(root, opts) {
   const { changed_only, base, dry_run } = opts;
+  const carry = opts.carry ?? true;
   const roadmap_root = path.join(root, "agents", "roadmaps");
   if (!_isDir(roadmap_root)) {
     return [];
@@ -308,8 +312,10 @@ function archive_completed(root, opts) {
     collect(roadmap_root).filter((s2) => s2.open_ === 0).map((s2) => s2.rel.replace(/\.md$/, ""))
   );
   const archived = [];
+  const only = opts.only ? opts.only.replace(/^.*\//, "").replace(/\.md$/, "") + ".md" : null;
   for (const stats of collect(roadmap_root)) {
-    const roadmapText = fs.readFileSync(path.join(roadmap_root, stats.rel), "utf-8");
+    if (only !== null && stats.rel !== only) continue;
+    let roadmapText = fs.readFileSync(path.join(roadmap_root, stats.rel), "utf-8");
     const guarded = parseGuardedBaselines(roadmapText);
     if (guarded.length > 0) {
       process.stderr.write(
@@ -325,11 +331,41 @@ function archive_completed(root, opts) {
     if (stats.open_ !== 0) {
       continue;
     }
+    const old_rel = `agents/roadmaps/${stats.rel}`;
+    let open_blockers = stats.open_blockers.map((b) => b.id);
     if (stats.deferred !== 0) {
       const abs = path.join(roadmap_root, stats.rel);
       const others = new Set(sweepSet);
       others.delete(stats.rel.replace(/\.md$/, ""));
-      const problems = deferralProblems(root, stats.rel, fs.readFileSync(abs, "utf-8"), others);
+      const inScope = !changed_only || touched.has(old_rel);
+      const bare = parseDeferredItems(roadmapText).some((d) => d.kind === null);
+      if (carry && inScope && bare) {
+        const outcome = planCarry(root, stats.rel, roadmapText, open_blockers, _today(), opts.owner_decision ?? "ask");
+        if ("refused" in outcome) {
+          process.stderr.write(`  \u26A0\uFE0F  ${stats.rel}: deferrals not carried \u2014 ${outcome.refused}.
+`);
+        } else if (outcome.plan.ownerBlockers.length > 0 && !outcome.plan.parked) {
+          process.stdout.write(_ownerDecisionBlock(stats.rel, outcome.plan));
+          continue;
+        } else {
+          const { plan } = outcome;
+          process.stdout.write(
+            `  \u21AA  ${stats.rel}: carried ${plan.carried} deferred step(s)` + (plan.movedBlockers.length > 0 ? ` and blocker(s) ${plan.movedBlockers.join(", ")}` : "") + ` \u2192 ${plan.destRel}
+`
+          );
+          if (dry_run) {
+            archived.push({ roadmap: old_rel, archived_to: `agents/roadmaps/archive/${stats.rel}`, refs_migrated: [] });
+            continue;
+          }
+          fs.mkdirSync(path.dirname(path.join(root, plan.destRel)), { recursive: true });
+          fs.writeFileSync(path.join(root, plan.destRel), plan.destText, "utf-8");
+          fs.writeFileSync(abs, plan.sourceText, "utf-8");
+          _run(["git", "add", "--", plan.destRel, old_rel], root);
+          roadmapText = plan.sourceText;
+          open_blockers = open_blockers.filter((id) => !plan.movedBlockers.includes(id));
+        }
+      }
+      const problems = deferralProblems(root, stats.rel, roadmapText, others);
       if (problems.length > 0) {
         process.stderr.write(
           `  \u26A0\uFE0F  ${stats.rel}: ${problems.length} unresolved deferral(s) \u2014 not archived.
@@ -340,16 +376,14 @@ function archive_completed(root, opts) {
         continue;
       }
     }
-    const open_blockers = stats.open_blockers;
     if (open_blockers.length > 0) {
-      const ids = open_blockers.map((b) => b.id).join(", ");
+      const ids = open_blockers.join(", ");
       process.stderr.write(
         `  \u26A0\uFE0F  ${stats.rel}: all steps closed but ${open_blockers.length} blocker(s) still open (${ids}) \u2014 not archived. Resolve them, or record the decision, then re-run the sweep.
 `
       );
       continue;
     }
-    const old_rel = `agents/roadmaps/${stats.rel}`;
     if (changed_only && !touched.has(old_rel)) {
       continue;
     }
@@ -383,6 +417,29 @@ function archive_completed(root, opts) {
   }
   return archived;
 }
+function _ownerDecisionBlock(rel, plan) {
+  const ids = plan.ownerBlockers.join(", ");
+  const park = `agents/roadmaps/later/${plan.destSlug}.md`;
+  const step = plan.firstStep.split("\n").map((l) => `             ${l}`).join("\n");
+  const record = {
+    roadmap: `agents/roadmaps/${rel}`,
+    owner_blockers: plan.ownerBlockers,
+    deferred_steps: plan.carried,
+    park_to: park,
+    archive_command: `./agent-config roadmap:archive --all --owner-decision later --only ${rel}`,
+    first_step: plan.firstStep
+  };
+  return `  \u2753  ${rel}: ${plan.carried} deferred step(s) wait on owner blocker(s) ${ids} \u2014 not archived; the owner decides:
+        1. Archive it \u2014 the steps and their blockers park in ${park}
+           (${record.archive_command})
+        2. Work them step by step, starting with:
+${step}
+  OWNER-DECISION ${JSON.stringify(record)}
+`;
+}
+function _today() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
 function _isDir(p) {
   try {
     return fs.statSync(p).isDirectory();
@@ -443,13 +500,16 @@ function _runTwin(root, script) {
 }
 var _PROG = "archive_completed_roadmaps.py";
 function _usage() {
-  return `usage: ${_PROG} [-h] [--all] [--base BASE] [--dry-run] [--repo-root REPO_ROOT]
+  return `usage: ${_PROG} [-h] [--all] [--base BASE] [--dry-run] [--no-carry] [--owner-decision later] [--only ROADMAP] [--repo-root REPO_ROOT]
 `;
 }
 function _parseArgs(argv) {
   let all = false;
   let base = "origin/main";
   let dry_run = false;
+  let carry = true;
+  let owner_decision = "ask";
+  let only = null;
   let repo_root = null;
   const emitError = (msg) => {
     process.stderr.write(_usage());
@@ -469,6 +529,23 @@ function _parseArgs(argv) {
     } else if (tok === "--dry-run") {
       dry_run = true;
       i += 1;
+    } else if (tok === "--no-carry") {
+      carry = false;
+      i += 1;
+    } else if (tok === "--only" || tok.startsWith("--only=")) {
+      const val = tok.includes("=") ? tok.slice(tok.indexOf("=") + 1) : argv[i + 1];
+      if (val === void 0 || val === "") {
+        emitError("argument --only: expected one argument");
+      }
+      only = val;
+      i += tok.includes("=") ? 1 : 2;
+    } else if (tok === "--owner-decision" || tok.startsWith("--owner-decision=")) {
+      const val = tok.includes("=") ? tok.slice(tok.indexOf("=") + 1) : argv[i + 1];
+      if (val !== "later" && val !== "ask") {
+        emitError("argument --owner-decision: expected 'later' or 'ask'");
+      }
+      owner_decision = val;
+      i += tok.includes("=") ? 1 : 2;
     } else if (tok === "--base") {
       const val = argv[i + 1];
       if (val === void 0) {
@@ -493,7 +570,7 @@ function _parseArgs(argv) {
       emitError(`unrecognized arguments: ${tok}`);
     }
   }
-  return { all, base, dry_run, repo_root };
+  return { all, base, dry_run, carry, owner_decision, only, repo_root };
 }
 function main(argv) {
   const ns = _parseArgs(argv ?? process.argv.slice(2));
@@ -501,7 +578,10 @@ function main(argv) {
   const archived = archive_completed(root, {
     changed_only: !ns.all,
     base: ns.base,
-    dry_run: ns.dry_run
+    dry_run: ns.dry_run,
+    carry: ns.carry,
+    owner_decision: ns.owner_decision,
+    only: ns.only
   });
   if (archived.length === 0) {
     process.stdout.write("  \u2139\uFE0F  No completed roadmaps to archive.\n");

package/dist/cli-delegate/check_update_banner.js

@@ -267,7 +267,18 @@ var MERGEABLE_KEYS = [
   // be followed. Class C, so a user still sets it by hand or through the
   // GUI; whitelisting decides only whether the value SURVIVES the merge
   // (ADR-271, road-to-design-intent-conformance 2.3).
-  "design.fidelity_mode"
+  "design.fidelity_mode",
+  // `lean_projection.*` is a per-MACHINE setting and the install it governs is
+  // a user-scope one: the layer being thinned is `~/.claude/rules`, which
+  // belongs to the machine and not to any checkout. Without these two rows a
+  // consumer who wrote the opt-in into the user-global file got no error, no
+  // warning and no effect — the same silent-filter defect the two entries
+  // above repair, reaching a third key, and unsatisfiable-by-construction on
+  // an ADR-020 global-only install, where no project layer exists to carry it.
+  // Whitelisting decides only whether a value SURVIVES the merge: it sets
+  // nothing, and `installerThinsHost` still refuses a template-only value.
+  "lean_projection.mode",
+  "lean_projection.hosts"
 ];
 var TEMPLATE_RELATIVE = path2.join("src", "config", "agent-settings.template.yml");
 var _PACKAGE_ROOT = path2.resolve(path2.dirname(fileURLToPath(import.meta.url)), "..", "..", "..");

package/dist/cli-delegate/chunk-523HCFYO.js

@@ -0,0 +1,90 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/install/plan.ts
+import { createHash } from "node:crypto";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+function sha256File(path) {
+  try {
+    const data = readFileSync(path);
+    return createHash("sha256").update(data).digest("hex");
+  } catch {
+    return null;
+  }
+}
+function fileEntry(path, kind, options) {
+  return {
+    path,
+    kind,
+    sha256: options.hashContent ? sha256File(path) : null
+  };
+}
+function walkSourceTree(dir) {
+  const out = [];
+  walkInto(dir, out);
+  return out;
+}
+function walkInto(dir, out) {
+  let entries;
+  try {
+    entries = readdirSync(dir).sort();
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    const full = join(dir, name);
+    let isDir;
+    try {
+      isDir = statSync(full).isDirectory();
+    } catch {
+      continue;
+    }
+    if (isDir) {
+      walkInto(full, out);
+    } else {
+      out.push(full);
+    }
+  }
+}
+function buildInstallPlan(inputs) {
+  const filesByTool = {};
+  for (const source of inputs.sources) {
+    const bucket = filesByTool[source.toolId] ?? [];
+    let files = walkSourceTree(source.srcDir);
+    if (source.fileFilter !== void 0) {
+      files = files.filter(source.fileFilter);
+    }
+    for (const srcFile of files) {
+      const rel = relative(source.srcDir, srcFile);
+      const destPath = resolve(source.destDir, rel);
+      bucket.push(
+        fileEntry(srcFile, source.kind, {
+          hashContent: source.kind !== "bridge"
+        })
+      );
+      bucket[bucket.length - 1] = {
+        ...bucket[bucket.length - 1],
+        path: destPath
+      };
+    }
+    filesByTool[source.toolId] = bucket;
+  }
+  for (const source of inputs.sources) {
+    if (!(source.toolId in filesByTool)) {
+      filesByTool[source.toolId] = [];
+    }
+  }
+  return {
+    version: 2,
+    target: inputs.target,
+    root: inputs.root,
+    filesByTool,
+    mergedKeysByTool: {},
+    policy: inputs.policy
+  };
+}
+
+export {
+  sha256File,
+  buildInstallPlan
+};

package/dist/cli-delegate/{chunk-M2DPGFZ4.js → chunk-6V6TA25H.js}

@@ -1,4 +1,23 @@
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  DEFAULT_GITIGNORE,
+  DEFAULT_TEMPLATE,
+  LEGACY_PATTERNS,
+  SECTION_FOOTER,
+  SECTION_HEADER,
+  TemplateNotFoundError,
+  _isFile,
+  _splitlines,
+  _strip,
+  block_entries,
+  build_fresh_block,
+  cleanup_legacy,
+  find_block,
+  format_file,
+  load_template,
+  sync_block,
+  template_entries
+} from "./chunk-ULQRUR23.js";
 import {
   resolvePackageRoot
 } from "./chunk-MCJYCQPF.js";
@@ -82,156 +101,7 @@ import * as fs2 from "node:fs";
 import * as path2 from "node:path";
 import process from "node:process";
 import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
-var SECTION_HEADER = "# event4u/agent-config";
-var SECTION_FOOTER = "# event4u/agent-config \u2014 END";
-var DEFAULT_GITIGNORE = ".gitignore";
 var _HERE = fileURLToPath2(import.meta.url);
-var DEFAULT_TEMPLATE = path2.join(
-  path2.dirname(_HERE),
-  "..",
-  "..",
-  "src",
-  "config",
-  "gitignore-block.txt"
-);
-var LEGACY_PATTERNS = [
-  ".agent-chat-history",
-  ".agent-chat-history.bak",
-  ".agent-chat-history.*.bak",
-  ".agent-prices.md",
-  ".council-tmp/",
-  // 2.x intermediate: prices cache lived directly under agents/ before
-  // consolidating under agents/runtime/.
-  "agents/.agent-prices.md",
-  // Budget history JSONLs — previously listed explicitly at project
-  // root or under agents/; now covered by the /agents/runtime/
-  // catch-all in the managed block.
-  ".augment-budget-history.jsonl",
-  ".rule-budget-history.jsonl",
-  "agents/.augment-budget-history.jsonl",
-  "agents/.rule-budget-history.jsonl"
-];
-function _strip(ln) {
-  return ln.replace(/\n+$/, "").replace(/\s+$/, "");
-}
-function _is_entry(ln) {
-  const s = _strip(ln).replace(/^\s+/, "");
-  return Boolean(s) && !s.startsWith("#");
-}
-var TemplateNotFoundError = class extends Error {
-  constructor(p) {
-    super(`template not found: ${p}`);
-    this.name = "TemplateNotFoundError";
-  }
-};
-function _isFile(p) {
-  try {
-    return fs2.statSync(p).isFile();
-  } catch {
-    return false;
-  }
-}
-function _splitlines(text) {
-  if (text === "") return [];
-  const parts = text.split(/\r\n|\r|\n/);
-  if (parts.length > 0 && parts[parts.length - 1] === "") parts.pop();
-  return parts;
-}
-function load_template(p) {
-  if (!_isFile(p)) {
-    throw new TemplateNotFoundError(p);
-  }
-  const text = fs2.readFileSync(p, "utf-8");
-  return _splitlines(text).map(_strip);
-}
-function find_block(lines) {
-  for (let i = 0; i < lines.length; i += 1) {
-    if (_strip(lines[i]) === SECTION_HEADER) {
-      const start = i;
-      for (let j = i + 1; j < lines.length; j += 1) {
-        if (_strip(lines[j]) === SECTION_FOOTER) {
-          return [start, j + 1];
-        }
-      }
-      let end = lines.length;
-      for (let j = i + 1; j < lines.length; j += 1) {
-        const s = _strip(lines[j]).replace(/^\s+/, "");
-        if (s.startsWith("#") && !s.startsWith("# Agent config") && s !== SECTION_HEADER) {
-          end = j;
-          while (end > i + 1 && _strip(lines[end - 1]) === "") {
-            end -= 1;
-          }
-          break;
-        }
-      }
-      return [start, end];
-    }
-  }
-  return null;
-}
-function block_entries(block_lines) {
-  return block_lines.filter((ln) => _is_entry(ln)).map((ln) => _strip(ln).replace(/^\s+/, ""));
-}
-function template_entries(template_lines) {
-  return template_lines.filter((ln) => _is_entry(ln)).map((ln) => ln.replace(/^\s+/, ""));
-}
-function build_fresh_block(template_lines) {
-  return [SECTION_HEADER, ...template_lines, SECTION_FOOTER];
-}
-function sync_block(existing_lines, template_lines, options = {}) {
-  const replace = options.replace ?? false;
-  const loc = find_block(existing_lines);
-  const fresh = build_fresh_block(template_lines);
-  if (loc === null) {
-    const newLines = [...existing_lines];
-    if (newLines.length > 0 && _strip(newLines[newLines.length - 1]) !== "") {
-      newLines.push("");
-    }
-    newLines.push(...fresh);
-    return [newLines, template_entries(template_lines)];
-  }
-  const [start, end] = loc;
-  const head = existing_lines.slice(0, start);
-  let block = existing_lines.slice(start, end);
-  const tail = existing_lines.slice(end);
-  if (replace) {
-    const existing = new Set(block_entries(block));
-    const added = template_entries(template_lines).filter((e) => !existing.has(e));
-    return [[...head, ...fresh, ...tail], added];
-  }
-  const existing_entries = new Set(block_entries(block));
-  const missing = template_entries(template_lines).filter((e) => !existing_entries.has(e));
-  if (missing.length === 0) {
-    return [[...existing_lines], []];
-  }
-  let insert_at;
-  if (block.length > 0 && _strip(block[block.length - 1]) === SECTION_FOOTER) {
-    insert_at = block.length - 1;
-  } else {
-    block = [...block, SECTION_FOOTER];
-    insert_at = block.length - 1;
-  }
-  const new_block = [...block.slice(0, insert_at), ...missing, ...block.slice(insert_at)];
-  return [[...head, ...new_block, ...tail], missing];
-}
-function cleanup_legacy(lines) {
-  const legacy = new Set(LEGACY_PATTERNS);
-  const kept = [];
-  const removed = [];
-  for (const ln of lines) {
-    const s = _strip(ln).replace(/^\s+/, "");
-    if (legacy.has(s) || s.startsWith("/") && legacy.has(s.slice(1))) {
-      removed.push(s);
-      continue;
-    }
-    kept.push(ln);
-  }
-  return [kept, removed];
-}
-function format_file(lines) {
-  const text = lines.join("\n");
-  return text.replace(/\n+$/, "") + "\n";
-}
 function render_diff(old_text, new_text, p) {
   return unified_diff(
     _splitlinesKeepends(old_text),
@@ -591,7 +461,7 @@ var DEFAULT_TEMPLATE2 = path3.join(
 function _strip2(ln) {
   return ln.replace(/\n+$/, "").replace(/\s+$/, "");
 }
-function _is_entry2(ln) {
+function _is_entry(ln) {
   const s = _strip2(ln).replace(/^\s+/, "");
   return Boolean(s) && !s.startsWith("#");
 }
@@ -635,10 +505,10 @@ function find_block2(lines) {
   return null;
 }
 function block_entries2(block_lines) {
-  return block_lines.filter((ln) => _is_entry2(ln)).map((ln) => _strip2(ln).replace(/^\s+/, ""));
+  return block_lines.filter((ln) => _is_entry(ln)).map((ln) => _strip2(ln).replace(/^\s+/, ""));
 }
 function template_entries2(template_lines) {
-  return template_lines.filter((ln) => _is_entry2(ln)).map((ln) => ln.replace(/^\s+/, ""));
+  return template_lines.filter((ln) => _is_entry(ln)).map((ln) => ln.replace(/^\s+/, ""));
 }
 function build_fresh_block2(template_lines) {
   return [SECTION_HEADER2, ...template_lines, SECTION_FOOTER2];