svamp-cli 0.2.162 → 0.2.164

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

@@ -58,7 +58,7 @@ 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', 'checklist.mjs', 'inject-loop.mjs', 'loop-status.mjs', 'precompact.mjs']) {
+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 {}

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

@@ -16,7 +16,6 @@ import { readFileSync, writeFileSync, renameSync, existsSync, appendFileSync, st
 import { dirname, join, resolve, relative } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { stateFingerprint } from './state-fp.mjs';
-import { readEffectiveChecklist, evaluateChecklist, allPassing, summarize, writeChecklistStatuses } from './checklist.mjs';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 // Resolve the loop home from the per-process env the daemon injects
@@ -132,26 +131,10 @@ if (evaluatorOn) {
   }
 }
 
-// --- (3) Checklist (the loop-engineering criteria atom) -----------------
-// The effective checklist = project invariants ∪ session goals. Each item with an
-// oracle is re-evaluated here (regression check); refreshed statuses are persisted
-// so the UI + agent see live state. No-op when no criteria.json exists anywhere
-// (allPassing([]) === true) — fully backward-compatible with criteria-only loops.
-let checklistPass = true;
-let checklistDetail = 'no checklist';
-try {
-  const items = evaluateChecklist(readEffectiveChecklist(LOOP_DIR, PROJECT), PROJECT);
-  if (items.length > 0) {
-    writeChecklistStatuses(LOOP_DIR, PROJECT, items);
-    checklistPass = allPassing(items);
-    const notDone = items.filter((i) => i.status !== 'done');
-    checklistDetail = checklistPass
-      ? `checklist: ${summarize(items)} — all done`
-      : `checklist: ${summarize(items)}\n--- not yet done ---\n${notDone.map((i) => `[${i.scope}] ${i.text}${i._oracle ? ` (oracle: ${i._oracle})` : ''}`).join('\n')}`;
-  }
-} catch { /* checklist is best-effort; never let it trap the gate */ }
-
-const done = oraclePass && evaluatorPass && checklistPass;
+// The loop gate is now two conditions: a real pass/fail oracle AND an independent
+// evaluator verdict. (The old best-effort "criteria atom" — a separate criteria.json
+// checklist — was removed: the backlog/oracle is the single source of success criteria.)
+const done = oraclePass && evaluatorPass;
 
 // --- Decide -------------------------------------------------------------
 const now = new Date().toISOString();
@@ -190,7 +173,7 @@ if (giveUp) {
 }
 
 writeJSONAtomic(STATE, { ...state, iteration: nextIter, phase: 'continue',
-  last_iteration_at: now, last_oracle: oracleDetail, last_eval: evaluatorDetail, last_checklist: checklistDetail, ...tokenField });
+  last_iteration_at: now, last_oracle: oracleDetail, last_eval: evaluatorDetail, ...tokenField });
 
 appendHistory({ ts: now, iteration: nextIter, decision: 'continue', oracle: oraclePass, evaluator: evaluatorPass, detail: oraclePass ? evaluatorDetail : oracleDetail });
 
@@ -200,5 +183,4 @@ const STATEFP_REL = relative(PROJECT, 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 \`${VERDICT_REL}\` as {"verdict":"done"|"continue","reason":"...","guidance":"...","state_fp":"<run: node ${STATEFP_REL}>"}. Do not write the verdict yourself.`
   : '';
-const checklistHint = !checklistPass ? `\n\n${checklistDetail}\nWork the items above until each one's oracle passes; finished items must stay green (regressions re-open).` : '';
-block(`Loop is not complete${remaining}. Keep working on the task in LOOP.md.\n\n${oracleDetail}\n${evaluatorOn ? '\n' + evaluatorDetail : ''}${checklistHint}${evalHint}\n\nUpdate LOOP.md progress, fix the blocking issue, then finish your turn again to be re-checked.`);
+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/dist/cli.mjs

@@ -375,7 +375,7 @@ async function main() {
     }), machineId);
     process.exit(0);
   } else if (subcommand === "issue" || subcommand === "issues") {
-    const { issueCommand } = await import('./commands-Bb0Oe9o7.mjs');
+    const { issueCommand } = await import('./commands-C8uqsoRM.mjs');
     await issueCommand(args.slice(1));
     process.exit(0);
   } else if (subcommand === "workflow" || subcommand === "workflows") {
@@ -398,7 +398,7 @@ async function main() {
   } else if (!subcommand || subcommand === "start") {
     await handleInteractiveCommand();
   } else if (subcommand === "--version" || subcommand === "-v") {
-    const pkg = await import('./package-CPitmvF2.mjs').catch(() => ({ default: { version: "unknown" } }));
+    const pkg = await import('./package-Dwhojj-r.mjs').catch(() => ({ default: { version: "unknown" } }));
     console.log(`svamp version: ${pkg.default.version}`);
   } else {
     console.error(`Unknown command: ${subcommand}`);

package/dist/{commands-Bb0Oe9o7.mjs → commands-C8uqsoRM.mjs}

@@ -240,7 +240,7 @@ ${issue.body}`);
       break;
     }
     case "pending": {
-      const pending = listIssues(root).filter((i) => i.status === "ready" || i.status === "in_progress");
+      const pending = listIssues(root).filter((i) => i.status === "ready" || i.status === "in_progress" || i.status === "backlog" && !i.triaged);
       if (json) console.log(JSON.stringify(pending));
       else out(pending.length ? `${pending.length} pending: ${pending.map((i) => "#" + i.id).join(" ")}` : "No pending issues.");
       process.exit(pending.length ? 1 : 0);
@@ -275,7 +275,7 @@ ${issue.body}`);
         "  work <id> [--branch <name>]   # mark in-progress (optionally on a branch; merge to main before close)",
         "  edit <id> [--title \u2026] [--label x] [--verify-cmd \u2026] [--no-verify] [--status \u2026] [--body \u2026]",
         '  comment <id> "<text>"   # append a follow-up to the issue',
-        "  pending                 # exit 0 if no ready/in-progress issues (loop oracle)",
+        "  pending                 # exit 0 if no actionable issues: ready, in_progress, or untriaged backlog (loop oracle)",
         '  search "<query>" [--json]'
       ].join("\n"));
       break;

