@lumoai/cli 1.38.0 → 1.40.0

package/dist/cli/src/index.js

@@ -45,11 +45,11 @@ 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");
 const verdict_1 = require("./commands/verdict");
+const crossing_explain_1 = require("./commands/crossing-explain");
 const task_context_1 = require("./commands/task-context");
 const task_create_1 = require("./commands/task-create");
 const task_update_1 = require("./commands/task-update");
@@ -68,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");
@@ -230,6 +232,14 @@ program
     .option('--note <text>', 'Optional send-back narrative, posted as a task comment')
     .option('--criterion <id>', 'Narrow a --fail to specific criteria (repeatable); omitted = the whole contract', verdict_1.collectCriterion)
     .action(wrap((task, options) => (0, verdict_1.verdict)(task, options)));
+const crossing = program
+    .command('crossing')
+    .description('Inspect and annotate boundary crossings');
+crossing
+    .command('explain <id>')
+    .description('Append an agent self-explanation ("申辩") to a boundary crossing (LUM-542). Append-only and for the human reviewer — it never clears the crossing or unblocks Done (a human dispositions that). Targets a crossing on the session-bound task.')
+    .requiredOption('--note <text>', 'The explanation to record (the rationale for the action / why it may be a false positive)')
+    .action(wrap((id, options) => (0, crossing_explain_1.crossingExplain)(id, options)));
 program
     .command('next')
     .description('Recommend the next task(s) to work on, ranked by priority, active sprint, and due date. Prints top N (default 3); pick one and run `session attach` + `task context`.')
@@ -255,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');
@@ -514,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,57 @@
+"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");
+/**
+ * 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)));
+        }
+        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

@@ -79,9 +79,17 @@ _now = new Date()) {
     if (path === 'pre-tool-use') {
         if (responseBody == null || typeof responseBody !== 'object')
             return [];
-        const warning = responseBody
-            .collisionWarning;
-        if (typeof warning !== 'string' || warning === '')
+        const body = responseBody;
+        // Two independent PreToolUse signals (LUM-150 collision, LUM-542 crossing
+        // reminder) share one additionalContext block when both are present.
+        const parts = [];
+        if (typeof body.collisionWarning === 'string' &&
+            body.collisionWarning !== '')
+            parts.push(body.collisionWarning);
+        if (typeof body.crossingReminder === 'string' &&
+            body.crossingReminder !== '')
+            parts.push(body.crossingReminder);
+        if (parts.length === 0)
             return [];
         return [
             JSON.stringify({
@@ -89,7 +97,7 @@ _now = new Date()) {
                     hookEventName: 'PreToolUse',
                     // Server-built text routed back to stdout — sanitize untrusted free
                     // text before Claude Code consumes it (ANSI/control-char injection).
-                    additionalContext: (0, sanitize_1.sanitizeField)(warning),
+                    additionalContext: (0, sanitize_1.sanitizeField)(parts.join('\n\n')),
                 },
             }),
         ];

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-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');
-}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffSync = diffSync;
+/**
+ * Pure reconcile: given the owned local files and the server bundle, classify
+ * each into add / update / remove / skipDrift. Idempotent — identical state
+ * yields empty add/update/remove. A locally-edited owned file (drift) is never
+ * an update or remove; it is reported as skipDrift so the dev's edit survives
+ * (and becomes a P3 upsync candidate).
+ */
+function diffSync(owned, bundle) {
+    const ownedById = new Map(owned.map(o => [o.id, o]));
+    const bundleById = new Map(bundle.map(b => [b.id, b]));
+    const add = bundle.filter(b => !ownedById.has(b.id));
+    const remove = [];
+    const update = [];
+    const skipDrift = [];
+    for (const o of owned) {
+        const b = bundleById.get(o.id);
+        if (o.diskHash !== o.contentHash) {
+            // locally edited → protect it regardless of whether the server changed
+            skipDrift.push(o.id);
+            continue;
+        }
+        if (!b) {
+            remove.push(o.id);
+            continue;
+        }
+        if (b.contentHash !== o.contentHash)
+            update.push(b);
+    }
+    return { add, update, remove, skipDrift };
+}

package/dist/cli/src/lib/upsync.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectUpsyncCandidates = collectUpsyncCandidates;
+exports.projectMemoriesEndpoint = projectMemoriesEndpoint;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const OUTBOX_DIR = 'outbox';
+/**
+ * Collect upsync candidates from `<root>/outbox/*.json` — each a structured
+ * `{ category, content }` the dev authored locally and wants promoted to the
+ * team. JSON (not the rendered team/*.md files) keeps the content lossless and
+ * already category-shaped; a rendered team file cannot be reversed back to
+ * structured content, so edited team files (P1 drift candidates) are reported by
+ * `lumo memory sync`, not auto-converted here. Malformed/non-JSON files are
+ * skipped, not fatal.
+ */
+function collectUpsyncCandidates(root) {
+    const dir = (0, node_path_1.join)(root, OUTBOX_DIR);
+    if (!(0, node_fs_1.existsSync)(dir))
+        return [];
+    const out = [];
+    for (const f of (0, node_fs_1.readdirSync)(dir).sort()) {
+        if (!f.endsWith('.json'))
+            continue;
+        const p = (0, node_path_1.join)(dir, f);
+        try {
+            const parsed = JSON.parse((0, node_fs_1.readFileSync)(p, 'utf8'));
+            if (typeof parsed.category === 'string' && parsed.content !== undefined) {
+                out.push({
+                    file: p,
+                    category: parsed.category,
+                    content: parsed.content,
+                });
+            }
+        }
+        catch {
+            // skip malformed JSON
+        }
+    }
+    return out;
+}
+/**
+ * The endpoint upsync POSTs to. Deliberately the SAME create-project-memory
+ * route the web/CLI already use (`createForProject`: canonicalize → dedup →
+ * reconcile-on-write, LUM-538) — upsync reuses that pipeline rather than adding
+ * a parallel one.
+ */
+function projectMemoriesEndpoint(base, projectId) {
+    return `${base}/api/projects/${encodeURIComponent(projectId)}/memories`;
+}