logdig 0.1.2 → 0.2.1

package/QUICKSTART.md

@@ -18,13 +18,16 @@ In the wizard:
 - **Daily-notes folder:** choose the folder holding `YYYY-MM-DD.md` notes, for example `My Vault/Daily`.
 - **Summary cache:** choose `My Vault/LogDig` to keep the full summaries visible in Obsidian.
 - **Heading and length:** `# Projects` and `small` are a good first try. Your personal `# Log` stays separate.
+- **Anchor heading:** optionally choose `# Log` to create Projects at the end of the Log section, before the next same-level or higher-level heading. The default is `none` (blank): append at the end of the note. Missing anchors also append at the end; existing Projects sections stay in place.
 - **Timezone:** check that this is the timezone you journal in.
-- **Advanced settings:** choose a custom Pi history folder, executable, model, or thinking level here. Thinking defaults to no LogDig override; choose an explicit level such as `max` for a cost-first reasoning model if you are willing to wait longer.
+- **Advanced settings:** choose a custom Pi history folder, executable, model, thinking level, or concurrency here. Thinking defaults to no LogDig override; choose an explicit level such as `max` for a cost-first reasoning model if you are willing to wait longer. Concurrency defaults to four independent sessions; use `1` for sequential processing.
 - **Automatic capture:** choose **no** for now.
 - **Pi extension:** optional. The CLI works without it.
 
 Press Enter to accept defaults. A typo only re-asks that question. Review the choices before saving. Ctrl+C or declining confirmation leaves your settings unchanged. Setup writes settings only, not summaries or daily notes.
 
+To change a setting later, run `logdig config`. Choose its number or type a name such as `thinking`, then enter the new value. Available choices are shown first. Enter keeps the current value; each valid change saves immediately and refreshes the list. Type `q` and Enter to exit. Environment overrides are labeled and still take precedence. Redirected output stays read-only.
+
 ## 2. Check and preview
 
 ```sh
@@ -41,6 +44,17 @@ logdig backfill 1 --dry-run
 logdig backfill 7 --dry-run
 ```
 
+To backfill older work without spending model requests on ongoing sessions, add `--skip-today`:
+
+```sh
+logdig backfill 7 --skip-today --dry-run
+logdig backfill 7 --skip-today
+logdig backfill 14 --skip-today
+logdig backfill 30 --skip-today
+```
+
+This selects complete calendar days through yesterday in your timezone and excludes whole work periods that continued today. Earlier periods in the same session can still be logged. Each wider run reuses unchanged summaries. The flag also works with `backfill all` and `status`.
+
 If no history is found at all, start a saved Pi session or select the right history folder in the wizard's advanced settings.
 
 ## 3. Make the first entry

package/README.md

@@ -30,6 +30,7 @@ For a comfortable first try:
 - Choose the folder **inside your vault** holding your daily notes, such as `My Vault/Daily`.
 - Put the summary cache in `My Vault/LogDig` if you want to browse it in Obsidian.
 - Keep the `# Projects` heading and **small** summary unless you prefer otherwise. Your personal `# Log` section stays separate.
+- Optionally choose `# Log` as the anchor heading to create Projects after your Log section, before the next sibling heading. Leave it unset to append at the end.
 - Check the timezone. It determines the journal date and time.
 - Leave automatic capture **off** until you have tried a manual run. Pi integration is optional.
 
