sanook-cli 0.5.11 → 0.5.13

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.5.13
+
+### Owner memory (Codex + all providers)
+
+- **Codex delegate** — `codex:gpt-5.5` now prepends `<owner_persona>` + `<auto_memory>` + brain/project context into every `codex exec` prompt (previously skipped all durable memory).
+- **SDK providers** — inject `<owner_persona>` into the static system prompt on every turn.
+- **System instructions** — when asked what you remember about the user, answer from persona/memory blocks instead of denying cross-session memory.
+
+## 0.5.12
+
+### Thai input cursor
+
+- **Cursor** — render the whole input line as one ANSI string with a cyan gap cell (`bgCyan`), not split `inverse` Text nodes that break Thai grapheme shaping and cover vowel marks.
+
 ## 0.5.11
 
 ### REPL layout stability

package/dist/commands.js

@@ -18,6 +18,7 @@ export const HELP_TEXT = `คำสั่ง:
   /setup           ดูขั้นตอน setup wizard (model · agent · tools · gateway · brain)
   /dashboard       เปิด Sanook Dashboard (local web UI)
   /persona         ตั้งค่า persona (ใครคุณเป็น + อยากให้ AI ทำงานยังไง)
+  /goal [text]     ตั้งเป้าหมาย/โฟกัสปัจจุบัน (จำข้ามทุก session) — /goal เปล่า = วิธีใช้
   /personality [name]
                    ดู/ตั้ง personality overlay
   /details [thinking|tools] [hidden|collapsed|expanded]
@@ -217,6 +218,18 @@ export function parseCommand(input, ctx) {
             };
         case 'persona':
             return { handled: true, action: 'personaSetup', message: 'เปิด persona wizard…' };
+        case 'goal': {
+            // /goal <text> sets the durable "current focus" (persona `goals` field) — remembered across
+            // every session via <owner_persona>. /goal alone shows usage (run /persona to edit the full set).
+            const goal = args.join(' ').trim();
+            if (!goal) {
+                return {
+                    handled: true,
+                    message: `ใช้: /goal <เป้าหมาย/โฟกัสตอนนี้>\n  เก็บลง persona (AI จำข้ามทุก session) · ดู/แก้ทั้งหมด: /persona`,
+                };
+            }
+            return { handled: true, action: 'goalSet', goalText: goal, message: `🎯 ตั้งเป้าหมาย → ${goal}` };
+        }
         case 'personality': {
             const raw = args.join(' ').trim();
             if (!raw)
@@ -325,6 +338,7 @@ export const BUILTIN_COMMANDS = new Set([
     'exit',
     'model',
     'personality',
+    'goal',
     'details',
     'platforms',
     'trail',

package/dist/i18n/en.js

@@ -11,7 +11,7 @@ export const en = {
         stepTools: '7. Tools & MCP',
         stepGateway: '8. Messaging gateway',
         stepBrain: '9. Second brain workspace',
-        stepComplete: '10. Ready',
+        stepComplete: '11. Ready',
         languageHint: 'You can change this later with sanook config set locale en|th',
         languageEn: 'English',
         languageTh: 'Thai (ภาษาไทย)',
@@ -47,6 +47,10 @@ export const en = {
         brainQuestion: 'Create a second-brain workspace (Obsidian) for durable AI memory?',
         brainYes: 'Yes — a few questions (name + path)',
         brainNo: 'Skip for now (run sanook brain init later)',
+        stepPersona: '10. Personal profile (persona)',
+        personaQuestion: 'Set up your persona now? (name · language · tone · goals — the AI remembers you across sessions)',
+        personaYes: 'Yes — a few quick questions (recommended)',
+        personaNo: 'Skip for now (run sanook persona or /persona later)',
         completeTitle: 'Setup complete',
         completeBody: 'Your CLI is ready. Open the dashboard for config and sessions, or start chatting in the terminal.',
         completeDashboard: 'Open Sanook Dashboard',

package/dist/i18n/th.js

@@ -11,7 +11,7 @@ export const th = {
         stepTools: '7. Tools & MCP',
         stepGateway: '8. Messaging gateway',
         stepBrain: '9. second brain workspace',
-        stepComplete: '10. พร้อมใช้งาน',
+        stepComplete: '11. พร้อมใช้งาน',
         languageHint: 'เปลี่ยนภาษาทีหลังได้: sanook config set locale en|th',
         languageEn: 'English (ภาษาอังกฤษ)',
         languageTh: 'ภาษาไทย',
@@ -47,6 +47,10 @@ export const th = {
         brainQuestion: 'สร้าง second-brain workspace (Obsidian) สำหรับความจำ AI ข้าม session?',
         brainYes: 'สร้างเลย — ตอบไม่กี่ข้อ (ชื่อ + ที่เก็บ)',
         brainNo: 'ข้ามไปก่อน (สั่ง sanook brain init ทีหลังได้)',
+        stepPersona: '10. โปรไฟล์ส่วนตัว (persona)',
+        personaQuestion: 'ตั้งโปรไฟล์ persona เลยไหม? (ชื่อ · ภาษา · โทน · เป้าหมาย — AI จะจำคุณข้ามทุก session)',
+        personaYes: 'ตั้งเลย — ตอบไม่กี่ข้อ (แนะนำ)',
+        personaNo: 'ข้ามไปก่อน (สั่ง sanook persona หรือ /persona ทีหลังได้)',
         completeTitle: 'ตั้งค่าเสร็จแล้ว',
         completeBody: 'CLI พร้อมใช้แล้ว เปิด Dashboard จัดการ config/sessions หรือเริ่มแชทใน terminal',
         completeDashboard: 'เปิด Sanook Dashboard',

package/dist/loop.js

@@ -4,7 +4,8 @@ import { resolveModel, specKey, parseSpec, PROVIDERS } from './providers/registr
 import { CostMeter, SharedBudget } from './cost.js';
 import { tools } from './tools/index.js';
 import { agentCwd } from './agentContext.js';
-import { loadMemory, loadAutoMemory, loadBrainContext } from './memory.js';
+import { loadMemory, loadAutoMemory, loadBrainContext, loadDelegateContext, loadOwnerPersonaBlock } from './memory.js';
+import { memoryStoreEpoch } from './memory-store.js';
 import { buildTurnRetrieval, PROJECT_SOURCES } from './turn-retrieval.js';
 import { loadSkills, renderAvailableSkills } from './skills.js';
 import { maybeWrapHooks } from './hooks.js';
@@ -41,6 +42,7 @@ export const SYSTEM = `You are ${BRAND.agentName}, an autonomous coding agent ru
 - If a skill in <available_skills> matches the task, load it with the skill tool BEFORE starting; use find_skills to search when unsure which fits.
 - For work that splits into independent parts (explore N modules, review N angles), fan out with task_parallel instead of doing them serially; for one big exploration whose result you only need summarized, use a single task. Kick off a long job with task_spawn and keep working, then task_collect it later or task_cancel it if it is no longer needed.
 - After finishing a multi-step task that worked and is likely to recur, use create_skill to save the procedure; use remember for durable facts/preferences.
+- Owner identity and durable preferences are injected in <owner_persona> and <auto_memory> — when asked what you remember about the user (name, preferences, past setup), answer from those blocks; do not deny memory if facts are present.
 - If the user asks for something on a schedule or recurring time ("ทุกๆ X", "ตอน X โมง", "every X", a future time), use schedule_task — the gateway (${BRAND.cliName} serve) runs it. Convert their phrasing to canonical when (every 30m / 09:00 / ISO).
 - Be concise. Answer in the user's language. Show what you found, then the answer.
 - Don't paste back file contents or large code blocks you just read or edited — the user already sees the diff/tool output; reference path:line instead. This keeps replies (and token cost) small without losing anything.`;
@@ -145,6 +147,12 @@ async function maybeWrapWithHeadroom(model) {
         stack: 'sanook-cli',
     });
 }
