logdig 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Soleone
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/QUICKSTART.md

@@ -0,0 +1,83 @@
+# LogDig quickstart
+
+A small work journal in your existing Obsidian daily notes. Start manually, with one day, and keep automatic capture off until the results feel useful.
+
+## 1. Install and configure
+
+With Node.js 22.19+ and Pi installed (once the first npm release is published):
+
+```sh
+npm install -g logdig
+logdig init
+```
+
+Before the first release, run `npm link` from this project folder instead. No build step is needed. To work directly from the checkout without installing, replace `logdig` below with `node ./bin/logdig.js`.
+
+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.
+- **Timezone:** check that this is the timezone you journal in.
+- **Advanced settings:** leave them alone unless you use a custom Pi history folder, executable, or model.
+- **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.
+
+## 2. Check and preview
+
+```sh
+logdig doctor
+logdig backfill 1 --dry-run
+```
+
+The preview shows projects, dates, destination files, cache hits, and which sessions need summarizing. **No model requests, file changes, or new folders.** It does not display transcript excerpts.
+
+`1` means today in your chosen timezone. If nothing happened today:
+
+```sh
+logdig backfill 7 --dry-run
+```
+
+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
+
+Once the preview looks right, run the same range without `--dry-run`:
+
+```sh
+logdig backfill 1
+```
+
+This may send selected, redacted history to your Pi model and incur provider charges. Pi uses its existing authentication. If authentication fails, open Pi, run `/login`, then retry. Common secrets are redacted, but redaction is not a complete secret scanner.
+
+Open the daily-note date printed by the command. You will find project subheadings under `# Projects`, with timestamped summaries grouped beneath each one. Your existing text stays in place. Click a timestamp to open that entry's saved snapshot of all three summary lengths, or browse `<cache folder>/Sessions/<session-id>.md` for the latest session summary.
+
+Repeating an unchanged session reuses its summary and does not insert that entry again. Updated sessions or changed summary settings can append a new version. Run only one save at a time against your journal, and let vault sync finish first.
+
+## Optional: use `/journal` inside Pi
+
+```sh
+logdig pi-install
+```
+
+Restart Pi or run `/reload`. Then, inside Pi:
+
+```text
+/journal backfill 1 --dry-run
+/journal
+```
+
+The first command previews today. The second journals the current session using your active Pi model, unless you configured an override. Automatic capture remains off unless you enable it.
+
+## Updating
+
+After a new npm release:
+
+```sh
+npm install -g logdig@latest
+logdig --version
+```
+
+For more commands, privacy details, and troubleshooting, see [README.md](README.md).

package/README.md

