@phren/agent 0.0.1 → 0.0.3

package/dist/providers/resolve.js

@@ -3,36 +3,45 @@ import { AnthropicProvider } from "./anthropic.js";
 import { OllamaProvider } from "./ollama.js";
 import { CodexProvider } from "./codex.js";
 import { hasCodexToken } from "./codex-auth.js";
-export function resolveProvider(overrideProvider, overrideModel) {
+import { lookupMaxOutputTokens } from "../cost.js";
+export function resolveProvider(overrideProvider, overrideModel, overrideMaxOutput) {
     const explicit = overrideProvider ?? process.env.PHREN_AGENT_PROVIDER;
+    // Resolve max output tokens: CLI override > model lookup > default 8192
+    const resolveLimit = (model) => overrideMaxOutput ?? lookupMaxOutputTokens(model);
     if (explicit === "openrouter" || (!explicit && process.env.OPENROUTER_API_KEY)) {
         const key = process.env.OPENROUTER_API_KEY;
         if (!key)
             throw new Error("OPENROUTER_API_KEY is required for OpenRouter provider.");
-        return new OpenRouterProvider(key, overrideModel);
+        const model = overrideModel ?? "anthropic/claude-sonnet-4-20250514";
+        return new OpenRouterProvider(key, overrideModel, undefined, resolveLimit(model));
     }
     if (explicit === "anthropic" || (!explicit && process.env.ANTHROPIC_API_KEY)) {
         const key = process.env.ANTHROPIC_API_KEY;
         if (!key)
             throw new Error("ANTHROPIC_API_KEY is required for Anthropic provider.");
-        return new AnthropicProvider(key, overrideModel);
+        const model = overrideModel ?? "claude-sonnet-4-20250514";
+        return new AnthropicProvider(key, overrideModel, resolveLimit(model));
     }
     if (explicit === "openai" || (!explicit && process.env.OPENAI_API_KEY)) {
         const key = process.env.OPENAI_API_KEY;
         if (!key)
             throw new Error("OPENAI_API_KEY is required for OpenAI provider.");
-        return new OpenAiProvider(key, overrideModel);
+        const model = overrideModel ?? "gpt-4o";
+        return new OpenAiProvider(key, overrideModel, undefined, resolveLimit(model));
     }
     // Codex: uses your ChatGPT subscription directly — no API key, no middleman
     if (explicit === "codex" || (!explicit && hasCodexToken())) {
-        return new CodexProvider(overrideModel);
+        const model = overrideModel ?? "gpt-5.2-codex";
+        return new CodexProvider(overrideModel, resolveLimit(model));
     }
     if (explicit === "ollama" || (!explicit && process.env.PHREN_OLLAMA_URL && process.env.PHREN_OLLAMA_URL !== "off")) {
-        return new OllamaProvider(overrideModel, process.env.PHREN_OLLAMA_URL);
+        const model = overrideModel ?? "qwen2.5-coder:14b";
+        return new OllamaProvider(overrideModel, process.env.PHREN_OLLAMA_URL, resolveLimit(model));
     }
     // Last resort: try Ollama at default URL
     if (!explicit) {
-        return new OllamaProvider(overrideModel);
+        const model = overrideModel ?? "qwen2.5-coder:14b";
+        return new OllamaProvider(overrideModel, undefined, resolveLimit(model));
     }
     throw new Error(`Unknown provider "${explicit}". Supported: openrouter, anthropic, openai, codex, ollama.\n` +
         "Set one of: OPENROUTER_API_KEY, ANTHROPIC_API_KEY, OPENAI_API_KEY, or run 'phren-agent auth login' for Codex.");

package/dist/repl.js

@@ -5,9 +5,9 @@ import * as path from "node:path";
 import * as os from "node:os";
 import { createSession, runTurn } from "./agent-loop.js";
 import { handleCommand } from "./commands.js";
+import { loadInputMode, saveInputMode, savePermissionMode } from "./settings.js";
 const HISTORY_DIR = path.join(os.homedir(), ".phren-agent");
 const HISTORY_FILE = path.join(HISTORY_DIR, "repl-history.txt");
-const SETTINGS_FILE = path.join(HISTORY_DIR, "settings.json");
 const MAX_HISTORY = 500;
 const CYAN = "\x1b[36m";
 const RED = "\x1b[31m";
@@ -30,41 +30,6 @@ function saveHistory(lines) {
     }
     catch { /* ignore */ }
 }
-function loadInputMode() {
-    try {
-        const data = JSON.parse(fs.readFileSync(SETTINGS_FILE, "utf-8"));
-        if (data.inputMode === "queue")
-            return "queue";
-    }
-    catch { /* ignore */ }
-    return "steering";
-}
-function saveInputMode(mode) {
-    try {
-        fs.mkdirSync(HISTORY_DIR, { recursive: true });
-        let data = {};
-        try {
-            data = JSON.parse(fs.readFileSync(SETTINGS_FILE, "utf-8"));
-        }
-        catch { /* fresh */ }
-        data.inputMode = mode;
-        fs.writeFileSync(SETTINGS_FILE, JSON.stringify(data, null, 2) + "\n");
-    }
-    catch { /* ignore */ }
-}
-function savePermissionMode(mode) {
-    try {
-        fs.mkdirSync(HISTORY_DIR, { recursive: true });
-        let data = {};
-        try {
-            data = JSON.parse(fs.readFileSync(SETTINGS_FILE, "utf-8"));
-        }
-        catch { /* fresh */ }
-        data.permissionMode = mode;
-        fs.writeFileSync(SETTINGS_FILE, JSON.stringify(data, null, 2) + "\n");
-    }
-    catch { /* ignore */ }
-}
 export async function startRepl(config) {
     const contextLimit = config.provider.contextWindow ?? 200_000;
     const session = createSession(contextLimit);

package/dist/settings.js

@@ -0,0 +1,42 @@
+/** Shared settings persistence for agent TUI and REPL. */
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+export const SETTINGS_FILE = path.join(os.homedir(), ".phren-agent", "settings.json");
+export function loadInputMode() {
+    try {
+        const data = JSON.parse(fs.readFileSync(SETTINGS_FILE, "utf-8"));
+        if (data.inputMode === "queue")
+            return "queue";
+    }
+    catch { }
+    return "steering";
+}
+export function saveInputMode(mode) {
+    try {
+        const dir = path.dirname(SETTINGS_FILE);
+        fs.mkdirSync(dir, { recursive: true });
+        let data = {};
+        try {
+            data = JSON.parse(fs.readFileSync(SETTINGS_FILE, "utf-8"));
+        }
+        catch { }
+        data.inputMode = mode;
+        fs.writeFileSync(SETTINGS_FILE, JSON.stringify(data, null, 2) + "\n");
+    }
+    catch { }
+}
+export function savePermissionMode(mode) {
+    try {
+        const dir = path.dirname(SETTINGS_FILE);
+        fs.mkdirSync(dir, { recursive: true });
+        let data = {};
+        try {
+            data = JSON.parse(fs.readFileSync(SETTINGS_FILE, "utf-8"));
+        }
+        catch { }
+        data.permissionMode = mode;
+        fs.writeFileSync(SETTINGS_FILE, JSON.stringify(data, null, 2) + "\n");
+    }
+    catch { }
+}

package/dist/tools/edit-file.js

@@ -1,5 +1,7 @@
 import * as fs from "fs";
+import * as path from "path";
 import { encodeDiffPayload } from "../multi/diff-renderer.js";
+import { checkSensitivePath, validatePath } from "../permissions/sandbox.js";
 export const editFileTool = {
     name: "edit_file",
     description: "Edit a file by replacing an exact string match. Preferred over write_file for modifying existing files — only changes what's needed. The old_string must appear exactly once; include surrounding lines for uniqueness if needed.",
@@ -16,6 +18,17 @@ export const editFileTool = {
         const filePath = input.path;
         const oldStr = input.old_string;
         const newStr = input.new_string;
+        // Defense-in-depth: sensitive path check
+        const resolved = path.resolve(filePath);
+        const sensitive = checkSensitivePath(resolved);
+        if (sensitive.sensitive) {
+            return { output: `Access denied: ${sensitive.reason}`, is_error: true };
+        }
+        // Defense-in-depth: sandbox check
+        const sandboxResult = validatePath(filePath, process.cwd(), []);
+        if (!sandboxResult.ok) {
+            return { output: `Path outside sandbox: ${sandboxResult.error}`, is_error: true };
+        }
         if (!fs.existsSync(filePath))
             return { output: `File not found: ${filePath}`, is_error: true };
         const oldContent = fs.readFileSync(filePath, "utf-8");

package/dist/tools/git.js

@@ -1,4 +1,5 @@
 import { execFileSync } from "child_process";
+import { validatePath } from "../permissions/sandbox.js";
 function git(args, cwd) {
     return execFileSync("git", args, {
         cwd,
@@ -20,6 +21,10 @@ export const gitStatusTool = {
     },
     async execute(input) {
         const cwd = input.cwd || process.cwd();
+        const cwdCheck = validatePath(cwd, process.cwd(), []);
+        if (!cwdCheck.ok) {
+            return { output: `Git cwd outside sandbox: ${cwdCheck.error}`, is_error: true };
+        }
         try {
             const output = git(["status", "--short"], cwd);
             return { output: output || "(working tree clean)" };
@@ -43,6 +48,10 @@ export const gitDiffTool = {
     },
     async execute(input) {
         const cwd = input.cwd || process.cwd();
+        const cwdCheck = validatePath(cwd, process.cwd(), []);
+        if (!cwdCheck.ok) {
+            return { output: `Git cwd outside sandbox: ${cwdCheck.error}`, is_error: true };
+        }
         const args = ["diff"];
         if (input.cached)
             args.push("--cached");
@@ -75,6 +84,10 @@ export const gitCommitTool = {
     },
     async execute(input) {
         const cwd = input.cwd || process.cwd();
+        const cwdCheck = validatePath(cwd, process.cwd(), []);
+        if (!cwdCheck.ok) {
+            return { output: `Git cwd outside sandbox: ${cwdCheck.error}`, is_error: true };
+        }
         const message = input.message;
         const files = input.files || [];
         try {

package/dist/tools/write-file.js

@@ -1,6 +1,7 @@
 import * as fs from "fs";
 import * as path from "path";
 import { encodeDiffPayload } from "../multi/diff-renderer.js";
+import { checkSensitivePath, validatePath } from "../permissions/sandbox.js";
 export const writeFileTool = {
     name: "write_file",
     description: "Write content to a file, creating parent directories as needed. Use for new files only — prefer edit_file for modifying existing files. Overwrites existing content entirely.",
@@ -15,6 +16,17 @@ export const writeFileTool = {
     async execute(input) {
         const filePath = input.path;
         const content = input.content;
+        // Defense-in-depth: sensitive path check
+        const resolved = path.resolve(filePath);
+        const sensitive = checkSensitivePath(resolved);
+        if (sensitive.sensitive) {
+            return { output: `Access denied: ${sensitive.reason}`, is_error: true };
+        }
+        // Defense-in-depth: sandbox check
+        const sandboxResult = validatePath(filePath, process.cwd(), []);
+        if (!sandboxResult.ok) {
+            return { output: `Path outside sandbox: ${sandboxResult.error}`, is_error: true };
+        }
         const oldContent = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf-8") : "";
         fs.mkdirSync(path.dirname(filePath), { recursive: true });
         fs.writeFileSync(filePath, content);

package/dist/tui.js

@@ -8,21 +8,25 @@ import { createSession, runTurn } from "./agent-loop.js";
 import { handleCommand } from "./commands.js";
 import { renderMarkdown } from "./multi/markdown.js";
 import { decodeDiffPayload, renderInlineDiff, DIFF_MARKER } from "./multi/diff-renderer.js";
-import * as fs from "fs";
-import * as path from "path";
 import * as os from "os";
+import { loadInputMode, saveInputMode, savePermissionMode } from "./settings.js";
 // ── ANSI helpers ─────────────────────────────────────────────────────────────
 const ESC = "\x1b[";
 const s = {
     reset: `${ESC}0m`,
     bold: (t) => `${ESC}1m${t}${ESC}0m`,
     dim: (t) => `${ESC}2m${t}${ESC}0m`,
+    italic: (t) => `${ESC}3m${t}${ESC}0m`,
     cyan: (t) => `${ESC}36m${t}${ESC}0m`,
     green: (t) => `${ESC}32m${t}${ESC}0m`,
     yellow: (t) => `${ESC}33m${t}${ESC}0m`,
     red: (t) => `${ESC}31m${t}${ESC}0m`,
+    blue: (t) => `${ESC}34m${t}${ESC}0m`,
+    magenta: (t) => `${ESC}35m${t}${ESC}0m`,
     gray: (t) => `${ESC}90m${t}${ESC}0m`,
     invert: (t) => `${ESC}7m${t}${ESC}0m`,
+    // Gradient-style brand text
+    brand: (t) => `${ESC}1;35m${t}${ESC}0m`,
 };
 function cols() {
     return process.stdout.columns || 80;
@@ -38,23 +42,28 @@ const PERMISSION_LABELS = {
     "auto-confirm": "auto",
     "full-auto": "full-auto",
 };
-function formatPermissionMode(mode) {
-    const label = PERMISSION_LABELS[mode];
-    switch (mode) {
-        case "suggest": return s.cyan(`[${label}]`);
-        case "auto-confirm": return s.green(`[${label}]`);
-        case "full-auto": return s.yellow(`[${label}]`);
-    }
-}
 // ── Status bar ───────────────────────────────────────────────────────────────
 function renderStatusBar(provider, project, turns, cost, permMode, agentCount) {
-    const modeStr = permMode ? ` ${PERMISSION_LABELS[permMode]}` : "";
-    const agentTag = agentCount && agentCount > 0 ? ` ${s.dim(`A${agentCount}`)}` : "";
-    const left = ` ${s.bold("phren-agent")} ${s.dim("·")} ${provider}${project ? ` ${s.dim("·")} ${project}` : ""}`;
-    const right = `${modeStr}${agentTag} ${cost ? cost + " " : ""}${s.dim(`T${turns}`)} `;
+    const modeLabel = permMode ? PERMISSION_LABELS[permMode] : "";
+    const agentTag = agentCount && agentCount > 0 ? ` A${agentCount}` : "";
+    // Left: brand + provider + project
+    const parts = [" ◆ phren", provider];
+    if (project)
+        parts.push(project);
+    const left = parts.join(" · ");
+    // Right: mode + agents + cost + turns
+    const rightParts = [];
+    if (modeLabel)
+        rightParts.push(modeLabel);
+    if (agentTag)
+        rightParts.push(agentTag.trim());
+    if (cost)
+        rightParts.push(cost);
+    rightParts.push(`T${turns}`);
+    const right = rightParts.join("  ") + " ";
     const w = cols();
-    const pad = Math.max(0, w - stripAnsi(left).length - stripAnsi(right).length);
-    return s.invert(stripAnsi(left) + " ".repeat(pad) + stripAnsi(right));
+    const pad = Math.max(0, w - left.length - right.length);
+    return s.invert(left + " ".repeat(pad) + right);
 }
 function stripAnsi(t) {
     return t.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "");
@@ -70,17 +79,34 @@ function formatDuration(ms) {
     const secs = Math.round((ms % 60_000) / 1000);
     return `${mins}m ${secs}s`;
 }
+function formatToolInput(name, input) {
+    // Show the most relevant input field for each tool type
+    switch (name) {
+        case "read_file": return input.file_path ?? "";
+        case "write_file": return input.file_path ?? "";
+        case "edit_file": return input.file_path ?? "";
+        case "shell": return (input.command ?? "").slice(0, 60);
+        case "glob": return input.pattern ?? "";
+        case "grep": return `/${input.pattern ?? ""}/ ${input.path ?? ""}`;
+        case "git_commit": return (input.message ?? "").slice(0, 50);
+        case "phren_search": return input.query ?? "";
+        case "phren_add_finding": return (input.finding ?? "").slice(0, 50);
+        default: return JSON.stringify(input).slice(0, 60);
+    }
+}
 function renderToolCall(name, input, output, isError, durationMs) {
-    const inputPreview = JSON.stringify(input).slice(0, 80);
+    const preview = formatToolInput(name, input);
     const dur = formatDuration(durationMs);
-    const icon = isError ? s.red("✗") : s.green("✓");
-    const header = s.dim(`  ${name}(${inputPreview})`) + `  ${icon} ${s.dim(dur)}`;
+    const icon = isError ? s.red("✗") : s.green("→");
+    const header = `  ${icon} ${s.bold(name)} ${s.gray(preview)}  ${s.dim(dur)}`;
     // Compact: show first 3 lines only, with overflow count
     const allLines = output.split("\n").filter(Boolean);
+    if (allLines.length === 0)
+        return header;
     const shown = allLines.slice(0, COMPACT_LINES);
-    const body = shown.map((l) => s.dim(`  │ ${l.slice(0, cols() - 6)}`)).join("\n");
+    const body = shown.map((l) => s.dim(`    ${l.slice(0, cols() - 6)}`)).join("\n");
     const overflow = allLines.length - COMPACT_LINES;
-    const more = overflow > 0 ? `\n${s.dim(`  │ [+${overflow} lines]`)}` : "";
+    const more = overflow > 0 ? `\n${s.dim(`    ... +${overflow} lines`)}` : "";
     return `${header}\n${body}${more}`;
 }
 // ── Menu mode helpers ────────────────────────────────────────────────────────
@@ -155,8 +181,10 @@ export async function startTui(config, spawner) {
     }
     // Print prompt
     function prompt() {
-        const modeTag = inputMode === "steering" ? s.dim("[steer]") : s.dim("[queue]");
-        w.write(`\n${s.cyan("phren>")} ${modeTag} `);
+        const mode = config.registry.permissionConfig.mode;
+        const modeIcon = mode === "full-auto" ? "●" : mode === "auto-confirm" ? "◐" : "○";
+        const modeColor = mode === "full-auto" ? s.yellow : mode === "auto-confirm" ? s.green : s.cyan;
+        w.write(`\n${modeColor(modeIcon)} ${s.dim("▸")} `);
     }
     // Terminal cleanup: restore state on exit
     function cleanupTerminal() {
@@ -175,7 +203,45 @@ export async function startTui(config, spawner) {
         w.write(`${ESC}1;1H`); // move to top
         statusBar();
         w.write(`${ESC}2;1H`); // move below status bar
-        w.write(s.dim("phren-agent TUI. Tab: memory browser  Shift+Tab: permissions  /help: commands  Ctrl+D: exit\n"));
+        // Startup banner
+        const project = config.phrenCtx?.project;
+        const cwd = process.cwd().replace(os.homedir(), "~");
+        const permMode = config.registry.permissionConfig.mode;
+        const modeColor = permMode === "full-auto" ? s.yellow : permMode === "auto-confirm" ? s.green : s.cyan;
+        // Try to show the phren character art alongside info
+        let artLines = [];
+        try {
+            const { PHREN_ART } = await import("@phren/cli/phren-art");
+            artLines = PHREN_ART.filter((l) => l.trim());
+        }
+        catch { /* art not available */ }
+        if (artLines.length > 0) {
+            // Art on left, info on right
+            const info = [
+                `${s.brand("◆ phren agent")}  ${s.dim("v0.0.1")}`,
+                `${s.dim(config.provider.name)}${project ? s.dim(` · ${project}`) : ""}`,
+                `${s.dim(cwd)}`,
+                ``,
+                `${modeColor(`${permMode === "full-auto" ? "●" : permMode === "auto-confirm" ? "◐" : "○"} ${permMode}`)} ${s.dim("permissions (shift+tab to cycle)")}`,
+                ``,
+                `${s.dim("Tab")} memory  ${s.dim("Shift+Tab")} perms  ${s.dim("/help")} cmds  ${s.dim("Ctrl+D")} exit`,
+            ];
+            const maxArtWidth = 26; // phren art is ~24 chars wide
+            for (let i = 0; i < Math.max(artLines.length, info.length); i++) {
+                const artPart = i < artLines.length ? artLines[i] : "";
+                const infoPart = i < info.length ? info[i] : "";
+                const artPadded = artPart + " ".repeat(Math.max(0, maxArtWidth - stripAnsi(artPart).length));
+                w.write(`${artPadded}${infoPart}\n`);
+            }
+        }
+        else {
+            // Fallback: text-only banner
+            w.write(`\n  ${s.brand("◆ phren agent")}  ${s.dim("v0.0.1")}\n`);
+            w.write(`  ${s.dim(config.provider.name)}${project ? s.dim(` · ${project}`) : ""}  ${s.dim(cwd)}\n`);
+            w.write(`  ${modeColor(`${permMode === "full-auto" ? "●" : permMode === "auto-confirm" ? "◐" : "○"} ${permMode}`)} ${s.dim("permissions (shift+tab to cycle)")}\n\n`);
+            w.write(`  ${s.dim("Tab")} memory  ${s.dim("Shift+Tab")} perms  ${s.dim("/help")} cmds  ${s.dim("Ctrl+D")} exit\n\n`);
+        }
+        w.write("\n");
     }
     // Raw stdin for steering
     if (process.stdin.isTTY) {
@@ -255,7 +321,9 @@ export async function startTui(config, spawner) {
             const next = nextPermissionMode(current);
             config.registry.setPermissions({ ...config.registry.permissionConfig, mode: next });
             savePermissionMode(next);
-            w.write(s.yellow(`  [mode: ${next}]\n`));
+            const modeColor = next === "full-auto" ? s.yellow : next === "auto-confirm" ? s.green : s.cyan;
+            const modeIcon = next === "full-auto" ? "●" : next === "auto-confirm" ? "◐" : "○";
+            w.write(`  ${modeColor(`${modeIcon} ${next}`)}\n`);
             statusBar();
             if (!running)
                 prompt();
@@ -360,9 +428,11 @@ export async function startTui(config, spawner) {
             if (!text.endsWith("\n"))
                 w.write("\n");
         },
-        onToolStart: (name, _input, _count) => {
+        onToolStart: (name, input, count) => {
             flushTextBuffer();
-            w.write(s.dim(`  ⠋ ${name}...\r`));
+            const preview = formatToolInput(name, input);
+            const countLabel = count > 1 ? s.dim(` (${count} tools)`) : "";
+            w.write(`${ESC}2K  ${s.dim("◌")} ${s.gray(name)} ${s.dim(preview)}${countLabel}\r`);
         },
         onToolEnd: (name, input, output, isError, dur) => {
             w.write(`${ESC}2K\r`);
@@ -386,7 +456,7 @@ export async function startTui(config, spawner) {
     };
     async function runAgentTurn(userInput) {
         running = true;
-        w.write(s.dim("  ⠋ Thinking...\r"));
+        w.write(`${ESC}2K  ${s.dim("◌ thinking...")}\r`);
         try {
             await runTurn(userInput, session, config, tuiHooks);
             statusBar();
@@ -410,42 +480,3 @@ export async function startTui(config, spawner) {
     prompt();
     return done;
 }
-// ── Settings persistence ─────────────────────────────────────────────────────
-const SETTINGS_FILE = path.join(os.homedir(), ".phren-agent", "settings.json");
-function loadInputMode() {
-    try {
-        const data = JSON.parse(fs.readFileSync(SETTINGS_FILE, "utf-8"));
-        if (data.inputMode === "queue")
-            return "queue";
-    }
-    catch { }
-    return "steering";
-}
-function saveInputMode(mode) {
-    try {
-        const dir = path.dirname(SETTINGS_FILE);
-        fs.mkdirSync(dir, { recursive: true });
-        let data = {};
-        try {
-            data = JSON.parse(fs.readFileSync(SETTINGS_FILE, "utf-8"));
-        }
-        catch { }
-        data.inputMode = mode;
-        fs.writeFileSync(SETTINGS_FILE, JSON.stringify(data, null, 2) + "\n");
-    }
-    catch { }
-}
-function savePermissionMode(mode) {
-    try {
-        const dir = path.dirname(SETTINGS_FILE);
-        fs.mkdirSync(dir, { recursive: true });
-        let data = {};
-        try {
-            data = JSON.parse(fs.readFileSync(SETTINGS_FILE, "utf-8"));
-        }
-        catch { }
-        data.permissionMode = mode;
-        fs.writeFileSync(SETTINGS_FILE, JSON.stringify(data, null, 2) + "\n");
-    }
-    catch { }
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phren/agent",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Coding agent with persistent memory — powered by phren",
   "type": "module",
   "bin": {
@@ -12,12 +12,8 @@
   "files": [
     "dist"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "test": "echo 'Run tests from repo root: pnpm -w test'"
-  },
   "dependencies": {
-    "@phren/cli": "workspace:*"
+    "@phren/cli": "0.0.58"
   },
   "engines": {
     "node": ">=20.0.0"
@@ -35,5 +31,9 @@
     "type": "git",
     "url": "git+https://github.com/alaarab/phren.git",
     "directory": "packages/agent"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "echo 'Run tests from repo root: pnpm -w test'"
   }
-}
+}

package/dist/multi/progress.js

@@ -1,32 +0,0 @@
-/**
- * Progress indicators for terminal output.
- */
-const FILLED = "█";
-const EMPTY = "░";
-const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-/** Render a progress bar: `[████░░░░] 50%` */
-export function renderProgressBar(current, total, width = 20) {
-    if (total <= 0)
-        return `[${"░".repeat(width)}] 0%`;
-    const pct = Math.min(1, Math.max(0, current / total));
-    const filled = Math.round(pct * width);
-    const empty = width - filled;
-    const percent = Math.round(pct * 100);
-    return `[${FILLED.repeat(filled)}${EMPTY.repeat(empty)}] ${percent}%`;
-}
-/** Get a braille spinner frame by index (wraps automatically). */
-export function renderSpinnerFrame(frame) {
-    return SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
-}
-/** Format elapsed time from a start timestamp: `2.1s` or `1m 30s`. */
-export function renderElapsed(startMs) {
-    const elapsed = Date.now() - startMs;
-    if (elapsed < 1000)
-        return `${elapsed}ms`;
-    const secs = elapsed / 1000;
-    if (secs < 60)
-        return `${secs.toFixed(1)}s`;
-    const mins = Math.floor(secs / 60);
-    const remSecs = Math.round(secs % 60);
-    return `${mins}m ${remSecs}s`;
-}