logdig 0.1.0 → 0.1.1

package/QUICKSTART.md

@@ -29,10 +29,11 @@ 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` shows what's already journaled, what needs updating or is missing, and which summaries would need a model request. It is read-only. The backfill preview shows projects, dates, destination files, cache hits, and which sessions 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:
 
@@ -54,7 +55,7 @@ This may send selected, redacted history to your Pi model and incur provider cha
 
 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.
 
-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.
+Repeating an unchanged session reuses its summary and does not insert that entry again. If a session evolves, LogDig updates its existing daily row to the latest summary, preserving manually edited blurbs and keeping older snapshots in `Entries/`. Run only one save at a time against your journal, and let vault sync finish first.
 
 ## Optional: use `/journal` inside Pi
 

package/README.md

@@ -94,7 +94,7 @@ Obsidian displays each link as just the timestamp; clicking it opens that entry'
 
 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.
 
-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.
+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. When a session evolves, LogDig replaces its daily-note row with a link to the latest summary instead of adding another row. Previous linked snapshots remain unchanged in `Entries/`, and manually edited daily summaries are preserved. Changing the default does not override existing saved heading preferences; rerun setup to change them. An inline timestamp can be expanded when its project gains another entry. 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.
 
@@ -113,11 +113,16 @@ 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 default    ignore a saved model 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 reports current journal entries, sessions that need updating, missing entries, and whether each summary is cached or needs a model request. It uses the last user message date in your configured timezone. It never calls a model or writes files; scan warnings make the command exit nonzero so incomplete coverage is clear.
 
 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.
 

package/bin/logdig.js

@@ -2,6 +2,7 @@
 import path from "node:path";
 import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
+import { listJournaledSessions } 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";
@@ -81,7 +82,6 @@ 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(", ")}`);
@@ -186,9 +186,10 @@ async function backfill(args) {
   });
   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(", ")}`);
@@ -207,6 +208,117 @@ async function backfill(args) {
   }
 }
 
+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(
+    { cacheKey: settings.model || "Pi default" },
+    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) || [];
+      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);
+      return {
+        sessionId: session.sessionId,
+        project: session.project,
+        date: session.date,
+        time: session.time,
+        status,
+        ...(status === "needs-update" ? {
+          reason: sourceChanged ? "session changed since its previous journal entry" : "previous journal entry is not current",
+        } : {}),
+        summaryStatus: session.summaryReused ? "cached" : "needs-generation",
+        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 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,
+      needsUpdate,
+      missing,
+      needsModelRequest,
+      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: ${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");
+    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";
+        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.");
+    } 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 (warnings.length) {
+    if (!json) console.error(`Status may be incomplete:\n${warnings.join("\n")}`);
+    process.exitCode = 1;
+  }
+}
+
 function helpText() {
   return [
     "LogDig: a little work journal from your Pi sessions.",
@@ -222,6 +334,7 @@ function helpText() {
     "  logdig config                       show settings and active environment overrides",
     "  logdig backfill [N|all] [--dry-run] [--model provider/model|default]",
     "                                      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",
     "",
@@ -237,13 +350,13 @@ function helpText() {
 
 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 +376,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.1",
   "description": "Turn saved Pi sessions into a work journal in your Obsidian daily notes.",
   "license": "MIT",
   "author": "Soleone",

package/src/index.js

@@ -93,9 +93,10 @@ async function runBackfill(ctx, argument) {
   const warnings = [...found.warnings, ...result.errors];
   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 summary = dryRun
-    ? `LogDig preview: would create ${summaryCount}, reuse ${result.summariesReused}, append ${entryCount}; ${result.entriesSkipped} already present.`
-    : `LogDig: ${summaryCount} created, ${result.summariesReused} reused, ${entryCount} appended; ${result.entriesSkipped} already present.`;
+    ? `LogDig preview: would create ${summaryCount}, reuse ${result.summariesReused}, append ${entryCount}; ${result.entriesSkipped} already present; update ${updateCount}.`
+    : `LogDig: ${summaryCount} created, ${result.summariesReused} reused, appended ${entryCount}; ${result.entriesSkipped} already present; updated ${updateCount}.`;
   const details = warnings.length
     ? `\n${warnings.slice(0, 3).join("\n")}${warnings.length > 3 ? `\n${warnings.length - 3} more warnings in the console.` : ""}\nFix the issues and rerun; successful summaries are cached.`
     : result.dates.length ? `\nDaily notes: ${settings.dailyDirectory} (${result.dates.join(", ")})` : "\nNothing to journal in this range. Try /journal backfill 7 --dry-run.";
@@ -121,7 +122,7 @@ function helpText() {
 export default function (pi) {
   let saving = false;
   pi.registerCommand("journal", {
-    description: "Cache layered session summaries and append to Obsidian journals",
+    description: "Cache layered session summaries and keep Obsidian journal entries current",
     handler: async (argument, ctx) => {
       const [command, ...rest] = argument.trim().split(/\s+/).filter(Boolean);
       if (["help", "--help", "-h"].includes(command)) {
@@ -151,7 +152,8 @@ export default function (pi) {
         if (!result.dailyPaths.length) {
           notify(ctx, "Nothing to journal yet. Send a message to Pi, then run /journal.");
         } else {
-          notify(ctx, `${result.entriesAppended ? `Saved ${settings.dailySummary} summary` : "Already in your journal"}: ${result.dailyPaths.join(", ")}\nFull summaries: ${path.join(settings.cacheDirectory, "Sessions")}`, "success");
+          const saved = result.entriesAppended || result.entriesUpdated;
+          notify(ctx, `${saved ? `Saved ${settings.dailySummary} summary` : "Already in your journal"}: ${result.dailyPaths.join(", ")}\nFull summaries: ${path.join(settings.cacheDirectory, "Sessions")}`, "success");
         }
       } catch (error) {
         notify(ctx, `LogDig could not save: ${error.message}`, "error");

package/src/journal.js

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { sessionMetrics } from "./transcript.js";
 
@@ -187,6 +187,35 @@ export function parseSessionNote(markdown) {
   return { ...metadata, summary };
 }
 
+export async function listJournaledSessions(cacheDirectory) {
+  const directory = path.join(cacheDirectory, "Entries");
+  let files;
+  try {
+    files = await readdir(directory, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") return new Map();
+    throw error;
+  }
+
+  const sessions = new Map();
+  for (const file of files) {
+    if (!file.isFile() || !file.name.endsWith(".md")) continue;
+    const markdown = await readFile(path.join(directory, file.name), "utf8");
+    const metadata = frontmatter(markdown);
+    if (typeof metadata.sessionId !== "string") continue;
+    const versions = sessions.get(metadata.sessionId) || [];
+    versions.push({
+      id: file.name.slice(0, -3),
+      date: metadata.date,
+      time: metadata.time,
+      sourceFingerprint: metadata.sourceFingerprint,
+      summary: parseSessionNote(markdown)?.summary,
+    });
+    sessions.set(metadata.sessionId, versions);
+  }
+  return sessions;
+}
+
 const LEGACY_METRIC_FIELDS = "startedAt|endedAt|durationSeconds|costUsd|cacheReadTokens|inputTokens|outputTokens|cacheWriteTokens";
 const LEGACY_METRIC_LINE = new RegExp(`^(?:${LEGACY_METRIC_FIELDS}): .*\\n`, "gm");
 
@@ -317,6 +346,11 @@ function headingLevel(line) {
   return match?.[1].length;
 }
 
+function isProjectHeading(line, targetLevel) {
+  const level = headingLevel(line);
+  return targetLevel < 6 ? level === targetLevel + 1 : /^\*\*Project: .+\*\*$/.test(line);
+}
+
 function addEntryAt(markdown, offset, entry) {
   const before = markdown.slice(0, offset).replace(/\n{3,}$/, "\n\n");
   const after = markdown.slice(offset);
@@ -327,7 +361,109 @@ function addEntryAt(markdown, offset, entry) {
 
 function timestampEntry(line) {
   const match = line.match(/^(\*\*\[\[([a-f0-9]{64})\|(\d{2}:\d{2})\]\]\*\*)(?:: (.*)|\s*)$/);
-  return match && { header: match[1], id: match[2], time: match[3], inline: match[4] !== undefined };
+  return match && { header: match[1], id: match[2], time: match[3], inline: match[4] !== undefined, summary: match[4] || "" };
+}
+
+function markdownLines(markdown) {
+  const lines = [];
+  let start = 0;
+  let fence;
+  let insideFrontmatter = /^---\r?\n/.test(markdown);
+  while (start < markdown.length) {
+    const newline = markdown.indexOf("\n", start);
+    const lineEnd = newline === -1 ? markdown.length : newline;
+    const text = markdown.slice(start, lineEnd).replace(/\r$/, "");
+    const wasFenced = Boolean(fence);
+    let blocked = insideFrontmatter || wasFenced;
+    if (insideFrontmatter) {
+      if (start > 0 && /^(---|\.\.\.)\s*$/.test(text)) insideFrontmatter = false;
+    } else {
+      fence = codeFenceAfter(text, fence);
+      blocked ||= Boolean(fence);
+    }
+    lines.push({ text, start, end: newline === -1 ? markdown.length : newline + 1, blocked });
+    if (newline === -1) break;
+    start = newline + 1;
+  }
+  return lines;
+}
+
+function sessionEntryBlocks(markdown, ids) {
+  const lines = markdownLines(markdown);
+  const blocks = [];
+  const covered = new Set();
+
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index];
+    if (line.blocked) continue;
+    const marker = line.text.match(/^<!-- logdig:([a-f0-9]{64}):start -->$/);
+    if (!marker || !ids.has(marker[1])) continue;
+    const endMarker = `<!-- logdig:${marker[1]}:end -->`;
+    let endIndex = index + 1;
+    while (endIndex < lines.length && lines[endIndex].text !== endMarker) endIndex++;
+    if (endIndex === lines.length) continue;
+    const end = lines[endIndex].end;
+    blocks.push({ id: marker[1], start: line.start, end, displayedSummary: "" });
+    for (let coveredIndex = index; coveredIndex <= endIndex; coveredIndex++) covered.add(coveredIndex);
+  }
+
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index];
+    if (line.blocked || covered.has(index)) continue;
+    const entry = timestampEntry(line.text);
+    if (!entry || !ids.has(entry.id)) continue;
+
+    let endIndex = index + 1;
+    while (endIndex < lines.length) {
+      const next = lines[endIndex];
+      if (!next.blocked && !covered.has(endIndex) && (timestampEntry(next.text) || headingLevel(next.text) !== undefined)) break;
+      endIndex++;
+    }
+    const end = endIndex < lines.length ? lines[endIndex].start : markdown.length;
+    const continuation = markdown.slice(line.end, end);
+    const displayedSummary = (entry.inline ? `${entry.summary}${continuation ? `\n${continuation}` : ""}` : continuation).trim();
+    blocks.push({ id: entry.id, start: line.start, end, displayedSummary });
+  }
+
+  return blocks.sort((left, right) => left.start - right.start);
+}
+
+function removeMarkdownRanges(markdown, ranges) {
+  let updated = markdown;
+  for (const range of [...ranges].sort((left, right) => right.start - left.start)) {
+    updated = `${updated.slice(0, range.start)}${updated.slice(range.end)}`;
+  }
+  return updated;
+}
+
+function removeEmptyProjectGroups(markdown, heading) {
+  const targetLevel = headingLevel(heading);
+  const lines = markdownLines(markdown);
+  let inSection = false;
+  let sectionEnd = markdown.length;
+  const projects = [];
+
+  for (const line of lines) {
+    if (line.blocked) continue;
+    if (!inSection) {
+      if (line.text.trimEnd() === heading) inSection = true;
+      continue;
+    }
+    const level = headingLevel(line.text);
+    if (level !== undefined && level <= targetLevel) {
+      sectionEnd = line.start;
+      break;
+    }
+    if (isProjectHeading(line.text, targetLevel)) projects.push(line);
+  }
+
+  const emptyGroups = [];
+  for (let index = 0; index < projects.length; index++) {
+    const project = projects[index];
+    const end = projects[index + 1]?.start ?? sectionEnd;
+    if (!markdown.slice(project.end, end).trim()) emptyGroups.push({ start: project.start, end });
+  }
+  return removeMarkdownRanges(markdown, emptyGroups);
 }
 
 function appendUnderProject(markdown, heading, entry) {
@@ -375,8 +511,8 @@ function appendUnderProject(markdown, heading, entry) {
             sectionEnd = lineStart;
             break;
           }
-          const isProjectHeading = targetLevel < 6 ? level === targetLevel + 1 : /^\*\*Project: .+\*\*$/.test(line);
-          if (projectStart !== -1 && projectEnd === undefined && isProjectHeading) projectEnd = lineStart;
+          const isProjectGroup = isProjectHeading(line, targetLevel);
+          if (projectStart !== -1 && projectEnd === undefined && isProjectGroup) projectEnd = lineStart;
           if (projectStart === -1 && line.trimEnd() === projectHeading) projectStart = lineStart;
           if (projectStart !== -1 && projectEnd === undefined) {
             const timestamp = timestampEntry(line);
@@ -413,17 +549,49 @@ export function dailyEntryId(entry, heading) {
   return hashValue([entry.sessionId, entry.cacheFingerprint, entry.summaryLevel, heading]);
 }
 
-function dailyEntryText(entry, heading, inline) {
-  const id = dailyEntryId(entry, heading);
-  // Daily notes stay section-safe; structured headings and code live in the linked note.
-  const summary = entry.summary.split(/\r?\n/)
+function formatDailySummary(summary) {
+  return summary.split(/\r?\n/)
     .map((line) => /^ {0,3}(`{3,}|~{3,})/.test(line) ? "" : line.replace(/^( {0,3})(#{1,6})(?=\s)/, "$1\\$2"))
     .join("\n").trim();
+}
+
+function dailyEntryText(entry, heading, inline) {
+  const id = dailyEntryId(entry, heading);
+  // Daily notes stay section-safe; structured detail lives in the linked snapshot.
+  const summary = entry.summaryOverride ?? formatDailySummary(entry.summary);
   const timestamp = `**[[${id}|${entry.time}]]**`;
   return inline ? `${timestamp}: ${summary}` : `${timestamp}\n\n${summary}`;
 }
 
-export async function inspectDailyEntry(dailyDirectory, heading, entry) {
+async function sessionEntryLocations(dailyDirectory, heading, entry, existing, journaledEntries) {
+  const versions = journaledEntries.get(entry.sessionId) || [];
+  const snapshots = new Map(versions.map((version) => [version.id, version]));
+  const ids = new Set([...snapshots.keys(), dailyEntryId(entry, heading)]);
+  const dates = new Set([entry.date, ...versions.map((version) => version.date).filter((date) => /^\d{4}-\d{2}-\d{2}$/.test(date || ""))]);
+  const documents = new Map();
+  const blocks = [];
+
+  for (const date of dates) {
+    const dailyPath = path.join(dailyDirectory, `${date}.md`);
+    const markdown = date === entry.date ? existing : await readMarkdownIfPresent(dailyPath);
+    if (markdown === undefined) continue;
+    const found = sessionEntryBlocks(markdown, ids);
+    if (!found.length) continue;
+    documents.set(dailyPath, markdown);
+    for (const block of found) blocks.push({ ...block, dailyPath, snapshot: snapshots.get(block.id) });
+  }
+
+  return { documents, blocks };
+}
+
+function isUneditedEntry(block) {
+  if (!block.displayedSummary) return true;
+  return Object.values(block.snapshot?.summary || {}).some((summary) =>
+    formatDailySummary(summary).trim() === block.displayedSummary.trim(),
+  );
+}
+
+export async function inspectDailyEntry(dailyDirectory, heading, entry, journaledEntries) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(entry.date)) throw new Error(`Invalid journal date: ${entry.date}`);
   const dailyPath = path.join(dailyDirectory, `${entry.date}.md`);
   const existing = await readMarkdownIfPresent(dailyPath) || "";
@@ -431,27 +599,65 @@ export async function inspectDailyEntry(dailyDirectory, heading, entry) {
   const present = existing.includes(`<!-- logdig:${id}:start -->`) ||
     existing.split(/\r?\n/).some((line) => timestampEntry(line)?.id === id ||
       (line.startsWith("**") && line.includes(` · [[${id}|`) && line.endsWith("]]**")));
-  return { dailyPath, existing, appended: !present };
+  const snapshots = journaledEntries || await listJournaledSessions(path.resolve(path.dirname(entry.sessionPath), ".."));
+  const locations = await sessionEntryLocations(dailyDirectory, heading, entry, existing, snapshots);
+  const oldBlocks = locations.blocks.filter((block) => block.id !== id);
+  const sameIdBlocks = locations.blocks.filter((block) => block.id === id);
+  const updated = oldBlocks.length > 0 || sameIdBlocks.length > 1 || (!present && sameIdBlocks.length > 0);
+  return {
+    dailyPath,
+    existing,
+    appended: !present && !updated,
+    updated,
+    sessionBlocks: locations.blocks,
+    sessionDocuments: locations.documents,
+  };
 }
 
-export async function appendDailyEntry(dailyDirectory, heading, entry) {
-  const { dailyPath, existing, appended } = await inspectDailyEntry(dailyDirectory, heading, entry);
-  const entryPath = path.join(path.dirname(entry.sessionPath), "..", "Entries", `${dailyEntryId(entry, heading)}.md`);
-  if (!appended) {
-    if (entry.metrics) {
-      const snapshot = await readMarkdownIfPresent(entryPath);
-      if (snapshot) {
-        const enriched = enrichSessionNote(snapshot, entry.sourceFingerprint, entry.metrics);
-        if (enriched !== snapshot) await writeAtomically(entryPath, enriched);
-      }
-    }
-    return { dailyPath, appended: false };
+async function updateEntrySnapshot(entryPath, entry, createIfMissing) {
+  const snapshot = await readMarkdownIfPresent(entryPath);
+  if (!snapshot) {
+    if (createIfMissing) await writeAtomically(entryPath, await readFile(entry.sessionPath, "utf8"));
+    return;
+  }
+  if (!entry.metrics) return;
+  const enriched = enrichSessionNote(snapshot, entry.sourceFingerprint, entry.metrics);
+  if (enriched !== snapshot) await writeAtomically(entryPath, enriched);
+}
+
+async function updateSessionDailyNotes(heading, entry, inspection) {
+  const { dailyPath, existing, sessionBlocks, sessionDocuments } = inspection;
+  const customSummaries = [...new Set(sessionBlocks
+    .filter((block) => !isUneditedEntry(block))
+    .map((block) => block.displayedSummary.trim())
+    .filter(Boolean))];
+  let markdown = existing;
+  const cleanedDocuments = new Map();
+  for (const [filePath, contents] of sessionDocuments) {
+    const found = sessionBlocks.filter((block) => block.dailyPath === filePath);
+    const cleaned = removeEmptyProjectGroups(removeMarkdownRanges(contents, found), heading);
+    if (filePath === dailyPath) markdown = cleaned;
+    else if (cleaned !== contents) cleanedDocuments.set(filePath, cleaned);
   }
 
-  if (await readMarkdownIfPresent(entryPath) === undefined) {
-    await writeAtomically(entryPath, await readFile(entry.sessionPath, "utf8"));
+  const updatedMarkdown = appendUnderProject(markdown, heading, {
+    ...entry,
+    ...(customSummaries.length ? { summaryOverride: customSummaries.join("\n\n") } : {}),
+  });
+  await writeAtomically(dailyPath, updatedMarkdown);
+  for (const [filePath, contents] of cleanedDocuments) await writeAtomically(filePath, contents);
+}
+
+export async function appendDailyEntry(dailyDirectory, heading, entry, journaledEntries) {
+  const inspection = await inspectDailyEntry(dailyDirectory, heading, entry, journaledEntries);
+  const { dailyPath, appended, updated } = inspection;
+  const entryPath = path.join(path.dirname(entry.sessionPath), "..", "Entries", `${dailyEntryId(entry, heading)}.md`);
+  if (!appended && !updated) {
+    await updateEntrySnapshot(entryPath, entry, false);
+    return { dailyPath, appended: false, updated: false };
   }
-  const markdown = appendUnderProject(existing, heading, entry);
-  await writeAtomically(dailyPath, markdown);
-  return { dailyPath, entryPath, appended: true };
+
+  await updateEntrySnapshot(entryPath, entry, true);
+  await updateSessionDailyNotes(heading, entry, inspection);
+  return { dailyPath, entryPath, appended, updated: updated || inspection.sessionBlocks.length > 0 };
 }

package/src/session-runner.js

@@ -1,6 +1,6 @@
 import { readFile, readdir, stat } from "node:fs/promises";
 import path from "node:path";
-import { appendDailyEntry, inspectDailyEntry, inspectSessionSummary, saveSessionSummary } from "./journal.js";
+import { appendDailyEntry, inspectDailyEntry, inspectSessionSummary, listJournaledSessions, saveSessionSummary } from "./journal.js";
 import { eventsForSession, fingerprintSession, sessionFromJsonl, sessionMetrics } from "./transcript.js";
 
 function localDate(timestamp, timeZone) {
@@ -100,11 +100,14 @@ export async function writeSessions(modelClient, sessions, settings, range = {})
   let summariesCreated = 0;
   let summariesReused = 0;
   let entriesAppended = 0;
+  let entriesUpdated = 0;
   let entriesSkipped = 0;
   let sessionsSkipped = 0;
   const dates = new Set();
   const dailyPaths = new Set();
   const errors = [];
+  const sessionResults = [];
+  const journaledEntries = range.journaledEntries || await listJournaledSessions(settings.cacheDirectory);
 
   for (const [index, session] of sessions.entries()) {
     const progress = { index: index + 1, total: sessions.length, sessionId: session.header.id };
@@ -114,7 +117,9 @@ export async function writeSessions(modelClient, sessions, settings, range = {})
       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" });
+        const reason = closingEvent ? "outside date range" : "no journalable events";
+        sessionResults.push({ sessionId: session.header.id, status: "skipped", reason });
+        range.onProgress?.({ ...progress, phase: "skipped", status: reason });
         continue;
       }
 
@@ -150,10 +155,23 @@ export async function writeSessions(modelClient, sessions, settings, range = {})
         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++;
+        ? await inspectDailyEntry(settings.dailyDirectory, settings.dailyHeader, entry, journaledEntries)
+        : await appendDailyEntry(settings.dailyDirectory, settings.dailyHeader, entry, journaledEntries);
+      if (dailyEntry.updated) entriesUpdated++;
+      else if (dailyEntry.appended) entriesAppended++;
       else entriesSkipped++;
+      sessionResults.push({
+        sessionId: journalSession.header.id,
+        project: journalSession.project,
+        date: journalSession.date,
+        time: journalSession.time,
+        entryPresent: !dailyEntry.appended && !dailyEntry.updated,
+        entryUpdated: Boolean(dailyEntry.updated),
+        summaryReused: cached.reused,
+        sourceFingerprint: journalSession.sourceFingerprint,
+        sessionPath: cached.sessionPath,
+        dailyPath: dailyEntry.dailyPath,
+      });
       dates.add(journalSession.date);
       dailyPaths.add(dailyEntry.dailyPath);
       range.onProgress?.({
@@ -162,24 +180,25 @@ export async function writeSessions(modelClient, sessions, settings, range = {})
         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"}`,
+          ? `${cached.reused ? "would reuse summary" : "would summarize with Pi"}, ${dailyEntry.updated ? "would update entry" : dailyEntry.appended ? "would append entry" : "entry already present"}`
+          : `${cached.reused ? "summary reused" : "summary created"}, ${dailyEntry.updated ? "entry updated" : dailyEntry.appended ? "entry appended" : "entry already present"}`,
       });
     } catch (error) {
       errors.push(`${session.header.id}: ${error.message}`);
+      sessionResults.push({ sessionId: session.header.id, status: "error", error: error.message });
       range.onProgress?.({ ...progress, phase: "error", error: error.message });
     }
   }
 
-  return { summariesCreated, summariesReused, entriesAppended, entriesSkipped, sessionsSkipped, dates: [...dates].sort(), dailyPaths: [...dailyPaths].sort(), errors };
+  return { summariesCreated, summariesReused, entriesAppended, entriesUpdated, entriesSkipped, sessionsSkipped, dates: [...dates].sort(), dailyPaths: [...dailyPaths].sort(), errors, sessionResults };
 }
 
-export function parseBackfillArgument(argument = "") {
+export function parseBackfillArgument(argument = "", command = "backfill") {
   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'.");
+    throw new Error(`Usage: logdig ${command} [number-of-days|all]. Choose 1 to 3650 days, or 'all'.`);
   }
   return { days };
 }