@@ -0,0 +1,208 @@
+# LogDig
+
+Remember what you worked on, without writing another status report.
+
+LogDig turns saved [Pi](https://pi.dev) sessions into short entries in your Obsidian daily notes. Your handwritten content stays in place. Each session also gets a cached Markdown note with **Small**, **Medium**, and **Large** summaries, so the details are there when you want them.
+
+No build step, runtime dependencies, or separate model credentials. Try a safe preview before sending any history to a model.
+
+## Start small
+
+You need **Node.js 22.19+**, Pi installed and signed in, and a daily-notes folder using `YYYY-MM-DD.md` filenames. Custom daily-note filename formats are not supported yet.
+
+Install globally to make `logdig` available on your PATH (once the first npm release is published):
+
+```sh
+npm install -g logdig
+logdig init
+logdig doctor
+logdig backfill 1 --dry-run
+```
+
+Working from a checkout before the first release? Run `npm link` once, then use the same commands. No build step is needed. You can also run `node ./bin/logdig.js ...` without installing anything.
+
+For a one-off run without a global install, use `npx logdig --help`.
+
+Setup explains the choices, keeps defaults on Enter, and re-asks only the question you mistyped. It shows a review before saving. Declining that review or pressing Ctrl+C leaves your settings unchanged. Setup does not summarize sessions or write daily notes.
+
+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.
+- 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.
+
+`doctor` checks folder access and Pi availability without requesting a summary. It reports broken paths and a missing Pi executable together, with a next step for each.
+
+**`--dry-run` never calls Pi, writes files, or creates folders.** It shows the projects, dates, destination files, matching cached summaries, and sessions that would need model requests. The preview does not print transcript excerpts.
+
+When the preview looks right:
+
+```sh
+logdig backfill 1
+```
+
+This journals sessions whose last user message was **today in your configured timezone**, not a rolling 24-hour window. If today is quiet, preview seven days instead:
+
+```sh
+logdig backfill 7 --dry-run
+```
+
+See [QUICKSTART.md](QUICKSTART.md) for the short, copyable walkthrough.
+
+## What you get
+
+With `My Vault/Daily` and `My Vault/LogDig` selected:
+
+```text
+My Vault/
+├── Daily/
+│   └── YYYY-MM-DD.md             your writing, plus project-grouped summaries under # Projects
+└── LogDig/
+    ├── Sessions/
+    │   └── <session-id>.md       latest cached summary and provenance
+    └── Entries/
+        └── <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.
+
+For example:
+
+```markdown
+# Projects
+
+## my-project
+
+**[[<entry-id>|20:54]]**
+
+A short summary.
+
+**[[<another-entry-id>|21:19]]**
+
+More work on the same project.
+
+## another-project
+
+**[[<single-entry-id>|23:13]]**: One entry stays compact.
+```
+
+A project with one entry puts the timestamp inline at the start of its summary. When a second entry arrives, both timestamps move to separate lines. Summary wording is preserved, including any edits you made.
+
+Obsidian displays each link as just the timestamp; clicking it opens that entry's detailed summary. The detailed note has two compact frontmatter properties when available: `sessionUsage` for recorded Pi-session usage and `logUsage` for LogDig's summary-generation requests, including intermediate chunks. Each shows cost, cached input, uncached input, output, and elapsed time, for example `"$3.73 ⚡12.2M ↑747k ↓62k · 1h 55m"`. Session duration is wall-clock time, including idle periods; LogDig duration is the time spent generating that summary. The original session and LogDig calls are counted separately. Historical summaries made before usage tracking have no `logUsage`; their cost cannot be recovered without making new requests. Unknown cost or token counts are omitted, not shown as zero. Keep the summary cache inside your vault so Obsidian can resolve these links. Daily summaries do not create headings or code fences; structured detail stays in the linked note. Custom section headings are supported, with project subheadings one level deeper (or bold project labels beneath a level-six heading).
+
+The **last user message** supplies the date and time, even if the assistant finishes after midnight. Alternate session branches are included as explorations, not assumed to be the final result.
+
+Unchanged sessions reuse their summaries. The identifier in each timestamp link prevents duplicate entries, without HTML comments. Older project-name links and comment-wrapped entries are still recognized. Changing the default does not override existing saved heading preferences; rerun setup to change them. Changing the session, timezone, explicit model, summary level, or heading can append a **new version** rather than replace an earlier journal entry. Linked entry notes keep their original summary even when the latest session cache changes. Handwritten content and summary wording are preserved; an inline timestamp can be expanded when its project gains another entry. Headings inside frontmatter or fenced code are not insertion targets.
+
+Missing daily-note and cache folders are created only by a real save. Raw Pi history stays in Pi's storage.
+
+## Commands
+
+After a global install or `npm link`, use `logdig` from any directory. All commands also work as `node ./bin/logdig.js ...` from the checkout.
+
+```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 --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 --model provider/model
+logdig backfill 7 --model default    ignore a saved model override for this run
+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` and `logdig backfill --help`.
+
+New summaries may incur provider charges. Large sessions are summarized in chunks and may need several model requests each. Backfill shows which project it is working on before the model completes. Failed sessions are reported, other sessions continue, and the command exits nonzero if anything needs attention. Fix the issue and rerun the same command; completed summaries are reused, even if a previous attempt failed to write a daily note.
+
+Run one backfill at a time against a given journal. The extension prevents overlapping saves within one Pi process, but separate CLI/Pi processes and external note editors are not coordinated. Let an existing save or vault sync finish first.
+
+## Inside Pi
+
+Install the extension if you did not choose it during setup:
+
+```sh
+logdig pi-install
+```
+
+Restart Pi or run `/reload`. Then, **inside Pi**:
+
+```text
+/journal                           journal the current session
+/journal backfill 1 --dry-run       preview today, including the active session
+/journal backfill                   journal the last 3 calendar days
+/journal backfill 7                 journal seven days
+/journal backfill all               journal every discoverable session
+/journal help                      show available commands
+```
+
+The extension shows progress in Pi's status area, clears it when the operation ends, and tells you where the note and full summaries live. An empty session gets a next step rather than a false “saved” message.
+
+Automatic capture is opt-in through `logdig init` or `PI_JOURNAL_AUTO=1`. It catches up recent sessions when Pi shuts down and can delay shutdown while summaries are generated. Capture failures are reported with recovery instructions.
+
+## Models and privacy
+
+CLI backfill uses Pi's normal startup model and existing authentication unless you configure a `provider/model` override. It runs headless requests with **tools, extensions, skills, prompt templates, project context files, and session saving disabled**. Providers supplied only by extensions are therefore not available to CLI backfill.
+
+`/journal` uses the current Pi model, including registered providers, unless a LogDig override is set. The preview needs no available model or authentication. `doctor` checks the executable but does not validate model authentication; open Pi and run `/login` if a real save reports an authentication problem.
+
+Selected user prompts, assistant conclusions, tool actions, test results, and error excerpts are sent to the chosen model after common credential redaction. System prompts, hidden reasoning, and image payloads are excluded. **Redaction is not a comprehensive secret scanner.** Review your provider's data handling before processing sensitive sessions or enabling automatic capture. Summaries can also contain private project details, so treat your cache and vault accordingly.
+
+Model summaries are aids to memory, not proof of completed work. Keep Pi history as the source of truth.
+
+## Settings and troubleshooting
+
+Settings contain paths and preferences, never provider credentials:
+
+- Linux: `$XDG_CONFIG_HOME/logdig/settings.json`, or `~/.config/logdig/settings.json`
+- macOS: `~/Library/Application Support/LogDig/settings.json`
+- Windows: `%APPDATA%\LogDig\settings.json`
+
+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.
+- **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`.
+
+## Development
+
+```sh
+npm ci
+npm test
+npm link
+```
+
+Tests use temporary directories and local fake model responses, including CLI subprocess tests and a packed, globally installed CLI smoke test. They do not use your Pi credentials, call a provider, or write to your actual vault. The package test installs only into a temporary prefix, not your real global npm directory.
+
+`release-it` is a development dependency only. Version 20 supports the same Node.js minimum as LogDig. The `undici` override keeps its pinned HTTP dependency on a patched 7.x version until release-it updates that dependency. Published installations have no runtime dependencies.
+
+## Releases
+
+Releases are interactive and run from a clean, committed `main` checkout with its upstream configured. You need npm publishing access and permission to push to `origin`. No GitHub API token is needed; this workflow creates Git tags, not GitHub release pages.
+
+The starting version is `0.0.0`, so the first minor release becomes `0.1.0`:
+
+```sh
+npm ci
+npm login
+npm run release:dry-run -- minor
+npm run release -- minor
+```
+
+The dry run runs tests and checks npm/Git access, but does not bump versions, commit, tag, push, or publish. The real command runs tests, updates `package.json` and `package-lock.json`, publishes to npm, creates a release commit and `vX.Y.Z` tag, and pushes the commit/tag. Follow npm's authentication or two-factor prompts if requested. Future releases can use `npm run release -- patch` or choose the version interactively with `npm run release`.
+
+`prepublishOnly` also runs the tests before a direct `npm publish`. Use `npm pack --dry-run` to inspect the published files: CLI, source, docs, manifest, and license only.
+
+After a release, update a global installation with `npm install -g logdig@latest`. Uninstall with `npm uninstall -g logdig`; this does not remove settings or notes. If you installed the Pi extension, run `logdig pi-uninstall` before uninstalling the CLI.
+
+## License
+
+[MIT](LICENSE).

package/bin/logdig.js

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { collectSessions, parseBackfillArgument, writeSessions } from "../src/session-runner.js";
+import { createPiModelClient } from "../src/pi-client.js";
+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";
+
+const packageRoot = fileURLToPath(new URL("../", import.meta.url));
+const relativeEntry = path.relative(process.cwd(), fileURLToPath(import.meta.url)).split(path.sep).join("/");
+const entryArgument = relativeEntry.startsWith(".") ? relativeEntry : `./${relativeEntry}`;
+const installedPackage = path.basename(path.dirname(path.resolve(packageRoot))) === "node_modules";
+const commandName = installedPackage || path.basename(process.argv[1] || "") === "logdig"
+  ? "logdig"
+  : `node ${/\s/.test(entryArgument) ? JSON.stringify(entryArgument) : entryArgument}`;
+
+function requireJournalPaths(settings) {
+  if (!settings.cacheDirectory || !settings.dailyDirectory) {
+    throw new Error(`Run '${commandName} init' first, or set PI_JOURNAL_DIR and PI_JOURNAL_DAILY_DIR. Settings file: ${settings.filePath}`);
+  }
+}
+
+async function init() {
+  const configured = await configureLogDig(await loadSettings(), commandName);
+  if (!configured) return;
+  const { settings, installExtension } = configured;
+  if (installExtension) {
+    try {
+      await runPiCommand(settings.piCommand, ["install", packageRoot], { inherit: true, timeoutMs: 120_000 });
+      console.log("Pi extension installed. Restart Pi or run /reload to load /journal.");
+    } catch (error) {
+      throw new Error(`Your settings are saved, but the extension could not be installed: ${error.message}. Run '${commandName} pi-install' when Pi is available.`);
+    }
+  } else {
+    console.log(`Pi integration is optional. You can add it later with: ${commandName} pi-install`);
+    if (settings.autoCapture) console.warn(`Automatic capture needs the Pi extension installed. To enable it, run '${commandName} pi-install'.`);
+  }
+}
+
+function runPiCommand(command, args, { cwd = process.cwd(), inherit = false, timeoutMs = 10_000 } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawnPiProcess(command, args, {
+      cwd,
+      stdio: inherit ? "inherit" : ["ignore", "pipe", "pipe"],
+    });
+    let stdoutText = "";
+    let stderrText = "";
+    if (!inherit) {
+      child.stdout.on("data", (chunk) => { stdoutText += chunk.toString("utf8"); });
+      child.stderr.on("data", (chunk) => { stderrText += chunk.toString("utf8"); });
+    }
+    const timeout = setTimeout(() => {
+      child.kill("SIGTERM");
+      reject(new Error(`'${command}' did not respond within ${timeoutMs / 1000} seconds`));
+    }, timeoutMs);
+    child.once("error", (error) => {
+      clearTimeout(timeout);
+      reject(new Error(`Could not start '${command}': ${error.message}`));
+    });
+    child.once("close", (code, signal) => {
+      clearTimeout(timeout);
+      if (code === 0) resolve({ stdout: stdoutText.trim(), stderr: stderrText.trim() });
+      else reject(new Error(`${command} failed${signal ? ` (${signal})` : ` with exit code ${code}`}${stderrText ? `: ${stderrText.trim()}` : ""}`));
+    });
+  });
+}
+
+async function showConfig() {
+  const settings = await loadSettings();
+  const { filePath, configured, ...values } = settings;
+  console.log(`Settings: ${filePath}${configured ? "" : " (not created yet)"}`);
+  console.log(JSON.stringify(values, null, 2));
+  const overrides = environmentOverrides();
+  if (overrides.length) console.log(`Environment overrides: ${overrides.join(", ")}`);
+}
+
+async function doctor() {
+  const settings = await loadSettings();
+  let issues = 0;
+  let warnings = 0;
+  console.log("LogDig checkup (no model requests or file changes)\n");
+  console.log(`Settings: ${settings.filePath}${settings.configured ? " (saved)" : " (not saved; using defaults/environment)"}`);
+  const overrides = environmentOverrides();
+  if (overrides.length) console.log(`Environment overrides: ${overrides.join(", ")}`);
+
+  for (const [label, directory, writable] of [
+    ["Session history", settings.sessionDirectory, false],
+    ["Summary cache", settings.cacheDirectory, true],
+    ["Daily notes", settings.dailyDirectory, true],
+  ]) {
+    if (!directory) {
+      console.error(`FIX   ${label}: not configured. Run '${commandName} init' to choose a folder.`);
+      issues++;
+      continue;
+    }
+    try {
+      const result = await checkDirectory(directory, { writable, allowMissing: writable });
+      console.log(`OK    ${label}: ${directory}${result.exists ? "" : " (will be created on a real backfill)"}`);
+    } catch (error) {
+      if (label === "Session history" && error.code === "ENOENT") {
+        console.warn(`WARN  ${label}: ${directory} (not found yet). Start a saved Pi session, or choose its location with '${commandName} init'.`);
+        warnings++;
+      } else {
+        console.error(`FIX   ${label}: ${directory} (${error.message}). Check folder permissions or choose another folder with '${commandName} init'.`);
+        issues++;
+      }
+    }
+  }
+
+  try {
+    const pi = await runPiCommand(settings.piCommand, ["--version", "--no-extensions", "--no-skills", "--no-prompt-templates", "--no-context-files", "--offline"]);
+    console.log(`OK    Pi: ${pi.stdout || pi.stderr || "available"}`);
+  } catch (error) {
+    console.error(`FIX   Pi: ${error.message}. Install Pi or set its executable in '${commandName} init' (advanced settings).`);
+    issues++;
+  }
+  console.log(`\nSummary model: ${settings.model || "Pi startup default"}`);
+  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.`);
+    process.exitCode = 1;
+  } else {
+    console.log(`\nChecks passed${warnings ? ` with ${warnings} warning${warnings === 1 ? "" : "s"}` : ""}. Next: ${commandName} backfill 1 --dry-run`);
+  }
+}
+
+async function backfill(args) {
+  const settings = await loadSettings();
+  let daysArgument;
+  let dryRun = false;
+  let selectedModel = settings.model;
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--dry-run") {
+      dryRun = 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");
+    } else if (arg.startsWith("--model=")) {
+      selectedModel = arg.slice("--model=".length);
+    } else if (!arg.startsWith("-") && daysArgument === undefined) {
+      daysArgument = arg;
+    } else {
+      throw new Error(`Unknown backfill argument: ${arg}. Run '${commandName} backfill --help'.`);
+    }
+  }
+  selectedModel = selectedModel?.trim().toLowerCase() === "default" ? undefined : selectedModel;
+  selectedModel = validateSettings({ ...settings, model: selectedModel }).model;
+  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(`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(dryRun
+    ? "Dry run: no model requests, no file changes, and no folders created."
+    : "Only new or changed sessions need model requests. 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}` : ""}.`);
+  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.`);
+    if (found.warnings.length) {
+      console.warn(found.warnings.join("\n"));
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  const modelClient = createPiModelClient({ ...settings, model: selectedModel });
+  const result = await writeSessions(modelClient, found.sessions, settings, {
+    ...found,
+    dryRun,
+    onProgress: ({ index, total, sessionId, project, date, time, status, error, phase, sessionPath, dailyPath }) => {
+      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}`);
+      }
+    },
+  });
+  const summaryCount = `${result.summariesCreated} ${result.summariesCreated === 1 ? "summary" : "summaries"}`;
+  const entryCount = `${result.entriesAppended} daily ${result.entriesAppended === 1 ? "entry" : "entries"}`;
+  console.log(dryRun
+    ? `\nWould create ${summaryCount}, reuse ${result.summariesReused}, append ${entryCount}; ${result.entriesSkipped} already present.`
+    : `\nSaved: ${summaryCount} created, ${result.summariesReused} reused, ${entryCount} appended; ${result.entriesSkipped} already present.`);
+  if (result.sessionsSkipped) console.log(`${result.sessionsSkipped} session${result.sessionsSkipped === 1 ? "" : "s"} skipped (outside the date range or without journalable messages).`);
+  if (result.dates.length) {
+    console.log(`Daily-note dates: ${result.dates.join(", ")}`);
+    if (dryRun && result.summariesCreated) console.log(`${result.summariesCreated} session${result.summariesCreated === 1 ? "" : "s"} would need model requests. Large sessions may require multiple requests each.`);
+    if (!result.summariesCreated && !result.errors.length) console.log("These unchanged sessions 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'.`);
+  }
+  const warnings = [...found.warnings, ...result.errors];
+  if (warnings.length) {
+    console.warn(warnings.join("\n"));
+    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" : ""}`);
+  }
+}
+
+function helpText() {
+  return [
+    "LogDig: a little work journal from your Pi sessions.",
+    "",
+    commandName === "logdig" ? "Start here:" : "Start here, from this checkout (no install needed):",
+    `  ${commandName} init`,
+    `  ${commandName} doctor`,
+    `  ${commandName} backfill 1 --dry-run`,
+    "",
+    "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]",
+    "                                      journal saved sessions (default: last 3 days)",
+    "  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.",
+    "",
+    "Real backfill uses Pi's startup model and existing authentication. Tools,",
+    "extensions, project context, and session saving are disabled for model requests.",
+    "Use --model default to ignore a saved model override for one run.",
+    "More help: README.md and QUICKSTART.md",
+  ].join("\n");
+}
+
+async function main() {
+  const [command = "help", ...args] = process.argv.slice(2);
+  const commands = ["init", "config", "doctor", "backfill", "pi-install", "pi-uninstall", "help", "--help", "-h", "--version", "-v"];
+  if (!commands.includes(command)) throw new Error(`Unknown command: ${command}. Run '${commandName} help'.`);
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(helpText());
+    return;
+  }
+  if (command !== "backfill" && args.length) throw new Error(`'${command}' does not accept arguments. Run '${commandName} help'.`);
+  switch (command) {
+    case "--version":
+    case "-v": {
+      const { version } = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+      console.log(version);
+      break;
+    }
+    case "init":
+      await init();
+      break;
+    case "config":
+      await showConfig();
+      break;
+    case "doctor":
+      await doctor();
+      break;
+    case "backfill":
+      await backfill(args);
+      break;
+    case "pi-install": {
+      const settings = await loadSettings();
+      await runPiCommand(settings.piCommand, ["install", packageRoot], { inherit: true, timeoutMs: 120_000 });
+      console.log("Pi extension installed. Restart Pi or run /reload to load /journal.");
+      break;
+    }
+    case "pi-uninstall": {
+      const settings = await loadSettings();
+      await runPiCommand(settings.piCommand, ["remove", packageRoot], { inherit: true, timeoutMs: 120_000 });
+      console.log("Pi extension removed.");
+      break;
+    }
+    case "help":
+    case "--help":
+    case "-h":
+      console.log(helpText());
+      break;
+  }
+}
+
+main().catch((error) => {
+  console.error(`logdig: ${error.message}`);
+  process.exitCode = error.code === "LOGDIG_SETUP_CANCELLED" ? 130 : 1;
+});

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "logdig",
+  "version": "0.1.0",
+  "description": "Turn saved Pi sessions into a work journal in your Obsidian daily notes.",
+  "license": "MIT",
+  "author": "Soleone",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Soleone/logdig.git"
+  },
+  "homepage": "https://github.com/Soleone/logdig#readme",
+  "bugs": "https://github.com/Soleone/logdig/issues",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "obsidian",
+    "journal",
+    "cli"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "bin": {
+    "logdig": "./bin/logdig.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "QUICKSTART.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./src/index.js"
+    ]
+  },
+  "scripts": {
+    "test": "node --test",
+    "prepublishOnly": "npm test",
+    "release": "release-it",
+    "release:dry-run": "npm test && release-it --dry-run"
+  },
+  "devDependencies": {
+    "release-it": "^20.2.1"
+  },
+  "overrides": {
+    "release-it": {
+      "undici": "^7.30.0"
+    }
+  }
+}