@event4u/agent-config 16.1.0 → 16.3.0

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];

package/dist/cli-delegate/chunk-7IQE3D5S.js

@@ -0,0 +1,191 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/agent-src/scripts/deferral_carry.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+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]/;
+var BLOCKED_BY_RE = /blocked-by:\s*([A-Za-z0-9._-]+)/g;
+var BLOCKER_HEAD_RE = /^###[ \t]+blocker:[ \t]*(.+?)[ \t]*$/i;
+var STATUS_LINE_RE = /^([ \t]*-[ \t]+\*\*Status:\*\*[ \t]*)(.*)$/;
+var AC_HEADING_RE = /^##[ \t]+acceptance/i;
+var OWNER_LINE_RE = /^[ \t]*-[ \t]+\*\*Owner:\*\*[ \t]*`?([A-Za-z]+)/;
+var AGENT_SIDE_OWNERS = /* @__PURE__ */ new Set(["implementer", "council", "agent", "ai"]);
+var LIGHTWEIGHT_LINE_BUDGET = 500;
+var DISPOSITION_DIRS = ["", "later", "archive", "skipped"];
+function _bareSteps(lines) {
+  const out = [];
+  let inAcceptance = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^##[ \t]/.test(line)) inAcceptance = AC_HEADING_RE.test(line);
+    const m = DEFERRED_STEP_RE.exec(line);
+    if (m === null) continue;
+    let end = i + 1;
+    while (end < lines.length && !BLOCK_END_RE.test(lines[end])) end++;
+    const raw = lines.slice(i, end);
+    if (DEFERRED_RESOLUTION_RE.test(raw.join("\n"))) continue;
+    while (raw.length > 1 && raw[raw.length - 1].trim() === "") raw.pop();
+    const indent = /^[ \t]*/.exec(line)[0].length;
+    const block = raw.map((l) => l.slice(0, indent).trim() === "" ? l.slice(indent) : l);
+    const ids = /* @__PURE__ */ new Set();
+    for (const b of raw) for (const hit of b.matchAll(BLOCKED_BY_RE)) ids.add(hit[1]);
+    out.push({ line: i, block, isAcceptance: inAcceptance, blockerIds: [...ids] });
+  }
+  return out;
+}
+function _blockerSpans(lines) {
+  const start = lines.findIndex((l) => /^##[ \t]+Blockers[ \t]*$/i.test(l));
+  if (start === -1) return [];
+  let sectionEnd = lines.length;
+  for (let i = start + 1; i < lines.length; i++) {
+    if (/^##[ \t]+\S/.test(lines[i])) {
+      sectionEnd = i;
+      break;
+    }
+  }
+  const spans = [];
+  for (let i = start + 1; i < sectionEnd; i++) {
+    const m = BLOCKER_HEAD_RE.exec(lines[i]);
+    if (m === null) continue;
+    let end = i + 1;
+    while (end < sectionEnd && !/^###?[ \t]/.test(lines[end])) end++;
+    const status = lines.slice(i, end).map((l) => STATUS_LINE_RE.exec(l)).find((s) => s !== null);
+    const value = (status?.[2] ?? "open").trim().toLowerCase();
+    const owner = lines.slice(i, end).map((l) => OWNER_LINE_RE.exec(l)).find((o) => o !== null);
+    spans.push({
+      id: m[1].trim(),
+      start: i,
+      end,
+      open: !/^resolved\b/.test(value),
+      ownerDependent: !AGENT_SIDE_OWNERS.has((owner?.[1] ?? "").toLowerCase())
+    });
+  }
+  return spans;
+}
+function _plusDays(date, days) {
+  const d = /* @__PURE__ */ new Date(`${date}T00:00:00Z`);
+  d.setUTCDate(d.getUTCDate() + days);
+  return d.toISOString().slice(0, 10);
+}
+function nextCarrySlug(root, sourceSlug) {
+  const base = sourceSlug.replace(/-carried(-\d+)?$/, "");
+  for (let n = 1; ; n++) {
+    const slug = n === 1 ? `${base}-carried` : `${base}-carried-${n}`;
+    const taken = DISPOSITION_DIRS.some(
+      (d) => fs.existsSync(path.join(root, "agents", "roadmaps", d, `${slug}.md`))
+    );
+    if (!taken) return slug;
+  }
+}
+function _title(sourceText, sourceSlug) {
+  const h1 = /^#[ \t]+(.+?)[ \t]*$/m.exec(sourceText.replace(/^---\n[\s\S]*?\n---\n/, ""));
+  return h1 !== null ? h1[1] : sourceSlug.replace(/-/g, " ");
+}
+function planCarry(root, rel, text, openBlockerIds, date, ownerDecision = "ask") {
+  const sourceSlug = rel.replace(/\.md$/, "");
+  const lines = text.split("\n");
+  const steps = _bareSteps(lines);
+  if (steps.length === 0) return { refused: "no bare `[~]` step to carry" };
+  const named = new Set(steps.flatMap((s) => s.blockerIds));
+  const stranded = openBlockerIds.filter((id) => !named.has(id));
+  if (stranded.length > 0) {
+    return {
+      refused: `open blocker(s) no deferred step names (${stranded.join(", ")}) \u2014 carrying around them would not let this roadmap archive`
+    };
+  }
+  const moved = _blockerSpans(lines).filter((b) => b.open && named.has(b.id));
+  const ownerBlockers = moved.filter((b) => b.ownerDependent).map((b) => b.id);
+  const parked = ownerBlockers.length > 0 && ownerDecision === "later";
+  const destSlug = nextCarrySlug(root, sourceSlug);
+  const annotation = `<!-- deferred-resolution: carried-to=${destSlug} -->`;
+  const out = [...lines];
+  for (const b of moved) {
+    for (let i = b.start; i < b.end; i++) {
+      const s = STATUS_LINE_RE.exec(out[i]);
+      if (s === null) continue;
+      out[i] = `${s[1]}resolved \u2014 carried, still open, to \`${destSlug}\` with the steps it blocks (was: ${s[2].trim()})`;
+      break;
+    }
+  }
+  for (const s of steps) out[s.line] = `${out[s.line]} ${annotation}`;
+  const toOpen = (block) => block.map((l, i) => i === 0 ? l.replace(/\[~\]/, "[ ]") : l).join("\n");
+  const phaseSteps = steps.filter((s) => !s.isAcceptance).map((s) => toOpen(s.block));
+  const acSteps = steps.filter((s) => s.isAcceptance).map((s) => toOpen(s.block));
+  const phaseName = `Deferred steps carried from ${sourceSlug}`;
+  const blockerText = moved.map((b) => lines.slice(b.start, b.end).join("\n").trimEnd());
+  const body = [
+    `# ${_title(text, sourceSlug)} \u2014 carried`,
+    "",
+    `> **Source:** carried by the archival sweep on ${date} from`,
+    `> [\`${sourceSlug}\`](${parked ? "../" : ""}archive/${sourceSlug}.md), which closed every other step.`,
+    "> Each step below was `[~]` there and is restated verbatim as open work, so",
+    "> archiving the parent buried nothing. Blockers the steps name moved with them.",
+    "",
+    "## Goal",
+    "",
+    `Every step ${sourceSlug} deferred is either done here or explicitly disposed`,
+    "of \u2014 a step that still cannot run is re-deferred with its reason, never",
+    "left to read as finished.",
+    "",
+    `## Phase 1 \u2014 ${phaseName}`,
+    "",
+    phaseSteps.length > 0 ? phaseSteps.join("\n") : "- [ ] **1.1 Close the carried acceptance criteria below.** The parent deferred\n      only acceptance criteria; this step is done when each is checked or disposed of.\n      verify: every criterion under `## Acceptance Criteria` is `[x]` or `[-]`",
+    "",
+    ...blockerText.length > 0 ? ["## Blockers", "", blockerText.join("\n\n"), ""] : [],
+    "## Risk Register",
+    `<!-- risk-review: v1 | reviewed: ${date} | reviewer: archive-sweep/auto-carry -->`,
+    "",
+    "| Rank | Item | Risk type | Description | Mitigation | Anchored under |",
+    "|------|------|-----------|-------------|------------|----------------|",
+    `| 1 | Carried steps stay blocked indefinitely | implementation | A step deferred once for elapsed time or a decision can sit here as long as it sat in the parent | It now counts as open work in the dashboard instead of as 100 %, and its blocker is listed where the estate gates count it | Phase 1 \u2014 ${phaseName} |`,
+    "",
+    "## Acceptance Criteria",
+    "",
+    acSteps.length > 0 ? acSteps.join("\n") : `- [ ] AC-1 \u2014 No step carried from \`${sourceSlug}\` is still \`[ ]\` without a recorded disposition.`,
+    ""
+  ].join("\n");
+  const complexity = body.split("\n").length > LIGHTWEIGHT_LINE_BUDGET ? "structural" : "lightweight";
+  const ids = ownerBlockers.join(", ");
+  const parkedKeys = parked ? `entry_condition:
+  what: the owner resolves blocker(s) ${ids}
+  when: whenever the owner takes the next step
+  who: owner
+review_by: ${_plusDays(date, 90)}
+estate_growth_exempt: >-
+  Owner-chosen archive of ${sourceSlug}: its deferred steps wait on owner
+  blocker(s) ${ids} and are parked here instead of left active. The parent
+  is archived in the same change, so the active count drops by one.
+` : "";
+  const destText = `---
+complexity: ${complexity}
+status: ${parked ? "later" : "ready"}
+execution:
+  mode: phase-checkpoints
+parent_roadmap: ${sourceSlug}
+${parkedKeys}---
+${body}`;
+  const destRel = parked ? `agents/roadmaps/later/${destSlug}.md` : `agents/roadmaps/${destSlug}.md`;
+  return {
+    plan: {
+      destSlug,
+      destRel,
+      destText,
+      sourceText: out.join("\n"),
+      carried: steps.length,
+      movedBlockers: moved.map((b) => b.id),
+      ownerBlockers,
+      firstStep: steps[0].block.join("\n"),
+      parked
+    }
+  };
+}
+
+export {
+  DEFERRED_RESOLUTION_RE,
+  DEFERRED_STEP_RE,
+  BLOCK_END_RE,
+  nextCarrySlug,
+  planCarry
+};

