svamp-cli 0.2.223-canary.2 → 0.2.224

package/bin/skills/loop/bin/loop-init.mjs

@@ -1,194 +0,0 @@
-#!/usr/bin/env node
-// loop-init.mjs — project the loop config into Claude Code's native files.
-// Generates, in a target project dir, a SESSION-SCOPED loop home:
-//   .svamp/<sessionId>/loop/{LOOP.md,loop.config.json,loop-state.json,bin/*}
-//   .claude/settings.json hooks (Stop gate + LOOP.md injection),
-//   and (optional) .claude/agents/loop-evaluator.md.
-// Session-scoping keeps sibling sessions in the same working dir from colliding.
-// Usage:
-//   node loop-init.mjs <dir> --task "..." [--criteria "..."] [--oracle "cmd"]
-//        [--max N] [--evaluator on|off] [--model NAME] [--loop-file LOOP.md]
-import { mkdirSync, writeFileSync, copyFileSync, readFileSync, existsSync, chmodSync, rmSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-
-function parseArgs(argv) {
-  const a = { _: [] };
-  for (let i = 0; i < argv.length; i++) {
-    const t = argv[i];
-    if (t.startsWith('--')) { a[t.slice(2)] = (argv[i + 1] && !argv[i + 1].startsWith('--')) ? argv[++i] : true; }
-    else a._.push(t);
-  }
-  return a;
-}
-const args = parseArgs(process.argv.slice(2));
-const dir = resolve(args._[0] || process.cwd());
-const loopFile = args['loop-file'] || 'LOOP.md';
-const oracle = typeof args.oracle === 'string' ? args.oracle : null;
-// #0156: default max_iterations to 10000 — a high but FINITE default suitable for long-running tasks,
-// configurable both here (--max N) and AFTER the loop starts (the limit-only modify-in-place path:
-// `svamp session loop <id> --max N` / the Issues-page loop banner). An explicit --max overrides it;
-// clearing it (∞, governed by a token-rate budget) is still available via the UI.
-const max = args.max ? Number(args.max) : 10000;
-const evaluatorOn = args.evaluator !== 'off';
-const model = typeof args.model === 'string' ? args.model : null;
-const taskProvided = typeof args.task === 'string';
-const task = taskProvided ? args.task : '(describe the task here)';
-const criteria = typeof args.criteria === 'string' ? args.criteria : null;
-// Owning session id, stamped into loop-state.json so the daemon can scope
-// "loop active" (auto-approve / AskUserQuestion auto-dismiss / loop resume) to the
-// session that started the loop instead of every session sharing this directory.
-const sessionId = typeof args.session === 'string' ? args.session
-  : (typeof process.env.SVAMP_SESSION_ID === 'string' && process.env.SVAMP_SESSION_ID) ? process.env.SVAMP_SESSION_ID
-  : null;
-// #0166: hooks-only mode — install the gate scripts + MERGE the hooks into settings.json, but DON'T
-// create a loop (no config/state/LOOP.md/evaluator). Run at SESSION SPAWN so the Stop-gate hook is
-// loaded before any loop exists; the hooks no-op while no loop is active (stop-gate: `!cfg` → allow).
-// This is what makes loop start/stop/config-update SEAMLESS — the daemon never restarts Claude to load
-// the hook. Idempotent + safe to call on every spawn (it does NOT touch an existing loop's state).
-const hooksOnly = args['hooks-only'] === true || args['hooks-only'] === 'true';
-
-// Session-scoped loop home so sessions sharing a working dir never collide:
-//   <dir>/.svamp/<sessionId>/loop/   (falls back to <dir>/.svamp/loop/ with no session).
-// The Claude Code hook DEFINITIONS still live in <dir>/.claude/settings.json (that is
-// Claude Code's own config), but the loop's state + memory now live under .svamp.
-const loopDir = sessionId ? join(dir, '.svamp', sessionId, 'loop') : join(dir, '.svamp', 'loop');
-const binDir = join(loopDir, 'bin');
-mkdirSync(binDir, { recursive: true });
-mkdirSync(join(dir, '.claude', 'agents'), { recursive: true });
-
-// Re-arm cleanly: a NEW loop must NOT inherit the PREVIOUS loop's evaluator verdict or
-// history. A verdict is task+instance specific, but its freshness fingerprint only covers
-// the work tree (state-fp excludes LOOP.md + .svamp/). So a stale {verdict:done, state_fp}
-// left by a finished loop would FALSE-CLOSE a fresh loop at iteration 0 whenever the tree
-// is unchanged between loops. Always clear them so a new loop requires its own fresh verdict.
-// #0166: hooks-only NEVER re-arms — it must not disturb an existing loop's verdict/history/state.
-if (!hooksOnly) {
-  rmSync(join(loopDir, 'evaluator-verdict.json'), { force: true });
-  rmSync(join(loopDir, 'history.jsonl'), { force: true });
-}
-
-// 1. Copy hook scripts so the project is self-contained.
-for (const f of ['state-fp.mjs', 'stop-gate.mjs', 'inject-loop.mjs', 'loop-status.mjs', 'precompact.mjs']) {
-  const dest = join(binDir, f);
-  copyFileSync(join(HERE, f), dest);
-  try { chmodSync(dest, 0o755); } catch {}
-}
-
-// #0166: steps 2-4 CREATE/refresh the loop — skipped in hooks-only mode (the spawn pre-install only
-// installs the dormant gate). The copy-scripts (1) + hooks (5) below always run.
-if (!hooksOnly) {
-// 2. loop.config.json
-const config = {
-  loop_file: loopFile,
-  // The repo/working root — copied hook scripts (which live under .svamp/<sid>/loop/bin
-  // and resolve their own dir relatively) read this to run the oracle + fingerprint the
-  // work product, since their depth no longer encodes the project root.
-  project_dir: dir,
-  // The success contract — the "until" the loop gate runs against. Read by the daemon
-  // to populate the loop verdict event (legacy wire type: supervision:verdict).
-  ...(criteria ? { criteria: criteria.trim() } : {}),
-  oracle: oracle ? { command: oracle, timeout_sec: 600 } : null,
-  evaluator: { enabled: evaluatorOn, model },
-  max_iterations: max,
-  budget: (args['max-runtime'] || args['max-tokens'] || args['max-tokens-per-hour']) ? {
-    ...(args['max-runtime'] ? { max_runtime_sec: Number(args['max-runtime']) } : {}),
-    ...(args['max-tokens'] ? { max_tokens: Number(args['max-tokens']) } : {}),
-    // #0156: a ROLLING token-rate cap (tokens per the last hour) — the primary limiter for a
-    // long-running loop. The gate sums only the last hour's transcript usage and stalls if over.
-    ...(args['max-tokens-per-hour'] ? { max_tokens_per_hour: Number(args['max-tokens-per-hour']) } : {}),
-  } : undefined,
-};
-writeFileSync(join(loopDir, 'loop.config.json'), JSON.stringify(config, null, 2));
-
-// 3. loop-state.json (machine state, daemon/gate-owned)
-writeFileSync(join(loopDir, 'loop-state.json'), JSON.stringify({
-  active: true, iteration: 0, phase: 'running', started_at: new Date().toISOString(),
-  ...(sessionId ? { session_id: sessionId } : {}),
-}, null, 2));
-
-// 4. LOOP.md (agent + human editable) — lives inside the session-scoped loop dir
-// so two sessions in one working dir keep separate memory. Write it when a task is
-// provided (a fresh loop-start must NOT inherit a previous loop's task left over in the
-// same session dir), or when none exists yet. Only a hand-authored LOOP.md with NO
-// --task passed is preserved (standalone "I pre-wrote the task" case).
-const loopPath = join(loopDir, loopFile);
-if (taskProvided || !existsSync(loopPath)) {
-  writeFileSync(loopPath, `# Loop Task
-
-## Task
-${task}
-
-## Success criteria
-${criteria
-  ? criteria.split('\n').map((l) => l.trim()).filter(Boolean).map((l) => (l.startsWith('-') ? l : `- ${l}`)).join('\n')
-  : '- (define objective success criteria)'}
-${oracle ? `- The oracle passes: \`${oracle}\`` : ''}
-- An independent evaluator confirms the work is genuinely complete.
-
-## Plan
-- (the agent fills this in)
-
-## Progress
-- (the agent appends iteration notes here; this is durable memory)
-`);
-}
-} // end if(!hooksOnly): loop creation (config/state/LOOP.md)
-
-// 5. .claude/settings.json hooks — ALWAYS install/refresh the gate so it's loaded at the next Claude
-// start (pre-installed at spawn via hooks-only, so loop start/stop/config never needs a restart).
-// #0166: MERGE, don't clobber — preserve any user-defined hooks for these events; only replace OUR
-// own prior entry (matched by the loop script name) so re-running can't duplicate it.
-const settingsPath = join(dir, '.claude', 'settings.json');
-let settings = {};
-if (existsSync(settingsPath)) { try { settings = JSON.parse(readFileSync(settingsPath, 'utf8')); } catch {} }
-const node = process.execPath;
-const cmd = (script) => `"${node}" "${join(binDir, script)}"`;
-settings.hooks = settings.hooks || {};
-const mergeHook = (event, script) => {
-  const existing = Array.isArray(settings.hooks[event]) ? settings.hooks[event] : [];
-  // Drop any prior group that points at one of OUR loop scripts (so we refresh, never duplicate),
-  // keeping all user-defined groups for this event intact.
-  const others = existing.filter((g) => !(Array.isArray(g?.hooks) && g.hooks.some(
-    (h) => typeof h?.command === 'string' && /loop[\\/](bin[\\/])?(inject-loop|stop-gate|precompact)\.mjs/.test(h.command))));
-  settings.hooks[event] = [...others, { hooks: [{ type: 'command', command: cmd(script) }] }];
-};
-mergeHook('SessionStart', 'inject-loop.mjs');
-mergeHook('UserPromptSubmit', 'inject-loop.mjs');
-mergeHook('Stop', 'stop-gate.mjs');
-mergeHook('PreCompact', 'precompact.mjs');
-writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-
-// 6. Evaluator agent (materialized) — optional (skipped in hooks-only: no loop yet)
-if (!hooksOnly && evaluatorOn) {
-  const fm = ['---', 'name: loop-evaluator',
-    'description: Skeptical independent reviewer that decides if a loop task is genuinely complete.',
-    'tools: Read, Bash, Grep, Glob', ...(model ? [`model: ${model}`] : []), '---', ''].join('\n');
-  writeFileSync(join(dir, '.claude', 'agents', 'loop-evaluator.md'), fm +
-`You are an INDEPENDENT, skeptical reviewer. You did NOT write the code under review.
-
-You are given: the task/goal (from LOOP.md), the current diff, and the oracle output.
-Decide whether the work is GENUINELY and COMPLETELY done — default to "continue" on any doubt.
-
-Check:
-- Does it actually satisfy every success criterion in LOOP.md (not just look plausible)?
-- Does the oracle genuinely pass, and does it actually cover the requirement?
-- Edge cases, stubbed/faked functionality, regressions.
-- If this loop works an ISSUE BACKLOG: is EACH issue closed this round genuinely resolved by the real change? A green oracle only means "no open issues", not that each closed issue actually works — reject "done" if any was closed without real resolution.
-- HOLISTIC, from the USER's perspective: re-read the ORIGINAL request behind each closed issue (not just its triaged title) and the OVERALL project goal, and confirm we delivered what the user actually wanted end-to-end — INCLUDING that the change was built / published / deployed wherever the request implied it, not merely committed. Reject "done" if the project goal isn't genuinely met from the user's point of view, even when no issues remain open.
-
-Return ONLY a JSON object:
-{"verdict":"done"|"continue","reason":"<concise>","guidance":"<what to fix if continue>"}
-Be strict. A false "done" is far worse than one more iteration.
-`);
-}
-
-console.log(`✅ loop initialised in ${dir}
-  loop dir  : ${loopDir}
-  task file : ${join(loopDir, loopFile)}
-  oracle    : ${oracle || '(none)'}
-  evaluator : ${evaluatorOn ? 'on' + (model ? ` (${model})` : '') : 'off'}
-  max iters : ${max}
-  hooks     : SessionStart, UserPromptSubmit, Stop  (.claude/settings.json)`);

package/bin/skills/loop/bin/loop-status.mjs

@@ -1,51 +0,0 @@
-#!/usr/bin/env node
-// loop-status.mjs — show a loop's current state + per-iteration history timeline.
-// Usage: node loop-status.mjs [project-dir] [--session <id>] [--json] [-n <count>]
-import { readFileSync, existsSync, readdirSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-
-const args = process.argv.slice(2);
-const json = args.includes('--json');
-const nIdx = args.indexOf('-n');
-const limit = nIdx !== -1 ? Number(args[nIdx + 1]) : 20;
-const sIdx = args.indexOf('--session');
-const sessionId = sIdx !== -1 ? args[sIdx + 1] : (process.env.SVAMP_SESSION_ID || null);
-const dir = resolve(args.find((a) => !a.startsWith('-') && a !== String(limit) && a !== sessionId) || process.cwd());
-
-// Find the loop home: explicit session → .svamp/<sid>/loop; else any session-scoped
-// loop that has state; else .svamp/loop; else legacy .claude/loop.
-function pickLoopDir(root, sid) {
-  const cands = [];
-  if (sid) cands.push(join(root, '.svamp', sid, 'loop'));
-  try { for (const e of readdirSync(join(root, '.svamp'), { withFileTypes: true })) if (e.isDirectory() && e.name !== sid) cands.push(join(root, '.svamp', e.name, 'loop')); } catch {}
-  cands.push(join(root, '.svamp', 'loop'), join(root, '.claude', 'loop'));
-  for (const c of cands) if (existsSync(join(c, 'loop-state.json'))) return c;
-  return sid ? join(root, '.svamp', sid, 'loop') : cands[cands.length - 1];
-}
-const LOOP_DIR = pickLoopDir(dir, sessionId);
-
-const readJSON = (p, f) => { try { return JSON.parse(readFileSync(p, 'utf8')); } catch { return f; } };
-const state = readJSON(join(LOOP_DIR, 'loop.config.json'), null)
-  ? readJSON(join(LOOP_DIR, 'loop-state.json'), {})
-  : null;
-
-let history = [];
-try {
-  history = readFileSync(join(LOOP_DIR, 'history.jsonl'), 'utf8')
-    .split('\n').filter(Boolean).map((l) => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
-} catch {}
-
-if (json) {
-  console.log(JSON.stringify({ state, history: history.slice(-limit) }, null, 2));
-} else if (!state) {
-  console.log('No loop configured in', dir);
-} else {
-  const icon = { done: '✅', gave_up: '🛑', continue: '🔄', running: '🔄' };
-  console.log(`Loop in ${dir}`);
-  console.log(`  phase: ${state.phase || '?'} | iteration: ${state.iteration ?? 0}${state.gave_up_reason ? ` | gave up: ${state.gave_up_reason}` : ''}`);
-  if (state.last_oracle) console.log(`  oracle: ${String(state.last_oracle).split('\n')[0]}`);
-  console.log(`  history (last ${Math.min(limit, history.length)} of ${history.length}):`);
-  for (const h of history.slice(-limit)) {
-    console.log(`    ${icon[h.decision] || '·'} iter ${h.iteration} [${h.decision}] ${h.ts}${h.reason ? ' — ' + h.reason : ''}`);
-  }
-}

package/bin/skills/loop/bin/precompact.mjs

@@ -1,30 +0,0 @@
-#!/usr/bin/env node
-// precompact.mjs — Claude Code `PreCompact` hook. Records a compaction event in
-// the loop's history timeline (so the monitor shows context resets) and reminds
-// the agent that LOOP.md is the durable handoff across compaction.
-import { readFileSync, appendFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-// Resolve the loop home from the per-process env (shared-settings safe); fallback to
-// the parent of this copied bin/ dir.
-const SID = process.env.SVAMP_SESSION_ID || null;
-const PROJECT_ENV = process.env.CLAUDE_PROJECT_DIR || null;
-const LOOP_DIR = (SID && PROJECT_ENV) ? join(PROJECT_ENV, '.svamp', SID, 'loop') : resolve(HERE, '..');
-
-let active = false;
-try { active = JSON.parse(readFileSync(join(LOOP_DIR, 'loop-state.json'), 'utf8')).active !== false; } catch {}
-if (!active) process.exit(0);
-
-let iteration = 0;
-try { iteration = JSON.parse(readFileSync(join(LOOP_DIR, 'loop-state.json'), 'utf8')).iteration || 0; } catch {}
-try {
-  appendFileSync(join(LOOP_DIR, 'history.jsonl'),
-    JSON.stringify({ ts: new Date().toISOString(), iteration, decision: 'compaction' }) + '\n');
-} catch {}
-
-// Context is about to be compacted — LOOP.md (auto-injected on the next turn) is
-// the durable handoff. Nudge the agent to ensure its progress is captured there.
-process.stdout.write('Context is being compacted. LOOP.md is your durable memory across this reset — ensure your latest progress, plan, and remaining work are written there before continuing.');
-process.exit(0);

package/bin/skills/loop/bin/routine-core.mjs

@@ -1,126 +0,0 @@
-#!/usr/bin/env node
-// routine-core.mjs — dependency-free primitives for the routine layer:
-//   * cron matching + next-fire (standard 5-field cron)
-//   * payload templating (${body.x}/${query.x}/${now}) for trigger -> action
-//   * routine spec validation
-// No external deps (mirrors the loop gate). Pure + unit-testable.
-
-// ---- cron ---------------------------------------------------------------
-const FIELD_RANGES = [
-  [0, 59], // minute
-  [0, 23], // hour
-  [1, 31], // day of month
-  [1, 12], // month
-  [0, 6],  // day of week (0=Sun)
-];
-
-function parseField(token, [min, max]) {
-  const set = new Set();
-  for (const part of token.split(',')) {
-    let m;
-    if (part === '*') { for (let i = min; i <= max; i++) set.add(i); }
-    else if ((m = part.match(/^\*\/(\d+)$/))) { const s = +m[1]; for (let i = min; i <= max; i += s) set.add(i); }
-    else if ((m = part.match(/^(\d+)-(\d+)\/(\d+)$/))) { const [, a, b, s] = m; for (let i = +a; i <= +b; i += +s) set.add(i); }
-    else if ((m = part.match(/^(\d+)-(\d+)$/))) { const [, a, b] = m; for (let i = +a; i <= +b; i++) set.add(i); }
-    else if ((m = part.match(/^(\d+)$/))) { set.add(+m[1]); }
-    else throw new Error(`invalid cron field: "${token}"`);
-  }
-  for (const v of set) if (v < min || v > max) throw new Error(`cron value ${v} out of range [${min},${max}]`);
-  return set;
-}
-
-export function parseCron(expr) {
-  const fields = String(expr).trim().split(/\s+/);
-  if (fields.length !== 5) throw new Error(`cron must have 5 fields, got ${fields.length}: "${expr}"`);
-  const [minute, hour, dom, month, dow] = fields.map((f, i) => parseField(f, FIELD_RANGES[i]));
-  const domRestricted = fields[2] !== '*';
-  const dowRestricted = fields[4] !== '*';
-  return { minute, hour, dom, month, dow, domRestricted, dowRestricted };
-}
-
-/** Does `date` (minute resolution) match the cron expr? */
-export function cronMatches(expr, date) {
-  const c = typeof expr === 'string' ? parseCron(expr) : expr;
-  if (!c.minute.has(date.getMinutes())) return false;
-  if (!c.hour.has(date.getHours())) return false;
-  if (!c.month.has(date.getMonth() + 1)) return false;
-  const domOk = c.dom.has(date.getDate());
-  const dowOk = c.dow.has(date.getDay());
-  // Standard cron: when BOTH dom and dow are restricted, match is OR; else AND.
-  if (c.domRestricted && c.dowRestricted) return domOk || dowOk;
-  return domOk && dowOk;
-}
-
-/** First firing strictly after `from` (defaults to now-ish; caller passes Date). */
-// Return a Date whose LOCAL fields equal the wall-clock time in `tz`, so
-// cronMatches (which reads local getHours/getMinutes/...) effectively matches
-// against that timezone. Falls back to the input on any error.
-export function inZone(date, tz) {
-  if (!tz) return date;
-  try {
-    const p = new Intl.DateTimeFormat('en-US', { timeZone: tz, hour12: false,
-      year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit' })
-      .formatToParts(date).reduce((o, x) => { o[x.type] = x.value; return o; }, {});
-    return new Date(+p.year, +p.month - 1, +p.day, +(p.hour === '24' ? 0 : p.hour), +p.minute);
-  } catch { return date; }
-}
-
-export function nextFire(expr, from, tz) {
-  const c = parseCron(expr);
-  const d = new Date(from.getTime());
-  d.setSeconds(0, 0);
-  d.setMinutes(d.getMinutes() + 1); // strictly after
-  const limit = 366 * 24 * 60; // scan up to ~1 year of minutes
-  for (let i = 0; i < limit; i++) {
-    if (cronMatches(c, tz ? inZone(d, tz) : d)) return new Date(d.getTime());
-    d.setMinutes(d.getMinutes() + 1);
-  }
-  return null;
-}
-
-// ---- templating ---------------------------------------------------------
-function resolvePath(ctx, path) {
-  return path.split('.').reduce((o, k) => (o == null ? undefined : o[k]), ctx);
-}
-/** Replace ${a.b.c} from ctx; missing -> empty string. No code eval. */
-export function renderTemplate(template, ctx) {
-  return String(template).replace(/\$\{([\w.$]+)\}/g, (_, p) => {
-    const v = resolvePath(ctx, p);
-    return v == null ? '' : (typeof v === 'object' ? JSON.stringify(v) : String(v));
-  });
-}
-
-// ---- spec validation ----------------------------------------------------
-const TRIGGER_TYPES = ['manual', 'schedule', 'webhook', 'api'];
-const ACTION_KINDS = ['message', 'loop'];
-const OVERLAP = ['queue', 'skip', 'replace'];
-
-export function validateRoutine(r) {
-  const errs = [];
-  if (!r || typeof r !== 'object') return ['routine must be an object'];
-  if (!r.session_id) errs.push('session_id required');
-  if (!r.name) errs.push('name required');
-  const t = r.trigger;
-  if (!t || !TRIGGER_TYPES.includes(t.type)) errs.push(`trigger.type must be one of ${TRIGGER_TYPES.join('|')}`);
-  if (t?.type === 'schedule') {
-    try { parseCron(t.cron); } catch (e) { errs.push(`trigger.cron: ${e.message}`); }
-    if (t.missed && !['catchup', 'skip'].includes(t.missed)) errs.push('trigger.missed must be catchup|skip');
-  }
-  const a = r.action;
-  if (!a || !ACTION_KINDS.includes(a.kind)) errs.push(`action.kind must be one of ${ACTION_KINDS.join('|')}`);
-  if (a?.kind === 'message' && !a.template) errs.push('action.template required for message action');
-  if (a?.kind === 'loop' && !a.loop && !a.task_template) errs.push('action.loop or action.task_template required for loop action');
-  if (r.overlap && !OVERLAP.includes(r.overlap)) errs.push(`overlap must be one of ${OVERLAP.join('|')}`);
-  // Security: a public (keyless) webhook + loop action = unauthenticated task
-  // injection into the session. Require a key for loop actions.
-  if ((t?.type === 'webhook' || t?.type === 'api') && t.public && a?.kind === 'loop')
-    errs.push('a public webhook/api may not use a loop action (unauthenticated task injection) — use a message action or require a key');
-  return errs;
-}
-
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const [cmd, ...rest] = process.argv.slice(2);
-  if (cmd === 'next') console.log(nextFire(rest.join(' '), new Date())?.toISOString() || 'no fire');
-  else if (cmd === 'matches') console.log(cronMatches(rest.slice(0, 5).join(' '), new Date()));
-  else console.log('usage: routine-core.mjs next "<cron>" | matches "<cron>"');
-}

package/bin/skills/loop/bin/state-fp.mjs

@@ -1,111 +0,0 @@
-#!/usr/bin/env node
-// state-fp.mjs — deterministic fingerprint of a project's working-tree state.
-// Used to tie an evaluator verdict to the exact code it judged: if the actor
-// edits anything after the evaluator ran, the fingerprint changes and the
-// stale verdict is rejected by the Stop gate.
-import { execFileSync } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import { readFileSync, statSync, readdirSync, readlinkSync } from 'node:fs';
-import { join } from 'node:path';
-
-function git(dir, args) {
-  try {
-    return execFileSync('git', ['-C', dir, ...args], {
-      encoding: 'utf8', maxBuffer: 64 * 1024 * 1024,
-      stdio: ['ignore', 'pipe', 'ignore'], // swallow "not a git repository" noise
-    });
-  } catch {
-    return '';
-  }
-}
-
-// Paths excluded from the fingerprint: the loop's own bookkeeping AND its
-// memory file (LOOP.md). The fingerprint must track the WORK PRODUCT only —
-// LOOP.md/state/verdict change every iteration and would otherwise make every
-// verdict look stale (the agent updates LOOP.md progress as it works).
-function excludedPaths(dir) {
-  // The loop's bookkeeping + memory now live under .svamp/<sid>/loop/ (and legacy
-  // loops under .claude/loop/). Both — plus a root LOOP.md a legacy loop may have
-  // left — are excluded so the fingerprint tracks the WORK PRODUCT only.
-  return { loopFile: 'LOOP.md', prefixes: ['.svamp/', '.claude/loop/'] };
-}
-
-const WALK_SKIP = new Set(['.git', 'node_modules', '.svamp', '.expo', 'dist', 'build']);
-
-/** Fallback for non-git (or no-HEAD) dirs: hash all files on disk so the
- * fingerprint actually reflects content. Without this, git plumbing returns
- * empty strings and every state hashes identically — accepting stale verdicts. */
-function walkFingerprint(dir, isExcluded) {
-  const h = createHash('sha256');
-  h.update('WALK\0');
-  const files = [];
-  const links = [];
-  const walk = (abs, rel) => {
-    let entries; try { entries = readdirSync(abs, { withFileTypes: true }); } catch { return; }
-    for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-      const childRel = rel ? `${rel}/${e.name}` : e.name;
-      if (WALK_SKIP.has(e.name) || isExcluded(childRel)) continue;
-      const childAbs = join(abs, e.name);
-      // Symlinks: hash the link TARGET (don't follow — avoids cycles/escape) so a
-      // work product reached via a symlink still changes the fingerprint.
-      if (e.isSymbolicLink()) { try { links.push([childRel, readlinkSync(childAbs)]); } catch { links.push([childRel, 'unreadable']); } }
-      else if (e.isDirectory()) walk(childAbs, childRel);
-      else if (e.isFile()) files.push([childRel, childAbs]);
-    }
-  };
-  walk(dir, '');
-  for (const [rel, abs] of files.sort((a, b) => a[0].localeCompare(b[0]))) {
-    let part = rel + ':';
-    try {
-      const st = statSync(abs);
-      part += st.size < 4 * 1024 * 1024
-        ? st.size + ':' + createHash('sha256').update(readFileSync(abs)).digest('hex')
-        : st.size + ':skip';
-    } catch { part += 'missing'; }
-    h.update(part + '\0');
-  }
-  h.update('SYMLINKS\0');
-  for (const [rel, target] of links.sort((a, b) => a[0].localeCompare(b[0]))) h.update(rel + ':->' + target + '\0');
-  return h.digest('hex');
-}
-
-/** Fingerprint = HEAD + tracked diff + untracked file contents (size+sha).
- * Falls back to a filesystem walk when the dir is not a git repo / has no HEAD. */
-export function stateFingerprint(dir) {
-  const { loopFile, prefixes } = excludedPaths(dir);
-  const isExcluded = (p) => p === loopFile || prefixes.some((pre) => p.startsWith(pre));
-  const head = git(dir, ['rev-parse', 'HEAD']).trim();
-  if (!head) return walkFingerprint(dir, isExcluded); // non-git / no commit yet
-  // Exclude bookkeeping/memory from the tracked diff too (in case they're committed).
-  const diff = git(dir, ['-c', 'core.quotepath=false', 'diff', 'HEAD', '--',
-    '.', `:(exclude)${loopFile}`, ':(exclude).claude/loop', ':(exclude).svamp']);
-  // KNOWN LIMITATION (review #8): --exclude-standard omits gitignored files, so a
-  // loop whose work product lands in a gitignored path (e.g. dist/) won't change
-  // the fingerprint. Acceptable since work products are normally tracked; loops
-  // targeting gitignored output should commit/track it or run in a non-git dir.
-  const untrackedList = git(dir, ['ls-files', '--others', '--exclude-standard'])
-    .split('\n').map((s) => s.trim()).filter(Boolean)
-    .filter((p) => !isExcluded(p))
-    .sort();
-  const h = createHash('sha256');
-  h.update('HEAD\0' + head + '\0DIFF\0' + diff + '\0UNTRACKED\0');
-  for (const rel of untrackedList) {
-    const abs = join(dir, rel);
-    let part = rel + ':';
-    try {
-      const st = statSync(abs);
-      if (st.isFile() && st.size < 4 * 1024 * 1024) {
-        part += st.size + ':' + createHash('sha256').update(readFileSync(abs)).digest('hex');
-      } else {
-        part += st.size + ':skip';
-      }
-    } catch { part += 'missing'; }
-    h.update(part + '\0');
-  }
-  return h.digest('hex');
-}
-
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const dir = process.argv[2] || process.cwd();
-  process.stdout.write(stateFingerprint(dir) + '\n');
-}