@getrift/rift 0.1.0-beta.12 → 0.1.0-beta.14

package/dist/src/cli/commands/onboard.js

@@ -38,10 +38,20 @@ import { runAutoCapture, resolveCodexCaptureDeps, } from "../../capture/auto-cap
 import { CodexCliTriageProvider } from "../../capture/codex-cli-triage-provider.js";
 import { discoverClaudeCodeSessions } from "../../ingestion/parsers/claude-code-jsonl.js";
 import { discoverCodexSessions } from "../../ingestion/parsers/codex-jsonl.js";
+import { sniffInboxSource } from "../../ingestion/inbox-core/source-sniffer.js";
 import { writeHookConfig } from "../hooks-writers/index.js";
 import { HooksParseFailedError } from "../hooks-writers/index.js";
 import { pollJob } from "../job-poller.js";
 import { isJobFailure } from "../output.js";
+import * as ui from "../ui.js";
+/**
+ * Resolve a `--no-<flag>` to a single boolean ("yes, skip this thing").
+ * Commander populates the affirmative key with `false`; programmatic
+ * callers may pass the `no*` key with `true`. Either form wins.
+ */
+export function isOff(opts, affirmative, negative) {
+    return opts[affirmative] === false || opts[negative] === true;
+}
 const SUPPORTED_INGEST_EXTENSIONS = new Set([".json", ".zip"]);
 const DEFAULT_DATA_DIR = path.join(os.homedir(), "Library", "Application Support", "Rift", "data");
 // Inline import is intentionally narrow until Slice 3 lands the real