package/dist/cli-delegate/{chunk-6KFEC3G7.js → chunk-CQWX336L.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-MCJYCQPF.js";
 import {
   resolve_project_root
-} from "./chunk-FC75PGJE.js";
+} from "./chunk-JY2I2DXV.js";
 
 // src/scripts/_cli/cmd_migrate.ts
 import { spawnSync } from "node:child_process";

package/dist/cli-delegate/chunk-DEIV7XP7.js

@@ -0,0 +1,108 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/scripts/_lib/json_merge.ts
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function deepcopy(v) {
+  if (v === null || typeof v !== "object") return v;
+  if (Array.isArray(v)) return v.map((x) => deepcopy(x));
+  const out = {};
+  for (const k of Object.keys(v)) {
+    out[k] = deepcopy(v[k]);
+  }
+  return out;
+}
+function deepMerge(base, overlay) {
+  const result = deepcopy(base);
+  for (const key of Object.keys(overlay)) {
+    const value = overlay[key];
+    if (Object.prototype.hasOwnProperty.call(result, key) && isPlainObject(result[key]) && isPlainObject(value)) {
+      result[key] = deepMerge(result[key], value);
+    } else {
+      result[key] = deepcopy(value);
+    }
+  }
+  return result;
+}
+function jsonEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((v, i) => jsonEqual(v, b[i]));
+  }
+  if (isPlainObject(a) && isPlainObject(b)) {
+    const ka = Object.keys(a);
+    const kb = Object.keys(b);
+    if (ka.length !== kb.length) return false;
+    return ka.every(
+      (k) => Object.prototype.hasOwnProperty.call(b, k) && jsonEqual(a[k], b[k])
+    );
+  }
+  return false;
+}
+
+// src/scripts/_lib/host_hook_merge.ts
+var HOOK_SIGNATURES = {
+  "~/.augment/settings.json": "augment-dispatcher.sh",
+  ".cursor/hooks.json": "dispatch:hook --platform cursor",
+  "~/.cursor/hooks.json": "cursor-dispatcher.sh",
+  ".windsurf/hooks.json": "dispatch:hook --platform windsurf",
+  "~/.codeium/windsurf/hooks.json": "windsurf-dispatcher.sh",
+  ".gemini/settings.json": "dispatch:hook --platform gemini",
+  "~/.gemini/settings.json": "gemini-dispatcher.sh"
+};
+function entryCommands(entry) {
+  if (!isPlainObject(entry)) return [];
+  const out = [];
+  if (typeof entry["command"] === "string") out.push(entry["command"]);
+  const nested = entry["hooks"];
+  if (Array.isArray(nested)) {
+    for (const inner of nested) {
+      if (isPlainObject(inner) && typeof inner["command"] === "string") {
+        out.push(inner["command"]);
+      }
+    }
+  }
+  return out;
+}
+function isManagedEntry(entry, signature) {
+  if (signature === "") return false;
+  return entryCommands(entry).some((cmd) => cmd.includes(signature));
+}
+function mergeEventEntries(existing, incoming, signature) {
+  const kept = existing.filter((entry) => !isManagedEntry(entry, signature));
+  return [...kept.map((e) => deepcopy(e)), ...incoming.map((e) => deepcopy(e))];
+}
+function mergeHookEvents(existingHooks, patchHooks, signature) {
+  if (!isPlainObject(existingHooks)) return deepcopy(patchHooks);
+  const out = deepcopy(existingHooks);
+  for (const event of Object.keys(patchHooks)) {
+    const incoming = patchHooks[event];
+    const current = out[event];
+    if (!Array.isArray(incoming)) {
+      out[event] = deepcopy(incoming);
+      continue;
+    }
+    out[event] = mergeEventEntries(Array.isArray(current) ? current : [], incoming, signature);
+  }
+  return out;
+}
+function mergeHostConfig(existing, patch, signature, deepMergeFn) {
+  const merged = deepMergeFn(existing, patch);
+  const patchHooks = patch["hooks"];
+  if (signature === "" || !isPlainObject(patchHooks)) return merged;
+  merged["hooks"] = mergeHookEvents(existing["hooks"], patchHooks, signature);
+  return merged;
+}
+
+export {
+  isPlainObject,
+  deepMerge,
+  jsonEqual,
+  HOOK_SIGNATURES,
+  entryCommands,
+  isManagedEntry,
+  mergeHostConfig
+};