logdig 0.1.0 → 0.1.2

package/QUICKSTART.md

@@ -19,7 +19,7 @@ In the wizard:
 - **Summary cache:** choose `My Vault/LogDig` to keep the full summaries visible in Obsidian.
 - **Heading and length:** `# Projects` and `small` are a good first try. Your personal `# Log` stays separate.
 - **Timezone:** check that this is the timezone you journal in.
-- **Advanced settings:** leave them alone unless you use a custom Pi history folder, executable, or model.
+- **Advanced settings:** choose a custom Pi history folder, executable, model, or thinking level here. Thinking defaults to no LogDig override; choose an explicit level such as `max` for a cost-first reasoning model if you are willing to wait longer.
 - **Automatic capture:** choose **no** for now.
 - **Pi extension:** optional. The CLI works without it.
 
@@ -29,12 +29,13 @@ Press Enter to accept defaults. A typo only re-asks that question. Review the ch
 
 ```sh
 logdig doctor
+logdig status 7
 logdig backfill 1 --dry-run
 ```
 
-The preview shows projects, dates, destination files, cache hits, and which sessions need summarizing. **No model requests, file changes, or new folders.** It does not display transcript excerpts.
+`status` counts **logged**, **stale**, and **new** work blocks, with reusable summaries counted separately from blocks needing summarization. It is read-only. The backfill preview shows projects, dates, destination files, cache hits, and which blocks need summarizing. **Neither command makes model requests or changes files.** The preview does not display transcript excerpts.
 
-`1` means today in your chosen timezone. If nothing happened today:
+`1` means conversation activity today in your chosen timezone. Continuous overnight work stays on its starting day, so today's backfill may update yesterday's note. Resuming on a later date after at least four hours without conversation activity starts a linked continuation entry. If its preceding snapshot is missing, preview explicitly includes the earlier block needed for that link. If nothing happened today:
 
 ```sh
 logdig backfill 7 --dry-run
@@ -50,11 +51,15 @@ Once the preview looks right, run the same range without `--dry-run`:
 logdig backfill 1
 ```
 
+To override the model and thinking level for one run, use `logdig backfill 1 --model provider/model --thinking max`. Use `--thinking default` to ignore a saved thinking override. More thinking may improve factual reconstruction, but can increase latency and token cost; available effort depends on the model. Saved thinking preferences also apply to `/journal` and automatic capture.
+
 This may send selected, redacted history to your Pi model and incur provider charges. Pi uses its existing authentication. If authentication fails, open Pi, run `/login`, then retry. Common secrets are redacted, but redaction is not a complete secret scanner.
 
-Open the daily-note date printed by the command. You will find project subheadings under `# Projects`, with timestamped summaries grouped beneath each one. Your existing text stays in place. Click a timestamp to open that entry's saved snapshot of all three summary lengths, or browse `<cache folder>/Sessions/<session-id>.md` for the latest session summary.
+Open the daily-note date printed by the command. You will find project subheadings under `# Projects`, with timestamped summaries grouped beneath each one. Your existing text stays in place. Click a timestamp to open that entry's saved snapshot of all three summary lengths, or browse `<cache folder>/Sessions/` for the latest work-block summaries.
+
+Repeating unchanged work reuses its summary and does not insert that entry again. Session renames and other bookkeeping do not trigger regeneration. New work in the same block updates that block's row; continuation blocks get separate linked entries. Manually edited blurbs and older snapshots in `Entries/` are preserved. Run only one save at a time against your journal, and let vault sync finish first.
 
-Repeating an unchanged session reuses its summary and does not insert that entry again. Updated sessions or changed summary settings can append a new version. Run only one save at a time against your journal, and let vault sync finish first.
+If you used the older whole-session journal format, the first real save regenerates summaries for selected work blocks and migrates the old rows while keeping their linked snapshots. Preview before saving to check the dates and model work.
 
 ## Optional: use `/journal` inside Pi
 

package/README.md

@@ -2,7 +2,7 @@
 
 Remember what you worked on, without writing another status report.
 
