sanook-cli 0.5.0 → 0.5.2

package/dist/mcp-registry.js

@@ -0,0 +1,350 @@
+import { inlineValue, takeValue } from './cli-option-values.js';
+export const MCP_REGISTRY_BASE_URL = 'https://registry.modelcontextprotocol.io/v0';
+export const MCP_PRESETS = [
+    {
+        name: 'dev',
+        description: 'Repo/issues/releases, error debugging, and versioned docs.',
+        servers: ['com.gitlab/mcp', 'com.mcparmory/github', 'com.mcparmory/sentry', 'ai.smithery/renCosta2025-context7fork'],
+    },
+    {
+        name: 'research',
+        description: 'Web/doc fetching, search, and knowledge intake.',
+        servers: ['ai.smithery/smithery-ai-fetch', 'ai.groundroute/web-search', 'ai.smithery/arjunkmrm-brave-search-mcp-server', 'ai.smithery/sunub-obsidian-mcp-server'],
+    },
+    {
+        name: 'pm',
+        description: 'Issue tracking, planning, and team/workspace context.',
+        servers: ['app.linear/linear', 'ai.waystation/jira', 'ai.waystation/slack', 'com.mcparmory/notion'],
+    },
+    {
+        name: 'ops',
+        description: 'Read-only data inspection, production errors, and infra helpers.',
+        servers: ['capital.hove/read-only-local-postgres-mcp-server', 'com.mcparmory/sentry', 'io.github.CSOAI-ORG/docker-helper-ai-mcp'],
+    },
+];
+export function parseKeyValueList(values) {
+    const out = {};
+    for (const value of values) {
+        const idx = value.indexOf('=');
+        if (idx <= 0)
+            throw new Error(`ต้องใช้รูปแบบ KEY=value: ${value}`);
+        const key = value.slice(0, idx).trim();
+        if (!key)
+            throw new Error(`ต้องใช้รูปแบบ KEY=value: ${value}`);
+        out[key] = value.slice(idx + 1);
+    }
+    return out;
+}
+function parseRegistrySearchLimit(raw) {
+    if (!raw || !/^[1-9]\d*$/.test(raw))
+        return undefined;
+    const n = Number(raw);
+    return Number.isSafeInteger(n) && n <= 50 ? n : undefined;
+}
+export function parseMcpRegistrySearchArgs(args) {
+    const query = [];
+    let limit = 10;
+    let cursor;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--') {
+            query.push(...args.slice(i + 1));
+            break;
+        }
+        if (a === '--limit' || a.startsWith('--limit=')) {
+            const next = a === '--limit' ? takeValue(args, i) : undefined;
+            const raw = next ? next.value : inlineValue('--limit', a);
+            if (next)
+                i = next.nextIndex;
+            const parsed = parseRegistrySearchLimit(raw);
+            if (parsed === undefined)
+                return { ok: false, message: '--limit ต้องเป็นจำนวนเต็ม 1-50' };
+            limit = parsed;
+        }
+        else if (a === '--cursor' || a.startsWith('--cursor=')) {
+            const next = a === '--cursor' ? takeValue(args, i) : undefined;
+            const raw = next ? next.value : inlineValue('--cursor', a);
+            if (next)
+                i = next.nextIndex;
+            const parsed = raw?.trim();
+            if (!parsed)
+                return { ok: false, message: '--cursor ต้องระบุค่า' };
+            cursor = parsed;
+        }
+        else {
+            query.push(a);
+        }
+    }
+    return { ok: true, value: { query: query.join(' ').trim(), limit, cursor } };
+}
+export function aliasFromRegistryName(name) {
+    const [scope = '', rawLeaf = name] = name.split('/');
+    const leaf = rawLeaf
+        .replace(/^mcp[-_]?/i, '')
+        .replace(/[-_]?mcp[-_]?server$/i, '')
+        .replace(/[-_]?server$/i, '')
+        .replace(/^smithery[-_]?ai[-_]?/i, '');
+    const scopeParts = scope.split('.').filter(Boolean);
+    const fallback = scopeParts.length > 1 ? scopeParts[1] : scopeParts[0] || name;
+    const candidate = leaf && leaf.toLowerCase() !== 'mcp' ? leaf : fallback;
+    const alias = candidate.replace(/[^a-zA-Z0-9_-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 64);
+    return alias || 'mcp-server';
+}
+export async function searchMcpRegistry(query, options = {}) {
+    const params = new URLSearchParams();
+    if (query.trim())
+        params.set('search', query.trim());
+    params.set('limit', String(options.limit ?? 10));
+    if (options.cursor)
+        params.set('cursor', options.cursor);
+    const json = await fetchRegistryJson(`${options.baseUrl ?? MCP_REGISTRY_BASE_URL}/servers?${params}`, options.fetchImpl);
+    const entries = Array.isArray(json.servers) ? json.servers : [];
+    return {
+        servers: latestOnly(entries.map(normalizeRegistryEntry).filter((item) => !!item)),
+        nextCursor: typeof json.metadata?.nextCursor === 'string' ? json.metadata.nextCursor : undefined,
+    };
+}
+export async function getMcpRegistryServer(name, options = {}) {
+    const encoded = encodeURIComponent(name);
+    const base = options.baseUrl ?? MCP_REGISTRY_BASE_URL;
+    if (options.version) {
+        const raw = await fetchRegistryJson(`${base}/servers/${encoded}/versions/${encodeURIComponent(options.version)}`, options.fetchImpl);
+        return normalizeRegistryEntry(raw);
+    }
+    const json = await fetchRegistryJson(`${base}/servers/${encoded}/versions`, options.fetchImpl);
+    const entries = Array.isArray(json.servers) ? json.servers : [];
+    const servers = entries.map(normalizeRegistryEntry).filter((item) => !!item);
+    return servers.find((server) => server.isLatest) ?? servers.at(-1);
+}
+export function buildMcpInstallPlan(server, options = {}) {
+    const alias = options.alias ?? aliasFromRegistryName(server.name);
+    const warnings = [];
+    const requirements = [];
+    const preferred = options.transport ?? 'auto';
+    if (preferred !== 'stdio') {
+        const remote = server.remotes.find((item) => item.type === 'streamable-http' && item.url) ?? server.remotes.find((item) => item.url);
+        if (remote?.url) {
+            const headers = resolveHeaders(remote.headers, options.headers ?? {});
+            requirements.push(...headers.requirements);
+            if (headers.missing.length)
+                return { ok: false, alias, missing: headers.missing, warnings, requirements };
+            if (remote.type && remote.type !== 'streamable-http')
+                warnings.push(`remote transport เป็น ${remote.type}; Sanook รองรับ Streamable HTTP เป็นหลัก`);
+            return { ok: true, alias, config: { url: remote.url, ...(Object.keys(headers.values).length ? { headers: headers.values } : {}) }, source: 'remote', warnings, requirements };
+        }
+        if (preferred === 'remote') {
+            warnings.push('server นี้ไม่มี remote URL ที่ install ได้');
+            return { ok: false, alias, missing: [], warnings, requirements };
+        }
+    }
+    const pkg = choosePackage(server.packages);
+    if (!pkg)
+        return { ok: false, alias, missing: [], warnings: [...warnings, 'ไม่พบ package/remote ที่ Sanook install อัตโนมัติได้'], requirements };
+    const env = resolveEnv(pkg.environmentVariables ?? [], options.env ?? {});
+    requirements.push(...env.requirements);
+    if (env.missing.length)
+        return { ok: false, alias, missing: env.missing, warnings, requirements };
+    const commandArgs = packageCommand(pkg);
+    if (!commandArgs)
+        return { ok: false, alias, missing: [], warnings: [...warnings, `ยังไม่รองรับ package runtime: ${pkg.runtimeHint ?? pkg.registryType ?? '(unknown)'}`], requirements };
+    return {
+        ok: true,
+        alias,
+        config: { command: commandArgs.command, args: commandArgs.args, ...(Object.keys(env.values).length ? { env: env.values } : {}) },
+        source: 'package',
+        warnings,
+        requirements,
+    };
+}
+export function formatRegistrySearch(result) {
+    const lines = ['MCP registry search'];
+    if (!result.servers.length)
+        return `${lines[0]}\n(no matches)`;
+    for (const server of result.servers) {
+        lines.push(`${server.name}${server.version ? `@${server.version}` : ''} — ${server.description ?? '(no description)'}`);
+        lines.push(`  transport: ${transportSummary(server)}${server.repositoryUrl ? ` · repo: ${server.repositoryUrl}` : ''}`);
+    }
+    if (result.nextCursor)
+        lines.push(`next: --cursor ${result.nextCursor}`);
+    return lines.join('\n');
+}
+export function formatRegistryInfo(server) {
+    const lines = [`${server.name}${server.version ? `@${server.version}` : ''}`, server.description ?? '(no description)'];
+    if (server.repositoryUrl)
+        lines.push(`repo: ${server.repositoryUrl}`);
+    if (server.websiteUrl)
+        lines.push(`website: ${server.websiteUrl}`);
+    lines.push(`transport: ${transportSummary(server)}`);
+    if (server.remotes.length) {
+        lines.push('remotes:');
+        for (const remote of server.remotes) {
+            lines.push(`  - ${remote.type ?? 'remote'} ${remote.url ?? '(missing url)'}`);
+            for (const req of inputSummaries(inputArray(remote.headers)))
+                lines.push(`    ${req}`);
+        }
+    }
+    if (server.packages.length) {
+        lines.push('packages:');
+        for (const pkg of server.packages) {
+            lines.push(`  - ${pkg.registryType ?? 'pkg'} ${pkg.identifier ?? '(missing identifier)'}${pkg.version ? `@${pkg.version}` : ''}${pkg.runtimeHint ? ` via ${pkg.runtimeHint}` : ''}`);
+            for (const req of inputSummaries(pkg.environmentVariables ?? []))
+                lines.push(`    ${req}`);
+        }
+    }
+    lines.push(`install: sanook mcp install ${server.name} --name ${aliasFromRegistryName(server.name)}`);
+    return lines.join('\n');
+}
+export function formatPreset(name) {
+    if (!name) {
+        return ['MCP presets', ...MCP_PRESETS.map((preset) => `  ${preset.name.padEnd(8)} ${preset.description}`)].join('\n');
+    }
+    const preset = MCP_PRESETS.find((item) => item.name === name);
+    if (!preset)
+        return `ไม่เจอ preset: ${name}\nมีให้เลือก: ${MCP_PRESETS.map((item) => item.name).join(', ')}`;
+    return [
+        `MCP preset: ${preset.name}`,
+        preset.description,
+        '',
+        ...preset.servers.map((server) => `- ${server}\n  sanook mcp info ${server}\n  sanook mcp install ${server} --name ${aliasFromRegistryName(server)}`),
+    ].join('\n');
+}
+function normalizeRegistryEntry(raw) {
+    const server = raw.server;
+    if (!server?.name)
+        return undefined;
+    return {
+        name: server.name,
+        title: server.title,
+        description: server.description,
+        version: server.version,
+        repositoryUrl: server.repository?.url,
+        websiteUrl: server.websiteUrl,
+        isLatest: raw._meta?.['io.modelcontextprotocol.registry/official']?.isLatest !== false,
+        remotes: Array.isArray(server.remotes) ? server.remotes : [],
+        packages: Array.isArray(server.packages) ? server.packages : [],
+    };
+}
+function latestOnly(servers) {
+    const out = new Map();
+    for (const server of servers) {
+        const current = out.get(server.name);
+        if (!current || server.isLatest)
+            out.set(server.name, server);
+    }
+    return [...out.values()];
+}
+async function fetchRegistryJson(url, fetchImpl = fetch) {
+    const res = await fetchImpl(url, { headers: { accept: 'application/json' } });
+    if (!res.ok)
+        throw new Error(`registry ${res.status} ${res.statusText}`);
+    return (await res.json());
+}
+function transportSummary(server) {
+    const transports = [
+        ...server.remotes.map((remote) => `remote:${remote.type ?? 'unknown'}`),
+        ...server.packages.map((pkg) => `${pkg.registryType ?? 'pkg'}:${pkg.runtimeHint ?? 'package'}`),
+    ];
+    return transports.length ? transports.join(', ') : 'none listed';
+}
+function inputArray(value) {
+    if (!value)
+        return [];
+    if (Array.isArray(value))
+        return value;
+    return Object.entries(value).map(([name, input]) => ({ name, value: String(input) }));
+}
+function inputSummaries(inputs) {
+    return inputs.map((input) => {
+        const name = input.name ?? '(positional)';
+        const flags = [input.isRequired ? 'required' : undefined, input.isSecret ? 'secret' : undefined].filter(Boolean).join(', ');
+        return `${name}${flags ? ` (${flags})` : ''}${input.description ? ` — ${input.description}` : ''}`;
+    });
+}
+function resolveHeaders(raw, provided) {
+    const values = {};
+    const missing = [];
+    const requirements = [];
+    for (const input of inputArray(raw)) {
+        const name = input.name;
+        if (!name)
+            continue;
+        requirements.push(`header ${name}${input.isSecret ? ' (secret)' : ''}`);
+        const explicit = provided[name];
+        if (explicit != null)
+            values[name] = explicit;
+        else if (input.value && !/\{[^}]+\}/.test(input.value))
+            values[name] = input.value;
+        else if (input.default != null)
+            values[name] = input.default;
+        else if (input.isRequired || input.value)
+            missing.push(`header:${name}`);
+    }
+    for (const [name, value] of Object.entries(provided))
+        values[name] = value;
+    return { values, missing, requirements };
+}
+function resolveEnv(inputs, provided) {
+    const values = {};
+    const missing = [];
+    const requirements = [];
+    for (const input of inputs) {
+        const name = input.name;
+        if (!name)
+            continue;
+        requirements.push(`env ${name}${input.isSecret ? ' (secret)' : ''}`);
+        const explicit = provided[name];
+        if (explicit != null)
+            values[name] = explicit;
+        else if (input.value && !/\{[^}]+\}/.test(input.value))
+            values[name] = input.value;
+        else if (input.default != null)
+            values[name] = input.default;
+        else if (input.isRequired)
+            missing.push(`env:${name}`);
+    }
+    for (const [name, value] of Object.entries(provided))
+        values[name] = value;
+    return { values, missing, requirements };
+}
+function choosePackage(packages) {
+    return (packages.find((pkg) => pkg.transport?.type === 'stdio' && (pkg.runtimeHint === 'npx' || pkg.registryType === 'npm')) ??
+        packages.find((pkg) => pkg.transport?.type === 'stdio' && pkg.runtimeHint === 'uvx') ??
+        packages.find((pkg) => pkg.transport?.type === 'stdio' && pkg.runtimeHint === 'docker') ??
+        packages.find((pkg) => pkg.transport?.type === 'stdio'));
+}
+function packageCommand(pkg) {
+    const identifier = pkg.identifier;
+    if (!identifier)
+        return undefined;
+    const runtime = pkg.runtimeHint ?? (pkg.registryType === 'npm' ? 'npx' : pkg.registryType === 'pypi' ? 'uvx' : undefined);
+    const pkgId = packageIdentifierWithVersion(identifier, pkg.version);
+    const runtimeArgs = materializeArgs(pkg.runtimeArguments ?? []);
+    const packageArgs = materializeArgs(pkg.packageArguments ?? []);
+    if (runtime === 'npx') {
+        const args = runtimeArgs.length ? runtimeArgs : ['-y'];
+        return { command: 'npx', args: [...args, pkgId, ...packageArgs] };
+    }
+    if (runtime === 'uvx')
+        return { command: 'uvx', args: [...runtimeArgs, pkgId, ...packageArgs] };
+    if (runtime === 'docker')
+        return { command: 'docker', args: ['run', '-i', '--rm', ...runtimeArgs, pkgId, ...packageArgs] };
+    return undefined;
+}
+function packageIdentifierWithVersion(identifier, version) {
+    if (!version)
+        return identifier;
+    const scopedPackageNameEnd = identifier.startsWith('@') ? identifier.indexOf('/', 1) + 1 : 0;
+    return identifier.indexOf('@', scopedPackageNameEnd) === -1 ? `${identifier}@${version}` : identifier;
+}
+function materializeArgs(args) {
+    const out = [];
+    for (const arg of args) {
+        const value = arg.value ?? arg.default;
+        if (!value || /\{[^}]+\}/.test(value))
+            continue;
+        if (arg.name)
+            out.push(arg.name);
+        out.push(value);
+    }
+    return out;
+}

