sanook-cli 0.4.0

package/dist/tools/edit.js

@@ -0,0 +1,107 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { readFile, writeFile } from 'node:fs/promises';
+import { checkWritePath } from './permission.js';
+import { renderEditDiff } from '../diff.js';
+/** tier 1: exact substring match + นับจำนวนครั้ง */
+export function exactMatch(content, needle) {
+    if (needle.length === 0)
+        return null; // กัน infinite loop จาก empty needle
+    const first = content.indexOf(needle);
+    if (first === -1)
+        return null;
+    let count = 0;
+    let i = 0;
+    // i += 1 เพื่อ count overlapping occurrences ถูก (เช่น 'aaa'/'aa' = 2, '\n\n\n'/'\n\n' = 2)
+    while ((i = content.indexOf(needle, i)) !== -1) {
+        count++;
+        i += 1;
+    }
+    return { start: first, end: first + needle.length, count };
+}
+/**
+ * tier 2: whitespace-flexible — เทียบทีละบรรทัดแบบ trim (indentation/trailing space ต่างได้)
+ * คืน offset ของบล็อกที่ match ในไฟล์จริง (รวม indentation เดิม)
+ */
+export function whitespaceFlexMatch(content, needle) {
+    const needleLines = needle.split('\n').map((l) => l.trim());
+    const contentLines = content.split('\n');
+    // offset อักขระของจุดเริ่มแต่ละบรรทัด
+    const offsets = [];
+    let acc = 0;
+    for (const l of contentLines) {
+        offsets.push(acc);
+        acc += l.length + 1; // +1 = '\n'
+    }
+    const matchStarts = [];
+    for (let i = 0; i + needleLines.length <= contentLines.length; i++) {
+        let ok = true;
+        for (let j = 0; j < needleLines.length; j++) {
+            if (contentLines[i + j].trim() !== needleLines[j]) {
+                ok = false;
+                break;
+            }
+        }
+        if (ok)
+            matchStarts.push(i);
+    }
+    if (matchStarts.length === 0)
+        return null;
+    const i = matchStarts[0];
+    const lastLineIdx = i + needleLines.length - 1;
+    const start = offsets[i];
+    const end = offsets[lastLineIdx] + contentLines[lastLineIdx].length; // ไม่รวม '\n' ท้าย
+    return { start, end, count: matchStarts.length };
+}
+/** หา match แบบ multi-tier: exact ก่อน แล้วค่อย whitespace-flexible */
+export function findMatch(content, needle) {
+    return exactMatch(content, needle) ?? whitespaceFlexMatch(content, needle);
+}
+export const editFileTool = tool({
+    description: 'แก้ไฟล์โดยแทนที่ old_string ด้วย new_string. old_string ต้องมีอยู่จริงและ unique ในไฟล์ (ใส่ context รอบๆ ให้พอระบุตำแหน่งเดียว). อ่านไฟล์ด้วย read_file ก่อนเสมอ',
+    inputSchema: z.object({
+        path: z.string().describe('path ของไฟล์ที่จะแก้'),
+        old_string: z.string().describe('ข้อความเดิมที่จะถูกแทนที่ (ต้องตรงและ unique)'),
+        new_string: z.string().describe('ข้อความใหม่'),
+    }),
+    execute: async ({ path, old_string, new_string }) => {
+        const guard = checkWritePath(path);
+        if (!guard.ok)
+            return `BLOCKED: ${guard.reason}`;
+        if (old_string === '')
+            return `ERROR: old_string ต้องไม่ว่าง`;
+        if (old_string === new_string) {
+            return `ERROR: old_string กับ new_string เหมือนกัน — ไม่มีอะไรเปลี่ยน`;
+        }
+        let raw;
+        try {
+            raw = await readFile(path, 'utf8');
+        }
+        catch (err) {
+            return `ERROR: อ่านไฟล์ "${path}" ไม่ได้ — ${err.message}`;
+        }
+        // normalize CRLF→LF เพื่อให้ match/offset consistent แล้ว restore EOL เดิมตอนเขียน
+        // (กัน flex match กิน \r แล้วทำ line ending พังบนไฟล์ Windows)
+        const usesCRLF = raw.includes('\r\n');
+        const content = usesCRLF ? raw.replace(/\r\n/g, '\n') : raw;
+        const oldNorm = old_string.replace(/\r\n/g, '\n');
+        const newNorm = new_string.replace(/\r\n/g, '\n');
+        const m = findMatch(content, oldNorm);
+        if (!m) {
+            return `ERROR: ไม่พบ old_string ในไฟล์ "${path}" — อ่านไฟล์ใหม่ด้วย read_file แล้วคัดข้อความที่ตรงเป๊ะมาใช้`;
+        }
+        if (m.count > 1) {
+            return `ERROR: old_string พบ ${m.count} ที่ในไฟล์ "${path}" (ต้อง unique) — ใส่ context รอบๆ ให้มากขึ้นเพื่อระบุตำแหน่งเดียว`;
+        }
+        let updated = content.slice(0, m.start) + newNorm + content.slice(m.end);
+        if (usesCRLF)
+            updated = updated.replace(/\n/g, '\r\n');
+        try {
+            await writeFile(path, updated, 'utf8');
+        }
+        catch (err) {
+            return `ERROR: เขียนไฟล์ "${path}" ไม่ได้ — ${err.message}`;
+        }
+        return `OK: แก้ "${path}" (1 ที่)\n${renderEditDiff(oldNorm, newNorm)}`;
+    },
+});