@@ -67,7 +68,7 @@ My Vault/
         └── <entry-id>.md         snapshot of all three layers for a journal entry
 ```
 
-Daily entries live under `# Projects`, grouped by project in first-seen order, with timestamps sorted within each project. For [try](https://github.com/tobi/try)-style directories, a leading `YYYY-MM-DD-` is omitted from the project label: `2026-01-17-learn` becomes `learn`. The source path is unchanged.
+Daily entries live under `# Projects`, grouped by project in first-seen order, with timestamps sorted within each project. For Git worktrees, LogDig uses the shared repository's name rather than the worktree directory's name. For [try](https://github.com/tobi/try)-style directories, a leading `YYYY-MM-DD-` is omitted from the project label: `2026-01-17-learn` becomes `learn`. The source path is unchanged.
 
 For example:
 
@@ -104,6 +105,22 @@ The block's **starting date and time** supply its journal timestamp. Continuous
 
 Date ranges select actual conversation activity, not just assigned journal dates. Today's backfill therefore catches assistant completion or continued work after midnight and updates yesterday's entry. If a selected continuation has no preceding snapshot, LogDig includes the missing earlier block(s) as prerequisites. Status and preview explicitly show these additions, including their summary-generation cost implications.
 
+### Backfill past work without touching today
+
+Use `--skip-today` with CLI `backfill` or `status` to select the last N **complete calendar days**, ending yesterday in your configured timezone. For example, `backfill 1 --skip-today` selects yesterday, and `backfill 7 --skip-today` selects seven days through yesterday. `all --skip-today` selects all past work.
+
+Work periods with conversation activity today are excluded entirely, even if they started before midnight. Earlier periods in the same session remain eligible. This avoids generating partial summaries or updating an ongoing period's existing cache or journal entry. Metadata-only activity does not exclude a period. Missing earlier continuation snapshots are still included as prerequisites.
+
+```sh
+logdig backfill 7 --skip-today --dry-run
+logdig backfill 7 --skip-today
+logdig backfill 14 --skip-today
+logdig backfill 30 --skip-today
+logdig backfill all --skip-today
+```
+
+Widening the range reuses unchanged summaries and fills the additional history. Status and preview show the selected dates and the number of excluded work periods; status JSON includes `timeframe.skipToday` and `totals.excludedToday` when the flag is set. Without the flag, the normal range still includes today.
+
 ### Summary reuse and existing journals
 
 Summary freshness is based on the selected, redacted evidence and bounded earlier context, plus summary-processing version, timezone, and configured generation policy. Earlier context is drawn from the preceding block's evidence, not its generated summary, and is marked as background rather than work to repeat. Metadata-only changes do not trigger model requests; usage totals can refresh separately. Explicit LogDig model or thinking-level changes invalidate summaries, while changes to Pi's defaults do not force regeneration under the default policy.
@@ -123,23 +140,25 @@ After a global install or `npm link`, use `logdig` from any directory. All comma
 ```text
 logdig init                         configure paths, summaries, and optional Pi integration
 logdig doctor                       check paths and Pi, with no model request
-logdig config                       show effective settings and environment overrides
+logdig config                       edit settings by number or name; q quits
 logdig --version                    show the installed version
 logdig backfill                     journal the last 3 calendar days
 logdig backfill 7 --dry-run          preview seven days without changing anything
 logdig backfill all --dry-run        preview every discoverable saved session
 logdig backfill 7                    journal seven days
+logdig backfill 7 --skip-today       journal seven complete days through yesterday
 logdig backfill 7 --model provider/model --thinking max
 logdig backfill 7 --model default    ignore a saved model override for this run
 logdig backfill 7 --thinking default ignore a saved thinking override for this run
 logdig status                       show coverage for the last 3 calendar days
 logdig status 7                     show coverage for seven days
+logdig status 7 --skip-today        show coverage excluding work active today
 logdig status all --json            output coverage for every saved session as JSON
 logdig pi-install                   install the /journal extension
 logdig pi-uninstall                 remove it without deleting notes or summaries
 ```
 
-`--help` works before setup, including `logdig init --help`, `logdig backfill --help`, and `logdig status --help`.
+`--help` works before setup, including `logdig init --help`, `logdig config --help`, `logdig backfill --help`, and `logdig status --help`.
 
 `status` is a read-only coverage check. It counts work blocks: **logged** means the expected entry is present, **stale** means a previous snapshot exists but the entry needs updating, and **new** means no previous block snapshot was found. Summaries are reported separately as reusable or needing summarization. These are block counts, not exact request counts. It selects blocks by conversation activity in your configured timezone, including overnight updates and any missing continuation prerequisites. It never calls a model or writes files; scan warnings make the command exit nonzero so incomplete coverage is clear. JSON retains `sessions` as the result array, with one row per work block and both `sessionId` and `blockId`; totals use `logged`, `stale`, `new`, and `needsSummarizing`.
 
@@ -192,13 +211,36 @@ Settings contain paths and preferences, never provider credentials:
 - macOS: `~/Library/Application Support/LogDig/settings.json`
 - Windows: `%APPDATA%\LogDig\settings.json`
 
+### Change one setting
+
+Run `logdig config` in a terminal to see a numbered list of settings and current saved values. Enter a number (including `10`, `11`, or `12`) or a setting name such as `thinking` or `parallel`. Allowed values and a short explanation appear before you enter a new value. Enter keeps the current value; invalid input re-asks only that field. Each valid change saves immediately and shows the updated list. Type `q` and Enter at either prompt to exit. Ctrl+C or ending input also exits; completed saves are kept.
+
+Use `default` to clear a model or thinking override, and `none` to clear the anchor heading. Active environment overrides are labeled next to their saved preferences and are never copied into the settings file. Changing a preference does not defeat its environment override. Enabling automatic capture still requires the Pi extension (`logdig pi-install`). Configuration never requests summaries, writes notes, or creates note/cache folders. Run `init` first if those folders have not been configured.
+
+The menu uses Node's built-in line prompts with no runtime dependencies. Save confirmations follow the existing Nerd Font, `LOGDIG_ICONS=0`, and `NO_COLOR` conventions. `TERM=dumb` uses plain prompts. When input or output is redirected, `config` stays read-only and shows effective settings as formatted JSON with the settings path and override names, as before. For example: `logdig config > settings-report.txt`.
+
+### Journal preferences
+
+`dailyHeader` selects the section for project entries (default `# Projects`). The optional `dailyHeaderAnchor` selects where to create that section:
+
+```json
+{
+  "dailyHeader": "# Projects",
+  "dailyHeaderAnchor": "# Log"
+}
+```
+
+This inserts a new Projects section after the entire Log section, including its subheadings, and before the next same-level or higher-level heading. Use the same heading level for both settings to keep the sections as siblings. The anchor must be one Markdown heading, including its `#` level, and matches the first occurrence outside frontmatter and fenced code. The default is `""` (blank): append at the end of the note. A missing anchor also falls back to the end. Existing Projects sections stay where they are; this setting does not relocate them or regenerate summaries. Run `config` to edit the anchor or choose `none` to clear it. `PI_JOURNAL_DAILY_HEADER_ANCHOR` overrides the saved setting, including an empty value to clear it.
+
+Backfill and automatic capture process up to **four independent sessions concurrently** by default. Set `concurrency` in the settings file or choose “Maximum parallel sessions” in setup's advanced settings. It must be a positive integer; use `1` for sequential processing or to reduce provider rate-limit pressure. Work blocks and extraction requests within each session remain sequential to preserve continuation links. Shared daily-note updates are serialized to avoid overwriting entries. CLI result rows appear in session order even when parallel sessions finish out of order. Session numbers are zero-padded to match the total, for example `[01/65]`, followed by the date, a fixed-width status column, project, and short session ID. Each work period has one final result row; resumed sessions can have multiple dated rows with the same session number. In interactive terminals, a bounded live panel below the permanent results separates active sessions from finished results. Its progress line shows completed, active, and queued (not yet started) session counts. Active rows show the elapsed time in their current stage (`CHECKING` or `SUMMARIZING`), refreshed every second even while the model is silent. Finished sessions no longer occupy active rows. Instead, a message such as “20 finished sessions waiting to print after #021” identifies the earlier session holding up result display; completed counts include these unprinted results. Short terminals show fewer active rows and indicate how many are not shown. The panel redraws in place and clears when the run finishes. A slow earlier session can delay printing later result rows, but other sessions keep processing and picking up queued work. Redirected output and `TERM=dumb` use plain `Active` and `Finished` log lines instead of cursor controls. Dry-run output stays static. Blocks outside the selected range that are needed for continuation links are marked `prerequisite`. The final checked count distinguishes work blocks from sessions. Status reports retain chronological session order. Changing concurrency does not invalidate cached summaries. Avoid running separate LogDig commands against the same notes at the same time; the write queue is local to one run.
+
 Set `LOGDIG_CONFIG_PATH` to choose another settings file. Existing `PI_JOURNAL_*` environment variables remain supported and override saved values. Setup, `config`, and `doctor` name active overrides so you can see why a saved preference is not taking effect.
 
 - **No saved history found:** create a saved Pi session, or use setup's advanced settings to select your history folder. This is especially useful with a custom Pi session directory.
-- **Notes went to the wrong folder:** run `config`, check environment overrides, then run `init` to choose the daily-notes folder rather than the vault root.
-- **Pi cannot start:** run `doctor`, then use setup's advanced settings to set the executable path.
+- **Notes went to the wrong folder:** run `config`, check environment overrides, and edit the daily-notes folder rather than the vault root.
+- **Pi cannot start:** run `doctor`, then use `config` to set the executable path.
 - **A summary or note failed:** read the error, fix the path, permissions, authentication, or provider issue, and rerun. Successful cached work is kept.
-- **Want to stop automatic capture:** rerun `init` and choose “no”, or set `PI_JOURNAL_AUTO=0`.
+- **Want to stop automatic capture:** run `config` and set automatic capture to `no`, or set `PI_JOURNAL_AUTO=0`.
 
 ## Development
 

package/bin/logdig.js

@@ -9,7 +9,9 @@ import { spawnPiProcess } from "../src/pi-process.js";
 import { environmentOverrides, loadSettings, validateSettings } from "../src/settings.js";
 import { checkDirectory } from "../src/directories.js";
 import { configureLogDig } from "../src/setup.js";
+import { editConfig } from "../src/config-menu.js";
 import { statusPrefix, statusPrefixWidth } from "../src/cli-status.js";
+import { createBackfillProgress } from "../src/backfill-progress.js";
 
 const packageRoot = fileURLToPath(new URL("../", import.meta.url));
 const relativeEntry = path.relative(process.cwd(), fileURLToPath(import.meta.url)).split(path.sep).join("/");
@@ -71,6 +73,7 @@ function runPiCommand(command, args, { cwd = process.cwd(), inherit = false, tim
 }
 
 async function showConfig() {
+  if (process.stdin.isTTY && process.stdout.isTTY) return editConfig(commandName);
   const settings = await loadSettings();
   const { filePath, configured, ...values } = settings;
   console.log(`Settings: ${filePath}${configured ? "" : " (not created yet)"}`);
@@ -126,6 +129,7 @@ async function doctor() {
   }
   console.log(`\nSummary model: ${settings.model || "Pi startup default"}`);
   console.log(`Thinking: ${settings.thinkingLevel || "Pi startup default"}`);
+  console.log(`Parallel sessions: ${settings.concurrency}`);
   console.log("Authentication is checked only when you request a summary. If it fails, open Pi and run /login.");
   if (issues) {
     console.error(`\n${issues} thing${issues === 1 ? "" : "s"} to fix. Address the FIX lines above, then run '${commandName} doctor' again.`);
@@ -139,12 +143,15 @@ async function backfill(args) {
   const settings = await loadSettings();
   let daysArgument;
   let dryRun = false;
+  let skipToday = false;
   let selectedModel = settings.model;
   let selectedThinking = settings.thinkingLevel;
   for (let index = 0; index < args.length; index++) {
     const arg = args[index];
     if (arg === "--dry-run") {
       dryRun = true;
+    } else if (arg === "--skip-today") {
+      skipToday = true;
     } else if (arg === "--model" || arg === "-m") {
       selectedModel = args[++index];
       if (!selectedModel || selectedModel.startsWith("-")) throw new Error("--model requires provider/model, or 'default' to use Pi's startup model");
@@ -168,16 +175,17 @@ async function backfill(args) {
   const range = parseBackfillArgument(daysArgument);
   requireJournalPaths(settings);
 
-  console.log(`${dryRun ? "Preview" : "Backfill"}: ${range.all ? "all saved sessions" : `last ${range.days} day${range.days === 1 ? "" : "s"}`} (${settings.timeZone})`);
+  console.log(`${dryRun ? "Preview" : "Backfill"}: ${range.all ? "all saved sessions" : `last ${range.days}${skipToday ? " complete" : ""} day${range.days === 1 ? "" : "s"}`} (${settings.timeZone})${skipToday ? " · skipping today" : ""}`);
   console.log(`Daily notes: ${settings.dailyDirectory} (${settings.dailyHeader}, ${settings.dailySummary})`);
   console.log(`Summary cache: ${path.join(settings.cacheDirectory, "Sessions")}`);
   console.log(`Model: ${selectedModel || "Pi startup default"}`);
   console.log(`Thinking: ${selectedThinking || "Pi startup default"}`);
+  console.log(`Parallel sessions: ${settings.concurrency}`);
   console.log(dryRun
     ? "Dry run: no model requests, no file changes, and no folders created."
     : "Only new or changed work blocks need summarizing. Selected, redacted history is sent to Pi's model; provider charges may apply.");
-  const found = await collectSessions({ sessionDirectory: settings.sessionDirectory, timeZone: settings.timeZone, days: range.days });
-  console.log(`\nFound ${found.sessions.length} saved Pi session${found.sessions.length === 1 ? "" : "s"}${found.firstDate ? ` to check for ${found.firstDate} through ${found.lastDate}` : ""}.`);
+  const found = await collectSessions({ sessionDirectory: settings.sessionDirectory, timeZone: settings.timeZone, days: range.days, skipToday });
+  console.log(`\nFound ${found.sessions.length} saved Pi session${found.sessions.length === 1 ? "" : "s"}${found.firstDate ? ` to check for ${found.firstDate} through ${found.lastDate}` : skipToday ? ` to check through ${found.lastDate}` : ""}.`);
   if (found.sessions.length === 0) {
     console.log(`No saved sessions found. History folder: ${settings.sessionDirectory}`);
     console.log(`If you have saved history elsewhere, choose it in '${commandName} init' (advanced settings). Otherwise, start a Pi session first.`);
@@ -188,33 +196,45 @@ async function backfill(args) {
     return;
   }
 
-  const modelClient = createPiModelClient(generationSettings);
-  const result = await writeSessions(modelClient, found.sessions, settings, {
-    ...found,
-    dryRun,
-    onProgress: ({ index, total, sessionId, project, date, time, status, error, phase, sessionPath, dailyPath, prerequisite }) => {
-      if (["checking", "skipped"].includes(phase)) return;
-      console.log(`[${index}/${total}] ${project || sessionId}${date ? ` · ${date} ${time}` : ""}: ${error || status}`);
-      if (dryRun && dailyPath) {
-        console.log(`  Daily note: ${dailyPath}`);
-        console.log(`  Full summary: ${sessionPath}`);
-        if (prerequisite) console.log("  Includes this earlier block to establish the continuation link.");
-      }
-    },
-  });
+  console.log("Results are shown in session order; processing remains parallel.");
+  console.log("One result per work period; resumed sessions may have multiple dated rows.");
+  if (!dryRun) console.log("Summarizing may take a few minutes. Finished results wait to print until earlier sessions finish; other sessions keep processing.");
+  console.log();
+  const progress = createBackfillProgress({ total: found.sessions.length, concurrency: settings.concurrency, dryRun });
+  const interrupt = () => { cleanupProgress(); process.kill(process.pid, "SIGINT"); };
+  const terminate = () => { cleanupProgress(); process.kill(process.pid, "SIGTERM"); };
+  function cleanupProgress() {
+    progress.close();
+    process.removeListener("SIGINT", interrupt);
+    process.removeListener("SIGTERM", terminate);
+  }
+  process.once("SIGINT", interrupt);
+  process.once("SIGTERM", terminate);
+  let result;
+  try {
+    result = await writeSessions(createPiModelClient(generationSettings), found.sessions, settings, {
+      ...found, dryRun, onProgress: progress.onProgress, onSessionComplete: progress.onSessionComplete,
+    });
+  } finally {
+    cleanupProgress();
+  }
   const summaryCount = `${result.summariesCreated} ${result.summariesCreated === 1 ? "summary" : "summaries"}`;
   const entryCount = `${result.entriesAppended} daily ${result.entriesAppended === 1 ? "entry" : "entries"}`;
   const updateCount = `${result.entriesUpdated} ${result.entriesUpdated === 1 ? "entry" : "entries"}`;
+  const checkedBlocks = result.sessionResults.filter((entry) => entry.blockId);
+  const checkedSessions = new Set(checkedBlocks.map((entry) => entry.sessionId)).size;
+  console.log(`\nChecked: ${checkedBlocks.length} work block${checkedBlocks.length === 1 ? "" : "s"} across ${checkedSessions} session${checkedSessions === 1 ? "" : "s"}.`);
   console.log(dryRun
-    ? `\nWould create ${summaryCount}, reuse ${result.summariesReused}, append ${entryCount}; ${result.entriesSkipped} already present; update ${updateCount}.`
-    : `\nSaved: ${summaryCount} created, ${result.summariesReused} reused, appended ${entryCount}; ${result.entriesSkipped} already present; updated ${updateCount}.`);
-  if (result.sessionsSkipped) console.log(`${result.sessionsSkipped} session${result.sessionsSkipped === 1 ? "" : "s"} skipped (outside the date range or without journalable messages).`);
+    ? `Would create ${summaryCount}, reuse ${result.summariesReused}, append ${entryCount}; ${result.entriesSkipped} already present; update ${updateCount}.`
+    : `Saved: ${summaryCount} created, ${result.summariesReused} reused, appended ${entryCount}; ${result.entriesSkipped} already present; updated ${updateCount}.`);
+  if (result.sessionsSkipped) console.log(`${result.sessionsSkipped} session${result.sessionsSkipped === 1 ? "" : "s"} skipped (outside the date range or without journalable messages${skipToday ? ", or active today" : ""}).`);
+  if (skipToday) console.log(`${result.blocksExcludedToday} work period${result.blocksExcludedToday === 1 ? "" : "s"} excluded because of activity today (--skip-today).`);
   if (result.dates.length) {
     console.log(`Daily-note dates: ${result.dates.join(", ")}`);
     if (dryRun && result.summariesCreated) console.log(`${result.summariesCreated} work block${result.summariesCreated === 1 ? "" : "s"} would need summarizing. Large blocks may require multiple model requests each.`);
     if (!result.summariesCreated && !result.errors.length) console.log("These unchanged work blocks need no model requests.");
   } else if (!result.errors.length) {
-    console.log(`Nothing to journal in this range. Try '${commandName} backfill 7 --dry-run' or '${commandName} backfill all --dry-run'.`);
+    console.log(`Nothing to journal in this range. Try '${commandName} backfill 7${skipToday ? " --skip-today" : ""} --dry-run' or '${commandName} backfill all${skipToday ? " --skip-today" : ""} --dry-run'.`);
   }
   const warnings = [...found.warnings, ...result.errors];
   if (warnings.length) {
@@ -222,35 +242,39 @@ async function backfill(args) {
     console.warn(dryRun ? "Preview incomplete. Fix the issues above, then preview again." : "Some sessions could not be saved. Successful summaries are cached. Fix the issues above and rerun the same command to retry.");
     process.exitCode = 1;
   } else if (dryRun && result.dates.length) {
-    console.log(`\nWhen you're ready: ${commandName} backfill ${range.all ? "all" : range.days}${selectedModel ? ` --model ${selectedModel}` : settings.model ? " --model default" : ""}${selectedThinking ? ` --thinking ${selectedThinking}` : settings.thinkingLevel ? " --thinking default" : ""}`);
+    console.log(`\nWhen you're ready: ${commandName} backfill ${range.all ? "all" : range.days}${skipToday ? " --skip-today" : ""}${selectedModel ? ` --model ${selectedModel}` : settings.model ? " --model default" : ""}${selectedThinking ? ` --thinking ${selectedThinking}` : settings.thinkingLevel ? " --thinking default" : ""}`);
   }
 }
 
 function parseStatusArguments(args) {
   let rangeArgument;
   let json = false;
+  let skipToday = false;
   for (const arg of args) {
     if (arg === "--json") {
       json = true;
+    } else if (arg === "--skip-today") {
+      skipToday = true;
     } else if (arg.startsWith("-")) {
       throw new Error(`Unknown status argument: ${arg}. Run '${commandName} status --help'.`);
     } else if (rangeArgument !== undefined) {
-      throw new Error(`Usage: ${commandName} status [number-of-days|all] [--json]`);
+      throw new Error(`Usage: ${commandName} status [number-of-days|all] [--json] [--skip-today]`);
     } else {
       rangeArgument = arg;
     }
   }
-  return { range: parseBackfillArgument(rangeArgument, "status"), json };
+  return { range: parseBackfillArgument(rangeArgument, "status"), json, skipToday };
 }
 
 async function status(args) {
-  const { range, json } = parseStatusArguments(args);
+  const { range, json, skipToday } = parseStatusArguments(args);
   const settings = await loadSettings();
   requireJournalPaths(settings);
   const found = await collectSessions({
     sessionDirectory: settings.sessionDirectory,
     timeZone: settings.timeZone,
     days: range.days,
+    skipToday,
   });
   const previousEntries = await listJournaledSessions(settings.cacheDirectory);
   const inspection = await writeSessions(
@@ -295,6 +319,7 @@ async function status(args) {
       firstDate: found.firstDate || null,
       lastDate: found.lastDate,
       timeZone: settings.timeZone,
+      ...(skipToday ? { skipToday: true } : {}),
     },
     totals: {
       scanned: found.sessions.length,
@@ -305,6 +330,7 @@ async function status(args) {
       needsSummarizing,
       skipped: inspection.sessionsSkipped,
       errors: inspection.errors.length,
+      ...(skipToday ? { excludedToday: inspection.blocksExcludedToday } : {}),
     },
     sessions,
     warnings,
@@ -313,8 +339,9 @@ async function status(args) {
   if (json) {
     console.log(JSON.stringify(report, null, 2));
   } else {
-    const label = range.all ? "all saved sessions" : `last ${range.days} calendar day${range.days === 1 ? "" : "s"}`;
-    console.log(`LogDig status: activity in ${label} (${settings.timeZone})${found.firstDate ? ` · ${found.firstDate} through ${found.lastDate}` : ""}`);
+    const label = range.all ? "all saved sessions" : `last ${range.days}${skipToday ? " complete" : ""} calendar day${range.days === 1 ? "" : "s"}`;
+    console.log(`LogDig status: activity in ${label} (${settings.timeZone})${found.firstDate ? ` · ${found.firstDate} through ${found.lastDate}` : skipToday ? ` · through ${found.lastDate}` : ""}${skipToday ? " · skipping today" : ""}`);
+    if (skipToday) console.log(`${inspection.blocksExcludedToday} work period${inspection.blocksExcludedToday === 1 ? "" : "s"} excluded because of activity today (--skip-today).`);
     console.log(`${report.totals.eligible} work block${report.totals.eligible === 1 ? "" : "s"}: ${report.totals.logged} logged, ${stale} stale, ${newCount} new.`);
     console.log(`Summaries: ${report.totals.eligible - needsSummarizing} reusable, ${needsSummarizing} work block${needsSummarizing === 1 ? " needs" : "s need"} summarizing.`);
     const prerequisites = sessions.filter((session) => session.prerequisite).length;
@@ -334,7 +361,7 @@ async function status(args) {
       console.log("Everything in this timeframe is current.");
     }
     if (newCount || stale || needsSummarizing) {
-      console.log(`\nTo update the journal: ${commandName} backfill ${range.all ? "all" : range.days}`);
+      console.log(`\nTo update the journal: ${commandName} backfill ${range.all ? "all" : range.days}${skipToday ? " --skip-today" : ""}`);
     }
   }
 
@@ -356,16 +383,20 @@ function helpText() {
     "Commands (install with 'npm install -g logdig', or use 'npm link' in a checkout):",
     "  logdig init                         guided setup; nothing is summarized",
     "  logdig doctor                       check paths and Pi without a model request",
-    "  logdig config                       show settings and active environment overrides",
-    "  logdig backfill [N|all] [--dry-run] [--model provider/model|default]",
+    "  logdig config                       edit numbered settings; q quits (redirected: read-only)",
+    "  logdig backfill [N|all] [--dry-run] [--skip-today]",
+    "                                      [--model provider/model|default]",
     "                                      [--thinking default|off|minimal|low|medium|high|xhigh|max]",
     "                                      journal saved sessions (default: last 3 days)",
-    "  logdig status [N|all] [--json]       show journal coverage (default: last 3 days; read-only)",
+    "  logdig status [N|all] [--json] [--skip-today]",
+    "                                      show journal coverage (default: last 3 days; read-only)",
     "  logdig pi-install | pi-uninstall     add or remove /journal integration",
     "  logdig --version                    show the installed version",
     "",
     "Preview first: --dry-run shows dates, files, and cache hits. It never calls Pi",
     "or writes files. Remove --dry-run when you're ready to summarize.",
+    "--skip-today selects N complete calendar days ending yesterday, or all past work.",
+    "Work periods with activity today are excluded entirely, including overnight work.",
     "",
     "Real backfill uses Pi's startup model and existing authentication. Tools,",
     "extensions, project context, and session saving are disabled for model requests.",
@@ -428,5 +459,5 @@ async function main() {
 
 main().catch((error) => {
   console.error(`logdig: ${error.message}`);
-  process.exitCode = error.code === "LOGDIG_SETUP_CANCELLED" ? 130 : 1;
+  process.exitCode = ["LOGDIG_SETUP_CANCELLED", "LOGDIG_CONFIG_CANCELLED"].includes(error.code) ? 130 : 1;
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "logdig",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "Turn saved Pi sessions into a work journal in your Obsidian daily notes.",
   "license": "MIT",
   "author": "Soleone",

package/src/backfill-progress.js

@@ -0,0 +1,136 @@
+import { stripVTControlCharacters } from "node:util";
+import { progressStatus } from "./cli-status.js";
+
+function cleanText(value) {
+  return stripVTControlCharacters(String(value ?? "")).replace(/[\x00-\x1f\x7f-\x9f]/g, " ");
+}
+
+function fitLiveLine(line, columns) {
+  const limit = Math.max(0, columns - 1);
+  let width = 0;
+  let fitted = "";
+  for (const token of line.match(/\x1b\[[0-9;]*m|./gu) || []) {
+    if (token.startsWith("\x1b[")) {
+      fitted += token;
+      continue;
+    }
+    // Conservatively allow two cells for non-ASCII text so panel rows never wrap.
+    const cells = token.codePointAt(0) > 127 ? 2 : 1;
+    if (width + cells > limit) break;
+    width += cells;
+    fitted += token;
+  }
+  return fitted + (line.includes("\x1b[") ? "\x1b[0m" : "");
+}
+
+export function createBackfillProgress({ total, concurrency, dryRun = false, stream = process.stdout, term = process.env.TERM, icons, noColor }) {
+  const live = stream.isTTY && term !== "dumb" && !dryRun;
+  const statusOptions = { isTTY: stream.isTTY, term, icons, noColor, pad: true };
+  const sessions = Array.from({ length: total }, () => ({ lines: [], complete: false, failed: false }));
+  let nextResult = 0;
+  let completed = 0;
+  let panelRows = 0;
+  let refreshTimer;
+  let closed = false;
+
+  function clearPanel() {
+    if (!panelRows) return;
+    stream.write("\r" + "\x1b[1A\x1b[2K\r".repeat(panelRows));
+    panelRows = 0;
+  }
+
+  function sessionLabel(event, status = event.status, elapsed = "") {
+    const position = `${String(event.index).padStart(String(total).length, "0")}/${total}`;
+    const timestamp = `${cleanText(event.date)}${event.time ? ` ${cleanText(event.time)}` : ""}`.padEnd(16);
+    return `[${position}] ${timestamp} · ${progressStatus(status, statusOptions)} · ${elapsed ? `${elapsed} · ` : ""}${cleanText(event.project) || "session"} (${cleanText(event.sessionId).slice(-8)})`;
+  }
+
+  function renderPanel() {
+    if (!live || closed) return;
+    clearPanel();
+    const pending = sessions.slice(nextResult).filter((session) => session.event);
+    const waiting = pending.filter((session) => session.complete);
+    const active = pending.filter((session) => !session.complete);
+    if (active.length && !refreshTimer) {
+      refreshTimer = setInterval(renderPanel, 1000);
+      refreshTimer.unref();
+    } else if (!active.length && refreshTimer) {
+      clearInterval(refreshTimer);
+      refreshTimer = undefined;
+    }
+    if (!pending.length) return;
+    const queued = total - completed - active.length;
+    const overhead = 1 + Number(active.length > 0) + Number(waiting.length > 0);
+    const capacity = Math.max(0, Math.min(concurrency, (stream.rows || 24) - 2 - overhead));
+    const lines = [`Progress: ${completed}/${total} complete · ${active.length} active · ${queued} queued`];
+    if (active.length) {
+      const hidden = Math.max(0, active.length - capacity);
+      lines.push(`Active sessions (stage elapsed${hidden ? `; ${hidden} not shown` : ""}):`);
+      for (const session of active.slice(0, capacity)) {
+        const seconds = Math.max(0, Math.floor((Date.now() - session.stageStartedAt) / 1000));
+        const elapsed = seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+        lines.push(sessionLabel(session.event, session.event.status, elapsed));
+      }
+    }
+    if (waiting.length) {
+      const blocker = String(nextResult + 1).padStart(String(total).length, "0");
+      const failed = waiting.filter((session) => session.failed).length;
+      lines.push(`${waiting.length} finished session${waiting.length === 1 ? "" : "s"} waiting to print after #${blocker}.${failed ? ` ${failed} with errors.` : ""}`);
+    }
+    stream.write(lines.map((line) => fitLiveLine(line, stream.columns || 80)).join("\n") + "\n");
+    panelRows = lines.length;
+  }
+
+  function onProgress(event) {
+    if (closed) return;
+    const session = sessions[event.index - 1];
+    const previous = session.event;
+    if (!previous || previous.phase !== event.phase || previous.blockId !== event.blockId || previous.date !== event.date || previous.time !== event.time) {
+      session.stageStartedAt = Date.now();
+    }
+    session.event = event;
+    if (event.phase === "error") session.failed = true;
+    if (["complete", "skipped", "error"].includes(event.phase)) {
+      const detail = event.error || event.reason;
+      session.lines.push(`${sessionLabel(event)}${event.prerequisite ? " · prerequisite" : ""}${detail ? `: ${cleanText(detail)}` : ""}`);
+      if (dryRun && event.dailyPath) {
+        session.lines.push(`  Daily note: ${cleanText(event.dailyPath)}`, `  Full summary: ${cleanText(event.sessionPath)}`);
+        if (event.prerequisite) session.lines.push("  Includes this earlier block to establish the continuation link.");
+      }
+    } else if (!live && event.phase === "summarizing") {
+      stream.write(`Active ${sessionLabel(event)}\n`);
+    }
+    renderPanel();
+  }
+
+  function onSessionComplete({ index }) {
+    if (closed) return;
+    const session = sessions[index - 1];
+    session.complete = true;
+    completed++;
+    clearPanel();
+    if (!live && !dryRun && index - 1 > nextResult) {
+      const blocker = String(nextResult + 1).padStart(String(total).length, "0");
+      stream.write(`Finished ${sessionLabel(session.event, session.failed ? "FAILED" : "DONE")} (waiting to print after #${blocker}; processing continues)\n`);
+    }
+    while (sessions[nextResult]?.complete) {
+      const { lines } = sessions[nextResult];
+      if (lines.length) stream.write(lines.join("\n") + "\n");
+      lines.length = 0;
+      nextResult++;
+    }
+    renderPanel();
+  }
+
+  function close() {
+    if (closed) return;
+    clearPanel();
+    closed = true;
+    clearInterval(refreshTimer);
+    refreshTimer = undefined;
+    if (live) stream.removeListener("resize", renderPanel);
+  }
+
+  if (live) stream.on("resize", renderPanel);
+  return { onProgress, onSessionComplete, close };
+}

package/src/cli-status.js

@@ -7,6 +7,20 @@ const statuses = {
   error: { text: "FIX", icon: "\uf00d", color: "31" },
 };
 
+const progressStatuses = {
+  CHECKING: { icon: "\uf002", color: "36" },
+  SUMMARIZING: { icon: "\uf110", color: "36" },
+  SAVED: { icon: "\uf00c", color: "32" },
+  UPDATED: { icon: "\uf040", color: "36" },
+  CURRENT: { icon: "\uf058", color: "32" },
+  DONE: { icon: "\uf00c", color: "32" },
+  SKIPPED: { icon: "\uf05e", color: "33" },
+  FAILED: { icon: "\uf00d", color: "31" },
+  PREVIEW: { icon: "\uf06e", color: "36" },
+};
+
+const PROGRESS_STATUS_WIDTH = Math.max(...Object.keys(progressStatuses).map((status) => status.length));
+
 export { STATUS_WIDTH };
 
 function useIcons({
@@ -33,3 +47,14 @@ export function statusPrefix(status, options = {}) {
   const icon = noColor ? marker.icon : `\u001b[${marker.color}m${marker.icon}\u001b[0m`;
   return `${icon} `;
 }
+
+export function progressStatus(status, options = {}) {
+  const marker = progressStatuses[status];
+  if (!marker) throw new TypeError(`Unknown progress status: ${status}`);
+  const text = options.pad ? status.padEnd(PROGRESS_STATUS_WIDTH) : status;
+  if (!useIcons(options)) return text;
+
+  const noColor = options.noColor ?? process.env.NO_COLOR !== undefined;
+  const icon = noColor ? marker.icon : `\u001b[${marker.color}m${marker.icon}\u001b[0m`;
+  return `${icon} ${text}`;
+}

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

@@ -3,6 +3,7 @@ import path from "node:path";
 import { JOURNAL_SYSTEM_PROMPT, summaryCachePolicy } from "./journal.js";
 import { collectSessions, parseBackfillArgument, writeSessions } from "./session-runner.js";
 import { loadSettings } from "./settings.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");
@@ -68,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);
   };
 }
 

package/src/journal.js

@@ -391,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}`;
 }
@@ -503,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)};`);
@@ -568,8 +568,24 @@ function appendUnderProject(markdown, heading, entry) {
 
   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}`);
@@ -668,7 +684,7 @@ 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))
@@ -686,12 +702,12 @@ 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`);
@@ -701,6 +717,6 @@ export async function appendDailyEntry(dailyDirectory, heading, entry, journaled
   }
 
   await updateEntrySnapshot(entryPath, entry, true);
-  await updateSessionDailyNotes(heading, entry, inspection);
+  await updateSessionDailyNotes(heading, entry, inspection, anchorHeading);
   return { dailyPath, entryPath, appended, updated: updated || inspection.sessionBlocks.length > 0, legacyEntry: inspection.legacyEntry };
 }

package/src/session-runner.js

@@ -2,6 +2,7 @@ import { readFile, readdir, stat } from "node:fs/promises";
 import path from "node:path";
 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) {
@@ -66,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();
 
@@ -93,7 +96,7 @@ 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) {
@@ -128,13 +131,22 @@ 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 {
@@ -142,37 +154,49 @@ export async function writeSessions(modelClient, sessions, settings, range = {})
     } 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;
+      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 = blocks.length ? "outside date range" : "no journalable events";
+      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, phase: "skipped", status: reason });
-      continue;
+      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, project: block.project, date: block.date, time: block.time };
+      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 = !blockInRange(block, range);
-        range.onProgress?.({ ...blockProgress, phase: "checking", status: "checking saved summary" });
+        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 with Pi; large sessions may take a few minutes" }),
+            onGenerate: () => range.onProgress?.({ ...blockProgress, phase: "summarizing", status: "SUMMARIZING" }),
           });
         if (cached.reused) summariesReused++;
         else summariesCreated++;
@@ -194,7 +218,7 @@ export async function writeSessions(modelClient, sessions, settings, range = {})
         };
         const dailyEntry = range.dryRun
           ? await inspectDailyEntry(settings.dailyDirectory, settings.dailyHeader, entry, journaledEntries)
-          : await appendDailyEntry(settings.dailyDirectory, settings.dailyHeader, entry, journaledEntries);
+          : await writeDailyEntry(entry);
         if (dailyEntry.updated) entriesUpdated++;
         else if (dailyEntry.appended) entriesAppended++;
         else entriesSkipped++;
@@ -230,19 +254,32 @@ export async function writeSessions(modelClient, sessions, settings, range = {})
           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)" : ""),
+          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", 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,10 +3,13 @@ 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"],
@@ -40,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,
   };
 }
 
@@ -64,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 });
@@ -94,6 +107,14 @@ export function validateSettings(settings, { requirePaths = false, home = homedi
     }
     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");
   }
