logdig 0.1.1 → 0.1.2

package/src/journal.js

@@ -4,7 +4,7 @@ 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.",
@@ -209,6 +211,10 @@ export async function listJournaledSessions(cacheDirectory) {
       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);
@@ -251,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;
 }
@@ -267,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)}`,
@@ -277,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,
@@ -308,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?.();
@@ -336,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) {
@@ -529,24 +566,20 @@ 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 formatDailySummary(summary) {
@@ -555,16 +588,17 @@ function formatDailySummary(summary) {
     .join("\n").trim();
 }
 
-function dailyEntryText(entry, heading, inline) {
+function dailyEntryText(entry, heading) {
   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 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) || [];
+  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 || ""))]);
@@ -584,10 +618,17 @@ async function sessionEntryLocations(dailyDirectory, heading, entry, existing, j
   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;
+}
+
 function isUneditedEntry(block) {
   if (!block.displayedSummary) return true;
   return Object.values(block.snapshot?.summary || {}).some((summary) =>
-    formatDailySummary(summary).trim() === block.displayedSummary.trim(),
+    formatDailySummary(summary).trim() === entryBlurb(block),
   );
 }
 
@@ -603,12 +644,14 @@ export async function inspectDailyEntry(dailyDirectory, heading, entry, journale
   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);
+  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,
   };
@@ -629,7 +672,7 @@ 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())
+    .map((block) => entryBlurb(block))
     .filter(Boolean))];
   let markdown = existing;
   const cleanedDocuments = new Map();
@@ -653,11 +696,11 @@ export async function appendDailyEntry(dailyDirectory, heading, entry, journaled
   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 };
+    await updateEntrySnapshot(entryPath, entry, true);
+    return { dailyPath, appended: false, updated: false, legacyEntry: inspection.legacyEntry };
   }
 
   await updateEntrySnapshot(entryPath, entry, true);
   await updateSessionDailyNotes(heading, entry, inspection);
-  return { dailyPath, entryPath, appended, updated: updated || inspection.sessionBlocks.length > 0 };
+  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),
   };
 }

package/src/session-runner.js

@@ -1,7 +1,8 @@
 import { readFile, readdir, stat } from "node:fs/promises";
 import path from "node:path";
-import { appendDailyEntry, inspectDailyEntry, inspectSessionSummary, listJournaledSessions, saveSessionSummary } from "./journal.js";
-import { eventsForSession, fingerprintSession, sessionFromJsonl, sessionMetrics } from "./transcript.js";
+import { appendDailyEntry, dailyEntryId, inspectDailyEntry, inspectSessionSummary, listJournaledSessions, saveSessionSummary } from "./journal.js";
+import { sessionFromJsonl, sessionMetrics } from "./transcript.js";
+import { assignLegacyBlocks, blockInRange, workBlocksForSession } from "./work-blocks.js";
 
 function localDate(timestamp, timeZone) {
   const parts = new Intl.DateTimeFormat("en-CA", {
@@ -83,7 +84,6 @@ export async function collectSessions({ sessionDirectory, timeZone, days, curren
       if (modifiedAfter && fileStat.mtimeMs < modifiedAfter) continue;
       const session = sessionFromJsonl(await readFile(file, "utf8"), file);
       if (session.header.id === currentId || seen.has(session.header.id)) continue;
-      session.fingerprint = fingerprintSession(session);
       seen.add(session.header.id);
       sessions.push(session);
     } catch (error) {
@@ -96,6 +96,31 @@ export async function collectSessions({ sessionDirectory, timeZone, days, curren
   return { sessions, warnings, firstDate, lastDate: today };
 }
 
+function selectedBlockIndexes(blocks, versions, range) {
+  const selected = new Set(blocks.flatMap((block, index) => blockInRange(block, range) ? [index] : []));
+  // A continuation must link to a real snapshot, not a predicted filename.
+  for (let index = blocks.length - 1; index > 0; index--) {
+    if (selected.has(index) && !versions.some((version) => version.blockId === blocks[index - 1].blockId && version.summary)) {
+      selected.add(index - 1);
+    }
+  }
+  return selected;
+}
+
+async function precedingSnapshot(modelClient, previous, versions, settings) {
+  const snapshots = versions.filter((version) => version.blockId === previous.blockId && version.summary);
+  if (!snapshots.length) throw new Error("preceding work block has no saved snapshot; fix its error and retry");
+  const cached = await inspectSessionSummary(modelClient, settings.cacheDirectory, previous);
+  const expectedId = dailyEntryId({
+    sessionId: previous.header.id,
+    blockId: previous.blockId,
+    cacheFingerprint: cached.cacheFingerprint,
+    continuationOf: cached.continuationOf,
+    summaryLevel: settings.dailySummary,
+  }, settings.dailyHeader);
+  return (snapshots.find((snapshot) => snapshot.id === expectedId) || snapshots[0]).id;
+}
+
 export async function writeSessions(modelClient, sessions, settings, range = {}) {
   let summariesCreated = 0;
   let summariesReused = 0;
@@ -111,82 +136,109 @@ export async function writeSessions(modelClient, sessions, settings, range = {})
 
   for (const [index, session] of sessions.entries()) {
     const progress = { index: index + 1, total: sessions.length, sessionId: session.header.id };
+    let blocks;
     try {
-      const events = eventsForSession(session, settings.timeZone);
-      const lastUserEvent = events.findLast((event) => event.kind === "user intent");
-      const closingEvent = lastUserEvent || events.at(-1);
-      if (!closingEvent || (range.firstDate && (closingEvent.date < range.firstDate || closingEvent.date > range.lastDate))) {
-        sessionsSkipped++;
-        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;
-      }
-
-      const journalSession = {
-        ...session,
-        date: closingEvent.date,
-        time: closingEvent.time,
-        timezone: settings.timeZone,
-        project: events[0].project || "unknown project",
-        events,
-        sourceFingerprint: session.fingerprint || fingerprintSession(session),
-      };
-      Object.assign(progress, { project: journalSession.project, date: journalSession.date, time: journalSession.time });
-      range.onProgress?.({ ...progress, phase: "checking", status: "checking saved summary" });
-      const cached = range.dryRun
-        ? await inspectSessionSummary(modelClient, settings.cacheDirectory, journalSession)
-        : await saveSessionSummary(modelClient, settings.cacheDirectory, journalSession, {
-          onGenerate: () => range.onProgress?.({ ...progress, phase: "summarizing", status: "summarizing with Pi; large sessions may take a few minutes" }),
-        });
-      if (cached.reused) summariesReused++;
-      else summariesCreated++;
-
-      const entry = {
-        date: journalSession.date,
-        time: journalSession.time,
-        project: journalSession.project,
-        sessionId: journalSession.header.id,
-        cacheFingerprint: cached.cacheFingerprint,
-        sessionPath: cached.sessionPath,
-        sourceFingerprint: journalSession.sourceFingerprint,
-        metrics: sessionMetrics(journalSession),
-        summaryLevel: settings.dailySummary,
-        summary: cached.summary?.[settings.dailySummary],
-      };
-      const dailyEntry = range.dryRun
-        ? await inspectDailyEntry(settings.dailyDirectory, settings.dailyHeader, entry, 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?.({
-        ...progress,
-        phase: "complete",
-        sessionPath: cached.sessionPath,
-        dailyPath: dailyEntry.dailyPath,
-        status: range.dryRun
-          ? `${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"}`,
-      });
+      blocks = workBlocksForSession(session, settings.timeZone);
     } 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 });
