waku-memory 0.1.0 → 0.2.0

package/dist/capture.js

@@ -13,63 +13,88 @@
 // "y" before anything else happens, including asking for a key.
 //
 // Zero dependencies, per the shim's package.json: only node:fs, node:path
-// and node:util (all built in) below.
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+// and node:util (all built in) below, one constant from hook.ts -- the
+// process budget the SessionEnd entry installs, which hook.ts's own network
+// budget has to fit under -- and, since task 13, the bootstrap module (spec
+// 011 §8): the third question's scan/render/parse (task 12) and send (task
+// 13) all live in bootstrap.ts, so enable() below only orchestrates them.
+// hook.ts imports nothing from here in return; bootstrap.ts imports from
+// hook.ts (the watermark rule) but nothing from this file either.
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
-// The marker every hook command this tool writes contains, and the only
-// thing removeHookSettings uses to tell "ours" from a foreign hook on the
-// same event. Deliberately just the tail of the real command (not the full
-// "npx -y waku-memory hook" string) so a hand-edited variant --
-// different flags, a pinned version -- is still recognized as ours.
-export const WAKU_HOOK_MARKER = 'waku-memory hook';
-// No separate script file to install, version, or leave stale (spec 005):
-// every event runs the shim package itself via npx. `-y` skips npm's
-// install-confirmation prompt, which would otherwise hang a hook that has
-// no terminal to answer it.
-const WAKU_HOOK_COMMAND = `npx -y ${WAKU_HOOK_MARKER}`;
-// Must match hook.ts's own (unexported) CONFIG_FILE_NAME -- the two files
-// agree on this only by convention, not by import, because hook.ts is
-// deliberately dependency-free of this file (it is the piece that runs
-// unattended on every turn; this is the piece a human runs once).
-const CONFIG_FILE_NAME = 'config.json';
+import { LIVE_WINDOW_MS, parseBootstrapAnswer, renderBootstrapList, runBootstrap, scanClaudeCode, } from "./bootstrap.js";
+import { CONFIG_FILE_NAME, SESSION_END_HOOK_TIMEOUT_S } from "./hook.js";
 // `Stop` is where captured content is actually sent -- "async": true so it
 // runs in the background without blocking the turn (600s default budget,
-// research doc §2). `SessionStart` posts the liveness heartbeat on the same
-// fire-and-forget basis. `SessionEnd` is the flush: all SessionEnd hooks
-// share a 1.5s-by-default exit budget (raisable only to 60s) and cannot
-// block Claude Code's own exit -- hook.ts's SESSION_END_TIMEOUT_MS comment
-// has the measured detail -- so it carries a `timeout` instead of `async`.
-// `async` only affects whether a hook keeps running after Claude Code moves
-// on; for an event that already cannot block exit, that distinction does
-// not apply, so it is left off rather than set to a value the harness
-// ignores anyway (pinned by the given test's `sessionEnd.async === undefined`).
-const HOOK_EVENTS = {
-    Stop: { type: 'command', command: WAKU_HOOK_COMMAND, async: true },
-    SessionStart: { type: 'command', command: WAKU_HOOK_COMMAND, async: true },
-    SessionEnd: { type: 'command', command: WAKU_HOOK_COMMAND, timeout: 10 },
-};
+// research doc §2). `SessionStart` is synchronous instead, with a 5s
+// timeout and a matcher naming the five events worth a brief: its stdout is
+// printed straight into the session as context (spec 011 §6, task 9), which
+// is exactly why it can no longer be fire-and-forget the way 0.1.x had it.
+// `SessionEnd` is the flush: all SessionEnd hooks share a 1.5s-by-default
+// exit budget and cannot block Claude Code's own exit, so it carries a
+// `timeout` instead of `async` -- raised to SESSION_END_HOOK_TIMEOUT_S
+// seconds, the process budget hook.ts's own network budget is derived from
+// (its SESSION_END_TIMEOUT_MS comment has the measured detail). `async`
+// only affects whether a hook keeps running after Claude Code moves on; for
+// an event that already cannot block exit, that distinction does not
+// apply, so it is left off rather than set to a value the harness ignores
+// anyway (pinned by the given test's `sessionEnd.async === undefined`).
+const SESSION_START_MATCHER = 'startup|resume|clear|compact|fork';
+function hookEvents(run) {
+    const base = run.args
+        ? { type: 'command', command: run.command, args: run.args }
+        : { type: 'command', command: run.command };
+    return {
+        Stop: { hooks: [{ ...base, async: true }] },
+        SessionStart: { matcher: SESSION_START_MATCHER, hooks: [{ ...base, timeout: 5 }] },
+        SessionEnd: { hooks: [{ ...base, timeout: SESSION_END_HOOK_TIMEOUT_S }] },
+    };
+}
+// Ours in either form: a shell command that names the package and ends
+// with the subcommand (0.1.x), or an exec-form entry whose last argument is
+// `hook` and whose script lives under a `.waku-memory/hook/` directory.
+// Deliberately not a single marker constant checked against one field
+// anymore -- the exec form has no one field that both names the package and
+// the subcommand the way the 0.1.x shell string did, so recognising it
+// needs its own arm.
+export function isOwnEntry(entry) {
+    // settings.json is only validated as a top-level plain object
+    // (readClaudeSettings's own comment) -- anything inside `hooks` is
+    // whatever some other tool wrote there, so `command` and `args` are
+    // `unknown` in practice despite what HookCommandEntry claims at compile
+    // time. An entry this cannot prove is shaped the way ours would be is
+    // never ours: false, not a thrown TypeError (final review M1 -- a real
+    // exec-form entry with a non-string argument used to throw out of here,
+    // reaching mergeHookSettings, reaching enable() *after* config.json is
+    // already written).
+    if (typeof entry.command !== 'string')
+        return false;
+    if (entry.args !== undefined) {
+        if (!Array.isArray(entry.args) || entry.args.some((a) => typeof a !== 'string'))
+            return false;
+        const args = entry.args;
+        return args[args.length - 1] === 'hook' && args.some((a) => a.replace(/\\/g, '/').includes('/.waku-memory/hook/'));
+    }
+    return entry.command.includes('waku-memory') && entry.command.trimEnd().endsWith(' hook');
+}
 // A group is "ours" only if every hook inside it is ours -- mergeHookSettings
 // only ever writes single-hook groups, so in practice this means exactly
