sanook-cli 0.5.1 → 0.5.5

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() {
@@ -25,10 +26,37 @@ function safeEnv() {
     }
     return out;
 }
+export function isMcpServerEnabled(cfg) {
+    return cfg.enabled !== false;
+}
+/** auth hints for hosted MCP remotes that return HTTP 401 */
+export function mcpAuthHints(cfg, error) {
+    if (!cfg.url || !error || !/\b401\b/.test(error))
+        return [];
+    const hints = [];
+    const authHeader = cfg.headers?.Authorization ?? cfg.headers?.authorization;
+    if (!authHeader) {
+        hints.push('remote server ตอบ 401 — เพิ่ม Authorization header ใน ~/.sanook/mcp.json หรือตอน install: --header Authorization=\'Bearer <token>\'');
+    }
+    else {
+        hints.push('remote server ตอบ 401 แม้มี Authorization header — ตรวจว่า token หมดอายุ, scope ไม่พอ, หรือ header name/format ไม่ตรงที่ server ต้องการ');
+    }
+    if (!Object.keys(cfg.env ?? {}).length) {
+        hints.push('บาง hosted MCP ใช้ API key ผ่าน env แทน header — ดู requirements: sanook mcp info <registry-server-name>');
+    }
+    hints.push('ทดสอบหลังแก้: sanook mcp test <name>');
+    return hints;
+}
 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 +64,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
@@ -44,11 +73,19 @@ class StdioTransport {
             // Windows: `npx`/`npm`/JS bins เป็น .cmd shim → spawn ตรงๆ = ENOENT. shell=true ให้ผ่าน PATHEXT.
             // (config นี้ user เป็นเจ้าของ/trust แล้ว — bare-name resolution เท่านั้น)
             shell: process.platform === 'win32',
+            // POSIX: own process group → close() can SIGTERM the whole tree (npx/uvx/docker wrappers
+            // spawn the real server as a grandchild; killing only the wrapper would orphan it).
+            detached: process.platform !== 'win32',
             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) {
@@ -112,11 +149,21 @@ class StdioTransport {
         this.proc.stdin?.write(`${JSON.stringify({ jsonrpc: '2.0', method, params })}\n`);
     }
     close() {
+        const pid = this.proc.pid;
         try {
-            this.proc.kill();
+            // POSIX: negative pid = the whole process group (kills npx/uvx/docker + the real server child).
+            if (pid && process.platform !== 'win32')
+                process.kill(-pid, 'SIGTERM');
+            else
+                this.proc.kill();
         }
         catch {
-            /* ตายแล้ว */
+            try {
+                this.proc.kill();
+            }
+            catch {
+                /* already dead */
+            }
         }
     }
 }