+      continue;
+    }
+    const versions = journaledEntries.get(session.header.id) || [];
+    journaledEntries.set(session.header.id, versions);
+    assignLegacyBlocks(versions, blocks);
+    const selected = selectedBlockIndexes(blocks, versions, range);
+    if (!selected.size) {
+      sessionsSkipped++;
+      const reason = blocks.length ? "outside date range" : "no journalable events";
+      sessionResults.push({ sessionId: session.header.id, status: "skipped", reason });
+      range.onProgress?.({ ...progress, phase: "skipped", status: reason });
+      continue;
+    }
+
+    const plannedSnapshots = new Map();
+    for (const [blockIndex, block] of blocks.entries()) {
+      if (!selected.has(blockIndex)) continue;
+      const blockProgress = { ...progress, blockId: block.blockId, project: block.project, date: block.date, time: block.time };
+      try {
+        const previous = blocks[blockIndex - 1];
+        const continuationOf = previous
+          ? plannedSnapshots.get(previous.blockId) || await precedingSnapshot(modelClient, previous, versions, settings)
+          : undefined;
+        const journalBlock = { ...block, continuationOf };
+        const prerequisite = !blockInRange(block, range);
+        range.onProgress?.({ ...blockProgress, phase: "checking", status: "checking saved summary" });
+        const cached = range.dryRun
+          ? await inspectSessionSummary(modelClient, settings.cacheDirectory, journalBlock)
+          : await saveSessionSummary(modelClient, settings.cacheDirectory, journalBlock, {
+            onGenerate: () => range.onProgress?.({ ...blockProgress, phase: "summarizing", status: "summarizing with Pi; large sessions may take a few minutes" }),
+          });
+        if (cached.reused) summariesReused++;
+        else summariesCreated++;
+
+        const entry = {
+          date: block.date,
+          time: block.time,
+          project: block.project,
+          sessionId: session.header.id,
+          blockId: block.blockId,
+          blockStart: block.blockStart,
+          continuationOf,
+          cacheFingerprint: cached.cacheFingerprint,
+          sessionPath: cached.sessionPath,
+          sourceFingerprint: cached.sourceFingerprint,
+          metrics: sessionMetrics(block),
+          summaryLevel: settings.dailySummary,
+          summary: cached.summary?.[settings.dailySummary],
+        };
+        const dailyEntry = range.dryRun
+          ? 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++;
+        const entryId = dailyEntryId(entry, settings.dailyHeader);
+        plannedSnapshots.set(block.blockId, entryId);
+        sessionResults.push({
+          sessionId: session.header.id,
+          blockId: block.blockId,
+          project: block.project,
+          date: block.date,
+          time: block.time,
+          activityDates: block.activityDates,
+          prerequisite,
+          continuationOf,
+          entryPresent: !dailyEntry.appended && !dailyEntry.updated,
+          entryUpdated: Boolean(dailyEntry.updated),
+          legacyEntry: dailyEntry.legacyEntry,
+          summaryReused: cached.reused,
+          sourceFingerprint: cached.sourceFingerprint,
+          cacheFingerprint: cached.cacheFingerprint,
+          sessionPath: cached.sessionPath,
+          dailyPath: dailyEntry.dailyPath,
+        });
+        // Dry-run predictions stay in plannedSnapshots, never in the real index.
+        if (!range.dryRun && !versions.some((version) => version.id === entryId)) {
+          versions.push({ ...entry, id: entryId, summary: cached.summary });
+        }
+        dates.add(block.date);
+        dailyPaths.add(dailyEntry.dailyPath);
+        range.onProgress?.({
+          ...blockProgress,
+          phase: "complete",
+          prerequisite,
+          sessionPath: cached.sessionPath,
+          dailyPath: dailyEntry.dailyPath,
+          status: (range.dryRun
+            ? `${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"}`) + (prerequisite ? " (earlier block needed for continuation link)" : ""),
+        });
+      } catch (error) {
+        errors.push(`${session.header.id}: ${block.date} ${block.time}: ${error.message}`);
+        sessionResults.push({ sessionId: session.header.id, blockId: block.blockId, status: "error", error: error.message });
+        range.onProgress?.({ ...blockProgress, phase: "error", error: error.message });
+      }
     }
   }
 

