logdig 0.1.1 → 0.2.0

package/src/config-menu.js

@@ -0,0 +1,135 @@
+import { createInterface } from "node:readline";
+import { stdin, stdout } from "node:process";
+import { checkDirectory } from "./directories.js";
+import { environmentOverrideFor, loadSettings, saveSettings, validateSettings } from "./settings.js";
+import { statusPrefix } from "./cli-status.js";
+
+const fields = [
+  { key: "dailyDirectory", label: "Daily-notes folder", folder: "write",
+    hint: "The folder holding YYYY-MM-DD.md notes, not the vault root." },
+  { key: "cacheDirectory", label: "Summary cache folder", folder: "write",
+    hint: "Keeps all three summary lengths. Put it inside your vault to browse them in Obsidian." },
+  { key: "dailyHeader", label: "Journal heading",
+    hint: "One Markdown heading, including its # level, for example # Projects." },
+  { key: "dailyHeaderAnchor", label: "Anchor heading", empty: "none",
+    hint: "Create the journal section after this heading's full section. Type none to append at the end. Existing sections stay in place." },
+  { key: "dailySummary", label: "Daily summary length", choices: ["small", "medium", "large"],
+    hint: "Small: a few sentences. Medium: goal, progress, and next steps. Large: a short timeline." },
+  { key: "timeZone", label: "Timezone",
+    hint: "Determines journal dates and times, for example Europe/Berlin or UTC." },
+  { key: "sessionDirectory", label: "Pi session-history folder", folder: "read",
+    hint: "The folder containing saved Pi sessions. Missing folders are allowed." },
+  { key: "piCommand", label: "Pi executable",
+    hint: "A command on your PATH, such as pi, or a full executable path." },
+  { key: "model", label: "Summary model", empty: "default",
+    hint: "Use provider/model, or type default to remove the LogDig override. Changing the model can require new summaries." },
+  { key: "thinkingLevel", label: "Thinking level", empty: "default",
+    choices: ["default", "off", "minimal", "low", "medium", "high", "xhigh", "max"],
+    hint: "More thinking may take longer and cost more. Model support varies. Default removes the LogDig override." },
+  { key: "concurrency", label: "Maximum parallel sessions",
+    hint: "A positive integer. Use 1 for sequential processing or to reduce rate-limit pressure." },
+  { key: "autoCapture", label: "Automatic capture", choices: ["yes", "no"],
+    hint: "Capture on Pi shutdown. Requires the Pi extension; sends selected, redacted history to your model, may incur charges, and can delay shutdown. Redaction is not a complete secret scanner." },
+];
+
+function displayValue(field, value) {
+  if (typeof value === "boolean") return value ? "yes" : "no";
+  return String(value || field.empty || "not configured");
+}
+
+export async function editConfig(commandName = "logdig", { input = stdin, output = stdout, env = process.env } = {}) {
+  let settings = await loadSettings({ env, applyEnvironment: false });
+  const print = (text = "") => output.write(`${text}\n`);
+  const labelWidth = Math.max(...fields.map((field) => field.label.length));
+  const showMenu = () => {
+    print("\nLogDig settings");
+    print(`Settings: ${settings.filePath}`);
+    print("Values below are saved preferences (or defaults). Environment overrides take precedence.");
+    print();
+    fields.forEach((field, index) => {
+      const variable = environmentOverrideFor(field.key, env);
+      print(`  ${String(index + 1).padStart(2)}. ${field.label.padEnd(labelWidth)}  ${displayValue(field, settings[field.key])}`);
+      if (variable) print(`      Override: ${variable}=${JSON.stringify(env[variable])} (saved changes will not override it)`);
+    });
+    print("\nChanges save immediately. No summaries or daily notes are written here.");
+  };
+  showMenu();
+  if (!settings.dailyDirectory || !settings.cacheDirectory) {
+    print(`\nRun '${commandName} init' first to configure your notes and cache folders.`);
+    return;
+  }
+
+  const rl = createInterface({ input, output, terminal: Boolean(output.isTTY) && env.TERM !== "dumb" });
+  const answers = rl[Symbol.asyncIterator]();
+  let interrupted = false;
+  const cancel = () => { interrupted = true; rl.close(); };
+  rl.on("SIGINT", cancel);
+  process.once("SIGINT", cancel);
+  const checkInterrupted = () => {
+    if (!interrupted) return;
+    const error = new Error("Configuration cancelled. Previously saved changes are kept.");
+    error.code = "LOGDIG_CONFIG_CANCELLED";
+    throw error;
+  };
+  const ask = async (prompt) => {
+    rl.setPrompt(prompt);
+    rl.prompt();
+    const answer = await answers.next();
+    checkInterrupted();
+    return answer.done ? "q" : answer.value.trim();
+  };
+
+  try {
+    while (true) {
+      const selection = await ask("\nChoose a setting by number or name (q to quit): ");
+      if (selection.toLowerCase() === "q") break;
+      if (!selection) continue;
+      const matches = /^\d+$/.test(selection)
+        ? fields.filter((_, index) => index + 1 === Number(selection))
+        : fields.filter((field) => `${field.label} ${field.key}`.toLowerCase().includes(selection.toLowerCase()));
+      if (matches.length !== 1) {
+        print(matches.length
+          ? `Please be more specific: ${matches.map((field) => `${fields.indexOf(field) + 1}. ${field.label}`).join("; ")}.`
+          : `Choose a number from 1 to ${fields.length}, a setting name, or q.`);
+        continue;
+      }
+      const field = matches[0];
+      print(`\n${field.label}`);
+      print(field.hint);
+      if (field.choices) print(`Available values: ${field.choices.join(", ")}`);
+      print("Enter keeps the current value. q quits without changing this field.");
+      while (true) {
+        const value = await ask(`New value [${displayValue(field, settings[field.key])}]: `);
+        if (value.toLowerCase() === "q") return;
+        if (!value) {
+          print("Kept the current value.");
+          break;
+        }
+        let nextSettings;
+        try {
+          let parsed = value;
+          if (field.key === "autoCapture") {
+            if (!/^(yes|no|y|n)$/i.test(value)) throw new Error("Please enter yes or no");
+            parsed = /^(yes|y)$/i.test(value);
+          } else if (field.key === "model" && value.toLowerCase() === "default") parsed = undefined;
+          else if (field.key === "dailyHeaderAnchor" && value.toLowerCase() === "none") parsed = "";
+          nextSettings = validateSettings({ ...settings, [field.key]: parsed });
+          if (field.folder) await checkDirectory(nextSettings[field.key], { writable: field.folder === "write", allowMissing: true });
+        } catch (error) {
+          print(`  ${error.message}. Let's try that again.`);
+          continue;
+        }
+        checkInterrupted();
+        await saveSettings(nextSettings, settings.filePath);
+        settings = nextSettings;
+        print(`\n${statusPrefix("ok", { isTTY: output.isTTY, term: env.TERM, icons: env.LOGDIG_ICONS !== "0", noColor: env.NO_COLOR !== undefined })}${field.label} saved: ${displayValue(field, settings[field.key])}`);
+        if (field.key === "autoCapture" && settings.autoCapture) print(`If the Pi extension is not installed, run '${commandName} pi-install'.`);
+        break;
+      }
+      showMenu();
+    }
+  } finally {
+    process.removeListener("SIGINT", cancel);
+    rl.close();
+  }
+}

