sanook-cli 0.5.2 → 0.5.7

package/dist/brain-consolidate.js

@@ -0,0 +1,335 @@
+import { mkdir, readdir, readFile, rename, stat, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { persistenceEnabled } from './brand.js';
+import { normalize, consolidate, loadStore, saveStore } from './memory-store.js';
+import { search } from './search/engine.js';
+const ARCHIVE_EXEMPT_PREFIXES = ['Shared/Core-Facts/', 'Shared/Archive/'];
+const RETRIEVAL_CASES = [
+    { id: 'RET-01', query: 'memory write protocol merge dont append', expectedPath: 'Shared/Rules/memory-write-protocol.md' },
+    { id: 'RET-02', query: 'context assembly policy small context', expectedPath: 'Shared/Rules/context-assembly-policy.md' },
+    { id: 'RET-03', query: 'quality ledger retrieval hit grounded', expectedPath: 'Evals/quality-ledger.md' },
+];
+export function parseBrainConsolidateArgs(args) {
+    let apply = false;
+    let archive = false;
+    let memory = false;
+    let runRetrieval = true;
+    for (const a of args) {
+        if (a === '--apply')
+            apply = true;
+        else if (a === '--archive')
+            archive = true;
+        else if (a === '--memory')
+            memory = true;
+        else if (a === '--no-retrieval')
+            runRetrieval = false;
+        else
+            return { ok: false, message: `ไม่รู้จัก option: ${a}` };
+    }
+    if (archive && !apply)
+        return { ok: false, message: '--archive ต้องใช้ร่วมกับ --apply (destructive move ถามก่อน — default เป็น dry-run)' };
+    return { ok: true, value: { apply, archive, memory, runRetrieval } };
+}
+function step(id, title, findings, message, fail = false, applied) {
+    const status = fail ? 'fail' : findings.length ? 'warn' : 'pass';
+    return { id, title, status, message, findings, applied };
+}
+function sectionBullets(content, heading) {
+    const lines = content.split('\n');
+    const start = lines.findIndex((line) => line.trim().toLowerCase() === `## ${heading.toLowerCase()}`);
+    if (start < 0)
+        return [];
+    const out = [];
+    for (const line of lines.slice(start + 1)) {
+        if (/^#{1,6}\s+/.test(line.trim()))
+            break;
+        const trimmed = line.trim();
+        if (trimmed.startsWith('- ') && !trimmed.includes('_('))
+            out.push(trimmed);
+    }
+    return out;
+}
+function parseFrontmatterField(content, field) {
+    const match = content.match(new RegExp(`^${field}:\\s*(.+)$`, 'm'));
+    return match?.[1]?.trim().replace(/^["']|["']$/g, '');
+}
+function parseIsoDate(value) {
+    if (!value)
+        return undefined;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+async function readText(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+async function listMarkdown(root) {
+    const out = [];
+    async function walk(abs, rel) {
+        let entries;
+        try {
+            entries = await readdir(abs, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const childRel = rel ? `${rel}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                if (entry.name.startsWith('.') || entry.name === '.git' || entry.name === '.obsidian' || entry.name === 'node_modules')
+                    continue;
+                await walk(join(abs, entry.name), childRel);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                out.push(childRel);
+            }
+        }
+    }
+    await walk(root, '');
+    return out;
+}
+async function routeInboxStep(brainPath, apply) {
+    const path = join(brainPath, 'Shared', 'Memory-Inbox', 'memory-inbox.md');
+    const content = await readText(path);
+    if (!content) {
+        return step('consolidate.inbox-route', 'Route Memory-Inbox', [{ message: 'Memory-Inbox file is missing.', path }], 'Memory-Inbox is missing.', true);
+    }
+    const candidates = sectionBullets(content, 'New Candidates');
+    const needsMerge = sectionBullets(content, 'Needs Merge');
+    const findings = [];
+    const applied = [];
+    if (needsMerge.length) {
+        findings.push({
+            message: `${needsMerge.length} item(s) waiting in Needs Merge — promote to durable or discard.`,
+            path,
+            details: needsMerge.slice(0, 15),
+        });
+    }
+    const seen = new Map();
+    const duplicates = [];
+    for (const candidate of candidates) {
+        const key = normalize(candidate.replace(/^-\s*/, '').replace(/\s+/g, ' ')).trim();
+        if (!key)
+            continue;
+        if (seen.has(key))
+            duplicates.push(candidate);
+        else
+            seen.set(key, candidate);
+    }
+    if (duplicates.length) {
+        findings.push({ message: `${duplicates.length} duplicate candidate(s) in New Candidates.`, path, details: duplicates.slice(0, 15) });
+        if (apply) {
+            let next = content;
+            for (const dup of duplicates)
+                next = next.replace(`${dup}\n`, '');
+            if (next !== content) {
+                await writeFile(path, next);
+                applied.push(`removed ${duplicates.length} exact duplicate inbox candidate(s)`);
+            }
+        }
+    }
+    if (candidates.length && !needsMerge.length && !duplicates.length) {
+        findings.push({
+            message: `${candidates.length} candidate(s) ready for routing (ADD/UPDATE/DELETE/NOOP).`,
+            path,
+            details: candidates.slice(0, 10),
+        });
+    }
+    return step('consolidate.inbox-route', 'Route Memory-Inbox', findings, candidates.length ? `${candidates.length} inbox candidate(s) reviewed.` : 'Memory-Inbox has no active candidates.', false, applied.length ? applied : undefined);
+}
+async function dedupMergeStep(brainPath) {
+    const path = join(brainPath, 'Shared', 'Memory-Inbox', 'memory-inbox.md');
+    const content = await readText(path);
+    const candidates = [...sectionBullets(content, 'New Candidates'), ...sectionBullets(content, 'Needs Merge')];
+    const findings = [];
+    const buckets = new Map();
+    for (const candidate of candidates) {
+        const key = normalize(candidate.replace(/^-\s*/, '').replace(/\s+/g, ' ')).trim();
+        if (!key)
+            continue;
+        const bucket = buckets.get(key) ?? [];
+        bucket.push(candidate);
+        buckets.set(key, bucket);
+    }
+    const overlaps = [...buckets.entries()].filter(([, items]) => items.length > 1);
+    if (overlaps.length) {
+        findings.push({
+            message: `${overlaps.length} overlapping inbox group(s) need merge.`,
+            path,
+            details: overlaps.slice(0, 10).map(([key, items]) => `${key} (${items.length}x)`),
+        });
+    }
+    return step('consolidate.dedup-merge', 'Dedup + merge inbox', findings, 'Inbox overlap scan complete.');
+}
+async function staleArchiveStep(brainPath, nowMs, apply, archive) {
+    const findings = [];
+    const applied = [];
+    const candidates = [];
+    for (const rel of await listMarkdown(brainPath)) {
+        if (ARCHIVE_EXEMPT_PREFIXES.some((prefix) => rel.startsWith(prefix)))
+            continue;
+        const abs = join(brainPath, rel);
+        const content = await readText(abs);
+        const staleAfter = parseFrontmatterField(content, 'stale_after');
+        const staleMs = parseIsoDate(staleAfter);
+        if (staleMs === undefined || staleMs > nowMs)
+            continue;
+        candidates.push(rel);
+        findings.push({ message: `Stale candidate: stale_after=${staleAfter}`, path: abs });
+    }
+    if (archive && apply) {
+        await mkdir(join(brainPath, 'Shared', 'Archive'), { recursive: true });
+        for (const rel of candidates) {
+            const src = join(brainPath, rel);
+            const dest = join(brainPath, 'Shared', 'Archive', rel.split('/').pop());
+            await rename(src, dest);
+            applied.push(`archived ${rel} → Shared/Archive/${rel.split('/').pop()}`);
+        }
+    }
+    else if (candidates.length) {
+        findings.unshift({
+            message: `${candidates.length} note(s) past stale_after — dry-run only; rerun with --apply --archive to move into Shared/Archive.`,
+        });
+    }
+    return step('consolidate.stale-archive', 'Stale → Archive', findings, candidates.length ? `${candidates.length} stale note(s) flagged.` : 'No stale notes flagged.', false, applied.length ? applied : undefined);
+}
+async function patternPromoteStep(brainPath) {
+    const inboxPath = join(brainPath, 'Shared', 'Memory-Inbox', 'memory-inbox.md');
+    const candidates = sectionBullets(await readText(inboxPath), 'New Candidates');
+    const findings = [];
+    const markdown = await listMarkdown(brainPath);
+    const corpusParts = [];
+    for (const rel of markdown.slice(0, 200)) {
+        const text = await readText(join(brainPath, rel));
+        if (text)
+            corpusParts.push(normalize(text));
+    }
+    const corpus = corpusParts.join('\n');
+    for (const candidate of candidates) {
+        const phrase = normalize(candidate.replace(/^-\s*/, '').replace(/\s+/g, ' ')).trim();
+        if (phrase.length < 12)
+            continue;
+        const tokens = phrase.split(/\s+/).filter((t) => t.length > 3).slice(0, 4);
+        if (tokens.length < 2)
+            continue;
+        const hits = tokens.filter((token) => corpus.includes(token)).length;
+        if (hits >= 3 || (tokens.length >= 2 && hits === tokens.length && corpus.includes(phrase.slice(0, 20)))) {
+            findings.push({
+                message: `Possible recurring pattern (≥3 signals): "${phrase.slice(0, 80)}"`,
+                path: inboxPath,
+                details: ['Consider promoting to Playbooks/ or Distillations/ after review.'],
+            });
+        }
+    }
+    return step('consolidate.pattern-promote', 'Pattern → promote', findings, findings.length ? `${findings.length} pattern candidate(s) found.` : 'No recurring patterns detected in inbox.');
+}
+async function retrievalCheckStep(runRetrieval, searchImpl) {
+    if (!runRetrieval) {
+        return { id: 'consolidate.retrieval-check', title: 'Retrieval check', status: 'skipped', message: 'Skipped (--no-retrieval).', findings: [] };
+    }
+    const findings = [];
+    for (const item of RETRIEVAL_CASES) {
+        const res = await searchImpl(item.query);
+        const hit = res.hits.find((candidate) => candidate.path === item.expectedPath);
+        if (!hit) {
+            findings.push({
+                message: `${item.id} miss: query did not return ${item.expectedPath}`,
+                details: [`query="${item.query}"`, ...res.hits.slice(0, 3).map((h) => `got: ${h.path ?? h.snippet.slice(0, 60)}`)],
+            });
+        }
+    }
+    return step('consolidate.retrieval-check', 'Retrieval check', findings, findings.length ? `${findings.length} retrieval miss(es).` : 'Retrieval eval cases passed.', false);
+}
+async function memoryConsolidateStep(apply, memory, nowMs) {
+    if (!memory) {
+        return { id: 'consolidate.auto-memory', title: 'Auto-memory consolidate', status: 'skipped', message: 'Skipped (pass --memory to consolidate ~/.sanook memory store).', findings: [] };
+    }
+    if (!persistenceEnabled()) {
+        return step('consolidate.auto-memory', 'Auto-memory consolidate', [{ message: 'Persistence is disabled (SANOOK_DISABLE_PERSISTENCE).' }], 'Auto-memory consolidate skipped.', false);
+    }
+    const store = await loadStore();
+    const { store: next, report } = consolidate(store, nowMs);
+    const findings = [];
+    if (report.archived.length)
+        findings.push({ message: `Would archive ${report.archived.length} auto-memory fact(s).`, details: report.archived.slice(0, 10) });
+    if (report.merged.length)
+        findings.push({ message: `Merged ${report.merged.length} overlapping auto-memory fact(s).`, details: report.merged.slice(0, 10) });
+    if (report.needsReview.length)
+        findings.push({ message: `${report.needsReview.length} auto-memory fact(s) need review.`, details: report.needsReview.slice(0, 10) });
+    const applied = [];
+    if (apply) {
+        await saveStore(next);
+        applied.push('saved consolidated auto-memory store');
+    }
+    return step('consolidate.auto-memory', 'Auto-memory consolidate', findings, apply ? 'Auto-memory store consolidated.' : 'Auto-memory consolidate dry-run (pass --apply --memory to save).', false, applied.length ? applied : undefined);
+}
+export async function runBrainConsolidate(options = {}) {
+    const brainPath = options.brainPath;
+    const apply = options.apply ?? false;
+    const dryRun = !apply;
+    if (!brainPath) {
+        return {
+            ok: false,
+            dryRun,
+            steps: [step('consolidate.configured', 'Second-brain configured', [{ message: 'No second-brain path is configured.' }], 'Run `sanook brain init [path]` first.', true)],
+        };
+    }
+    try {
+        if (!(await stat(brainPath)).isDirectory()) {
+            return {
+                ok: false,
+                brainPath,
+                dryRun,
+                steps: [step('consolidate.path', 'Second-brain path', [{ message: 'Configured path is not a directory.', path: brainPath }], 'Configured brainPath is not usable.', true)],
+            };
+        }
+    }
+    catch {
+        return {
+            ok: false,
+            brainPath,
+            dryRun,
+            steps: [step('consolidate.path', 'Second-brain path', [{ message: 'Configured path does not exist.', path: brainPath }], 'Configured brainPath is not usable.', true)],
+        };
+    }
+    const nowMs = options.nowMs ?? Date.now();
+    const searchImpl = options.searchImpl ??
+        ((query) => search(query, { mode: 'fts', limit: 5, sources: ['vault'] }));
+    const steps = [
+        await routeInboxStep(brainPath, apply),
+        await dedupMergeStep(brainPath),
+        await staleArchiveStep(brainPath, nowMs, apply, options.archive ?? false),
+        await patternPromoteStep(brainPath),
+        await retrievalCheckStep(options.runRetrieval !== false, searchImpl),
+        await memoryConsolidateStep(apply, options.memory ?? false, nowMs),
+    ];
+    const ok = !steps.some((s) => s.status === 'fail');
+    return { ok, brainPath, dryRun, steps };
+}
+function statusLabel(status) {
+    return status.toUpperCase().padEnd(7);
+}
+export function formatBrainConsolidateReport(report) {
+    const lines = [
+        'Sanook brain consolidate',
+        `vault: ${report.brainPath ?? '(not configured)'}`,
+        `mode: ${report.dryRun ? 'dry-run (pass --apply for safe fixes; --apply --archive for stale moves)' : 'apply'}`,
+    ];
+    for (const s of report.steps) {
+        lines.push(`[${statusLabel(s.status)}] ${s.id} — ${s.message}`);
+        for (const finding of s.findings) {
+            lines.push(`       - ${finding.message}`);
+            if (finding.path)
+                lines.push(`         ${finding.path}`);
+            for (const detail of finding.details ?? [])
+                lines.push(`         · ${detail}`);
+        }
+        for (const action of s.applied ?? [])
+            lines.push(`       ✓ ${action}`);
+    }
+    return lines.join('\n');
+}

package/dist/brain-context.js

@@ -1,4 +1,5 @@
 import { stat } from 'node:fs/promises';
+import { resolveVaultProject } from './project-registry.js';
 import { inlineValue, takeValue } from './cli-option-values.js';
 import { buildBrainContextParts, renderBrainContext, } from './memory.js';
 import { checkSearchIndexFreshness } from './brain-doctor.js';
@@ -26,8 +27,11 @@ function inlineSourceValue(value) {
 export function parseBrainContextArgs(args) {
     const taskParts = [];
     let task;
+    let project;
     let mode = 'auto';
+    let modeSet = false;
     let limit = 5;
+    let limitSet = false;
     let sources;
     let showContent = true;
     for (let i = 0; i < args.length; i++) {
@@ -43,10 +47,23 @@ export function parseBrainContextArgs(args) {
                 i = next.nextIndex;
             if (!raw)
                 return { ok: false, message: '--task ต้องระบุข้อความ task' };
+            if (task !== undefined)
+                return { ok: false, message: 'ระบุ task ได้ครั้งเดียว: ใช้ --task เพียงครั้งเดียว' };
             task = raw.trim();
             if (!task)
                 return { ok: false, message: '--task ต้องระบุข้อความ task' };
         }
+        else if (a === '--project' || a.startsWith('--project=')) {
+            const next = a === '--project' ? takeValue(args, i) : undefined;
+            const raw = next ? next.value : inlineValue('--project', a);
+            if (next)
+                i = next.nextIndex;
+            if (!raw?.trim())
+                return { ok: false, message: 'ต้องระบุค่าให้ --project' };
+            if (project !== undefined)
+                return { ok: false, message: 'ระบุ project ได้ครั้งเดียว' };
+            project = raw.trim();
+        }
         else if (a === '--mode' || a.startsWith('--mode=')) {
             const next = a === '--mode' ? takeValue(args, i) : undefined;
             const raw = next ? next.value : inlineValue('--mode', a);
@@ -56,7 +73,10 @@ export function parseBrainContextArgs(args) {
                 return { ok: false, message: `--mode ต้องระบุค่าเป็น ${SEARCH_MODES.join('|')}` };
             if (!isSearchMode(raw))
                 return { ok: false, message: `--mode ต้องเป็น ${SEARCH_MODES.join('|')}` };
+            if (modeSet)
+                return { ok: false, message: 'ใช้ --mode เพียงครั้งเดียว' };
             mode = raw;
+            modeSet = true;
         }
         else if (a === '--limit' || a.startsWith('--limit=')) {
             const next = a === '--limit' ? takeValue(args, i) : undefined;
@@ -66,7 +86,10 @@ export function parseBrainContextArgs(args) {
             const n = parsePositiveInteger(raw);
             if (n === undefined)
                 return { ok: false, message: '--limit ต้องเป็น integer บวก เช่น 5' };
+            if (limitSet)
+                return { ok: false, message: 'ใช้ --limit เพียงครั้งเดียว' };
             limit = n;
+            limitSet = true;
         }
         else if (a === '--source' || a === '--sources' || a.startsWith('--source=') || a.startsWith('--sources=')) {
             const next = a === '--source' || a === '--sources' ? takeValue(args, i) : undefined;
@@ -79,7 +102,7 @@ export function parseBrainContextArgs(args) {
             const bad = requested.filter((s) => !isSearchSource(s));
             if (bad.length)
                 return { ok: false, message: `--source ต้องเป็น ${SEARCH_SOURCES.join(',')}` };
-            sources = [...new Set(requested)];
+            sources = [...new Set([...(sources ?? []), ...requested])];
         }
         else if (a === '--no-content' || a === '--summary') {
             showContent = false;
@@ -92,8 +115,10 @@ export function parseBrainContextArgs(args) {
         }
     }
     const positionalTask = taskParts.join(' ').trim();
+    if (task !== undefined && positionalTask)
+        return { ok: false, message: 'ระบุ task ได้ครั้งเดียว: ใช้ positional หรือ --task อย่างใดอย่างหนึ่ง' };
     const finalTask = (task ?? positionalTask).trim();
-    return { ok: true, value: { task: finalTask || undefined, mode, limit, sources, showContent } };
+    return { ok: true, value: { task: finalTask || undefined, project, mode, limit, sources, showContent } };
 }
 export async function inspectBrainContext(options = {}) {
     const brainPath = options.brainPath;
@@ -129,8 +154,17 @@ export async function inspectBrainContext(options = {}) {
             warnings: ['Configured second-brain path does not exist.'],
         };
     }
-    const parts = await buildBrainContextParts(brainPath);
+    const parts = await buildBrainContextParts(brainPath, {
+        taskQuery: options.task,
+        cwd: options.cwd,
+        projectSlug: options.projectSlug,
+    });
     const context = renderBrainContext(brainPath, parts);
+    const activeProject = await resolveVaultProject({
+        brainPath,
+        cwd: options.cwd,
+        slug: options.projectSlug,
+    });
     const sourceReports = parts.map((part) => ({
         id: part.id,
         label: part.label,
@@ -174,6 +208,8 @@ export async function inspectBrainContext(options = {}) {
     return {
         ok: true,
         brainPath,
+        projectSlug: activeProject?.slug,
+        projectRepo: activeProject?.repoPath,
         context,
         contextChars: context.length,
         sources: sourceReports,
@@ -187,6 +223,9 @@ function statusLabel(status) {
 export function formatBrainContextReport(report, showContent = true) {
     const lines = ['Sanook brain context'];
     lines.push(`vault: ${report.brainPath ?? '(not configured)'}`);
+    if (report.projectSlug) {
+        lines.push(`project: ${report.projectSlug}${report.projectRepo ? ` (${report.projectRepo})` : ''}`);
+    }
     lines.push(`context: ${report.contextChars} chars`);
     if (report.sources.length) {
         lines.push('sources:');

package/dist/brain-final.js

@@ -3,6 +3,7 @@ import { mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';
 import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
+import { inlineValue, takeValue } from './cli-option-values.js';
 const execFileAsync = promisify(execFile);
 const TEMPLATE_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', 'second-brain', 'Templates');
 const FINAL_HEADINGS = [
@@ -31,28 +32,33 @@ export function parseBrainFinalArgs(args) {
         else if (arg === '--force') {
             parsed.force = true;
         }
-        else if (arg === '--task') {
-            const value = args[++i];
+        else if (arg === '--task' || arg.startsWith('--task=')) {
+            const next = arg === '--task' ? takeValue(args, i) : undefined;
+            const value = next ? next.value : inlineValue('--task', arg);
+            if (next)
+                i = next.nextIndex;
             if (!value?.trim())
                 return { ok: false, message: 'ต้องระบุค่าให้ --task' };
+            if (parsed.task)
+                return { ok: false, message: 'ระบุ task ได้ครั้งเดียว: ใช้ --task เพียงครั้งเดียว' };
             parsed.task = value.trim();
         }
-        else if (arg.startsWith('--task=')) {
-            const value = arg.slice('--task='.length).trim();
-            if (!value)
-                return { ok: false, message: 'ต้องระบุค่าให้ --task' };
-            parsed.task = value;
-        }
         else if (arg === '--output') {
-            const value = args[++i];
+            const next = takeValue(args, i);
+            const value = next.value;
+            i = next.nextIndex;
             if (!value?.trim())
                 return { ok: false, message: 'ต้องระบุค่าให้ --output' };
+            if (parsed.output !== undefined)
+                return { ok: false, message: 'ระบุ output ได้ครั้งเดียว: ใช้ --output เพียงครั้งเดียว' };
             parsed.output = value.trim();
         }
         else if (arg.startsWith('--output=')) {
             const value = arg.slice('--output='.length).trim();
             if (!value)
                 return { ok: false, message: 'ต้องระบุค่าให้ --output' };
+            if (parsed.output !== undefined)
+                return { ok: false, message: 'ระบุ output ได้ครั้งเดียว: ใช้ --output เพียงครั้งเดียว' };
             parsed.output = value;
         }
         else if (arg === '--') {

package/dist/brain-link.js

@@ -0,0 +1,73 @@
+import { readFile, stat, writeFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { BRAND } from './brand.js';
+import { scaffoldProjectWorkspace } from './project-scaffold.js';
+async function exists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Wire a freshly scaffolded vault to the current repo: Projects/<slug>/ + SANOOK.md memory stub. */
+export async function linkBrainToProject(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const brainPath = options.brainPath;
+    const title = options.title?.trim() || basename(cwd) || 'Project';
+    const today = options.today ?? new Date().toISOString().slice(0, 10);
+    const warnings = [];
+    const scaffold = await scaffoldProjectWorkspace({
+        brainPath,
+        title,
+        repoPath: cwd,
+        today,
+    });
+    if (!scaffold.ok && scaffold.skipped.length) {
+        warnings.push(...scaffold.warnings);
+    }
+    else if (scaffold.warnings.length) {
+        warnings.push(...scaffold.warnings);
+    }
+    const memoryFile = join(cwd, BRAND.memoryFileName);
+    let memoryCreated = false;
+    if (!(await exists(memoryFile))) {
+        const body = [
+            `# ${BRAND.productName} project memory`,
+            '',
+            `> Linked to second-brain vault: \`${brainPath}\``,
+            scaffold.ok || scaffold.slug ? `> Project workspace: \`Projects/${scaffold.slug}/\`` : '',
+            '',
+            '## Conventions',
+            '',
+            '- Decisions, gotchas, and preferences discovered in this repo belong here or in the vault.',
+            `- Session summaries are auto-written to \`Sessions/\` in the vault on exit (Ctrl+C / /quit).`,
+            '',
+        ]
+            .filter(Boolean)
+            .join('\n');
+        await writeFile(memoryFile, `${body}\n`, 'utf8');
+        memoryCreated = true;
+    }
+    else {
+        try {
+            const current = await readFile(memoryFile, 'utf8');
+            if (!current.includes(brainPath)) {
+                await writeFile(memoryFile, `${current.trimEnd()}\n\n<!-- ${BRAND.productName} -->\nsecond-brain: ${brainPath}\nproject: Projects/${scaffold.slug}/\n`, 'utf8');
+            }
+        }
+        catch {
+            warnings.push(`Could not update existing ${BRAND.memoryFileName}`);
+        }
+    }
+    return {
+        ok: scaffold.ok || scaffold.skipped.length > 0,
+        brainPath,
+        projectSlug: scaffold.slug,
+        projectRelDir: scaffold.relDir,
+        memoryFile,
+        memoryCreated,
+        warnings,
+    };
+}