@lumoai/cli 1.39.0 → 1.41.0

package/dist/cli/src/index.js

@@ -45,7 +45,6 @@ const whoami_1 = require("./commands/whoami");
 const hook_1 = require("./commands/hook");
 const session_attach_1 = require("./commands/session-attach");
 const session_status_1 = require("./commands/session-status");
-const session_wrap_1 = require("./commands/session-wrap");
 const next_1 = require("./commands/next");
 const cost_1 = require("./commands/cost");
 const verify_1 = require("./commands/verify");
@@ -69,6 +68,8 @@ const memory_project_add_1 = require("./commands/memory-project-add");
 const memory_promote_1 = require("./commands/memory-promote");
 const memory_rm_1 = require("./commands/memory-rm");
 const memory_show_1 = require("./commands/memory-show");
+const memory_sync_1 = require("./commands/memory-sync");
+const memory_push_1 = require("./commands/memory-push");
 const task_artifact_add_1 = require("./commands/task-artifact-add");
 const task_criteria_set_1 = require("./commands/task-criteria-set");
 const task_criteria_list_1 = require("./commands/task-criteria-list");
@@ -264,13 +265,6 @@ session
     .command('status')
     .description('Show the task currently bound to this Claude Code session (or "no task" if none).')
     .action(wrap(() => (0, session_status_1.sessionStatus)()));
-session
-    .command('wrap')
-    .description('Session-end wrap-up: review the memories sedimented this session, vote which injected context fragments were actually used, and optionally flag the bound task blocked.')
-    .option('-y, --yes', 'Keep all memories without prompting (agent-friendly); does not auto-apply the blocked tag')
-    .option('--dry-run', 'Print the section drafts but do not mutate memories/tags or advance watermarks')
-    .option('--used <indices>', 'Mark which injected context fragments you actually used (1-based indices, comma/space separated; "none" for all-unused). Omit to skip recording.')
-    .action(wrap(options => (0, session_wrap_1.sessionWrap)(options)));
 const task = program
     .command('task')
     .description('Inspect tasks from the terminal');
@@ -523,6 +517,22 @@ memoryCmd
     .description('Delete a memory (hard delete). Requires --yes.')
     .option('--yes', 'Confirm deletion')
     .action(wrap((id, opts) => (0, memory_rm_1.memoryRm)(id, opts)));
+memoryCmd
+    .command('sync')
+    .description('Downsync team memory into the local Claude Code memory store (team/*.md + a managed MEMORY.md block). Only touches files it owns; never clobbers your own memory. Resolves the project from the bound session unless --project is given.')
+    .option('--project <ref>', 'Project to sync (name/slug/id); default = bound session')
+    .option('--dir <path>', 'Target memory dir (default: ~/.claude/projects/<cwd>/memory)')
+    .option('--dry-run', 'Print the reconcile plan without writing files')
+    .option('--clean', 'Remove every file + index block sync owns (full rollback)')
+    .option('--no-anchor-check', 'Skip code-anchor staleness detection (the post-sync check that flags memories referencing deleted files/symbols)')
+    .action(wrap((opts) => (0, memory_sync_1.memorySync)(opts)));
+memoryCmd
+    .command('push')
+    .description('Upsync locally-authored memories (<memory-dir>/outbox/*.json, each {category, content}) to the team via the existing create-project-memory pipeline. Pushed files are removed from the outbox on success.')
+    .option('--project <ref>', 'Project to push to (name/slug/id); default = bound session')
+    .option('--dir <path>', 'Memory dir (default: ~/.claude/projects/<cwd>/memory)')
+    .option('--dry-run', 'List what would be pushed without sending')
+    .action(wrap((opts) => (0, memory_push_1.memoryPush)(opts)));
 const milestoneCmd = program
     .command('milestone')
     .description('Inspect milestones from the terminal');

