svamp-cli 0.2.204 → 0.2.206

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

@@ -155,17 +155,70 @@ if (done) {
   const inboxBlocks = Number(state.inbox_blocks) || 0;
   if (cfg.inbox_guard !== false && inboxBlocks < INBOX_BLOCK_CAP) {
     let pending = 0;
+    let pendingIds = [];
     try {
       const arr = readJSON(join(LOOP_DIR, '..', 'inbox.json'), []);
       const msgs = Array.isArray(arr) ? arr : (Array.isArray(arr?.messages) ? arr.messages : []);
-      pending = msgs.filter((m) => m && !m.handled && !m.read).length;
+      const pendingMsgs = msgs.filter((m) => m && !m.handled && !m.read);
+      pending = pendingMsgs.length;
+      pendingIds = pendingMsgs.map((m) => m.messageId).filter(Boolean);
     } catch { pending = 0; } // fail-open: no/corrupt inbox file → never block
     if (pending > 0) {
+      // #0146: this guard already surfaced these messages — record them in the shared hint ledger so
+      // the non-urgent settle hint below won't re-surface the same ids on the next iteration.
+      try {
+        const HINTED = join(LOOP_DIR, 'hinted-inbox.json');
+        const hintedRaw = readJSON(HINTED, []);
+        const merged = new Set([...(Array.isArray(hintedRaw) ? hintedRaw : []), ...pendingIds]);
+        writeJSONAtomic(HINTED, [...merged]);
+      } catch {}
       writeJSONAtomic(STATE, { ...state, inbox_blocks: inboxBlocks + 1, last_oracle: oracleDetail });
       appendHistory({ ts: now, iteration: iterNum, decision: 'inbox-block', pending, detail: oracleDetail });
       block(`The loop's exit conditions are met (oracle empty + evaluator done), but you have ${pending} UNHANDLED inbox message(s). Handle them first — read/reply/triage/merge each (\`svamp session inbox list\`), then finish your turn. (This guard fires at most once per loop, then allows stop, so a flood can't trap the loop.)`);
     }
   }
+  // #0146: NON-URGENT inbox hint at the settle point. We only reach here when the gate would
+  // OTHERWISE ALLOW the end (oracle pass + evaluator done) AND the urgent/unhandled guard above did
+  // not block. Surface UNREAD, NON-URGENT, NOT-awaiting-reply inbox messages the agent hasn't been
+  // hinted about yet so they don't pile up unseen while the loop grinds. Reads the same durable
+  // inbox.json (sibling of the loop dir) — no subprocess/daemon round-trip. Hint-once-per-message:
+  // we record the hinted ids in <LOOP_DIR>/hinted-inbox.json and BLOCK ONCE so the agent sees the
+  // hint this turn; the next settle won't re-hint the same ids → it allows the end (non-blocking
+  // thereafter). Fully defensive: any error → fall through to the normal allow (never trap the loop).
+  // Disable with `inbox_hint: false` in loop.config.json.
+  if (cfg.inbox_hint !== false) {
+    try {
+      const HINTED = join(LOOP_DIR, 'hinted-inbox.json');
+      const arr = readJSON(join(LOOP_DIR, '..', 'inbox.json'), []);
+      const msgs = Array.isArray(arr) ? arr : (Array.isArray(arr?.messages) ? arr.messages : []);
+      const hintedRaw = readJSON(HINTED, []);
+      const hintedIds = new Set(Array.isArray(hintedRaw) ? hintedRaw : []);
+      // unread + not-handled-by-agent + NOT urgent + NOT awaiting-reply (those already interrupt the
+      // loop) + not yet hinted. `handled` means the agent already consumed the message into a turn, so
+      // it's not "unseen" — only genuinely-unseen non-urgent mail deserves a settle-point nudge.
+      const fresh = msgs.filter((m) => m
+        && m.read !== true
+        && m.handled !== true
+        && m.urgency !== 'urgent'
+        && !(m.channelId && m.correlationId) // awaiting-reply markers
+        && m.messageId && !hintedIds.has(m.messageId));
+      if (fresh.length > 0) {
+        const preview = fresh.slice(0, 3).map((m) => {
+          const who = m.from || m.fromSession || 'unknown';
+          const subj = m.subject ? ` re "${m.subject}"` : '';
+          return `from ${who}${subj}`;
+        }).join('; ');
+        const more = fresh.length > 3 ? ` (+${fresh.length - 3} more)` : '';
+        // Record BEFORE blocking so the next settle won't re-hint these ids (hint-once guarantee).
+        for (const m of fresh) hintedIds.add(m.messageId);
+        try { writeJSONAtomic(HINTED, [...hintedIds]); } catch {}
+        process.stderr.write(`[loop] 📥 ${fresh.length} unread inbox message(s) while you worked: ${preview}${more}\n`);
+        writeJSONAtomic(STATE, { ...state, last_oracle: oracleDetail });
+        appendHistory({ ts: now, iteration: iterNum, decision: 'inbox-hint', count: fresh.length, detail: preview });
+        block(`📥 ${fresh.length} unread inbox message(s) arrived while you worked: ${preview}${more}. Consider reading them (\`svamp session inbox list\`) before settling. (This hint fires once per message — finish your turn again to be re-checked; it won't block on these again.)`);
+      }
+    } catch { /* fail-open: any inbox-hint error → never block, fall through to allow */ }
+  }
   // #0128: NON-BLOCKING open-crew hint. The loop is about to STOP — surface any active crew children
   // the lead hasn't merged/closed so an orphaned/forgotten crew is visible at the natural checkpoint.
   // Purely informational: it NEVER blocks or affects the decision (the loop still stops). Computed
@@ -203,14 +256,42 @@ const giveUp = overIters || overTime || overTokens;
 const tokenField = maxTokens ? { tokens_used: tokensUsed } : {};
 
 if (giveUp) {
-  // Bounded out: let it stop so we never block forever. (Single state write.)
   const why = overTokens ? `token budget (${tokensUsed}/${maxTokens} tokens)`
     : overTime ? `runtime budget (${cfg.budget.max_runtime_sec}s)`
     : `max_iterations (${max})`;
+  const limitName = overTokens ? 'token budget' : overTime ? 'runtime budget' : 'iteration limit';
+  // #0156: reaching the cap here means the exit conditions are NOT met (the `done` path above
+  // already handled the met case) — i.e. work is STILL REMAINING. Going silently dormant
+  // (active:false) makes a STALL indistinguishable from 'completed' (idle-pike's 11h-dormant bug).
+  // So block ONCE to make the agent surface the stall LOUDLY + offer extend/resume <options>;
+  // then on the next stop allow it (a stall must never trap the loop forever).
+  if (!state.stall_hinted) {
+    writeJSONAtomic(STATE, { ...state, iteration: nextIter, stall_hinted: true,
+      last_iteration_at: now, last_oracle: oracleDetail, ...tokenField });
+    appendHistory({ ts: now, iteration: nextIter, decision: 'stall_hint', reason: why, oracle: oraclePass, detail: oracleDetail });
+    const suggested = (overIters && max != null) ? Math.max(max * 2, nextIter + 10) : null;
+    const sess = SID || '<session>';
+    const resumeCmd = suggested != null
+      ? `svamp session loop ${sess} --max ${suggested}`
+      : `svamp session loop ${sess} --budget <bigger>`;
+    const firstLine = String(oracleDetail || 'oracle still failing').split('\n')[0];
+    block(
+      `⚠️ LOOP STALLED — hit the ${limitName} (${why}) but the exit conditions are NOT met: ${firstLine}. `
+      + `Work is still remaining; do NOT keep grinding, and do NOT just stop silently. In ONE final message:\n`
+      + `1) Tell the user the loop hit its ${limitName} with work still pending, and briefly why it didn't finish.\n`
+      + `2) Present clickable options so they can extend+resume or stop — exactly like:\n`
+      + `<options>\n`
+      + `  <option>Extend the limit${suggested != null ? ` to ${suggested}` : ''} and resume the loop</option>\n`
+      + `  <option>Stop the loop here</option>\n`
+      + `</options>\n`
+      + `If the user picks an extend option, run:  ${resumeCmd}  (this reactivates + extends the loop). Then end your turn.`,
+    );
+  }
+  // Already surfaced the stall once → allow stop so it can never trap the loop.
   writeJSONAtomic(STATE, { ...state, active: false, phase: 'gave_up', iteration: nextIter,
     completed_at: now, last_oracle: oracleDetail, gave_up_reason: why, ...tokenField });
   appendHistory({ ts: now, iteration: nextIter, decision: 'gave_up', reason: why, oracle: oraclePass, detail: oracleDetail });
-  process.stderr.write(`[loop] reached ${why}; allowing stop.\n`);
+  process.stderr.write(`[loop] reached ${why}; allowing stop after stall hint.\n`);
   allow();
 }
 

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

@@ -113,13 +113,21 @@ try {
     ok(!r.blocked, 'gate allows when evaluator off and oracle passes');
   }
 
-  // ---- Test 7: max_iterations bound -> eventually allows (never infinite) ----
-  console.log('Test 7: max_iterations prevents infinite blocking');
+  // ---- Test 7: max_iterations bound -> STALL hint once, then allows (never infinite) ----
+  console.log('Test 7: max_iterations → stall hint once, then allows');
   { const d = newProject({ evaluator: 'off', max: 1 }); dirs.push(d); // oracle keeps failing (answer.txt=TODO)
-    const r1 = runGate(d);        // iteration -> 1, block
-    const r2 = runGate(d, true);  // iteration -> 2 > max -> give up, allow
+    const r1 = runGate(d);        // iteration -> 1, block (oracle fails)
+    const r2 = runGate(d, true);  // iteration -> 2 > max -> #0156 STALL: block ONCE with options
+    const r3 = runGate(d, true);  // already hinted -> give up, allow
     ok(r1.blocked, 'first failing attempt blocks');
-    ok(!r2.blocked, 'after exceeding max_iterations the gate allows stop (no infinite loop)');
+    // #0156: exceeding the cap with the oracle still failing is a STALL — surface it loudly ONCE
+    // (don't go silently dormant), presenting extend/resume <options>.
+    ok(r2.blocked, '#0156: exceeding max_iterations blocks ONCE with a stall hint (not silent)');
+    ok(/STALL/i.test(r2.reason) && /<options>/.test(r2.reason), '#0156: stall hint explains + presents <options>');
+    ok(/loop .* --max/.test(r2.reason), '#0156: stall hint gives the resume+extend command');
+    ok(readState(d).stall_hinted === true, '#0156: state records stall_hinted after the hint');
+    ok(!r3.blocked, 'after the stall hint the gate allows stop (no infinite loop)');
+    ok(readState(d).phase === 'gave_up' && readState(d).active === false, 'finally marked gave_up/inactive');
   }
 
   // ---- Test 8: inactive loop -> no-op allow ----
@@ -152,8 +160,10 @@ try {
     const cfg = JSON.parse(readFileSync(cfgP, 'utf8')); cfg.budget = { max_runtime_sec: 1 }; writeFileSync(cfgP, JSON.stringify(cfg));
     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');
+    const r = runGate(d);          // #0156: first over-budget hit → stall hint (block once)
+    const r2 = runGate(d);         // already hinted → allow
+    ok(r.blocked && /STALL/i.test(r.reason), 'runtime over-budget surfaces a stall hint first (not silent)');
+    ok(!r2.blocked, 'gate allows stop once runtime budget is exceeded (after the stall hint)');
     ok(readState(d).gave_up_reason?.includes('runtime'), 'state records runtime give-up reason');
   }
 
@@ -180,8 +190,10 @@ try {
       JSON.stringify({ message: { usage: { input_tokens: 400, output_tokens: 300 } } }),
       JSON.stringify({ message: { usage: { input_tokens: 500, output_tokens: 200, cache_read_input_tokens: 50 } } }),
     ].join('\n')); // total = 1450 > 1000