+// Per-session snapshot of the two memory blocks whose rendering drifts turn-to-turn (owner persona +
+// auto-memory decay with Date.now()). Frozen for the life of a session+epoch so the system-prompt
+// prefix stays byte-identical across read-only turns (prompt cache stays warm); a store write bumps
+// memoryStoreEpoch() → key changes → reload, so a name/goal set mid-session is reflected next turn.
+// Keyed by sessionId (gateway/serve runs many sessions in one process); capped to bound memory.
+const personaSnapshots = new Map();
 /**
  * แกน harness — agent loop: LLM -> tool -> result -> loop จนเสร็จ
  * multi-provider (BYOK) ผ่าน registry + cost meter + budget cap
@@ -153,23 +161,30 @@ async function runDelegate(opts) {
     const { runCodex } = await import('./providers/codex.js');
     const meter = new CostMeter(specKey(opts.model), opts.budgetUsd, agentContext.getStore()?.sharedBudget);
     const { model } = parseSpec(opts.model);
-    // codex exec ไม่เห็น conversation history เอง → prepend transcript ให้มี context ข้าม turn
-    // (ไม่งั้น REPL ทุก turn = contextless, codex ลืมที่คุยมาทั้งหมด)
-    const prior = (opts.history ?? [])
-        .map((m) => {
-        const role = m.role === 'user' ? 'User' : m.role === 'assistant' ? 'Assistant' : '';
-        if (!role)
-            return '';
-        const c = typeof m.content === 'string'
-            ? m.content
-            : Array.isArray(m.content)
-                ? m.content.map((p) => (typeof p === 'object' && p && 'type' in p && p.type === 'text' ? p.text : '')).join('')
-                : '';
-        return c.trim() ? `${role}: ${c.trim()}` : '';
-    })
+    const [context, priorParts] = await Promise.all([
+        loadDelegateContext(opts.cwd ?? agentCwd()),
+        Promise.resolve((opts.history ?? [])
+            .map((m) => {
+            const role = m.role === 'user' ? 'User' : m.role === 'assistant' ? 'Assistant' : '';
+            if (!role)
+                return '';
+            const c = typeof m.content === 'string'
+                ? m.content
+                : Array.isArray(m.content)
+                    ? m.content.map((p) => (typeof p === 'object' && p && 'type' in p && p.type === 'text' ? p.text : '')).join('')
+                    : '';
+            return c.trim() ? `${role}: ${c.trim()}` : '';
+        })
+            .filter(Boolean)
+            .join('\n\n')),
+    ]);
+    const prompt = [
+        context,
+        priorParts ? `Previous conversation:\n${priorParts}` : '',
+        `Now: ${opts.prompt}`,
+    ]
         .filter(Boolean)
-        .join('\n\n');
-    const prompt = prior ? `Previous conversation:\n${prior}\n\n---\nNow: ${opts.prompt}` : opts.prompt;
+        .join('\n\n---\n');
     // sandbox: plan/ask-mode → read-only (สกัด approval รายไฟล์ของ codex ไม่ได้ จึงไม่ให้แก้);
     // auto (--yes / config auto) → workspace-write เพื่อให้ codex แก้ไฟล์ได้จริง (ไม่งั้นเป็น coding agent ที่แก้อะไรไม่ได้)
     const sandbox = opts.planMode || (opts.permissionMode ?? 'ask') === 'ask' ? 'read-only' : 'workspace-write';
@@ -250,9 +265,17 @@ export async function runAgent(opts) {
     let meter = new CostMeter(specKey(opts.model), opts.budgetUsd, sharedBudget);
     // โหลด context: auto-memory + skills + git state + repo map + project SANOOK.md → system prompt
     // sub-agent (opts.tools) ข้าม repo map (มี subset tool + prompt เฉพาะอยู่แล้ว — ประหยัด context)
-    const [memory, autoMemory, skills, git, brain, repoMap, tuning, config] = await Promise.all([
+    // persona + auto-memory are frozen per (session, memory-epoch) so the cached prompt prefix doesn't
+    // shift every turn from decay re-ranking. Sub-agents (opts.tools) and sessionless runs skip the cache
+    // and always load fresh. A store write (remember/persona/goal) bumps the epoch → next turn reloads.
+    const snapSessionId = opts.tools ? undefined : opts.usageMeta?.sessionId;
+    const snapEpoch = memoryStoreEpoch();
+    const personaHit = snapSessionId ? personaSnapshots.get(snapSessionId) : undefined;
+    const personaCached = personaHit && personaHit.epoch === snapEpoch ? personaHit : undefined;
+    const [memory, autoMemory, ownerPersona, skills, git, brain, repoMap, tuning, config] = await Promise.all([
         loadMemory(),
-        loadAutoMemory(),
+        personaCached ? Promise.resolve(personaCached.autoMemory) : loadAutoMemory(),
+        personaCached ? Promise.resolve(personaCached.ownerPersona) : loadOwnerPersonaBlock(),
         loadSkills(),
         gitContext(opts.cwd), // worktree ของ sub-agent ถ้ามี → git context สะท้อน tree ที่ถูกต้อง
         loadBrainContext(opts.cwd ?? agentCwd()),
@@ -260,6 +283,11 @@ export async function runAgent(opts) {
         agentTuning(), // cache TTL + thinking budget (อ่านจาก config/env)
         loadConfig({}, opts.cwd ?? process.cwd()),
     ]);
+    if (snapSessionId && !personaCached) {
+        if (personaSnapshots.size > 100)
+            personaSnapshots.clear(); // bound long-running serve processes
+        personaSnapshots.set(snapSessionId, { epoch: snapEpoch, ownerPersona, autoMemory });
+    }
     // self-retrieving brain: proactively surface vault/memory/session notes relevant to THIS prompt.
     // Runs AFTER the gather so it can DEDUP against what's already statically injected (auto_memory +
     // brain hot-files) — H8 showed memory hits were otherwise 100% duplicated. Sub-agents skip it like
@@ -291,6 +319,7 @@ export async function runAgent(opts) {
     const staticSystem = [
         SYSTEM + planSuffix + brainNudge,
         personalityPrompt(config.personality),
+        ownerPersona,
         autoMemory,
         renderAvailableSkills(skills),
         brain,

package/dist/memory-store.js

@@ -23,6 +23,7 @@ import { randomUUID } from 'node:crypto';
 import { z } from 'zod';
 import { appHomePath, BRAND, persistenceEnabled } from './brand.js';
 import { redactKey } from './providers/keys.js';
+import { neutralizeBlockTags } from './prompt-safety.js';
 // ---- enums / taxonomy ------------------------------------------------------
 export const TRUST = ['owner', 'agent', 'derived', 'untrusted'];
 export const STATUS = ['active', 'superseded', 'archived'];
@@ -443,7 +444,7 @@ export function renderPromptBlock(store, now = Date.now()) {
     const picked = [];
     let size = 0;
     for (const f of ranked(store, now)) {
-        const line = `- ${f.text}`;
+        const line = `- ${neutralizeBlockTags(f.text)}`;
         if (picked.length && size + line.length + 1 > PROMPT_CAP)
             break;
         picked.push(line);
@@ -569,18 +570,22 @@ async function preserveUnvalidatableStore(now) {
         /* best-effort */
     }
 }
