sanook-cli 0.4.0 → 0.5.0

package/dist/skills.js

@@ -1,14 +1,14 @@
 import { readFile, writeFile, mkdir, readdir } from 'node:fs/promises';
-import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { appHomePath } from './brand.js';
+import { projectConfigPathIfTrusted } from './trust.js';
 // skills = วิธีทำงานเฉพาะทาง/runbook ที่โหลด on-demand (progressive disclosure)
 // agent เห็นแค่ name+description ใน system prompt → โหลดเต็มด้วย `skill` tool เมื่อ task ตรง
 // self-improvement: agent สร้าง skill เองด้วย `create_skill` เมื่อเจอ procedure ที่ reuse ได้
 // 3 ชั้น: bundled (ship กับ CLI) → global (~/.sanook) → project (.sanook) — ชั้นหลัง override ชื่อซ้ำ
 const BUNDLED_SKILLS = join(dirname(fileURLToPath(import.meta.url)), '..', 'skills');
-const GLOBAL_SKILLS = join(homedir(), '.sanook', 'skills');
-const projectSkills = () => join(process.cwd(), '.sanook', 'skills');
+const GLOBAL_SKILLS = appHomePath('skills');
 /** minimal frontmatter parser (key: value ใน --- block) — ไม่พึ่ง YAML dep */
 export function parseFrontmatter(content) {
     const m = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
@@ -34,10 +34,11 @@ export function isValidSkillName(name) {
     return /^[a-z0-9][a-z0-9-]{0,63}$/.test(name);
 }
 /** scan project + global skills → list (name+description เท่านั้น สำหรับ inject). project ทับ global ชื่อซ้ำ */
-export async function loadSkills() {
+export async function loadSkills(cwd = process.cwd()) {
     const out = new Map();
+    const projectSkills = await projectConfigPathIfTrusted('skills', cwd);
     // bundled ก่อน → global → project ทับ (specific กว่าอยู่ท้าย)
-    for (const dir of [BUNDLED_SKILLS, GLOBAL_SKILLS, projectSkills()]) {
+    for (const dir of [BUNDLED_SKILLS, GLOBAL_SKILLS, projectSkills].filter((d) => Boolean(d))) {
         let entries;
         try {
             entries = await readdir(dir, { withFileTypes: true });
@@ -51,8 +52,9 @@ export async function loadSkills() {
             const p = join(dir, e.name, 'SKILL.md');
             try {
                 const { meta } = parseFrontmatter(await readFile(p, 'utf8'));
-                out.set(meta.name || e.name, {
-                    name: meta.name || e.name,
+                const name = meta.name && isValidSkillName(meta.name) ? meta.name : e.name;
+                out.set(name, {
+                    name,
                     description: meta.description ?? '',
                     whenToUse: meta.when_to_use,
                     path: p,
@@ -66,10 +68,11 @@ export async function loadSkills() {
     return [...out.values()];
 }
 /** อ่านเนื้อหา SKILL.md เต็ม (skill tool เรียกเมื่อ agent ตัดสินใจใช้) */
-export async function getSkillBody(name) {
+export async function getSkillBody(name, cwd = process.cwd()) {
     if (!isValidSkillName(name))
         return null;
-    for (const dir of [projectSkills(), GLOBAL_SKILLS, BUNDLED_SKILLS]) {
+    const projectSkills = await projectConfigPathIfTrusted('skills', cwd);
+    for (const dir of [projectSkills, GLOBAL_SKILLS, BUNDLED_SKILLS].filter((d) => Boolean(d))) {
         try {
             return await readFile(join(dir, name, 'SKILL.md'), 'utf8');
         }

package/dist/summarize.js

@@ -0,0 +1,31 @@
+// ============================================================================
+// src/summarize.ts — cheap-model transcript summarizer for compaction.
+//
+// compaction='summarize' replaces the dropped middle of a long conversation with
+// a condensed brief instead of truncating it — better recall at the same token
+// budget. The summary runs on a CHEAP model (the fast sibling of the main model,
+// same provider/key) so the saving isn't eaten by the summarization call itself.
+// resolveModel() is called lazily inside the returned fn, so a missing key throws
+// at summarize-time and summarizeCompact() catches it → falls back to truncation.
+// ============================================================================
+import { generateText } from 'ai';
+import { resolveModel, fastSibling } from './providers/registry.js';
+const SUMMARY_PROMPT = 'You are compacting a coding-session transcript so the agent can CONTINUE the work with less context. ' +
+    'Write a terse factual brief (bullet points, no preamble) that preserves: the task/intent, decisions made, ' +
+    'files created or changed, key findings, and unfinished TODOs. Drop chit-chat and verbose tool output.\n\nTRANSCRIPT:\n';
+/**
+ * Build a summarizer using a cheap model — `summaryModel` if set, else the fast
+ * sibling of `mainModel` (same provider, cheaper tier). Returns a fn ready for
+ * compaction.summarizeCompact().
+ */
+export function makeSummarizer(mainModel, summaryModel) {
+    const spec = summaryModel ?? fastSibling(mainModel);
+    return async (transcript) => {
+        const { text } = await generateText({
+            model: resolveModel(spec), // lazy: throws here if no key → caller falls back to truncation
+            prompt: SUMMARY_PROMPT + transcript,
+            maxOutputTokens: 1024,
+        });
+        return text;
+    };
+}

package/dist/tools/bash.js

@@ -1,10 +1,23 @@
 import { tool } from 'ai';
 import { z } from 'zod';
-import { exec } from 'node:child_process';
+import { exec, execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { clamp } from './util.js';
 import { checkBash } from './permission.js';
+import { maybeSandbox } from './sandbox.js';
+import { agentCwd } from '../agentContext.js';
 const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
+const SAFE_ENV_KEYS = ['PATH', 'HOME', 'TMPDIR', 'TEMP', 'LANG', 'LC_ALL', 'USER', 'SHELL', 'TERM', 'NODE_PATH', 'NVM_DIR', 'APPDATA'];
+function safeEnv() {
+    const out = {};
+    for (const k of SAFE_ENV_KEYS) {
+        const v = process.env[k];
+        if (v != null)
+            out[k] = v;
+    }
+    return out;
+}
 export const bashTool = tool({
     description: 'รันคำสั่ง shell (ls/grep/find/cat/test/npm ฯลฯ) เพื่อค้นหา ตรวจสอบ หรือรัน build/test',
     inputSchema: z.object({
@@ -14,8 +27,14 @@ export const bashTool = tool({
         const guard = checkBash(cmd);
         if (!guard.ok)
             return `BLOCKED: ${guard.reason}`;
+        const cwd = agentCwd(); // worktree ของ sub-agent ถ้ามี (sandbox confine write ตาม cwd นี้)
+        const opts = { cwd, env: safeEnv(), timeout: 120_000, maxBuffer: 10 * 1024 * 1024 };
         try {
-            const { stdout, stderr } = await execAsync(cmd, { timeout: 120_000, maxBuffer: 10 * 1024 * 1024 });
+            // OS sandbox (Seatbelt/bubblewrap) confine write ให้อยู่ใน workspace ถ้ามี — ไม่งั้นรันตรงตามเดิม
+            const sb = await maybeSandbox(cmd, cwd);
+            const { stdout, stderr } = sb
+                ? await execFileAsync(sb.file, sb.args, opts)
+                : await execAsync(cmd, opts);
             const out = (stdout + (stderr ? `\n[stderr]\n${stderr}` : '')).trim();
             return clamp(out) || '(no output)';
         }

package/dist/tools/diagnostics.js

@@ -0,0 +1,41 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { diagnose } from '../lsp/index.js';
+import { resolveAgentPath } from './util.js';
+import { agentCwd } from '../agentContext.js';
+import { checkReadPath } from './permission.js';
+import { clamp } from './util.js';
+const SYM = { error: '✗', warning: '⚠', info: 'ℹ', hint: '·' };
+const MAX_SHOWN = 100;
+/**
+ * diagnostics tool — type errors/warnings จาก language server (LSP) ของไฟล์เดียว
+ * โดยไม่ต้อง build ทั้งโปรเจค. ปิด verify-loop: agent แก้ไฟล์ → ตรวจ → แก้ error ต่อทันที.
+ * graceful: ไม่มี server ติดตั้ง → บอกวิธีติดตั้ง (ไม่ crash). respect worktree (agentCwd).
+ */
+export const diagnosticsTool = tool({
+    description: 'ตรวจ type error / warning ของไฟล์ด้วย language server (LSP) — เรียก "หลังแก้ไฟล์" เพื่อจับ error ทันทีโดยไม่ต้อง build/test ทั้งโปรเจค. ' +
+        'รองรับ TS/JS · Python · Go · Rust · JSON ฯลฯ (ถ้าติดตั้ง LSP server ไว้; ไม่มี = บอกวิธีติดตั้ง). ' +
+        'ใส่ content เพื่อตรวจฉบับที่ยังไม่ save ได้',
+    inputSchema: z.object({
+        path: z.string().describe('path ไฟล์ที่จะตรวจ'),
+        content: z.string().optional().describe('เนื้อหาที่จะตรวจ (ฉบับยังไม่ save) — ไม่ใส่ = อ่านจากดิสก์'),
+    }),
+    execute: async ({ path, content }) => {
+        const full = resolveAgentPath(path);
+        const guard = await checkReadPath(full);
+        if (!guard.ok)
+            return `BLOCKED: ${guard.reason}`;
+        const r = await diagnose(full, { cwd: agentCwd(), content });
+        if (!r.ok)
+            return `LSP: ${r.reason}`;
+        if (!r.diagnostics.length)
+            return `✓ ไม่มี diagnostics (${r.serverId}) — ${path}`;
+        const errs = r.diagnostics.filter((d) => d.severity === 'error').length;
+        const warns = r.diagnostics.filter((d) => d.severity === 'warning').length;
+        const lines = r.diagnostics
+            .slice(0, MAX_SHOWN)
+            .map((d) => `${SYM[d.severity]} ${path}:${d.line}:${d.character} ${d.message}${d.code != null ? ` [${d.code}]` : ''}`);
+        const more = r.diagnostics.length > MAX_SHOWN ? `\n… +${r.diagnostics.length - MAX_SHOWN} เพิ่มเติม` : '';
+        return clamp(`${errs} error · ${warns} warning (${r.serverId}):\n${lines.join('\n')}${more}`);
+    },
+});

package/dist/tools/edit.js

@@ -2,6 +2,7 @@ import { tool } from 'ai';
 import { z } from 'zod';
 import { readFile, writeFile } from 'node:fs/promises';
 import { checkWritePath } from './permission.js';
+import { resolveAgentPath } from './util.js';
 import { renderEditDiff } from '../diff.js';
 /** tier 1: exact substring match + นับจำนวนครั้ง */
 export function exactMatch(content, needle) {
@@ -58,14 +59,18 @@ 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 ก่อนเสมอ',
+    description: 'แก้ไฟล์แบบ search/replace — แทนที่เฉพาะ "ช่วงที่ส่งมา" ไม่ใช่ทั้งไฟล์/ทั้งบรรทัด. ' +
+        'ให้ old_string สั้นที่สุดเท่าที่ยัง unique (ประหยัด token — ไม่ต้องลอกทั้งบรรทัด/ทั้ง block ถ้าไม่จำเป็น). ' +
+        'จะแก้ token เดิมหลายที่ (rename) → ตั้ง replace_all:true แล้วใส่ old_string สั้นๆ ได้เลย ไม่ต้องทำให้ unique. อ่านไฟล์ด้วย read_file ก่อนเสมอ',
     inputSchema: z.object({
         path: z.string().describe('path ของไฟล์ที่จะแก้'),
-        old_string: z.string().describe('ข้อความเดิมที่จะถูกแทนที่ (ต้องตรงและ unique)'),
+        old_string: z.string().describe('ข้อความเดิมที่จะถูกแทนที่ — สั้นที่สุดที่ยัง unique (replace_all:true ไม่ต้อง unique)'),
         new_string: z.string().describe('ข้อความใหม่'),
+        replace_all: z.boolean().optional().describe('true = แทนที่ทุกที่ที่ตรง old_string เป๊ะ (เหมาะกับ rename) — old_string ไม่ต้อง unique'),
     }),
-    execute: async ({ path, old_string, new_string }) => {
-        const guard = checkWritePath(path);
+    execute: async ({ path, old_string, new_string, replace_all = false }) => {
+        const full = resolveAgentPath(path); // relative ผูกกับ agentCwd (worktree ของ sub-agent ถ้ามี)
+        const guard = await checkWritePath(full);
         if (!guard.ok)
             return `BLOCKED: ${guard.reason}`;
         if (old_string === '')
@@ -75,7 +80,7 @@ export const editFileTool = tool({
         }
         let raw;
         try {
-            raw = await readFile(path, 'utf8');
+            raw = await readFile(full, 'utf8');
         }
         catch (err) {
             return `ERROR: อ่านไฟล์ "${path}" ไม่ได้ — ${err.message}`;
@@ -86,18 +91,35 @@ export const editFileTool = tool({
         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');
+        // replace_all: แทนที่ทุกที่ที่ตรง "เป๊ะ" (exact เท่านั้น — flex หลายช่วงกำกวม) → old_string สั้นได้ ไม่ต้อง unique
+        if (replace_all) {
+            const exact = exactMatch(content, oldNorm);
+            if (!exact) {
+                return `ERROR: ไม่พบ old_string ในไฟล์ "${path}" — replace_all ใช้ match แบบตรงเป๊ะเท่านั้น (อ่านไฟล์ใหม่แล้วคัดข้อความที่ตรง)`;
+            }
+            let updated = content.split(oldNorm).join(newNorm); // split/join = แทนที่ทุกที่ (string literal, ไม่ใช่ regex)
+            if (usesCRLF)
+                updated = updated.replace(/\n/g, '\r\n');
+            try {
+                await writeFile(full, updated, 'utf8');
+            }
+            catch (err) {
+                return `ERROR: เขียนไฟล์ "${path}" ไม่ได้ — ${err.message}`;
+            }
+            return `OK: แก้ "${path}" (${exact.count} ที่)\n${renderEditDiff(oldNorm, newNorm)}`;
+        }
         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 รอบๆ ให้มากขึ้นเพื่อระบุตำแหน่งเดียว`;
+            return `ERROR: old_string พบ ${m.count} ที่ในไฟล์ "${path}" — ตั้ง replace_all:true เพื่อแก้ทุกที่ หรือใส่ context รอบๆ ให้พอ unique (ใช้เท่าที่จำเป็น ประหยัด token)`;
         }
         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');
+            await writeFile(full, updated, 'utf8');
         }
         catch (err) {
             return `ERROR: เขียนไฟล์ "${path}" ไม่ได้ — ${err.message}`;

package/dist/tools/index.js

@@ -8,7 +8,8 @@ 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 { taskTool, taskParallelTool, taskSpawnTool, taskCollectTool, taskCancelTool, taskStatusTool } from './task.js';
+import { diagnosticsTool } from './diagnostics.js';
 import { gitStatusTool, gitDiffTool, gitLogTool, gitCommitTool } from './git.js';
 /** tool registry ที่ส่งให้ agent loop */
 export const tools = {
@@ -28,6 +29,12 @@ export const tools = {
     list_scheduled: listScheduledTool,
     cancel_scheduled: cancelScheduledTool,
     task: taskTool,
+    task_parallel: taskParallelTool,
+    task_spawn: taskSpawnTool,
+    task_collect: taskCollectTool,
+    task_cancel: taskCancelTool,
+    task_status: taskStatusTool,
+    diagnostics: diagnosticsTool,
     git_status: gitStatusTool,
     git_diff: gitDiffTool,
     git_log: gitLogTool,

package/dist/tools/list.js

@@ -1,15 +1,20 @@
 import { tool } from 'ai';
 import { z } from 'zod';
 import { readdir } from 'node:fs/promises';
-import { clamp } from './util.js';
+import { clamp, resolveAgentPath } from './util.js';
+import { checkReadPath } from './permission.js';
 export const listDirTool = tool({
     description: 'list ไฟล์และโฟลเดอร์ใน directory (โฟลเดอร์ลงท้ายด้วย /)',
     inputSchema: z.object({
         path: z.string().default('.').describe('directory ที่จะ list (default: current dir)'),
     }),
     execute: async ({ path }) => {
+        const full = resolveAgentPath(path); // relative ผูกกับ agentCwd (worktree ของ sub-agent ถ้ามี)
+        const guard = await checkReadPath(full);
+        if (!guard.ok)
+            return `BLOCKED: ${guard.reason}`;
         try {
-            const entries = await readdir(path, { withFileTypes: true });
+            const entries = await readdir(full, { 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))

package/dist/tools/permission.js

@@ -1,30 +1,111 @@
 import { homedir } from 'node:os';
-import { resolve, join, sep } from 'node:path';
+import { realpath, stat } from 'node:fs/promises';
+import { basename, dirname, resolve, join, sep } from 'node:path';
+import { getBrainPath } from '../memory.js';
+import { BRAND_ENV, envFlag } from '../brand.js';
+import { agentCwd } from '../agentContext.js';
 // 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 DESTRUCTIVE_CMD = /(\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 PROTECTED_CMD_PATH = /(\$HOME|~)?\/?(\.ssh|\.aws|\.gnupg|\.sanook)(\/|\b)|(^|\s)(cat|less|more|sed|awk|tail|head)\s+[^|;&]*\.env(\.|\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;
+const PROTECTED_SEGMENTS = new Set(['.git', 'node_modules', '.ssh', '.aws', '.gnupg', '.sanook']);
+function hasRmRecursiveForce(cmd) {
+    for (const match of cmd.matchAll(/\brm\b([^;&|]*)/gi)) {
+        const parts = match[1].split(/\s+/).filter(Boolean);
+        const shortFlags = parts.filter((part) => /^-[^-]/.test(part)).join('');
+        const recursive = /r/i.test(shortFlags) || parts.includes('--recursive') || parts.includes('--dir');
+        const force = /f/i.test(shortFlags) || parts.includes('--force');
+        if (recursive && force)
+            return true;
+    }
+    return false;
+}
 export function checkBash(cmd) {
-    if (DESTRUCTIVE_CMD.test(cmd)) {
+    if (hasRmRecursiveForce(cmd) || DESTRUCTIVE_CMD.test(cmd)) {
         return { ok: false, reason: `คำสั่งทำลายล้าง/irreversible ถูกปฏิเสธ: "${cmd}"` };
     }
+    if (PROTECTED_CMD_PATH.test(cmd)) {
+        return { ok: false, reason: `คำสั่งที่อ่าน/แตะ path ลับถูกปฏิเสธ: "${cmd}"` };
+    }
+    return { ok: true };
+}
+async function canonicalExisting(path) {
+    try {
+        return await realpath(path);
+    }
+    catch {
+        return resolve(path);
+    }
+}
+async function existingAncestor(path) {
+    let dir = resolve(path);
+    for (;;) {
+        try {
+            await stat(dir);
+            return canonicalExisting(dir);
+        }
+        catch {
+            const parent = dirname(dir);
+            if (parent === dir)
+                return dir;
+            dir = parent;
+        }
+    }
+}
+async function allowedRoots() {
+    if (envFlag(BRAND_ENV.allowOutsideWorkspace))
+        return ['/'];
+    // agentCwd() = worktree ของ sub-agent ที่ถูก isolate (ถ้ามี) ไม่งั้น = process.cwd().
+    // ผล: sub-agent ใน worktree เขียนได้เฉพาะใน worktree ตัวเอง (isolation) ส่วน main agent เขียนใน workspace ปกติ
+    const roots = [await canonicalExisting(agentCwd())];
+    const brain = await getBrainPath();
+    if (brain)
+        roots.push(await canonicalExisting(brain));
+    return roots;
+}
+function inside(abs, root) {
+    return abs === root || abs.startsWith(root.endsWith(sep) ? root : root + sep);
+}
+function protectedSegment(abs) {
+    const parts = abs.split(/[\\/]+/);
+    if (parts.some((p) => PROTECTED_SEGMENTS.has(p)))
+        return true;
+    const base = basename(abs);
+    return base.startsWith('.env') && base !== '.env.example';
+}
+async function checkPathScope(path, intent) {
+    const abs = intent === 'write' ? await existingAncestor(path) : await canonicalExisting(path);
+    const roots = await allowedRoots();
+    if (!roots.some((root) => inside(abs, root))) {
+        return {
+            ok: false,
+            reason: `path อยู่นอก workspace/brain ที่อนุญาต: "${path}" (ตั้ง ${BRAND_ENV.allowOutsideWorkspace}=1 เพื่อ opt-in)`,
+        };
+    }
     return { ok: true };
 }
-/** กันเขียนทับ secrets/shell-rc/.sanook — resolve เป็น absolute ก่อน (กัน ../ และ symlink-ish bypass) */
-export function checkWritePath(path) {
+/** กันอ่าน secrets/.git/node_modules และกันอ่านนอก workspace/brain */
+export async function checkReadPath(path) {
+    const abs = await canonicalExisting(path);
+    if (protectedSegment(abs)) {
+        return { ok: false, reason: `path ที่ป้องกันถูกปฏิเสธ: "${path}" (secrets / .git / .env / node_modules)` };
+    }
+    return checkPathScope(path, 'read');
+}
+/** กันเขียนทับ secrets/shell-rc/.sanook + กันเขียนนอก workspace/brain */
+export async 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)) {
+    if (PROTECTED_EXACT.has(abs) || inProtectedDir || protectedSegment(abs)) {
         return {
             ok: false,
             reason: `path ที่ป้องกันถูกปฏิเสธ: "${path}" (secrets / shell-rc / .sanook / .git / .env / node_modules)`,
         };
     }
-    return { ok: true };
+    return checkPathScope(path, 'write');
 }

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;
+}