@@ -60,6 +70,7 @@ export function makeOnboardCommand() {
         .option("--reconfigure-voyage", "Recovery flow: replace the Voyage key only", false)
         .option("--yes", "Accept all defaults (non-interactive)", false)
         .option("--skip-capture", "Skip the post-setup capture pass (test-only)", false)
+        .option("--no-codex-capture", "Skip the Codex CLI preflight + disable the capture pass for this run")
         .option("--with-claude-hook", "Install the Rift policy hook into Claude Code without prompting", false)
         .option("--no-claude-hook", "Skip the Claude Code policy-hook prompt entirely")
         .action(async (opts, cmd) => {
@@ -89,23 +100,23 @@ async function runOnboard(opts, globalOpts) {
             await reconfigureVoyageFlow(opts, globalOpts, rl);
             return;
         }
-        say("");
-        say("Rift — first-run setup");
-        say("─────────────────────");
+        ui.banner();
         // Step 1 — legacy migration (idempotent).
         const dataDir = await ensureConfigAndDataDir(globalOpts.config, opts, rl);
-        say("");
-        say("Running legacy migration check…");
         const migration = await runLegacyMigration({ dataDir });
         if (migration.migratedCount > 0) {
-            say(`Migrated ${migration.migratedCount} legacy artifact(s).`);
+            ui.step("ok", "Existing data", `carried over ${migration.migratedCount} item(s)`);
         }
         else {
-            say("No legacy artifacts found.");
+            ui.step("ok", "Existing data", "nothing to carry over");
         }
+        // Privacy contract — shown BEFORE the first outbound choice (the
+        // Voyage key, whose snippets leave the machine for embedding). A beta
+        // user should understand what stays local and what leaves before they
+        // paste anything.
+        ui.step("info", "Privacy", "");
+        sayPrivacyContract();
         // Step 2 — Voyage key + validate + persist + kickstart + smoke.
-        say("");
-        say("Voyage API key");
         const last4 = await collectAndPersistVoyageKey(opts, globalOpts, rl);
         // Step 2b — sanitize + persist optional --voyage-label to config.json
         // (backup first). Invalid labels are dropped without echoing the raw
@@ -113,39 +124,53 @@ async function runOnboard(opts, globalOpts) {
         // can never leak through stdout or config.json.
         const safeLabel = applyVoyageLabel(opts.voyageLabel, globalOpts.config, say);
         // Step 3 — Codex CLI preflight.
-        say("");
-        say("Codex CLI preflight…");
-        const codexOk = await codexPreflight();
-        if (!codexOk) {
-            say("Codex CLI is not authenticated. Run: codex login");
-            say("(Auto-capture needs Codex CLI auth. Re-run rift onboard once codex login succeeds.)");
-            throw new CliError("Codex CLI preflight failed.", "validation");
-        }
-        say("Codex CLI ready.");
+        //
+        // Codex CLI is only required by the auto-capture lane. Friends who
+        // use only Claude Desktop / Claude Code (and import via the inbox
+        // or `rift import`) should not be blocked by a missing/expired
+        // Codex auth. So a failed preflight is a warning, not fatal —
+        // onboarding continues and the capture pass is skipped for this
+        // run. `--no-codex-capture` skips the preflight entirely.
+        let captureDisabled = false;
+        if (isOff(opts, "codexCapture", "noCodexCapture")) {
+            ui.step("skip", "Chat access", "skipped (--no-codex-capture) · auto-import off");
+            captureDisabled = true;
+        }
+        else {
+            const codexSpin = new ui.Spinner("Chat access").start();
+            const codexOk = await codexPreflight();
+            if (codexOk) {
+                codexSpin.succeed("Chat access", "ready · Codex CLI");
+            }
+            else {
+                codexSpin.fail("Chat access", "not ready · Codex CLI — auto-import off");
+                ui.note("To enable later: run `codex login`, then re-run `rift onboard`.");
+                captureDisabled = true;
+            }
+        }
         // Step 4 — discover sessions.
-        say("");
         const claudeSessions = safeDiscover(() => discoverClaudeCodeSessions(path.join(os.homedir(), ".claude")));
         const codexSessions = safeDiscover(() => discoverCodexSessions());
-        say(`Found ${claudeSessions} Claude Code session(s) and ${codexSessions} Codex CLI session(s).`);
-        // Step 5 — privacy + feedback opt-in.
-        say("");
-        say("Privacy");
-        sayPrivacyContract();
-        const feedback = await collectFeedbackPreference(opts, rl, dataDir);
+        ui.step("ok", "Chat history", `${claudeSessions} Claude Code · ${codexSessions} Codex CLI`);
+        // Step 5 — feedback preference (privacy contract already shown above).
+        const feedback = await collectFeedbackPreference(opts, dataDir);
         if (feedback.enabled) {
-            say(`Feedback relay enabled (installation_id: ${feedback.installation_id}).`);
+            ui.step("ok", "Feedback", `relay on (installation_id: ${feedback.installation_id})`);
         }
         else {
-            say("Feedback relay off — feedback stays in local JSONL only.");
+            ui.step("ok", "Feedback", "relay off — stays in local JSONL");
         }
         // Step 5b — optional Claude Code policy hook.
-        say("");
         await maybeInstallClaudeCodeHook(opts, rl);
         // Step 6 + 7 — watermark current sessions + run one capture pass.
         let captureSaved = 0;
-        if (!opts.skipCapture) {
-            say("");
-            say("Running first capture pass (watermark + scan)…");
+        if (opts.skipCapture) {
+            ui.step("skip", "Chat import", "skipped (--skip-capture)");
+        }
+        else if (captureDisabled) {
+            ui.step("skip", "Chat import", "skipped (Codex CLI not ready)");
+        }
+        else {
             const captureResult = await runFirstCapturePass(globalOpts.config, dataDir);
             captureSaved = captureResult.saved;
             // Per A-1.1/C-1.3: a token-issuance failure during capture-pass
@@ -157,13 +182,12 @@ async function runOnboard(opts, globalOpts) {
                 return;
             }
         }
-        else {
-            say("Skipping capture pass (--skip-capture).");
-        }
         // Step 8 — optional export import.
-        say("");
         let importSucceeded = false;
-        if (!opts.noImportExport) {
+        if (isOff(opts, "importExport", "noImportExport")) {
+            ui.step("skip", "File import", "skipped (--no-import-export)");
+        }
+        else {
             const importPath = await collectImportPath(opts, rl);
             if (importPath) {
                 const outcome = await runImport(importPath, globalOpts.config);
@@ -172,30 +196,34 @@ async function runOnboard(opts, globalOpts) {
                 }
             }
             else {
-                say("Skipping import. Run rift import <path> --source <name> later.");
+                ui.step("skip", "File import", "none — run `rift import <path> --source <name>` later");
             }
         }
-        else {
-            say("Skipping import (--no-import-export).");
-        }
         // Step 9 — first-recall verification.
         // Onboarding declares "complete" only when (a) capture or import landed
         // user data this run, AND (b) a recall query against the daemon returns
         // at least one hit. Without (a), there is nothing to recall — calling
         // it "complete" because /search returned 0 rows would be misleading.
-        say("");
         const ingestedAny = captureSaved > 0 || importSucceeded;
-        say(`First-recall sanity check (capture saved ${captureSaved} · import ${importSucceeded ? "ok" : "none"})…`);
+        const recallSpin = new ui.Spinner("Search check").start();
         const recall = ingestedAny
             ? await firstRecallCheck(globalOpts.config)
             : { ok: false, reason: "no user data was captured or imported during onboarding" };
+        if (recall.ok && recall.hits > 0) {
+            recallSpin.succeed("Search check", `found ${recall.hits} result(s)`);
+        }
+        else if (recall.ok) {
+            // 0 hits is NOT success — decideOnboardOutcome treats it as incomplete.
+            recallSpin.warn("Search check", "no results yet — index is fresh, try a query shortly");
+        }
+        else {
+            recallSpin.fail("Search check", recall.reason);
+        }
         // Step 10 — next-action card.
-        say("");
-        say("─────────────────────");
-        for (const line of decideOnboardOutcome({ ingestedAny, recall }))
-            say(line);
-        say(`Voyage: key valid (last 4 …${last4})${safeLabel ? ` · label ${safeLabel}` : ""}`);
-        say("");
+        const card = decideOnboardOutcome({ ingestedAny, recall });
+        card.push(ui.pc.dim(`Voyage: key valid (last 4 …${last4})${safeLabel ? ` · label ${safeLabel}` : ""}`));
+        ui.box(card);
+        ui.line("");
     }
     finally {
         rl.close();
@@ -204,10 +232,11 @@ async function runOnboard(opts, globalOpts) {
 // ----- Step 1: config.json + data dir -----
 async function ensureConfigAndDataDir(configPath, opts, rl) {
     const absoluteConfig = path.resolve(configPath);
+    const shownConfig = absoluteConfig.replace(os.homedir(), "~");
     if (fs.existsSync(absoluteConfig)) {
         const config = loadConfig(absoluteConfig);
-        say(`Using existing config: ${absoluteConfig}`);
-        say(`Data dir: ${config.data_paths.data_dir}`);
+        ui.step("ok", "Settings", shownConfig);
+        ui.note(`data dir: ${config.data_paths.data_dir}`);
         return config.data_paths.data_dir;
     }
     const defaultDataDir = DEFAULT_DATA_DIR;
@@ -237,8 +266,8 @@ async function ensureConfigAndDataDir(configPath, opts, rl) {
         encoding: "utf8",
         mode: 0o644,
     });
-    say(`Wrote default config: ${absoluteConfig}`);
-    say(`Data dir: ${dataDir}`);
+    ui.step("ok", "Settings", `wrote default · ${shownConfig}`);
+    ui.note(`data dir: ${dataDir}`);
     // Trigger ensureDirectories.
     loadConfig(absoluteConfig);
     return dataDir;
@@ -311,17 +340,18 @@ export function persistVoyageLabel(configPath, label) {
 // ----- Step 2: Voyage key flow -----
 async function collectAndPersistVoyageKey(opts, globalOpts, rl) {
     const key = await collectVoyageKey(opts, rl);
-    say("Validating with Voyage API…");
+    const validateSpin = new ui.Spinner("Search index").start();
     const validation = await validateVoyageKey({ apiKey: key });
     if (!validation.ok) {
+        validateSpin.fail("Search index", "validation failed");
         throw new CliError(`Voyage validation failed: ${validation.reason}`, "validation");
     }
-    say(`Voyage key valid (last 4 …${validation.last4}).`);
+    validateSpin.succeed("Search index", `connected · Voyage · ····${validation.last4}`);
     const envPath = defaultRiftEnvPath();
     const writeResult = writeEnvFile({ filePath: envPath, key: "VOYAGE_API_KEY", value: key });
-    say(writeResult.backedUp
-        ? "Wrote ~/.rift.env (existing file backed up)."
-        : "Wrote ~/.rift.env (mode 0600).");
+    ui.note(writeResult.backedUp
+        ? "wrote ~/.rift.env (existing file backed up)"
+        : "wrote ~/.rift.env (mode 0600)");
     // Refresh process.env so any subsequent in-process Voyage call sees it.
     loadRiftEnv({ filePath: envPath });
     const refresh = await daemonRefreshFlow(globalOpts);
@@ -342,6 +372,14 @@ async function collectVoyageKey(opts, rl) {
     if (opts.yes) {
         throw new CliError("--yes given but no Voyage key found (use --voyage-key or set VOYAGE_API_KEY).", "validation");
     }
+    // Explain the key BEFORE asking for it — a beta user should know what
+    // they are pasting and why, not be confronted with a bare prompt.
+    ui.detail([
+        "Search index key",
+        "• What: paste the Voyage key Clem sent you (it won't echo as you type).",
+        "• Why: Rift uses Voyage to make your archive searchable by meaning.",
+        "• Privacy: the key is stored locally and only sent to Voyage when Rift calls Voyage; never sent to Clem.",
+    ].join("\n"));
     const answer = (await ask(rl, "Paste your Voyage API key: ")).trim();
     if (answer.length === 0) {
         throw new CliError("Voyage key is required.", "validation");
@@ -359,35 +397,38 @@ async function collectVoyageKey(opts, rl) {
 async function daemonRefreshFlow(globalOpts) {
     const baseUrl = safeResolveBaseUrl(globalOpts.config);
     if (!baseUrl) {
-        say("Daemon not configured yet — skipping kickstart. Bootstrap via install.sh, then re-run rift onboard.");
+        ui.step("skip", "Rift service", "not configured yet — bootstrap via install.sh, then re-run");
         return { ok: false, reason: "daemon not configured", kind: "not_configured" };
     }
+    const daemonSpin = new ui.Spinner("Rift service").start();
     const kick = await kickstartDaemon();
     if (kick.status === "agent_not_loaded") {
-        say(kick.hint);
+        daemonSpin.fail("Rift service", "launchd agent not loaded");
+        ui.note(kick.hint);
         return { ok: false, reason: kick.hint ?? "agent not loaded", kind: "agent_not_loaded" };
     }
     if (kick.status === "failed") {
+        daemonSpin.fail("Rift service", "kickstart failed");
         return {
             ok: false,
             reason: kick.hint ?? "kickstart failed",
             kind: "kickstart_failed",
         };
     }
-    say("Daemon kickstarted.");
     const health = await waitForHealth({ baseUrl });
     if (!health.ok) {
+        daemonSpin.fail("Rift service", "health check failed");
         return { ok: false, reason: health.reason, kind: "health_failed" };
     }
-    say(`Daemon healthy (uptime ${health.uptimeSeconds}s).`);
     if (!health.voyageKeyPresent) {
+        daemonSpin.fail("Rift service", "voyage_key_present=false after kickstart");
         return {
             ok: false,
             reason: "Daemon /health reports voyage_key_present=false after kickstart.",
             kind: "smoke_failed",
         };
     }
-    say("Cloud embedding live (daemon loaded VOYAGE_API_KEY).");
+    daemonSpin.succeed("Rift service", `healthy · daemon · uptime ${health.uptimeSeconds}s`);
     return { ok: true, kickstarted: true };
 }
 export function classifyTokenFailure(err) {
@@ -490,30 +531,18 @@ async function codexPreflight() {
         return false;
     }
 }
-async function collectFeedbackPreference(opts, rl, dataDir) {
+async function collectFeedbackPreference(opts, dataDir) {
     let enabled = false;
     let url;
+    // Default onboarding keeps feedback fully local (JSONL). There is no
+    // bundled hosted relay endpoint, so we never ask a beta user to paste a
+    // "Relay URL:" — that field is operator-only infrastructure. The relay
+    // is reachable solely via the advanced, non-interactive
+    // `--enable-feedback-relay <url>` flag.
     if (opts.enableFeedbackRelay) {
         enabled = true;
         url = opts.enableFeedbackRelay;
     }
-    else if (opts.noFeedbackRelay || opts.yes) {
-        enabled = false;
-    }
-    else {
-        const answer = (await ask(rl, "Opt into the Rift feedback relay? [y/N]: ", "n"))
-            .trim()
-            .toLowerCase();
-        enabled = answer === "y" || answer === "yes";
-        if (enabled) {
-            url = (await ask(rl, "Relay URL: ")).trim();
-            if (!url) {
-                say("No URL supplied — keeping relay off.");
-                enabled = false;
-                url = undefined;
-            }
-        }
-    }
     const cfg = enabled && url
         ? { enabled: true, url, installation_id: crypto.randomUUID() }
         : { enabled: false };
@@ -540,7 +569,7 @@ async function collectFeedbackPreference(opts, rl, dataDir) {
  * guardrail, not a correctness requirement.
  */
 async function maybeInstallClaudeCodeHook(opts, rl) {
-    if (opts.noClaudeHook) {
+    if (isOff(opts, "claudeHook", "noClaudeHook")) {
         return;
     }
     const homeDir = os.homedir();
@@ -555,20 +584,22 @@ async function maybeInstallClaudeCodeHook(opts, rl) {
     }
     else if (opts.yes) {
         // Non-interactive default: skip. Operator must opt in with --with-claude-hook.
-        say("Claude Code detected — skipping the policy-hook prompt (pass --with-claude-hook to install non-interactively).");
+        ui.step("skip", "Claude Code", "skipped (pass --with-claude-hook to install non-interactively)");
         return;
     }
     else {
-        say("Claude Code detected.");
-        say("Optional: install a PreToolUse policy hook so Rift retrieval starts with rift_context_pack");
-        say("(prevents broad rift_search dumps from burning context). Disable any time with RIFT_POLICY_DISABLED=1.");
-        const answer = (await ask(rl, "Install Claude Code policy hook? [y/N]: ", "n"))
+        ui.note([
+            "Claude Code detected.",
+            "Optional: install a PreToolUse policy hook so Rift retrieval starts with rift_context_pack",
+            "(prevents broad rift_search dumps from burning context). Disable any time with RIFT_POLICY_DISABLED=1.",
+        ].join("\n"));
+        const answer = (await ask(rl, "  Install Claude Code policy hook? [y/N]: ", "n"))
             .trim()
             .toLowerCase();
         install = answer === "y" || answer === "yes";
     }
     if (!install) {
-        say("Skipping Claude Code policy hook.");
+        ui.step("skip", "Claude Code", "not installed");
         return;
     }
     try {
@@ -578,25 +609,25 @@ async function maybeInstallClaudeCodeHook(opts, rl) {
             dryRun: false,
         });
         if (outcome.hookEntryAdded) {
-            say("Installed Rift policy hook into Claude Code (PreToolUse entry added).");
+            ui.step("ok", "Claude Code", "connected · auto-recall hook added");
         }
         else if (outcome.hookEntryReplaced || outcome.scriptUpdated) {
-            say("Updated Rift policy hook in Claude Code.");
+            ui.step("ok", "Claude Code", "updated");
         }
         else {
-            say("Rift policy hook already up-to-date in Claude Code.");
+            ui.step("ok", "Claude Code", "already up-to-date");
         }
         if (outcome.backupId) {
-            say(`  Backup ID: ${outcome.backupId}`);
+            ui.note(`backup ID: ${outcome.backupId}`);
         }
-        say("  (Restart Claude Code or open /hooks once for the new entry to load.)");
+        ui.note("(Restart Claude Code or open /hooks once for the new entry to load.)");
     }
     catch (err) {
         if (err instanceof HooksParseFailedError) {
-            say(err.message);
+            ui.step("fail", "Claude Code", err.message);
         }
         else {
-            say(`Claude Code hook install failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+            ui.step("fail", "Claude Code", `install failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
         }
     }
 }
@@ -604,7 +635,7 @@ async function maybeInstallClaudeCodeHook(opts, rl) {
 export async function runFirstCapturePass(configPath, dataDir) {
     const baseUrl = safeResolveBaseUrl(configPath);
     if (!baseUrl) {
-        say("Daemon not reachable — skipping capture pass.");
+        ui.step("skip", "Chat import", "daemon not reachable — skipped");
         return { saved: 0, reviewed: 0 };
     }
     // Per A-1.1/C-1.3: token failure here is fatal. The wizard cannot
@@ -642,6 +673,7 @@ export async function runFirstCapturePass(configPath, dataDir) {
     catch {
         codexCaptureDeps = {};
     }
+    const captureSpin = new ui.Spinner("Chat import").start();
     try {
         const report = await runAutoCapture({
             dataDir,
@@ -667,21 +699,43 @@ export async function runFirstCapturePass(configPath, dataDir) {
                 }
             },
         });
-        say(`Capture: discovered ${report.total_discovered}, new ${report.new_conversations}, saved ${report.saved}, review ${report.review}, errors ${report.errors}.`);
+        const base = `${report.saved} added · ${report.review} to review`;
+        if (report.errors > 0) {
+            captureSpin.warn("Chat import", `${base} · ${report.errors} error(s)`);
+        }
+        else {
+            captureSpin.succeed("Chat import", base);
+        }
         return { saved: report.saved, reviewed: report.review };
     }
     catch (err) {
-        say(`Capture pass error (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+        captureSpin.fail("Chat import", `error (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
         return { saved: 0, reviewed: 0 };
     }
 }
 // ----- Step 8: import -----
 async function collectImportPath(opts, rl) {
-    if (opts.importExport)
+    // opts.importExport is `string | false | undefined` — Commander writes
+    // `false` when `--no-import-export` was passed, but the caller already
+    // short-circuits in that case. Only a non-empty string is a real path.
+    if (typeof opts.importExport === "string" && opts.importExport.length > 0) {
         return opts.importExport;
+    }
     if (opts.yes)
         return null;
-    const answer = (await ask(rl, "Drop a path to a ChatGPT/Claude/Grok/Gemini export to import now (or `skip`): ", "skip")).trim();
+    // Explain what a path is, where to find the export, why it's optional,
+    // and that ChatGPT is the only inline source — BEFORE the prompt. A beta
+    // user who has never exported a chat archive shouldn't hit a bare
+    // "Drop a path" prompt. The source-sniffer below still fail-fasts a
+    // non-ChatGPT export, but the friend learns the boundary earlier here.
+    ui.detail([
+        "Import past chats (optional)",
+        "• What: the file path to a ChatGPT data export (a .zip or .json on your Mac), e.g. ~/Downloads/chatgpt-export.zip.",
+        "• Where: chatgpt.com → Settings → Data controls → Export data, then unzip nothing — just drop the downloaded file's path here.",
+        "• Why: this seeds Rift with your existing ChatGPT history so search works on day one; skipping is fine — new chats get captured automatically.",
+        "• Other tools: Claude/Grok/Gemini exports aren't imported here. Run them later with: rift import <path> --source claude_web|grok_web|gemini_web",
+    ].join("\n"));
+    const answer = (await ask(rl, "Path to a ChatGPT export to import now (or `skip`): ", "skip")).trim();
     if (!answer || answer.toLowerCase() === "skip")
         return null;
     return answer;
@@ -711,11 +765,20 @@ async function runImport(filePath, configPath) {
     }
     const client = createHttpClient({ baseUrl, token: tokenResult.token });
     const buf = fs.readFileSync(absolute);
+    // Fail-fast for non-ChatGPT exports: route them to `rift import` with
+    // the right `--source` flag instead of silently feeding them through
+    // the ChatGPT parser. Returns null on "looks like ChatGPT or unknown,"
+    // a concrete provider otherwise.
+    const sniffed = sniffInboxSource(path.basename(absolute), buf);
+    if (sniffed) {
+        say(`Detected a ${sniffed} export — the inline importer is ChatGPT-only.`);
+        say(`Run: rift import "${absolute}" --source ${sniffed}`);
+        return { kind: "skipped", reason: `non-chatgpt export detected: ${sniffed}` };
+    }
     const form = new FormData();
     form.append("source", ONBOARD_INLINE_IMPORT_SOURCE);
     form.append("file", new Blob([buf]), path.basename(absolute));
     say(`Importing ${path.basename(absolute)} as ${ONBOARD_INLINE_IMPORT_SOURCE}…`);
-    say("(For Claude/Grok/Gemini exports, run: rift import <path> --source <name>)");
     const { data } = await client.postMultipart("/ingest", form);
     const resp = data;
     if (resp.duplicate) {
@@ -755,8 +818,10 @@ export function decideOnboardOutcome(input) {
     }
     if (recall.ok) {
         return [
-            "Setup partially complete — capture+import succeeded but search returned 0 hits.",
-            "Next: rift feedback --kind=broke --with-status \"first-recall returned 0\"",
+            "Setup ready — capture+import succeeded but the generic recall query returned 0 hits.",
+            "Indexing may still be in flight, or this query just didn't match your archive yet.",
+            "Try: rift search \"<a topic you remember discussing>\"",
+            "If repeated tries still return nothing, run: rift feedback --kind=broke --with-status",
         ];
     }
     return [
@@ -776,19 +841,35 @@ async function firstRecallCheck(configPath) {
     // sessions or imported chat exports without targeting any onboarding
     // marker. The smoke is non-indexing (see daemonRefreshFlow), so any
     // hit returned here is real user data, not a leftover probe.
-    try {
-        const { data } = await client.post("/search", {
-            query: "recent conversation",
-            scope: "all",
-            top_k: 10,
-        });
-        const body = data;
-        const hits = (body.results?.length ?? body.hits?.length ?? 0);
-        return { ok: true, hits };
-    }
-    catch (err) {
-        return { ok: false, reason: err instanceof Error ? err.message : String(err) };
+    //
+    // Small unusual imports (e.g. one short Claude project export) can
+    // return 0 hits for this generic query even when the data was
+    // indexed correctly. Retry briefly so the post-onboard nudge isn't a
+    // false alarm on slow embedders / sparse archives.
+    const RECALL_RETRY_DELAYS_MS = [0, 5_000];
+    let lastErr = null;
+    for (const delay of RECALL_RETRY_DELAYS_MS) {
+        if (delay > 0)
+            await new Promise((r) => setTimeout(r, delay));
+        try {
+            const { data } = await client.post("/search", {
+                query: "recent conversation",
+                scope: "all",
+                top_k: 10,
+            });
+            const body = data;
+            const hits = (body.results?.length ?? body.hits?.length ?? 0);
+            if (hits > 0)
+                return { ok: true, hits };
+            lastErr = null;
+        }
+        catch (err) {
+            lastErr = err instanceof Error ? err.message : String(err);
+        }
     }
+    if (lastErr)
+        return { ok: false, reason: lastErr };
+    return { ok: true, hits: 0 };
 }
 // ----- Slice 6: --reconfigure-voyage -----
 /**
@@ -893,13 +974,14 @@ function say(line) {
     process.stdout.write(line + "\n");
 }
 function sayPrivacyContract() {
-    say([
-        "  • Conversation content stays local (LanceDB + raw transcripts).",
-        "  • Content snippets leave the machine for embedding only (Voyage AI).",
-        "  • The Voyage key sits in ~/.rift.env (mode 0600). Never logged, never sent to Clem.",
-        "  • Feedback is stored locally as JSONL. Relay is opt-in: explicit notes only,",
-        "    plus daemon health booleans — no paths, no content, no key bytes.",
-        "  • Full contract: docs/feedback/PRIVACY.md",
+    ui.detail([
+        "• Conversation content stays local (LanceDB + raw transcripts).",
+        "• Content snippets leave the machine for embedding only (Voyage AI).",
+        "• The Voyage key sits in ~/.rift.env (mode 0600), is sent only to Voyage,",
+        "  and is never logged or sent to Clem.",
+        "• Feedback is stored locally as JSONL. Relay is opt-in: explicit notes only,",
+        "  plus daemon health booleans — no paths, no content, no key bytes.",
+        "• Full contract: https://getrift.dev/privacy",
     ].join("\n"));
 }
 function safeDiscover(fn) {