logdig 0.1.1 → 0.2.0

package/src/session-runner.js

@@ -1,7 +1,9 @@
 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 { DEFAULT_CONCURRENCY } from "./settings.js";
+import { assignLegacyBlocks, blockInRange, workBlocksForSession } from "./work-blocks.js";
 
 function localDate(timestamp, timeZone) {
   const parts = new Intl.DateTimeFormat("en-CA", {
@@ -65,13 +67,15 @@ async function findSessionFiles(root) {
   return { files, warnings };
 }
 
-export async function collectSessions({ sessionDirectory, timeZone, days, currentSession }) {
+export async function collectSessions({ sessionDirectory, timeZone, days, currentSession, skipToday = false }) {
   const { files, warnings } = await findSessionFiles(sessionDirectory);
   const currentId = currentSession?.header.id;
   const currentPath = currentSession?.sourcePath;
-  const today = localDate(Date.now(), timeZone);
-  const firstDate = days ? shiftDate(today, 1 - days) : undefined;
-  const modifiedAfter = days ? Date.now() - (days + 1) * 86400000 : undefined;
+  const now = Date.now();
+  const today = localDate(now, timeZone);
+  const lastDate = skipToday ? shiftDate(today, -1) : today;
+  const firstDate = days ? shiftDate(lastDate, 1 - days) : undefined;
+  const modifiedAfter = days ? now - (days + 1 + Number(skipToday)) * 86400000 : undefined;
   const sessions = [];
   const seen = new Set();
 
@@ -83,7 +87,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) {
@@ -93,7 +96,32 @@ export async function collectSessions({ sessionDirectory, timeZone, days, curren
 
   if (currentSession && !seen.has(currentSession.header.id)) sessions.push(currentSession);
   sessions.sort((left, right) => sessionEndTime(left) - sessionEndTime(right) || left.header.id.localeCompare(right.header.id));
-  return { sessions, warnings, firstDate, lastDate: today };
+  return { sessions, warnings, firstDate, lastDate, ...(skipToday ? { skipToday: true } : {}) };
+}
+
+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 = {}) {
@@ -103,94 +131,155 @@ export async function writeSessions(modelClient, sessions, settings, range = {})
   let entriesUpdated = 0;
   let entriesSkipped = 0;
   let sessionsSkipped = 0;
+  let blocksExcludedToday = 0;
   const dates = new Set();
   const dailyPaths = new Set();
-  const errors = [];
-  const sessionResults = [];
+  const results = sessions.map(() => ({ errors: [], sessionResults: [] }));
   const journaledEntries = range.journaledEntries || await listJournaledSessions(settings.cacheDirectory);
+  let dailyWrites = Promise.resolve();
+  const writeDailyEntry = (entry) => {
+    // Entry migration can touch multiple dates, so serialize all daily-note read/modify/writes.
+    const pending = dailyWrites.then(() => appendDailyEntry(settings.dailyDirectory, settings.dailyHeader, entry, journaledEntries, settings.dailyHeaderAnchor));
+    // The caller reports a failed write; it must not poison later queued writes.
+    dailyWrites = pending.catch(() => {});
+    return pending;
+  };
 
-  for (const [index, session] of sessions.entries()) {
+  async function writeSession(session, index) {
+    const { errors, sessionResults } = results[index];
     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 });
+      range.onProgress?.({ ...progress, phase: "error", status: "FAILED", error: error.message });
+      return;
+    }
+    const versions = journaledEntries.get(session.header.id) || [];
+    journaledEntries.set(session.header.id, versions);
+    assignLegacyBlocks(versions, blocks);
+    const excludedToday = range.skipToday ? blocks.filter((block) => block.activityDates.some((date) => date > range.lastDate)).length : 0;
+    blocksExcludedToday += excludedToday;
+    const selected = selectedBlockIndexes(blocks, versions, range);
+    if (!selected.size) {
+      sessionsSkipped++;
+      const reason = excludedToday ? "work periods active today (--skip-today)" : blocks.length ? "outside date range" : "no journalable events";
+      const latestBlock = blocks.at(-1);
+      sessionResults.push({ sessionId: session.header.id, status: "skipped", reason });
+      range.onProgress?.({
+        ...progress,
+        ...(latestBlock && { project: latestBlock.project, date: latestBlock.date, time: latestBlock.time }),
+        phase: "skipped",
+        status: "SKIPPED",
+        reason,
+      });
+      return;
+    }
+
+    const plannedSnapshots = new Map();
+    for (const [blockIndex, block] of blocks.entries()) {
+      if (!selected.has(blockIndex)) continue;
+      const blockProgress = {
+        ...progress, blockId: block.blockId, blockIndex: blockIndex + 1, blockTotal: blocks.length,
+        project: block.project, date: block.date, time: block.time, prerequisite: !blockInRange(block, range),
+      };
+      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 } = blockProgress;
+        range.onProgress?.({ ...blockProgress, phase: "checking", status: "CHECKING" });
+        const cached = range.dryRun
+          ? await inspectSessionSummary(modelClient, settings.cacheDirectory, journalBlock)
+          : await saveSessionSummary(modelClient, settings.cacheDirectory, journalBlock, {
+            onGenerate: () => range.onProgress?.({ ...blockProgress, phase: "summarizing", status: "SUMMARIZING" }),
+          });
+        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 writeDailyEntry(entry);
+        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 ? "PREVIEW" : dailyEntry.updated ? "UPDATED" : dailyEntry.appended ? "SAVED" : "CURRENT",
+        });
+      } 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", status: "FAILED", error: error.message });
+      }
     }
   }
 