-// one hook whose command carries the marker, but the "every" check (rather
-// than "some") is what makes removeHookSettings's contract exact: it must
-// never delete a group that also carries someone else's hook.
+// one hook isOwnEntry recognises, but the "every" check (rather than
+// "some") is what makes removeHookSettings's contract exact: it must never
+// delete a group that also carries someone else's hook.
 function isOwnGroup(group) {
-    return group.hooks.length > 0 && group.hooks.every((h) => h.command.includes(WAKU_HOOK_MARKER));
+    return group.hooks.length > 0 && group.hooks.every(isOwnEntry);
 }
-// Appends one group per event in HOOK_EVENTS, skipping any event that
-// already carries one of ours -- running `enable` twice must not duplicate
-// entries (pinned by the brief's idempotence test and this file's "running
-// twice" orchestration test). A foreign group already on the same event is
-// never inspected beyond isOwnGroup's check and is never reordered or
-// rewritten -- only ours is ever added.
-export function mergeHookSettings(existing) {
+// Replaces any group of ours on each event -- an older version's entry, in
+// either form -- with one built from `run`, and keeps every foreign group
+// untouched. Idempotent: merging the same invocation twice yields the same
+// settings (pinned below), which is what makes running `enable` again, on
+// the same version, safe.
+export function mergeHookSettings(existing, run) {
     const hooks = { ...(existing.hooks ?? {}) };
-    for (const [event, entry] of Object.entries(HOOK_EVENTS)) {
-        const groups = hooks[event] ?? [];
-        if (!groups.some(isOwnGroup)) {
-            hooks[event] = [...groups, { hooks: [entry] }];
-        }
+    for (const [event, group] of Object.entries(hookEvents(run))) {
+        hooks[event] = [...(hooks[event] ?? []).filter((g) => !isOwnGroup(g)), group];
     }
     return { ...existing, hooks };
 }
@@ -94,14 +119,86 @@ export function removeHookSettings(existing) {
     }
     return { ...existing, hooks };
 }
-// The exact two sentences spec 005's "Disclosure" section requires, shown
-// at the moment that discharges status.md item 9's obligation for capture:
-// "before anyone outside the three of us is invited, and no later than the
-// day a worker is deployed, they need to be told the environment can lose
-// their data and that importing [or capturing] sends its contents to
-// Anthropic." Both facts, two sentences, nothing softened.
+// Copies the shim's own compiled dist/*.js, next to a one-line ESM
+// package.json, into a version-numbered directory under configDir --
+// installed rather than run via npx (2.5s per hook, measured, on top of
+// SessionStart now being synchronous and printing: spec 011 §6) and
+// versioned rather than a single fixed path so an in-flight hook from the
+// previous version is never overwritten mid-run by the next `enable`
+// (pruneHookCopies below cleans up once settings.json has moved on).
+// A no-op when sourceDir already *is* the copy -- enable() re-run from
+// inside an already-installed copy has nothing left to do.
+export function installHookCopy(sourceDir, configDir, version) {
+    const target = join(configDir, 'hook', version);
+    const indexPath = join(target, 'index.js').replace(/\\/g, '/'); // Claude Code spawns this directly -- see hookInvocation
+    if (resolve(sourceDir) === resolve(target))
+        return indexPath;
+    mkdirSync(target, { recursive: true });
+    for (const name of readdirSync(sourceDir)) {
+        if (name.endsWith('.js'))
+            copyFileSync(join(sourceDir, name), join(target, name));
+    }
+    writeFileSync(join(target, 'package.json'), '{"type":"module"}\n', 'utf8'); // dist/*.js is ESM
+    return indexPath;
+}
+// After settings.json points only at `keep`, every other copy under
+// configDir/hook is stale disk. A directory Windows refuses to delete
+// (EBUSY: an old hook process still running) is reported and left for the
+// next enable to retry -- the entries already point elsewhere, so a copy
+// left behind here is wasted space, never a wrong hook running.
+export function pruneHookCopies(configDir, keep) {
+    const root = join(configDir, 'hook');
+    let names;
+    try {
+        names = readdirSync(root);
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        if (name === keep)
+            continue;
+        try {
+            rmSync(join(root, name), { recursive: true, force: true });
+        }
+        catch (err) {
+            console.error(`Could not remove the old hook copy ${join(root, name)} -- ${err.message}. ` +
+                `It will be removed by the next "capture enable".`);
+        }
+    }
+}
+// Exec form (spec 011 §6): Claude Code spawns command/args directly, no
+// shell. The command is the Node that ran `enable`, by absolute path, not
+// the bare word "node" -- Claude Code ships no Node of its own and a
+// launcher's PATH is not guaranteed to have one on it either.
+export function hookInvocation(execPath, indexPath) {
+    return { command: execPath.replace(/\\/g, '/'), args: [indexPath, 'hook'] };
+}
+// The first two sentences are spec 005's "Disclosure" section, shown at the
+// moment that discharges status.md item 9's obligation for capture: "before
+// anyone outside the three of us is invited, and no later than the day a
+// worker is deployed, they need to be told the environment can lose their
+// data and that importing [or capturing] sends its contents to Anthropic."
+// Both facts, two sentences, nothing softened.
+//
+// The next three sentences are spec 011 §9 (A15, task 14), added because
+// "captured content is sent" on its own reads as "everything on this
+// machine is sent" -- not true, and the gap matters enough to name: typed
+// text, replies and tool names go; the files an agent reads and the
+// commands it runs stay local *unless the agent's own reply quotes them
+// back* (the one path by which their content can still leave, so the
+// carve-out has to say so rather than imply a cleaner boundary than the
+// hook actually draws); reasoning is never sent, full stop. The last
+// sentence previews enable()'s own third question (task 13, spec 011 §8):
+// "the next question" is literal, not rhetorical -- renderBootstrapList
+// (bootstrap.ts) is the list it points at, printed immediately after this
+// disclosure and the "y" it gates, before that question is ever asked.
 export const DISCLOSURE = 'Captured content is sent to our servers and to Anthropic for extraction. ' +
-    'This is an alpha whose data can be lost.';
+    'This is an alpha whose data can be lost. ' +
+    'What you type, what the agent replies, and the names of the tools it uses are sent; ' +
+    'the files it reads and the commands it runs are not, except where the agent quotes them in its reply, ' +
+    'and its reasoning is never sent. ' +
+    'Enabling can also import the memory and history Claude Code already keeps here; the next question lists exactly what.';
 // Exported so cli.ts's usage text can point at the same URL without a
 // second copy of it drifting out of sync.
 //
@@ -140,6 +237,102 @@ function readClaudeSettings(settingsPath) {
         return undefined;
     }
 }
