@phren/agent 0.1.2 → 0.1.4

package/dist/agent-loop.js

@@ -1,326 +1,7 @@
-import { createSpinner, formatTurnHeader, formatToolCall } from "./spinner.js";
-import { searchErrorRecovery } from "./memory/error-recovery.js";
-import { shouldPrune, pruneMessages } from "./context/pruner.js";
-import { withRetry } from "./providers/retry.js";
-import { createCaptureState, analyzeAndCapture } from "./memory/auto-capture.js";
-import { AntiPatternTracker } from "./memory/anti-patterns.js";
-import { createFlushConfig, checkFlushNeeded } from "./memory/context-flush.js";
-import { injectPlanPrompt, requestPlanApproval } from "./plan.js";
-import { detectLintCommand, detectTestCommand, runPostEditCheck } from "./tools/lint-test.js";
-import { createCheckpoint } from "./checkpoint.js";
-const MAX_TOOL_CONCURRENCY = 5;
-export function createSession(contextLimit) {
-    return {
-        messages: [],
-        turns: 0,
-        toolCalls: 0,
-        captureState: createCaptureState(),
-        antiPatterns: new AntiPatternTracker(),
-        flushConfig: createFlushConfig(contextLimit ?? 200_000),
-    };
-}
-/** Run tool blocks with concurrency limit. */
-async function runToolsConcurrently(blocks, registry) {
-    const results = [];
-    for (let i = 0; i < blocks.length; i += MAX_TOOL_CONCURRENCY) {
-        const batch = blocks.slice(i, i + MAX_TOOL_CONCURRENCY);
-        const batchResults = await Promise.all(batch.map(async (block) => {
-            const TOOL_TIMEOUT_MS = 120_000;
-            try {
-                const result = await Promise.race([
-                    registry.execute(block.name, block.input),
-                    new Promise((_, reject) => setTimeout(() => reject(new Error(`Tool '${block.name}' timed out after ${TOOL_TIMEOUT_MS / 1000}s`)), TOOL_TIMEOUT_MS)),
-                ]);
-                return { block, output: result.output, is_error: !!result.is_error };
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { block, output: msg, is_error: true };
-            }
-        }));
-        results.push(...batchResults);
-    }
-    return results;
-}
-/** Consume a chatStream into ContentBlock[] + stop_reason, streaming text via callback. */
-async function consumeStream(stream, costTracker, onTextDelta) {
-    const content = [];
-    let stop_reason = "end_turn";
-    let currentText = "";
-    // Map block index -> tool state for Anthropic-style index-based IDs
-    const toolsByIndex = new Map();
-    for await (const delta of stream) {
-        if (delta.type === "text_delta") {
-            (onTextDelta ?? process.stdout.write.bind(process.stdout))(delta.text);
-            currentText += delta.text;
-        }
-        else if (delta.type === "tool_use_start") {
-            // Flush accumulated text
-            if (currentText) {
-                content.push({ type: "text", text: currentText });
-                currentText = "";
-            }
-            toolsByIndex.set(delta.id, { id: delta.id, name: delta.name, jsonParts: [] });
-        }
-        else if (delta.type === "tool_use_delta") {
-            const tool = toolsByIndex.get(delta.id);
-            if (tool)
-                tool.jsonParts.push(delta.json);
-        }
-        else if (delta.type === "tool_use_end") {
-            const tool = toolsByIndex.get(delta.id);
-            if (tool) {
-                const jsonStr = tool.jsonParts.join("");
-                let input = {};
-                try {
-                    input = JSON.parse(jsonStr);
-                }
-                catch {
-                    process.stderr.write(`\x1b[33m[warning] Malformed tool_use JSON for ${tool.name} (${tool.id}), skipping block\x1b[0m\n`);
-                    continue;
-                }
-                content.push({ type: "tool_use", id: tool.id, name: tool.name, input });
-            }
-        }
-        else if (delta.type === "done") {
-            stop_reason = delta.stop_reason;
-            if (costTracker && delta.usage) {
-                costTracker.recordUsage(delta.usage.input_tokens, delta.usage.output_tokens);
-            }
-        }
-    }
-    // Flush remaining text
-    if (currentText) {
-        if (!currentText.endsWith("\n")) {
-            (onTextDelta ?? process.stdout.write.bind(process.stdout))("\n");
-        }
-        content.push({ type: "text", text: currentText });
-    }
-    return { content, stop_reason };
-}
-export async function runTurn(userInput, session, config, hooks) {
-    const { provider, registry, maxTurns, verbose, costTracker } = config;
-    let systemPrompt = config.systemPrompt;
-    const toolDefs = registry.getDefinitions();
-    const spinner = createSpinner();
-    const useStream = typeof provider.chatStream === "function";
-    const status = hooks?.onStatus ?? ((msg) => process.stderr.write(msg));
-    // Plan mode: modify system prompt for first turn
-    let planPending = config.plan && session.turns === 0;
-    if (planPending) {
-        systemPrompt = injectPlanPrompt(systemPrompt);
-    }
-    // Append user message
-    session.messages.push({ role: "user", content: userInput });
-    let turnToolCalls = 0;
-    const turnStart = session.turns;
-    while (session.turns - turnStart < maxTurns) {
-        // Budget check
-        if (costTracker?.isOverBudget()) {
-            status(`\x1b[33m[budget exceeded: ${costTracker.formatCost()}]\x1b[0m\n`);
-            break;
-        }
-        if (verbose && session.turns > turnStart) {
-            status(`\n${formatTurnHeader(session.turns + 1, turnToolCalls)}\n`);
-        }
-        // Check if context flush is needed (one-time per session) — must run before pruning
-        const contextLimit = provider.contextWindow ?? 200_000;
-        const flushPrompt = checkFlushNeeded(systemPrompt, session.messages, session.flushConfig);
-        if (flushPrompt) {
-            session.messages.push({ role: "user", content: flushPrompt });
-            if (verbose)
-                status("[context flush injected]\n");
-        }
-        // Prune context if approaching limit
-        if (shouldPrune(systemPrompt, session.messages, { contextLimit })) {
-            session.messages = pruneMessages(session.messages, { contextLimit, keepRecentTurns: 6 });
-            if (verbose)
-                status("[context pruned]\n");
-        }
-        // For plan mode first turn, pass empty tools so LLM can't call any
-        const turnTools = planPending ? [] : toolDefs;
-        let assistantContent;
-        let stopReason;
-        if (useStream) {
-            // Streaming path — retry the initial connection (before consuming deltas)
-            const stream = await withRetry(async () => provider.chatStream(systemPrompt, session.messages, turnTools), undefined, verbose);
-            const result = await consumeStream(stream, costTracker, hooks?.onTextDelta);
-            assistantContent = result.content;
-            stopReason = result.stop_reason;
-        }
-        else {
-            // Batch path
-            spinner.start("Thinking...");
-            const response = await withRetry(() => provider.chat(systemPrompt, session.messages, turnTools), undefined, verbose);
-            spinner.stop();
-            assistantContent = response.content;
-            stopReason = response.stop_reason;
-            // Track cost from batch response
-            if (costTracker && response.usage) {
-                costTracker.recordUsage(response.usage.input_tokens, response.usage.output_tokens);
-            }
-            // Print text blocks (streaming already prints inline)
-            for (const block of assistantContent) {
-                if (block.type === "text" && block.text) {
-                    if (hooks?.onTextBlock) {
-                        hooks.onTextBlock(block.text);
-                    }
-                    else {
-                        process.stdout.write(block.text);
-                        if (!block.text.endsWith("\n"))
-                            process.stdout.write("\n");
-                    }
-                }
-            }
-        }
-        session.messages.push({ role: "assistant", content: assistantContent });
-        session.turns++;
-        // Show turn cost
-        if (verbose && costTracker) {
-            status(`\x1b[2m  cost: ${costTracker.formatCost()}\x1b[0m\n`);
-        }
-        // Plan mode gate: after first response, ask for approval
-        if (planPending) {
-            planPending = false;
-            const { approved, feedback } = await requestPlanApproval();
-            if (!approved) {
-                // Always restore original system prompt on rejection to prevent plan prompt leaking
-                systemPrompt = config.systemPrompt;
-                const msg = feedback
-                    ? `The user rejected the plan with feedback: ${feedback}\nPlease revise your plan.`
-                    : "The user rejected the plan. Task aborted.";
-                if (feedback) {
-                    // Let the LLM revise — add feedback as user message and continue
-                    session.messages.push({ role: "user", content: msg });
-                    continue;
-                }
-                break;
-            }
-            // Approved — restore original system prompt and continue with tools enabled
-            systemPrompt = config.systemPrompt;
-            session.messages.push({ role: "user", content: "Plan approved. Proceed with execution." });
-            continue;
-        }
-        // If max_tokens, warn user and inject continuation prompt
-        if (stopReason === "max_tokens") {
-            status("\x1b[33m[response truncated: max_tokens reached, requesting continuation]\x1b[0m\n");
-            session.messages.push({ role: "user", content: "Your response was truncated due to length. Please continue where you left off." });
-            continue;
-        }
-        // If no tool use, we're done
-        if (stopReason !== "tool_use")
-            break;
-        // Execute tool calls with concurrency
-        const toolUseBlocks = assistantContent.filter((b) => b.type === "tool_use");
-        // Log all tool calls upfront
-        if (hooks?.onToolStart) {
-            for (const block of toolUseBlocks)
-                hooks.onToolStart(block.name, block.input, toolUseBlocks.length);
-        }
-        else {
-            for (const block of toolUseBlocks)
-                status(formatToolCall(block.name, block.input) + "\n");
-        }
-        if (!hooks?.onToolStart)
-            spinner.start(`Running ${toolUseBlocks.length} tool${toolUseBlocks.length > 1 ? "s" : ""}...`);
-        const execResults = await runToolsConcurrently(toolUseBlocks, registry);
-        if (!hooks?.onToolStart)
-            spinner.stop();
-        const toolResults = [];
-        for (const { block, output, is_error } of execResults) {
-            session.toolCalls++;
-            turnToolCalls++;
-            let finalOutput = output;
-            // Record for anti-pattern tracking
-            session.antiPatterns.recordAttempt(block.name, block.input, !is_error, output);
-            // Append phren recovery context on tool errors
-            if (is_error && config.phrenCtx) {
-                try {
-                    const recovery = await searchErrorRecovery(config.phrenCtx, output);
-                    if (recovery)
-                        finalOutput += recovery;
-                }
-                catch { /* best effort */ }
-                // Auto-capture error patterns
-                try {
-                    await analyzeAndCapture(config.phrenCtx, output, session.captureState);
-                }
-                catch { /* best effort */ }
-            }
-            if (hooks?.onToolEnd) {
-                hooks.onToolEnd(block.name, block.input, finalOutput, is_error, 0);
-            }
-            else if (verbose) {
-                const preview = finalOutput.slice(0, 200);
-                status(`\x1b[2m  ← ${is_error ? "ERROR: " : ""}${preview}${finalOutput.length > 200 ? "..." : ""}\x1b[0m\n`);
-            }
-            toolResults.push({
-                type: "tool_result",
-                tool_use_id: block.id,
-                content: finalOutput,
-                is_error,
-            });
-        }
-        // Post-edit lint/test check
-        const mutatingTools = new Set(["edit_file", "write_file"]);
-        const hasMutation = toolUseBlocks.some(b => mutatingTools.has(b.name));
-        if (hasMutation && config.lintTestConfig) {
-            const cwd = process.cwd();
-            const lintCmd = config.lintTestConfig.lintCmd ?? detectLintCommand(cwd);
-            const testCmd = config.lintTestConfig.testCmd ?? detectTestCommand(cwd);
-            const lintFailures = [];
-            for (const cmd of [lintCmd, testCmd].filter(Boolean)) {
-                const check = runPostEditCheck(cmd, cwd);
-                if (!check.passed) {
-                    if (verbose)
-                        status(`\x1b[33m[post-edit check failed: ${cmd}]\x1b[0m\n`);
-                    lintFailures.push(`Post-edit check failed (${cmd}):\n${check.output.slice(0, 2000)}`);
-                }
-            }
-            if (lintFailures.length > 0) {
-                // Inject as plain text in the tool results user message (not as a fabricated tool_result)
-                toolResults.push({
-                    type: "text",
-                    text: lintFailures.join("\n\n"),
-                });
-            }
-        }
-        // Create checkpoint before mutating tool results are committed to conversation
-        if (hasMutation) {
-            createCheckpoint(process.cwd(), `turn-${session.turns}`);
-        }
-        // Add tool results as a user message
-        session.messages.push({ role: "user", content: toolResults });
-        // Steering input injection (TUI mid-turn input)
-        const steer = hooks?.getSteeringInput?.();
-        if (steer) {
-            session.messages.push({ role: "user", content: steer });
-        }
-    }
-    // Extract text from the last assistant message in this turn
-    const lastAssistant = [...session.messages].reverse().find((m) => m.role === "assistant");
-    let text = "";
-    if (lastAssistant && Array.isArray(lastAssistant.content)) {
-        text = lastAssistant.content
-            .filter((b) => b.type === "text")
-            .map((b) => b.text)
-            .join("\n");
-    }
-    else if (lastAssistant && typeof lastAssistant.content === "string") {
-        text = lastAssistant.content;
-    }
-    return { text, turns: session.turns - turnStart, toolCalls: turnToolCalls };
-}
-/** One-shot agent run — thin wrapper around createSession + runTurn. */
-export async function runAgent(task, config) {
-    const contextLimit = config.provider.contextWindow ?? 200_000;
-    const session = createSession(contextLimit);
-    const result = await runTurn(task, session, config, config.hooks);
-    return {
-        finalText: result.text,
-        turns: result.turns,
-        toolCalls: result.toolCalls,
-        totalCost: config.costTracker?.formatCost(),
-        messages: session.messages,
-    };
-}
+/**
+ * Barrel re-export — the actual implementation lives in agent-loop/ directory.
+ * This file exists so all existing `from "./agent-loop.js"` imports continue working.
+ */
+export { createSession, } from "./agent-loop/types.js";
+export { consumeStream, runToolsConcurrently } from "./agent-loop/stream.js";
+export { runTurn, runAgent } from "./agent-loop/index.js";