-LogDig turns saved [Pi](https://pi.dev) sessions into short entries in your Obsidian daily notes. Your handwritten content stays in place. Each session also gets a cached Markdown note with **Small**, **Medium**, and **Large** summaries, so the details are there when you want them.
+LogDig turns saved [Pi](https://pi.dev) sessions into short entries in your Obsidian daily notes. Your handwritten content stays in place. Each work block also gets a cached Markdown note with **Small**, **Medium**, and **Large** summaries, so the details are there when you want them.
 
 No build step, runtime dependencies, or separate model credentials. Try a safe preview before sending any history to a model.
 
@@ -33,7 +33,7 @@ For a comfortable first try:
 - Check the timezone. It determines the journal date and time.
 - Leave automatic capture **off** until you have tried a manual run. Pi integration is optional.
 
-`doctor` checks folder access and Pi availability without requesting a summary. It reports broken paths and a missing Pi executable together, with a next step for each.
+`doctor` checks folder access and Pi availability without requesting a summary. It reports broken paths and a missing Pi executable together, with a next step for each. Interactive terminals use colored Nerd Font status icons; set `LOGDIG_ICONS=0` for text markers, and `NO_COLOR` to disable color.
 
 **`--dry-run` never calls Pi, writes files, or creates folders.** It shows the projects, dates, destination files, matching cached summaries, and sessions that would need model requests. The preview does not print transcript excerpts.
 
@@ -43,7 +43,7 @@ When the preview looks right:
 logdig backfill 1
 ```
 
-This journals sessions whose last user message was **today in your configured timezone**, not a rolling 24-hour window. If today is quiet, preview seven days instead:
+This journals work blocks with conversation activity **today in your configured timezone**, not a rolling 24-hour window. Overnight work can update yesterday's note without moving it to today. If today is quiet, preview seven days instead:
 
 ```sh
 logdig backfill 7 --dry-run
@@ -61,7 +61,8 @@ My Vault/
 │   └── YYYY-MM-DD.md             your writing, plus project-grouped summaries under # Projects
 └── LogDig/
     ├── Sessions/
-    │   └── <session-id>.md       latest cached summary and provenance
+    │   ├── <session-id>.md       latest summary of the first work block
+│   └── <session-id>-<block-id>.md  latest summary of each continuation
     └── Entries/
         └── <entry-id>.md         snapshot of all three layers for a journal entry
 ```
@@ -88,13 +89,30 @@ More work on the same project.
 **[[<single-entry-id>|23:13]]**: One entry stays compact.
 ```
 
-A project with one entry puts the timestamp inline at the start of its summary. When a second entry arrives, both timestamps move to separate lines. Summary wording is preserved, including any edits you made.
+Each entry keeps its timestamp inline at the start of its summary, even when a project has multiple entries. Summary wording is preserved, including any edits you made.
 
-Obsidian displays each link as just the timestamp; clicking it opens that entry's detailed summary. The detailed note has two compact frontmatter properties when available: `sessionUsage` for recorded Pi-session usage and `logUsage` for LogDig's summary-generation requests, including intermediate chunks. Each shows cost, cached input, uncached input, output, and elapsed time, for example `"$3.73 ⚡12.2M ↑747k ↓62k · 1h 55m"`. Session duration is wall-clock time, including idle periods; LogDig duration is the time spent generating that summary. The original session and LogDig calls are counted separately. Historical summaries made before usage tracking have no `logUsage`; their cost cannot be recovered without making new requests. Unknown cost or token counts are omitted, not shown as zero. Keep the summary cache inside your vault so Obsidian can resolve these links. Daily summaries do not create headings or code fences; structured detail stays in the linked note. Custom section headings are supported, with project subheadings one level deeper (or bold project labels beneath a level-six heading).
+Obsidian displays each link as just the timestamp; clicking it opens that entry's detailed summary. The detailed note has two compact frontmatter properties when available: `sessionUsage` for recorded Pi usage within that work block and `logUsage` for LogDig's summary-generation requests, including intermediate chunks. Each shows cost, cached input, uncached input, output, and elapsed time, for example `"$3.73 ⚡12.2M ↑747k ↓62k · 1h 55m"`. Work-block duration is wall-clock time, including idle periods within the block; LogDig duration is the time spent generating that summary. The original session and LogDig calls are counted separately. Historical summaries made before usage tracking have no `logUsage`; their cost cannot be recovered without making new requests. Unknown cost or token counts are omitted, not shown as zero. Keep the summary cache inside your vault so Obsidian can resolve these links. Daily summaries do not create headings or code fences; structured detail stays in the linked note. Custom section headings are supported, with project subheadings one level deeper (or bold project labels beneath a level-six heading).
 
-The **last user message** supplies the date and time, even if the assistant finishes after midnight. Alternate session branches are included as explorations, not assumed to be the final result.
+### Overnight work and continuations
 
-Unchanged sessions reuse their summaries. The identifier in each timestamp link prevents duplicate entries, without HTML comments. Older project-name links and comment-wrapped entries are still recognized. Changing the default does not override existing saved heading preferences; rerun setup to change them. Changing the session, timezone, explicit model, summary level, or heading can append a **new version** rather than replace an earlier journal entry. Linked entry notes keep their original summary even when the latest session cache changes. Handwritten content and summary wording are preserved; an inline timestamp can be expanded when its project gains another entry. Headings inside frontmatter or fenced code are not insertion targets.
+A saved Pi session can contain several **work blocks**. A new block starts only at a new user message when both conditions hold:
+
+- Its local date is later than the current block's starting date.
+- At least **four hours** have passed since the preceding conversation activity. Assistant messages and tool results count as activity; session names, model switches, labels, usage records, and extension bookkeeping do not.
+
+The block's **starting date and time** supply its journal timestamp. Continuous work from 10pm to 2am stays one entry on the starting day. Returning at 11am after a long break creates a separate entry on the new day, with a **Continues** link to the preceding block's saved snapshot. Repeated saves are checkpoints, not boundaries. Alternate session branches are included as explorations, not assumed to be the final result.
+
+Date ranges select actual conversation activity, not just assigned journal dates. Today's backfill therefore catches assistant completion or continued work after midnight and updates yesterday's entry. If a selected continuation has no preceding snapshot, LogDig includes the missing earlier block(s) as prerequisites. Status and preview explicitly show these additions, including their summary-generation cost implications.
+
+### Summary reuse and existing journals
+
+Summary freshness is based on the selected, redacted evidence and bounded earlier context, plus summary-processing version, timezone, and configured generation policy. Earlier context is drawn from the preceding block's evidence, not its generated summary, and is marked as background rather than work to repeat. Metadata-only changes do not trigger model requests; usage totals can refresh separately. Explicit LogDig model or thinking-level changes invalidate summaries, while changes to Pi's defaults do not force regeneration under the default policy.
+
+The identifier in each timestamp link prevents duplicate entries, without HTML comments. Older project-name links and comment-wrapped entries are still recognized. When a block evolves, LogDig replaces only that block's daily-note row with a link to the latest summary. Earlier blocks stay in place. Previous linked summary snapshots remain in `Entries/`, and manually edited daily summaries are preserved; usage metadata may be refreshed without regenerating the prose.
+
+**Upgrading from whole-session journaling:** old summaries use an incompatible cache key and need one regeneration per selected work block. A real save assigns legacy entries to their work blocks using their recorded journal timestamp, updates or relocates their rows as needed, and keeps the original linked snapshots. Run `backfill N --dry-run` first to see the scope and model work. Status and preview never migrate files.
+
+Saved heading preferences are not overridden by new defaults; rerun setup to change them. New entries keep their timestamps inline even when their project already has entries. Headings inside frontmatter or fenced code are not insertion targets.
 
 Missing daily-note and cache folders are created only by a real save. Raw Pi history stays in Pi's storage.
 
@@ -111,15 +129,21 @@ logdig backfill                     journal the last 3 calendar days
 logdig backfill 7 --dry-run          preview seven days without changing anything
 logdig backfill all --dry-run        preview every discoverable saved session
 logdig backfill 7                    journal seven days
-logdig backfill 7 --model provider/model
+logdig backfill 7 --model provider/model --thinking max
 logdig backfill 7 --model default    ignore a saved model override for this run
+logdig backfill 7 --thinking default ignore a saved thinking override for this run
+logdig status                       show coverage for the last 3 calendar days
+logdig status 7                     show coverage for seven days
+logdig status all --json            output coverage for every saved session as JSON
 logdig pi-install                   install the /journal extension
 logdig pi-uninstall                 remove it without deleting notes or summaries
 ```
 
-`--help` works before setup, including `logdig init --help` and `logdig backfill --help`.
+`--help` works before setup, including `logdig init --help`, `logdig backfill --help`, and `logdig status --help`.
+
+`status` is a read-only coverage check. It counts work blocks: **logged** means the expected entry is present, **stale** means a previous snapshot exists but the entry needs updating, and **new** means no previous block snapshot was found. Summaries are reported separately as reusable or needing summarization. These are block counts, not exact request counts. It selects blocks by conversation activity in your configured timezone, including overnight updates and any missing continuation prerequisites. It never calls a model or writes files; scan warnings make the command exit nonzero so incomplete coverage is clear. JSON retains `sessions` as the result array, with one row per work block and both `sessionId` and `blockId`; totals use `logged`, `stale`, `new`, and `needsSummarizing`.
 
-New summaries may incur provider charges. Large sessions are summarized in chunks and may need several model requests each. Backfill shows which project it is working on before the model completes. Failed sessions are reported, other sessions continue, and the command exits nonzero if anything needs attention. Fix the issue and rerun the same command; completed summaries are reused, even if a previous attempt failed to write a daily note.
+New summaries may incur provider charges. Large work blocks are summarized in chunks and may need several model requests each. Backfill shows which project it is working on before the model completes. Failed sessions are reported, other sessions continue, and the command exits nonzero if anything needs attention. Fix the issue and rerun the same command; completed summaries are reused, even if a previous attempt failed to write a daily note.
 
 Run one backfill at a time against a given journal. The extension prevents overlapping saves within one Pi process, but separate CLI/Pi processes and external note editors are not coordinated. Let an existing save or vault sync finish first.
 
@@ -152,6 +176,10 @@ CLI backfill uses Pi's normal startup model and existing authentication unless y
 
 `/journal` uses the current Pi model, including registered providers, unless a LogDig override is set. The preview needs no available model or authentication. `doctor` checks the executable but does not validate model authentication; open Pi and run `/login` if a real save reports an authentication problem.
 
+Choose a **thinking level** alongside the model in setup's advanced settings, or use `--thinking` for one CLI backfill. Supported values are `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`; `default` removes the LogDig override. Saved settings use `thinkingLevel`, and `PI_JOURNAL_THINKING` overrides it. This applies to intermediate timeline extraction and final summaries, including `/journal` and automatic capture. Support and effort mapping depend on the model and Pi provider, so `max` is not necessarily a distinct supported tier on every model.
+
+More thinking can help separate proposals, failed attempts, and verified outcomes, but can increase latency and token cost. Explicitly enabled thinking allows CLI requests up to 30 minutes each, rather than the usual five; providers may impose their own timeouts. With no LogDig override, CLI backfill keeps Pi's startup thinking policy, while `/journal` keeps its existing provider-default behavior and does **not** inherit the active session's thinking level. Select an explicit level for consistent control in both paths. Changing it causes selected cached summaries to need regeneration; preview first to see the scope.
+
 Selected user prompts, assistant conclusions, tool actions, test results, and error excerpts are sent to the chosen model after common credential redaction. System prompts, hidden reasoning, and image payloads are excluded. **Redaction is not a comprehensive secret scanner.** Review your provider's data handling before processing sensitive sessions or enabling automatic capture. Summaries can also contain private project details, so treat your cache and vault accordingly.
 
 Model summaries are aids to memory, not proof of completed work. Keep Pi history as the source of truth.

package/bin/logdig.js

@@ -2,12 +2,14 @@
 import path from "node:path";
 import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
+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 { statusPrefix, statusPrefixWidth } from "../src/cli-status.js";
 
 const packageRoot = fileURLToPath(new URL("../", import.meta.url));
 const relativeEntry = path.relative(process.cwd(), fileURLToPath(import.meta.url)).split(path.sep).join("/");
@@ -81,30 +83,35 @@ async function doctor() {
   const settings = await loadSettings();
   let issues = 0;
   let warnings = 0;
-  console.log("LogDig checkup (no model requests or file changes)\n");
-  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 +119,13 @@ 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("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.`);
@@ -132,6 +140,7 @@ async function backfill(args) {
   let daysArgument;
   let dryRun = 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") {
@@ -141,6 +150,11 @@ async function backfill(args) {
       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,7 +162,9 @@ 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);
 
@@ -156,9 +172,10 @@ async function backfill(args) {
   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(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.");
+    : "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 });
   console.log(`\nFound ${found.sessions.length} saved Pi session${found.sessions.length === 1 ? "" : "s"}${found.firstDate ? ` to check for ${found.firstDate} through ${found.lastDate}` : ""}.`);
   if (found.sessions.length === 0) {
@@ -171,29 +188,31 @@ async function backfill(args) {
     return;
   }
 
-  const modelClient = createPiModelClient({ ...settings, model: selectedModel });
+  const modelClient = createPiModelClient(generationSettings);
   const result = await writeSessions(modelClient, found.sessions, settings, {
     ...found,
     dryRun,
-    onProgress: ({ index, total, sessionId, project, date, time, status, error, phase, sessionPath, dailyPath }) => {
+    onProgress: ({ index, total, sessionId, project, date, time, status, error, phase, sessionPath, dailyPath, prerequisite }) => {
       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}`);
+        if (prerequisite) console.log("  Includes this earlier block to establish the continuation link.");
       }
     },
   });
   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"}`;
   console.log(dryRun
-    ? `\nWould create ${summaryCount}, reuse ${result.summariesReused}, append ${entryCount}; ${result.entriesSkipped} already present.`
-    : `\nSaved: ${summaryCount} created, ${result.summariesReused} reused, ${entryCount} appended; ${result.entriesSkipped} already present.`);
+    ? `\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).`);
   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'.`);
   }
@@ -203,7 +222,125 @@ 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}${selectedModel ? ` --model ${selectedModel}` : settings.model ? " --model default" : ""}${selectedThinking ? ` --thinking ${selectedThinking}` : settings.thinkingLevel ? " --thinking default" : ""}`);
+  }
+}
+
+function parseStatusArguments(args) {
+  let rangeArgument;
+  let json = false;
+  for (const arg of args) {
+    if (arg === "--json") {
+      json = 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]`);
+    } else {
+      rangeArgument = arg;
+    }
+  }
+  return { range: parseBackfillArgument(rangeArgument, "status"), json };
+}
+
+async function status(args) {
+  const { range, json } = parseStatusArguments(args);
+  const settings = await loadSettings();
+  requireJournalPaths(settings);
+  const found = await collectSessions({
+    sessionDirectory: settings.sessionDirectory,
+    timeZone: settings.timeZone,
+    days: range.days,
+  });
+  const previousEntries = await listJournaledSessions(settings.cacheDirectory);
+  const inspection = await writeSessions(
+    { cachePolicy: summaryCachePolicy(settings) },
+    found.sessions,
+    settings,
+    { ...found, dryRun: true, journaledEntries: previousEntries },
+  );
+  const sessions = inspection.sessionResults
+    .filter((session) => !["skipped", "error"].includes(session.status))
+    .map((session) => {
+      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 === "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 ? "reusable" : "needs-summarizing",
+        dailyPath: session.dailyPath,
+      };
+    });
+  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: {
+      kind: range.all ? "all" : "days",
+      ...(range.days ? { days: range.days } : {}),
+      firstDate: found.firstDate || null,
+      lastDate: found.lastDate,
+      timeZone: settings.timeZone,
+    },
+    totals: {
+      scanned: found.sessions.length,
+      eligible: sessions.length,
+      logged: sessions.filter((session) => session.status === "logged").length,
+      stale,
+      new: newCount,
+      needsSummarizing,
+      skipped: inspection.sessionsSkipped,
+      errors: inspection.errors.length,
+    },
+    sessions,
+    warnings,
+  };
+
+  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: activity in ${label} (${settings.timeZone})${found.firstDate ? ` · ${found.firstDate} through ${found.lastDate}` : ""}`);
+    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 + (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 work blocks found in this timeframe.");
+    } else {
+      console.log("Everything in this timeframe is current.");
+    }
+    if (newCount || stale || needsSummarizing) {
+      console.log(`\nTo update the journal: ${commandName} backfill ${range.all ? "all" : range.days}`);
+    }
+  }
+
+  if (warnings.length) {
+    if (!json) console.error(`Status may be incomplete:\n${warnings.join("\n")}`);
+    process.exitCode = 1;
   }
 }
 
@@ -221,7 +358,9 @@ function helpText() {
     "  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]",
+    "                                      [--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 pi-install | pi-uninstall     add or remove /journal integration",
     "  logdig --version                    show the installed version",
     "",
@@ -230,20 +369,21 @@ function helpText() {
     "",
     "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");
 }
 
 async function main() {
   const [command = "help", ...args] = process.argv.slice(2);
-  const commands = ["init", "config", "doctor", "backfill", "pi-install", "pi-uninstall", "help", "--help", "-h", "--version", "-v"];
+  const commands = ["init", "config", "doctor", "backfill", "status", "pi-install", "pi-uninstall", "help", "--help", "-h", "--version", "-v"];
   if (!commands.includes(command)) throw new Error(`Unknown command: ${command}. Run '${commandName} help'.`);
   if (args.includes("--help") || args.includes("-h")) {
     console.log(helpText());
     return;
   }
-  if (command !== "backfill" && args.length) throw new Error(`'${command}' does not accept arguments. Run '${commandName} help'.`);
+  if (!["backfill", "status"].includes(command) && args.length) throw new Error(`'${command}' does not accept arguments. Run '${commandName} help'.`);
   switch (command) {
     case "--version":
     case "-v": {
@@ -263,6 +403,9 @@ async function main() {
     case "backfill":
       await backfill(args);
       break;
+    case "status":
+      await status(args);
+      break;
     case "pi-install": {
       const settings = await loadSettings();
       await runPiCommand(settings.piCommand, ["install", packageRoot], { inherit: true, timeoutMs: 120_000 });

package/package.json

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

package/src/cli-status.js

@@ -0,0 +1,35 @@
+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" },
+};
+
+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} `;
+}