@event4u/agent-config 14.21.0 → 14.22.0

package/dist/cli-delegate/chunk-5EK5WQN6.js

@@ -0,0 +1,28 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/agent-src/scripts/_cli_entry.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+function isCliEntry(moduleUrl, name) {
+  const argv1 = process.argv[1];
+  if (argv1 === void 0) {
+    return false;
+  }
+  if (path.basename(argv1, ".js") === name) {
+    return true;
+  }
+  const argvPath = path.resolve(argv1);
+  if (moduleUrl === pathToFileURL(argvPath).href) {
+    return true;
+  }
+  try {
+    return fs.realpathSync(fileURLToPath(moduleUrl)) === fs.realpathSync(argvPath);
+  } catch {
+    return false;
+  }
+}
+
+export {
+  isCliEntry
+};

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

@@ -0,0 +1,96 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/agent-src/scripts/dashboard_mode.ts
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+function isTrackedInGit(abs, repo_root) {
+  const r = spawnSync("git", ["ls-files", "--error-unmatch", "--", abs], {
+    cwd: repo_root,
+    encoding: "utf-8",
+    timeout: 1e4
+  });
+  return r.status === 0;
+}
+var REGEN = "Run `./scripts-run src/agent-src/scripts/update_roadmap_progress` to regenerate (or `task roadmap-progress` in Taskfile projects).";
+function evaluateDashboardState(inp) {
+  const { mode, present, trackedInGit, current, rel } = inp;
+  const regen = inp.regen ?? REGEN;
+  const noun = inp.noun ?? "dashboard";
+  if (mode === "untracked" && trackedInGit) {
+    return {
+      stale: true,
+      error: `\u274C  ${rel} is still tracked by git, but this repository runs \`--untracked-mode\`. Untrack it, keeping the working-tree file:
+      git rm --cached ${rel}
+`,
+      ok: null
+    };
+  }
+  if (!present) {
+    if (mode === "tracked") {
+      return {
+        stale: true,
+        error: `\u274C  ${rel} is missing. ` + regen.replace("to regenerate", "to generate it") + ` If this repository deliberately does not commit the ${noun}, pass \`--untracked-mode\`.
+`,
+        ok: null
+      };
+    }
+    return {
+      stale: false,
+      error: null,
+      ok: `\u2705  ${rel} is not committed here (--untracked-mode) and no stale copy is on disk.
+`
+    };
+  }
+  if (!current) {
+    return { stale: true, error: `\u274C  ${rel} is stale. ${regen}
+`, ok: null };
+  }
+  return { stale: false, error: null, ok: `\u2705  ${rel} is up to date.
+` };
+}
+function evaluateDashboardOnDisk(opts) {
+  const present = fs.existsSync(opts.target);
+  return evaluateDashboardState({
+    mode: opts.mode,
+    present,
+    trackedInGit: opts.mode === "untracked" && isTrackedInGit(opts.target, opts.repo_root),
+    current: present && fs.readFileSync(opts.target, { encoding: "utf-8" }) === opts.rendered,
+    rel: opts.rel,
+    ...opts.regen === void 0 ? {} : { regen: opts.regen },
+    ...opts.noun === void 0 ? {} : { noun: opts.noun }
+  });
+}
+function reportCheckVerdict(inp) {
+  const { verdict, dashboardOnly } = inp;
+  const complete = dashboardOnly ? [] : inp.complete;
+  const pending = dashboardOnly ? [] : inp.pending;
+  let err = verdict.error ?? "";
+  if (complete.length) {
+    err += "\u274C  Completed roadmaps are still in `agents/roadmaps/` \u2014 move them to `agents/roadmaps/archive/` (per the `roadmap-progress-sync` rule):\n";
+    for (const r of complete) err += `      - ${r.rel}  (${r.done}/${r.total_active} done)
+`;
+  }
+  if (pending.length) {
+    err += "\u274C  Iron Law 3 \u2014 roadmaps with unresolved `[~]` deferred items must NOT auto-archive. Resolve via `roadmap-management \xA7 4b` (spawn follow-up, restore, or cancel):\n";
+    for (const r of pending) {
+      err += `      - ${r.rel}  (${r.done}/${r.total_active} done \xB7 ${r.deferred} deferred)
+`;
+    }
+  }
+  if (!dashboardOnly && inp.gatedCount > 0) inp.warnMergeGated();
+  const rc = verdict.stale || complete.length > 0 || pending.length > 0 ? 1 : 0;
+  return { rc, stdout: rc === 0 ? verdict.ok ?? "" : "", stderr: err };
+}
+function parseModeToken(tok) {
+  if (tok === "--tracked-mode") return "tracked";
+  if (tok === "--untracked-mode") return "untracked";
+  return null;
+}
+
+export {
+  isTrackedInGit,
+  evaluateDashboardState,
+  evaluateDashboardOnDisk,
+  reportCheckVerdict,
+  parseModeToken
+};

package/dist/cli-delegate/{chunk-643Z7FIC.js → chunk-BIXEDQPZ.js}