package/dist/commands/info.js

@@ -0,0 +1,146 @@
+import { estimateMessageTokens } from "../context/token-counter.js";
+import { execSync } from "node:child_process";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const CYAN = "\x1b[36m";
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+const YELLOW = "\x1b[33m";
+const RESET = "\x1b[0m";
+export function helpCommand(_parts, _ctx) {
+    process.stderr.write(`${DIM}Commands:
+  /help       Show this help
+  /model      Interactive model + reasoning picker
+  /model add <id>  Add a custom model
+  /model remove <id>  Remove a custom model
+  /provider   Show configured providers + auth status
+  /turns      Show turn and tool call counts
+  /clear      Clear conversation history and terminal screen
+  /cwd        Show current working directory
+  /files      Quick file tree (max depth 2, first 30 files)
+  /cost       Show token usage and estimated cost
+  /plan       Show conversation plan (tool calls so far)
+  /undo       Undo last user message and response
+  /history [n|full]  Show last N messages (default 10) with rich formatting
+  /compact    Compact conversation to save context space
+  /context    Show context window usage and provider info
+  /mode       Toggle input mode (steering ↔ queue)
+  /spawn <name> <task>  Spawn a background agent
+  /agents     List running agents
+  /session    Show session info (id, duration, stats)
+  /session save  Save conversation checkpoint
+  /session export  Export conversation as JSON
+  /diff [--staged]  Show git diff with syntax highlighting
+  /git <cmd>  Run common git commands (status, log, stash, stash pop)
+  /ask <question>  Quick LLM query (no tools, not added to session)
+  /mem search <query>  Search phren memory directly
+  /mem findings [project]  Show recent findings
+  /mem tasks [project]  Show tasks
+  /mem add <finding>  Quick-add a finding
+  /preset [name|save|delete|list]  Config presets
+  /exit       Exit the REPL${RESET}\n`);
+    return true;
+}
+export function turnsCommand(_parts, ctx) {
+    const tokens = estimateMessageTokens(ctx.session.messages);
+    const pct = ctx.contextLimit > 0 ? ((tokens / ctx.contextLimit) * 100).toFixed(1) : "?";
+    const costLine = ctx.costTracker ? `  Cost: $${ctx.costTracker.totalCost.toFixed(4)}` : "";
+    process.stderr.write(`${DIM}Turns: ${ctx.session.turns}  Tool calls: ${ctx.session.toolCalls}  ` +
+        `Messages: ${ctx.session.messages.length}  Tokens: ~${tokens} (${pct}%)${costLine}${RESET}\n`);
+    return true;
+}
+export function clearCommand(_parts, ctx) {
+    ctx.session.messages.length = 0;
+    ctx.session.turns = 0;
+    ctx.session.toolCalls = 0;
+    ctx.undoStack.length = 0;
+    process.stdout.write("\x1b[2J\x1b[H");
+    process.stderr.write(`${DIM}Conversation cleared.${RESET}\n`);
+    return true;
+}
+export function cwdCommand(_parts, _ctx) {
+    process.stderr.write(`${DIM}${process.cwd()}${RESET}\n`);
+    return true;
+}
+export function filesCommand(_parts, _ctx) {
+    try {
+        const countRaw = execSync("find . -type f -not -path '*/node_modules/*' -not -path '*/.git/*' -not -path '*/dist/*' | wc -l", { encoding: "utf-8", timeout: 5_000, cwd: process.cwd() }).trim();
+        const total = parseInt(countRaw, 10) || 0;
+        const listRaw = execSync("find . -maxdepth 2 -type f -not -path '*/node_modules/*' -not -path '*/.git/*' -not -path '*/dist/*' | sort | head -30", { encoding: "utf-8", timeout: 5_000, cwd: process.cwd() }).trim();
+        if (!listRaw) {
+            process.stderr.write(`${DIM}No files found.${RESET}\n`);
+        }
+        else {
+            const lines = listRaw.split("\n");
+            const label = total > lines.length ? `${total} files (showing first ${lines.length})` : `${total} files`;
+            process.stderr.write(`${DIM}${label}\n${listRaw}${RESET}\n`);
+        }
+    }
+    catch (err) {
+        const e = err;
+        process.stderr.write(`${RED}${e.stderr || e.message || "find failed"}${RESET}\n`);
+    }
+    return true;
+}
+export function costCommand(_parts, ctx) {
+    const ct = ctx.costTracker;
+    if (ct) {
+        process.stderr.write(`${DIM}Tokens — input: ${ct.inputTokens}  output: ${ct.outputTokens}  est. cost: $${ct.totalCost.toFixed(4)}${RESET}\n`);
+    }
+    else {
+        process.stderr.write(`${DIM}Cost tracking not available.${RESET}\n`);
+    }
+    return true;
+}
+export function planCommand(_parts, ctx) {
+    const tools = [];
+    for (const msg of ctx.session.messages) {
+        if (typeof msg.content !== "string") {
+            for (const block of msg.content) {
+                if (block.type === "tool_use") {
+                    tools.push(block.name);
+                }
+            }
+        }
+    }
+    if (tools.length === 0) {
+        process.stderr.write(`${DIM}No tool calls yet.${RESET}\n`);
+    }
+    else {
+        process.stderr.write(`${DIM}Tool calls (${tools.length}): ${tools.join(" → ")}${RESET}\n`);
+    }
+    return true;
+}
+export function undoCommand(_parts, ctx) {
+    if (ctx.session.messages.length < 2) {
+        process.stderr.write(`${DIM}Nothing to undo.${RESET}\n`);
+        return true;
+    }
+    let removed = 0;
+    while (ctx.session.messages.length > 0) {
+        const last = ctx.session.messages.pop();
+        removed++;
+        if (last?.role === "user" && typeof last.content === "string")
+            break;
+    }
+    process.stderr.write(`${DIM}Undid ${removed} messages.${RESET}\n`);
+    return true;
+}
+export function contextCommand(_parts, ctx) {
+    const ctxTokens = estimateMessageTokens(ctx.session.messages);
+    const ctxPct = ctx.contextLimit > 0 ? (ctxTokens / ctx.contextLimit) * 100 : 0;
+    const ctxPctStr = ctxPct.toFixed(1);
+    const ctxWindowK = ctx.contextLimit >= 1000 ? `${(ctx.contextLimit / 1000).toFixed(0)}k` : String(ctx.contextLimit);
+    const ctxTokensStr = ctxTokens >= 1000 ? `~${(ctxTokens / 1000).toFixed(1)}k` : `~${ctxTokens}`;
+    const filled = Math.round(ctxPct / 10);
+    const bar = "\u2588".repeat(Math.min(filled, 10)) + "\u2591".repeat(Math.max(10 - filled, 0));
+    const barColor = ctxPct > 80 ? RED : ctxPct > 50 ? YELLOW : GREEN;
+    const providerLabel = ctx.providerName ?? "unknown";
+    const modelLabel = ctx.currentModel ?? "default";
+    process.stderr.write(`${DIM}  Messages: ${ctx.session.messages.length}\n` +
+        `  Tokens: ${ctxTokensStr} / ${ctxWindowK} (${ctxPctStr}%)\n` +
+        `  Provider: ${providerLabel} (${modelLabel})\n` +
+        `  Context window: ${ctxWindowK}\n` +
+        `  ${barColor}[${bar}]${RESET}${DIM} ${ctxPctStr}%${RESET}\n`);
+    return true;
+}

