@event4u/agent-config 14.21.0 → 14.23.0

package/dist/agent-src/scripts/update_roadmap_progress.ts

@@ -62,7 +62,7 @@ import { createRequire } from 'node:module';
 import { spawnSync } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
+import { fileURLToPath } from 'node:url';
 import { run_archival_sweep } from './archival_sweep.js';
 import {
     evaluateDashboardOnDisk,
@@ -72,6 +72,8 @@ import {
 } from './dashboard_mode.js';
 import type * as YamlModule from 'yaml';
 import { headerFragment as stubHeaderFragment } from './stubs_due.js';
+
+import { isCliEntry } from './_cli_entry.js';
 import { reportGuardedBaselines } from './guarded_baseline.js'; // third step state; contract lives there
 
 const _HERE = fileURLToPath(import.meta.url);
@@ -96,7 +98,9 @@ const EXCLUDE_DIRS: ReadonlySet<string> = new Set(['archive', 'skipped', 'stubs'
 
 // FRONTMATTER_RE = re.compile(r"\A---\n(.*?)\n---\s*\n", re.DOTALL)
 const FRONTMATTER_RE = /^---\n([\s\S]*?)\n---[ \t\n\r\f\v]*\n/;
-const UNSCHEDULED_VALUES: ReadonlySet<string> = new Set(['draft', 'carrier']);
+// A set of one since ADR-262 deleted `status: carrier`; the shape stays so a
+// future unscheduled value is one entry rather than a control-flow change.
+const UNSCHEDULED_VALUES: ReadonlySet<string> = new Set(['draft']);
 
 const MERGE_GATED_RE = /merge-gated/i;
 // PR_NUM_RE = re.compile(r"pr\s*[=#:]?\s*#?\s*(\d+)", re.IGNORECASE)
@@ -1438,28 +1442,7 @@ function main(argv?: readonly string[]): number {
     return guarded.problems > 0 ? 1 : 0;
 }
 
-function _isCliEntry(): boolean {
-    if (process.argv[1] === undefined) {
-        return false;
-    }
-    const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
-    if (import.meta.url === argvUrl) {
-        return true;
-    }
-    // A symlinked invocation (e.g. via `.augment/scripts` → `dist/agent-src/scripts`,
-    // or macOS /var → /private/var temp dirs) makes the raw URLs differ:
-    // import.meta.url is the resolved real path while argv[1] keeps the symlink
-    // path. Compare realpaths so the entry guard still fires (without this the
-    // dashboard regen silently no-ops when run through the symlink).
-    try {
-        const here = fs.realpathSync(fileURLToPath(import.meta.url));
-        const argv = fs.realpathSync(path.resolve(process.argv[1]));
-        return here === argv;
-    } catch {
-        return false;
-    }
-}
-if (_isCliEntry() || process.argv[1] === _HERE) {
+if (isCliEntry(import.meta.url, 'update_roadmap_progress')) {
     try {
         process.exitCode = main();
     } catch (exc) {

package/dist/agent-src/skills/code-intelligence/SKILL.md

@@ -1,7 +1,7 @@
 ---
 model_tier: inherit
 name: code-intelligence
-description: "Route codebase-structure questions (who calls X, where is this used, what imports, change-impact) to an existing code-graph first: cheaper, never more precise; grep stays routine. Also 'call graph'."
+description: "Route codebase-structure questions (who calls X, where used, change-impact) to an existing code-graph first: impact, tests-for, dead cheaper, never more precise; grep routine. Also 'call graph'."
 domain: engineering
 workspaces:
   - engineering
@@ -182,6 +182,84 @@ consumer-shipped SCIP index. Literal-string probes are reported as a separate
 cannot answer them at all, which is where grep stays necessary rather than a
 defect in the engine.
 
+## Staleness delivery — which hosts get it for free, and which do not
+
+Migrated verbatim from `external-code-graph-interop` so the obligation stays in
+the rule and the per-host delivery detail is paid only on activation.
+
+On a host with a verified `pre_tool_use` contract, the `code-graph-context`
+concern supplies this for free: once per session, on the first search or
+code read, it delivers the graph's state as structured `additionalContext` —
+`code-graph: fresh` or `code-graph: N commit(s) behind`. It is silent when no
+graph exists, so hearing nothing is not evidence that the graph is fresh.
+
+**On every other host that carrier does not exist**, and this section is the
+delivery: run `agent-config code-graph detect --format json` before trusting a
+relationship answer, and say which state you got. Which hosts those are is
+`agent-config hooks:status` — resolved from the platform table, never guessed
+from the host's name.
+
+Either way the disposition is the same: `behind:N` → `agent-config code-graph
+refresh` first, or use grep and say so. This is a freshness obligation, not an
+ordering claim; the rule's query-first ordering still governs which source to
+reach for.
+
+## The four gate verbs — a diff, not a symbol (2026-09-08)
+
+`query` / `affected` / `path` / `explain` answer a question about a SYMBOL.
+Four more answer a question about a DIFF, and they are documented here rather
+than in § Procedure for a mechanical reason worth stating: step 4.3 of
+`road-to-a-graph-that-is-shipped` verifies that this file's line 164 — the
+**No class is graph-first** sentence — is unchanged, and inserting anything
+above it moves that line. So the ordering claim K5 protects stays byte-fixed
+and the new material sits below it.
+
+Each of the four walks only edges whose resolution mechanism is a stated fact
+(never a repo-wide same-name guess, never an untyped receiver), and each prints
+the mechanisms it accepted, the mechanisms it refused, and the graph's
+staleness — so a narrow answer is distinguishable from a decoupled one:
+
+- `agent-config code-graph impact --diff <rev>` — callers, dependents and test
+  files reachable from the changed symbols, plus the producing edges and a
+  minimal read set.
+- `agent-config code-graph tests-for <symbol>` — the test files that import it.
+  An empty list is a finding, not an error.
+- `agent-config code-graph untested --diff <rev>` — changed symbols that no test
+  file imports.
+- `agent-config code-graph dead [--entry-points F | --accept-missing-exports]` —
+  symbols with no accepted reference that no declared entry point names. It
+  **refuses** rather than answering while an entry-point source cannot be read:
+  this engine records no exportedness, so without a supplied list an
+  exported-but-unimported symbol is indistinguishable from a dead one, and a
+  confident false "dead" invites a deletion the graph cannot justify. Nothing it
+  lists is a deletion recommendation.
+
+These answers reach an agent over MCP without shelling out, and the mapping is
+**not** one tool per verb — corrected after an independent review found this
+paragraph claiming "the same five answers" directly after a list of four:
+
+| MCP tool | answers |
+|---|---|
+| `graph_impact` | `impact --diff`, **and** `untested --diff` via `untested_only: true` |
+| `graph_tests_for` | `tests-for` |
+| `graph_dead` | `dead` |
+| `graph_query` | `query` |
+| `graph_path` | `path` |
+
+`untested` has no tool of its own; it is a flag on `graph_impact`, because the
+two answer the same question over the same diff and a sixth tool would have cost
+standing context for a boolean. `graph_impact` is the only one that is not
+read-only — it runs `git diff --name-only` to resolve its rev — and
+`graph_dead`'s refusal arrives as `status: "refused"`, never as `status: "ok"`
+with an empty list.
+
+**No ordering claim is added here, and no measurement claim either.** These
+verbs are cheaper than reconstructing the same relationship by hand — that is a
+claim about the ALTERNATIVE being a manual reconstruction, not about grep.
+Nothing on this page says they beat grep, none of the four appears in the v2
+benchmark corpus (which measures `callers`, `transitive-impact`, `path-between`
+and `references`), and § Measured twice still governs that question.
+
 ## Do NOT
 
 - Do NOT rebuild a **fresh** consumer-shipped index — query it (interop
@@ -199,3 +277,6 @@ defect in the engine.
   discipline; the graph is one evidence source, still confirmed against the real
   code when load-bearing.
 - `agent-config code-graph` — the CLI surface over the engine (build / query / detect / affected).
+- [`discovery_graph`](../../scripts/discovery_graph.ts) — this suite's OWN
+  artifact relation-graph (`affected`/`explain`). The external code-graph is the
+  *source-code* analogue; keep the two apart when answering.

package/dist/agent-src/skills/git-workflow/references/push-closes-its-loop.md

@@ -68,6 +68,15 @@ returned 0, the turn closed, and the red arrived where the user found it.
   ending the turn silently on one is what the reminder exists to stop. Whether
   the reminder changes behavior is unmeasured — it ships as a carrier, not as a
   claim.
+- **`ci_settle` will not answer for a head that stopped mattering.** Since
+  2026-09-08 it reads the PR's `state` and compares its recorded head against
+  `git ls-remote` — before the wait and again at verdict time — and exits 2 with
+  a reason when the PR is merged, closed, or record-behind-branch. A green names
+  the head it is about. The measured reason: a merged PR's rollup kept answering
+  with its merge-time checks, so the tool reported `SETTLED GREEN — 40 check(s)`
+  for a commit that had zero check runs. The check does not apply to a fork PR
+  whose ref is not under this `origin`, and the line says so instead of claiming
+  it passed.
 - **Neither reaches a host without the slot.** `agent-config hooks:status`
   answers which slots are bound where you actually are; `post_tool_use` is
   unbound on windsurf and copilot, and there the settle obligation is

package/dist/agent-src/skills/roadmap-writing/SKILL.md

@@ -224,6 +224,23 @@ procedure when [`roadmap-management`](../roadmap-management/SKILL.md)
 spawns a follow-up). Bare `[~]` / `[-]` is allowed; annotated is
 preferred.
 
+#### A prohibition-shaped step closes with `[x]`
+
+A step whose content is a **prohibition** (*"Do not build the enforcement"*) has
+no artifact to point at. `[~]` invents receiver work nobody owes, `[-]` mislabels
+restraint as cancellation, `[ ]` makes an honoured bounded obligation
+unarchivable. It closes with **`[x]`** — the obligation was discharged, and `[x]`
+never required that something was created. Its `verify:` must name every
+implementation, registration and semantically-equivalent surface (a structural
+check, not one literal grep, which misses aliases and generated code); **fail if
+an expected search root is missing**, checked BEFORE the absence check, because a
+glob over a vanished directory returns nothing and reads as success; scope the
+claim to the branch diff — *"this change introduced no enforcement"*, never the
+unprovable *"enforcement exists nowhere"*; and be re-run at archival. Not for a
+prohibition meant to hold indefinitely — that belongs in a rule, test or linter,
+because a closed step stops watching. Council convention, 2026-09-08 (2 seats,
+convergent); falsified if tooling defines `[x]` as requiring a positive mutation.
+
 ### 7. Follow-up roadmaps spawn from deferred items — frontmatter shape
 
 When a parent roadmap closes with `[~]` items, the

package/dist/agent-src/skills/tailwind-engineer/SKILL.md

@@ -51,6 +51,42 @@ radius, spacing, shadow, font-size to a configured token. If the design hands yo
 (`bg-[#3B82F6]`, `mt-[17px]`) are a smell — accept only with a
 one-line comment naming the design source.
 
+**That paragraph is written for greenfield, and artifact-bound work inverts
+it.** When a provided finished design is the spec
+([`design-fidelity`](../../rules/design-fidelity.md)), `#3B82F6` is a decision
+somebody already made and `bg-blue-500` is a guess about it. Three obligations
+follow, and the third is the one this skill used to get wrong:
+
+1. **Do not snap.** Replacing the artifact's value with the nearest configured
+   token is the deviation the rule's Iron Law forbids — *"NEVER SWAP … SPACING,
+   OR COLOUR"* without explicit confirmation. An artifact-derived exact value is
+   not a smell here: it *is* the spec, and the source-naming comment the
+   paragraph above asks for is what records it.
+2. **Translate once, not per call site.** Where the artifact's literal genuinely
+   needs to live in the project's system, add **one** named project token
+   carrying that exact value and use it everywhere — one token the project owns
+   beats N approximations of the same colour. That is a token duty, not a
+   deviation: the value does not change.
+3. **Reconcile as a proposal, never autonomously.** Report each value's
+   distance to the nearest project token on the `Reconciled:` line below, and
+   let the human decide. Writing a *different* project value because the
+   difference looks small is exactly the unconfirmed swap (1) rules out — the
+   mode table at `design-fidelity.md:117-121` grants no visibility exemption,
+   and `structural` grants only the filling of a spec that is genuinely
+   **silent**, which an artifact stating `#3B82F6` is not.
+
+**Why not "just approximate within tolerance", which is the eventual intent:**
+that needs a tolerance to exist. There is none — no `reconcile`, `tolerance`,
+`approximat` or `nearest` in the rule or its guideline — and both the threshold
+and whether approximation is autonomous by default are owner decisions, tracked
+as `blocker: approximation-tolerance` and `blocker: fidelity-default-flip` on
+`road-to-design-intent-conformance`. Until they land, a skill granting that
+autonomy would be re-writing the rule from underneath it.
+
+Structure, controls, icons, grid and breakpoints are never this skill's to
+adjust; those stay 1:1 with the artifact and belong to the rule, not to a
+utility-class decision.
+
 Token authoring (DTCG 3-layer model, CSS-var/Tailwind generation) lives
 in [`design-tokens`](../design-tokens/SKILL.md); its
 `tokens.ts validate --dir <path>` is the **single token-discipline
@@ -103,7 +139,11 @@ When reviewing or proposing styles, return:
 
 1. Token map — every colour, spacing, radius, shadow, font-size mapped
    to its configured token; arbitrary values flagged with the design
-   source they cite.
+   source they cite. Artifact-bound work adds a **Reconciled** block here:
+   one line per value, as `<artifact value> → <kept, or the token that
+   carries it exactly> (<distance to the nearest project token>)`. This is
+   the destination "report the distance" means; without it the obligation
+   has nowhere to land and is unobservable in the deliverable.
 2. Class list — ordered (layout → box-model → typography → colour →
    state → responsive); inline-style use justified per element.
 3. Extraction + risk call-out — component / constant / `@apply` / none
@@ -115,6 +155,7 @@ Concrete shape:
 ```
 Element:        <selector or component name>
 Token map:      <colour/spacing/etc → config token>
+Reconciled:     <artifact value → kept or exact-carrying token, + distance>
 Class list:     <ordered classes>
 Inline style:   <only if runtime-computed; else "none">
 Extraction:     <component | constant | @apply | none — reason>
@@ -128,7 +169,16 @@ Risks:          <arbitrary values, !important, dark-mode gaps>
 - `dark:` variants need a token map in both modes; one-sided dark
   styling is half a feature.
 - Arbitrary values (`mt-[17px]`) survive Tailwind upgrades but
-  break the design system; they accumulate silently.
+  break the design system; they accumulate silently. **Artifact-bound is the
+  exception, not a loophole:** a value the provided design specifies is not
+  accumulation, and step 1's three obligations decide it. An arbitrary value
+  nobody can trace to a source is still the smell this bullet is about.
+- **The carrier is CSS or a utility class; the value is the design's.** Static
+  presentation belongs in CSS / tokens / classes — `style=` is for what only
+  the runtime knows (a computed width, a live transform, a measured offset).
+  Porting an artifact's inline `style=` into classes is therefore expected and
+  is not a deviation, **as long as the resolved value comes out identical**.
+  Changing the carrier is free; changing the number is not.
 - `@apply` inside component CSS interacts with PurgeCSS — keep it
   in files Tailwind scans, not in vendor CSS.
 - **Anti-AI-slop catalog.** The bullets below are the Tailwind-specific

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

@@ -629,7 +629,6 @@ the canonical narrative lives in
 | `hooks.injection_scan.enabled` | `true`, `false` | `false` | PostToolUse prompt-injection scanner: scans tool output for injection signatures and warns in context (exit 2) — never blocks. |
 | `hooks.rtk_wrap.enabled` | `true`, `false` | `false` | PreToolUse RTK-wrap nudge: when `rtk` is on PATH, warns (exit 2, never blocks) to re-run a verbose CLI command wrapped with rtk. |
 | `hooks.design_slop.enabled` | `true`, `false` | `false` | PreToolUse anti-slop nudge: runs the `lint_design_slop` registry against about-to-be-written UI content and warns (exit 2, never blocks) on P0/P1 aesthetic tells. |
-| `hooks.code_graph.enabled` | `true`, `false` | `false` | PreToolUse code-graph nudge (deprecated — honest null 2026-07-28): when a code-graph index exists, warns once per session to query the graph before grep. Requires manually installing the ABI-locked parser pair. |
 | `pipelines.skill_improvement` | `true`, `false` | `true` | When `true`: propose learning capture after meaningful tasks. When `false`: silent. Included in every profile except `custom`. |
 | `roadmap.skip_pre_run_gate` | `true`, `false` | `true` | When `true` (default): `/roadmap:process-step\|phase\|full` skips the interactive pre-run summary and starts the loop immediately — the resolved roadmap, cadence, and council are surfaced inline so an unwanted pick can still be aborted. When `false`: the loop shows the pre-run summary with numbered options (Go / Different roadmap / Different scope / Toggle council / Abort) and waits. The gate is always shown — regardless of this flag — when the roadmap is ambiguous (multiple active, none named) or a scope / cadence conflict has no sensible default. |
 | `roadmap.quality_cadence` | `end_of_roadmap`, `per_phase`, `per_step` | `end_of_roadmap` | When `/roadmap:process-step|phase|full` runs the project's quality pipeline — only relevant when `quality.local_auto_run` is `true`; when it is `false` (the default) local pipeline runs are suppressed at every cadence and remote CI is the gate. Default skips per-step / per-phase runs and gates only the final archival. `per_phase` runs once after every phase; `per_step` is the legacy verbose mode. Step checkboxes and the dashboard are always updated regardless. |

package/dist/agent-src/templates/agents/agent-project-settings.example.yml

@@ -39,7 +39,7 @@ schema_version: 1
 # CI guard: a release bump of `package.json` must update this value
 # in lockstep — see scripts/check_template_pin_drift.ts (road-to-
 # portable-runtime-and-update-check P3.3).
-agent_config_version: "14.21.0"
+agent_config_version: "14.23.0"
 
 # --- Project identity ---
 project:

package/dist/cli/registry.js

@@ -73,7 +73,7 @@ export const REGISTRY = [
     { name: 'affected', disposition: 'delegate', synopsis: 'Artefacts related to <artefact> via the discovery relation-graph (BFS).' },
     { name: 'graph-explain', disposition: 'delegate', synopsis: 'Seed on a <concept>, expand 2 hops over the discovery relation-graph with a node budget.' },
     { name: 'benchmark', disposition: 'delegate', synopsis: 'Report context-token reduction vs the full always-loaded projection.' },
-    { name: 'code-graph', disposition: 'delegate', synopsis: 'Deterministic code-graph engine: build|detect|query|affected|path|explain|validate.' },
+    { name: 'code-graph', disposition: 'delegate', synopsis: 'Deterministic code-graph engine: build|detect|refresh|validate|query|affected|path|explain, plus the gate verbs impact|tests-for|untested|dead.' },
     { name: 'hooks:install', disposition: 'delegate', synopsis: 'Install the combined pre-commit hook.' },
     { name: 'hooks:status', disposition: 'delegate', synopsis: 'Print the runtime hook matrix (per-platform install + bindings).' },
     { name: 'hooks:doctor', disposition: 'delegate', synopsis: 'Diagnose hook health: concerns, posture, missing trampolines (read-only).' },

package/dist/cli-delegate/_cli_entry.js

@@ -0,0 +1,8 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  isCliEntry
+} from "./chunk-5EK5WQN6.js";
+import "./chunk-JO25G5H7.js";
+export {
+  isCliEntry
+};

package/dist/cli-delegate/_lib/pin_resolver.js

@@ -0,0 +1,170 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/scripts/_lib/pin_resolver.ts
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+var PACKAGE_NAME = "@event4u/agent-config";
+var PIN_KEY = "agent_config_version";
+var NO_REEXEC_ENV = "AGENT_CONFIG_NO_PIN_REEXEC";
+var REEXEC_DEPTH_ENV = "AGENT_CONFIG_PIN_REEXEC_DEPTH";
+function _normalize(version) {
+  return version.trim().replace(/^v+/, "");
+}
+async function read_pin(cwd, options = {}) {
+  let settings;
+  try {
+    let loader = options.settings_loader;
+    if (loader === void 0) {
+      const specifier = "./agent_settings";
+      const mod = await import(specifier);
+      if (typeof mod.load_agent_settings !== "function") {
+        return null;
+      }
+      loader = mod.load_agent_settings;
+    }
+    settings = await loader({ cwd });
+  } catch {
+    return null;
+  }
+  const raw = settings[PIN_KEY];
+  if (typeof raw !== "string") {
+    return null;
+  }
+  const pin = raw.trim();
+  return pin || null;
+}
+function should_reexec(pin, installed, options = {}) {
+  const env = options.env ?? process.env;
+  if (env[NO_REEXEC_ENV] === "1") {
+    return false;
+  }
+  if (env[REEXEC_DEPTH_ENV] === "1") {
+    return false;
+  }
+  if (!pin) {
+    return false;
+  }
+  if (!installed) {
+    return false;
+  }
+  return _normalize(pin) !== _normalize(installed);
+}
+function build_reexec_argv(pin, argv) {
+  return ["npx", "--yes", `${PACKAGE_NAME}@${_normalize(pin)}`, ...argv];
+}
+function _which(cmd) {
+  const path_var = process.env.PATH ?? "";
+  const exts = process.platform === "win32" ? (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";") : [""];
+  for (const dir of path_var.split(path.delimiter)) {
+    if (!dir) {
+      continue;
+    }
+    for (const ext of exts) {
+      const candidate = path.join(dir, cmd + ext.toLowerCase());
+      try {
+        const st = fs.statSync(candidate);
+        if (st.isFile()) {
+          if (process.platform !== "win32") {
+            fs.accessSync(candidate, fs.constants.X_OK);
+          }
+          return candidate;
+        }
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function _exec_runner(npx, argv, env) {
+  const result = spawnSync(npx, argv.slice(1), {
+    env,
+    stdio: "inherit"
+  });
+  process.exit(result.status ?? 1);
+}
+async function maybe_reexec(installed, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const argv = options.argv ?? process.argv.slice(1);
+  const env = options.env ?? process.env;
+  const pin_reader = options.pin_reader ?? ((c) => read_pin(c));
+  const which = options.which ?? _which;
+  const pin = await pin_reader(cwd);
+  if (!should_reexec(pin, installed, { env })) {
+    return null;
+  }
+  if (pin == null) {
+    throw new Error("maybe_reexec: pin narrowed to null after should_reexec");
+  }
+  const npx = which("npx");
+  if (!npx) {
+    return null;
+  }
+  const new_argv = build_reexec_argv(pin, argv.length > 0 ? argv.slice(1) : []);
+  const child_env = { ...env };
+  child_env[REEXEC_DEPTH_ENV] = "1";
+  const runner = options.runner ?? null;
+  if (runner === null) {
+    return _exec_runner(npx, new_argv, child_env);
+  }
+  return runner(npx, new_argv, child_env);
+}
+function _parse_cli(argv) {
+  let cwd = process.cwd();
+  let installed = "";
+  let forward = [];
+  let i = 0;
+  while (i < argv.length) {
+    const token = argv[i];
+    if (token === "--cwd" && i + 1 < argv.length) {
+      cwd = argv[i + 1];
+      i += 2;
+    } else if (token === "--installed" && i + 1 < argv.length) {
+      installed = argv[i + 1];
+      i += 2;
+    } else if (token === "--") {
+      forward = argv.slice(i + 1);
+      break;
+    } else {
+      i += 1;
+    }
+  }
+  return { cwd, installed, forward };
+}
+function _isCliEntry() {
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  if (true) {
+    if (path.basename(process.argv[1], ".js") === "pin_resolver") {
+      return true;
+    }
+  }
+  const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs.realpathSync(fileURLToPath(import.meta.url));
+    const argv = fs.realpathSync(path.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry()) {
+  const { cwd, installed, forward } = _parse_cli(process.argv.slice(2));
+  const child_argv = ["agent-config", ...forward];
+  await maybe_reexec(installed, { cwd, argv: child_argv });
+}
+export {
+  NO_REEXEC_ENV,
+  PACKAGE_NAME,
+  PIN_KEY,
+  REEXEC_DEPTH_ENV,
+  build_reexec_argv,
+  maybe_reexec,
+  read_pin,
+  should_reexec
+};

package/dist/cli-delegate/archival_sweep.js

@@ -0,0 +1,8 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  run_archival_sweep
+} from "./chunk-YWVXLR44.js";
+import "./chunk-JO25G5H7.js";
+export {
+  run_archival_sweep
+};