memarium 0.13.1

package/dist/src/commands/sync.js

@@ -0,0 +1,279 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import chalk from "chalk";
+import { ClaudeCodeAdapter } from "../sources/claude-code.js";
+import { VSCodeCopilotAdapter } from "../sources/vscode-copilot.js";
+import { loadIndex, saveIndex, hasUnchanged, upsertEntry } from "../index-store.js";
+import { writeSession } from "../writer.js";
+import { readConfig, writeConfig } from "../config.js";
+import { deviceBranchFromHostname } from "../device.js";
+import { ensureRepo, commitAndPush, ensureDeviceBranch, fastForwardBranch } from "../git-ops.js";
+import { migrateLegacyMainToDevice, migrateLegacyDataDir, migratedDataDirPaths } from "../migrate.js";
+import { INDEX_REL } from "../repo-data-dir.js";
+export async function runSync(opts) {
+    // One-shot migration: rename the newest legacy data dir (`.vibebook/`, else
+    // `.memvc/`) → `.memarium/` if present. Done before loadIndex so the read
+    // picks up the file at its new location.
+    const dataDirMig = await migrateLegacyDataDir(opts.repoPath);
+    if (dataDirMig.migrated) {
+        console.log(chalk.cyan(`Migrating: renamed legacy ${dataDirMig.from}/ → .memarium/ ${dataDirMig.viaGit ? "(via git mv; staged for next commit)" : "(non-git mode)"}`));
+    }
+    const adapters = [
+        new ClaudeCodeAdapter(opts.claudeRoot),
+        new VSCodeCopilotAdapter(opts.vscodeRoot),
+    ];
+    const idx = loadIndex(opts.repoPath);
+    let newCount = 0, skippedCount = 0;
+    const pathsWritten = [];
+    for (const adapter of adapters) {
+        for await (const d of adapter.discover()) {
+            let s;
+            try {
+                s = await d.load();
+            }
+            catch (err) {
+                console.log(chalk.yellow(`! skip ${d.sourcePath}: ${err.message}`));
+                continue;
+            }
+            if (hasUnchanged(idx, s.tool, s.sessionId, d.sourceMtimeMs, d.sourceSha256, opts.repoPath)) {
+                skippedCount++;
+                continue;
+            }
+            // Skip empty-shell sessions — VS Code creates a chatSessions/<id>.jsonl
+            // for every chat tab the user opens (even ones they immediately
+            // close), so we'd otherwise write a `1970-01-01/untitled__<id>.md`
+            // for each. Audit on 2026-05-23 found 142 such shells in Yue's repo.
+            if (s.messages.length === 0) {
+                skippedCount++;
+                continue;
+            }
+            const rel = writeSession(opts.repoPath, s, { includeReasoning: opts.includeReasoning });
+            pathsWritten.push(rel.md);
+            const entry = {
+                sessionId: s.sessionId,
+                shortId: s.shortId,
+                tool: s.tool,
+                project: s.project,
+                projectRaw: s.projectRaw,
+                startedAt: s.startedAt,
+                endedAt: s.endedAt,
+                nameSlug: s.nameSlug,
+                displayName: s.displayName,
+                relativePath: rel.md,
+                sourcePath: s.sourcePath,
+                sourceMtimeMs: d.sourceMtimeMs,
+                sourceSha256: d.sourceSha256,
+            };
+            upsertEntry(idx, entry);
+            newCount++;
+            console.log(chalk.green(`+ ${s.tool}/${s.project}/${s.nameSlug} (${s.shortId})`));
+        }
+    }
+    // 0.8.4: prune orphan index entries — entries whose source jsonl no
+    // longer exists on disk AND whose rendered .md is also gone. Pre-0.8.4,
+    // a session deleted from ~/.claude/projects/ (or its workspaceStorage
+    // counterpart) left its index entry forever; CI aggregate then logged
+    // "missing despite spool index; skipping" for each, eating noise but
+    // also losing the chance to clean up stale aggregated state on main.
+    let prunedIndex = 0;
+    for (const [key, e] of Object.entries(idx.entries)) {
+        if (!existsSync(e.sourcePath) && !existsSync(join(opts.repoPath, e.relativePath))) {
+            delete idx.entries[key];
+            prunedIndex++;
+        }
+    }
+    if (prunedIndex > 0) {
+        console.log(chalk.gray(`  pruned ${prunedIndex} index entr${prunedIndex === 1 ? "y" : "ies"} (source jsonl gone)`));
+    }
+    saveIndex(opts.repoPath, idx);
+    let committed = false, pushed = false;
+    if (opts.push && opts.repoUrl && opts.deviceBranch) {
+        console.log(chalk.gray(`\nOpening repo at ${opts.repoPath}...`));
+        const git = await ensureRepo(opts.repoPath, opts.repoUrl);
+        const mig = await migrateLegacyMainToDevice(opts.repoPath, opts.deviceBranch);
+        if (mig.migrated) {
+            console.log(chalk.cyan(`Migrated legacy 'main' branch to '${opts.deviceBranch}'. 'main' is now unborn locally.`));
+        }
+        try {
+            await git.fetch();
+        }
+        catch { /* remote may be empty / offline */ }
+        console.log(chalk.gray(`Ensuring branch '${opts.deviceBranch}' is checked out...`));
+        await ensureDeviceBranch(git, opts.deviceBranch);
+        // Pull --rebase --autostash before committing, so CI's auto-commits on
+        // origin/<device> don't cause non-fast-forward push failures.
+        try {
+            const ff = await fastForwardBranch(git, opts.deviceBranch, (s) => console.log(chalk.gray(`  ${s}`)));
+            if (!ff.pulled && ff.reason === "no-tracking") {
+                console.log(chalk.gray(`  no remote ${opts.deviceBranch} yet — first push will create it`));
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.log(chalk.red(`! could not sync local branch with origin: ${msg}`));
+            console.log(chalk.cyan(`  Skipping push. Resolve in ${opts.repoPath} and re-run \`memarium sync\`.`));
+            return { newCount, skippedCount, pathsWritten, committed: false, pushed: false };
+        }
+        const all = [...pathsWritten, INDEX_REL];
+        if (dataDirMig.migrated && dataDirMig.viaGit) {
+            for (const p of migratedDataDirPaths(opts.repoPath))
+                all.push(p);
+        }
+        // P1 (0.8.1): make sure this device branch carries a copy of
+        // `.github/workflows/memarium-aggregate.yml`. GitHub Actions on `push`
+        // events reads the workflow definition from THE PUSHED BRANCH (not
+        // from the default branch), so without this the CI never triggers on
+        // freshly-init'd devices and main never gets aggregated. The file
+        // itself is identical to what `memarium workflow init` planted on
+        // main; we just clone-in the latest copy on every sync so device
+        // branches stay in sync with workflow updates too.
+        const workflowAdded = await ensureWorkflowFileFromMain(opts.repoPath, git);
+        if (workflowAdded)
+            all.push(".github/workflows/memarium-aggregate.yml");
+        // memory/ (typed-memory layer, 0.8.6): the plugin's `memory-write` writes
+        // memory/<type>/... + .memarium/index.memory.json into the working tree but
+        // doesn't push. Stage them here so they reach the device branch and CI's
+        // merge-books can aggregate memory cross-device. commitAndPush() no-ops if
+        // nothing actually changed.
+        if (existsSync(join(opts.repoPath, "memory")))
+            all.push("memory");
+        if (existsSync(join(opts.repoPath, ".memarium", "index.memory.json"))) {
+            all.push(".memarium/index.memory.json");
+        }
+        // entity index: memory/entities/ is already covered by staging
+        // "memory/" above; we just need to also push the entity index so that
+        // merge-books' anyEntityIndexSeen check fires on CI.
+        if (existsSync(join(opts.repoPath, ".memarium", "index.entity.json"))) {
+            all.push(".memarium/index.entity.json");
+        }
+        // qa index: memory/qa/ is already covered by staging "memory" above; we just
+        // need to also push the qa index so cross-device merge-books can union it.
+        if (existsSync(join(opts.repoPath, ".memarium", "index.qa.json"))) {
+            all.push(".memarium/index.qa.json");
+        }
+        console.log(chalk.gray(`Staging ${all.length} paths and committing...`));
+        const commitMsg = newCount > 0
+            ? `memarium sync: +${newCount} sessions${dataDirMig.migrated ? ` (+ rename ${dataDirMig.from}/→.memarium/)` : ""}`
+            : (dataDirMig.migrated ? `memarium: rename ${dataDirMig.from}/ → .memarium/` :
+                `memarium sync: +${newCount} sessions`);
+        const r = await commitAndPush(git, commitMsg, all, opts.deviceBranch, (stage) => console.log(chalk.gray(`  ${stage}`)));
+        committed = r.committed;
+        pushed = r.pushed;
+        if (committed && !pushed) {
+            if (r.pushResult?.secretBlocked) {
+                console.log(chalk.red("\n  Push blocked by GitHub secret-scanning (GH013). Your raw_sessions contain something that looks like a real secret (token, API key) — typically because past AI conversations included one verbatim."));
+                console.log(chalk.cyan("  Fix: remove the secret from the offending raw_sessions md (or rotate it and use GitHub's unblock URL), then re-sync. A private repo + push protection is the intended guard here."));
+            }
+            else {
+                console.log(chalk.yellow("Commit done, push failed or skipped."));
+            }
+        }
+    }
+    else if (opts.push && !opts.repoUrl) {
+        console.log(chalk.gray("Local-only mode (no remote URL configured); skipping commit/push."));
+    }
+    // P7 (0.8.0): refresh the read-only aggregated worktree so `list-sessions`
+    // / `resume` can see every sibling device's raw_sessions. Best-effort —
+    // if this fails (no remote, first push didn't create main yet, network
+    // issue), we just log and move on; the user's own sync still succeeded.
+    if (pushed && opts.repoUrl) {
+        const { refreshAggregatedWorktree } = await import("../aggregated-store.js");
+        const ok = await refreshAggregatedWorktree(opts.repoPath);
+        if (ok) {
+            console.log(chalk.gray("  refreshed aggregated worktree (~/.memarium/aggregated/)"));
+        }
+        else {
+            // Likely "main has nothing yet" on a fresh repo — CI hasn't run an
+            // aggregate yet. Stays quiet unless DEBUG; this is the expected path
+            // on first sync of a brand-new remote.
+            if (process.env.MEMARIUM_DEBUG) {
+                console.log(chalk.gray("  (aggregated worktree refresh skipped — no main yet?)"));
+            }
+        }
+    }
+    return { newCount, skippedCount, pathsWritten, committed, pushed };
+}
+/**
+ * Ensure `.github/workflows/memarium-aggregate.yml` exists in the device
+ * branch's working tree. GitHub Actions on `push` events reads the
+ * workflow file from the pushed branch — not from the default branch —
+ * so a device branch without this file silently never triggers CI. The
+ * "fresh init never aggregated" symptom on macmini 2026-05-25 was this
+ * exact path: `memarium workflow init` (0.5.3+) only writes the file to
+ * main, but the new device branch had no `.github/` directory at all.
+ *
+ * Strategy: best-effort fetch + restore-from-main on every sync. If main
+ * doesn't have the file yet (first push on a brand-new remote), silently
+ * skip — the user just needs to run `memarium workflow init` once.
+ *
+ * Returns true when the working tree file was created OR refreshed (the
+ * caller should stage it). Returns false when nothing to do or main has
+ * no workflow yet.
+ */
+async function ensureWorkflowFileFromMain(repoPath, git) {
+    const wfRel = ".github/workflows/memarium-aggregate.yml";
+    const wfAbs = join(repoPath, wfRel);
+    let mainContent;
+    try {
+        await git.fetch("origin", "main");
+        mainContent = await git.show([`origin/main:${wfRel}`]);
+    }
+    catch (err) {
+        if (process.env.MEMARIUM_DEBUG) {
+            console.log(chalk.gray(`  (workflow file: skip — ${err.message?.split("\n")[0]})`));
+        }
+        return false;
+    }
+    if (existsSync(wfAbs)) {
+        const localContent = readFileSync(wfAbs, "utf8");
+        if (localContent === mainContent)
+            return false; // already up to date
+    }
+    mkdirSync(join(repoPath, ".github", "workflows"), { recursive: true });
+    writeFileSync(wfAbs, mainContent);
+    return true;
+}
+/**
+ * Pure helper: returns a possibly-migrated copy of cfg with deviceBranch set
+ * from hostname when the input is missing/empty. `migrated` indicates whether
+ * a write-back is needed.
+ */
+export function ensureDeviceBranchOnConfig(cfg) {
+    if (cfg.deviceBranch && cfg.deviceBranch.trim() !== "") {
+        return { migrated: false, cfg };
+    }
+    return {
+        migrated: true,
+        cfg: { ...cfg, deviceBranch: deviceBranchFromHostname() },
+    };
+}
+/**
+ * Loads ~/.memarium/config.json and applies any in-place migrations needed by
+ * current code (currently: deviceBranch self-heal). On migration, writes the
+ * fixed config back to disk.
+ */
+export function readConfigWithMigration() {
+    const rawCfg = readConfig();
+    const heal = ensureDeviceBranchOnConfig(rawCfg);
+    if (heal.migrated) {
+        console.log(chalk.cyan(`Migrating: legacy config missing deviceBranch. Setting to "${heal.cfg.deviceBranch}" and saving to ~/.memarium/config.json.`));
+        writeConfig(heal.cfg);
+    }
+    return heal.cfg;
+}
+export async function syncCmd() {
+    const cfg = readConfigWithMigration();
+    const r = await runSync({
+        repoPath: cfg.repoPath,
+        push: true,
+        repoUrl: cfg.repoUrl,
+        deviceBranch: cfg.deviceBranch,
+        includeReasoning: cfg.includeReasoning,
+    });
+    console.log(chalk.bold(`\nSynced: +${r.newCount} new, ${r.skippedCount} unchanged`));
+    if (r.committed)
+        console.log(chalk.cyan(r.pushed ? "Pushed." : "Committed (push failed)."));
+    if (r.newCount > 0) {
+        console.log(chalk.cyan("\nNext: in Claude Code, run `/memarium` to digest into chronicle/topics/cards."));
+    }
+}

package/dist/src/commands/upgrade.js

@@ -0,0 +1,47 @@
+import { spawnSync } from "node:child_process";
+import chalk from "chalk";
+export async function upgradeCmd(opts = {}) {
+    console.log(chalk.cyan("memarium upgrade — refresh the npm CLI\n"));
+    // Refresh the npm-global CLI.
+    if (!opts.noCli) {
+        if (isLinkedDevInstall()) {
+            console.log(chalk.gray("  ✓ skipping npm install (memarium is npm-link'd from a dev checkout)"));
+        }
+        else {
+            console.log(chalk.cyan("→ npm install -g memarium@latest"));
+            const r = spawnSync("npm", ["install", "-g", "memarium@latest"], { stdio: "inherit" });
+            if (r.status === 0) {
+                console.log(chalk.green("  ✓ CLI refreshed"));
+            }
+            else {
+                console.log(chalk.yellow("  ! npm install failed. Common causes:\n" +
+                    "    - You're on a system Node — try `sudo npm install -g memarium@latest`\n" +
+                    "    - Or a stale nvm cache — try `nvm use --lts && npm install -g memarium@latest`"));
+            }
+        }
+    }
+    // Final summary — point users at the separate plugin update flow.
+    console.log("");
+    console.log(chalk.cyan("For the digest + recall plugin, run:"));
+    console.log("  /plugin update memarium    (in any Claude Code session)");
+}
+/** Detect a development install — `npm link` puts the global memarium
+ *  binary as a symlink to the user's local checkout. We don't want to
+ *  blow that away with a tarball install. Strategy: ask npm where the
+ *  global package lives, then check if it's a symlink. */
+function isLinkedDevInstall() {
+    try {
+        const root = spawnSync("npm", ["root", "-g"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+        if (root.status !== 0)
+            return false;
+        const globalRoot = root.stdout.trim();
+        if (!globalRoot)
+            return false;
+        const { lstatSync } = require("node:fs");
+        const stat = lstatSync(`${globalRoot}/memarium`);
+        return stat.isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/commands/workflow.js

@@ -0,0 +1,126 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import chalk from "chalk";
+import { readConfig } from "../config.js";
+import { migrateLegacyDataDir } from "../migrate.js";
+import { ensureRepo, commitToMainViaWorktree } from "../git-ops.js";
+/**
+ * Resolve the path to a bundled asset. The build emits to `dist/src/commands/`
+ * (because tsconfig has rootDir="." and includes both bin/ and src/), while
+ * dev runs from `src/commands/`. Probe both layouts plus npm-global ones.
+ */
+function assetPath(rel) {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        resolve(here, "..", "..", rel), // src/commands/
+        resolve(here, "..", "..", "..", rel), // dist/src/commands/
+        resolve(here, "..", "..", "..", "..", rel),
+    ];
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
+    }
+    throw new Error(`memarium bundled asset not found: ${rel}. Tried:\n  ${candidates.join("\n  ")}\nIf you installed memarium from npm, please file an issue.`);
+}
+const WORKFLOW_REL = ".github/workflows/memarium-aggregate.yml";
+const SCRIPT_REL = "scripts/merge-books.mjs";
+/**
+ * Read the workflow yaml template and substitute the user's `bookLocale`
+ * into the `MEMARIUM_LOCALE` env line. Done at install time so the
+ * locale travels with the workflow on main (not pulled per-CI-run).
+ */
+function renderWorkflowYaml(bookLocale) {
+    const raw = readFileSync(assetPath("assets/workflows/memarium-aggregate.yml"), "utf8");
+    return raw.replace("__MEMARIUM_LOCALE__", bookLocale);
+}
+/**
+ * `memarium workflow init` — install the CI aggregation workflow + merge
+ * script directly onto the **main** branch (where GitHub Actions actually
+ * reads them from), without touching the user's current device branch or
+ * working tree.
+ *
+ * Why main instead of the device branch: GitHub Actions only resolves
+ * workflow files from the default branch. If we wrote them to a device
+ * branch, every CI run would fail with MODULE_NOT_FOUND on the merge
+ * script (because main, where the workflow checks out, doesn't have it).
+ * That was the 0.5.0 → 0.5.2 cold-start bug.
+ *
+ * Local-only repos (no repoUrl) still get files written to the device
+ * branch's working tree for completeness, but won't push anywhere.
+ */
+export async function workflowInitCmd(opts = {}) {
+    const cfg = readConfig();
+    // Local-only mode: write into the current working tree like before.
+    // Nothing to push — no CI matters in this mode anyway.
+    if (!cfg.repoUrl) {
+        const yamlTarget = join(cfg.repoPath, WORKFLOW_REL);
+        const scriptTarget = join(cfg.repoPath, SCRIPT_REL);
+        if ((existsSync(yamlTarget) || existsSync(scriptTarget)) && !opts.force) {
+            if (existsSync(yamlTarget))
+                console.log(chalk.yellow(`already exists: ${yamlTarget}`));
+            if (existsSync(scriptTarget))
+                console.log(chalk.yellow(`already exists: ${scriptTarget}`));
+            console.log(chalk.gray("  re-run with --force to overwrite"));
+            return;
+        }
+        mkdirSync(dirname(yamlTarget), { recursive: true });
+        writeFileSync(yamlTarget, renderWorkflowYaml(cfg.bookLocale));
+        mkdirSync(dirname(scriptTarget), { recursive: true });
+        writeFileSync(scriptTarget, readFileSync(assetPath("assets/scripts/merge-books.mjs"), "utf8"));
+        console.log(chalk.green(`workflow + script written under ${cfg.repoPath}`));
+        console.log(chalk.gray("Local-only mode: no remote configured — CI aggregation has no effect."));
+        return;
+    }
+    // Remote-mode: install on main via a temp worktree so we don't disturb the
+    // user's device branch or working tree.
+    if (opts.noPush) {
+        console.log(chalk.yellow("  --no-push is incompatible with the new workflow-init flow (which writes\n" +
+            "  directly to origin/main via a temp worktree). To inspect files locally,\n" +
+            "  see assets/workflows/memarium-aggregate.yml + assets/scripts/merge-books.mjs\n" +
+            "  in the memarium npm package."));
+        return;
+    }
+    // Opportunistic: rename the newest legacy data dir (`.vibebook/`, else
+    // `.memvc/`) → `.memarium/` if the user skipped it on earlier syncs. This
+    // happens on the user's main working tree (device branch), independent of
+    // the main-side workflow push below.
+    const dataDirMig = await migrateLegacyDataDir(cfg.repoPath);
+    if (dataDirMig.migrated) {
+        console.log(chalk.green(`renamed legacy ${dataDirMig.from}/ → .memarium/ ${dataDirMig.viaGit ? "(via git mv)" : ""}`));
+    }
+    const git = await ensureRepo(cfg.repoPath, cfg.repoUrl);
+    console.log(chalk.cyan("Installing workflow + script on origin/main..."));
+    const r = await commitToMainViaWorktree(git, cfg.repoPath, async (worktreePath) => {
+        const yamlAbs = join(worktreePath, WORKFLOW_REL);
+        const scriptAbs = join(worktreePath, SCRIPT_REL);
+        const newYaml = renderWorkflowYaml(cfg.bookLocale);
+        const newScript = readFileSync(assetPath("assets/scripts/merge-books.mjs"), "utf8");
+        // If the file is already present on main and we're not --force, skip.
+        if (!opts.force && existsSync(yamlAbs) && existsSync(scriptAbs)) {
+            const existingYaml = readFileSync(yamlAbs, "utf8");
+            const existingScript = readFileSync(scriptAbs, "utf8");
+            if (existingYaml === newYaml && existingScript === newScript) {
+                // Nothing changes; tell the worktree commit step to no-op.
+                return [];
+            }
+        }
+        mkdirSync(dirname(yamlAbs), { recursive: true });
+        writeFileSync(yamlAbs, newYaml);
+        mkdirSync(dirname(scriptAbs), { recursive: true });
+        writeFileSync(scriptAbs, newScript);
+        return [WORKFLOW_REL, SCRIPT_REL];
+    }, "memarium: install / update CI aggregation workflow + merge-books script", (stage) => console.log(chalk.gray(`  ${stage}`)));
+    if (r.committed && r.pushed) {
+        console.log(chalk.green(`\n✓ workflow + script pushed to origin/main`));
+        console.log(chalk.gray("The workflow fires on every push to a non-main branch."));
+        console.log(chalk.gray("Each device's `memarium sync` will trigger it; CI merges all device book/s into main."));
+    }
+    else if (!r.committed) {
+        console.log(chalk.gray("\nMain already has the latest workflow + script (no-op)."));
+    }
+    else {
+        console.log(chalk.yellow("\n! committed locally on the temp worktree but push failed."));
+        console.log(chalk.cyan("  Inspect ~/.memarium/session-repo, fetch origin/main, and retry."));
+    }
+}

package/dist/src/config.js

@@ -0,0 +1,98 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+// Resolved lazily (not module-level consts) so they always reflect the current
+// HOME — important for tests that stub HOME, and correct for a CLI in general.
+function configDir() { return join(homedir(), ".memarium"); }
+function configPath() { return join(configDir(), "config.json"); }
+/** One-shot: move the whole config dir from the old `~/.vibebook/` (project's
+ *  pre-rename name) to `~/.memarium/` if the old one exists and the new one
+ *  doesn't. Idempotent, best-effort. Covers config.json, session-repo/,
+ *  aggregated/, usage/, local-proposals/ in one move, then rewrites the
+ *  absolute `~/.vibebook/` paths stored inside config.json. Finally repairs
+ *  the `aggregated/` git worktree, whose absolute back-link to session-repo the
+ *  move staled (refreshAggregatedWorktree only rebuilds when `aggregated/.git`
+ *  is ABSENT, so a dangling link would silently break cross-device recall).
+ *  Runs before reads. */
+export function migrateLegacyConfigDir() {
+    const legacy = join(homedir(), ".vibebook");
+    const dir = configDir();
+    if (existsSync(dir) || !existsSync(legacy))
+        return;
+    try {
+        renameSync(legacy, dir);
+        // Fix stored paths (repoPath etc.) that pointed into ~/.vibebook — both the
+        // expanded form (`/home/u/.vibebook`) and the literal-tilde form
+        // (`~/.vibebook`) that config.json may legally store.
+        const p = configPath();
+        let repoPath = join(dir, "session-repo");
+        if (existsSync(p)) {
+            const raw = readFileSync(p, "utf8");
+            const fixed = raw.split(legacy).join(dir).split("~/.vibebook").join("~/.memarium");
+            if (fixed !== raw)
+                writeFileSync(p, fixed);
+            try {
+                const parsed = JSON.parse(fixed);
+                if (parsed.repoPath)
+                    repoPath = parsed.repoPath.replace(/^~(?=$|\/)/, homedir());
+            }
+            catch { /* keep default repoPath */ }
+        }
+        // Repair the read-only aggregated worktree's absolute links (both the
+        // worktree's `.git` file and the session-repo's admin `gitdir`) so a later
+        // `memarium sync` can still refresh it instead of silently failing.
+        // Bounded so a hung git can't stall the SessionStart migration path.
+        const agg = join(dir, "aggregated");
+        if (existsSync(agg)) {
+            spawnSync("git", ["-C", repoPath, "worktree", "repair", agg], { stdio: "ignore", timeout: 10_000 });
+        }
+    }
+    catch { /* best-effort */ }
+}
+/** Default cap on concurrent runner calls during the threading phase.
+ *  claude-cli can comfortably handle 4 (each spawn is its own subprocess
+ *  against the user's own Claude quota). anthropic-api also fine at 4. */
+export const DEFAULT_THREADING_CONCURRENCY = 4;
+/** Default attempts per threading batch before soft-failing it. */
+export const DEFAULT_THREADING_MAX_ATTEMPTS = 3;
+const Schema = z.object({
+    repoPath: z.string(),
+    repoUrl: z.string(),
+    deviceBranch: z.string().default(""),
+    runner: z.enum(["claude-cli", "anthropic-api"]).default("claude-cli"),
+    /** When true, the user opted into the CI book-aggregation workflow
+     *  (scripts/merge-books.mjs runs on push to any non-main branch and
+     *  merges device books into main). Purely informational — the workflow
+     *  yaml + script live in the user's repo, not driven by this flag. */
+    enableAggregateCI: z.boolean().default(false),
+    /** When true, include the assistant's reasoning/thinking content in synced
+     *  raw_sessions/*.md files. Improves digest quality (the summarizing LLM
+     *  can see WHY the assistant chose a path) but can grow each md file by
+     *  30-100%. Recommended when summarizing with a 400K+ context model;
+     *  recommended off when summarizing with a smaller model. Default: true. */
+    includeReasoning: z.boolean().default(true),
+    threadingConcurrency: z.number().int().positive().default(DEFAULT_THREADING_CONCURRENCY),
+    threadingMaxAttempts: z.number().int().positive().default(DEFAULT_THREADING_MAX_ATTEMPTS),
+    digestEnabled: z.boolean().default(true),
+    /** Cross-device path translation: source-prefix → this-machine-prefix.
+     *  Used by `memarium resume` to rewrite jsonl paths from another machine
+     *  into local paths. Set via `memarium config --map-path A=B`. */
+    pathMap: z.record(z.string()).optional(),
+    /** Locale for the rendered book pages (book/index.md, book/_meta/timeline.md,
+     *  per-project index pages). Drives string tables in merge-books.mjs via
+     *  the MEMARIUM_LOCALE env var the workflow yml exports. Default "en". */
+    bookLocale: z.enum(["en", "zh"]).default("en"),
+});
+export function configExists() { migrateLegacyConfigDir(); return existsSync(configPath()); }
+export function readConfig() {
+    migrateLegacyConfigDir();
+    if (!existsSync(configPath()))
+        throw new Error("memarium not initialized. Run `memarium init <repoUrl>`.");
+    return Schema.parse(JSON.parse(readFileSync(configPath(), "utf8")));
+}
+export function writeConfig(cfg) {
+    mkdirSync(configDir(), { recursive: true });
+    writeFileSync(configPath(), JSON.stringify(cfg, null, 2) + "\n");
+}