@stfade/pi-read-delegator 1.0.11 → 1.0.13

package/dist/index.js

@@ -0,0 +1,295 @@
+/**
+ * index.ts — pi-read-delegator entry point
+ *
+ * Blocks read tools from the orchestrator and tells it to delegate every
+ * file-read / search task to the 'reader' subagent.
+ *
+ * Architecture:
+ *  - Factory body: registration only (pi.on, pi.registerCommand, ensureReaderTemplate)
+ *  - session_start: dependency check → tool blocking → status bar
+ *  - before_agent_start: inject orchestrator system prompt
+ *  - tool_call: intercept bash read commands → redirect to reader
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { loadConfig, saveConfig } from "./config";
+import { checkDependencies, isSubagentsInstalled, sessionCache, } from "./reader-manager";
+import { getLanguage, msg } from "./ui";
+import { isReadCommand } from "./bash-filter";
+// ---------------------------------------------------------------------------
+// Reader template path
+// ---------------------------------------------------------------------------
+function readerPath() {
+    return path.join(os.homedir(), ".pi", "agent", "agents", "reader.md");
+}
+function syncReaderTemplate(model) {
+    const rp = readerPath();
+    try {
+        const dir = path.dirname(rp);
+        fs.mkdirSync(dir, { recursive: true });
+        const content = [
+            "---",
+            "name: reader",
+            "description: Compact code-reader — executes tasks, returns results with line numbers",
+            "tools: read, grep, find, ls",
+            `model: ${model}`,
+            "---",
+            "",
+            "Execute the task. Return only the result, nothing else.",
+            "Always include line numbers for grep and read results.",
+            "No explanations, summaries, or conversational text.",
+            "",
+            "### Structure masks (auto-apply to code output)",
+            "- Skip import statements unless task explicitly mentions them.",
+            "- Collapse long type annotations: `Record<string, string>[]` → `Record<...>[]`.",
+            "- Truncate paths: `C:/Users/samet/Documents/Projects/pi-read-delegator/src/` → `src/`.",
+            "",
+            "### Stats-first for grep / find",
+            "- grep: show total match count on line 1, then matches. Large result sets (>20): only count.",
+            "- find: show file count first, then list. >50 files: only count.",
+            "- ls: show file count first, then list.",
+            "",
+            "### Smart filtering",
+            "- Skip node_modules, .git, dist, .next, coverage, __pycache__ unless task specifies a path inside.",
+            "- Skip binary files (images, .exe, .dll, .zip, .db) — return '(binary)'.",
+            "- Deduplicate: if same file appears in multiple grep matches, show it once with all line numbers.",
+            "",
+            "### Output format (no markdown headers)",
+            "grep: src/file.ts:42  matched line",
+            "read: 42: line content",
+            "find: file list, one per line",
+            "ls:   name  size",
+            "No matches: (no matches)",
+            "Error: Error: <message>",
+        ].join("\n");
+        fs.writeFileSync(rp, content, "utf8");
+    }
+    catch {
+        // read-only home directory — template sync is best-effort
+    }
+}
+// ---------------------------------------------------------------------------
+// Model picker
+// ---------------------------------------------------------------------------
+/**
+ * Interactive model picker using Pi's model registry.
+ * Shows a select UI with all configured models and updates config + reader.md
+ * when the user picks a new model.
+ *
+ * Returns the selected model string ("provider/model") or undefined if the
+ * picker is unavailable or the user cancels.
+ */
+async function pickReaderModel(config, ctx) {
+    try {
+        const models = ctx.modelRegistry?.getAvailable?.() ?? [];
+        if (models.length === 0)
+            return undefined;
+        const options = models.map((m) => `${m.provider ?? "?"}/${m.id}`);
+        if (!options.includes(config.reader_model)) {
+            options.unshift(config.reader_model);
+        }
+        const selected = await ctx.ui.select("Choose reader model (ESC to keep current)", options);
+        if (selected && selected !== config.reader_model) {
+            config.reader_model = selected;
+            saveConfig(config, { silent: true });
+            syncReaderTemplate(selected);
+            ctx.ui.notify("✅ Reader model set to: " + selected, "info");
+            return selected;
+        }
+    }
+    catch {
+        // modelRegistry or ui.select not available — fallback
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Tool helpers
+// ---------------------------------------------------------------------------
+/** Determine which tools stay active after blocking read tools.
+ *  Always keeps "subagent" — the bridge to the reader. */
+function computeActiveTools(pi, blocked) {
+    const all = pi.getAllTools();
+    const blockedSet = new Set(blocked);
+    const forceKeep = new Set(["subagent"]);
+    return all
+        .map((t) => t.name)
+        .filter((name) => forceKeep.has(name) || !blockedSet.has(name));
+}
+// ---------------------------------------------------------------------------
+// Dependency check helpers — extracted to keep session_start handler lean
+// ---------------------------------------------------------------------------
+function createProgressCallback(ctx) {
+    return (status) => {
+        if (status === "installing") {
+            ctx.ui.setStatus("read-delegator", "⏳ Installing pi-subagents…");
+            ctx.ui.notify(msg("deps_installing") +
+                " This may take up to 60 seconds. Please wait…", "info");
+        }
+        else if (status === "done") {
+            ctx.ui.setStatus("read-delegator", msg("status_active"));
+            ctx.ui.notify("✅ pi-subagents installed successfully.", "info");
+        }
+        else if (status === "failed") {
+            ctx.ui.setStatus("read-delegator", msg("status_error"));
+        }
+    };
+}
+async function performDependencyCheck(ctx, config) {
+    const promptFn = async (message) => {
+        const ok = await ctx.ui.confirm("pi-subagents required", message);
+        return ok ? "y" : "n";
+    };
+    const ready = await checkDependencies(promptFn, createProgressCallback(ctx));
+    if (!ready) {
+        config.enabled = false;
+        saveConfig(config, { silent: true });
+        ctx.ui.setStatus("read-delegator", msg("status_error"));
+        ctx.ui.notify(msg("deps_disabled"), "warning");
+        return false;
+    }
+    if (!config.enabled) {
+        config.enabled = true;
+        saveConfig(config, { silent: true });
+    }
+    return true;
+}
+// ---------------------------------------------------------------------------
+// Extension factory — registration only; actions go inside events
+// ---------------------------------------------------------------------------
+export default async function (pi) {
+    const config = loadConfig();
+    // Detect language
+    getLanguage(config.language);
+    // Quick sync dependency check — interactive prompt is deferred to
+    // session_start where we have access to ctx.ui.confirm().
+    let depsReady = isSubagentsInstalled();
+    let depsChecked = depsReady; // if already ready, no need to check again
+    // -----------------------------------------------------------------------
+    // 1. session_start: dependency check → tool blocking → status bar
+    // -----------------------------------------------------------------------
+    pi.on("session_start", async (_event, ctx) => {
+        // --- Dependency check ---
+        if (!depsChecked) {
+            depsReady = await performDependencyCheck(ctx, config);
+            depsChecked = true;
+            if (!depsReady)
+                return;
+            // First install: pick reader model from available models
+            await pickReaderModel(config, ctx);
+        }
+        // --- Tool blocking ---
+        if (config.enabled) {
+            pi.setActiveTools(computeActiveTools(pi, config.blocked_tools));
+        }
+        ctx.ui.setStatus("read-delegator", config.enabled ? msg("status_active") : msg("status_off"));
+    });
+    // -----------------------------------------------------------------------
+    // 2. before_agent_start: inject orchestrator system prompt
+    // -----------------------------------------------------------------------
+    pi.on("before_agent_start", (event, _ctx) => {
+        if (!config.enabled)
+            return;
+        return {
+            systemPrompt: event.systemPrompt + "\n\n" + config.orchestrator_prompt,
+        };
+    });
+    // -----------------------------------------------------------------------
+    // 3. tool_call: intercept bash read commands
+    // -----------------------------------------------------------------------
+    pi.on("tool_call", (event, _ctx) => {
+        if (!config.enabled)
+            return;
+        if (event.toolName === "bash" || event.toolName === "shell") {
+            const command = String(event.input?.command ?? "");
+            if (!command)
+                return;
+            if (isReadCommand(command)) {
+                return {
+                    block: true,
+                    reason: [
+                        'Use subagent(agent: "' +
+                            config.reader_subagent_name +
+                            '", task: "Execute and summarize: ' +
+                            command +
+                            '")',
+                        "instead of running file-reading commands directly.",
+                    ].join(" "),
+                };
+            }
+        }
+    });
+    // -----------------------------------------------------------------------
+    // 4. Commands
+    // -----------------------------------------------------------------------
+    // Shared status helper
+    const showStatus = (ctx) => {
+        const s = sessionCache.stats();
+        const lines = [
+            "Read delegation: " + (config.enabled ? "🟢 enabled" : "🔴 disabled"),
+            "Reader subagent: " + config.reader_subagent_name,
+            "Reader model: " + config.reader_model,
+            "Dependencies: " + (depsReady ? "✅ ready" : "❌ missing"),
+            "Blocked tools: " + config.blocked_tools.join(", "),
+            "Cache: " + s.files + " files (" + s.sizeKB + " KB)",
+        ];
+        ctx.ui.notify(lines.join("\n"), "info");
+    };
+    // Shortcut: enable/disable toggle with subcommand syntax (kept for back compat)
+    pi.registerCommand("read-delegator", {
+        description: "Show read-delegator status",
+        handler: async (_args, ctx) => {
+            showStatus(ctx);
+        },
+    });
+    pi.registerCommand("read-delegator-status", {
+        description: "Show read-delegator status",
+        handler: async (_args, ctx) => {
+            showStatus(ctx);
+        },
+    });
+    pi.registerCommand("read-delegator-on", {
+        description: "Enable read delegation",
+        handler: async (_args, ctx) => {
+            if (!depsReady) {
+                ctx.ui.notify("pi-subagents not installed. Install it first to enable read delegation.", "warning");
+                return;
+            }
+            config.enabled = true;
+            saveConfig(config, { silent: true });
+            pi.setActiveTools(computeActiveTools(pi, config.blocked_tools));
+            ctx.ui.notify(msg("enabled"), "info");
+            ctx.ui.setStatus("read-delegator", msg("status_active"));
+        },
+    });
+    pi.registerCommand("read-delegator-off", {
+        description: "Disable read delegation",
+        handler: async (_args, ctx) => {
+            config.enabled = false;
+            saveConfig(config, { silent: true });
+            pi.setActiveTools(pi.getAllTools().map((t) => t.name));
+            ctx.ui.notify(msg("disabled"), "info");
+            ctx.ui.setStatus("read-delegator", msg("status_off"));
+        },
+    });
+    pi.registerCommand("read-delegator-model", {
+        description: "Set or view the reader model",
+        handler: async (args, ctx) => {
+            const modelArg = args?.trim() ?? "";
+            if (!modelArg) {
+                // Interactive picker via available models
+                const picked = await pickReaderModel(config, ctx);
+                if (picked === undefined) {
+                }
+                return;
+            }
+            config.reader_model = modelArg;
+            saveConfig(config, { silent: true });
+            syncReaderTemplate(modelArg);
+            ctx.ui.notify("✅ Reader model set to: " + modelArg, "info");
+        },
+    });
+    // 5. Background: sync reader.md template from config
+    syncReaderTemplate(config.reader_model);
+}
+//# sourceMappingURL=index.js.map

package/{reader-manager.d.ts → dist/reader-manager.d.ts}

@@ -9,7 +9,32 @@
  */
 import type { ReadDelegatorConfig } from "./config";
 import type { ExtensionAgent } from "./tool-blocker";
-/** Progress callback for dependency installation. */
+export declare class SessionFileCache {
+    private files;
+    private readRanges;
+    /** Cache a file's content with a hash for change detection. */
+    set(path: string, content: string): void;
+    get(path: string): string | undefined;
+    has(path: string): boolean;
+    getHash(path: string): string | undefined;
+    /** Record that a specific line range of a path has been read. */
+    markReadRange(path: string, from: number, to: number): void;
+    getReadRanges(path: string): Array<[number, number]>;
+    /** Compute gaps (unread line ranges) given total line count. */
+    getUnreadRanges(path: string, totalLines: number): Array<[number, number]>;
+    /** Return cache statistics for the status command. */
+    stats(): {
+        files: number;
+        sizeKB: number;
+        ranges: number;
+    };
+    clear(): void;
+}
+/** Singleton cache instance shared across the extension session. */
+export declare const sessionCache: SessionFileCache;
+/**
+ * Progress callback for dependency installation.
+ */
 export type InstallProgress = "installing" | "done" | "failed";
 export interface AgentWithSubagent extends ExtensionAgent {
     /** Call a subagent by name with a task string. Returns the subagent's response. */

package/{reader-manager.js → dist/reader-manager.js}

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * reader-manager.ts — Reader subagent lifecycle and error handling
  *
@@ -8,53 +7,86 @@
  *  - 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]; } };
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { exec } from "child_process";
+import { rawLog, rawWarn, rawError } from "./ui";
+export class SessionFileCache {
+    files = new Map();
+    readRanges = new Map();
+    /** Cache a file's content with a hash for change detection. */
+    set(path, content) {
+        this.files.set(path, {
+            content,
+            hash: simpleHash(content),
+            timestamp: Date.now(),
+            sizeBytes: Buffer.byteLength(content, "utf-8"),
+        });
+    }
+    get(path) {
+        return this.files.get(path)?.content;
+    }
+    has(path) {
+        return this.files.has(path);
+    }
+    getHash(path) {
+        return this.files.get(path)?.hash;
+    }
+    /** Record that a specific line range of a path has been read. */
+    markReadRange(path, from, to) {
+        const existing = this.readRanges.get(path) ?? [];
+        existing.push([from, to]);
+        this.readRanges.set(path, existing);
+    }
+    getReadRanges(path) {
+        return this.readRanges.get(path) ?? [];
+    }
+    /** Compute gaps (unread line ranges) given total line count. */
+    getUnreadRanges(path, totalLines) {
+        const read = this.readRanges.get(path);
+        if (!read || read.length === 0)
+            return [[1, totalLines]];
+        const sorted = [...read].sort((a, b) => a[0] - b[0]);
+        const gaps = [];
+        let pos = 1;
+        for (const [from, to] of sorted) {
+            if (from > pos)
+                gaps.push([pos, from - 1]);
+            pos = Math.max(pos, to + 1);
+        }
+        if (pos <= totalLines)
+            gaps.push([pos, totalLines]);
+        return gaps;
     }
-    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 cache statistics for the status command. */
+    stats() {
+        let totalSize = 0;
+        for (const entry of this.files.values())
+            totalSize += entry.sizeBytes;
+        return {
+            files: this.files.size,
+            sizeKB: Math.round(totalSize / 1024),
+            ranges: this.readRanges.size,
         };
-        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.isSubagentsInstalled = isSubagentsInstalled;
-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");
-const ui_1 = require("./ui");
+    }
+    clear() {
+        this.files.clear();
+        this.readRanges.clear();
+    }
+}
+/** Singleton cache instance shared across the extension session. */
+export const sessionCache = new SessionFileCache();
+/** Simple non-cryptographic hash for cache invalidation. */
+function simpleHash(str) {
+    let h = 0;
+    for (let i = 0; i < str.length; i++) {
+        h = (Math.imul(31, h) + str.charCodeAt(i)) | 0;
+    }
+    return h.toString(36);
+}
 /** Error thrown when the Reader subagent fails. */