package/dist/mcp-server.js

@@ -130,7 +130,7 @@ async function callTool(name, args) {
             const r = await reindex();
             resetSearchCaches();
             return (`indexed: +${r.added} ~${r.updated} -${r.removed} (skipped ${r.skipped}) · ` +
-                `memory=${r.memory} sessions=${r.sessions} skills=${r.skills} · vault=${r.vaultPath ?? '(none)'}`);
+                `memory=${r.memory} sessions=${r.sessions} skills=${r.skills} vectors=${r.vectors} · vault=${r.vaultPath ?? '(none)'}`);
         }
         case 'sanook_stats': {
             const { index } = await loadIndex();

package/dist/mcp.js

@@ -14,6 +14,7 @@ const VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.u
 export const PROTOCOL_VERSION = '2024-11-05'; // shared by the MCP client (here) and server (mcp-server.ts)
 const MAX_BUF = 16 * 1024 * 1024; // กัน server ส่ง byte ยาวไม่มี newline → memory โต unbounded
 const REQUEST_TIMEOUT = 20_000;
+export const MAX_MCP_TOOL_OUTPUT_CHARS = 200_000;
 // env ปลอดภัยที่ส่งให้ MCP child (ไม่มี secret) — server ที่ต้อง token ให้ตั้งใน cfg.env เอง
 const SAFE_ENV_KEYS = ['PATH', 'HOME', 'TMPDIR', 'TEMP', 'LANG', 'LC_ALL', 'USER', 'SHELL', 'TERM', 'NODE_PATH', 'NVM_DIR', 'APPDATA'];
 function safeEnv() {
@@ -29,6 +30,12 @@ export function isValidMcpServerName(name) {
     return (/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(name) &&
         !['__proto__', 'prototype', 'constructor'].includes(name));
 }
+export function capMcpToolOutput(text, max = MAX_MCP_TOOL_OUTPUT_CHARS) {
+    if (text.length <= max)
+        return text;
+    const omitted = text.length - max;
+    return `${text.slice(0, max)}\n\n[MCP output truncated: ${omitted} chars omitted]`;
+}
 /** stdio transport — JSON-RPC 2.0, newline-delimited ผ่าน child process stdin/stdout */
 class StdioTransport {
     proc;
@@ -36,6 +43,7 @@ class StdioTransport {
     nextId = 1;
     pending = new Map();
     dead = false;
+    stderrTail = '';
     constructor(cfg) {
         this.proc = spawn(cfg.command, cfg.args ?? [], {
             // minimal env เท่านั้น (PATH/HOME/locale) + cfg.env ที่ user ตั้งเอง — ไม่ส่ง secret
@@ -47,8 +55,13 @@ class StdioTransport {
             stdio: ['pipe', 'pipe', 'pipe'],
         });
         this.proc.stdout?.on('data', (d) => this.onData(d.toString()));
+        // ต้อง drain stderr — piped ไว้แต่ไม่อ่าน = OS pipe buffer (~64KB) เต็ม → server บล็อกตอนเขียน log = แฮงค์
+        // เก็บหางไว้ ~2KB ช่วย debug ว่า server ตายเพราะอะไร
+        this.proc.stderr?.on('data', (d) => {
+            this.stderrTail = (this.stderrTail + d.toString()).slice(-2000);
+        });
         this.proc.on('error', () => this.fail('spawn error'));
-        this.proc.on('exit', () => this.fail('server exited'));
+        this.proc.on('exit', () => this.fail(this.stderrTail.trim() ? `server exited — ${this.stderrTail.trim().split('\n').pop()}` : 'server exited'));
         this.proc.stdin?.on('error', () => { }); // กัน EPIPE
     }
     fail(reason) {
@@ -206,16 +219,16 @@ class McpClient {
     constructor(cfg) {
         this.transport = cfg.url ? new HttpTransport(cfg.url, cfg.headers) : new StdioTransport(cfg);
     }
-    async initialize() {
+    async initialize(timeoutMs = REQUEST_TIMEOUT) {
         await this.transport.request('initialize', {
             protocolVersion: PROTOCOL_VERSION,
             capabilities: {},
             clientInfo: { name: BRAND.mcpClientName, version: VERSION },
-        });
+        }, timeoutMs);
         this.transport.notify('notifications/initialized');
     }
-    async listTools() {
-        const r = (await this.transport.request('tools/list'));
+    async listTools(timeoutMs = REQUEST_TIMEOUT) {
+        const r = (await this.transport.request('tools/list', undefined, timeoutMs));
         return r?.tools ?? [];
     }
     async callTool(name, args) {
@@ -224,12 +237,37 @@ class McpClient {
             .filter((c) => c.type === 'text')
             .map((c) => c.text ?? '')
             .join('\n');
-        return r?.isError ? `MCP error: ${text}` : text || '(no output)';
+        const capped = capMcpToolOutput(text);
+        return r?.isError ? `MCP error: ${capped}` : capped || '(no output)';
     }
     close() {
         this.transport.close();
     }
 }
+export async function probeMcpServer(cfg, timeoutMs = REQUEST_TIMEOUT) {
+    const transport = cfg.url ? 'http' : 'stdio';
+    if (!cfg.url && !cfg.command)
+        return { ok: false, transport, tools: [], error: 'ต้องมี command หรือ url' };
+    const client = new McpClient(cfg);
+    const deadline = Date.now() + Math.max(1, timeoutMs);
+    const remaining = (method) => {
+        const ms = deadline - Date.now();
+        if (ms <= 0)
+            throw new Error(`mcp timeout: ${method}`);
+        return ms;
+    };
+    try {
+        await client.initialize(remaining('initialize'));
+        const tools = await client.listTools(remaining('tools/list'));
+        return { ok: true, transport, tools };
+    }
+    catch (e) {
+        return { ok: false, transport, tools: [], error: e.message };
+    }
+    finally {
+        client.close();
+    }
+}
 function stringRecord(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         return undefined;

package/dist/memory.js

@@ -81,54 +81,121 @@ export async function loadBrainContext() {
     const brainPath = await getBrainPath();
     return brainPath ? buildBrainContext(brainPath) : '';
 }
+/** ประกอบ source parts ชุดเดียวกับที่ inject เข้า prompt จริง — ให้ CLI inspect ได้โดยไม่ drift */
+export async function buildBrainContextParts(brainPath) {
+    const idx = await readTrimmedPart({
+        id: 'ai-context-index',
+        label: 'AI Context Index',
+        brainPath,
+        relPath: 'Shared/AI-Context-Index.md',
+        maxChars: 3000,
+    });
+    const currentState = await readTrimmedPart({
+        id: 'current-state',
+        label: 'Current State',
+        brainPath,
+        relPath: 'Shared/Operating-State/current-state.md',
+        maxChars: 1500,
+        wrap: (content) => `## current-state\n${content}`,
+    });
+    const inbox = await readInboxPart(brainPath, 'Shared/Memory-Inbox/memory-inbox.md', 1200);
+    return [idx, currentState, inbox];
+}
+export function renderBrainContext(brainPath, parts) {
+    const content = parts.map((part) => part.content).filter(Boolean);
+    if (!content.length)
+        return '';
+    return `<brain_vault path="${brainPath}" note="second-brain ของ user — สิ่งที่จำไว้/state ปัจจุบันอยู่ใน block นี้; route โน้ตตาม Vault Structure Map; อ่าน/เขียนไฟล์ใน vault ด้วย absolute path ได้">\n${content.join('\n\n')}\n</brain_vault>`;
+}
 /** ประกอบ brain context จาก vault path (pure → testable) — entry + current-state + remembered facts */
 export async function buildBrainContext(brainPath) {
-    const parts = [];
-    // 1. entry/pointers (Vault Structure Map ฯลฯ)
-    const idx = await readTrimmed(join(brainPath, 'Shared', 'AI-Context-Index.md'), 3000);
-    if (idx)
-        parts.push(idx);
-    // 2. current-state — เนื้อจริง (live focus) ไม่ใช่แค่ pointer
-    const cs = await readTrimmed(join(brainPath, 'Shared', 'Operating-State', 'current-state.md'), 1500);
-    if (cs)
-        parts.push(`## current-state\n${cs}`);
-    // 3. ปิด loop: fact ที่ remember ไว้ (Memory-Inbox) กลับเข้า context — ไม่งั้น vault = write-only
-    const inbox = await inboxCandidates(join(brainPath, 'Shared', 'Memory-Inbox', 'memory-inbox.md'), 1200);
-    if (inbox)
-        parts.push(`## remembered (Memory-Inbox)\n${inbox}`);
-    if (!parts.length)
-        return '';
-    return `<brain_vault path="${brainPath}" note="second-brain ของ user — สิ่งที่จำไว้/state ปัจจุบันอยู่ใน block นี้; route โน้ตตาม Vault Structure Map; อ่าน/เขียนไฟล์ใน vault ด้วย absolute path ได้">\n${parts.join('\n\n')}\n</brain_vault>`;
+    return renderBrainContext(brainPath, await buildBrainContextParts(brainPath));
 }
-/** อ่านไฟล์ + trim หัว N ตัว ('' ถ้าไม่มี/ว่าง) */
-async function readTrimmed(p, max) {
+async function readTrimmedPart(input) {
+    const p = join(input.brainPath, input.relPath);
     try {
-        const c = (await readFile(p, 'utf8')).trim();
-        if (!c)
-            return '';
-        return c.length > max ? `${c.slice(0, max)}\n…` : c;
+        const raw = (await readFile(p, 'utf8')).trim();
+        const trimmed = raw.length > input.maxChars ? `${raw.slice(0, input.maxChars)}\n…` : raw;
+        const content = trimmed ? input.wrap?.(trimmed) ?? trimmed : '';
+        return {
+            id: input.id,
+            label: input.label,
+            relPath: input.relPath,
+            path: p,
+            content,
+            chars: content.length,
+            maxChars: input.maxChars,
+            status: content ? 'present' : 'empty',
+        };
     }
     catch {
-        return '';
+        return {
+            id: input.id,
+            label: input.label,
+            relPath: input.relPath,
+            path: p,
+            content: '',
+            chars: 0,
+            maxChars: input.maxChars,
+            status: 'missing',
+        };
     }
 }
 /** ดึงรายการ "- ..." ใต้ "## New Candidates" จาก memory-inbox (fact ที่ remember ไว้) */
 async function inboxCandidates(p, max) {
     try {
-        const after = (await readFile(p, 'utf8')).split('## New Candidates')[1];
-        if (!after)
-            return '';
-        const lines = after
-            .split('\n')
-            .filter((l) => l.trim().startsWith('- ') && !l.includes('_('))
-            .map((l) => l.trim());
-        const text = lines.join('\n').trim();
-        return text.length > max ? `${text.slice(0, max)}\n…` : text;
+        return inboxCandidatesFromText(await readFile(p, 'utf8'), max);
     }
     catch {
         return '';
     }
 }
+function inboxCandidatesFromText(content, max) {
+    const lines = content.split('\n');
+    const markerIndex = lines.findIndex((line) => line.trim() === '## New Candidates');
+    if (markerIndex === -1)
+        return '';
+    const sectionLines = [];
+    for (const line of lines.slice(markerIndex + 1)) {
+        if (/^#{1,6}\s+/.test(line.trim()))
+            break;
+        sectionLines.push(line);
+    }
+    const candidates = sectionLines
+        .filter((l) => l.trim().startsWith('- ') && !l.includes('_('))
+        .map((l) => l.trim());
+    const text = candidates.join('\n').trim();
+    return text.length > max ? `${text.slice(0, max)}\n…` : text;
+}
+async function readInboxPart(brainPath, relPath, maxChars) {
+    const p = join(brainPath, relPath);
+    try {
+        const content = inboxCandidatesFromText(await readFile(p, 'utf8'), maxChars);
+        const wrapped = content ? `## remembered (Memory-Inbox)\n${content}` : '';
+        return {
+            id: 'memory-inbox',
+            label: 'Memory Inbox',
+            relPath,
+            path: p,
+            content: wrapped,
+            chars: wrapped.length,
+            maxChars,
+            status: wrapped ? 'present' : 'empty',
+        };
+    }
+    catch {
+        return {
+            id: 'memory-inbox',
+            label: 'Memory Inbox',
+            relPath,
+            path: p,
+            content: '',
+            chars: 0,
+            maxChars,
+            status: 'missing',
+        };
+    }
+}
 /** path ของ second-brain vault จาก config (undefined = ไม่ได้ตั้ง) */
 export async function getBrainPath() {
     try {
@@ -165,7 +232,7 @@ export async function appendToVaultInbox(brainPath, fact) {
 }
 /** บันทึก worklog ย่อเข้า vault Sessions/ (รายวัน) — "second brain จำว่าวันนี้ทำอะไร" */
 export async function appendBrainWorklog(brainPath, entry) {
-    if (!worklogEnabled())
+    if (!persistenceEnabled() || !worklogEnabled())
         return false;
     const dir = join(brainPath, 'Sessions');
     if (!(await exists(dir)))