@inetafrica/open-claudia 3.0.43 → 3.1.0

package/core/providers/claude-events.js

@@ -4,6 +4,7 @@ const {
   normalizeDecoderError,
   normalizedUsage,
   providerErrorFlags,
+  refusalDetailsFromMessage,
 } = require("./events");
 
 function createClaudeParserState() {
@@ -14,6 +15,7 @@ function createClaudeParserState() {
     tools: new Map(),
     seenUsage: new Set(),
     totalCostUsd: 0,
+    refusal: null,
   };
 }
 
@@ -30,6 +32,27 @@ function claudeErrorMessage(rawEvent) {
   return "Claude provider failed";
 }
 
+function captureRefusal(state, stopReason, stopDetails) {
+  if (stopReason !== "refusal") return;
+  state.refusal = {
+    category: stopDetails?.category ?? null,
+    explanation: stopDetails?.explanation ?? null,
+  };
+}
+
+function claudeFailureEvent(message, state) {
+  const flags = providerErrorFlags(message);
+  const event = { type: "error", message, ...flags };
+  if (flags.refusal || state.refusal) {
+    const parsed = refusalDetailsFromMessage(message);
+    event.refusal = true;
+    event.refusalCategory = state.refusal?.category ?? null;
+    event.refusalExplanation = state.refusal?.explanation || parsed.explanation || null;
+    event.requestId = parsed.requestId;
+  }
+  return event;
+}
+
 function normalizeClaudeEvent(rawEvent, state = createClaudeParserState()) {
   if (!rawEvent || typeof rawEvent !== "object") return [];
   const decoderFailure = normalizeDecoderError(rawEvent);
@@ -41,6 +64,9 @@ function normalizeClaudeEvent(rawEvent, state = createClaudeParserState()) {
   }
 
   if (rawEvent.type === "stream_event") {
+    if (rawEvent.event?.type === "message_delta") {
+      captureRefusal(state, rawEvent.event.delta?.stop_reason, rawEvent.event.delta?.stop_details ?? rawEvent.event.stop_details);
+    }
     const delta = rawEvent.event?.type === "content_block_delta" ? rawEvent.event.delta : null;
     if (delta?.type === "text_delta" && typeof delta.text === "string" && delta.text) {
       state.sawText = true;
@@ -51,6 +77,7 @@ function normalizeClaudeEvent(rawEvent, state = createClaudeParserState()) {
 
   if (rawEvent.type === "assistant") {
     const events = [];
+    captureRefusal(state, rawEvent.message?.stop_reason, rawEvent.message?.stop_details);
     for (const block of rawEvent.message?.content || []) {
       if (block?.type === "text" && typeof block.text === "string" && block.text) {
         state.sawText = true;
@@ -95,8 +122,7 @@ function normalizeClaudeEvent(rawEvent, state = createClaudeParserState()) {
     state.terminal = true;
     if (Number.isFinite(rawEvent.total_cost_usd)) state.totalCostUsd = rawEvent.total_cost_usd;
     if (rawEvent.is_error || /^error/.test(String(rawEvent.subtype || ""))) {
-      const message = claudeErrorMessage(rawEvent);
-      return [{ type: "error", message, ...providerErrorFlags(message) }];
+      return [claudeFailureEvent(claudeErrorMessage(rawEvent), state)];
     }
     const events = [];
     const session = sessionEvent(rawEvent.session_id, state);
@@ -104,12 +130,19 @@ function normalizeClaudeEvent(rawEvent, state = createClaudeParserState()) {
     const usage = normalizedUsage(rawEvent.usage, "turn", state.seenUsage);
     if (usage) events.push(usage);
     const hasStructuredOutput = Object.prototype.hasOwnProperty.call(rawEvent, "structured_output");
+    const resultText = typeof rawEvent.result === "string" ? rawEvent.result : "";
+    if (state.refusal && !hasStructuredOutput && !state.sawText && !resultText.trim()) {
+      // A refusal the CLI reports as a "successful" empty turn would otherwise
+      // surface as "(no output)" — fail it with the real reason instead.
+      events.push(claudeFailureEvent('The model refused this request (stop_reason "refusal").', state));
+      return events;
+    }
     const structuredText = hasStructuredOutput ? JSON.stringify(rawEvent.structured_output) : "";
     events.push({
       type: "result",
       text: hasStructuredOutput
         ? (structuredText === undefined ? "" : structuredText)
-        : (state.sawText ? "" : (typeof rawEvent.result === "string" ? rawEvent.result : "")),
+        : (state.sawText ? "" : resultText),
       sessionId: rawEvent.session_id || state.sessionId || null,
     });
     return events;

package/core/providers/events.js

@@ -131,9 +131,19 @@ function providerErrorFlags(message) {
   return {
     authError: /unauthori[sz]ed|not (?:logged in|authenticated)|unauthenticated|login required|authentication failed|auth failed|invalid api key|no credentials|401/.test(text),
     usageLimit: /usage limit|spend limit|monthly cycle|quota|rate limit/.test(text),
+    refusal: /refusals-and-fallback|usage policy|safety classifier|stop_reason['":\s]*refusal/.test(text),
   };
 }
 
+// The CLI flattens the API's stop_details into the error text; recover the
+// human-readable pieces so the chat message can lead with the actual reason.
+function refusalDetailsFromMessage(message) {
+  const text = String(message || "");
+  const requestId = text.match(/\breq_[A-Za-z0-9]+\b/)?.[0] || null;
+  const explanation = text.match(/This request triggered[^.]+\./i)?.[0]?.trim() || null;
+  return { requestId, explanation };
+}
+
 function normalizeDecoderError(rawEvent) {
   if (!rawEvent || rawEvent.type !== "decoder.error") return null;
   // Warning, not error: a single oversized or malformed record is skippable.
@@ -171,6 +181,7 @@ module.exports = {
   normalizeDecoderError,
   normalizedUsage,
   providerErrorFlags,
+  refusalDetailsFromMessage,
   selectTerminalText,
   usageFingerprint,
 };

package/core/recall/discoverer.js

@@ -150,18 +150,34 @@ function maybeSync(packsLib, entitiesLib) {
 // seed — with a 147-pack corpus that is virtually every turn (measured: gated
 // 0.4% of 500 turns), so "thanks!" still paid a full 13s walk. Three tiers:
 //   skip  — pure pleasantry/ack/emoji: no recall at all, regardless of seeds.
-//   seeds — short command-like turns (≤4 words): keyword seeds are precise
-//           enough; inject user-origin seeds directly and skip graph + walker
-//           (the classic baseline, ~ms instead of ~13s).
+//   seeds — short command-like turns (≤4 words after any pleasantry prefix):
+//           keyword seeds are precise enough; inject user-origin seeds directly
+//           and skip graph + walker (the classic baseline, ~ms instead of ~13s).
 //   full  — substantive turns: graph expansion + walker judgement.
 const PLEASANTRY_RE = /^(ok(ay)?|k|kk|thanks?|thank you|thx|ty|yes|yep|yeah|no|nope|nah|cool|nice|great|perfect|awesome|lovely|done|sure|got it|sounds good|will do|lol|haha|hi|hey|hello|yo|morning|evening|night|good (morning|afternoon|evening|night)|bye|goodnight|cheers|please do|go ahead)\b/;
 
+// B2: a pleasantry PREFIX must not hide a real request from the gate — "ok
+// deploy kazee now" is a deploy command wearing an ack, yet the old ≤4-word
+// rule skipped recall for it entirely. Strip leading pleasantry tokens
+// (stacked ones too) plus separators and tier what remains; a pure pleasantry
+// chain strips to "" and skips regardless of its length.
+function stripPleasantryPrefix(t) {
+  let s = t;
+  for (;;) {
+    const m = PLEASANTRY_RE.exec(s);
+    if (!m) return s;
+    s = s.slice(m[0].length).replace(/^[\s,.!?;:—–-]+/, "");
+    if (!s) return "";
+  }
+}
+
 function recallTier(userText, seedCount) {
   const t = String(userText || "").trim().toLowerCase();
   if (!t) return "skip";
-  const words = t.split(/\s+/).filter(Boolean);
   if (!/[a-z0-9]/.test(t)) return "skip"; // emoji/punctuation only
-  if (words.length <= 4 && PLEASANTRY_RE.test(t)) return "skip";
+  const core = stripPleasantryPrefix(t);
+  if (!core) return "skip"; // pure pleasantry/ack chain
+  const words = core.split(/\s+/).filter(Boolean);
   if (words.length <= 2 && seedCount === 0) return "skip";
   if (words.length <= tuning.get("seedsTierMaxWords")) return "seeds";
   return "full";
@@ -325,7 +341,7 @@ function cokeptPairs(keptIds, scoreById, groundedIds, { minScore = 60, maxPairs
       pairs.push({ a, b, strength: scoreById.get(a) + scoreById.get(b) });
     }
   }
-  pairs.sort((x, y) => y.strength - x.strength || (x.a + "" + x.b).localeCompare(y.a + "" + y.b));
+  pairs.sort((x, y) => y.strength - x.strength || (x.a + "\u0000" + x.b).localeCompare(y.a + "\u0000" + y.b));
   return pairs.slice(0, Math.max(0, maxPairs)).map((p) => [p.a, p.b]);
 }
 

package/core/recall/graph.js

@@ -12,6 +12,14 @@
 // `weight` and `last_reinforced`. Structural edges (parent/related from pack
 // metadata) are re-derived idempotently; their weight floor is kept but any
 // extra reinforcement earned through use is preserved.
+//
+// Decay is computed ON READ, never rewritten in place ("decay-on-read"): the
+// stored `weight` is the value AS OF `last_reinforced`, and every read maps it
+// through effectiveWeight(). Writes that change a weight (reinforce, weaken)
+// first settle the decay accrued so far, then apply their delta and restamp.
+// The old nightly decay() rewrite reapplied the full age to an already-decayed
+// weight every night (compounding — a 60d half-life emptied in ~10 nights);
+// with no rewrite path, that bug class cannot exist.
 
 const fs = require("fs");
 const path = require("path");
@@ -29,13 +37,14 @@ const EDGE_TYPES = ["parent", "governed-by", "related"];
 // Base weights when an edge is first derived from structure.
 const BASE_WEIGHT = { parent: 3, "governed-by": 2.5, related: 1 };
 // Spreading-activation tunables (overridable via env / dream knobs).
+// The decay half-life lives in tuning.js (`decayHalfLifeDays`, env-pinnable),
+// read lazily so a dream knob change applies to the very next read.
 const DEFAULTS = {
   hops: 2,
   threshold: 0.18,   // firing threshold as a fraction of the strongest seed
   damping: 0.55,     // fraction of activation transmitted per hop
   perNodeTopK: 6,    // cap fan-out per node (sparsity)
   maxWeight: 6,      // weight at which an edge transmits at full damping
-  halfLifeDays: 60,  // Hebbian weight half-life for decay()
 };
 
 let _db = null;
@@ -62,6 +71,17 @@ function openDb() {
     )`);
     db.exec("CREATE INDEX IF NOT EXISTS edges_src ON edges (src)");
     db.exec("CREATE INDEX IF NOT EXISTS edges_dst ON edges (dst)");
+    // v1 migration: legacy DBs carry weights the old nightly decay() rewrite
+    // had already over-decayed (it reapplied the full age every night). Treat
+    // stored values as current and restart the clock — decay is read-time from
+    // here on, so this is the last time the stamp is touched in bulk.
+    try {
+      const uv = db.prepare("PRAGMA user_version").get() || {};
+      if (Number(uv.user_version || 0) < 1) {
+        db.prepare("UPDATE edges SET last_reinforced=? WHERE last_reinforced IS NOT NULL").run(now());
+        db.exec("PRAGMA user_version = 1");
+      }
+    } catch (e) {}
     _db = db;
     return db;
   } catch (e) {
@@ -76,6 +96,29 @@ function normType(t) {
   return EDGE_TYPES.includes(s) ? s : "related";
 }
 
+// Effective decay half-life: explicit override > dream-tunable knob (env-pinnable).
+function currentHalfLife(opts = {}) {
+  if (Number.isFinite(opts.halfLifeDays)) return Math.max(1, opts.halfLifeDays);
+  let hl;
+  try { hl = require("./tuning").get("decayHalfLifeDays"); } catch (e) {}
+  return Number.isFinite(hl) ? Math.max(1, hl) : 60;
+}
+
+// Read-time weight of an edge row: exponential decay of the stored weight since
+// last_reinforced, clamped at the structural floor. Pure — storage is never
+// touched. An edge that was never reinforced (last_reinforced null) does not
+// decay: it sits at its structural base until first use.
+function effectiveWeight(e, nowMs = Date.now(), halfLifeDays = currentHalfLife()) {
+  if (!e || !Number.isFinite(e.weight)) return 0;
+  if (!e.last_reinforced) return e.weight;
+  const ageDays = (nowMs - Date.parse(e.last_reinforced)) / 86400000;
+  if (!(ageDays > 0)) return e.weight;
+  const floor = BASE_WEIGHT[e.type] || 0;
+  if (e.weight <= floor) return e.weight;
+  const f = Math.exp(-Math.log(2) * ageDays / Math.max(1, halfLifeDays));
+  return Math.max(floor, e.weight * f);
+}
+
 // Upsert an edge. By default keeps the larger of the existing/new weight so a
 // structural re-derive never stomps reinforcement; pass `{ bump }` to add to
 // the current weight (Hebbian) and stamp last_reinforced.
@@ -86,15 +129,19 @@ function addEdge(src, dst, type, opts = {}) {
   const weight = Number.isFinite(opts.weight) ? opts.weight : (BASE_WEIGHT[t] || 1);
   const bump = Number.isFinite(opts.bump) ? opts.bump : 0;
   try {
-    const existing = db.prepare("SELECT weight FROM edges WHERE src=? AND dst=? AND type=?").get(src, dst, t);
+    const existing = db.prepare("SELECT weight, last_reinforced FROM edges WHERE src=? AND dst=? AND type=?").get(src, dst, t);
     if (existing) {
-      const next = bump ? existing.weight + bump : Math.max(existing.weight, weight);
-      const stamp = bump ? now() : null;
-      if (stamp) {
+      if (bump) {
+        // Settle the decay accrued since last_reinforced, then bump and restamp
+        // — keeps the invariant that the stored weight is valued at its stamp.
+        const settled = effectiveWeight({ ...existing, type: t });
         db.prepare("UPDATE edges SET weight=?, last_reinforced=? WHERE src=? AND dst=? AND type=?")
-          .run(next, stamp, src, dst, t);
+          .run(settled + bump, now(), src, dst, t);
       } else {
-        db.prepare("UPDATE edges SET weight=? WHERE src=? AND dst=? AND type=?").run(next, src, dst, t);
+        const next = Math.max(existing.weight, weight);
+        if (next !== existing.weight) {
+          db.prepare("UPDATE edges SET weight=? WHERE src=? AND dst=? AND type=?").run(next, src, dst, t);
+        }
       }
     } else {
       db.prepare("INSERT INTO edges (src, dst, type, weight, last_reinforced, created) VALUES (?,?,?,?,?,?)")
@@ -123,18 +170,21 @@ function allEdges() {
   catch (e) { return []; }
 }
 
-// Undirected neighbours of a node: edges where it is src OR dst.
+// Undirected neighbours of a node: edges where it is src OR dst. Weights are
+// read-time effective values.
 function neighbors(nodeId) {
   const db = openDb();
   if (!db || !nodeId) return [];
   try {
     const rows = db.prepare(
-      "SELECT src, dst, type, weight FROM edges WHERE src=? OR dst=?"
+      "SELECT src, dst, type, weight, last_reinforced FROM edges WHERE src=? OR dst=?"
     ).all(nodeId, nodeId);
+    const nowMs = Date.now();
+    const hl = currentHalfLife();
     return rows.map((r) => ({
       node: r.src === nodeId ? r.dst : r.src,
       type: r.type,
-      weight: r.weight,
+      weight: effectiveWeight(r, nowMs, hl),
     }));
   } catch (e) { return []; }
 }
@@ -158,24 +208,30 @@ function reinforceSet(nodeIds, amount = 1) {
 
 // Negative Hebbian: weaken every edge touching a node that keeps surfacing
 // via the graph but never gets kept or used — firing wrongly, so unwire.
-// Same floor contract as decay(); additionally, `related` edges that fall to
-// their structural base are deleted outright: a link-derived edge re-derives
-// at base weight on the next sync (harmless), while a co-use edge that earned
-// its weight from wrong firings is gone for good.
+// Operates on the EFFECTIVE weight (settle accrued decay first, then apply the
+// factor and restamp — same invariant as the reinforce path). Floor contract
+// as everywhere: never below the type's base weight. Additionally, `related`
+// edges that fall to their structural base are deleted outright: a
+// link-derived edge re-derives at base weight on the next sync (harmless),
+// while a co-use edge that earned its weight from wrong firings is gone for
+// good.
 function weakenNode(nodeId, { factor = 0.6, prune = true } = {}) {
   const db = openDb();
   if (!db || !nodeId) return { weakened: 0, pruned: 0 };
   let weakened = 0, pruned = 0;
   try {
-    const rows = db.prepare("SELECT src, dst, type, weight FROM edges WHERE src=? OR dst=?").all(nodeId, nodeId);
+    const rows = db.prepare("SELECT src, dst, type, weight, last_reinforced FROM edges WHERE src=? OR dst=?").all(nodeId, nodeId);
+    const nowMs = Date.now();
+    const hl = currentHalfLife();
+    const stamp = now();
     for (const e of rows) {
       const floor = BASE_WEIGHT[e.type] || 0;
-      const next = Math.max(floor, e.weight * factor);
+      const next = Math.max(floor, effectiveWeight(e, nowMs, hl) * factor);
       if (prune && e.type === "related" && next <= floor + 0.05) {
         db.prepare("DELETE FROM edges WHERE src=? AND dst=? AND type=?").run(e.src, e.dst, e.type);
         pruned++;
       } else if (Math.abs(next - e.weight) > 1e-6) {
-        db.prepare("UPDATE edges SET weight=? WHERE src=? AND dst=? AND type=?").run(next, e.src, e.dst, e.type);
+        db.prepare("UPDATE edges SET weight=?, last_reinforced=? WHERE src=? AND dst=? AND type=?").run(next, stamp, e.src, e.dst, e.type);
         weakened++;
       }
     }
@@ -183,33 +239,6 @@ function weakenNode(nodeId, { factor = 0.6, prune = true } = {}) {
   return { weakened, pruned };
 }
 
-// Exponential time decay on reinforced weight. Structural floor is preserved:
-// an edge never decays below its type's base weight.
-function decay({ halfLifeDays = DEFAULTS.halfLifeDays } = {}) {
-  const db = openDb();
-  if (!db) return 0;
-  const rows = allEdges();
-  const nowMs = Date.now();
-  const ln2 = Math.log(2);
-  let changed = 0;
-  for (const e of rows) {
-    if (!e.last_reinforced) continue;
-    const ageDays = (nowMs - Date.parse(e.last_reinforced)) / 86400000;
-    if (!(ageDays > 0)) continue;
-    const factor = Math.exp(-ln2 * ageDays / Math.max(1, halfLifeDays));
-    const floor = BASE_WEIGHT[e.type] || 0;
-    const next = Math.max(floor, e.weight * factor);
-    if (Math.abs(next - e.weight) > 1e-6) {
-      try {
-        db.prepare("UPDATE edges SET weight=? WHERE src=? AND dst=? AND type=?")
-          .run(next, e.src, e.dst, e.type);
-        changed++;
-      } catch (e2) {}
-    }
-  }
-  return changed;
-}
-
 // Spreading activation. `seeds` is [{ id, score }] (score = match strength).
 // Returns Map id -> { activation, hop, via } for nodes that fired above the
 // threshold, EXCLUDING the original seeds (those are already in the result set
@@ -220,10 +249,13 @@ function expand(seeds, opts = {}) {
   const seedList = (seeds || []).filter((s) => s && s.id);
   if (!seedList.length || !available()) return out;
 
-  // Build adjacency once, keeping the strongest edge per (node, neighbour).
+  // Build adjacency once over READ-TIME weights, keeping the strongest edge
+  // per (node, neighbour).
   const adj = new Map();
+  const nowMs = Date.now();
+  const hl = currentHalfLife(opts);
   for (const e of allEdges()) {
-    const w = e.weight;
+    const w = effectiveWeight(e, nowMs, hl);
     const push = (from, to) => {
       if (!adj.has(from)) adj.set(from, new Map());
       const m = adj.get(from);
@@ -378,14 +410,14 @@ function pruneOrphans(packsLib, entitiesLib) {
   return removed;
 }
 
-// Nightly maintenance: refresh structural edges, decay reinforced weights,
-// drop orphans. Deterministic + safe — the high-judgment "extract shared
+// Nightly maintenance: refresh structural edges, drop orphans. There is no
+// weight pass — decay is applied on read (effectiveWeight), so nightly has
+// nothing to rewrite. Deterministic + safe — the high-judgment "extract shared
 // concern node" surgery is left to the dream model proper.
-function tend(packsLib, entitiesLib, opts = {}) {
+function tend(packsLib, entitiesLib) {
   const synced = syncFromCorpus(packsLib, entitiesLib);
-  const decayed = decay(opts);
   const pruned = pruneOrphans(packsLib, entitiesLib);
-  return { synced: synced.edges, decayed, pruned, ...stats() };
+  return { synced: synced.edges, pruned, ...stats() };
 }
 
 function stats() {
@@ -404,7 +436,7 @@ module.exports = {
   EDGE_TYPES, DEFAULTS, GRAPH_DB,
   available, openDb,
   addEdge, removeEdge, allEdges, neighbors,
-  reinforce, reinforceSet, decay, weakenNode, expand,
+  reinforce, reinforceSet, effectiveWeight, weakenNode, expand,
   syncFromCorpus, parseLinks, pruneOrphans, tend, stats, isSharedConcern,
   _resetForTest,
 };

package/core/recall/tuning.js

@@ -132,8 +132,7 @@ function history() { return readFile().history || []; }
 
 function write(data) {
   try {
-    fs.mkdirSync(path.dirname(TUNING_FILE), { recursive: true });
-    fs.writeFileSync(TUNING_FILE, JSON.stringify(data, null, 2));
+    require("../fsutil").atomicWriteFileSync(TUNING_FILE, JSON.stringify(data, null, 2), { mode: 0o600 });
   } catch (e) {}
   _cache = null; _cacheMtime = -1;
 }

package/core/router.js

@@ -27,6 +27,7 @@ const { MAX_FILE_SIZE, MAX_VOICE_SIZE, FILES_DIR } = require("./config");
 const keyring = require("./keyring");
 const { classifyPastedCredential } = require("./credential-detect");
 const channelWizard = require("./channel-wizard");
+const safeModeLib = require("./safe-mode");
 require("./handlers"); // side-effect: register slash commands
 
 const USER_VISIBLE_PROVIDER_ERRORS = new Set([
@@ -96,6 +97,19 @@ async function onMessage(envelope) {
       // owner's canonical bucket on first contact, before any state is read.
       try { autoLinkOwnerChannel(envelope.adapter?.type, envelope.channelId); } catch (e) {}
 
+      // Safe mode: only the diagnosis/rescue command set runs; everything else
+      // gets a short banner pointing at /safemode. Preempts wizards, media and
+      // agent turns — nothing may write memory or spawn a provider here.
+      if (safeModeLib.isSafeMode()) {
+        const raw = envelope.text || "";
+        const isCommand = envelope.type === "command" || raw.startsWith("/");
+        if (!isCommand || !safeModeLib.commandAllowed(raw)) {
+          if (isDuplicate(envelope)) return;
+          await send(safeModeLib.banner());
+          return;
+        }
+      }
+
       // A channel wizard listening for the owner's message on a freshly-added
       // adapter consumes that inbound message here: it arrives on a different
       // channel than the operator's, so the isAwaiting() gate below (keyed to
@@ -151,6 +165,10 @@ async function onMessage(envelope) {
 async function onAction(envelope) {
   return scope(envelope, async () => {
     try {
+      if (safeModeLib.isSafeMode()) {
+        try { await send(safeModeLib.banner()); } catch (e) {}
+        return;
+      }
       if (await channelWizard.handleAction(envelope)) return;
       await handleAction(envelope);
     }

package/core/run-context.js

@@ -97,9 +97,14 @@ function captureRunContext({
   }
   const project = projectSnapshot(state, cwd, opts.project);
   const activeSessionId = state.activeSessions?.[project.name]?.[provider] || null;
-  const admittedSessionId = opts.fresh
+  const requestedSessionId = opts.fresh
     ? null
     : (opts.resumeSessionId || activeSessionId || null);
+  // A quarantined session's provider-side context tripped a safety refusal;
+  // resuming would re-send the flagged context and refuse again. Force the
+  // turn fresh instead (explicit resume requests included).
+  const quarantinedResume = !!(requestedSessionId && state.quarantinedSessions?.[requestedSessionId]);
+  const admittedSessionId = quarantinedResume ? null : requestedSessionId;
   const origin = serializableOrigin(opts.origin, store || {});
   const resolvedChannelId = channelId != null
     ? String(channelId)
@@ -128,9 +133,10 @@ function captureRunContext({
     cwd: cwd || project.dir || null,
     replyToMsgId: replyToMsgId == null ? null : String(replyToMsgId),
     userPrompt: prompt,
-    fresh: !!opts.fresh,
-    continueSession: !!opts.continueSession,
-    resumeSessionId: opts.resumeSessionId || null,
+    fresh: !!opts.fresh || quarantinedResume,
+    continueSession: quarantinedResume ? false : !!opts.continueSession,
+    resumeSessionId: quarantinedResume ? null : (opts.resumeSessionId || null),
+    quarantinedResume,
     skipAutoCompact: !!opts.skipAutoCompact,
     timeoutMs: Number.isFinite(opts.timeoutMs) ? opts.timeoutMs : null,
     maxTurns: Number.isFinite(opts.maxTurns) ? opts.maxTurns : null,