-class ReaderError extends Error {
+export class ReaderError extends Error {
     originalError;
     constructor(message, originalError) {
         super(message);
@@ -62,7 +94,6 @@ class ReaderError extends Error {
         this.name = "ReaderError";
     }
 }
-exports.ReaderError = ReaderError;
 // ---------------------------------------------------------------------------
 // Paths
 // ---------------------------------------------------------------------------
@@ -91,43 +122,102 @@ function piSubagentsDir() {
 function piSubagentsPackageJson() {
     return path.join(piSubagentsDir(), "package.json");
 }
-async function checkDependencies(prompt, onProgress) {
+function piSettingsPath() {
+    return path.join(os.homedir(), ".pi", "agent", "settings.json");
+}
+/**
+ * Register pi-subagents in Pi's package list (settings.json).
+ *
+ * npm install puts the package on disk, but Pi's `pi list` command reads
+ * from settings.json's `packages` array. Without this step, the user
+ * won't see pi-subagents in their package list.
+ */
+function registerPiSubagentsPackage() {
+    try {
+        const settingsPath = piSettingsPath();
+        let settings = {};
+        if (fs.existsSync(settingsPath)) {
+            const raw = fs.readFileSync(settingsPath, "utf-8");
+            settings = JSON.parse(raw);
+        }
+        const packages = Array.isArray(settings.packages)
+            ? [...settings.packages]
+            : [];
+        const pkgName = "npm:pi-subagents";
+        if (!packages.includes(pkgName)) {
+            packages.push(pkgName);
+            settings.packages = packages;
+            // Atomic write: write to temp file then rename to avoid
+            // corruption from concurrent writes by other extensions.
+            const tmpPath = settingsPath + ".tmp";
+            fs.writeFileSync(tmpPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+            fs.renameSync(tmpPath, settingsPath);
+            rawLog("✅ Registered pi-subagents in settings.json package list.");
+        }
+    }
+    catch (err) {
+        rawWarn("⚠️ Failed to register pi-subagents in settings.json: " + String(err));
+    }
+}
+/**
+ * Async wrapper around child_process.exec.
+ * Returns stdout/stderr and rejects on non-zero exit or timeout.
+ */
+function execAsync(command, options = {}) {
+    return new Promise((resolve, reject) => {
+        const child = exec(command, { cwd: options.cwd, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+            if (err) {
+                reject(Object.assign(err, { stdout, stderr }));
+            }
+            else {
+                resolve({ stdout, stderr });
+            }
+        });
+        if (options.timeout && options.timeout > 0) {
+            setTimeout(() => {
+                child.kill();
+                reject(new Error(`Command timed out after ${options.timeout}ms`));
+            }, options.timeout);
+        }
+    });
+}
+export async function checkDependencies(prompt, onProgress) {
     // Already installed — nothing to do
     if (fs.existsSync(piSubagentsPackageJson())) {
+        registerPiSubagentsPackage();
         return true;
     }
-    (0, ui_1.rawWarn)("⚠️ pi-subagents is not installed.");
+    rawWarn("⚠️ 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") {
-        (0, ui_1.rawError)("❌ Cannot proceed without pi-subagents. Extension disabled.");
+        rawError("❌ Cannot proceed without pi-subagents. Extension disabled.");
         return false;
     }
     // Attempt installation
     const piNpmDir = path.join(os.homedir(), ".pi", "agent", "npm");
-    (0, ui_1.rawLog)("📦 Installing pi-subagents to " + piNpmDir + "…");
+    rawLog("📦 Installing pi-subagents to " + piNpmDir + "…");
     onProgress?.("installing");
     try {
-        (0, child_process_1.execSync)(`npm install --prefix "${piNpmDir}" pi-subagents`, {
-            stdio: "pipe",
-            timeout: 60_000,
-            encoding: "utf-8",
+        await execAsync(`npm install --prefix "${piNpmDir}" pi-subagents`, {
+            timeout: 120_000,
         });
-        (0, ui_1.rawLog)("✅ pi-subagents installed via npm.");
+        rawLog("✅ pi-subagents installed via npm.");
+        registerPiSubagentsPackage();
         onProgress?.("done");
     }
     catch (firstErr) {
         onProgress?.("failed");
-        (0, ui_1.rawError)("⚠️ npm install failed: " +
+        rawError("⚠️ npm install failed: " +
             (firstErr instanceof Error ? firstErr.message : String(firstErr)));
-        (0, ui_1.rawError)("❌ Cannot proceed without pi-subagents. Extension disabled.");
+        rawError("❌ Cannot proceed without pi-subagents. Extension disabled.");
         return false;
     }
     // Verify installation took effect
     if (fs.existsSync(piSubagentsPackageJson())) {
         return true;
     }
-    (0, ui_1.rawError)("❌ pi-subagents installed but cannot be found at " +
+    rawError("❌ pi-subagents installed but cannot be found at " +
         piSubagentsDir() +
         ". Restart Pi and try again.");
     return false;
@@ -135,7 +225,7 @@ async function checkDependencies(prompt, onProgress) {
 /**
  * Quick synchronous check: does pi-subagents exist on disk?
  */
-function isSubagentsInstalled() {
+export function isSubagentsInstalled() {
     return fs.existsSync(piSubagentsPackageJson());
 }
 // ---------------------------------------------------------------------------
@@ -147,26 +237,26 @@ function isSubagentsInstalled() {
  *
  * @returns true if the template exists after this call
  */
-function ensureReaderTemplate() {
+export 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)) {
-        (0, ui_1.rawWarn)("⚠️ Bundled reader template not found at: " + bundledPath);
-        (0, ui_1.rawWarn)("Please create ~/.pi/agent/agents/reader.md manually.");
+        rawWarn("⚠️ Bundled reader template not found at: " + bundledPath);
+        rawWarn("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");
-        (0, ui_1.rawLog)(`✅ Created reader subagent template: ${READER_TEMPLATE_PATH}`);
+        rawLog(`✅ Created reader subagent template: ${READER_TEMPLATE_PATH}`);
         return true;
     }
     catch (err) {
-        (0, ui_1.rawError)("⚠️ Failed to create reader template: " + String(err));
+        rawError("⚠️ Failed to create reader template: " + String(err));
         return false;
     }
 }
@@ -183,7 +273,7 @@ function ensureReaderTemplate() {
  * @returns       The Reader's response text
  * @throws        ReaderError on timeout, failure, or empty response
  */
-async function callReader(agent, config, task, timeoutMs = 30_000) {
+export async function callReader(agent, config, task, timeoutMs = 30_000) {
     const result = await withTimeout(agent.callSubagent({
         name: config.reader_subagent_name,
         task,
@@ -213,21 +303,21 @@ async function callReader(agent, config, task, timeoutMs = 30_000) {
  * @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) {
+export async function handleReaderError(agent, config, blockedTools, error, task, prompt) {
     const errMsg = error instanceof Error ? error.message : String(error);
-    (0, ui_1.rawError)(`❌ Reader failed: ${errMsg}`);
+    rawError(`❌ 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
-        (0, ui_1.rawLog)("🔄 Retrying Reader…");
+        rawLog("🔄 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.
-        (0, ui_1.rawLog)("🔓 Allowing main model to read once…");
+        rawLog("🔓 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