+// Only printable ASCII can be part of a bearer key. Non-printable
+// characters at either *end* came from the terminal, not the person: on
+// 2026-09-04 a Windows console delivered Ctrl+V's own control code (0x16)
+// ahead of the key, `.trim()` left it in place, and every hook call then
+// failed with an opaque "fetch failed" (undici refusing the Authorization
+// header). Whitespace and non-ASCII (an IME's full-width space, say) are
+// stripped from the ends for the same reason.
+//
+// Anything non-printable left *inside* is a different thing: the paste
+// held more than the key ("Bearer mem_sk_..."), and stripping it would
+// glue two tokens into one wrong key that looks right -- the 0.1.1 review
+// reproduced exactly that, with the next hook's 401 landing in a
+// background process nobody watches. So the interior count is returned,
+// not repaired, and askForKey refuses on it.
+export function sanitizeKey(raw) {
+    const printable = (c) => {
+        const code = c.charCodeAt(0);
+        return code >= 0x21 && code <= 0x7e;
+    };
+    const chars = [...raw];
+    let start = 0;
+    let end = chars.length;
+    while (start < end && !printable(chars[start]))
+        start++;
+    while (end > start && !printable(chars[end - 1]))
+        end--;
+    const kept = chars.slice(start, end);
+    return {
+        key: kept.join(''),
+        removed: chars.length - kept.length,
+        interior: kept.filter((c) => !printable(c)).length,
+    };
+}
+const KEY_ATTEMPTS = 3;
+// What every key minted at KEYS_PAGE_URL starts with (api_key_repository.py:
+// PREFIX + token_urlsafe(32)). A key without it is warned about, not
+// refused: the server's opinion is the only one that counts, and a refusal
+// here would make a future prefix change strand every user on this shim.
+const KEY_PREFIX = 'mem_sk_';
+// Asks up to KEY_ATTEMPTS times. null means the person never pasted anything
+// usable, and enable() then ends with the same "nothing was written"
+// guarantee that declining the disclosure carries. No branch below ever
+// prints the key or any part of it -- counts and a prefix only.
+async function askForKey(deps) {
+    for (let attempt = 1; attempt <= KEY_ATTEMPTS; attempt++) {
+        const raw = await deps.prompt(`Paste an API key from ${KEYS_PAGE_URL} (it is shown once, at mint time): `);
+        const { key, removed, interior } = sanitizeKey(raw);
+        if (interior > 0) {
+            console.log(`The pasted text has ${interior} character(s) inside it that cannot be part of a key -- ` +
+                `more than the key was pasted. Paste the key itself, nothing else.`);
+            continue;
+        }
+        if (key === '') {
+            if (attempt < KEY_ATTEMPTS) {
+                console.log('That did not contain a usable key -- paste the key itself, nothing else.');
+            }
+            continue;
+        }
+        if (removed > 0) {
+            console.log(`Removed ${removed} non-printable character(s) from the ends of the pasted key -- ` +
+                `a terminal can add Ctrl+V's own code ahead of what it pastes.`);
+        }
+        if (!key.startsWith(KEY_PREFIX)) {
+            console.log(`Note: the key does not start with ${KEY_PREFIX}, which every key minted at ${KEYS_PAGE_URL} does. ` +
+                `Saving it as pasted; if the hook reports 401, run this command again with a fresh key.`);
+        }
+        return key;
+    }
+    return null;
+}
+// A parsed BootstrapAnswer still carries `invalid`; runBootstrap's own
+// BootstrapSelection does not (its three real outcomes are `all`, `skip` and
+// `exclude`) -- askBootstrapSelection's own re-ask loop below is where a
+// still-invalid second answer becomes `skip`, so by the time this is called
+// that case has already been decided; this is a plain, total mapping, never
+// itself a decision point.
+function toSelection(answer) {
+    if (answer.kind === 'exclude')
+        return { kind: 'exclude', numbers: answer.numbers };
+    if (answer.kind === 'all')
+        return { kind: 'all' };
+    return { kind: 'skip' }; // 'skip', or a still-invalid second answer
+}
+// The third question, spec 011 §8: asks '> ' once, and on an invalid answer
+// prints the one-line hint and asks once more -- a second invalid answer is
+// treated as skip rather than asked a third time, the same "stop pestering
+// the person" reasoning A12's own parseBootstrapAnswer comment gives for
+// only ever re-asking once.
+async function askBootstrapSelection(projectCount, prompt) {
+    let answer = parseBootstrapAnswer(await prompt('> '), projectCount);
+    if (answer.kind === 'invalid') {
+        console.log('Enter, numbers, or n.');
+        answer = parseBootstrapAnswer(await prompt('> '), projectCount);
+    }
+    return toSelection(answer);
+}
 // The one gesture that turns capture on. Order is deliberate and each step
 // depends on the one before it having succeeded:
 //   1. refuse if Claude Code itself is not on this machine -- the directory
