sanook-cli 0.5.0 → 0.5.2

package/dist/orchestrate.js

@@ -1,21 +1,48 @@
-// ============================================================================
-// 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.
-// ============================================================================
+import { inspect } from 'node:util';
+export function formatSubagentError(e) {
+    if (e instanceof Error)
+        return e.message || e.name;
+    if (typeof e === 'string')
+        return e;
+    if (e == null)
+        return String(e);
+    try {
+        const json = JSON.stringify(e);
+        if (json)
+            return json;
+    }
+    catch {
+        return inspect(e, { breakLength: Infinity, depth: 2 });
+    }
+    return String(e);
+}
 const DEFAULT_CONCURRENCY = 5;
+const DEFAULT_GLOBAL_SUBAGENT_CONCURRENCY = 16;
+let globalInFlight = 0;
+const globalWaiters = [];
+function globalSubagentLimit() {
+    const raw = process.env.SANOOK_SUBAGENT_CONCURRENCY?.trim();
+    if (!raw || !/^\d+$/.test(raw))
+        return DEFAULT_GLOBAL_SUBAGENT_CONCURRENCY;
+    const parsed = Number(raw);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? Math.min(parsed, 64) : DEFAULT_GLOBAL_SUBAGENT_CONCURRENCY;
+}
+export function globalSubagentRunningCount() {
+    return globalInFlight;
+}
+export async function withGlobalSubagentSlot(fn) {
+    while (globalInFlight >= globalSubagentLimit()) {
+        await new Promise((resolve) => globalWaiters.push(resolve));
+    }
+    globalInFlight++;
+    try {
+        return await fn();
+    }
+    finally {
+        globalInFlight--;
+        globalWaiters.shift()?.();
+    }
+}
 /**
  * Run thunks concurrently, capped at `concurrency`, results in input order.
  * The generic concurrency primitive both runParallel and worktree isolation use.
@@ -41,7 +68,7 @@ async function runOne(spec, runner, signal) {
         return { ok: true, description: spec.description, text };
     }
     catch (e) {
-        return { ok: false, description: spec.description, text: '', error: e.message };
+        return { ok: false, description: spec.description, text: '', error: formatSubagentError(e) };
     }
 }
 /**
@@ -89,7 +116,7 @@ export class TaskRegistry {
             catch (e) {
                 const cur = this.tasks.get(id);
                 if (cur.state !== 'canceled')
-                    Object.assign(cur, { state: 'error', error: e.message, endedMs: this.now() });
+                    Object.assign(cur, { state: 'error', error: formatSubagentError(e), endedMs: this.now() });
                 return cur;
             }
             finally {
@@ -116,6 +143,9 @@ export class TaskRegistry {
         const settle = this.settles.get(id);
         if (!settle)
             return undefined;
+        const current = this.tasks.get(id);
+        if (current && current.state !== 'running')
+            return current;
         if (timeoutMs == null)
             return settle;
         let timer;

package/dist/personality.js

@@ -0,0 +1,58 @@
+export const PERSONALITIES = {
+    concise: {
+        label: 'Concise',
+        prompt: 'Keep responses short, direct, and practical. Prefer the smallest useful answer.',
+    },
+    friendly: {
+        label: 'Friendly',
+        prompt: 'Use a warm, encouraging tone while staying precise and useful.',
+    },
+    formal: {
+        label: 'Formal',
+        prompt: 'Use a polished, professional tone. Avoid slang and keep recommendations structured.',
+    },
+    direct: {
+        label: 'Direct',
+        prompt: 'Be blunt, decisive, and action-oriented. Lead with the answer and avoid hedging.',
+    },
+    teacher: {
+        label: 'Teacher',
+        prompt: 'Explain the reasoning clearly and teach as you go, without becoming long-winded.',
+    },
+    researcher: {
+        label: 'Researcher',
+        prompt: 'Be evidence-minded. Distinguish facts, assumptions, and uncertainty clearly.',
+    },
+    creative: {
+        label: 'Creative',
+        prompt: 'Offer imaginative options and phrasing while keeping the implementation grounded.',
+    },
+    thai: {
+        label: 'Thai-first',
+        prompt: 'Prefer Thai for user-facing prose unless the user asks for another language.',
+    },
+};
+export function normalizePersonalityName(raw) {
+    const name = raw?.trim().toLowerCase();
+    if (!name)
+        return null;
+    if (['none', 'default', 'neutral', 'off', 'clear'].includes(name))
+        return 'none';
+    return PERSONALITIES[name] ? name : null;
+}
+export function personalityPrompt(name) {
+    const normalized = normalizePersonalityName(name);
+    if (!normalized || normalized === 'none')
+        return '';
+    const def = PERSONALITIES[normalized];
+    return def ? `Personality overlay (${def.label}): ${def.prompt}` : '';
+}
+export function personalityListText() {
+    return [
+        'personality ที่เลือกได้:',
+        '  none — ปิด personality overlay',
+        ...Object.entries(PERSONALITIES).map(([name, def]) => `  ${name} — ${def.label}`),
+        '',
+        'ใช้: /personality <name>',
+    ].join('\n');
+}

package/dist/providers/codex.js

@@ -2,18 +2,32 @@ import { spawn } from 'node:child_process';
 import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+export function codexHome() {
+    return process.env.CODEX_HOME?.trim() || join(homedir(), '.codex');
+}
 /** เช็กว่า codex CLI ติดตั้ง + login ChatGPT แล้ว */
 export async function detectCodex() {
     const hasBinary = await new Promise((resolve) => {
         const p = spawn('codex', ['--version'], { shell: process.platform === 'win32' });
-        p.on('error', () => resolve(false));
-        p.on('close', (code) => resolve(code === 0));
+        // timeout: binary ค้าง (shim รอ stdin / Gatekeeper stall ตอนรันครั้งแรกบน macOS) → ไม่ให้ wizard ตัน
+        const timer = setTimeout(() => {
+            p.kill();
+            resolve(false);
+        }, 5000);
+        p.on('error', () => {
+            clearTimeout(timer);
+            resolve(false);
+        });
+        p.on('close', (code) => {
+            clearTimeout(timer);
+            resolve(code === 0);
+        });
     });
     if (!hasBinary) {
         return { installed: false, loggedIn: false, reason: 'ไม่พบ codex CLI — ติดตั้ง: npm i -g @openai/codex' };
     }
     try {
-        const auth = JSON.parse(await readFile(join(homedir(), '.codex', 'auth.json'), 'utf8'));
+        const auth = JSON.parse(await readFile(join(codexHome(), 'auth.json'), 'utf8'));
         const loggedIn = auth?.auth_mode === 'chatgpt' || Boolean(auth?.tokens?.access_token);
         return { installed: true, loggedIn, reason: loggedIn ? undefined : 'ยังไม่ได้ login — รัน: codex login' };
     }
@@ -26,6 +40,7 @@ export async function detectCodex() {
  * tolerant ต่อ malformed JSONL (codex bug #15451: --json ถูก ignore เมื่อมี tools active)
  */
 export async function runCodex(opts) {
+    // `codex exec` is already non-interactive; sandbox controls whether generated commands may write.
     const args = ['exec', '--skip-git-repo-check', '--sandbox', opts.sandbox ?? 'read-only', '--json'];
     if (opts.model)
         args.push('-m', opts.model);
@@ -33,54 +48,87 @@ export async function runCodex(opts) {
         args.push('resume', opts.resumeThreadId);
     args.push('-'); // prompt via stdin
     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, shell: process.platform === 'win32' }); // Windows: codex.cmd
+        // ลบ OPENAI_API_KEY ออกจาก env ของ child — กัน BYOK key ของ Sanook ไป override/ชนกับ ChatGPT login
+        // (codex bug #2733/#3286: ตั้ง OPENAI_API_KEY ค้าง env ทำให้ ChatGPT-plan auth วน loop sign-in)
+        const env = { ...process.env };
+        delete env.OPENAI_API_KEY;
+        const p = spawn('codex', args, { env, cwd: opts.cwd, shell: process.platform === 'win32' }); // Windows: codex = JS shim ผ่าน .cmd → ต้อง shell
         let finalText = '';
         let threadId;
         let buf = '';
-        opts.signal?.addEventListener('abort', () => p.kill());
-        p.stdin.write(opts.prompt);
-        p.stdin.end();
+        let stderr = '';
+        let aborted = false;
+        const handleStdoutLine = (line) => {
+            const t = line.trim();
+            if (!t)
+                return;
+            if (!t.startsWith('{')) {
+                // plain stdout fallback (JSONL ถูก ignore) — เก็บเป็น final text
+                finalText += (finalText ? '\n' : '') + t;
+                opts.onEvent?.({ type: 'text', text: finalText });
+                return;
+            }
+            try {
+                const ev = JSON.parse(t);
+                if (ev.type === 'thread.started' && ev.thread_id) {
+                    threadId = ev.thread_id;
+                    opts.onEvent?.({ type: 'thread', threadId });
+                }
+                else if (ev.type === 'item.completed' && ev.item?.type === 'agent_message') {
+                    finalText = ev.item.text ?? finalText;
+                    opts.onEvent?.({ type: 'text', text: finalText });
+                }
+                else if (ev.type === 'turn.completed') {
+                    opts.onEvent?.({ type: 'usage', usage: ev.usage });
+                }
+            }
+            catch {
+                // malformed JSON line — ข้าม
+            }
+        };
+        const abortHandler = () => {
+            aborted = true;
+            p.kill();
+        };
+        const cleanupAbortHandler = () => opts.signal?.removeEventListener('abort', abortHandler);
+        // codex อาจตายระหว่างรับ prompt → write ลง stdin ที่ปิดแล้ว = EPIPE; ถ้าไม่ดัก = crash ทั้ง CLI
+        // (close handler ด้านล่าง reject error ที่อ่านรู้เรื่องแทน)
+        p.stdin.on('error', () => { });
+        if (opts.signal?.aborted)
+            abortHandler();
+        else
+            opts.signal?.addEventListener('abort', abortHandler, { once: true });
+        if (!aborted) {
+            p.stdin.write(opts.prompt);
+            p.stdin.end();
+        }
         p.stdout.on('data', (chunk) => {
             buf += chunk.toString();
             const lines = buf.split('\n');
             buf = lines.pop() ?? '';
             for (const line of lines) {
-                const t = line.trim();
-                if (!t)
-                    continue;
-                if (!t.startsWith('{')) {
-                    // plain stdout fallback (JSONL ถูก ignore) — เก็บเป็น final text
-                    finalText += (finalText ? '\n' : '') + t;
-                    opts.onEvent?.({ type: 'text', text: finalText });
-                    continue;
-                }
-                try {
-                    const ev = JSON.parse(t);
-                    if (ev.type === 'thread.started' && ev.thread_id) {
-                        threadId = ev.thread_id;
-                        opts.onEvent?.({ type: 'thread', threadId });
-                    }
-                    else if (ev.type === 'item.completed' && ev.item?.type === 'agent_message') {
-                        finalText = ev.item.text ?? finalText;
-                        opts.onEvent?.({ type: 'text', text: finalText });
-                    }
-                    else if (ev.type === 'turn.completed') {
-                        opts.onEvent?.({ type: 'usage', usage: ev.usage });
-                    }
-                }
-                catch {
-                    // malformed JSON line — ข้าม
-                }
+                handleStdoutLine(line);
             }
         });
-        p.on('error', (err) => reject(new Error(`เรียก codex ไม่ได้: ${err.message}`)));
+        p.stderr.on('data', (chunk) => {
+            stderr += chunk.toString();
+            if (stderr.length > 4000)
+                stderr = stderr.slice(-4000);
+        });
+        p.on('error', (err) => {
+            cleanupAbortHandler();
+            reject(new Error(`เรียก codex ไม่ได้: ${err.message}`));
+        });
         p.on('close', (code) => {
-            if (code === 0)
+            cleanupAbortHandler();
+            handleStdoutLine(buf);
+            buf = '';
+            if (aborted)
+                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}`));
+                reject(new Error(`codex exec จบด้วย exit code ${code}${stderr.trim() ? `: ${stderr.trim()}` : ''}`));
         });
     });
 }

package/dist/providers/keys.js

@@ -8,7 +8,7 @@
 /** อ่าน API key จาก env (หลัก + fallbacks) — keychain เป็น enhancement ทีหลัง */
 export function resolveKeyFromEnv(envVar, fallbacks = []) {
     for (const name of [envVar, ...fallbacks]) {
-        const v = process.env[name];
+        const v = process.env[name]?.trim();
         if (v)
             return v;
     }

package/dist/providers/models.js

@@ -43,13 +43,29 @@ export async function listRemoteModels(cfg, key, timeoutMs = 6000) {
 }
 /**
  * merge: curated alias (registry — มี label สื่อความหมาย) นำหน้า + remote id ที่เหลือต่อท้าย
- * dedup ด้วย model id (ไม่โชว์ id ซ้ำสองครั้ง). ใช้ทั้ง setup wizard และ /model picker
+ * dedup ด้วย model id — alias หลายตัวที่ชี้ id เดียวกัน (เช่น haiku/fast → claude-haiku-4-5,
+ * smart/gpt → gpt-5.5) ต้องรวมเป็น "haiku / fast — id" บรรทัดเดียว ไม่งั้น value ซ้ำ → React key ชน
+ * → ตัวเลือกโผล่ซ้ำ/หาย (bug "มีตัวเลือกสองตัวเลือกเป็น model เดียวกัน"). ใช้ทั้ง setup wizard และ /model picker
  */
 export function mergeModelOptions(cfg, remote = []) {
-    const curated = Object.entries(cfg.models)
-        .filter(([alias]) => alias !== 'default')
-        .map(([alias, id]) => ({ id, label: `${alias} — ${id}` }));
-    const seen = new Set(curated.map((c) => c.id));
-    const extra = remote.filter((id) => !seen.has(id)).map((id) => ({ id, label: id }));
+    // 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)) {
+        if (!aliasesById.has(id)) {
+            aliasesById.set(id, []);
+            order.push(id);
+        }
+        aliasesById.get(id)?.push(alias);
+    }
+    const curated = order.map((id) => {
+        const aliases = aliasesById.get(id) ?? [];
+        const named = aliases.filter((a) => a !== 'default');
+        const shown = named.length ? named : aliases; // มีแต่ 'default' → โชว์ 'default' (ดีกว่าซ่อน id หายไป)
+        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 }));
     return [...curated, ...extra].map((o) => ({ label: o.label, value: o.id }));
 }

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,26 +181,51 @@ 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];
 }
-/** หา provider ที่ "มี key ใน env แล้ว" (cloud, ตามลำดับนิยม) — ใช้ทำ first-run smart skip + แนะ headless */
+/**
+ * provider นี้มี key ใน env ที่ "ใช้ได้จริง" ไหม — มี key + ผ่าน policy (ไม่ใช่ OAuth/subscription token
+ * หรือ format ผิด). ใช้ทั้ง first-run smart-skip และ -m flag เพื่อไม่ให้ข้าม wizard ทั้งที่ key ใช้ไม่ได้
+ * (เช่น export ANTHROPIC_API_KEY=sk-ant-oat… → ถูกแบน → ต้องเข้า wizard ไม่ใช่ขึ้น "พร้อมใช้")
+ */
+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);
+    if (!k)
+        return false;
+    try {
+        assertDirectApiKey(cfg, k); // reject OAuth prefix / format ผิด
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** หา 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 && resolveKeyFromEnv(cfg.envVar, cfg.envFallbacks)) {
+        if (cfg?.requiresKey && hasUsableEnvKey(id)) {
             return { provider: id, label: cfg.label, envVar: cfg.envVar, model: cfg.models.default };
         }
     }
@@ -270,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;
@@ -281,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,75 @@
+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 limit = 8;
+    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('|')}` };
+            mode = v;
+        }
+        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' };
+            limit = n;
+        }
+        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(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;