@stfade/pi-read-delegator 1.0.0

package/index.js

@@ -0,0 +1,260 @@
+"use strict";
+/**
+ * index.ts — pi-read-delegator extension entry point
+ *
+ * Lifecycle:
+ *   init(agent)  → load config, check deps, ensure template, enable/disable
+ *   enable(agent) → block tools, add system prompt, attach bash filter
+ *   disable(agent) → restore tools, remove prompt, detach bash filter
+ *
+ * Commands:
+ *   /read-delegator on     → enable the delegator
+ *   /read-delegator off    → disable the delegator
+ *   /read-delegator status  → show current status
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const config_1 = require("./config");
+const tool_blocker_1 = require("./tool-blocker");
+const bash_filter_1 = require("./bash-filter");
+const reader_manager_1 = require("./reader-manager");
+const ui_1 = require("./ui");
+// ---------------------------------------------------------------------------
+// Module state
+// ---------------------------------------------------------------------------
+let enabled = false;
+let config = null;
+let currentSystemMessage = null;
+// ---------------------------------------------------------------------------
+// Lifecycle: init
+// ---------------------------------------------------------------------------
+/**
+ * Initialize the extension.
+ *
+ * This is the function Pi calls when loading the extension.
+ * It returns a lifecycle object with enable() and disable().
+ */
+function init(agent) {
+    // 1. Load configuration
+    config = (0, config_1.loadConfig)();
+    // 2. Detect language
+    (0, ui_1.getLanguage)(config.language);
+    // 3. Initialize status bar
+    (0, ui_1.initStatusBar)(agent);
+    // 4. Register commands
+    registerCommands(agent);
+    // 5. Run async init tasks (dependency check, template) in background.
+    //    We do NOT block init — if deps are missing the user will be prompted.
+    initAsync(agent);
+    // Build lifecycle interface
+    const enable = () => doEnable(agent);
+    const disable = () => doDisable(agent);
+    // If config says enabled, auto-enable (synchronous part first)
+    if (config?.enabled) {
+        doEnable(agent);
+    }
+    return { enable, disable };
+}
+// ---------------------------------------------------------------------------
+// Async initialization (runs in background)
+// ---------------------------------------------------------------------------
+async function initAsync(agent) {
+    try {
+        // Check pi-subagents dependency
+        await (0, reader_manager_1.checkDependencies)(agent.promptUser);
+    }
+    catch (err) {
+        (0, ui_1.logError)("deps_failed");
+        (0, ui_1.logError)("reader_failed", String(err));
+        // Disable the extension if dependencies can't be satisfied
+        doDisable(agent);
+        return;
+    }
+    // Ensure reader.md template exists
+    const templateOk = (0, reader_manager_1.ensureReaderTemplate)();
+    if (!templateOk) {
+        (0, ui_1.logWarn)("reader_failed", "Reader template could not be created. Create ~/.pi/agent/agents/reader.md manually.");
+    }
+}
+// ---------------------------------------------------------------------------
+// Enable / Disable
+// ---------------------------------------------------------------------------
+function doEnable(agent) {
+    if (enabled) {
+        agent.displayMessage((0, ui_1.msg)("already_blocked"));
+        return;
+    }
+    if (!config) {
+        (0, ui_1.logError)("reader_failed", "No configuration loaded.");
+        return;
+    }
+    // Block read tools
+    (0, tool_blocker_1.blockTools)(agent, config.blocked_tools);
+    // Add system message
+    currentSystemMessage = config.orchestrator_prompt;
+    agent.addSystemMessage(config.orchestrator_prompt);
+    // Attach bash filter hook
+    attachBashFilter(agent);
+    // Update status
+    enabled = true;
+    (0, ui_1.updateStatusBar)("active");
+    (0, ui_1.log)("enabled");
+    agent.displayMessage((0, ui_1.msg)("enabled"));
+}
+function doDisable(agent) {
+    if (!enabled) {
+        agent.displayMessage((0, ui_1.msg)("already_enabled"));
+        return;
+    }
+    // Restore read tools
+    (0, tool_blocker_1.restoreTools)(agent);
+    // Remove system message
+    if (currentSystemMessage) {
+        try {
+            agent.removeSystemMessage(currentSystemMessage);
+        }
+        catch {
+            // Best effort — the message text may have been mutated
+        }
+        currentSystemMessage = null;
+    }
+    // Detach bash filter (we can't undo onBeforeToolCall, but we set a flag)
+    enabled = false;
+    (0, ui_1.updateStatusBar)("idle");
+    (0, ui_1.log)("disabled");
+    agent.displayMessage((0, ui_1.msg)("disabled"));
+}
+// ---------------------------------------------------------------------------
+// Bash filter hook
+// ---------------------------------------------------------------------------
+/**
+ * Attach a before-tool-call hook on the "bash" (and "shell") tools.
+ *
+ * When the main model tries to execute a bash command:
+ *  - Read commands → forwarded to Reader subagent
+ *  - Write commands → executed directly
+ *  - Ambiguous → user is prompted
+ */
+function attachBashFilter(agent) {
+    // Hook both "bash" and "shell" tools, since Pi may expose either.
+    const bashToolNames = ["bash", "shell"];
+    for (const toolName of bashToolNames) {
+        try {
+            agent.onBeforeToolCall(toolName, async (params) => {
+                // Only intercept if the extension is enabled
+                if (!enabled || !config)
+                    return undefined; // undefined = proceed normally
+                const p = params;
+                const command = typeof p.command === "string" ? p.command : "";
+                if (!command)
+                    return undefined; // Let the tool handle the error
+                // Classify the command
+                if ((0, bash_filter_1.isWriteCommand)(command)) {
+                    // Let the raw bash/shell tool execute this directly
+                    return undefined; // undefined → Pi runs the original tool
+                }
+                if ((0, bash_filter_1.isReadCommand)(command)) {
+                    // Forward to Reader subagent
+                    (0, ui_1.log)("reader_calling", command);
+                    try {
+                        const result = await (0, reader_manager_1.callReader)(agent, config, (0, bash_filter_1.wrapForReader)(command));
+                        (0, ui_1.log)("reader_done");
+                        // Return the result directly — Pi will use this as the tool output
+                        // instead of running the original bash command.
+                        return { result, subagent_used: true };
+                    }
+                    catch (err) {
+                        (0, ui_1.logError)("reader_failed", String(err));
+                        // Offer the [R/A/C] dialog
+                        try {
+                            const handled = await (0, reader_manager_1.handleReaderError)(agent, config, config.blocked_tools, err, (0, bash_filter_1.wrapForReader)(command), agent.promptUser);
+                            // If "Allow once" was selected, return a special marker
+                            if (handled.startsWith("[ALLOW_ONCE]")) {
+                                return { result: handled, allow_once: true };
+                            }
+                            // Retry succeeded — return the result
+                            return { result: handled, subagent_used: true };
+                        }
+                        catch (finalErr) {
+                            (0, ui_1.updateStatusBar)("error");
+                            return {
+                                error: true,
+                                message: finalErr instanceof Error
+                                    ? finalErr.message
+                                    : "Reader failed",
+                            };
+                        }
+                    }
+                }
+                // Ambiguous command → ask user
+                const answer = await agent.promptUser(`The command "${command}" may read files. Run via Reader? [Y/n]`);
+                if (answer.trim().toLowerCase() === "n" ||
+                    answer.trim().toLowerCase() === "no") {
+                    // Let the original tool run
+                    return undefined;
+                }
+                // Forward to Reader
+                (0, ui_1.log)("reader_calling", command);
+                try {
+                    const result = await (0, reader_manager_1.callReader)(agent, config, (0, bash_filter_1.wrapForReader)(command));
+                    (0, ui_1.log)("reader_done");
+                    return { result, subagent_used: true };
+                }
+                catch (err) {
+                    (0, ui_1.logError)("reader_failed", String(err));
+                    return {
+                        error: true,
+                        message: err instanceof Error ? err.message : "Reader failed",
+                    };
+                }
+            });
+        }
+        catch {
+            // onBeforeToolCall not supported for this tool — no-op
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Pi commands
+// ---------------------------------------------------------------------------
+function registerCommands(agent) {
+    agent.registerCommand("read-delegator", async (args) => {
+        const sub = args[0]?.toLowerCase();
+        switch (sub) {
+            case "on":
+            case "enable": {
+                if (!config) {
+                    config = (0, config_1.loadConfig)();
+                }
+                config.enabled = true;
+                (0, config_1.saveConfig)(config, { silent: true });
+                doEnable(agent);
+                return (0, ui_1.msg)("enabled");
+            }
+            case "off":
+            case "disable": {
+                if (config) {
+                    config.enabled = false;
+                    (0, config_1.saveConfig)(config, { silent: true });
+                }
+                doDisable(agent);
+                return (0, ui_1.msg)("disabled");
+            }
+            case "status": {
+                const status = (0, ui_1.getStatus)();
+                const blocked = (0, tool_blocker_1.getBlockedTools)();
+                return (`pi-read-delegator is ${status}\n` +
+                    `Enabled: ${enabled ? "yes" : "no"}\n` +
+                    `Blocked tools: ${blocked.join(", ") || "(none)"}\n` +
+                    `Reader subagent: ${config?.reader_subagent_name ?? "reader"}\n` +
+                    `Language: ${config?.language ?? "auto"}`);
+            }
+            default:
+                return ("Usage:\n" +
+                    "  /read-delegator on     — enable read delegation\n" +
+                    "  /read-delegator off    — disable read delegation\n" +
+                    "  /read-delegator status — show current status");
+        }
+    });
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@stfade/pi-read-delegator",
+  "version": "1.0.0",
+  "description": "Pi extension that delegates all read operations to a Reader subagent, blocking read tools from the main model",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "pi-extension": true,
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "config.js",
+    "config.d.ts",
+    "tool-blocker.js",
+    "tool-blocker.d.ts",
+    "bash-filter.js",
+    "bash-filter.d.ts",
+    "reader-manager.js",
+    "reader-manager.d.ts",
+    "ui.js",
+    "ui.d.ts",
+    "templates/reader.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "pi",
+    "pi-extension",
+    "read-delegator",
+    "subagent",
+    "reader"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.4.0"
+  },
+  "peerDependencies": {
+    "pi-subagents": "*"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/reader-manager.d.ts

@@ -0,0 +1,71 @@
+/**
+ * reader-manager.ts — Reader subagent lifecycle and error handling
+ *
+ * Responsibilities:
+ *  - Check that pi-subagents is installed (prompt user if not)
+ *  - Ensure the reader.md subagent template exists
+ *  - Call the Reader subagent with a task
+ *  - Handle errors with a [R]etry / [A]llow once / [C]ancel prompt
+ */
+import type { ReadDelegatorConfig } from "./config";
+import type { ExtensionAgent } from "./tool-blocker";
+export interface AgentWithSubagent extends ExtensionAgent {
+    /** Call a subagent by name with a task string. Returns the subagent's response. */
+    callSubagent(params: {
+        name: string;
+        task: string;
+    }): Promise<string>;
+}
+/** Error thrown when the Reader subagent fails. */
+export declare class ReaderError extends Error {
+    readonly originalError?: unknown | undefined;
+    constructor(message: string, originalError?: unknown | undefined);
+}
+/**
+ * Verify that pi-subagents is installed as a Pi extension.
+ *
+ * Strategy: check whether the `pi-subagents` npm package is findable.
+ * If not, prompt the user to install it. If they agree, install via
+ * `pi install pi-subagents` (fallback: `npm install -g pi-subagents`).
+ *
+ * @returns true if installed or successfully installed
+ * @throws  if the user declines or installation fails
+ */
+export declare function checkDependencies(prompt: (message: string) => Promise<string>): Promise<boolean>;
+/**
+ * Ensure the reader.md subagent template exists.
+ * If not, copy the bundled template from `templates/reader.md`.
+ *
+ * @returns true if the template exists after this call
+ */
+export declare function ensureReaderTemplate(): boolean;
+/**
+ * Send a task to the Reader subagent and return its response.
+ *
+ * @param agent   The Pi agent with subagent-calling capability
+ * @param config  Current extension configuration
+ * @param task    The task string to send
+ * @param timeoutMs  Timeout in milliseconds (default 30s)
+ * @returns       The Reader's response text
+ * @throws        ReaderError on timeout, failure, or empty response
+ */
+export declare function callReader(agent: AgentWithSubagent, config: ReadDelegatorConfig, task: string, timeoutMs?: number): Promise<string>;
+/**
+ * Handle a Reader failure by prompting the user.
+ *
+ * Options:
+ * - [R]etry  → re-send the same task to Reader
+ * - [A]llow once → temporarily unblock tools, let main model do it, re-block
+ * - [C]ancel → throw the error upstream
+ *
+ * @param agent         The Pi agent
+ * @param config        Extension config
+ * @param blockedTools  Tool names currently blocked
+ * @param error         The error that occurred
+ * @param task          The original task string
+ * @param prompt        Async prompt function (should collect user input)
+ * @returns             Reader response on Retry/Allow; never returns on Cancel
+ * @throws              ReaderError on Cancel or repeated failure
+ */
+export declare function handleReaderError(agent: AgentWithSubagent, config: ReadDelegatorConfig, blockedTools: string[], error: unknown, task: string, prompt: (message: string) => Promise<string>): Promise<string>;
+//# sourceMappingURL=reader-manager.d.ts.map

package/reader-manager.js

@@ -0,0 +1,274 @@
+"use strict";
+/**
+ * reader-manager.ts — Reader subagent lifecycle and error handling
+ *
+ * Responsibilities:
+ *  - Check that pi-subagents is installed (prompt user if not)
+ *  - Ensure the reader.md subagent template exists
+ *  - Call the Reader subagent with a task
+ *  - Handle errors with a [R]etry / [A]llow once / [C]ancel prompt
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReaderError = void 0;
+exports.checkDependencies = checkDependencies;
+exports.ensureReaderTemplate = ensureReaderTemplate;
+exports.callReader = callReader;
+exports.handleReaderError = handleReaderError;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+/** Error thrown when the Reader subagent fails. */
+class ReaderError extends Error {
+    originalError;
+    constructor(message, originalError) {
+        super(message);
+        this.originalError = originalError;
+        this.name = "ReaderError";
+    }
+}
+exports.ReaderError = ReaderError;
+// ---------------------------------------------------------------------------
+// Paths
+// ---------------------------------------------------------------------------
+function expandTilde(p) {
+    if (p.startsWith("~"))
+        return path.join(os.homedir(), p.slice(1));
+    return p;
+}
+const READER_TEMPLATE_PATH = expandTilde("~/.pi/agent/agents/reader.md");
+// ---------------------------------------------------------------------------
+// 1. Dependency check
+// ---------------------------------------------------------------------------
+/**
+ * Verify that pi-subagents is installed as a Pi extension.
+ *
+ * Strategy: check whether the `pi-subagents` npm package is findable.
+ * If not, prompt the user to install it. If they agree, install via
+ * `pi install pi-subagents` (fallback: `npm install -g pi-subagents`).
+ *
+ * @returns true if installed or successfully installed
+ * @throws  if the user declines or installation fails
+ */
+async function checkDependencies(prompt) {
+    // Try to resolve pi-subagents to verify it's installed
+    if (isSubagentsInstalled()) {
+        return true;
+    }
+    console.warn("[pi-read-delegator] ⚠️ pi-subagents is not installed.");
+    const answer = await prompt("⚠️ pi-subagents is not installed. Install it now? [Y/n]");
+    const normalized = answer.trim().toLowerCase();
+    if (normalized !== "" && normalized !== "y" && normalized !== "yes") {
+        throw new Error("pi-subagents is required. Please install it manually: pi install pi-subagents");
+    }
+    // Attempt installation
+    console.log("[pi-read-delegator] 📦 Installing pi-subagents…");
+    try {
+        // Try `pi install pi-subagents` first (the Pi package manager)
+        (0, child_process_1.execSync)("pi install pi-subagents", {
+            stdio: "pipe",
+            timeout: 60_000,
+            encoding: "utf-8",
+        });
+        console.log("[pi-read-delegator] ✅ pi-subagents installed via pi.");
+    }
+    catch {
+        // Fallback to global npm install
+        try {
+            (0, child_process_1.execSync)("npm install -g pi-subagents", {
+                stdio: "pipe",
+                timeout: 60_000,
+                encoding: "utf-8",
+            });
+            console.log("[pi-read-delegator] ✅ pi-subagents installed via npm.");
+        }
+        catch (err) {
+            throw new Error("❌ Installation failed. Please install manually: npm install -g pi-subagents");
+        }
+    }
+    // Verify installation took effect
+    if (!isSubagentsInstalled()) {
+        throw new Error("❌ pi-subagents installed but cannot be found. Restart Pi and try again.");
+    }
+    return true;
+}
+/**
+ * Simple check: can we require/import pi-subagents?
+ */
+function isSubagentsInstalled() {
+    try {
+        // Dynamic require that works even if TypeScript doesn't know the module
+        const mod = require("pi-subagents");
+        return mod !== undefined;
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// 2. Reader template
+// ---------------------------------------------------------------------------
+/**
+ * Ensure the reader.md subagent template exists.
+ * If not, copy the bundled template from `templates/reader.md`.
+ *
+ * @returns true if the template exists after this call
+ */
+function ensureReaderTemplate() {
+    if (fs.existsSync(READER_TEMPLATE_PATH)) {
+        return true;
+    }
+    // Path to the bundled template (sibling to the compiled JS)
+    const bundledPath = path.join(__dirname, "templates", "reader.md");
+    if (!fs.existsSync(bundledPath)) {
+        console.warn("[pi-read-delegator] ⚠️ Bundled reader template not found at:", bundledPath);
+        console.warn("[pi-read-delegator] Please create ~/.pi/agent/agents/reader.md manually.");
+        return false;
+    }
+    try {
+        const content = fs.readFileSync(bundledPath, "utf-8");
+        ensureDir(path.dirname(READER_TEMPLATE_PATH));
+        fs.writeFileSync(READER_TEMPLATE_PATH, content, "utf-8");
+        console.log(`[pi-read-delegator] ✅ Created reader subagent template: ${READER_TEMPLATE_PATH}`);
+        return true;
+    }
+    catch (err) {
+        console.error("[pi-read-delegator] ⚠️ Failed to create reader template:", err);
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// 3. Call Reader
+// ---------------------------------------------------------------------------
+/**
+ * Send a task to the Reader subagent and return its response.
+ *
+ * @param agent   The Pi agent with subagent-calling capability
+ * @param config  Current extension configuration
+ * @param task    The task string to send
+ * @param timeoutMs  Timeout in milliseconds (default 30s)
+ * @returns       The Reader's response text
+ * @throws        ReaderError on timeout, failure, or empty response
+ */
+async function callReader(agent, config, task, timeoutMs = 30_000) {
+    const result = await withTimeout(agent.callSubagent({
+        name: config.reader_subagent_name,
+        task,
+    }), timeoutMs, `Reader subagent timed out after ${timeoutMs / 1000}s`);
+    if (!result || result.trim().length === 0) {
+        throw new ReaderError("Reader subagent returned an empty response.");
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// 4. Error handling: [R]etry / [A]llow once / [C]ancel
+// ---------------------------------------------------------------------------
+/**
+ * Handle a Reader failure by prompting the user.
+ *
+ * Options:
+ * - [R]etry  → re-send the same task to Reader
+ * - [A]llow once → temporarily unblock tools, let main model do it, re-block
+ * - [C]ancel → throw the error upstream
+ *
+ * @param agent         The Pi agent
+ * @param config        Extension config
+ * @param blockedTools  Tool names currently blocked
+ * @param error         The error that occurred
+ * @param task          The original task string
+ * @param prompt        Async prompt function (should collect user input)
+ * @returns             Reader response on Retry/Allow; never returns on Cancel
+ * @throws              ReaderError on Cancel or repeated failure
+ */
+async function handleReaderError(agent, config, blockedTools, error, task, prompt) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    console.error(`[pi-read-delegator] ❌ Reader failed: ${errMsg}`);
+    const answer = await prompt(`\n❌ Reader subagent failed: ${errMsg}\n` +
+        `[R]etry  [A]llow once (let main model do it)  [C]ancel\n`);
+    const choice = answer.trim().toLowerCase();
+    if (choice === "r" || choice === "retry") {
+        // Retry the same task
+        console.log("[pi-read-delegator] 🔄 Retrying Reader…");
+        return callReader(agent, config, task);
+    }
+    if (choice === "a" || choice === "allow" || choice === "allow once") {
+        // Temporarily unblock tools, let main model execute the task,
+        // then re-block.
+        console.log("[pi-read-delegator] 🔓 Allowing main model to read once…");
+        // NOTE: For "Allow once", we need the main model to perform the task.
+        // However, we are inside a tool call — the main model can't run code
+        // inline. We return a specially formatted string that instructs the
+        // main model: "blocked tools are now available for one operation;
+        // please perform the following task and then they will be re-locked."
+        //
+        // The tempAllowOnce wrapper re-blocks after this handler returns.
+        // Actually, the flow for "Allow once" is:
+        // 1. We restore tools (they're currently blocked)
+        // 2. We return a message telling the main model "do this task yourself"
+        // 3. After the main model does ONE operation, tools are re-blocked
+        //
+        // But since we can't intercept the main model's turn boundary
+        // precisely, we return a message and rely on the next hook point
+        // to re-block. The caller should call tempAllowOnce around this.
+        return `[ALLOW_ONCE] The blocked tools (${blockedTools.join(", ")}) are now temporarily available. Please perform the following task yourself, then tools will be re-blocked:\n\n${task}`;
+    }
+    // Cancel
+    throw new ReaderError(`Reader failed and user cancelled: ${errMsg}`, error);
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Race a promise against a timeout. */
+async function withTimeout(promise, ms, timeoutMessage) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new ReaderError(timeoutMessage)), ms);
+    });
+    try {
+        const result = await Promise.race([promise, timeout]);
+        return result;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** Ensure a directory exists, creating it recursively. */
+function ensureDir(dir) {
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+//# sourceMappingURL=reader-manager.js.map

package/templates/reader.md

@@ -0,0 +1,8 @@
+---
+name: reader
+description: Read-only file agent that returns minimal results
+tools: read, grep, find, ls
+model: lmstudio/nemotron-mini
+---
+
+You are a token-efficient assistant. Execute read/search tasks and return ONLY the essential result. Max 5 lines or a single number. Never dump files. If running a shell command, return only the output, nothing else.