package/dist/cli/src/lib/anchor-staleness.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRepoProbe = createRepoProbe;
+exports.detectStaleCandidates = detectStaleCandidates;
+exports.reportStaleCandidates = reportStaleCandidates;
+exports.shouldRunAnchorCheck = shouldRunAnchorCheck;
+exports.runAnchorCheck = runAnchorCheck;
+const node_child_process_1 = require("node:child_process");
+const code_anchor_1 = require("../../../shared/src/code-anchor");
+/**
+ * Build an existence probe over the repo at `cwd`. Resolves against git-tracked
+ * state, never the dirty working tree, so an uncommitted local rename/branch
+ * cannot false-flag a team memory. Fails OPEN: if git is unavailable or the
+ * lookup errors, anchors are treated as still-existing (宁可放过 — never
+ * false-flag a good memory off a broken probe).
+ */
+function createRepoProbe(cwd) {
+    const tracked = new Set();
+    try {
+        const out = (0, node_child_process_1.execFileSync)('git', ['ls-files'], {
+            cwd,
+            encoding: 'utf8',
+            maxBuffer: 256 * 1024 * 1024,
+        });
+        for (const line of out.split('\n')) {
+            const p = line.trim();
+            if (p)
+                tracked.add(p);
+        }
+    }
+    catch {
+        // not a git repo / git missing — leave `tracked` empty → fail open below.
+    }
+    const ready = tracked.size > 0;
+    return {
+        fileExists: p => (ready ? tracked.has(p) : true),
+        symbolExists: name => {
+            if (!ready)
+                return true;
+            try {
+                // exit 0 = found. `-w` word-boundary, `-q` quiet, `-F` fixed string,
+                // `-e` so a name starting with '-' is never read as a flag.
+                (0, node_child_process_1.execFileSync)('git', ['grep', '-wqF', '-e', name], {
+                    cwd,
+                    stdio: 'ignore',
+                });
+                return true;
+            }
+            catch (err) {
+                // exit 1 = clean "no match" → absent; any other exit = probe error →
+                // fail open (treat as present) so we never false-flag on a git hiccup.
+                const status = err.status;
+                return status === 1 ? false : true;
+            }
+        },
+    };
+}
+/**
+ * Classify each synced memory and keep only the stale candidates (every anchor
+ * dead). Pure given the probe — the heavy lifting lives in
+ * {@link classifyMemoryStaleness}.
+ */
+function detectStaleCandidates(entries, probe) {
+    const out = [];
+    for (const e of entries) {
+        const verdict = (0, code_anchor_1.classifyMemoryStaleness)(e.body, probe);
+        if (verdict.stale) {
+            out.push({ memoryId: e.id, deadAnchors: verdict.deadAnchors });
+        }
+    }
+    return out;
+}
+/**
+ * Report stale candidates to the server's stale-anchors endpoint (bearer auth).
+ * No candidates → no network call. This is the ONLY server write the detection
+ * path makes; it records candidacy, never archives.
+ */
+async function reportStaleCandidates(base, token, projectId, candidates) {
+    if (candidates.length === 0)
+        return { ok: true, recorded: 0 };
+    const res = await fetch(`${base}/api/projects/${encodeURIComponent(projectId)}/memories/stale-anchors`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${token}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ candidates }),
+    });
+    if (!res.ok)
+        return { ok: false, status: res.status };
+    const data = (await res.json().catch(() => ({})));
+    return { ok: true, recorded: data.recorded };
+}
+/**
+ * Whether `memory sync` should run the anchor check. Skipped for an explicit
+ * `--no-anchor-check`, and for `--dry-run` / `--clean` (a preview or rollback
+ * must not write candidates to the server).
+ */
+function shouldRunAnchorCheck(options) {
+    if (options.anchorCheck === false)
+        return false;
+    if (options.dryRun || options.clean)
+        return false;
+    return true;
+}
+/**
+ * Orchestrate the check: build the repo probe, detect candidates over the synced
+ * entries, and report them. Best-effort — returns the candidate count and the
+ * report result; callers log and move on (never fail the sync over detection).
+ */
+async function runAnchorCheck(input) {
+    const probe = createRepoProbe(input.cwd);
+    const candidates = detectStaleCandidates(input.entries, probe);
+    const report = await reportStaleCandidates(input.base, input.token, input.projectId, candidates);
+    return { candidates, report };
+}

