s-app-scoder-agent 0.8.21 → 0.9.3

package/dist/repo-map.js

@@ -0,0 +1,177 @@
+/**
+ * v2 (3.2): Repo map — file tree + symbol outline injected into the system
+ * prompt so the agent orients without reading half the repo first.
+ *
+ * Design:
+ *  - No new dependencies: symbols are extracted with per-language regexes
+ *    (tree-sitter is only a dependency for bash; TS grammars aren't present).
+ *  - Budget-bounded: the map is capped by chars (~budgetChars ≈ budgetTokens
+ *    × 4); deeper trees are truncated with a "… more files" marker.
+ *  - Cached: .scoder/cache/repo-map.json keyed by a content signature
+ *    (relpath + mtime of every walked file). Any edit invalidates the map.
+ *  - Hidden + noise dirs skipped (node_modules/.git/dist/…, dot-dirs).
+ */
+import { readFileSync, readdirSync, statSync, mkdirSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { dirname, join, relative, sep } from "node:path";
+const SKIP_DIRS = new Set([
+    "node_modules", ".git", "dist", "build", ".next", "__pycache__", ".venv",
+    "coverage", "out", "target", ".scoder", ".idea", ".vscode", "vendor",
+]);
+const SYMBOL_FILE = /\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|rb|php|cs)$/i;
+const MAX_WALK_FILES = 2000;
+const MAX_FILE_BYTES = 150 * 1024;
+const MAX_SYMBOLS_PER_FILE = 8;
+const DEFAULT_BUDGET_CHARS = 8000; // ~2k tokens
+/** Walk the workdir (bounded) collecting regular files, skipping noise dirs. */
+export function walkRepo(workdir, sub = ".", maxFiles = MAX_WALK_FILES) {
+    const out = [];
+    const walk = (dir, depth) => {
+        if (depth > 8 || out.length >= maxFiles)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (out.length >= maxFiles)
+                return;
+            if (e.name.startsWith(".") && e.name !== ".github")
+                continue; // hidden
+            if (e.isDirectory()) {
+                if (SKIP_DIRS.has(e.name))
+                    continue;
+                walk(join(dir, e.name), depth + 1);
+            }
+            else if (e.isFile()) {
+                const abs = join(dir, e.name);
+                try {
+                    const st = statSync(abs);
+                    out.push({ rel: relative(workdir, abs).split(sep).join("/"), abs, size: st.size, mtimeMs: st.mtimeMs });
+                }
+                catch {
+                    // unreadable entry — skip
+                }
+            }
+        }
+    };
+    walk(join(workdir, sub), 0);
+    out.sort((a, b) => (a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0));
+    return out;
+}
+/** Content signature — changes iff any walked file's path or mtime changes. */
+export function repoMapKey(workdir) {
+    const h = createHash("sha1");
+    for (const f of walkRepo(workdir)) {
+        h.update(`${f.rel}:${Math.floor(f.mtimeMs)};`);
+    }
+    return h.digest("hex");
+}
+// ── Symbol extraction (per-language regex, intentionally conservative) ───────
+const PATTERNS = [
+    // TS/JS: export [default] [async] function|class|interface|type|enum|const…
+    { rx: /(?:export\s+)?(?:default\s+)?(?:async\s+)?(?:function|class)\s*([A-Za-z_$][\w$]*)/g, group: 1 },
+    { rx: /export\s+(?:declare\s+)?(?:const|let|var|interface|type|enum)\s+([A-Za-z_$][\w$]*)/g, group: 1 },
+    // Python
+    { rx: /^\s*(?:async\s+)?def\s+([A-Za-z_]\w*)/gm, group: 1 },
+    { rx: /^\s*class\s+([A-Za-z_]\w*)/gm, group: 1 },
+    // Go: func [(recv)] Name, type Name
+    { rx: /^func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)/gm, group: 1 },
+    { rx: /^type\s+([A-Za-z_]\w*)/gm, group: 1 },
+    // Rust: [pub] fn|struct|enum|trait Name
+    { rx: /^\s*(?:pub\s+)?(?:fn|struct|enum|trait)\s+([A-Za-z_]\w*)/gm, group: 1 },
+    // Java/C#: class|interface Name
+    { rx: /(?:class|interface|enum)\s+([A-Za-z_]\w*)/g, group: 1 },
+];
+export function extractSymbols(path, content) {
+    const out = new Set();
+    for (const { rx, group } of PATTERNS) {
+        rx.lastIndex = 0;
+        let m;
+        while ((m = rx.exec(content)) !== null && out.size < MAX_SYMBOLS_PER_FILE) {
+            const sym = m[group];
+            if (sym && !/^(if|for|while|switch|return|import|from|package)$/.test(sym))
+                out.add(sym);
+        }
+        if (out.size >= MAX_SYMBOLS_PER_FILE)
+            break;
+    }
+    // Java/C# pattern matches keywords-ish names — filter common noise
+    void path;
+    return [...out].slice(0, MAX_SYMBOLS_PER_FILE);
+}
+// ── Rendering ────────────────────────────────────────────────────────────────
+function kb(size) {
+    return size >= 1024 * 1024 ? `${(size / 1024 / 1024).toFixed(1)}MB` : `${Math.max(1, Math.round(size / 1024))}KB`;
+}
+/** Render the map without touching the cache (used for sub-tree maps). */
+export function renderRepoMap(workdir, budgetChars = DEFAULT_BUDGET_CHARS, sub = ".") {
+    const files = walkRepo(workdir, sub);
+    const lines = [
+        `REPO MAP — ${files.length} files (auto-generated; orient from this, don't read everything)`,
+    ];
+    let budget = budgetChars;
+    let truncated = 0;
+    for (const f of files) {
+        let line = `  ${f.rel} (${kb(f.size)})`;
+        if (SYMBOL_FILE.test(f.rel) && f.size <= MAX_FILE_BYTES) {
+            try {
+                const syms = extractSymbols(f.rel, readFileSync(f.abs, "utf8"));
+                if (syms.length > 0)
+                    line += ` — ${syms.join(", ")}`;
+            }
+            catch {
+                // unreadable — keep just the path
+            }
+        }
+        if (budget - line.length - 1 < 0) {
+            truncated++;
+            continue; // keep counting for the "… more files" marker
+        }
+        lines.push(line);
+        budget -= line.length + 1;
+    }
+    if (truncated > 0)
+        lines.push(`  … ${truncated} more file(s) — use list_files/glob to explore`);
+    return lines.join("\n");
+}
+function cacheFile(workdir) {
+    return join(workdir, ".scoder", "cache", "repo-map.json");
+}
+/**
+ * Build (or reuse from cache) the repo map for the workdir root.
+ * Cache lives in .scoder/cache/ — safe to delete at any time.
+ */
+export function buildRepoMap(workdir, budgetChars = DEFAULT_BUDGET_CHARS) {
+    let key = "";
+    try {
+        key = repoMapKey(workdir);
+        const cached = JSON.parse(readFileSync(cacheFile(workdir), "utf8"));
+        if (cached.key === key && typeof cached.map === "string")
+            return cached.map;
+    }
+    catch {
+        // no/invalid cache — rebuild
+    }
+    const map = renderRepoMap(workdir, budgetChars);
+    try {
+        mkdirSync(dirname(cacheFile(workdir)), { recursive: true });
+        writeFileSync(cacheFile(workdir), JSON.stringify({ key, generatedAt: new Date().toISOString(), map }), "utf8");
+    }
+    catch {
+        // cache is best-effort
+    }
+    return map;
+}
+/** Explicit invalidation (e.g. after /compact or a cache-clearing command). */
+export function invalidateRepoMap(workdir) {
+    try {
+        writeFileSync(cacheFile(workdir), "{}", "utf8");
+    }
+    catch {
+        // ignore — the mtime key will catch any real change anyway
+    }
+}

