sanook-cli 0.5.7 → 0.5.8

package/dist/persona.js

@@ -0,0 +1,300 @@
+// Persona questionnaire — questions, durable-fact mapping, and the vault profile note.
+// 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.
+/** sentinel value: a select option that drops into a free-text follow-up */
+export const PERSONA_OTHER = '__other__';
+const otherOption = { label: 'อื่นๆ (พิมพ์เอง)', value: PERSONA_OTHER };
+/**
+ * The questionnaire. Mix of A/B/C/D selects and free-text inputs so the agent learns
+ * who the owner is + how they want to be worked with. Text answers may be left blank
+ * (Enter to skip) — blanks are not written as facts.
+ */
+export const PERSONA_QUESTIONS = [
+    {
+        id: 'ownerName',
+        prompt: 'เรียกคุณว่าอะไรดี? (ชื่อ / ชื่อเล่น)',
+        type: 'text',
+        label: 'ชื่อ / เรียกว่า',
+        placeholder: 'เช่น ชวกร, พี่หนึ่ง',
+        fact: (v) => (v ? `เจ้าของชื่อ ${v} — เรียกเจ้าของด้วยชื่อนี้` : null),
+    },
+    {
+        id: 'aiName',
+        prompt: 'อยากให้ AI เรียกตัวเองว่าอะไร?',
+        type: 'text',
+        label: 'AI เรียกตัวเองว่า',
+        placeholder: 'เช่น สนุก, ผู้ช่วย',
+        fact: (v) => (v ? `AI เรียกตัวเองว่า "${v}" เมื่อคุยกับเจ้าของ` : null),
+    },
+    {
+        id: 'role',
+        prompt: 'อาชีพ / บทบาทหลักของคุณคืออะไร?',
+        type: 'select',
+        label: 'บทบาท / อาชีพ',
+        options: [
+            { label: 'นักพัฒนา / โปรแกรมเมอร์', value: 'นักพัฒนา/โปรแกรมเมอร์' },
+            { label: 'นักเรียน / นักศึกษา', value: 'นักเรียน/นักศึกษา' },
+            { label: 'ครู / อาจารย์', value: 'ครู/อาจารย์' },
+            { label: 'เจ้าของธุรกิจ / ฟรีแลนซ์', value: 'เจ้าของธุรกิจ/ฟรีแลนซ์' },
+            otherOption,
+        ],
+        fact: (v) => (v ? `บทบาท/อาชีพของเจ้าของ: ${v}` : null),
+    },
+    {
+        id: 'experience',
+        prompt: 'ระดับประสบการณ์การเขียนโปรแกรมของคุณ?',
+        type: 'select',
+        label: 'ประสบการณ์',
+        options: [
+            { label: 'เริ่มต้น (beginner)', value: 'beginner' },
+            { label: 'ระดับกลาง (intermediate)', value: 'intermediate' },
+            { label: 'ระดับสูง (advanced)', value: 'advanced' },
+            { label: 'เชี่ยวชาญ (expert)', value: 'expert' },
+            { label: 'ไม่ใช่สายโค้ด', value: 'ไม่ใช่สายโค้ด' },
+        ],
+        fact: (v) => (v ? `ระดับประสบการณ์เขียนโปรแกรมของเจ้าของ: ${v}` : null),
+    },
+    {
+        id: 'language',
+        prompt: 'อยากให้ AI ตอบเป็นภาษาอะไร?',
+        type: 'select',
+        label: 'ภาษา',
+        options: [
+            { label: 'ไทยล้วน', value: 'ไทย' },
+            { label: 'ไทย + ศัพท์เทคนิคอังกฤษ', value: 'ไทย + tech-en' },
+            { label: 'อังกฤษล้วน', value: 'English' },
+        ],
+        fact: (v) => (v ? `ภาษาที่เจ้าของต้องการให้ตอบ: ${v}` : null),
+    },
+    {
+        id: 'tone',
+        prompt: 'อยากให้โทนการสื่อสารเป็นแบบไหน?',
+        type: 'select',
+        label: 'โทน',
+        options: [
+            { label: 'กระชับ ตรงประเด็น', value: 'กระชับ ตรงประเด็น' },
+            { label: 'ละเอียด อธิบายเยอะ', value: 'ละเอียด อธิบายเยอะ' },
+            { label: 'เป็นกันเอง สนุก', value: 'เป็นกันเอง สนุก' },
+            { label: 'ทางการ สุภาพ', value: 'ทางการ สุภาพ' },
+        ],
+        fact: (v) => (v ? `โทนการสื่อสารที่เจ้าของชอบ: ${v}` : null),
+    },
+    {
+        id: 'depth',
+        prompt: 'เวลาอธิบายโค้ด/คำตอบ อยากได้ละเอียดแค่ไหน?',
+        type: 'select',
+        label: 'ความละเอียดของคำอธิบาย',
+        options: [
+            { label: 'เอาแค่คำตอบ / โค้ด', value: 'เอาแค่คำตอบ' },
+            { label: 'คำตอบ + เหตุผลสั้นๆ', value: 'คำตอบ + เหตุผลสั้นๆ' },
+            { label: 'อธิบายละเอียดทีละขั้น', value: 'อธิบายละเอียดทีละขั้น' },
+        ],
+        fact: (v) => (v ? `ระดับความละเอียดที่เจ้าของอยากได้เวลาอธิบาย: ${v}` : null),
+    },
+    {
+        id: 'autonomy',
+        prompt: 'อยากให้ AI ทำงานแบบไหน?',
+        type: 'select',
+        label: 'Autonomy',
+        options: [
+            { label: 'ask-on-risk — ทำเลย ถามเฉพาะตอนเสี่ยง', value: 'ask-on-risk' },
+            { label: 'act-first — ลงมือก่อน รายงานทีหลัง', value: 'act-first' },
+            { label: 'ask-first — ถามก่อนทุกครั้ง', value: 'ask-first' },
+        ],
+        fact: (v) => (v ? `ระดับ autonomy ที่เจ้าของเลือก: ${v}` : null),
+    },
+    {
+        id: 'stack',
+        prompt: 'ภาษา / เทคโนโลยีที่ใช้บ่อย? (Enter เพื่อข้าม)',
+        type: 'text',
+        label: 'เทคโนโลยีที่ใช้บ่อย',
+        placeholder: 'เช่น TypeScript, React, Python, PostgreSQL',
+        fact: (v) => (v ? `เทคโนโลยีที่เจ้าของใช้บ่อย: ${v}` : null),
+    },
+    {
+        id: 'domains',
+        prompt: 'สนใจ / ทำงานด้านไหนเป็นหลัก? (Enter เพื่อข้าม)',
+        type: 'text',
+        label: 'ด้านที่สนใจ',
+        placeholder: 'เช่น web, AI/ML, mobile, การศึกษา',
+        fact: (v) => (v ? `ด้านที่เจ้าของทำงาน/สนใจ: ${v}` : null),
+    },
+    {
+        id: 'goals',
+        prompt: 'ตอนนี้กำลังโฟกัสทำอะไร / เป้าหมายหลัก? (Enter เพื่อข้าม)',
+        type: 'text',
+        label: 'เป้าหมาย / โฟกัส',
+        placeholder: 'เช่น สร้าง CLI ของตัวเอง, เรียน Rust',
+        fact: (v) => (v ? `เป้าหมาย/สิ่งที่เจ้าของกำลังโฟกัส: ${v}` : null),
+    },
+    {
+        id: 'preferences',
+        prompt: 'มีอะไรที่ชอบ / ไม่ชอบให้ AI ทำไหม? (Enter เพื่อข้าม)',
+        type: 'text',
+        label: 'สิ่งที่ชอบ/ไม่ชอบ',
+        placeholder: 'เช่น อย่าใส่ emoji, ใส่คอมเมนต์ภาษาไทย',
+        fact: (v) => (v ? `สิ่งที่เจ้าของชอบ/ไม่ชอบให้ AI ทำ: ${v}` : null),
+    },
+    {
+        id: 'emoji',
+        prompt: 'ใช้ emoji ในคำตอบไหม?',
+        type: 'select',
+        label: 'การใช้ emoji',
+        options: [
+            { label: 'ใช้ได้', value: 'ใช้ได้' },
+            { label: 'ใช้น้อยๆ', value: 'ใช้น้อยๆ' },
+            { label: 'ไม่ใช้เลย', value: 'ไม่ใช้เลย' },
+        ],
+        fact: (v) => (v ? `การใช้ emoji ที่เจ้าของต้องการ: ${v}` : null),
+    },
+    {
+        id: 'timezone',
+        prompt: 'Timezone / เวลาทำงานปกติ? (Enter เพื่อข้าม)',
+        type: 'text',
+        label: 'Timezone / เวลาทำงาน',
+        placeholder: 'เช่น Asia/Bangkok, ชอบทำงานกลางคืน',
+        fact: (v) => (v ? `Timezone/เวลาทำงานของเจ้าของ: ${v}` : null),
+    },
+];
+function clean(value) {
+    return (value ?? '').trim();
+}
+/** Build durable owner facts (protected tier) from the answers, skipping blanks/sentinels. */
+export function personaFacts(answers) {
+    const out = [];
+    for (const q of PERSONA_QUESTIONS) {
+        const v = clean(answers[q.id]);
+        if (!v || v === PERSONA_OTHER)
+            continue;
+        const fact = q.fact(v);
+        if (fact)
+            out.push(fact);
+    }
+    return out;
+}
+/** 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) {
+        const hit = q.options.find((o) => o.value === value);
+        if (hit && hit.value !== PERSONA_OTHER)
+            return hit.label;
+    }
+    return value;
+}
+/** Render the second-brain persona profile note (markdown) from the answers. */
+export function renderPersonaProfile(answers, today) {
+    const rows = PERSONA_QUESTIONS.map((q) => {
+        const v = clean(answers[q.id]);
+        const shown = v && v !== PERSONA_OTHER ? answerLabel(q, v) : '—';
+        return `| ${q.label} | ${shown.replace(/\|/g, '\\|')} |`;
+    }).join('\n');
+    return `---
+tags: [persona, identity, user-owned]
+note_type: persona
+created: ${today}
+updated: ${today}
+source: "sanook persona"
+parent: "[[Shared/User-Persona/_Index]]"
+---
+
+# Persona — โปรไฟล์เจ้าของ
+
+> สร้างจากคำสั่ง \`sanook persona\` — AI อ่านบริบทนี้เพื่อเข้าใจเจ้าของและปรับสไตล์การทำงาน.
+> แก้ไขได้โดยตรง หรือรัน \`sanook persona\` ใหม่เพื่ออัปเดต (เขียนทับไฟล์นี้).
+
+## โปรไฟล์
+
+| หัวข้อ | ค่า |
+|---|---|
+${rows}
+
+up:: [[Shared/User-Persona/_Index]]
+`;
+}
+/** map display label (stored in persona.md table) back to select value */
+export function valueFromDisplayLabel(q, shown) {
+    const s = shown.trim();
+    if (!s || s === '—')
+        return '';
+    if (q.type === 'select' && q.options) {
+        const byLabel = q.options.find((o) => o.label === s);
+        if (byLabel)
+            return byLabel.value;
+        const byValue = q.options.find((o) => o.value === s);
+        if (byValue)
+            return byValue.value;
+    }
+    return s;
+}
+/** Parse persona.md table rows back into answers (label → value). */
+export function parsePersonaProfileMarkdown(md) {
+    const out = {};
+    const labelToId = new Map(PERSONA_QUESTIONS.map((q) => [q.label, q.id]));
+    for (const line of md.split('\n')) {
+        const m = line.match(/^\|\s*(.+?)\s*\|\s*(.+?)\s*\|$/);
+        if (!m)
+            continue;
+        const label = m[1].trim();
+        const shown = m[2].trim().replace(/\\\|/g, '|');
+        if (label === 'หัวข้อ' || label === '---')
+            continue;
+        const id = labelToId.get(label);
+        if (!id)
+            continue;
+        const q = PERSONA_QUESTIONS.find((x) => x.id === id);
+        const v = valueFromDisplayLabel(q, shown);
+        if (v)
+            out[id] = v;
+    }
+    return out;
+}
+/** Extract persona fields from protected owner facts in auto-memory. */
+export function personaAnswersFromFacts(factTexts) {
+    const out = {};
+    for (const raw of factTexts) {
+        const text = raw.trim();
+        let m = text.match(/^เจ้าของชื่อ (.+?) — เรียกเจ้าของด้วยชื่อนี้$/);
+        if (m) {
+            out.ownerName = m[1];
+            continue;
+        }
+        m = text.match(/^AI เรียกตัวเองว่า "(.+?)" เมื่อคุยกับเจ้าของ$/);
+        if (m) {
+            out.aiName = m[1];
+            continue;
+        }
+        const prefixes = [
+            ['บทบาท/อาชีพของเจ้าของ: ', 'role'],
+            ['ระดับประสบการณ์เขียนโปรแกรมของเจ้าของ: ', 'experience'],
+            ['ภาษาที่เจ้าของต้องการให้ตอบ: ', 'language'],
+            ['โทนการสื่อสารที่เจ้าของชอบ: ', 'tone'],
+            ['ระดับความละเอียดที่เจ้าของอยากได้เวลาอธิบาย: ', 'depth'],
+            ['ระดับ autonomy ที่เจ้าของเลือก: ', 'autonomy'],
+            ['เทคโนโลยีที่เจ้าของใช้บ่อย: ', 'stack'],
+            ['ด้านที่เจ้าของทำงาน/สนใจ: ', 'domains'],
+            ['เป้าหมาย/สิ่งที่เจ้าของกำลังโฟกัส: ', 'goals'],
+            ['สิ่งที่เจ้าของชอบ/ไม่ชอบให้ AI ทำ: ', 'preferences'],
+            ['การใช้ emoji ที่เจ้าของต้องการ: ', 'emoji'],
+            ['Timezone/เวลาทำงานของเจ้าของ: ', 'timezone'],
+        ];
+        for (const [prefix, id] of prefixes) {
+            if (text.startsWith(prefix)) {
+                out[id] = text.slice(prefix.length);
+                break;
+            }
+        }
+    }
+    return out;
+}
+/** Merge persona answers — later sources override earlier for each field. */
+export function mergePersonaAnswers(...sources) {
+    const out = {};
+    for (const src of sources) {
+        for (const [k, v] of Object.entries(src)) {
+            if (v?.trim())
+                out[k] = v.trim();
+        }
+    }
+    return out;
+}