package/dist/{package-CPitmvF2.mjs → package-Dwhojj-r.mjs}

@@ -1,5 +1,5 @@
 var name = "svamp-cli";
-var version = "0.2.162";
+var version = "0.2.163";
 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.162",
+  "version": "0.2.164",
   "description": "Svamp CLI — AI workspace daemon on Hypha Cloud",
   "author": "Amun AI AB",
   "license": "SEE LICENSE IN LICENSE",

package/bin/skills/loop/bin/checklist.mjs

@@ -1,129 +0,0 @@
-// checklist.mjs — the loop-engineering checklist atom, gate side.
-// See docs/checklist-atom-spec.md + docs/svamp-loop-engineering-vision.md. A checklist
-// is a list of evaluable goal items persisted as JSON, in two layered scopes:
-//   session: <loopDir>/criteria.json             (this session's goal)
-//   project: <projectDir>/.svamp/criteria.json   (durable invariants, all sessions)
-// Effective checklist a session enforces = project ∪ session. Each item is oracle-checked
-// (an eval cmd) or agent/human-evaluated. Done ≠ gone: a 'done' item STAYS and is
-// re-verified every loop, so it can regress to 'blocked'. The gate lets the turn end only
-// when ALL effective items are 'done'.
-//
-// This is the GATE runtime (a .mjs skill — it cannot import the TS atom in
-// checklist/core.ts), so it mirrors the canonical vocab by value: ItemStatus +
-// canonicalChecklistStatus are kept in sync with sync/checklistModel.ts + parseMarkdown.ts.
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { execSync } from 'node:child_process';
-
-// CANONICAL: the session checklist lives INSIDE the loop dir at
-// <project>/.svamp/<sid>/loop/criteria.json — beside the other loop-gate state
-// (loop-state.json, supervisor-verdict.json — the latter is the daemon's legacy
-// verdict file name). Matches the daemon writer
-// (checklist/core.ts checklistPath) + the frontend (sync/ops.ts sessionChecklistRel).
-export function sessionChecklistPath(loopDir) { return join(loopDir, 'criteria.json'); }
-export function projectChecklistPath(projectDir) { return join(projectDir, '.svamp', 'criteria.json'); }
-
-/**
- * Map any accepted token — canonical OR the legacy loop aliases (pending/passing/failing) —
- * to the canonical ItemStatus set. Mirrors checklistModel.canonicalChecklistStatus.
- */
-export function canonicalChecklistStatus(raw) {
-  switch (String(raw ?? '').toLowerCase()) {
-    case 'passing': case 'done': return 'done';
-    case 'failing': case 'blocked': return 'blocked';
-    case 'pending': case 'todo': case '': return 'todo';
-    case 'active': case 'in_progress': case 'in-progress': return 'active';
-    case 'verifying': return 'verifying';
-    case 'awaiting_review': case 'awaiting-review': case 'review': return 'awaiting_review';
-    case 'rework': return 'rework';
-    default: return 'todo';
-  }
-}
-
-/** The oracle command for an item: the atom's eval.cmd (type:'oracle'), else legacy item.oracle. */
-function itemOracle(it) {
-  if (it?.eval?.type === 'oracle' && typeof it.eval.cmd === 'string' && it.eval.cmd.trim()) return it.eval.cmd.trim();
-  return typeof it?.oracle === 'string' && it.oracle.trim() ? it.oracle.trim() : null;
-}
-
-function readOne(path, scope) {
-  try {
-    if (!existsSync(path)) return [];
-    const j = JSON.parse(readFileSync(path, 'utf-8'));
-    const items = Array.isArray(j) ? j : (Array.isArray(j?.items) ? j.items : []);
-    return items.map((it, i) => ({
-      // Preserve the full atom item (eval, child, disposition, order, …) so the gate
-      // never strips fields the UI/core own; it only refreshes `status`.
-      ...it,
-      id: typeof it?.id === 'string' && it.id ? it.id : `${scope}-${i}`,
-      text: String(it?.text ?? '').trim(),
-      status: canonicalChecklistStatus(it?.status),
-      // transient helpers (underscored) — used for evaluation, stripped before persist:
-      scope,
-      _oracle: itemOracle(it),
-      _delegated: it?.disposition === 'delegated',
-    })).filter((it) => it.text);
-  } catch { return []; }
-}
-
-/** Effective checklist = project invariants ∪ session goals (project first, then session). */
-export function readEffectiveChecklist(loopDir, projectDir) {
-  return [
-    ...readOne(projectChecklistPath(projectDir), 'project'),
-    ...readOne(sessionChecklistPath(loopDir), 'session'),
-  ];
-}
-
-/**
- * Run each INLINE item's oracle (if any) and return items with refreshed status:
- * oracle pass → 'done', oracle fail → 'blocked'. This is the per-loop regression check
- * (a previously 'done' item whose oracle now fails flips to 'blocked'). Delegated items
- * (gated by their child) and non-oracle items (agent/human-evaluated) keep their status.
- */
-export function evaluateChecklist(items, projectDir, timeoutSec = 600) {
-  return items.map((it) => {
-    if (it._delegated || !it._oracle) return it;
-    try {
-      execSync(it._oracle, { cwd: projectDir, stdio: 'pipe', maxBuffer: 16 * 1024 * 1024, timeout: timeoutSec * 1000 });
-      return { ...it, status: 'done' };
-    } catch {
-      return { ...it, status: 'blocked' };
-    }
-  });
-}
-
-/** True when every effective item is 'done' (an empty list is trivially satisfied). */
-export function allPassing(items) {
-  return items.length === 0 ? true : items.every((it) => it.status === 'done');
-}
-
-/** A one-line summary for the gate's history/state. */
-export function summarize(items) {
-  const done = items.filter((i) => i.status === 'done').length;
-  const blocked = items.filter((i) => i.status === 'blocked' || i.status === 'rework').length;
-  return `${done}/${items.length} done${blocked ? `, ${blocked} blocked` : ''}`;
-}
-
-/**
- * Persist refreshed statuses back to each scope's file so the UI + agent see live state.
- * Preserves the full atom item shape — only the transient helper fields (_scope/_oracle/
- * _delegated) are stripped; everything else (eval, child, disposition, order, …) round-trips.
- */
-export function writeChecklistStatuses(loopDir, projectDir, items) {
-  const strip = (it) => {
-    const { scope: _s, _oracle, _delegated, ...rest } = it;
-    return rest;
-  };
-  const targets = [
-    ['session', sessionChecklistPath(loopDir)],
-    ['project', projectChecklistPath(projectDir)],
-  ];
-  for (const [scope, path] of targets) {
-    const scoped = items.filter((it) => it.scope === scope).map(strip);
-    if (scoped.length === 0 && !existsSync(path)) continue; // don't create empty files
-    try {
-      mkdirSync(dirname(path), { recursive: true });
-      writeFileSync(path, JSON.stringify({ items: scoped }, null, 2));
-    } catch { /* best-effort persistence */ }
-  }
-}

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

