sanook-cli 0.4.0 → 0.5.1

package/dist/search/store.js

@@ -0,0 +1,77 @@
+// ============================================================================
+// src/search/store.ts — the ONLY disk-touching module of the search subsystem.
+//
+// Mirrors memory-store.ts's FS discipline exactly: atomic tmp+rename writes,
+// 0o600 permissions, honors persistenceEnabled(), and loadIndex() NEVER writes
+// (read paths stay pure). The persisted payload is one JSON file next to
+// memory.json under ~/.sanook/search/index.json — no SQLite file, no native db.
+// Vectors live in their own sidecar (embed-store.ts) so the BM25 floor never
+// pays to read them.
+// ============================================================================
+import { chmod, mkdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { appHomePath, persistenceEnabled } from '../brand.js';
+import { emptyIndex, indexFromJSON, indexToJSON, } from './index-core.js';
+export const SEARCH_DIR = appHomePath('search');
+export const INDEX_PATH = join(SEARCH_DIR, 'index.json');
+const FILE_VERSION = 1;
+async function pathExists(p) {
+    try {
+        await stat(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** mtime of the on-disk index (ms) or 0 if absent — lets the engine cache-invalidate cheaply. */
+export async function indexMtimeMs() {
+    try {
+        return (await stat(INDEX_PATH)).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Load the persisted index + manifest. Pure read: a missing or malformed file
+ * degrades to an empty index rather than throwing, so a corrupt cache never
+ * bricks search — the next index() rebuilds it.
+ */
+export async function loadIndex() {
+    try {
+        const raw = JSON.parse(await readFile(INDEX_PATH, 'utf8'));
+        if (raw && raw.v === FILE_VERSION) {
+            return { index: indexFromJSON(raw.index), manifest: raw.manifest ?? {} };
+        }
+    }
+    catch {
+        /* no file yet, or malformed → fall through to empty */
+    }
+    return { index: emptyIndex(), manifest: {} };
+}
+/**
+ * Persist index + manifest atomically (tmp+rename), 0o600. No-op when persistence
+ * is disabled (the in-memory index still works for the process, just uncached).
+ */
+export async function saveIndex(index, manifest) {
+    if (!persistenceEnabled())
+        return;
+    await mkdir(SEARCH_DIR, { recursive: true });
+    const payload = { v: FILE_VERSION, index: indexToJSON(index), manifest };
+    const tmp = join(SEARCH_DIR, `index.${randomUUID()}.tmp`);
+    try {
+        await writeFile(tmp, `${JSON.stringify(payload)}\n`, { mode: 0o600 });
+        await chmod(tmp, 0o600).catch(() => { });
+        await rename(tmp, INDEX_PATH);
+    }
+    catch (e) {
+        await rm(tmp, { force: true }).catch(() => { });
+        throw e;
+    }
+}
+/** true if a persisted index already exists on disk. */
+export function hasIndex() {
+    return pathExists(INDEX_PATH);
+}

package/dist/session.js

@@ -1,16 +1,45 @@
-import { readFile, writeFile, mkdir, readdir } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { chmod, readFile, writeFile, mkdir, readdir, realpath } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { appHomePath, persistenceEnabled } from './brand.js';
+import { redactKey } from './providers/keys.js';
 // session store — จำ conversation + ความคืบหน้า เพื่อ "ทำงานต่อได้" ไม่ลืมว่าทำถึงไหน
-const SESSION_DIR = join(homedir(), '.sanook', 'sessions');
+const SESSION_DIR = appHomePath('sessions');
 export function newSessionId() {
     // CLI runtime — ใช้ Date/random ได้ (ไม่ใช่ workflow context)
     const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
     return `${ts}-${Math.random().toString(36).slice(2, 8)}`;
 }
+function redactUnknown(value) {
+    if (typeof value === 'string')
+        return redactKey(value);
+    if (Array.isArray(value))
+        return value.map(redactUnknown);
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, redactUnknown(v)]));
+    }
+    return value;
+}
+function sanitizeSession(s) {
+    return {
+        ...s,
+        messages: redactUnknown(s.messages),
+    };
+}
+async function canonicalPath(path) {
+    try {
+        return await realpath(path);
+    }
+    catch {
+        return resolve(path);
+    }
+}
 export async function saveSession(s) {
+    if (!persistenceEnabled())
+        return;
     await mkdir(SESSION_DIR, { recursive: true });
-    await writeFile(join(SESSION_DIR, `${s.id}.json`), `${JSON.stringify(s, null, 2)}\n`);
+    const path = join(SESSION_DIR, `${s.id}.json`);
+    await writeFile(path, `${JSON.stringify(sanitizeSession(s), null, 2)}\n`, { mode: 0o600 });
+    await chmod(path, 0o600).catch(() => { });
 }
 export async function loadSession(id) {
     try {
@@ -20,13 +49,18 @@ export async function loadSession(id) {
         return null;
     }
 }
-/** session ล่าสุด (สำหรับ --continue) */
-export async function latestSession() {
+/** session ล่าสุด (สำหรับ --continue). ค่า default จำกัดเฉพาะ cwd ปัจจุบัน กัน context ข้าม project */
+export async function latestSession(cwd = process.cwd()) {
     try {
         const ids = (await readdir(SESSION_DIR)).filter((f) => f.endsWith('.json')).map((f) => f.slice(0, -5));
         if (!ids.length)
             return null;
-        const sessions = (await Promise.all(ids.map(loadSession))).filter((s) => s !== null);
+        let sessions = (await Promise.all(ids.map(loadSession))).filter((s) => s !== null);
+        if (cwd) {
+            const current = await canonicalPath(cwd);
+            const pairs = await Promise.all(sessions.map(async (s) => ({ session: s, cwd: await canonicalPath(s.cwd) })));
+            sessions = pairs.filter((p) => p.cwd === current).map((p) => p.session);
+        }
         sessions.sort((a, b) => b.updated.localeCompare(a.updated));
         return sessions[0] ?? null;
     }

package/dist/skill-install.js

@@ -1,5 +1,5 @@
 import { readFile, writeFile, mkdir, readdir, rm, stat, lstat, copyFile } from 'node:fs/promises';
-import { homedir, tmpdir } from 'node:os';
+import { tmpdir } from 'node:os';
 import { join, basename, resolve, sep, dirname } from 'node:path';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
@@ -7,8 +7,9 @@ import { randomUUID } from 'node:crypto';
 import { lookup } from 'node:dns/promises';
 import { isIP } from 'node:net';
 import { parseFrontmatter, isValidSkillName } from './skills.js';
+import { appHomePath, BRAND } from './brand.js';
 const execFileAsync = promisify(execFile);
-const USER_SKILLS = join(homedir(), '.sanook', 'skills');
+const USER_SKILLS = appHomePath('skills');
 const MAX_FILES = 300;
 const MAX_BYTES = 20 * 1024 * 1024; // 20MB ต่อ skill
 const MAX_MD = 2 * 1024 * 1024; // 2MB ต่อ SKILL.md จาก URL
@@ -75,6 +76,7 @@ async function installFromContent(content, fallbackName) {
     if (!isValidSkillName(name))
         throw new Error(`ชื่อ skill ไม่ถูกต้อง: "${name}"`);
     const dest = join(USER_SKILLS, name);
+    await rm(dest, { recursive: true, force: true });
     await mkdir(dest, { recursive: true });
     await writeFile(join(dest, 'SKILL.md'), content);
     return { name, path: dest };
@@ -109,7 +111,7 @@ async function installFromLocal(path, onLog) {
 }
 /** clone GitHub repo (shallow) → ติดตั้ง skill — subPath ต้องอยู่ใต้ clone dir (กัน traversal escape) */
 async function installFromGitHub(repoUrl, subPath, onLog) {
-    const tmp = join(tmpdir(), `sanook-skill-${randomUUID().slice(0, 8)}`);
+    const tmp = join(tmpdir(), `${BRAND.skillTempPrefix}${randomUUID().slice(0, 8)}`);
     try {
         onLog?.(`clone ${repoUrl} …`);
         // execFile (no shell) + '--' กัน url ขึ้นต้น '-' ถูกตีเป็น git option + timeout
@@ -138,14 +140,12 @@ async function fetchSkillMd(url) {
     if (u.protocol !== 'https:')
         throw new Error('รองรับเฉพาะ https สำหรับ URL ของ SKILL.md');
     // resolve hostname → block private/loopback IP (กัน SSRF ยิง internal/cloud-metadata)
-    let ip = u.hostname;
-    if (!isIP(u.hostname)) {
-        const res = await lookup(u.hostname).catch(() => null);
-        ip = res?.address ?? '';
-    }
-    if (!ip || PRIVATE_IP.test(ip))
+    const host = u.hostname.replace(/^\[|\]$/g, '');
+    const ips = isIP(host) ? [host] : (await lookup(host, { all: true }).catch(() => [])).map((r) => r.address);
+    if (!ips.length || ips.some((ip) => PRIVATE_IP.test(ip))) {
         throw new Error(`URL ชี้ไป internal/private address — ปฏิเสธ (${u.hostname})`);
-    const r = await fetch(url, { signal: AbortSignal.timeout(30_000) });
+    }
+    const r = await fetch(url, { redirect: 'error', signal: AbortSignal.timeout(30_000) });
     if (!r.ok)
         throw new Error(`fetch ไม่สำเร็จ: HTTP ${r.status}`);
     if (Number(r.headers.get('content-length') ?? 0) > MAX_MD)

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');
 }