package/dist/project-scaffold.js

@@ -16,7 +16,8 @@ export function slugifyProject(value) {
 function renderTemplate(raw, vars) {
     let out = raw;
     for (const [key, value] of Object.entries(vars)) {
-        out = out.replaceAll(`{{${key}}}`, value);
+        // replacer function so `$`-sequences in a var value aren't interpreted as String.replace patterns
+        out = out.replaceAll(`{{${key}}}`, () => value);
     }
     return out;
 }
@@ -46,7 +47,8 @@ async function maybeAppendProjectsIndex(brainPath, slug, title) {
         return false;
     const line = `- ${link} — ${title}`;
     const marker = 'up:: [[Home]]';
-    const next = content.includes(marker) ? content.replace(marker, `${line}\n\n${marker}`) : `${content.trimEnd()}\n${line}\n`;
+    // replacer function so `$`-sequences in the project title aren't interpreted as replace patterns
+    const next = content.includes(marker) ? content.replace(marker, () => `${line}\n\n${marker}`) : `${content.trimEnd()}\n${line}\n`;
     await writeFile(indexPath, next, 'utf8');
     return true;
 }

package/dist/self-improve-synth.js

@@ -0,0 +1,86 @@
+// Default skill synthesizer for self-improvement. Tries the model (cheap sibling) to write a
+// proper runbook; if no key resolves or the model output isn't usable, falls back to a deterministic
+// template built from the observed prompts — so a skill is ALWAYS created on the Nth repeat without
+// depending on fragile LLM JSON. Kept out of self-improve.ts so the detection core stays offline.
+import { generateText } from 'ai';
+import { resolveModel, fastSibling, PROVIDERS, parseSpec } from './providers/registry.js';
+import { redactKey } from './providers/keys.js';
+import { slugifySkillName } from './self-improve.js';
+const SYNTH_PROMPT = 'คุณกำลังสร้าง "skill" (runbook ทำซ้ำได้) จากคำสั่งที่ผู้ใช้สั่งซ้ำหลายครั้ง. ' +
+    'ตอบเป็น JSON อย่างเดียว (ไม่มีข้อความอื่น) รูปแบบ: ' +
+    '{"name":"slug-a-z0-9-","description":"1 บรรทัดบอกว่า skill ทำอะไร","when_to_use":"เมื่อไรควรหยิบมาใช้","steps":["ขั้นตอน 1","ขั้นตอน 2"]}. ' +
+    'name ต้องเป็น slug a-z 0-9 - สั้นๆ. steps เป็นขั้นตอนที่ทำให้ครั้งหน้าทำงานนี้ได้เร็วและไม่พลาด.\n\nคำสั่งที่สั่งซ้ำ:\n';
+function templateDraft(family) {
+    const top = family.terms.slice(0, 4).join('-');
+    const name = slugifySkillName(top || family.samples[0] || 'recurring-task');
+    const requests = family.samples.map((s) => `- ${s}`).join('\n');
+    const body = [
+        '## When to Use',
+        `งานเกี่ยวกับ: ${family.terms.slice(0, 8).join(', ')}`,
+        '',
+        '## Observed requests',
+        requests,
+        '',
+        '## Steps',
+        '_(สร้างอัตโนมัติจากงานที่ทำซ้ำ — เพิ่มขั้นตอน/คำสั่งที่ใช้จริงได้)_',
+        '',
+        '## Common Errors / Gotchas',
+        '_(เติมข้อควรระวังที่เจอระหว่างทำงานนี้)_',
+    ].join('\n');
+    return {
+        name,
+        description: `งานที่ทำซ้ำ: ${family.samples[0]?.slice(0, 80) ?? family.terms.slice(0, 5).join(' ')}`,
+        whenToUse: `เมื่อเจองานเกี่ยวกับ ${family.terms.slice(0, 5).join(', ')}`,
+        body,
+    };
+}
+function draftFromModelText(text, family) {
+    const match = text.match(/\{[\s\S]*\}/);
+    if (!match)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(match[0]);
+    }
+    catch {
+        return null;
+    }
+    const name = typeof parsed.name === 'string' ? parsed.name : '';
+    const description = typeof parsed.description === 'string' ? parsed.description : '';
+    const whenToUse = typeof parsed.when_to_use === 'string' ? parsed.when_to_use : undefined;
+    const steps = Array.isArray(parsed.steps) ? parsed.steps.filter((s) => typeof s === 'string') : [];
+    if (!name.trim() || !steps.length)
+        return null;
+    const fallback = templateDraft(family);
+    const body = [
+        '## When to Use',
+        whenToUse || fallback.whenToUse || '',
+        '',
+        '## Steps',
+        steps.map((s, i) => `${i + 1}. ${s}`).join('\n'),
+        '',
+        '## Observed requests',
+        family.samples.map((s) => `- ${s}`).join('\n'),
+    ].join('\n');
+    return { name, description: description || fallback.description, whenToUse, body };
+}
+/** สร้าง synthesizer: ลอง model ก่อน (ค่าย sibling ถูก) → ถ้าไม่ได้ key/parse พัง ใช้ template */
+export function defaultSkillSynthesizer(mainModel) {
+    return async (family) => {
+        // delegate provider (codex) ไม่มี generateText ตรง → ใช้ template ทันที
+        if (PROVIDERS[parseSpec(mainModel).provider]?.kind === 'delegate')
+            return templateDraft(family);
+        const transcript = family.samples.map((s, i) => `${i + 1}. ${s}`).join('\n');
+        try {
+            const { text } = await generateText({
+                model: resolveModel(fastSibling(mainModel)),
+                prompt: SYNTH_PROMPT + redactKey(transcript),
+                maxOutputTokens: 700,
+            });
+            return draftFromModelText(text, family) ?? templateDraft(family);
+        }
+        catch {
+            return templateDraft(family); // ไม่มี key / network ล้ม → ยังสร้าง skill ได้
+        }
+    };
+}

