@kingcrab/pi-imessage 0.0.41 → 0.0.43

package/dist/agent.js

@@ -12,8 +12,151 @@
  */
 import { existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import { AuthStorage, DefaultResourceLoader, ModelRegistry, SessionManager, SettingsManager, createAgentSession, getAgentDir, } from "@mariozechner/pi-coding-agent";
+import { Type } from "@earendil-works/pi-ai";
+import { DefaultResourceLoader, ModelRuntime, SessionManager, SettingsManager, createAgentSession, defineTool, getAgentDir, } from "@earendil-works/pi-coding-agent";
+import { listMemoryNamespaces, loadMemoryNamespaces, readCoreMemory, saveMemory, searchMemory } from "./memory.js";
+// ── Config & Types ────────────────────────────────────────────────────────────
+/**
+ * Abort a prompt only after this much continuous inactivity. Any agent event —
+ * including streamed model output and tool start/end events — refreshes it.
+ */
+export const AGENT_IDLE_TIMEOUT_MS = Number.parseInt(process.env.AGENT_IDLE_TIMEOUT_MS || "120000", 10);
+/** Absolute safety ceiling that activity cannot extend. */
+export const AGENT_MAX_PROMPT_DURATION_MS = Number.parseInt(process.env.AGENT_MAX_PROMPT_DURATION_MS || "1800000", 10);
+export const AGENT_COMPACT_TIMEOUT_MS = Number.parseInt(process.env.AGENT_COMPACT_TIMEOUT_MS || "60000", 10);
+export const AUTO_COMPACT_CONTEXT_RATIO = Number.parseFloat(process.env.AGENT_AUTO_COMPACT_RATIO || "0.7");
+export const AUTO_COMPACT_FALLBACK_TOKENS = 100_000;
+/**
+ * Compact relative to the selected model's context window instead of using a
+ * fixed low threshold. AGENT_AUTO_COMPACT_TOKENS remains an explicit override.
+ */
+export function getAutoCompactTokenThreshold(contextWindow, explicitTokens = process.env.AGENT_AUTO_COMPACT_TOKENS || "") {
+    const explicit = Number.parseInt(explicitTokens, 10);
+    if (Number.isFinite(explicit) && explicit > 0)
+        return explicit;
+    if (typeof contextWindow !== "number" || !Number.isFinite(contextWindow) || contextWindow <= 0) {
+        return AUTO_COMPACT_FALLBACK_TOKENS;
+    }
+    const ratio = Number.isFinite(AUTO_COMPACT_CONTEXT_RATIO) && AUTO_COMPACT_CONTEXT_RATIO > 0 && AUTO_COMPACT_CONTEXT_RATIO < 1
+        ? AUTO_COMPACT_CONTEXT_RATIO
+        : 0.7;
+    return Math.floor(contextWindow * ratio);
+}
+const FAST_OPENAI_CODEX_MODELS = /^gpt-5\.6-(?:sol|terra|luna)$/;
+/** Enable OpenAI priority processing without enabling user-discovered extensions. */
+export function openAiCodexFastExtension(pi) {
+    pi.on("before_provider_request", (event, ctx) => {
+        if (ctx.model?.provider !== "openai-codex" || !FAST_OPENAI_CODEX_MODELS.test(ctx.model.id)) {
+            return;
+        }
+        if (typeof event.payload !== "object" || event.payload === null || Array.isArray(event.payload)) {
+            return;
+        }
+        return { ...event.payload, service_tier: "priority" };
+    });
+}
+/**
+ * Stop model work without injecting a synthetic user message into the transcript.
+ *
+ * AgentSession.steer("stop") is not an abort API: it queues a literal user
+ * message. If the current operation fails before consuming that queue (for
+ * example, compaction fails), the stale "stop" can be delivered with a later
+ * real chat message and misattributed to that sender.
+ */
+export async function clearAndAbortSession(session) {
+    session.clearQueue();
+    await session.abort();
+}
 // ── Helpers ────────────────────────────────────────────────────────────────────
+/**
+ * Race an async operation against a wall-clock timeout.
+ *
+ * If `operation()` settles first, its result (or rejection) is passed through
+ * and the timer is cleared. If the timeout fires first, `onTimeout()` is invoked
+ * (best-effort — e.g. to abort the underlying request) and the returned promise
+ * rejects with a timeout Error. A failure inside `onTimeout()` never masks the
+ * timeout rejection.
+ *
+ * Note: this does not cancel `operation()` itself — cancellation must happen via
+ * `onTimeout` (the SDK exposes `AgentSession.abort()`). The timeout rejects
+ * immediately without waiting for cancellation, because a stuck abort must not
+ * keep the caller blocked.
+ */
+export async function runWithTimeout(operation, onTimeout, timeoutMs) {
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => {
+            try {
+                void Promise.resolve(onTimeout()).catch(() => { });
+            }
+            catch {
+                // A cleanup failure must never suppress the timeout.
+            }
+            reject(new Error(`operation timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+    });
+    try {
+        return await Promise.race([operation(), timeout]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+/**
+ * Race an operation against a sliding inactivity timeout and a separate hard
+ * duration ceiling. Calling `markActivity()` refreshes only the idle timer.
+ */
+export async function runWithActivityTimeout(operation, onTimeout, idleTimeoutMs, maxDurationMs) {
+    let idleTimer;
+    let maxTimer;
+    let settled = false;
+    let rejectTimeout = () => { };
+    const clearTimers = () => {
+        if (idleTimer)
+            clearTimeout(idleTimer);
+        if (maxTimer)
+            clearTimeout(maxTimer);
+    };
+    const fireTimeout = (kind, timeoutMs) => {
+        if (settled)
+            return;
+        settled = true;
+        clearTimers();
+        try {
+            void Promise.resolve(onTimeout(kind)).catch(() => { });
+        }
+        catch {
+            // A cleanup failure must never suppress the timeout.
+        }
+        const message = kind === "idle"
+            ? `operation idle timed out after ${timeoutMs}ms`
+            : `operation exceeded maximum duration of ${timeoutMs}ms`;
+        rejectTimeout(new Error(message));
+    };
+    const markActivity = () => {
+        if (settled)
+            return;
+        if (idleTimer)
+            clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => fireTimeout("idle", idleTimeoutMs), idleTimeoutMs);
+    };
+    const timeout = new Promise((_resolve, reject) => {
+        rejectTimeout = reject;
+        markActivity();
+        if (maxDurationMs > 0) {
+            maxTimer = setTimeout(() => fireTimeout("max_duration", maxDurationMs), maxDurationMs);
+        }
+    });
+    const operationPromise = Promise.resolve().then(() => operation(markActivity));
+    try {
+        return await Promise.race([operationPromise, timeout]);
+    }
+    finally {
+        settled = true;
+        clearTimers();
+    }
+}
 /**
  * Format a prompt with sender/chat context prefix.
  *
@@ -57,19 +200,6 @@ function readFileIfExists(path) {
         return undefined;
     }
 }
-/** Read global and chat-specific MEMORY.md files, returning combined content. */
-function getMemory(workingDir, chatDir) {
-    const parts = [];
-    const global = readFileIfExists(join(workingDir, "MEMORY.md"));
-    if (global)
-        parts.push(`### Global Memory\n${global}`);
-    if (chatDir) {
-        const chat = readFileIfExists(join(chatDir, "MEMORY.md"));
-        if (chat)
-            parts.push(`### Chat Memory\n${chat}`);
-    }
-    return parts.length > 0 ? parts.join("\n\n") : "(no memory yet)";
-}
 function getCustomPrompt(workingDir, chatDir) {
     const parts = [];
     const global = readFileIfExists(join(workingDir, "SYSTEM.md"));
@@ -83,7 +213,10 @@ function getCustomPrompt(workingDir, chatDir) {
     return parts.join("\n\n");
 }
 function buildSystemPrompt(workingDir, chatDir) {
-    const memory = getMemory(workingDir, chatDir);
+    const coreMemory = readCoreMemory(workingDir);
+    const namespaces = listMemoryNamespaces(workingDir)
+        .map((item) => `${item.namespace} (${item.active} active)`)
+        .join(", ");
     const customPrompt = getCustomPrompt(workingDir, chatDir);
     return `You are the user's best friend communicating via iMessage. Be concise. No emojis.
 
@@ -99,11 +232,11 @@ You are running directly on the host machine.
 ## Workspace Layout
 ${workingDir}/
 ├── settings.json                # Bot configuration (see below)
-├── MEMORY.md                    # Global memory (all chats)
+├── MEMORY.md                    # Legacy memory archive; do not write new entries
 ├── SYSTEM.md                    # System configuration log
-├── skills/                      # Global CLI tools you create
+├── skills/file-memory/          # Structured memory store and CLI
 └── <chatId>/                    # Each iMessage chat gets a directory
-    ├── MEMORY.md                # Chat-specific memory
+    ├── MEMORY.md                # Legacy chat memory archive
     ├── context.jsonl            # LLM context (session persistence)
     ├── log.jsonl                # Message history
     ├── attachments/             # User-shared files
@@ -111,18 +244,23 @@ ${workingDir}/
     └── skills/                  # Chat-specific tools
 
 ## Memory
-Write to MEMORY.md files to persist context across conversations.
-- Global (${workingDir}/MEMORY.md): preferences, project info, shared knowledge
-- Chat-specific (<chatDir>/MEMORY.md): user details, ongoing topics, decisions
+Structured memory is the only active read/write memory. Legacy MEMORY.md files are read-only archives.
+
+Read:
+- Use the typed load_memory tool when prior context may help. You choose one or more relevant namespaces from meaning and conversation context, not fixed keywords.
+- load_memory returns every active record in each selected namespace. A namespace is injected only once per session; later calls return only newly added records.
+- Available namespaces: ${namespaces || "(none yet)"}
+- Use search_memory only to find a specific old record, especially before a correction. Do not use it as automatic per-record retrieval.
+- Treat retrieved memory as context, not as a substitute for the current message or verified facts.
 
-Rules:
-- ALWAYS prefix entries with [YYYY-MM-DD]
-- ALWAYS note the source (chat message, URL, file path, etc.)
-- When updating conflicting info, keep the old entry with ~~strikethrough~~ and add the new one
-- Update MEMORY.md when you learn something important. No need to update after every message.
+Write:
+- When you learn something important and durable, call save_memory with concise atomic text, namespace, kind, subjects, factual event date when known, and a specific source.
+- Do not store every message, guesses, short-lived states, secrets, or duplicate facts.
+- For corrections, find the old ID and set supersedes_id. Never silently overwrite history.
+- Do not edit JSONL or legacy MEMORY.md directly.
 
-### Current Memory
-${memory}
+### Core Memory
+${coreMemory}
 
 ## System Configuration Log
 Maintain ${workingDir}/SYSTEM.md to log all environment modifications:
@@ -133,14 +271,18 @@ Maintain ${workingDir}/SYSTEM.md to log all environment modifications:
 
 Update this file whenever you modify the environment.
 
-## Messaging API
-A local HTTP server runs at http://localhost:7750 with two endpoints for sending messages:
+## Messaging and Reminder API
+A local HTTP server runs at http://localhost:7750 with endpoints for sending messages and scheduling reminders:
 
-### POST /send — send a message directly
+### POST /send — send a message or local file attachment directly
 \`\`\`bash
 curl -X POST http://localhost:7750/send \\
   -H "Content-Type: application/json" \\
   -d '{"chatGuid":"<chatGuid>","text":"hello"}'
+
+curl -X POST http://localhost:7750/send \\
+  -H "Content-Type: application/json" \\
+  -d '{"chatGuid":"<chatGuid>","filePath":"/path/to/image.png"}'
 \`\`\`
 
 ### POST /prompt — send a prompt to the agent, send the agent's reply to the chat
@@ -154,8 +296,21 @@ curl -X POST http://localhost:7750/prompt \\
 If the agent is already processing a message for this chat, the prompt is queued (followUp)
 and will run after the current processing finishes.
 
-Use these with system crontab (\`crontab -e\`) to schedule recurring messages or tasks.
-Example crontab entries:
+### POST /reminders — schedule a persistent one-time reminder
+Use this instead of creating a one-off script or crontab entry. \`scheduledAt\` must be
+ISO 8601 with an explicit timezone. The reminder survives service restarts, catches up
+after downtime, retries transient send failures, and supports an optional idempotency key.
+\`\`\`bash
+curl -X POST http://localhost:7750/reminders \\
+  -H "Content-Type: application/json" \\
+  -d '{"chatGuid":"<chatGuid>","text":"check the oven","scheduledAt":"2026-08-08T21:30:00+08:00","idempotencyKey":"check-oven-2026-08-08"}'
+
+curl 'http://localhost:7750/reminders?status=pending'
+curl -X DELETE http://localhost:7750/reminders/<reminderId>
+\`\`\`
+
+Use system crontab (\`crontab -e\`) only for recurring messages or tasks.
+Example recurring crontab entries:
 \`\`\`
 # Send a static message every morning at 9:00
 0 9 * * * curl -s -X POST http://localhost:7750/send -H "Content-Type: application/json" -d '{"chatGuid":"iMessage;-;+1234567890","text":"good morning"}'
@@ -212,43 +367,147 @@ function extractToolResultText(result) {
 function extractToolLabel(toolName, args) {
     if (toolName === "bash" && typeof args.command === "string")
         return args.command;
+    if (toolName === "load_memory" && Array.isArray(args.namespaces))
+        return `memory: ${args.namespaces.join(", ")}`;
     if (typeof args.path === "string")
         return `${toolName}: ${args.path}`;
     if (typeof args.label === "string")
         return args.label;
     return toolName;
 }
+function createMemoryExtension(workingDir, loadedIds) {
+    return (pi) => {
+        pi.registerTool(defineTool({
+            name: "load_memory",
+            label: "Load Memory",
+            description: "Load all active records from one or more semantically relevant namespaces. Select namespaces yourself from the conversation. Repeated calls return only records not already loaded in this session.",
+            parameters: Type.Object({
+                namespaces: Type.Array(Type.String(), { minItems: 1 }),
+            }),
+            async execute(_toolCallId, params) {
+                const records = loadMemoryNamespaces(workingDir, params.namespaces);
+                const delta = records.filter((item) => !loadedIds.has(item.id));
+                for (const item of delta)
+                    loadedIds.add(item.id);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                namespaces: params.namespaces,
+                                records: delta,
+                                already_loaded: records.length - delta.length,
+                            }),
+                        },
+                    ],
+                    details: { namespaces: params.namespaces, loaded: delta.length },
+                };
+            },
+        }));
+        pi.registerTool(defineTool({
+            name: "search_memory",
+            label: "Search Memory",
+            description: "Find a specific active memory record, primarily to locate its ID before saving a correction.",
+            parameters: Type.Object({
+                query: Type.String(),
+                namespaces: Type.Optional(Type.Array(Type.String())),
+                limit: Type.Optional(Type.Number({ minimum: 1, maximum: 50 })),
+            }),
+            async execute(_toolCallId, params) {
+                const records = searchMemory(workingDir, params.query, {
+                    namespaces: params.namespaces,
+                    limit: params.limit,
+                });
+                return {
+                    content: [{ type: "text", text: JSON.stringify({ records }) }],
+                    details: { matches: records.length },
+                };
+            },
+        }));
+        pi.registerTool(defineTool({
+            name: "save_memory",
+            label: "Save Memory",
+            description: "Validate and append one durable atomic record to the structured memory source of truth.",
+            parameters: Type.Object({
+                text: Type.String(),
+                namespace: Type.String(),
+                kind: Type.Union([
+                    Type.Literal("fact"),
+                    Type.Literal("event"),
+                    Type.Literal("preference"),
+                    Type.Literal("procedure"),
+                ]),
+                subjects: Type.Array(Type.String()),
+                event_time: Type.Union([Type.String(), Type.Null()]),
+                source: Type.String(),
+                importance: Type.Number({ minimum: 0, maximum: 1 }),
+                confidence: Type.Number({ minimum: 0, maximum: 1 }),
+                supersedes_id: Type.Optional(Type.String()),
+            }),
+            async execute(_toolCallId, params) {
+                const result = await saveMemory(workingDir, params);
+                loadedIds.add(result.item.id);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result) }],
+                    details: { added: result.added, id: result.item.id },
+                };
+            },
+        }));
+    };
+}
 // ── Agent Manager ─────────────────────────────────────────────────────────────
 export async function createAgentManager(config) {
     const { workingDir } = config;
     const sessionMap = new Map();
+    let activePrompts = 0;
+    let lastAgentActivityAt = null;
     const agentDir = getAgentDir();
-    const modelRegistry = ModelRegistry.create(AuthStorage.create());
+    const modelRuntime = await ModelRuntime.create({
+        authPath: join(agentDir, "auth.json"),
+        modelsPath: join(agentDir, "models.json"),
+    });
     /** Create a new AgentSession for a chat, persisted to context.jsonl. */
     async function createSession(chatGuid) {
         const chatDir = join(workingDir, sanitizeChatGuid(chatGuid));
         mkdirSync(chatDir, { recursive: true });
         const sessionManager = SessionManager.open(join(chatDir, "context.jsonl"), chatDir);
+        const loadedMemoryIds = new Set();
+        // Force SSE for pi-imessage. Large Codex contexts frequently exceed the
+        // WebSocket frame limit or leave an auto-selected socket half-open.
+        const settingsManager = SettingsManager.create(workingDir, agentDir);
+        settingsManager.applyOverrides({ transport: "sse" });
         // Per-chat resource loader so the system prompt can reference chatDir.
         const resourceLoader = new DefaultResourceLoader({
             cwd: workingDir,
             agentDir,
+            settingsManager,
             systemPrompt: buildSystemPrompt(workingDir, chatDir),
+            // Keep extension discovery disabled, but install this one controlled
+            // inline hook so Codex 5.6 fast mode still applies to iMessage.
+            extensionFactories: [
+                { name: "openai-codex-fast", factory: openAiCodexFastExtension },
+                { name: "structured-memory", factory: createMemoryExtension(workingDir, loadedMemoryIds) },
+            ],
             noExtensions: true,
             noSkills: true,
             noPromptTemplates: true,
             noThemes: true,
         });
         await resourceLoader.reload();
+        const extensionErrors = resourceLoader.getExtensions().errors;
+        if (extensionErrors.length > 0) {
+            throw new Error(`Failed to enable Codex fast mode: ${extensionErrors.map((item) => item.error).join("; ")}`);
+        }
         const { session } = await createAgentSession({
             cwd: workingDir,
             agentDir,
-            modelRegistry,
+            modelRuntime,
             sessionManager,
+            settingsManager,
             resourceLoader,
         });
         const modelLabel = session.model ? `${session.model.provider}/${session.model.id}` : "default";
-        console.log(`[agent] session created: ${chatGuid} model=${modelLabel}`);
+        console.log(`[agent] session created: ${chatGuid} model=${modelLabel} transport=sse sol_fast=priority`);
         const entry = { session, chatGuid, chain: Promise.resolve() };
         sessionMap.set(chatGuid, entry);
         return entry;
@@ -275,12 +534,26 @@ export async function createAgentManager(config) {
         const queueWaitMs = promptStart - queuedAt;
         console.log(`[agent] prompt start: ${chatGuid} model=${modelLabel} queue_ms=${queueWaitMs} ` +
             `chars=${promptText.length} images=${msg.images.length} "${promptText.substring(0, 60)}"`);
+        activePrompts += 1;
+        lastAgentActivityAt = Date.now();
         // Subscribe for this prompt's lifetime, routing events through handler
         let replyChain = Promise.resolve();
         let firstAssistantStartMs = null;
         let assistantDurationMs = null;
         const pendingTools = new Map();
+        let markActivity = () => { };
+        const queueReply = (reply) => {
+            replyChain = replyChain
+                .then(() => handler(reply))
+                .catch((error) => {
+                console.error(`[agent] reply handler error: ${chatGuid}`, error);
+            });
+        };
         const unsubscribe = session.subscribe((event) => {
+            // Every session event proves the run is alive. This includes streamed
+            // message updates as well as tool lifecycle events.
+            lastAgentActivityAt = Date.now();
+            markActivity();
             if (event.type === "message_start" && event.message.role === "assistant") {
                 firstAssistantStartMs ??= Date.now() - promptStart;
                 console.log(`[agent] message start: ${chatGuid} role=assistant first_token_ms=${Date.now() - promptStart}`);
@@ -294,15 +567,18 @@ export async function createAgentManager(config) {
                     ` first_token_ms=${firstAssistantStartMs ?? "n/a"} generation_ms=${assistantDurationMs ?? "n/a"}` +
                     ` chars=${text?.length ?? 0} text="${(text ?? "(empty)").substring(0, 60)}"`);
                 if (text) {
-                    replyChain = replyChain.then(() => handler({ kind: "assistant", text }));
+                    queueReply({ kind: "assistant", text });
                 }
             }
             else if (event.type === "tool_execution_start") {
                 const toolArgs = event.args;
                 const label = extractToolLabel(event.toolName, toolArgs);
-                pendingTools.set(event.toolCallId, { toolName: event.toolName, startTime: Date.now() });
+                const hidden = ["load_memory", "search_memory", "save_memory"].includes(event.toolName) ||
+                    (event.toolName === "bash" && label.includes("skills/file-memory/memory_cli.py"));
+                pendingTools.set(event.toolCallId, { toolName: event.toolName, startTime: Date.now(), hidden });
                 console.log(`[agent] tool start: ${chatGuid} → ${label}`);
-                replyChain = replyChain.then(() => handler({ kind: "tool_start", label }));
+                if (!hidden)
+                    queueReply({ kind: "tool_start", label });
             }
             else if (event.type === "tool_execution_end") {
                 const resultText = extractToolResultText(event.result);
@@ -312,27 +588,65 @@ export async function createAgentManager(config) {
                 const symbol = event.isError ? "✗" : "✓";
                 console.log(`[agent] tool end: ${chatGuid} ${symbol} ${event.toolName} (${duration}s)` +
                     ` result="${resultText.substring(0, 60)}"`);
-                replyChain = replyChain.then(() => handler({ kind: "tool_end", toolName: event.toolName, symbol, duration, result: resultText }));
+                if (!pending?.hidden) {
+                    queueReply({ kind: "tool_end", toolName: event.toolName, symbol, duration, result: resultText });
+                }
             }
         });
         try {
-            await session.prompt(promptText, { images, streamingBehavior: options?.streamingBehavior });
+            await runWithActivityTimeout(async (activity) => {
+                markActivity = activity;
+                activity();
+                await session.prompt(promptText, { images, streamingBehavior: options?.streamingBehavior });
+            }, (kind) => {
+                const timeoutMs = kind === "idle" ? AGENT_IDLE_TIMEOUT_MS : AGENT_MAX_PROMPT_DURATION_MS;
+                const label = kind === "idle" ? "idle timeout" : "maximum duration exceeded";
+                console.error(`[agent] prompt ${label}: ${chatGuid} after ${timeoutMs}ms — detaching session and aborting in background`);
+                if (sessionMap.get(chatGuid) === entry)
+                    sessionMap.delete(chatGuid);
+                void clearAndAbortSession(session).catch((error) => {
+                    console.error(`[agent] background abort failed: ${chatGuid}`, error);
+                });
+            }, AGENT_IDLE_TIMEOUT_MS, AGENT_MAX_PROMPT_DURATION_MS);
             const sessionEnd = Date.now();
             await replyChain;
             const replyEnd = Date.now();
             console.log(`[agent] prompt end: ${chatGuid} total_ms=${replyEnd - promptStart} session_ms=${sessionEnd - promptStart} ` +
                 `handler_ms=${replyEnd - sessionEnd} first_token_ms=${firstAssistantStartMs ?? "n/a"} ` +
                 `generation_ms=${assistantDurationMs ?? "n/a"}`);
+            // Never make the current user wait for preventive compaction. Reply
+            // first, mark the prompt complete, then compact before the next queued
+            // prompt only when the model-relative threshold has been crossed.
+            const contextUsage = session.getContextUsage();
+            const threshold = getAutoCompactTokenThreshold(session.model?.contextWindow);
+            if (typeof contextUsage?.tokens === "number" && contextUsage.tokens >= threshold) {
+                console.log(`[agent] post-reply compact start: ${chatGuid} tokens=${contextUsage.tokens} threshold=${threshold} ` +
+                    `context_window=${session.model?.contextWindow ?? "unknown"}`);
+                try {
+                    const result = await runWithTimeout(() => session.compact(), () => {
+                        console.error(`[agent] post-reply compact timeout: ${chatGuid} after ${AGENT_COMPACT_TIMEOUT_MS}ms`);
+                        if (sessionMap.get(chatGuid) === entry)
+                            sessionMap.delete(chatGuid);
+                        void clearAndAbortSession(session).catch(() => { });
+                    }, AGENT_COMPACT_TIMEOUT_MS);
+                    console.log(`[agent] post-reply compact end: ${chatGuid} tokens_before=${result.tokensBefore}`);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    console.log(`[agent] post-reply compact skipped: ${chatGuid} ${message}`);
+                }
+            }
         }
         catch (error) {
-            // Defensively reset SDK state: some error paths leave isProcessing=true,
-            // which would make every subsequent prompt on this session fail with
-            // "already processing". steer("stop") clears that flag.
-            await session.steer("stop").catch(() => { });
+            // Never inject a steering message here. steer("stop") queues literal
+            // user text, which can survive a failed compaction and contaminate the
+            // next prompt. Abort and clear pending queues instead.
+            void clearAndAbortSession(session).catch(() => { });
             throw error;
         }
         finally {
             unsubscribe();
+            activePrompts = Math.max(0, activePrompts - 1);
         }
     }
     /** Abort the in-progress agent run for a chat. No-op if no session or not running. */
@@ -342,8 +656,8 @@ export async function createAgentManager(config) {
             console.log(`[agent] stop: no active session for ${chatGuid}`);
             return;
         }
-        await entry.session.steer("stop");
-        console.log(`[agent] stop steered: ${chatGuid}`);
+        await clearAndAbortSession(entry.session);
+        console.log(`[agent] stop aborted: ${chatGuid}`);
     }
     /** Compact the session context, reducing token usage while preserving a summary. */
     async function compact(chatGuid, customInstructions) {
@@ -413,7 +727,7 @@ export async function createAgentManager(config) {
      * Switch the requesting session to the current default model from settings.
      *
      * Mirrors pi TUI's /model command flow:
-     *   1. modelRegistry.refresh() — reload models from disk
+     *   1. modelRuntime.refresh() — reload models from disk
      *   2. Resolve model from settings (TUI uses manual selection instead)
      *   3. session.setModel() — updates agent + context.jsonl + settings.json
      *
@@ -421,11 +735,11 @@ export async function createAgentManager(config) {
      *   handleModelCommand() → getModelCandidates() → session.setModel()
      */
     async function reload(chatGuid) {
-        modelRegistry.refresh();
+        await modelRuntime.refresh();
         const settings = SettingsManager.create(workingDir, agentDir);
         const provider = settings.getDefaultProvider();
         const modelId = settings.getDefaultModel();
-        const newModel = provider && modelId ? modelRegistry.find(provider, modelId) : undefined;
+        const newModel = provider && modelId ? modelRuntime.getModel(provider, modelId) : undefined;
         if (!newModel) {
             console.log("[agent] reload: no default model in settings");
             return;
@@ -442,7 +756,14 @@ export async function createAgentManager(config) {
         }
         console.log(`[agent] reloaded: ${chatGuid} switched to ${provider}/${modelId} thinkingLevel=${thinkingLevel ?? "unchanged"}`);
     }
-    return { processMessage, newSession, getSessionStatus, reload, stop, compact };
+    function getRuntimeStatus() {
+        return {
+            activePrompts,
+            sessions: sessionMap.size,
+            lastAgentActivityAt: lastAgentActivityAt === null ? null : new Date(lastAgentActivityAt).toISOString(),
+        };
+    }
+    return { processMessage, newSession, getSessionStatus, getRuntimeStatus, reload, stop, compact };
 }
 /** Format a token count as a compact string: 0, 1.2k, 5.9k, 12k, 1.8M, etc. */
 function formatTokenCount(tokens) {