@kingcrab/pi-imessage 1.0.0 → 1.1.1

package/README.md

@@ -32,18 +32,8 @@ For installation and service operations, see [ops/README.md](ops/README.md).
 
 ## Commands
 
-Send these commands as iMessages:
-
-| Command | Description |
-|---|---|
-| `/help` | List commands |
-| `/new` | Cancel current work and start a fresh conversation |
-| `/status` | Show tokens, context usage, and model |
-| `/thinking <level\|default>` | Set thinking for this chat or follow the default |
-| `/compact` | Compress context without replaying prior work |
-| `/run <duration> [task]` | Keep working for up to the given time, e.g. `/run 1h`; `/stop` ends it early |
-| `/stop` | Abort current work and stop `/run`; later messages are still answered |
-| `/reload` | Refresh models/auth, AGENTS, skills and extensions without cancelling work |
+Send `/help` in a chat to list commands: `/new`, `/status`, `/thinking`,
+`/verbose`, `/compact`, `/run`, `/stop` and `/reload`.
 
 ## Configuration
 
@@ -64,27 +54,6 @@ Edit `WORKING_DIR/settings.json`. All fields are optional.
 }
 ```
 
-Add chat GUIDs to `whitelist` to enable replies; `blacklist: ["*"]` blocks replies
-elsewhere. An explicit blacklist entry takes priority. Messages are always logged.
-Rich text is optional; `markdown: true` renders bold spans in direct iMessage chats.
-
-### Workspace extensions and scheduler
-
-Context compaction runs every six hours as a native Durable background task.
-Personal tools, tasks and optional daily/interval schedules live in
-`WORKING_DIR/extensions/<name>/index.ts` with `config.json`, not framework
-settings. Startup and `/reload` load them; the assistant can use
-`reload_extensions` to apply its own changes.
-
-See [workspace extensions](docs/workspace-extensions.md) for the factory contract
-and scheduling rules.
-One-off runs use the same scheduler: declare a stable `runRequests` ID, target
-schedule and `at: "now"` (or epoch milliseconds) in the extension configuration,
-then call `reload_extensions`. No restart or separate execution API is needed.
-
-Times use the service machine's local timezone. Saved deadlines survive reload
-and restart; view schedules and latest-ten execution history at `/scheduled`.
-
 ### Model policy
 
 Optional `settings.json` fields, applied at startup and `/reload`:
@@ -98,11 +67,8 @@ Optional `settings.json` fields, applied at startup and `/reload`:
 }
 ```
 
-Without a fallback, an unavailable default fails explicitly. Without a tier,
-provider requests are unchanged. `codexServiceTier` accepts `default` or
-`priority`; priority may have a different cost. Existing deployments migrate
-their previous choices into explicit configuration rather than silently changing
-behavior.
+Without a fallback, an unavailable default fails explicitly. `codexServiceTier`
+accepts `default` or `priority`; priority may have a different cost.
 
 ### Environment Variables
 
@@ -118,9 +84,7 @@ All variables are optional.
 ### Web and API
 
 See the [HTTP API](docs/api.md) for read-only state and model health checks.
-The agent sends files and extra messages with `send_message`. The scheduler
-provides daily/interval cadence and one-off triggers for workspace tasks, plus built-in six-hour compaction.
-It does not revive legacy cron files or HTTP prompt/send endpoints.
+The agent sends files and extra messages with `send_message`.
 
 ## How It Works
 
