sanook-cli 0.5.7 → 0.5.9

package/dist/providers/codex.js

@@ -47,6 +47,69 @@ export async function detectCodex() {
     }
     return { installed: true, loggedIn: false, reason: 'ยังไม่ได้ login — รัน: codex login' };
 }
+/** Models rejected by official `codex exec` when auth is ChatGPT plan (not OpenAI API key). */
+export const CODEX_CHATGPT_UNSUPPORTED_MODELS = new Set([
+    'gpt-5-codex',
+    'gpt-5.2-codex',
+    'gpt-5.3-codex',
+    'gpt-5.3-codex-spark',
+]);
+/** Models verified to work with ChatGPT-plan auth via `codex exec` (Jun 2026). */
+export const CODEX_CHATGPT_SUPPORTED_MODELS = ['gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini'];
+/** Curated aliases for setup + /model picker — only ChatGPT-plan-safe ids. */
+export const CODEX_CHATGPT_MODEL_ALIASES = {
+    default: 'gpt-5.5',
+    codex: 'gpt-5.5',
+    smart: 'gpt-5.5',
+    '5.5': 'gpt-5.5',
+    '5.4': 'gpt-5.4',
+    '5.4-mini': 'gpt-5.4-mini',
+    fast: 'gpt-5.4-mini',
+};
+export function isCodexChatGptSupportedModel(model) {
+    return CODEX_CHATGPT_SUPPORTED_MODELS.includes(model.trim());
+}
+/** Migrate saved config specs that still point at deprecated Codex CLI model ids. */
+export function migrateDeprecatedCodexModel(spec) {
+    const idx = spec.indexOf(':');
+    if (idx === -1)
+        return spec;
+    const provider = spec.slice(0, idx);
+    if (provider !== 'codex')
+        return spec;
+    const { model, migratedFrom } = normalizeCodexChatGptModel(spec.slice(idx + 1));
+    return migratedFrom ? `${provider}:${model}` : spec;
+}
+/** Map legacy/unsupported Codex CLI model ids to a ChatGPT-plan-safe default. */
+export function normalizeCodexChatGptModel(model) {
+    const trimmed = model.trim();
+    if (!trimmed || !CODEX_CHATGPT_UNSUPPORTED_MODELS.has(trimmed)) {
+        return { model: trimmed };
+    }
+    return { model: 'gpt-5.5', migratedFrom: trimmed };
+}
+function extractCodexErrorMessage(raw) {
+    const t = raw.trim();
+    if (!t)
+        return '';
+    try {
+        const outer = JSON.parse(t);
+        const nested = typeof outer.message === 'string' ? outer.message : '';
+        if (nested.startsWith('{')) {
+            try {
+                const inner = JSON.parse(nested);
+                return inner.error?.message ?? inner.message ?? nested;
+            }
+            catch {
+                return nested;
+            }
+        }
+        return outer.error?.message ?? outer.message ?? t;
+    }
+    catch {
+        return t;
+    }
+}
 /**
  * รัน `codex exec` แบบ non-interactive — ส่ง prompt ทาง stdin, parse JSONL events
  * tolerant ต่อ malformed JSONL (codex bug #15451: --json ถูก ignore เมื่อมี tools active)
@@ -69,6 +132,7 @@ export async function runCodex(opts) {
         let threadId;
         let buf = '';
         let stderr = '';
+        let jsonlError = '';
         let aborted = false;
         const handleStdoutLine = (line) => {
             const t = line.trim();
@@ -93,6 +157,13 @@ export async function runCodex(opts) {
                 else if (ev.type === 'turn.completed') {
                     opts.onEvent?.({ type: 'usage', usage: ev.usage });
                 }
+                else if (ev.type === 'error' || ev.type === 'turn.failed') {
+                    const msg = extractCodexErrorMessage(ev.message ?? ev.error?.message ?? t);
+                    if (msg) {
+                        jsonlError = msg;
+                        opts.onEvent?.({ type: 'error', message: msg });
+                    }
+                }
             }
             catch {
                 // malformed JSON line — ข้าม
@@ -139,8 +210,10 @@ export async function runCodex(opts) {
                 reject(new Error(`codex exec ถูกยกเลิก${stderr.trim() ? `: ${stderr.trim()}` : ''}`));
             else if (code === 0)
                 resolve({ text: finalText.trim(), threadId });
-            else
-                reject(new Error(`codex exec จบด้วย exit code ${code}${stderr.trim() ? `: ${stderr.trim()}` : ''}`));
+            else {
+                const detail = jsonlError.trim() || stderr.trim();
+                reject(new Error(`codex exec จบด้วย exit code ${code}${detail ? `: ${detail}` : ''}`));
+            }
         });
     });
 }

package/dist/providers/models.js

@@ -1,3 +1,15 @@
+import { isCodexChatGptSupportedModel, normalizeCodexChatGptModel } from './codex.js';
+function curatedModels(cfg) {
+    if (cfg.id !== 'codex')
+        return cfg.models;
+    const out = {};
+    for (const [alias, id] of Object.entries(cfg.models)) {
+        const model = normalizeCodexChatGptModel(id).model;
+        if (isCodexChatGptSupportedModel(model))
+            out[alias] = model;
+    }
+    return out;
+}
 /**
  * ดึงรายชื่อ model จริงจาก provider (GET /models) — "เลือกโมเดลที่เจ้าของมี" แบบ Hermes
  * - provider เป็นคน authoritative เรื่อง id (เราไม่ต้อง hardcode/เดา id ที่อาจ stale)
@@ -48,11 +60,12 @@ export async function listRemoteModels(cfg, key, timeoutMs = 6000) {
  * → ตัวเลือกโผล่ซ้ำ/หาย (bug "มีตัวเลือกสองตัวเลือกเป็น model เดียวกัน"). ใช้ทั้ง setup wizard และ /model picker
  */
 export function mergeModelOptions(cfg, remote = []) {
+    const models = curatedModels(cfg);
     // group alias ทั้งหมดตาม id (รวม 'default' ด้วย — กัน id ที่มีแต่ alias 'default' เช่น lmstudio:local-model,
     // ollama:llama3.3 หายไปจนเลือกไม่ได้/Select ว่าง). ตอนทำ label ค่อยซ่อนคำ "default" ถ้ามีชื่ออื่นอยู่แล้ว
     const aliasesById = new Map();
     const order = []; // คง first-seen order ของ id
-    for (const [alias, id] of Object.entries(cfg.models)) {
+    for (const [alias, id] of Object.entries(models)) {
         if (!aliasesById.has(id)) {
             aliasesById.set(id, []);
             order.push(id);
@@ -66,6 +79,8 @@ export function mergeModelOptions(cfg, remote = []) {
         return { id, label: `${shown.join(' / ')} — ${id}` };
     });
     const seen = new Set(order);
-    const extra = [...new Set(remote)].filter((id) => id && !seen.has(id)).map((id) => ({ id, label: id }));
+    const extra = cfg.id === 'codex'
+        ? []
+        : [...new Set(remote)].filter((id) => id && !seen.has(id)).map((id) => ({ id, label: id }));
     return [...curated, ...extra].map((o) => ({ label: o.label, value: o.id }));
 }

package/dist/providers/registry.js

@@ -6,6 +6,7 @@ import { createMistral } from '@ai-sdk/mistral';
 import { createGroq } from '@ai-sdk/groq';
 import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
 import { resolveKeyFromEnv, assertDirectApiKey } from './keys.js';
+import { CODEX_CHATGPT_MODEL_ALIASES, normalizeCodexChatGptModel } from './codex.js';
 import { BRAND } from '../brand.js';
 // ────────────────────────────────────────────────────────────────────────────
 // PROVIDER TABLE — เพิ่มค่าย = เพิ่ม 1 entry (loop/cost/keys ไม่ต้องแตะ)
@@ -134,21 +135,11 @@ export const PROVIDERS = {
         requiresKey: false,
         localPlaceholderKey: 'codex',
         keyFormat: null,
-        models: {
-            default: 'gpt-5.5',
-            codex: 'gpt-5.5',
-            '5.5': 'gpt-5.5',
-            '5.4': 'gpt-5.4',
-            '5.4-mini': 'gpt-5.4-mini',
-            '5.3-codex': 'gpt-5.3-codex',
-            '5.2-codex': 'gpt-5.2-codex',
-            '5-codex': 'gpt-5-codex',
-            spark: 'gpt-5.3-codex-spark',
-        },
+        models: { ...CODEX_CHATGPT_MODEL_ALIASES },
         create: () => {
             throw new Error('codex เป็น delegate provider — ใช้ผ่าน codex subprocess ไม่ใช่ Vercel AI SDK');
         },
-        note: 'ใช้ ChatGPT plan quota ผ่าน official codex CLI (ToS-safe, ไม่เก็บ credential). ต้อง codex login ก่อน',
+        note: 'ChatGPT plan ผ่าน codex CLI — รองรับ gpt-5.5 / gpt-5.4 / gpt-5.4-mini เท่านั้น (ต้อง codex login)',
     },
 };
 export const SUPPORTED_PROVIDERS = Object.keys(PROVIDERS);
@@ -177,7 +168,9 @@ export function parseSpec(spec) {
         const rest = spec.slice(idx + 1);
         const cfg = PROVIDERS[provider];
         // ถ้าเป็น alias ของ provider นั้น → map เป็น model id จริง, ไม่งั้นใช้ rest เป็น raw model id
-        const model = cfg?.models[rest] ?? rest;
+        let model = cfg?.models[rest] ?? rest;
+        if (provider === 'codex')
+            model = normalizeCodexChatGptModel(model).model;
         return { provider, model };
     }
     const g = GLOBAL_ALIAS[spec];

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' },