-    const r = runGate(d, false, tp);
-    ok(!r.blocked, 'gate allows stop once token budget is exceeded');
+    const r = runGate(d, false, tp);   // #0156: first over-budget hit → stall hint
+    const r2 = runGate(d, false, tp);  // already hinted → allow
+    ok(r.blocked && /STALL/i.test(r.reason), 'token over-budget surfaces a stall hint first (not silent)');
+    ok(!r2.blocked, 'gate allows stop once token budget is exceeded (after the stall hint)');
     ok(readState(d).gave_up_reason?.includes('token'), 'state records token give-up reason');
     ok(readState(d).tokens_used === 1450, 'tokens summed from transcript');
   }
@@ -193,8 +205,10 @@ try {
     const cfg = JSON.parse(readFileSync(cfgP, 'utf8')); cfg.max_iterations = null; writeFileSync(cfgP, JSON.stringify(cfg));
     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');
+    const r = runGate(d);   // #0156: stall hint first
+    const r2 = runGate(d);  // then allow
+    ok(r.blocked && /STALL/i.test(r.reason), 'hard-ceiling hit surfaces a stall hint first');
+    ok(!r2.blocked, 'gate allows stop at the hard fallback ceiling even with null max_iterations');
   }
 
   // ---- Test 14: non-git project fingerprint is content-sensitive (CRITICAL #1) ----