package/dist/tools/git.js

@@ -0,0 +1,68 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { runGit } from '../git.js';
+const gitErr = (e) => `git error: ${e.message}`;
+export const gitStatusTool = tool({
+    description: 'ดู git status — ไฟล์ที่เปลี่ยน/staged/untracked + branch',
+    inputSchema: z.object({
+        path: z.string().optional().describe('จำกัดเฉพาะ path (ไม่ใส่ = ทั้ง repo)'),
+    }),
+    execute: async ({ path }) => {
+        try {
+            const args = ['status', '--short', '--branch', ...(path ? ['--', path] : [])];
+            return (await runGit(args)).trim() || '(clean)';
+        }
+        catch (e) {
+            return gitErr(e);
+        }
+    },
+});
+export const gitDiffTool = tool({
+    description: 'ดู git diff — เนื้อหาที่เปลี่ยน (staged=true ดูที่ stage แล้ว)',
+    inputSchema: z.object({
+        staged: z.boolean().optional().describe('true = diff ของที่ staged แล้ว'),
+        path: z.string().optional().describe('จำกัดเฉพาะไฟล์/โฟลเดอร์'),
+    }),
+    execute: async ({ staged, path }) => {
+        try {
+            const args = ['diff', ...(staged ? ['--staged'] : []), ...(path ? ['--', path] : [])];
+            const out = await runGit(args);
+            return out.length > 20000 ? `${out.slice(0, 20000)}\n... [diff ยาว, ตัด]` : out || '(no changes)';
+        }
+        catch (e) {
+            return gitErr(e);
+        }
+    },
+});
+export const gitLogTool = tool({
+    description: 'ดู git log — commit ล่าสุด (oneline)',
+    inputSchema: z.object({
+        count: z.number().optional().describe('จำนวน commit (default 10, max 50)'),
+    }),
+    execute: async ({ count = 10 }) => {
+        try {
+            return (await runGit(['log', '--oneline', '-n', String(Math.min(Math.max(count, 1), 50))])) || '(no commits)';
+        }
+        catch (e) {
+            return gitErr(e);
+        }
+    },
+});
+export const gitCommitTool = tool({
+    description: 'git commit — commit ที่ staged ไว้ (addAll=true เพื่อ git add -A ก่อน). ' +
+        'ใช้เมื่อ user สั่งให้ commit เท่านั้น. ไม่ push (push ต้องให้ user ทำเอง)',
+    inputSchema: z.object({
+        message: z.string().describe('commit message'),
+        addAll: z.boolean().optional().describe('true = git add -A ก่อน commit'),
+    }),
+    execute: async ({ message, addAll }) => {
+        try {
+            if (addAll)
+                await runGit(['add', '-A']);
+            return (await runGit(['commit', '-m', message])).trim();
+        }
+        catch (e) {
+            return gitErr(e);
+        }
+    },
+});