package/dist/sandbox.js

@@ -27,8 +27,9 @@ export function buildSandboxArgv(wrapper, profile, workdir, command) {
             realWs = realpathSync(workdir);
         }
         catch { /* nonexistent — raw path đủ */ }
+        const escapeSbp = (p) => p.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
         const wsSubpaths = [...new Set([workdir, realWs])]
-            .map((p) => `(subpath "${p}/")`)
+            .map((p) => `(subpath "${escapeSbp(p)}/")`)
             .join(" ");
         const allowWrites = profile === "workspace-write"
             ? `(allow file-write* ${wsSubpaths} (subpath "/tmp") (subpath "/private/tmp"))`
@@ -47,10 +48,10 @@ export function buildSandboxArgv(wrapper, profile, workdir, command) {
             "--dev-bind", "/", "/", // giữ root — sandbox theo write-permission, không chroot
             "--ro-bind", "/", "/", // override: mọi mount ro
         ];
-        for (const w of writes)
-            args.push("--bind", w, w);
-        if (profile === "readonly")
-            args.pop(); // readOnly: bỏ rw workspace
+        if (profile === "workspace-write") {
+            for (const w of writes)
+                args.push("--bind", w, w);
+        }
         args.push("--", "/bin/sh", "-c", command);
         return args;
     }