+// In-process "memory epoch" — bumped after every successful store write. Lets per-session callers
+// (the loop's prompt snapshot) cache a rendered memory block and invalidate it the instant a
+// remember/persona/goal write lands, instead of re-rendering every turn. Re-rendering each turn
+// otherwise busts the model prompt-prefix cache because effImportance() decays with Date.now(), so a
+// byte-identical store still produces a slightly different block on the next turn.
+let memoryEpoch = 0;
+export function memoryStoreEpoch() {
+    return memoryEpoch;
+}
 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) {
+    if (await exists(MEMORY_JSON)) {
         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(() => { });
-    }
     const tmp = join(MEMORY_DIR, `memory.${randomUUID()}.tmp`);
     try {
         await writeFile(tmp, `${JSON.stringify(store, null, 2)}\n`, { mode: 0o600 });
@@ -591,5 +596,13 @@ export async function saveStore(store, now = Date.now()) {
         await rm(tmp, { force: true }).catch(() => { });
         throw e;
     }
+    // drift guard: MEMORY.md is a DERIVED view re-rendered from the store on every write, so a hand-edit
+    // (or the legacy pre-json file) would be silently clobbered. Snapshot the current view to MEMORY.md.bak
+    // before overwriting, so the previous version is always one `cp` away — on every write, not just the first.
+    if (await exists(AUTO_MEMORY_FILE)) {
+        await copyFile(AUTO_MEMORY_FILE, MEMORY_BAK).catch(() => { });
+        await chmod(MEMORY_BAK, 0o600).catch(() => { });
+    }
     await writeSecure(AUTO_MEMORY_FILE, renderView(store, now));
+    memoryEpoch++; // invalidate any per-session prompt snapshot built from the prior store
 }

package/dist/memory.js

@@ -4,8 +4,9 @@ import { buildContextPackBlock, listContextPacks, readContextPackExcerpt, select
 import { buildProjectContextBlock, resolveVaultProject } from './project-registry.js';
 import { appHomePath, BRAND, brainTranscriptEnvForced, persistenceEnabled, worklogEnabled } from './brand.js';
 import { redactKey } from './providers/keys.js';
+import { neutralizeBlockTags } from './prompt-safety.js';
 import { loadStore, saveStore, mergeFact, maybeConsolidate, consolidate, renderPromptBlock, activeFacts } from './memory-store.js';
-import { renderPersonaProfile, personaFacts, mergePersonaAnswers, parsePersonaProfileMarkdown, personaAnswersFromFacts } from './persona.js';
+import { renderPersonaProfile, personaFacts, mergePersonaAnswers, parsePersonaProfileMarkdown, personaAnswersFromFacts, renderOwnerPersonaPromptBlock } from './persona.js';
 const MEMORY_FILE = BRAND.memoryFileName;
 // auto-memory (สิ่งที่ agent จำเองข้าม session) ย้ายไปอยู่ใน ./memory-store.ts —
 // memory.json เป็น source of truth, MEMORY.md เป็น view ที่ render จากมัน
@@ -53,8 +54,10 @@ export async function loadMemory(cwd = process.cwd()) {
         seen.add(p);
         try {
             const content = (await readFile(p, 'utf8')).trim();
+            // SANOOK.md is untrusted (anyone can drop one in a shared parent dir) — fence so it can't forge
+            // a block boundary / role tag and smuggle instructions into the system prompt (§10.4).
             if (content)
-                blocks.push(`<memory src="${p}">\n${content}\n</memory>`);
+                blocks.push(`<memory src="${p}">\n${neutralizeBlockTags(content)}\n</memory>`);
         }
         catch {
             // ไม่มีไฟล์ = ข้าม
@@ -75,6 +78,34 @@ export async function loadAutoMemory() {
         return '';
     }
 }
+/** Owner persona facts for every agent turn (REPL + Codex delegate). Empty until user runs `sanook persona` or `/persona`. */
+export async function loadOwnerPersonaBlock() {
+    try {
+        return renderOwnerPersonaPromptBlock(await loadPersonaAnswers());
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Context bundle for delegate providers (codex exec) — they skip the SDK system prompt, so we prepend
+ * owner persona + auto-memory + project/brain context manually.
+ */
+export async function loadDelegateContext(cwd = process.cwd()) {
+    const [persona, autoMemory, brain, memory] = await Promise.all([
+        loadOwnerPersonaBlock(),
+        loadAutoMemory(),
+        loadBrainContext(cwd),
+        loadMemory(cwd),
+    ]);
+    const instructions = [
+        `You are ${BRAND.agentName}.`,
+        'Durable owner facts live in <owner_persona> and <auto_memory> below.',
+        'When the user asks what you remember about them, their name, or preferences, answer from those blocks — do not claim you have no cross-session memory if facts are present.',
+        `If both blocks are empty, say you have not learned their profile yet and suggest \`${BRAND.cliName} persona\` or \`/persona\` in the REPL.`,
+    ].join(' ');
+    return [instructions, persona, autoMemory, brain, memory].filter(Boolean).join('\n\n');
+}
 /**
  * โหลด context ของ second-brain vault ที่ user scaffold ไว้ (sanook brain) — ทำให้ agent
  * "รู้จัก" vault: inject Shared/AI-Context-Index.md (ไฟล์ที่ vault บอกให้อ่านก่อน) เข้า system prompt
@@ -148,7 +179,10 @@ 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>`;
+    // vault files are user/ingested content (clippings, intake, pasted notes) = untrusted data, not
+    // instructions (§10.4). Fence so a note containing `</brain_vault>` or `<system>…` can't break out.
+    const fenced = neutralizeBlockTags(content.join('\n\n'));
+    return `<brain_vault path="${brainPath}" note="second-brain ของ user — สิ่งที่จำไว้/state ปัจจุบันอยู่ใน block นี้; route โน้ตตาม Vault Structure Map; อ่าน/เขียนไฟล์ใน vault ด้วย absolute path ได้">\n${fenced}\n</brain_vault>`;
 }
 /** ประกอบ brain context จาก vault path (pure → testable) — entry + current-state + remembered facts + optional context pack */
 export async function buildBrainContext(brainPath, options = {}) {
@@ -430,7 +464,7 @@ export async function appendMemory(fact, noteType) {
  * เขียน 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.
+ * idempotent: เขียนซ้ำ = NOOP (mergeFact). ข้ามค่าว่าง (raw typed '') เพื่อไม่ปน noise.
  */
 export async function seedPersonaMemory(input) {
     if (!persistenceEnabled())
@@ -440,9 +474,14 @@ export async function seedPersonaMemory(input) {
     const ai = input.aiName?.trim();
     const lang = input.language?.trim();
     const autonomy = input.autonomy?.trim();
-    if (owner && owner !== input.defaults?.ownerName)
+    // Gate on "did the user actually type a value" (non-empty) — NOT on equality with a default
+    // sentinel. The old `owner !== defaults.ownerName` check silently DROPPED a real name that happened
+    // to equal the placeholder ('Owner'), and forced callers to coerce blank→default first (so a skipped
+    // name became 'Owner' and was then dropped). Callers now pass the RAW typed value ('' when skipped);
+    // an empty string simply isn't seeded, any non-empty value always is.
+    if (owner)
         facts.push({ text: `เจ้าของชื่อ ${owner} — เรียกเจ้าของด้วยชื่อนี้`, noteType: 'entity', trust: 'owner', tier: 'protected' });
-    if (ai && ai !== input.defaults?.aiName)
+    if (ai)
         facts.push({ text: `AI เรียกตัวเองว่า "${ai}" เมื่อคุยกับเจ้าของ`, noteType: 'preference', trust: 'owner', tier: 'protected' });
     if (lang)
         facts.push({ text: `ภาษาที่เจ้าของต้องการให้ตอบ: ${lang}`, noteType: 'preference', trust: 'owner', tier: 'protected' });
@@ -551,3 +590,15 @@ export async function persistPersonaAnswers(answers) {
     const vaultWritten = brain ? await writePersonaProfile(brain, answers).catch(() => false) : false;
     return { memoryWritten, vaultWritten, brainPath: brain };
 }
+/**
+ * Persist a PARTIAL persona update (e.g. `/goal <text>` sets only `goals`) without clobbering the rest.
+ * `persistPersonaAnswers` rewrites the vault persona.md table from exactly the answers it's given, so
+ * passing only `{ goals }` would blank every other field. Here we load the existing answers first
+ * (memory + vault), merge the patch on top, then persist the full merged set — so a single-field update
+ * keeps name/language/tone/etc. intact in both auto-memory and the vault profile.
+ */
+export async function persistPersonaPatch(patch) {
+    const existing = await loadPersonaAnswers().catch(() => ({}));
+    const merged = mergePersonaAnswers(existing, patch);
+    return persistPersonaAnswers(merged);
+}

package/dist/persona.js

@@ -2,6 +2,7 @@
 // Pure / no-UI so it stays unit-testable; the Ink wizard (src/ui/persona-wizard.tsx)
 // renders PERSONA_QUESTIONS and the persist layer (src/memory.ts) uses personaFacts /
 // renderPersonaProfile to write to auto-memory + the second-brain vault.
+import { neutralizeBlockTags } from './prompt-safety.js';
 /** sentinel value: a select option that drops into a free-text follow-up */
 export const PERSONA_OTHER = '__other__';
 const otherOption = { label: 'อื่นๆ (พิมพ์เอง)', value: PERSONA_OTHER };
@@ -173,6 +174,15 @@ export function personaFacts(answers) {
     }
     return out;
 }
+/** Compact owner block for system/delegate prompts — facts only, no markdown table noise. */
+export function renderOwnerPersonaPromptBlock(answers) {
+    const facts = personaFacts(answers);
+    if (!facts.length)
+        return '';
+    // fence each fact: persona answers are user-typed and could contain a forged block boundary
+    const fenced = facts.map((f) => `- ${neutralizeBlockTags(f)}`).join('\n');
+    return `<owner_persona note="โปรไฟล์เจ้าของจาก sanook persona — ground truth สำหรับชื่อ/บทบาท/ความชอบ; เมื่อ user ถามว่าจำได้ไหม/ชื่ออะไร ให้ตอบจาก block นี้และ auto_memory">\n${fenced}\n</owner_persona>`;
+}
 /** human-friendly label for a stored select value (falls back to the raw value / free text). */
 function answerLabel(q, value) {
     if (q.type === 'select' && q.options) {

package/dist/prompt-safety.js

@@ -0,0 +1,13 @@
+// Prompt-injection fencing for memory/persona content that gets wrapped in XML-ish blocks
+// (<auto_memory>, <owner_persona>, <brain_vault>, …) inside the system prompt. A remembered fact or
+// vault line is untrusted data — if it contains a literal `</auto_memory>` (or a fake `<system>` /
+// role tag) it could forge the end of its block and smuggle instructions into the prompt. We break any
+// such boundary token by inserting a zero-width space after the `<`, so the rendered text looks
+// identical to a human but no longer parses as a real tag.
+const BLOCK_TAGS = /<\/?\s*(auto_memory|owner_persona|brain_vault|memory|system|user|assistant|tool_result|tool_call)\b/gi;
+const ZW = '​'; // zero-width space — visually invisible, breaks the `<tag` token
+/** Neutralize block-boundary / role tags embedded in untrusted memory text. Idempotent-ish and safe on
+ * normal prose (only touches the specific tag tokens above). */
+export function neutralizeBlockTags(text) {
+    return text.replace(BLOCK_TAGS, (m) => `<${ZW}${m.slice(1)}`);
+}

package/dist/prompt-size.js

@@ -2,7 +2,7 @@ import { BRAND } from './brand.js';
 import { loadConfig } from './config.js';
 import { gitContext } from './git.js';
 import { SYSTEM } from './loop.js';
-import { loadAutoMemory, loadBrainContext, loadMemory } from './memory.js';
+import { loadAutoMemory, loadBrainContext, loadMemory, loadOwnerPersonaBlock } from './memory.js';
 import { personalityPrompt } from './personality.js';
 import { loadRepoMap } from './repomap.js';
 import { loadSkills, renderAvailableSkills } from './skills.js';
@@ -76,10 +76,11 @@ export function serializeToolSchemas(tools) {
 export async function buildPromptSizeBreakdown(options = {}) {
     const cwd = options.cwd ?? process.cwd();
     const planMode = options.planMode ?? false;
-    const [config, memory, autoMemory, skills, git, brain, repoMap,] = await Promise.all([
+    const [config, memory, autoMemory, ownerPersona, skills, git, brain, repoMap,] = await Promise.all([
         (options.loadConfigImpl ?? loadConfig)({}, cwd),
         (options.loadMemoryImpl ?? loadMemory)(cwd),
         (options.loadAutoMemoryImpl ?? loadAutoMemory)(),
+        (options.loadOwnerPersonaBlockImpl ?? loadOwnerPersonaBlock)(),
         (options.loadSkillsImpl ?? loadSkills)(cwd),
         (options.gitContextImpl ?? gitContext)(cwd),
         (options.loadBrainContextImpl ?? loadBrainContext)(),
@@ -94,12 +95,13 @@ export async function buildPromptSizeBreakdown(options = {}) {
     const baseSystem = SYSTEM + planSuffix + brainNudge;
     const personality = personalityPrompt(config.personality);
     const skillsBlock = renderAvailableSkills(skills);
-    const staticSystem = joinPromptBlocks([baseSystem, personality, autoMemory, skillsBlock, brain, memory, repoMap]);
+    const staticSystem = joinPromptBlocks([baseSystem, personality, ownerPersona, autoMemory, skillsBlock, brain, memory, repoMap]);
     const systemPromptText = joinPromptBlocks([staticSystem, git]);
     const toolSchemaText = serializeToolSchemas(options.tools ?? builtInTools);
     const sections = [
         measurePromptSection('base-system', 'Base system', baseSystem),
         measurePromptSection('personality', 'Personality overlay', personality),
+        measurePromptSection('owner-persona', 'Owner persona', ownerPersona),
         measurePromptSection('auto-memory', 'Auto memory', autoMemory),
         measurePromptSection('skills-index', 'Skills index', skillsBlock),
         measurePromptSection('brain-context', 'Second-brain context', brain),

package/dist/ui/app.js

@@ -37,7 +37,7 @@ import { MarkdownText, StreamingMarkdownText } from './markdown.js';
 import { SessionPanel } from './session-panel.js';
 import { getTranscriptWindow, transcriptScrollStep, transcriptWindowSize } from './transcript.js';
 import { footerStatus } from './status.js';
-import { inputViewport, graphemesOf, cursorInsertGraphemeIndex, SCROLL_LEAD, SCROLL_TAIL } from './input-view.js';
+import { inputViewport, formatInputLineDisplay, formatMultilineInputDisplay } from './input-view.js';
 import { PersonaOverlay } from './persona-wizard.js';
 import { thinkingPanelLines, snapshotThinking } from './thinking-panel.js';
 import { toolTrailLines, toolTrailHeader, toolTrailWidth, updateToolTrailOnEvent } from './tool-trail.js';
@@ -974,6 +974,15 @@ export function App({ initialModel, fallbackModel, budgetUsd, permissionMode = '
                 setPersonaOpen(true);
                 return;
             }
+            if (cmd.action === 'goalSet') {
+                const goalText = cmd.goalText ?? '';
+                void (async () => {
+                    const { persistPersonaPatch } = await import('../memory.js');
+                    await persistPersonaPatch({ goals: goalText });
+                    addTurn('system', cmd.message ?? 'บันทึกเป้าหมายแล้ว');
+                })().catch((e) => addTurn('system', `goal: ${e.message}`));
+                return;
+            }
             if (cmd.action === 'insights') {
                 void renderInsights({ days: cmd.insightsDays, cwd: cmd.insightsAll ? null : undefined })
                     .then((msg) => addTurn('system', msg))
@@ -1246,20 +1255,16 @@ function InputView({ value, cursor, busy, agentStatus, toolTrail, columns = 80,
     if (!busy && !value) {
         return (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: "\u0E16\u0E32\u0E21\u0E2D\u0E30\u0E44\u0E23\u0E01\u0E47\u0E44\u0E14\u0E49 \u2014 /help \u0E14\u0E39\u0E04\u0E33\u0E2A\u0E31\u0E48\u0E07 \u00B7 /tools \u0E14\u0E39 tools \u00B7 @\u0E44\u0E1F\u0E25\u0E4C \u0E41\u0E19\u0E1A context/\u0E23\u0E39\u0E1B" }));
     }
-    // multiline (กด Alt+Enter / ลงท้าย \) — สูงหลายบรรทัดตั้งใจอยู่แล้ว: render grapheme-cursor แบบ wrap ปกติ
+    // multiline (กด Alt+Enter / ลงท้าย \) — สูงหลายบรรทัดตั้งใจอยู่แล้ว
     if (value.includes('\n')) {
-        const insertAt = cursorInsertGraphemeIndex(value, cursor);
-        const graphemes = graphemesOf(value);
-        const before = graphemes.slice(0, insertAt).join('');
-        const after = graphemes.slice(insertAt).join('');
-        return (_jsxs(Text, { children: [before, _jsx(Text, { inverse: true, children: ' ' }), after, busy ? _jsxs(Text, { dimColor: true, children: ['  ', "(\u23CE \u0E15\u0E48\u0E2D\u0E04\u0E34\u0E27)"] }) : null] }));
+        return (_jsx(Text, { wrap: "truncate-end", children: formatMultilineInputDisplay(value, cursor, { queueHint: busy ? '  (⏎ ต่อคิว)' : undefined }) }));
     }
     // บรรทัดเดียว: viewport กว้างคงที่ (เลื่อนแนวนอนแทน wrap) → กล่อง input สูง 1 บรรทัดเสมอ ไม่เด้งตอนพิมพ์ไทย
     // เผื่อ overhead: border(2) + paddingX(2) + prefix "› "(2) + ช่อง cursor/suffix ~2
     const queueHint = busy ? '  (⏎ ต่อคิว)' : '';
     const reserved = 8 + queueHint.length;
     const vp = inputViewport(value, cursor, Math.max(8, columns - reserved));
-    return (_jsxs(Text, { wrap: "truncate-end", children: [vp.lead ? _jsx(Text, { dimColor: true, children: SCROLL_LEAD }) : null, vp.before, _jsx(Text, { inverse: true, children: vp.at }), vp.after, vp.tail ? _jsx(Text, { dimColor: true, children: SCROLL_TAIL }) : null, queueHint ? _jsx(Text, { dimColor: true, children: queueHint }) : null] }));
+    return _jsx(Text, { wrap: "truncate-end", children: formatInputLineDisplay(vp, { queueHint: queueHint || undefined }) });
 }
 function statusColor(status) {
     return status === 'error' ? 'red' : status === 'running' ? 'yellow' : 'green';

package/dist/ui/banner.js

@@ -5,6 +5,7 @@ import Gradient from 'ink-gradient';
 import { homedir } from 'node:os';
 import { readFileSync } from 'node:fs';
 import { BRAND } from '../brand.js';
+import { clipToWidth, padEndToWidth } from './text-width.js';
 // gradient ของ Sanook: เขียว → ส้ม → ฟ้า (สนุก = สดใส)
 const SANOOK_GRADIENT = ['#22C55E', '#F97316', '#38BDF8'];
 const BANNER_TITLE = BRAND.bannerWide.toUpperCase();
@@ -24,11 +25,8 @@ const TINY_PANEL_COLUMNS = 44;
 const MAX_PANEL_COLUMNS = 100;
 // version จาก package.json (single source of truth) — กัน default drift เหมือน bin.ts
 const VERSION = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8')).version;
-const clip = (text, width) => {
-    if (width <= 0)
-        return '';
-    return text.length > width ? `${text.slice(0, Math.max(0, width - 1))}…` : text;
-};
+// display-width aware so the Thai brand line + box border don't drift (Thai marks 0, emoji 2 cells)
+const clip = (text, width) => clipToWidth(text, width);
 function signalText(signals) {
     return signals
         .filter((signal) => signal.label.trim() && signal.value.trim())
@@ -73,7 +71,7 @@ function bannerLines({ account, dir, model, mode, signals, version, }, columns)
         `◆ ${BRAND_LINE}`,
         flow,
         routeLine,
-        ...SERVICE_ROUTES.map(([num, label, hint]) => `› ${num} ${label.padEnd(7)} ${hint}`),
+        ...SERVICE_ROUTES.map(([num, label, hint]) => `› ${num} ${padEndToWidth(label, 7)} ${hint}`),
     ];
 }
 /** welcome banner — Hermes-style responsive wordmark + compact Sanook launchpad. */

package/dist/ui/brain-wizard.js

@@ -10,16 +10,18 @@ const DEFAULT_PATH = join(homedir(), 'Documents', BRAIN_DEFAULTS.vaultName);
 export function BrainWizard({ onComplete }) {
     const [step, setStep] = useState('path');
     const [path, setPath] = useState(DEFAULT_PATH);
-    const [ownerName, setOwnerName] = useState(BRAIN_DEFAULTS.ownerName);
-    const [aiName, setAiName] = useState(BRAIN_DEFAULTS.aiName);
+    // raw typed values — '' means "skipped" (so it isn't seeded as a name); the placeholder still shows
+    // the default so the user knows what Enter-to-skip yields in the scaffolded vault.
+    const [ownerName, setOwnerName] = useState('');
+    const [aiName, setAiName] = useState('');
     return (_jsxs(Box, { flexDirection: "column", gap: 1, marginY: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "\uD83E\uDDE0 \u0E2A\u0E23\u0E49\u0E32\u0E07 Second Brain workspace" }), step === 'path' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "1. \u0E27\u0E32\u0E07\u0E42\u0E04\u0E23\u0E07\u0E2A\u0E23\u0E49\u0E32\u0E07\u0E44\u0E27\u0E49\u0E17\u0E35\u0E48\u0E44\u0E2B\u0E19? (Enter = default)" }), _jsxs(Text, { color: "gray", children: ["   ", DEFAULT_PATH] }), _jsx(TextInput, { defaultValue: DEFAULT_PATH, placeholder: DEFAULT_PATH, onSubmit: (v) => {
                             setPath(v.trim() || DEFAULT_PATH);
                             setStep('owner');
                         } })] })), step === 'owner' && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["2. \u0E40\u0E23\u0E35\u0E22\u0E01\u0E04\u0E38\u0E13\u0E27\u0E48\u0E32\u0E2D\u0E30\u0E44\u0E23\u0E14\u0E35? (\u0E0A\u0E37\u0E48\u0E2D/\u0E0A\u0E37\u0E48\u0E2D\u0E40\u0E25\u0E48\u0E19 \u2014 Enter \u0E40\u0E1B\u0E25\u0E48\u0E32 = \u0E43\u0E0A\u0E49 \"", BRAIN_DEFAULTS.ownerName, "\")"] }), _jsx(TextInput, { placeholder: BRAIN_DEFAULTS.ownerName, onSubmit: (v) => {
-                            setOwnerName(v.trim() || BRAIN_DEFAULTS.ownerName);
+                            setOwnerName(v.trim());
                             setStep('ai');
                         } })] })), step === 'ai' && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["3. \u0E2D\u0E22\u0E32\u0E01\u0E43\u0E2B\u0E49 AI \u0E40\u0E23\u0E35\u0E22\u0E01\u0E15\u0E31\u0E27\u0E40\u0E2D\u0E07\u0E27\u0E48\u0E32\u0E2D\u0E30\u0E44\u0E23? ", _jsxs(Text, { color: "gray", children: ["(Enter \u0E40\u0E1B\u0E25\u0E48\u0E32 = \"", BRAIN_DEFAULTS.aiName, "\")"] })] }), _jsx(TextInput, { placeholder: BRAIN_DEFAULTS.aiName, onSubmit: (v) => {
-                            setAiName(v.trim() || BRAIN_DEFAULTS.aiName);
+                            setAiName(v.trim());
                             setStep('autonomy');
                         } })] })), step === 'autonomy' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "4. \u0E43\u0E2B\u0E49 AI \u0E17\u0E33\u0E07\u0E32\u0E19\u0E41\u0E1A\u0E1A\u0E44\u0E2B\u0E19?" }), _jsx(Select, { options: [
                             { label: 'ask-on-risk — ทำเลยถ้าปลอดภัย ถามเฉพาะ destructive (แนะนำ)', value: 'ask-on-risk' },

package/dist/ui/input-view.js

@@ -1,3 +1,4 @@
+import chalk from 'chalk';
 import stringWidth from 'string-width';
 import { clampCursorToGrapheme, graphemeBoundaries } from './useEditor.js';
 // ────────────────────────────────────────────────────────────────────────────
@@ -5,9 +6,9 @@ import { clampCursorToGrapheme, graphemeBoundaries } from './useEditor.js';
 // Regression guards: repl-layout-guard.test.ts + input-view.test.ts (width + gap cursor).
 //
 // Two bugs this fixes (เทียบกับ CLI เจ้าอื่นที่ "นิ่ง"):
-//  1) block cursor on Thai text — inverting the grapheme under the caret paints a solid
-//     cell over the base char + combining marks and looks like the cursor "covers" the letter.
-//     Fix: gap cursor — render an inverse space BETWEEN clusters, never on top of a letter.
+//  1) block cursor on Thai text — splitting the line across multiple Ink <Text> nodes breaks
+//     grapheme shaping; inverse video on a middle segment paints over Thai base marks + vowels.
+//     Fix: one ANSI string for the whole line + bgCyan gap cell between clusters (never inverse on letters).
 //  2) the line bounced between 1 and 2 rows while typing — a wrapping <Text> grows the box
 //     vertically the moment content crosses the right edge, shoving the footer down on every
 //     keystroke. Fix: a fixed-width horizontal viewport (readline-style) so the input box is
@@ -107,3 +108,26 @@ export function inputViewport(value, cursor, width) {
         tail: end < units.length,
     };
 }
+/** Styled gap cursor cell — background highlight, not inverse video (safer for Thai terminals). */
+export function inputCursorCell() {
+    return chalk.bgCyan.black(' ');
+}
+/**
+ * Render the whole input line as one string so Thai clusters are shaped once (no split Text nodes).
+ * The cursor is a single highlighted gap cell between grapheme clusters, never on a letter.
+ */
+export function formatInputLineDisplay(vp, opts) {
+    const lead = vp.lead ? chalk.dim(SCROLL_LEAD) : '';
+    const tail = vp.tail ? chalk.dim(SCROLL_TAIL) : '';
+    const queue = opts?.queueHint ? chalk.dim(opts.queueHint) : '';
+    return `${lead}${vp.before}${inputCursorCell()}${vp.after}${tail}${queue}`;
+}
+/** Multiline input: same single-string cursor treatment at the grapheme insert point. */
+export function formatMultilineInputDisplay(value, cursor, opts) {
+    const insertAt = cursorInsertGraphemeIndex(value, cursor);
+    const graphemes = graphemesOf(value);
+    const before = graphemes.slice(0, insertAt).join('');
+    const after = graphemes.slice(insertAt).join('');
+    const queue = opts?.queueHint ? chalk.dim(opts.queueHint) : '';
+    return `${before}${inputCursorCell()}${after}${queue}`;
+}

package/dist/ui/markdown.js

@@ -1,11 +1,11 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { memo, useRef } from 'react';
+import { clipToWidth } from './text-width.js';
 const FENCE_RE = /^\s*(`{3,}|~{3,})(.*)$/;
+// display-width aware so Thai/emoji/code lines in transcript truncate at the right column
 function clip(text, width) {
-    if (width <= 0)
-        return '';
-    return text.length > width ? `${text.slice(0, Math.max(0, width - 3))}...` : text;
+    return clipToWidth(text, width, '...');
 }
 function bodyWidth(columns) {
     return Math.max(24, Math.min(Math.max(30, columns - 4), 100));

package/dist/ui/overlay.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { HOTKEYS } from '../hotkeys.js';
+import { clipToWidth, padEndToWidth } from './text-width.js';
 const MIN_OVERLAY_COLUMNS = 42;
 const MAX_OVERLAY_COLUMNS = 96;
 const MODEL_WINDOW = 10;
@@ -34,10 +35,10 @@ function OverlayBox({ children, columns }) {
 function overlayWidth(columns) {
     return Math.max(34, Math.min(Math.max(MIN_OVERLAY_COLUMNS, Math.floor(columns || 80) - 4), MAX_OVERLAY_COLUMNS));
 }
+// display-width aware (Thai marks 0, emoji/CJK 2) so the bordered overlay columns + right edge stay
+// aligned for non-ASCII session titles / skill names / mcp targets / model labels.
 function clip(text, width) {
-    if (width <= 0)
-        return '';
-    return text.length > width ? `${text.slice(0, Math.max(0, width - 1))}…` : text;
+    return clipToWidth(text, width);
 }
 export function completionOverlayLines(items, selected, columns) {
     if (!items.length)
@@ -52,7 +53,7 @@ export function completionOverlayLines(items, selected, columns) {
     const lines = visible.map((item, offset) => {
         const index = start + offset;
         const cursor = index === safeSelected ? '>' : ' ';
-        return `${cursor} ${clip(item.display, commandWidth).padEnd(commandWidth)} ${clip(item.meta, metaWidth)}`;
+        return `${cursor} ${padEndToWidth(clip(item.display, commandWidth), commandWidth)} ${clip(item.meta, metaWidth)}`;
     });
     lines.push('↑↓ select · Tab/Enter complete');
     return lines;
@@ -113,7 +114,7 @@ export function modelOverlayLines(overlay, columns) {
         for (const [offset, provider] of visible.entries()) {
             const index = window.start + offset;
             const cursor = index === overlay.selected ? '>' : ' ';
-            lines.push(`${cursor} ${clip(provider.label, nameWidth).padEnd(nameWidth)} ${provider.modelCount} models · ${provider.status}`);
+            lines.push(`${cursor} ${padEndToWidth(clip(provider.label, nameWidth), nameWidth)} ${provider.modelCount} models · ${provider.status}`);
         }
         if (window.end < overlay.providers.length)
             lines.push(`... ${overlay.providers.length - window.end} more`);
@@ -132,7 +133,7 @@ export function modelOverlayLines(overlay, columns) {
         const index = window.start + offset;
         const cursor = index === overlay.selected ? '>' : ' ';
         const current = option.current ? '*' : ' ';
-        lines.push(`${cursor}${current} ${clip(option.label, optionWidth).padEnd(optionWidth)} ${clip(option.meta, metaWidth)}`);
+        lines.push(`${cursor}${current} ${padEndToWidth(clip(option.label, optionWidth), optionWidth)} ${clip(option.meta, metaWidth)}`);
     }
     if (window.end < overlay.options.length)
         lines.push(`... ${overlay.options.length - window.end} more`);
@@ -186,7 +187,7 @@ export function mcpOverlayLines(overlay, columns) {
     for (const [offset, server] of visible.entries()) {
         const index = window.start + offset;
         const cursor = index === overlay.selected ? '>' : ' ';
-        lines.push(`${cursor} ${clip(server.name, nameWidth).padEnd(nameWidth)} ${server.transport.padEnd(5)} ${clip(server.target, targetWidth)}`);
+        lines.push(`${cursor} ${padEndToWidth(clip(server.name, nameWidth), nameWidth)} ${server.transport.padEnd(5)} ${clip(server.target, targetWidth)}`);
     }
     if (window.end < overlay.servers.length)
         lines.push(`... ${overlay.servers.length - window.end} more`);
@@ -277,7 +278,7 @@ export function skillsOverlayLines(overlay, columns) {
     for (const [offset, skill] of visible.entries()) {
         const index = window.start + offset;
         const cursor = index === overlay.selected ? '>' : ' ';
-        lines.push(`${cursor} ${clip(skill.name, nameWidth).padEnd(nameWidth)} ${clip(skill.description || '(no description)', descWidth)}`);
+        lines.push(`${cursor} ${padEndToWidth(clip(skill.name, nameWidth), nameWidth)} ${clip(skill.description || '(no description)', descWidth)}`);
     }
     if (window.end < overlay.skills.length)
         lines.push(`... ${overlay.skills.length - window.end} more`);
@@ -321,7 +322,7 @@ export function toolsOverlayLines(overlay, columns) {
     for (const [offset, tool] of visible.entries()) {
         const index = window.start + offset;
         const cursor = index === overlay.selected ? '>' : ' ';
-        lines.push(`${cursor} ${clip(tool.group, groupWidth).padEnd(groupWidth)} ${clip(tool.name, nameWidth).padEnd(nameWidth)} ${clip(tool.summary, summaryWidth)}`);
+        lines.push(`${cursor} ${padEndToWidth(clip(tool.group, groupWidth), groupWidth)} ${padEndToWidth(clip(tool.name, nameWidth), nameWidth)} ${clip(tool.summary, summaryWidth)}`);
     }
     if (window.end < overlay.tools.length)
         lines.push(`... ${overlay.tools.length - window.end} more`);
@@ -469,7 +470,7 @@ export function sessionsOverlayLines(overlay, columns) {
         const cursor = index === overlay.selected ? '>' : ' ';
         const title = sessionTitle(session, overlay.currentCwd);
         const meta = `${session.model} · ${shortDate(session.updated)}`;
-        lines.push(`${cursor} ${clip(session.id, idWidth).padEnd(idWidth)} ${clip(title, titleWidth).padEnd(titleWidth)} ${clip(meta, metaWidth)}`);
+        lines.push(`${cursor} ${padEndToWidth(clip(session.id, idWidth), idWidth)} ${padEndToWidth(clip(title, titleWidth), titleWidth)} ${clip(meta, metaWidth)}`);
     }
     if (window.end < overlay.sessions.length)
         lines.push(`... ${overlay.sessions.length - window.end} more`);

package/dist/ui/queue.js

@@ -1,7 +1,8 @@
+import { clipToWidth } from './text-width.js';
 export const QUEUE_WINDOW = 3;
+// display-width aware: queued items are user prompts (often Thai) — clip by columns, not code units
 export function compactPreview(text, width) {
-    const max = Math.max(8, width);
-    return text.length > max ? `${text.slice(0, Math.max(0, max - 1))}…` : text;
+    return clipToWidth(text, Math.max(8, width));
 }
 export function getQueueWindow(queueLength, activeIndex = null) {
     const start = activeIndex === null ? 0 : Math.max(0, Math.min(activeIndex - 1, Math.max(0, queueLength - QUEUE_WINDOW)));

package/dist/ui/render.js

@@ -4,7 +4,7 @@ import { render } from 'ink';
 import { App } from './app.js';
 import { SetupWizard } from './setup.js';
 import { BrainWizard } from './brain-wizard.js';
-import { PersonaWizard } from './persona-wizard.js';
+import { PersonaWizard, PersonaOverlay } from './persona-wizard.js';
 import { saveKey, saveGlobalConfig, saveBrainPath } from '../config.js';
 import { BRAND } from '../brand.js';
 // Ink needs raw mode; mounting on a non-TTY stdin (piped/redirected/cron/CI) throws
@@ -33,6 +33,8 @@ export function Root({ needsSetup, appProps, clearScreen }) {
     const [model, setModel] = useState(appProps.initialModel);
     const [brainNote, setBrainNote] = useState(undefined);
     const [locale, setLocale] = useState('th');
+    // carried across the brain phase so the persona questionnaire still runs after brain creation
+    const [setupPersona, setSetupPersona] = useState(false);
     // เข้า REPL: เคลียร์จอที่เต็มไปด้วย wizard ก่อน → banner "Sanook AI" เด้งบนจอว่าง
     const enterApp = () => {
         clearScreen?.();
@@ -51,8 +53,14 @@ export function Root({ needsSetup, appProps, clearScreen }) {
                 });
                 setModel(r.model);
                 setLocale(r.locale);
+                setSetupPersona(r.setupPersona ?? false);
+                // setup → (brain?) → (persona?) → REPL. The persona phase runs after brain creation when both
+                // were requested, so a user who creates a vault AND fills the questionnaire isn't asked twice
+                // (the questionnaire prefills from the brain-seeded name).
                 if (r.createBrain)
                     setPhase('brain');
+                else if (r.setupPersona)
+                    setPhase('persona');
                 else
                     enterApp();
             })();
@@ -71,8 +79,9 @@ export function Root({ needsSetup, appProps, clearScreen }) {
                 try {
                     const res = await scaffoldBrain(target, {
                         ...BRAIN_DEFAULTS,
-                        ownerName: a.ownerName,
-                        aiName: a.aiName,
+                        // vault scaffold needs a non-empty name → apply the default when the user skipped (a.* === '')
+                        ownerName: a.ownerName || BRAIN_DEFAULTS.ownerName,
+                        aiName: a.aiName || BRAIN_DEFAULTS.aiName,
                         autonomy: a.autonomy,
                         language,
                         today,
@@ -81,12 +90,12 @@ export function Root({ needsSetup, appProps, clearScreen }) {
                     const wired = await wireBrainMcp(target).catch(() => 'skip');
                     const linked = await linkBrainToProject({ brainPath: target, cwd: process.cwd(), today }).catch(() => null);
                     // เซฟ persona/identity ที่เก็บใน wizard ลง durable memory (owner ground-truth) → agent จำได้ทันที
+                    // ส่ง RAW value (a.ownerName อาจเป็น '') — seedPersonaMemory จะข้ามค่าว่างเอง ไม่ seed 'Owner' placeholder
                     const seeded = await seedPersonaMemory({
                         ownerName: a.ownerName,
                         aiName: a.aiName,
                         language,
                         autonomy: a.autonomy,
-                        defaults: { ownerName: BRAIN_DEFAULTS.ownerName, aiName: BRAIN_DEFAULTS.aiName },
                     }).catch(() => 0);
                     const linkNote = linked?.projectRelDir
                         ? ` · project ${linked.projectRelDir} · ${linked.memoryCreated ? 'created' : 'linked'} ${BRAND.memoryFileName}`
@@ -98,11 +107,22 @@ export function Root({ needsSetup, appProps, clearScreen }) {
                 catch (e) {
                     setBrainNote(`⚠ สร้าง second-brain ไม่สำเร็จ: ${e.message} — ลองใหม่ด้วย ${'`'}sanook brain init${'`'}`);
                 }
-                enterApp();
+                if (setupPersona)
+                    setPhase('persona');
+                else
+                    enterApp();
             })();
         };
         return _jsx(BrainWizard, { onComplete: onComplete });
     }
+    if (phase === 'persona') {
+        // full persona questionnaire (PersonaOverlay loads existing answers — incl. a brain-seeded name —
+        // persists to auto-memory + vault, then reports). Its note is appended to any brain note above.
+        return (_jsx(PersonaOverlay, { onDone: (msg) => {
+                setBrainNote((n) => (n ? `${n}\n${msg}` : msg));
+                enterApp();
+            } }));
+    }
     // App mount สดตอน phase = 'app' → useState(initialModel) หยิบ model ที่เลือกจาก wizard ถูกต้อง
     return _jsx(App, { ...appProps, initialModel: model, initialNote: brainNote ?? appProps.initialNote });
 }
@@ -140,8 +160,8 @@ export function startBrainSetup() {
                 const target = expandHome(a.path);
                 const res = await scaffoldBrain(target, {
                     ...BRAIN_DEFAULTS,
-                    ownerName: a.ownerName,
-                    aiName: a.aiName,
+                    ownerName: a.ownerName || BRAIN_DEFAULTS.ownerName,
+                    aiName: a.aiName || BRAIN_DEFAULTS.aiName,
                     autonomy: a.autonomy,
                     today,
                 });
@@ -152,7 +172,6 @@ export function startBrainSetup() {
                     ownerName: a.ownerName,
                     aiName: a.aiName,
                     autonomy: a.autonomy,
-                    defaults: { ownerName: BRAIN_DEFAULTS.ownerName, aiName: BRAIN_DEFAULTS.aiName },
                 }).catch(() => 0);
                 unmount();
                 const linkLine = linked?.projectRelDir ? `\n   linked repo → ${linked.projectRelDir} · ${BRAND.memoryFileName} in cwd` : '';

package/dist/ui/session-panel.js

@@ -4,15 +4,13 @@ import { homedir } from 'node:os';
 import { useState } from 'react';
 import { BRAND } from '../brand.js';
 import { TOOL_CATALOG } from '../tool-catalog.js';
+import { clipToWidth } from './text-width.js';
 const MIN_PANEL_COLUMNS = 48;
 const COMPACT_PANEL_COLUMNS = 72;
 const MAX_PANEL_COLUMNS = 100;
 const PREVIEW_LIMIT = 4;
-const clip = (text, width) => {
-    if (width <= 0)
-        return '';
-    return text.length > width ? `${text.slice(0, Math.max(0, width - 1))}…` : text;
-};
+// display-width aware (Thai/emoji) so panel rows align with the border
+const clip = (text, width) => clipToWidth(text, width);
 function displayDir(cwd) {
     return (cwd ?? process.cwd()).replace(homedir(), '~');
 }

package/dist/ui/setup.js

@@ -31,6 +31,7 @@ export function SetupWizard({ onComplete }) {
     const [codexDeviceAttempt, setCodexDeviceAttempt] = useState(0);
     const [permissionMode, setPermissionMode] = useState('ask');
     const [gatewayHint, setGatewayHint] = useState();
+    const [createBrain, setCreateBrain] = useState(false);
     const cfg = provider ? PROVIDERS[provider] : undefined;
     const providerOptions = setupProviderOptions();
     const providerMenuLines = setupProviderMenuLines();
@@ -106,23 +107,9 @@ export function SetupWizard({ onComplete }) {
         };
     }, [step, cfg, key]);
     const modelOptions = cfg ? mergeModelOptions(cfg, remote) : [];
-    const finish = (createBrain) => {
-        if (createBrain) {
-            onComplete({
-                locale,
-                provider,
-                model,
-                envVar: cfg?.envVar ?? '',
-                key,
-                permissionMode,
-                gatewayHint,
-                createBrain: true,
-            });
-            return;
-        }
-        setStep('complete');
-    };
-    const finishRepl = () => onComplete({
+    // single terminal exit — carries both post-setup branch flags (brain creation + persona questionnaire).
+    // Root sequences them: setup → (brain?) → (persona?) → REPL.
+    const complete = (flags) => onComplete({
         locale,
         provider,
         model,
@@ -130,7 +117,8 @@ export function SetupWizard({ onComplete }) {
         key,
         permissionMode,
         gatewayHint,
-        createBrain: false,
+        createBrain: flags.createBrain,
+        setupPersona: flags.setupPersona,
     });
     const backToProvider = () => {
         setProvider('');
@@ -252,5 +240,19 @@ export function SetupWizard({ onComplete }) {
                         } })] })), step === 'brain-offer' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: m.stepBrain }), _jsx(Text, { color: "gray", children: m.brainQuestion }), _jsx(Select, { options: [
                             { label: m.brainYes, value: 'yes' },
                             { label: m.brainNo, value: 'no' },
-                        ], onChange: (v) => finish(v === 'yes') })] })), step === 'complete' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: m.stepComplete }), _jsx(Text, { bold: true, children: m.completeTitle }), _jsx(Text, { color: "gray", children: m.completeBody }), _jsxs(Text, { color: "cyan", children: ["   ", m.completeDashboard, ": ", BRAND.cliName, " dashboard"] }), gatewayHint ? _jsxs(Text, { color: "yellow", children: ["   Gateway: ", gatewayHint] }) : null, _jsxs(Text, { color: "gray", children: ["   permissionMode: ", permissionMode] }), _jsx(Select, { options: [{ label: m.completeRepl, value: 'repl' }], onChange: () => finishRepl() })] }))] }));
+                        ], onChange: (v) => {
+                            setCreateBrain(v === 'yes');
+                            setStep('persona-offer');
+                        } })] })), step === 'persona-offer' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: m.stepPersona }), _jsx(Text, { color: "gray", children: m.personaQuestion }), _jsx(Select, { options: [
+                            { label: m.personaYes, value: 'yes' },
+                            { label: m.personaNo, value: 'no' },
+                        ], onChange: (v) => {
+                            const setupPersona = v === 'yes';
+                            // jump straight to onComplete when a follow-up phase (brain/persona) will run; otherwise
+                            // show the summary 'complete' screen before entering the REPL.
+                            if (setupPersona || createBrain)
+                                complete({ createBrain, setupPersona });
+                            else
+                                setStep('complete');
+                        } })] })), step === 'complete' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: m.stepComplete }), _jsx(Text, { bold: true, children: m.completeTitle }), _jsx(Text, { color: "gray", children: m.completeBody }), _jsxs(Text, { color: "cyan", children: ["   ", m.completeDashboard, ": ", BRAND.cliName, " dashboard"] }), gatewayHint ? _jsxs(Text, { color: "yellow", children: ["   Gateway: ", gatewayHint] }) : null, _jsxs(Text, { color: "gray", children: ["   permissionMode: ", permissionMode] }), _jsx(Select, { options: [{ label: m.completeRepl, value: 'repl' }], onChange: () => complete({ createBrain: false, setupPersona: false }) })] }))] }));
 }

package/dist/ui/status.js

@@ -1,8 +1,6 @@
-const clip = (text, width) => {
-    if (width <= 0)
-        return '';
-    return text.length > width ? `${text.slice(0, Math.max(0, width - 1))}…` : text;
-};
+import { clipToWidth, displayWidth, padEndToWidth } from './text-width.js';
+// display-width aware (Thai marks 0, emoji/CJK 2) so the two-column footer stays aligned
+const clip = (text, width) => clipToWidth(text, width);
 export function statusSegments(columns) {
     const width = Math.max(20, Math.floor(columns || 80));
     return {
@@ -25,7 +23,7 @@ export function statusRuleWidths(columns, rightLabel, minLeftContent = 0) {
     const maxRight = Math.max(0, width - separatorWidth - leftFloor);
     if (!rightLabel || maxRight <= 0)
         return { leftWidth: width, rightWidth: 0, separatorWidth: 0 };
-    const rightWidth = Math.min(rightLabel.length, maxRight);
+    const rightWidth = Math.min(displayWidth(rightLabel), maxRight);
     return {
         leftWidth: Math.max(1, width - separatorWidth - rightWidth),
         rightWidth,
@@ -58,12 +56,13 @@ export function footerStatus({ branch, backgroundTaskCount = 0, busy = false, co
     if (!segments.cwd || !cwd)
         return clip(left, width);
     const right = formatCwd(cwd, branch);
-    const minRight = width >= 96 ? Math.min(right.length, 22) : Math.min(right.length, 12);
-    const minLeft = Math.min(width, Math.max(20, Math.min(left.length, width - 3 - minRight)));
+    const rightW = displayWidth(right);
+    const minRight = width >= 96 ? Math.min(rightW, 22) : Math.min(rightW, 12);
+    const minLeft = Math.min(width, Math.max(20, Math.min(displayWidth(left), width - 3 - minRight)));
     const rule = statusRuleWidths(width, right, minLeft);
     if (!rule.rightWidth)
         return clip(left, width);
-    const leftPart = clip(left, rule.leftWidth).padEnd(rule.leftWidth);
+    const leftPart = padEndToWidth(clip(left, rule.leftWidth), rule.leftWidth);
     const rightPart = clip(right, rule.rightWidth);
     return `${leftPart}${' '.repeat(rule.separatorWidth)}${rightPart}`;
 }

package/dist/ui/text-width.js

@@ -0,0 +1,52 @@
+import stringWidth from 'string-width';
+// Display-WIDTH-aware text helpers. The REPL renders Thai (combining vowels/tone marks = 0 cells),
+// emoji (2 cells), and CJK (2 cells); measuring those with String.prototype.length / .slice / .padEnd
+// counts UTF-16 code units, not terminal columns, so fixed-width layouts (banner box, status bar,
+// tool-trail columns, transcript truncation) drift, the right edge misaligns, and borders look broken
+// — differently across terminals. These helpers measure with string-width (the same table Ink uses to
+// wrap) and cut on grapheme boundaries, so a base char and its marks never split. For pure ASCII the
+// output is byte-identical to the old .length math (display width == length), so capable terminals are
+// unaffected; only Thai/emoji/CJK lines change — toward correct alignment.
+const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+/** split into grapheme clusters (base char + combining marks / emoji ZWJ sequences stay together) */
+function graphemes(text) {
+    return Array.from(segmenter.segment(text), (s) => s.segment);
+}
+/** terminal display width in columns (Thai marks 0, emoji/CJK 2) */
+export function displayWidth(text) {
+    return stringWidth(text);
+}
+/**
+ * Truncate `text` to at most `maxWidth` DISPLAY columns, appending `ellipsis` when content is cut.
+ * Cuts on grapheme boundaries (never splits a Thai cluster or emoji). When maxWidth is too small even
+ * for the ellipsis, fills with as many whole clusters as fit (no ellipsis).
+ */
+export function clipToWidth(text, maxWidth, ellipsis = '…') {
+    if (maxWidth <= 0)
+        return '';
+    if (stringWidth(text) <= maxWidth)
+        return text;
+    const ellW = stringWidth(ellipsis);
+    const budget = maxWidth > ellW ? maxWidth - ellW : maxWidth;
+    const withEllipsis = maxWidth > ellW;
+    let out = '';
+    let w = 0;
+    for (const g of graphemes(text)) {
+        const gw = Math.max(1, stringWidth(g)); // guard: a stray 0-width cluster still consumes one slot
+        if (w + gw > budget)
+            break;
+        out += g;
+        w += gw;
+    }
+    return withEllipsis ? out + ellipsis : out;
+}
+/** Pad the END with spaces to a target DISPLAY width (returns text unchanged if already ≥ target). */
+export function padEndToWidth(text, target) {
+    const pad = target - stringWidth(text);
+    return pad > 0 ? text + ' '.repeat(pad) : text;
+}
+/** Pad the START with spaces to a target DISPLAY width (returns text unchanged if already ≥ target). */
+export function padStartToWidth(text, target) {
+    const pad = target - stringWidth(text);
+    return pad > 0 ? ' '.repeat(pad) + text : text;
+}

package/dist/ui/thinking-panel.js

@@ -1,9 +1,10 @@
+import { clipToWidth } from './text-width.js';
 const THINKING_CHAR_LIMIT = 2_000;
 const THINKING_LINE_LIMIT = 6;
+// display-width aware: the panel body is the model's Thai reasoning — .length-based clipping under-fills
+// the line and can split a cluster (orphaned tone mark)
 function clip(text, width) {
-    if (width <= 0)
-        return '';
-    return text.length > width ? `${text.slice(0, Math.max(0, width - 3))}...` : text;
+    return clipToWidth(text, width, '...');
 }
 function normalize(text) {
     return text.replace(/\s+/g, ' ').trim();

package/dist/ui/tool-trail.js

@@ -1,10 +1,10 @@
 import { inspect } from 'node:util';
 import { describeToolCall } from './tool-activity.js';
+import { clipToWidth, padEndToWidth } from './text-width.js';
 export const TOOL_TRAIL_LIMIT = 6;
+// display-width aware (Thai filenames / emoji activity titles) so the trail columns stay aligned
 function clip(text, width) {
-    if (width <= 0)
-        return '';
-    return text.length > width ? `${text.slice(0, Math.max(0, width - 3))}...` : text;
+    return clipToWidth(text, width, '...');
 }
 function normalizeWhitespace(text) {
     return text.replace(/\s+/g, ' ').trim();
@@ -103,7 +103,7 @@ export function toolTrailLines(items, columns, mode = 'expanded') {
     for (const item of items) {
         const marker = markerForStatus(item.status);
         const detail = item.detail ? ` ${clip(item.detail, detailWidth)}` : '';
-        lines.push(`${marker} ${clip(item.name, nameWidth).padEnd(nameWidth)} ${item.status.padEnd(7)}${detail}`);
+        lines.push(`${marker} ${padEndToWidth(clip(item.name, nameWidth), nameWidth)} ${item.status.padEnd(7)}${detail}`);
     }
     return lines.map((line) => clip(line, width));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sanook-cli",
-  "version": "0.5.11",
+  "version": "0.5.13",
   "description": "A terminal AI coding agent — BYOK, 9 providers, MCP, cron gateway, skills, and git awareness. Built from scratch in TypeScript.",
   "type": "module",
   "bin": {