sanook-cli 0.4.0 → 0.5.0

package/dist/memory.js

@@ -1,10 +1,11 @@
-import { readFile, writeFile, mkdir, stat } from 'node:fs/promises';
-import { homedir } from 'node:os';
+import { readFile, writeFile, stat } from 'node:fs/promises';
 import { join, dirname, resolve } from 'node:path';
-const MEMORY_FILE = 'SANOOK.md';
-// auto-memory: สิ่งที่ agent จำเองข้าม session (เลียน MEMORY.md ของ Claude Code)
-const AUTO_MEMORY_DIR = join(homedir(), '.sanook', 'memory');
-const AUTO_MEMORY_FILE = join(AUTO_MEMORY_DIR, 'MEMORY.md');
+import { appHomePath, BRAND, persistenceEnabled, worklogEnabled } from './brand.js';
+import { redactKey } from './providers/keys.js';
+import { loadStore, saveStore, mergeFact, maybeConsolidate, consolidate, renderPromptBlock } from './memory-store.js';
+const MEMORY_FILE = BRAND.memoryFileName;
+// auto-memory (สิ่งที่ agent จำเองข้าม session) ย้ายไปอยู่ใน ./memory-store.ts —
+// memory.json เป็น source of truth, MEMORY.md เป็น view ที่ render จากมัน
 // เดินขึ้นหยุดที่ project root — ไม่เลยขึ้นไปถึง filesystem root
 // (กัน prompt-injection จาก SANOOK.md ที่ใครก็วางใน parent dir ที่ share กันได้)
 const BOUNDARY_MARKERS = ['.git', 'package.json'];
@@ -40,7 +41,7 @@ export async function loadMemory(cwd = process.cwd()) {
         dir = parent;
     }
     chain.reverse(); // project root ก่อน → cwd ท้าย (local override general)
-    const paths = [join(homedir(), '.sanook', MEMORY_FILE), ...chain.map((d) => join(d, MEMORY_FILE))];
+    const paths = [appHomePath(MEMORY_FILE), ...chain.map((d) => join(d, MEMORY_FILE))];
     const blocks = [];
     const seen = new Set();
     for (const p of paths) {
@@ -58,11 +59,14 @@ export async function loadMemory(cwd = process.cwd()) {
     }
     return blocks.join('\n\n');
 }