@@ -175,8 +222,11 @@ class HttpTransport {
         const sid = res.headers.get('mcp-session-id');
         if (sid)
             this.sessionId = sid;
-        if (!res.ok)
-            throw new Error(`mcp http ${res.status} ${res.statusText}`);
+        if (!res.ok) {
+            const err = new Error(`mcp http ${res.status} ${res.statusText}`);
+            err.status = res.status;
+            throw err;
+        }
         const ctype = res.headers.get('content-type') ?? '';
         if (ctype.includes('text/event-stream'))
             return this.parseSse(await res.text(), id);
@@ -206,16 +256,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 +274,39 @@ 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) {
+        const error = e.message;
+        const authHints = mcpAuthHints(cfg, error);
+        return { ok: false, transport, tools: [], error, ...(authHints.length ? { authHints } : {}) };
+    }
+    finally {
+        client.close();
+    }
+}
 function stringRecord(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         return undefined;
@@ -257,6 +334,10 @@ function sanitizeMcpServerConfig(raw) {
     const headers = stringRecord(r.headers);
     if (headers)
         cfg.headers = headers;
+    if (r.enabled === false)
+        cfg.enabled = false;
+    else if (r.enabled === true)
+        cfg.enabled = true;
     return cfg.command || cfg.url ? cfg : null;
 }
 async function readMcpFile(path, merged) {
@@ -294,6 +375,31 @@ export async function loadMcpConfig(onLog, cwd = process.cwd()) {
     }
     return merged;
 }
+/** หา path ของไฟล์ config ที่เก็บ server นี้ (global หรือ trusted project) */
+export async function findMcpServerConfigPath(name, cwd = process.cwd()) {
+    const globalPath = appHomePath('mcp.json');
+    try {
+        const cfg = JSON.parse(await readFile(globalPath, 'utf8'));
+        if (cfg.mcpServers && isValidMcpServerName(name) && name in cfg.mcpServers)
+            return globalPath;
+    }
+    catch {
+        /* no global config */
+    }
+    const root = await projectRoot(cwd);
+    const projectPath = await projectConfigPathIfTrusted('mcp.json', root);
+    if (!projectPath)
+        return undefined;
+    try {
+        const cfg = JSON.parse(await readFile(projectPath, 'utf8'));
+        if (cfg.mcpServers && isValidMcpServerName(name) && name in cfg.mcpServers)
+            return projectPath;
+    }
+    catch {
+        /* unreadable project config */
+    }
+    return undefined;
+}
 let cachePromise = null;
 let activeClients = []; // sync ref สำหรับ closeMcp ใน exit handler
 /** โหลด tools จาก MCP servers — in-flight promise singleton (concurrent call ไม่ spawn ซ้ำ/leak child) */
@@ -309,6 +415,10 @@ async function buildMcpTools(onLog) {
     const clients = [];
     activeClients = clients; // ref เดียวกัน → closeMcp kill client ที่ spawn ระหว่าง build ได้ด้วย
     for (const [serverName, cfg] of Object.entries(config)) {
+        if (!isMcpServerEnabled(cfg)) {
+            onLog?.(`MCP "${serverName}" disabled — ข้าม`);
+            continue;
+        }
         if (!cfg.url && !cfg.command) {
             onLog?.(`MCP "${serverName}" ข้าม: ต้องมี "command" (stdio) หรือ "url" (remote)`);
             continue;

package/dist/memory-log.js

@@ -0,0 +1,90 @@
+// `sanook memory log` — a read-only viewer over the BI-TEMPORAL memory store: see how a belief about
+// the project evolved over time (what was true, when it was superseded, and by what). The store keeps
+// superseded/archived facts with validFrom/invalidatedAt/supersededBy/supersedes edges — most coding
+// CLIs overwrite memory, so this "decision evolution" view is genuinely differentiated. Pure +
+// deterministic (no disk/clock of its own) → fully testable.
+import { tokens } from './memory-store.js';
+function relevance(query, fact) {
+    const q = [...tokens(query)];
+    if (!q.length)
+        return 0;
+    const ft = [...tokens(fact.text)];
+    // forgiving match for a human-facing viewer: exact OR a shared prefix (deploy↔deploys↔deployment)
+    const matches = (t) => ft.some((w) => w === t || (t.length >= 3 && (w.startsWith(t) || t.startsWith(w))));
+    let overlap = 0;
+    for (const t of q)
+        if (matches(t))
+            overlap++;
+    return overlap;
+}
+/**
+ * Facts matching `query` across ALL statuses (active + superseded + archived), each with its
+ * evolution edges resolved. Empty query → the most recently CHANGED facts (superseded/archived first)
+ * so `sanook memory log` with no args surfaces "what beliefs changed recently".
+ */
+export function memoryLog(store, query = '', limit = 12) {
+    const byId = new Map(store.facts.map((f) => [f.id, f]));
+    const q = query.trim();
+    const ranked = q
+        ? store.facts
+            .map((f) => ({ f, score: relevance(q, f) }))
+            .filter((x) => x.score > 0)
+            .sort((a, b) => b.score - a.score || b.f.updated - a.f.updated)
+            .map((x) => x.f)
+        : [...store.facts]
+            .filter((f) => f.status !== 'active') // no query → highlight what CHANGED
+            .sort((a, b) => (b.invalidatedAt ?? b.updated) - (a.invalidatedAt ?? a.updated));
+    return ranked.slice(0, limit).map((f) => ({
+        fact: f,
+        supersededBy: f.supersededBy ? byId.get(f.supersededBy) : undefined,
+        supersedes: f.supersedes.map((id) => byId.get(id)).filter((x) => !!x),
+    }));
+}
+export function memoryStats(store) {
+    const byTier = {};
+    let active = 0, superseded = 0, archived = 0;
+    for (const f of store.facts) {
+        byTier[f.tier] = (byTier[f.tier] ?? 0) + 1;
+        if (f.status === 'active')
+            active++;
+        else if (f.status === 'superseded')
+            superseded++;
+        else if (f.status === 'archived')
+            archived++;
+    }
+    return { total: store.facts.length, active, superseded, archived, byTier };
+}
+function day(ms) {
+    try {
+        return new Date(ms).toISOString().slice(0, 10);
+    }
+    catch {
+        return '?';
+    }
+}
+const BADGE = { active: '● active', superseded: '↻ superseded', archived: '⌁ archived' };
+export function renderMemoryLog(entries, query = '') {
+    if (!entries.length) {
+        return query ? `ไม่เจอ fact ที่ตรงกับ "${query}" ใน memory (รวม superseded/archived)` : 'ยังไม่มี belief ที่เปลี่ยน (superseded/archived) — memory ยังนิ่ง';
+    }
+    const lines = [query ? `memory log — "${query}" (${entries.length})` : `memory log — recent changes (${entries.length})`];
+    for (const e of entries) {
+        const f = e.fact;
+        const when = f.invalidatedAt ? `${day(f.validFrom)} → ${day(f.invalidatedAt)}` : `since ${day(f.validFrom)}`;
+        lines.push('', `${BADGE[f.status] ?? f.status}  [${f.noteType}/${f.tier}]  ${when}`);
+        lines.push(`  ${f.text}`);
+        if (e.supersededBy)
+            lines.push(`  ↳ superseded by: ${e.supersededBy.text} (${day(e.supersededBy.validFrom)})`);
+        for (const s of e.supersedes)
+            lines.push(`  ↳ supersedes: ${s.text}`);
+    }
+    return lines.join('\n');
+}
+export function renderMemoryStats(s) {
+    const tiers = Object.entries(s.byTier).map(([t, n]) => `${t}:${n}`).join(' · ') || '(none)';
+    return [
+        `memory: ${s.total} fact(s)`,
+        `  ● active ${s.active} · ↻ superseded ${s.superseded} · ⌁ archived ${s.archived}`,
+        `  tiers: ${tiers}`,
+    ].join('\n');
+}

package/dist/memory-store.js

@@ -503,6 +503,8 @@ export async function loadStore(now = Date.now()) {
         const parsed = StoreSchema.safeParse(JSON.parse(await readFile(MEMORY_JSON, 'utf8')));
         if (parsed.success)
             return parsed.data;
+        // parseable but schema-invalid (version bump / partial write): DON'T lose it — saveStore
+        // preserves the original to a .corrupt backup before the next overwrite (loadStore stays pure).
     }
     catch {
         /* no json yet, or malformed → fall through */
@@ -536,12 +538,46 @@ async function writeSecure(path, content) {
  * Both files are 0o600. On the very first json write, the legacy MEMORY.md is backed up
  * to MEMORY.md.bak so raw legacy text is never destroyed. No-op when persistence is disabled.
  */
+/**
+ * If an existing memory.json cannot be validated (schema bump / corruption / partial write),
+ * copy it verbatim to memory.json.<ts>.corrupt before it gets overwritten — so a single schema
+ * mismatch never silently destroys the entire auto-memory. Best-effort, idempotent per `now`.
+ */
+async function preserveUnvalidatableStore(now) {
+    let raw;
+    try {
+        raw = await readFile(MEMORY_JSON, 'utf8');
+    }
+    catch {
+        return;
+    }
+    try {
+        if (StoreSchema.safeParse(JSON.parse(raw)).success)
+            return; // valid → nothing to rescue
+    }
+    catch {
+        /* unparseable → preserve below */
+    }
+    const backup = `${MEMORY_JSON}.${now}.corrupt`;
+    if (await exists(backup))
+        return;
+    try {
+        await writeFile(backup, raw, { mode: 0o600 });
+        await chmod(backup, 0o600).catch(() => { });
+    }
+    catch {
+        /* best-effort */
+    }
+}
 export async function saveStore(store, now = Date.now()) {
     if (!persistenceEnabled())
         return;
     await mkdir(MEMORY_DIR, { recursive: true });
     const firstJson = !(await exists(MEMORY_JSON));
-    if (firstJson && (await exists(AUTO_MEMORY_FILE))) {
+    if (!firstJson) {
+        await preserveUnvalidatableStore(now); // data-loss guard before overwriting an unvalidatable store
+    }
+    else if (await exists(AUTO_MEMORY_FILE)) {
         await copyFile(AUTO_MEMORY_FILE, MEMORY_BAK).catch(() => { });
         await chmod(MEMORY_BAK, 0o600).catch(() => { });
     }

package/dist/memory.js

@@ -1,5 +1,7 @@
 import { readFile, writeFile, stat } from 'node:fs/promises';
 import { join, dirname, resolve } from 'node:path';
+import { buildContextPackBlock, listContextPacks, readContextPackExcerpt, selectContextPack } from './context-pack.js';
+import { buildProjectContextBlock, resolveVaultProject } from './project-registry.js';
 import { appHomePath, BRAND, persistenceEnabled, worklogEnabled } from './brand.js';
 import { redactKey } from './providers/keys.js';
 import { loadStore, saveStore, mergeFact, maybeConsolidate, consolidate, renderPromptBlock } from './memory-store.js';
@@ -77,58 +79,167 @@ export async function loadAutoMemory() {
  * "รู้จัก" vault: inject Shared/AI-Context-Index.md (ไฟล์ที่ vault บอกให้อ่านก่อน) เข้า system prompt
  * brainPath มาจาก ~/.sanook/config.json · ไม่มี/ไฟล์หาย → คืน '' (เงียบ)
  */
-export async function loadBrainContext() {
+export async function loadBrainContext(cwd = process.cwd()) {
     const brainPath = await getBrainPath();
-    return brainPath ? buildBrainContext(brainPath) : '';
-}
-/** ประกอบ 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 brainPath ? buildBrainContext(brainPath, { cwd }) : '';
+}
+/** ประกอบ source parts ชุดเดียวกับที่ inject เข้า prompt จริง — ให้ CLI inspect ได้โดยไม่ drift */
+export async function buildBrainContextParts(brainPath, options = {}) {
+    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);
+    const parts = [idx, currentState, inbox];
+    const project = await resolveVaultProject({
+        brainPath,
+        cwd: options.cwd,
+        slug: options.projectSlug,
+    });
+    if (project) {
+        const block = await buildProjectContextBlock(brainPath, project);
+        parts.push({
+            id: 'project-workspace',
+            label: `Project (${project.slug})`,
+            relPath: `${project.relDir}/`,
+            path: join(brainPath, project.relDir),
+            content: block,
+            chars: block.length,
+            maxChars: 3500,
+            status: block ? 'present' : 'empty',
+        });
+    }
+    const taskQuery = options.taskQuery?.trim();
+    if (taskQuery) {
+        const packs = await listContextPacks(brainPath);
+        const selected = selectContextPack(taskQuery, packs);
+        if (selected) {
+            const relPath = selected.pack.relPath;
+            const path = join(brainPath, relPath);
+            const maxChars = 1200;
+            const excerpt = await readContextPackExcerpt(brainPath, selected.pack, maxChars);
+            parts.push({
+                id: 'context-pack',
+                label: `Context Pack (${selected.pack.slug})`,
+                relPath,
+                path,
+                content: excerpt,
+                chars: excerpt.length,
+                maxChars,
+                status: excerpt ? 'present' : 'empty',
+            });
+        }
+    }
+    return parts;
+}
+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${parts.join('\n\n')}\n</brain_vault>`;
+    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>`;
 }
-/** อ่านไฟล์ + trim หัว N ตัว ('' ถ้าไม่มี/ว่าง) */
-async function readTrimmed(p, max) {
+/** ประกอบ brain context จาก vault path (pure → testable) — entry + current-state + remembered facts + optional context pack */
+export async function buildBrainContext(brainPath, options = {}) {
+    return renderBrainContext(brainPath, await buildBrainContextParts(brainPath, options));
+}
+/** Build a standalone context-pack block for per-turn injection (turn-retrieval path). */
+export { buildContextPackBlock };
+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 +276,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)))

package/dist/model-picker.js

@@ -0,0 +1,58 @@
+import { canonicalSpec, hasUsableEnvKey, PROVIDERS, parseSpec } from './providers/registry.js';
+function statusFor(provider) {
+    const cfg = PROVIDERS[provider];
+    if (cfg.kind === 'delegate')
+        return 'delegate';
+    if (!cfg.requiresKey)
+        return 'local';
+    return hasUsableEnvKey(provider) ? 'ready' : 'needs-key';
+}
+function statusLabel(status) {
+    if (status === 'needs-key')
+        return 'needs key';
+    return status;
+}
+export function modelPickerOptions(current) {
+    const currentSpec = canonicalSpec(current);
+    return Object.entries(PROVIDERS).flatMap(([provider, cfg]) => {
+        const grouped = new Map();
+        for (const [alias, model] of Object.entries(cfg.models)) {
+            const aliases = grouped.get(model) ?? [];
+            aliases.push(alias);
+            grouped.set(model, aliases);
+        }
+        const status = statusFor(provider);
+        return [...grouped.entries()].map(([model, aliases]) => {
+            const nonDefaultAliases = aliases.filter((alias) => alias !== 'default');
+            const displayAliases = nonDefaultAliases.length ? nonDefaultAliases.join('/') : 'default';
+            const spec = `${provider}:${model}`;
+            return {
+                aliases: displayAliases,
+                current: spec === currentSpec,
+                label: `${provider}:${displayAliases}`,
+                meta: `${cfg.label} · ${statusLabel(status)}`,
+                model,
+                provider,
+                spec,
+                status,
+            };
+        });
+    });
+}
+export function initialModelPickerIndex(options) {
+    const current = options.findIndex((option) => option.current);
+    return current === -1 ? 0 : current;
+}
+export function modelProviderEntries() {
+    return Object.entries(PROVIDERS).map(([id, cfg]) => ({
+        id,
+        label: cfg.label,
+        status: statusFor(id),
+        modelCount: new Set(Object.values(cfg.models)).size,
+    }));
+}
+export function filterModelPickerOptions(options, providerId) {
+    if (!providerId)
+        return options;
+    return options.filter((option) => option.provider === providerId);
+}