@ikon85/agent-workflow-kit 0.43.0 → 0.44.0

package/scripts/lib/audit-refs.mjs

@@ -1,146 +0,0 @@
-/**
- * audit-refs.mjs — fail-closed publish guard: a shipped skill body must not
- * reference an executable (helper script / hook / git-hook) that the kit does
- * NOT ship. Such a reference is dangling-on-arrival in a consumer repo — the
- * skill instructs the agent to run something that was never installed.
- *
- * The gap this closes: neither the publish scrub (token-level) nor the
- * portability lint (board constants) nor build-kit.test (helpers *exist*) looks
- * at whether a skill body points at a script/hook absent from the bundle. A
- * skill edit that names `scripts/foo.py` shipped silently until a consumer hit
- * the dead path. This audit catches it at build time, at the source.
- *
- * Scope = executable references only. A `*.json` data file the kit instructs the
- * consumer to *seed* (e.g. max-lines-allowlist.json via /setup-workflow) is not
- * an executable and is intentionally out of scope. A pattern mention
- * (`*.guard.test.ts`) is not a concrete path and does not match.
- */
-
-// Concrete executable paths a skill body could tell the agent to run. Both the
-// `scripts/` and `.claude/hooks/` trees ship `.py` AND `.sh` helpers, so a body
-// that names a non-shipped shell script dangles exactly like a Python one.
-const EXEC_REF = /(?:scripts\/[\w.-]+\.(?:py|sh)|\.claude\/hooks\/[\w.-]+\.(?:py|sh)|\.githooks\/[\w.-]+)/g;
-
-/**
- * Refs that are intentionally NOT shipped at the referenced path. Two legit
- * classes: (a) a documented INSTALL TARGET — the skill ships the source under
- * its own `scripts/` dir and instructs the consumer to copy it to a hook path,
- * so the hook path never ships; (b) debt — knowingly not-yet-shippable, tracked
- * for follow-up. Each entry MUST carry a reason so the carve-out is visible,
- * never silent. Keep class (b) shrinking — debt is not a destination.
- */
-export const EXEMPT_REFS = {
-  // (a) install target: git-guardrails ships the source at its own
-  // scripts/block-dangerous-git.sh (skill-relative, shipped) and documents
-  // copying it into the consumer's .claude/hooks/. The hook path is a destination.
-  '.claude/hooks/block-dangerous-git.sh': 'install target; source ships at the skill\'s scripts/',
-  // (a) install targets: setup-pre-commit ships the generic template at its own
-  // scripts/pre-commit.template.sh and instructs the consumer to CREATE these
-  // .githooks/ entries from it (wired via core.hooksPath). They never ship.
-  '.githooks/pre-commit': 'install target; setup-pre-commit ships scripts/pre-commit.template.sh',
-  '.githooks/pre-push': 'install target; optional heavy-gate hook the consumer creates',
-};
-
-/**
- * @param {(path: string) => (string|null)} readShipped  returns the shipped
- *   (scrubbed) body for a dist path, or null if it is not a scannable text file.
- * @param {Array<{path: string, kind: string}>} manifestFiles  the shipped set.
- * @returns {Array<{file: string, ref: string}>} violations (empty = clean).
- */
-export function auditExecRefs(manifestFiles, readShipped) {
-  const shipped = new Set(manifestFiles.map((f) => f.path));
-  const violations = [];
-  for (const f of manifestFiles) {
-    if (f.kind !== 'skill' || !f.path.endsWith('.md')) continue;
-    const body = readShipped(f.path);
-    if (body == null) continue;
-    // A `scripts/foo.sh` mention in a skill body may be skill-relative — the
-    // helper bundles INSIDE the skill (`<skillDir>/scripts/foo.sh`), not at the
-    // repo root. A ref is satisfied if EITHER the repo-root path OR the
-    // skill-relative path ships. skillDir = the SKILL.md's directory.
-    const skillDir = f.path.slice(0, f.path.lastIndexOf('/'));
-    for (const ref of new Set(body.match(EXEC_REF) ?? [])) {
-      if (shipped.has(ref) || shipped.has(`${skillDir}/${ref}`) || ref in EXEMPT_REFS) continue;
-      violations.push({ file: f.path, ref });
-    }
-  }
-  return violations;
-}
-
-// `from foo import …` / `import foo` — capture the top-level module name.
-const PY_IMPORT = /^[ \t]*(?:from[ \t]+(\w+)[ \t]+import|import[ \t]+(\w+))/gm;
-
-/**
- * Sibling guard: a shipped Python helper must not `import` a repo-local module
- * the kit does not ship (the bug that left drift-guard.py importing an unshipped
- * _hook_utils — invisible to the skill-body scan above). Scope = the repo's OWN
- * modules; third-party/stdlib names are not in `localModules`, so they are
- * ignored. Sub-dependencies ride along because their files ship too.
- *
- * @param {Array<{path: string}>} manifestFiles  the shipped set.
- * @param {(path: string) => (string|null)} readShipped
- * @param {Iterable<string>} localModules  basenames of the repo's own *.py modules.
- * @returns {Array<{file: string, module: string}>} violations (empty = clean).
- */
-export function auditModuleImports(manifestFiles, readShipped, localModules) {
-  const shippedMods = new Set(
-    manifestFiles
-      .filter((f) => f.path.endsWith('.py'))
-      .map((f) => f.path.split('/').pop().replace(/\.py$/, '')),
-  );
-  const local = new Set(localModules);
-  const violations = [];
-  for (const f of manifestFiles) {
-    if (!f.path.endsWith('.py')) continue;
-    const body = readShipped(f.path);
-    if (body == null) continue;
-    for (const m of body.matchAll(PY_IMPORT)) {
-      const mod = m[1] ?? m[2];
-      if (local.has(mod) && !shippedMods.has(mod)) {
-        violations.push({ file: f.path, module: mod });
-      }
-    }
-  }
-  return violations;
-}
-
-const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\-]/g, '\\$&');
-
-/**
- * Sibling guard #2: a shipped skill body must not reference (by skill name)
- * another skill the kit does NOT publish. That reference is dangling-on-arrival
- * — the consumer is told to invoke a skill that was never installed (the
- * `to-issues → codex-adapter-sync` class, before that skill was published).
- *
- * A "reference" is a NAME match in one of two unambiguous forms — a backtick
- * code span (`name` / `/name`) or a slash-command token (`/name`, not preceded
- * by a path char). Plain prose and path segments (`scripts/migrations/up`) do
- * NOT match, so a word that merely coincides with a skill name (the DB concept
- * "migrations") is ignored. Only names KNOWN to the manifest are candidates;
- * the violation fires only when that known name is NOT in the publish set.
- *
- * @param {Array<{path: string, kind: string, ownerSkill?: string}>} manifestFiles  shipped set.
- * @param {(path: string) => (string|null)} readShipped
- * @param {{known: Iterable<string>, published: Iterable<string>}} skills
- * @returns {Array<{file: string, skill: string}>} violations (empty = clean).
- */
-export function auditSkillNameRefs(manifestFiles, readShipped, { known, published }) {
-  const pub = new Set(published);
-  // Only known-but-unpublished names can dangle. Each is matched on its own
-  // delimiter boundary, so a name that is a substring of another (e.g. a skill
-  // whose name prefixes a longer one) is not falsely subsumed.
-  const danglers = [...new Set(known)].filter((n) => !pub.has(n));
-  const violations = [];
-  for (const f of manifestFiles) {
-    if (f.kind !== 'skill' || !f.path.endsWith('.md')) continue;
-    const body = readShipped(f.path);
-    if (body == null) continue;
-    for (const name of danglers) {
-      const e = escapeRe(name);
-      // backtick span `name`/`/name`  OR  slash-command /name not inside a path
-      const re = new RegExp('`/?' + e + '`|(?<![\\w/-])/' + e + '(?![\\w-])');
-      if (re.test(body)) violations.push({ file: f.path, skill: name });
-    }
-  }
-  return violations;
-}