package/dist/cli/src/lib/apply-sync.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applySync = applySync;
+const local_memory_store_1 = require("./local-memory-store");
+const memory_reconcile_1 = require("./memory-reconcile");
+const managed_block_1 = require("./managed-block");
+const sync_throttle_1 = require("./sync-throttle");
+/**
+ * Apply a downsync bundle to the local memory dir. Owns only `root/team/*.md`
+ * and the MEMORY.md managed block; dev-authored files and out-of-block index
+ * content are never touched. `--clean` removes all owned files + the block;
+ * `--dry-run` computes the plan and writes nothing.
+ */
+function applySync(root, bundle, opts = {}) {
+    if (opts.clean) {
+        const owned = (0, local_memory_store_1.readOwned)(root);
+        if (!opts.dryRun) {
+            for (const o of owned)
+                (0, local_memory_store_1.removeEntry)(root, o.id);
+            (0, local_memory_store_1.writeIndex)(root, (0, managed_block_1.removeBlock)((0, local_memory_store_1.readIndex)(root)));
+            (0, sync_throttle_1.clearThrottleState)(root);
+        }
+        return {
+            added: [],
+            updated: [],
+            removed: owned.map(o => o.id),
+            skippedDrift: [],
+            noop: owned.length === 0,
+        };
+    }
+    const owned = (0, local_memory_store_1.readOwned)(root);
+    const plan = (0, memory_reconcile_1.diffSync)(owned, bundle.entries.map(e => ({ id: e.id, contentHash: e.contentHash })));
+    const byId = new Map(bundle.entries.map(e => [e.id, e]));
+    const summary = {
+        added: plan.add.map(a => a.id),
+        updated: plan.update.map(u => u.id),
+        removed: plan.remove,
+        skippedDrift: plan.skipDrift,
+        noop: plan.add.length === 0 &&
+            plan.update.length === 0 &&
+            plan.remove.length === 0,
+    };
+    if (opts.dryRun)
+        return summary;
+    for (const a of plan.add) {
+        const e = byId.get(a.id);
+        (0, local_memory_store_1.writeEntry)(root, e);
+    }
+    for (const u of plan.update) {
+        const e = byId.get(u.id);
+        (0, local_memory_store_1.writeEntry)(root, e);
+    }
+    for (const id of plan.remove)
+        (0, local_memory_store_1.removeEntry)(root, id);
+    // Index = every bundle entry's line (added/updated/unchanged/drift-skipped all
+    // still exist locally); removed ids are absent from the bundle so they drop out.
+    (0, local_memory_store_1.writeIndex)(root, (0, managed_block_1.upsertBlock)((0, local_memory_store_1.readIndex)(root), bundle.entries.map(e => e.indexLine)));
+    return summary;
+}