@@ -153,10 +346,37 @@ function readClaudeSettings(settingsPath) {
 //      including asking for the key, so declining costs the user nothing
 //      and asks for nothing;
 //   4. only then ask for the key;
-//   5. write config.json, then merge and write settings.json. Everything
-//      before this point (refusing, declining) writes nothing at all --
-//      that guarantee is real. This step itself is not atomic across the
-//      two files, though: config.json is committed to disk first, so a
+//   5. install a local copy of the shim under configDir/hook/<version> and
+//      run it for real -- verifyHook -- before anything is wired into
+//      settings.json. A copy that does not even start (a corrupted copy, a
+//      Node too old for it, ...) must never become the thing Claude Code
+//      calls on every turn, so a failed verification removes the copy this
+//      call made under configDir/hook/<version> (and configDir/hook itself,
+//      if that copy was the only thing under it) and refuses right here,
+//      before config.json or settings.json is ever touched. A refusal
+//      removes only a copy this call made, though: installHookCopy is a
+//      no-op when hookSourceDir already *is* configDir/hook/<version> --
+//      enable running from inside the copy already installed there, which
+//      is what hookSourceDir (derived from the running cli.js's own
+//      import.meta.url) gives once a copy is in place -- and then this call
+//      installed nothing, so a failed verification leaves that directory
+//      alone: it may be the very copy settings.json still points at from an
+//      earlier, successful enable, and it is not this call's to delete.
+//      installHookCopy's mkdirSync(..., { recursive: true }) creates every
+//      ancestor directory on the way down, though, so the one thing a
+//      first-ever run can still leave behind after refusing here is an
+//      empty configDir -- not removed, since it is the config directory
+//      itself, not anything this step wrote into it;
+//   6. write config.json, then merge and write settings.json with the
+//      now-verified invocation. Everything before this point (refusing,
+//      declining, a failed verification) writes nothing new to disk -- step
+//      5's own cleanup is what makes that true when a failed verification
+//      follows a real copy, down to the empty-configDir exception described
+//      there; when installHookCopy was instead a no-op, this call had
+//      nothing of its own to remove, and the pre-existing copy it leaves in
+//      place was never new. This step
+//      itself is not atomic across the two files, though: config.json is
+//      committed to disk first, so a
 //      failure on the settings.json write right after -- disk full, a
 //      permission error -- does leave a real credential saved with no
 //      hook actually installed, i.e. capture silently not active despite
@@ -166,7 +386,22 @@ function readClaudeSettings(settingsPath) {
 //      sets a nonzero exit code, so it is not silent; it fails toward
 //      "capture not enabled" rather than a consent bypass; and re-running
 //      `enable` repairs it, since writing config.json again is a plain
-//      overwrite (capture.test.mjs's "running twice" test).
+//      overwrite (capture.test.mjs's "running twice" test);
+//   7. prune every other hook/<version> copy now that settings.json points
+//      only at this one (pruneHookCopies) -- best-effort, never fatal, and
+//      only after the settings write so a prune failure can never leave
+//      settings.json pointing at a copy this step just deleted.
+//   8. when deps.bootstrap.enabled (task 13, spec 011 §8): scan the machine
+//      for Claude Code's own memory files and transcripts (scanClaudeCode)
+//      and, only if that scan found something, print the one numbered list
+//      and ask the third and last question. This runs after the hooks are
+//      wired in and verified, deliberately: bootstrap is additional value
+//      once capture itself is real, not a precondition for it, and its own
+//      failure (a bad answer, a network error inside runBootstrap) must
+//      never undo a successful enable -- so nothing below this point can
+//      turn 'enabled' into anything else. An empty scan (nothing found, no
+//      user CLAUDE.md) says so and asks nothing at all: the person who has
+//      nothing to import should not be asked whether to skip importing it.
 export async function enable(url, deps) {
     if (!existsSync(deps.claudeDir)) {
         console.error(`Claude Code not found at ${deps.claudeDir} -- install Claude Code first, then run ` +
@@ -186,7 +421,35 @@ export async function enable(url, deps) {
         console.log('Capture not enabled -- nothing was written.');
         return 'declined';
     }
-    const key = (await deps.prompt(`Paste an API key from ${KEYS_PAGE_URL} (it is shown once, at mint time): `)).trim();
+    const key = await askForKey(deps);
+    if (key === null) {
+        console.log('Capture not enabled -- no usable key was entered; nothing was written.');
+        return 'declined';
+    }
+    const indexPath = installHookCopy(deps.hookSourceDir, deps.configDir, deps.version);
+    const run = hookInvocation(deps.execPath, indexPath);
+    if (!deps.verifyHook(run)) {
+        // Undo the copy this call just installed -- but only if it made one.
+        // installHookCopy no-ops when hookSourceDir already *is* the target
+        // directory (enable re-run from inside the installed copy); deleting
+        // the target in that case would remove a pre-existing directory this
+        // call never wrote, possibly the very copy settings.json still points
+        // at from an earlier, successful enable.
+        if (resolve(deps.hookSourceDir) !== resolve(dirname(indexPath))) {
+            rmSync(dirname(indexPath), { recursive: true, force: true });
+            const hookRoot = join(deps.configDir, 'hook');
+            try {
+                if (readdirSync(hookRoot).length === 0)
+                    rmSync(hookRoot, { recursive: true, force: true });
+            }
+            catch {
+                // hookRoot is already gone -- nothing left to prune
+            }
+        }
+        console.error(`The hook entry did not run (${run.command} ${(run.args ?? []).join(' ')}) -- ` +
+            `nothing was written.`);
+        return 'refused';
+    }
     mkdirSync(deps.configDir, { recursive: true }); // first run: ~/.waku-memory may not exist yet
     const configPath = join(deps.configDir, CONFIG_FILE_NAME);
     // {mode: 0o600} is a request, not a guarantee: Windows has no POSIX
@@ -199,11 +462,43 @@ export async function enable(url, deps) {
     // atomic temp-file-plus-rename technique earns its complexity there, not
     // here.
     writeFileSync(configPath, JSON.stringify({ url, key }, null, 2) + '\n', { mode: 0o600 });
-    const merged = mergeHookSettings(existingSettings);
+    const merged = mergeHookSettings(existingSettings, run);
     deps.writeSettingsJson(deps.settingsPath, merged);
+    pruneHookCopies(deps.configDir, deps.version);
     console.log('');
     console.log(`Capture enabled -- wrote ${configPath} and merged hooks into ${deps.settingsPath}.`);
     console.log('Start a new Claude Code session to pick up the hooks.');
+    if (deps.bootstrap.enabled) {
+        const { windowDays } = deps.bootstrap;
+        const stateDir = join(deps.configDir, 'state');
+        const scan = scanClaudeCode(deps.claudeDir, stateDir, {
+            nowMs: Date.now(),
+            sinceMs: windowDays === null ? 0 : Date.now() - windowDays * 86_400_000,
+            liveWindowMs: LIVE_WINDOW_MS,
+            all: windowDays === null,
+        });
+        console.log('');
+        // renderBootstrapList already returns the one "nothing found" sentence
+        // for an empty scan (A12) -- reusing it here, rather than a second copy
+        // of that literal string, is what keeps the two from drifting apart.
+        // The question itself is skipped on exactly the same condition: a
+        // person with nothing to import should not be asked whether to skip it.
+        console.log(renderBootstrapList(scan, windowDays));
+        if (scan.projects.length > 0 || scan.userClaudeMd !== null) {
+            const selection = await askBootstrapSelection(scan.projects.length, deps.prompt);
+            const result = await runBootstrap(scan, selection, {
+                url,
+                key,
+                fetchImpl: deps.fetchImpl,
+                stateDir,
+                all: windowDays === null,
+            });
+            let line = `${result.memoryFiles} memory files queued, ${result.sessions} sessions queued in ${result.pieces} pieces`;
+            if (result.failed > 0)
+                line += `, ${result.failed} failed`;
+            console.log(line);
+        }
+    }
     return 'enabled';
 }
 // Removes exactly what enable() added and nothing else. Deliberately leaves