package/dist/tools/index.js

@@ -0,0 +1,36 @@
+import { readFileTool } from './read.js';
+import { writeFileTool } from './write.js';
+import { editFileTool } from './edit.js';
+import { listDirTool } from './list.js';
+import { globTool, grepTool } from './search.js';
+import { bashTool } from './bash.js';
+import { rememberTool } from './remember.js';
+import { skillTool, createSkillTool, findSkillsTool } from './skill.js';
+import { recallTool } from './recall.js';
+import { scheduleTaskTool, listScheduledTool, cancelScheduledTool } from './schedule.js';
+import { taskTool } from './task.js';
+import { gitStatusTool, gitDiffTool, gitLogTool, gitCommitTool } from './git.js';
+/** tool registry ที่ส่งให้ agent loop */
+export const tools = {
+    read_file: readFileTool,
+    write_file: writeFileTool,
+    edit_file: editFileTool,
+    list_dir: listDirTool,
+    glob: globTool,
+    grep: grepTool,
+    run_bash: bashTool,
+    remember: rememberTool,
+    recall: recallTool,
+    skill: skillTool,
+    find_skills: findSkillsTool,
+    create_skill: createSkillTool,
+    schedule_task: scheduleTaskTool,
+    list_scheduled: listScheduledTool,
+    cancel_scheduled: cancelScheduledTool,
+    task: taskTool,
+    git_status: gitStatusTool,
+    git_diff: gitDiffTool,
+    git_log: gitLogTool,
+    git_commit: gitCommitTool,
+};
+export { readFileTool, writeFileTool, editFileTool, listDirTool, globTool, grepTool, bashTool };

package/dist/tools/list.js

@@ -0,0 +1,24 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { readdir } from 'node:fs/promises';
+import { clamp } from './util.js';
+export const listDirTool = tool({
+    description: 'list ไฟล์และโฟลเดอร์ใน directory (โฟลเดอร์ลงท้ายด้วย /)',
+    inputSchema: z.object({
+        path: z.string().default('.').describe('directory ที่จะ list (default: current dir)'),
+    }),
+    execute: async ({ path }) => {
+        try {
+            const entries = await readdir(path, { withFileTypes: true });
+            const out = entries
+                .filter((e) => !e.name.startsWith('.') || e.name === '.env.example' || e.name === '.gitignore')
+                .map((e) => (e.isDirectory() ? `${e.name}/` : e.name))
+                .sort()
+                .join('\n');
+            return clamp(out) || '(empty)';
+        }
+        catch (err) {
+            return `ERROR: list "${path}" ไม่ได้ — ${err.message}`;
+        }
+    },
+});

package/dist/tools/permission.js