-  return { summariesCreated, summariesReused, entriesAppended, entriesUpdated, entriesSkipped, sessionsSkipped, dates: [...dates].sort(), dailyPaths: [...dailyPaths].sort(), errors, sessionResults };
+  let nextIndex = 0;
+  const concurrency = Math.min(settings.concurrency ?? DEFAULT_CONCURRENCY, sessions.length);
+  await Promise.all(Array.from({ length: concurrency }, async () => {
+    while (nextIndex < sessions.length) {
+      const index = nextIndex++;
+      await writeSession(sessions[index], index);
+      range.onSessionComplete?.({ index: index + 1, total: sessions.length, sessionId: sessions[index].header.id });
+    }
+  }));
+
+  return {
+    summariesCreated, summariesReused, entriesAppended, entriesUpdated, entriesSkipped, sessionsSkipped, blocksExcludedToday,
+    dates: [...dates].sort(), dailyPaths: [...dailyPaths].sort(),
+    errors: results.flatMap((result) => result.errors),
+    sessionResults: results.flatMap((result) => result.sessionResults),
+  };
 }
 
 export function parseBackfillArgument(argument = "", command = "backfill") {

package/src/settings.js

@@ -3,13 +3,17 @@ import { homedir } from "node:os";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 
+export const DEFAULT_CONCURRENCY = 4;
+
 const ENVIRONMENT_SETTINGS = [
   ["PI_JOURNAL_DIR", "cacheDirectory"],
   ["PI_JOURNAL_DAILY_DIR", "dailyDirectory"],
   ["PI_JOURNAL_DAILY_HEADER", "dailyHeader"],
+  ["PI_JOURNAL_DAILY_HEADER_ANCHOR", "dailyHeaderAnchor"],
   ["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"],
 ];
@@ -39,11 +43,13 @@ function defaults({ env = process.env, home = homedir() } = {}) {
     cacheDirectory: undefined,
     dailyDirectory: undefined,
     dailyHeader: "# Projects",
+    dailyHeaderAnchor: "",
     dailySummary: "small",
     timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC",
     sessionDirectory: path.join(expandPath(agentDirectory, home), "sessions"),
     piCommand: "pi",
-    autoCapture: env.PI_JOURNAL_AUTO === "1",
+    concurrency: DEFAULT_CONCURRENCY,
+    autoCapture: false,
   };
 }
 
