@event4u/agent-config 16.1.0 → 16.3.0

package/dist/agent-src/templates/scripts/work_engine/taxonomy/place.ts

@@ -0,0 +1,183 @@
+/**
+ * Placing a new component inside the taxonomy a project already chose.
+ *
+ * Leaf module — no intra-`work_engine` imports beyond its sibling detector's
+ * `NO_TAXONOMY` constant. That one import does pull `node:fs` in transitively;
+ * "stdlib-free" was the old wording here and it was simply wrong. Public API names stay snake_case to
+ * mirror the sibling detectors 1:1, per ADR-200.
+ *
+ * The contract, and the reason it is this small: placement reads the RECORDED
+ * tier list by name and conforms to whatever it holds. There is no table of
+ * tier names here, no ordering, no per-tier rule, and no numeric budget keyed
+ * to a tier — a component is placed when the brief names a tier the project
+ * has, and is reported as a gap when it does not. Anything richer would be the
+ * compiled-in taxonomy this suite refused to hard-code, arriving as an
+ * implementation detail rather than as a decision.
+ *
+ * That is also why an unplaceable component is never quietly put somewhere
+ * else. Choosing a tier for it would need exactly the per-tier rule the line
+ * above rules out, so the honest output is a named gap the author resolves.
+ *
+ * With {@link NO_TAXONOMY} recorded — the value for a project that evidences
+ * no taxonomy — every plan comes back empty and {@link conformance_lines}
+ * returns nothing, so the authoring step's output is byte-identical to what it
+ * was before this module existed. Holding to the project's own structures is
+ * the standing rule; a project that organises its components some other way
+ * must not be able to tell that this module shipped.
+ */
+import { NO_TAXONOMY } from './detect.js';
+
+/** A component the design brief asks for. */
+export interface ComponentRequest {
+    /** The component's name, as the brief writes it. */
+    name?: unknown;
+    /** The granularity tier the brief assigns it, when it assigns one. */
+    tier?: unknown;
+}
+
+/** Where one component lands, or why it could not be placed. */
+export interface PlacementPlan {
+    /** The component's name as read from the brief. */
+    name: string;
+    /** The project's own tier name it was matched to, or `null`. */
+    tier: string | null;
+    /** The directory it belongs in, or `null` when unplaced. */
+    directory: string | null;
+    /** Why it could not be placed, or `null` when it was. */
+    gap: string | null;
+}
+
+/** Component root used when the audit recorded none. */
+/**
+ * Gap reported when a taxonomy is recorded without the root it lives under.
+ *
+ * Guessing `src/components` here is the same failure as placing a component in
+ * a tier the project does not have, at the other end of the path: a project
+ * rooted at `app/components` or `resources/js/components` — both of which the
+ * detector searches — would have been handed a directory that does not exist,
+ * with no gap and no warning. This module exists so nothing is placed
+ * somewhere the project did not choose, so it says so instead.
+ */
+export const MISSING_ROOT_GAP =
+    'the audit recorded a taxonomy but no `component_root`, so there is no ' +
+    'directory to place into — re-run the audit, or record the root by hand';
+
+/**
+ * Plan where each requested component belongs under a recorded taxonomy.
+ *
+ * @param taxonomy The recorded `state.ui_audit.component_taxonomy` value —
+ *   the project's own tiers joined with `/`, or {@link NO_TAXONOMY}.
+ * @param component_root The recorded component root, relative to the project.
+ * @param components The components the design brief asks for.
+ */
+export function plan_component_placement(
+    taxonomy: string,
+    component_root: string,
+    components: ReadonlyArray<ComponentRequest>,
+): PlacementPlan[] {
+    const tiers = read_tiers(taxonomy);
+    const root = _trim_slashes(component_root);
+    return components.map((component) => {
+        const name = _text(component.name) || '(unnamed)';
+        if (tiers.length === 0) {
+            return { name, tier: null, directory: null, gap: null };
+        }
+        if (root === '') {
+            return { name, tier: null, directory: null, gap: `\`${name}\` — ${MISSING_ROOT_GAP}` };
+        }
+        const hint = _text(component.tier);
+        if (hint === '') {
+            return {
+                name,
+                tier: null,
+                directory: null,
+                gap:
+                    `\`${name}\` names no granularity tier, and the project's ` +
+                    `taxonomy \`${taxonomy}\` carries no rule that assigns one ` +
+                    '— left unplaced for the author to decide',
+            };
+        }
+        const matched = tiers.find((tier) => _normalise(tier) === _normalise(hint));
+        if (matched === undefined) {
+            return {
+                name,
+                tier: null,
+                directory: null,
+                gap:
+                    `\`${name}\` declares tier \`${hint}\`, which the project's ` +
+                    `taxonomy \`${taxonomy}\` does not contain — left unplaced ` +
+                    'rather than moved somewhere the project did not choose',
+            };
+        }
+        return { name, tier: matched, directory: `${root}/${matched}`, gap: null };
+    });
+}
+
+/**
+ * Split a recorded taxonomy value into the project's own tier names.
+ *
+ * **The sentinel comparison is case-insensitive, and that is not politeness.**
+ * This field is written by an agent following `existing-ui-audit` § 1b, so
+ * `'None'` is reachable, and an exact comparison let it through as a
+ * one-element tier list: a project with no taxonomy then got a "conforming to
+ * `None`" banner and a conformance gap per component — precisely the output
+ * AC-2 forbids. It is the one guard standing between a no-taxonomy project and
+ * a changed authoring step, so it refuses every spelling of the sentinel.
+ */
+export function read_tiers(taxonomy: string): string[] {
+    const value = _text(taxonomy);
+    if (value === '' || value.toLowerCase() === NO_TAXONOMY) {
+        return [];
+    }
+    return value
+        .split('/')
+        .map((part) => part.trim())
+        .filter((part) => part !== '');
+}
+
+/**
+ * Render the lines the authoring step says out loud.
+ *
+ * Empty for {@link NO_TAXONOMY}, which is what keeps a no-taxonomy project's
+ * output unchanged.
+ */
+export function conformance_lines(
+    taxonomy: string,
+    component_root: string,
+    plans: ReadonlyArray<PlacementPlan>,
+): string[] {
+    if (read_tiers(taxonomy).length === 0) {
+        return [];
+    }
+    const root = _trim_slashes(component_root);
+    const under = root === '' ? 'an unrecorded component root' : `\`${root}/\``;
+    const lines: string[] = [
+        `> Conforming to the project's own component taxonomy ` +
+            `\`${taxonomy}\` under ${under} — detected, not imposed. ` +
+            'A component that fits no tier is reported, never relocated.',
+    ];
+    for (const plan of plans) {
+        if (plan.gap === null && plan.directory !== null) {
+            lines.push(
+                `>   - \`${plan.name}\` → \`${plan.directory}/\` (tier \`${plan.tier}\`)`,
+            );
+        } else if (plan.gap !== null) {
+            lines.push(`>   - conformance gap: ${plan.gap}`);
+        }
+    }
+    return lines;
+}
+
+/** Lower-case and drop a trailing plural `s`, so `Molecule` matches `molecules`. */
+function _normalise(name: string): string {
+    const lower = name.trim().toLowerCase();
+    return lower.endsWith('s') && lower.length > 2 ? lower.slice(0, -1) : lower;
+}
+
+function _text(value: unknown): string {
+    return typeof value === 'string' ? value.trim() : '';
+}
+
+function _trim_slashes(value: unknown): string {
+    return _text(value).replace(/^\/+|\/+$/gu, '');
+}

package/dist/cli/python/knowledge_ingest.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env -S node --import tsx
+#!/usr/bin/env tsx
 /**
  * Local knowledge ingestion — file walk, redaction, chunking, manifest.
  *

package/dist/cli/python/workspace_drive.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env -S node --import tsx
+#!/usr/bin/env tsx
 // Drive-loop era frozen per ADR-206 (2026-08-03): governing ADRs 068/070-084 are
 // superseded — subsystem is beta-internal, bugfix-only; no new capability work.
 /**

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
+};