logdig 0.2.0 → 0.2.2

package/README.md

@@ -68,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:
 
@@ -232,7 +232,7 @@ The menu uses Node's built-in line prompts with no runtime dependencies. Save co
 
 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 shows active workers (`CHECKING` or `SUMMARIZING`), the completed-session count, and sessions that are `DONE` but awaiting ordered output. The panel redraws in place and clears when the run finishes. A slow earlier session can delay display of later result rows, but does not block processing or live feedback. 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.
+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.
 

package/bin/logdig.js

@@ -198,7 +198,7 @@ async function backfill(args) {
 
   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 new or changed work may take a few minutes; a slow session can delay later 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"); };

package/package.json

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

package/src/backfill-progress.js

@@ -30,6 +30,7 @@ export function createBackfillProgress({ total, concurrency, dryRun = false, str
   let nextResult = 0;
   let completed = 0;
   let panelRows = 0;
+  let refreshTimer;
   let closed = false;
 
   function clearPanel() {
@@ -38,24 +39,44 @@ export function createBackfillProgress({ total, concurrency, dryRun = false, str
     panelRows = 0;
   }
 
-  function sessionLabel(event, status = event.status) {
+  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)} · ${cleanText(event.project) || "session"} (${cleanText(event.sessionId).slice(-8)})`;
+    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);
-    if (!pending.length) return;
     const waiting = pending.filter((session) => session.complete);
     const active = pending.filter((session) => !session.complete);
-    const capacity = Math.max(0, Math.min(concurrency, (stream.rows || 24) - 3));
-    const lines = [
-      `Completed: ${completed}/${total} sessions${waiting.length ? ` · ${waiting.length} awaiting ordered output` : ""}`,
-      ...[...active, ...waiting].slice(0, capacity).map((session) => sessionLabel(session.event, session.complete ? session.failed ? "FAILED" : "DONE" : session.event.status)),
-    ];
+    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;
   }
@@ -63,6 +84,10 @@ export function createBackfillProgress({ total, concurrency, dryRun = false, str
   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)) {
@@ -85,7 +110,8 @@ export function createBackfillProgress({ total, concurrency, dryRun = false, str
     completed++;
     clearPanel();
     if (!live && !dryRun && index - 1 > nextResult) {
-      stream.write(`Finished ${sessionLabel(session.event, session.failed ? "FAILED" : "DONE")} (waiting for earlier results)\n`);
+      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];
@@ -100,6 +126,8 @@ export function createBackfillProgress({ total, concurrency, dryRun = false, str
     if (closed) return;
     clearPanel();
     closed = true;
+    clearInterval(refreshTimer);
+    refreshTimer = undefined;
     if (live) stream.removeListener("resize", renderPanel);
   }
 

package/src/journal.js

@@ -212,6 +212,7 @@ export async function listJournaledSessions(cacheDirectory) {
       time: metadata.time,
       sourceFingerprint: metadata.sourceFingerprint,
       cacheFingerprint: metadata.cacheFingerprint,
+      project: metadata.project,
       blockId: metadata.blockId,
       blockStart: metadata.blockStart,
       continuationOf: metadata.continuationOf,
@@ -336,6 +337,18 @@ function updateContinuationReference(markdown, continuationOf) {
   return header + (continuationOf ? `\nContinues [[${continuationOf}|previous entry]].\n` : "") + body;
 }
 
+function sourceFingerprintForProject(session, project) {
+  const events = [...(session.context || []), ...(session.events || [])];
+  if (events.some((event) => event.project !== session.project)) return undefined;
+  const relabel = (items) => items.map((event) => ({ ...event, project }));
+  return hashValue([
+    project,
+    session.timezone,
+    relabel(session.context || []),
+    relabel(session.events || []),
+  ]);
+}
+
 export async function inspectSessionSummary(modelClient, cacheDirectory, session) {
   const sourceFingerprint = hashValue([session.project, session.timezone, session.context || [], session.events]);
   // Keep generation policy separate from evidence so model and thinking changes can
@@ -348,7 +361,20 @@ export async function inspectSessionSummary(modelClient, cacheDirectory, session
   const existing = cached && parseSessionNote(cached);
 
   const reused = existing?.cacheFingerprint === cacheFingerprint;
-  return { sessionPath, sourceFingerprint, cacheFingerprint, reused, continuationOf: existing?.continuationOf, summary: reused ? existing.summary : undefined };
+  const previousSourceFingerprint = existing?.project && existing.project !== session.project
+    ? sourceFingerprintForProject(session, existing.project)
+    : undefined;
+  const relabeledReuse = !reused && previousSourceFingerprint === existing?.sourceFingerprint &&
+    existing?.cacheFingerprint === hashValue([SUMMARY_VERSION, JOURNAL_SYSTEM_PROMPT, CHUNK_LIMIT, previousSourceFingerprint, policy]);
+  const reusable = reused || relabeledReuse;
+  return {
+    sessionPath,
+    sourceFingerprint: reusable ? existing.sourceFingerprint : sourceFingerprint,
+    cacheFingerprint: reusable ? existing.cacheFingerprint : cacheFingerprint,
+    reused: reusable,
+    continuationOf: existing?.continuationOf,
+    summary: reusable ? existing.summary : undefined,
+  };
 }
 
 export async function saveSessionSummary(modelClient, cacheDirectory, session, { onGenerate } = {}) {
@@ -661,7 +687,10 @@ export async function inspectDailyEntry(dailyDirectory, heading, entry, journale
   const oldBlocks = locations.blocks.filter((block) => block.id !== id);
   const sameIdBlocks = locations.blocks.filter((block) => block.id === id);
   const missingSnapshot = entry.blockId && present && !snapshots.get(entry.sessionId)?.some((version) => version.id === id);
-  const updated = Boolean(missingSnapshot) || oldBlocks.length > 0 || sameIdBlocks.length > 1 || (!present && sameIdBlocks.length > 0);
+  const projectChanged = locations.blocks.some((block) =>
+    block.snapshot?.project && entry.project && block.snapshot.project !== entry.project,
+  );
+  const updated = Boolean(missingSnapshot) || oldBlocks.length > 0 || sameIdBlocks.length > 1 || (!present && sameIdBlocks.length > 0) || projectChanged;
   return {
     dailyPath,
     existing,
@@ -673,14 +702,19 @@ export async function inspectDailyEntry(dailyDirectory, heading, entry, journale
   };
 }
 
+function updateSnapshotProject(markdown, project) {
+  if (!project || frontmatter(markdown).project === project) return markdown;
+  return markdown.replace(/^project: .*$/m, `project: ${frontmatterValue(project)}`);
+}
+
 async function updateEntrySnapshot(entryPath, entry, createIfMissing) {
   const snapshot = await readMarkdownIfPresent(entryPath);
   if (!snapshot) {
     if (createIfMissing) await writeAtomically(entryPath, await readFile(entry.sessionPath, "utf8"));
     return;
   }
-  if (!entry.metrics) return;
-  const enriched = enrichSessionNote(snapshot, entry.sourceFingerprint, entry.metrics);
+  const withProject = updateSnapshotProject(snapshot, entry.project);
+  const enriched = entry.metrics ? enrichSessionNote(withProject, entry.sourceFingerprint, entry.metrics) : withProject;
   if (enriched !== snapshot) await writeAtomically(entryPath, enriched);
 }
 

package/src/session-runner.js

@@ -243,8 +243,11 @@ export async function writeSessions(modelClient, sessions, settings, range = {})
           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 });
+        if (!range.dryRun) {
+          const versionIndex = versions.findIndex((version) => version.id === entryId);
+          const updatedVersion = { ...entry, id: entryId, summary: cached.summary };
+          if (versionIndex === -1) versions.push(updatedVersion);
+          else versions[versionIndex] = updatedVersion;
         }
         dates.add(block.date);
         dailyPaths.add(dailyEntry.dailyPath);

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);