sanook-cli 0.4.0 → 0.5.1

package/dist/tools/read.js

@@ -1,15 +1,34 @@
 import { tool } from 'ai';
 import { z } from 'zod';
 import { readFile } from 'node:fs/promises';
-import { clamp } from './util.js';
+import { clamp, resolveAgentPath } from './util.js';
+import { checkReadPath } from './permission.js';
 export const readFileTool = tool({
-    description: 'อ่านไฟล์ใน workspace แล้วคืนเนื้อหา (UTF-8). อ่านก่อนแก้ไฟล์เสมอ',
+    description: 'อ่านไฟล์ใน workspace (UTF-8). อ่านก่อนแก้ไฟล์เสมอ. ' +
+        'ไฟล์ใหญ่หรือต้องการแค่บางส่วน → ใส่ offset/limit อ่านเฉพาะช่วงบรรทัด (ประหยัด token มาก — คู่กับ grep ที่ให้เลขบรรทัด)',
     inputSchema: z.object({
         path: z.string().describe('relative หรือ absolute path ของไฟล์ที่จะอ่าน'),
+        offset: z.number().int().min(1).optional().describe('บรรทัดเริ่ม (1-based) — อ่านเฉพาะช่วง ไม่ใส่ = ต้นไฟล์'),
+        limit: z.number().int().min(1).optional().describe('จำนวนบรรทัดจาก offset — ไม่ใส่ = ถึงท้ายไฟล์'),
     }),
-    execute: async ({ path }) => {
+    execute: async ({ path, offset, limit }) => {
+        const full = resolveAgentPath(path); // relative ผูกกับ agentCwd (worktree ของ sub-agent ถ้ามี)
+        const guard = await checkReadPath(full);
+        if (!guard.ok)
+            return `BLOCKED: ${guard.reason}`;
         try {
-            return clamp(await readFile(path, 'utf8'));
+            const content = await readFile(full, 'utf8');
+            // ไม่ระบุช่วง → คืนทั้งไฟล์ (clamp) เหมือนเดิม
+            if (offset == null && limit == null)
+                return clamp(content);
+            // ระบุช่วง → อ่านเฉพาะบรรทัด start..end (ส่งเฉพาะที่ต้องการเข้า context, ประหยัด token)
+            const lines = content.split('\n');
+            const start = Math.max(0, (offset ?? 1) - 1);
+            if (start >= lines.length)
+                return `(ไฟล์มี ${lines.length} บรรทัด — offset ${offset} เกินช่วง)`;
+            const end = limit == null ? lines.length : Math.min(lines.length, start + limit);
+            const slice = lines.slice(start, end).join('\n');
+            return clamp(`[บรรทัด ${start + 1}-${end} จาก ${lines.length}]\n${slice}`);
         }
         catch (err) {
             return `ERROR: อ่านไฟล์ "${path}" ไม่ได้ — ${err.message}`;

package/dist/tools/remember.js

@@ -3,7 +3,7 @@ import { z } from 'zod';
 import { appendMemory } from '../memory.js';
 export const rememberTool = tool({
     description: 'จำข้อเท็จจริง/preference/decision สำคัญข้าม session — ใช้เมื่อเจอสิ่งที่ควรจำไว้ใช้ครั้งหน้า ' +
-        '(เช่น user ชอบ/ไม่ชอบอะไร, decision สำคัญ, convention ของ project). บันทึกลง ~/.sanook/memory',
+        '(เช่น user ชอบ/ไม่ชอบอะไร, decision สำคัญ, convention ของ project). บันทึกลง ~/.sanook/memory + route เข้า second-brain vault (Memory-Inbox) ถ้าตั้งไว้',
     inputSchema: z.object({
         fact: z.string().describe('สิ่งที่ต้องจำ — 1 ประโยคกระชับ atomic'),
     }),

package/dist/tools/sandbox.js

@@ -0,0 +1,61 @@
+import { platform, tmpdir } from 'node:os';
+import { existsSync, realpathSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { getBrainPath } from '../memory.js';
+import { BRAND_ENV, envFlag } from '../brand.js';
+// OS-level sandbox สำหรับ run_bash — confine "write" ให้อยู่ใน workspace (cwd + brain + tmp)
+// ให้สอดคล้องกับ file-tool ที่ confine อยู่แล้ว (bash เคยเป็นช่องโหว่). อ่าน/network = ปกติ (ไม่ break build/test)
+//   macOS  → sandbox-exec (Seatbelt)      Linux → bwrap (bubblewrap) ถ้ามี
+// ปิด: SANOOK_NO_SANDBOX=1 · SANOOK_ALLOW_OUTSIDE_WORKSPACE=1 (อนุญาตนอก workspace อยู่แล้ว = ไม่ sandbox)
+function canon(p) {
+    try {
+        return realpathSync(p);
+    }
+    catch {
+        return resolve(p);
+    }
+}
+function seatbeltProfile(writable) {
+    const allow = writable.map((w) => `  (subpath ${JSON.stringify(w)})`).join('\n');
+    return [
+        '(version 1)',
+        '(allow default)',
+        '(deny file-write*)',
+        '(allow file-write*',
+        allow,
+        '  (subpath "/dev")',
+        '  (literal "/dev/null") (literal "/dev/stdout") (literal "/dev/stderr"))',
+    ].join('\n');
+}
+function bwrapArgs(writable, cmd) {
+    const binds = writable.flatMap((w) => ['--bind', w, w]);
+    return ['--ro-bind', '/', '/', '--dev', '/dev', '--proc', '/proc', ...binds, '/bin/sh', '-c', cmd];
+}
+/**
+ * คืน {file,args} สำหรับรัน cmd แบบ sandbox (ผ่าน execFile) — หรือ null ถ้าไม่มี sandbox/ปิดไว้
+ * (caller รัน cmd ตรงๆ ตามเดิม). path ที่มี '"' → ข้าม sandbox (กัน profile พัง)
+ */
+export async function maybeSandbox(cmd, cwd = process.cwd()) {
+    if (envFlag(BRAND_ENV.allowOutsideWorkspace) || envFlag('SANOOK_NO_SANDBOX'))
+        return null;
+    const writable = [canon(cwd), canon(tmpdir())];
+    const brain = await getBrainPath().catch(() => null);
+    if (brain && existsSync(brain))
+        writable.push(canon(brain));
+    if (writable.some((w) => w.includes('"')))
+        return null;
+    const os = platform();
+    if (os === 'darwin') {
+        const bin = ['/usr/bin/sandbox-exec', '/usr/sbin/sandbox-exec'].find((p) => existsSync(p));
+        if (!bin)
+            return null;
+        return { file: bin, args: ['-p', seatbeltProfile(writable), '/bin/sh', '-c', cmd] };
+    }
+    if (os === 'linux') {
+        const bin = ['/usr/bin/bwrap', '/bin/bwrap'].find((p) => existsSync(p));
+        if (!bin)
+            return null;
+        return { file: bin, args: bwrapArgs(writable, cmd) };
+    }
+    return null;
+}

package/dist/tools/search.js

@@ -1,11 +1,98 @@
 import { tool } from 'ai';
 import { z } from 'zod';
-import { glob } from 'node:fs/promises';
+import { glob, readdir, stat, readFile } from 'node:fs/promises';
 import { execFile } from 'node:child_process';
+import { isAbsolute, join, relative } from 'node:path';
 import { promisify } from 'node:util';
-import { clamp } from './util.js';
+import { clamp, resolveAgentPath } from './util.js';
+import { checkReadPath } from './permission.js';
+import { agentCwd } from '../agentContext.js';
+// pure-JS grep fallback — ใช้เมื่อ ripgrep (rg) ไม่ได้ติดตั้ง (เช่น Windows สะอาด) → grep ใช้ได้ทุกแพลตฟอร์ม
+const FALLBACK_IGNORE = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', '.next', '.cache', '.turbo', '.vercel', 'vendor']);
+const FALLBACK_MAX_FILE = 2 * 1024 * 1024; // ข้ามไฟล์ใหญ่ (กันช้า/binary)
+const PER_FILE_CAP = 50; // เหมือน rg --max-count 50
+export async function jsGrep(pattern, base, target) {
+    let re;
+    try {
+        re = new RegExp(pattern); // rg ใช้ Rust regex; JS regex ใกล้เคียงพอสำหรับ pattern ทั่วไป
+    }
+    catch {
+        return `ERROR: grep regex ไม่ถูกต้อง: "${pattern}"`;
+    }
+    const root = isAbsolute(target) ? target : join(base, target);
+    const out = [];
+    const scanFile = async (full) => {
+        let s;
+        try {
+            s = await stat(full);
+        }
+        catch {
+            return;
+        }
+        if (s.size > FALLBACK_MAX_FILE)
+            return;
+        let content;
+        try {
+            content = await readFile(full, 'utf8');
+        }
+        catch {
+            return;
+        }
+        if (content.includes('\u0000'))
+            return; // binary
+        const rel = relative(base, full) || full;
+        const lines = content.split(/\r?\n/);
+        let perFile = 0;
+        for (let i = 0; i < lines.length && out.length < MAX_RESULTS; i++) {
+            if (re.test(lines[i])) {
+                out.push(`${rel}:${i + 1}:${lines[i].slice(0, 300)}`);
+                if (++perFile >= PER_FILE_CAP)
+                    break;
+            }
+        }
+    };
+    const walk = async (dir) => {
+        if (out.length >= MAX_RESULTS)
+            return;
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (out.length >= MAX_RESULTS)
+                return;
+            if (e.isDirectory()) {
+                if (!FALLBACK_IGNORE.has(e.name) && !e.name.startsWith('.'))
+                    await walk(join(dir, e.name));
+            }
+            else if (e.isFile()) {
+                await scanFile(join(dir, e.name));
+            }
+        }
+    };
+    let st;
+    try {
+        st = await stat(root);
+    }
+    catch {
+        return `ERROR: grep path ไม่พบ: "${target}"`;
+    }
+    if (st.isFile())
+        await scanFile(root);
+    else
+        await walk(root);
+    if (!out.length)
+        return '(no matches)';
+    return `${clamp(out.join('\n'))}\n[JS fallback — ติดตั้ง ripgrep (rg) เพื่อความเร็ว + เคารพ .gitignore: brew/apt/choco/scoop install ripgrep]`;
+}
 const execFileAsync = promisify(execFile);
 const MAX_RESULTS = 200;
+function unsafeGlobPattern(pattern) {
+    return isAbsolute(pattern) || pattern.split(/[\\/]+/).includes('..');
+}
 export const globTool = tool({
     description: 'หาไฟล์ด้วย glob pattern (เช่น "src/**/*.ts", "**/*.json")',
     inputSchema: z.object({
@@ -13,9 +100,16 @@ export const globTool = tool({
         cwd: z.string().default('.').describe('directory ที่จะค้นจาก'),
     }),
     execute: async ({ pattern, cwd }) => {
+        if (unsafeGlobPattern(pattern)) {
+            return `BLOCKED: glob pattern ต้องเป็น relative path ภายใน cwd และห้ามมี "..": "${pattern}"`;
+        }
+        const base = resolveAgentPath(cwd); // '.' → agentCwd (worktree ของ sub-agent ถ้ามี)
+        const guard = await checkReadPath(base);
+        if (!guard.ok)
+            return `BLOCKED: ${guard.reason}`;
         try {
             const out = [];
-            for await (const f of glob(pattern, { cwd })) {
+            for await (const f of glob(pattern, { cwd: base })) {
                 out.push(f);
                 if (out.length >= MAX_RESULTS) {
                     out.push(`... [>${MAX_RESULTS} matches, truncated]`);
@@ -36,10 +130,14 @@ export const grepTool = tool({
         path: z.string().default('.').describe('directory หรือไฟล์ที่จะค้น'),
     }),
     execute: async ({ pattern, path }) => {
+        const base = agentCwd(); // รัน rg ใน worktree ของ sub-agent ถ้ามี → path relative ผูกถูก tree
+        const guard = await checkReadPath(resolveAgentPath(path));
+        if (!guard.ok)
+            return `BLOCKED: ${guard.reason}`;
         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 { stdout } = await execFileAsync('rg', ['--line-number', '--no-heading', '--max-count', '50', '-e', pattern, '--', path], { cwd: base, maxBuffer: 10 * 1024 * 1024 });
             const lines = stdout.trim().split('\n').slice(0, MAX_RESULTS);
             return clamp(lines.join('\n')) || '(no matches)';
         }
@@ -48,6 +146,9 @@ export const grepTool = tool({
             const e = err;
             if (e.code === 1)
                 return '(no matches)';
+            // rg ไม่ได้ติดตั้ง (Windows สะอาด ฯลฯ) → fallback เป็น JS grep ให้ใช้ได้ทุกแพลตฟอร์ม
+            if (e.code === 'ENOENT')
+                return jsGrep(pattern, base, path);
             return `ERROR: grep "${pattern}" ล้มเหลว — ${err.message}`;
         }
     },

package/dist/tools/task.js

@@ -1,46 +1,212 @@
 import { tool } from 'ai';
 import { z } from 'zod';
-import { agentContext } from '../agentContext.js';
+import { agentContext, agentCwd } from '../agentContext.js';
 import { approvalContext } from '../approval.js';
+import { runParallel, runThunks, TaskRegistry } from '../orchestrate.js';
+import { runInWorktrees, getRepoRoot } from '../worktree.js';
 // task = มอบงานย่อยให้ sub-agent ทำใน context แยก (เลียน Claude Code Task tool)
 // depth/model/budget thread ผ่าน AsyncLocalStorage (parallel-safe, ไม่ใช่ process.env)
+// orchestration: task (single) · task_parallel (fan-out) · task_spawn/collect/cancel/status (background)
 const MAX_DEPTH = 2;
+const MAX_FANOUT = 16; // กัน fan-out ระเบิด: 1 task_parallel call สูงสุด 16 subagents
+const DEFAULT_CONCURRENCY = 5; // subagent = API-bound → คุม concurrency กัน rate-limit
+const SUB_MAX_STEPS = 15;
 // 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 ไม่จบ) — ทำงานนี้เองแทน';
-        }
+// 'task'/'task_parallel' อยู่ใน set → nested orchestration ได้ (depth cap กันไม่จบ)
+const READ_TOOLS = ['read_file', 'list_dir', 'glob', 'grep', 'git_status', 'git_diff', 'git_log', 'recall', 'skill', 'find_skills', 'task', 'task_parallel'];
+// sub-agent ห้ามมี: scheduling + background orchestration (เป็น side-effect ของ main agent — detached task ที่ subagent spawn จะ outlive มันงงๆ)
+const SUBAGENT_EXCLUDE = ['schedule_task', 'list_scheduled', 'cancel_scheduled', 'task_spawn', 'task_collect', 'task_cancel', 'task_status'];
+// registry ของ background task — อยู่ระดับ process (อยู่ข้าม tool call ใน session เดียว)
+const registry = new TaskRegistry();
+/** snapshot ของ parent context ตอนเรียก tool (sync, ก่อน await) — ส่งต่อให้ subagent ทั้ง parallel + background */
+function parentCtx() {
+    const ctx = agentContext.getStore();
+    const appr = approvalContext.getStore();
+    return { model: ctx?.model, budgetUsd: ctx?.budgetUsd, depth: ctx?.depth ?? 0, cwd: ctx?.cwd, mode: appr?.mode ?? 'ask', approve: appr?.approve };
+}
+/**
+ * real subagent runner — รัน runAgent ใน context แยก. ครอบด้วย agentContext.run() ให้
+ * แต่ละ subagent (parallel/nested) มี ALS context ของตัวเอง ไม่ bleed ข้ามกัน
+ * (enterWith ของ runAgent อย่างเดียวไม่ isolate พอตอนรัน concurrent จาก parent เดียวกัน)
+ */
+function makeRunner(parent) {
+    return async (spec, signal) => {
         const { runAgent } = await import('../loop.js');
         const { tools } = await import('./index.js');
         const entries = Object.entries(tools);
+        const readonly = spec.readonly ?? true;
         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,
+        // model: explicit spec ก่อน → SANOOK_SUBAGENT_MODEL (opt-in: route งาน subagent ไป model ถูกกว่า เช่น haiku
+        // สำหรับ exploration/search ที่เป็นงานกลไก — ประหยัด cost มาก โดย quality หลักไม่กระทบ) → inherit จาก parent
+        const model = spec.model ?? process.env.SANOOK_SUBAGENT_MODEL ?? parent.model ?? 'sonnet';
+        const depth = parent.depth + 1;
+        const cwd = spec.cwd ?? parent.cwd; // worktree ของ subagent นี้ (ถ้า isolate) ไม่งั้น inherit
+        const childStore = { model, budgetUsd: parent.budgetUsd, depth, cwd };
+        const { text } = await agentContext.run(childStore, () => runAgent({
+            model,
+            budgetUsd: parent.budgetUsd, // cap เดียวกับ main (กัน subagent วิ่ง uncapped)
+            subagentDepth: depth,
+            cwd, // file ops ของ subagent ผูกกับ worktree นี้ (isolation)
+            permissionMode: parent.mode, // inherit ask-mode (กัน subagent เลี่ยง approval)
+            approve: parent.approve,
+            prompt: spec.prompt,
+            maxSteps: SUB_MAX_STEPS,
+            signal,
             tools: Object.fromEntries(picked),
-        });
+        }));
         return text || '(sub-agent ไม่มีผลลัพธ์)';
+    };
+}
+const atDepthLimit = (parent) => parent.depth >= MAX_DEPTH;
+const DEPTH_MSG = 'ถึงขีดจำกัดความลึก sub-agent แล้ว (กัน spawn ไม่จบ) — ทำงานนี้เองแทน';
+const taskInput = {
+    description: z.string().describe('สรุปงาน 3-5 คำ'),
+    prompt: z.string().describe('คำสั่งเต็ม self-contained ให้ sub-agent (มันไม่เห็น context นี้)'),
+    readonly: z.boolean().optional().describe('true (default) = อ่าน/ค้นเท่านั้น; false = แก้ไฟล์/bash ได้'),
+};
+export const taskTool = tool({
+    description: 'มอบงานย่อย 1 ชิ้นให้ sub-agent ทำใน context แยก — ใช้ตอนต้องสำรวจหลายไฟล์/ค้นหาเยอะแล้วอยากได้แค่บทสรุป ' +
+        '(กัน context หลักบวม). sub-agent เริ่มสะอาด ไม่เห็น conversation นี้ → เขียน prompt ให้ครบในตัว. ' +
+        'default read-only (อ่าน/ค้น); readonly=false ให้แก้ไฟล์/รัน bash ได้. หลายชิ้นพร้อมกัน → ใช้ task_parallel',
+    inputSchema: z.object(taskInput),
+    execute: async ({ description, prompt, readonly = true }) => {
+        const parent = parentCtx();
+        if (atDepthLimit(parent))
+            return DEPTH_MSG;
+        const runner = makeRunner(parent);
+        const [outcome] = await runParallel([{ description, prompt, readonly }], runner);
+        return outcome.ok ? outcome.text : `sub-agent ล้มเหลว: ${outcome.error}`;
+    },
+});
+/** จัดรูปผลของ subagent หลายตัว */
+function formatOutcomes(outcomes) {
+    const okN = outcomes.filter((o) => o.ok).length;
+    const head = `${outcomes.length} subagents (${okN} สำเร็จ, ${outcomes.length - okN} ล้มเหลว):`;
+    const body = outcomes
+        .map((o, i) => `\n## [${i + 1}] ${o.description} ${o.ok ? '✓' : '✗'}\n${o.ok ? o.text : `error: ${o.error}`}`)
+        .join('\n');
+    return `${head}\n${body}`;
+}
+/**
+ * isolate mode — subagent ที่ "เขียนไฟล์" รันใน git worktree ของตัวเอง (จาก HEAD) ไม่ชนกัน
+ * แล้ว capture diff แต่ละ worktree → apply กลับ main tree แบบ sequential (ชน = รายงาน ไม่ทับเงียบ).
+ * worktree lifecycle อยู่ใน worktree.ts (testable); ตรงนี้แค่ผูก subagent runner เข้าไป
+ */
+async function runIsolated(specs, parent, concurrency) {
+    const root = await getRepoRoot(parent.cwd ?? agentCwd());
+    if (!root)
+        return 'isolate=worktree ต้องอยู่ใน git repo — ใช้ task_parallel แบบปกติแทน (ไม่มี worktree)';
+    const runner = makeRunner(parent);
+    const runs = await runInWorktrees(specs, root, 
+    // งานต่อ subagent: รันใน worktree (cwd) ของมัน, readonly=false (isolate มีไว้ให้แก้ไฟล์)
+    (spec, cwd) => runner({ ...spec, cwd, readonly: spec.readonly ?? false }, undefined)
+        .then((text) => ({ ok: true, description: spec.description, text }))
+        .catch((e) => ({ ok: false, description: spec.description, text: '', error: e.message })), (thunks) => runThunks(thunks, concurrency));
+    if (!runs)
+        return 'สร้าง git worktree ไม่สำเร็จ (หรือไม่ใช่ git repo) — ยกเลิก isolate';
+    const outcomes = runs.map((r) => r.result);
+    const mergeNotes = runs.map((r, i) => {
+        const m = r.merge;
+        if (!m.changed.length)
+            return `[${i + 1}] ${m.description}: ไม่มีการแก้ไฟล์`;
+        return m.applied
+            ? `[${i + 1}] ${m.description}: merge แล้ว — ${m.changed.length} ไฟล์ (${m.changed.slice(0, 8).join(', ')})`
+            : `[${i + 1}] ${m.description}: ⚠ merge ชน — ${m.reason}; ไฟล์: ${m.changed.join(', ')} (แก้ conflict เอง)`;
+    });
+    return `${formatOutcomes(outcomes)}\n\n--- worktree merge → main tree ---\n${mergeNotes.join('\n')}`;
+}
+export const taskParallelTool = tool({
+    description: 'มอบงานย่อยหลายชิ้นให้ sub-agent ทำ "พร้อมกัน" (fan-out) — ใช้เมื่องานแตกเป็นส่วนๆ ที่ไม่ขึ้นต่อกัน ' +
+        '(เช่น สำรวจหลายโมดูล / review หลายมิติ / ค้นหลายมุม). คืนผลรวมทุกตัว (ตัวล้มไม่ทำให้ทั้ง batch ล้ม). ' +
+        `สูงสุด ${MAX_FANOUT} ชิ้น/ครั้ง. แต่ละชิ้นเขียน prompt ให้ครบในตัว (subagent ไม่เห็น context นี้). ` +
+        'isolate=true → subagent ที่แก้ไฟล์รันใน git worktree แยกกัน (ไม่ชนไฟล์) แล้ว merge กลับให้',
+    inputSchema: z.object({
+        tasks: z.array(z.object(taskInput)).min(1).max(MAX_FANOUT).describe('รายการงานย่อยที่จะรันพร้อมกัน'),
+        concurrency: z.number().int().min(1).max(MAX_FANOUT).optional().describe(`จำนวนที่รันพร้อมกันสูงสุด (default ${DEFAULT_CONCURRENCY})`),
+        isolate: z.boolean().optional().describe('true = รัน subagent ที่เขียนไฟล์ใน git worktree แยก (กันชนไฟล์) แล้ว merge กลับ — ต้องอยู่ใน git repo'),
+    }),
+    execute: async ({ tasks, concurrency, isolate }) => {
+        const parent = parentCtx();
+        if (atDepthLimit(parent))
+            return DEPTH_MSG;
+        const specs = tasks.map((t) => ({ description: t.description, prompt: t.prompt, readonly: t.readonly ?? true }));
+        const cc = concurrency ?? DEFAULT_CONCURRENCY;
+        if (isolate)
+            return runIsolated(specs, parent, cc);
+        const outcomes = await runParallel(specs, makeRunner(parent), { concurrency: cc });
+        return formatOutcomes(outcomes);
+    },
+});
+export const taskSpawnTool = tool({
+    description: 'เริ่มงานย่อยแบบ "background" — คืน task id ทันที แล้ว sub-agent ทำต่อเบื้องหลัง ขณะที่ main agent ทำอย่างอื่นต่อได้ ' +
+        'เก็บผลภายหลังด้วย task_collect, ดูสถานะด้วย task_status, ยกเลิกด้วย task_cancel. เหมาะกับงานยาว (research ลึก, สแกนทั้ง repo) ที่ไม่อยากบล็อก. ' +
+        '(อยู่แค่ใน session นี้ — งานข้าม session ใช้ schedule_task)',
+    inputSchema: z.object(taskInput),
+    execute: async ({ description, prompt, readonly = true }) => {
+        const parent = parentCtx();
+        if (atDepthLimit(parent))
+            return DEPTH_MSG;
+        const id = registry.spawn({ description, prompt, readonly }, makeRunner(parent));
+        return `เริ่ม background task "${description}" แล้ว — id: ${id}. เก็บผลด้วย task_collect("${id}") · ยกเลิกด้วย task_cancel("${id}") · ดูสถานะ task_status`;
+    },
+});
+export const taskCollectTool = tool({
+    description: 'เก็บผลของ background task (จาก task_spawn) — ส่ง id เดียวหรือหลาย id. ' +
+        'default รอจนเสร็จ; ใส่ timeoutSec เพื่อ poll แบบไม่บล็อก (ยังไม่เสร็จจะคืนสถานะ running)',
+    inputSchema: z.object({
+        ids: z.union([z.string(), z.array(z.string())]).describe('task id เดียว หรือ array ของ id'),
+        timeoutSec: z.number().min(0).optional().describe('รอสูงสุดกี่วินาที (ไม่ใส่ = รอจนเสร็จ)'),
+    }),
+    execute: async ({ ids, timeoutSec }) => {
+        const idList = Array.isArray(ids) ? ids : [ids];
+        const timeoutMs = timeoutSec == null ? undefined : Math.round(timeoutSec * 1000);
+        const recs = await Promise.all(idList.map((id) => registry.collect(id, timeoutMs)));
+        return recs
+            .map((r, i) => {
+            if (!r)
+                return `[${idList[i]}] ไม่พบ task นี้`;
+            if (r.state === 'done')
+                return `## ${r.id} ${r.description} ✓\n${r.text ?? ''}`;
+            if (r.state === 'error')
+                return `## ${r.id} ${r.description} ✗ error: ${r.error}`;
+            if (r.state === 'canceled')
+                return `## ${r.id} ${r.description} (ยกเลิกแล้ว)`;
+            return `## ${r.id} ${r.description} (ยังทำงานอยู่ — collect อีกครั้งภายหลัง)`;
+        })
+            .join('\n\n');
+    },
+});
+export const taskCancelTool = tool({
+    description: 'ยกเลิก background task ที่ยัง running อยู่ (จาก task_spawn) ด้วย AbortSignal',
+    inputSchema: z.object({
+        id: z.string().describe('task id จาก task_spawn'),
+    }),
+    execute: async ({ id }) => {
+        const rec = registry.get(id);
+        if (!rec)
+            return `[${id}] ไม่พบ task นี้`;
+        if (rec.state !== 'running')
+            return `[${id}] ยกเลิกไม่ได้ — สถานะปัจจุบัน: ${rec.state}`;
+        const ok = registry.cancel(id);
+        if (ok)
+            return `[${id}] ยกเลิกแล้ว — ${rec.description}`;
+        return `[${id}] ยกเลิกไม่ได้ — สถานะปัจจุบัน: ${registry.get(id)?.state ?? rec.state}`;
+    },
+});
+export const taskStatusTool = tool({
+    description: 'ดูสถานะ background task ทั้งหมดใน session นี้ (running/done/error/canceled)',
+    inputSchema: z.object({}),
+    execute: async () => {
+        const all = registry.list();
+        if (!all.length)
+            return 'ยังไม่มี background task';
+        return all
+            .map((r) => {
+            const elapsed = r.endedMs ? `${((r.endedMs - r.startedMs) / 1000).toFixed(1)}s` : 'running…';
+            return `${r.id}  ${r.state.padEnd(8)} ${elapsed}  — ${r.description}`;
+        })
+            .join('\n');
     },
 });

package/dist/tools/timeout.js

@@ -0,0 +1,35 @@
+// ครอบ tool ด้วย timeout — กัน read/grep/glob/edit บนไฟล์ใหญ่ค้าง แล้วแขวน loop ทั้ง session ไม่จบ
+// tool ที่จัดการ timeout เองอยู่แล้ว → ไม่ครอบ: run_bash (120s ในตัว), task (sub-agent อาจรันนาน)
+const SELF_TIMED = new Set(['run_bash', 'task']);
+export const DEFAULT_TOOL_TIMEOUT = 120_000;
+/** Promise.race tool execute กับ timer — timeout คืนเป็น ERROR string (tool ไม่ throw เข้า loop) */
+export function wrapToolsWithTimeout(tools, ms = DEFAULT_TOOL_TIMEOUT) {
+    const out = {};
+    for (const [name, t] of Object.entries(tools)) {
+        if (SELF_TIMED.has(name) || typeof t.execute !== 'function') {
+            out[name] = t;
+            continue;
+        }
+        const orig = t.execute;
+        out[name] = {
+            ...t,
+            execute: async (input, opts) => {
+                let timer;
+                const timeout = new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(new Error(`tool "${name}" ค้างเกิน ${ms}ms — ยกเลิก`)), ms);
+                });
+                try {
+                    return await Promise.race([Promise.resolve(orig(input, opts)), timeout]);
+                }
+                catch (e) {
+                    return `ERROR: ${e.message}`;
+                }
+                finally {
+                    if (timer)
+                        clearTimeout(timer);
+                }
+            },
+        };
+    }
+    return out;
+}

package/dist/tools/util.js

@@ -1,5 +1,15 @@
+import { isAbsolute, resolve } from 'node:path';
+import { agentCwd } from '../agentContext.js';
 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;
 }
+/**
+ * resolve path ของ tool ให้ผูกกับ working dir ของ agent ปัจจุบัน (agentCwd) ไม่ใช่ process.cwd().
+ * สำคัญตอน sub-agent รันใน git worktree แยก: relative path ("src/foo.ts") ต้องชี้เข้า worktree
+ * ของ sub-agent นั้น ไม่ใช่ main tree (ไม่งั้น isolation หลุด — แก้ผิดไฟล์). absolute path คงเดิม.
+ */
+export function resolveAgentPath(p) {
+    return isAbsolute(p) ? p : resolve(agentCwd(), p);
+}

package/dist/tools/write.js

@@ -3,6 +3,7 @@ import { z } from 'zod';
 import { writeFile, mkdir, readFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 import { checkWritePath } from './permission.js';
+import { resolveAgentPath } from './util.js';
 import { summarizeWrite } from '../diff.js';
 export const writeFileTool = tool({
     description: 'เขียนไฟล์ใหม่ (overwrite ถ้ามีอยู่แล้ว) — สร้าง directory ให้อัตโนมัติ. ใช้สร้างไฟล์ใหม่ทั้งไฟล์ (แก้บางส่วนใช้ edit_file)',
@@ -11,13 +12,14 @@ export const writeFileTool = tool({
         content: z.string().describe('เนื้อหาทั้งหมดของไฟล์'),
     }),
     execute: async ({ path, content }) => {
-        const guard = checkWritePath(path);
+        const full = resolveAgentPath(path); // relative ผูกกับ agentCwd (worktree ของ sub-agent ถ้ามี)
+        const guard = await checkWritePath(full);
         if (!guard.ok)
             return `BLOCKED: ${guard.reason}`;
-        const previous = await readFile(path, 'utf8').catch(() => undefined); // มีอยู่เดิมไหม (โชว์ before→after)
+        const previous = await readFile(full, 'utf8').catch(() => undefined); // มีอยู่เดิมไหม (โชว์ before→after)
         try {
-            await mkdir(dirname(path), { recursive: true });
-            await writeFile(path, content, 'utf8');
+            await mkdir(dirname(full), { recursive: true });
+            await writeFile(full, content, 'utf8');
             return `OK: "${path}" — ${summarizeWrite(content, previous)}`;
         }
         catch (err) {