@@ -225,7 +239,8 @@ try {
     const cfg = JSON.parse(readFileSync(cfgP, 'utf8')); cfg.max_iterations = 1e9; writeFileSync(cfgP, JSON.stringify(cfg));
     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);
+    runGate(d);             // #0156: stall hint first
+    const r = runGate(d);   // then allow
     ok(!r.blocked && /max_iterations \(200\)/.test(readState(d).gave_up_reason || ''), 'max_iterations 1e9 clamped to 200 → gives up');
   }
 
@@ -374,6 +389,44 @@ try {
     ok(!r.blocked && readState(d).phase === 'done', 'all-handled inbox allows the loop to complete');
   }
 
+  // ---- Test 25: NON-URGENT inbox hint at settle — blocks ONCE, then allows (de-duped) (#0146) ----
+  console.log('Test 25: non-urgent inbox hint blocks once at settle, then allows (de-duped)');
+  { const d = newProject({ evaluator: 'on' }); dirs.push(d);
+    writeFileSync(join(d, 'answer.txt'), 'DONE\n'); // oracle passes
+    writeVerdict(d, { verdict: 'done', reason: 'ok', state_fp: fp(d) });
+    // Disable the #0103 urgent/unhandled guard so we exercise the non-urgent hint in isolation
+    // (otherwise the #0103 guard would block first on the same genuinely-pending message).
+    const cfgP = join(d, '.svamp', SID, 'loop', 'loop.config.json');
+    writeFileSync(cfgP, JSON.stringify({ ...JSON.parse(readFileSync(cfgP, 'utf8')), inbox_guard: false }));
+    // A genuinely-unseen (read=false, handled=false), non-urgent, non-awaiting-reply message.
+    writeFileSync(join(d, '.svamp', SID, 'inbox.json'), JSON.stringify([
+      { messageId: 'n1', from: 'agent:peer', subject: 'fyi', read: false, handled: false, urgency: 'normal' },
+    ]));
+    const r1 = runGate(d);
+    ok(r1.blocked && /unread inbox message/i.test(r1.reason), 'non-urgent unread message hints (blocks once) at the settle point');
+    ok(/fyi/.test(r1.reason), 'hint names the subject');
+    const hinted = JSON.parse(readFileSync(join(d, '.svamp', SID, 'loop', 'hinted-inbox.json'), 'utf8'));
+    ok(hinted.includes('n1'), 'hinted id recorded for de-dupe');
+    // Second settle: same message id already hinted → allows the loop to end (non-blocking thereafter).
+    const r2 = runGate(d);
+    ok(!r2.blocked && readState(d).phase === 'done', 'already-hinted message does not re-block — loop completes');
+  }
+
+  // ---- Test 26: urgent + awaiting-reply messages are NOT hinted by the non-urgent path (#0146) ----
+  console.log('Test 26: urgent / awaiting-reply messages skip the non-urgent hint');
+  { const d = newProject({ evaluator: 'on' }); dirs.push(d);
+    writeFileSync(join(d, 'answer.txt'), 'DONE\n');
+    writeVerdict(d, { verdict: 'done', reason: 'ok', state_fp: fp(d) });
+    // All handled (no #0103 block); one urgent, one awaiting-reply, one already-read → none qualify.
+    writeFileSync(join(d, '.svamp', SID, 'inbox.json'), JSON.stringify([
+      { messageId: 'u1', read: false, handled: true, urgency: 'urgent' },
+      { messageId: 'a1', read: false, handled: true, channelId: 'c', correlationId: 'x' },
+      { messageId: 'r1', read: true, handled: true, urgency: 'normal' },
+    ]));
+    const r = runGate(d);
+    ok(!r.blocked && readState(d).phase === 'done', 'no qualifying non-urgent unread message → loop completes (no noise)');
+  }
+
   console.log(`\n${fail === 0 ? '✅' : '❌'} ${pass} passed, ${fail} failed`);
   process.exit(fail === 0 ? 0 : 1);
 } finally {

package/dist/{agentCommands-D92DfTGP.mjs → agentCommands-akIoZemu.mjs}

@@ -2,7 +2,7 @@ import { existsSync, readFileSync, mkdirSync, writeFileSync, renameSync } from '
 import { join, dirname } from 'node:path';
 import os from 'node:os';
 import { requireNotSandboxed } from './sandboxDetect-DNTcbgWD.mjs';
-import { A as shortId } from './run-BfgkuBEg.mjs';
+import { A as shortId } from './run-C9ZeF2iG.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';
@@ -96,7 +96,7 @@ async function sessionSetTitle(title) {
 }
 async function sessionSetProjectDescription(description) {
   const dir = process.cwd();
-  const { projectName, writeProjectInfo, sanitizeDescription, projectInfoPath } = await import('./run-BfgkuBEg.mjs').then(function (n) { return n.a8; });
+  const { projectName, writeProjectInfo, sanitizeDescription, projectInfoPath } = await import('./run-C9ZeF2iG.mjs').then(function (n) { return n.a8; });
   const desc = sanitizeDescription(description, 240);
   if (!desc) {
     console.error("Project description is empty.");
@@ -180,7 +180,7 @@ async function sessionBroadcast(action, args) {
   console.log(`Broadcast sent: ${action}`);
 }
 async function connectToMachineService() {
-  const { connectAndGetMachine } = await import('./commands-u68ODpBt.mjs');
+  const { connectAndGetMachine } = await import('./commands-BRmWVCNf.mjs');
   return connectAndGetMachine();
 }
 function buildInboxMessage(args) {
@@ -258,7 +258,7 @@ async function inboxSend(targetSessionId, opts) {
     console.error("Message body is required.");
     process.exit(1);
   }
-  const { connectAndResolveSession } = await import('./commands-u68ODpBt.mjs');
+  const { connectAndResolveSession } = await import('./commands-BRmWVCNf.mjs');
   let server;
   try {
     const { targetId, messageId } = await inboxSendCore(
@@ -312,7 +312,7 @@ async function inboxReply(messageId, body) {
     console.error("SVAMP_SESSION_ID not set. This command must be run inside a Svamp session.");
     process.exit(1);
   }
-  const { connectAndResolveSession } = await import('./commands-u68ODpBt.mjs');
+  const { connectAndResolveSession } = await import('./commands-BRmWVCNf.mjs');
   const { server: localServer, machine: localMachine } = await connectToMachineService();
   let localDisconnected = false;
   const disconnectLocal = async () => {

package/dist/{auth-BvO7QtaP.mjs → auth-Dzf0cndq.mjs}

@@ -1,4 +1,4 @@
-import { P as resolveModel } from './run-BfgkuBEg.mjs';
+import { P as resolveModel } from './run-C9ZeF2iG.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';