package/dist/cli/src/lib/claude-memory-dir.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveMemoryDir = resolveMemoryDir;
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+/**
+ * Resolve the local Claude Code memory directory for a project working dir.
+ * Claude Code stores per-project memory under
+ * `~/.claude/projects/<encoded-cwd>/memory/`, where the cwd is encoded by
+ * replacing path separators with `-` (e.g. `/Users/x/lumo` →
+ * `-Users-x-lumo`). The encoding lives ONLY here so a Claude Code change is a
+ * one-line fix; `lumo memory sync --dry-run` prints the resolved path so the
+ * dev can sanity-check it, and `--dir` overrides entirely.
+ */
+function resolveMemoryDir(cwd, home = (0, node_os_1.homedir)(), override) {
+    if (override)
+        return override;
+    const encoded = cwd.replace(/\//g, '-');
+    return (0, node_path_1.join)(home, '.claude', 'projects', encoded, 'memory');
+}

package/dist/cli/src/lib/hook-runner.js

@@ -13,6 +13,9 @@ const sanitize_1 = require("./sanitize");
 const agent_1 = require("./agent");
 const git_task_1 = require("./git-task");
 const transcript_usage_1 = require("./transcript-usage");
+const resolve_project_1 = require("./resolve-project");
+const resolve_bound_task_1 = require("./resolve-bound-task");
+const memory_auto_1 = require("./memory-auto");
 /**
  * Hard timeout for the hook POST. On timeout the request is aborted,
  * logged, and `runHook` exits 0 — Claude Code is never blocked beyond
@@ -329,6 +332,31 @@ async function runHookWithBody(path, body, agentToken) {
         finally {
             clearTimeout(timer);
         }
+        // LUM-551: upsync drain on session-wrap-equivalent hooks. The outbox-empty
+        // fast path inside autoUpsyncOnDrain means most `stop` events do zero
+        // network (and never resolve the project). Best-effort: a failure is
+        // logged, never thrown — the hook still exits 0.
+        if (path === 'session-end' ||
+            path === 'stop' ||
+            path === 'task-completed') {
+            try {
+                await (0, memory_auto_1.autoUpsyncOnDrain)({
+                    cwd: process.cwd(),
+                    base: (0, api_1.trimTrailingSlash)(apiUrl),
+                    token: creds.token,
+                    resolveProjectId: async () => {
+                        const bound = await (0, resolve_bound_task_1.resolveBoundTaskIdentifier)(apiUrl, creds.token);
+                        if (!bound)
+                            return null;
+                        const r = await (0, resolve_project_1.resolveBoundProjectId)(apiUrl, creds.token, bound);
+                        return r.ok ? r.id : null;
+                    },
+                });
+            }
+            catch (err) {
+                (0, hook_log_1.logHookError)(`[${path}] upsync`, err);
+            }
+        }
     }
     catch (err) {
         (0, hook_log_1.logHookError)(`[${path}] runner`, err);

package/dist/cli/src/lib/local-memory-store.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashBody = hashBody;
+exports.readOwned = readOwned;
+exports.writeEntry = writeEntry;
+exports.removeEntry = removeEntry;
+exports.readIndex = readIndex;
+exports.writeIndex = writeIndex;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_crypto_1 = require("node:crypto");
+const TEAM_DIR = 'team';
+const INDEX_FILE = 'MEMORY.md';
+function teamPath(root) {
+    return (0, node_path_1.join)(root, TEAM_DIR);
+}
+function hashBody(body) {
+    return (0, node_crypto_1.createHash)('sha256').update(body).digest('hex');
+}
+/**
+ * Parse the `lumo: { ... }` ownership marker. Returns null unless the file
+ * carries `source: team` — dev-authored files (no marker) are NOT owned and
+ * must never be touched by sync.
+ */
+function parseMarker(text) {
+    const m = text.match(/lumo:\s*\{([^}]*)\}/);
+    if (!m || !m[1])
+        return null;
+    const inner = m[1];
+    if (!/\bsource:\s*team\b/.test(inner))
+        return null;
+    const id = inner.match(/\bid:\s*([^,}\s]+)/)?.[1];
+    const contentHash = inner.match(/\bcontentHash:\s*([^,}\s]+)/)?.[1];
+    if (!id || !contentHash)
+        return null;
+    return { id, contentHash };
+}
+/** Body = everything after the closing frontmatter fence, minus the single
+ * trailing newline {@link writeEntry} appends (keeps write/read hashing symmetric). */
+function bodyOf(text) {
+    const end = text.indexOf('\n---\n');
+    const raw = end === -1 ? text : text.slice(end + 5);
+    return raw.replace(/\n$/, '');
+}
+/** Read every owned team file under `root/team/`, newest-id order. */
+function readOwned(root) {
+    const dir = teamPath(root);
+    if (!(0, node_fs_1.existsSync)(dir))
+        return [];
+    const out = [];
+    for (const f of (0, node_fs_1.readdirSync)(dir)) {
+        if (!f.endsWith('.md'))
+            continue;
+        const text = (0, node_fs_1.readFileSync)((0, node_path_1.join)(dir, f), 'utf8');
+        const marker = parseMarker(text);
+        if (!marker)
+            continue; // dev-authored → not owned
+        out.push({
+            id: marker.id,
+            contentHash: marker.contentHash,
+            diskHash: hashBody(bodyOf(text)),
+        });
+    }
+    return out.sort((a, b) => a.id.localeCompare(b.id));
+}
+function writeEntry(root, entry) {
+    const dir = teamPath(root);
+    if (!(0, node_fs_1.existsSync)(dir))
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(dir, `${entry.id}.md`), `${entry.frontmatter}\n${entry.body}\n`);
+}
+function removeEntry(root, id) {
+    const p = (0, node_path_1.join)(teamPath(root), `${id}.md`);
+    if ((0, node_fs_1.existsSync)(p))
+        (0, node_fs_1.rmSync)(p);
+}
+function readIndex(root) {
+    const p = (0, node_path_1.join)(root, INDEX_FILE);
+    return (0, node_fs_1.existsSync)(p) ? (0, node_fs_1.readFileSync)(p, 'utf8') : '';
+}
+function writeIndex(root, text) {
+    if (!(0, node_fs_1.existsSync)(root))
+        (0, node_fs_1.mkdirSync)(root, { recursive: true });
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(root, INDEX_FILE), text);
+}