package/dist/session.js

@@ -29,11 +29,17 @@ function sessionsDir(workdir) {
     return resolve(workdir, SESSIONS_DIR);
 }
 function eventLogPath(workdir, id) {
+    validateSessionId(id);
     return join(sessionsDir(workdir), id, "events.jsonl");
 }
 function manifestPath(workdir, id) {
+    validateSessionId(id);
     return join(sessionsDir(workdir), id, "manifest.json");
 }
+function validateSessionId(id) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(id))
+        throw new Error(`Invalid session id: ${id}`);
+}
 /** Atomic write: write to .tmp then rename. */
 function atomicWrite(path, content) {
     mkdirSync(resolve(path, ".."), { recursive: true });
@@ -249,10 +255,21 @@ export class SessionStore {
 // Load / list / prune
 // ---------------------------------------------------------------------------
 export function loadSession(workdir, id) {
+    try {
+        validateSessionId(id);
+    }
+    catch {
+        return null;
+    }
     // v2 event-sourced session directory first
     const v2Dir = join(sessionsDir(workdir), id);
     if (existsSync(v2Dir) && statSync(v2Dir).isDirectory()) {
-        return sessionFromEventLog(workdir, id);
+        try {
+            const projected = sessionFromEventLog(workdir, id);
+            if (projected)
+                return projected;
+        }
+        catch { /* fall through to v1 snapshot */ }
     }
     const path = join(sessionsDir(workdir), `${id}.json`);
     if (!existsSync(path))
@@ -285,9 +302,12 @@ export function sessionFromEventLog(workdir, id) {
             lastBuild = { success: Boolean(ev.success), command: String(ev.command ?? ""), output: String(ev.output ?? "") };
         }
     }
-    const manifest = existsSync(manifestPath(workdir, id))
-        ? JSON.parse(readFileSync(manifestPath(workdir, id), "utf8"))
-        : {};
+    let manifest = {};
+    try {
+        if (existsSync(manifestPath(workdir, id)))
+            manifest = JSON.parse(readFileSync(manifestPath(workdir, id), "utf8"));
+    }
+    catch { /* malformed manifest — event log remains usable */ }
     return {
         id,
         createdAt,
@@ -311,14 +331,15 @@ export function listSessions(workdir) {
     // v2 event-sourced sessions (directories with manifest.json), newest first
     const v2 = [];
     for (const e of readdirSync(dir, { withFileTypes: true })) {
-        if (!e.isDirectory())
+        if (!e.isDirectory() || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(e.name))
             continue;
         const mf = join(dir, e.name, "manifest.json");
-        if (!existsSync(mf))
+        const evf = join(dir, e.name, "events.jsonl");
+        if (!existsSync(mf) && !existsSync(evf))
             continue;
         try {
-            const m = JSON.parse(readFileSync(mf, "utf8"));
-            v2.push({ id: m.id, task: (m.task ?? "").slice(0, 60), steps: m.steps ?? 0, updatedAt: m.updatedAt ?? "" });
+            const m = existsSync(mf) ? JSON.parse(readFileSync(mf, "utf8")) : { id: e.name, task: "", steps: 0, updatedAt: new Date(statSync(evf).mtimeMs).toISOString() };
+            v2.push({ id: m.id || e.name, task: (m.task ?? "").slice(0, 60), steps: m.steps ?? 0, updatedAt: m.updatedAt ?? "" });
         }
         catch {
             // skip malformed

package/dist/skills.js

@@ -1,44 +1,79 @@
 /**
  * Skill discovery & loading for scoder.
  *
- * A skill is a directory containing a SKILL.md file with YAML-lite frontmatter:
- *
- *   ---
- *   name: code-review
- *   description: Review code for bugs, security issues, and style
- *   ---
- *   (markdown instructions the agent follows)
- *
- * Discovery order (later wins on name conflict):
- *   1. ~/.scoder/skills/<name>/SKILL.md   (global, user-level)
- *   2. <workdir>/.scoder/skills/<name>/SKILL.md (project-local)
- *
- * Skills are advertised to the model in the system prompt (name + description)
- * so it can request one explicitly; users can also load one directly via
- * `/skill <name>`. Inspired by the SKILL.md convention, implemented from
- * scratch — no external dependencies.
+ * A skill is a directory containing a SKILL.md file with YAML-lite frontmatter.
+ * Skills 2.0: supports array/nested frontmatter (version, tags, references),
+ * progressive disclosure (index → body → references/*.md), allowed-tools
+ * enforcement, auto-match scoring, and compat with Claude/OpenCode skill dirs.
  */
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
-const SKILL_FILE = "SKILL.md";
+import { join, extname, resolve, relative, isAbsolute } from "node:path";
 const MAX_SKILL_BODY_CHARS = 20_000;
-/** M5: cảnh báo validate — consumer (Agent/TUI) hiển thị rồi clear. */
 export const skillWarnings = [];
-/** Parse a minimal YAML-lite frontmatter (key: value lines). */
+/** Minimal YAML-lite parser supporting scalars, flow arrays, block arrays, nested. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function parseFrontmatter(text) {
     const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(text);
     if (!m)
         return { meta: {}, body: text };
-    const meta = {};
-    for (const line of m[1].split(/\r?\n/)) {
+    const meta = parseYamlLite(m[1]);
+    return { meta, body: m[2].trim() };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function parseYamlLite(src) {
+    const lines = src.split(/\r?\n/);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const out = {};
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (!line.trim() || line.trim().startsWith("#")) {
+            i++;
+            continue;
+        }
         const kv = /^([a-zA-Z_][\w-]*)\s*:\s*(.*)$/.exec(line.trim());
-        if (kv)
-            meta[kv[1].toLowerCase()] = kv[2].trim().replace(/^["']|["']$/g, "");
+        if (!kv) {
+            i++;
+            continue;
+        }
+        const key = kv[1].toLowerCase();
+        const raw = kv[2].trim();
+        if (raw === "") {
+            // block array or nested
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const items = [];
+            let j = i + 1;
+            while (j < lines.length && /^\s+-\s+/.test(lines[j])) {
+                const item = lines[j].trim().replace(/^-\s+/, "").trim();
+                items.push(stripQuotes(item));
+                j++;
+            }
+            if (items.length > 0) {
+                out[key] = items;
+                i = j;
+                continue;
+            }
+            out[key] = "";
+            i++;
+            continue;
+        }
+        if (raw.startsWith("[") && raw.endsWith("]")) {
+            const inner = raw.slice(1, -1).trim();
+            out[key] = inner === "" ? [] : inner.split(",").map((s) => stripQuotes(s.trim())).filter((s) => s !== "");
+            i++;
+            continue;
+        }
+        out[key] = stripQuotes(raw);
+        i++;
     }
-    return { meta, body: m[2].trim() };
+    return out;
+}
+function stripQuotes(s) {
+    if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'")))
+        return s.slice(1, -1);
+    return s;
 }
-/** Read one SKILL.md into a Skill record (null when the file is malformed). */
 export function loadSkillFile(path, scope) {
     let text;
     try {
@@ -48,75 +83,189 @@ export function loadSkillFile(path, scope) {
         return null;
     }
     const { meta, body } = parseFrontmatter(text);
-    const name = (meta.name || "").trim() || null;
+    const name = String(meta.name || "").trim() || null;
     if (!name)
-        return null; // a skill without a usable name is not discoverable
-    // M5: thiếu description → skip + warn (Anthropic convention: description
-    // là bắt buộc — model dùng nó để quyết định khi nào load skill).
-    const description = (meta.description || "").trim();
+        return null;
+    const description = String(meta.description || "").trim();
     if (!description) {
-        skillWarnings.push({ path, message: `skill "${name}" thiếu description — bỏ qua (thêm description vào frontmatter)` });
+        skillWarnings.push({ path, message: `skill "${name}" thiếu description — bỏ qua` });
         return null;
     }
-    const allowedToolsRaw = (meta["allowed-tools"] || "").trim();
+    const allowedToolsRaw = meta["allowed-tools"] ?? meta.allowedtools ?? meta.allowed_tools;
+    const allowedTools = Array.isArray(allowedToolsRaw)
+        ? allowedToolsRaw.map(String)
+        : (typeof allowedToolsRaw === "string" && allowedToolsRaw.trim()
+            ? String(allowedToolsRaw).split(",").map((t) => t.trim()).filter(Boolean)
+            : undefined);
+    const tagsRaw = meta.tags;
+    const tags = Array.isArray(tagsRaw) ? tagsRaw.map(String) : (typeof tagsRaw === "string" && tagsRaw.trim() ? tagsRaw.split(",").map((t) => t.trim()).filter(Boolean) : undefined);
+    const referencesRaw = meta.references;
+    const references = Array.isArray(referencesRaw) ? referencesRaw.map(String) : (typeof referencesRaw === "string" && referencesRaw.trim() ? referencesRaw.split(",").map((t) => t.trim()).filter(Boolean) : undefined);
+    const dir = path.replace(/[\\/]SKILL\.md$/i, "");
+    // discover reference files in references/ subdir
+    const refDir = join(dir, "references");
+    const refFiles = [];
+    if (existsSync(refDir)) {
+        try {
+            for (const f of readdirSync(refDir)) {
+                if (extname(f).toLowerCase() === ".md")
+                    refFiles.push(f);
+            }
+        }
+        catch { /* ignore */ }
+    }
+    const allRefs = [...(references ?? []), ...refFiles.filter((f) => !(references ?? []).includes(f))];
     return {
         name,
         description,
         path,
         scope,
         body: body.length > MAX_SKILL_BODY_CHARS ? body.slice(0, MAX_SKILL_BODY_CHARS) + "\n… [truncated]" : body,
-        ...(allowedToolsRaw ? { allowedTools: allowedToolsRaw.split(",").map((t) => t.trim()).filter(Boolean) } : {}),
-        ...(meta.license ? { license: meta.license } : {}),
-        ...(meta["when-to-use"] ? { whenToUse: meta["when-to-use"] } : {}),
+        dir,
+        ...(allowedTools && allowedTools.length ? { allowedTools } : {}),
+        ...(meta.license ? { license: String(meta.license) } : {}),
+        ...(meta["when-to-use"] || meta.whentouse ? { whenToUse: String(meta["when-to-use"] || meta.whentouse) } : {}),
+        ...(meta.version ? { version: String(meta.version) } : {}),
+        ...(tags ? { tags } : {}),
+        ...(allRefs.length ? { references: allRefs } : {}),
     };
 }
-/** Collect SKILL.md files from one skills root (one level of directories). */
+function globalSkillsRoots() {
+    const roots = [];
+    const base = process.env.SCODER_SKILLS || join(homedir(), ".scoder", "skills");
+    roots.push(base);
+    // compat: Claude / OpenCode skill dirs
+    roots.push(join(homedir(), ".claude", "skills"));
+    roots.push(join(homedir(), ".opencode", "skills"));
+    return roots;
+}
+function projectSkillsRoots(workdir) {
+    return [
+        join(workdir, ".scoder", "skills"),
+        join(workdir, ".claude", "skills"),
+        join(workdir, ".opencode", "skills"),
+    ];
+}
 function scanRoot(root, scope) {
     if (!existsSync(root))
         return [];
     const out = [];
+    // Skills may be <root>/<name>/SKILL.md OR <root>/*.md (flat) for compat.
+    // First: directory form.
     for (const entry of readdirSync(root, { withFileTypes: true })) {
-        if (!entry.isDirectory())
-            continue;
-        const file = join(root, entry.name, SKILL_FILE);
-        if (!existsSync(file))
-            continue;
-        const skill = loadSkillFile(file, scope);
+        if (entry.isDirectory()) {
+            const file = join(root, entry.name, "SKILL.md");
+            if (existsSync(file)) {
+                const skill = loadSkillFile(file, scope);
+                if (skill)
+                    out.push(skill);
+            }
+            // also nested references not skills
+        }
+        else if (entry.isFile() && entry.name.toLowerCase().endsWith(".md") && entry.name.toLowerCase() !== "skill.md") {
+            // flat skill file: name from frontmatter or filename
+            const skill = loadSkillFile(join(root, entry.name), scope);
+            if (skill)
+                out.push(skill);
+        }
+    }
+    // If root itself contains SKILL.md
+    const self = join(root, "SKILL.md");
+    if (existsSync(self)) {
+        const skill = loadSkillFile(self, scope);
         if (skill)
             out.push(skill);
     }
     return out;
 }
-/** Global skills root — overridable via SCODER_SKILLS for tests. */
-function globalSkillsRoot() {
-    return process.env.SCODER_SKILLS || join(homedir(), ".scoder", "skills");
-}
-/** Discover all skills visible to a project: global first, project overrides. */
 export function discoverSkills(workdir) {
-    const global = scanRoot(globalSkillsRoot(), "global");
-    const project = scanRoot(join(workdir, ".scoder", "skills"), "project");
     const byName = new Map();
-    for (const s of [...global, ...project]) {
-        // M5: trùng name → warn (project wins per merge order).
-        if (byName.has(s.name)) {
-            skillWarnings.push({ path: s.path, message: `skill "${s.name}" trùng tên (${s.scope} overrides ${byName.get(s.name)?.scope})` });
+    for (const root of [...globalSkillsRoots(), ...projectSkillsRoots(workdir)]) {
+        const relRoot = relative(resolve(workdir), resolve(root));
+        const scope = !relRoot.startsWith("..") && !isAbsolute(relRoot) ? "project" : "global";
+        for (const s of scanRoot(root, scope)) {
+            if (byName.has(s.name)) {
+                skillWarnings.push({ path: s.path, message: `skill "${s.name}" trùng tên (${s.scope} overrides ${byName.get(s.name)?.scope})` });
+            }
+            byName.set(s.name, s);
         }
-        byName.set(s.name, s); // project wins
     }
     return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
 }
-/** Find one skill by (case-insensitive) name, or null. */
 export function findSkill(workdir, name) {
     const wanted = name.toLowerCase();
     return discoverSkills(workdir).find((s) => s.name.toLowerCase() === wanted) ?? null;
 }
-/**
- * One-line-per-skill advertisement for the system prompt — the model sees
- * names + descriptions and can ask to load a skill, or the user invokes
- * `/skill <name>` directly.
- */
 export function formatSkillIndex(skills) {
     if (skills.length === 0)
         return "";
-    return skills.map((s) => `- ${s.name}: ${s.description || "(no description)"}`).join("\n");
+    return skills.map((s) => {
+        const tags = s.tags?.length ? ` [${s.tags.join(",")}]` : "";
+        return `- ${s.name}: ${s.description || "(no description)"}${tags}`;
+    }).join("\n");
+}
+/** Progressive disclosure: read a reference file's content. */
+export function readSkillReference(skill, ref) {
+    if (!skill.dir)
+        return null;
+    const candidates = [join(skill.dir, ref), join(skill.dir, "references", ref)];
+    for (const c of candidates) {
+        try {
+            const root = resolve(skill.dir);
+            const abs = resolve(c);
+            const rel = relative(root, abs);
+            if (rel.startsWith("..") || isAbsolute(rel))
+                continue;
+            if (existsSync(abs))
+                return readFileSync(abs, "utf8");
+        }
+        catch { /* ignore */ }
+    }
+    return null;
+}
+/** Load a section of a skill body by heading name (case-insensitive). */
+export function loadSkillSection(skill, section) {
+    if (!section)
+        return skill.body;
+    const lines = skill.body.split(/\r?\n/);
+    const target = section.toLowerCase().trim();
+    let collecting = false;
+    const out = [];
+    for (const line of lines) {
+        const hm = /^(#{1,6})\s+(.*)$/.exec(line);
+        if (hm) {
+            if (collecting)
+                break;
+            if (hm[2].toLowerCase().trim() === target) {
+                collecting = true;
+                continue;
+            }
+            continue;
+        }
+        if (collecting)
+            out.push(line);
+    }
+    return collecting ? out.join("\n").trim() : skill.body;
+}
+/** Auto-match scoring: rank skills by keyword overlap with task text. */
+export function scoreSkills(task, skills) {
+    const tokens = new Set(task.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 2));
+    return skills.map((s) => {
+        const haystack = `${s.name} ${s.description} ${s.whenToUse ?? ""} ${(s.tags ?? []).join(" ")}`.toLowerCase();
+        let score = 0;
+        for (const t of tokens)
+            if (haystack.includes(t))
+                score += 1;
+        // name match bonus
+        if (task.toLowerCase().includes(s.name.toLowerCase()))
+            score += 3;
+        return { skill: s, score };
+    }).sort((a, b) => b.score - a.score);
+}
+/** Filter tool specs by an allowed-tools list (glob-ish names). */
+export function filterToolsByAllowed(specs, allowed) {
+    if (!allowed || allowed.length === 0)
+        return specs;
+    const set = new Set(allowed.map((a) => a.toLowerCase()));
+    return specs.filter((s) => set.has(String(s.name ?? s.function?.name ?? "").toLowerCase()));
 }

package/dist/snapshot.js

@@ -159,6 +159,11 @@ export class SnapshotManager {
                     else if (!treeFiles.has(r))
                         rmSync(abs, { force: true });
                 }
+                try {
+                    if (dir !== this.workdir && readdirSync(dir).length === 0)
+                        rmSync(dir, { recursive: true, force: true });
+                }
+                catch { /* best effort */ }
             };
             walk(this.workdir, "");
             return true;

package/dist/steering.js

@@ -29,6 +29,10 @@ export class SteeringInbox {
     get size() {
         return this.items.length;
     }
+    /** Breakdown for the `queue` event: total pending vs steer-mode count. */
+    counts() {
+        return { pending: this.items.length, steering: this.items.filter((x) => x.mode === "steer").length };
+    }
     clear() {
         this.items = [];
     }