package/dist/commands/memory.js

@@ -0,0 +1,165 @@
+import { renderMarkdown } from "../multi/markdown.js";
+import { buildIndex } from "@phren/cli/shared";
+import { searchKnowledgeRows, rankResults } from "@phren/cli/shared/retrieval";
+import { readFindings } from "@phren/cli/data/access";
+import { readTasks } from "@phren/cli/data/tasks";
+import { addFinding } from "@phren/cli/core/finding";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const CYAN = "\x1b[36m";
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+const RESET = "\x1b[0m";
+export function memCommand(parts, ctx) {
+    const sub = parts[1]?.toLowerCase();
+    if (!ctx.phrenCtx) {
+        process.stderr.write(`${DIM}No phren context available.${RESET}\n`);
+        return true;
+    }
+    const pCtx = ctx.phrenCtx;
+    if (!sub || sub === "help") {
+        process.stderr.write(`${DIM}Usage:
+  /mem search <query>     Search phren memory
+  /mem findings [project] Show recent findings
+  /mem tasks [project]    Show tasks
+  /mem add <finding>      Quick-add a finding${RESET}\n`);
+        return true;
+    }
+    if (sub === "search") {
+        const query = parts.slice(2).join(" ").trim();
+        if (!query) {
+            process.stderr.write(`${DIM}Usage: /mem search <query>${RESET}\n`);
+            return true;
+        }
+        return (async () => {
+            try {
+                const db = await buildIndex(pCtx.phrenPath, pCtx.profile);
+                const result = await searchKnowledgeRows(db, {
+                    query,
+                    maxResults: 10,
+                    filterProject: pCtx.project || null,
+                    filterType: null,
+                    phrenPath: pCtx.phrenPath,
+                });
+                const ranked = rankResults(result.rows ?? [], query, null, pCtx.project || null, pCtx.phrenPath, db);
+                if (ranked.length === 0) {
+                    process.stderr.write(`${DIM}No results found.${RESET}\n`);
+                }
+                else {
+                    const lines = ranked.slice(0, 10).map((r, i) => {
+                        const snippet = r.content?.slice(0, 200) ?? "";
+                        return `  ${CYAN}${i + 1}.${RESET} ${DIM}[${r.project}/${r.filename}]${RESET} ${snippet}`;
+                    });
+                    process.stderr.write(lines.join("\n") + "\n");
+                }
+            }
+            catch (err) {
+                process.stderr.write(`${RED}Search failed: ${err instanceof Error ? err.message : String(err)}${RESET}\n`);
+            }
+            return true;
+        })();
+    }
+    if (sub === "findings") {
+        const project = parts[2] || pCtx.project;
+        if (!project) {
+            process.stderr.write(`${DIM}Usage: /mem findings <project>${RESET}\n`);
+            return true;
+        }
+        const result = readFindings(pCtx.phrenPath, project);
+        if (!result.ok) {
+            process.stderr.write(`${RED}${result.error}${RESET}\n`);
+            return true;
+        }
+        const items = result.data ?? [];
+        if (items.length === 0) {
+            process.stderr.write(`${DIM}No findings for ${project}.${RESET}\n`);
+            return true;
+        }
+        const recent = items.slice(-15);
+        const lines = recent.map((f) => `  ${DIM}${f.date}${RESET} ${f.text.slice(0, 120)}${f.text.length > 120 ? "..." : ""}`);
+        process.stderr.write(`${DIM}-- Findings (${items.length} total, showing last ${recent.length}) --${RESET}\n`);
+        process.stderr.write(lines.join("\n") + "\n");
+        return true;
+    }
+    if (sub === "tasks") {
+        const project = parts[2] || pCtx.project;
+        if (!project) {
+            process.stderr.write(`${DIM}Usage: /mem tasks <project>${RESET}\n`);
+            return true;
+        }
+        const result = readTasks(pCtx.phrenPath, project);
+        if (!result.ok) {
+            process.stderr.write(`${RED}${result.error}${RESET}\n`);
+            return true;
+        }
+        const sections = [];
+        for (const [section, items] of Object.entries(result.data.items)) {
+            if (section === "Done")
+                continue;
+            if (items.length === 0)
+                continue;
+            const lines = items.map((t) => {
+                const icon = t.checked ? `${GREEN}\u2713${RESET}` : `${DIM}\u25CB${RESET}`;
+                return `  ${icon} ${t.line}`;
+            });
+            sections.push(`${BOLD}${section}${RESET}\n${lines.join("\n")}`);
+        }
+        if (sections.length === 0) {
+            process.stderr.write(`${DIM}No active tasks for ${project}.${RESET}\n`);
+        }
+        else {
+            process.stderr.write(sections.join("\n") + "\n");
+        }
+        return true;
+    }
+    if (sub === "add") {
+        const finding = parts.slice(2).join(" ").trim();
+        if (!finding) {
+            process.stderr.write(`${DIM}Usage: /mem add <finding text>${RESET}\n`);
+            return true;
+        }
+        const project = pCtx.project;
+        if (!project) {
+            process.stderr.write(`${DIM}No project context. Cannot add finding without a project.${RESET}\n`);
+            return true;
+        }
+        const result = addFinding(pCtx.phrenPath, project, finding);
+        if (result.ok) {
+            process.stderr.write(`${GREEN}-> Finding saved to ${project}.${RESET}\n`);
+        }
+        else {
+            process.stderr.write(`${RED}${result.message ?? "Failed to save finding."}${RESET}\n`);
+        }
+        return true;
+    }
+    process.stderr.write(`${DIM}Unknown /mem subcommand: ${sub}. Try /mem help${RESET}\n`);
+    return true;
+}
+export function askCommand(parts, ctx) {
+    const question = parts.slice(1).join(" ").trim();
+    if (!question) {
+        process.stderr.write(`${DIM}Usage: /ask <question>${RESET}\n`);
+        return true;
+    }
+    if (!ctx.provider) {
+        process.stderr.write(`${DIM}Provider not available for /ask.${RESET}\n`);
+        return true;
+    }
+    const provider = ctx.provider;
+    const sysPrompt = ctx.systemPrompt ?? "You are a helpful assistant.";
+    return (async () => {
+        process.stderr.write(`${DIM}\u25C6 quick answer (no tools):${RESET}\n`);
+        try {
+            const response = await provider.chat(sysPrompt, [{ role: "user", content: question }], []);
+            for (const block of response.content) {
+                if (block.type === "text") {
+                    process.stderr.write(renderMarkdown(block.text) + "\n");
+                }
+            }
+        }
+        catch (err) {
+            process.stderr.write(`${RED}${err instanceof Error ? err.message : String(err)}${RESET}\n`);
+        }
+        return true;
+    })();
+}