package/dist/cli/src/lib/managed-block.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BLOCK_END = exports.BLOCK_START = void 0;
+exports.upsertBlock = upsertBlock;
+exports.removeBlock = removeBlock;
+exports.BLOCK_START = '<!-- lumo:team-memory:start (managed by `lumo memory sync` — do not edit inside) -->';
+exports.BLOCK_END = '<!-- lumo:team-memory:end -->';
+/**
+ * Replace the managed team-memory block in MEMORY.md with `lines`, leaving
+ * every byte OUTSIDE the markers untouched. If no block exists, append a fresh
+ * one at EOF (original content preserved verbatim as the prefix). This is the
+ * only writer allowed to touch MEMORY.md, and it never edits dev-authored
+ * index lines outside the markers.
+ */
+function upsertBlock(md, lines) {
+    const block = `${exports.BLOCK_START}\n${lines.join('\n')}\n${exports.BLOCK_END}`;
+    const s = md.indexOf(exports.BLOCK_START);
+    const e = md.indexOf(exports.BLOCK_END);
+    if (s !== -1 && e !== -1 && e > s) {
+        return md.slice(0, s) + block + md.slice(e + exports.BLOCK_END.length);
+    }
+    const sep = md.length === 0 ? '' : md.endsWith('\n') ? '\n' : '\n\n';
+    return `${md}${sep}${block}\n`;
+}
+/** Remove the managed block entirely (used by `--clean`). Bytes outside the
+ * markers are preserved. No-op if no block is present. */
+function removeBlock(md) {
+    const s = md.indexOf(exports.BLOCK_START);
+    const e = md.indexOf(exports.BLOCK_END);
+    if (s === -1 || e === -1 || e < s)
+        return md;
+    return md.slice(0, s) + md.slice(e + exports.BLOCK_END.length);
+}

