sanook-cli 0.5.1 → 0.5.5

package/dist/config.js

@@ -7,7 +7,10 @@ import { registerPricing } from './cost.js';
 export const CONFIG_DIR = appHomePath();
 const CONFIG_PATH = join(CONFIG_DIR, 'config.json');
 const AUTH_PATH = join(CONFIG_DIR, 'auth.json'); // API keys (chmod 0600)
-export const PricingOverrideSchema = z.record(z.string(), z
+const AUTH_ENV_VAR_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const RESERVED_AUTH_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+const PricingKeySchema = z.string().regex(/^[^:\s]+:\S+$/, 'key ต้องเป็น provider:model');
+export const PricingOverrideSchema = z.record(PricingKeySchema, z
     .object({
     input: z.number().finite().nonnegative().optional(),
     output: z.number().finite().nonnegative().optional(),
@@ -33,52 +36,115 @@ export const ConfigSchema = z.object({
     cacheTtl: z.enum(['5m', '1h']).catch('5m').default('5m'),
     // วิธีบีบ context ตอนยาว: 'truncate' (default, zero-LLM) · 'summarize' (ใช้ model ถูกย่อ — จำ context ได้ดีกว่า)
     compaction: z.enum(['truncate', 'summarize']).catch('truncate').default('truncate'),
+    // token reducer: off, local zero-LLM selective compressor, or optional Headroom proxy adapter.
+    contextCompression: z.enum(['off', 'selective', 'headroom']).catch('selective').default('selective'),
     // extended thinking (Anthropic): false/ไม่ตั้ง = ปิด · true = budget default · number = budget tokens
     thinking: z.union([z.boolean(), z.number().int().positive()]).optional().catch(undefined),
     // model สำหรับย่อ (compaction=summarize) — ไม่ตั้ง = ใช้ fast-sibling ของ model หลัก (ค่ายเดียวกัน ถูกกว่า)
     summaryModel: z.string().optional().catch(undefined),
+    // model สำหรับ semantic search embeddings (เช่น openai:text-embedding-3-small)
+    embeddingModel: z.string().optional().catch(undefined),
+    // Hermes-style /personality overlay (stored as a small named prompt)
+    personality: z.string().optional().catch(undefined),
+    /** UI + setup wizard language */
+    locale: z.enum(['en', 'th']).catch('th').default('th'),
 });
 const DEFAULT_THINKING_BUDGET = 4096;
+function normalizeThinkingBudget(value) {
+    const budget = Math.floor(value);
+    return Number.isSafeInteger(budget) && budget > 0 ? budget : undefined;
+}
 /** parse thinking config (config field หรือ env) → budget tokens (undefined = ปิด) */
 function parseThinking(v) {
-    if (typeof v === 'number' && v > 0)
-        return Math.floor(v);
+    if (typeof v === 'number' && Number.isFinite(v))
+        return normalizeThinkingBudget(v);
     if (v === true)
         return DEFAULT_THINKING_BUDGET;
     if (typeof v === 'string') {
-        if (/^\d+$/.test(v))
-            return Number.parseInt(v, 10);
-        if (['on', 'true', '1', 'yes'].includes(v.toLowerCase()))
+        const clean = v.trim();
+        if (/^\d+$/.test(clean))
+            return normalizeThinkingBudget(Number(clean));
+        if (['on', 'true', '1', 'yes'].includes(clean.toLowerCase()))
             return DEFAULT_THINKING_BUDGET;
     }
     return undefined;
 }
+function trimmedString(v) {
+    if (typeof v !== 'string')
+        return undefined;
+    const clean = v.trim();
+    return clean ? clean : undefined;
+}
+function parseCacheTtl(v) {
+    const clean = trimmedString(v);
+    return clean === '5m' || clean === '1h' ? clean : undefined;
+}
+function parseCompaction(v) {
+    const clean = trimmedString(v);
+    return clean === 'truncate' || clean === 'summarize' ? clean : undefined;
+}
+function parseContextCompression(v) {
+    const clean = trimmedString(v);
+    return clean === 'off' || clean === 'selective' || clean === 'headroom' ? clean : undefined;
+}
 /**
  * อ่าน tuning knobs (cache TTL / thinking / compaction / summary model) จาก global config.json
- * + env override (SANOOK_CACHE_TTL / SANOOK_THINKING / SANOOK_COMPACTION / SANOOK_SUMMARY_MODEL).
+ * + env override (SANOOK_CACHE_TTL / SANOOK_THINKING / SANOOK_COMPACTION / SANOOK_CONTEXT_COMPRESSION / SANOOK_SUMMARY_MODEL).
  * อ่านตรงจาก config.json (เลี่ยง thread ผ่าน call stack ลึก) — เบา, เรียกครั้งเดียวต่อ turn.
  */
 export async function agentTuning() {
     const raw = await readGlobalConfigRaw();
-    const envTtl = process.env.SANOOK_CACHE_TTL;
-    const cacheTtl = envTtl === '1h' || (envTtl !== '5m' && raw.cacheTtl === '1h') ? '1h' : '5m';
-    const thinkingBudget = parseThinking(process.env.SANOOK_THINKING ?? raw.thinking);
-    const compaction = (process.env.SANOOK_COMPACTION ?? raw.compaction) === 'summarize' ? 'summarize' : 'truncate';
-    const summaryModel = process.env.SANOOK_SUMMARY_MODEL ?? (typeof raw.summaryModel === 'string' ? raw.summaryModel : undefined);
-    return { cacheTtl, thinkingBudget, compaction, summaryModel };
+    const cacheTtl = parseCacheTtl(process.env.SANOOK_CACHE_TTL) ?? parseCacheTtl(raw.cacheTtl) ?? '5m';
+    const thinkingBudget = parseThinking(trimmedString(process.env.SANOOK_THINKING) ?? raw.thinking);
+    const compaction = parseCompaction(process.env.SANOOK_COMPACTION) ?? parseCompaction(raw.compaction) ?? 'truncate';
+    const contextCompression = parseContextCompression(process.env.SANOOK_CONTEXT_COMPRESSION) ?? parseContextCompression(raw.contextCompression) ?? 'selective';
+    const summaryModel = trimmedString(process.env.SANOOK_SUMMARY_MODEL) ?? trimmedString(raw.summaryModel);
+    return { cacheTtl, thinkingBudget, compaction, contextCompression, summaryModel };
+}
+const warnedBadConfigKeys = new Set();
+/**
+ * Validate the merged config, but degrade gracefully: a malformed strict field (bad model/maxSteps/
+ * permissionMode/budgetUsd/pricing in a hand-edited config.json) is dropped to its default with a
+ * one-time stderr warning instead of throwing and crashing boot. Security-sensitive fields drop to
+ * the SAFE default (budgetUsd→no cap is still surfaced by the warning; pricing→none).
+ */
+function parseConfigGraceful(merged) {
+    const first = ConfigSchema.safeParse(merged);
+    if (first.success)
+        return first.data;
+    const badKeys = [...new Set(first.error.issues.map((i) => String(i.path[0])).filter(Boolean))];
+    const cleaned = { ...merged };
+    for (const k of badKeys)
+        delete cleaned[k];
+    const fresh = badKeys.filter((k) => !warnedBadConfigKeys.has(k));
+    if (fresh.length) {
+        fresh.forEach((k) => warnedBadConfigKeys.add(k));
+        process.stderr.write(`${BRAND.cliName}: ⚠ ละเลย config ที่ค่าผิด (ใช้ค่า default แทน): ${fresh.join(', ')}\n`);
+    }
+    const second = ConfigSchema.safeParse(cleaned);
+    return second.success ? second.data : ConfigSchema.parse({});
 }
 async function readJson(path) {
     try {
         const parsed = JSON.parse(await readFile(path, 'utf8'));
-        return parsed && typeof parsed === 'object' ? parsed : {};
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
     }
     catch {
         return {}; // ไม่มีไฟล์ / parse ไม่ได้ = ใช้ default
     }
 }
+// key ที่ untrusted project ตั้งไม่ได้ (ต้อง `sanook trust` ก่อน):
+//  - permissionMode: auto = auto-approve mutation (รัน bash/แก้ไฟล์ไม่ถาม) — อันตรายสุด
+//  - budgetUsd: repo อันตรายตั้งสูงๆ = ปิด spend cap ของ user (เปลืองเงินจริง)
+//  - pricing: ตั้งราคาปลอม = ทำให้ budget cap ไม่ trigger (ซ่อน cost / bypass cap)
+// (model/maxSteps/embeddingModel ฯลฯ ปล่อยได้ — เป็น preference ที่ user เห็น/override ได้ และตอนนี้ถูกคุมด้วย budget จริงของ user)
+const UNTRUSTED_PROJECT_DENY = new Set(['permissionMode', 'budgetUsd', 'pricing']);
 function sanitizeUntrustedProjectConfig(cfg) {
-    const out = { ...cfg };
-    delete out.permissionMode;
+    const out = {};
+    for (const [k, v] of Object.entries(cfg)) {
+        if (!UNTRUSTED_PROJECT_DENY.has(k))
+            out[k] = v;
+    }
     return out;
 }
 /**
@@ -93,15 +159,16 @@ export async function loadConfig(overrides = {}, cwd = process.cwd()) {
     const trust = await projectTrustStatus(root);
     const project = trust.trusted ? projectRaw : sanitizeUntrustedProjectConfig(projectRaw);
     const envConfig = {};
-    if (process.env[BRAND.modelEnvVar])
-        envConfig.model = process.env[BRAND.modelEnvVar];
+    const envModel = trimmedString(process.env[BRAND.modelEnvVar]);
+    if (envModel)
+        envConfig.model = envModel;
     const cleanOverrides = {};
     for (const [k, v] of Object.entries(overrides)) {
         if (v !== undefined)
             cleanOverrides[k] = v;
     }
     const merged = { ...global, ...project, ...envConfig, ...cleanOverrides };
-    const config = ConfigSchema.parse(merged);
+    const config = parseConfigGraceful(merged);
     // pricing override: config.pricing + env SANOOK_PRICING (JSON) → ลงทะเบียนเข้า cost table
     registerPricing(config.pricing);
     registerPricing(parseEnvPricing());
@@ -113,16 +180,29 @@ function parseEnvPricing() {
     if (!raw)
         return undefined;
     try {
-        const parsed = JSON.parse(raw);
-        const res = PricingOverrideSchema.safeParse(parsed);
-        return res.success ? res.data : undefined;
+        return parsePricingOverride(raw);
     }
     catch {
         return undefined; // JSON ไม่ถูก = ข้าม (ไม่ทำให้ boot ล้ม)
     }
 }
 export function parsePricingOverride(raw) {
-    return PricingOverrideSchema.parse(JSON.parse(raw));
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error('pricing JSON parse ไม่สำเร็จ');
+    }
+    const res = PricingOverrideSchema.safeParse(parsed);
+    if (!res.success) {
+        const details = res.error.issues
+            .slice(0, 3)
+            .map((issue) => `${issue.path.length ? issue.path.join('.') : 'pricing'}: ${issue.message}`)
+            .join('; ');
+        throw new Error(`pricing schema ไม่ถูกต้อง${details ? ` — ${details}` : ''}`);
+    }
+    return res.data;
 }
 /** ครั้งแรกที่รัน (ยังไม่มี global config) → ต้องทำ setup wizard */
 export async function isFirstRun() {
@@ -134,7 +214,7 @@ export async function isFirstRun() {
         return true;
     }
 }
-/** บันทึก global config (model/provider ที่เลือกตอน setup) */
+/** บันทึก global config (model/provider/locale ที่เลือกตอน setup) */
 export async function saveGlobalConfig(cfg) {
     await mkdir(CONFIG_DIR, { recursive: true });
     const existing = await readJson(CONFIG_PATH);
@@ -152,6 +232,23 @@ export async function saveBrainPath(path) {
 export async function readGlobalConfigRaw() {
     return readJson(CONFIG_PATH);
 }
+/** path ของ auth.json (ใช้โชว์ใน CLI เท่านั้น; ห้าม print raw secret) */
+export function authConfigPath() {
+    return AUTH_PATH;
+}
+function isSafeAuthEnvVarName(name) {
+    return AUTH_ENV_VAR_RE.test(name) && !RESERVED_AUTH_KEYS.has(name);
+}
+/** อ่าน auth.json ดิบแบบกรองเฉพาะ string values — caller ต้อง redact ก่อนโชว์ */
+export async function readStoredAuthRaw() {
+    const raw = await readJson(AUTH_PATH);
+    const auth = {};
+    for (const [k, v] of Object.entries(raw)) {
+        if (isSafeAuthEnvVarName(k) && typeof v === 'string')
+            auth[k] = v;
+    }
+    return auth;
+}
 /** merge patch ลง config.json (สำหรับ `sanook config set`) */
 export async function patchGlobalConfig(patch) {
     await mkdir(CONFIG_DIR, { recursive: true });
@@ -161,25 +258,44 @@ export async function patchGlobalConfig(patch) {
 }
 /** บันทึก API key ลง ~/.sanook/auth.json (chmod 0600) + set env ทันทีสำหรับ session นี้ */
 export async function saveKey(envVar, key) {
+    if (!isSafeAuthEnvVarName(envVar))
+        throw new Error(`env var ไม่ถูกต้อง: ${envVar}`);
     await mkdir(CONFIG_DIR, { recursive: true });
-    let auth = {};
-    try {
-        auth = JSON.parse(await readFile(AUTH_PATH, 'utf8'));
-    }
-    catch {
-        /* ยังไม่มีไฟล์ */
-    }
+    const auth = await readStoredAuthRaw();
     auth[envVar] = key;
     await writeFile(AUTH_PATH, `${JSON.stringify(auth, null, 2)}\n`, { mode: 0o600 });
     await chmod(AUTH_PATH, 0o600); // เจ้าของอ่าน/เขียนเท่านั้น
     process.env[envVar] = key;
 }
+/** ลบ key ที่ Sanook เก็บไว้ใน auth.json (ไม่แตะ env จริงของ shell ภายนอก) */
+export async function removeStoredKey(envVar) {
+    if (!isSafeAuthEnvVarName(envVar))
+        return false;
+    await mkdir(CONFIG_DIR, { recursive: true });
+    const auth = await readStoredAuthRaw();
+    if (!Object.prototype.hasOwnProperty.call(auth, envVar))
+        return false;
+    delete auth[envVar];
+    await writeFile(AUTH_PATH, `${JSON.stringify(auth, null, 2)}\n`, { mode: 0o600 });
+    await chmod(AUTH_PATH, 0o600).catch(() => { });
+    delete process.env[envVar];
+    return true;
+}
+/** ล้าง auth.json ที่ Sanook เก็บไว้ทั้งหมด */
+export async function clearStoredAuth() {
+    await mkdir(CONFIG_DIR, { recursive: true });
+    const auth = await readStoredAuthRaw();
+    for (const envVar of Object.keys(auth))
+        delete process.env[envVar];
+    await writeFile(AUTH_PATH, '{}\n', { mode: 0o600 });
+    await chmod(AUTH_PATH, 0o600).catch(() => { });
+}
 /** โหลด key จาก auth.json เข้า env ตอน boot (ไม่ override env ที่ตั้งไว้แล้ว) */
 export async function loadKeysIntoEnv() {
     try {
-        const auth = JSON.parse(await readFile(AUTH_PATH, 'utf8'));
+        const auth = await readStoredAuthRaw();
         for (const [k, v] of Object.entries(auth)) {
-            if (!process.env[k] && typeof v === 'string')
+            if (!process.env[k])
                 process.env[k] = v;
         }
     }

package/dist/context-compression.js

@@ -0,0 +1,191 @@
+const DEFAULT_TARGET_CHARS = 6_000;
+const DEFAULT_MIN_CHARS = 8_000;
+const DEFAULT_MAX_LINE_CHARS = 800;
+const IMPORTANT_RE = /\b(error|exception|fail(?:ed|ure)?|warning|warn|timeout|denied|unauthorized|traceback|panic|regression|todo|fixme)\b/i;
+const CODE_RE = /^\s*(?:import|export|function|class|interface|type|const|let|var|async|await|return|if|for|while|switch|case)\b/;
+const DIFF_RE = /^\s*(?:diff --git|@@|\+\+\+|---|\+|-)/;
+const PATH_RE = /(?:^|\s)[\w@./-]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|py|rs|go|java|css|scss|html|yml|yaml|toml)(?::\d+)?\b/;
+const STRUCTURE_RE = /^\s*(?:#{1,6}\s|\*|-|\d+\.|["'][^"']+["']\s*:)/;
+const TOKEN_RE = /[\p{L}\p{N}_./:-]{2,}/gu;
+function clampPositive(value, fallback) {
+    return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function tokens(line) {
+    return [...line.toLowerCase().matchAll(TOKEN_RE)].map((match) => match[0]);
+}
+function queryTokens(query) {
+    const out = new Set();
+    for (const token of tokens(query ?? '')) {
+        if (token.length >= 3)
+            out.add(token);
+        const leaf = token.split(/[/:\\]/).pop();
+        if (leaf && leaf.length >= 3)
+            out.add(leaf);
+    }
+    return out;
+}
+function shrinkLine(line, maxChars) {
+    if (line.length <= maxChars)
+        return line;
+    const head = Math.max(80, Math.floor(maxChars * 0.55));
+    const tail = Math.max(60, maxChars - head - 48);
+    return `${line.slice(0, head)} ... [line pruned ${line.length - head - tail} chars] ... ${line.slice(-tail)}`;
+}
+function addAnchors(lines, budget, fromEnd = false) {
+    const selected = new Set();
+    let chars = 0;
+    for (let step = 0; step < lines.length; step++) {
+        const index = fromEnd ? lines.length - 1 - step : step;
+        if (index < 0 || index >= lines.length)
+            break;
+        if (chars >= budget)
+            break;
+        selected.add(index);
+        chars += lines[index].length + 1;
+    }
+    return selected;
+}
+function selectedChars(lines, selected, maxLineChars) {
+    let chars = 0;
+    for (const index of selected)
+        chars += Math.min(lines[index].length, maxLineChars) + 1;
+    return chars;
+}
+function lineScores(lines, selected, query) {
+    const candidates = lines
+        .map((line, index) => ({ line, index }))
+        .filter(({ line, index }) => !selected.has(index) && line.trim());
+    const df = new Map();
+    for (const { line } of candidates) {
+        for (const token of new Set(tokens(line)))
+            df.set(token, (df.get(token) ?? 0) + 1);
+    }
+    const total = Math.max(1, candidates.length);
+    const seenLines = new Map();
+    const scores = new Map();
+    for (const { line, index } of candidates) {
+        const clean = line.trim();
+        const lineTokens = tokens(clean);
+        let score = 0;
+        for (const token of lineTokens)
+            score += Math.log((total + 1) / ((df.get(token) ?? 0) + 1));
+        score = score / Math.sqrt(Math.max(1, lineTokens.length));
+        if (query.size) {
+            let overlap = 0;
+            for (const token of new Set(lineTokens)) {
+                const leaf = token.split(/[/:\\]/).pop() ?? token;
+                if (query.has(token) || query.has(leaf))
+                    overlap += 1;
+            }
+            if (overlap)
+                score += Math.min(40, overlap * 18);
+        }
+        if (IMPORTANT_RE.test(clean))
+            score += 8;
+        if (PATH_RE.test(clean))
+            score += 5;
+        if (DIFF_RE.test(clean))
+            score += 4;
+        if (CODE_RE.test(clean))
+            score += 3;
+        if (STRUCTURE_RE.test(clean))
+            score += 2;
+        if (/https?:\/\//i.test(clean))
+            score += 2;
+        if (/^\s*[}\])],?\s*$/.test(clean))
+            score -= 1;
+        if (clean.length > 500 && !/\s/.test(clean))
+            score -= 5;
+        const repeated = seenLines.get(clean) ?? 0;
+        if (repeated)
+            score -= Math.min(8, repeated * 2);
+        seenLines.set(clean, repeated + 1);
+        scores.set(index, score);
+    }
+    return scores;
+}
+function renderSelected(lines, selected, maxLineChars) {
+    const out = [];
+    let omittedLines = 0;
+    let omittedChars = 0;
+    let gapLines = 0;
+    let gapChars = 0;
+    const flushGap = () => {
+        if (!gapLines)
+            return;
+        out.push(`... [selective context compression: omitted ${gapLines} line(s), ${gapChars} chars] ...`);
+        omittedLines += gapLines;
+        omittedChars += gapChars;
+        gapLines = 0;
+        gapChars = 0;
+    };
+    for (let index = 0; index < lines.length; index++) {
+        if (selected.has(index)) {
+            flushGap();
+            out.push(shrinkLine(lines[index], maxLineChars));
+        }
+        else {
+            gapLines += 1;
+            gapChars += lines[index].length + 1;
+        }
+    }
+    flushGap();
+    return { text: out.join('\n'), omittedLines, omittedChars };
+}
+/**
+ * Zero-LLM selective context compression inspired by Selective Context / Headroom:
+ * keep anchors plus high-information lines (errors, paths, code structure, rare terms),
+ * then preserve original order with omission markers.
+ */
+export function selectiveCompressText(input, options = {}) {
+    const originalChars = input.length;
+    const targetChars = clampPositive(options.targetChars, DEFAULT_TARGET_CHARS);
+    const minChars = clampPositive(options.minChars, DEFAULT_MIN_CHARS);
+    const maxLineChars = clampPositive(options.maxLineChars, DEFAULT_MAX_LINE_CHARS);
+    if (originalChars <= minChars || originalChars <= targetChars) {
+        return { text: input, changed: false, originalChars, compressedChars: originalChars, omittedLines: 0, omittedChars: 0 };
+    }
+    const lines = input.split(/\r?\n/);
+    if (lines.length <= 4) {
+        const text = shrinkLine(input, targetChars);
+        return {
+            text,
+            changed: text !== input,
+            originalChars,
+            compressedChars: text.length,
+            omittedLines: text === input ? 0 : 1,
+            omittedChars: Math.max(0, originalChars - text.length),
+        };
+    }
+    const headBudget = Math.min(clampPositive(options.headChars, Math.floor(targetChars * 0.18)), Math.floor(targetChars * 0.35));
+    const tailBudget = Math.min(clampPositive(options.tailChars, Math.floor(targetChars * 0.25)), Math.floor(targetChars * 0.45));
+    const selected = new Set([
+        ...addAnchors(lines, headBudget),
+        ...addAnchors(lines, tailBudget, true),
+    ]);
+    const scores = lineScores(lines, selected, queryTokens(options.query));
+    const ranked = [...scores.entries()].sort((a, b) => b[1] - a[1]);
+    let used = selectedChars(lines, selected, maxLineChars);
+    const softBudget = Math.max(400, targetChars - 600);
+    for (const [index] of ranked) {
+        const nextCost = Math.min(lines[index].length, maxLineChars) + 1;
+        if (used + nextCost > softBudget && selected.size > 0)
+            continue;
+        selected.add(index);
+        used += nextCost;
+        if (used >= softBudget)
+            break;
+    }
+    const rendered = renderSelected(lines, selected, maxLineChars);
+    if (rendered.text.length >= originalChars) {
+        return { text: input, changed: false, originalChars, compressedChars: originalChars, omittedLines: 0, omittedChars: 0 };
+    }
+    return {
+        text: rendered.text,
+        changed: true,
+        originalChars,
+        compressedChars: rendered.text.length,
+        omittedLines: rendered.omittedLines,
+        omittedChars: rendered.omittedChars,
+    };
+}

package/dist/context-pack.js

@@ -0,0 +1,145 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { termList } from './search/index-core.js';
+const PACK_DIR = 'Shared/Context-Packs';
+const MIN_SCORE = 0.35;
+const DEFAULT_MAX_CHARS = 1200;
+/** Known packs + retrieval signals (aligned with Shared/Context-Packs/_Index.md). */
+const PACK_CATALOG = [
+    {
+        slug: 'second-brain-maintenance',
+        title: 'Second-Brain Maintenance',
+        description: 'vault structure, routing rules, memory policy, indexes, runbooks, agent adapters',
+        signalTerms: [
+            'vault',
+            'structure',
+            'routing',
+            'memory',
+            'policy',
+            'index',
+            'runbook',
+            'agent',
+            'adapter',
+            'framework',
+            'obsidian',
+            'maintenance',
+            'brain',
+            'scaffold',
+            'frontmatter',
+        ],
+    },
+    {
+        slug: 'coding-release',
+        title: 'Coding & Release',
+        description: 'source code, tests, build/release, CLI commands, runtime scripts',
+        signalTerms: [
+            'code',
+            'coding',
+            'test',
+            'tests',
+            'build',
+            'release',
+            'cli',
+            'script',
+            'implement',
+            'fix',
+            'bug',
+            'typecheck',
+            'npm',
+            'ship',
+            'deploy',
+            'refactor',
+        ],
+    },
+    {
+        slug: 'research-to-framework',
+        title: 'Research To Framework',
+        description: 'research, experiment, comparison, promote findings into framework',
+        signalTerms: [
+            'research',
+            'experiment',
+            'framework',
+            'benchmark',
+            'eval',
+            'hypothesis',
+            'promote',
+            'distillation',
+            'comparison',
+            'method',
+            'sota',
+        ],
+    },
+];
+function catalogEntry(slug) {
+    const base = PACK_CATALOG.find((item) => item.slug === slug);
+    if (!base)
+        throw new Error(`unknown context pack slug: ${slug}`);
+    return { ...base, relPath: `${PACK_DIR}/${slug}.md` };
+}
+function packTerms(pack) {
+    return new Set([...termList(pack.slug), ...termList(pack.title), ...pack.signalTerms.map((t) => t.toLowerCase())]);
+}
+/** Score query against a pack via token overlap (deterministic, no network). */
+export function scoreContextPack(query, pack) {
+    const queryTerms = termList(query);
+    if (!queryTerms.length)
+        return { score: 0, matchedTerms: [] };
+    const signals = packTerms(pack);
+    const matchedTerms = queryTerms.filter((term) => signals.has(term));
+    if (!matchedTerms.length)
+        return { score: 0, matchedTerms: [] };
+    const recall = matchedTerms.length / queryTerms.length;
+    const precision = matchedTerms.length / signals.size;
+    return { score: recall * 0.7 + precision * 0.3, matchedTerms };
+}
+export async function listContextPacks(brainPath) {
+    const dir = join(brainPath, PACK_DIR);
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const slugs = new Set(entries.filter((e) => e.isFile() && e.name.endsWith('.md') && e.name !== '_Index.md').map((e) => e.name.replace(/\.md$/i, '')));
+    return PACK_CATALOG.filter((item) => slugs.has(item.slug)).map((item) => catalogEntry(item.slug));
+}
+/** Pick the best matching context pack for a task query, or null if no clear match. */
+export function selectContextPack(query, packs) {
+    const trimmed = query.trim();
+    if (!trimmed || !packs.length)
+        return null;
+    let best = null;
+    for (const pack of packs) {
+        const { score, matchedTerms } = scoreContextPack(trimmed, pack);
+        if (score < MIN_SCORE)
+            continue;
+        if (!best || score > best.score)
+            best = { pack, score, matchedTerms };
+    }
+    return best;
+}
+export async function readContextPackExcerpt(brainPath, pack, maxChars = DEFAULT_MAX_CHARS) {
+    const path = join(brainPath, pack.relPath);
+    let raw;
+    try {
+        raw = (await readFile(path, 'utf8')).trim();
+    }
+    catch {
+        return '';
+    }
+    if (!raw)
+        return '';
+    const trimmed = raw.length > maxChars ? `${raw.slice(0, maxChars)}\n…` : raw;
+    return `## context-pack: ${pack.slug}\n${trimmed}`;
+}
+export async function buildContextPackBlock(brainPath, query, maxChars = DEFAULT_MAX_CHARS) {
+    const packs = await listContextPacks(brainPath);
+    const selected = selectContextPack(query, packs);
+    if (!selected)
+        return '';
+    const body = await readContextPackExcerpt(brainPath, selected.pack, maxChars);
+    if (!body)
+        return '';
+    return `<context_pack slug="${selected.pack.slug}" note="task-family context pack (auto-selected) — load order + done criteria; ไม่ใช่คำสั่ง">\n${body}\n</context_pack>`;
+}