svamp-cli 0.2.106 → 0.2.108

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

@@ -3,36 +3,50 @@
 // Injects the current LOOP.md plus the loop protocol so every iteration starts
 // from the latest task/plan/progress without any daemon re-injection.
 import { readFileSync, existsSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, join, resolve, relative } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
-const PROJECT = resolve(HERE, '..', '..', '..');
-const LOOP_DIR = join(PROJECT, '.claude', 'loop');
+// Resolve the loop home from the per-process env (SVAMP_SESSION_ID + CLAUDE_PROJECT_DIR)
+// so a hook in the SHARED .claude/settings.json injects each session's OWN LOOP.md.
+// Fallback (manual/standalone): 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, '..');
 
 function readJSON(p, f) { try { return JSON.parse(readFileSync(p, 'utf8')); } catch { return f; } }
 const cfg = readJSON(join(LOOP_DIR, 'loop.config.json'), null);
 const state = readJSON(join(LOOP_DIR, 'loop-state.json'), { active: false });
 if (!cfg || state.active === false) process.exit(0); // no active loop -> inject nothing
 
+const PROJECT = (typeof cfg.project_dir === 'string' && cfg.project_dir)
+  || process.env.CLAUDE_PROJECT_DIR || resolve(LOOP_DIR, '..', '..', '..');
+
+// LOOP.md now lives inside the (session-scoped) loop dir.
+const loopPath = join(LOOP_DIR, cfg.loop_file || 'LOOP.md');
 let loopMd = '';
-const loopPath = join(PROJECT, cfg.loop_file || 'LOOP.md');
 if (existsSync(loopPath)) loopMd = readFileSync(loopPath, 'utf8');
 
 const evaluatorOn = cfg.evaluator?.enabled !== false;
 const oracleCmd = cfg.oracle?.command || cfg.oracle?.test || cfg.oracle?.build || cfg.oracle || null;