package/dist/cli/src/lib/memory-auto.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoDownsyncOnAttach = autoDownsyncOnAttach;
+exports.autoUpsyncOnDrain = autoUpsyncOnDrain;
+const node_fs_1 = require("node:fs");
+const claude_memory_dir_1 = require("./claude-memory-dir");
+const apply_sync_1 = require("./apply-sync");
+const anchor_staleness_1 = require("./anchor-staleness");
+const upsync_1 = require("./upsync");
+const sync_throttle_1 = require("./sync-throttle");
+/**
+ * LUM-551 — best-effort auto-triggers for team-memory sync/push.
+ *
+ * Both orchestrators are CLI-local, total `try/catch` (never throw), and quiet.
+ * They reuse the existing sync/push/anchor primitives rather than adding a
+ * parallel path. `LUMO_DISABLE_MEMORY_AUTO` turns both off wholesale.
+ */
+function autoDisabled() {
+    return !!process.env.LUMO_DISABLE_MEMORY_AUTO;
+}
+/** Fetch the team-memory sync bundle for a project. Throws on a non-2xx. */
+async function fetchSyncBundle(base, token, projectId) {
+    const res = await fetch(`${base}/api/projects/${encodeURIComponent(projectId)}/memories/sync-bundle`, { headers: { Authorization: `Bearer ${token}` } });
+    if (!res.ok)
+        throw new Error(`sync-bundle HTTP ${res.status}`);
+    const { bundle } = (await res.json());
+    return bundle;
+}
+/**
+ * Attach-triggered best-effort downsync (LUM-551). Throttle-gated; swallows all
+ * errors into `{ error }`; NEVER throws. On a real sync it also runs the P4b
+ * anchor check (advisory) and records the throttle timestamp.
+ */
+async function autoDownsyncOnAttach(input) {
+    if (autoDisabled())
+        return { skipped: 'disabled' };
+    try {
+        const dir = (0, claude_memory_dir_1.resolveMemoryDir)(input.cwd, undefined, input.dir);
+        const state = (0, sync_throttle_1.readThrottleState)(dir);
+        if ((0, sync_throttle_1.isThrottled)(state, input.now, (0, sync_throttle_1.throttleHours)(), input.projectId)) {
+            return { skipped: 'throttled' };
+        }
+        const bundle = await fetchSyncBundle(input.base, input.token, input.projectId);
+        const summary = (0, apply_sync_1.applySync)(dir, bundle);
+        let anchorCandidates = 0;
+        try {
+            const { candidates, report } = await (0, anchor_staleness_1.runAnchorCheck)({
+                cwd: input.cwd,
+                base: input.base,
+                token: input.token,
+                projectId: input.projectId,
+                entries: bundle.entries,
+            });
+            if (report.ok)
+                anchorCandidates = candidates.length;
+        }
+        catch {
+            // anchor detection is advisory — never fail the sync over it
+        }
+        (0, sync_throttle_1.writeThrottleState)(dir, { lastSyncAt: input.now.toISOString(), projectId: input.projectId }, input.now);
+        return {
+            added: summary.added.length,
+            updated: summary.updated.length,
+            removed: summary.removed.length,
+            anchorCandidates,
+        };
+    }
+    catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}
+/**
+ * Lifecycle-hook upsync drain (LUM-551). Outbox-empty fast path FIRST (no
+ * network); only a non-empty outbox resolves the project and pushes. Reuses the
+ * `memory-push` semantics (POST → unlink on 2xx). NEVER throws.
+ */
+async function autoUpsyncOnDrain(input) {
+    if (autoDisabled())
+        return { skipped: 'disabled' };
+    try {
+        const dir = (0, claude_memory_dir_1.resolveMemoryDir)(input.cwd, undefined, input.dir);
+        const candidates = (0, upsync_1.collectUpsyncCandidates)(dir);
+        if (candidates.length === 0)
+            return { skipped: 'empty' };
+        const projectId = await input.resolveProjectId();
+        if (!projectId)
+            return { error: 'no resolvable project for upsync' };
+        const url = (0, upsync_1.projectMemoriesEndpoint)(input.base, projectId);
+        let pushed = 0;
+        for (const c of candidates) {
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${input.token}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ category: c.category, content: c.content }),
+            });
+            if (!res.ok)
+                continue;
+            try {
+                (0, node_fs_1.unlinkSync)(c.file);
+            }
+            catch {
+                // best-effort cleanup; a re-push is idempotent via reconcile-on-write
+            }
+            pushed++;
+        }
+        return { pushed };
+    }
+    catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}

package/dist/cli/src/lib/memory-content.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildMemoryContent = buildMemoryContent;
 exports.formatMemoryList = formatMemoryList;
-exports.formatMemoryReviewList = formatMemoryReviewList;
 // Category/field metadata + builders for the `lumo memory` commands.
 // Mirrors the four content shapes validated server-side by parseMemoryContent.
 const sanitize_1 = require("./sanitize");
