sanook-cli 0.5.10 → 0.5.13

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # 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
+
+- **Transcript** — completed chat turns render in Ink `<Static>` so typing no longer redraws the whole history (input dock stays put).
+- **Input** — Thai-safe gap cursor + single-row horizontal viewport (no 1↔2 line bounce).
+- **Completions** — fixed-height slot for `/` and `@` completion overlay so the prompt does not jump when suggestions appear.
+- **Regression guards** — source + behavior tests in `repl-layout-guard.test.ts`, `repl-input.test.tsx`, `overlay.test.tsx`.
+
 ## 0.5.10
 
 - Patch release (npm republish guard — use this version after 0.5.9 is already on the registry).

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

@@ -2,7 +2,7 @@ import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-run
 import { useEffect, useState, useRef } from 'react';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
-import { Box, Text, useApp, useInput, useStdout } from 'ink';
+import { Box, Static, Text, useApp, useInput, useStdout } from 'ink';
 import { homedir } from 'node:os';
 import { BUILTIN_COMMANDS, HELP_TEXT, expandCustomCommand, loadCustomCommands, parseCommand, parseSlashInvocation, } from '../commands.js';
 import { runAgent } from '../loop.js';
@@ -31,13 +31,13 @@ import { expandMentions } from './mentions.js';
 import { BRAND } from '../brand.js';
 import { backgroundTaskRunningCount, listBackgroundTasks } from '../tools/task.js';
 import { Banner } from './banner.js';
-import { CompletionOverlay, FloatingOverlay, firstUserSummary } from './overlay.js';
+import { CompletionOverlay, FloatingOverlay, firstUserSummary, shouldReserveCompletionSlot } from './overlay.js';
 import { clampQueueActiveIndex, compactPreview, getQueueWindow, queueActiveIndexAfterDelete } from './queue.js';
 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, cursorGraphemeIndex, 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';
