@event4u/agent-config 16.2.0 → 16.4.0

package/dist/agent-src/templates/skill.md

@@ -163,7 +163,7 @@ Do NOT use when:
   2. Are numbered options absent unless options differ in *consequence*?
   3. Is every cited rule linked, not restated?
   4. {artifact-specific question — e.g., for `command-writing`:
-     "Does the command honor `verbosity.routine_confirmations: false`?"}
+     "Does the command skip confirmation on routine one-answer steps?"}
   5. {artifact-specific question — e.g., for `rule-writing`:
      "Does the rule body open with the Iron Law, no preamble?"}
 -->

package/dist/cli/registry.js

@@ -25,6 +25,7 @@ export const REGISTRY = [
     { name: 'settings:sync', disposition: 'delegate', synopsis: 'Additively merge new template keys into an existing .agent-settings.yml.' },
     { name: 'settings:migrate', disposition: 'delegate', synopsis: 'Lift legacy project-local settings into ~/.event4u/agent-config/.' },
     { name: 'settings:get', disposition: 'delegate', synopsis: 'Read one setting: value, resolved source file, class, and absent-vs-default divergence.' },
+    { name: 'git:convention', disposition: 'delegate', synopsis: 'The git convention: show the keys, check subjects, read a ticket, render a branch name, measure the history.' },
     { name: 'settings:set', disposition: 'delegate', synopsis: 'Set one A/B-class setting in the global file; C-class keys are refused.' },
     { name: 'uninstall', disposition: 'delegate', synopsis: 'Remove bridge markers (project) or lockfile entries (global).' },
     { name: 'prune', disposition: 'delegate', synopsis: 'Remove project bridge markers not declared in installed-tools.lock.' },
@@ -94,7 +95,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");