sanook-cli 0.4.0 → 0.5.1

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,9 +5,20 @@ import { join } from 'node:path';
 /** เช็กว่า codex CLI ติดตั้ง + login ChatGPT แล้ว */
 export async function detectCodex() {
     const hasBinary = await new Promise((resolve) => {
-        const p = spawn('codex', ['--version']);
-        p.on('error', () => resolve(false));
-        p.on('close', (code) => resolve(code === 0));
+        const p = spawn('codex', ['--version'], { shell: process.platform === 'win32' });
+        // 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' };
@@ -26,16 +37,19 @@ export async function detectCodex() {
  * tolerant ต่อ malformed JSONL (codex bug #15451: --json ถูก ignore เมื่อมี tools active)
  */
 export async function runCodex(opts) {
-    const args = ['exec', '--skip-git-repo-check', '--sandbox', opts.sandbox ?? 'read-only', '--json'];
+    // --ask-for-approval never: รัน non-interactive ไม่ค้างรอ approval (ปลอดภัยเพราะ default sandbox = read-only)
+    const args = ['exec', '--skip-git-repo-check', '--sandbox', opts.sandbox ?? 'read-only', '--ask-for-approval', 'never', '--json'];
     if (opts.model)
         args.push('-m', opts.model);
     if (opts.resumeThreadId)
         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 });
+        // ลบ 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, shell: process.platform === 'win32' }); // Windows: codex = JS shim ผ่าน .cmd → ต้อง shell
         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/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:qwen3 หายไปจนเลือกไม่ได้/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 }));
 }