@@ -24,7 +23,11 @@ function buildMemoryContent(category, flags) {
                 return { ok: false, error: '--trigger is required for category trap.' };
             if (!outcome)
                 return { ok: false, error: '--outcome is required for category trap.' };
-            return { ok: true, category: 'TRAP', content: { trigger, outcome, ...(workaround ? { workaround } : {}) } };
+            return {
+                ok: true,
+                category: 'TRAP',
+                content: { trigger, outcome, ...(workaround ? { workaround } : {}) },
+            };
         }
         case 'decision': {
             const what = trimmed(flags.what);
@@ -38,40 +41,73 @@ function buildMemoryContent(category, flags) {
             return {
                 ok: true,
                 category: 'DECISION',
-                content: { what, why, ...(alternatives ? { alternatives } : {}), ...(implications ? { implications } : {}) },
+                content: {
+                    what,
+                    why,
+                    ...(alternatives ? { alternatives } : {}),
+                    ...(implications ? { implications } : {}),
+                },
             };
         }
         case 'convention': {
             const rule = trimmed(flags.rule);
             const applies = trimmed(flags.applies);
             if (!rule)
-                return { ok: false, error: '--rule is required for category convention.' };
+                return {
+                    ok: false,
+                    error: '--rule is required for category convention.',
+                };
             if (!applies)
-                return { ok: false, error: '--applies is required for category convention (where the rule applies).' };
-            return { ok: true, category: 'CONVENTION', content: { rule, scope: applies } };
+                return {
+                    ok: false,
+                    error: '--applies is required for category convention (where the rule applies).',
+                };
+            return {
+                ok: true,
+                category: 'CONVENTION',
+                content: { rule, scope: applies },
+            };
         }
         case 'procedural': {
             const workflow = trimmed(flags.workflow);
             const trigger = trimmed(flags.trigger);
             const steps = (flags.step ?? []).map(s => s.trim()).filter(Boolean);
             if (!workflow)
-                return { ok: false, error: '--workflow is required for category procedural.' };
+                return {
+                    ok: false,
+                    error: '--workflow is required for category procedural.',
+                };
             if (!trigger)
-                return { ok: false, error: '--trigger is required for category procedural.' };
-            return { ok: true, category: 'PROCEDURAL', content: { workflow, trigger, ...(steps.length ? { steps } : {}) } };
+                return {
+                    ok: false,
+                    error: '--trigger is required for category procedural.',
+                };
+            return {
+                ok: true,
+                category: 'PROCEDURAL',
+                content: { workflow, trigger, ...(steps.length ? { steps } : {}) },
+            };
         }
         default:
-            return { ok: false, error: `Unknown --category "${category}". Use trap | decision | convention | procedural.` };
+            return {
+                ok: false,
+                error: `Unknown --category "${category}". Use trap | decision | convention | procedural.`,
+            };
     }
 }
 function headline(category, content) {
     const c = (content ?? {});
-    const key = category === 'TRAP' ? 'trigger'
-        : category === 'DECISION' ? 'what'
-            : category === 'CONVENTION' ? 'rule'
+    const key = category === 'TRAP'
+        ? 'trigger'
+        : category === 'DECISION'
+            ? 'what'
+            : category === 'CONVENTION'
+                ? 'rule'
                 : 'workflow';
     const v = c[key];
-    return typeof v === 'string' && v.length > 0 ? (0, sanitize_1.sanitizeField)(v) : '(unparseable)';
+    return typeof v === 'string' && v.length > 0
+        ? (0, sanitize_1.sanitizeField)(v)
+        : '(unparseable)';
 }
 /** Fixed-width rows: id  SCOPE  CATEGORY  headline  source(auto|manual). */
 function formatMemoryList(rows) {
@@ -87,9 +123,3 @@ function formatMemoryList(rows) {
     })
         .join('\n');
 }
-/** Numbered review list: `  N. [SCOPE] CATEGORY  headline`. 1-indexed. */
-function formatMemoryReviewList(rows) {
-    return rows
-        .map((r, i) => `  ${i + 1}. [${r.scope}] ${r.category}  ${headline(r.category, r.content)}`)
-        .join('\n');
-}