package/dist/self-improve.js

@@ -0,0 +1,203 @@
+// ============================================================================
+// src/self-improve.ts — Hermes-style "Self-improvement": when the user keeps asking
+// for the SAME kind of task, Sanook notices, writes a reusable skill automatically,
+// and announces it in the terminal ("✨ Self-improvement: created skill …").
+//
+// How it works (cheap, deterministic detection · LLM only fires on the Nth repeat):
+//   1) every completed turn, the prompt is reduced to a TERM SIGNATURE and matched
+//      (token-Jaccard) against a small persistent ledger at ~/.sanook/self-improve/ledger.json.
+//   2) when a task family reaches the threshold (default 3) and no skill exists for it yet,
+//      we synthesize a SKILL.md (model if a key resolves, else a deterministic template) and
+//      save it via skills.saveSkill — then mark the family so we never duplicate it.
+//
+// Pure functions (signature, match, ledger transforms) are unit-tested with an injected
+// clock and no FS/LLM. The orchestrator takes an injected `synthesize` so tests stay offline.
+// ============================================================================
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { z } from 'zod';
+import { appHomePath, persistenceEnabled, selfImproveEnabled, selfImproveThreshold } from './brand.js';
+import { termList } from './search/index-core.js';
+export const LEDGER_PATH = appHomePath('self-improve', 'ledger.json');
+const MAX_SAMPLES = 6; // prompts kept per task family (for synthesis context)
+const MAX_FAMILIES = 200; // ledger cap (drop oldest)
+const MATCH_THRESHOLD = 0.5; // token-Jaccard ≥ this ⇒ "same kind of task"
+const MAX_SIG_TERMS = 12;
+export const TaskFamilySchema = z.object({
+    sig: z.string(),
+    terms: z.array(z.string()),
+    samples: z.array(z.string()),
+    count: z.number().int().nonnegative(),
+    skillCreated: z.boolean().default(false),
+    skillName: z.string().nullable().default(null),
+    firstSeen: z.number(),
+    lastSeen: z.number(),
+});
+export const LedgerSchema = z.object({
+    version: z.literal(1).default(1),
+    families: z.array(TaskFamilySchema).default([]),
+});
+export function emptyLedger() {
+    return { version: 1, families: [] };
+}
+/** prompt → ชุด term สำคัญ (ตัด slash-command / @mention / ของสั้น) — เป็น signature ของงาน */
+export function signatureTerms(prompt) {
+    const cleaned = prompt
+        .replace(/^\s*\/\w+\s*/, '') // ตัด /command นำหน้า
+        .replace(/@[^\s]+/g, ' ') // ตัด @file mention
+        .replace(/\[\[\s*paste[^\]]*\]\]/gi, ' '); // ตัด paste token
+    const seen = new Set();
+    const out = [];
+    for (const t of termList(cleaned)) {
+        if (seen.has(t))
+            continue;
+        seen.add(t);
+        out.push(t);
+        if (out.length >= MAX_SIG_TERMS)
+            break;
+    }
+    return out;
+}
+export function signatureKey(terms) {
+    return [...terms].sort().join(' ');
+}
+/** token-Jaccard ระหว่าง 2 ชุด term (0..1) */
+export function jaccard(a, b) {
+    if (!a.length || !b.length)
+        return 0;
+    const setA = new Set(a);
+    const setB = new Set(b);
+    let inter = 0;
+    for (const t of setA)
+        if (setB.has(t))
+            inter += 1;
+    return inter / (setA.size + setB.size - inter);
+}
+/**
+ * บันทึก task 1 ครั้งเข้า ledger — match กับ family เดิมด้วย Jaccard, ไม่งั้นเปิด family ใหม่.
+ * คืน shouldCreateSkill=true เมื่อ count ถึง threshold ครั้งแรก (ยังไม่เคยสร้าง skill).
+ */
+export function recordTask(ledger, prompt, now, createThresholdOverride) {
+    const createThreshold = createThresholdOverride ?? selfImproveThreshold();
+    const terms = signatureTerms(prompt);
+    const sample = prompt.trim().replace(/\s+/g, ' ').slice(0, 240);
+    // งานสั้น/generic เกินไป (term น้อย) → ไม่ติดตาม (กัน false positive เช่น "ok", "ลองอีกที")
+    if (terms.length < 3) {
+        return { ledger, family: phantomFamily(terms, sample, now), shouldCreateSkill: false };
+    }
+    const families = ledger.families.slice();
+    let bestIdx = -1;
+    let bestSim = 0;
+    for (let i = 0; i < families.length; i += 1) {
+        const s = jaccard(terms, families[i].terms);
+        if (s > bestSim) {
+            bestSim = s;
+            bestIdx = i;
+        }
+    }
+    if (bestIdx >= 0 && bestSim >= MATCH_THRESHOLD) {
+        const prev = families[bestIdx];
+        const samples = prev.samples.includes(sample) ? prev.samples : [...prev.samples, sample].slice(-MAX_SAMPLES);
+        // keep family.terms = the first-seen signature (stable) so Jaccard doesn't drift/shrink as the family grows
+        const next = { ...prev, samples, count: prev.count + 1, lastSeen: now };
+        families[bestIdx] = next;
+        const shouldCreateSkill = !next.skillCreated && next.count >= createThreshold;
+        return { ledger: { ...ledger, families: capFamilies(families) }, family: next, shouldCreateSkill };
+    }
+    const fresh = {
+        sig: signatureKey(terms),
+        terms,
+        samples: [sample],
+        count: 1,
+        skillCreated: false,
+        skillName: null,
+        firstSeen: now,
+        lastSeen: now,
+    };
+    families.push(fresh);
+    return { ledger: { ...ledger, families: capFamilies(families) }, family: fresh, shouldCreateSkill: false };
+}
+/** mark ว่า family นี้สร้าง skill แล้ว (กันสร้างซ้ำ) */
+export function markSkillCreated(ledger, sig, skillName) {
+    return {
+        ...ledger,
+        families: ledger.families.map((f) => (f.sig === sig ? { ...f, skillCreated: true, skillName } : f)),
+    };
+}
+function capFamilies(families) {
+    if (families.length <= MAX_FAMILIES)
+        return families;
+    return [...families].sort((x, y) => y.lastSeen - x.lastSeen).slice(0, MAX_FAMILIES);
+}
+function phantomFamily(terms, sample, now) {
+    return { sig: signatureKey(terms), terms, samples: [sample], count: 0, skillCreated: false, skillName: null, firstSeen: now, lastSeen: now };
+}
+// ---- FS (gated by persistence) ---------------------------------------------
+export async function loadLedger() {
+    try {
+        const parsed = LedgerSchema.safeParse(JSON.parse(await readFile(LEDGER_PATH, 'utf8')));
+        return parsed.success ? parsed.data : emptyLedger();
+    }
+    catch {
+        return emptyLedger();
+    }
+}
+export async function saveLedger(ledger) {
+    if (!persistenceEnabled())
+        return;
+    await mkdir(dirname(LEDGER_PATH), { recursive: true });
+    await writeFile(LEDGER_PATH, `${JSON.stringify(ledger, null, 2)}\n`, { mode: 0o600 });
+}
+/**
+ * เรียกหลังจบ turn (best-effort, fire-and-forget). บันทึก task เข้า ledger; ถ้าถึง threshold
+ * และยังไม่เคยมี skill → synthesize + save + mark + คืน announcement สำหรับโชว์ใน terminal.
+ */
+export async function maybeAutoSkill(prompt, deps) {
+    if (!selfImproveEnabled())
+        return { created: false };
+    const now = deps.now ?? Date.now();
+    const ledger = await loadLedger();
+    const rec = recordTask(ledger, prompt, now);
+    await saveLedger(rec.ledger);
+    if (!rec.shouldCreateSkill)
+        return { created: false };
+    const draft = await deps.synthesize(rec.family).catch(() => null);
+    if (!draft || !draft.name.trim())
+        return { created: false };
+    const name = uniqueSkillName(draft.name, deps.existingSkillNames);
+    let path;
+    try {
+        path = await deps.saveSkill(name, draft.description, draft.body, draft.whenToUse);
+    }
+    catch {
+        return { created: false };
+    }
+    await saveLedger(markSkillCreated(rec.ledger, rec.family.sig, name)).catch(() => { });
+    return {
+        created: true,
+        skillName: name,
+        count: rec.family.count,
+        path,
+        announcement: `✨ Self-improvement: สร้าง skill \`${name}\` อัตโนมัติ จากงานที่ทำซ้ำ ${rec.family.count} ครั้ง — ครั้งหน้าหยิบใช้ได้เลย (\`sanook skill list\`)`,
+    };
+}
+/** slug ชื่อ skill ให้ไม่ชนของเดิม (เติม -2, -3, …) */
+export function uniqueSkillName(raw, existing) {
+    const base = slugifySkillName(raw);
+    if (!existing || !existing.has(base))
+        return base;
+    for (let i = 2; i < 100; i += 1) {
+        const candidate = `${base}-${i}`;
+        if (!existing.has(candidate))
+            return candidate;
+    }
+    return `${base}-${Date.now().toString(36).slice(-4)}`;
+}
+export function slugifySkillName(raw) {
+    const slug = raw
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 48);
+    return slug || `auto-skill-${Date.now().toString(36).slice(-4)}`;
+}

