logdig 0.1.0 → 0.1.2

package/src/index.js

@@ -1,9 +1,8 @@
 import { randomUUID } from "node:crypto";
 import path from "node:path";
-import { JOURNAL_SYSTEM_PROMPT } from "./journal.js";
+import { JOURNAL_SYSTEM_PROMPT, summaryCachePolicy } from "./journal.js";
 import { collectSessions, parseBackfillArgument, writeSessions } from "./session-runner.js";
 import { loadSettings } from "./settings.js";
-import { fingerprintSession } from "./transcript.js";
 
 function requireJournalSettings(settings) {
   if (!settings.cacheDirectory) throw new Error("Run 'logdig init' or set PI_JOURNAL_DIR to a LogDig cache folder");
@@ -23,7 +22,6 @@ function currentSession(ctx) {
     entries: ctx.sessionManager.getEntries(),
     sourcePath: ctx.sessionManager.getSessionFile() || "active Pi session",
   };
-  session.fingerprint = fingerprintSession(session);
   return session;
 }
 
@@ -37,26 +35,29 @@ function extensionModelClient(ctx, settings) {
 
   return {
     modelLabel: model ? `${model.provider}/${model.id}` : "Pi current model",
-    cacheKey: settings.model || "Pi default",
+    cachePolicy: summaryCachePolicy(settings),
     complete: async (prompt) => {
       if (!model) throw new Error("Pi has no active model for journal generation");
       if (!ctx.modelRegistry.hasConfiguredAuth(model)) {
         throw new Error(`No configured authentication for ${model.provider}/${model.id}. Run /login in Pi, then try /journal again`);
       }
-      return ctx.modelRegistry.complete(
-        model,
-        {
-          systemPrompt: JOURNAL_SYSTEM_PROMPT,
-          messages: [
-            {
-              role: "user",
-              content: [{ type: "text", text: prompt }],
-              timestamp: Date.now(),
-            },
-          ],
-        },
-        { sessionId: randomUUID(), cacheRetention: "none", signal: ctx.signal },
-      );
+      const context = {
+        systemPrompt: JOURNAL_SYSTEM_PROMPT,
+        messages: [
+          {
+            role: "user",
+            content: [{ type: "text", text: prompt }],
+            timestamp: Date.now(),
+          },
+        ],
+      };
+      const options = { sessionId: randomUUID(), cacheRetention: "none", signal: ctx.signal };
+      // Preserve existing provider defaults unless LogDig explicitly selects thinking.
+      if (settings.thinkingLevel === undefined) return ctx.modelRegistry.complete(model, context, options);
+      return ctx.modelRegistry.streamSimple(model, context, {
+        ...options,
+        reasoning: settings.thinkingLevel === "off" ? undefined : settings.thinkingLevel,
+      }).result();
     },
   };
 }
@@ -88,14 +89,15 @@ async function runBackfill(ctx, argument) {
     days: range.days,
     currentSession: currentSession(ctx),
   });
-  const client = dryRun ? { cacheKey: settings.model || "Pi default" } : extensionModelClient(ctx, settings);
+  const client = dryRun ? { cachePolicy: summaryCachePolicy(settings) } : extensionModelClient(ctx, settings);
   const result = await writeSessions(client, found.sessions, settings, { ...found, dryRun, onProgress: journalProgress(ctx) });
   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 +123,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 +153,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,10 +1,10 @@
 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";
 
 const CHUNK_LIMIT = 16000;