@@ -129,12 +93,40 @@ Messages chat.db → Watcher → Pi Durable → Messages.app
 ```
 
 Each chat has its own conversation, persisted under `WORKING_DIR/durable/`.
-Durable resumes pending work after a crash. Agent replies are sent at most once;
-uncertain send results are flagged, never automatically resent.
+Durable resumes pending work after a crash. Replies are sent at most once;
+uncertain sends are flagged, never resent. Context is compacted silently every
+six hours and near the model's limit.
 
-Context is compacted silently every 6 hours and near the model's limit. Failed
-compaction keeps the old context. `/new` starts fresh without deleting searchable
-history.
+## Layout
+
+This repository is the framework; `WORKING_DIR` is one deployment's data and code.
+Startup, `/reload` and the assistant's `reload_extensions` load the extensions.
+See [workspace extensions](docs/workspace-extensions.md),
+[ADR 0036](docs/adr/0036-workspace-policy-and-neutral-service-id.md) and
+[ADR 0042](docs/adr/0042-background-schedules-and-workspace-extensions.md).
+
+```text
+pi-imessage/                      framework, shared by every deployment
+├── src/
+│   ├── main.ts, cli.ts           startup, wiring, launchd install
+│   ├── web/                      read-only HTTP API and pages
+│   ├── agent/                    Durable harness, models, prompt, delivery, scheduler
+│   ├── extensions/               built-in tools, workspace extension loader
+│   ├── transport/                chat.db polling, Messages.app sending
+│   └── config/                   settings, environment, chat allowlist
+├── docs/                         architecture and ADRs (the design ground truth)
+├── examples/workspace-extensions/ reference extensions to copy into a workspace
+├── ops/                          deployment, preflight and smoke scripts
+└── test/
+
+WORKING_DIR/  (default ~/.pi/imessage)   one deployment, back it up yourself
+├── settings.json                 chat allowlist, model policy
+├── extensions/<name>/            personal tools, tasks and schedules
+├── skills/file-memory/           structured memory store and core summary
+├── durable/                      conversation state; never edit by hand
+├── attachments/                  archived incoming files
+└── service.log
+```
 
 ## Development
 

package/dist/agent/chats.js

@@ -6,13 +6,34 @@ export const Chats = defineDoc({
     version: 1,
     scope: "session",
     initial: () => ({ items: [] }),
+    checkpointWhen: () => false,
 });
 export const WatchCursor = defineDoc({
     kind: "imessage.watch-cursor",
     version: 1,
     scope: "session",
     initial: () => ({}),
+    checkpointWhen: () => false,
 });
+export function progressEnabled(settings, chats, chatGuid) {
+    return chats.find((chat) => chat.chatGuid === chatGuid)?.progress ?? settings.progressMessages;
+}
+/** Stores the chat's /verbose choice; `undefined` returns the chat to the global setting. */
+export async function setChatProgress(harness, chatGuid, progress) {
+    await harness.commit(async (tx) => {
+        const chats = await tx.doc(Chats);
+        const index = chats.items.findIndex((item) => item.chatGuid === chatGuid);
+        if (index < 0)
+            throw new Error("Chat conversation is missing");
+        const { conversationId } = chats.items[index];
+        // Replace the record so the stored delta never carries an undefined value.
+        chats.items.splice(index, 1, {
+            chatGuid,
+            conversationId,
+            ...(progress === undefined ? {} : { progress }),
+        });
+    }, BACKGROUND_CONTEXT);
+}
 export function formatInput(input) {
     let prefix = "";
     if (input.sender !== undefined) {

package/dist/agent/commands.js

@@ -1,14 +1,18 @@
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
-import { LiveDoc, UsageDoc, UserEntry, } from "@earendil-works/pi-durable";
-import { chatConversation } from "./chats.js";
+import { getCurrentSystemMessage } from "@earendil-works/pi-ai/utils/transcript";
+import { calculateContextTokens, estimateTokens } from "@earendil-works/pi-coding-agent";
+import { LiveDoc, UserEntry, } from "@earendil-works/pi-durable";
+import { readSettings } from "../config/settings.js";
+import { Chats, chatConversation, progressEnabled, setChatProgress } from "./chats.js";
 import { activeRun, Runs, startRun } from "./run.js";
 const help = [
     "/help - list commands",
     "/new - stop current work and start an empty context",
-    "/status - show messages, tokens, context usage, model and run",
+    "/status - show messages, context usage, model and the active run",
     "/compact [instructions] - compress context",
     "/thinking <level|default> - set thinking for this chat",
-    "/reload - reload models, instructions and skills; apply the default model to this chat",
+    "/verbose [on|off|default] - show or set tool progress notices for this chat",
+    "/reload - reload models, instructions and skills; apply the default model to this chat and show /status",
     "/run <duration> [task] - keep working until done, blocked or the deadline, e.g. /run 1h",
     "/stop - stop the current work or /run",
 ].join("\n");
@@ -23,7 +27,7 @@ export function parseDuration(value) {
     return (Number(match[1] ?? 0) * 60 + Number(match[2] ?? 0)) * 60000;
 }
 function tokens(count) {
-    return count >= 1000 ? `${(count / 1000).toFixed(1)}k` : String(count);
+    return count >= 1000 ? `${Math.round(count / 1000)}k` : String(count);
 }
 export function compactionReply(outcome, placement) {
     if (outcome.status === "aborted")
@@ -57,6 +61,41 @@ export async function runCommand(options) {
         if (run)
             await (await harness.conversation(run.conversationId, BACKGROUND_CONTEXT))?.configure(change, BACKGROUND_CONTEXT);
     };
+    // The /status report: user messages with context usage, then model with thinking (ADR 0013).
+    // A third line appears only while a /run is active. Cumulative token totals are deliberately omitted.
+    const status = async (withRun) => {
+        const agent = await conversation.agent(BACKGROUND_CONTEXT);
+        const context = await conversation.context(BACKGROUND_CONTEXT);
+        const window = agent.model && options.models.getModel(agent.model.provider, agent.model.modelId)?.contextWindow;
+        // Context size: the last reported usage, or before the first reply a local estimate of about four characters
+        // per token. After /new the next request restates the system prompt and tools, so the estimate replays them
+        // from the context just before the reset marker.
+        const last = context.messages.findLast((message) => message.role === "assistant" && message.usage.totalTokens > 0);
+        const estimate = async () => {
+            let system = getCurrentSystemMessage(context.messages);
+            if (!system && context.head) {
+                const head = context.head.id;
+                const before = (await conversation.entries({ maxEntryId: head }, 2, undefined, BACKGROUND_CONTEXT)).items.find((entry) => entry.id !== head);
+                if (before)
+                    system = getCurrentSystemMessage((await conversation.context(BACKGROUND_CONTEXT, { at: before.id })).messages);
+            }
+            return context.messages
+                .filter((message) => message.role !== "system")
+                .reduce((sum, message) => sum + estimateTokens(message), system ? estimateTokens(system) : 0);
+        };
+        const used = last?.role === "assistant" ? calculateContextTokens(last.usage) : await estimate();
+        const usage = `${last ? "" : "~"}${((used / (window || 1)) * 100).toFixed(1)}%`;
+        return [
+            [
+                `${context.messages.filter((message) => message.role === "user").length} msgs`,
+                window ? `${usage} / ${tokens(window)}` : "",
+            ]
+                .filter(Boolean)
+                .join(" · "),
+            `${agent.model ? `${agent.model.provider}/${agent.model.modelId}` : "unset"} · ${agent.thinkingLevel}`,
+            ...(withRun && run ? [`run · until ${new Date(run.deadline).toISOString()}`] : []),
+        ].join("\n");
+    };
     switch (name) {
         case "/help":
             return { reply: help };
@@ -91,38 +130,13 @@ export async function runCommand(options) {
             return { reply: "Stopped." };
         }
         case "/new":
-        case "/status": {
-            if (name === "/new") {
-                // The run task belongs to the chat conversation, so this abort stops it too.
-                await conversation.abort(BACKGROUND_CONTEXT);
-                await options.closeBrowsers?.(conversation.id);
-                await conversation.reset(undefined, BACKGROUND_CONTEXT);
-            }
-            const agent = await conversation.agent(BACKGROUND_CONTEXT);
-            const context = await conversation.context(BACKGROUND_CONTEXT);
-            const usage = Object.values((await harness.snapshot(UsageDoc, conversation.id, BACKGROUND_CONTEXT))?.models ?? {});
-            const last = context.messages.findLast((message) => message.role === "assistant" && message.usage.totalTokens > 0);
-            const window = agent.model && options.models.getModel(agent.model.provider, agent.model.modelId)?.contextWindow;
-            const used = last?.role === "assistant" ? last.usage.totalTokens : undefined;
-            return {
-                reply: [
-                    [
-                        `${context.messages.filter((message) => message.role === "user").length} msgs -`,
-                        `in ${tokens(usage.reduce((sum, item) => sum + item.input, 0))}`,
-                        `out ${tokens(usage.reduce((sum, item) => sum + item.output, 0))}`,
-                        window
-                            ? `${used === undefined ? "?" : `${((used / window) * 100).toFixed(1)}%`}/${tokens(window)}`
-                            : "",
-                    ]
-                        .join(" ")
-                        .trim(),
-                    `Model: ${agent.model ? `${agent.model.provider}/${agent.model.modelId}` : "unset"}, thinking: ${agent.thinkingLevel}`,
-                    ...(name === "/status"
-                        ? [`Run: ${run ? `until ${new Date(run.deadline).toISOString()}` : "none"}`]
-                        : []),
-                ].join("\n"),
-            };
-        }
+            // The run task belongs to the chat conversation, so this abort stops it too.
+            await conversation.abort(BACKGROUND_CONTEXT);
+            await options.closeBrowsers?.(conversation.id);
+            await conversation.reset(undefined, BACKGROUND_CONTEXT);
+            return { reply: await status(false) };
+        case "/status":
+            return { reply: await status(true) };
         case "/compact":
             return {
                 wait: await conversation.compact(argument || undefined, BACKGROUND_CONTEXT),
@@ -136,10 +150,24 @@ export async function runCommand(options) {
                 return { reply: `Usage: /thinking <${thinkingLevels.join("|")}|default>` };
             await configure({ thinkingLevel: argument });
             return { reply: `Thinking: ${argument} (this chat only)` };
+        case "/verbose": {
+            if (argument && argument !== "on" && argument !== "off" && argument !== "default")
+                return { reply: "Usage: /verbose [on|off|default]" };
+            if (argument)
+                await setChatProgress(harness, chatGuid, argument === "default" ? undefined : argument === "on");
+            const chats = (await harness.snapshot(Chats, BACKGROUND_CONTEXT))?.items ?? [];
+            const chat = chats.find((item) => item.chatGuid === chatGuid);
+            const settings = await readSettings(options.workingDir);
+            const state = progressEnabled(settings, chats, chatGuid) ? "on" : "off";
+            if (chat?.progress === undefined)
+                return { reply: `Verbose: ${state} (default)` };
+            return { reply: `Verbose: ${state} (this chat only)` };
+        }
         case "/reload": {
             const current = await options.reload();
             await configure({ model: current.model });
-            return { reply: `Reloaded. Model: ${current.model.provider}/${current.model.modelId}` };
+            // Reply in the /status format so the applied model and run are visible at once.
+            return { reply: await status(true) };
         }
         case "/run": {
             const duration = parseDuration(rest[0] ?? "");

package/dist/agent/direct-send.js

@@ -6,6 +6,7 @@ export const DirectSends = defineDoc({
     version: 1,
     scope: "session",
     initial: () => ({ requests: [] }),
+    checkpointWhen: () => false,
 });
 export async function deliverDirect(harness, input, sender) {
     const { chatGuid, requestId } = input;

package/dist/agent/error-log.js

@@ -0,0 +1,37 @@
+const REASON_LIMIT = 200;
+const failedAssistant = (message) => message.role === "assistant" && message.stopReason === "error";
+/**
+ * Service-log error lines for failures that break normal operation (ADR 0053). Durable keeps a failed
+ * task only in its records, so without this an exhausted provider quota leaves stdout silent while the
+ * process, port and HTTP checks look healthy. Each error kind is one branch here; the first is a model
+ * call that ends failed, which leaves the chat or scheduled job without the answer it was waiting for.
+ */
+export function logErrors(harness) {
+    return harness.subscribeCommits(({ changes }) => {
+        for (const change of changes) {
+            if (change.type !== "task" || change.value.kind !== "pi.generation")
+                continue;
+            const task = change.value;
+            if (task.state.status !== "terminal")
+                continue;
+            const { outcome } = task.state;
+            if (outcome.status === "completed" || outcome.status === "aborted")
+                continue;
+            // The failing assistant message is committed together with the task and names provider and model.
+            const failed = changes
+                .flatMap((item) => item.type === "entry" && item.value.conversationId === task.conversationId
+                ? (item.value.model ?? [])
+                : [])
+                .find(failedAssistant);
+            console.error(new Date().toISOString(), "Model call failed", {
+                kind: task.kind,
+                task: task.id,
+                conversation: task.conversationId,
+                status: outcome.status,
+                provider: failed?.provider,
+                model: failed?.model,
+                reason: (outcome.error?.message ?? outcome.reason ?? "").slice(0, REASON_LIMIT),
+            });
+        }
+    });
+}

package/dist/agent/health.js

@@ -6,6 +6,7 @@ export const Sessions = defineDoc({
     version: 1,
     scope: "session",
     initial: () => ({ items: [] }),
+    checkpointWhen: () => false,
 });
 /** Explicit health checks reuse one tool-less conversation and never deliver to a chat. */
 export async function submitHealth(harness, defaults) {

package/dist/agent/progress.js

@@ -1,6 +1,10 @@
+import { realpath } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
 import { isReplyEnabled, readSettings } from "../config/settings.js";
-import { Chats } from "./chats.js";
+import { Chats, progressEnabled } from "./chats.js";
 import { takeScheduledCompaction } from "./compaction.js";
 import { deliverDirect } from "./direct-send.js";
 import { argumentSummary, commandPreview, formatProgress } from "./progress-format.js";
@@ -10,6 +14,9 @@ async function calledTool(harness, task) {
         return;
     // The registered native task owns this input shape and its branded assistant ID.
     const input = task.input;
+    // Nested calls belong to a parent tool; only model-issued calls get progress notices.
+    if (input.kind !== "model")
+        return;
     const entry = await harness.commit((tx) => tx.entry(input.assistant), BACKGROUND_CONTEXT);
     const message = entry?.model?.[0];
     if (message?.role !== "assistant")
@@ -17,6 +24,33 @@ async function calledTool(harness, task) {
     const call = message.content.find((part) => part.type === "toolCall" && part.id === input.callId);
     return call?.type === "toolCall" ? call : undefined;
 }
+async function canonicalPath(path) {
+    return realpath(path).catch(async () => resolve(await realpath(dirname(path)).catch(() => dirname(path)), basename(path)));
+}
+/** Classify metadata only; attachment reads still execute and keep their normal results/history. */
+async function attachmentPath(workingDir, path) {
+    if (typeof path !== "string")
+        return false;
+    // Match the native read tool's @, Unicode-space and home-path normalization.
+    let normalized = path.replace(/[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g, " ");
+    if (normalized.startsWith("@"))
+        normalized = normalized.slice(1);
+    if (normalized === "~" || normalized.startsWith("~/"))
+        normalized = resolve(homedir(), normalized.slice(2));
+    if (normalized.startsWith("file://")) {
+        try {
+            normalized = fileURLToPath(normalized);
+        }
+        catch {
+            /* Keep malformed URLs as ordinary paths, like native read. */
+        }
+    }
+    const root = resolve(workingDir, "attachments");
+    const candidate = resolve(workingDir, normalized);
+    const roots = [root, await canonicalPath(root)];
+    const candidates = [candidate, await canonicalPath(candidate)];
+    return roots.some((directory) => candidates.some((file) => file === directory || file.startsWith(`${directory}${sep}`)));
+}
 /** Observe native admission and settlement; Durable owns execution and recovery. */
 export async function startProgress(harness, workingDir, sender) {
     // Existing live work belongs to the previous startup; do not replay historical progress.
@@ -27,9 +61,10 @@ export async function startProgress(harness, workingDir, sender) {
         if (task.kind === "pi.compaction" && (await takeScheduledCompaction(harness, task.id)))
             return;
         const settings = await readSettings(workingDir);
-        if (!settings.progressMessages)
-            return;
         const chats = (await harness.snapshot(Chats, BACKGROUND_CONTEXT))?.items ?? [];
+        // Nothing can be enabled when the global setting is off and no chat chose /verbose on.
+        if (!settings.progressMessages && !chats.some((chat) => chat.progress))
+            return;
         const runs = (await harness.snapshot(Runs, BACKGROUND_CONTEXT))?.items ?? [];
         let conversationId = task.conversationId;
         let chatGuid;
@@ -46,9 +81,11 @@ export async function startProgress(harness, workingDir, sender) {
             parents.unshift(call?.name ?? owner?.kind ?? "child");
             conversationId = conversation.owner.conversationId;
         }
-        if (!isReplyEnabled(settings, chatGuid))
+        if (!isReplyEnabled(settings, chatGuid) || !progressEnabled(settings, chats, chatGuid))
             return;
         const tool = await calledTool(harness, task);
+        if (tool?.name === "read" && (await attachmentPath(workingDir, tool.arguments.path)))
+            return;
         const request = tool
             ? {
                 phase: "request",
@@ -71,7 +108,8 @@ export async function startProgress(harness, workingDir, sender) {
         if (!notice.chatGuid || !notice.request || task.state.status !== "terminal")
             return;
         const settings = await readSettings(workingDir);
-        if (!settings.progressMessages || !isReplyEnabled(settings, notice.chatGuid))
+        const chats = (await harness.snapshot(Chats, BACKGROUND_CONTEXT))?.items ?? [];
+        if (!isReplyEnabled(settings, notice.chatGuid) || !progressEnabled(settings, chats, notice.chatGuid))
             return;
         const outcome = task.state.outcome;
         let success = outcome.status === "completed";

package/dist/agent/replies.js

@@ -6,4 +6,5 @@ export const Deliveries = defineDoc({
     history: "latest",
     fork: "initial",
     initial: () => ({ answers: {} }),
+    checkpointWhen: () => false,
 });

package/dist/agent/run.js

@@ -9,6 +9,7 @@ export const Runs = defineDoc({
     version: 1,
     scope: "session",
     initial: () => ({ items: [] }),
+    checkpointWhen: () => false,
 });
 /** Model-visible notes in the chat conversation about what happened in a run. */
 export const RUN_RECORD = "imessage.run-record";
@@ -103,7 +104,7 @@ export const RunExtension = defineExtension({
                     if (run)
                         run.endReason = args.reason;
                 }, context);
-                return { content: [{ type: "text", text: "The run ends after this answer." }] };
+                return { output: [{ type: "text", text: "The run ends after this answer." }] };
             },
         }),
     ],

package/dist/agent/scheduling.js

@@ -11,12 +11,14 @@ export const Schedules = defineDoc({
     version: 1,
     scope: "session",
     initial: () => ({ items: [] }),
+    checkpointWhen: () => false,
 });
 export const RunRequests = defineDoc({
     kind: "imessage.schedule-requests",
     version: 1,
     scope: "session",
     initial: () => ({ items: [] }),
+    checkpointWhen: () => false,
 });
 function nextAt(schedule, previous, now) {
     if (schedule.time !== undefined)
@@ -91,13 +93,12 @@ export function schedulingExtension(harness, defaults) {
         phases: {
             async sleep(task, runtime, context) {
                 const { at } = task.state.checkpoint;
-                await runtime.sleep(at, context);
+                // A sleeping task resumes this phase at the same checkpoint once it is due.
+                if (runtime.now() < at)
+                    return runtime.sleepUntil(at, task.state.checkpoint, context);
                 // Due-now work must not start between the configuration commit and registry publication.
-                if (!admissionReady) {
-                    await runtime.sleep(runtime.now() + 100, context);
-                    await runtime.commit(() => ({ status: "running", checkpoint: task.state.checkpoint }), context);
-                    return;
-                }
+                if (!admissionReady)
+                    return runtime.sleepUntil(runtime.now() + 100, task.state.checkpoint, context);
                 await runtime.commit(async (tx) => {
                     const schedule = (await tx.doc(Schedules)).items.find((item) => item.id === task.input.jobId);
                     if (!schedule)
@@ -114,7 +115,7 @@ export function schedulingExtension(harness, defaults) {
                     if (!task.input.requestId && beforeToday)
                         return { status: "running", checkpoint: { phase: "sleep", at: nextAt(schedule, at, now) } };
                     // All triggers of a job share its non-overlap boundary.
-                    for (const status of ["pending", "running", "waiting", "completing"]) {
+                    for (const status of ["pending", "running", "waiting", "sleeping", "completing"]) {
                         const existing = (await tx.scanTasks({ conversationId: schedule.conversationId, kind: EXECUTION_KIND, status }, 1)).items[0];
                         if (existing)
                             return {

package/dist/extensions/browser.js

@@ -312,7 +312,7 @@ export async function createBrowser(workingDir, agentDir) {
                 executionMode: "sequential",
                 async execute(args, api, context) {
                     return {
-                        content: [{ type: "text", text: await run(api.conversationId, args, context.abortSignal) }],
+                        output: [{ type: "text", text: await run(api.conversationId, args, context.abortSignal) }],
                     };
                 },
             }),

package/dist/extensions/memory.js

@@ -15,7 +15,7 @@ async function memoryCli(workingDir, args, signal) {
     });
     return stdout;
 }
-const text = (value) => ({ content: [{ type: "text", text: value }] });
+const text = (value) => ({ output: [{ type: "text", text: value }] });
 /** Structured memory tools; the namespace list and core memory are read when the extension is built. */
 export async function memoryExtension(workingDir) {
     const namespaces = await memoryCli(workingDir, ["list-namespaces"])

package/dist/extensions/message.js

@@ -25,7 +25,7 @@ export function messageExtension(messaging) {
                         text: args.text,
                         filePath: args.filePath,
                     });
-                    return { content: [{ type: "text", text: JSON.stringify(receipt) }] };
+                    return { output: [{ type: "text", text: JSON.stringify(receipt) }] };
                 },
             }),
         ],

package/dist/extensions/read-image.js

@@ -19,7 +19,7 @@ export const ImageRead = defineExtension({
                     throw new Error("No image filesystem");
                 const path = getOrThrow(await api.env.canonicalPath(args.path, context));
                 return {
-                    content: [{ type: "text", text: imagePrefix + JSON.stringify(path) }],
+                    output: [{ type: "text", text: imagePrefix + JSON.stringify(path) }],
                     details: { imagePath: path },
                 };
             },