memarium 0.13.1

package/dist/src/commands/doctor.js

@@ -0,0 +1,383 @@
+import { existsSync, readFileSync, readdirSync, realpathSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import chalk from "chalk";
+import { isStableDeviceName } from "../device.js";
+import { aggregatedPath } from "../aggregated-store.js";
+export async function doctorCmd() {
+    const checks = [];
+    // 1. CLI on PATH
+    const cliVersion = readPathCliVersion();
+    if (cliVersion) {
+        checks.push({ name: "CLI on PATH", status: "ok", detail: `memarium ${cliVersion}` });
+    }
+    else {
+        checks.push({
+            name: "CLI on PATH", status: "fail",
+            detail: "memarium --version did not respond",
+            fix: "npm install -g memarium@latest",
+        });
+    }
+    // 1b. Multi-install footgun (0.8.4): a user can have `memarium` installed
+    // to both Homebrew's npm prefix AND nvm's prefix at the same time. `memarium
+    // upgrade` lands in whichever npm runs first, but shell `memarium` resolves
+    // by PATH order — so users routinely upgrade one install while continuing
+    // to run the other. Tell them which one wins and which to nuke.
+    const allInstalls = listAllPathInstalls();
+    if (allInstalls.length > 1) {
+        const lines = allInstalls
+            .map((i, idx) => `    ${idx === 0 ? "→" : " "} ${i.path} (${i.version ?? "?"})`)
+            .join("\n");
+        const losers = allInstalls.slice(1);
+        const fixCmd = losers
+            .map((i) => {
+            // Infer the npm prefix from the install path and recommend that
+            // npm to uninstall, so the user doesn't accidentally uninstall
+            // the one they wanted to keep.
+            const prefix = i.path.replace(/\/bin\/memarium$/, "");
+            return `${prefix}/bin/npm uninstall -g memarium`;
+        })
+            .join(" && ") + " && hash -r";
+        checks.push({
+            name: "PATH conflicts", status: "warn",
+            detail: `${allInstalls.length} memarium installs on PATH (shell uses the → marked one):\n${lines}`,
+            fix: fixCmd,
+        });
+    }
+    // 2. npm latest
+    const npmLatest = readNpmLatestVersion();
+    if (npmLatest) {
+        if (cliVersion && cliVersion !== npmLatest) {
+            checks.push({
+                name: "CLI vs npm latest", status: "warn",
+                detail: `local ${cliVersion} · npm ${npmLatest}`,
+                fix: "memarium upgrade",
+            });
+        }
+        else if (cliVersion) {
+            checks.push({ name: "CLI vs npm latest", status: "ok", detail: `${cliVersion} = ${npmLatest}` });
+        }
+    }
+    else {
+        checks.push({
+            name: "CLI vs npm latest", status: "info",
+            detail: "couldn't reach npm registry (offline?)",
+        });
+    }
+    // 3. Claude plugin (outside-in detection — the plugin lives in its own repo,
+    //    cloned by Claude Code into ~/.claude/plugins/marketplaces/memarium-plugin/
+    //    when the user runs `/plugin marketplace add june9593/memarium-plugin`.
+    //    npm memarium itself does not install the plugin.)
+    const pluginMarketplacePath = join(homedir(), ".claude", "plugins", "marketplaces", "memarium-plugin");
+    if (existsSync(pluginMarketplacePath)) {
+        checks.push({
+            name: "Claude plugin", status: "ok",
+            detail: "memarium-plugin marketplace registered",
+        });
+    }
+    else {
+        checks.push({
+            name: "Claude plugin", status: "warn",
+            detail: "memarium-plugin (chronicle digest + recall) not installed",
+            fix: "/plugin marketplace add june9593/memarium-plugin && /plugin install memarium   # optional — npm memarium handles cross-device sync; the plugin handles digest + recall",
+        });
+    }
+    // 4. Config + repoPath
+    const config = readConfigSafe();
+    if (!config) {
+        checks.push({
+            name: "memarium config", status: "fail",
+            detail: "~/.memarium/config.json missing",
+            fix: "memarium init",
+        });
+    }
+    else {
+        const repoExists = existsSync(config.repoPath);
+        const repoHasGit = repoExists && existsSync(join(config.repoPath, ".git"));
+        if (!repoExists) {
+            checks.push({
+                name: "Session repo", status: "fail",
+                detail: `repoPath ${config.repoPath} does not exist`,
+                fix: "memarium init   # re-clone",
+            });
+        }
+        else if (!repoHasGit) {
+            checks.push({
+                name: "Session repo", status: "warn",
+                detail: `${config.repoPath} exists but is not a git repo`,
+            });
+        }
+        else {
+            checks.push({
+                name: "Session repo", status: "ok",
+                detail: `${config.repoPath} (${config.repoUrl || "local-only"})`,
+            });
+        }
+        // 4b. Device branch drift check. hostname() on macOS varies across
+        //     networks (mDNS / corp DHCP / hotspot) — if init wrote the volatile
+        //     value, each network creates a new branch and the spool fragments.
+        if (config.deviceBranch !== undefined) {
+            if (!isStableDeviceName(config.deviceBranch)) {
+                checks.push({
+                    name: "Device branch", status: "warn",
+                    detail: `'${config.deviceBranch}' looks like a volatile macOS hostname — sync may push to a new branch when you change networks`,
+                    fix: `memarium config --device <stable-name>   # e.g. 'mini2', 'work-laptop'`,
+                });
+            }
+            else {
+                checks.push({
+                    name: "Device branch", status: "ok",
+                    detail: config.deviceBranch,
+                });
+            }
+        }
+        // 5. 0.5.x spool residue check. memarium 0.6 only writes .md per session.
+        //    Existing .raw.json and .jsonl from 0.5.x are dead weight; suggest cleanup.
+        if (repoExists) {
+            const residue = countResidue(config.repoPath);
+            if (residue.rawJsonCount + residue.jsonlCount > 0) {
+                const lines = [
+                    `${residue.rawJsonCount} .raw.json files, ${residue.jsonlCount} .jsonl files in spool`,
+                    `(memarium 0.6 only writes .md — these are 0.5.x residue)`,
+                ];
+                checks.push({
+                    name: "0.5.x spool residue",
+                    status: "warn",
+                    detail: lines.join(" — "),
+                    fix: `find "${join(config.repoPath, "raw_sessions")}" -name "*.jsonl" -delete && ` +
+                        `find "${join(config.repoPath, "raw_sessions")}" -name "*.raw.json" -delete && ` +
+                        `rm "${join(config.repoPath, ".memarium/index.json")}" && ` +
+                        `memarium sync   # regenerates index + new-format .md per session`,
+                });
+            }
+            // 5b. resume-forks.json residue (from 0.5.1 fork-tracking, removed in 0.6)
+            const forkRegPath = join(homedir(), ".memarium/resume-forks.json");
+            if (existsSync(forkRegPath)) {
+                checks.push({
+                    name: "0.5.1 fork registry residue",
+                    status: "warn",
+                    detail: `~/.memarium/resume-forks.json exists (no longer used)`,
+                    fix: `rm ${forkRegPath}`,
+                });
+            }
+            // 5c. Workflow residue on device branch. Pre-0.5.3 `memarium workflow
+            //     init` wrote files to the user's device branch; from 0.5.3 they
+            //     live on main only. Warn if the user still has stale copies on
+            //     the device branch (we can't easily distinguish "I'm a 0.5.2
+            //     user who already pushed these once" from "I'm a 0.5.3 user with
+            //     a leftover commit", so we just always warn when both branches
+            //     have them on disk).
+            const deviceYaml = join(config.repoPath, ".github/workflows/memarium-aggregate.yml");
+            const deviceScript = join(config.repoPath, "scripts/merge-books.mjs");
+            if (existsSync(deviceYaml) || existsSync(deviceScript)) {
+                checks.push({
+                    name: "Workflow residue", status: "warn",
+                    detail: "Found .github/workflows/memarium-aggregate.yml + scripts/merge-books.mjs on device-branch working tree — these belong on main only (since 0.5.3)",
+                    fix: `cd "${config.repoPath}" && git rm -r .github/workflows scripts 2>/dev/null; git commit -m "remove workflow residue (lives on main since 0.5.3)" && git push`,
+                });
+            }
+            // 5d. Cross-device overlay freshness (P1). The plugin's recall/primer read
+            //     ~/.memarium/aggregated (a read-only worktree of origin/main) for
+            //     sibling-device memory (P0b, plugin 0.12). If it's missing or behind
+            //     origin/main, cross-device recall silently misses sibling memory.
+            if (repoHasGit && config.repoUrl) {
+                const aggPath = aggregatedPath();
+                if (!existsSync(aggPath)) {
+                    checks.push({
+                        name: "Cross-device overlay", status: "warn",
+                        detail: "~/.memarium/aggregated not set up — recall/primer see only this device's memory",
+                        fix: "memarium sync   # creates + refreshes the cross-device overlay",
+                    });
+                }
+                else {
+                    const overlayHead = gitRevParse(aggPath, "HEAD");
+                    const originMain = gitRevParse(config.repoPath, "origin/main");
+                    if (!overlayHead) {
+                        // Dir exists but HEAD won't resolve → broken/orphaned worktree.
+                        // The whole point of this check is to surface silently-broken
+                        // cross-device recall, so don't mask it as ok.
+                        checks.push({
+                            name: "Cross-device overlay", status: "warn",
+                            detail: "overlay present but its HEAD can't be resolved (broken/orphaned worktree) — cross-device recall may be silently broken",
+                            fix: "memarium sync   # rebuild the overlay",
+                        });
+                    }
+                    else if (originMain && overlayHead !== originMain) {
+                        checks.push({
+                            name: "Cross-device overlay", status: "warn",
+                            detail: "overlay is behind origin/main — cross-device recall may miss recent sibling-device memory",
+                            fix: "memarium sync   # refresh the overlay",
+                        });
+                    }
+                    else {
+                        checks.push({
+                            name: "Cross-device overlay", status: "ok",
+                            detail: originMain ? "present + in sync with origin/main" : "present",
+                        });
+                    }
+                }
+            }
+        }
+    }
+    // 6. memex (informational)
+    const memexVersion = readMemexVersion();
+    if (memexVersion) {
+        checks.push({
+            name: "Memex (optional)", status: "ok",
+            detail: `${memexVersion} — /memarium recall folds memex cards in automatically`,
+        });
+    }
+    else {
+        checks.push({
+            name: "Memex (optional)", status: "info",
+            detail: "not installed — atomic-card layer is unavailable",
+            fix: "npm install -g @touchskyer/memex   # only if you want atomic cards",
+        });
+    }
+    // ---------- render ----------
+    const symbol = {
+        ok: chalk.green("✓"),
+        warn: chalk.yellow("!"),
+        fail: chalk.red("✗"),
+        info: chalk.gray("·"),
+    };
+    for (const c of checks) {
+        console.log(`${symbol[c.status]} ${c.name.padEnd(28)} ${c.detail}`);
+    }
+    const fixes = checks.filter((c) => c.fix);
+    if (fixes.length > 0) {
+        console.log(chalk.cyan("\nSuggested fixes:"));
+        const seen = new Set();
+        for (const c of fixes) {
+            if (seen.has(c.fix))
+                continue;
+            seen.add(c.fix);
+            console.log(`  ${c.fix}`);
+        }
+    }
+    else {
+        console.log(chalk.green("\nAll checks passed."));
+    }
+    // Exit non-zero only if a `fail`. `warn` is on you to interpret.
+    const hasFail = checks.some((c) => c.status === "fail");
+    process.exit(hasFail ? 1 : 0);
+}
+// ---------- check primitives ----------
+function readPathCliVersion() {
+    // Use --version (mapped to -v in 0.3.1+); fall back to -V which still
+    // works on older releases.
+    for (const flag of ["--version", "-V"]) {
+        const r = spawnSync("memarium", [flag], {
+            encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 3000,
+        });
+        if (r.status === 0)
+            return r.stdout.trim();
+    }
+    return null;
+}
+/**
+ * Walk every PATH directory and return each `memarium` binary found plus its
+ * --version output. Multi-install footgun: a user can have npm installed
+ * to both Homebrew's npm prefix (/opt/homebrew/lib/node_modules/) AND nvm's
+ * (~/.nvm/versions/node/<v>/lib/node_modules/) at the same time. `memarium
+ * upgrade` installs to whichever npm is on PATH first, but the shell
+ * resolves `memarium` by PATH order — so users routinely upgrade one
+ * install while continuing to run the other. Bit Yue twice on 2026-05-25.
+ */
+function listAllPathInstalls() {
+    const pathDirs = (process.env.PATH ?? "").split(":").filter(Boolean);
+    const seen = new Set();
+    const out = [];
+    for (const dir of pathDirs) {
+        const abs = join(dir, "memarium");
+        if (seen.has(abs) || !existsSync(abs))
+            continue;
+        seen.add(abs);
+        // Resolve symlink target so two PATH entries pointing at the same
+        // physical binary collapse into one row.
+        let real = abs;
+        try {
+            real = realpathSync(abs);
+        }
+        catch { /* fall through */ }
+        if (seen.has(real))
+            continue;
+        seen.add(real);
+        const r = spawnSync(abs, ["--version"], {
+            encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 3000,
+        });
+        out.push({ path: abs, version: r.status === 0 ? r.stdout.trim() : null });
+    }
+    return out;
+}
+function readNpmLatestVersion() {
+    const r = spawnSync("npm", ["view", "memarium", "version"], {
+        encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 5000,
+    });
+    if (r.status !== 0)
+        return null;
+    const v = r.stdout.trim();
+    return v || null;
+}
+function readConfigSafe() {
+    const path = join(homedir(), ".memarium", "config.json");
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function countResidue(repoPath) {
+    const root = join(repoPath, "raw_sessions");
+    if (!existsSync(root))
+        return { rawJsonCount: 0, jsonlCount: 0 };
+    let rawJsonCount = 0;
+    let jsonlCount = 0;
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const p = join(dir, e.name);
+            if (e.isDirectory()) {
+                walk(p);
+                continue;
+            }
+            if (!e.isFile())
+                continue;
+            if (e.name.endsWith(".raw.json"))
+                rawJsonCount++;
+            else if (e.name.endsWith(".jsonl"))
+                jsonlCount++;
+        }
+    };
+    walk(root);
+    return { rawJsonCount, jsonlCount };
+}
+function readMemexVersion() {
+    const r = spawnSync("memex", ["--version"], {
+        encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 3000,
+    });
+    if (r.status !== 0)
+        return null;
+    return r.stdout.trim() || null;
+}
+/** Resolve a git ref to a commit sha in `dir` (which shares .git with the
+ *  session repo). Null when the ref doesn't resolve / not a repo. Offline-safe:
+ *  reads local refs only, no network. */
+function gitRevParse(dir, ref) {
+    const r = spawnSync("git", ["-C", dir, "rev-parse", "--verify", "--quiet", `${ref}^{commit}`], {
+        encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 3000,
+    });
+    if (r.status !== 0)
+        return null;
+    return (r.stdout ?? "").trim() || null;
+}