-/** โหลด auto-memory (สิ่งที่ agent จำเองข้าม session) จาก ~/.sanook/memory/MEMORY.md */
+/**
+ * โหลด auto-memory เข้า system prompt — render จาก structured store (./memory-store.ts)
+ * เป็น block ที่ rank + cap แล้ว (top facts ตาม importance·recency, ≤ ~2k token กัน context-rot)
+ * contract เดิม: '' ถ้าว่าง, ไม่งั้นคืน <auto_memory> block เดียวที่ self-contained
+ */
 export async function loadAutoMemory() {
     try {
-        const content = (await readFile(AUTO_MEMORY_FILE, 'utf8')).trim();
-        return content ? `<auto_memory note="สิ่งที่จำไว้จาก session ก่อน">\n${content}\n</auto_memory>` : '';
+        return renderPromptBlock(await loadStore());
     }
     catch {
         return '';
@@ -74,35 +78,145 @@ export async function loadAutoMemory() {
  * brainPath มาจาก ~/.sanook/config.json · ไม่มี/ไฟล์หาย → คืน '' (เงียบ)
  */
 export async function loadBrainContext() {
+    const brainPath = await getBrainPath();
+    return brainPath ? buildBrainContext(brainPath) : '';
+}
+/** ประกอบ brain context จาก vault path (pure → testable) — entry + current-state + remembered facts */
+export async function buildBrainContext(brainPath) {
+    const parts = [];
+    // 1. entry/pointers (Vault Structure Map ฯลฯ)
+    const idx = await readTrimmed(join(brainPath, 'Shared', 'AI-Context-Index.md'), 3000);
+    if (idx)
+        parts.push(idx);
+    // 2. current-state — เนื้อจริง (live focus) ไม่ใช่แค่ pointer
+    const cs = await readTrimmed(join(brainPath, 'Shared', 'Operating-State', 'current-state.md'), 1500);
+    if (cs)
+        parts.push(`## current-state\n${cs}`);
+    // 3. ปิด loop: fact ที่ remember ไว้ (Memory-Inbox) กลับเข้า context — ไม่งั้น vault = write-only
+    const inbox = await inboxCandidates(join(brainPath, 'Shared', 'Memory-Inbox', 'memory-inbox.md'), 1200);
+    if (inbox)
+        parts.push(`## remembered (Memory-Inbox)\n${inbox}`);
+    if (!parts.length)
+        return '';
+    return `<brain_vault path="${brainPath}" note="second-brain ของ user — สิ่งที่จำไว้/state ปัจจุบันอยู่ใน block นี้; route โน้ตตาม Vault Structure Map; อ่าน/เขียนไฟล์ใน vault ด้วย absolute path ได้">\n${parts.join('\n\n')}\n</brain_vault>`;
+}
+/** อ่านไฟล์ + trim หัว N ตัว ('' ถ้าไม่มี/ว่าง) */
+async function readTrimmed(p, max) {
     try {
-        const cfg = JSON.parse(await readFile(join(homedir(), '.sanook', 'config.json'), 'utf8'));
-        if (!cfg.brainPath)
+        const c = (await readFile(p, 'utf8')).trim();
+        if (!c)
             return '';
-        const idxPath = join(cfg.brainPath, 'Shared', 'AI-Context-Index.md');
-        const content = (await readFile(idxPath, 'utf8')).trim();
-        if (!content)
+        return c.length > max ? `${c.slice(0, max)}\n…` : c;
+    }
+    catch {
+        return '';
+    }
+}
+/** ดึงรายการ "- ..." ใต้ "## New Candidates" จาก memory-inbox (fact ที่ remember ไว้) */
+async function inboxCandidates(p, max) {
+    try {
+        const after = (await readFile(p, 'utf8')).split('## New Candidates')[1];
+        if (!after)
             return '';
-        // budget (context-assembly): signal สูงอยู่หัวไฟล์ → เอาหัว ~4000 ตัว, ที่เหลอ agent อ่านเองได้
-        const body = content.length > 4000 ? `${content.slice(0, 4000)}\n…(ตัด — อ่านเต็มที่ ${idxPath})` : content;
-        return `<brain_vault path="${cfg.brainPath}" note="second-brain ของ user — อ่าน context นี้ก่อน; route/เก็บโน้ตตาม Vault Structure Map; อ่านไฟล์อื่นใน vault ด้วย absolute path ได้">\n${body}\n</brain_vault>`;
+        const lines = after
+            .split('\n')
+            .filter((l) => l.trim().startsWith('- ') && !l.includes('_('))
+            .map((l) => l.trim());
+        const text = lines.join('\n').trim();
+        return text.length > max ? `${text.slice(0, max)}\n…` : text;
     }
     catch {
         return '';
     }
 }
-/** บันทึก fact ลง auto-memory (remember tool เรียก) — dedup บรรทัดซ้ำ */
-export async function appendMemory(fact) {
-    const line = `- ${fact.trim().replace(/\s+/g, ' ')}`;
-    await mkdir(AUTO_MEMORY_DIR, { recursive: true });
-    let existing = '';
+/** path ของ second-brain vault จาก config (undefined = ไม่ได้ตั้ง) */
+export async function getBrainPath() {
     try {
-        existing = await readFile(AUTO_MEMORY_FILE, 'utf8');
+        const cfg = JSON.parse(await readFile(appHomePath('config.json'), 'utf8'));
+        return cfg.brainPath;
     }
     catch {
-        /* ยังไม่มีไฟล์ */
+        return undefined;
     }
-    if (existing.includes(line))
-        return; // จำแล้ว ไม่ซ้ำ
-    const header = existing.trim() ? existing.trimEnd() : '# Sanook Auto-Memory';
-    await writeFile(AUTO_MEMORY_FILE, `${header}\n${line}\n`);
+}
+/**
+ * route fact เข้า vault Memory-Inbox (candidate buffer ตาม §4) — "AI เขียนลง second brain ของคุณ"
+ * เขียนเฉพาะถ้า memory-inbox.md มีจริง (กันสร้างไฟล์ใน path ที่ไม่ใช่ vault) · คืน true ถ้าเขียน
+ */
+export async function appendToVaultInbox(brainPath, fact) {
+    const p = join(brainPath, 'Shared', 'Memory-Inbox', 'memory-inbox.md');
+    let content;
+    try {
+        content = await readFile(p, 'utf8');
+    }
+    catch {
+        return false; // ไม่ใช่ vault ที่มีไฟล์นี้ → ไม่ route
+    }
+    const safeFact = redactKey(fact);
+    const line = `- ${safeFact.trim().replace(/\s+/g, ' ')}`;
+    if (content.includes(line))
+        return false; // dedup
+    const marker = '## New Candidates';
+    const next = content.includes(marker)
+        ? content.replace(marker, `${marker}\n${line}`)
+        : `${content.trimEnd()}\n${line}\n`;
+    await writeFile(p, next);
+    return true;
+}
+/** บันทึก worklog ย่อเข้า vault Sessions/ (รายวัน) — "second brain จำว่าวันนี้ทำอะไร" */
+export async function appendBrainWorklog(brainPath, entry) {
+    if (!worklogEnabled())
+        return false;
+    const dir = join(brainPath, 'Sessions');
+    if (!(await exists(dir)))
+        return false; // ไม่ใช่ vault → ข้าม
+    const topic = entry.prompt.trim().split(/\s+/).slice(0, 6).join(' ').slice(0, 50) || 'work';
+    const file = join(dir, `${entry.today}-worklog.md`);
+    let content;
+    try {
+        content = await readFile(file, 'utf8');
+    }
+    catch {
+        content = `---\ntags: [session, session-log, worklog]\nnote_type: session-log\ncreated: ${entry.today}\nupdated: ${entry.today}\nparent: "[[Sessions/_Index]]"\nai_surface: history\n---\n\n# ${entry.today} — Worklog (auto by ${BRAND.cliName})\n\nup:: [[Sessions/_Index]]\n`;
+    }
+    const block = `\n## ${topic}\n- prompt: ${redactKey(entry.prompt).trim().slice(0, 200)}\n- model: ${entry.model}\n- ${redactKey(entry.summary).trim().slice(0, 300)}\n`;
+    // แทรกก่อน up:: ท้ายไฟล์ (กัน up:: หลุดไปกลาง)
+    const out = content.includes('\nup:: ')
+        ? content.replace(/\nup:: .*$/s, `\n${block}\nup:: [[Sessions/_Index]]\n`)
+        : `${content.trimEnd()}\n${block}`;
+    await writeFile(file, out);
+    return true;
+}
+// in-process write serializer: the AI SDK runs tool calls from one model step concurrently, so two
+// `remember` calls in a turn would otherwise load → mergeFact → save on the SAME baseline and the
+// last save would clobber the first (lost update). Chaining the read-modify-write makes them sequential.
+let memWriteChain = Promise.resolve();
+function withMemLock(fn) {
+    const run = memWriteChain.then(fn, fn); // run regardless of the prior task's outcome
+    memWriteChain = run.catch(() => { }); // a rejection must not break the chain for the next writer
+    return run;
+}
+/**
+ * บันทึก fact ลง auto-memory (remember tool เรียก) — "Merge, Don't Append":
+ * โหลด store → mergeFact (ADD/UPDATE/NOOP/SUPERSEDE) → save (ถ้าไม่ใช่ no-write op)
+ * → consolidate เป็นระยะ → route เข้า vault inbox (best-effort) เหมือนเดิม
+ * read-modify-write ของ store และ vault inbox ถูก serialize ด้วย withMemLock กัน lost-update ตอน parallel remember
+ */
+export async function appendMemory(fact, noteType) {
+    if (!persistenceEnabled())
+        return;
+    const safeFact = redactKey(fact);
+    await withMemLock(async () => {
+        const store = await loadStore();
+        const { store: next, op } = mergeFact(store, { text: safeFact, trust: 'agent', noteType });
+        // PROTECTED_HALT = ไม่เขียน (ขัดกับ protected fact); op อื่นเขียนหมด (NOOP ก็เขียนเพราะ touch accessCount)
+        if (op !== 'PROTECTED_HALT') {
+            const toSave = maybeConsolidate(next) ? consolidate(next).store : next;
+            await saveStore(toSave);
+        }
+        // route เข้า vault second-brain ด้วย (best-effort) — ส่ง plain redacted string เหมือนเดิม
+        const brain = await getBrainPath();
+        if (brain)
+            await appendToVaultInbox(brain, safeFact).catch(() => false);
+    });
 }

package/dist/orchestrate.js

@@ -0,0 +1,150 @@
+// ============================================================================
+// src/orchestrate.ts — subagent ORCHESTRATION (parallel fan-out + background).
+//
+// The single Task subagent (src/tools/task.ts) is one-shot and synchronous. This
+// module adds the two missing orchestration primitives a frontier harness needs:
+//   1. runParallel() — fan a list of subagents out concurrently with a real
+//      concurrency cap and PER-ITEM error isolation (one failure never sinks the
+//      batch), results returned in input order.
+//   2. TaskRegistry — fire-and-forget BACKGROUND subagents: spawn() returns an id
+//      immediately, the work runs detached, and collect()/list()/cancel() let the
+//      main agent keep working and gather results later in the same session.
+//
+// Everything is PURE w.r.t. the actual agent: the subagent runner is INJECTED
+// (SubagentRunner), and the clock + id generator are injectable, so the whole
+// orchestration layer unit-tests with a fake runner — zero model calls, zero
+// network — exactly like the search subsystem injects its fs.
+// ============================================================================
+const DEFAULT_CONCURRENCY = 5;
+/**
+ * Run thunks concurrently, capped at `concurrency`, results in input order.
+ * The generic concurrency primitive both runParallel and worktree isolation use.
+ */
+export async function runThunks(thunks, concurrency = DEFAULT_CONCURRENCY) {
+    const cap = Math.max(1, Math.floor(concurrency));
+    const results = new Array(thunks.length);
+    let next = 0;
+    const worker = async () => {
+        for (;;) {
+            const i = next++;
+            if (i >= thunks.length)
+                return;
+            results[i] = await thunks[i]();
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(cap, thunks.length) }, worker));
+    return results;
+}
+async function runOne(spec, runner, signal) {
+    try {
+        const text = await runner(spec, signal);
+        return { ok: true, description: spec.description, text };
+    }
+    catch (e) {
+        return { ok: false, description: spec.description, text: '', error: e.message };
+    }
+}
+/**
+ * Run subagents concurrently, capped at `concurrency`, results in input order.
+ * Never rejects: a thrown subagent becomes an {ok:false,error} outcome so the
+ * caller always gets one outcome per spec.
+ */
+export async function runParallel(specs, runner, opts = {}) {
+    return runThunks(specs.map((s) => () => runOne(s, runner, opts.signal)), opts.concurrency ?? DEFAULT_CONCURRENCY);
+}
+/**
+ * In-process registry of BACKGROUND subagents. spawn() launches detached work and
+ * returns an id; collect() awaits (optionally with a timeout so the agent can poll
+ * instead of block); cancel() aborts via the runner's AbortSignal. Lives for the
+ * process — background work dies when the CLI exits, so it is for within-session
+ * fan-out ("kick off research, keep coding, gather it later"), not durable jobs
+ * (use `schedule_task` / the gateway for those).
+ */
+export class TaskRegistry {
+    tasks = new Map();
+    settles = new Map();
+    controllers = new Map();
+    counter = 0;
+    now;
+    idGen;
+    constructor(opts = {}) {
+        this.now = opts.now ?? Date.now;
+        this.idGen = opts.idGen ?? (() => `t${++this.counter}`);
+    }
+    /** launch a detached subagent; returns its id immediately. */
+    spawn(spec, runner) {
+        const id = this.idGen();
+        const ac = new AbortController();
+        this.controllers.set(id, ac);
+        const rec = { id, description: spec.description, state: 'running', startedMs: this.now() };
+        this.tasks.set(id, rec);
+        const settle = (async () => {
+            try {
+                const text = await runner(spec, ac.signal);
+                const cur = this.tasks.get(id);
+                if (cur.state !== 'canceled')
+                    Object.assign(cur, { state: 'done', text, endedMs: this.now() });
+                return cur;
+            }
+            catch (e) {
+                const cur = this.tasks.get(id);
+                if (cur.state !== 'canceled')
+                    Object.assign(cur, { state: 'error', error: e.message, endedMs: this.now() });
+                return cur;
+            }
+            finally {
+                this.controllers.delete(id);
+            }
+        })();
+        // swallow at the source — collect() is the consumer; an uncollected reject must not crash the process
+        settle.catch(() => { });
+        this.settles.set(id, settle);
+        return id;
+    }
+    get(id) {
+        return this.tasks.get(id);
+    }
+    list() {
+        return [...this.tasks.values()];
+    }
+    /**
+     * Await a background task. With timeoutMs, resolves to the current (possibly
+     * still-running) record if it hasn't settled in time, so the caller can poll.
+     * Returns undefined for an unknown id.
+     */
+    async collect(id, timeoutMs) {
+        const settle = this.settles.get(id);
+        if (!settle)
+            return undefined;
+        if (timeoutMs == null)
+            return settle;
+        let timer;
+        const timeout = new Promise((resolve) => {
+            timer = setTimeout(() => resolve(this.tasks.get(id)), Math.max(0, timeoutMs));
+        });
+        try {
+            return await Promise.race([settle, timeout]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    /** abort a running task (best-effort via its AbortSignal). Returns false if not running. */
+    cancel(id) {
+        const rec = this.tasks.get(id);
+        if (!rec || rec.state !== 'running')
+            return false;
+        this.controllers.get(id)?.abort();
+        Object.assign(rec, { state: 'canceled', endedMs: this.now() });
+        return true;
+    }
+    /** number of tasks still running — used to gate runaway fan-out. */
+    runningCount() {
+        let n = 0;
+        for (const r of this.tasks.values())
+            if (r.state === 'running')
+                n++;
+        return n;
+    }
+}

package/dist/providers/codex.js

@@ -5,7 +5,7 @@ import { join } from 'node:path';
 /** เช็กว่า codex CLI ติดตั้ง + login ChatGPT แล้ว */
 export async function detectCodex() {
     const hasBinary = await new Promise((resolve) => {
-        const p = spawn('codex', ['--version']);
+        const p = spawn('codex', ['--version'], { shell: process.platform === 'win32' });
         p.on('error', () => resolve(false));
         p.on('close', (code) => resolve(code === 0));
     });
@@ -35,7 +35,7 @@ export async function runCodex(opts) {
     return new Promise((resolve, reject) => {
         // OPENAI_API_KEY='' กัน BYOK key ของ Sanook ไป override ChatGPT login ของ codex
         const env = { ...process.env, OPENAI_API_KEY: '' };
-        const p = spawn('codex', args, { env });
+        const p = spawn('codex', args, { env, shell: process.platform === 'win32' }); // Windows: codex.cmd
         let finalText = '';
         let threadId;
         let buf = '';

package/dist/providers/keys.js

@@ -28,10 +28,11 @@ export function assertDirectApiKey(policy, key) {
         }
     }
     if (policy.keyFormat && !policy.keyFormat.test(k)) {
-        throw new Error(`${policy.label}: format ของ API key ไม่ถูกต้อง — เช็ก/วางใหม่ (คาดว่าขึ้นต้นตาม ${policy.keyFormat.source})`);
+        const hint = policy.keyExample ? `ขึ้นต้นแบบ ${policy.keyExample}` : `ขึ้นต้นตาม ${policy.keyFormat.source}`;
+        throw new Error(`${policy.label}: format ของ API key ไม่ถูกต้อง — เช็ก/วางใหม่ (${hint})`);
     }
 }
 /** ปิดบัง API key ในข้อความ log/error — เก็บแค่หัว 4 + ท้าย 2 ตัว */
 export function redactKey(s) {
-    return s.replace(/\b(sk-[A-Za-z0-9_-]{6,}|AIza[A-Za-z0-9_-]{10,}|xai-[A-Za-z0-9]{10,}|gsk_[A-Za-z0-9]{10,}|[A-Za-z0-9_-]{24,})\b/g, (m) => (m.length > 8 ? `${m.slice(0, 4)}…${m.slice(-2)}` : '…'));
+    return s.replace(/\b(AKIA[0-9A-Z]{16}|sk-[A-Za-z0-9_-]{6,}|AIza[A-Za-z0-9_-]{10,}|xai-[A-Za-z0-9]{10,}|gsk_[A-Za-z0-9]{10,}|[A-Za-z0-9_-]{24,})\b/g, (m) => (m.length > 8 ? `${m.slice(0, 4)}…${m.slice(-2)}` : '…'));
 }

package/dist/providers/registry.js

@@ -7,6 +7,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 { BRAND } from '../brand.js';
 // ────────────────────────────────────────────────────────────────────────────
 // PROVIDER TABLE — เพิ่มค่าย = เพิ่ม 1 entry (loop/cost/keys ไม่ต้องแตะ)
 // auth/format/OAuth-reject verify มิ.ย. 2026 (ดู Research/provider-connect-matrix)
@@ -20,6 +21,7 @@ export const PROVIDERS = {
         baseURL: 'https://api.anthropic.com/v1',
         requiresKey: true,
         keyFormat: /^sk-ant-api\d{2}-/,
+        keyExample: 'sk-ant-…', // สั้นพอไม่โดน redactKey (sk- + ≥6 chars ถึงโดนตัด)
         oauthRejectPrefixes: ['sk-ant-oat'], // Claude.ai subscription OAuth → banned
         models: {
             default: 'claude-opus-4-8',
@@ -39,6 +41,7 @@ export const PROVIDERS = {
         envFallbacks: ['GOOGLE_API_KEY', 'GEMINI_API_KEY'],
         requiresKey: true,
         keyFormat: /^AIza[0-9A-Za-z_-]{35}$/,
+        keyExample: 'AIza…',
         oauthRejectPrefixes: ['ya29.', 'AQ.'], // Google OAuth / restricted token → banned
         models: {
             default: 'gemini-2.5-pro',
@@ -57,6 +60,7 @@ export const PROVIDERS = {
         baseURL: 'https://api.openai.com/v1',
         requiresKey: true,
         keyFormat: /^sk-/,
+        keyExample: 'sk-…',
         models: {
             default: 'gpt-5.5',
             smart: 'gpt-5.5',
@@ -83,6 +87,7 @@ export const PROVIDERS = {
         envVar: 'XAI_API_KEY',
         requiresKey: true,
         keyFormat: /^xai-[A-Za-z0-9]{16,}$/,
+        keyExample: 'xai-…',
         // grok-4 (snapshot grok-4-0709) retired 2026-05-15 → redirect grok-4.3 (doc audit มิ.ย. 2026)
         models: { default: 'grok-4.3', smart: 'grok-4.3', grok: 'grok-4.3' },
         create: (key) => createXai({ apiKey: key }),
@@ -102,6 +107,7 @@ export const PROVIDERS = {
         envVar: 'GROQ_API_KEY',
         requiresKey: true,
         keyFormat: /^gsk_[A-Za-z0-9]{20,}$/,
+        keyExample: 'gsk_…',
         models: { default: 'llama-3.3-70b-versatile', fast: 'llama-3.3-70b-versatile' },
         create: (key) => createGroq({ apiKey: key }),
     },
@@ -215,6 +221,43 @@ export function specKey(spec) {
     const { provider, model } = parseSpec(spec);
     return `${provider}:${model}`;
 }
+/** หน้า 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];
+}
+/** หา 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']) {
+        const cfg = PROVIDERS[id];
+        if (cfg?.requiresKey && resolveKeyFromEnv(cfg.envVar, cfg.envFallbacks)) {
+            return { provider: id, label: cfg.label, envVar: cfg.envVar, model: cfg.models.default };
+        }
+    }
+    return null;
+}
+/**
+ * model ที่ "ถูก/เร็วกว่า" ในค่ายเดียวกับ spec (สำหรับงานกลไก เช่น summarize/compaction) —
+ * ใช้ key เดียวกัน ไม่ต้องตั้ง key ใหม่. ไม่มี fast tier → คืน spec เดิม (ทำงานได้แต่ไม่ประหยัด)
+ */
+export function fastSibling(spec) {
+    const { provider } = parseSpec(spec);
+    const cfg = PROVIDERS[provider];
+    if (!cfg)
+        return spec;
+    const fast = cfg.models.fast ?? cfg.models.flash ?? cfg.models.haiku ?? cfg.models.air;
+    return fast ? `${provider}:${fast}` : spec;
+}
 /** resolve spec → LanguageModel (throw ถ้าไม่มี key / provider ผิด / key เป็น OAuth) */
 export function resolveModel(spec) {
     const { provider, model } = parseSpec(spec);
@@ -226,7 +269,11 @@ export function resolveModel(spec) {
     if (cfg.requiresKey) {
         const found = resolveKeyFromEnv(cfg.envVar, cfg.envFallbacks);
         if (!found) {
-            throw new Error(`ต้องตั้ง ${cfg.envVar} ก่อนใช้ provider "${provider}" (BYOK — API key ตรงจาก console)`);
+            const url = consoleUrl(provider);
+            throw new Error(`ยังไม่มี API key ของ ${cfg.label} (${cfg.envVar})\n` +
+                (url ? `  • เอา key ที่: ${url}\n` : '') +
+                `  • ตั้ง: export ${cfg.envVar}="..."   ` +
+                `หรือรัน \`${BRAND.cliName}\` (ไม่ใส่ task) เพื่อ setup wizard`);
         }
         assertDirectApiKey(cfg, found); // reject OAuth/subscription token + format ผิด
         key = found;
@@ -239,3 +286,88 @@ export function resolveModel(spec) {
         (cfg.requiresKey ? cfg.baseURL : process.env[cfg.envVar] ?? cfg.baseURL);
     return cfg.create(key, baseURL)(model);
 }
+export const EMBEDDING_PROVIDERS = {
+    openai: {
+        envVar: 'OPENAI_API_KEY',
+        requiresKey: true,
+        defaultModel: 'text-embedding-3-small',
+        create: (key, baseURL) => (id) => createOpenAI({ apiKey: key, baseURL }).textEmbeddingModel(id),
+    },
+    mistral: {
+        envVar: 'MISTRAL_API_KEY',
+        requiresKey: true,
+        defaultModel: 'mistral-embed',
+        create: (key) => (id) => createMistral({ apiKey: key }).textEmbeddingModel(id),
+    },
+    google: {
+        envVar: 'GOOGLE_GENERATIVE_AI_API_KEY',
+        envFallbacks: ['GOOGLE_API_KEY', 'GEMINI_API_KEY'],
+        requiresKey: true,
+        defaultModel: 'text-embedding-004',
+        create: (key) => (id) => createGoogleGenerativeAI({ apiKey: key }).textEmbeddingModel(id),
+    },
+    // local — only picked when explicitly requested (auto-detect never assumes a server is up)
+    ollama: {
+        envVar: 'OLLAMA_BASE_URL',
+        requiresKey: false,
+        localPlaceholderKey: 'ollama',
+        defaultModel: 'nomic-embed-text',
+        create: (key, baseURL) => (id) => createOpenAICompatible({ name: 'ollama', apiKey: key, baseURL: baseURL ?? 'http://localhost:11434/v1' }).textEmbeddingModel(id),
+    },
+};
+/** cloud, key-gated providers tried (in order) when no explicit embeddingModel is configured. */
+const EMBED_AUTODETECT = ['openai', 'mistral', 'google'];
+function buildEmbedder(provider, modelId) {
+    const cfg = EMBEDDING_PROVIDERS[provider];
+    if (!cfg)
+        return null;
+    let key;
+    if (cfg.requiresKey) {
+        const found = resolveKeyFromEnv(cfg.envVar, cfg.envFallbacks);
+        if (!found)
+            return null;
+        const policy = PROVIDERS[provider];
+        if (policy) {
+            try {
+                assertDirectApiKey(policy, found);
+            }
+            catch {
+                return null;
+            }
+        }
+        key = found;
+    }
+    else {
+        key = resolveKeyFromEnv(cfg.envVar) ?? cfg.localPlaceholderKey ?? 'local';
+    }
+    const baseURL = process.env[`${provider.toUpperCase()}_BASE_URL`] ??
+        (cfg.requiresKey ? undefined : process.env[cfg.envVar] ?? undefined);
+    const id = modelId ?? cfg.defaultModel;
+    try {
+        return { model: cfg.create(key, baseURL)(id), provider, modelId: id, tag: `${provider}:${id}` };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve an embeddings model. `spec` is 'provider' | 'provider:modelId' | undefined.
+ * undefined → auto-detect the first cloud provider whose key is present. Returns null
+ * (never throws) when nothing resolves, so callers degrade to BM25-only.
+ */
+export function resolveEmbedder(spec) {
+    if (spec) {
+        const idx = spec.indexOf(':');
+        const provider = (idx === -1 ? spec : spec.slice(0, idx)).trim();
+        if (!provider)
+            return null;
+        const modelId = idx === -1 ? undefined : spec.slice(idx + 1).trim() || undefined;
+        return buildEmbedder(provider, modelId);
+    }
+    for (const provider of EMBED_AUTODETECT) {
+        const e = buildEmbedder(provider);
+        if (e)
+            return e;
+    }
+    return null;
+}