package/src/settings.js

@@ -10,6 +10,7 @@ const ENVIRONMENT_SETTINGS = [
   ["PI_JOURNAL_DAILY_SUMMARY", "dailySummary"],
   ["PI_JOURNAL_TIMEZONE", "timeZone"],
   ["PI_JOURNAL_MODEL", "model"],
+  ["PI_JOURNAL_THINKING", "thinkingLevel"],
   ["PI_JOURNAL_PI_COMMAND", "piCommand"],
   ["PI_CODING_AGENT_SESSION_DIR", "sessionDirectory"],
 ];
@@ -85,6 +86,14 @@ export function validateSettings(settings, { requirePaths = false, home = homedi
     if (!provider || !modelId) throw new Error("model must use provider/model format");
     settings.model = `${provider}/${modelId}`;
   }
+  if (settings.thinkingLevel !== undefined) {
+    if (typeof settings.thinkingLevel !== "string") throw new Error("thinkingLevel must be default, off, minimal, low, medium, high, xhigh, or max");
+    const level = settings.thinkingLevel.trim().toLowerCase();
+    if (!["default", "off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(level)) {
+      throw new Error("thinkingLevel must be default, off, minimal, low, medium, high, xhigh, or max");
+    }
+    settings.thinkingLevel = level === "default" ? undefined : level;
+  }
   if (settings.autoCapture !== undefined && typeof settings.autoCapture !== "boolean") {
     throw new Error("autoCapture must be a boolean");
   }
@@ -144,6 +153,7 @@ export async function saveSettings(settings, filePath = settings.filePath || set
     piCommand: settings.piCommand || "pi",
     autoCapture: settings.autoCapture === true,
     ...(settings.model ? { model: settings.model } : {}),
+    ...(settings.thinkingLevel !== undefined ? { thinkingLevel: settings.thinkingLevel } : {}),
   };
   validateSettings(persisted, { requirePaths: true });
 

package/src/setup.js

@@ -76,14 +76,18 @@ export async function configureLogDig(settings, commandName = "logdig") {
     console.log("\n2. Pi and privacy");
     console.log(`History: ${settings.sessionDirectory}`);
     console.log(`Model: ${settings.model || "Pi's default (your active model for /journal)"}`);
-    const advanced = await ask("Change history folder, Pi executable, or model? (yes/no)", "no", yesNo);
-    let { sessionDirectory, piCommand, model } = settings;
+    console.log(`Thinking: ${settings.thinkingLevel || "default (no LogDig override)"}`);
+    const advanced = await ask("Change history folder, Pi executable, model, or thinking level? (yes/no)", "no", yesNo);
+    let { sessionDirectory, piCommand, model, thinkingLevel } = settings;
     if (advanced) {
       sessionDirectory = await ask("Pi session-history folder", sessionDirectory,
         (value) => folder("sessionDirectory", value, false));
       piCommand = await ask("Pi executable", piCommand, (value) => field("piCommand", value));
       model = await ask("Model (provider/model), or 'default'", model || "default",
         (value) => value.toLowerCase() === "default" ? undefined : field("model", value));
+      console.log("More thinking can help distinguish attempts from outcomes, but takes longer and may cost more. Support depends on the model.");
+      thinkingLevel = await ask("Thinking level (default/off/minimal/low/medium/high/xhigh/max)", thinkingLevel || "default",
+        (value) => field("thinkingLevel", value));
     }
     console.log("Summarizing sends selected, redacted history to your Pi model. Provider charges may apply.");
     console.log("Common secrets are redacted, but this is not a complete secret scanner. Pi keeps your credentials.");
@@ -91,7 +95,7 @@ export async function configureLogDig(settings, commandName = "logdig") {
     const autoCapture = await ask("Capture on Pi shutdown? (yes/no)", settings.autoCapture ? "yes" : "no", yesNo);
     installExtension = await ask("Install the Pi extension for /journal? (yes/no)", "no", yesNo);
 
-    nextSettings = { ...settings, cacheDirectory, dailyDirectory, dailyHeader, dailySummary, timeZone, sessionDirectory, piCommand, model, autoCapture };
+    nextSettings = { ...settings, cacheDirectory, dailyDirectory, dailyHeader, dailySummary, timeZone, sessionDirectory, piCommand, model, thinkingLevel, autoCapture };
     console.log([
       "",
       "Ready to save",
@@ -102,6 +106,7 @@ export async function configureLogDig(settings, commandName = "logdig") {
       `  History:     ${sessionDirectory}`,
       `  Pi:          ${piCommand}`,
       `  Model:       ${model || "Pi default"}`,
+      `  Thinking:    ${thinkingLevel || "default (no LogDig override)"}`,
       `  Auto-capture: ${autoCapture ? "on" : "off"}`,
       `  Extension:   ${installExtension ? "install now" : "leave unchanged"}`,
       "Missing note and cache folders will be created on your first real backfill.",