onadit 0.0.1 → 1.0.0

package/dist/src/cli/status/friend-header.js

@@ -0,0 +1,727 @@
+import { formatOnboardingDuration } from "../../observability/onboarding-metric.js";
+import { REINSTALL_COMMAND, RIFT_DOWNLOAD_URL } from "../../diagnostics/install-layout.js";
+import { renamePreviousToolNames } from "../../mcp/names.js";
+export function renderFriendHeader(input) {
+    const { status } = input;
+    const now = input.now ? input.now() : Date.now();
+    const lines = [];
+    if (!status) {
+        lines.push("Onadit  ·  daemon: unreachable");
+        lines.push("Next:        run: launchctl kickstart -k gui/$UID/com.getrift.daemon");
+        return lines;
+    }
+    // Derive when the current daemon process started so we can tell
+    // "happened during this uptime" from "historical error from a prior
+    // run." Without this, a 20h-old schema_mismatch keeps advertising
+    // "broken" in the Next: line for a full 24h after a perfectly
+    // healthy respawn.
+    const daemonStartMs = now - status.daemon.uptime_seconds * 1000;
+    // 1. version + daemon
+    lines.push(`Onadit v${status.build.version}  ·  daemon: running (uptime ${formatDuration(status.daemon.uptime_seconds)})  ·  port ${status.daemon.port}${status.daemon.voyage_key_present ? " ✓" : status.daemon.capture_enabled ? " ✗" : ""}`);
+    // 2. voyage
+    lines.push(renderVoyageLine(input, now));
+    // 3. index — distinct from voyage: an embed can succeed but the
+    // downstream LanceDB write can still fail (schema, lock, IO).
+    // Without this line the user has no signal that "embedded" does not
+    // imply "searchable yet".
+    lines.push(renderIndexLine(status.index, now));
+    // 4. inbox — surfaces drop-folder freshness. Distinct from index:
+    // a watcher-fed write can succeed at the index lane without ever
+    // having processed an inbox file. This line is the user-visible
+    // confirmation that the inbox path itself is wired up and current.
+    lines.push(renderInboxLine(status.inbox, now));
+    const memoryLine = renderMemoryLine(status);
+    if (memoryLine)
+        lines.push(memoryLine);
+    // 5. codex
+    lines.push(renderCodexLine(status.codex, now));
+    const modelSwitchLine = renderCodexModelSwitchLine(status.codex, now);
+    if (modelSwitchLine)
+        lines.push(modelSwitchLine);
+    // 6. capture — when the daemon's own scheduled loop is failing but a
+    //    manual run is working, split into "what works now" (the manual run)
+    //    plus an honest "Automatic:" advisory, so a manual success never
+    //    paints the scheduled loop green. Collapses back to one line once the
+    //    daemon records a healthy run.
+    const daemonCaptureStale = isDaemonCaptureStale(status.capture, daemonStartMs);
+    lines.push(renderCaptureLine(status, now, daemonCaptureStale));
+    const automaticCaptureLine = renderAutomaticCaptureLine(status.capture, now, daemonCaptureStale);
+    if (automaticCaptureLine)
+        lines.push(automaticCaptureLine);
+    const cursorLine = renderCursorLine(status.capture);
+    if (cursorLine)
+        lines.push(cursorLine);
+    const coworkLine = renderCoworkLine(status.capture);
+    if (coworkLine)
+        lines.push(coworkLine);
+    if (status.capture.grok_cli) {
+        lines.push(status.capture.grok_cli.scheduled
+            ? "Grok CLI:    opt-in capture on — existing and new local CLI sessions are eligible"
+            : "Grok CLI:    opt-in — run onadit onboard --enable-grok-capture (existing and new local CLI sessions)");
+    }
+    // 6b. local AI apps — honest source-coverage boundary. Onadit auto-captures the
+    //     CLI agents (Claude Code, Codex CLI); the desktop/web chat apps keep
+    //     their history server-side, so those chats need export → onadit import.
+    //     Shown ONLY when such an app is actually installed, so the line targets
+    //     the users who would otherwise assume "auto-capture" covers everything.
+    const localAiAppsLine = renderLocalAiAppsLine(input.localAiApps);
+    if (localAiAppsLine)
+        lines.push(localAiAppsLine);
+    // 7. MCP
+    lines.push(renderMcpLine(input.mcpClients));
+    // 7b. menu bar — only when probed (macOS) AND SwiftBar is absent. The plugin
+    //     is installed but the app that draws the icon is missing, so `status`
+    //     surfaces the same "menu can't show" warning `doctor` does instead of
+    //     leaving a silently-missing icon undiagnosed. Installed/unprobed stays
+    //     quiet so a healthy install never grows a noise line.
+    const swiftBarLine = renderSwiftBarLine(input.swiftBar);
+    if (swiftBarLine)
+        lines.push(swiftBarLine);
+    // 8. feedback
+    lines.push(`Feedback:    ${renderFeedbackLine(status.feedback)}`);
+    // 9. update — surfaced only when the daemon's last probe found a
+    //    newer beta. Probe failures and up-to-date installs print nothing
+    //    so npm reachability cannot make Onadit look broken.
+    const updateLine = renderUpdateLine(status.update);
+    if (updateLine)
+        lines.push(updateLine);
+    // 10. onboarding — `time_to_first_useful_recall`. Hidden state prints
+    //     nothing so a fresh post-onboard install never shows a stale
+    //     placeholder. Pending shows the in-flight wait; completed shows
+    //     the captured duration + the MCP tool that closed it.
+    const onboardingLine = renderOnboardingLine(status.onboarding, now);
+    if (onboardingLine)
+        lines.push(onboardingLine);
+    lines.push("");
+    lines.push(`Next:        ${decideNextLine({ status, mcpClients: input.mcpClients, daemonStartMs })}`);
+    return lines;
+}
+/**
+ * True only when `iso` parses to a timestamp after the daemon's current
+ * start. Historical errors that predate the running process are not
+ * current and must not drive the Next: nudge — a friend with a healthy
+ * respawned daemon would otherwise see "broken, file feedback" for the
+ * full 24h window every error class keeps.
+ */
+function isCurrentUptime(iso, daemonStartMs) {
+    if (!iso)
+        return false;
+    const ts = Date.parse(iso);
+    if (Number.isNaN(ts))
+        return false;
+    return ts >= daemonStartMs;
+}
+/**
+ * Translate internal error class names into copy a friend can act on.
+ * Falls back to the raw class so new/unknown values still surface
+ * (better an unfamiliar word than a missing one).
+ */
+function humanizeErrorClass(reason) {
+    if (!reason)
+        return "unknown";
+    switch (reason) {
+        case "schema_mismatch":
+            return "index format changed by update";
+        case "lock_conflict":
+            return "index busy (concurrent write)";
+        case "provider_400":
+            return "embedding rejected by Voyage";
+        case "network":
+            return "network error";
+        default:
+            return reason;
+    }
+}
+function renderFeedbackLine(feedback) {
+    if (feedback.relay_enabled) {
+        return "relay on (local JSONL + Clem-side relay)";
+    }
+    if (feedback.contact_opted_in) {
+        // Opted in for updates, but no relay endpoint is wired yet — be honest
+        // that nothing is transmitting, without telling them to "opt in" again.
+        return "opted in — stays local until the feedback relay is live";
+    }
+    return "relay off (local JSONL only) — opt in via onadit onboard";
+}
+function renderUpdateLine(update) {
+    if (!update.available)
+        return null;
+    if (!update.latest_beta)
+        return null;
+    return `Update:      available ${update.installed} → ${update.latest_beta} — ${updateAction(update)}`;
+}
+/**
+ * The action to upgrade, chosen by install layout. A packaged (.pkg) install
+ * can't self-update (`onadit update` refuses it), so it gets the .pkg download;
+ * only an explicit `false` flips it, so an older daemon that predates the flag
+ * (`undefined`) keeps the historical `onadit update` advice. Shared by the
+ * Update line and the "what to do next" summary so they never disagree.
+ */
+function updateAction(update) {
+    if (update.reinstall_needed)
+        return `run the installer again: ${REINSTALL_COMMAND}`;
+    return update.self_update_supported === false
+        ? `download the latest .pkg: ${RIFT_DOWNLOAD_URL}`
+        : "run: onadit update";
+}
+function renderVoyageLine(input, now) {
+    const { status, voyageLast4 } = input;
+    if (!status)
+        return "Voyage:      unknown";
+    if (!status.daemon.voyage_key_present) {
+        // No key is an intentional local mode, not a fault: keyword (lexical)
+        // search is fully on; only semantic search is off. We only nudge toward a
+        // Voyage key when a feature that actually needs one (auto-capture) is
+        // enabled — otherwise the line must read as "working as configured."
+        return status.daemon.capture_enabled
+            ? "Search:      keyword on, semantic off — auto-capture needs a Voyage key: onadit onboard --reconfigure-voyage"
+            : "Search:      keyword on · semantic off (no Voyage key — local mode)";
+    }
+    const last4 = voyageLast4 ? `last 4 …${voyageLast4}` : "key valid";
+    const labelSuffix = status.voyage.project_label
+        ? ` · label ${status.voyage.project_label}`
+        : "";
+    const embedSuffix = status.voyage.last_embed_at
+        ? `, last embed ${formatAge(status.voyage.last_embed_at, now)}`
+        : "";
+    const errorSuffix = status.voyage.last_error_at
+        ? ` · last error ${formatAge(status.voyage.last_error_at, now)} (${status.voyage.last_error_reason ?? "unknown"})`
+        : "";
+    return `Voyage:      key valid (${last4}${embedSuffix})${labelSuffix}${errorSuffix}`;
+}
+function renderIndexLine(index, now) {
+    if (index.last_update_at === null && index.last_error_at === null) {
+        return "Index:       no writes yet";
+    }
+    const updateSuffix = index.last_update_at
+        ? `last update ${formatAge(index.last_update_at, now)}`
+        : "no writes yet";
+    const errorSuffix = index.last_error_at
+        ? ` · last error ${formatAge(index.last_error_at, now)} (${index.last_error_reason ?? "unknown"})`
+        : "";
+    return `Index:       ${updateSuffix}${errorSuffix}`;
+}
+function renderInboxLine(inbox, now) {
+    // Older daemons (pre-this-slice) don't ship an `inbox` block. Treat
+    // the missing block exactly as "idle" — the line stays present and
+    // the CLI never crashes on a cross-version mismatch.
+    if (!inbox ||
+        (inbox.last_import_at === null &&
+            inbox.last_error_at === null &&
+            inbox.pending === 0)) {
+        // A command, not a folder: a relative path means nothing to a reader who
+        // does not know where Onadit keeps its data.
+        return "Inbox:       empty — to add a chat export: onadit import <file> --source <name>";
+    }
+    const parts = [];
+    if (inbox.last_import_at) {
+        parts.push(`last import ${formatAge(inbox.last_import_at, now)}`);
+    }
+    if (inbox.pending > 0) {
+        parts.push(`${inbox.pending} pending`);
+    }
+    const head = parts.length > 0 ? parts.join(" · ") : "idle";
+    const errorSuffix = inbox.last_error_at
+        ? ` · last error ${formatAge(inbox.last_error_at, now)} (${inbox.last_error_reason ?? "unknown"})`
+        : "";
+    return `Inbox:       ${head}${errorSuffix}`;
+}
+function renderMemoryLine(status) {
+    const memory = status.memory;
+    if (!memory?.counts)
+        return null;
+    const counts = memory.counts;
+    const docsPart = `docs ${counts.structured_docs}${counts.structured_docs === 0 ? ` (${documentReason(memory.documents.status)})` : ""}`;
+    // Digests are an optional extra on top of the stored conversations.
+    // "digests 0 (AI enrichment off)" was relayed as "Onadit is not writing
+    // summaries", so a lane that is simply not in use is not listed.
+    const digestsInUse = counts.digests > 0 ||
+        (memory.digests.status !== "unavailable_basic" && memory.digests.status !== "unavailable_claude");
+    const parts = [`${counts.conversations.toLocaleString("en-US")} conversations`];
+    if (digestsInUse) {
+        parts.push(`digests ${counts.digests}${counts.digests === 0 ? ` (${digestReason(memory.digests.status)})` : ""}`);
+    }
+    parts.push(docsPart);
+    return `Memory:      ${parts.join(" · ")}`;
+}
+function digestReason(status) {
+    switch (status) {
+        case "unavailable_basic":
+            return "AI enrichment off";
+        case "unavailable_claude":
+            return "Claude digests not shipped";
+        case "unavailable_worker":
+            return "digest worker unavailable";
+        case "available_not_run":
+            return "none yet";
+        case "unknown":
+            return "unknown";
+        case "indexed":
+            return "indexed";
+    }
+}
+function documentReason(status) {
+    switch (status) {
+        case "not_configured":
+            return "no sources";
+        case "source_missing":
+            return "source missing";
+        case "source_empty":
+            return "source empty";
+        case "embedding_unavailable":
+            return "Voyage key missing";
+        case "backfill_needed":
+            return "backfill needed";
+        case "unknown":
+            return "unknown";
+        case "indexed":
+            return "indexed";
+    }
+}
+function renderCodexLine(codex, now) {
+    // Claude-Code triage worker: a wholly separate label + remedy set. The Codex
+    // copy below is left byte-for-byte unchanged.
+    if (codex.last_preflight_worker === "claude") {
+        return renderClaudeLine(codex, now);
+    }
+    if (codex.last_preflight_at === null) {
+        return "Codex CLI:   not checked yet — auto-capture has not run";
+    }
+    if (codex.last_preflight_ok === true) {
+        return `Codex CLI:   authed ✓ (last checked: ${formatAge(codex.last_preflight_at, now)})`;
+    }
+    const checked = `last checked: ${formatAge(codex.last_preflight_at, now)}`;
+    if (codex.last_preflight_error_class === "auth") {
+        return `Codex CLI:   auth expired ✗ (${checked}) — run: codex login`;
+    }
+    // Not auth — say what actually failed and don't nag about login.
+    const summary = codex.last_preflight_error_summary ?? "Codex preflight failed.";
+    return `Codex CLI:   probe failing ✗ (${checked}) — ${summary}`;
+}
+/**
+ * Says so when Onadit moved capture to another Codex model because Codex
+ * refused the old one (shown for a week). When the refused model is the one
+ * in `codex_cli.model`, that setting is now ignored, so point at it.
+ */
+function renderCodexModelSwitchLine(codex, now) {
+    const modelSwitch = codex.model_switch;
+    if (!modelSwitch || codex.last_preflight_worker === "claude") {
+        return null;
+    }
+    const line = `Codex model: switched to ${modelSwitch.to} ${formatAge(modelSwitch.at, now)}` +
+        ` — Codex no longer accepts ${modelSwitch.from}`;
+    return modelSwitch.from_config
+        ? `${line} · update codex_cli.model in config.json`
+        : line;
+}
+/**
+ * Claude-Code triage worker status line — the `claude_code` analogue of the
+ * Codex line. Remedies are Claude-shaped (sign into `claude`, upgrade an old
+ * CLI, point past a wrapper), never "codex login".
+ */
+function renderClaudeLine(codex, now) {
+    if (codex.last_preflight_at === null) {
+        return "Claude Code: not checked yet — auto-capture has not run";
+    }
+    if (codex.last_preflight_ok === true) {
+        return `Claude Code: ready ✓ (last checked: ${formatAge(codex.last_preflight_at, now)})`;
+    }
+    const checked = `last checked: ${formatAge(codex.last_preflight_at, now)}`;
+    switch (codex.last_preflight_error_class) {
+        case "auth":
+            return `Claude Code: signed out ✗ (${checked}) — run: claude (sign in)`;
+        case "missing":
+            return `Claude Code: not found ✗ (${checked}) — install claude or set RIFT_CLAUDE_CLI_PATH`;
+        case "incompatible":
+            return `Claude Code: too old ✗ (${checked}) — upgrade claude (needs --safe-mode)`;
+        case "wrapper":
+            return `Claude Code: wrapper blocking ✗ (${checked}) — set RIFT_CLAUDE_CLI_PATH to the real claude`;
+        default: {
+            const summary = codex.last_preflight_error_summary ?? "Claude preflight failed.";
+            return `Claude Code: probe failing ✗ (${checked}) — ${summary}`;
+        }
+    }
+}
+/**
+ * True when the daemon's own scheduled loop last failed (during this
+ * uptime) but the newest run is a healthy ad-hoc run (a manual `rift
+ * capture` or the onboard first-capture pass). This is the "capture works
+ * now, but automation is still failing" split — kept in sync with the
+ * `capture_daemon_stale` check in diagnostics/doctor.ts.
+ *
+ * `last_daemon_failed` carries the full failure verdict (a `run_ok`-only
+ * check would miss the common expired-Codex case, which completes with
+ * `run_ok: true, preflight_ok: false`). The newest run must be a non-daemon
+ * trigger — legacy untagged rows report as `daemon`, so `!== "daemon"`
+ * cleanly means manual or onboard.
+ */
+function isDaemonCaptureStale(capture, daemonStartMs) {
+    return (capture.last_daemon_failed === true &&
+        isCurrentUptime(capture.last_daemon_run_at ?? null, daemonStartMs) &&
+        capture.last_run_trigger != null &&
+        capture.last_run_trigger !== "daemon" &&
+        capture.last_run_ok === true &&
+        capture.last_errors === 0);
+}
+/**
+ * Split the parked-oversized count into "still self-repairing" vs. "exhausted
+ * retries, needs a manual save". The daemon ships explicit `oversized_repairing`
+ * / `oversized_repair_failed`; an older daemon omits them, so we fall back to
+ * treating every parked session as still-repairing (`parked - failed`, with
+ * failed defaulting to 0) — the calm, accurate read for a daemon that simply
+ * hasn't reported a budget yet.
+ */
+function deriveParkedState(capture) {
+    const parked = capture.oversized_parked ?? 0;
+    const failed = capture.oversized_repair_failed ?? 0;
+    const repairing = capture.oversized_repairing ?? Math.max(parked - failed, 0);
+    return { parked, repairing, failed };
+}
+function renderCaptureLine(status, now, daemonStale) {
+    const { capture, daemon, codex } = status;
+    // When the split "Automatic:" line is shown it carries the daemon's next
+    // tick, so keep it off this line — otherwise a manual run would look
+    // scheduled. With no split, this line keeps the next-tick hint.
+    const next = daemonStale ? null : formatNextRunSuffix(capture.next_run_at, now);
+    const nextPart = next ? ` · ${next}` : "";
+    const retryPart = next ? ` · ${retryWording(next)}` : "";
+    const lastRun = capture.last_run_at
+        ? `${capture.last_run_trigger === "manual" ? "last manual run" : "last run"} ${formatAge(capture.last_run_at, now)}`
+        : null;
+    // The line opens with one of: off, on (no run yet), working, failed. A
+    // reader, or an agent relaying this, must be able to tell a quiet hour from
+    // a fault, and capture being off from capture finding nothing.
+    //
+    // Off. Only an explicit `false`: a daemon from before the flag does not say.
+    if (daemon.capture_enabled === false) {
+        return `Capture:     off — new sessions from your AI tools are not saved${lastRun ? ` (${lastRun})` : ""}. Turn it on: onadit onboard --enable-capture`;
+    }
+    // On, but nothing it saves could be embedded.
+    if (daemon.capture_enabled === true && !daemon.voyage_key_present) {
+        return "Capture:     failed — capture is on but Onadit has no search key, so nothing can be saved. Fix: onadit onboard --reconfigure-voyage";
+    }
+    if (lastRun === null) {
+        if (daemon.capture_enabled === true)
+            return `Capture:     on — no run yet${nextPart}`;
+        return next ? `Capture:     no runs yet · ${next}` : "Capture:     no runs yet";
+    }
+    // Failed: the AI worker that reads sessions was not ready, the run stopped,
+    // or sessions could not be saved (the same bar as `autoCaptureRunFailed`).
+    if (codex.last_preflight_ok === false) {
+        const worker = codex.last_preflight_worker === "claude" ? "Claude Code" : "Codex CLI";
+        return `Capture:     failed — ${lastRun} saved nothing: ${worker} is not ready (see the ${worker} line)${retryPart}`;
+    }
+    if (capture.last_run_ok === false) {
+        return `Capture:     failed — ${lastRun} stopped with an error (details: onadit doctor)${retryPart}`;
+    }
+    if (capture.last_errors > 0) {
+        const n = capture.last_errors;
+        return `Capture:     failed for ${n} session${n === 1 ? "" : "s"} — ${lastRun}: ${capture.last_saved} saved, ${n} not saved (details: onadit doctor)${retryPart}`;
+    }
+    // Driven by the parked-session count (state of the world), NOT
+    // `last_quarantined` (the last run's count) — otherwise this visible line
+    // flickers between showing and hiding as a stable oversized file dedups on
+    // one run and re-quarantines on the next. Large sessions now self-repair in
+    // the background, so the suffix reports honest state: "saving …" while Onadit
+    // is still recovering them, "need a manual save" only once retries are
+    // exhausted — never a bare "run the repair command" on a self-healing path.
+    const { repairing, failed } = deriveParkedState(capture);
+    const parkedSuffix = failed > 0
+        ? ` · ${failed} large session${failed === 1 ? "" : "s"} need a manual save`
+        : repairing > 0
+            ? ` · saving ${repairing} large session${repairing === 1 ? "" : "s"} to memory`
+            : "";
+    // Working. "Nothing new" is said in words: three zeros look like a fault.
+    const found = capture.last_saved === 0 && capture.last_review === 0
+        ? "nothing new"
+        : `${capture.last_saved} saved${capture.last_review > 0 ? `, ${capture.last_review} to review` : ""}`;
+    return `Capture:     working — ${lastRun}: ${found}${parkedSuffix}${nextPart}`;
+}
+/** "next in 59m" as a failure reads it: when the next attempt comes. */
+function retryWording(next) {
+    return next === "next tick due" ? "next try due" : next.replace(/^next in /, "next try in ");
+}
+/**
+ * Native-Cursor capture line. Honest states for an explicit opt-in:
+ *   - not installed AND not scheduled → omit (return null); never advertise a
+ *     tool the user doesn't have.
+ *   - scheduled but the store is missing/unreadable (file probe) → WARN.
+ *   - scheduled, store readable, but the last discovery RUN failed to read it
+ *     (e.g. `sqlite3` missing / corrupt query — invisible to the file probe)
+ *     → WARN. The opt-in (cursor_composer in capture.sources) must never read
+ *     as "capture on" while capture physically can't run; that would silently
+ *     swallow the one thing the user asked for.
+ *   - installed but not scheduled → offer the opt-in.
+ *   - scheduled, readable, and no observed discovery failure → on.
+ * Returns null for a pre-this-slice payload that omits the `cursor` block.
+ */
+function renderCursorLine(capture) {
+    const cursor = capture.cursor;
+    if (!cursor)
+        return null;
+    if (cursor.scheduled) {
+        if (!cursor.available) {
+            return "Cursor:      scheduled but no readable Cursor store found — capture can't run (is Cursor installed?)";
+        }
+        // File is readable, but the last run that actually read the store failed —
+        // the store is present yet Onadit can't parse it (commonly: no `sqlite3` on
+        // PATH). Warn instead of claiming the schedule is working.
+        if (cursor.last_discovery_ok === false) {
+            return "Cursor:      scheduled but Onadit couldn't read your Cursor sessions last run — capture isn't working (try: onadit doctor)";
+        }
+        return "Cursor:      capture on — native Cursor sessions are captured on the schedule";
+    }
+    // Not scheduled: only advertise the opt-in when Cursor is actually present.
+    if (!cursor.available)
+        return null;
+    return 'Cursor:      not captured — to capture Cursor sessions, add "cursor_composer" to capture.sources in Onadit\'s config.json, then restart Onadit';
+}
+/**
+ * Claude Desktop agent/Cowork capture line. Cowork is an explicit opt-in like
+ * Cursor, not part of the default auto-capture set. Existing sessions are
+ * baselined on first opt-in, so the line deliberately says "new" sessions.
+ */
+function renderCoworkLine(capture) {
+    const cowork = capture.claude_desktop;
+    if (!cowork)
+        return null;
+    if (cowork.scheduled) {
+        if (!cowork.available) {
+            return "Cowork:      scheduled but no readable Claude Desktop Cowork store found — capture can't run (open a Cowork session, then run onadit status)";
+        }
+        if (cowork.last_discovery_ok === false) {
+            return "Cowork:      scheduled but Onadit couldn't read your Cowork sessions last run — capture isn't working (try: onadit doctor)";
+        }
+        return "Cowork:      capture on — new Claude Desktop Cowork sessions are captured on the schedule";
+    }
+    if (!cowork.available)
+        return null;
+    return "Cowork:      available — run onadit onboard --enable-cowork-capture to capture new Cowork sessions";
+}
+/**
+ * Honest source-coverage line. Onadit auto-captures the CLI agents (Claude Code,
+ * Codex CLI), and can opt into Claude Desktop Cowork agent sessions. Normal
+ * Claude/ChatGPT desktop and web chats still need export → `onadit import`.
+ * Rendered only when such an app is actually installed, so it sets the right
+ * expectation for exactly the users who would assume "auto-capture" already
+ * covers them, and stays silent for everyone else.
+ */
+function renderLocalAiAppsLine(apps) {
+    if (!apps)
+        return null;
+    const names = [];
+    if (apps.claudeDesktop)
+        names.push("Claude Desktop");
+    if (apps.chatgptApp)
+        names.push("ChatGPT");
+    if (names.length === 0)
+        return null;
+    const possessive = names.length === 1 ? "its" : "their";
+    return `App chats:   ${names.join(" + ")} installed — ${possessive} normal chats aren't auto-captured; export → onadit import`;
+}
+/**
+ * The "Automatic:" advisory line — shown only when `isDaemonCaptureStale`
+ * holds (the scheduled loop's last run failed while a manual run is
+ * working). Returns null otherwise; a healthy or not-yet-run daemon needs
+ * no second capture line.
+ */
+function renderAutomaticCaptureLine(capture, now, daemonStale) {
+    if (!daemonStale || !capture.last_daemon_run_at)
+        return null;
+    const age = formatAge(capture.last_daemon_run_at, now);
+    const nextSuffix = formatNextRunSuffix(capture.next_run_at, now);
+    return `Automatic:   failed — last scheduled run ${age}${nextSuffix ? ` · ${retryWording(nextSuffix)}` : ""}`;
+}
+function formatNextRunSuffix(iso, now) {
+    if (!iso)
+        return null;
+    const then = Date.parse(iso);
+    if (Number.isNaN(then))
+        return null;
+    const deltaSeconds = Math.round((then - now) / 1000);
+    if (deltaSeconds <= 0)
+        return "next tick due";
+    return `next in ${formatDuration(deltaSeconds)}`;
+}
+function renderMcpLine(clients) {
+    if (clients.length === 0)
+        return "MCP:         (no clients detected)";
+    const parts = clients.map((c) => c.installed
+        ? `${c.client} ✓`
+        : `${c.client} ✗ (run: onadit mcp install --client=${c.client})`);
+    return `MCP:         ${parts.join("  ·  ")}`;
+}
+/**
+ * Render the menu-bar advisory line, or null to omit it. Two cases print:
+ * SwiftBar absent (install the app), and SwiftBar present but the plugin is a
+ * dangling shortcut (reinstall it) — so the everyday `onadit status` can't look
+ * clean while the icon is broken. A healthy install and `null` (non-macOS /
+ * unprobed, e.g. the daemon notifier) stay silent, matching `onadit doctor`.
+ */
+function renderSwiftBarLine(swiftBar) {
+    if (!swiftBar)
+        return null;
+    if (!swiftBar.installed) {
+        // Lead with the real first step (install the app); `onadit menubar install`
+        // alone would only re-print that same recovery, so name it directly.
+        return "Menu bar:    SwiftBar not installed ✗ (icon can't show → install SwiftBar from swiftbar.app, then run: onadit menubar install)";
+    }
+    if (swiftBar.pluginDangling) {
+        return "Menu bar:    plugin broken ✗ (icon can't update → reinstall: onadit menubar install)";
+    }
+    return null;
+}
+function decideNextLine(input) {
+    const { status, mcpClients, daemonStartMs } = input;
+    // A missing key is only an action item when something needs it. With
+    // auto-capture off, no-key is the intended local mode, so it must not claim
+    // the Next: line — that would read as "broken" on a healthy local install.
+    if (!status.daemon.voyage_key_present && status.daemon.capture_enabled) {
+        return "Auto-capture is on but has no Voyage key to embed with → run: onadit onboard --reconfigure-voyage";
+    }
+    if (status.codex.last_preflight_ok === false) {
+        if (status.codex.last_preflight_worker === "claude") {
+            switch (status.codex.last_preflight_error_class) {
+                case "auth":
+                    return "Claude Code signed out → run: claude (sign in); Onadit retries automatically";
+                case "missing":
+                    return "Claude Code CLI not found → install claude or set RIFT_CLAUDE_CLI_PATH; Onadit retries automatically";
+                case "incompatible":
+                    return "Claude Code CLI too old → upgrade claude (needs --safe-mode); Onadit retries automatically";
+                case "wrapper":
+                    return "A wrapper is intercepting claude → set RIFT_CLAUDE_CLI_PATH to the real binary; Onadit retries automatically";
+                case "rate_limit":
+                    return "Claude hit a rate/usage limit → wait for it to reset; Onadit retries automatically";
+                default:
+                    return "Claude capture probe failing → Onadit retries automatically";
+            }
+        }
+        if (status.codex.last_preflight_error_class === "auth") {
+            return "Codex auth expired → run: codex login";
+        }
+        if (status.codex.last_preflight_error_class === "model") {
+            return "Codex rejected the model → set codex_cli.model; Onadit retries automatically";
+        }
+        if (status.codex.last_preflight_error_class === "cli_incompatible") {
+            return "Codex CLI too old → upgrade Codex; Onadit retries automatically";
+        }
+        if (status.codex.last_preflight_error_class === "binary") {
+            return "Codex CLI missing or moved → reinstall/upgrade codex; Onadit retries automatically";
+        }
+        if (status.codex.last_preflight_error_class === "rate_limit") {
+            return "Codex out of credits or rate-limited → top up your OpenAI balance or wait; Onadit retries automatically";
+        }
+        return "Codex capture probe failing → Onadit retries automatically";
+    }
+    // Recency gating: only errors stamped *after* the current daemon
+    // start can drive the Next: action. A 20h-old schema_mismatch from a
+    // prior process should not advertise "broken, file feedback" on a
+    // healthy respawn.
+    if (isCurrentUptime(status.voyage.last_error_at, daemonStartMs)) {
+        return `Voyage embedding errors since daemon start (${humanizeErrorClass(status.voyage.last_error_reason)}) → run: onadit feedback --kind=broke --with-status`;
+    }
+    if (isCurrentUptime(status.index.last_error_at, daemonStartMs)) {
+        return `Index write errors since daemon start (${humanizeErrorClass(status.index.last_error_reason)}) → run: onadit feedback --kind=broke --with-status`;
+    }
+    // Inbox import failures are usually the user's own drop being rejected
+    // (malformed export, corrupted ZIP, unsupported source). The fix is on
+    // their side — re-drop a fresh export — not in the feedback flow.
+    // We deliberately do NOT name `data/quarantine/`: pre-parse failures
+    // (e.g. corrupted ZIPs that throw inside extractArchive) never write
+    // a quarantine record, so the path would point at an empty folder.
+    // Only the parser-level per-conversation failures land there, and
+    // the user doesn't need to disambiguate before re-dropping.
+    if (status.inbox && isCurrentUptime(status.inbox.last_error_at, daemonStartMs)) {
+        return `Inbox import errors since daemon start (${humanizeErrorClass(status.inbox.last_error_reason)}) → import a fresh export: onadit import <file> --source <name>`;
+    }
+    // Capture errors only count when the failing run happened during the
+    // current daemon uptime — a prior process's failure shouldn't keep
+    // nudging the friend post-respawn.
+    if ((status.capture.last_errors > 0 || status.capture.last_run_ok === false) &&
+        isCurrentUptime(status.capture.last_run_at, daemonStartMs)) {
+        return "Capture errors detected → run: onadit feedback --kind=broke --with-status";
+    }
+    // Scheduled loop failing while the newest run is a healthy manual one:
+    // capture works now, so surface the honest "will re-check" advisory
+    // rather than a broken-capture action or "nothing broken."
+    if (isDaemonCaptureStale(status.capture, daemonStartMs)) {
+        return "capture works now; automatic capture will re-check on the next scheduled run";
+    }
+    const missing = mcpClients.filter((c) => !c.installed).map((c) => c.client);
+    if (missing.length > 0) {
+        return `MCP not installed for ${missing.join(", ")} → run: onadit mcp install --client=${missing[0]}`;
+    }
+    // Oversized Codex sessions parked in quarantine are a graceful skip, not an
+    // error — and they now SELF-REPAIR in the background. So the default copy is
+    // the honest in-progress state ("Onadit is saving N … to memory"), with NO
+    // command for the friend to run. The manual `onadit doctor repair
+    // capture-large-sessions` is surfaced only once a session has exhausted its
+    // bounded retry budget — the genuine "Onadit couldn't, you take over" case.
+    const { repairing, failed } = deriveParkedState(status.capture);
+    if (failed > 0) {
+        return `${failed} large Codex session${failed === 1 ? "" : "s"} could not be saved automatically → run: onadit doctor repair capture-large-sessions`;
+    }
+    if (repairing > 0) {
+        return `Onadit is saving ${repairing} large Codex session${repairing === 1 ? "" : "s"} to memory — no action needed`;
+    }
+    // Update available wins over "nothing broken" — a friend who runs
+    // status precisely to find out what to do next should see the update
+    // hint surfaced as the action, not buried under "all green." It is
+    // still strictly below every real error branch above, so a broken
+    // daemon never prefers an update suggestion over a Voyage/Index fix.
+    if (status.update.available && status.update.latest_beta) {
+        return `Update available (${status.update.installed} → ${status.update.latest_beta}) → ${updateAction(status.update)}`;
+    }
+    return 'nothing broken. Try onadit search "<topic>".';
+}
+export function formatAge(iso, now) {
+    const then = Date.parse(iso);
+    if (Number.isNaN(then))
+        return "unknown";
+    return formatDuration(Math.max(0, Math.round((now - then) / 1000))) + " ago";
+}
+/**
+ * Render the `time_to_first_useful_recall` line. Returns null when the
+ * state is `hidden` so the caller can drop the line entirely — a fresh
+ * post-onboard install should not advertise a metric it has not yet
+ * earned the right to display.
+ */
+export function renderOnboardingLine(onboarding, now) {
+    if (!onboarding)
+        return null;
+    if (onboarding.state === "hidden")
+        return null;
+    if (onboarding.state === "pending") {
+        const since = onboarding.useful_state_reached_at
+            ? ` (waiting ${formatAge(onboarding.useful_state_reached_at, now)})`
+            : "";
+        // The record is the first answer that came back complete and with
+        // results. A tool may well have asked already and got nothing or a partial
+        // answer, so this must not say that no tool has asked.
+        return `First recall: not yet — no AI tool has got a complete answer with results from Onadit so far; an empty or partial answer is not counted${since}`;
+    }
+    const duration = onboarding.duration_seconds !== null
+        ? formatOnboardingDuration(onboarding.duration_seconds)
+        : "?";
+    // The metric stores the label the tool had when it was recorded.
+    const tool = renamePreviousToolNames(onboarding.first_useful_recall_tool ?? "?");
+    // Said as what happened: "0s after first useful state" is our metric's name,
+    // not something a reader can act on or relay. The event is the first answer
+    // that was complete and had results, not the first time a tool asked.
+    return `First recall: done — an AI tool first got a complete answer with results from Onadit ${duration} after Onadit was ready (${tool})`;
+}
+export function formatDuration(seconds) {
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    const remMin = minutes % 60;
+    if (hours < 24)
+        return remMin > 0 ? `${hours}h ${remMin}m` : `${hours}h`;
+    const days = Math.floor(hours / 24);
+    const remHours = hours % 24;
+    return remHours > 0 ? `${days}d ${remHours}h` : `${days}d`;
+}
+//# sourceMappingURL=friend-header.js.map