@anhlp/alp-runtime 0.0.0-beta.1 → 0.0.0-beta.2

package/dist/acp-transport.d.ts

@@ -58,6 +58,18 @@ export declare function acpWhat(request: AcpPermission): string;
  */
 export declare function acpEnv(provider: Pick<AcpProvider, 'command' | 'env'>, base: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 /** Maps an ACP agent over stdio to the normalized runtime protocol. */
+/** One turn-input part as ACP's: text, or a data-URL image as an ACP image block; anything else is dropped. */
+export declare function acpContent(part: any): {
+    type: string;
+    text: any;
+    mimeType?: undefined;
+    data?: undefined;
+} | {
+    type: string;
+    mimeType: string;
+    data: string;
+    text?: undefined;
+} | null;
 export declare class AcpTransport {
     private readonly provider;
     private readonly cwd;
@@ -71,6 +83,8 @@ export declare class AcpTransport {
     private requestHandler?;
     private closed;
     private capabilities;
+    /** ACP agents say in initialize whether a prompt may hold images (promptCapabilities.image). */
+    takesImages(): boolean;
     private sessionId;
     private config;
     /** Instructions go with the first prompt of a new session; a loaded one has them already. */
@@ -95,6 +109,8 @@ export declare class AcpTransport {
     request(method: string, params: any): Promise<any>;
     /** Picks the session's model when ALP was given one and the agent offers a choice. */
     private chooseModel;
+    /** The tokens of the turn the prompt response says (ACP's unstable usage), before its end. */
+    private turnUsage;
     private endTurn;
     private closeMessage;
     private update;

package/dist/acp-transport.js

@@ -9,6 +9,7 @@ import path from "node:path";
 import { createInterface } from "node:readline";
 import { commandDecision, unwrapShell } from "@anhlp/alp-core/permissions";
 import { launchCommand } from "@anhlp/alp-core/providers";
+import { acpText, acpToolDetail } from "./tool-detail.js";
 var BRIDGE = `
 const net = require('node:net');
 const readline = require('node:readline');
@@ -92,6 +93,11 @@ function acpServers(servers, http) {
     return { name, command: server.command, args: server.args ?? [], env: Object.entries(server.env ?? {}).map(([key, value]) => ({ name: key, value: String(value) })) };
   });
 }
+function acpContent(part) {
+  if (typeof part?.text === "string") return { type: "text", text: part.text };
+  const image = part?.type === "image" && typeof part.url === "string" ? /^data:(image\/(?:png|jpeg|gif|webp));base64,([A-Za-z0-9+/]+={0,2})$/.exec(part.url) : null;
+  return image ? { type: "image", mimeType: image[1], data: image[2] } : null;
+}
 var AcpTransport = class {
   constructor(provider, cwd, env) {
     this.provider = provider;
@@ -107,6 +113,10 @@ var AcpTransport = class {
   requestHandler;
   closed = false;
   capabilities = {};
+  /** ACP agents say in initialize whether a prompt may hold images (promptCapabilities.image). */
+  takesImages() {
+    return this.capabilities?.promptCapabilities?.image === true;
+  }
   sessionId = "";
   config;
   /** Instructions go with the first prompt of a new session; a loaded one has them already. */
@@ -191,7 +201,8 @@ var AcpTransport = class {
       const turnId = randomUUID();
       this.activeTurn = turnId;
       this.message = void 0;
-      const prompt = (params.input ?? []).filter((part) => typeof part?.text === "string").map((part) => ({ type: "text", text: part.text }));
+      const prompt = (params.input ?? []).map(acpContent).filter(Boolean);
+      if (prompt.some((part) => part.type === "image") && !this.takesImages()) throw new Error(`${this.provider.label} takes no images`);
       if (!this.instructionsSent && this.config?.developerInstructions) {
         prompt.unshift({ type: "text", text: `Instructions from ALP, which runs you. Follow them for this whole session.
 
@@ -199,7 +210,10 @@ ${this.config.developerInstructions}` });
         this.instructionsSent = true;
       }
       this.prompting = this.call("session/prompt", { sessionId: this.sessionId, prompt }).then(
-        (result) => this.endTurn(turnId, result?.stopReason),
+        (result) => {
+          this.turnUsage(turnId, result?.usage);
+          this.endTurn(turnId, result?.stopReason);
+        },
         (error) => this.endTurn(turnId, "error", error instanceof Error ? error.message : String(error))
       ).finally(() => {
         if (this.activeTurn === void 0 || this.activeTurn === turnId) this.prompting = void 0;
@@ -234,6 +248,12 @@ ${this.config.developerInstructions}` });
     if (!models.availableModels.some((model) => model?.modelId === wanted)) throw new Error(`${this.provider.label} has no model '${wanted}'`);
     await this.call("session/set_model", { sessionId: this.sessionId, modelId: wanted }, 3e4);
   }
+  /** The tokens of the turn the prompt response says (ACP's unstable usage), before its end. */
+  turnUsage(turnId, usage) {
+    if (this.closed || this.activeTurn !== turnId || !usage || typeof usage !== "object") return;
+    const last = { inputTokens: usage.inputTokens, outputTokens: usage.outputTokens, cachedInputTokens: usage.cachedReadTokens };
+    this.emit("thread/tokenUsage/updated", { threadId: this.sessionId, turnId, tokenUsage: { last } });
+  }
   endTurn(turnId, stopReason, error) {
     if (this.closed || this.activeTurn !== turnId) return;
     this.closeMessage();
@@ -264,22 +284,34 @@ ${this.config.developerInstructions}` });
       const id = String(update.toolCallId ?? "");
       if (!id) return;
       let call = this.toolCalls.get(id);
+      const first = !call;
+      if (call?.done) return;
       if (!call) {
         const request = acpPermission(update, this.tools.map((tool) => tool.name));
-        call = { command: request.command ?? `${request.kind}: ${request.title}`, alp: request.alpTool };
+        call = { command: request.command ?? `${request.kind}: ${request.title}`, alp: request.alpTool, state: {} };
         this.toolCalls.set(id, call);
         this.closeMessage();
-        if (!call.alp) this.emit("item/started", { threadId: this.sessionId, item: { type: "commandExecution", id, command: call.command, cwd: this.cwd, status: "inProgress", aggregatedOutput: "" } });
       }
-      if ((update.status === "completed" || update.status === "failed") && !call.alp) {
+      for (const field of ["kind", "title", "rawInput", "rawOutput", "locations", "content"]) if (update[field] !== void 0 && update[field] !== null) call.state[field] = update[field];
+      if (call.alp) return;
+      const detail = acpToolDetail(call.state);
+      const typed = detail ? { tool: call.state.title || call.state.kind || "tool", detail } : {};
+      const done = update.status === "completed" || update.status === "failed";
+      if (first) this.emit("item/started", { threadId: this.sessionId, item: { type: "commandExecution", id, command: call.command, cwd: this.cwd, status: "inProgress", aggregatedOutput: "", ...typed } });
+      else if (!done && detail) this.emit("item/updated", { threadId: this.sessionId, item: { type: "commandExecution", id, command: call.command, cwd: this.cwd, status: "inProgress", aggregatedOutput: "", ...typed } });
+      if (done) {
+        call.state = {};
+        call.done = true;
         const output = (Array.isArray(update.content) ? update.content : []).map((part) => part?.type === "content" && part.content?.type === "text" ? part.content.text : part?.type === "diff" ? `diff ${part.path}` : "").filter(Boolean).join("\n");
-        this.emit("item/completed", { threadId: this.sessionId, item: { type: "commandExecution", id, command: call.command, cwd: this.cwd, status: update.status, exitCode: update.status === "failed" ? 1 : 0, aggregatedOutput: output } });
+        const error = update.status === "failed" && detail ? { error: acpText(update.content) ?? (typeof update.rawOutput === "string" ? update.rawOutput : void 0) } : {};
+        this.emit("item/completed", { threadId: this.sessionId, item: { type: "commandExecution", id, command: call.command, cwd: this.cwd, status: update.status, exitCode: update.status === "failed" ? 1 : 0, aggregatedOutput: output, ...typed, ...error } });
       }
       return;
     }
     if (kind === "usage_update" && typeof update.used === "number") {
       const last = { totalTokens: update.used };
-      this.emit("thread/tokenUsage/updated", { threadId: this.sessionId, turnId: this.activeTurn, tokenUsage: { last, total: last, ...typeof update.size === "number" ? { modelContextWindow: update.size } : {} } });
+      const cost = update.cost?.currency === "USD" && typeof update.cost.amount === "number" ? { totalCostUsd: update.cost.amount } : {};
+      this.emit("thread/tokenUsage/updated", { threadId: this.sessionId, turnId: this.activeTurn, tokenUsage: { last, total: last, ...typeof update.size === "number" ? { modelContextWindow: update.size } : {}, ...cost } });
     }
   }
   /** The agent asks before using a tool; ALP's runtime decides, and the answer picks one of the agent's options. */
@@ -471,6 +503,7 @@ ${this.config.developerInstructions}` });
 };
 export {
   AcpTransport,
+  acpContent,
   acpDecision,
   acpEnv,
   acpPermission,

package/dist/antigravity-transport.d.ts

@@ -33,6 +33,8 @@ export declare class AntigravityTransport {
     private readonly cwd;
     private readonly env;
     private readonly provider?;
+    /** Antigravity's prompt is one line of text: no images. */
+    takesImages(): boolean;
     private child?;
     private lines?;
     private exit;

package/dist/antigravity-transport.js

@@ -8,6 +8,7 @@ import os from "node:os";
 import path from "node:path";
 import { createInterface } from "node:readline";
 import { openMcpTools } from "./mcp-tools.js";
+import { antigravityToolDetail } from "./tool-detail.js";
 var BRIDGE = `// ALP Antigravity bridge v1
 
 const net = require('node:net');
@@ -53,6 +54,10 @@ var AntigravityTransport = class {
     this.env = env;
     this.provider = provider;
   }
+  /** Antigravity's prompt is one line of text: no images. */
+  takesImages() {
+    return false;
+  }
   child;
   lines;
   exit = Promise.resolve();
@@ -331,6 +336,8 @@ ${promptText}`;
     if (step.step_type === "tool") {
       const toolName = step.tool_name || "tool";
       const callId = `agy-tool-${this.activeTurn}-${step.step_index ?? ++this.messages}`;
+      const detail = antigravityToolDetail(step.tool_info ?? { name: toolName });
+      const typed = { tool: typeof step.tool_info?.name === "string" && step.tool_info.name ? step.tool_info.name : toolName, detail };
       if (step.state === "ACTIVE") {
         this.emit("item/started", {
           threadId: this.conversationId,
@@ -340,7 +347,8 @@ ${promptText}`;
             command: toolName,
             cwd: this.cwd,
             status: "inProgress",
-            aggregatedOutput: ""
+            aggregatedOutput: "",
+            ...typed
           }
         });
       } else if (step.state === "DONE" || step.state === "ERROR") {
@@ -354,7 +362,9 @@ ${promptText}`;
             cwd: this.cwd,
             status: step.state === "DONE" ? "completed" : "failed",
             exitCode: step.state === "DONE" ? 0 : 1,
-            aggregatedOutput: output
+            aggregatedOutput: output,
+            ...typed,
+            ...step.state === "ERROR" ? { error: step.tool_info?.error?.message } : {}
           }
         });
       }

package/dist/claude-transport.d.ts

@@ -24,6 +24,20 @@ type PermissionRules = {
 /** Whether Claude Code can sandbox Bash here: Seatbelt on macOS, bubblewrap and socat on Linux. ALP_CLAUDE_SANDBOX=0 turns it off, =1 claims it (tests). */
 export declare function claudeSandboxAvailable(): boolean;
 /** What ALP asks the user for a permission Claude would otherwise not have. */
+/** One turn-input part as Claude's: text, or a data-URL image as a base64 image block. */
+export declare function claudeContent(part: any): {
+    type: string;
+    source: {
+        type: string;
+        media_type: string;
+        data: string;
+    };
+    text?: undefined;
+} | {
+    type: string;
+    text: any;
+    source?: undefined;
+};
 export type PermissionRequest = {
     tool: string;
     input: Record<string, unknown>;

package/dist/claude-transport.js

@@ -7,6 +7,7 @@ import { optionalRead, claudeUsage } from "./runtime-context.js";
 import { randomUUID } from "node:crypto";
 import { z } from "zod";
 import { PIN_KINDS } from "./board.js";
+import { claudeToolDetail, resultText } from "./tool-detail.js";
 import { CLOSE_REASONS, GATE_KINDS, TASK_STATUSES, TASK_TYPES } from "@anhlp/alp-core/tasks";
 import { commandDecision } from "@anhlp/alp-core/permissions";
 var CLAUDE_SDK = ["@anthropic-ai", "claude-agent-sdk"].join("/");
@@ -158,6 +159,11 @@ function claudeSandboxAvailable() {
   return onPath("bwrap") && onPath("socat");
 }
 var WRITERS = ["Edit", "Write", "MultiEdit", "NotebookEdit"];
+function claudeContent(part) {
+  const image = part?.type === "image" && typeof part.url === "string" ? /^data:(image\/(?:png|jpeg|gif|webp));base64,([A-Za-z0-9+/]+={0,2})$/.exec(part.url) : null;
+  if (part?.type === "image" && !image) throw new Error("Claude takes images as inline base64 PNG, JPEG, GIF or WebP only");
+  return image ? { type: "image", source: { type: "base64", media_type: image[1], data: image[2] } } : { type: "text", text: part.text };
+}
 function suggestedRule(tool, input, suggestions) {
   const suggestion = (Array.isArray(suggestions) ? suggestions : []).find((entry) => entry?.type === "addRules" && entry.behavior === "allow" && entry.rules?.length);
   const rule = suggestion?.rules[0];
@@ -365,10 +371,7 @@ var ClaudeTransport = class {
         type: "user",
         message: {
           role: "user",
-          content: params.input.map((part) => ({
-            type: "text",
-            text: part.text
-          }))
+          content: params.input.map(claudeContent)
         },
         parent_tool_use_id: null,
         uuid: randomUUID(),
@@ -558,6 +561,8 @@ var ClaudeTransport = class {
       });
     }
     if (message.type === "result") {
+      const cost = message.total_cost_usd;
+      if (typeof cost === "number" && Number.isFinite(cost) && cost >= 0) this.emit("thread/tokenUsage/updated", { threadId: this.threadId, turnId: this.activeTurn, tokenUsage: { totalCostUsd: cost } });
       const windows = Object.values(message.modelUsage ?? {}).map((entry) => entry?.contextWindow).filter((value) => typeof value === "number" && value > 0);
       if (windows.length && !this.compactAt) this.contextWindow = Math.max(...windows);
     }
@@ -573,7 +578,8 @@ var ClaudeTransport = class {
           });
         } else if (block.type === "tool_use") {
           const command = block.name === "Bash" ? String(block.input?.command ?? "") : `${block.name} ${JSON.stringify(block.input ?? {})}`;
-          this.toolCalls.set(block.id, { name: block.name, command });
+          this.toolCalls.set(block.id, { name: block.name, command, input: block.input });
+          const detail = claudeToolDetail(block.name, block.input);
           this.emit("item/started", {
             threadId: this.threadId,
             item: {
@@ -582,7 +588,8 @@ var ClaudeTransport = class {
               command,
               cwd: this.cwd,
               status: "inProgress",
-              aggregatedOutput: ""
+              aggregatedOutput: "",
+              ...detail ? { tool: block.name, detail } : {}
             }
           });
         }
@@ -591,11 +598,14 @@ var ClaudeTransport = class {
     }
     if (message.type === "user") {
       const content = Array.isArray(message.message.content) ? message.message.content : [];
-      for (const block of content) {
-        if (block.type !== "tool_result") continue;
+      const results = content.filter((block) => block.type === "tool_result");
+      const structured = results.length === 1 ? message.tool_use_result : void 0;
+      for (const block of results) {
         const call = this.toolCalls.get(block.tool_use_id);
         if (!call) continue;
         const output = typeof block.content === "string" ? block.content : JSON.stringify(block.content ?? "");
+        const text = resultText(block.content);
+        const detail = claudeToolDetail(call.name, call.input, { text, structured, error: Boolean(block.is_error) });
         this.emit("item/completed", {
           threadId: this.threadId,
           item: {
@@ -605,7 +615,8 @@ var ClaudeTransport = class {
             cwd: this.cwd,
             status: block.is_error ? "failed" : "completed",
             exitCode: block.is_error ? 1 : 0,
-            aggregatedOutput: output
+            aggregatedOutput: output,
+            ...detail ? { tool: call.name, detail, ...block.is_error ? { error: text } : {} } : {}
           }
         });
         this.toolCalls.delete(block.tool_use_id);
@@ -662,6 +673,7 @@ var ClaudeTransport = class {
 export {
   ClaudeTransport,
   SKILL_PLUGIN,
+  claudeContent,
   claudeLimited,
   claudePermissionMode,
   claudePermissions,

package/dist/contracts.d.ts

@@ -15,6 +15,8 @@ export type RuntimeTransport = {
     onFailure(listener: (error: unknown) => void): void;
     close(): Promise<void>;
     onRequest?: (listener: (method: string, params: any) => Promise<unknown>) => void;
+    /** Whether turn input may hold images (`{ type: 'image', url: 'data:…' }`); omitted, Codex and Claude do. */
+    takesImages?: () => boolean;
 };
 export type RuntimeOptions = {
     /** Native adapter overrides, isolated to this runtime; the legacy transport hook takes precedence. */
@@ -155,8 +157,12 @@ export type AlpRuntime = {
 };
 import type { SessionPreview } from '@anhlp/alp-protocol/session';
 export type { SessionPreview } from '@anhlp/alp-protocol/session';
-/** The team a viewer starts a root in when neither it nor the project's settings choose one, as Paseo does. */
-export declare const DEFAULT_TEAM = "pho";
+/**
+ * The team `alp init` names in a new project's settings (core INIT_TEAM). Kept for compatibility;
+ * it is not the default of a session: preview and create both resolve that through core
+ * `defaultTeam` (settings without workflow.mode run `custom`).
+ */
+export { INIT_TEAM as DEFAULT_TEAM } from '@anhlp/alp-core/workflow';
 import type { RecoveryOutcome, Pause, PauseState } from '@anhlp/alp-protocol/session';
 export type { RecoveryOutcome, Pause, PauseState } from '@anhlp/alp-protocol/session';
 import type { RecallAnswer } from '@anhlp/alp-protocol/session';

package/dist/contracts.js

@@ -1,5 +1,5 @@
 // packages/runtime/src/contracts.ts
-var DEFAULT_TEAM = "pho";
+import { INIT_TEAM } from "@anhlp/alp-core/workflow";
 export {
-  DEFAULT_TEAM
+  INIT_TEAM as DEFAULT_TEAM
 };

package/dist/index.d.ts

@@ -22,3 +22,5 @@ export type { Words } from './language.js';
 export type { Pin, PinKind } from './board.js';
 export { ProviderRegistry, createProviderRegistry } from './providers.js';
 export type { ProviderContext, ProviderFactory, ProviderFactories } from './providers.js';
+export { acpToolDetail, antigravityToolDetail, boundDetail, claudeToolDetail, clipText, codexToolCall, stripReadGutter, toolError, DETAIL_FILE_PATHS, DETAIL_TEXT_CHARS, DETAIL_WEB_RESULTS, ERROR_CHARS, TOOL_FAILED } from './tool-detail.js';
+export type { AcpCall, ClaudeResult, CodexToolCall, ToolCallDetail } from './tool-detail.js';

package/dist/index.js

@@ -13,6 +13,7 @@ import { OWN_START, processStartedAt, sameProcessAlive } from "./process-info.js
 import { PIN_KINDS, renderBoard, renderPin } from "./board.js";
 import { CHOICES, isVietnamese, languageInstruction, words } from "./language.js";
 import { ProviderRegistry, createProviderRegistry } from "./providers.js";
+import { acpToolDetail, antigravityToolDetail, boundDetail, claudeToolDetail, clipText, codexToolCall, stripReadGutter, toolError, DETAIL_FILE_PATHS, DETAIL_TEXT_CHARS, DETAIL_WEB_RESULTS, ERROR_CHARS, TOOL_FAILED } from "./tool-detail.js";
 export {
   AcpTransport,
   AntigravityTransport,
@@ -22,6 +23,10 @@ export {
   DEFAULT_CLAUDE_MODEL,
   DEFAULT_MODEL,
   DEFAULT_TEAM,
+  DETAIL_FILE_PATHS,
+  DETAIL_TEXT_CHARS,
+  DETAIL_WEB_RESULTS,
+  ERROR_CHARS,
   InstructionsAdapter,
   MAIL_BATCH_CHARS,
   MAIL_BODY_CHARS,
@@ -29,13 +34,20 @@ export {
   PIN_KINDS,
   ProviderRegistry,
   SKILL_PLUGIN,
+  TOOL_FAILED,
   USER,
   acpDecision,
   acpEnv,
   acpPermission,
+  acpToolDetail,
+  antigravityToolDetail,
+  boundDetail,
   claudePermissions,
   claudeSandboxAvailable,
+  claudeToolDetail,
   toolShapes as claudeToolShapes,
+  clipText,
+  codexToolCall,
   createAlpRuntime,
   createCopy,
   createProviderRegistry,
@@ -56,9 +68,11 @@ export {
   sameProcessAlive,
   skillDescription,
   skillPlugin,
+  stripReadGutter,
   takeBatch,
   thinkingOptions,
   thinkingOptionsFor,
+  toolError,
   usageAllows,
   words
 };

package/dist/resolve.js

@@ -1,7 +1,7 @@
 // packages/runtime/src/resolve.ts
 import path from "node:path";
 import { access, readFile, stat } from "node:fs/promises";
-import { resolveWorkflow } from "@anhlp/alp-core/workflow";
+import { defaultTeam, resolveWorkflow } from "@anhlp/alp-core/workflow";
 import { initProject } from "@anhlp/alp-core/init";
 import { profileModel, agentProfiles, selectedProfile } from "@anhlp/alp-core/profiles";
 import { jsonObject, resolveAgent } from "@anhlp/alp-core/resolver";
@@ -68,13 +68,13 @@ async function resolveSession(spec, options = {}) {
     if (scaffoldMissing) await initProject(spec.cwd, { ...starter, library: options.library });
     else if (!spec.restore) {
       const settings = await jsonObject(settingsFile, "INVALID_SETTINGS");
-      await initProject(spec.cwd, { ...starter, library: options.library, onlyManagedProfiles: true, teamIds: [teamOf(spec.workflow ?? settings.workflow?.mode ?? "custom")] });
+      await initProject(spec.cwd, { ...starter, library: options.library, onlyManagedProfiles: true, teamIds: [spec.workflow === void 0 ? defaultTeam(settings) : teamOf(spec.workflow)] });
     }
   }
   if (options.library) await ensureLibrary(options.library, options.templates ? { templates: options.templates } : {});
   const restored = spec.restore;
   if (restored && spec.agent !== void 0 && spec.agent !== restored.agent) throw new Error("Cannot resume a thread as a different ALP agent");
-  const { team, ...workflow } = await resolveWorkflow(spec.cwd, spec.workflow, restored?.workflow, { library: options.library, templates: options.templates });
+  const { team, ...workflow } = await resolveWorkflow(spec.cwd, spec.workflow, restored?.workflow, { library: options.library, templates: options.templates, scaffold: options.initialize === false });
   const agent = await resolveAgent(spec.cwd, { agent: spec.agent ?? restored?.agent, library: options.library, templates: options.templates });
   const oracleModels = team?.oracleModels ?? ORACLE_MODELS;
   if (agent.name === "oracle" && !restored && !oracleModels.includes(spec.model ?? "")) throw new Error(`Oracle runs on ${oracleModels.join(" or ")}; choose one`);

package/dist/runtime.js

@@ -2,10 +2,10 @@
 import { constants as fsConstants } from "node:fs";
 import { errorData, plainObject, toolResult } from "./tool-results.js";
 import { createLogger } from "@anhlp/alp-core/log";
+import { PROMPT_IMAGES, base64Bytes } from "@anhlp/alp-protocol";
 import { createBoardDomain } from "./board-domain.js";
 import { createWorktreeDomain } from "./worktree-domain.js";
 import { DEFAULT_TEAM } from "./contracts.js";
-import { DEFAULT_TEAM as DEFAULT_TEAM2 } from "./contracts.js";
 import { verdictLine, parseHandoff } from "./handoff.js";
 import { TASK_ACTIONS, TASK_PAST, TASK_FIELDS, mainOf, roleOf, taskActions, taskBrief } from "./tools.js";
 import { nativeEnvironment, createTransport } from "./providers.js";
@@ -36,9 +36,10 @@ import { OWN_START, sameProcessAlive } from "./process-info.js";
 import { createRecallBook, recallPrompt, RECALL_KEEP_MS, RECALL_QUESTION_CHARS, RECALL_TIMEOUT_MS } from "./recall.js";
 import { branchExists, checkoutFingerprint, checkoutKey, createCopy, createWorktree, reattachWorktree, removeCopy, removeWorktree } from "./workspace.js";
 import { claudeSandboxAvailable, SKILL_PLUGIN } from "./claude-transport.js";
+import { boundDetail, codexToolCall, toolError } from "./tool-detail.js";
 import { ALP_REPO, gh, projectRepo } from "./github.js";
 import { optionalRead, usageAllows, COMPACT_SHARE } from "./runtime-context.js";
-import { providerUsage } from "./usage.js";
+import { providerUsage, sessionUsage } from "./usage.js";
 import { parse as toml } from "smol-toml";
 import { findFormula, formulaDirs, listFormulas, pourFormula } from "@anhlp/alp-core/formulas";
 import { addAllowRule, capMode, commandDecision, profileFor, unwrapShell } from "@anhlp/alp-core/permissions";
@@ -119,6 +120,9 @@ function createAlpRuntime(options = {}) {
     });
     return run;
   }
+  function takesImages(session) {
+    return session.runtime.takesImages ? session.runtime.takesImages() : session.runtimeKind === "codex" || session.runtimeKind === "claude";
+  }
   function snapshot(sessionId, session) {
     return {
       id: sessionId,
@@ -137,6 +141,8 @@ function createAlpRuntime(options = {}) {
       ...session.active ? { activeTurnId: session.active } : {},
       ...session.parked ? { parked: session.parked.reason } : {},
       ...session.instructionsSha ? { instructionsSha: session.instructionsSha } : {},
+      ...takesImages(session) ? { promptImages: true } : {},
+      ...session.usage ? { usage: session.usage } : {},
       busy: !!(session.active || session.pending || session.children.size || session.assignments.size || hasActiveMail(session) || reviewing(session))
     };
   }
@@ -186,7 +192,7 @@ function createAlpRuntime(options = {}) {
     }
     session.settle?.(state, error);
   }
-  function nativeItem(sessionId, session, item) {
+  function nativeItem(sessionId, session, item, done = false) {
     if (item.type === "agentMessage") {
       if (session.userWaiting !== void 0 && String(item.text ?? "").trim()) {
         if (session.supervisor) session.journal.push(stamp(`${session.mapping.agent.name} answered the user ${span(Date.now() - session.userWaiting)} after their message of ${clock(session.userWaiting)}`));
@@ -198,7 +204,8 @@ function createAlpRuntime(options = {}) {
     }
     if (item.type === "userMessage") {
       const text2 = (item.content ?? []).filter((c) => c.type === "text").map((c) => c.text).join("\n");
-      emit(sessionId, { type: "item", item: { kind: "user_message", id: item.id, text: text2 } });
+      const images = (item.content ?? []).filter((c) => c.type === "image" || c.type === "localImage").length;
+      emit(sessionId, { type: "item", item: { kind: "user_message", id: item.id, text: text2, ...images ? { images } : {} } });
       return;
     }
     if (item.type === "dynamicToolCall") {
@@ -229,24 +236,33 @@ function createAlpRuntime(options = {}) {
       if (session.supervisor && status !== "running") {
         session.journal.push(stamp(`${session.mapping.agent.name} shell ${status}${item.exitCode != null ? ` (exit ${item.exitCode})` : ""}: ${clip(String(item.command ?? ""))}`));
       }
+      const typed = item.detail && typeof item.detail === "object" && item.detail.type !== "shell" ? boundDetail(item.detail) : void 0;
       emit(sessionId, {
         type: "item",
         item: {
           kind: "tool_call",
           id: item.id,
           callId: item.id,
-          name: "shell",
+          name: typed ? String(item.tool || "tool") : "shell",
           status,
-          ...status === "failed" ? { error: "Command failed" } : {},
-          detail: {
+          ...status === "failed" ? { error: typed ? toolError(item.error) : "Command failed" } : {},
+          detail: typed ?? (item.detail?.type === "shell" ? item.detail : {
             type: "shell",
             command: item.command,
             cwd: item.cwd,
             output: item.aggregatedOutput ?? "",
             exitCode: item.exitCode
-          }
+          })
         }
       });
+      return;
+    }
+    const call = codexToolCall(item, done);
+    if (call) {
+      emit(sessionId, {
+        type: "item",
+        item: { kind: "tool_call", id: item.id, callId: item.id, name: call.name, status: call.status, ...call.error ? { error: call.error } : {}, detail: call.detail }
+      });
     }
   }
   function notification(sessionId, session, method, params) {
@@ -270,17 +286,26 @@ function createAlpRuntime(options = {}) {
     if (method === "item/completed" || method === "item/started") {
       if (method === "item/completed") session.progressAt = Date.now();
       if (params.item?.type !== "userMessage") {
-        nativeItem(sessionId, session, params.item);
+        nativeItem(sessionId, session, params.item, method === "item/completed");
       }
       if (method === "item/started" && params.item?.type === "commandExecution") watchCopy(sessionId, session, params.item);
       if (method === "item/started" && params.item) skillUse(sessionId, session, params.item);
       return;
     }
+    if (method === "item/updated") {
+      if (params.item?.type === "commandExecution" && params.item.status === "inProgress") nativeItem(sessionId, session, params.item);
+      return;
+    }
     if (method === "account/rateLimits/updated") {
       usageReport(session, params);
       return;
     }
     if (method === "thread/tokenUsage/updated") {
+      const usage2 = sessionUsage(session.usage, params?.tokenUsage);
+      if (usage2) {
+        session.usage = usage2;
+        emit(sessionId, { type: "usage", usage: usage2 });
+      }
       contextReport(sessionId, session, params?.tokenUsage);
       return;
     }
@@ -2656,12 +2681,20 @@ Write scope: change files only under ${session.spec.writeRoot}. Your working dir
     )) {
       return;
     }
-    if (prompt.content.some(
-      (content) => content.type !== "text"
-    )) {
-      throw new Error(
-        "Only text prompts are supported"
-      );
+    if (prompt.content.some((content) => content.type !== "text" && content.type !== "image")) {
+      throw new Error("Only text and image prompts are supported");
+    }
+    const images = prompt.content.filter((content) => content.type === "image");
+    if (images.length) {
+      if (!takesImages(session)) throw new Error(`${session.runtimeKind === "acp" ? "This ACP agent" : session.runtimeKind[0].toUpperCase() + session.runtimeKind.slice(1)} takes no images; send the message as text`);
+      if (images.length > PROMPT_IMAGES.maxCount) throw new Error(`A prompt takes at most ${PROMPT_IMAGES.maxCount} images`);
+      if (images.reduce((sum, image) => sum + (typeof image.data === "string" ? base64Bytes(image.data) : 0), 0) > PROMPT_IMAGES.maxTotalBytes) throw new Error(`The images of a prompt are at most ${PROMPT_IMAGES.maxTotalBytes} bytes together`);
+      for (const image of images) {
+        const keys = Object.keys(image).filter((key) => !["type", "mimeType", "data", "name"].includes(key));
+        if (keys.length || !PROMPT_IMAGES.mimeTypes.includes(image.mimeType) || typeof image.data !== "string" || !/^[A-Za-z0-9+/]+={0,2}$/.test(image.data) || base64Bytes(image.data) > PROMPT_IMAGES.maxBytes) {
+          throw new Error(`An image must be inline base64 ${PROMPT_IMAGES.mimeTypes.join(", ")} of at most ${PROMPT_IMAGES.maxBytes} bytes`);
+        }
+      }
     }
     if (prompt.delivery === "steer" && !session.active) {
       throw new Error(
@@ -2673,9 +2706,7 @@ Write scope: change files only under ${session.spec.writeRoot}. Your working dir
         "Turn already active; use steering or interrupt first"
       );
     }
-    const text2 = prompt.content.map(
-      (content) => content.text ?? ""
-    ).join("\n");
+    const text2 = prompt.content.filter((content) => content.type === "text").map((content) => content.text ?? "").join("\n");
     const mail = wake ?? (prompt.delivery === "steer" ? [] : takeBatch(session.mail, () => true));
     for (const event of mail) event.deliveredTurn = STARTING;
     session.pending = true;
@@ -2712,6 +2743,7 @@ ${interrupted}`), text_elements: [] }] : [],
           text: origin === "user" ? text2 : promptSafe(text2),
           text_elements: []
         },
+        ...images.map((image) => ({ type: "image", url: `data:${image.mimeType};base64,${image.data}` })),
         ...mail.length && !wake ? [{ type: "text", text: promptSafe(renderMail(mail, session.parentAgent)), text_elements: [] }] : []
       ];
       const result = prompt.delivery === "steer" ? await session.runtime.request(
@@ -2744,7 +2776,8 @@ ${interrupted}`), text_elements: [] }] : [],
           kind: "user_message",
           id: `user:${prompt.clientMessageId}`,
           clientMessageId: prompt.clientMessageId,
-          text: text2
+          text: text2,
+          ...images.length ? { images: images.length } : {}
         }
       });
       if (origin === "user" && !session.parent) session.userWaiting ??= Date.now();
@@ -2893,10 +2926,7 @@ ${interrupted}`), text_elements: [] }] : [],
     },
     async preview(spec) {
       const resolveOptions = { templates: options.templates, library: options.libraryDir, language: options.language };
-      const settings = JSON.parse(await readFile(path.join(spec.cwd, ".alp", "settings.json"), "utf8").catch(() => "{}"));
-      const named = typeof settings?.workflow?.mode === "string" && settings.workflow.mode !== "custom" ? settings.workflow.mode : void 0;
-      const workflow = spec.workflow ?? named ?? DEFAULT_TEAM;
-      const mapping = await resolveSession({ ...spec, workflow }, { ...resolveOptions, initialize: false });
+      const mapping = await resolveSession(spec, { ...resolveOptions, initialize: false });
       const teams = (await listTeams(spec.cwd, { library: options.libraryDir, templates: options.templates })).filter((team) => !team.error).map((team) => ({ id: team.id, label: team.label ?? team.id, ...team.description ? { description: team.description } : {} }));
       return {
         teams,
@@ -2974,6 +3004,6 @@ ${interrupted}`), text_elements: [] }] : [],
   };
 }
 export {
-  DEFAULT_TEAM2 as DEFAULT_TEAM,
+  DEFAULT_TEAM,
   createAlpRuntime
 };