package/dist/src/commands/init-wizard.js

@@ -0,0 +1,201 @@
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+import chalk from "chalk";
+import { prompt, promptYesNo, closePrompts } from "../prompts.js";
+import { materializeRepoAtPath, expandHome } from "../git-ops.js";
+import { writeConfig, configExists, DEFAULT_THREADING_CONCURRENCY, DEFAULT_THREADING_MAX_ATTEMPTS, } from "../config.js";
+import { deviceBranchFromHostname, isStableDeviceName } from "../device.js";
+/**
+ * Returns the path the wizard will use when the user skips the path question.
+ * Fixed at `~/.memarium/session-repo` so the /memarium skill can detect
+ * "global mode" by cwd-equality without per-user configuration.
+ */
+export function defaultLocalPath() {
+    return join(homedir(), ".memarium", "session-repo");
+}
+/**
+ * Run the interactive wizard. Returns answers; caller owns writing config +
+ * materializing the repo. Throws on user-invalid input that the loops can't
+ * recover from (caller catches and exits non-zero).
+ */
+export async function runWizard() {
+    console.log(chalk.bold("\nmemarium init wizard\n"));
+    // Q0: sync to remote?
+    const syncToRemote = await promptYesNo(chalk.cyan("Q0") + " Sync to a remote git repo (GitHub etc.)? Choose 'no' for local-only.", true);
+    let repoUrl = "";
+    let localPath = defaultLocalPath();
+    if (syncToRemote) {
+        // Q1: repo URL
+        repoUrl = await prompt(chalk.cyan("Q1") + " Private git repo URL (e.g. git@github.com:you/work-memory.git)");
+        if (!repoUrl)
+            throw new Error("repo URL is required");
+        // Q2: local path
+        const rawPath = await prompt(chalk.cyan("Q2") + ` Where should the repo live locally? (recommend the default — the /memarium skill detects "global mode" by this exact path)`, localPath);
+        localPath = resolve(expandHome(rawPath));
+    }
+    else {
+        console.log(chalk.gray("  local-only mode: no remote URL, no push."));
+    }
+    // Q5 / Q6 / Q7 dropped in 0.6.1:
+    //   - Q6 (enable CI aggregation): now defaults true when sync-to-remote
+    //     (the CI workflow is small + universally useful; escape hatch is
+    //     editing config.json's enableAggregateCI: false post-init).
+    //   - Q7 (include reasoning): always true in 0.6+ — reasoning blocks are
+    //     part of the context.md by design; truncation handles size.
+    //   (v0.1 had a "claude model" question here. Removed in v0.2 because the
+    //   LLM lives entirely in the user's Claude Code session now.)
+    //   (v0.5: Q5 "digest enabled" and the original Q8 "recommend memex"
+    //   dropped.)
+    const enableAggregateCI = syncToRemote;
+    // Q6 (was Q8 pre-0.6.1): device branch name. hostname() drifts on macOS
+    // (mDNS in home wifi, DHCP-given names on corp VPN, hotspot etc.) — each
+    // network creates a new device branch, fragmenting the spool. We strip
+    // common volatile suffixes (.local / .lan) from the default and warn if
+    // the cleaned name still looks volatile.
+    const hostnameDefault = stripVolatileSuffixes(deviceBranchFromHostname());
+    const stableLooking = isStableDeviceName(hostnameDefault);
+    const stableHint = stableLooking
+        ? "current hostname looks stable, can keep"
+        : "WARNING: current hostname looks like macOS drift (e.g. DHCP) — recommend overriding with a physical label like 'mini2' or 'work-laptop'";
+    const deviceBranch = (await prompt(chalk.cyan("Q6") + ` Stable device name for this machine's git branch? (${stableHint})`, hostnameDefault)).trim() || hostnameDefault;
+    return { repoUrl, localPath, enableAggregateCI, deviceBranch };
+}
+/** Strip common macOS-volatile suffixes from a hostname-derived branch name.
+ *  `Mac-mini-2.local` → `Mac-mini-2`; `MIS-EV2-BB1.surfacescenarios.org` →
+ *  `MIS-EV2-BB1` (the FQDN suffix is irrelevant for memarium's purposes; the
+ *  identifying part of a personal machine name is the bare hostname). */
+export function stripVolatileSuffixes(name) {
+    return name
+        .replace(/\.local$/i, "")
+        .replace(/\.lan$/i, "")
+        // Strip first .<dotted-suffix> on FQDN-shaped names; preserves multi-dot
+        // user-provided names like "yue.mini.2" by only touching the case where
+        // the suffix contains letters (DNS-style).
+        .replace(/\.[a-z][a-z0-9.-]*$/i, "");
+}
+/**
+ * Materialize repo + write config. Pure I/O, separated so wizard logic stays
+ * unit-testable.
+ */
+export async function applyWizardAnswers(a) {
+    if (a.repoUrl) {
+        let mat;
+        try {
+            mat = await materializeRepoAtPath(a.localPath, a.repoUrl);
+        }
+        catch (err) {
+            // Plugin-first scenario: the user installed memarium-plugin before
+            // the npm CLI, so ~/.memarium/session-repo/ is non-empty (book/,
+            // raw_sessions/) but not a git repo. Offer to adopt it in place
+            // rather than asking the user to `rm -rf` their plugin data.
+            const msg = err.message;
+            if (msg.includes("is not empty and is not a git repo")) {
+                const adopt = await promptYesNo(chalk.yellow(`\n  ${a.localPath} has data in it but isn't a git repo (looks like\n` +
+                    `  memarium-plugin wrote it before the npm CLI was installed).\n` +
+                    `  Adopt this directory: 'git init' + add origin '${a.repoUrl}' + create\n` +
+                    `  branch '${a.deviceBranch}' with your existing files as its first commit?\n` +
+                    `  (Nothing on disk is deleted or moved.)`), true);
+                if (!adopt)
+                    throw err;
+                const { adoptPluginDir } = await import("../git-ops.js");
+                mat = await adoptPluginDir(a.localPath, a.repoUrl, a.deviceBranch);
+                console.log(chalk.gray(`  adopted ${a.localPath} into new repo on branch '${a.deviceBranch}'`));
+            }
+            else {
+                throw err;
+            }
+        }
+        if (mat.kind === "existing" && mat.existingRemote && mat.existingRemote !== a.repoUrl) {
+            console.log(chalk.yellow(`  warning: ${a.localPath} already has remote '${mat.existingRemote}', not '${a.repoUrl}'. Using existing.`));
+        }
+        else if (mat.kind === "cloned") {
+            console.log(chalk.gray(`  cloned ${a.repoUrl} -> ${a.localPath}`));
+        }
+        else if (mat.kind === "existing") {
+            console.log(chalk.gray(`  using existing repo at ${a.localPath}`));
+        }
+        // "adopted" already logged inline above.
+    }
+    else {
+        // Local-only mode: ensure the path exists as a plain git repo (no remote).
+        const { mkdirSync, existsSync } = await import("node:fs");
+        const { join } = await import("node:path");
+        const { simpleGit } = await import("simple-git");
+        mkdirSync(a.localPath, { recursive: true });
+        if (!existsSync(join(a.localPath, ".git"))) {
+            await simpleGit(a.localPath).init();
+            console.log(chalk.gray(`  initialized local-only git repo at ${a.localPath}`));
+        }
+        else {
+            console.log(chalk.gray(`  using existing repo at ${a.localPath}`));
+        }
+    }
+    const cfg = {
+        repoPath: a.localPath,
+        repoUrl: a.repoUrl,
+        deviceBranch: a.deviceBranch,
+        runner: "claude-cli",
+        enableAggregateCI: a.enableAggregateCI,
+        // 0.6+: reasoning blocks are always rendered into context.md (they're
+        // part of the content-block stream by design; truncation handles size).
+        // The schema retains the field but the wizard no longer asks; default true.
+        includeReasoning: true,
+        threadingConcurrency: DEFAULT_THREADING_CONCURRENCY,
+        threadingMaxAttempts: DEFAULT_THREADING_MAX_ATTEMPTS,
+        // digestEnabled retained at schema default (true) for downstream
+        // consumers; the wizard no longer prompts for it (v0.5).
+        digestEnabled: true,
+        // bookLocale defaults to "en" via schema; we set it inline to satisfy
+        // the strict TypeScript Config type, which doesn't see through z.default().
+        bookLocale: "en",
+    };
+    writeConfig(cfg);
+    console.log(chalk.green("\n✓ memarium configured."));
+    console.log(chalk.gray(`  Config: ~/.memarium/config.json`));
+    if (!a.repoUrl) {
+        console.log(chalk.cyan(`  local-only mode: sessions stay on this machine. To enable sync later, edit ~/.memarium/config.json and set "repoUrl".`));
+        return;
+    }
+    console.log("");
+    console.log(chalk.cyan("Try on this machine:"));
+    console.log("  memarium sync                    # extract local sessions + push to your device branch");
+    console.log("");
+    console.log(chalk.cyan("On ANOTHER machine after memarium init + memarium sync:"));
+    console.log("  memarium list-sessions --since 7d        # see what's synced from elsewhere");
+    console.log("  cd <project-dir> && memarium resume <id> # spawn claude with that prior session's context");
+    console.log("");
+    console.log(chalk.cyan("For digest + recall (chronicles, topics, bookmark recall):"));
+    console.log(chalk.gray("  Install the Claude Code plugin:"));
+    console.log("    /plugin marketplace add june9593/memarium-plugin");
+    console.log("    /plugin install memarium");
+    if (a.enableAggregateCI) {
+        console.log("");
+        console.log(chalk.cyan("Installing CI aggregation workflow on origin/main..."));
+        try {
+            const { workflowInitCmd } = await import("./workflow.js");
+            await workflowInitCmd({});
+        }
+        catch (err) {
+            console.log(chalk.yellow(`! workflow auto-install failed: ${err.message}`));
+            console.log(chalk.gray(`  You can retry later with: memarium workflow init`));
+        }
+    }
+}
+/** Top-level entry — composes wizard + apply, with cleanup. */
+export async function runInitWizard() {
+    if (configExists()) {
+        const overwrite = await promptYesNo(chalk.yellow("memarium already initialized at ~/.memarium/config.json. Overwrite?"), false);
+        if (!overwrite) {
+            console.log(chalk.gray("aborted"));
+            closePrompts();
+            return;
+        }
+    }
+    try {
+        const answers = await runWizard();
+        await applyWizardAnswers(answers);
+    }
+    finally {
+        closePrompts();
+    }
+}