@@ -0,0 +1,30 @@
+import { homedir } from 'node:os';
+import { resolve, join, sep } from 'node:path';
+// Permission gate (M1): ก่อนมี interactive ask (M4) — hard-deny อันตราย, allow ที่เหลือ
+// คำสั่ง shell ที่ทำลายล้าง irreversible
+const DESTRUCTIVE_CMD = /(\brm\s+-rf\b|\bgit\s+reset\s+--hard\b|\bgit\s+push\b.*--force|\bmkfs\b|\bdd\s+if=|:\(\)\s*\{|\bchmod\s+-R\s+777\b|>\s*\/dev\/sd|\bsudo\b|\bcrontab\b)/i;
+const HOME = homedir();
+// ไฟล์ที่ห้ามเขียน (persistence backdoor): shell rc, git/npm config, ~/.sanook (token/mcp/hooks)
+const PROTECTED_EXACT = new Set(['.gitconfig', '.zshrc', '.bashrc', '.bash_profile', '.profile', '.zprofile', '.npmrc'].map((f) => join(HOME, f)));
+// โฟลเดอร์ที่ห้ามเขียนเข้าไป (credentials + sanook internal)
+const PROTECTED_DIRS = ['.ssh', '.aws', '.gnupg', '.sanook'].map((d) => join(HOME, d));
+// segment ที่ห้ามไม่ว่าอยู่ที่ไหน (.git internals / .env / deps / credentials dir)
+const PROTECTED_SEGMENT = /(^|\/)(\.git|node_modules|\.ssh|\.aws|\.gnupg)(\/|$)|(^|\/)\.env($|\.)/i;
+export function checkBash(cmd) {
+    if (DESTRUCTIVE_CMD.test(cmd)) {
+        return { ok: false, reason: `คำสั่งทำลายล้าง/irreversible ถูกปฏิเสธ: "${cmd}"` };
+    }
+    return { ok: true };
+}
+/** กันเขียนทับ secrets/shell-rc/.sanook — resolve เป็น absolute ก่อน (กัน ../ และ symlink-ish bypass) */
+export function checkWritePath(path) {
+    const abs = resolve(path);
+    const inProtectedDir = PROTECTED_DIRS.some((d) => abs === d || abs.startsWith(d + sep));
+    if (PROTECTED_EXACT.has(abs) || inProtectedDir || PROTECTED_SEGMENT.test(abs)) {
+        return {
+            ok: false,
+            reason: `path ที่ป้องกันถูกปฏิเสธ: "${path}" (secrets / shell-rc / .sanook / .git / .env / node_modules)`,
+        };
+    }
+    return { ok: true };
+}

package/dist/tools/read.js

@@ -0,0 +1,18 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { readFile } from 'node:fs/promises';
+import { clamp } from './util.js';
+export const readFileTool = tool({
+    description: 'อ่านไฟล์ใน workspace แล้วคืนเนื้อหา (UTF-8). อ่านก่อนแก้ไฟล์เสมอ',
+    inputSchema: z.object({
+        path: z.string().describe('relative หรือ absolute path ของไฟล์ที่จะอ่าน'),
+    }),
+    execute: async ({ path }) => {
+        try {
+            return clamp(await readFile(path, 'utf8'));
+        }
+        catch (err) {
+            return `ERROR: อ่านไฟล์ "${path}" ไม่ได้ — ${err.message}`;
+        }
+    },
+});

package/dist/tools/recall.js

@@ -0,0 +1,12 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { recall } from '../knowledge.js';
+/** ค้น knowledge ที่สะสม (memory + skills + session เก่า) — reuse ไม่เริ่มจากศูนย์ */
+export const recallTool = tool({
+    description: 'ค้นความรู้ที่สะสมไว้ (สิ่งที่จำไว้, skills, งานที่เคยทำใน session เก่า) — เรียกตอนเริ่ม task ' +
+        'เพื่อ reuse ของเดิม/ไม่ลืมว่าเคยทำอะไรไปแล้ว ก่อนลงมือทำใหม่',
+    inputSchema: z.object({
+        query: z.string().describe('คำค้น — หัวข้อ/เทคโนโลยี/ชื่องาน'),
+    }),
+    execute: async ({ query }) => recall(query),
+});

package/dist/tools/remember.js

@@ -0,0 +1,14 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { appendMemory } from '../memory.js';
+export const rememberTool = tool({
+    description: 'จำข้อเท็จจริง/preference/decision สำคัญข้าม session — ใช้เมื่อเจอสิ่งที่ควรจำไว้ใช้ครั้งหน้า ' +
+        '(เช่น user ชอบ/ไม่ชอบอะไร, decision สำคัญ, convention ของ project). บันทึกลง ~/.sanook/memory',
+    inputSchema: z.object({
+        fact: z.string().describe('สิ่งที่ต้องจำ — 1 ประโยคกระชับ atomic'),
+    }),
+    execute: async ({ fact }) => {
+        await appendMemory(fact);
+        return `OK: จำแล้ว — "${fact}"`;
+    },
+});

package/dist/tools/schedule.js

@@ -0,0 +1,61 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { parseSchedule } from '../gateway/schedule.js';
+import { enqueueTask, listTasks, removeTask } from '../gateway/ledger.js';
+/** ตั้งงานตามเวลา — agent เรียกเองเมื่อ user พูดเรื่องเวลา/รอบ ("ทุกๆ X โมง/นาที") */
+export const scheduleTaskTool = tool({
+    description: 'ตั้งงานให้ทำตามเวลา/เป็นรอบ — เรียกเมื่อ user ขอให้ทำอะไร "ทุกๆ X" หรือ "ตอน X โมง" หรือเวลาในอนาคต. ' +
+        'งานรันโดย gateway (ต้องเปิด `sanook serve` ไว้). ' +
+        'when ใส่รูปแบบ canonical: "every 30m"/"every 2h"/"every 1d" (รอบ) · "09:00" (ทุกวันเวลานี้) · ' +
+        'ISO เช่น "2026-12-25T09:00" (ครั้งเดียว). ภาษาไทยก็ได้ ("ทุก 30 นาที", "ทุกวัน 9:00") — ' +
+        'แปลงคำพูด user เป็นรูปแบบนี้ก่อนส่ง',
+    inputSchema: z.object({
+        when: z.string().describe('เวลา: every 30m / 09:00 / ISO / "ทุก 2 ชั่วโมง"'),
+        task: z.string().describe('สิ่งที่จะให้ทำตอนถึงเวลา — เขียนเป็น prompt เต็มในตัวเอง (รันเป็น fresh agent ไม่มี context นี้)'),
+        model: z.string().optional().describe('model spec (ไม่ใส่ = default ของ gateway)'),
+    }),
+    execute: async ({ when, task, model }) => {
+        const sched = parseSchedule(when, Date.now());
+        if (!sched) {
+            return `ตั้งเวลาไม่ได้: "${when}" ไม่ใช่รูปแบบที่รองรับ — ลอง "every 30m", "09:00", ISO, หรือ "ทุก 2 ชั่วโมง"`;
+        }
+        const t = await enqueueTask({
+            kind: sched.recurring ? 'cron' : 'once',
+            spec: task,
+            schedule: sched.recurring ? sched.normalized : undefined,
+            model,
+            runAt: sched.runAt,
+        });
+        const at = new Date(t.runAt).toLocaleString();
+        return (`ตั้งงาน ${t.id} แล้ว — รัน ${at}${sched.recurring ? ` แล้วทุก ${sched.normalized}` : ' (ครั้งเดียว)'}. ` +
+            `งานจะทำงานเมื่อ gateway เปิดอยู่ (sanook serve)`);
+    },
+});
+/** ดูงานที่ตั้งเวลาไว้ */
+export const listScheduledTool = tool({
+    description: 'ดูงานที่ตั้งเวลาไว้ทั้งหมด (cron / one-shot) พร้อมสถานะและเวลารันถัดไป',
+    inputSchema: z.object({
+        filter: z.string().optional().describe('กรองตาม status เช่น queued/done/failed (ไม่ใส่ = ทั้งหมด)'),
+    }),
+    execute: async ({ filter }) => {
+        let tasks = await listTasks();
+        if (filter)
+            tasks = tasks.filter((t) => t.status === filter);
+        if (!tasks.length)
+            return filter ? `ไม่มีงานสถานะ ${filter}` : 'ยังไม่มีงานที่ตั้งเวลาไว้';
+        return tasks
+            .map((t) => `${t.id} [${t.status}] ${t.schedule ?? 'once'} → ${t.spec.slice(0, 60)} (next ${new Date(t.runAt).toLocaleString()})`)
+            .join('\n');
+    },
+});
+/** ยกเลิกงานที่ตั้งเวลาไว้ */
+export const cancelScheduledTool = tool({
+    description: 'ยกเลิกงานที่ตั้งเวลาไว้ ด้วย task id (ดู id จาก list_scheduled)',
+    inputSchema: z.object({
+        id: z.string().describe('task id'),
+    }),
+    execute: async ({ id }) => {
+        const ok = await removeTask(id);
+        return ok ? `ยกเลิกงาน ${id} แล้ว` : `ไม่เจองาน ${id}`;
+    },
+});

package/dist/tools/search.js

@@ -0,0 +1,54 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { glob } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { clamp } from './util.js';
+const execFileAsync = promisify(execFile);
+const MAX_RESULTS = 200;
+export const globTool = tool({
+    description: 'หาไฟล์ด้วย glob pattern (เช่น "src/**/*.ts", "**/*.json")',
+    inputSchema: z.object({
+        pattern: z.string().describe('glob pattern'),
+        cwd: z.string().default('.').describe('directory ที่จะค้นจาก'),
+    }),
+    execute: async ({ pattern, cwd }) => {
+        try {
+            const out = [];
+            for await (const f of glob(pattern, { cwd })) {
+                out.push(f);
+                if (out.length >= MAX_RESULTS) {
+                    out.push(`... [>${MAX_RESULTS} matches, truncated]`);
+                    break;
+                }
+            }
+            return out.length ? out.sort().join('\n') : '(no matches)';
+        }
+        catch (err) {
+            return `ERROR: glob "${pattern}" ล้มเหลว — ${err.message}`;
+        }
+    },
+});
+export const grepTool = tool({
+    description: 'ค้นข้อความใน codebase ด้วย ripgrep (regex) — คืน file:line:text, เคารพ .gitignore',
+    inputSchema: z.object({
+        pattern: z.string().describe('regex ที่จะค้น'),
+        path: z.string().default('.').describe('directory หรือไฟล์ที่จะค้น'),
+    }),
+    execute: async ({ pattern, path }) => {
+        try {
+            // execFile (args array, ไม่ผ่าน shell) → $(...)/backtick/$VAR ใน pattern/path เป็น inert
+            // กัน command injection (JSON.stringify ไม่ใช่ shell quoting — เคยรั่ว); -e กัน pattern ขึ้นต้นด้วย -
+            const { stdout } = await execFileAsync('rg', ['--line-number', '--no-heading', '--max-count', '50', '-e', pattern, '--', path], { maxBuffer: 10 * 1024 * 1024 });
+            const lines = stdout.trim().split('\n').slice(0, MAX_RESULTS);
+            return clamp(lines.join('\n')) || '(no matches)';
+        }
+        catch (err) {
+            // ripgrep exit code 1 = ไม่เจอ match (ไม่ใช่ error จริง)
+            const e = err;
+            if (e.code === 1)
+                return '(no matches)';
+            return `ERROR: grep "${pattern}" ล้มเหลว — ${err.message}`;
+        }
+    },
+});

package/dist/tools/skill.js

@@ -0,0 +1,65 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { getSkillBody, saveSkill, loadSkills } from '../skills.js';
+/** ค้น skill ที่เกี่ยวกับงาน — "skill ช่วยไปหา skill" (discovery) */
+export const findSkillsTool = tool({
+    description: 'ค้น skill ที่เกี่ยวกับงานนี้ — คืน skill ที่ match (จาก built-in + ที่ติดตั้งไว้). ' +
+        'ใช้ตอนเริ่มงานเพื่อดูว่ามี skill ไหนช่วยได้ ก่อนลงมือเอง แล้วโหลดด้วย skill tool',
+    inputSchema: z.object({
+        query: z.string().describe('ประเภทงาน เช่น "review code", "debug", "deploy", "เขียน test"'),
+    }),
+    execute: async ({ query }) => {
+        const terms = query
+            .toLowerCase()
+            .split(/\s+/)
+            .filter((t) => t.length > 1);
+        const skills = await loadSkills();
+        const scored = skills
+            .map((s) => {
+            const hay = `${s.name} ${s.description} ${s.whenToUse ?? ''}`.toLowerCase();
+            return { s, score: terms.reduce((n, t) => n + (hay.includes(t) ? 1 : 0), 0) };
+        })
+            .filter((x) => x.score > 0)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, 8);
+        if (!scored.length) {
+            return `ไม่เจอ skill ตรงกับ "${query}" — มี ${skills.length} skills (ดู <available_skills>)`;
+        }
+        return `${scored
+            .map(({ s }) => `- ${s.name}: ${s.description}${s.whenToUse ? ` (ใช้เมื่อ: ${s.whenToUse})` : ''}`)
+            .join('\n')}\n\nโหลดเต็มด้วย skill tool`;
+    },
+});
+/** โหลด skill เต็มเมื่อ task ตรงกับ available_skills */
+export const skillTool = tool({
+    description: 'โหลดเนื้อหา skill เต็ม (วิธีทำงานเฉพาะทาง/runbook) เมื่อ task ตรงกับ skill ใน <available_skills>. ' +
+        'อ่านก่อนลงมือทำงานประเภทนั้น เพื่อทำตามขั้นตอนที่ผ่านการพิสูจน์แล้ว',
+    inputSchema: z.object({
+        name: z.string().describe('ชื่อ skill จาก <available_skills>'),
+    }),
+    execute: async ({ name }) => {
+        const body = await getSkillBody(name);
+        return body ?? `ไม่เจอ skill "${name}" — ดูชื่อที่มีใน <available_skills>`;
+    },
+});
+/** self-improvement: agent เขียน skill ใหม่เมื่อเจอ procedure ที่น่าจะทำซ้ำอีก */
+export const createSkillTool = tool({
+    description: 'สร้าง/อัปเดต skill ใหม่ — ใช้เมื่อเพิ่งทำงานที่ (1) มีหลายขั้นตอน (2) สำเร็จแล้ว (3) น่าจะเจออีก. ' +
+        'บันทึกขั้นตอนเป็น runbook เพื่อครั้งหน้าทำได้เร็ว/ไม่พลาดซ้ำ (เก็บใน ~/.sanook/skills/). ' +
+        'body ควรมี: When to Use, Steps, Common Errors/Gotchas',
+    inputSchema: z.object({
+        name: z.string().describe('slug a-z0-9- เช่น "deploy-vercel", "fix-eslint-flat-config"'),
+        description: z.string().describe('1 บรรทัด: skill นี้ทำอะไร'),
+        when_to_use: z.string().optional().describe('สถานการณ์ที่ควรหยิบ skill นี้มาใช้'),
+        body: z.string().describe('เนื้อหา markdown: When to Use, Steps, Common Errors'),
+    }),
+    execute: async ({ name, description, when_to_use, body }) => {
+        try {
+            const path = await saveSkill(name, description, body, when_to_use);
+            return `OK: บันทึก skill "${name}" แล้ว (${path}) — ครั้งหน้าจะเห็นใน available_skills`;
+        }
+        catch (err) {
+            return `สร้าง skill ไม่ได้: ${err.message}`;
+        }
+    },
+});

