abmind 0.2.5-alpha.0 → 0.2.6

package/dist/src/sleep/orchestrator.js

@@ -16,10 +16,9 @@
  */
 import { localISO } from "../local-time.js";
 import { getAbmindEnv } from "../env-schema.js";
-import { join, basename, dirname } from "node:path";
+import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { appendFileSync, mkdirSync, existsSync, readdirSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
-import { atomicWriteSync } from "../atomic-write.js";
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { MemoryManager } from "../memory-manager.js";
 import { loadMemoryConfig } from "../memory-config.js";
 import { SleepStateGatherer } from "../sleep-state-gatherer.js";
@@ -27,23 +26,18 @@ import { loadSleepSteps, buildSleepVars, substituteVars } from "../sleep-pipelin
 import { buildDailySummary, writeDailyFile, LLMUnavailableError } from "../sleep-pipeline.js";
 import { extractFromDaily } from "../sleep-pipeline.js";
 import { logInfo, logWarn, logError } from "../mem-logger.js";
-import { redactSecrets } from "../redact-secrets.js";
 import { localDate } from "../local-time.js";
 import { parseLevel, DEFAULT_LEVEL } from "./levels.js";
+import { readStateFile, writeStateFile, runWiredPreTasks, formatWiredResults, fireOnStep } from "./state.js";
+import { buildSnapshotSummary, writeAuditLog } from "./audit.js";
+import { toDateStr, toIsoDate, scanPreviousLocks } from "./locks.js";
+import { redactSecrets } from "../redact-secrets.js";
+import { ModelUnavailableError, LlmBudget, sendWithRetry, DEFAULT_TRANSPORT_RETRY_WINDOW_MS, MAX_RETRIES } from "./llm-budget.js";
+import { runCatchUp } from "./catchup.js";
 const TAG = "abmind-sleep";
-/** Format a timestamp as YYYYMMDD (for lock file names). */
-function toDateStr(ts) {
-    const d = new Date(ts);
-    return `${d.getFullYear()}${String(d.getMonth() + 1).padStart(2, "0")}${String(d.getDate()).padStart(2, "0")}`;
-}
-/** Format a timestamp as YYYY-MM-DD (for daily file paths). */
-function toIsoDate(ts) {
-    const d = new Date(ts);
-    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
-}
 /** Steps whose failure blocks watermark advance. Public so tests can derive reject targets. */
-export const ESSENTIAL_STEPS = new Set(["daily-summary", "extract-memories", "retrospective"]);
-const CATCHUP_MAX_AGE_DAYS = 3;
+// Re-exported from catchup.ts — kept here for backward compat of any direct orchestrator imports.
+export { ESSENTIAL_STEPS } from "./catchup.js";
 /** Thrown by runSleepCycle when memory layer fails to initialize. */
 export class SleepInitError extends Error {
     constructor(message) { super(message); this.name = "SleepInitError"; }
@@ -70,405 +64,9 @@ export function parseArgs(argv) {
     }
     return parsed;
 }
-// getPrimaryUserId moved to SleepDataAccess in memory package
-function readStateFile(path) {
-    try {
-        if (!existsSync(path))
-            return null;
-        const raw = JSON.parse(readFileSync(path, "utf-8"));
-        if (typeof raw !== "object" || raw === null || !raw.steps)
-            return null;
-        // Backfill defaults for legacy lock files
-        if (!raw.status)
-            raw.status = "ongoing";
-        if (raw.llmCalls == null)
-            raw.llmCalls = 0;
-        return raw;
-    }
-    catch {
-        return null;
-    }
-}
-function writeStateFile(path, state) {
-    atomicWriteSync(path, JSON.stringify(state, null, 2));
-}
-// ── Wired pre-tasks (delegated to abmind MaintenanceService) ────────────────
-async function runWiredPreTasks(sleepData, memoryDir, memory) {
-    const r = await memory.maintenance.runPreSleepTasks(memory, sleepData);
-    // Bridge-side: log rotation (not memory's concern)
-    let logsDeleted = 0;
-    try {
-        const logsDir = join(memoryDir, "..", "logs");
-        if (existsSync(logsDir)) {
-            const cutoff = Date.now() - 7 * 86400000;
-            for (const f of readdirSync(logsDir)) {
-                if (!f.startsWith("bridge-") || !f.endsWith(".log"))
-                    continue;
-                const match = f.match(/bridge-(\d{4}-\d{2}-\d{2})\.log/);
-                if (match && new Date(match[1]).getTime() < cutoff) {
-                    unlinkSync(join(logsDir, f));
-                    logsDeleted++;
-                }
-            }
-        }
-    }
-    catch (err) {
-        logWarn(TAG, `[WIRED] log rotation: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    return { purged: r.purged, deduped: r.deduped, embedded: r.embedded, anomaliesFixed: r.anomaliesFixed, walOk: r.walOk, ftsOk: r.ftsOk, logsDeleted };
-}
-function formatWiredResults(r) {
-    const parts = [];
-    if (r.purged > 0)
-        parts.push(`${r.purged} garbage purged`);
-    if (r.deduped > 0)
-        parts.push(`${r.deduped} dupes deleted`);
-    parts.push(`WAL ${r.walOk ? "ok" : "FAILED"}`);
-    parts.push(`FTS ${r.ftsOk ? "ok" : "FAILED"}`);
-    if (r.embedded > 0)
-        parts.push(`${r.embedded} embedded`);
-    if (r.anomaliesFixed > 0)
-        parts.push(`${r.anomaliesFixed} anomalies fixed`);
-    if (r.logsDeleted > 0)
-        parts.push(`${r.logsDeleted} old logs deleted`);
-    return parts.length > 0 ? parts.join(", ") : "nothing to do";
-}
+// ── Subagent invocation ─────────────────────────────────────────────────────
+/** LLM call entry for sleep steps — caller provides the runtime via RunOpts. */
 // ── Transport ───────────────────────────────────────────────────────────────
-// (SleepRuntime is imported at the top of the file.)
-const MAX_RETRIES = 3;
-/** Budget tracker — shared across all sendWithRetry calls in a sleep cycle. */
-class LlmBudget {
-    state;
-    statePath;
-    exhausted = false;
-    constructor(state, statePath) {
-        this.state = state;
-        this.statePath = statePath;
-    }
-    /** Increment counter, return false if budget exhausted. */
-    consume() {
-        this.state.llmCalls = (this.state.llmCalls ?? 0) + 1;
-        writeStateFile(this.statePath, this.state);
-        if (this.state.llmCalls > getAbmindEnv().sleepMaxLlmCalls) {
-            this.exhausted = true;
-            return false;
-        }
-        return true;
-    }
-    get calls() { return this.state.llmCalls ?? 0; }
-}
-async function sendWithRetry(runtime, prompt, stepName, _verbose, budget, delayMs = 6000) {
-    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-        if (budget && !budget.consume()) {
-            logWarn(TAG, `[BUDGET] LLM call limit (${getAbmindEnv().sleepMaxLlmCalls}) reached at step ${stepName} — suspending`);
-            return null;
-        }
-        try {
-            const result = await runtime.complete(prompt);
-            if (!result || !result.trim()) {
-                logWarn(TAG, `Step ${stepName} attempt ${attempt}/${MAX_RETRIES} returned empty response`);
-                if (attempt === MAX_RETRIES) {
-                    logError(TAG, `Step ${stepName} failed after ${MAX_RETRIES} attempts (empty), skipping`);
-                    return null;
-                }
-                if (delayMs > 0)
-                    await new Promise(r => setTimeout(r, delayMs));
-                continue;
-            }
-            return result;
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            logWarn(TAG, `Step ${stepName} attempt ${attempt}/${MAX_RETRIES} failed: ${msg}`);
-            if (attempt === MAX_RETRIES) {
-                logError(TAG, `Step ${stepName} failed after ${MAX_RETRIES} attempts, skipping`);
-                return null;
-            }
-            if (delayMs > 0)
-                await new Promise(r => setTimeout(r, delayMs));
-        }
-    }
-    return null;
-}
-// ── Audit trail helpers ─────────────────────────────────────────────────────
-function buildSnapshotSummary(snapshot) {
-    return [
-        `Working dirs: ${snapshot.workingDirs.length}`,
-        `Messages: ${snapshot.dbStats.messageCount}`,
-        `Embeddings: ${snapshot.dbStats.embeddingCount}`,
-        `Extracted memories: ${snapshot.dbStats.extractedMemoryCount}`,
-        `Disk: ${(snapshot.diskUsageBytes / 1024 / 1024).toFixed(1)} MB / ${(snapshot.diskBudgetBytes / 1024 / 1024).toFixed(0)} MB`,
-        `Topics: ${snapshot.topicFiles.length}`,
-        `FTS5: messages=${snapshot.fts5Health.messages_fts}, extracted=${snapshot.fts5Health.extracted_memories_fts}, original=${snapshot.fts5Health.extracted_memories_original_fts}`,
-    ].join(", ");
-}
-/**
- * Parse outcome counts from the subagent's free-form text response.
- *
- * The subagent response is unstructured text, so we use best-effort regex
- * matching for common patterns like "consolidated 3 files", "pruned 42
- * messages", etc. Returns 0 for any count that can't be parsed.
- */
-function parseOutcomesFromResponse(response) {
-    const defaults = {
-        filesConsolidated: 0,
-        messagesPruned: 0,
-        embeddingsRemoved: 0,
-        sessionsCleaned: 0,
-        topicsMerged: 0,
-        topicsDeleted: 0,
-    };
-    if (!response)
-        return defaults;
-    const text = response.toLowerCase();
-    // Each pattern array contains regexes to try in order for a given outcome.
-    // We take the first match found. Patterns cover both "verb N noun" and
-    // "N noun verb" orderings that an LLM might produce.
-    const patterns = [
-        {
-            key: "filesConsolidated",
-            regexes: [
-                /consolidat\w*\s+(\d+)\s+(?:file|dir|working)/i,
-                /(\d+)\s+(?:file|dir|working\s*dir)\w*\s+consolidat/i,
-                /files?\s+consolidated\s*:\s*(\d+)/i,
-            ],
-        },
-        {
-            key: "messagesPruned",
-            regexes: [
-                /prun\w*\s+(\d+)\s+message/i,
-                /(\d+)\s+message\w*\s+prun/i,
-                /(?:delet|remov)\w*\s+(\d+)\s+message/i,
-                /(\d+)\s+message\w*\s+(?:delet|remov)/i,
-                /messages?\s+pruned\s*:\s*(\d+)/i,
-            ],
-        },
-        {
-            key: "embeddingsRemoved",
-            regexes: [
-                /(?:remov|delet|clean)\w*\s+(\d+)\s+embedding/i,
-                /(\d+)\s+embedding\w*\s+(?:remov|delet|clean)/i,
-                /embeddings?\s+removed\s*:\s*(\d+)/i,
-            ],
-        },
-        {
-            key: "sessionsCleaned",
-            regexes: [
-                /(?:clean|delet|remov)\w*\s+(\d+)\s+session/i,
-                /(\d+)\s+session\w*\s+(?:clean|delet|remov)/i,
-                /sessions?\s+cleaned\s*:\s*(\d+)/i,
-            ],
-        },
-        {
-            key: "topicsMerged",
-            regexes: [
-                /merg\w*\s+(\d+)\s+topic/i,
-                /(\d+)\s+topic\w*\s+merg/i,
-                /topics?\s+merged\s*:\s*(\d+)/i,
-            ],
-        },
-        {
-            key: "topicsDeleted",
-            regexes: [
-                /delet\w*\s+(\d+)\s+topic/i,
-                /(\d+)\s+topic\w*\s+delet/i,
-                /topics?\s+deleted\s*:\s*(\d+)/i,
-            ],
-        },
-    ];
-    for (const { key, regexes } of patterns) {
-        for (const regex of regexes) {
-            const match = text.match(regex);
-            if (match?.[1]) {
-                const parsed = parseInt(match[1], 10);
-                if (!isNaN(parsed) && parsed >= 0) {
-                    defaults[key] = parsed;
-                    break;
-                }
-            }
-        }
-    }
-    return defaults;
-}
-function writeAuditLog(memoryDir, entry) {
-    const sleepDir = join(memoryDir, "sleep");
-    mkdirSync(sleepDir, { recursive: true });
-    const suffix = [
-        ``,
-        `---`,
-        ``,
-        `## CLI Wrapper`,
-        ``,
-        `**Timestamp:** ${entry.timestamp}`,
-        `**Model:** ${entry.model}`,
-        ``,
-        `### State Snapshot`,
-        `${entry.stateSnapshotSummary}`,
-        ``,
-        `### Outcomes`,
-        `- Files consolidated: ${entry.outcomes.filesConsolidated}`,
-        `- Messages pruned: ${entry.outcomes.messagesPruned}`,
-        `- Embeddings removed: ${entry.outcomes.embeddingsRemoved}`,
-        `- Sessions cleaned: ${entry.outcomes.sessionsCleaned}`,
-        `- Topics merged: ${entry.outcomes.topicsMerged}`,
-        `- Topics deleted: ${entry.outcomes.topicsDeleted}`,
-        entry.error ? `\n### Error\n${entry.error}` : "",
-    ].join("\n");
-    // Find the subagent's audit file and append to it
-    const today = localDate().replace(/-/g, "");
-    try {
-        const files = readdirSync(sleepDir)
-            .filter(f => f.startsWith(`sleep_${today}`) && f.endsWith(".md"))
-            .sort();
-        if (files.length > 0) {
-            const target = join(sleepDir, files[files.length - 1]);
-            const existingLines = readFileSync(target, "utf-8").split("\n").length;
-            if (existingLines < 50) {
-                logWarn(TAG, `Sleep audit suspiciously short (${existingLines} lines) — subagent may have truncated`);
-            }
-            appendFileSync(target, redactSecrets(suffix), "utf-8");
-            return;
-        }
-    }
-    catch { /* fall through to standalone */ }
-    // Fallback: no subagent file found — write standalone
-    const now = new Date();
-    const dateStr = localDate().replace(/-/g, "");
-    const timeStr = now.toTimeString().slice(0, 5).replace(/:/g, "");
-    const filename = `sleep_${dateStr}_${timeStr}.md`;
-    writeFileSync(join(sleepDir, filename), redactSecrets(`# Sleep Audit Log${suffix}`), "utf-8");
-}
-function scanPreviousLocks(sleepDir, todayStr) {
-    if (!existsSync(sleepDir))
-        return [];
-    const locks = [];
-    const todayMs = dateStrToMs(todayStr);
-    for (const f of readdirSync(sleepDir)) {
-        const m = f.match(/^sleep_(\d{8})\.lock$/);
-        if (!m || m[1] === todayStr)
-            continue;
-        const state = readStateFile(join(sleepDir, f));
-        if (!state)
-            continue;
-        const ageDays = Math.round((todayMs - dateStrToMs(m[1])) / 86400000);
-        if (ageDays > 0)
-            locks.push({ path: join(sleepDir, f), dateStr: m[1], state, ageDays });
-    }
-    return locks.sort((a, b) => b.dateStr.localeCompare(a.dateStr)); // newest first
-}
-function dateStrToMs(ds) {
-    return new Date(`${ds.slice(0, 4)}-${ds.slice(4, 6)}-${ds.slice(6, 8)}T00:00:00`).getTime();
-}
-function dateStrToFormatted(ds) {
-    return `${ds.slice(0, 4)}-${ds.slice(4, 6)}-${ds.slice(6, 8)}`;
-}
-function failedEssentials(state) {
-    const failed = [];
-    for (const name of ESSENTIAL_STEPS) {
-        const s = state.steps[name];
-        if (!s || s.status === "failed" || s.status === "timeout" || s.status === "pending") {
-            failed.push(name);
-        }
-    }
-    return failed;
-}
-async function runCatchUp(locks, sleepData, memoryConfig, steps, flags, runtime, budget, retryDelayMs = 6000) {
-    for (const lock of locks) {
-        if (lock.ageDays > CATCHUP_MAX_AGE_DAYS) {
-            logError(TAG, `[CATCH-UP] Abandoning stale lock ${basename(lock.path)} — ${lock.ageDays} days old, data unrecoverable`);
-            unlinkSync(lock.path);
-            continue;
-        }
-        const needed = failedEssentials(lock.state);
-        if (needed.length === 0) {
-            logInfo(TAG, `[CATCH-UP] Cleaning up completed lock ${basename(lock.path)}`);
-            unlinkSync(lock.path);
-            continue;
-        }
-        logInfo(TAG, `[CATCH-UP] ${basename(lock.path)} — recovering: ${needed.join(", ")}`);
-        // 04a — daily summary with date-range
-        if (needed.includes("daily-summary")) {
-            const start = Date.now();
-            try {
-                const ctxWindow = getAbmindEnv().sleepCtxWindow;
-                const userId = sleepData.getPrimaryUserId();
-                const dayStart = dateStrToMs(lock.dateStr);
-                const dayEnd = dayStart + 86400000;
-                const summary = await buildDailySummary(sleepData.getDb(), (p) => sendWithRetry(runtime, p, "catch-up-04a", flags.verbose, budget, retryDelayMs).then(r => { if (r === null)
-                    throw new LLMUnavailableError(); return r; }), {
-                    ctxWindow, memoryDir: memoryConfig.memoryDir, userId, watermarkTs: 0,
-                    dateRange: { startTs: dayStart, endTs: dayEnd },
-                });
-                if (summary) {
-                    writeDailyFile(memoryConfig.memoryDir, dateStrToFormatted(lock.dateStr), summary);
-                    lock.state.steps["daily-summary"] = { status: "ok", duration: Math.round((Date.now() - start) / 100) / 10 };
-                }
-                else {
-                    lock.state.steps["daily-summary"] = { status: "skipped" };
-                }
-                logInfo(TAG, `[CATCH-UP] ✓ 04a-daily-summary for ${lock.dateStr} (${((Date.now() - start) / 1000).toFixed(1)}s)`);
-            }
-            catch (err) {
-                logWarn(TAG, `[CATCH-UP] ✗ 04a-daily-summary for ${lock.dateStr}: ${err instanceof Error ? err.message : String(err)}`);
-                lock.state.steps["daily-summary"] = { status: "failed", duration: Math.round((Date.now() - start) / 100) / 10 };
-            }
-            writeStateFile(lock.path, lock.state);
-        }
-        // 04b — extract memories from daily (needs daily file to exist)
-        if (needed.includes("extract-memories")) {
-            const dailyPath = join(memoryConfig.memoryDir, "daily", `daily_${dateStrToFormatted(lock.dateStr)}.md`);
-            if (!existsSync(dailyPath)) {
-                logInfo(TAG, `[CATCH-UP] ⏭ 04b — no daily file for ${lock.dateStr}`);
-                lock.state.steps["extract-memories"] = { status: "skipped" };
-            }
-            else {
-                const start = Date.now();
-                try {
-                    const userId = sleepData.getPrimaryUserId();
-                    const result = await extractFromDaily(dailyPath, userId, (p) => sendWithRetry(runtime, p, "catch-up-04b", flags.verbose, budget, retryDelayMs).then(r => { if (r === null)
-                        throw new LLMUnavailableError(); return r; }));
-                    lock.state.steps["extract-memories"] = { status: "ok", duration: Math.round((Date.now() - start) / 100) / 10 };
-                    logInfo(TAG, `[CATCH-UP] ✓ 04b-extract-memories for ${lock.dateStr} (${((Date.now() - start) / 1000).toFixed(1)}s) — ${result.slice(0, 80)}`);
-                }
-                catch (err) {
-                    logWarn(TAG, `[CATCH-UP] ✗ 04b for ${lock.dateStr}: ${err instanceof Error ? err.message : String(err)}`);
-                    lock.state.steps["extract-memories"] = { status: "failed", duration: Math.round((Date.now() - start) / 100) / 10 };
-                }
-            }
-            writeStateFile(lock.path, lock.state);
-        }
-        // Prompt-driven essentials (retrospective — now includes extraction)
-        for (const stepName of ["retrospective"]) {
-            if (!needed.includes(stepName))
-                continue;
-            const step = steps.find(s => s.name === stepName);
-            if (!step) {
-                logWarn(TAG, `[CATCH-UP] Step file not found: ${stepName}`);
-                continue;
-            }
-            const start = Date.now();
-            const response = await sendWithRetry(runtime, step.rawPrompt, `catch-up-${stepName}`, flags.verbose, budget, retryDelayMs);
-            if (response) {
-                lock.state.steps[stepName] = { status: "ok", duration: Math.round((Date.now() - start) / 100) / 10 };
-                logInfo(TAG, `[CATCH-UP] ✓ ${stepName} (${((Date.now() - start) / 1000).toFixed(1)}s)`);
-            }
-            else {
-                lock.state.steps[stepName] = { status: "failed", duration: Math.round((Date.now() - start) / 100) / 10 };
-                logWarn(TAG, `[CATCH-UP] ✗ ${stepName}`);
-            }
-            writeStateFile(lock.path, lock.state);
-        }
-        // Final check: all essentials recovered?
-        const stillFailing = failedEssentials(lock.state);
-        if (stillFailing.length === 0) {
-            logInfo(TAG, `[CATCH-UP] ✅ ${basename(lock.path)} — all essentials recovered, lock deleted`);
-            unlinkSync(lock.path);
-        }
-        else {
-            logWarn(TAG, `[CATCH-UP] ${basename(lock.path)} — still failing: ${stillFailing.join(", ")} (failing ${lock.ageDays} day(s))`);
-        }
-    }
-}
 // ── Main orchestration ──────────────────────────────────────────────────────
 /**
  * Run the full sleep cycle. Extracted from main() for testability (#175).
@@ -484,6 +82,8 @@ export async function runSleepCycle(opts) {
     const timeoutMs = opts.timeoutMs ?? getAbmindEnv().sleepTimeoutMin * 60 * 1000;
     const backoffMs = opts.backoffMs ?? ((n) => [10, 30, 60][Math.min(n, 2)] * 1000);
     const retryDelayMs = opts.retryDelayMs ?? 6000;
+    const transportBackoffMs = opts.transportBackoffMs ?? ((n) => Math.min(30_000 * Math.pow(2, n - 1), 120_000));
+    const transportRetryWindowMs = opts.transportRetryWindowMs ?? DEFAULT_TRANSPORT_RETRY_WINDOW_MS;
     const runtime = opts.runtime;
     if (flags.verbose) {
         logInfo(TAG, "Verbose mode enabled");
@@ -641,6 +241,13 @@ export async function runSleepCycle(opts) {
         const snapshotVars = buildSleepVars(snapshot);
         for (const [k, v] of Object.entries(snapshotVars))
             vars[k] = vars[k] ?? v;
+        // #895: Fire onCycleStart once before the first step — hosts use this to
+        // create a stepped card or reset per-night state. fireOnStep() already
+        // swallows handler errors so a misbehaving host can never break the cycle.
+        try {
+            opts.onCycleStart?.({ totalSteps: steps.length });
+        }
+        catch { /* host display only */ }
         // Progress protocol — emit PROGRESS:<pct>:<label> on stdout
         const totalSteps = steps.length;
         let stepIndex = 0;
@@ -754,7 +361,7 @@ export async function runSleepCycle(opts) {
             const previousLocks = scanPreviousLocks(sleepDir, dateStr);
             if (previousLocks.length > 0) {
                 logInfo(TAG, `[CATCH-UP] Found ${previousLocks.length} previous lock(s)`);
-                await runCatchUp(previousLocks, sleepData, memoryConfig, steps, flags, runtime, budget, retryDelayMs);
+                await runCatchUp(previousLocks, sleepData, memoryConfig, steps, flags, runtime, budget, retryDelayMs, opts.onStep);
             }
             // Housekeeping: move misplaced daily/consolidation_* to weekly/ (#640)
             try {
@@ -799,13 +406,19 @@ export async function runSleepCycle(opts) {
                 }
                 emitProgress(step.name);
                 stepIndex++;
+                // #895: "start" fires once per step (before skip checks) so every step
+                // emits exactly one start + one terminal (done/skipped/failed). Display-only,
+                // best-effort — a throwing handler never breaks the cycle.
+                fireOnStep(opts.onStep, { name: step.name, filename: step.filename, index: stepIndex, total: totalSteps, phase: "start" });
                 // Resume: skip already completed steps
                 if (isResume && existingState?.steps[step.name]?.status === "ok") {
                     logInfo(TAG, `[SLEEP] ⏭ ${step.name} — already done (resume)`);
+                    fireOnStep(opts.onStep, { name: step.name, filename: step.filename, index: stepIndex, total: totalSteps, phase: "skipped" });
                     continue;
                 }
                 if (isResume && existingState?.steps[step.name]?.status === "skipped") {
                     logInfo(TAG, `[SLEEP] ⏭ ${step.name} — skipped (resume)`);
+                    fireOnStep(opts.onStep, { name: step.name, filename: step.filename, index: stepIndex, total: totalSteps, phase: "skipped" });
                     continue;
                 }
                 // Skip logic (essential steps always run)
@@ -813,6 +426,7 @@ export async function runSleepCycle(opts) {
                     logInfo(TAG, `[SLEEP] ⏭ ${step.name} — skipped`);
                     state.steps[step.name] = { status: "skipped" };
                     writeStateFile(statePath, state);
+                    fireOnStep(opts.onStep, { name: step.name, filename: step.filename, index: stepIndex, total: totalSteps, phase: "skipped" });
                     continue;
                 }
                 const start = Date.now();
@@ -829,7 +443,7 @@ export async function runSleepCycle(opts) {
                         const firstMsgTs = sleepData.getFirstMessageAfter(userId, watermarkTs);
                         const firstMsgDate = firstMsgTs ? new Date(firstMsgTs) : new Date(now());
                         const targetDate = `${firstMsgDate.getFullYear()}-${String(firstMsgDate.getMonth() + 1).padStart(2, "0")}-${String(firstMsgDate.getDate()).padStart(2, "0")}`;
-                        const summary = await buildDailySummary(sleepData.getDb(), (p) => sendWithRetry(runtime, p, "daily-summary", flags.verbose, budget, retryDelayMs).then(r => { if (r === null)
+                        const summary = await buildDailySummary(sleepData.getDb(), (p) => sendWithRetry(runtime, p, "daily-summary", flags.verbose, budget, retryDelayMs, transportBackoffMs, transportRetryWindowMs, now).then(r => { if (r === null)
                             throw new LLMUnavailableError(); return r; }), {
                             ctxWindow, memoryDir: memoryConfig.memoryDir, userId, watermarkTs,
                         });
@@ -846,9 +460,30 @@ export async function runSleepCycle(opts) {
                         logWarn(TAG, `[SLEEP] 04a failed: ${err instanceof Error ? err.message : String(err)}`);
                         state.steps[step.name] = { status: "failed", duration: Math.round((Date.now() - start) / 100) / 10 };
                         dreamySucceeded = false;
+                        writeStateFile(statePath, state);
+                        fireOnStep(opts.onStep, { name: step.name, filename: step.filename, index: stepIndex, total: totalSteps, phase: "failed" });
+                        if (err instanceof ModelUnavailableError) {
+                            logWarn(TAG, `[SLEEP] ${step.name} — model unavailable, stopping cycle (not advancing to next phase)`);
+                            break;
+                        }
+                    }
+                    if (state.steps[step.name]?.status !== "failed") {
+                        // success/skip path: persist state + log + fire event
+                        writeStateFile(statePath, state);
                     }
-                    writeStateFile(statePath, state);
                     logInfo(TAG, `[SLEEP] ${state.steps[step.name]?.status === "ok" ? "✓" : "✗"} ${step.name} (${((Date.now() - start) / 1000).toFixed(1)}s)`);
+                    // #895: emit terminal event for code-driven daily-summary (failure already fired in catch)
+                    if (state.steps[step.name]?.status !== "failed") {
+                        fireOnStep(opts.onStep, {
+                            name: step.name,
+                            filename: step.filename,
+                            index: stepIndex,
+                            total: totalSteps,
+                            phase: state.steps[step.name]?.status === "ok" ? "done"
+                                : state.steps[step.name]?.status === "skipped" ? "skipped"
+                                    : "failed",
+                        });
+                    }
                     continue;
                 }
                 if (step.name === "extract-memories") {
@@ -866,11 +501,13 @@ export async function runSleepCycle(opts) {
                         state.steps[step.name] = { status: "skipped" };
                         writeStateFile(statePath, state);
                         logInfo(TAG, `[SLEEP] ⏭ ${step.name} — no daily summary`);
+                        // #895: emit skip when there's no daily summary to extract from
+                        fireOnStep(opts.onStep, { name: step.name, filename: step.filename, index: stepIndex, total: totalSteps, phase: "skipped" });
                         continue;
                     }
                     try {
                         const userId = sleepData.getPrimaryUserId();
-                        const result = await extractFromDaily(dailySummaryPath, userId, (p) => sendWithRetry(runtime, p, "04b-extract", flags.verbose, budget, retryDelayMs).then(r => { if (r === null)
+                        const result = await extractFromDaily(dailySummaryPath, userId, (p) => sendWithRetry(runtime, p, "04b-extract", flags.verbose, budget, retryDelayMs, transportBackoffMs, transportRetryWindowMs, now).then(r => { if (r === null)
                             throw new LLMUnavailableError(); return r; }));
                         state.steps[step.name] = { status: "ok", duration: Math.round((Date.now() - start) / 100) / 10 };
                         writeFileSync(join(stepLogDir, `${String(stepIndex).padStart(2, "0")}-${step.name}.md`), redactSecrets(result), "utf-8");
@@ -880,8 +517,24 @@ export async function runSleepCycle(opts) {
                         logWarn(TAG, `[SLEEP] 04b failed: ${err instanceof Error ? err.message : String(err)}`);
                         state.steps[step.name] = { status: "failed", duration: Math.round((Date.now() - start) / 100) / 10 };
                         dreamySucceeded = false;
+                        writeStateFile(statePath, state);
+                        fireOnStep(opts.onStep, { name: step.name, filename: step.filename, index: stepIndex, total: totalSteps, phase: "failed" });
+                        if (err instanceof ModelUnavailableError) {
+                            logWarn(TAG, `[SLEEP] ${step.name} — model unavailable, stopping cycle (not advancing to next phase)`);
+                            break;
+                        }
+                    }
+                    if (state.steps[step.name]?.status !== "failed") {
+                        writeStateFile(statePath, state);
+                        // #895: emit terminal event for code-driven extract-memories (failure already fired in catch)
+                        fireOnStep(opts.onStep, {
+                            name: step.name,
+                            filename: step.filename,
+                            index: stepIndex,
+                            total: totalSteps,
+                            phase: state.steps[step.name]?.status === "ok" ? "done" : "failed",
+                        });
                     }
-                    writeStateFile(statePath, state);
                     continue;
                 }
                 // Standard prompt-driven step — JIT substitution
@@ -896,6 +549,8 @@ export async function runSleepCycle(opts) {
                             state.steps[step.name] = { status: "skipped" };
                             writeStateFile(statePath, state);
                             logInfo(TAG, `[SLEEP] ⏭ ${step.name} — no new extractions today`);
+                            // #895: emit skip when there's no work for contradiction-and-graph
+                            fireOnStep(opts.onStep, { name: step.name, filename: step.filename, index: stepIndex, total: totalSteps, phase: "skipped" });
                             continue;
                         }
                         vars.NEW_EXTRACTIONS = newRows.map(r => `[id=${r.id}] (${r.memory_type}, trust=${r.trust}) ${r.content_en}`).join("\n");
@@ -925,6 +580,8 @@ export async function runSleepCycle(opts) {
                         logWarn(TAG, `[SLEEP] contradiction-and-graph var prep failed: ${err instanceof Error ? err.message : String(err)}`);
                         state.steps[step.name] = { status: "skipped" };
                         writeStateFile(statePath, state);
+                        // #895: emit skip on var-prep failure
+                        fireOnStep(opts.onStep, { name: step.name, filename: step.filename, index: stepIndex, total: totalSteps, phase: "skipped" });
                         continue;
                     }
                 }
@@ -937,6 +594,8 @@ export async function runSleepCycle(opts) {
                             state.steps[step.name] = { status: "skipped" };
                             writeStateFile(statePath, state);
                             logInfo(TAG, `[SLEEP] ⏭ ${step.name} — not enough memories for REM`);
+                            // #895: emit skip when not enough memories for REM
+                            fireOnStep(opts.onStep, { name: step.name, filename: step.filename, index: stepIndex, total: totalSteps, phase: "skipped" });
                             continue;
                         }
                         vars.REM_SAMPLE = sample.map(r => `[${r.memory_type}, ${new Date(r.created_at).toISOString().slice(0, 10)}] ${r.content_en}`).join("\n");
@@ -944,6 +603,8 @@ export async function runSleepCycle(opts) {
                     catch {
                         state.steps[step.name] = { status: "skipped" };
                         writeStateFile(statePath, state);
+                        // #895: emit skip on var-prep failure for rem-synthesis
+                        fireOnStep(opts.onStep, { name: step.name, filename: step.filename, index: stepIndex, total: totalSteps, phase: "skipped" });
                         continue;
                     }
                 }
@@ -952,7 +613,22 @@ export async function runSleepCycle(opts) {
                 if (soulPrefix)
                     soulPrefix = ""; // only prepend to first step
                 const ctxBefore = -1;
-                const response = await sendWithRetry(runtime, fullPrompt, step.name, flags.verbose, budget, retryDelayMs);
+                let response;
+                try {
+                    response = await sendWithRetry(runtime, fullPrompt, step.name, flags.verbose, budget, retryDelayMs, transportBackoffMs, transportRetryWindowMs, now);
+                }
+                catch (err) {
+                    if (err instanceof ModelUnavailableError) {
+                        const duration = Date.now() - start;
+                        logWarn(TAG, `[SLEEP] ${step.name} — model unavailable, stopping cycle (not advancing to next phase)`);
+                        state.steps[step.name] = { status: "failed", duration: Math.round(duration / 100) / 10, ctxBefore, ctxAfter: -1 };
+                        dreamySucceeded = false;
+                        writeStateFile(statePath, state);
+                        fireOnStep(opts.onStep, { name: step.name, filename: step.filename, index: stepIndex, total: totalSteps, phase: "failed" });
+                        break;
+                    }
+                    throw err;
+                }
                 const ctxAfter = -1;
                 const duration = Date.now() - start;
                 if (response) {
@@ -1005,6 +681,14 @@ export async function runSleepCycle(opts) {
                     dreamySucceeded = false;
                 }
                 writeStateFile(statePath, state);
+                // #895: emit terminal event for the standard prompt-driven step
+                fireOnStep(opts.onStep, {
+                    name: step.name,
+                    filename: step.filename,
+                    index: stepIndex,
+                    total: totalSteps,
+                    phase: response ? "done" : "failed",
+                });
                 logInfo(TAG, `[SLEEP] ${response ? "✓" : "✗"} ${step.name} (${(duration / 1000).toFixed(1)}s, ${response?.length ?? 0} chars)`);
                 // Backoff between steps: 10s → 30s → 60s on consecutive failures, reset on success
                 if (response) {