+// Paths the agent must use, expressed relative to where it runs (PROJECT).
+const LOOPMD_REL = relative(PROJECT, loopPath) || 'LOOP.md';
+const VERDICT_REL = relative(PROJECT, join(LOOP_DIR, 'evaluator-verdict.json')) || join(LOOP_DIR, 'evaluator-verdict.json');
+const STATEFP_REL = relative(PROJECT, join(LOOP_DIR, 'bin', 'state-fp.mjs')) || join(LOOP_DIR, 'bin', 'state-fp.mjs');
 
 const protocol = `# 🔁 LOOP MODE IS ACTIVE
 
 You are running inside a loop. Each turn is one iteration. Work toward completing the task described in LOOP.md below. You CANNOT end the loop by simply saying you are done — a Stop gate independently re-checks the exit conditions and will send you back to work if they are not met.
 
+Your LOOP.md (durable memory) is at \`${LOOPMD_REL}\` — read and update it there.
+
 **Exit conditions (all must hold before the loop ends):**
-${oracleCmd ? `1. The oracle command must pass: \`${oracleCmd}\` (exit 0). The gate runs this itself — do not fake it.\n` : '1. (No oracle configured.)\n'}${evaluatorOn ? `2. An INDEPENDENT evaluator must judge the work \"done\". Before you finish: spawn a fresh subagent (Task tool) named/acting as \`loop-evaluator\` with a skeptical reviewer prompt; give it ONLY the goal (from LOOP.md), the current diff, and the oracle output. Have IT decide. Then record its verdict to \`.claude/loop/evaluator-verdict.json\`:\n   {"verdict":"done"|"continue","reason":"...","guidance":"...","state_fp":"<output of: node .claude/loop/bin/state-fp.mjs>"}\n   Do NOT grade your own work — the verdict must come from the subagent, and it is only valid for the exact code state it reviewed.\n` : ''}
+${oracleCmd ? `1. The oracle command must pass: \`${oracleCmd}\` (exit 0). The gate runs this itself — do not fake it.\n` : '1. (No oracle configured.)\n'}${evaluatorOn ? `2. An INDEPENDENT evaluator must judge the work \"done\". Before you finish: spawn a fresh subagent (Task tool) named/acting as \`loop-evaluator\` with a skeptical reviewer prompt; give it ONLY the goal (from LOOP.md), the current diff, and the oracle output. Have IT decide. Then record its verdict to \`${VERDICT_REL}\`:\n   {"verdict":"done"|"continue","reason":"...","guidance":"...","state_fp":"<output of: node ${STATEFP_REL}>"}\n   Do NOT grade your own work — the verdict must come from the subagent, and it is only valid for the exact code state it reviewed.\n` : ''}
 
 **Each iteration:** read LOOP.md → make real progress on the task → update the Progress section of LOOP.md → run/verify the oracle → (if you believe it's done) get the evaluator verdict → end your turn to be re-checked. Keep LOOP.md current; it is your durable memory across iterations and restarts.
 
 ---
-## LOOP.md
+## LOOP.md (${LOOPMD_REL})
 ${loopMd || '(LOOP.md not found — create it with the task and a Progress section.)'}
 `;
 

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

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 // loop-init.mjs — project the loop config into Claude Code's native files.
-// Generates, in a target project dir:
-//   LOOP.md (if absent), .claude/loop/{loop.config.json,loop-state.json,bin/*},
+// 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]
@@ -34,9 +35,15 @@ 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 : null;
-
-const loopDir = join(dir, '.claude', 'loop');
+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;
+
+// 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 });
@@ -51,6 +58,10 @@ for (const f of ['state-fp.mjs', 'stop-gate.mjs', 'inject-loop.mjs', 'loop-statu
 // 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,
   oracle: oracle ? { command: oracle, timeout_sec: 600 } : null,
   evaluator: { enabled: evaluatorOn, model },
   max_iterations: max,
@@ -67,8 +78,9 @@ writeFileSync(join(loopDir, 'loop-state.json'), JSON.stringify({
   ...(sessionId ? { session_id: sessionId } : {}),
 }, null, 2));
 
-// 4. LOOP.md (agent + human editable) — only if not present
-const loopPath = join(dir, loopFile);
+// 4. LOOP.md (agent + human editable) — lives inside the session-scoped loop dir
+// so two sessions in one working dir keep separate memory. Only written if absent.
+const loopPath = join(loopDir, loopFile);
 if (!existsSync(loopPath)) {
   writeFileSync(loopPath, `# Loop Task
 
@@ -126,7 +138,8 @@ Be strict. A false "done" is far worse than one more iteration.
 }
 
 console.log(`✅ loop initialised in ${dir}
-  task file : ${loopFile}
+  loop dir  : ${loopDir}
+  task file : ${join(loopDir, loopFile)}
   oracle    : ${oracle || '(none)'}
   evaluator : ${evaluatorOn ? 'on' + (model ? ` (${model})` : '') : 'off'}
   max iters : ${max}

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

@@ -1,15 +1,28 @@
 #!/usr/bin/env node
 // loop-status.mjs — show a loop's current state + per-iteration history timeline.
-// Usage: node loop-status.mjs [project-dir] [--json] [-n <count>]
-import { readFileSync } from 'node:fs';
+// 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 dir = resolve(args.find((a) => !a.startsWith('-') && a !== String(limit)) || process.cwd());
-const LOOP_DIR = join(dir, '.claude', 'loop');
+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)

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

@@ -7,8 +7,11 @@ import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
-const PROJECT = resolve(HERE, '..', '..', '..');
-const LOOP_DIR = join(PROJECT, '.claude', 'loop');
+// 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 {}

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

@@ -24,12 +24,10 @@ function git(dir, args) {
 // 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) {
-  let loopFile = 'LOOP.md';
-  try {
-    const cfg = JSON.parse(readFileSync(join(dir, '.claude', 'loop', 'loop.config.json'), 'utf8'));
-    if (cfg.loop_file) loopFile = cfg.loop_file;
-  } catch {}
-  return { loopFile, prefixes: ['.claude/loop/'] };
+  // 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']);
@@ -80,7 +78,7 @@ export function stateFingerprint(dir) {
   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)${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

package/bin/skills/loop/bin/stop-gate.mjs

@@ -13,13 +13,19 @@
 // budgets so it can never block forever, even if loop.config.json is hand-edited.
 import { execSync } from 'node:child_process';
 import { readFileSync, writeFileSync, renameSync, existsSync, appendFileSync, statSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, join, resolve, relative } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { stateFingerprint } from './state-fp.mjs';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
-const PROJECT = resolve(HERE, '..', '..', '..'); // <project>/.claude/loop/bin -> <project>
-const LOOP_DIR = join(PROJECT, '.claude', 'loop');
+// Resolve the loop home from the per-process env the daemon injects
+// (SVAMP_SESSION_ID + Claude Code's CLAUDE_PROJECT_DIR) so a hook defined in the
+// SHARED .claude/settings.json gates each session against ITS OWN .svamp/<sid>/loop/
+// — a sibling session in the same dir resolves a different (or empty) loop and no-ops.
+// Fallback (manual run / standalone): 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, '..');
 const CONFIG = join(LOOP_DIR, 'loop.config.json');
 const STATE = join(LOOP_DIR, 'loop-state.json');
 const VERDICT = join(LOOP_DIR, 'evaluator-verdict.json');
@@ -73,6 +79,11 @@ const state = readJSON(STATE, { active: false, iteration: 0 });
 // Safe no-op if there is no active loop here.
 if (!cfg || state.active === false) allow();
 
+// The repo/working root: where the oracle runs and the work-product is fingerprinted.
+// Stamped by loop-init (loop dir depth no longer encodes it); fall back to env/cwd.
+const PROJECT = (typeof cfg.project_dir === 'string' && cfg.project_dir)
+  || process.env.CLAUDE_PROJECT_DIR || resolve(LOOP_DIR, '..', '..', '..');
+
 // Hard fallback ceiling: a hand-edited/null max_iterations must never let the
 // gate block forever (the hook would trap the session). Default to 200.
 const HARD_MAX = 200;
@@ -164,7 +175,9 @@ writeJSONAtomic(STATE, { ...state, iteration: nextIter, phase: 'continue',
 appendHistory({ ts: now, iteration: nextIter, decision: 'continue', oracle: oraclePass, evaluator: evaluatorPass, detail: oraclePass ? evaluatorDetail : oracleDetail });
 
 const remaining = max != null ? ` (iteration ${nextIter}/${max})` : '';
+const VERDICT_REL = relative(PROJECT, VERDICT) || VERDICT;
+const STATEFP_REL = relative(PROJECT, join(LOOP_DIR, 'bin', 'state-fp.mjs')) || join(LOOP_DIR, 'bin', 'state-fp.mjs');
 const evalHint = evaluatorOn && !evaluatorPass && oraclePass
-  ? `\n\nThe code looks like it may be ready, but you must get an independent verdict: spawn the \`loop-evaluator\` subagent (or a fresh Task agent with a skeptical reviewer prompt) to judge the current diff against LOOP.md, then write its result to \`.claude/loop/evaluator-verdict.json\` as {"verdict":"done"|"continue","reason":"...","guidance":"...","state_fp":"<run .claude/loop/bin/state-fp.mjs>"}. Do not write the verdict yourself.`
+  ? `\n\nThe code looks like it may be ready, but you must get an independent verdict: spawn the \`loop-evaluator\` subagent (or a fresh Task agent with a skeptical reviewer prompt) to judge the current diff against LOOP.md, then write its result to \`${VERDICT_REL}\` as {"verdict":"done"|"continue","reason":"...","guidance":"...","state_fp":"<run: node ${STATEFP_REL}>"}. Do not write the verdict yourself.`
   : '';
 block(`Loop is not complete${remaining}. Keep working on the task in LOOP.md.\n\n${oracleDetail}\n${evaluatorOn ? '\n' + evaluatorDetail : ''}${evalHint}\n\nUpdate LOOP.md progress, fix the blocking issue, then finish your turn again to be re-checked.`);

package/bin/skills/loop/test/test-loop-gate.mjs

@@ -12,6 +12,10 @@ const INIT = resolve(HERE, '..', 'bin', 'loop-init.mjs');
 const STATE_FP = resolve(HERE, '..', 'bin', 'state-fp.mjs');
 const node = process.execPath;
 
+// Loops are SESSION-SCOPED under .svamp/<sid>/loop. Run every project with a session
+// id so the test exercises the real production layout + env-resolved hooks.
+const SID = 'test-session-0000';
+
 let pass = 0, fail = 0;
 function ok(cond, msg) { if (cond) { pass++; console.log(`  ✓ ${msg}`); } else { fail++; console.log(`  ✗ ${msg}`); } }
 
@@ -20,17 +24,23 @@ function sh(dir, cmd) { return execFileSync('bash', ['-lc', cmd], { cwd: dir, en
 
 // Run the COPIED stop-gate inside the project; return {blocked, reason, exit}.
 function runGate(dir, stopHookActive = false, transcriptPath = undefined) {
-  const gate = join(dir, '.claude', 'loop', 'bin', 'stop-gate.mjs');
+  const gate = join(dir, '.svamp', SID, 'loop', 'bin', 'stop-gate.mjs');
   let out = '', code = 0;
   try {
-    out = execFileSync(node, [gate], { input: JSON.stringify({ stop_hook_active: stopHookActive, hook_event_name: 'Stop', cwd: dir, transcript_path: transcriptPath }), encoding: 'utf8' });
+    // The daemon injects SVAMP_SESSION_ID + CLAUDE_PROJECT_DIR; the gate resolves its
+    // session-scoped loop dir from them (so a shared settings.json gates the right loop).
+    out = execFileSync(node, [gate], {
+      input: JSON.stringify({ stop_hook_active: stopHookActive, hook_event_name: 'Stop', cwd: dir, transcript_path: transcriptPath }),
+      encoding: 'utf8',
+      env: { ...process.env, SVAMP_SESSION_ID: SID, CLAUDE_PROJECT_DIR: dir },
+    });
   } catch (e) { out = e.stdout || ''; code = e.status || 1; }
   let parsed = null; try { parsed = JSON.parse(out); } catch {}
   return { blocked: parsed?.decision === 'block', reason: parsed?.reason || '', exit: code, raw: out };
 }
 function fp(dir) { return execFileSync(node, [STATE_FP, dir], { encoding: 'utf8' }).trim(); }
-function readState(dir) { return JSON.parse(readFileSync(join(dir, '.claude', 'loop', 'loop-state.json'), 'utf8')); }
-function writeVerdict(dir, obj) { writeFileSync(join(dir, '.claude', 'loop', 'evaluator-verdict.json'), JSON.stringify(obj)); }
+function readState(dir) { return JSON.parse(readFileSync(join(dir, '.svamp', SID, 'loop', 'loop-state.json'), 'utf8')); }
+function writeVerdict(dir, obj) { writeFileSync(join(dir, '.svamp', SID, 'loop', 'evaluator-verdict.json'), JSON.stringify(obj)); }
 
 function newProject({ evaluator = 'on', max = 20 } = {}) {
   const dir = mkdtempSync(join(tmpdir(), 'loopgate-'));
@@ -38,7 +48,7 @@ function newProject({ evaluator = 'on', max = 20 } = {}) {
   git(dir, ['config', 'user.email', 't@t']); git(dir, ['config', 'user.name', 't']);
   writeFileSync(join(dir, 'answer.txt'), 'TODO\n');
   git(dir, ['add', '-A']); git(dir, ['commit', '-qm', 'init']);
-  execFileSync(node, [INIT, dir, '--task', 'make answer.txt contain DONE',
+  execFileSync(node, [INIT, dir, '--session', SID, '--task', 'make answer.txt contain DONE',
     '--oracle', 'grep -q DONE answer.txt', '--evaluator', evaluator, '--max', String(max)],
     { encoding: 'utf8' });
   return dir;
@@ -115,7 +125,7 @@ try {
   // ---- Test 8: inactive loop -> no-op allow ----
   console.log('Test 8: inactive loop is a no-op');
   { const d = newProject({ evaluator: 'off' }); dirs.push(d);
-    const sp = join(d, '.claude', 'loop', 'loop-state.json');
+    const sp = join(d, '.svamp', SID, 'loop', 'loop-state.json');
     const s = JSON.parse(readFileSync(sp, 'utf8')); s.active = false; writeFileSync(sp, JSON.stringify(s));
     const r = runGate(d);
     ok(!r.blocked, 'gate is a safe no-op when loop inactive');
@@ -127,8 +137,9 @@ try {
   { const d = newProject(); dirs.push(d);
     writeFileSync(join(d, 'answer.txt'), 'DONE\n');
     writeVerdict(d, { verdict: 'done', reason: 'complete', state_fp: fp(d) });
-    // Agent updates its progress memory AFTER getting the verdict:
-    writeFileSync(join(d, 'LOOP.md'), readFileSync(join(d, 'LOOP.md'), 'utf8') + '\n- iter note: done\n');
+    // Agent updates its progress memory (session-scoped LOOP.md) AFTER getting the verdict:
+    const md = join(d, '.svamp', SID, 'loop', 'LOOP.md');
+    writeFileSync(md, readFileSync(md, 'utf8') + '\n- iter note: done\n');
     const r = runGate(d);
     ok(!r.blocked, 'gate still allows stop after LOOP.md was updated post-verdict');
   }
@@ -137,9 +148,9 @@ try {
   console.log('Test 10: runtime budget backstop allows stop');
   { const d = newProject({ evaluator: 'off', max: 9999 }); dirs.push(d); // oracle keeps failing
     // set a tiny runtime budget and an old start time
-    const cfgP = join(d, '.claude', 'loop', 'loop.config.json');
+    const cfgP = join(d, '.svamp', SID, 'loop', 'loop.config.json');
     const cfg = JSON.parse(readFileSync(cfgP, 'utf8')); cfg.budget = { max_runtime_sec: 1 }; writeFileSync(cfgP, JSON.stringify(cfg));
-    const spP = join(d, '.claude', 'loop', 'loop-state.json');
+    const spP = join(d, '.svamp', SID, 'loop', 'loop-state.json');
     const sp = JSON.parse(readFileSync(spP, 'utf8')); sp.started_at = new Date(Date.now() - 5000).toISOString(); writeFileSync(spP, JSON.stringify(sp));
     const r = runGate(d);
     ok(!r.blocked, 'gate allows stop once runtime budget is exceeded');
@@ -149,7 +160,7 @@ try {
   // ---- Test 11: per-iteration history trail is recorded ----
   console.log('Test 11: history.jsonl audit trail');
   { const d = newProject({ evaluator: 'off' }); dirs.push(d);
-    const histPath = join(d, '.claude', 'loop', 'history.jsonl');
+    const histPath = join(d, '.svamp', SID, 'loop', 'history.jsonl');
     runGate(d); // oracle fails -> continue entry
     let lines = readFileSync(histPath, 'utf8').split('\n').filter(Boolean).map((l) => JSON.parse(l));
     ok(lines.length === 1 && lines[0].decision === 'continue', 'continue iteration recorded in history');
@@ -162,7 +173,7 @@ try {
   // ---- Test 12: token budget from transcript gives up ----
   console.log('Test 12: token budget backstop (from transcript)');
   { const d = newProject({ evaluator: 'off', max: 9999 }); dirs.push(d); // oracle keeps failing
-    const cfgP = join(d, '.claude', 'loop', 'loop.config.json');
+    const cfgP = join(d, '.svamp', SID, 'loop', 'loop.config.json');
     const cfg = JSON.parse(readFileSync(cfgP, 'utf8')); cfg.budget = { max_tokens: 1000 }; writeFileSync(cfgP, JSON.stringify(cfg));
     const tp = join(d, 'transcript.jsonl');
     writeFileSync(tp, [
@@ -178,9 +189,9 @@ try {
   // ---- Test 13: null max_iterations must NOT block forever (hard fallback ceiling) ----
   console.log('Test 13: null max_iterations is bounded by hard ceiling');
   { const d = newProject({ evaluator: 'off' }); dirs.push(d); // oracle keeps failing
-    const cfgP = join(d, '.claude', 'loop', 'loop.config.json');
+    const cfgP = join(d, '.svamp', SID, 'loop', 'loop.config.json');
     const cfg = JSON.parse(readFileSync(cfgP, 'utf8')); cfg.max_iterations = null; writeFileSync(cfgP, JSON.stringify(cfg));
-    const spP = join(d, '.claude', 'loop', 'loop-state.json');
+    const spP = join(d, '.svamp', SID, 'loop', 'loop-state.json');
     const sp = JSON.parse(readFileSync(spP, 'utf8')); sp.iteration = 200; writeFileSync(spP, JSON.stringify(sp)); // at the hard ceiling
     const r = runGate(d);
     ok(!r.blocked, 'gate allows stop at the hard fallback ceiling even with null max_iterations');
@@ -199,7 +210,7 @@ try {
   // ---- Test 15: oracle that exits 0 with >1MB output is a PASS, not a failure (#3) ----
   console.log('Test 15: large passing-oracle output is not misread as failure');
   { const d = newProject({ evaluator: 'off' }); dirs.push(d);
-    const cfgP = join(d, '.claude', 'loop', 'loop.config.json');
+    const cfgP = join(d, '.svamp', SID, 'loop', 'loop.config.json');
     const cfg = JSON.parse(readFileSync(cfgP, 'utf8'));
     cfg.oracle = { command: `node -e "console.log('x'.repeat(2000000)); process.exit(0)"` }; // 2MB, exit 0
     writeFileSync(cfgP, JSON.stringify(cfg));
@@ -210,9 +221,9 @@ try {
   // ---- Test 16: huge finite max_iterations is CLAMPED to the hard ceiling (#1) ----
   console.log('Test 16: huge max_iterations is clamped');
   { const d = newProject({ evaluator: 'off' }); dirs.push(d); // oracle keeps failing
-    const cfgP = join(d, '.claude', 'loop', 'loop.config.json');
+    const cfgP = join(d, '.svamp', SID, 'loop', 'loop.config.json');
     const cfg = JSON.parse(readFileSync(cfgP, 'utf8')); cfg.max_iterations = 1e9; writeFileSync(cfgP, JSON.stringify(cfg));
-    const spP = join(d, '.claude', 'loop', 'loop-state.json');
+    const spP = join(d, '.svamp', SID, 'loop', 'loop-state.json');
     const sp = JSON.parse(readFileSync(spP, 'utf8')); sp.iteration = 201; writeFileSync(spP, JSON.stringify(sp));
     const r = runGate(d);
     ok(!r.blocked && /max_iterations \(200\)/.test(readState(d).gave_up_reason || ''), 'max_iterations 1e9 clamped to 200 → gives up');
@@ -221,7 +232,7 @@ try {
   // ---- Test 17: non-numeric iteration is coerced (cap stays alive) (#2) ----
   console.log('Test 17: corrupt non-numeric iteration is coerced');
   { const d = newProject({ evaluator: 'off' }); dirs.push(d);
-    const spP = join(d, '.claude', 'loop', 'loop-state.json');
+    const spP = join(d, '.svamp', SID, 'loop', 'loop-state.json');
     const sp = JSON.parse(readFileSync(spP, 'utf8')); sp.iteration = 'not-a-number'; writeFileSync(spP, JSON.stringify(sp));
     runGate(d); // oracle fails -> blocks, iteration coerced to 0+1
     ok(readState(d).iteration === 1, 'non-numeric iteration coerced to a number (cap not disabled)');
@@ -239,6 +250,32 @@ try {
     ok(fpA !== fpB, 'changing a symlink target changes the non-git fingerprint (no stale-verdict hole)');
   }
 
+  // ---- Test 19: two sessions in ONE dir get isolated loops; a non-loop sibling no-ops ----
+  console.log('Test 19: session-scoped isolation in a shared working dir');
+  { const dir = mkdtempSync(join(tmpdir(), 'loopshare-')); dirs.push(dir);
+    git(dir, ['init', '-q']); git(dir, ['config', 'user.email', 't@t']); git(dir, ['config', 'user.name', 't']);
+    writeFileSync(join(dir, 'answer.txt'), 'TODO\n');
+    git(dir, ['add', '-A']); git(dir, ['commit', '-qm', 'init']);
+    const A = 'sess-aaaa', B = 'sess-bbbb';
+    // A failing oracle so the gate blocks (and increments) rather than completing instantly.
+    const O = 'grep -q DONE answer.txt';
+    execFileSync(node, [INIT, dir, '--session', A, '--task', 'task A', '--oracle', O, '--evaluator', 'off', '--max', '20'], { encoding: 'utf8' });
+    execFileSync(node, [INIT, dir, '--session', B, '--task', 'task B', '--oracle', O, '--evaluator', 'off', '--max', '20'], { encoding: 'utf8' });
+    const runAs = (sid) => {
+      // The SHARED settings.json now points at B's gate copy; run THAT script as each session.
+      const gate = join(dir, '.svamp', B, 'loop', 'bin', 'stop-gate.mjs');
+      let out = ''; try { out = execFileSync(node, [gate], { input: '{}', encoding: 'utf8', env: { ...process.env, SVAMP_SESSION_ID: sid, CLAUDE_PROJECT_DIR: dir } }); } catch (e) { out = e.stdout || ''; }
+      let p = null; try { p = JSON.parse(out); } catch {}
+      return { blocked: p?.decision === 'block', raw: out };
+    };
+    const stateOf = (sid) => JSON.parse(readFileSync(join(dir, '.svamp', sid, 'loop', 'loop-state.json'), 'utf8'));
+    runAs(A); // oracle-less + evaluator-off: not done -> blocks, increments A only
+    ok(stateOf(A).iteration === 1, 'session A loop advanced to iter 1');
+    ok((stateOf(B).iteration ?? 0) === 0, 'session B loop untouched (no cross-talk)');
+    const sib = runAs('sess-cccc-noloop'); // a sibling with no loop
+    ok(!sib.blocked && sib.raw === '', 'non-loop sibling session no-ops (allows stop)');
+  }
+
   console.log(`\n${fail === 0 ? '✅' : '❌'} ${pass} passed, ${fail} failed`);
   process.exit(fail === 0 ? 0 : 1);
 } finally {

package/dist/{agentCommands-V14aFkLp.mjs → agentCommands-Cpq_Yk3h.mjs}

@@ -148,7 +148,7 @@ async function sessionBroadcast(action, args) {
   console.log(`Broadcast sent: ${action}`);
 }
 async function connectToMachineService() {
-  const { connectAndGetMachine } = await import('./commands-Cectk2JF.mjs');
+  const { connectAndGetMachine } = await import('./commands-DOsK9QRw.mjs');
   return connectAndGetMachine();
 }
 async function inboxSend(targetSessionId, opts) {
@@ -165,7 +165,7 @@ async function inboxSend(targetSessionId, opts) {
   }
   const { server, machine } = await connectToMachineService();
   try {
-    const { resolveSessionId } = await import('./commands-Cectk2JF.mjs');
+    const { resolveSessionId } = await import('./commands-DOsK9QRw.mjs');
     const sessions = await machine.listSessions();
     const match = resolveSessionId(sessions, targetSessionId);
     const fullTargetId = match.sessionId;

package/dist/{auth-CuCvqsTH.mjs → auth-DBKbI5IE.mjs}

@@ -1,4 +1,4 @@
-import { E as resolveModel } from './run-9j9_wlx5.mjs';
+import { E as resolveModel } from './run-LyzVTe3J.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';