@@ -1,86 +0,0 @@
-// test-checklist.mjs — the loop-engineering checklist atom (read/merge/evaluate/persist).
-import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import {
-  readEffectiveChecklist, evaluateChecklist, allPassing, summarize,
-  writeChecklistStatuses, sessionChecklistPath, projectChecklistPath,
-} from '../bin/checklist.mjs';
-
-let passed = 0, failed = 0;
-function ok(cond, msg) { if (cond) { passed++; console.log(`  ✓ ${msg}`); } else { failed++; console.log(`  ✗ ${msg}`); } }
-function eq(a, b, msg) { ok(JSON.stringify(a) === JSON.stringify(b), `${msg} (got ${JSON.stringify(a)})`); }
-
-const root = mkdtempSync(join(tmpdir(), 'cl-test-'));
-const projectDir = root;
-const loopDir = join(root, '.svamp', 'sess1', 'loop');
-mkdirSync(loopDir, { recursive: true });
-mkdirSync(join(root, '.svamp'), { recursive: true });
-
-console.log('scope merge + normalization');
-writeFileSync(projectChecklistPath(projectDir), JSON.stringify({ items: [
-  { text: 'tests pass', oracle: 'true', status: 'done' },
-] }));
-writeFileSync(sessionChecklistPath(loopDir), JSON.stringify({ items: [
-  { text: 'add feature', status: 'done' },              // 'done' alias → passing
-  { text: '   ', status: 'pending' },                    // blank → dropped
-  { text: 'no TODOs', oracle: 'false' },                 // defaults to pending
-] }));
-let eff = readEffectiveChecklist(loopDir, projectDir);
-eq(eff.length, 3, 'effective = project ∪ session, blanks dropped');
-eq(eff[0].scope, 'project', 'project items come first');
-eq(eff[0].text, 'tests pass', 'project item text');
-eq(eff[1].status, 'done', "'done' normalized to done");
-ok(eff.map(i => i.scope).join(',') === 'project,session,session', 'scope tags correct');
-
-console.log('evaluate — oracle pass/fail drives status (regression check)');
-const evaluated = evaluateChecklist(eff, projectDir);
-eq(evaluated.find(i => i.text === 'tests pass').status, 'done', 'oracle `true` → passing');
-eq(evaluated.find(i => i.text === 'no TODOs').status, 'blocked', 'oracle `false` → failing');
-eq(evaluated.find(i => i.text === 'add feature').status, 'done', 'no-oracle item keeps stored status');
-
-console.log('allPassing gate');
-ok(!allPassing(evaluated), 'not all done while one oracle fails');
-ok(allPassing([]), 'empty list is trivially satisfied');
-ok(allPassing(evaluated.map(i => ({ ...i, status: 'done' }))), 'all done → true');
-
-console.log('summarize');
-ok(summarize(evaluated).startsWith('2/3 done'), `summary reads "${summarize(evaluated)}"`);
-
-console.log('persist statuses back to the right scope files');
-writeChecklistStatuses(loopDir, projectDir, evaluated);
-const proj = JSON.parse(readFileSync(projectChecklistPath(projectDir), 'utf-8'));
-const sess = JSON.parse(readFileSync(sessionChecklistPath(loopDir), 'utf-8'));
-eq(proj.items.length, 1, 'project file holds only project items');
-eq(sess.items.length, 2, 'session file holds only session items');
-ok(proj.items[0].scope === undefined, 'scope stripped from persisted file');
-ok(sess.items.find(i => i.text === 'no TODOs').status === 'blocked', 'blocked status persisted (UI will show it)');
-
-// regression: a re-read after persist is stable
-const reEff = readEffectiveChecklist(loopDir, projectDir);
-eq(reEff.length, 3, 're-read after persist is stable');
-
-console.log('canonical atom shape — eval.cmd oracle, disposition, ItemStatus, field round-trip');
-const root2 = mkdtempSync(join(tmpdir(), 'cl-atom-'));
-const loopDir2 = join(root2, '.svamp', 'sessA', 'loop');
-mkdirSync(loopDir2, { recursive: true });
-writeFileSync(sessionChecklistPath(loopDir2), JSON.stringify({ items: [
-  { id: 'a', text: 'build green', disposition: 'inline', eval: { type: 'oracle', cmd: 'true' }, status: 'todo', order: 0 },
-  { id: 'b', text: 'lint clean', disposition: 'inline', eval: { type: 'oracle', cmd: 'false' }, status: 'todo' },
-  { id: 'c', text: 'ship the API', disposition: 'delegated', status: 'active', child: { sessionId: 'x', branch: 'feat/api' } },
-] }));
-const atom = evaluateChecklist(readEffectiveChecklist(loopDir2, root2), root2);
-eq(atom.find(i => i.id === 'a').status, 'done', 'eval.cmd `true` → done');
-eq(atom.find(i => i.id === 'b').status, 'blocked', 'eval.cmd `false` → blocked');
-eq(atom.find(i => i.id === 'c').status, 'active', 'delegated item NOT oracle-evaluated (child-gated), keeps status');
-ok(!allPassing(atom), 'not all done while an inline oracle fails');
-writeChecklistStatuses(loopDir2, root2, atom);
-const persisted = JSON.parse(readFileSync(sessionChecklistPath(loopDir2), 'utf-8')).items;
-const cItem = persisted.find(i => i.id === 'c');
-ok(cItem.disposition === 'delegated' && cItem.child?.branch === 'feat/api', 'atom fields (disposition/child) round-trip — gate never strips them');
-ok(persisted.find(i => i.id === 'a').eval?.cmd === 'true' && !('_oracle' in persisted.find(i => i.id === 'a')), 'eval preserved, transient _oracle stripped');
-rmSync(root2, { recursive: true, force: true });
-
-rmSync(root, { recursive: true, force: true });
-console.log(`\nchecklist: ${passed} passed, ${failed} failed`);
-process.exit(failed ? 1 : 0);