package/scripts/lib/scrub.mjs

@@ -1,113 +0,0 @@
-/**
- * scrub(text) — publish-time transforms that strip project-private tokens and
- * internal issue/HR references from a skill/script/doc BODY before it lands in
- * dist-kit. Pure function; the SOURCE is never modified (build-kit feeds it file
- * contents, PLAN scrub model). Generated credit files (LICENSE / NOTICES) are
- * NOT scrubbed — build-kit excludes them (Codex R1#2) so legitimate
- * maintainer/upstream names survive there.
- *
- * Three transform classes (PLAN Step 11):
- *   (a) private identity tokens   → neutral placeholders
- *   (b) internal #NNN / HRn refs  → removed, with ONE adjacent space
- *   (c) project-coupled ../ paths → project-root convention
- *
- * DESIGN — no global whitespace/punctuation normalization. An early version
- * collapsed all double-spaces (corrupting ASCII diagrams + aligned tables),
- * trimmed spaces before any `.` (corrupting `an .env`), and removed empty parens
- * (which would nuke code `()` like `build_parser()`). Instead each removal eats
- * exactly one adjacent space, and the ref-only-paren rule consumes COMPOUND refs
- * (`HR7/8`, `#1010/#971`) so it never leaves an empty `()` behind. Pre-existing
- * whitespace in untouched text is preserved verbatim.
- *
- * Negatives that MUST survive (tested): `#<n>` / `<issue-number>` placeholders,
- * hex colors (`#0f172a`, `#dc2626`), shell comments (`# foo`), code `#{issue}`
- * interpolations and `()`. The `{3,5}`-digit bound on issue refs is what keeps
- * those out of the match set.
- *
- * The fail-closed publish audit (Step 13) is the backstop: any residual ref or
- * private token fails the build, so an imperfect scrub never leaks silently.
- */
-
-const ISSUES = String.raw`#\d{3,5}(?:\s*/\s*#?\d{3,5})*`;   // issue ref, incl. slash-joined
-const REF = String.raw`(?:#\d{3,5}|HR\d+)(?:/\d+)*`;        // issue OR HR, compound
-// Provenance cross-refs a kit consumer cannot resolve (no docs/adr, no wave
-// history). Stripped ONLY in citation position (a ref-only parenthetical) so
-// bare-prose fixtures/examples ("Welle 1 covers 9 slices", "contradicts
-// ADR-0007 — but", the `Welle 7 — X` parser example) survive untouched — those
-// are NOT citation-shaped. Kept in sync with the publish audit's PROVENANCE_DENY.
-const PROV = String.raw`(?:ADR-\d{3,4}|Welle \d+|Slice \d+[a-z]?)`;
-// Any internal ref token — the union consumed inside a ref-only parenthetical.
-const ANYREF = String.raw`(?:#\d{3,5}|HR\d+(?:/\d+)*|${PROV})`;
-
-// (a) -----------------------------------------------------------------------
-function privateTokens(s) {
-  return s
-    // deploy domains first (they contain "testreporter") → neutral domain
-    .replace(/(?:[a-z0-9-]+\.)*iverra\.de/g, '<your-app-domain>')
-    // repo slug before bare owner/repo
-    .replace(/iKon85\/Testreporter/g, '<owner>/<repo>')
-    // home memory path — both `~/` and `$HOME/` forms; the project slug
-    // (`-home-<user>-projects-<project>`) leaks the username, so the WHOLE slug
-    // is replaced (before the bare lowercase rule touches it).
-    .replace(/(~|\$HOME)(\/\.claude\/projects\/)[^/\s)`]+(\/memory)/g, '$1$2<project>$3')
-    .replace(/\bCoolify\b/g, 'your deploy platform')
-    .replace(/\biKon85\b/g, '<owner>')
-    .replace(/\bTestreporter\b/g, '<repo>')
-    .replace(/\btestreporter\b/g, '<project>')
-    .replace(/\bNikos\b/g, '<maintainer>s')         // German genitive before bare
-    .replace(/\bNiko\b/g, '<maintainer>');
-}
-
-// (b) -----------------------------------------------------------------------
-function internalRefs(s) {
-  let out = s;
-  // (b0) prose-suffix `#NNN-Word` → keep the descriptive word, drop the ref
-  out = out.replace(/#\d{3,5}-(?=\p{L})/gu, '');
-  // (b1) ref-only parenthetical `(#NNN[, HRn][/#MMM][, Welle N / Slice N][, ADR-####]…)`
-  //      → '' (+ one leading space). ANYREF folds in provenance tokens, so a pure
-  //      citation paren like `(Welle 52 / Slice 3)` or `(Welle 26 / Slice 1g, #983)`
-  //      is consumed whole; a content-bearing paren (`(Welle 3 — 'Backend')`,
-  //      `(Format aus Slice 7)`) keeps a non-ref token → is NOT matched here.
-  out = out.replace(new RegExp(`[ \\t]?\\(${ANYREF}(?:[\\s,;/]*${ANYREF})*\\)`, 'g'), '');
-  // (b1a2) paren-INITIAL ref + connective + space + prose: `(#NNN, prose` /
-  //        `(#NNN; prose` → `(prose`. b1c only catches a connective with NO
-  //        following space (`(#NNN/Word`); a `, `/`; ` with a space fell through
-  //        and left a dangling `(, `/`(; ` after b2b stripped just the ref (#1949).
-  out = out.replace(new RegExp(`\\(${ISSUES}[ \\t]*[,;][ \\t]+`, 'g'), '(');
-  // (b1b) issue ref joined to PRECEDING text by a connective (`, ` `/ ` `; ` `: `)
-  //       → drop the ref AND the joining separator. Without this, removing a
-  //       mid-sentence ref leaves a dangling `,)` / `(Fix A /):` / `:.` / `, —`.
-  //       Safe because the mandatory `#\d{3,5}` in ISSUES means a bare separator
-  //       with no following ref is never matched (code `a/b`, prose `Verify / DoD`,
-  //       `def f():` all survive — there is no `#NNN` after their separator).
-  out = out.replace(new RegExp(`[ \\t]*[,/;:][ \\t]*${ISSUES}`, 'g'), '');
-  // (b1c) issue ref FOLLOWED by a connective + non-space (paren-start `(#NNN/Word…`)
-  //       → drop the ref + that trailing separator. `:` is excluded here so a
-  //       trailing-colon label keeps its colon (`(Lehre #1010/#971: …)` → `(Lehre: …)`).
-  out = out.replace(new RegExp(`${ISSUES}[ \\t]*[/;,](?=\\S)`, 'g'), '');
-  // (b2a) inline issue ref WITH a leading space → eat the leading space
-  out = out.replace(new RegExp(`[ \\t]${ISSUES}`, 'g'), '');
-  // (b2b) remaining issue ref (line/paren-start) → eat one trailing space
-  out = out.replace(new RegExp(`${ISSUES}[ \\t]?`, 'g'), '');
-  // (b3-conn) HR ref joined by a connective → drop ref + separator (mirror of b1b)
-  out = out.replace(/[ \t]*[,/;:][ \t]*HR\d+(?:\/\d+)*\b/g, '');
-  // (b3a) HR ref (compound) with a leading space
-  out = out.replace(/[ \t]HR\d+(?:\/\d+)*\b/g, '');
-  // (b3b) remaining HR ref → eat one trailing space
-  out = out.replace(/\bHR\d+(?:\/\d+)*\b[ \t]?/g, '');
-  return out;
-}
-
-// (c) -----------------------------------------------------------------------
-function projectPaths(s) {
-  // `../../.claude/skills/...` → root-relative (cross-skill reach, PLAN c)
-  return s.replace(/(?:\.\.\/)+(?=(?:\.claude|\.agents|docs|scripts)\/)/g, '');
-}
-
-export function scrub(text) {
-  if (!text) return text;
-  let out = privateTokens(text);
-  out = internalRefs(out);
-  out = projectPaths(out);
-  return out;
-}

package/scripts/lib/scrub.test.mjs

@@ -1,187 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { scrub } from './scrub.mjs';
-
-// =========================================================================
-// (a) private identity tokens  →  neutral placeholders
-// =========================================================================
-test('(a) repo slug + bare owner/repo', () => {
-  assert.equal(scrub('see iKon85/Testreporter for x'), 'see <owner>/<repo> for x');
-  assert.equal(scrub('github.com/iKon85/Testreporter/issues/5'),
-    'github.com/<owner>/<repo>/issues/5');
-  assert.equal(scrub('authored by iKon85.'), 'authored by <owner>.');
-  assert.equal(scrub('the Testreporter board'), 'the <repo> board');
-});
-
-test('(a) deploy platform + domains', () => {
-  assert.equal(scrub('gemerged → Coolify deployt `main`'),
-    'gemerged → your deploy platform deployt `main`');
-  assert.equal(scrub('curl https://testreporter.iverra.de/version.txt'),
-    'curl https://<your-app-domain>/version.txt');
-  assert.equal(scrub('api.testreporter.iverra.de/health'), '<your-app-domain>/health');
-});
-
-test('(a) person + home memory path', () => {
-  assert.equal(scrub('↓ (Niko wählt Wellen)'), '↓ (<maintainer> wählt Wellen)');
-  assert.equal(scrub('das war Nikos Call'), 'das war <maintainer>s Call');
-  assert.equal(scrub('Note `~/.claude/projects/-home-x-testreporter/memory/foo`'),
-    'Note `~/.claude/projects/<project>/memory/foo`');
-  // $HOME form + the Claude project slug (which embeds the username) must go too
-  assert.equal(scrub('ls "$HOME/.claude/projects/-home-niko-projects-testreporter/memory/"*.md'),
-    'ls "$HOME/.claude/projects/<project>/memory/"*.md');
-});
-
-// =========================================================================
-// (b) internal #NNN / HRn refs  →  removed, surrounding text normalized
-// =========================================================================
-test('(b) ref-only parenthetical removed cleanly', () => {
-  assert.equal(scrub('fixed the guard (#824).'), 'fixed the guard.');
-  assert.equal(scrub('coherence (#983, #1078) before merge'), 'coherence before merge');
-  assert.equal(scrub('Verify / DoD (HR1): must assert'), 'Verify / DoD: must assert');
-  assert.equal(scrub('the rule (#1010/#971) holds'), 'the rule holds');
-});
-
-test('(b) refs inside content-bearing paren stay readable', () => {
-  assert.equal(scrub('(Lehre #1010/#971: erst prüfen)'), '(Lehre: erst prüfen)');
-  assert.equal(scrub('(#983 Q2). `a`'), '(Q2). `a`');
-});
-
-test('(b) inline prose refs + prose-suffix form', () => {
-  assert.equal(scrub('the #824 anchor guard'), 'the anchor guard');
-  assert.equal(scrub('war der #599-Tracker'), 'war der Tracker');
-  assert.equal(scrub('pro Strang (HR7/8). Sub'), 'pro Strang. Sub');
-});
-
-test('(b) code-embedded ref in a string message', () => {
-  assert.equal(scrub('verfrüht (#824). `Part of #{parent}`'),
-    'verfrüht. `Part of #{parent}`');
-});
-
-test('(b) connective-joined refs drop the dangling separator (no `,)` / `/):` / `:.`)', () => {
-  // leading `/ ` connective → the slash goes with the ref
-  assert.equal(scrub('its own slice (Fix A / #1010): foo'), 'its own slice (Fix A): foo');
-  // leading `, ` connective before a close paren — whole ref-only paren goes
-  // (Welle/Slice are provenance refs now too, so nothing content-bearing remains)
-  assert.equal(scrub('(Welle 26 / Slice 1g, #983).'), '.');
-  // leading `, ` connective before an em-dash
-  assert.equal(scrub('(provenienz-neutral, #1342 — die Form)'), '(provenienz-neutral — die Form)');
-  // leading `: ` connective (label: ref)
-  assert.equal(scrub('Reference output: #1060.'), 'Reference output.');
-  // trailing connective at paren-start (`(#NNN/Word…`)
-  assert.equal(scrub('(#1069/Q4=A: tag once → free)'), '(Q4=A: tag once → free)');
-  // paren-INITIAL ref + connective + SPACE + prose → drop ref+separator, keep `(`
-  assert.equal(scrub('before any write (#1076, real path only)'),
-    'before any write (real path only)');
-  assert.equal(scrub('in place (#1076; own grammar, not anchor-sync)'),
-    'in place (own grammar, not anchor-sync)');
-  assert.equal(scrub('on every run (#983, proven by a double-run).'),
-    'on every run (proven by a double-run).');
-});
-
-test('(b) connective handling preserves real separators with NO adjacent ref', () => {
-  assert.equal(scrub('Verify / DoD: must assert'), 'Verify / DoD: must assert');
-  assert.equal(scrub('def parse(): return a/b'), 'def parse(): return a/b');
-  // a trailing-colon label keeps its colon (the ref before it is removed)
-  assert.equal(scrub('(Lehre #1010/#971: erst prüfen)'), '(Lehre: erst prüfen)');
-});
-
-// =========================================================================
-// (b) NEGATIVES — must be preserved verbatim
-// =========================================================================
-test('(b) preserves placeholders, hex colors, shell comments', () => {
-  assert.equal(scrub('Body braucht `Part of #<parent>`'), 'Body braucht `Part of #<parent>`');
-  assert.equal(scrub('use #<n> and #<anker>'), 'use #<n> and #<anker>');
-  assert.equal(scrub('bg #0f172a text #dc2626'), 'bg #0f172a text #dc2626');
-  assert.equal(scrub('color #1e293b;'), 'color #1e293b;');
-  assert.equal(scrub('# noqa: E402'), '# noqa: E402');
-  assert.equal(scrub('<issue-number> form'), '<issue-number> form');
-  // a code interpolation that looks ref-ish must survive
-  assert.equal(scrub('`closes #{issue}`'), '`closes #{issue}`');
-});
-
-// =========================================================================
-// (b-prov) provenance refs (Welle N / Slice N / ADR-####) — citation-shaped only
-// =========================================================================
-test('(b-prov) ref-only provenance parens are consumed whole', () => {
-  assert.equal(scrub('key (Welle 52) — literal getter'), 'key — literal getter');
-  assert.equal(scrub('items (Welle 52 / Slice 3).'), 'items.');
-  assert.equal(scrub("job (Welle 52 / Slice 1) — this stays"), 'job — this stays');
-  assert.equal(scrub('the CLI adapter (ADR-0034).'), 'the CLI adapter.');
-  assert.equal(scrub('`to-waves` (Slice 4) stamps'), '`to-waves` stamps');
-  assert.equal(scrub('green path (Slice 1).'), 'green path.');
-});
-
-test('(b-prov) mixed provenance+issue paren still consumed', () => {
-  assert.equal(scrub('coherence (Welle 26 / Slice 1g, #983) before'), 'coherence before');
-});
-
-test('(b-prov) NEGATIVE: bare prose / examples survive verbatim', () => {
-  // synthetic PRD fixture prose (spec-self-critique/scenarios.md)
-  assert.equal(scrub('Welle 1 covers 9 slices'), 'Welle 1 covers 9 slices');
-  assert.equal(scrub("Welle 3 — 'Backend'. Welle 4 — 'Frontend'."),
-    "Welle 3 — 'Backend'. Welle 4 — 'Frontend'.");
-  // wave-prefix parser example (board-sync.py) — bare em-dash form
-  assert.equal(scrub('a title like `fix: Welle 7 — X` only'), 'a title like `fix: Welle 7 — X` only');
-  // illustrative ADR name in bare prose (improve-codebase-architecture)
-  assert.equal(scrub('contradicts ADR-0007 — but worth reopening'),
-    'contradicts ADR-0007 — but worth reopening');
-  assert.equal(scrub('Contradicts ADR-0007 (event-sourced orders) — but'),
-    'Contradicts ADR-0007 (event-sourced orders) — but');
-  // template placeholder (wave-anchor-template) — Slice bare, non-ref paren kept
-  assert.equal(scrub('Slice 1 — <Titel> · empf. <Modell>'), 'Slice 1 — <Titel> · empf. <Modell>');
-});
-
-// =========================================================================
-// (c) project-coupled paths  →  project-root convention
-// =========================================================================
-test('(c) ../ paths collapse to root convention', () => {
-  assert.equal(scrub('[X](../../.claude/skills/board-to-waves/SKILL.md)'),
-    '[X](.claude/skills/board-to-waves/SKILL.md)');
-});
-
-test('(c) preserves relative code imports', () => {
-  assert.equal(scrub("import { sha256File } from '../lib/hash.mjs';"),
-    "import { sha256File } from '../lib/hash.mjs';");
-  assert.equal(scrub("import { update } from './update.mjs';"),
-    "import { update } from './update.mjs';");
-});
-
-// =========================================================================
-// idempotency — scrub(scrub(x)) === scrub(x)
-// =========================================================================
-test('scrub is idempotent', () => {
-  const samples = [
-    'iKon85/Testreporter (#824) — Niko, Coolify, testreporter.iverra.de',
-    '(Lehre #1010/#971: erst prüfen) the #824 anchor guard, war der #599-Tracker',
-    'keep #<n> #0f172a # comment <issue-number>',
-    'pro Strang (HR7/8). DoD (HR1): x',
-  ];
-  for (const s of samples) assert.equal(scrub(scrub(s)), scrub(s), `not idempotent: ${s}`);
-});
-
-// =========================================================================
-// removal of single-spaced refs is clean (no empty parens, no new doubles)
-// =========================================================================
-test('removal of single-spaced refs leaves clean text', () => {
-  const out = scrub('a (#824) b (#983, #1078) c (HR1) d');
-  assert.equal(out, 'a b c d');
-  assert.ok(!/\(\s*\)/.test(out), `empty paren in: ${out}`);
-});
-
-// =========================================================================
-// ANTI-CORRUPTION — scrub must NOT touch code, filenames, or aligned whitespace
-// (the failure modes an early global-normalize version introduced)
-// =========================================================================
-test('preserves code parens, filename dots, and aligned whitespace', () => {
-  // code () must never be collapsed (an empty-paren cleanup would have nuked it)
-  assert.equal(scrub('def foo(): pass'), 'def foo(): pass');
-  assert.equal(scrub('build_parser().parse_args()'), 'build_parser().parse_args()');
-  // a leading filename dot must keep its preceding space ("an .env check")
-  assert.equal(scrub('after an .env/secret check'), 'after an .env/secret check');
-  assert.equal(scrub('see [x](docs/agents/board-sync.md) here'),
-    'see [x](docs/agents/board-sync.md) here');
-  // intentional alignment / indentation (ASCII diagrams, tables) is preserved
-  assert.equal(scrub('col1    col2    col3'), 'col1    col2    col3');
-  assert.equal(scrub('board-to-waves   Board → STUB   ← HIER'),
-    'board-to-waves   Board → STUB   ← HIER');
-});

package/scripts/memory-lifecycle/memory-lifecycle.test.mjs

@@ -1,170 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtemp, mkdir, readFile, readdir, symlink, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import {
-  executeMemoryLifecycle,
-  planMemoryLifecycle,
-  runMemoryLifecycle,
-} from './index.mjs';
-
-test('dry-run classifies each candidate once without writing', async () => {
-  const root = await mkdtemp(join(tmpdir(), 'memory-lifecycle-'));
-  const activeRoot = join(root, 'active');
-  const archiveRoot = join(root, 'archive');
-  await mkdir(archiveRoot, { recursive: true });
-  await writeFile(join(archiveRoot, 'returning.md'), 'archived memory\n');
-
-  const plan = await planMemoryLifecycle({
-    activeRoot,
-    archiveRoot,
-    candidates: ['new.md', 'returning.md'],
-    approved: true,
-  });
-
-  assert.deepEqual(plan.actions.map(({ path, action }) => [path, action]), [
-    ['new.md', 'create'],
-    ['returning.md', 'restore'],
-  ]);
-  await assert.rejects(readFile(join(activeRoot, 'new.md'), 'utf8'), { code: 'ENOENT' });
-  await assert.rejects(readFile(join(activeRoot, 'returning.md'), 'utf8'), { code: 'ENOENT' });
-});
-
-test('dry-run refuses unsafe roots, collisions, outside paths, and unapproved restores', async () => {
-  const root = await mkdtemp(join(tmpdir(), 'memory-lifecycle-'));
-  const activeRoot = join(root, 'active');
-  const archiveRoot = join(root, 'archive');
-  await mkdir(activeRoot, { recursive: true });
-  await mkdir(archiveRoot, { recursive: true });
-  await writeFile(join(activeRoot, 'collision.md'), 'active\n');
-  await writeFile(join(archiveRoot, 'collision.md'), 'different archive\n');
-  await writeFile(join(archiveRoot, 'approval.md'), 'archived\n');
-
-  const plan = await planMemoryLifecycle({
-    activeRoot,
-    archiveRoot,
-    candidates: ['../foreign.md', 'collision.md', 'approval.md'],
-  });
-  assert.deepEqual(plan.actions.map(({ action }) => action), ['refuse', 'refuse', 'refuse']);
-
-  const linkedActive = join(root, 'linked-active');
-  await symlink(activeRoot, linkedActive, 'dir');
-  const symlinkPlan = await planMemoryLifecycle({
-    activeRoot: linkedActive,
-    archiveRoot,
-    candidates: ['safe.md'],
-    approved: true,
-  });
-  assert.equal(symlinkPlan.actions[0].action, 'refuse');
-});
-
-test('execute restores without removing the archive and writes a content-free receipt', async () => {
-  const root = await mkdtemp(join(tmpdir(), 'memory-lifecycle-'));
-  const activeRoot = join(root, 'active');
-  const archiveRoot = join(root, 'archive');
-  const receiptRoot = join(root, 'receipts');
-  await mkdir(archiveRoot, { recursive: true });
-  await writeFile(join(archiveRoot, 'returning.md'), 'private memory contents\n');
-
-  const result = await executeMemoryLifecycle({
-    activeRoot,
-    archiveRoot,
-    receiptRoot,
-    candidates: ['returning.md'],
-    approved: true,
-    source: { kitVersion: '1.2.3', bundleVersion: 'bundle-abc' },
-  });
-
-  assert.equal(await readFile(join(activeRoot, 'returning.md'), 'utf8'), 'private memory contents\n');
-  assert.equal(await readFile(join(archiveRoot, 'returning.md'), 'utf8'), 'private memory contents\n');
-  assert.equal(result.verdicts[0].verdict, 'restored');
-  const [receiptName] = await readdir(receiptRoot);
-  const receiptText = await readFile(join(receiptRoot, receiptName), 'utf8');
-  const receipt = JSON.parse(receiptText);
-  assert.equal(receipt.schemaVersion, 1);
-  assert.deepEqual(receipt.source, { kitVersion: '1.2.3', bundleVersion: 'bundle-abc' });
-  assert.match(receipt.verdicts[0].sha256, /^[a-f0-9]{64}$/);
-  assert.ok(!receiptText.includes('private memory contents'));
-});
-
-test('rerun preserves restored memory and never overwrites or duplicates its receipt', async () => {
-  const root = await mkdtemp(join(tmpdir(), 'memory-lifecycle-'));
-  const activeRoot = join(root, 'active');
-  const archiveRoot = join(root, 'archive');
-  const receiptRoot = join(root, 'receipts');
-  await mkdir(archiveRoot, { recursive: true });
-  await writeFile(join(archiveRoot, 'stable.md'), 'stable\n');
-  const options = {
-    activeRoot,
-    archiveRoot,
-    receiptRoot,
-    candidates: ['stable.md'],
-    approved: true,
-    source: { kitVersion: '1.2.3', bundleVersion: 'bundle-abc' },
-  };
-
-  const first = await executeMemoryLifecycle(options);
-  const receiptBefore = await readFile(first.receiptPath, 'utf8');
-  const second = await executeMemoryLifecycle(options);
-
-  assert.equal(second.verdicts[0].verdict, 'skipped');
-  assert.equal(second.receiptPath, null);
-  assert.deepEqual(await readdir(receiptRoot), [first.receiptPath.split('/').at(-1)]);
-  assert.equal(await readFile(first.receiptPath, 'utf8'), receiptBefore);
-});
-
-test('disabled and duplicate candidates produce one explicit skip verdict per path', async () => {
-  const root = await mkdtemp(join(tmpdir(), 'memory-lifecycle-'));
-  const plan = await planMemoryLifecycle({
-    activeRoot: join(root, 'active'),
-    archiveRoot: join(root, 'archive'),
-    candidates: [
-      { path: 'later.md', enabled: false },
-      { path: 'later.md', enabled: false },
-    ],
-    approved: true,
-  });
-
-  assert.deepEqual(plan.actions, [{
-    path: 'later.md',
-    action: 'skip',
-    reason: 'candidate is disabled by consumer policy',
-  }]);
-});
-
-test('missing or disabled consumer profile is a no-write disabled result', async () => {
-  const root = await mkdtemp(join(tmpdir(), 'memory-lifecycle-'));
-
-  assert.deepEqual(await runMemoryLifecycle({ projectRoot: root }), {
-    state: 'disabled',
-    dryRun: true,
-    actions: [],
-  });
-  await assert.rejects(readFile(join(root, '.memory'), 'utf8'), { code: 'ENOENT' });
-});
-
-test('frozen Testreporter parity profile classifies all three native memory rows', async () => {
-  const root = await mkdtemp(join(tmpdir(), 'memory-lifecycle-'));
-  const fixture = JSON.parse(await readFile(new URL(
-    '../../test/fixtures/memory-lifecycle/testreporter-parity.json',
-    import.meta.url,
-  )));
-  const activeRoot = join(root, fixture.activeRoot);
-  const archiveRoot = join(root, fixture.archiveRoot);
-  await mkdir(archiveRoot, { recursive: true });
-  for (const { path } of fixture.memories) {
-    await writeFile(join(archiveRoot, path), `${path}\n`);
-  }
-
-  const plan = await planMemoryLifecycle({
-    activeRoot,
-    archiveRoot,
-    candidates: fixture.memories,
-    approved: fixture.approvals.restore,
-  });
-
-  assert.equal(plan.actions.length, 3);
-  assert.deepEqual(plan.actions.map(({ action }) => action), ['restore', 'restore', 'restore']);
-});