@@ -111,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 = {}) {
@@ -133,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 };
 }
@@ -147,10 +176,12 @@ 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 } : {}),

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));
@@ -77,8 +80,9 @@ export async function configureLogDig(settings, commandName = "logdig") {
     console.log(`History: ${settings.sessionDirectory}`);
     console.log(`Model: ${settings.model || "Pi's default (your active model for /journal)"}`);
     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;
+    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));
@@ -88,6 +92,8 @@ export async function configureLogDig(settings, commandName = "logdig") {
       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.");
@@ -95,18 +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, thinkingLevel, 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,3 +1,4 @@
+import { readFileSync, statSync } from "node:fs";
 import path from "node:path";
 
 const READ_TOOLS = new Set([
@@ -248,11 +249,80 @@ function eventFor(entry, formatter, toolCalls) {
   return undefined;
 }
 
+const PROJECT_NAME_CACHE = new Map();
+
+function cleanProjectName(name) {
+  return name.replace(/^\d{4}-\d{2}-\d{2}-(?=.)/, "");
+}
+
+function commonGitDirectory(gitDir) {
+  try {
+    const commonDir = readFileSync(path.join(gitDir, "commondir"), "utf8").trim();
+    return commonDir ? path.resolve(gitDir, commonDir) : undefined;
+  } catch {
+    const segments = gitDir.split(path.sep);
+    const worktreesIndex = segments.lastIndexOf("worktrees");
+    return worktreesIndex >= 0 ? segments.slice(0, worktreesIndex).join(path.sep) : undefined;
+  }
+}
+
+function projectNameFromGitMarker(directory) {
+  try {
+    const gitMarker = path.join(directory, ".git");
+    const markerStat = statSync(gitMarker);
+    if (markerStat.isDirectory()) return cleanProjectName(path.basename(directory)) || undefined;
+    if (!markerStat.isFile()) return undefined;
+
+    const gitDirMatch = readFileSync(gitMarker, "utf8").match(/^gitdir:\s*(.+?)\s*$/m);
+    if (!gitDirMatch) return undefined;
+    const commonDir = commonGitDirectory(path.resolve(directory, gitDirMatch[1]));
+    return commonDir ? cleanProjectName(path.basename(path.dirname(commonDir))) || undefined : undefined;
+  } catch {
+    // Project names are best-effort when historical checkout metadata is missing.
+    return undefined;
+  }
+}
+
+function projectNameFromCwd(cwd) {
+  if (!cwd) return "unknown project";
+  const resolved = path.resolve(cwd);
+  if (PROJECT_NAME_CACHE.has(resolved)) return PROJECT_NAME_CACHE.get(resolved);
+
+  let directory = resolved;
+  while (true) {
+    const project = projectNameFromGitMarker(directory);
+    if (project) {
+      PROJECT_NAME_CACHE.set(resolved, project);
+      return project;
+    }
+
+    const parent = path.dirname(directory);
+    if (parent === directory) break;
+    directory = parent;
+  }
+
+  // Keep historical sessions grouped when a worktree's checkout has been removed.
+  const segments = resolved.split(path.sep);
+  const worktreesIndex = segments.lastIndexOf("worktrees");
+  const dotWorktreesIndex = segments.lastIndexOf(".worktrees");
+  let fallback = path.basename(resolved);
+  if (worktreesIndex >= 0) {
+    fallback = segments.length > worktreesIndex + 2
+      ? segments[worktreesIndex + 1]
+      : segments[worktreesIndex - 1] || fallback;
+  } else if (dotWorktreesIndex > 0) {
+    fallback = segments[dotWorktreesIndex - 1];
+  }
+  const name = cleanProjectName(fallback) || "unknown project";
+  PROJECT_NAME_CACHE.set(resolved, name);
+  return name;
+}
+
 export function eventsForSession(session, timeZone, extraction = { formatter: localTimeFormatter(timeZone), toolCalls: new Map() }) {
   const events = [];
   const { formatter, toolCalls } = extraction;
   const cwd = session.header.cwd || "";
-  const project = (cwd ? path.basename(cwd) : "").replace(/^\d{4}-\d{2}-\d{2}-(?=.)/, "") || "unknown project";
+  const project = projectNameFromCwd(cwd);
 
   for (const entry of session.entries) {
     const generated = eventFor(entry, formatter, toolCalls);

package/src/work-blocks.js

@@ -79,6 +79,8 @@ export function workBlocksForSession(session, timeZone) {
 }
 
 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);
 }