@@ -176,6 +176,9 @@ export function App({ initialModel, fallbackModel, budgetUsd, permissionMode = '
     };
     const addTurn = (role, text, extras) => {
         setTranscriptScroll(0);
+        // Remount frozen transcript when history grows so scrollback styling (e.g. latest-only expanded
+        // tool diffs) stays correct. Keystrokes never call addTurn, so the input dock stays stable while typing.
+        setHistoryResetKey((key) => key + 1);
         setHistory((h) => [
             ...h,
             {
@@ -212,6 +215,7 @@ export function App({ initialModel, fallbackModel, budgetUsd, permissionMode = '
     const pagerPageSize = Math.max(5, Math.min(18, (stdout?.rows ?? 24) - 10));
     const completion = !overlay && !busy ? completionForInput(editor.value, cwd) : { items: [], replaceFrom: 0 };
     const completions = completion.items;
+    const reserveCompletionSlot = shouldReserveCompletionSlot(editor.value, completions);
     const selectedCompletion = clampCompletionIndex(completionIndex, completions.length);
     useEffect(() => {
         let alive = true;
@@ -970,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))
@@ -1208,20 +1221,25 @@ export function App({ initialModel, fallbackModel, budgetUsd, permissionMode = '
     const transcriptLimit = transcriptWindowSize(stdout?.rows);
     const transcriptView = getTranscriptWindow(history.length, transcriptLimit, transcriptScroll);
     const visibleHistory = history.slice(transcriptView.start, transcriptView.end);
-    return (_jsxs(Box, { flexDirection: "column", children: [history.length === 0 ? (_jsxs(_Fragment, { children: [_jsx(Banner, { columns: columns, model: model, mode: permissionMode === 'ask' ? 'ask' : 'auto', signals: bannerSignals }), _jsx(SessionPanel, { columns: columns, cwd: cwd, mcp: startupReadiness.mcp, model: model, mode: permissionMode === 'ask' ? 'ask' : 'auto', skills: startupReadiness.skills })] })) : null, transcriptView.showOlder ? (_jsxs(Text, { dimColor: true, children: ["\u2026 ", transcriptView.start, " older turns \u00B7 PgUp/Ctrl+U scroll \u00B7 PgDn/Ctrl+D newer"] })) : null, visibleHistory.map((turn) => (_jsx(TurnView, { columns: columns, isLatest: turn.id === latestTrailTurnId, thinkingMode: thinkingMode, toolTrailMode: toolTrailMode, turn: turn }, `${historyResetKey}-${turn.id}`))), transcriptView.showNewer ? (_jsxs(Text, { dimColor: true, children: ["\u2026 ", transcriptView.scrollFromBottom, " newer turns hidden \u00B7 PgDn/Ctrl+D to catch up"] })) : null, thinkingView.length ? _jsx(ThinkingView, { columns: columns, mode: thinkingMode, text: thinking }) : null, streaming ? (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(StreamingMarkdownText, { columns: columns, text: streaming }) })) : null, showToolTrail ? (_jsx(ToolTrailView, { columns: columns, items: toolTrail, mode: toolTrailMode })) : null, _jsx(FloatingOverlay, { columns: columns, overlay: overlay, pageSize: pagerPageSize }), _jsx(CompletionOverlay, { columns: columns, items: completions, selected: selectedCompletion }), queued.length ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { dimColor: true, children: ["queued (", queued.length, ") \u00B7 \u2191\u2193 select \u00B7 Ctrl+X delete \u00B7 Esc clears"] }), queueWindow.showLead ? _jsx(Text, { dimColor: true, children: " \u2026" }) : null, queued.slice(queueWindow.start, queueWindow.end).map((q, i) => (_jsxs(Text, { color: queueWindow.start + i === activeQueueIndex ? 'yellow' : undefined, dimColor: queueWindow.start + i !== activeQueueIndex, children: [queueWindow.start + i === activeQueueIndex ? '›' : ' ', " ", queueWindow.start + i + 1, ".", ' ', compactPreview(q, Math.max(16, columns - 10))] }, `${queueWindow.start + i}-${q.slice(0, 16)}`))), queueWindow.showTail ? _jsxs(Text, { dimColor: true, children: ["  \u2026and ", queued.length - queueWindow.end, " more"] }) : null] })) : null, approvalReq ? (_jsxs(Box, { marginTop: 1, borderStyle: "round", borderColor: "yellow", paddingX: 1, flexDirection: "column", children: [_jsxs(Text, { color: "yellow", children: ["\u0E2D\u0E19\u0E38\u0E21\u0E31\u0E15\u0E34\u0E23\u0E31\u0E19 ", approvalReq.tool, "?"] }), _jsx(Text, { dimColor: true, children: approvalReq.summary }), _jsx(Text, { dimColor: true, children: "y = \u0E23\u0E31\u0E19 \u00B7 n = \u0E1B\u0E0F\u0E34\u0E40\u0E2A\u0E18" })] })) : personaOpen ? (_jsx(PersonaOverlay, { onDone: (msg) => { setPersonaOpen(false); addTurn('system', msg); } })) : (_jsxs(Box, { marginTop: 1, borderStyle: "round", borderColor: busy ? 'gray' : 'blue', paddingX: 1, children: [_jsx(Text, { color: busy ? 'gray' : 'cyan', children: busy ? '· ' : '› ' }), _jsx(InputView, { value: editor.value, cursor: editor.cursor, busy: busy, agentStatus: agentStatus, toolTrail: toolTrail, columns: columns })] })), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: footerStatus({
-                    branch: gitBranch,
-                    backgroundTaskCount: bgTaskCount,
-                    busy,
-                    columns,
-                    contextCompression,
-                    contextTokens,
-                    costHint,
-                    cwd,
-                    elapsedSeconds: busyElapsedSeconds,
-                    model,
-                    mode: permissionMode === 'ask' ? 'ask' : 'auto',
-                    queuedCount: queued.length,
-                }) })] }));
+    // REPL layout invariants — see repl-layout-guard.test.ts (regression guards if this jumps while typing).
+    // Pinned to latest: freeze completed turns in Ink <Static> so keystrokes only redraw input/footer
+    // (readline / Claude Code pattern). When scrolled up, fall back to a windowed dynamic transcript.
+    const pinnedToBottom = transcriptScroll === 0;
+    const renderTurn = (turn) => (_jsx(TurnView, { columns: columns, isLatest: turn.id === latestTrailTurnId, thinkingMode: thinkingMode, toolTrailMode: toolTrailMode, turn: turn }, turn.id));
+    return (_jsxs(Box, { flexDirection: "column", children: [history.length === 0 ? (_jsxs(_Fragment, { children: [_jsx(Banner, { columns: columns, model: model, mode: permissionMode === 'ask' ? 'ask' : 'auto', signals: bannerSignals }), _jsx(SessionPanel, { columns: columns, cwd: cwd, mcp: startupReadiness.mcp, model: model, mode: permissionMode === 'ask' ? 'ask' : 'auto', skills: startupReadiness.skills })] })) : null, pinnedToBottom ? (history.length ? (_jsx(Static, { items: history, children: (turn) => renderTurn(turn) }, historyResetKey)) : null) : (_jsxs(_Fragment, { children: [transcriptView.showOlder ? (_jsxs(Text, { dimColor: true, children: ["\u2026 ", transcriptView.start, " older turns \u00B7 PgUp/Ctrl+U scroll \u00B7 PgDn/Ctrl+D newer"] })) : null, visibleHistory.map((turn) => renderTurn(turn)), transcriptView.showNewer ? (_jsxs(Text, { dimColor: true, children: ["\u2026 ", transcriptView.scrollFromBottom, " newer turns hidden \u00B7 PgDn/Ctrl+D to catch up"] })) : null] })), _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [thinkingView.length ? _jsx(ThinkingView, { columns: columns, mode: thinkingMode, text: thinking }) : null, streaming ? (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(StreamingMarkdownText, { columns: columns, text: streaming }) })) : null, showToolTrail ? (_jsx(ToolTrailView, { columns: columns, items: toolTrail, mode: toolTrailMode })) : null, _jsx(FloatingOverlay, { columns: columns, overlay: overlay, pageSize: pagerPageSize }), _jsx(CompletionOverlay, { columns: columns, items: completions, reserved: reserveCompletionSlot, selected: selectedCompletion }), queued.length ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { dimColor: true, children: ["queued (", queued.length, ") \u00B7 \u2191\u2193 select \u00B7 Ctrl+X delete \u00B7 Esc clears"] }), queueWindow.showLead ? _jsx(Text, { dimColor: true, children: " \u2026" }) : null, queued.slice(queueWindow.start, queueWindow.end).map((q, i) => (_jsxs(Text, { color: queueWindow.start + i === activeQueueIndex ? 'yellow' : undefined, dimColor: queueWindow.start + i !== activeQueueIndex, children: [queueWindow.start + i === activeQueueIndex ? '›' : ' ', " ", queueWindow.start + i + 1, ".", ' ', compactPreview(q, Math.max(16, columns - 10))] }, `${queueWindow.start + i}-${q.slice(0, 16)}`))), queueWindow.showTail ? _jsxs(Text, { dimColor: true, children: ["  \u2026and ", queued.length - queueWindow.end, " more"] }) : null] })) : null, approvalReq ? (_jsxs(Box, { marginTop: 1, borderStyle: "round", borderColor: "yellow", paddingX: 1, flexDirection: "column", children: [_jsxs(Text, { color: "yellow", children: ["\u0E2D\u0E19\u0E38\u0E21\u0E31\u0E15\u0E34\u0E23\u0E31\u0E19 ", approvalReq.tool, "?"] }), _jsx(Text, { dimColor: true, children: approvalReq.summary }), _jsx(Text, { dimColor: true, children: "y = \u0E23\u0E31\u0E19 \u00B7 n = \u0E1B\u0E0F\u0E34\u0E40\u0E2A\u0E18" })] })) : personaOpen ? (_jsx(PersonaOverlay, { onDone: (msg) => { setPersonaOpen(false); addTurn('system', msg); } })) : (_jsxs(Box, { marginTop: 1, borderStyle: "round", borderColor: busy ? 'gray' : 'blue', paddingX: 1, flexDirection: "row", flexShrink: 0, children: [_jsx(Text, { color: busy ? 'gray' : 'cyan', children: busy ? '· ' : '› ' }), _jsx(InputView, { value: editor.value, cursor: editor.cursor, busy: busy, agentStatus: agentStatus, toolTrail: toolTrail, columns: columns })] })), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: footerStatus({
+                            branch: gitBranch,
+                            backgroundTaskCount: bgTaskCount,
+                            busy,
+                            columns,
+                            contextCompression,
+                            contextTokens,
+                            costHint,
+                            cwd,
+                            elapsedSeconds: busyElapsedSeconds,
+                            model,
+                            mode: permissionMode === 'ask' ? 'ask' : 'auto',
+                            queuedCount: queued.length,
+                        }) })] })] }));
 }
 /** input ที่มี cursor (inverse) + placeholder — minimal; รับ input ได้แม้ busy (ต่อคิว) */
 function InputView({ value, cursor, busy, agentStatus, toolTrail, columns = 80, }) {
@@ -1237,21 +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 ci = cursorGraphemeIndex(value, cursor);
-        const graphemes = graphemesOf(value);
-        const before = graphemes.slice(0, ci).join('');
-        const at = ci < graphemes.length ? graphemes[ci] : ' ';
-        const after = ci < graphemes.length ? graphemes.slice(ci + 1).join('') : '';
-        return (_jsxs(Text, { children: [before, _jsx(Text, { inverse: true, children: at }), 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';