logdig 0.1.0

package/src/pi-client.js

@@ -0,0 +1,127 @@
+import os from "node:os";
+import { JOURNAL_SYSTEM_PROMPT } from "./journal.js";
+import { spawnPiProcess } from "./pi-process.js";
+
+const MODEL_TIMEOUT_MS = 5 * 60 * 1000;
+const MAX_STDOUT = 2_000_000;
+const MAX_STDERR = 16_000;
+
+function appendTail(current, chunk, limit) {
+  const text = current + chunk.toString("utf8");
+  return text.length > limit ? text.slice(-limit) : text;
+}
+
+function piArguments(settings) {
+  const args = [
+    "--mode", "json",
+    "--no-session",
+    "--no-tools",
+    "--no-extensions",
+    "--no-skills",
+    "--no-prompt-templates",
+    "--no-context-files",
+    "--system-prompt",
+    JOURNAL_SYSTEM_PROMPT,
+  ];
+  if (settings.model) args.push("--model", settings.model);
+  args.push("--", "Use the journal request and evidence supplied on standard input. Return the requested JSON only.");
+  return args;
+}
+
+function runPiPrompt(prompt, settings, spawnProcess) {
+  return new Promise((resolve, reject) => {
+    const child = spawnPiProcess(settings.piCommand || "pi", piArguments(settings), {
+      cwd: os.tmpdir(),
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"],
+    }, { spawnProcess });
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let outputLength = 0;
+    let stderr = "";
+    let settled = false;
+    let agentSettled = false;
+    let finalMessage;
+    const usages = [];
+
+    const finish = (error, result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      if (error) reject(error);
+      else resolve(result);
+    };
+
+    const timeout = setTimeout(() => {
+      child.kill("SIGTERM");
+      finish(new Error(`Pi summarization timed out after ${MODEL_TIMEOUT_MS / 1000} seconds`));
+    }, MODEL_TIMEOUT_MS);
+
+    child.stdout.on("data", (chunk) => {
+      outputLength += chunk.length;
+      if (outputLength > MAX_STDOUT) {
+        child.kill("SIGTERM");
+        finish(new Error("Pi summarization output exceeded the size limit"));
+        return;
+      }
+      buffer += decoder.decode(chunk, { stream: true });
+      let newline;
+      while ((newline = buffer.indexOf("\n")) !== -1) {
+        const line = buffer.slice(0, newline).replace(/\r$/, "");
+        buffer = buffer.slice(newline + 1);
+        if (!line) continue;
+        let event;
+        try {
+          event = JSON.parse(line);
+        } catch {
+          child.kill("SIGTERM");
+          finish(new Error("Pi summarization returned invalid JSON events"));
+          return;
+        }
+        if (event.type === "message_end" && event.message?.role === "assistant") {
+          finalMessage = event.message;
+          if (event.message.usage) usages.push(event.message.usage);
+        }
+        if (event.type === "compaction_end" && event.result?.usage) usages.push(event.result.usage);
+        if (event.type === "agent_settled") agentSettled = true;
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr = appendTail(stderr, chunk, MAX_STDERR);
+    });
+    child.once("error", (error) => {
+      finish(new Error(`Could not start Pi at '${settings.piCommand || "pi"}': ${error.message}`));
+    });
+    child.once("close", (code, signal) => {
+      if (settled) return;
+      buffer += decoder.decode();
+      if (code !== 0) {
+        const detail = stderr.trim();
+        finish(new Error(`Pi summarization failed${signal ? ` (${signal})` : ` with exit code ${code}`}${detail ? `: ${detail}` : ""}`));
+        return;
+      }
+      if (!agentSettled || !finalMessage || buffer.trim()) {
+        finish(new Error("Pi summarization returned incomplete JSON events"));
+        return;
+      }
+      if (["error", "aborted"].includes(finalMessage.stopReason)) {
+        finish(new Error(finalMessage.errorMessage || `Pi summarization ${finalMessage.stopReason}`));
+        return;
+      }
+      const text = (finalMessage.content || []).filter((block) => block.type === "text").map((block) => block.text).join("\n").trim();
+      finish(undefined, { text, usages });
+    });
+    child.stdin.once("error", (error) => {
+      if (error.code !== "EPIPE") finish(error);
+    });
+    child.stdin.end(prompt);
+  });
+}
+
+export function createPiModelClient(settings, options = {}) {
+  return {
+    modelLabel: settings.model || "Pi startup default",
+    cacheKey: settings.model || "Pi default",
+    complete: (prompt) => runPiPrompt(prompt, settings, options.spawnProcess),
+  };
+}

package/src/pi-process.js

@@ -0,0 +1,19 @@
+import { spawn } from "node:child_process";
+
+function quoteCmdArgument(value) {
+  const text = String(value);
+  if (/[\0\r\n"]/.test(text) || text.includes("%")) {
+    throw new Error("Pi command arguments cannot contain quotes, newlines, or percent signs on Windows");
+  }
+  return `"${text}"`;
+}
+
+export function spawnPiProcess(command, args, options, { platform = process.platform, spawnProcess = spawn } = {}) {
+  if (platform !== "win32") return spawnProcess(command, args, options);
+
+  const commandLine = [command, ...args].map(quoteCmdArgument).join(" ");
+  return spawnProcess(process.env.ComSpec || "cmd.exe", ["/d", "/s", "/v:off", "/c", `"${commandLine}"`], {
+    ...options,
+    windowsVerbatimArguments: true,
+  });
+}

package/src/session-runner.js

@@ -0,0 +1,185 @@
+import { readFile, readdir, stat } from "node:fs/promises";
+import path from "node:path";
+import { appendDailyEntry, inspectDailyEntry, inspectSessionSummary, saveSessionSummary } from "./journal.js";
+import { eventsForSession, fingerprintSession, sessionFromJsonl, sessionMetrics } from "./transcript.js";
+
+function localDate(timestamp, timeZone) {
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  }).formatToParts(new Date(timestamp));
+  const values = Object.fromEntries(parts.map((part) => [part.type, part.value]));
+  return `${values.year}-${values.month}-${values.day}`;
+}
+
+function shiftDate(date, amount) {
+  const [year, month, day] = date.split("-").map(Number);
+  const shifted = new Date(Date.UTC(year, month - 1, day + amount));
+  return shifted.toISOString().slice(0, 10);
+}
+
+function sessionEndTime(session) {
+  for (let index = session.entries.length - 1; index >= 0; index--) {
+    const entry = session.entries[index];
+    const value = entry.timestamp ?? entry.message?.timestamp;
+    if (typeof value === "number") return value;
+    if (typeof value === "string") {
+      const parsed = Date.parse(value);
+      if (Number.isFinite(parsed)) return parsed;
+    }
+  }
+  const headerTime = Date.parse(session.header.timestamp || "");
+  return Number.isFinite(headerTime) ? headerTime : 0;
+}
+
+async function findSessionFiles(root) {
+  const files = [];
+  const warnings = [];
+  const pending = [root];
+
+  while (pending.length > 0) {
+    const directory = pending.pop();
+    let entries;
+    try {
+      entries = await readdir(directory, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        if (directory === root) warnings.push(`Pi history folder not found: ${root}. Start a saved Pi session or check the history path with 'logdig init'.`);
+        continue;
+      }
+      throw error;
+    }
+
+    for (const entry of entries) {
+      const fullPath = path.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name !== "subagent-artifacts") pending.push(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl") && entry.name !== "session.jsonl") {
+        files.push(fullPath);
+      }
+    }
+  }
+
+  return { files, warnings };
+}
+
+export async function collectSessions({ sessionDirectory, timeZone, days, currentSession }) {
+  const { files, warnings } = await findSessionFiles(sessionDirectory);
+  const currentId = currentSession?.header.id;
+  const currentPath = currentSession?.sourcePath;
+  const today = localDate(Date.now(), timeZone);
+  const firstDate = days ? shiftDate(today, 1 - days) : undefined;
+  const modifiedAfter = days ? Date.now() - (days + 1) * 86400000 : undefined;
+  const sessions = [];
+  const seen = new Set();
+
+  for (const file of files) {
+    if (file === currentPath) continue;
+
+    try {
+      const fileStat = await stat(file);
+      if (modifiedAfter && fileStat.mtimeMs < modifiedAfter) continue;
+      const session = sessionFromJsonl(await readFile(file, "utf8"), file);
+      if (session.header.id === currentId || seen.has(session.header.id)) continue;
+      session.fingerprint = fingerprintSession(session);
+      seen.add(session.header.id);
+      sessions.push(session);
+    } catch (error) {
+      warnings.push(`${path.basename(file)}: ${error.message}`);
+    }
+  }
+
+  if (currentSession && !seen.has(currentSession.header.id)) sessions.push(currentSession);
+  sessions.sort((left, right) => sessionEndTime(left) - sessionEndTime(right) || left.header.id.localeCompare(right.header.id));
+  return { sessions, warnings, firstDate, lastDate: today };
+}
+
+export async function writeSessions(modelClient, sessions, settings, range = {}) {
+  let summariesCreated = 0;
+  let summariesReused = 0;
+  let entriesAppended = 0;
+  let entriesSkipped = 0;
+  let sessionsSkipped = 0;
+  const dates = new Set();
+  const dailyPaths = new Set();
+  const errors = [];
+
+  for (const [index, session] of sessions.entries()) {
+    const progress = { index: index + 1, total: sessions.length, sessionId: session.header.id };
+    try {
+      const events = eventsForSession(session, settings.timeZone);
+      const lastUserEvent = events.findLast((event) => event.kind === "user intent");
+      const closingEvent = lastUserEvent || events.at(-1);
+      if (!closingEvent || (range.firstDate && (closingEvent.date < range.firstDate || closingEvent.date > range.lastDate))) {
+        sessionsSkipped++;
+        range.onProgress?.({ ...progress, phase: "skipped", status: closingEvent ? "outside date range" : "no journalable events" });
+        continue;
+      }
+
+      const journalSession = {
+        ...session,
+        date: closingEvent.date,
+        time: closingEvent.time,
+        timezone: settings.timeZone,
+        project: events[0].project || "unknown project",
+        events,
+        sourceFingerprint: session.fingerprint || fingerprintSession(session),
+      };
+      Object.assign(progress, { project: journalSession.project, date: journalSession.date, time: journalSession.time });
+      range.onProgress?.({ ...progress, phase: "checking", status: "checking saved summary" });
+      const cached = range.dryRun
+        ? await inspectSessionSummary(modelClient, settings.cacheDirectory, journalSession)
+        : await saveSessionSummary(modelClient, settings.cacheDirectory, journalSession, {
+          onGenerate: () => range.onProgress?.({ ...progress, phase: "summarizing", status: "summarizing with Pi; large sessions may take a few minutes" }),
+        });
+      if (cached.reused) summariesReused++;
+      else summariesCreated++;
+
+      const entry = {
+        date: journalSession.date,
+        time: journalSession.time,
+        project: journalSession.project,
+        sessionId: journalSession.header.id,
+        cacheFingerprint: cached.cacheFingerprint,
+        sessionPath: cached.sessionPath,
+        sourceFingerprint: journalSession.sourceFingerprint,
+        metrics: sessionMetrics(journalSession),
+        summaryLevel: settings.dailySummary,
+        summary: cached.summary?.[settings.dailySummary],
+      };
+      const dailyEntry = range.dryRun
+        ? await inspectDailyEntry(settings.dailyDirectory, settings.dailyHeader, entry)
+        : await appendDailyEntry(settings.dailyDirectory, settings.dailyHeader, entry);
+      if (dailyEntry.appended) entriesAppended++;
+      else entriesSkipped++;
+      dates.add(journalSession.date);
+      dailyPaths.add(dailyEntry.dailyPath);
+      range.onProgress?.({
+        ...progress,
+        phase: "complete",
+        sessionPath: cached.sessionPath,
+        dailyPath: dailyEntry.dailyPath,
+        status: range.dryRun
+          ? `${cached.reused ? "would reuse summary" : "would summarize with Pi"}, ${dailyEntry.appended ? "would append entry" : "entry already present"}`
+          : `${cached.reused ? "summary reused" : "summary created"}, ${dailyEntry.appended ? "entry appended" : "entry already present"}`,
+      });
+    } catch (error) {
+      errors.push(`${session.header.id}: ${error.message}`);
+      range.onProgress?.({ ...progress, phase: "error", error: error.message });
+    }
+  }
+
+  return { summariesCreated, summariesReused, entriesAppended, entriesSkipped, sessionsSkipped, dates: [...dates].sort(), dailyPaths: [...dailyPaths].sort(), errors };
+}
+
+export function parseBackfillArgument(argument = "") {
+  const value = argument.trim().toLowerCase() || "3";
+  if (value === "all") return { all: true };
+  const days = Number(value);
+  if (!/^\d+$/.test(value) || !Number.isInteger(days) || days < 1 || days > 3650) {
+    throw new Error("Usage: logdig backfill [number-of-days|all]. Choose 1 to 3650 days, or 'all'.");
+  }
+  return { days };
+}