package/dist/session-brain.js

@@ -5,6 +5,7 @@ import { getBrainPath } from './memory.js';
 import { PROVIDERS, parseSpec } from './providers/registry.js';
 import { makeSummarizer } from './summarize.js';
 import { distilledFactsFromMessages } from './session-distill.js';
+import { autoMaintainEnabled } from './auto-maintain.js';
 import { saveSession } from './session.js';
 function transcriptFromTurns(turns) {
     return turns
@@ -25,7 +26,8 @@ function injectSessionSummary(template, summary, facts) {
         .filter(Boolean)
         .join('\n');
     if (/^## Summary\s*$/m.test(template)) {
-        return template.replace(/^## Summary\s*$/m, `## Summary\n\n${summaryBlock}`);
+        // replacer function so `$`-sequences in the AI summary/facts aren't interpreted as replace patterns
+        return template.replace(/^## Summary\s*$/m, () => `## Summary\n\n${summaryBlock}`);
     }
     return `${template.trimEnd()}\n\n## Summary\n\n${summaryBlock}\n`;
 }
@@ -87,6 +89,13 @@ export async function finalizeReplSession(options) {
     const raw = await readFile(report.path, 'utf8');
     const next = injectSessionSummary(raw, summary, facts.slice(0, 8));
     await writeFile(report.path, next, 'utf8');
+    // also compound the distilled facts into durable auto-memory (not just the session note) so the
+    // self-retrieving brain surfaces them next session. Gated by autoMaintain (default on). Best-effort.
+    if (await autoMaintainEnabled()) {
+        const { appendMemory } = await import('./memory.js');
+        for (const fact of facts.slice(0, 8))
+            await appendMemory(fact).catch(() => { });
+    }
     return {
         sessionSaved: true,
         brainNoteRel: report.relPath,

package/dist/slash-completion.js

@@ -41,6 +41,7 @@ const BUILTIN_SLASH_COMPLETIONS = [
     { text: '/cost', display: '/cost', meta: 'last usage/cost' },
     { text: '/usage', display: '/usage', meta: 'last usage/cost' },
     { text: '/insights', display: '/insights', meta: 'local usage insights' },
+    { text: '/persona', display: '/persona', meta: 'set owner persona' },
     { text: '/personality', display: '/personality', meta: 'set response style' },
     { text: '/compact', display: '/compact', meta: 'compress context' },
     { text: '/compress', display: '/compress', meta: 'compress context' },