package/dist/src/commands/init.js

@@ -0,0 +1,45 @@
+import { writeConfig, DEFAULT_THREADING_CONCURRENCY, DEFAULT_THREADING_MAX_ATTEMPTS } from "../config.js";
+import { materializeRepoAtPath } from "../git-ops.js";
+import { deviceBranchFromHostname } from "../device.js";
+import { join } from "node:path";
+import chalk from "chalk";
+/** Wizard mode kicks in when caller passed no flags AND no repoUrl. */
+function isFlagMode(opts) {
+    return Boolean(opts.repoUrl || opts.localPath || opts.device || opts.digestEnabled === false);
+}
+export async function initCmd(opts) {
+    if (!isFlagMode(opts)) {
+        // No flags → interactive wizard.
+        const { runInitWizard } = await import("./init-wizard.js");
+        await runInitWizard();
+        return;
+    }
+    // Flag mode: non-interactive.
+    if (!opts.repoUrl) {
+        throw new Error("repoUrl is required in flag mode (or run `memarium init` with no args for the wizard)");
+    }
+    const localPath = opts.localPath ?? join(process.cwd(), ".memarium", "repo");
+    const mat = await materializeRepoAtPath(localPath, opts.repoUrl);
+    if (mat.kind === "existing" && mat.existingRemote && mat.existingRemote !== opts.repoUrl) {
+        console.log(chalk.yellow(`warning: ${localPath} already has remote '${mat.existingRemote}', not '${opts.repoUrl}'. Using existing.`));
+    }
+    const cfg = {
+        repoPath: localPath,
+        repoUrl: opts.repoUrl,
+        deviceBranch: opts.device ?? deviceBranchFromHostname(),
+        runner: "claude-cli",
+        enableAggregateCI: false,
+        includeReasoning: true,
+        threadingConcurrency: DEFAULT_THREADING_CONCURRENCY,
+        threadingMaxAttempts: DEFAULT_THREADING_MAX_ATTEMPTS,
+        digestEnabled: opts.digestEnabled !== false,
+        bookLocale: "en",
+    };
+    writeConfig(cfg);
+    console.log(chalk.green(`memarium initialized:`));
+    console.log(`  repo: ${localPath}`);
+    console.log(`  remote: ${opts.repoUrl}`);
+    console.log(`  device branch: ${cfg.deviceBranch}`);
+    console.log(`  digest enabled: ${cfg.digestEnabled}`);
+    console.log(chalk.cyan(`\n  next: memarium sync  →  open Claude Code  →  /memarium`));
+}

package/dist/src/commands/list.js

@@ -0,0 +1,19 @@
+import chalk from "chalk";
+import { readConfig } from "../config.js";
+import { loadIndex } from "../index-store.js";
+export async function listCmd(opts) {
+    const cfg = readConfig();
+    const idx = loadIndex(cfg.repoPath);
+    const rows = Object.values(idx.entries)
+        .filter((e) => !opts.tool || e.tool === opts.tool)
+        .filter((e) => !opts.project || e.project === opts.project)
+        .sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+    if (rows.length === 0) {
+        console.log(chalk.gray("(no sessions)"));
+        return;
+    }
+    for (const e of rows) {
+        const date = e.startedAt.slice(0, 10);
+        console.log(`${chalk.gray(date)}  ${chalk.cyan(e.tool)}  ${chalk.yellow(e.project)}  ${e.displayName}  ${chalk.gray(e.shortId)}`);
+    }
+}