svamp-cli 0.2.186 → 0.2.188

package/bin/skills/loop/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: loop
-version: 0.4.0
+version: 0.4.1
 description: Run a task as a reliable, self-verifying loop — iterate until objective exit conditions are met, with an independent evaluator instead of self-judging. Use when a task needs repeated iterations until "done" (fix until tests pass, refactor until clean, build until a spec is met, autonomous long-running work).
 ---
 
@@ -54,6 +54,7 @@ The loop ends only when **all** configured conditions hold:
 4. **Run the oracle yourself** to check you're actually passing before claiming done.
 5. **When you believe it's complete, get an independent verdict — do not grade yourself:**
    - Spawn a fresh subagent with the `Task` tool (use the `loop-evaluator` agent if present, otherwise an inline *skeptical reviewer* prompt). Give it **only** the goal (from `LOOP.md`), the current diff, and the oracle output — never your chain of thought.
+   - For an **issue-backlog** loop the evaluator must go further than the oracle: confirm EACH issue closed this round is genuinely resolved by the real change, AND judge **holistically from the user's perspective** — re-read the *original request* behind each closed issue and the *overall project goal*, and confirm we delivered what the user actually wanted end-to-end (built / published / deployed wherever the request implied it, not merely committed). A green oracle only means "no open issues"; reject `done` if the project goal isn't truly met for the user.
    - It returns `{"verdict":"done"|"continue","reason":...,"guidance":...}`. It should default to `continue` on any doubt.
    - Record it to `.claude/loop/evaluator-verdict.json`, adding the current state fingerprint:
      `{"verdict":"done","reason":"...","guidance":"...","state_fp":"<output of: node .claude/loop/bin/state-fp.mjs>"}`

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

@@ -2,7 +2,7 @@
 // inject-loop.mjs — Claude Code `SessionStart` / `UserPromptSubmit` hook.
 // 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 { readFileSync, writeFileSync, renameSync, existsSync } from 'node:fs';
 import { dirname, join, resolve, relative } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -19,6 +19,41 @@ 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
 
+// Self-heal the Stop gate (#0072). This hook runs on every SessionStart/UserPromptSubmit while a
+// loop is active, so it's the reliable place to GUARANTEE the gate is installed: in a shared working
+// tree another tool/agent can rewrite .claude/settings.json and silently drop the Stop hook, which
+// would let the loop end without the completion gate ever firing. If the loop's own stop-gate.mjs is
+// missing from settings.hooks.Stop, re-install all four loop hooks (idempotent; merges, never clobbers
+// unrelated settings). BIN points at THIS session's copied bin/, so each session heals its own gate.
+function ensureLoopHooks() {
+  try {
+    const settingsPath = join(PROJECT_ENV || resolve(LOOP_DIR, '..', '..', '..'), '.claude', 'settings.json');
+    const binDir = join(LOOP_DIR, 'bin');
+    const node = process.execPath;
+    const cmd = (script) => `"${node}" "${join(binDir, script)}"`;
+    const stopGate = join(binDir, 'stop-gate.mjs');
+    if (!existsSync(stopGate)) return; // can't heal what isn't copied; loop-init owns first install
+    let settings = {};
+    if (existsSync(settingsPath)) { try { settings = JSON.parse(readFileSync(settingsPath, 'utf8')); } catch { settings = {}; } }
+    const hooks = settings.hooks || {};
+    // Is THIS loop's stop-gate present anywhere under hooks.Stop?
+    const stopOk = Array.isArray(hooks.Stop) && hooks.Stop.some((g) =>
+      Array.isArray(g?.hooks) && g.hooks.some((h) => typeof h?.command === 'string' && h.command.includes(stopGate)));
+    if (stopOk) return; // gate intact — nothing to do
+    // Re-install the loop hook set (same shape loop-init writes).
+    hooks.SessionStart = [{ hooks: [{ type: 'command', command: cmd('inject-loop.mjs') }] }];
+    hooks.UserPromptSubmit = [{ hooks: [{ type: 'command', command: cmd('inject-loop.mjs') }] }];
+    hooks.Stop = [{ hooks: [{ type: 'command', command: cmd('stop-gate.mjs') }] }];
+    hooks.PreCompact = [{ hooks: [{ type: 'command', command: cmd('precompact.mjs') }] }];
+    settings.hooks = hooks;
+    const tmp = settingsPath + '.tmp';
+    writeFileSync(tmp, JSON.stringify(settings, null, 2));
+    renameSync(tmp, settingsPath);
+    process.stderr.write('[loop] re-installed missing Stop gate into .claude/settings.json (#0072 self-heal)\n');
+  } catch { /* best-effort; never block injection on a heal failure */ }
+}
+ensureLoopHooks();
+
 const PROJECT = (typeof cfg.project_dir === 'string' && cfg.project_dir)
   || process.env.CLAUDE_PROJECT_DIR || resolve(LOOP_DIR, '..', '..', '..');
 

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

@@ -145,6 +145,8 @@ 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>"}

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