package/src/index.js

@@ -1,9 +1,9 @@
 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";
+import { progressStatus } from "./cli-status.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 +23,6 @@ function currentSession(ctx) {
     entries: ctx.sessionManager.getEntries(),
     sourcePath: ctx.sessionManager.getSessionFile() || "active Pi session",
   };
-  session.fingerprint = fingerprintSession(session);
   return session;
 }
 
@@ -37,26 +36,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();
     },
   };
 }
@@ -67,10 +69,11 @@ function notify(ctx, message, level = "info") {
 }
 
 function journalProgress(ctx) {
-  return ({ index, total, project, status, error, phase }) => {
-    const message = `LogDig [${index}/${total}]${project ? ` ${project}` : ""}: ${error || status}`;
+  return ({ index, total, sessionId, project, date, time, status }) => {
+    const label = `${date ? `${date}${time ? ` ${time}` : ""} · ` : ""}${project || sessionId}`;
+    const message = `LogDig [${index}/${total}] ${label} · ${progressStatus(status || "CHECKING")}`;
     if (ctx.hasUI) ctx.ui.setStatus?.("logdig", message);
-    else if (["summarizing", "complete", "error"].includes(phase)) console.log(message);
+    else console.log(message);
   };
 }
 
@@ -88,7 +91,7 @@ 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"}`;

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) {
@@ -354,7 +391,7 @@ function isProjectHeading(line, targetLevel) {
 function addEntryAt(markdown, offset, entry) {
   const before = markdown.slice(0, offset).replace(/\n{3,}$/, "\n\n");
   const after = markdown.slice(offset);
-  const separator = before.endsWith("\n\n") ? "" : before.endsWith("\n") ? "\n" : "\n\n";
+  const separator = /\r?\n\r?\n$/.test(before) ? "" : before.endsWith("\n") ? "\n" : "\n\n";
   const suffix = after ? "\n\n" : "\n";
   return `${before}${separator}${entry}${suffix}${after}`;
 }
@@ -466,7 +503,7 @@ function removeEmptyProjectGroups(markdown, heading) {
   return removeMarkdownRanges(markdown, emptyGroups);
 }
 
-function appendUnderProject(markdown, heading, entry) {
+function appendUnderProject(markdown, heading, entry, anchorHeading) {
   const targetLevel = headingLevel(heading);
   const project = entry.project.replace(/[\\`*_[\]<>|&#\r\n]/g, (character) =>
     /[\r\n]/.test(character) ? " " : `&#${character.charCodeAt(0)};`);
@@ -529,24 +566,36 @@ 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`;
+    let anchorFound = false;
+    let offset = markdown.length;
+    const anchorLevel = headingLevel(anchorHeading || "");
+    if (anchorHeading) {
+      for (const line of markdownLines(markdown)) {
+        if (line.blocked) continue;
+        if (!anchorFound) {
+          if (line.text.trimEnd() === anchorHeading) anchorFound = true;
+        } else if (headingLevel(line.text) <= anchorLevel) {
+          offset = line.start;
+          break;
+        }
+      }
+    }
+    const section = `${heading}\n\n${projectHeading}\n\n${text}`;
+    if (offset < markdown.length) return addEntryAt(markdown, offset, section);
+    const separator = !markdown || /\r?\n\r?\n$/.test(markdown) ? "" : markdown.endsWith("\n") ? "\n" : "\n\n";
+    return `${markdown}${separator}${section}\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 +604,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 +634,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 +660,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,
   };
@@ -625,11 +684,11 @@ async function updateEntrySnapshot(entryPath, entry, createIfMissing) {
   if (enriched !== snapshot) await writeAtomically(entryPath, enriched);
 }
 
-async function updateSessionDailyNotes(heading, entry, inspection) {
+async function updateSessionDailyNotes(heading, entry, inspection, anchorHeading) {
   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();
@@ -643,21 +702,21 @@ async function updateSessionDailyNotes(heading, entry, inspection) {
   const updatedMarkdown = appendUnderProject(markdown, heading, {
     ...entry,
     ...(customSummaries.length ? { summaryOverride: customSummaries.join("\n\n") } : {}),
-  });
+  }, anchorHeading);
   await writeAtomically(dailyPath, updatedMarkdown);
   for (const [filePath, contents] of cleanedDocuments) await writeAtomically(filePath, contents);
 }
 
-export async function appendDailyEntry(dailyDirectory, heading, entry, journaledEntries) {
+export async function appendDailyEntry(dailyDirectory, heading, entry, journaledEntries, anchorHeading = "") {
   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 };
+    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 };
+  await updateSessionDailyNotes(heading, entry, inspection, anchorHeading);
+  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),
   };
 }