@@ -63,6 +69,14 @@ export function validateSettings(settings, { requirePaths = false, home = homedi
   if (!/^#{1,6}\s+[^\r\n]+$/.test(settings.dailyHeader)) {
     throw new Error("dailyHeader must be one Markdown heading, such as '# Projects'");
   }
+  settings.dailyHeaderAnchor ??= "";
+  if (typeof settings.dailyHeaderAnchor !== "string") {
+    throw new Error("dailyHeaderAnchor must be blank or one Markdown heading, such as '# Log'");
+  }
+  settings.dailyHeaderAnchor = settings.dailyHeaderAnchor.trim();
+  if (settings.dailyHeaderAnchor && !/^#{1,6}\s+[^\r\n]+$/.test(settings.dailyHeaderAnchor)) {
+    throw new Error("dailyHeaderAnchor must be blank or one Markdown heading, such as '# Log'");
+  }
   if (typeof settings.timeZone !== "string" || !settings.timeZone.trim()) throw new Error("timeZone must be a valid timezone");
   try {
     new Intl.DateTimeFormat("en", { timeZone: settings.timeZone });
@@ -85,6 +99,22 @@ 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.concurrency !== undefined) {
+    if (typeof settings.concurrency === "string" && /^\d+$/.test(settings.concurrency.trim())) {
+      settings.concurrency = Number(settings.concurrency.trim());
+    }
+    if (!Number.isSafeInteger(settings.concurrency) || settings.concurrency < 1) {
+      throw new Error("concurrency must be a positive integer (1 runs sessions sequentially)");
+    }
+  }
   if (settings.autoCapture !== undefined && typeof settings.autoCapture !== "boolean") {
     throw new Error("autoCapture must be a boolean");
   }
@@ -102,7 +132,13 @@ export function validateSettings(settings, { requirePaths = false, home = homedi
 
 export function environmentOverrides(env = process.env) {
   return [...ENVIRONMENT_SETTINGS.map(([variable]) => variable), "PI_JOURNAL_AUTO"]
-    .filter((variable) => env[variable] !== undefined && (env[variable] !== "" || variable === "PI_JOURNAL_AUTO"));
+    .filter((variable) => env[variable] !== undefined && (env[variable] !== "" || variable === "PI_JOURNAL_AUTO" || variable === "PI_JOURNAL_DAILY_HEADER_ANCHOR"));
+}
+
+export function environmentOverrideFor(key, env = process.env) {
+  const variable = [...ENVIRONMENT_SETTINGS, ["PI_JOURNAL_AUTO", "autoCapture"]]
+    .find(([, setting]) => setting === key)?.[0];
+  return environmentOverrides(env).includes(variable) ? variable : undefined;
 }
 
 export async function loadSettings(options = {}) {
@@ -124,10 +160,12 @@ export async function loadSettings(options = {}) {
   }
 
   const settings = { ...defaults({ env, home }), ...stored };
-  for (const [variable, key] of ENVIRONMENT_SETTINGS) {
-    if (env[variable] !== undefined && env[variable] !== "") settings[key] = env[variable];
+  if (options.applyEnvironment !== false) {
+    for (const [variable, key] of ENVIRONMENT_SETTINGS) {
+      if (env[variable] !== undefined && (env[variable] !== "" || key === "dailyHeaderAnchor")) settings[key] = env[variable];
+    }
+    if (env.PI_JOURNAL_AUTO !== undefined) settings.autoCapture = env.PI_JOURNAL_AUTO === "1" || env.PI_JOURNAL_AUTO === "true";
   }
-  if (env.PI_JOURNAL_AUTO !== undefined) settings.autoCapture = env.PI_JOURNAL_AUTO === "1" || env.PI_JOURNAL_AUTO === "true";
   validateSettings(settings);
   return { ...settings, filePath, configured };
 }
@@ -138,12 +176,15 @@ export async function saveSettings(settings, filePath = settings.filePath || set
     cacheDirectory: settings.cacheDirectory,
     dailyDirectory: settings.dailyDirectory,
     dailyHeader: settings.dailyHeader || "# Projects",
+    dailyHeaderAnchor: settings.dailyHeaderAnchor ?? "",
     dailySummary: settings.dailySummary || "small",
     timeZone: settings.timeZone || Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC",
     sessionDirectory: settings.sessionDirectory,
     piCommand: settings.piCommand || "pi",
+    concurrency: settings.concurrency ?? DEFAULT_CONCURRENCY,
     autoCapture: settings.autoCapture === true,
     ...(settings.model ? { model: settings.model } : {}),
+    ...(settings.thinkingLevel !== undefined ? { thinkingLevel: settings.thinkingLevel } : {}),
   };
   validateSettings(persisted, { requirePaths: true });
 

package/src/setup.js

@@ -69,6 +69,9 @@ export async function configureLogDig(settings, commandName = "logdig") {
       (value) => folder("cacheDirectory", value, true));
     console.log("Entries are grouped by project, then by time, under this heading. Use # Projects to keep your personal log separate.");
     const dailyHeader = await ask("Heading for journal entries", settings.dailyHeader, (value) => field("dailyHeader", value));
+    console.log("Create that section after an anchor's full section, before the next same-level or higher-level heading. Blank or missing anchors append at the end; existing sections stay in place.");
+    const dailyHeaderAnchor = await ask("Anchor heading (e.g. # Log), or 'none'", settings.dailyHeaderAnchor || "none",
+      (value) => field("dailyHeaderAnchor", value.toLowerCase() === "none" ? "" : value));
     console.log("Small: a few sentences. Medium: goal, progress, and next steps. Large: a short timeline.");
     const dailySummary = await ask("Daily summary (small/medium/large)", settings.dailySummary, (value) => field("dailySummary", value));
     const timeZone = await ask("Timezone", settings.timeZone, (value) => field("timeZone", value));
@@ -76,14 +79,21 @@ 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)"}`);
+    console.log(`Parallel sessions: ${settings.concurrency}`);
+    const advanced = await ask("Change history folder, Pi executable, model, thinking level, or concurrency? (yes/no)", "no", yesNo);
+    let { sessionDirectory, piCommand, model, thinkingLevel, concurrency } = 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("Independent sessions run in parallel. Use 1 for sequential processing or to reduce provider rate-limit pressure.");
+      concurrency = await ask("Maximum parallel sessions", concurrency, (value) => field("concurrency", 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,17 +101,20 @@ 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, dailyHeaderAnchor, dailySummary, timeZone, sessionDirectory, piCommand, model, thinkingLevel, concurrency, autoCapture };
     console.log([
       "",
       "Ready to save",
       `  Daily notes: ${dailyDirectory}/YYYY-MM-DD.md`,
       `  Heading:     ${dailyHeader}`,
+      `  Anchor:      ${dailyHeaderAnchor || "none (append at end)"}`,
       `  Summary:     ${dailySummary}, in ${timeZone}`,
       `  Cache:       ${path.join(cacheDirectory, "Sessions")}`,
       `  History:     ${sessionDirectory}`,
       `  Pi:          ${piCommand}`,
       `  Model:       ${model || "Pi default"}`,
+      `  Thinking:    ${thinkingLevel || "default (no LogDig override)"}`,
+      `  Parallel sessions: ${concurrency}`,
       `  Auto-capture: ${autoCapture ? "on" : "off"}`,
       `  Extension:   ${installExtension ? "install now" : "leave unchanged"}`,
       "Missing note and cache folders will be created on your first real backfill.",

package/src/transcript.js

@@ -1,4 +1,3 @@
-import { createHash } from "node:crypto";
 import path from "node:path";
 
 const READ_TOOLS = new Set([
@@ -45,12 +44,6 @@ export function sessionFromJsonl(text, sourcePath = "<session>") {
   return parseSessionJsonl(text, sourcePath);
 }
 
-export function fingerprintSession(session) {
-  return createHash("sha256")
-    .update(JSON.stringify([session.header, session.entries]))
-    .digest("hex");
-}
-
 export function textContent(content) {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return "";
@@ -69,7 +62,7 @@ export function redactAndClip(value, maxLength = 1800) {
   return `${text.slice(0, maxLength)}\n[truncated]`;
 }
 
-function timestampOf(entry) {
+export function timestampOf(entry) {
   const value = entry.timestamp ?? entry.message?.timestamp;
   if (typeof value === "number") return value;
   if (typeof value === "string") {
@@ -121,8 +114,8 @@ export function sessionMetrics(session) {
   return metrics;
 }
 
-function localParts(timestamp, timeZone) {
-  const parts = new Intl.DateTimeFormat("en-CA", {
+export function localTimeFormatter(timeZone) {
+  return new Intl.DateTimeFormat("en-CA", {
     timeZone,
     year: "numeric",
     month: "2-digit",
@@ -130,7 +123,11 @@ function localParts(timestamp, timeZone) {
     hour: "2-digit",
     minute: "2-digit",
     hourCycle: "h23",
-  }).formatToParts(new Date(timestamp));
+  });
+}
+
+export function localParts(timestamp, formatter) {
+  const parts = formatter.formatToParts(new Date(timestamp));
   const values = Object.fromEntries(parts.map((part) => [part.type, part.value]));
   return {
     date: `${values.year}-${values.month}-${values.day}`,
@@ -172,10 +169,10 @@ function outputExcerpt(content, limit = 420) {
   return `${text.slice(0, half)}\n[…output clipped…]\n${text.slice(-half)}`;
 }
 
-function eventFor(entry, timeZone, toolCalls) {
+function eventFor(entry, formatter, toolCalls) {
   const timestamp = timestampOf(entry);
   if (timestamp === undefined) return undefined;
-  const { date, time } = localParts(timestamp, timeZone);
+  const { date, time } = localParts(timestamp, formatter);
   const message = entry.message;
 
   if (entry.type === "compaction" || entry.type === "branch_summary") {
@@ -251,14 +248,14 @@ function eventFor(entry, timeZone, toolCalls) {
   return undefined;
 }
 
-export function eventsForSession(session, timeZone) {
+export function eventsForSession(session, timeZone, extraction = { formatter: localTimeFormatter(timeZone), toolCalls: new Map() }) {
   const events = [];
-  const toolCalls = new Map();
+  const { formatter, toolCalls } = extraction;
   const cwd = session.header.cwd || "";
   const project = (cwd ? path.basename(cwd) : "").replace(/^\d{4}-\d{2}-\d{2}-(?=.)/, "") || "unknown project";
 
   for (const entry of session.entries) {
-    const generated = eventFor(entry, timeZone, toolCalls);
+    const generated = eventFor(entry, formatter, toolCalls);
     if (!generated) continue;
     for (const event of Array.isArray(generated) ? generated : [generated]) {
       events.push({

package/src/work-blocks.js

@@ -0,0 +1,101 @@
+import { createHash } from "node:crypto";
+import { eventsForSession, localParts, localTimeFormatter, timestampOf } from "./transcript.js";
+
+const CONTINUATION_GAP_MS = 4 * 60 * 60 * 1000;
+const CONTEXT_LIMIT = 3200;
+const CONTEXT_EVENTS = 6;
+const ACTIVITY_ROLES = new Set(["user", "assistant", "toolResult", "bashExecution"]);
+
+function precedingContext(events) {
+  const context = [];
+  let size = 0;
+  for (let index = events.length - 1; index >= 0 && context.length < CONTEXT_EVENTS; index--) {
+    const event = events[index];
+    const length = JSON.stringify(event).length;
+    if (size + length > CONTEXT_LIMIT) break;
+    context.unshift(event);
+    size += length;
+  }
+  return context;
+}
+
+export function workBlocksForSession(session, timeZone) {
+  const formatter = localTimeFormatter(timeZone);
+  const blocks = [];
+  let current;
+  let lastActivity;
+  let userIndex = 0;
+  const pending = [];
+
+  for (const entry of session.entries) {
+    const contextSummary = ["compaction", "branch_summary"].includes(entry.type) && typeof entry.summary === "string" && entry.summary.trim();
+    const activity = (entry.type === "message" && ACTIVITY_ROLES.has(entry.message?.role)) || contextSummary;
+    const timestamp = activity ? timestampOf(entry) : undefined;
+    if (timestamp !== undefined) {
+      const { date, time } = localParts(timestamp, formatter);
+      const user = entry.message?.role === "user";
+      if (user) userIndex++;
+      if (!current || (user && date > current.date && timestamp - lastActivity >= CONTINUATION_GAP_MS)) {
+        const blockId = createHash("sha256")
+          .update(JSON.stringify([session.header.id, entry.id || [timestamp, userIndex]]))
+          .digest("hex");
+        current = {
+          ...session,
+          header: blocks.length ? { ...session.header, timestamp: new Date(timestamp).toISOString() } : session.header,
+          entries: blocks.length ? [] : pending.splice(0),
+          blockId,
+          blockStart: new Date(timestamp).toISOString(),
+          date,
+          time,
+          timezone: timeZone,
+          activityDates: new Set(),
+        };
+        blocks.push(current);
+      }
+      current.activityDates.add(date);
+      lastActivity = Math.max(lastActivity ?? timestamp, timestamp);
+    }
+    if (current) current.entries.push(entry);
+    else pending.push(entry);
+  }
+
+  const journalable = [];
+  const extraction = { formatter, toolCalls: new Map() };
+  for (const block of blocks) {
+    const events = eventsForSession(block, timeZone, extraction);
+    if (!events.length) continue;
+    const previous = journalable.at(-1);
+    journalable.push({
+      ...block,
+      blockIndex: journalable.length,
+      project: events[0].project,
+      events,
+      context: previous ? precedingContext(previous.events) : [],
+      previousBlockId: previous?.blockId,
+      activityDates: [...block.activityDates],
+    });
+  }
+  return journalable;
+}
+
+export function blockInRange(block, range) {
+  // Never create a partial summary of a work period that continues into today.
+  if (range.skipToday && block.activityDates.some((date) => date > range.lastDate)) return false;
+  return !range.firstDate || block.activityDates.some((date) => date >= range.firstDate && date <= range.lastDate);
+}
+
+// Legacy entries used their last user timestamp. Blocks that disappear after a
+// timezone change also need reassignment, without altering their linked notes.
+export function assignLegacyBlocks(versions, blocks) {
+  if (!blocks.length) return;
+  const currentIds = new Set(blocks.map((block) => block.blockId));
+  for (const version of versions) {
+    if (currentIds.has(version.blockId)) continue;
+    const anchor = `${version.date} ${version.time}`;
+    const block = blocks.findLast((candidate) => version.blockStart
+      ? candidate.blockStart <= version.blockStart
+      : `${candidate.date} ${candidate.time}` <= anchor) || blocks[0];
+    version.blockId = block.blockId;
+    version.legacy = true;
+  }
+}