package/dist/tools/task.js

@@ -0,0 +1,46 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { agentContext } from '../agentContext.js';
+import { approvalContext } from '../approval.js';
+// task = มอบงานย่อยให้ sub-agent ทำใน context แยก (เลียน Claude Code Task tool)
+// depth/model/budget thread ผ่าน AsyncLocalStorage (parallel-safe, ไม่ใช่ process.env)
+const MAX_DEPTH = 2;
+// read-only = อ่าน/ค้นเท่านั้น — ตัด run_bash ออก (shell = เลี่ยง read-only contract ได้)
+const READ_TOOLS = ['read_file', 'list_dir', 'glob', 'grep', 'git_status', 'git_diff', 'git_log', 'skill', 'find_skills'];
+// sub-agent ห้ามมี: task (recursion), scheduling (side-effect ที่ควรเป็น main agent)
+const SUBAGENT_EXCLUDE = ['task', 'schedule_task', 'list_scheduled', 'cancel_scheduled'];
+export const taskTool = tool({
+    description: 'มอบงานย่อยให้ sub-agent ทำใน context แยก — ใช้ตอนต้องสำรวจหลายไฟล์/ค้นหาเยอะแล้วอยากได้แค่บทสรุป ' +
+        '(กัน context หลักบวม). sub-agent เริ่มสะอาด ไม่เห็น conversation นี้ → เขียน prompt ให้ครบในตัว. ' +
+        'default read-only (อ่าน/ค้น); readonly=false ให้แก้ไฟล์/รัน bash ได้ด้วย',
+    inputSchema: z.object({
+        description: z.string().describe('สรุปงาน 3-5 คำ'),
+        prompt: z.string().describe('คำสั่งเต็ม self-contained ให้ sub-agent (มันไม่เห็น context นี้)'),
+        readonly: z.boolean().optional().describe('true (default) = อ่าน/ค้นเท่านั้น; false = แก้ไฟล์/bash ได้'),
+    }),
+    execute: async ({ prompt, readonly = true }) => {
+        const ctx = agentContext.getStore();
+        const depth = ctx?.depth ?? 0;
+        if (depth >= MAX_DEPTH) {
+            return 'ถึงขีดจำกัดความลึก sub-agent แล้ว (กัน spawn ไม่จบ) — ทำงานนี้เองแทน';
+        }
+        const { runAgent } = await import('../loop.js');
+        const { tools } = await import('./index.js');
+        const entries = Object.entries(tools);
+        const picked = readonly
+            ? entries.filter(([k]) => READ_TOOLS.includes(k))
+            : entries.filter(([k]) => !SUBAGENT_EXCLUDE.includes(k));
+        const appr = approvalContext.getStore();
+        const { text } = await runAgent({
+            model: ctx?.model ?? 'sonnet', // inherit จาก main
+            budgetUsd: ctx?.budgetUsd, // cap เดียวกับ main (กัน sub-agent วิ่ง uncapped)
+            subagentDepth: depth + 1, // thread depth ผ่าน param — ไม่ mutate global
+            permissionMode: appr?.mode ?? 'auto', // inherit ask-mode (กัน sub-agent เลี่ยง approval)
+            approve: appr?.approve,
+            prompt,
+            maxSteps: 15,
+            tools: Object.fromEntries(picked),
+        });
+        return text || '(sub-agent ไม่มีผลลัพธ์)';
+    },
+});

