@event4u/agent-config 16.2.0 → 16.3.0

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