logdig 0.1.1 → 0.2.0

package/bin/logdig.js

@@ -2,13 +2,16 @@
 import path from "node:path";
 import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
-import { listJournaledSessions } from "../src/journal.js";
+import { listJournaledSessions, summaryCachePolicy } from "../src/journal.js";
 import { collectSessions, parseBackfillArgument, writeSessions } from "../src/session-runner.js";
 import { createPiModelClient } from "../src/pi-client.js";
 import { spawnPiProcess } from "../src/pi-process.js";
 import { environmentOverrides, loadSettings, validateSettings } from "../src/settings.js";
 import { checkDirectory } from "../src/directories.js";
 import { configureLogDig } from "../src/setup.js";
+import { editConfig } from "../src/config-menu.js";
+import { statusPrefix, statusPrefixWidth } from "../src/cli-status.js";
+import { createBackfillProgress } from "../src/backfill-progress.js";
 
 const packageRoot = fileURLToPath(new URL("../", import.meta.url));
 const relativeEntry = path.relative(process.cwd(), fileURLToPath(import.meta.url)).split(path.sep).join("/");
@@ -70,6 +73,7 @@ function runPiCommand(command, args, { cwd = process.cwd(), inherit = false, tim
 }
 
 async function showConfig() {
+  if (process.stdin.isTTY && process.stdout.isTTY) return editConfig(commandName);
   const settings = await loadSettings();
   const { filePath, configured, ...values } = settings;
   console.log(`Settings: ${filePath}${configured ? "" : " (not created yet)"}`);
@@ -82,29 +86,35 @@ async function doctor() {
   const settings = await loadSettings();
   let issues = 0;
   let warnings = 0;
-  console.log(`Settings: ${settings.filePath}${settings.configured ? " (saved)" : " (not saved; using defaults/environment)"}`);
-  const overrides = environmentOverrides();
-  if (overrides.length) console.log(`Environment overrides: ${overrides.join(", ")}`);
-
-  for (const [label, directory, writable] of [
+  const checks = [
     ["Session history", settings.sessionDirectory, false],
     ["Summary cache", settings.cacheDirectory, true],
     ["Daily notes", settings.dailyDirectory, true],
-  ]) {
+  ];
+  const statusWidth = statusPrefixWidth();
+  const labelWidth = Math.max(...checks.map(([label]) => label.length), "Pi".length);
+  const valueColumn = statusWidth + labelWidth + 2;
+  const formatLabel = (label, prefixWidth = statusWidth) => `${label}:${" ".repeat(valueColumn - prefixWidth - label.length - 1)}`;
+
+  console.log(`${statusPrefix("ok")}${formatLabel("Settings")}${settings.filePath}${settings.configured ? " (saved)" : " (not saved; using defaults/environment)"}`);
+  const overrides = environmentOverrides();
+  if (overrides.length) console.log(`Environment overrides: ${overrides.join(", ")}`);
+
+  for (const [label, directory, writable] of checks) {
     if (!directory) {
-      console.error(`FIX   ${label}: not configured. Run '${commandName} init' to choose a folder.`);
+      console.error(`${statusPrefix("error")}${formatLabel(label)}not configured. Run '${commandName} init' to choose a folder.`);
       issues++;
       continue;
     }
     try {
       const result = await checkDirectory(directory, { writable, allowMissing: writable });
-      console.log(`OK    ${label}: ${directory}${result.exists ? "" : " (will be created on a real backfill)"}`);
+      console.log(`${statusPrefix("ok")}${formatLabel(label)}${directory}${result.exists ? "" : " (will be created on a real backfill)"}`);
     } catch (error) {
       if (label === "Session history" && error.code === "ENOENT") {
-        console.warn(`WARN  ${label}: ${directory} (not found yet). Start a saved Pi session, or choose its location with '${commandName} init'.`);
+        console.warn(`${statusPrefix("warning")}${formatLabel(label)}${directory} (not found yet). Start a saved Pi session, or choose its location with '${commandName} init'.`);
         warnings++;
       } else {
-        console.error(`FIX   ${label}: ${directory} (${error.message}). Check folder permissions or choose another folder with '${commandName} init'.`);
+        console.error(`${statusPrefix("error")}${formatLabel(label)}${directory} (${error.message}). Check folder permissions or choose another folder with '${commandName} init'.`);
         issues++;
       }
     }
@@ -112,12 +122,14 @@ async function doctor() {
 
   try {
     const pi = await runPiCommand(settings.piCommand, ["--version", "--no-extensions", "--no-skills", "--no-prompt-templates", "--no-context-files", "--offline"]);
-    console.log(`OK    Pi: ${pi.stdout || pi.stderr || "available"}`);
+    console.log(`${statusPrefix("ok")}${formatLabel("Pi")}${pi.stdout || pi.stderr || "available"}`);
   } catch (error) {
-    console.error(`FIX   Pi: ${error.message}. Install Pi or set its executable in '${commandName} init' (advanced settings).`);
+    console.error(`${statusPrefix("error")}${formatLabel("Pi")}${error.message}. Install Pi or set its executable in '${commandName} init' (advanced settings).`);
     issues++;
   }
   console.log(`\nSummary model: ${settings.model || "Pi startup default"}`);
+  console.log(`Thinking: ${settings.thinkingLevel || "Pi startup default"}`);
+  console.log(`Parallel sessions: ${settings.concurrency}`);
   console.log("Authentication is checked only when you request a summary. If it fails, open Pi and run /login.");
   if (issues) {
     console.error(`\n${issues} thing${issues === 1 ? "" : "s"} to fix. Address the FIX lines above, then run '${commandName} doctor' again.`);
@@ -131,16 +143,25 @@ async function backfill(args) {
   const settings = await loadSettings();
   let daysArgument;
   let dryRun = false;
+  let skipToday = false;
   let selectedModel = settings.model;
+  let selectedThinking = settings.thinkingLevel;
   for (let index = 0; index < args.length; index++) {
     const arg = args[index];
     if (arg === "--dry-run") {
       dryRun = true;
+    } else if (arg === "--skip-today") {
+      skipToday = true;
     } else if (arg === "--model" || arg === "-m") {
       selectedModel = args[++index];
       if (!selectedModel || selectedModel.startsWith("-")) throw new Error("--model requires provider/model, or 'default' to use Pi's startup model");
     } else if (arg.startsWith("--model=")) {
       selectedModel = arg.slice("--model=".length);
+    } else if (arg === "--thinking") {
+      selectedThinking = args[++index];
+      if (!selectedThinking || selectedThinking.startsWith("-")) throw new Error("--thinking requires default, off, minimal, low, medium, high, xhigh, or max");
+    } else if (arg.startsWith("--thinking=")) {
+      selectedThinking = arg.slice("--thinking=".length);
     } else if (!arg.startsWith("-") && daysArgument === undefined) {
       daysArgument = arg;
     } else {
@@ -148,19 +169,23 @@ async function backfill(args) {
     }
   }
   selectedModel = selectedModel?.trim().toLowerCase() === "default" ? undefined : selectedModel;
-  selectedModel = validateSettings({ ...settings, model: selectedModel }).model;
+  const generationSettings = validateSettings({ ...settings, model: selectedModel, thinkingLevel: selectedThinking });
+  selectedModel = generationSettings.model;
+  selectedThinking = generationSettings.thinkingLevel;
   const range = parseBackfillArgument(daysArgument);
   requireJournalPaths(settings);
 
-  console.log(`${dryRun ? "Preview" : "Backfill"}: ${range.all ? "all saved sessions" : `last ${range.days} day${range.days === 1 ? "" : "s"}`} (${settings.timeZone})`);
+  console.log(`${dryRun ? "Preview" : "Backfill"}: ${range.all ? "all saved sessions" : `last ${range.days}${skipToday ? " complete" : ""} day${range.days === 1 ? "" : "s"}`} (${settings.timeZone})${skipToday ? " · skipping today" : ""}`);
   console.log(`Daily notes: ${settings.dailyDirectory} (${settings.dailyHeader}, ${settings.dailySummary})`);
   console.log(`Summary cache: ${path.join(settings.cacheDirectory, "Sessions")}`);
   console.log(`Model: ${selectedModel || "Pi startup default"}`);
+  console.log(`Thinking: ${selectedThinking || "Pi startup default"}`);
+  console.log(`Parallel sessions: ${settings.concurrency}`);
   console.log(dryRun
     ? "Dry run: no model requests, no file changes, and no folders created."
-    : "Only new or changed sessions need model requests. Selected, redacted history is sent to Pi's model; provider charges may apply.");
-  const found = await collectSessions({ sessionDirectory: settings.sessionDirectory, timeZone: settings.timeZone, days: range.days });
-  console.log(`\nFound ${found.sessions.length} saved Pi session${found.sessions.length === 1 ? "" : "s"}${found.firstDate ? ` to check for ${found.firstDate} through ${found.lastDate}` : ""}.`);
+    : "Only new or changed work blocks need summarizing. Selected, redacted history is sent to Pi's model; provider charges may apply.");
+  const found = await collectSessions({ sessionDirectory: settings.sessionDirectory, timeZone: settings.timeZone, days: range.days, skipToday });
+  console.log(`\nFound ${found.sessions.length} saved Pi session${found.sessions.length === 1 ? "" : "s"}${found.firstDate ? ` to check for ${found.firstDate} through ${found.lastDate}` : skipToday ? ` to check through ${found.lastDate}` : ""}.`);
   if (found.sessions.length === 0) {
     console.log(`No saved sessions found. History folder: ${settings.sessionDirectory}`);
     console.log(`If you have saved history elsewhere, choose it in '${commandName} init' (advanced settings). Otherwise, start a Pi session first.`);
@@ -171,32 +196,45 @@ async function backfill(args) {
     return;
   }
 
-  const modelClient = createPiModelClient({ ...settings, model: selectedModel });
-  const result = await writeSessions(modelClient, found.sessions, settings, {
-    ...found,
-    dryRun,
-    onProgress: ({ index, total, sessionId, project, date, time, status, error, phase, sessionPath, dailyPath }) => {
-      if (["checking", "skipped"].includes(phase)) return;
-      console.log(`[${index}/${total}] ${project || sessionId}${date ? ` · ${date} ${time}` : ""}: ${error || status}`);
-      if (dryRun && dailyPath) {
-        console.log(`  Daily note: ${dailyPath}`);
-        console.log(`  Full summary: ${sessionPath}`);
-      }
-    },
-  });
+  console.log("Results are shown in session order; processing remains parallel.");
+  console.log("One result per work period; resumed sessions may have multiple dated rows.");
+  if (!dryRun) console.log("Summarizing new or changed work may take a few minutes; a slow session can delay later rows.");
+  console.log();
+  const progress = createBackfillProgress({ total: found.sessions.length, concurrency: settings.concurrency, dryRun });
+  const interrupt = () => { cleanupProgress(); process.kill(process.pid, "SIGINT"); };
+  const terminate = () => { cleanupProgress(); process.kill(process.pid, "SIGTERM"); };
+  function cleanupProgress() {
+    progress.close();
+    process.removeListener("SIGINT", interrupt);
+    process.removeListener("SIGTERM", terminate);
+  }
+  process.once("SIGINT", interrupt);
+  process.once("SIGTERM", terminate);
+  let result;
+  try {
+    result = await writeSessions(createPiModelClient(generationSettings), found.sessions, settings, {
+      ...found, dryRun, onProgress: progress.onProgress, onSessionComplete: progress.onSessionComplete,
+    });
+  } finally {
+    cleanupProgress();
+  }
   const summaryCount = `${result.summariesCreated} ${result.summariesCreated === 1 ? "summary" : "summaries"}`;
   const entryCount = `${result.entriesAppended} daily ${result.entriesAppended === 1 ? "entry" : "entries"}`;
   const updateCount = `${result.entriesUpdated} ${result.entriesUpdated === 1 ? "entry" : "entries"}`;
+  const checkedBlocks = result.sessionResults.filter((entry) => entry.blockId);
+  const checkedSessions = new Set(checkedBlocks.map((entry) => entry.sessionId)).size;
+  console.log(`\nChecked: ${checkedBlocks.length} work block${checkedBlocks.length === 1 ? "" : "s"} across ${checkedSessions} session${checkedSessions === 1 ? "" : "s"}.`);
   console.log(dryRun
-    ? `\nWould create ${summaryCount}, reuse ${result.summariesReused}, append ${entryCount}; ${result.entriesSkipped} already present; update ${updateCount}.`
-    : `\nSaved: ${summaryCount} created, ${result.summariesReused} reused, appended ${entryCount}; ${result.entriesSkipped} already present; updated ${updateCount}.`);
-  if (result.sessionsSkipped) console.log(`${result.sessionsSkipped} session${result.sessionsSkipped === 1 ? "" : "s"} skipped (outside the date range or without journalable messages).`);
+    ? `Would create ${summaryCount}, reuse ${result.summariesReused}, append ${entryCount}; ${result.entriesSkipped} already present; update ${updateCount}.`
+    : `Saved: ${summaryCount} created, ${result.summariesReused} reused, appended ${entryCount}; ${result.entriesSkipped} already present; updated ${updateCount}.`);
+  if (result.sessionsSkipped) console.log(`${result.sessionsSkipped} session${result.sessionsSkipped === 1 ? "" : "s"} skipped (outside the date range or without journalable messages${skipToday ? ", or active today" : ""}).`);
+  if (skipToday) console.log(`${result.blocksExcludedToday} work period${result.blocksExcludedToday === 1 ? "" : "s"} excluded because of activity today (--skip-today).`);
   if (result.dates.length) {
     console.log(`Daily-note dates: ${result.dates.join(", ")}`);
-    if (dryRun && result.summariesCreated) console.log(`${result.summariesCreated} session${result.summariesCreated === 1 ? "" : "s"} would need model requests. Large sessions may require multiple requests each.`);
-    if (!result.summariesCreated && !result.errors.length) console.log("These unchanged sessions need no model requests.");
+    if (dryRun && result.summariesCreated) console.log(`${result.summariesCreated} work block${result.summariesCreated === 1 ? "" : "s"} would need summarizing. Large blocks may require multiple model requests each.`);
+    if (!result.summariesCreated && !result.errors.length) console.log("These unchanged work blocks need no model requests.");
   } else if (!result.errors.length) {
-    console.log(`Nothing to journal in this range. Try '${commandName} backfill 7 --dry-run' or '${commandName} backfill all --dry-run'.`);
+    console.log(`Nothing to journal in this range. Try '${commandName} backfill 7${skipToday ? " --skip-today" : ""} --dry-run' or '${commandName} backfill all${skipToday ? " --skip-today" : ""} --dry-run'.`);
   }
   const warnings = [...found.warnings, ...result.errors];
   if (warnings.length) {
@@ -204,39 +242,43 @@ async function backfill(args) {
     console.warn(dryRun ? "Preview incomplete. Fix the issues above, then preview again." : "Some sessions could not be saved. Successful summaries are cached. Fix the issues above and rerun the same command to retry.");
     process.exitCode = 1;
   } else if (dryRun && result.dates.length) {
-    console.log(`\nWhen you're ready: ${commandName} backfill ${range.all ? "all" : range.days}${selectedModel ? ` --model ${selectedModel}` : settings.model ? " --model default" : ""}`);
+    console.log(`\nWhen you're ready: ${commandName} backfill ${range.all ? "all" : range.days}${skipToday ? " --skip-today" : ""}${selectedModel ? ` --model ${selectedModel}` : settings.model ? " --model default" : ""}${selectedThinking ? ` --thinking ${selectedThinking}` : settings.thinkingLevel ? " --thinking default" : ""}`);
   }
 }
 
 function parseStatusArguments(args) {
   let rangeArgument;
   let json = false;
+  let skipToday = false;
   for (const arg of args) {
     if (arg === "--json") {
       json = true;
+    } else if (arg === "--skip-today") {
+      skipToday = true;
     } else if (arg.startsWith("-")) {
       throw new Error(`Unknown status argument: ${arg}. Run '${commandName} status --help'.`);
     } else if (rangeArgument !== undefined) {
-      throw new Error(`Usage: ${commandName} status [number-of-days|all] [--json]`);
+      throw new Error(`Usage: ${commandName} status [number-of-days|all] [--json] [--skip-today]`);
     } else {
       rangeArgument = arg;
     }
   }
-  return { range: parseBackfillArgument(rangeArgument, "status"), json };
+  return { range: parseBackfillArgument(rangeArgument, "status"), json, skipToday };
 }
 
 async function status(args) {
-  const { range, json } = parseStatusArguments(args);
+  const { range, json, skipToday } = parseStatusArguments(args);
   const settings = await loadSettings();
   requireJournalPaths(settings);
   const found = await collectSessions({
     sessionDirectory: settings.sessionDirectory,
     timeZone: settings.timeZone,
     days: range.days,
+    skipToday,
   });
   const previousEntries = await listJournaledSessions(settings.cacheDirectory);
   const inspection = await writeSessions(
-    { cacheKey: settings.model || "Pi default" },
+    { cachePolicy: summaryCachePolicy(settings) },
     found.sessions,
     settings,
     { ...found, dryRun: true, journaledEntries: previousEntries },
@@ -244,26 +286,31 @@ async function status(args) {
   const sessions = inspection.sessionResults
     .filter((session) => !["skipped", "error"].includes(session.status))
     .map((session) => {
-      const previous = previousEntries.get(session.sessionId) || [];
-      const status = session.entryPresent ? "logged" : previous.length ? "needs-update" : "missing";
-      const hasCurrentSource = previous.some((entry) => entry.sourceFingerprint === session.sourceFingerprint);
-      const sourceChanged = !hasCurrentSource && previous.some((entry) => entry.sourceFingerprint);
+      const previous = (previousEntries.get(session.sessionId) || []).filter((entry) => entry.blockId === session.blockId);
+      const status = session.entryPresent ? "logged" : previous.length ? "stale" : "new";
+      const summaryChanged = previous.length && !previous.some((entry) => entry.cacheFingerprint === session.cacheFingerprint);
       return {
         sessionId: session.sessionId,
+        blockId: session.blockId,
         project: session.project,
         date: session.date,
         time: session.time,
+        activityDates: session.activityDates,
+        prerequisite: session.prerequisite,
+        ...(session.continuationOf ? { continuationOf: session.continuationOf } : {}),
         status,
-        ...(status === "needs-update" ? {
-          reason: sourceChanged ? "session changed since its previous journal entry" : "previous journal entry is not current",
+        ...(status === "stale" ? {
+          reason: session.legacyEntry
+            ? "previous entry needs work-block migration"
+            : summaryChanged ? "work-block evidence or generation policy changed" : "previous journal entry is not current",
         } : {}),
-        summaryStatus: session.summaryReused ? "cached" : "needs-generation",
+        summaryStatus: session.summaryReused ? "reusable" : "needs-summarizing",
         dailyPath: session.dailyPath,
       };
     });
-  const needsUpdate = sessions.filter((session) => session.status === "needs-update").length;
-  const missing = sessions.filter((session) => session.status === "missing").length;
-  const needsModelRequest = sessions.filter((session) => session.summaryStatus === "needs-generation").length;
+  const stale = sessions.filter((session) => session.status === "stale").length;
+  const newCount = sessions.filter((session) => session.status === "new").length;
+  const needsSummarizing = sessions.filter((session) => session.summaryStatus === "needs-summarizing").length;
   const warnings = [...found.warnings, ...inspection.errors];
   const report = {
     timeframe: {
@@ -272,16 +319,18 @@ async function status(args) {
       firstDate: found.firstDate || null,
       lastDate: found.lastDate,
       timeZone: settings.timeZone,
+      ...(skipToday ? { skipToday: true } : {}),
     },
     totals: {
       scanned: found.sessions.length,
       eligible: sessions.length,
       logged: sessions.filter((session) => session.status === "logged").length,
-      needsUpdate,
-      missing,
-      needsModelRequest,
+      stale,
+      new: newCount,
+      needsSummarizing,
       skipped: inspection.sessionsSkipped,
       errors: inspection.errors.length,
+      ...(skipToday ? { excludedToday: inspection.blocksExcludedToday } : {}),
     },
     sessions,
     warnings,
@@ -290,26 +339,29 @@ async function status(args) {
   if (json) {
     console.log(JSON.stringify(report, null, 2));
   } else {
-    const label = range.all ? "all saved sessions" : `last ${range.days} calendar day${range.days === 1 ? "" : "s"}`;
-    console.log(`LogDig status: ${label} (${settings.timeZone})${found.firstDate ? ` · ${found.firstDate} through ${found.lastDate}` : ""}`);
-    console.log(`${report.totals.eligible} journalable: ${report.totals.logged} current, ${needsUpdate} need updating, ${missing} missing.`);
-    console.log(`Summaries: ${report.totals.eligible - needsModelRequest} cached, ${needsModelRequest} need model requests.`);
-    const attention = sessions.filter((session) => session.status !== "logged" || session.summaryStatus !== "cached");
+    const label = range.all ? "all saved sessions" : `last ${range.days}${skipToday ? " complete" : ""} calendar day${range.days === 1 ? "" : "s"}`;
+    console.log(`LogDig status: activity in ${label} (${settings.timeZone})${found.firstDate ? ` · ${found.firstDate} through ${found.lastDate}` : skipToday ? ` · through ${found.lastDate}` : ""}${skipToday ? " · skipping today" : ""}`);
+    if (skipToday) console.log(`${inspection.blocksExcludedToday} work period${inspection.blocksExcludedToday === 1 ? "" : "s"} excluded because of activity today (--skip-today).`);
+    console.log(`${report.totals.eligible} work block${report.totals.eligible === 1 ? "" : "s"}: ${report.totals.logged} logged, ${stale} stale, ${newCount} new.`);
+    console.log(`Summaries: ${report.totals.eligible - needsSummarizing} reusable, ${needsSummarizing} work block${needsSummarizing === 1 ? " needs" : "s need"} summarizing.`);
+    const prerequisites = sessions.filter((session) => session.prerequisite).length;
+    if (prerequisites) console.log(`Includes ${prerequisites} earlier block${prerequisites === 1 ? "" : "s"} needed for continuation links.`);
+    const attention = sessions.filter((session) => session.status !== "logged" || session.summaryStatus !== "reusable");
     if (attention.length) {
       console.log("\nNeeds attention:");
       for (const session of attention) {
-        const state = session.status === "logged" ? "logged" : session.reason || "not yet logged";
-        const summary = session.summaryStatus === "cached" ? "summary cached" : "summary needs a model request";
+        const state = session.status + (session.reason ? `: ${session.reason}` : "");
+        const summary = session.summaryStatus === "reusable" ? "summary reusable" : "needs summarizing";
         console.log(`- ${session.date} ${session.time} · ${session.project} · ${state}; ${summary} (${session.sessionId})`);
         console.log(`  Daily note: ${session.dailyPath}`);
       }
     } else if (!sessions.length) {
-      console.log("No journalable sessions found in this timeframe.");
+      console.log("No journalable work blocks found in this timeframe.");
     } else {
       console.log("Everything in this timeframe is current.");
     }
-    if (missing || needsUpdate || needsModelRequest) {
-      console.log(`\nTo update the journal: ${commandName} backfill ${range.all ? "all" : range.days}`);
+    if (newCount || stale || needsSummarizing) {
+      console.log(`\nTo update the journal: ${commandName} backfill ${range.all ? "all" : range.days}${skipToday ? " --skip-today" : ""}`);
     }
   }
 
@@ -331,19 +383,25 @@ function helpText() {
     "Commands (install with 'npm install -g logdig', or use 'npm link' in a checkout):",
     "  logdig init                         guided setup; nothing is summarized",
     "  logdig doctor                       check paths and Pi without a model request",
-    "  logdig config                       show settings and active environment overrides",
-    "  logdig backfill [N|all] [--dry-run] [--model provider/model|default]",
+    "  logdig config                       edit numbered settings; q quits (redirected: read-only)",
+    "  logdig backfill [N|all] [--dry-run] [--skip-today]",
+    "                                      [--model provider/model|default]",
+    "                                      [--thinking default|off|minimal|low|medium|high|xhigh|max]",
     "                                      journal saved sessions (default: last 3 days)",
-    "  logdig status [N|all] [--json]       show journal coverage (default: last 3 days; read-only)",
+    "  logdig status [N|all] [--json] [--skip-today]",
+    "                                      show journal coverage (default: last 3 days; read-only)",
     "  logdig pi-install | pi-uninstall     add or remove /journal integration",
     "  logdig --version                    show the installed version",
     "",
     "Preview first: --dry-run shows dates, files, and cache hits. It never calls Pi",
     "or writes files. Remove --dry-run when you're ready to summarize.",
+    "--skip-today selects N complete calendar days ending yesterday, or all past work.",
+    "Work periods with activity today are excluded entirely, including overnight work.",
     "",
     "Real backfill uses Pi's startup model and existing authentication. Tools,",
     "extensions, project context, and session saving are disabled for model requests.",
-    "Use --model default to ignore a saved model override for one run.",
+    "Use --model default or --thinking default to ignore that saved override for one run.",
+    "More thinking may improve accuracy, but can increase latency and token cost.",
     "More help: README.md and QUICKSTART.md",
   ].join("\n");
 }
@@ -401,5 +459,5 @@ async function main() {
 
 main().catch((error) => {
   console.error(`logdig: ${error.message}`);
-  process.exitCode = error.code === "LOGDIG_SETUP_CANCELLED" ? 130 : 1;
+  process.exitCode = ["LOGDIG_SETUP_CANCELLED", "LOGDIG_CONFIG_CANCELLED"].includes(error.code) ? 130 : 1;
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "logdig",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Turn saved Pi sessions into a work journal in your Obsidian daily notes.",
   "license": "MIT",
   "author": "Soleone",

package/src/backfill-progress.js

@@ -0,0 +1,108 @@
+import { stripVTControlCharacters } from "node:util";
+import { progressStatus } from "./cli-status.js";
+
+function cleanText(value) {
+  return stripVTControlCharacters(String(value ?? "")).replace(/[\x00-\x1f\x7f-\x9f]/g, " ");
+}
+
+function fitLiveLine(line, columns) {
+  const limit = Math.max(0, columns - 1);
+  let width = 0;
+  let fitted = "";
+  for (const token of line.match(/\x1b\[[0-9;]*m|./gu) || []) {
+    if (token.startsWith("\x1b[")) {
+      fitted += token;
+      continue;
+    }
+    // Conservatively allow two cells for non-ASCII text so panel rows never wrap.
+    const cells = token.codePointAt(0) > 127 ? 2 : 1;
+    if (width + cells > limit) break;
+    width += cells;
+    fitted += token;
+  }
+  return fitted + (line.includes("\x1b[") ? "\x1b[0m" : "");
+}
+
+export function createBackfillProgress({ total, concurrency, dryRun = false, stream = process.stdout, term = process.env.TERM, icons, noColor }) {
+  const live = stream.isTTY && term !== "dumb" && !dryRun;
+  const statusOptions = { isTTY: stream.isTTY, term, icons, noColor, pad: true };
+  const sessions = Array.from({ length: total }, () => ({ lines: [], complete: false, failed: false }));
+  let nextResult = 0;
+  let completed = 0;
+  let panelRows = 0;
+  let closed = false;
+
+  function clearPanel() {
+    if (!panelRows) return;
+    stream.write("\r" + "\x1b[1A\x1b[2K\r".repeat(panelRows));
+    panelRows = 0;
+  }
+
+  function sessionLabel(event, status = event.status) {
+    const position = `${String(event.index).padStart(String(total).length, "0")}/${total}`;
+    const timestamp = `${cleanText(event.date)}${event.time ? ` ${cleanText(event.time)}` : ""}`.padEnd(16);
+    return `[${position}] ${timestamp} · ${progressStatus(status, statusOptions)} · ${cleanText(event.project) || "session"} (${cleanText(event.sessionId).slice(-8)})`;
+  }
+
+  function renderPanel() {
+    if (!live || closed) return;
+    clearPanel();
+    const pending = sessions.slice(nextResult).filter((session) => session.event);
+    if (!pending.length) return;
+    const waiting = pending.filter((session) => session.complete);
+    const active = pending.filter((session) => !session.complete);
+    const capacity = Math.max(0, Math.min(concurrency, (stream.rows || 24) - 3));
+    const lines = [
+      `Completed: ${completed}/${total} sessions${waiting.length ? ` · ${waiting.length} awaiting ordered output` : ""}`,
+      ...[...active, ...waiting].slice(0, capacity).map((session) => sessionLabel(session.event, session.complete ? session.failed ? "FAILED" : "DONE" : session.event.status)),
+    ];
+    stream.write(lines.map((line) => fitLiveLine(line, stream.columns || 80)).join("\n") + "\n");
+    panelRows = lines.length;
+  }
+
+  function onProgress(event) {
+    if (closed) return;
+    const session = sessions[event.index - 1];
+    session.event = event;
+    if (event.phase === "error") session.failed = true;
+    if (["complete", "skipped", "error"].includes(event.phase)) {
+      const detail = event.error || event.reason;
+      session.lines.push(`${sessionLabel(event)}${event.prerequisite ? " · prerequisite" : ""}${detail ? `: ${cleanText(detail)}` : ""}`);
+      if (dryRun && event.dailyPath) {
+        session.lines.push(`  Daily note: ${cleanText(event.dailyPath)}`, `  Full summary: ${cleanText(event.sessionPath)}`);
+        if (event.prerequisite) session.lines.push("  Includes this earlier block to establish the continuation link.");
+      }
+    } else if (!live && event.phase === "summarizing") {
+      stream.write(`Active ${sessionLabel(event)}\n`);
+    }
+    renderPanel();
+  }
+
+  function onSessionComplete({ index }) {
+    if (closed) return;
+    const session = sessions[index - 1];
+    session.complete = true;
+    completed++;
+    clearPanel();
+    if (!live && !dryRun && index - 1 > nextResult) {
+      stream.write(`Finished ${sessionLabel(session.event, session.failed ? "FAILED" : "DONE")} (waiting for earlier results)\n`);
+    }
+    while (sessions[nextResult]?.complete) {
+      const { lines } = sessions[nextResult];
+      if (lines.length) stream.write(lines.join("\n") + "\n");
+      lines.length = 0;
+      nextResult++;
+    }
+    renderPanel();
+  }
+
+  function close() {
+    if (closed) return;
+    clearPanel();
+    closed = true;
+    if (live) stream.removeListener("resize", renderPanel);
+  }
+
+  if (live) stream.on("resize", renderPanel);
+  return { onProgress, onSessionComplete, close };
+}

package/src/cli-status.js

@@ -0,0 +1,60 @@
+const STATUS_WIDTH = 6;
+const ICON_STATUS_WIDTH = 2;
+
+const statuses = {
+  ok: { text: "OK", icon: "\uf00c", color: "32" },
+  warning: { text: "WARN", icon: "\uf071", color: "33" },
+  error: { text: "FIX", icon: "\uf00d", color: "31" },
+};
+
+const progressStatuses = {
+  CHECKING: { icon: "\uf002", color: "36" },
+  SUMMARIZING: { icon: "\uf110", color: "36" },
+  SAVED: { icon: "\uf00c", color: "32" },
+  UPDATED: { icon: "\uf040", color: "36" },
+  CURRENT: { icon: "\uf058", color: "32" },
+  DONE: { icon: "\uf00c", color: "32" },
+  SKIPPED: { icon: "\uf05e", color: "33" },
+  FAILED: { icon: "\uf00d", color: "31" },
+  PREVIEW: { icon: "\uf06e", color: "36" },
+};
+
+const PROGRESS_STATUS_WIDTH = Math.max(...Object.keys(progressStatuses).map((status) => status.length));
+
+export { STATUS_WIDTH };
+
+function useIcons({
+  isTTY = process.stdout.isTTY,
+  term = process.env.TERM,
+  icons = process.env.LOGDIG_ICONS !== "0",
+} = {}) {
+  return isTTY && term !== "dumb" && icons;
+}
+
+export function statusPrefixWidth(options) {
+  return useIcons(options) ? ICON_STATUS_WIDTH : STATUS_WIDTH;
+}
+
+export function statusPrefix(status, options = {}) {
+  const marker = statuses[status];
+  if (!marker) throw new TypeError(`Unknown CLI status: ${status}`);
+
+  if (!useIcons(options)) {
+    return `${marker.text}${" ".repeat(STATUS_WIDTH - marker.text.length)}`;
+  }
+
+  const noColor = options.noColor ?? process.env.NO_COLOR !== undefined;
+  const icon = noColor ? marker.icon : `\u001b[${marker.color}m${marker.icon}\u001b[0m`;
+  return `${icon} `;
+}
+
+export function progressStatus(status, options = {}) {
+  const marker = progressStatuses[status];
+  if (!marker) throw new TypeError(`Unknown progress status: ${status}`);
+  const text = options.pad ? status.padEnd(PROGRESS_STATUS_WIDTH) : status;
+  if (!useIcons(options)) return text;
+
+  const noColor = options.noColor ?? process.env.NO_COLOR !== undefined;
+  const icon = noColor ? marker.icon : `\u001b[${marker.color}m${marker.icon}\u001b[0m`;
+  return `${icon} ${text}`;
+}