sanook-cli 0.5.1 → 0.5.5

package/dist/providers/registry.js

@@ -1,7 +1,6 @@
 import { createAnthropic } from '@ai-sdk/anthropic';
 import { createOpenAI } from '@ai-sdk/openai';
 import { createGoogleGenerativeAI } from '@ai-sdk/google';
-import { createDeepSeek } from '@ai-sdk/deepseek';
 import { createXai } from '@ai-sdk/xai';
 import { createMistral } from '@ai-sdk/mistral';
 import { createGroq } from '@ai-sdk/groq';
@@ -71,16 +70,6 @@ export const PROVIDERS = {
         create: (key, baseURL) => createOpenAI({ apiKey: key, baseURL }),
         note: 'Bearer key. org/project ผ่าน env. ห้าม reuse ChatGPT/Codex OAuth',
     },
-    deepseek: {
-        id: 'deepseek',
-        label: 'DeepSeek',
-        envVar: 'DEEPSEEK_API_KEY',
-        requiresKey: true,
-        keyFormat: null, // opaque sk- → ข้าม format check
-        // V4 ids (doc audit มิ.ย. 2026): deepseek-chat/deepseek-reasoner เลิกใช้ 2026-07-24 → redirect มา V4 (dual thinking-mode)
-        models: { default: 'deepseek-v4-flash', smart: 'deepseek-v4-pro', fast: 'deepseek-v4-flash' },
-        create: (key) => createDeepSeek({ apiKey: key }),
-    },
     xai: {
         id: 'xai',
         label: 'xAI Grok',
@@ -120,7 +109,7 @@ export const PROVIDERS = {
         requiresKey: false,
         localPlaceholderKey: 'ollama',
         keyFormat: null,
-        models: { default: 'qwen3', llama: 'llama3.3' },
+        models: { default: 'llama3.3', llama: 'llama3.3', mistral: 'mistral' },
         create: (key, baseURL) => createOpenAICompatible({ name: 'ollama', apiKey: key, baseURL: baseURL ?? 'http://localhost:11434/v1' }),
         note: 'OpenAI-compat /v1 endpoint. ไม่ต้อง key',
     },
@@ -136,32 +125,6 @@ export const PROVIDERS = {
         create: (key, baseURL) => createOpenAICompatible({ name: 'lmstudio', apiKey: key, baseURL: baseURL ?? 'http://localhost:1234/v1' }),
         note: 'ต้อง Start Server ในแอปก่อน; โหลด model เดียว ใส่ id อะไรก็ serve ตัวนั้น',
     },
-    // ── Cloud BYOK (OpenAI-compatible, จีน — data residency, ไม่มี OAuth landmine) ──
-    minimax: {
-        id: 'minimax',
-        label: 'MiniMax',
-        envVar: 'MINIMAX_API_KEY',
-        baseURL: 'https://api.minimax.io/v1',
-        requiresKey: true,
-        keyFormat: null, // opaque
-        models: { default: 'MiniMax-M2.7', smart: 'MiniMax-M3', fast: 'MiniMax-M2.7' },
-        create: (key, baseURL) => createOpenAICompatible({ name: 'minimax', apiKey: key, baseURL: baseURL ?? 'https://api.minimax.io/v1' }),
-        note: 'OpenAI-compat /v1. data จีน. MINIMAX_BASE_URL override (intl ↔ api.minimaxi.com/v1)',
-    },
-    glm: {
-        id: 'glm',
-        label: 'GLM (z.ai / Zhipu Coding Plan)',
-        envVar: 'ZHIPU_API_KEY',
-        envFallbacks: ['ZAI_API_KEY', 'GLM_API_KEY'],
-        // Coding Plan (subscription) ใช้ Anthropic Messages API — เหมือนที่ต่อกับ Claude Code.
-        // pay-as-you-go /paas/v4 (OpenAI-compat) มีแค่ glm-4.5-flash ฟรี ที่เหลือ 429 ถ้าไม่มี balance
-        baseURL: 'https://api.z.ai/api/anthropic/v1',
-        requiresKey: true,
-        keyFormat: null, // opaque ({id}.{secret})
-        models: { default: 'glm-4.6', smart: 'glm-5.1', air: 'glm-4.5-air', glm: 'glm-4.6' },
-        create: (key, baseURL) => createAnthropic({ apiKey: key, baseURL: baseURL ?? 'https://api.z.ai/api/anthropic/v1' }),
-        note: 'z.ai Coding Plan ผ่าน Anthropic Messages API. GLM_BASE_URL override → open.bigmodel.cn/api/anthropic/v1 (จีน)',
-    },
     // ── Delegate: OpenAI Codex ผ่าน ChatGPT plan quota (wrap official codex CLI, ToS-safe) ──
     codex: {
         id: 'codex',
@@ -191,13 +154,10 @@ const GLOBAL_ALIAS = {
     gemini: { provider: 'google', alias: 'gemini' },
     flash: { provider: 'google', alias: 'flash' },
     grok: { provider: 'xai', alias: 'grok' },
-    deepseek: { provider: 'deepseek', alias: 'default' },
     mistral: { provider: 'mistral', alias: 'default' },
     groq: { provider: 'groq', alias: 'default' },
     ollama: { provider: 'ollama', alias: 'default' },
     lmstudio: { provider: 'lmstudio', alias: 'default' },
-    glm: { provider: 'glm', alias: 'default' },
-    minimax: { provider: 'minimax', alias: 'default' },
 };
 /** parse "provider:model" | "provider:alias" | alias | "model" (default anthropic) */
 export function parseSpec(spec) {
@@ -221,17 +181,18 @@ export function specKey(spec) {
     const { provider, model } = parseSpec(spec);
     return `${provider}:${model}`;
 }
+/** canonical display/state spec: aliases become "provider:model-id" before reaching the REPL state. */
+export function canonicalSpec(spec) {
+    return specKey(spec.trim());
+}
 /** หน้า console ที่ใช้สร้าง API key ต่อ provider — โชว์ในข้อความ error/wizard ("ไปเอา key ที่ไหน") */
 const CONSOLE_URLS = {
     anthropic: 'https://console.anthropic.com/settings/keys',
     google: 'https://aistudio.google.com/apikey',
     openai: 'https://platform.openai.com/api-keys',
-    deepseek: 'https://platform.deepseek.com/api_keys',
     xai: 'https://console.x.ai',
     mistral: 'https://console.mistral.ai/api-keys',
     groq: 'https://console.groq.com/keys',
-    minimax: 'https://platform.minimax.io',
-    glm: 'https://z.ai/manage-apikey/apikey-list',
 };
 export function consoleUrl(provider) {
     return CONSOLE_URLS[provider];
@@ -245,6 +206,8 @@ export function hasUsableEnvKey(provider) {
     const cfg = PROVIDERS[provider];
     if (!cfg)
         return false;
+    if (cfg.kind === 'delegate')
+        return false; // ต้องเช็ก readiness แยก (เช่น codex CLI installed + logged in)
     if (!cfg.requiresKey)
         return true; // local — ไม่ต้อง key
     const k = resolveKeyFromEnv(cfg.envVar, cfg.envFallbacks);
@@ -260,7 +223,7 @@ export function hasUsableEnvKey(provider) {
 }
 /** หา provider ที่ "มี key ใช้ได้จริงใน env" (cloud, ตามลำดับนิยม) — ใช้ทำ first-run smart skip + แนะ headless */
 export function detectEnvProvider() {
-    for (const id of ['anthropic', 'openai', 'google', 'deepseek', 'xai', 'mistral', 'groq', 'glm', 'minimax']) {
+    for (const id of ['anthropic', 'openai', 'google', 'xai', 'mistral', 'groq']) {
         const cfg = PROVIDERS[id];
         if (cfg?.requiresKey && hasUsableEnvKey(id)) {
             return { provider: id, label: cfg.label, envVar: cfg.envVar, model: cfg.models.default };
@@ -292,10 +255,14 @@ export function resolveModel(spec) {
         const found = resolveKeyFromEnv(cfg.envVar, cfg.envFallbacks);
         if (!found) {
             const url = consoleUrl(provider);
+            const codexHint = provider === 'openai'
+                ? `\n  • ถ้าต้องการใช้ ChatGPT plan ไม่ใช้ API key: เลือก \`/model codex\` แล้วรัน \`codex login\``
+                : '';
             throw new Error(`ยังไม่มี API key ของ ${cfg.label} (${cfg.envVar})\n` +
                 (url ? `  • เอา key ที่: ${url}\n` : '') +
                 `  • ตั้ง: export ${cfg.envVar}="..."   ` +
-                `หรือรัน \`${BRAND.cliName}\` (ไม่ใส่ task) เพื่อ setup wizard`);
+                `หรือรัน \`${BRAND.cliName}\` (ไม่ใส่ task) เพื่อ setup wizard` +
+                codexHint);
         }
         assertDirectApiKey(cfg, found); // reject OAuth/subscription token + format ผิด
         key = found;
@@ -303,7 +270,7 @@ export function resolveModel(spec) {
     else {
         key = resolveKeyFromEnv(cfg.envVar) ?? cfg.localPlaceholderKey ?? 'local';
     }
-    // <PROVIDER>_BASE_URL env → override (สลับ region intl/จีน); ไม่งั้น local อ่าน env, cloud ใช้ default
+    // <PROVIDER>_BASE_URL env → override (สลับ region); ไม่งั้น local อ่าน env, cloud ใช้ default
     const baseURL = process.env[`${cfg.id.toUpperCase()}_BASE_URL`] ??
         (cfg.requiresKey ? cfg.baseURL : process.env[cfg.envVar] ?? cfg.baseURL);
     return cfg.create(key, baseURL)(model);

package/dist/search/chunk.js

@@ -12,15 +12,11 @@
 // or a stray [[ inside a code fence degrade to "no frontmatter / no links"
 // rather than throwing. We must never block indexing a real, messy vault file.
 // ============================================================================
+import { createHash } from 'node:crypto';
 const MIN_CHARS = 120; // sections shorter than this fold into the next chunk
-/** deterministic short hash of a path (fnv-1a → base36) — no crypto dep, stable chunk ids. */
+/** deterministic path hash — SHA-256 prefix keeps chunk ids short without 32-bit collision risk. */
 export function pathHash(path) {
-    let h = 0x811c9dc5;
-    for (let i = 0; i < path.length; i++) {
-        h ^= path.charCodeAt(i);
-        h = Math.imul(h, 0x01000193);
-    }
-    return (h >>> 0).toString(36);
+    return createHash('sha256').update(path).digest('hex').slice(0, 16);
 }
 /** split a leading `---\n…\n---` frontmatter block from the body. Defensive: no block ⇒ {} + full md. */
 export function parseFrontmatter(md) {
@@ -31,7 +27,10 @@ export function parseFrontmatter(md) {
     if (end === -1)
         return { data: empty, body: md };
     const block = md.slice(3, end).trim();
-    const body = md.slice(md.indexOf('\n', end + 1) + 1).replace(/^\n+/, '');
+    // หา newline หลัง closing fence; ถ้าไม่มี (frontmatter-only ไม่มี trailing newline) body = '' ไม่ใช่ทั้งไฟล์
+    // (indexOf คืน -1 → slice(0) = ทั้งไฟล์ → frontmatter รั่วเข้า body ทำ index/search เพี้ยน)
+    const afterFence = md.indexOf('\n', end + 1);
+    const body = (afterFence === -1 ? '' : md.slice(afterFence + 1)).replace(/^\n+/, '');
     const data = { tags: [] };
     const lines = block.split('\n');
     for (let i = 0; i < lines.length; i++) {

package/dist/search/cli.js

@@ -0,0 +1,83 @@
+import { inlineValue, takeValue } from '../cli-option-values.js';
+import { SEARCH_SOURCES } from './index-core.js';
+const SEARCH_MODES = ['auto', 'fts', 'semantic', 'hybrid'];
+function isSearchMode(v) {
+    return SEARCH_MODES.includes(v);
+}
+function isSearchSource(v) {
+    return SEARCH_SOURCES.includes(v);
+}
+function parsePositiveInteger(raw) {
+    if (!raw || !/^[1-9]\d*$/.test(raw))
+        return undefined;
+    const n = Number(raw);
+    return Number.isSafeInteger(n) ? n : undefined;
+}
+function inlineSourceValue(value) {
+    return inlineValue('--source', value) ?? inlineValue('--sources', value);
+}
+export function parseSearchArgs(args) {
+    const queryParts = [];
+    let mode = 'auto';
+    let modeSet = false;
+    let limit = 8;
+    let limitSet = false;
+    let sources;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--') {
+            queryParts.push(...args.slice(i + 1));
+            break;
+        }
+        else if (a === '--mode' || a.startsWith('--mode=')) {
+            const next = a === '--mode' ? takeValue(args, i) : undefined;
+            const v = next ? next.value : inlineValue('--mode', a);
+            if (next)
+                i = next.nextIndex;
+            if (!v)
+                return { ok: false, message: `--mode ต้องระบุค่าเป็น ${SEARCH_MODES.join('|')}` };
+            if (!isSearchMode(v))
+                return { ok: false, message: `--mode ต้องเป็น ${SEARCH_MODES.join('|')}` };
+            if (modeSet)
+                return { ok: false, message: 'ใช้ --mode เพียงครั้งเดียว' };
+            mode = v;
+            modeSet = true;
+        }
+        else if (a === '--limit' || a.startsWith('--limit=')) {
+            const next = a === '--limit' ? takeValue(args, i) : undefined;
+            const raw = next ? next.value : inlineValue('--limit', a);
+            if (next)
+                i = next.nextIndex;
+            if (!raw)
+                return { ok: false, message: '--limit ต้องระบุค่าเป็น integer บวก เช่น 8' };
+            const n = parsePositiveInteger(raw);
+            if (n === undefined)
+                return { ok: false, message: '--limit ต้องเป็น integer บวก เช่น 8' };
+            if (limitSet)
+                return { ok: false, message: 'ใช้ --limit เพียงครั้งเดียว' };
+            limit = n;
+            limitSet = true;
+        }
+        else if (a === '--source' || a === '--sources' || a.startsWith('--source=') || a.startsWith('--sources=')) {
+            const next = a === '--source' || a === '--sources' ? takeValue(args, i) : undefined;
+            const raw = next ? next.value : inlineSourceValue(a);
+            if (next)
+                i = next.nextIndex;
+            const requested = (raw ?? '').split(',').map((s) => s.trim()).filter(Boolean);
+            const bad = requested.filter((s) => !isSearchSource(s));
+            if (!requested.length) {
+                return { ok: false, message: `--source ต้องระบุค่าเป็น ${SEARCH_SOURCES.join(',')} (คั่นหลายค่าได้ด้วย comma)` };
+            }
+            if (bad.length)
+                return { ok: false, message: `--source ต้องเป็น ${SEARCH_SOURCES.join(',')} (คั่นหลายค่าได้ด้วย comma)` };
+            sources = [...new Set([...(sources ?? []), ...requested])];
+        }
+        else {
+            queryParts.push(a);
+        }
+    }
+    const query = queryParts.join(' ').trim();
+    if (!query)
+        return { ok: false, message: 'ต้องใส่ query สำหรับค้นหา' };
+    return { ok: true, value: { query, mode, limit, sources } };
+}

package/dist/search/embed-store.js

@@ -139,6 +139,9 @@ export async function saveVectors(vi) {
         throw e;
     }
 }
+export function invalidateVectors(tag = '') {
+    return saveVectors(emptyVectors(tag));
+}
 export async function vectorsMtimeMs() {
     try {
         return (await stat(VECTORS_PATH)).mtimeMs;

package/dist/search/embedding-config.js

@@ -0,0 +1,22 @@
+import { readFile } from 'node:fs/promises';
+import { appHomePath } from '../brand.js';
+const EMBEDDING_MODEL_ENV = 'SANOOK_EMBEDDING_MODEL';
+export function cleanEmbeddingModelSpec(v) {
+    if (typeof v !== 'string')
+        return undefined;
+    const clean = v.trim();
+    return clean ? clean : undefined;
+}
+/** read an optional embeddingModel spec from ~/.sanook/config.json. */
+export async function configEmbeddingModel() {
+    try {
+        const cfg = JSON.parse(await readFile(appHomePath('config.json'), 'utf8'));
+        return cleanEmbeddingModelSpec(cfg.embeddingModel);
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function embeddingModelSpec(override) {
+    return cleanEmbeddingModelSpec(override) ?? cleanEmbeddingModelSpec(process.env[EMBEDDING_MODEL_ENV]) ?? (await configEmbeddingModel());
+}

package/dist/search/engine.js

@@ -14,11 +14,10 @@
 // lazily, and on ANY embedding error degrades to BM25 with a `degraded` flag —
 // search must never throw at the floor.
 // ============================================================================
-import { readFile } from 'node:fs/promises';
-import { appHomePath } from '../brand.js';
 import { bm25Search, termList } from './index-core.js';
 import { rrfFuse } from './fuse.js';
 import { cosineTopK, embedQuery, getEmbedder, loadVectors, vectorsMtimeMs, } from './embed-store.js';
+import { embeddingModelSpec } from './embedding-config.js';
 import { indexMtimeMs, loadIndex } from './store.js';
 const CAND = 60; // candidate pool depth per leg before fusion/limit
 const SNIPPET_WIDTH = 64;
@@ -138,16 +137,6 @@ async function cachedVectors() {
     }
     return vectorCache.vectors;
 }
-/** read an optional embeddingModel spec from ~/.sanook/config.json. */
-async function configEmbeddingModel() {
-    try {
-        const cfg = JSON.parse(await readFile(appHomePath('config.json'), 'utf8'));
-        return cfg.embeddingModel;
-    }
-    catch {
-        return undefined;
-    }
-}
 /** drop in-process caches (tests + after a reindex in the same process). */
 export function resetSearchCaches() {
     indexCache = null;
@@ -165,7 +154,7 @@ export async function search(query, opts = {}) {
     const mode = opts.mode ?? 'auto';
     if (mode === 'fts')
         return rankSearch(index, query, opts);
-    const spec = opts.embeddingModel ?? process.env.SANOOK_EMBEDDING_MODEL ?? (await configEmbeddingModel());
+    const spec = await embeddingModelSpec(opts.embeddingModel);
     const embedder = getEmbedder(spec);
     if (!embedder) {
         const res = rankSearch(index, query, opts);

package/dist/search/indexer.js

@@ -24,7 +24,9 @@ import { loadSkills } from '../skills.js';
 import { activeFacts, effImportance, loadStore } from '../memory-store.js';
 import { chunkMarkdown } from './chunk.js';
 import { addDoc, removeDoc, removeSource } from './index-core.js';
+import { embeddingModelSpec } from './embedding-config.js';
 import { loadIndex, saveIndex } from './store.js';
+import { buildVectorIndex, embedTexts, getEmbedder, invalidateVectors, saveVectors } from './embed-store.js';
 /** strip a .md path to a human title fallback when a chunk has no heading. */
 function fileTitle(rel) {
     return (rel.split('/').pop() ?? rel).replace(/\.md$/i, '');
@@ -37,6 +39,14 @@ export async function indexVaultFiles(index, manifest, fs) {
     const next = {};
     const diff = { added: 0, updated: 0, removed: 0, skipped: 0 };
     const paths = await fs.listMarkdown();
+    // Guard against a momentarily-unreadable vault (unmounted drive / perms blip / wrong cwd): walk()
+    // swallows readdir errors and returns [], which would otherwise evict the ENTIRE persisted index
+    // via the deletion sweep below. If a non-empty manifest just lost >50% of its files, treat it as a
+    // transient read failure and keep the existing index+manifest untouched (recovers on the next pass).
+    const manifestSize = Object.keys(manifest).length;
+    if (manifestSize > 0 && paths.length < Math.ceil(manifestSize * 0.5)) {
+        return { manifest, diff: { added: 0, updated: 0, removed: 0, skipped: manifestSize } };
+    }
     const seenExisting = new Set();
     for (const rel of paths) {
         const fp = await fs.fingerprint(rel);
@@ -130,6 +140,21 @@ export function foldSkills(index, skills) {
     }
     return skills.length;
 }
+function docEmbeddingText(doc) {
+    return [doc.title?.trim(), doc.text.trim()].filter(Boolean).join('\n').slice(0, 4000);
+}
+export async function vectorizeIndex(index, tag, embed) {
+    const docs = [...index.docs.values()]
+        .filter((d) => d.text.trim())
+        .sort((a, b) => a.id.localeCompare(b.id));
+    if (!docs.length)
+        return buildVectorIndex(tag, []);
+    const vectors = await embed(docs.map(docEmbeddingText));
+    if (vectors.length !== docs.length) {
+        throw new Error(`embedding count mismatch: expected ${docs.length}, got ${vectors.length}`);
+    }
+    return buildVectorIndex(tag, docs.map((d, i) => ({ id: d.id, vec: vectors[i] })));
+}
 // ---- real-filesystem wiring ------------------------------------------------
 const IGNORE_DIRS = new Set([
     'node_modules', 'dist', 'build', 'coverage', '.next', '.cache', '.git',
@@ -237,5 +262,23 @@ export async function reindex(now = Date.now()) {
         text: `${s.description} ${s.whenToUse ?? ''}`.trim(),
     })));
     await saveIndex(index, nextManifest);
-    return { ...diff, memory, sessions, skills, vaultPath: brain ?? null };
+    let vectors = 0;
+    const embedder = getEmbedder(await embeddingModelSpec());
+    if (!embedder) {
+        await invalidateVectors().catch(() => { });
+    }
+    else {
+        try {
+            const vi = await vectorizeIndex(index, embedder.tag, (texts) => embedTexts(embedder, texts));
+            await saveVectors(vi);
+            vectors = vi.ids.length;
+        }
+        catch {
+            // Semantic search is optional. A provider/network failure must never break
+            // the BM25 floor. Clear stale vectors so hybrid/semantic cannot rank the
+            // freshly-saved BM25 index with embeddings from an older corpus.
+            await invalidateVectors(embedder.tag).catch(() => { });
+        }
+    }
+    return { ...diff, memory, sessions, skills, vectors, vaultPath: brain ?? null };
 }

package/dist/search/store.js

@@ -34,6 +34,28 @@ export async function indexMtimeMs() {
         return 0;
     }
 }
+export function sanitizeManifest(raw) {
+    const out = Object.create(null);
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return out;
+    for (const [path, entry] of Object.entries(raw)) {
+        if (!path || ['__proto__', 'prototype', 'constructor'].includes(path))
+            continue;
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            continue;
+        const r = entry;
+        const mtimeMs = Number(r.mtimeMs);
+        const size = Number(r.size);
+        if (!Number.isFinite(mtimeMs) || mtimeMs < 0 || !Number.isFinite(size) || size < 0)
+            continue;
+        if (typeof r.sha !== 'string' || !r.sha || r.sha.length > 256)
+            continue;
+        if (!Array.isArray(r.ids) || !r.ids.every((id) => typeof id === 'string' && id.length > 0 && id.length < 1024))
+            continue;
+        out[path] = { mtimeMs, size, sha: r.sha, ids: [...r.ids] };
+    }
+    return out;
+}
 /**
  * Load the persisted index + manifest. Pure read: a missing or malformed file
  * degrades to an empty index rather than throwing, so a corrupt cache never
@@ -43,7 +65,7 @@ export async function loadIndex() {
     try {
         const raw = JSON.parse(await readFile(INDEX_PATH, 'utf8'));
         if (raw && raw.v === FILE_VERSION) {
-            return { index: indexFromJSON(raw.index), manifest: raw.manifest ?? {} };
+            return { index: indexFromJSON(raw.index), manifest: sanitizeManifest(raw.manifest) };
         }
     }
     catch {

package/dist/session-distill.js

@@ -0,0 +1,84 @@
+// Session knowledge distiller — extracts DURABLE facts (decisions, gotchas, preferences,
+// constraints) from a finished session transcript so they can be folded into the memory store
+// WITHOUT the model voluntarily calling `remember`. Pure + deterministic (heuristic): the offline,
+// zero-cost fallback. An LLM-based extractor can layer on top when a model is available.
+// Signal patterns — a sentence is a candidate only if it matches one (keeps precision up).
+const SIGNALS = [
+    { kind: 'decision', re: /\b(decided|we['’]?ll use|we will use|we use|going with|chose|switch(?:ed|ing)? to|standardiz(?:e|ed|ing) on|settled on|agreed to)\b/i },
+    { kind: 'preference', re: /\b(prefer(?:s|red)?|convention(?: is|:)|by convention|coding style|likes? to|always (?:use|run|prefer|name)|we name)\b/i },
+    { kind: 'constraint', re: /\b(must not|must|never|do ?n['’]?t|don['’]t|required to|is required|only (?:use|run|allow)|forbidden|not allowed|has to)\b/i },
+    { kind: 'gotcha', re: /\b(gotcha|caveat|watch out|the (?:bug|issue|problem|error) (?:was|is)|turned out|root cause|fix(?:ed)? (?:was|by|it by)|fails? (?:if|when|because)|breaks? (?:if|when)|broke because|because the|note that|important:|heads up)\b/i },
+];
+// Strong "X not Y" / "X instead of Y" decision signal (e.g. "pnpm not npm", "tabs over spaces").
+const X_NOT_Y = /\b[\w.@/+-]{2,}\s+(?:not|instead of|over|rather than)\s+[\w.@/+-]{2,}\b/i;
+const MAX_CANDIDATES = 12;
+const MIN_WORDS = 4;
+const MAX_WORDS = 45;
+function looksLikeCodeOrLog(s) {
+    if (/^\s*[$#>]/.test(s))
+        return true; // shell prompt / diff marker
+    if (/[{};=]\s*$/.test(s) && /[(){}\[\]=;]/.test(s))
+        return true; // code-ish line
+    if (/\b(at |Error:|Traceback|stack trace|node_modules\/)/.test(s) && /:\d+/.test(s))
+        return true; // stack trace
+    const symbolRatio = (s.replace(/[\w\s]/g, '').length || 0) / Math.max(1, s.length);
+    return symbolRatio > 0.3; // mostly punctuation/symbols
+}
+function splitSentences(text) {
+    return text
+        .split(/(?<=[.!?])\s+|\n+/)
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+function normalize(s) {
+    return s.replace(/\s+/g, ' ').replace(/^[-*•\d.)\s]+/, '').trim();
+}
+/**
+ * Extract durable-fact candidates from a transcript. Skips questions, chit-chat, code/log lines,
+ * and too-short/too-long sentences; requires a decision/gotcha/preference/constraint signal.
+ */
+export function distillSession(messages) {
+    const out = [];
+    const seen = new Set();
+    for (const msg of messages) {
+        if (msg.role !== 'user' && msg.role !== 'assistant')
+            continue;
+        for (const raw of splitSentences(msg.text)) {
+            const s = normalize(raw);
+            const words = s.split(/\s+/).filter(Boolean);
+            if (words.length < MIN_WORDS || words.length > MAX_WORDS)
+                continue;
+            if (s.endsWith('?'))
+                continue; // questions aren't durable facts
+            if (looksLikeCodeOrLog(s))
+                continue;
+            const signal = SIGNALS.find((sig) => sig.re.test(s));
+            const kind = signal?.kind ?? (X_NOT_Y.test(s) ? 'decision' : undefined);
+            if (!kind)
+                continue;
+            const key = s.toLowerCase().replace(/[^a-z0-9 ]/g, '').trim();
+            if (!key || seen.has(key))
+                continue;
+            seen.add(key);
+            out.push({ text: s, kind });
+            if (out.length >= MAX_CANDIDATES)
+                return out;
+        }
+    }
+    return out;
+}
+/** flatten an AI-SDK ModelMessage content (string | parts[]) to its plain text. */
+function messageText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map((p) => (p && typeof p === 'object' && 'text' in p && typeof p.text === 'string' ? p.text : ''))
+        .join(' ')
+        .trim();
+}
+/** distill durable-fact texts from a finished conversation (ModelMessage[]-shaped). Pure. */
+export function distilledFactsFromMessages(messages) {
+    return distillSession(messages.map((m) => ({ role: m.role, text: messageText(m.content) }))).map((c) => c.text);
+}