sanook-cli 0.5.7 → 0.5.8

package/dist/dashboard/terminal.js

@@ -0,0 +1,214 @@
+import { runAgent } from '../loop.js';
+import { loadConfig } from '../config.js';
+import { redactKey } from '../providers/keys.js';
+import { describeToolCall } from '../ui/tool-activity.js';
+const HISTORY = new Map(); // sessionId → conversation (localhost single-user)
+const MAX_HISTORY_SESSIONS = 20;
+function sseSend(res, event) {
+    if (res.destroyed || res.writableEnded)
+        return; // client gone — don't write to a dead socket
+    try {
+        res.write(`data: ${JSON.stringify(event)}\n\n`);
+    }
+    catch {
+        /* socket closed mid-write */
+    }
+}
+async function readJsonBody(req) {
+    const chunks = [];
+    for await (const chunk of req)
+        chunks.push(Buffer.from(chunk));
+    const raw = Buffer.concat(chunks).toString('utf8');
+    try {
+        const parsed = JSON.parse(raw || '{}');
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** POST /api/terminal/run — body {prompt, sessionId, autoApprove?} → SSE stream of agent events */
+export async function handleTerminalRun(req, res) {
+    const body = await readJsonBody(req);
+    const prompt = typeof body.prompt === 'string' ? body.prompt.trim() : '';
+    const sessionId = typeof body.sessionId === 'string' && body.sessionId ? body.sessionId : 'web';
+    const autoApprove = body.autoApprove !== false; // default true (localhost = same trust as running CLI)
+    res.writeHead(200, {
+        'content-type': 'text/event-stream; charset=utf-8',
+        'cache-control': 'no-cache, no-transform',
+        connection: 'keep-alive',
+    });
+    if (!prompt) {
+        sseSend(res, { type: 'error', message: 'empty prompt' });
+        sseSend(res, { type: 'done' });
+        res.end();
+        return;
+    }
+    const rememberedFacts = [];
+    // abort the agent run if the browser disconnects mid-stream — otherwise it keeps executing
+    // (and metering cost) and writing to a closed socket. RunAgent honors opts.signal.
+    const ac = new AbortController();
+    const onClose = () => ac.abort();
+    res.on('close', onClose);
+    // headers are already sent above, so everything that can throw stays inside this try and emits an
+    // SSE error here — otherwise the throw propagates to the server's catch, which calls writeHead(500)
+    // on an already-headed response (ERR_HTTP_HEADERS_SENT).
+    try {
+        const config = await loadConfig({});
+        const model = config.model;
+        const history = HISTORY.get(sessionId) ?? [];
+        sseSend(res, { type: 'status', detail: `Agent · ${model}` });
+        const { messages } = await runAgent({
+            model,
+            prompt,
+            history,
+            maxSteps: 20,
+            permissionMode: autoApprove ? 'auto' : 'ask',
+            signal: ac.signal,
+            usageMeta: { sessionId: `web:${sessionId}`, source: 'repl' },
+            onEvent: (e) => {
+                switch (e.type) {
+                    case 'text':
+                        if (e.text)
+                            sseSend(res, { type: 'text', text: e.text });
+                        break;
+                    case 'reasoning':
+                        if (e.text)
+                            sseSend(res, { type: 'reasoning', text: e.text });
+                        break;
+                    case 'tool-call': {
+                        if (e.tool === 'remember') {
+                            const fact = e.detail?.fact;
+                            if (typeof fact === 'string' && fact.trim())
+                                rememberedFacts.push(fact.trim());
+                        }
+                        const activity = describeToolCall(e.tool ?? 'tool', e.detail);
+                        sseSend(res, { type: 'tool-call', tool: e.tool, title: activity.title, diff: activity.diff ?? null });
+                        break;
+                    }
+                    case 'tool-result':
+                        sseSend(res, { type: 'tool-result', tool: e.tool });
+                        break;
+                    case 'status':
+                        if (typeof e.detail === 'string')
+                            sseSend(res, { type: 'status', detail: e.detail });
+                        break;
+                    case 'error':
+                        sseSend(res, { type: 'error', message: redactKey(String(e.detail ?? e.text ?? 'error')) });
+                        break;
+                }
+            },
+        });
+        HISTORY.set(sessionId, messages);
+        if (HISTORY.size > MAX_HISTORY_SESSIONS)
+            HISTORY.delete([...HISTORY.keys()][0]);
+        for (const fact of rememberedFacts)
+            sseSend(res, { type: 'memory', fact });
+        // ✨ self-improvement (same path as REPL/headless)
+        try {
+            const { maybeAutoSkill } = await import('../self-improve.js');
+            const { defaultSkillSynthesizer } = await import('../self-improve-synth.js');
+            const { loadSkills, saveSkill } = await import('../skills.js');
+            const existing = new Set((await loadSkills()).map((s) => s.name));
+            const auto = await maybeAutoSkill(prompt, { synthesize: defaultSkillSynthesizer(model), saveSkill, existingSkillNames: existing });
+            if (auto.created && auto.skillName)
+                sseSend(res, { type: 'skill', name: auto.skillName, count: auto.count });
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    catch (err) {
+        sseSend(res, { type: 'error', message: redactKey(err.message) });
+    }
+    finally {
+        res.off('close', onClose);
+    }
+    sseSend(res, { type: 'done' });
+    if (!res.writableEnded)
+        res.end();
+}
+export function resetTerminalSession(sessionId) {
+    HISTORY.delete(sessionId);
+}
+// ---- Raw shell (optional node-pty + ws) ------------------------------------
+let shellAvailability = null;
+// computed specifiers so TS/bundler don't statically resolve these optional, possibly-absent deps
+const PTY_MODULE = 'node-pty';
+const WS_MODULE = 'ws';
+export async function shellStatus() {
+    if (shellAvailability)
+        return shellAvailability;
+    const missing = [];
+    try {
+        await import(PTY_MODULE);
+    }
+    catch {
+        missing.push('node-pty');
+    }
+    try {
+        await import(WS_MODULE);
+    }
+    catch {
+        missing.push('ws');
+    }
+    shellAvailability = missing.length
+        ? { available: false, reason: `ติดตั้ง dependency เสริมก่อน: npm i ${missing.join(' ')}` }
+        : { available: true, reason: 'ready' };
+    return shellAvailability;
+}
+/** Attach a ws upgrade handler for the raw shell at /api/terminal/shell. No-op if deps missing. */
+export async function attachShell(server) {
+    const status = await shellStatus();
+    if (!status.available)
+        return;
+    // dynamic import keeps node-pty/ws optional at build/runtime
+    const pty = (await import(PTY_MODULE));
+    const wsmod = (await import(WS_MODULE));
+    const wss = new wsmod.WebSocketServer({ noServer: true });
+    server.on('upgrade', (req, socket, head) => {
+        const url = new URL(req.url ?? '/', 'http://local');
+        if (url.pathname !== '/api/terminal/shell') {
+            // not ours — destroy the half-open upgraded socket so it doesn't leak (this is the only
+            // 'upgrade' handler on the dashboard server; with noServer ws, Node won't auto-close it).
+            socket.destroy();
+            return;
+        }
+        wss.handleUpgrade(req, socket, head, (ws) => {
+            const shell = process.platform === 'win32' ? 'powershell.exe' : process.env.SHELL || 'bash';
+            const term = pty.spawn(shell, [], {
+                name: 'xterm-color',
+                cols: 80,
+                rows: 24,
+                cwd: process.env.HOME || process.cwd(),
+                env: process.env,
+            });
+            const safeKill = () => {
+                try {
+                    term.kill();
+                }
+                catch {
+                    /* pty already exited — kill() can throw for a reaped pid on some platforms */
+                }
+            };
+            term.onData((data) => ws.send(JSON.stringify({ type: 'data', data })));
+            term.onExit(() => ws.close());
+            ws.on('message', (raw) => {
+                try {
+                    const msg = JSON.parse(String(raw));
+                    if (msg.type === 'data' && typeof msg.data === 'string')
+                        term.write(msg.data);
+                    else if (msg.type === 'resize' && msg.cols && msg.rows)
+                        term.resize(msg.cols, msg.rows);
+                }
+                catch {
+                    /* ignore malformed frame */
+                }
+            });
+            ws.on('close', safeKill);
+            // without an 'error' listener, a ws error (abrupt TCP reset / protocol violation) is rethrown
+            // by Node's EventEmitter as an uncaught exception and crashes the whole dashboard server.
+            ws.on('error', safeKill);
+        });
+    });
+}

package/dist/diff.js

@@ -1,7 +1,11 @@
 // minimal unified-ish diff (zero dep) — โชว์ให้เห็นว่าแก้อะไรก่อน/หลัง โปร่งใส
 const MAX_LINES = 14;
-/** diff ของ edit (old block → new block) — render เป็น -old / +new */
-export function renderEditDiff(oldStr, newStr) {
+/**
+ * core prefix/suffix-trim diff — shared by renderEditDiff (string) and the REPL's colored
+ * diffLines (src/ui/tool-activity.ts) so the algorithm lives in one place. Callers pick their
+ * own line cap; only the formatting differs.
+ */
+export function editDiffSegments(oldStr, newStr, max = MAX_LINES) {
     const oldL = oldStr.split('\n');
     const newL = newStr.split('\n');
     // ตัด common prefix/suffix lines ที่เหมือนกัน เพื่อโชว์เฉพาะส่วนที่เปลี่ยน
@@ -15,15 +19,25 @@ export function renderEditDiff(oldStr, newStr) {
         suf++;
     const oldMid = oldL.slice(pre, oldL.length - suf);
     const newMid = newL.slice(pre, newL.length - suf);
+    return {
+        removed: oldMid.slice(0, max),
+        added: newMid.slice(0, max),
+        moreRemoved: Math.max(0, oldMid.length - max),
+        moreAdded: Math.max(0, newMid.length - max),
+    };
+}
+/** diff ของ edit (old block → new block) — render เป็น -old / +new */
+export function renderEditDiff(oldStr, newStr) {
+    const seg = editDiffSegments(oldStr, newStr, MAX_LINES);
     const lines = [];
-    for (const l of oldMid.slice(0, MAX_LINES))
+    for (const l of seg.removed)
         lines.push(`- ${l}`);
-    if (oldMid.length > MAX_LINES)
-        lines.push(`  …(-${oldMid.length - MAX_LINES} บรรทัด)`);
-    for (const l of newMid.slice(0, MAX_LINES))
+    if (seg.moreRemoved)
+        lines.push(`  …(-${seg.moreRemoved} บรรทัด)`);
+    for (const l of seg.added)
         lines.push(`+ ${l}`);
-    if (newMid.length > MAX_LINES)
-        lines.push(`  …(+${newMid.length - MAX_LINES} บรรทัด)`);
+    if (seg.moreAdded)
+        lines.push(`  …(+${seg.moreAdded} บรรทัด)`);
     return lines.join('\n');
 }
 /** สรุปการ write — จำนวนบรรทัด/ตัวอักษร + ถ้าเขียนทับ บอก before→after */

package/dist/install-info.js

@@ -0,0 +1,91 @@
+// Multi-platform install metadata — single source for Dashboard, README sync, and docs.
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const INSTALL_PKG = 'sanook-cli';
+export const INSTALL_REPO = 'Sir-chawakorn/sanook-cli';
+export const INSTALL_REPO_URL = `https://github.com/${INSTALL_REPO}`;
+export const INSTALL_BRANCH = 'main';
+/** Custom domain when DNS + Pages are configured */
+export const INSTALL_DOMAIN = 'sanook.ai';
+/** GitHub Pages project URL (works when gh-pages branch is deployed) */
+export const INSTALL_PAGES_URL = `https://${INSTALL_REPO.split('/')[0]}.github.io/${INSTALL_REPO.split('/')[1]}`;
+/** jsDelivr CDN — stable short URL without custom domain */
+export const INSTALL_CDN_URL = `https://cdn.jsdelivr.net/gh/${INSTALL_REPO}@${INSTALL_BRANCH}/scripts`;
+const __dir = dirname(fileURLToPath(import.meta.url));
+/** package.json version at build time (repo root when running from src/) */
+export function installPkgVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(join(__dir, '..', 'package.json'), 'utf8'));
+        return pkg.version ?? 'latest';
+    }
+    catch {
+        return 'latest';
+    }
+}
+export function installScriptUrl(name, preferDomain = false) {
+    if (preferDomain)
+        return `https://${INSTALL_DOMAIN}/${name}`;
+    return `https://raw.githubusercontent.com/${INSTALL_REPO}/${INSTALL_BRANCH}/scripts/${name}`;
+}
+export function installScriptPagesUrl(name) {
+    return `${INSTALL_PAGES_URL}/${name}`;
+}
+export function installScriptCdnUrl(name) {
+    return `${INSTALL_CDN_URL}/${name}`;
+}
+/** Install channels shown on Dashboard + docs. `ready` = users can run today without extra infra. */
+export function installMethods() {
+    const sh = installScriptUrl('install.sh');
+    const ps1 = installScriptUrl('install.ps1');
+    const shPages = installScriptPagesUrl('install.sh');
+    const shDomain = installScriptUrl('install.sh', true);
+    const shCdn = installScriptCdnUrl('install.sh');
+    return [
+        {
+            id: 'npm',
+            label: 'npm / npx',
+            recommended: true,
+            ready: true,
+            commands: [
+                { os: 'macOS / Linux / Windows', cmd: `npm install -g ${INSTALL_PKG}` },
+                { os: 'Run without installing', cmd: `npx ${INSTALL_PKG}` },
+            ],
+            note: 'ต้องมี Node.js ≥ 22',
+        },
+        {
+            id: 'curl',
+            label: 'Install script',
+            ready: true,
+            commands: [
+                { os: 'macOS / Linux / WSL (GitHub raw)', cmd: `curl -fsSL ${sh} | bash` },
+                { os: 'Windows PowerShell (GitHub raw)', cmd: `irm ${ps1} | iex` },
+                { os: 'CDN (jsDelivr)', cmd: `curl -fsSL ${shCdn} | bash` },
+                { os: 'GitHub Pages', cmd: `curl -fsSL ${shPages} | bash` },
+                { os: `Short URL (${INSTALL_DOMAIN})`, cmd: `curl -fsSL ${shDomain} | bash` },
+            ],
+            note: `${INSTALL_DOMAIN} ต้องตั้ง DNS ที่ GoDaddy ก่อน — ดู scripts/configure-sanook-ai-dns.sh`,
+        },
+        {
+            id: 'homebrew',
+            label: 'Homebrew',
+            ready: true,
+            commands: [
+                { os: 'macOS / Linux (trust tap ครั้งแรก)', cmd: `brew trust ${INSTALL_REPO.split('/')[0]}/tap` },
+                { os: 'macOS / Linux', cmd: `brew tap ${INSTALL_REPO.split('/')[0]}/tap` },
+                { os: 'macOS / Linux', cmd: `brew install ${INSTALL_PKG}` },
+            ],
+            note: `Live ที่ homebrew-tap — brew tap ${INSTALL_REPO.split('/')[0]}/tap && brew install ${INSTALL_PKG}`,
+        },
+        {
+            id: 'winget',
+            label: 'WinGet',
+            ready: false,
+            commands: [{ os: 'Windows', cmd: 'winget install Sanook.SanookCLI' }],
+            note: 'CLA ลงนามแล้ว — PR #391114 รอ validation + merge (release zip v0.5.7 พร้อม)',
+        },
+    ];
+}
+export function dashboardInstallPayload() {
+    return { pkg: INSTALL_PKG, version: installPkgVersion(), methods: installMethods() };
+}

package/dist/memory.js

@@ -2,9 +2,10 @@ 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 { appHomePath, BRAND, brainTranscriptEnvForced, persistenceEnabled, worklogEnabled } from './brand.js';
 import { redactKey } from './providers/keys.js';
-import { loadStore, saveStore, mergeFact, maybeConsolidate, consolidate, renderPromptBlock } from './memory-store.js';
+import { loadStore, saveStore, mergeFact, maybeConsolidate, consolidate, renderPromptBlock, activeFacts } from './memory-store.js';
+import { renderPersonaProfile, personaFacts, mergePersonaAnswers, parsePersonaProfileMarkdown, personaAnswersFromFacts } from './persona.js';
 const MEMORY_FILE = BRAND.memoryFileName;
 // auto-memory (สิ่งที่ agent จำเองข้าม session) ย้ายไปอยู่ใน ./memory-store.ts —
 // memory.json เป็น source of truth, MEMORY.md เป็น view ที่ render จากมัน
@@ -250,6 +251,23 @@ export async function getBrainPath() {
         return undefined;
     }
 }
+/**
+ * เปิด/ปิดการเก็บ "บทสนทนาเต็ม" (prompt + คำตอบ AI ทุก turn) ลง vault หรือไม่ —
+ * config.brainTranscript = true (persistent) หรือ env SANOOK_BRAIN_TRANSCRIPT (force ชั่วคราว)
+ */
+export async function brainTranscriptEnabled() {
+    if (!persistenceEnabled())
+        return false;
+    if (brainTranscriptEnvForced())
+        return true;
+    try {
+        const cfg = JSON.parse(await readFile(appHomePath('config.json'), 'utf8'));
+        return cfg.brainTranscript === true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * route fact เข้า vault Memory-Inbox (candidate buffer ตาม §4) — "AI เขียนลง second brain ของคุณ"
  * เขียนเฉพาะถ้า memory-inbox.md มีจริง (กันสร้างไฟล์ใน path ที่ไม่ใช่ vault) · คืน true ถ้าเขียน
@@ -268,13 +286,50 @@ export async function appendToVaultInbox(brainPath, fact) {
     if (content.includes(line))
         return false; // dedup
     const marker = '## New Candidates';
+    // replacer function so `$`-sequences in the fact aren't interpreted as String.replace patterns
     const next = content.includes(marker)
-        ? content.replace(marker, `${marker}\n${line}`)
+        ? content.replace(marker, () => `${marker}\n${line}`)
         : `${content.trimEnd()}\n${line}\n`;
     await writeFile(p, next);
     return true;
 }
 /** บันทึก worklog ย่อเข้า vault Sessions/ (รายวัน) — "second brain จำว่าวันนี้ทำอะไร" */
+function worklogHeader(today) {
+    return `---\ntags: [session, session-log, worklog]\nnote_type: session-log\ncreated: ${today}\nupdated: ${today}\nparent: "[[Sessions/_Index]]"\nai_surface: history\n---\n\n# ${today} — Worklog (auto by ${BRAND.cliName})\n`;
+}
+function chatTranscriptHeader(today) {
+    return `---\ntags: [session, transcript, chat]\nnote_type: session-log\ncreated: ${today}\nupdated: ${today}\nparent: "[[Sessions/_Index]]"\nai_surface: history\n---\n\n# ${today} — Chat transcript (auto by ${BRAND.cliName})\n\n> บทสนทนาเต็มของ session นี้ — เก็บอัตโนมัติทุก turn\n`;
+}
+// Matches ONLY the trailing `up:: ...` footer (anchored to EOF), never a body line that merely
+// starts with `up:: ` (e.g. pasted vault content). `[^\n]*` can't cross newlines and `\s*$` forces
+// the match to reach end-of-file, so a mid-file `up:: ` occurrence can't be mistaken for the footer.
+const UP_FOOTER_RE = /\nup:: [^\n]*\s*$/;
+function ensureSessionNoteScaffold(content, header) {
+    const clean = content.trimEnd();
+    let next = clean;
+    if (!next)
+        next = header.trimEnd();
+    else if (!next.includes('note_type: session-log'))
+        next = `${header.trimEnd()}\n\n${next}`;
+    // Append a trailing footer only if the file doesn't already end with one. We deliberately do NOT strip
+    // any mid-file `up:: ` line — it may be real user content (e.g. pasted vault text). In the rare
+    // manual-edit case where a canonical footer sits mid-body, this yields a harmless duplicate footer line
+    // rather than risk deleting vault content.
+    if (!UP_FOOTER_RE.test(`${next}\n`))
+        next = `${next.trimEnd()}\n\nup:: [[Sessions/_Index]]`;
+    return `${next.trimEnd()}\n`;
+}
+/**
+ * Insert `block` just before the note's trailing `up:: ...` footer, preserving everything above it.
+ * Uses a REPLACER FUNCTION (so `$`-sequences in user prompt/answer text are written literally, not
+ * interpreted as String.replace patterns) and matches only the final footer (UP_FOOTER_RE), so a
+ * body `up:: ` line can never trigger a greedy truncation-to-EOF. Falls back to appending if no footer.
+ */
+function insertBeforeUpFooter(content, block) {
+    return UP_FOOTER_RE.test(content)
+        ? content.replace(UP_FOOTER_RE, () => `\n${block}\nup:: [[Sessions/_Index]]\n`)
+        : `${content.trimEnd()}\n${block}`;
+}
 export async function appendBrainWorklog(brainPath, entry) {
     if (!persistenceEnabled() || !worklogEnabled())
         return false;
@@ -283,20 +338,60 @@ export async function appendBrainWorklog(brainPath, entry) {
         return false; // ไม่ใช่ vault → ข้าม
     const topic = entry.prompt.trim().split(/\s+/).slice(0, 6).join(' ').slice(0, 50) || 'work';
     const file = join(dir, `${entry.today}-worklog.md`);
-    let content;
-    try {
-        content = await readFile(file, 'utf8');
-    }
-    catch {
-        content = `---\ntags: [session, session-log, worklog]\nnote_type: session-log\ncreated: ${entry.today}\nupdated: ${entry.today}\nparent: "[[Sessions/_Index]]"\nai_surface: history\n---\n\n# ${entry.today} — Worklog (auto by ${BRAND.cliName})\n\nup:: [[Sessions/_Index]]\n`;
-    }
     const block = `\n## ${topic}\n- prompt: ${redactKey(entry.prompt).trim().slice(0, 200)}\n- model: ${entry.model}\n- ${redactKey(entry.summary).trim().slice(0, 300)}\n`;
-    // แทรกก่อน up:: ท้ายไฟล์ (กัน up:: หลุดไปกลาง)
-    const out = content.includes('\nup:: ')
-        ? content.replace(/\nup:: .*$/s, `\n${block}\nup:: [[Sessions/_Index]]\n`)
-        : `${content.trimEnd()}\n${block}`;
-    await writeFile(file, out);
-    return true;
+    // serialize the read-modify-write with withMemLock (same as appendBrainTranscript) — turns run
+    // fire-and-forget in the REPL, so two concurrent worklog appends to the same daily file would
+    // otherwise read the same baseline and the later writeFile would clobber the earlier turn's block.
+    return withMemLock(async () => {
+        let content;
+        try {
+            content = await readFile(file, 'utf8');
+        }
+        catch {
+            content = '';
+        }
+        content = ensureSessionNoteScaffold(content, worklogHeader(entry.today));
+        // แทรกก่อน up:: footer ท้ายไฟล์ (กัน up:: หลุดไปกลาง + กัน $ ใน prompt ทำ replace เพี้ยน)
+        const out = insertBeforeUpFooter(content, block);
+        await writeFile(file, out);
+        return true;
+    });
+}
+/**
+ * เก็บ "บทสนทนาเต็ม" ลง vault Sessions/<date>-<sid>-chat.md — ต่อ 1 turn = 1 block (prompt + คำตอบ AI)
+ * ต่างจาก worklog (ย่อ prompt + cost): อันนี้เก็บข้อความจริงที่คุยกัน เพื่อ "ทุกอย่างที่คุยไปอยู่ใน second brain"
+ * - gate: brainTranscriptEnabled() (config.brainTranscript / env) + ต้องมีโฟลเดอร์ Sessions/ (เป็น vault จริง)
+ * - redact API key ทั้ง 2 ฝั่ง · serialize การเขียนไฟล์เดียวกันด้วย withMemLock กัน turn ชนกัน
+ */
+export async function appendBrainTranscript(brainPath, entry) {
+    if (!(await brainTranscriptEnabled()))
+        return false;
+    const dir = join(brainPath, 'Sessions');
+    if (!(await exists(dir)))
+        return false; // ไม่ใช่ vault → ข้าม
+    const created = entry.createdIso ?? new Date().toISOString();
+    const today = created.slice(0, 10);
+    const sid = entry.sessionId.slice(-6) || 'session';
+    const file = join(dir, `${today}-${sid}-chat.md`);
+    const time = created.slice(11, 16); // HH:MM (UTC)
+    const prompt = redactKey(entry.prompt).trim();
+    const answer = redactKey(entry.answer).trim();
+    if (!prompt && !answer)
+        return false;
+    return withMemLock(async () => {
+        let content;
+        try {
+            content = await readFile(file, 'utf8');
+        }
+        catch {
+            content = '';
+        }
+        content = ensureSessionNoteScaffold(content, chatTranscriptHeader(today));
+        const block = [`\n## ${time} · ${entry.model}`, '', '**You:**', '', prompt || '_(empty)_', '', `**${BRAND.agentName}:**`, '', answer || '_(no text output)_', ''].join('\n');
+        const out = insertBeforeUpFooter(content, block);
+        await writeFile(file, out);
+        return true;
+    });
 }
 // in-process write serializer: the AI SDK runs tool calls from one model step concurrently, so two
 // `remember` calls in a turn would otherwise load → mergeFact → save on the SAME baseline and the
@@ -331,3 +426,128 @@ export async function appendMemory(fact, noteType) {
             await appendToVaultInbox(brain, safeFact).catch(() => false);
     });
 }
+/**
+ * เขียน persona/identity ที่เก็บตอน setup (ขั้นที่ 9) ลง durable auto-memory เป็น owner ground-truth
+ * (tier protected, trust owner) → หลัง setup เสร็จ agent "จำ" ว่าเจ้าของชื่ออะไร / เรียก AI ว่าอะไร /
+ * ภาษา + autonomy ทันที โดยไม่ต้องรอ remember. ใช้คู่กับ scaffoldBrain ที่ substitute ลงไฟล์ vault อยู่แล้ว.
+ * idempotent: เขียนซ้ำ = NOOP (mergeFact). ข้ามค่า default/ว่าง เพื่อไม่ปน noise.
+ */
+export async function seedPersonaMemory(input) {
+    if (!persistenceEnabled())
+        return 0;
+    const facts = [];
+    const owner = input.ownerName?.trim();
+    const ai = input.aiName?.trim();
+    const lang = input.language?.trim();
+    const autonomy = input.autonomy?.trim();
+    if (owner && owner !== input.defaults?.ownerName)
+        facts.push({ text: `เจ้าของชื่อ ${owner} — เรียกเจ้าของด้วยชื่อนี้`, noteType: 'entity', trust: 'owner', tier: 'protected' });
+    if (ai && ai !== input.defaults?.aiName)
+        facts.push({ text: `AI เรียกตัวเองว่า "${ai}" เมื่อคุยกับเจ้าของ`, noteType: 'preference', trust: 'owner', tier: 'protected' });
+    if (lang)
+        facts.push({ text: `ภาษาที่เจ้าของต้องการให้ตอบ: ${lang}`, noteType: 'preference', trust: 'owner', tier: 'protected' });
+    if (autonomy)
+        facts.push({ text: `ระดับ autonomy ที่เจ้าของเลือก: ${autonomy}`, noteType: 'preference', trust: 'owner', tier: 'protected' });
+    if (!facts.length)
+        return 0;
+    let written = 0;
+    await withMemLock(async () => {
+        let store = await loadStore();
+        for (const inc of facts) {
+            const { store: next, op } = mergeFact(store, { ...inc, text: redactKey(inc.text) });
+            // persist any store mutation (NOOP bumps accessCount, QUARANTINE holds the fact aside),
+            // but only count facts actually remembered as new/changed — so a re-run with identical
+            // answers reports "nothing new" instead of falsely claiming N facts were saved.
+            if (op !== 'PROTECTED_HALT') {
+                store = next;
+                if (op === 'ADD' || op === 'UPDATE' || op === 'SUPERSEDE')
+                    written += 1;
+            }
+        }
+        await saveStore(store);
+    });
+    return written;
+}
+/**
+ * เขียน persona facts จาก `sanook persona` ลง durable auto-memory เป็น owner ground-truth
+ * (tier protected, trust owner) → agent "จำ" persona ทันทีทุก session โดยไม่ต้องรอ remember.
+ * idempotent: เขียนซ้ำ = merge/NOOP. รับ plain-string facts (สร้างจาก personaFacts()).
+ */
+export async function seedPersonaFacts(facts) {
+    if (!persistenceEnabled())
+        return 0;
+    const list = facts.map((f) => f.trim()).filter(Boolean);
+    if (!list.length)
+        return 0;
+    let written = 0;
+    await withMemLock(async () => {
+        let store = await loadStore();
+        for (const text of list) {
+            const { store: next, op } = mergeFact(store, {
+                text: redactKey(text),
+                noteType: 'preference',
+                trust: 'owner',
+                tier: 'protected',
+            });
+            // persist any store mutation (NOOP bumps accessCount, QUARANTINE holds the fact aside),
+            // but only count facts actually remembered as new/changed — so a re-run with identical
+            // answers reports "nothing new" instead of falsely claiming N facts were saved.
+            if (op !== 'PROTECTED_HALT') {
+                store = next;
+                if (op === 'ADD' || op === 'UPDATE' || op === 'SUPERSEDE')
+                    written += 1;
+            }
+        }
+        await saveStore(store);
+    });
+    return written;
+}
+/**
+ * เขียนโปรไฟล์ persona ลง second-brain vault ที่ Shared/User-Persona/persona.md
+ * (เขียนทับเสมอ — ไฟล์นี้เป็น canonical output ของ `sanook persona`). คืน false ถ้าไม่ใช่ vault จริง.
+ */
+export async function writePersonaProfile(brainPath, answers) {
+    const personaDir = join(brainPath, 'Shared', 'User-Persona');
+    if (!(await exists(personaDir)))
+        return false; // ไม่ใช่ vault ที่ scaffold แล้ว → ข้าม
+    const today = new Date().toISOString().slice(0, 10);
+    const md = redactKey(renderPersonaProfile(answers, today));
+    await writeFile(join(personaDir, 'persona.md'), md);
+    return true;
+}
+/** โหลดคำตอบ persona ที่มีอยู่ — vault persona.md ชนะ memory facts (สำหรับ pre-fill wizard) */
+export async function loadPersonaAnswers() {
+    const brain = await getBrainPath().catch(() => undefined);
+    let fromVault = {};
+    if (brain) {
+        const p = join(brain, 'Shared', 'User-Persona', 'persona.md');
+        try {
+            fromVault = parsePersonaProfileMarkdown(await readFile(p, 'utf8'));
+        }
+        catch {
+            /* no profile yet */
+        }
+    }
+    let fromMemory = {};
+    if (persistenceEnabled()) {
+        try {
+            const store = await loadStore();
+            const texts = activeFacts(store)
+                .filter((f) => f.trust === 'owner' || f.tier === 'protected')
+                .map((f) => f.text);
+            fromMemory = personaAnswersFromFacts(texts);
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    return mergePersonaAnswers(fromMemory, fromVault);
+}
+/** บันทึก persona ครบชุด — auto-memory + vault profile (ใช้ทั้ง CLI และ REPL /persona) */
+export async function persistPersonaAnswers(answers) {
+    const facts = personaFacts(answers);
+    const memoryWritten = await seedPersonaFacts(facts).catch(() => 0);
+    const brain = await getBrainPath().catch(() => undefined);
+    const vaultWritten = brain ? await writePersonaProfile(brain, answers).catch(() => false) : false;
+    return { memoryWritten, vaultWritten, brainPath: brain };
+}