@@ -181,6 +181,6 @@ 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. If this loop works an issue backlog, the evaluator MUST also confirm that EACH issue closed during this loop is genuinely resolved by the actual change — a green oracle only means 'no open issues', not that each closed issue works; reject 'done' if any was closed without real resolution. 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.`
+  ? `\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. If this loop works an issue backlog, the evaluator MUST also confirm that EACH issue closed during this loop is genuinely resolved by the actual change — a green oracle only means 'no open issues', not that each closed issue works; reject 'done' if any was closed without real resolution. BEYOND the individual issues, the evaluator MUST also judge HOLISTICALLY, 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 actually delivered what the user wanted end-to-end — including that the change was built / published / deployed wherever the issue implied it, not merely committed. Reject 'done' if the project goal is not genuinely met from the user's point of view, even when no issues remain open. 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

@@ -302,6 +302,40 @@ try {
     ok(readState(d).phase !== 'done', 'loop B did not close as done at iteration 0');
   }
 
+  // ---- Test 21: inject-loop self-heals a clobbered Stop gate (#0072) -------
+  console.log('Test 21: inject-loop re-installs a dropped Stop gate (shared-tree self-heal)');
+  { const INJECT = resolve(HERE, '..', 'bin', 'inject-loop.mjs');
+    const d = newProject(); dirs.push(d);
+    const settingsPath = join(d, '.claude', 'settings.json');
+    const stopGate = join(d, '.svamp', SID, 'loop', 'bin', 'stop-gate.mjs');
+    const runInject = () => execFileSync(node, [INJECT], {
+      input: JSON.stringify({ hook_event_name: 'SessionStart', cwd: d }),
+      encoding: 'utf8', env: { ...process.env, SVAMP_SESSION_ID: SID, CLAUDE_PROJECT_DIR: d },
+    });
+    const hasStop = () => { const s = JSON.parse(readFileSync(settingsPath, 'utf8'));
+      return Array.isArray(s.hooks?.Stop) && s.hooks.Stop.some((g) => Array.isArray(g?.hooks)
+        && g.hooks.some((h) => typeof h?.command === 'string' && h.command.includes(stopGate))); };
+    ok(hasStop(), 'precondition: loop-init installed the Stop gate');
+    // Simulate a shared-tree clobber: another tool rewrites settings.json, dropping the Stop hook.
+    const clob = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    delete clob.hooks.Stop; clob.permissions = { allow: ['Bash(ls:*)'] };
+    writeFileSync(settingsPath, JSON.stringify(clob, null, 2));
+    ok(!hasStop(), 'precondition: Stop gate removed by the clobber');
+    runInject();
+    ok(hasStop(), 'inject-loop re-installed the missing Stop gate');
+    ok(JSON.parse(readFileSync(settingsPath, 'utf8')).permissions?.allow?.includes('Bash(ls:*)'),
+      'self-heal preserved unrelated settings (merge, not clobber)');
+    runInject();
+    ok(JSON.parse(readFileSync(settingsPath, 'utf8')).hooks.Stop.length === 1,
+      'self-heal is idempotent when the gate is intact');
+    // Inactive loop (cancelled) must NOT be resurrected by inject-loop.
+    const stateP = join(d, '.svamp', SID, 'loop', 'loop-state.json');
+    const st = JSON.parse(readFileSync(stateP, 'utf8')); st.active = false; writeFileSync(stateP, JSON.stringify(st));
+    const clob2 = JSON.parse(readFileSync(settingsPath, 'utf8')); delete clob2.hooks.Stop; writeFileSync(settingsPath, JSON.stringify(clob2, null, 2));
+    runInject();
+    ok(!hasStop(), 'inactive loop: inject-loop does not re-install (respects cancel)');
+  }
+
   console.log(`\n${fail === 0 ? '✅' : '❌'} ${pass} passed, ${fail} failed`);
   process.exit(fail === 0 ? 0 : 1);
 } finally {

package/dist/cli.mjs

@@ -394,7 +394,7 @@ async function main() {
   } else if (!subcommand || subcommand === "start") {
     await handleInteractiveCommand();
   } else if (subcommand === "--version" || subcommand === "-v") {
-    const pkg = await import('./package-Bfi9GnpS.mjs').catch(() => ({ default: { version: "unknown" } }));
+    const pkg = await import('./package-B6C96K9S.mjs').catch(() => ({ default: { version: "unknown" } }));
     console.log(`svamp version: ${pkg.default.version}`);
   } else {
     console.error(`Unknown command: ${subcommand}`);

package/dist/{package-Bfi9GnpS.mjs → package-B6C96K9S.mjs}

@@ -1,5 +1,5 @@
 var name = "svamp-cli";
-var version = "0.2.186";
+var version = "0.2.187";
 var description = "Svamp CLI — AI workspace daemon on Hypha Cloud";
 var author = "Amun AI AB";
 var license = "SEE LICENSE IN LICENSE";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svamp-cli",
-  "version": "0.2.186",
+  "version": "0.2.188",
   "description": "Svamp CLI — AI workspace daemon on Hypha Cloud",
   "author": "Amun AI AB",
   "license": "SEE LICENSE IN LICENSE",