rikrok 0.5.0

package/src/cli/doctor.mjs

@@ -0,0 +1,152 @@
+// rikrok doctor: every dependency, one line each, with the fix when it fails.
+import fs from "node:fs";
+import net from "node:net";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import * as c from "../lib/config.mjs";
+import { sources } from "../sources/index.mjs";
+import { loadVoice } from "../voices/index.mjs";
+import { chat, stripThinking, extractJson, scriptBackend } from "../lib/llm.mjs";
+import { claudeChat } from "../lib/script-claude.mjs";
+import { sttEnabled, transcribeWords } from "../lib/stt.mjs";
+
+const ok = (label, detail = "") => console.log(`  ok    ${label}${detail ? `  (${detail})` : ""}`);
+const warn = (label, fix = "") => console.log(`  warn  ${label}${fix ? `\n        ${fix}` : ""}`);
+const fail = (label, fix = "") => console.log(`  FAIL  ${label}${fix ? `\n        ${fix}` : ""}`);
+
+function has(bin) {
+  try {
+    execFileSync(bin, ["-version"], { stdio: "ignore" });
+    return true;
+  } catch {
+    try {
+      execFileSync(bin, ["--version"], { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+function findChrome() {
+  const roots = [path.join(c.PKG_ROOT, "node_modules", ".remotion"), path.join(c.PKG_ROOT, "..", ".remotion")];
+  const walk = (dir, depth) => {
+    if (depth > 6) return null;
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return null;
+    }
+    for (const e of entries) {
+      const full = path.join(dir, e.name);
+      if (e.isFile() && /^chrome-headless-shell(\.exe)?$/.test(e.name)) return full;
+      if (e.isDirectory()) {
+        const hit = walk(full, depth + 1);
+        if (hit) return hit;
+      }
+    }
+    return null;
+  };
+  for (const r of roots) {
+    const hit = walk(r, 0);
+    if (hit) return hit;
+  }
+  return null;
+}
+
+function portFree(port, host) {
+  return new Promise((resolve) => {
+    const s = net.createServer();
+    s.once("error", () => resolve(false));
+    s.listen(port, host, () => s.close(() => resolve(true)));
+  });
+}
+
+export async function run(args) {
+  let failures = 0;
+  console.log(`rikrok ${c.PKG_VERSION} doctor  (home: ${c.RIKROK_HOME})\n`);
+
+  ok(`node ${process.versions.node}`);
+  for (const b of ["ffmpeg", "ffprobe", "git"]) {
+    if (has(b)) ok(b);
+    else {
+      fail(`${b} not found`, b === "git" ? "install git" : "install ffmpeg (brew install ffmpeg / apt install ffmpeg)");
+      failures++;
+    }
+  }
+
+  for (const src of sources()) {
+    let n = 0;
+    try {
+      n = src.listSessions().length;
+    } catch {}
+    if (n > 0) ok(`${src.id} sessions`, `${n} file(s)`);
+    else if (src.id === "claude") {
+      warn(`no Claude Code sessions under ${c.CLAUDE_PROJECTS}`, "run a Claude Code session first, or set RIKROK_CLAUDE_DIR");
+    } else warn(`no ${src.id} sessions found`);
+  }
+
+  const backend = await scriptBackend();
+  if (backend === "claude") {
+    const t0 = Date.now();
+    try {
+      const text = await claudeChat([{ role: "user", content: 'Reply with exactly this JSON and nothing else: {"ok":true}' }], { timeoutMs: 90_000 });
+      const j = extractJson(text);
+      if (j && j.ok === true) ok(`scripts by Claude Code (${c.CLAUDE_MODEL})`, `${Date.now() - t0} ms`);
+      else warn(`Claude Code answered but not with clean JSON: ${JSON.stringify(text).slice(0, 80)}`);
+    } catch (err) {
+      fail(`scripts by Claude Code: ${err.message}`, "is `claude` installed and logged in? Or set RIKROK_SCRIPT=local with a local model");
+      failures++;
+    }
+  } else if (backend === "none") {
+    warn("no script writer: reels fall back to the plain template", "install Claude Code (RIKROK_SCRIPT=claude) or set RIKROK_LLM_URL and RIKROK_LLM_MODEL for a local model");
+  } else {
+    const t0 = Date.now();
+    try {
+      const text = await chat([{ role: "user", content: 'Reply with exactly this JSON and nothing else: {"ok":true}' }], { temperature: 0, max_tokens: 64, timeoutMs: 60_000 });
+      const j = extractJson(stripThinking(text));
+      if (j && j.ok === true) ok(`LLM ${c.LLM_MODEL} at ${c.LLM_URL}`, `${Date.now() - t0} ms, JSON parsed`);
+      else {
+        warn(`LLM answered but not with clean JSON: ${JSON.stringify(text).slice(0, 80)}`, 'if this is a thinking model, try RIKROK_LLM_EXTRA=\'{"chat_template_kwargs":{"enable_thinking":false}}\' (oMLX/vLLM) or \'{"think":false}\' (Ollama)');
+      }
+    } catch (err) {
+      fail(`LLM ${c.LLM_MODEL} at ${c.LLM_URL}: ${err.message}`, "is the server running? Ollama: `ollama serve` then `ollama pull <model>`; the template script ships until it works");
+      failures++;
+    }
+  }
+
+  try {
+    const v = await loadVoice(c.VOICE);
+    const a = await v.available();
+    if (a.ok) ok(`voice ${v.name}`);
+    else {
+      warn(`voice ${c.VOICE} unavailable: ${a.reason}`, c.VOICE === "clone" ? "run `rikrok voice setup`, and point RIKROK_TTS_URL at a server that accepts a reference clip" : process.platform === "darwin" ? "falls back to say:Samantha, then silent captions" : "falls back to silent captions (rikrok voice setup for your own voice, or RIKROK_VOICE=openai-speech:<voice>)");
+    }
+  } catch (err) {
+    warn(`voice ${c.VOICE}: ${err.message}`);
+  }
+
+  if (sttEnabled()) {
+    try {
+      const r = await fetch(`${c.STT_URL}/v1/models`, { headers: c.authHeaders(c.STT_KEY), signal: AbortSignal.timeout(5000) });
+      if (r.ok) ok(`narration QA via ${c.STT_URL} (${c.STT_MODEL})`);
+      else warn(`STT server at ${c.STT_URL} answered HTTP ${r.status}; QA will be skipped per beat`);
+    } catch (err) {
+      warn(`STT server at ${c.STT_URL} unreachable (${err.message})`);
+    }
+  } else ok("narration QA off", "set RIKROK_STT_URL to enable transcribe-back checks");
+
+  const chrome = process.env.RIKROK_BROWSER || findChrome();
+  if (chrome) ok("render browser (headless Chrome)", path.basename(path.dirname(chrome)));
+  else warn("no headless Chrome yet: Remotion downloads one on the first render (a few hundred MB, one-off)", "run `rikrok demo` now to get that out of the way, or set RIKROK_BROWSER=/path/to/chrome");
+
+  if (await portFree(c.FEED_PORT, c.FEED_BIND)) ok(`feed port ${c.FEED_BIND}:${c.FEED_PORT} free`);
+  else warn(`feed port ${c.FEED_BIND}:${c.FEED_PORT} is in use`, "set RIKROK_PORT, or this is your own feed already running");
+
+  fs.mkdirSync(c.RIKROK_HOME, { recursive: true });
+  ok(`data dir ${c.RIKROK_HOME}`);
+
+  console.log(failures ? `\n${failures} problem(s) to fix.` : "\nAll good. Try: rikrok backfill --limit 2 && rikrok feed");
+  return failures ? 1 : 0;
+}

package/src/cli/feed.mjs

@@ -0,0 +1,7 @@
+import { startFeed } from "../../server/feed.mjs";
+export async function run(args) {
+  const port = args.port ? Number(args.port) : undefined;
+  const bind = typeof args.bind === "string" ? args.bind : undefined;
+  await startFeed({ port, bind });
+  await new Promise(() => {});
+}

package/src/cli/hook.mjs

@@ -0,0 +1,77 @@
+// rikrok hook install | uninstall | run
+// A Claude Code SessionEnd hook that recaps the session you just left. `run` reads the hook's
+// JSON from stdin, starts `rikrok recap` detached, and returns within the hook's time budget.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { BIN, LOG_DIR, RIKROK_HOME, ensureDirs } from "../lib/config.mjs";
+
+const SETTINGS = path.join(os.homedir(), ".claude", "settings.json");
+const isOurs = (entry) => Array.isArray(entry?.hooks) && entry.hooks.some((h) => /rikrok(\.mjs)?"? hook run/.test(String(h.command || "")));
+
+function readSettings() {
+  try {
+    return JSON.parse(fs.readFileSync(SETTINGS, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+export function install() {
+  const s = readSettings();
+  s.hooks = s.hooks || {};
+  const list = (s.hooks.SessionEnd = s.hooks.SessionEnd || []);
+  if (list.some(isOurs)) {
+    console.log("already installed");
+    return 0;
+  }
+  const command = `RIKROK_HOME=${JSON.stringify(RIKROK_HOME)} ${JSON.stringify(process.execPath)} ${JSON.stringify(BIN)} hook run`;
+  list.push({ matcher: "clear|logout|prompt_input_exit|other", hooks: [{ type: "command", command, timeout: 5 }] });
+  fs.mkdirSync(path.dirname(SETTINGS), { recursive: true });
+  fs.writeFileSync(SETTINGS, JSON.stringify(s, null, 2) + "\n");
+  console.log(`installed a SessionEnd hook in ${SETTINGS}\nWhen you leave a Claude Code session with real work in it, a reel is built in the background.`);
+  return 0;
+}
+
+export function uninstall() {
+  const s = readSettings();
+  const list = s.hooks?.SessionEnd;
+  if (!Array.isArray(list)) return 0;
+  const kept = list.filter((e) => !isOurs(e));
+  if (kept.length) s.hooks.SessionEnd = kept;
+  else delete s.hooks.SessionEnd;
+  if (!Object.keys(s.hooks).length) delete s.hooks;
+  fs.writeFileSync(SETTINGS, JSON.stringify(s, null, 2) + "\n");
+  console.log("removed");
+  return 0;
+}
+
+export async function runHook() {
+  if (process.env.RIKROK_HOOK_SKIP) return 0; // a session Rik Rok itself started (script writing)
+  let input = "";
+  for await (const chunk of process.stdin) input += chunk;
+  let j = {};
+  try {
+    j = JSON.parse(input);
+  } catch {}
+  if (!j.transcript_path || j.reason === "resume") return 0;
+  ensureDirs();
+  const out = fs.openSync(path.join(LOG_DIR, "recap.log"), "a");
+  const child = spawn(process.execPath, [BIN, "recap", "--transcript", j.transcript_path, "--session", j.session_id || ""], {
+    detached: true,
+    stdio: ["ignore", out, out],
+    env: { ...process.env, RIKROK_HOOK_SKIP: "" },
+  });
+  child.unref();
+  return 0;
+}
+
+export async function run(args) {
+  const sub = args._[0];
+  if (sub === "install") return install();
+  if (sub === "uninstall") return uninstall();
+  if (sub === "run") return runHook();
+  console.log("usage: rikrok hook install | uninstall | run");
+  return 1;
+}

package/src/cli/install.mjs

@@ -0,0 +1,66 @@
+// macOS: install launchd agents so the watcher and feed run at login.
+// RIKROK_* variables in your environment at install time are baked into the plists.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { PKG_ROOT, BIN, LOG_DIR, RIKROK_HOME, ensureDirs, effectiveEnv } from "../lib/config.mjs";
+
+const AGENTS = { watch: "com.rikrok.watch", feed: "com.rikrok.feed" };
+const VOICE_AGENT = "com.rikrok.voice";
+const dir = path.join(os.homedir(), "Library", "LaunchAgents");
+const uid = process.getuid?.() ?? 501;
+
+const esc = (s) => String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+
+function bootout(label) {
+  try {
+    execFileSync("launchctl", ["bootout", `gui/${uid}/${label}`], { stdio: "ignore" });
+  } catch {}
+}
+
+export async function run(args) {
+  if (process.platform !== "darwin") {
+    console.log(`No launchd here. Run the two processes under your service manager, for example systemd user units:\n`);
+    for (const cmd of ["watch", "feed"]) {
+      console.log(`# ~/.config/systemd/user/rikrok-${cmd}.service\n[Unit]\nDescription=Rik Rok ${cmd}\n[Service]\nExecStart=${process.execPath} ${BIN} ${cmd}\nRestart=always\nEnvironment=RIKROK_HOME=${RIKROK_HOME}\n[Install]\nWantedBy=default.target\n`);
+    }
+    console.log("then: systemctl --user daemon-reload && systemctl --user enable --now rikrok-watch rikrok-feed");
+    return 0;
+  }
+  if (args.uninstall) {
+    for (const label of [...Object.values(AGENTS), VOICE_AGENT]) {
+      bootout(label);
+      fs.rmSync(path.join(dir, `${label}.plist`), { force: true });
+      console.log(`removed ${label}`);
+    }
+    return 0;
+  }
+  ensureDirs();
+  fs.mkdirSync(dir, { recursive: true });
+  const tmpl = fs.readFileSync(path.join(PKG_ROOT, "launchd", "com.rikrok.plist.tmpl"), "utf-8");
+  const envVars = { RIKROK_HOME, ...effectiveEnv() };
+  const envXml = Object.entries(envVars).map(([k, v]) => `    <key>${esc(k)}</key><string>${esc(v)}</string>`).join("\n");
+  const PATH = ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin", path.dirname(process.execPath)].filter((p, i, a) => a.indexOf(p) === i).join(":");
+  const agents = { ...AGENTS };
+  if (process.env.RIKROK_CLONE_API === "voice-clone") agents["voice serve"] = VOICE_AGENT;
+  for (const [cmd, label] of Object.entries(agents)) {
+    const plist = tmpl
+      .replaceAll("{{LABEL}}", label)
+      .replaceAll("{{NODE}}", esc(process.execPath))
+      .replaceAll("{{BIN}}", esc(BIN))
+      .replaceAll("<string>{{CMD}}</string>", cmd.split(" ").map((c) => `<string>${c}</string>`).join("\n    "))
+      .replaceAll("{{WORKDIR}}", esc(PKG_ROOT))
+      .replaceAll("{{LOG}}", esc(path.join(LOG_DIR, `${cmd.replace(" ", "-")}.log`)))
+      .replaceAll("{{ERRLOG}}", esc(path.join(LOG_DIR, `${cmd.replace(" ", "-")}.err.log`)))
+      .replaceAll("{{PATH}}", esc(PATH))
+      .replaceAll("{{ENV}}", envXml);
+    const file = path.join(dir, `${label}.plist`);
+    bootout(label);
+    fs.writeFileSync(file, plist);
+    execFileSync("launchctl", ["bootstrap", `gui/${uid}`, file]);
+    console.log(`installed ${label} -> ${file}`);
+  }
+  console.log(`\nlogs: ${LOG_DIR}\nrestart: launchctl kickstart -k gui/${uid}/${AGENTS.watch}\nremove:  rikrok install --uninstall`);
+  return 0;
+}

package/src/cli/recap.mjs

@@ -0,0 +1,66 @@
+// rikrok recap --transcript <path> [--session <id>] [--cwd <dir>] [--force]
+// Recap one session now (what the SessionEnd hook calls). Covers only the lines since the
+// last recap of that session, respects the same "real work" bar as the watcher, and takes a
+// lock so two recaps never render at once.
+import fs from "node:fs";
+import path from "node:path";
+import { RIKROK_HOME, ensureDirs } from "../lib/config.mjs";
+import * as claude from "../sources/claude.mjs";
+import { loadState, saveState, sessionKey } from "../lib/state.mjs";
+import { buildReel } from "../lib/pipeline.mjs";
+
+const LOCK = () => path.join(RIKROK_HOME, "recap.lock");
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+async function withLock(fn) {
+  const lock = LOCK();
+  for (let i = 0; i < 120; i++) {
+    try {
+      const st = fs.statSync(lock);
+      if (Date.now() - st.mtimeMs > 30 * 60_000) fs.rmSync(lock, { force: true }); // stale
+      else {
+        await sleep(15_000);
+        continue;
+      }
+    } catch {}
+    try {
+      fs.writeFileSync(lock, String(process.pid), { flag: "wx" });
+      break;
+    } catch {}
+  }
+  try {
+    return await fn();
+  } finally {
+    fs.rmSync(lock, { force: true });
+  }
+}
+
+export async function run(args) {
+  ensureDirs();
+  const transcript = typeof args.transcript === "string" ? path.resolve(args.transcript) : null;
+  if (!transcript || !fs.existsSync(transcript)) {
+    console.error("usage: rikrok recap --transcript <session.jsonl> [--session <id>] [--force]");
+    return 1;
+  }
+  const sessionId = typeof args.session === "string" ? args.session : path.basename(transcript, ".jsonl");
+  const f = { source: "claude", path: transcript, sessionId, projectDir: path.basename(path.dirname(transcript)), mtimeMs: fs.statSync(transcript).mtimeMs };
+  return withLock(async () => {
+    const state = loadState();
+    const key = sessionKey(f);
+    const st = state.sessions[key];
+    const fromLine = args.force ? 0 : st?.lastLine || 0;
+    const act = await claude.parseSession(transcript, fromLine);
+    if (!args.force && !claude.qualifies(act)) {
+      console.log(`[recap] ${sessionId.slice(0, 8)}: not enough new work since line ${fromLine} (${act.assistantTurns} turns, ${act.toolUses} tool calls); skipped`);
+      state.sessions[key] = { lastMtimeMs: f.mtimeMs, lastLine: fromLine, skipped: true };
+      saveState(state);
+      return 0;
+    }
+    console.log(`[recap] ${sessionId.slice(0, 8)}: lines ${fromLine}..${act.totalLines}`);
+    const { totalLines, outPath } = await buildReel(f, fromLine);
+    state.sessions[key] = { lastMtimeMs: f.mtimeMs, lastLine: totalLines, lastRecapAt: new Date().toISOString() };
+    saveState(state);
+    console.log(`[recap] done: ${outPath}`);
+    return 0;
+  });
+}

package/src/cli/setup.mjs

@@ -0,0 +1,162 @@
+// rikrok setup: the guided path. Finds a local LLM (or installs Ollama), records your
+// voice, writes ~/.rikrok/config.json, renders the demo, and offers to start the feed.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { execFileSync, spawnSync } from "node:child_process";
+import * as c from "../lib/config.mjs";
+import { setup as voiceSetup, saveConfig } from "./voice.mjs";
+
+const has = (bin) => spawnSync("which", [bin]).status === 0;
+
+// oMLX keeps its API key in ~/.omlx/settings.json; the wizard copies it so nothing else needs typing.
+function omlxKey() {
+  try {
+    const j = JSON.parse(fs.readFileSync(path.join(os.homedir(), ".omlx", "settings.json"), "utf-8"));
+    return j.auth?.api_key || "";
+  } catch {
+    return "";
+  }
+}
+
+async function models(url) {
+  try {
+    const key = /:(8800|8000)$/.test(url) ? omlxKey() : "";
+    const r = await fetch(`${url}/v1/models`, { headers: key ? { Authorization: `Bearer ${key}` } : {}, signal: AbortSignal.timeout(4000) });
+    if (!r.ok) return null;
+    const j = await r.json();
+    return (j.data || []).map((m) => m.id);
+  } catch {
+    return null;
+  }
+}
+
+export async function run(args) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const ask = async (q, d) => {
+    const a = (await rl.question(`${q}${d !== undefined ? ` [${d}]` : ""} `)).trim();
+    return a === "" ? d : a;
+  };
+  const yes = async (q, d = "y") => /^y/i.test(await ask(`${q} (y/n)`, d));
+  const cfg = {};
+  try {
+    console.log(`\nRik Rok setup. Everything stays on this machine. Ctrl-C any time.\n`);
+
+    // 1. Who writes the script
+    const claudeHere = has("claude");
+    let useClaude = false;
+    if (claudeHere) {
+      console.log("Scripts. Rik Rok can ask Claude Code to write each recap (your subscription, no local model),\nor use a local model server (Ollama, LM Studio, oMLX).");
+      useClaude = await yes("Use Claude Code to write the recaps? (easiest)");
+    }
+    if (useClaude) {
+      cfg.RIKROK_SCRIPT = "claude";
+      saveConfig(cfg);
+      if (await yes("Recap a session automatically when you leave it? (adds a SessionEnd hook to ~/.claude/settings.json)")) {
+        const { install } = await import("./hook.mjs");
+        install();
+      }
+    }
+    const candidates = useClaude ? [] : [
+      ["Ollama", "http://127.0.0.1:11434"],
+      ["LM Studio", "http://127.0.0.1:1234"],
+      ["oMLX", "http://127.0.0.1:8800"],
+      ["oMLX", "http://127.0.0.1:8000"],
+      ["current setting", c.LLM_URL],
+    ];
+    let llmUrl = null, list = null, name = null;
+    for (const [n, url] of candidates) {
+      const m = await models(url);
+      if (m) {
+        llmUrl = url;
+        list = m;
+        name = n;
+        break;
+      }
+    }
+    if (!llmUrl && !useClaude) {
+      console.log("No local LLM server found (looked for Ollama, LM Studio, oMLX).");
+      if (process.platform === "darwin" && has("brew") && (await yes("Install Ollama with Homebrew and start it?"))) {
+        execFileSync("brew", ["install", "ollama"], { stdio: "inherit" });
+        spawnSync("brew", ["services", "start", "ollama"], { stdio: "inherit" });
+        await new Promise((r) => setTimeout(r, 3000));
+        list = await models("http://127.0.0.1:11434");
+        if (list) {
+          llmUrl = "http://127.0.0.1:11434";
+          name = "Ollama";
+        }
+      }
+    }
+    if (llmUrl) {
+      console.log(`Found ${name} at ${llmUrl}${list.length ? ` with ${list.length} model(s)` : ""}.`);
+      let model = c.LLM_MODEL && list.includes(c.LLM_MODEL) ? c.LLM_MODEL : list[0] || "";
+      if (name === "Ollama" && !list.length) {
+        if (await yes("No models yet. Pull qwen3:8b (about 5 GB)?")) {
+          execFileSync("ollama", ["pull", "qwen3:8b"], { stdio: "inherit" });
+          model = "qwen3:8b";
+        }
+      } else if (list.length > 1) {
+        list.slice(0, 15).forEach((m, i) => console.log(`  ${i + 1}  ${m}`));
+        const pick = await ask("Which model for scripts? (number or name)", model);
+        model = /^\d+$/.test(pick) ? list[Number(pick) - 1] || model : pick;
+      }
+      cfg.RIKROK_LLM_URL = llmUrl;
+      cfg.RIKROK_LLM_MODEL = model;
+      if (name === "Ollama") cfg.RIKROK_LLM_EXTRA = { think: false };
+      if (name === "oMLX") cfg.RIKROK_LLM_EXTRA = { chat_template_kwargs: { enable_thinking: false } };
+      if (name === "oMLX") {
+        // One server for everything: scripts, your voice (Qwen3-TTS Base) and narration QA (whisper).
+        cfg.RIKROK_TTS_URL = llmUrl;
+        cfg.RIKROK_STT_URL = llmUrl;
+        const key = omlxKey();
+        if (key) cfg.RIKROK_LLM_KEY = key;
+        const tts = list.find((m) => /Qwen3-TTS.*Base/i.test(m));
+        const stt = list.find((m) => /whisper/i.test(m));
+        if (tts) cfg.RIKROK_CLONE_MODEL = tts;
+        else console.log("  oMLX has no Qwen3-TTS Base model loaded yet. Add mlx-community/Qwen3-TTS-12Hz-1.7B-Base-bf16 in oMLX, then `rikrok voice setup`.");
+        if (stt) cfg.RIKROK_STT_MODEL = stt;
+        else delete cfg.RIKROK_STT_URL;
+      }
+    } else if (!useClaude) {
+      console.log("Skipping the LLM for now: reels will use the template script until you set RIKROK_LLM_MODEL.");
+    }
+    if (!useClaude) cfg.RIKROK_SCRIPT = "local";
+    saveConfig(cfg);
+
+    // 2. Voice
+    console.log("\nVoice. Reels can be narrated in your own voice from a 20-second recording.");
+    if (await yes("Record your voice now?")) {
+      await voiceSetup({}, rl);
+      if (!cfg.RIKROK_TTS_URL && (await yes("No cloning server yet. Install a local one now? (rikrok voice serve, about 4.5 GB download)"))) {
+        console.log("Run `rikrok voice serve` in another terminal and leave it running; `rikrok install` keeps it running at login.");
+      }
+    } else if (process.platform === "darwin") {
+      saveConfig({ RIKROK_VOICE: "say:Samantha" });
+      console.log("Using the built-in macOS voice for now. `rikrok voice setup` whenever you like.");
+    } else {
+      saveConfig({ RIKROK_VOICE: "none" });
+      console.log("Silent reels for now (captions carry the story). `rikrok voice setup` when you have a speech server.");
+    }
+
+    // 3. Check and demo
+    console.log("\nChecking everything...");
+    spawnSync(process.execPath, [c.BIN, "doctor"], { stdio: "inherit" });
+    if (await yes("Render the demo reel now? (first run downloads a headless Chrome)")) {
+      spawnSync(process.execPath, [c.BIN, "demo"], { stdio: "inherit" });
+    }
+    if (await yes("Recap your 3 most recent sessions now?")) {
+      spawnSync(process.execPath, [c.BIN, "backfill", "--limit", "3"], { stdio: "inherit" });
+    }
+    if (process.platform === "darwin" && (await yes("Keep the watcher and feed running at login?"))) {
+      spawnSync(process.execPath, [c.BIN, "install"], { stdio: "inherit" });
+      console.log(`\nFeed: http://127.0.0.1:${c.FEED_PORT}  (see README "On your phone" to reach it from your phone)`);
+    } else {
+      console.log(`\nStart the feed any time: rikrok feed   (then http://127.0.0.1:${c.FEED_PORT})\nWatch for new sessions: rikrok watch`);
+    }
+    console.log(`\nSettings saved to ${c.CONFIG_FILE}.`);
+    return 0;
+  } finally {
+    rl.close();
+  }
+}