@inetafrica/open-claudia 3.0.43 → 3.1.0

package/core/runner.js

@@ -14,7 +14,7 @@ const {
 const {
   currentState, saveState, recordSession,
   resetSessionUsage, acquireRunLock, getActiveProvider, getProjectKey,
-  getProviderSession, setProviderSession, clearProviderSession, getUsageForSession, commitProviderCompaction,
+  getProviderSession, setProviderSession, clearProviderSession, quarantineProviderSession, getUsageForSession, commitProviderCompaction,
 } = require("./state");
 const { chatContext, currentChannelId, currentAdapter } = require("./context");
 const { buildTurnPrompt } = require("./system-prompt");
@@ -525,7 +525,11 @@ async function executeProviderInvocation(options = {}) {
   else if (closeInfo.signal) failure = stableRunError(`Provider process exited on signal ${closeInfo.signal}`, "PROVIDER_SIGNAL_EXIT", { signal: closeInfo.signal });
   else if (rawErrors.length) {
     const event = rawErrors[0];
-    failure = stableRunError(event.message || "Provider reported an error", event.authError ? "PROVIDER_UNAUTHENTICATED" : (event.usageLimit ? "PROVIDER_USAGE_LIMIT" : "PROVIDER_EVENT_ERROR"), event);
+    failure = stableRunError(
+      event.message || "Provider reported an error",
+      event.refusal ? "PROVIDER_REFUSAL" : (event.authError ? "PROVIDER_UNAUTHENTICATED" : (event.usageLimit ? "PROVIDER_USAGE_LIMIT" : "PROVIDER_EVENT_ERROR")),
+      event,
+    );
   } else if (closeInfo.code !== 0) failure = stableRunError(`Provider process exited with code ${closeInfo.code}`, "PROVIDER_NONZERO_EXIT", { exitCode: closeInfo.code });
   else if (!terminalSeen) failure = stableRunError("Provider stream ended without a terminal event", "PROVIDER_MISSING_TERMINAL");
   else if (!cleanupOutcome.ok) failure = cleanupOutcome.error;
@@ -1197,6 +1201,7 @@ function deriveCompactionRunContext(base, overrides = {}) {
     resumeSessionId: overrides.resumeSessionId ?? null,
     continueSession: false,
     fresh: !!overrides.fresh,
+    recallQuery: overrides.recallQuery ?? null,
     skipAutoCompact: true,
     requiredDelivery: false,
     readOnly: true,
@@ -1210,6 +1215,25 @@ function deriveCompactionRunContext(base, overrides = {}) {
   });
 }
 
+// The seed turn opens a fresh session, so whatever packs were active before
+// compaction only come back if recall re-attracts them. Match on what the
+// work IS — the condensed brief plus open task titles — rather than the seed
+// prompt's instruction boilerplate.
+function seedRecallQuery(condensedSummary) {
+  const parts = [String(condensedSummary || "").slice(0, 4000)];
+  try {
+    const { currentAdapter, currentChannelId } = require("./context");
+    const adapter = currentAdapter();
+    const channelId = currentChannelId();
+    if (adapter && channelId) {
+      const titles = require("./tasks").pendingSummary(adapter.id, channelId)
+        .map((t) => t.content).filter(Boolean).slice(0, 20);
+      if (titles.length) parts.push(titles.join("\n"));
+    }
+  } catch (_) {}
+  return parts.filter(Boolean).join("\n");
+}
+
 function successfulTerminalCapture(result, { requireSession = false } = {}) {
   return !!result?.ok && result.status === "succeeded" && result.terminalSeen === true
     && (!requireSession || (typeof result.sessionId === "string" && !!result.sessionId));
@@ -1292,6 +1316,7 @@ function createCompactionService(dependencies = {}) {
         previousSessionId: oldSessionId,
         fresh: true,
         outputSchemaPath,
+        recallQuery: seedRecallQuery(condensed || fullBrief),
       });
       const seedRun = await runCapture(seedPrompt, seedContext.cwd || cwd, {
         runContext: seedContext,
@@ -1394,6 +1419,26 @@ function providerRunDiagnostic(result, runContext) {
   if (code === "PROVIDER_USAGE_LIMIT") {
     return `${label} reported a usage or rate limit. Check that provider's account status or select another configured provider.`;
   }
+  if (code === "PROVIDER_REFUSAL") {
+    const details = result.error?.details || {};
+    const reason = [
+      details.refusalCategory ? `[${details.refusalCategory}]` : null,
+      details.refusalExplanation || null,
+    ].filter(Boolean).join(" ");
+    const lines = [
+      `⛔ ${label} declined this turn — the model's safety classifier refused the request (a policy block, not a crash).`,
+    ];
+    if (reason) lines.push(`Reason: ${reason}`);
+    if (details.requestId) lines.push(`Request ID: ${details.requestId}`);
+    lines.push(
+      "",
+      "The classifier scores the whole conversation, not just your last message — so retrying in this session usually refuses again. Options:",
+      "• /new — fresh session without the flagged context",
+      "• Rephrase, or drop the material that tripped it",
+      "• /model or /backend — a different model can usually serve the same request",
+    );
+    return lines.join("\n");
+  }
   const detail = result.stderr ? `\n\nStderr:\n${result.stderr.slice(-1200)}` : "";
   return `${label} run failed: ${result.error?.message || "unknown provider failure"}${detail}`;
 }
@@ -1899,6 +1944,57 @@ function drainQueuedMessages(state) {
   return Promise.resolve();
 }
 
+// A refusal on a RESUMED session is almost always the safety classifier
+// rejecting flagged material in the old context — which every resume re-sends
+// — not the user's new message. Recovery: quarantine the poisoned session so
+// nothing resumes it again, then replay the same prompt once in a fresh
+// session. A refusal on already-fresh context gets no retry (the new message
+// itself is the problem), and the retry run never retries again.
+function shouldRetryRefusedRun(result, runContext, { capture = false, refusalRetried = false } = {}) {
+  return !capture
+    && !refusalRetried
+    && runContext?.purpose === "foreground"
+    && !!runContext?.sessionId
+    && !!result
+    && !result.ok
+    && result.error?.code === "PROVIDER_REFUSAL";
+}
+
+function quarantineRefusedRun(result, runContext, state) {
+  const details = result.error?.details || {};
+  const record = { reason: "refusal", requestId: details.requestId || null };
+  try {
+    quarantineProviderSession(state, runContext.provider, runContext.project?.name, runContext.sessionId, record);
+    // The CLI rotates session ids on resume; the rotated id observed this run
+    // carries the same poisoned context, so quarantine it too.
+    if (result.sessionId && result.sessionId !== runContext.sessionId) {
+      quarantineProviderSession(state, runContext.provider, runContext.project?.name, result.sessionId, record);
+    }
+    saveState({ strict: true });
+    return true;
+  } catch (error) {
+    console.error("refusal quarantine failed:", redactSensitive(String(error.message || error)));
+    return false;
+  }
+}
+
+function refusalRetryContext(runContext, state) {
+  return deepFreeze({
+    ...runContext,
+    runId: typeof crypto.randomUUID === "function"
+      ? crypto.randomUUID()
+      : `run-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`,
+    admittedAt: Date.now(),
+    sessionId: null,
+    admittedSessionId: null,
+    previousSessionId: getProviderSession(state, runContext.provider, runContext.project?.name) || null,
+    fresh: true,
+    continueSession: false,
+    resumeSessionId: null,
+    quarantinedResume: true,
+  });
+}
+
 async function executeAdmittedRun(runContext, state, store, capture, ownsAdmissionLock, executionOptions = {}) {
   const tracksMainRun = ownsAdmissionLock && !capture;
   if (tracksMainRun) state.activeRunContext = runContext;
@@ -1928,6 +2024,16 @@ async function executeAdmittedRun(runContext, state, store, capture, ownsAdmissi
     stopTyping();
   }
 
+  if (shouldRetryRefusedRun(result, runContext, { capture, refusalRetried: executionOptions.refusalRetried })
+    && quarantineRefusedRun(result, runContext, state)) {
+    try { service.turnObserver?.onTurnSettled(false); } catch (e) { /* best-effort */ }
+    // Re-arm the admission lock across the notice's async gap so a racing
+    // incoming message queues behind the retry instead of interleaving.
+    if (ownsAdmissionLock) state.preparingRun = true;
+    await send("♻️ That refusal came from flagged context in the old session — quarantined it, retrying your message in a fresh one.").catch(() => {});
+    return executeAdmittedRun(refusalRetryContext(runContext, state), state, store, capture, ownsAdmissionLock, { ...executionOptions, refusalRetried: true });
+  }
+
   if (tracksMainRun) {
     sideChatCoordinator.noteMainResult(runContext, result);
     for (const item of state.messageQueue) {
@@ -2114,6 +2220,9 @@ module.exports = {
   runAgent,
   runAgentCapture,
   runAgentSilent,
+  shouldRetryRefusedRun,
+  quarantineRefusedRun,
+  refusalRetryContext,
   shouldStartSideChat,
   runSideChatRequest,
   enqueueSideChatRequest,

package/core/safe-mode.js

@@ -0,0 +1,227 @@
+// Safe-mode boot gate. Two failure classes land here instead of running (or
+// dying) blind:
+//   1) REQUIRED substrate missing — no node:sqlite means no pack FTS, no
+//      recall graph, no episodes. A pod once ran 16 days like that, silently.
+//      Running degraded is now an explicit operator choice, never a default.
+//   2) Boot crash loop — N consecutive boots died before reaching stable
+//      uptime. A hard exit here would strand the operator with a dead chat;
+//      safe mode keeps the channel alive so /doctor, /upgrade, /downgrade and
+//      /safemode continue can rescue it FROM CHAT.
+// Safe mode boots adapters + slash commands only: no scheduler, no crons, no
+// agent turns, no reviewer. bot.js consults beginBoot() once at startup;
+// router.js gates every message through isSafeMode()/commandAllowed().
+
+const fs = require("fs");
+const path = require("path");
+const CONFIG_DIR = require("../config-dir");
+const { sqliteAvailable } = require("./doctor-memory");
+
+const MARKER_FILE = path.join(CONFIG_DIR, "boot-marker.json");
+const CONTINUE_FILE = path.join(CONFIG_DIR, "safemode-continue.json");
+const VERSION_HISTORY_FILE = path.join(CONFIG_DIR, "version-history.json");
+
+const CRASH_LOOP_THRESHOLD = 3;
+const STABLE_UPTIME_MS = 5 * 60 * 1000;
+const CONTINUE_FRESH_MS = 15 * 60 * 1000;
+const VERSION_HISTORY_CAP = 20;
+
+// Commands that still work in safe mode: diagnosis + the ways out. Everything
+// else (agent turns, memory, schedulers, wizards) is paused.
+const SAFE_COMMANDS = new Set([
+  "help", "start", "version", "status", "doctor", "requirements",
+  "restart", "upgrade", "downgrade", "safemode", "whoami", "cluster",
+]);
+
+let _state = { mode: "full", reasons: [], consecutiveCrashes: 0, prevExit: null };
+
+function readJson(file) {
+  try { return JSON.parse(fs.readFileSync(file, "utf-8")); } catch (_) { return null; }
+}
+
+function writeJson(file, value) {
+  try {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(file, JSON.stringify(value), { mode: 0o600 });
+    return true;
+  } catch (_) { return false; }
+}
+
+// Pure decision, unit-testable. degradedAllowed = explicit env override;
+// continueRequested = one-shot /safemode continue flag (also resets the loop).
+function decideBootMode({ sqliteOk, crashCount, degradedAllowed, continueRequested }) {
+  const reasons = [];
+  const effectiveCrashes = continueRequested ? 0 : crashCount;
+  if (!sqliteOk && !degradedAllowed && !continueRequested) reasons.push("substrate");
+  if (effectiveCrashes >= CRASH_LOOP_THRESHOLD) reasons.push("crash-loop");
+  if (reasons.length) return { mode: "safe", reasons };
+  return { mode: sqliteOk ? "full" : "degraded", reasons: [] };
+}
+
+function recordVersionSeen(version, now = Date.now()) {
+  if (!version) return;
+  const history = Array.isArray(readJson(VERSION_HISTORY_FILE)) ? readJson(VERSION_HISTORY_FILE) : [];
+  const last = history[history.length - 1];
+  if (last && last.version === version) return;
+  history.push({ version, at: new Date(now).toISOString() });
+  writeJson(VERSION_HISTORY_FILE, history.slice(-VERSION_HISTORY_CAP));
+}
+
+// Most recent version in boot history that differs from the current one — the
+// default /downgrade target ("what ran before this").
+function previousVersion(current) {
+  const history = readJson(VERSION_HISTORY_FILE);
+  if (!Array.isArray(history)) return null;
+  for (let i = history.length - 1; i >= 0; i--) {
+    const v = history[i] && history[i].version;
+    if (v && v !== current) return v;
+  }
+  return null;
+}
+
+function consumeContinueFlag(now = Date.now()) {
+  const flag = readJson(CONTINUE_FILE);
+  try { fs.rmSync(CONTINUE_FILE, { force: true }); } catch (_) {}
+  if (!flag || !flag.at) return false;
+  return now - Date.parse(flag.at) < CONTINUE_FRESH_MS;
+}
+
+function requestContinue() {
+  return writeJson(CONTINUE_FILE, { at: new Date().toISOString() });
+}
+
+// Called once per process at the very top of bot.js. Counts crash-loop state
+// from the previous boot marker + exit record, decides the boot mode, writes
+// this boot's marker. Crash rule: the previous incarnation counts as a crash
+// iff it never reached stable uptime AND did not record a clean (code 0)
+// deliberate exit. A safe-mode incarnation preserves the count (safe mode
+// being stable must not launder the loop away) — only markBootStable(),
+// /safemode continue, or a deliberate version change resets it.
+function beginBoot({ exitInfo = null, currentVersion = "", env = process.env, now = Date.now() } = {}) {
+  try {
+    // Test runs boot bot.js repeatedly and kill it hard; marker counting would
+    // sabotage the suite. The feature's own tests opt back in explicitly.
+    if (env.OPEN_CLAUDIA_TEST === "1" && env.OPEN_CLAUDIA_SAFEMODE_TEST !== "1") {
+      _state = { mode: "full", reasons: [], consecutiveCrashes: 0, prevExit: exitInfo };
+      return { ..._state };
+    }
+    recordVersionSeen(currentVersion, now);
+    const prev = readJson(MARKER_FILE);
+    const cleanExit = !!(exitInfo && Number(exitInfo.code) === 0);
+    const crashed = !!(prev && !prev.stable && !cleanExit);
+    const baseCount = prev ? Number(prev.consecutiveCrashes) || 0 : 0;
+    const crashCount = crashed ? baseCount + 1 : (prev && prev.mode === "safe" ? baseCount : 0);
+    const continueRequested = consumeContinueFlag(now);
+    const decision = decideBootMode({
+      sqliteOk: sqliteAvailable(),
+      crashCount,
+      degradedAllowed: env.MEMORY_ALLOW_DEGRADED === "1",
+      continueRequested,
+    });
+    const effectiveCount = continueRequested ? 0 : crashCount;
+    writeJson(MARKER_FILE, {
+      bootedAt: new Date(now).toISOString(),
+      pid: process.pid,
+      mode: decision.mode,
+      // The safe-mode process itself is stable; its marker must still carry
+      // the count so a plain /restart re-enters safe mode instead of retrying
+      // the crashing full boot.
+      stable: decision.mode === "safe",
+      consecutiveCrashes: effectiveCount,
+      version: currentVersion,
+    });
+    _state = {
+      mode: decision.mode,
+      reasons: decision.reasons,
+      consecutiveCrashes: effectiveCount,
+      prevExit: exitInfo,
+    };
+    return { ..._state };
+  } catch (e) {
+    // The gate must never itself brick a boot.
+    try { console.error("safe-mode beginBoot failed:", e.message); } catch (_) {}
+    _state = { mode: "full", reasons: [], consecutiveCrashes: 0, prevExit: exitInfo };
+    return { ..._state };
+  }
+}
+
+// Full/degraded boots call this after STABLE_UPTIME_MS: the incarnation
+// proved itself, so the crash streak resets.
+function markBootStable() {
+  const marker = readJson(MARKER_FILE);
+  if (!marker) return;
+  marker.stable = true;
+  marker.consecutiveCrashes = 0;
+  writeJson(MARKER_FILE, marker);
+}
+
+// A deliberate version change (/upgrade, /downgrade) is an operator fix
+// attempt: give the next boot a clean slate.
+function clearCrashLoop() {
+  const marker = readJson(MARKER_FILE);
+  if (!marker) return;
+  marker.consecutiveCrashes = 0;
+  if (marker.mode === "safe") marker.mode = "full";
+  writeJson(MARKER_FILE, marker);
+}
+
+function isSafeMode() {
+  return _state.mode === "safe";
+}
+
+function bootInfo() {
+  return { ..._state };
+}
+
+function commandAllowed(text) {
+  const t = String(text || "").trim();
+  if (!t.startsWith("/")) return false;
+  const word = t.slice(1).split(/\s+/)[0].split("@")[0].toLowerCase();
+  return SAFE_COMMANDS.has(word);
+}
+
+function reasonLines() {
+  const lines = [];
+  for (const r of _state.reasons) {
+    if (r === "substrate") {
+      lines.push(`• Memory substrate missing: Node ${process.version} has no node:sqlite (Open Claudia requires Node ≥24).`);
+    } else if (r === "crash-loop") {
+      lines.push(`• Boot crash loop: ${_state.consecutiveCrashes} consecutive boots died before reaching stable uptime.`);
+    }
+  }
+  return lines;
+}
+
+function lastExitLine() {
+  if (_state.prevExit && _state.prevExit.reason) return `Last exit: ${_state.prevExit.reason}`;
+  return "Last exit: hard kill — no exit record (OOM, SIGKILL, or a crash before any handler ran).";
+}
+
+function banner() {
+  const why = _state.reasons.includes("substrate") ? "memory substrate missing" : "boot crash loop";
+  return `⛔ Safe mode (${why}) — normal turns are paused. /safemode shows details and ways out; /doctor /status /upgrade /downgrade /restart still work.`;
+}
+
+function formatSafeModeAlert({ version = "" } = {}) {
+  return [
+    `⛔ SAFE MODE — Open Claudia v${version} booted with normal operation suspended.`,
+    ...reasonLines(),
+    lastExitLine(),
+    "",
+    "No agent turns, crons, watches or memory writes will run in this state.",
+    "Working commands: /doctor /status /version /cluster /upgrade /downgrade [version] /restart /safemode continue /help",
+    "",
+    "Ways out:",
+    "• /upgrade — install the latest release",
+    "• /downgrade — roll back to the previously-running version",
+    "• /safemode continue — boot normally anyway (keyword-only memory if the substrate is missing)",
+    "• Fix the runtime (pods: roll to the node:24 image), then /restart",
+  ].join("\n");
+}
+
+module.exports = {
+  MARKER_FILE, CONTINUE_FILE, VERSION_HISTORY_FILE,
+  CRASH_LOOP_THRESHOLD, STABLE_UPTIME_MS, SAFE_COMMANDS,
+  decideBootMode, beginBoot, markBootStable, clearCrashLoop,
+  recordVersionSeen, previousVersion, requestContinue,
+  isSafeMode, bootInfo, commandAllowed, banner, formatSafeModeAlert,
+};

package/core/state.js

@@ -428,6 +428,50 @@ function clearProviderSession(state, providerId, projectName) {
   return true;
 }
 
+const MAX_QUARANTINED_SESSIONS = 20;
+
+function boundQuarantinedSessions(source) {
+  if (!isRecord(source)) return {};
+  return Object.fromEntries(
+    Object.entries(source)
+      .filter(([sessionId, record]) => sessionId && isRecord(record))
+      .sort((a, b) => (a[1].at || 0) - (b[1].at || 0))
+      .slice(-MAX_QUARANTINED_SESSIONS)
+      .map(([sessionId, record]) => [sessionId, { ...record }]),
+  );
+}
+
+// A quarantined session is one whose provider-side context tripped the model's
+// safety classifier (stop_reason "refusal"). Resuming it re-sends the flagged
+// context and refuses again, so it must never be resumed — the run-context
+// capture forces such turns fresh. Quarantining also drops the active pointer
+// when it still points at the poisoned session.
+function quarantineProviderSession(state, providerId, projectName, sessionId, details = {}) {
+  const provider = normalizeProviderId(providerId, null);
+  if (!state || !provider || typeof sessionId !== "string" || !sessionId) return false;
+  if (!isRecord(state.quarantinedSessions)) state.quarantinedSessions = {};
+  state.quarantinedSessions[sessionId] = {
+    provider,
+    project: projectNameFrom(projectName) || getProjectKey(state, projectName) || null,
+    reason: String(details.reason || "refusal"),
+    requestId: details.requestId || null,
+    at: Number.isFinite(details.at) ? details.at : Date.now(),
+  };
+  state.quarantinedSessions = boundQuarantinedSessions(state.quarantinedSessions);
+  const project = getProjectKey(state, projectName);
+  if (project && getProviderSession(state, provider, project) === sessionId) {
+    clearProviderSession(state, provider, project);
+  }
+  return true;
+}
+
+function isSessionQuarantined(state, sessionId) {
+  return !!(sessionId
+    && typeof sessionId === "string"
+    && isRecord(state?.quarantinedSessions)
+    && isRecord(state.quarantinedSessions[sessionId]));
+}
+
 function getProviderSettings(state, providerId) {
   if (!state || typeof state !== "object") throw new TypeError("state is required");
   const provider = normalizeProviderId(providerId || getActiveProvider(state), null);
@@ -542,6 +586,7 @@ function createUserState(userId) {
     streamBuffer: "",
     streamInterval: null,
     activeSessions: normalizeActiveSessions(saved.activeSessions),
+    quarantinedSessions: boundQuarantinedSessions(saved.quarantinedSessions),
     providerSettings: normalizeProviderSettings(saved.providerSettings),
     usageBySession: boundUsageBySession(saved.usageBySession),
     messageQueue: [],
@@ -584,10 +629,10 @@ function seedConversationContinuity(state) {
   if (!isRecord(legacy) || isRecord(state.activeSessions[convo])) return;
   state.activeSessions[convo] = { ...legacy };
   if (isRecord(state.usageBySession)) {
-    const prefix = "Workspace";
+    const prefix = "Workspace\u0000";
     for (const [key, usage] of Object.entries(state.usageBySession)) {
       if (key.startsWith(prefix) && isRecord(usage)) {
-        const moved = `${convo}${key.slice(prefix.length)}`;
+        const moved = `${convo}\u0000${key.slice(prefix.length)}`;
         if (!state.usageBySession[moved]) state.usageBySession[moved] = { ...usage };
       }
     }
@@ -693,6 +738,7 @@ function serializeUserState(state, existing = {}) {
     ...existing,
     currentSession: state.currentSession,
     activeSessions: normalizeActiveSessions(state.activeSessions),
+    quarantinedSessions: boundQuarantinedSessions(state.quarantinedSessions),
     providerSettings: normalizeProviderSettings(state.providerSettings),
     usageBySession: boundUsageBySession(state.usageBySession),
     settings: serializeCommonSettings(state.settings),
@@ -1367,6 +1413,8 @@ module.exports = {
   getProviderSession,
   setProviderSession,
   clearProviderSession,
+  quarantineProviderSession,
+  isSessionQuarantined,
   getProviderSettings,
   getActiveUsage,
   getUsageForSession,

package/core/system-prompt.js

@@ -539,6 +539,23 @@ function consumeLastInjected() {
   return out;
 }
 
+// A Stance line carrying the word LOCKED (uppercase — prose "locked" stays
+// put) is a constraint the user explicitly froze. The branding-font incident
+// showed such a line sitting mid-Stance reads as background prose and gets
+// violated; hoist LOCKED lines under a must-follow header so they carry rule
+// authority in every injection mode.
+function formatStanceSection(stance) {
+  const lines = stance.split("\n");
+  const locked = lines.map((l) => l.trim()).filter((l) => l && /\bLOCKED\b/.test(l));
+  if (!locked.length) return stance;
+  const rest = lines.filter((l) => !/\bLOCKED\b/.test(l)).join("\n").trim();
+  const block = [
+    "BINDING CONSTRAINTS (LOCKED — follow exactly; do not deviate or reinterpret unless the user explicitly unlocks them this turn):",
+    ...locked.map((l) => (/^[-*]/.test(l) ? l : `- ${l}`)),
+  ].join("\n");
+  return rest ? `${block}\n\n${rest}` : block;
+}
+
 function formatPackForContext(pack, packsLib, opts = {}) {
   const extractive = !!opts.extractive;
   const headline = !!opts.headline;
@@ -564,7 +581,7 @@ function formatPackForContext(pack, packsLib, opts = {}) {
   // still used by the classic engine and as the fallback when no lines matched.
   if (extractive) {
     const stance = (pack.sections.Stance || "").trim();
-    if (stance) parts.push(`#### Stance\n${stance}`);
+    if (stance) parts.push(`#### Stance\n${formatStanceSection(stance)}`);
     const stanceLow = stance.toLowerCase();
     const bySection = new Map();
     for (const h of (Array.isArray(opts.matchedLines) ? opts.matchedLines : [])) {
@@ -598,7 +615,7 @@ function formatPackForContext(pack, packsLib, opts = {}) {
       : ["Stance", "Procedure", "State"];
     for (const section of sections) {
       const body = (pack.sections[section] || "").trim();
-      if (body) parts.push(`#### ${section}\n${body}`);
+      if (body) parts.push(`#### ${section}\n${section === "Stance" ? formatStanceSection(body) : body}`);
     }
     if (headline) {
       const hidden = ["State", "Procedure", "Journal"].filter((s) => (pack.sections[s] || "").trim());
@@ -984,7 +1001,25 @@ function voiceReplyGuidance(opts = {}) {
 
 async function buildOptionalRecallContext(prompt, opts = {}) {
   const collector = { packs: [], packDirs: [], entities: [], recall: null };
-  const { userText, contextText } = recallMatchParts(prompt);
+  // Compaction meta-turns: the summarizer's prompt is instructions about
+  // summarizing, so matching packs against it is pure noise — skip recall.
+  // The seed turn is the opposite: it opens a FRESH session, so recall is the
+  // only way the packs active before compaction come back — match on the
+  // runner-supplied recallQuery (condensed brief + open task titles), not the
+  // seed prompt's boilerplate.
+  if (opts.runContext?.purpose === "compact-summary") {
+    return {
+      dynamicContext: "",
+      metadata: { status: "omitted", omitted: true, reason: "compaction_meta_turn" },
+      legacy: collector,
+    };
+  }
+  const queryOverride = typeof opts.runContext?.recallQuery === "string" && opts.runContext.recallQuery.trim()
+    ? opts.runContext.recallQuery
+    : null;
+  const { userText, contextText } = queryOverride
+    ? { userText: stripRecallAnnouncements(queryOverride), contextText: "" }
+    : recallMatchParts(prompt);
   let historyText = "";
   try {
     historyText = stripRecallAnnouncements(require("./transcripts").recentTranscriptText({ limit: 6 }, promptState(opts)));
@@ -1085,12 +1120,17 @@ function createPromptBuilder(dependencies = {}) {
           throw new TypeError("recall builder returned an invalid result");
         }
       } catch (error) {
+        // Fail-open by design (a broken recall must not block the turn), but
+        // never silently: the error goes to the bot log here, and the turn
+        // observer counts consecutive failures and alerts the owner (B5).
+        try { console.error("[recall] builder failed:", error?.message || error); } catch (_) {}
         recallResult = {
           dynamicContext: "",
           metadata: {
             status: "omitted",
             omitted: true,
             reason: "optional_recall_unavailable",
+            detail: String(error?.message || error).slice(0, 200),
           },
           legacy: { packs: [], packDirs: [], entities: [], recall: null },
         };