package/src/settings.js

@@ -0,0 +1,155 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+
+const ENVIRONMENT_SETTINGS = [
+  ["PI_JOURNAL_DIR", "cacheDirectory"],
+  ["PI_JOURNAL_DAILY_DIR", "dailyDirectory"],
+  ["PI_JOURNAL_DAILY_HEADER", "dailyHeader"],
+  ["PI_JOURNAL_DAILY_SUMMARY", "dailySummary"],
+  ["PI_JOURNAL_TIMEZONE", "timeZone"],
+  ["PI_JOURNAL_MODEL", "model"],
+  ["PI_JOURNAL_PI_COMMAND", "piCommand"],
+  ["PI_CODING_AGENT_SESSION_DIR", "sessionDirectory"],
+];
+
+function expandPath(value, home) {
+  if (value === "~") return home;
+  if (value.startsWith("~/")) return path.join(home, value.slice(2));
+  return path.resolve(value);
+}
+
+export function settingsFilePath({ platform = process.platform, env = process.env, home = homedir() } = {}) {
+  if (env.LOGDIG_CONFIG_PATH) return expandPath(env.LOGDIG_CONFIG_PATH, home);
+
+  if (platform === "win32") {
+    return path.join(env.APPDATA || path.join(home, "AppData", "Roaming"), "LogDig", "settings.json");
+  }
+  if (platform === "darwin") {
+    return path.join(home, "Library", "Application Support", "LogDig", "settings.json");
+  }
+  return path.join(env.XDG_CONFIG_HOME || path.join(home, ".config"), "logdig", "settings.json");
+}
+
+function defaults({ env = process.env, home = homedir() } = {}) {
+  const agentDirectory = env.PI_CODING_AGENT_DIR || env.PI || path.join(home, ".pi", "agent");
+  return {
+    version: 1,
+    cacheDirectory: undefined,
+    dailyDirectory: undefined,
+    dailyHeader: "# Projects",
+    dailySummary: "small",
+    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC",
+    sessionDirectory: path.join(expandPath(agentDirectory, home), "sessions"),
+    piCommand: "pi",
+    autoCapture: env.PI_JOURNAL_AUTO === "1",
+  };
+}
+
+export function validateSettings(settings, { requirePaths = false, home = homedir() } = {}) {
+  if (settings.version !== undefined && settings.version !== 1) throw new Error(`Unsupported settings version: ${settings.version}`);
+  if (requirePaths && !settings.cacheDirectory) throw new Error("Set cacheDirectory to a LogDig save folder");
+  if (requirePaths && !settings.dailyDirectory) throw new Error("Set dailyDirectory to the folder containing YYYY-MM-DD.md notes");
+  if (settings.dailySummary !== undefined) {
+    if (typeof settings.dailySummary !== "string" || !settings.dailySummary.trim()) throw new Error("dailySummary must be small, medium, or large");
+    settings.dailySummary = settings.dailySummary.trim().toLowerCase();
+    if (!["small", "medium", "large"].includes(settings.dailySummary)) throw new Error("dailySummary must be small, medium, or large");
+  }
+  if (typeof settings.dailyHeader !== "string" || !settings.dailyHeader.trim()) {
+    throw new Error("dailyHeader must be one Markdown heading, such as '# Projects'");
+  }
+  settings.dailyHeader = settings.dailyHeader.trim();
+  if (!/^#{1,6}\s+[^\r\n]+$/.test(settings.dailyHeader)) {
+    throw new Error("dailyHeader must be one Markdown heading, such as '# Projects'");
+  }
+  if (typeof settings.timeZone !== "string" || !settings.timeZone.trim()) throw new Error("timeZone must be a valid timezone");
+  try {
+    new Intl.DateTimeFormat("en", { timeZone: settings.timeZone });
+  } catch {
+    throw new Error(`Invalid timeZone: ${settings.timeZone}`);
+  }
+  for (const key of ["cacheDirectory", "dailyDirectory", "sessionDirectory"]) {
+    if (settings[key] !== undefined && (typeof settings[key] !== "string" || !settings[key].trim())) {
+      throw new Error(`${key} must be a non-empty path`);
+    }
+    if (settings[key]) settings[key] = expandPath(settings[key].trim(), home);
+  }
+  if (settings.model !== undefined) {
+    if (typeof settings.model !== "string" || /[\r\n]/.test(settings.model)) throw new Error("model must use provider/model format");
+    settings.model = settings.model.trim();
+    const separator = settings.model.indexOf("/");
+    if (separator < 1 || separator === settings.model.length - 1) throw new Error("model must use provider/model format");
+    const provider = settings.model.slice(0, separator).trim();
+    const modelId = settings.model.slice(separator + 1).trim();
+    if (!provider || !modelId) throw new Error("model must use provider/model format");
+    settings.model = `${provider}/${modelId}`;
+  }
+  if (settings.autoCapture !== undefined && typeof settings.autoCapture !== "boolean") {
+    throw new Error("autoCapture must be a boolean");
+  }
+  if (typeof settings.piCommand !== "string" || !settings.piCommand.trim() || /[\r\n]/.test(settings.piCommand)) {
+    throw new Error("piCommand must be a command or executable path");
+  }
+  settings.piCommand = settings.piCommand.trim();
+  if (settings.piCommand === "~" || settings.piCommand.startsWith("~/")) {
+    settings.piCommand = expandPath(settings.piCommand, home);
+  } else if (settings.piCommand.includes("/") || settings.piCommand.includes("\\")) {
+    settings.piCommand = path.resolve(settings.piCommand);
+  }
+  return settings;
+}
+
+export function environmentOverrides(env = process.env) {
+  return [...ENVIRONMENT_SETTINGS.map(([variable]) => variable), "PI_JOURNAL_AUTO"]
+    .filter((variable) => env[variable] !== undefined && (env[variable] !== "" || variable === "PI_JOURNAL_AUTO"));
+}
+
+export async function loadSettings(options = {}) {
+  const env = options.env || process.env;
+  const home = options.home || homedir();
+  const filePath = options.filePath || settingsFilePath({ platform: options.platform, env, home });
+  let stored = {};
+  let configured = false;
+
+  try {
+    stored = JSON.parse(await readFile(filePath, "utf8"));
+    configured = true;
+  } catch (error) {
+    if (error.code !== "ENOENT") throw new Error(`Could not read LogDig settings at ${filePath}: ${error.message}`);
+  }
+
+  if (!stored || typeof stored !== "object" || Array.isArray(stored)) {
+    throw new Error(`LogDig settings at ${filePath} must contain a JSON object`);
+  }
+
+  const settings = { ...defaults({ env, home }), ...stored };
+  for (const [variable, key] of ENVIRONMENT_SETTINGS) {
+    if (env[variable] !== undefined && env[variable] !== "") settings[key] = env[variable];
+  }
+  if (env.PI_JOURNAL_AUTO !== undefined) settings.autoCapture = env.PI_JOURNAL_AUTO === "1" || env.PI_JOURNAL_AUTO === "true";
+  validateSettings(settings);
+  return { ...settings, filePath, configured };
+}
+
+export async function saveSettings(settings, filePath = settings.filePath || settingsFilePath()) {
+  const persisted = {
+    version: 1,
+    cacheDirectory: settings.cacheDirectory,
+    dailyDirectory: settings.dailyDirectory,
+    dailyHeader: settings.dailyHeader || "# Projects",
+    dailySummary: settings.dailySummary || "small",
+    timeZone: settings.timeZone || Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC",
+    sessionDirectory: settings.sessionDirectory,
+    piCommand: settings.piCommand || "pi",
+    autoCapture: settings.autoCapture === true,
+    ...(settings.model ? { model: settings.model } : {}),
+  };
+  validateSettings(persisted, { requirePaths: true });
+
+  await mkdir(path.dirname(filePath), { recursive: true });
+  const tempPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  await writeFile(tempPath, `${JSON.stringify(persisted, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+  await rename(tempPath, filePath);
+  return filePath;
+}

package/src/setup.js

@@ -0,0 +1,122 @@
+import { homedir } from "node:os";
+import path from "node:path";
+import { createInterface } from "node:readline";
+import { stdin, stdout } from "node:process";
+import { checkDirectory } from "./directories.js";
+import { environmentOverrides, saveSettings, validateSettings } from "./settings.js";
+
+function yesNo(value) {
+  if (/^(y|yes)$/i.test(value)) return true;
+  if (/^(n|no)$/i.test(value)) return false;
+  throw new Error("Please enter yes or no");
+}
+
+export async function configureLogDig(settings, commandName = "logdig") {
+  console.log([
+    "LogDig setup",
+    "A small work journal from your Pi sessions, in the notes you already use.",
+    "",
+    "Press Enter to keep a default. Ctrl+C leaves your settings unchanged.",
+    "No history is summarized and no daily notes are written during setup.",
+    `Settings: ${settings.filePath}`,
+    "",
+  ].join("\n"));
+  const overrides = environmentOverrides();
+  if (overrides.length) {
+    console.warn(`Environment overrides are active: ${overrides.join(", ")}. They will still take precedence over saved settings.`);
+  }
+
+  const rl = createInterface({ input: stdin, output: stdout });
+  const answers = rl[Symbol.asyncIterator]();
+  let interrupted = false;
+  const cancel = () => { interrupted = true; rl.close(); };
+  rl.on("SIGINT", cancel);
+  process.once("SIGINT", cancel);
+  let nextSettings;
+  let installExtension;
+
+  try {
+    const ask = async (label, defaultValue, parse = (value) => value) => {
+      while (true) {
+        stdout.write(`${label}${defaultValue ? ` [${defaultValue}]` : ""}: `);
+        const answer = await answers.next();
+        if (interrupted) {
+          const error = new Error("Setup cancelled. Your settings were not changed.");
+          error.code = "LOGDIG_SETUP_CANCELLED";
+          throw error;
+        }
+        if (answer.done) throw new Error(`Setup ended early. Your settings were not changed. Run '${commandName} init' to try again.`);
+        try {
+          return await parse(answer.value.trim() || defaultValue || "");
+        } catch (error) {
+          console.log(`  ${error.message}. Let's try that again.`);
+        }
+      }
+    };
+    const field = (key, value) => validateSettings({ ...settings, [key]: value })[key];
+    const folder = async (key, value, writable) => {
+      const directory = field(key, value);
+      await checkDirectory(directory, { writable, allowMissing: true });
+      return directory;
+    };
+
+    console.log("1. Your notes");
+    console.log("Choose the folder holding YYYY-MM-DD.md daily notes, not the vault root unless your notes live there.");
+    const dailyDirectory = await ask("Daily-notes folder", settings.dailyDirectory || path.join(homedir(), "Obsidian", "Daily"),
+      (value) => folder("dailyDirectory", value, true));
+    console.log("The cache keeps all three summary lengths. Put it inside your vault to browse it in Obsidian.");
+    const cacheDirectory = await ask("Summary cache folder", settings.cacheDirectory || path.join(path.dirname(dailyDirectory), "LogDig"),
+      (value) => folder("cacheDirectory", value, true));
+    console.log("Entries are grouped by project, then by time, under this heading. Use # Projects to keep your personal log separate.");
+    const dailyHeader = await ask("Heading for journal entries", settings.dailyHeader, (value) => field("dailyHeader", value));
+    console.log("Small: a few sentences. Medium: goal, progress, and next steps. Large: a short timeline.");
+    const dailySummary = await ask("Daily summary (small/medium/large)", settings.dailySummary, (value) => field("dailySummary", value));
+    const timeZone = await ask("Timezone", settings.timeZone, (value) => field("timeZone", value));
+
+    console.log("\n2. Pi and privacy");
+    console.log(`History: ${settings.sessionDirectory}`);
+    console.log(`Model: ${settings.model || "Pi's default (your active model for /journal)"}`);
+    const advanced = await ask("Change history folder, Pi executable, or model? (yes/no)", "no", yesNo);
+    let { sessionDirectory, piCommand, model } = settings;
+    if (advanced) {
+      sessionDirectory = await ask("Pi session-history folder", sessionDirectory,
+        (value) => folder("sessionDirectory", value, false));
+      piCommand = await ask("Pi executable", piCommand, (value) => field("piCommand", value));
+      model = await ask("Model (provider/model), or 'default'", model || "default",
+        (value) => value.toLowerCase() === "default" ? undefined : field("model", value));
+    }
+    console.log("Summarizing sends selected, redacted history to your Pi model. Provider charges may apply.");
+    console.log("Common secrets are redacted, but this is not a complete secret scanner. Pi keeps your credentials.");
+    console.log("Automatic capture may delay shutdown. Leave it off until you've tried a manual run.");
+    const autoCapture = await ask("Capture on Pi shutdown? (yes/no)", settings.autoCapture ? "yes" : "no", yesNo);
+    installExtension = await ask("Install the Pi extension for /journal? (yes/no)", "no", yesNo);
+
+    nextSettings = { ...settings, cacheDirectory, dailyDirectory, dailyHeader, dailySummary, timeZone, sessionDirectory, piCommand, model, autoCapture };
+    console.log([
+      "",
+      "Ready to save",
+      `  Daily notes: ${dailyDirectory}/YYYY-MM-DD.md`,
+      `  Heading:     ${dailyHeader}`,
+      `  Summary:     ${dailySummary}, in ${timeZone}`,
+      `  Cache:       ${path.join(cacheDirectory, "Sessions")}`,
+      `  History:     ${sessionDirectory}`,
+      `  Pi:          ${piCommand}`,
+      `  Model:       ${model || "Pi default"}`,
+      `  Auto-capture: ${autoCapture ? "on" : "off"}`,
+      `  Extension:   ${installExtension ? "install now" : "leave unchanged"}`,
+      "Missing note and cache folders will be created on your first real backfill.",
+    ].join("\n"));
+    if (!await ask("Save these settings? (yes/no)", "yes", yesNo)) {
+      console.log("Setup cancelled. Your settings were not changed.");
+      return undefined;
+    }
+  } finally {
+    process.removeListener("SIGINT", cancel);
+    rl.close();
+  }
+
+  const configPath = await saveSettings(nextSettings, settings.filePath);
+  console.log(`\nSaved settings: ${configPath}`);
+  console.log(`Next: ${commandName} doctor, then ${commandName} backfill 1 --dry-run. Preview is free and changes nothing.`);
+  return { settings: nextSettings, installExtension };
+}