@@ -748,6 +748,12 @@ function format_drift_report(entries) {
 // src/scripts/_lib/skill_catalogue.ts
 import * as fs4 from "node:fs";
 import * as path4 from "node:path";
+var PROJECT_CATALOGUE_ROOTS = ["src/skills", ".claude/skills"];
+var HOST_CATALOGUE_ROOT = ".claude/skills";
+var DEFAULT_CATALOGUE_ROOTS = [
+  ...PROJECT_CATALOGUE_ROOTS,
+  `~/${HOST_CATALOGUE_ROOT}`
+];
 var OBSERVATION_LOG = path4.join(
   "agents",
   "evidence",

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

@@ -0,0 +1,155 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/agent-src/scripts/gate_budget.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+var GATE_BUDGET_LEDGER_REL = path.join(
+  "agents",
+  "runtime",
+  "state",
+  "gate-budget-ledger.jsonl"
+);
+function gateBudgetLedgerPath(workspaceRoot) {
+  return path.join(workspaceRoot, GATE_BUDGET_LEDGER_REL);
+}
+var ROLLING_WINDOW_DAYS = 7;
+function _num(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  return null;
+}
+function _dig(settings, keys) {
+  let cursor = settings;
+  for (const k of keys) {
+    if (cursor === null || typeof cursor !== "object" || Array.isArray(cursor)) {
+      return void 0;
+    }
+    cursor = cursor[k];
+  }
+  return cursor;
+}
+function readGateBudgetCaps(settings) {
+  const perRun = _num(_dig(settings, ["roadmap", "gate_budget", "max_cost_per_run_usd"]));
+  const rolling = _num(
+    _dig(settings, ["roadmap", "gate_budget", "max_cost_per_rolling_7d_usd"])
+  );
+  if (perRun === null || rolling === null) {
+    return null;
+  }
+  return { maxCostPerRunUsd: perRun, maxCostPerRolling7dUsd: rolling };
+}
+function parseBudgetUsd(field) {
+  const text = field.trim();
+  if (text === "") {
+    return null;
+  }
+  const dollar = /\$\s*([0-9]+(?:[.,][0-9]+)?)/.exec(text);
+  if (dollar) {
+    return Number.parseFloat(dollar[1].replace(",", "."));
+  }
+  const usd = /([0-9]+(?:[.,][0-9]+)?)\s*(?:usd|dollars?)\b/i.exec(text);
+  if (usd) {
+    return Number.parseFloat(usd[1].replace(",", "."));
+  }
+  return null;
+}
+function readGateBudgetLedger(workspaceRoot) {
+  const file = gateBudgetLedgerPath(workspaceRoot);
+  if (!fs.existsSync(file)) {
+    return [];
+  }
+  const out = [];
+  for (const line of fs.readFileSync(file, "utf-8").split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (parsed === null || typeof parsed !== "object") {
+      continue;
+    }
+    const rec = parsed;
+    if (rec["kind"] !== "consumption" || typeof rec["blocker"] !== "string") {
+      continue;
+    }
+    out.push({
+      kind: "consumption",
+      blocker: rec["blocker"],
+      authorization: "confirm-flag",
+      estimated_usd: _num(rec["estimated_usd"]) ?? 0,
+      actual_usd: _num(rec["actual_usd"]),
+      at: typeof rec["at"] === "string" ? rec["at"] : "",
+      single_use: true
+    });
+  }
+  return out;
+}
+function appendGateBudgetReceipt(workspaceRoot, receipt) {
+  const file = gateBudgetLedgerPath(workspaceRoot);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.appendFileSync(file, `${JSON.stringify(receipt)}
+`, "utf-8");
+}
+function rollingSpendUsd(records, now) {
+  const cutoff = now.getTime() - ROLLING_WINDOW_DAYS * 24 * 60 * 60 * 1e3;
+  let total = 0;
+  for (const r of records) {
+    const stamp = Date.parse(r.at);
+    if (Number.isFinite(stamp) && stamp < cutoff) {
+      continue;
+    }
+    total += r.actual_usd ?? r.estimated_usd;
+  }
+  return total;
+}
+function evaluateGateBudget(opts) {
+  const { caps, records, estimateUsd, now } = opts;
+  if (caps === null) {
+    return {
+      ok: false,
+      reason: "no_caps",
+      detail: "no standing class-1 budget is configured (`roadmap.gate_budget.max_cost_per_run_usd` and `roadmap.gate_budget.max_cost_per_rolling_7d_usd`)"
+    };
+  }
+  if (estimateUsd === null) {
+    return {
+      ok: false,
+      reason: "no_estimate",
+      detail: "the entry states no USD estimate in its **Budget:** field, so no cap can be compared against it"
+    };
+  }
+  if (estimateUsd > caps.maxCostPerRunUsd) {
+    return {
+      ok: false,
+      reason: "over_per_run",
+      detail: `the estimate ($${estimateUsd.toFixed(2)}) exceeds the per-run cap ($${caps.maxCostPerRunUsd.toFixed(2)})`
+    };
+  }
+  const spent = rollingSpendUsd(records, now);
+  if (spent + estimateUsd > caps.maxCostPerRolling7dUsd) {
+    return {
+      ok: false,
+      reason: "over_rolling_7d",
+      detail: `$${spent.toFixed(2)} is already receipted in the last ${String(ROLLING_WINDOW_DAYS)} days and this run would add $${estimateUsd.toFixed(2)}, over the rolling cap ($${caps.maxCostPerRolling7dUsd.toFixed(2)})`
+    };
+  }
+  return { ok: true, estimateUsd, rollingUsd: spent };
+}
+
+export {
+  GATE_BUDGET_LEDGER_REL,
+  gateBudgetLedgerPath,
+  ROLLING_WINDOW_DAYS,
+  readGateBudgetCaps,
+  parseBudgetUsd,
+  readGateBudgetLedger,
+  appendGateBudgetReceipt,
+  rollingSpendUsd,
+  evaluateGateBudget
+};

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

@@ -0,0 +1,20 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+
+export {
+  __require,
+  __commonJS
+};