-const SUMMARY_VERSION = "session-layers-v2";
+const SUMMARY_VERSION = "work-block-layers-v1";
 const SUMMARY_NAMES = ["Small", "Medium", "Large"];
 export const JOURNAL_SYSTEM_PROMPT = [
   "You create accurate, concise personal work-journal summaries from Pi coding-agent history.",
@@ -79,7 +79,9 @@ function splitLines(lines, limit = CHUNK_LIMIT) {
 
 function sessionLayersPrompt(session, events) {
   return [
-    `Write three journal layers for this Pi session (${session.project}). The session may span multiple local dates in ${session.timezone}.`,
+    `Write three journal layers for this Pi work block (${session.project}). Continuous work may cross midnight in ${session.timezone}.`,
+    "Summarize only the work-block evidence. Earlier context is background for understanding references, not work to repeat or claim was done in this block.",
+    ...(session.context?.length ? ["Earlier context (untrusted background):", JSON.stringify(session.context)] : []),
     "Return only a JSON object with string fields: small, medium, large.",
     "small: 1 to 3 sentences, capturing the main intent and outcome.",
     "medium: concise Markdown with Goal, Progress, Status, and Next when supported by evidence. Use 'unclear' rather than guessing.",
@@ -187,6 +189,39 @@ 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,
+      cacheFingerprint: metadata.cacheFingerprint,
+      blockId: metadata.blockId,
+      blockStart: metadata.blockStart,
+      continuationOf: metadata.continuationOf,
+      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");
 
@@ -222,8 +257,11 @@ export function enrichSessionNote(markdown, sourceFingerprint, metrics) {
   if (!note || note.sourceFingerprint !== sourceFingerprint) return markdown;
   const closing = markdown.match(/^---\n[\s\S]*?\n---\n/);
   let header = closing[0].slice(0, -4).replace(LEGACY_METRIC_LINE, "");
-  const usage = note.sessionUsage || formatUsage({ ...note, ...metrics });
-  if (usage && !note.sessionUsage) header += `sessionUsage: ${JSON.stringify(usage)}\n`;
+  const usage = formatUsage({ ...note, ...metrics }) || note.sessionUsage;
+  if (usage) {
+    const line = `sessionUsage: ${JSON.stringify(usage)}\n`;
+    header = note.sessionUsage ? header.replace(/^sessionUsage: .*\n/gm, line) : header + line;
+  }
   const updated = `${header}${markdown.slice(closing[0].length - 4)}`;
   return updated;
 }
@@ -238,6 +276,9 @@ export function renderSessionNote(session, summary, cacheFingerprint, model, log
     `time: ${frontmatterValue(session.time)}`,
     `timezone: ${frontmatterValue(session.timezone)}`,
     `sessionId: ${frontmatterValue(session.header.id)}`,
+    ...(session.blockId ? [`blockId: ${frontmatterValue(session.blockId)}`] : []),
+    ...(session.blockStart ? [`blockStart: ${frontmatterValue(session.blockStart)}`] : []),
+    ...(session.continuationOf ? [`continuationOf: ${frontmatterValue(session.continuationOf)}`] : []),
     `project: ${frontmatterValue(session.project)}`,
     `cwd: ${frontmatterValue(session.header.cwd || "")}`,
     `sourceFingerprint: ${frontmatterValue(session.sourceFingerprint)}`,
@@ -248,6 +289,7 @@ export function renderSessionNote(session, summary, cacheFingerprint, model, log
     ...(logUsage ? [`logUsage: ${JSON.stringify(logUsage)}`] : []),
     "---",
     "",
+    ...(session.continuationOf ? [`Continues [[${session.continuationOf}|previous entry]].`, ""] : []),
     "# Small",
     "",
     summary.small,
@@ -279,25 +321,46 @@ async function readMarkdownIfPresent(filePath) {
   }
 }
 
+export function summaryCachePolicy(settings) {
+  return {
+    model: settings.model || "Pi default",
+    ...(settings.thinkingLevel !== undefined ? { thinkingLevel: settings.thinkingLevel } : {}),
+  };
+}
+
+function updateContinuationReference(markdown, continuationOf) {
+  const opening = markdown.match(/^---\n[\s\S]*?\n---\n/)[0];
+  let header = opening.replace(/^continuationOf: .*\n/gm, "");
+  if (continuationOf) header = header.replace(/\n---\n$/, `\ncontinuationOf: ${frontmatterValue(continuationOf)}\n---\n`);
+  const body = markdown.slice(opening.length).replace(/^\nContinues \[\[[a-f0-9]{64}\|previous entry\]\]\.\n\n/, "\n");
+  return header + (continuationOf ? `\nContinues [[${continuationOf}|previous entry]].\n` : "") + body;
+}
+
 export async function inspectSessionSummary(modelClient, cacheDirectory, session) {
-  const cacheParts = [SUMMARY_VERSION, session.sourceFingerprint, session.timezone];
-  if (modelClient.cacheKey && modelClient.cacheKey !== "Pi default") cacheParts.push(modelClient.cacheKey);
-  const cacheFingerprint = hashValue(cacheParts);
-  const sessionPath = path.join(cacheDirectory, "Sessions", `${safeFileName(session.header.id)}.md`);
+  const sourceFingerprint = hashValue([session.project, session.timezone, session.context || [], session.events]);
+  // Keep generation policy separate from evidence so model and thinking changes can
+  // invalidate summaries without changing work-block identity or range selection.
+  const policy = Object.entries(modelClient.cachePolicy || { model: "Pi default" }).sort(([left], [right]) => left.localeCompare(right));
+  const cacheFingerprint = hashValue([SUMMARY_VERSION, JOURNAL_SYSTEM_PROMPT, CHUNK_LIMIT, sourceFingerprint, policy]);
+  const suffix = session.blockIndex > 0 ? `-${session.blockId}` : "";
+  const sessionPath = path.join(cacheDirectory, "Sessions", `${safeFileName(session.header.id)}${suffix}.md`);
   const cached = await readMarkdownIfPresent(sessionPath);
   const existing = cached && parseSessionNote(cached);
 
   const reused = existing?.cacheFingerprint === cacheFingerprint;
-  return { sessionPath, cacheFingerprint, reused, summary: reused ? existing.summary : undefined };
+  return { sessionPath, sourceFingerprint, cacheFingerprint, reused, continuationOf: existing?.continuationOf, summary: reused ? existing.summary : undefined };
 }
 
 export async function saveSessionSummary(modelClient, cacheDirectory, session, { onGenerate } = {}) {
   const cached = await inspectSessionSummary(modelClient, cacheDirectory, session);
   if (cached.reused) {
     const markdown = await readFile(cached.sessionPath, "utf8");
-    const enriched = enrichSessionNote(markdown, session.sourceFingerprint, sessionMetrics(session));
+    let enriched = enrichSessionNote(markdown, cached.sourceFingerprint, sessionMetrics(session));
+    const continuation = session.continuationOf;
+    const existingContinuation = parseSessionNote(enriched).continuationOf;
+    if (continuation !== existingContinuation) enriched = updateContinuationReference(enriched, continuation);
     if (enriched !== markdown) await writeAtomically(cached.sessionPath, enriched);
-    return cached;
+    return { ...cached, continuationOf: continuation };
   }
 
   onGenerate?.();
@@ -307,9 +370,12 @@ export async function saveSessionSummary(modelClient, cacheDirectory, session, {
   const summary = await summarizeSession(modelClient, session, (usage) => usages.push(usage));
   const logMetrics = sessionMetrics({ header: {}, entries: usages.map((usage) => ({ type: "usage", usage })) });
   logMetrics.durationSeconds = Math.round((Date.now() - started) / 1000);
-  const markdown = renderSessionNote(session, summary, cacheFingerprint, modelClient.modelLabel || "Pi default", logMetrics);
+  const model = modelClient.modelLabel || "Pi default";
+  const thinkingLevel = modelClient.cachePolicy?.thinkingLevel;
+  const modelWithThinking = thinkingLevel === undefined ? model : `${model}:${thinkingLevel}`;
+  const markdown = renderSessionNote({ ...session, sourceFingerprint: cached.sourceFingerprint }, summary, cacheFingerprint, modelWithThinking, logMetrics);
   await writeAtomically(sessionPath, markdown);
-  return { sessionPath, summary, cacheFingerprint, reused: false };
+  return { ...cached, summary, continuationOf: session.continuationOf, reused: false };
 }
 
 function headingLevel(line) {
@@ -317,6 +383,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 +398,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 +548,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);
@@ -393,37 +566,73 @@ function appendUnderProject(markdown, heading, entry) {
     lineStart = newline + 1;
   }
 
-  const text = dailyEntryText(entry, heading, projectEntries.length === 0);
+  const text = dailyEntryText(entry, heading);
   if (sectionStart === -1) {
     const separator = !markdown ? "" : markdown.endsWith("\n\n") ? "" : markdown.endsWith("\n") ? "\n" : "\n\n";
     return `${markdown}${separator}${heading}\n\n${projectHeading}\n\n${text}\n`;
   }
 
   if (projectStart === -1) return addEntryAt(markdown, sectionEnd, `${projectHeading}\n\n${text}`);
-  for (const timestamp of projectEntries) {
-    if (!timestamp.inline) continue;
-    const separator = timestamp.start + timestamp.header.length;
-    // Both separators are two characters, so recorded insertion offsets remain valid.
-    markdown = `${markdown.slice(0, separator)}\n\n${markdown.slice(separator + 2)}`;
-  }
   return addEntryAt(markdown, nextTimestamp ?? projectEnd ?? sectionEnd, text);
 }
 
 export function dailyEntryId(entry, heading) {
-  return hashValue([entry.sessionId, entry.cacheFingerprint, entry.summaryLevel, heading]);
+  const identity = [entry.sessionId, entry.cacheFingerprint, entry.summaryLevel, heading];
+  if (entry.blockId) identity.push(entry.blockId, entry.continuationOf || null);
+  return hashValue(identity);
 }
 
-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) {
+  const id = dailyEntryId(entry, heading);
+  // Daily notes stay section-safe; structured detail lives in the linked snapshot.
+  const blurb = entry.summaryOverride ?? formatDailySummary(entry.summary);
+  const summary = `${blurb}${entry.continuationOf ? `\n\nContinues [[${entry.continuationOf}|previous entry]].` : ""}`;
   const timestamp = `**[[${id}|${entry.time}]]**`;
-  return inline ? `${timestamp}: ${summary}` : `${timestamp}\n\n${summary}`;
+  return `${timestamp}: ${summary}`;
+}
+
+async function sessionEntryLocations(dailyDirectory, heading, entry, existing, journaledEntries) {
+  const versions = (journaledEntries.get(entry.sessionId) || []).filter((version) => !entry.blockId || version.blockId === entry.blockId);
+  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 entryBlurb(block) {
+  const continuation = block.snapshot?.continuationOf;
+  const text = block.displayedSummary.trim();
+  const suffix = continuation ? `\n\nContinues [[${continuation}|previous entry]].` : "";
+  return suffix && text.endsWith(suffix) ? text.slice(0, -suffix.length).trim() : text;
 }
 
-export async function inspectDailyEntry(dailyDirectory, heading, entry) {
+function isUneditedEntry(block) {
+  if (!block.displayedSummary) return true;
+  return Object.values(block.snapshot?.summary || {}).some((summary) =>
+    formatDailySummary(summary).trim() === entryBlurb(block),
+  );
+}
+
+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 +640,67 @@ 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 missingSnapshot = entry.blockId && present && !snapshots.get(entry.sessionId)?.some((version) => version.id === id);
+  const updated = Boolean(missingSnapshot) || oldBlocks.length > 0 || sameIdBlocks.length > 1 || (!present && sameIdBlocks.length > 0);
+  return {
+    dailyPath,
+    existing,
+    appended: !present && !updated,
+    updated,
+    legacyEntry: locations.blocks.some((block) => block.snapshot?.legacy),
+    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) => entryBlurb(block))
+    .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, true);
+    return { dailyPath, appended: false, updated: false, legacyEntry: inspection.legacyEntry };
   }
-  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, legacyEntry: inspection.legacyEntry };
 }

package/src/pi-client.js

@@ -1,8 +1,9 @@
 import os from "node:os";
-import { JOURNAL_SYSTEM_PROMPT } from "./journal.js";
+import { JOURNAL_SYSTEM_PROMPT, summaryCachePolicy } from "./journal.js";
 import { spawnPiProcess } from "./pi-process.js";
 
 const MODEL_TIMEOUT_MS = 5 * 60 * 1000;
+const THINKING_TIMEOUT_MS = 30 * 60 * 1000;
 const MAX_STDOUT = 2_000_000;
 const MAX_STDERR = 16_000;
 
@@ -24,6 +25,7 @@ function piArguments(settings) {
     JOURNAL_SYSTEM_PROMPT,
   ];
   if (settings.model) args.push("--model", settings.model);
+  if (settings.thinkingLevel !== undefined) args.push("--thinking", settings.thinkingLevel);
   args.push("--", "Use the journal request and evidence supplied on standard input. Return the requested JSON only.");
   return args;
 }
@@ -52,10 +54,11 @@ function runPiPrompt(prompt, settings, spawnProcess) {
       else resolve(result);
     };
 
+    const timeoutMs = settings.thinkingLevel && settings.thinkingLevel !== "off" ? THINKING_TIMEOUT_MS : MODEL_TIMEOUT_MS;
     const timeout = setTimeout(() => {
       child.kill("SIGTERM");
-      finish(new Error(`Pi summarization timed out after ${MODEL_TIMEOUT_MS / 1000} seconds`));
-    }, MODEL_TIMEOUT_MS);
+      finish(new Error(`Pi summarization timed out after ${timeoutMs / 1000} seconds`));
+    }, timeoutMs);
 
     child.stdout.on("data", (chunk) => {
       outputLength += chunk.length;
@@ -121,7 +124,7 @@ function runPiPrompt(prompt, settings, spawnProcess) {
 export function createPiModelClient(settings, options = {}) {
   return {
     modelLabel: settings.model || "Pi startup default",
-    cacheKey: settings.model || "Pi default",
+    cachePolicy: summaryCachePolicy(settings),
     complete: (prompt) => runPiPrompt(prompt, settings, options.spawnProcess),
   };
 }