package/dist/tools/util.js

@@ -0,0 +1,5 @@
+export const MAX_OUTPUT = 30_000;
+/** ตัด output ที่ยาวเกิน กัน context ระเบิด */
+export function clamp(s, max = MAX_OUTPUT) {
+    return s.length > max ? s.slice(0, max) + `\n... [truncated ${s.length - max} chars]` : s;
+}

package/dist/tools/write.js

@@ -0,0 +1,27 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { writeFile, mkdir, readFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { checkWritePath } from './permission.js';
+import { summarizeWrite } from '../diff.js';
+export const writeFileTool = tool({
+    description: 'เขียนไฟล์ใหม่ (overwrite ถ้ามีอยู่แล้ว) — สร้าง directory ให้อัตโนมัติ. ใช้สร้างไฟล์ใหม่ทั้งไฟล์ (แก้บางส่วนใช้ edit_file)',
+    inputSchema: z.object({
+        path: z.string().describe('path ของไฟล์ที่จะเขียน'),
+        content: z.string().describe('เนื้อหาทั้งหมดของไฟล์'),
+    }),
+    execute: async ({ path, content }) => {
+        const guard = checkWritePath(path);
+        if (!guard.ok)
+            return `BLOCKED: ${guard.reason}`;
+        const previous = await readFile(path, 'utf8').catch(() => undefined); // มีอยู่เดิมไหม (โชว์ before→after)
+        try {
+            await mkdir(dirname(path), { recursive: true });
+            await writeFile(path, content, 'utf8');
+            return `OK: "${path}" — ${summarizeWrite(content, previous)}`;
+        }
+        catch (err) {
+            return `ERROR: เขียนไฟล์ "${path}" ไม่ได้ — ${err.message}`;
+        }
+    },
+});