@armadra/agent 0.4.0 → 0.5.0

package/dist/modes/acp/acp-server.js

@@ -0,0 +1,315 @@
+/**
+ * `ama --mode acp`：把 ama 的会话暴露为 ACP Agent（docs/wave5-plan.md §5.6，D14）。[W5-E]
+ *
+ * 与 `--mode rpc` 同一引擎（Runtime + 组装根的会话切换），一次只有一个活动会话：
+ * - `session/new` 新开（启动时那个空会话第一次直接认领）；`session/load` 切到该会话并回放历史；
+ *   `session/resume` 切换不回放；`session/list` 列本 cwd 的会话；`session/close` 中断并释放；
+ *   对非活动会话发 `session/prompt` 时（空闲）先切过去。
+ * - `session/prompt` → `prompt`（文本 + 图片；资源链接以 `@uri` 文本给出，嵌入资源取文本）；
+ *   回合结束按会话状态给 stopReason：中断 → cancelled，输出截断 → max_tokens，出错 → JSON-RPC 错误。
+ * - `session/cancel` → `abort`；`session/set_mode` → `setPermissionMode`（模式 id = ama 权限模式）。
+ * - 审批：ama 的审批请求经 `session/request_permission` 交给客户端（允许 / 本会话允许 / 拒绝）；
+ *   客户端回 cancelled、连接断开或回合被中断 → 交给链上下一个回答者（无人 → 拒绝）。
+ * - 不声明 / 不使用客户端的 `fs`、`terminal` 能力（Armadra Q5）；ama 自己读写、自己跑命令。
+ * - cwd 固定为启动目录（信任与项目配置都按它判定）；客户端给别的 cwd → invalid params。
+ */
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+import { currentSession, switchSession } from "../../cli/compose-session.js";
+import { listSessions } from "../../cli/compose-store.js";
+import { AgentSessionImpl } from "../../agent/session.js";
+import { JsonRpcPeer, RpcError } from "../../drivers/jsonrpc.js";
+import { ACP_METHODS, ACP_PROTOCOL_VERSION, RPC_ERRORS, } from "../../drivers/acp/types.js";
+import { isPermissionMode } from "../../permissions/modes.js";
+import { AMA_VERSION } from "../../version.js";
+import { errorText } from "../shared.js";
+import { AcpEventMapper, permissionModes, toolKind, toolLocations, toolTitle, } from "./acp-events.js";
+export const ACP_AGENT_CAPABILITIES = {
+    loadSession: true,
+    promptCapabilities: { image: true, audio: false, embeddedContext: true },
+    mcpCapabilities: { http: false, sse: false },
+    sessionCapabilities: { list: {}, resume: {}, close: {} },
+};
+/** 解析符号链接后的绝对路径（macOS 的 /var → /private/var 等）；不存在时退回 resolve。 */
+function canonical(path) {
+    try {
+        return realpathSync.native(resolve(path));
+    }
+    catch {
+        return resolve(path);
+    }
+}
+function str(params, key) {
+    const value = params[key];
+    if (typeof value !== "string" || value === "")
+        throw new RpcError(RPC_ERRORS.invalidParams, `缺少 ${key}`);
+    return value;
+}
+/** ACP 提示 → ama 的文本与图片。 */
+export function promptOf(blocks) {
+    if (!Array.isArray(blocks))
+        throw new RpcError(RPC_ERRORS.invalidParams, "prompt 应为内容块数组");
+    const parts = [];
+    const images = [];
+    for (const block of blocks) {
+        if (block.type === "text")
+            parts.push(block.text);
+        else if (block.type === "image")
+            images.push({ type: "image", data: block.data, mimeType: block.mimeType });
+        else if (block.type === "resource_link")
+            parts.push(`@${block.uri}`);
+        else if (block.type === "resource" && typeof block.resource.text === "string")
+            parts.push(`<resource uri="${block.resource.uri}">\n${block.resource.text}\n</resource>`);
+    }
+    return { text: parts.join("\n"), images };
+}
+export class AcpServer {
+    runtime;
+    log;
+    peer;
+    activeId;
+    /** 启动时的空会话还没被 session/new 认领。 */
+    freshUnclaimed = true;
+    mapper;
+    unsubscribe = () => undefined;
+    cancelRequested = false;
+    cwd;
+    constructor(runtime, streams, log = () => undefined) {
+        this.runtime = runtime;
+        this.log = log;
+        this.cwd = canonical(runtime.paths.cwd);
+        this.mapper = this.makeMapper();
+        this.peer = new JsonRpcPeer({
+            input: streams.input,
+            output: streams.output,
+            onRequest: (method, params) => this.handle(method, (params ?? {})),
+            onNotification: (method, params) => {
+                if (method === ACP_METHODS.sessionCancel)
+                    void this.cancel((params ?? {}));
+            },
+            onProtocolError: (_line, reason) => this.log(`ACP：无法解析的输入（${reason}）`),
+        });
+        this.subscribe();
+    }
+    session() {
+        return currentSession(this.runtime);
+    }
+    /** 审批交给客户端：ama 的 UI broker。 */
+    broker = {
+        ask: (request, signal) => this.askClient(request, signal),
+    };
+    makeMapper() {
+        return new AcpEventMapper(this.cwd, (update) => this.emit(update), () => this.session());
+    }
+    emit(update) {
+        if (this.activeId === undefined)
+            return;
+        void this.peer.notify(ACP_METHODS.sessionUpdate, { sessionId: this.activeId, update });
+    }
+    subscribe() {
+        this.unsubscribe();
+        const mapper = this.mapper;
+        this.unsubscribe = this.session().subscribe((event) => mapper.onEvent(event));
+    }
+    dispose() {
+        this.unsubscribe();
+    }
+    async handle(method, params) {
+        switch (method) {
+            case ACP_METHODS.initialize:
+                return this.initialize(params);
+            case ACP_METHODS.sessionNew:
+                return this.newSession(params);
+            case ACP_METHODS.sessionLoad:
+                return this.openSession(params, true);
+            case ACP_METHODS.sessionResume:
+                return this.openSession(params, false);
+            case ACP_METHODS.sessionList:
+                return this.list();
+            case ACP_METHODS.sessionClose:
+                return this.close(params);
+            case ACP_METHODS.sessionPrompt:
+                return this.prompt(params);
+            case ACP_METHODS.sessionSetMode:
+                return this.setMode(params);
+            default:
+                throw new RpcError(RPC_ERRORS.methodNotFound, `method not found: ${method}`);
+        }
+    }
+    initialize(params) {
+        if (typeof params["protocolVersion"] !== "number")
+            throw new RpcError(RPC_ERRORS.invalidParams, "缺少 protocolVersion");
+        return {
+            protocolVersion: ACP_PROTOCOL_VERSION,
+            agentCapabilities: ACP_AGENT_CAPABILITIES,
+            authMethods: [],
+            agentInfo: { name: "ama", title: "ama", version: AMA_VERSION },
+        };
+    }
+    checkCwd(params) {
+        const cwd = params["cwd"];
+        if (cwd === undefined)
+            return;
+        if (typeof cwd !== "string" || canonical(cwd) !== this.cwd)
+            throw new RpcError(RPC_ERRORS.invalidParams, `ama --mode acp 的会话目录固定为启动目录 ${this.cwd}（收到 ${String(cwd)}）`);
+    }
+    modes() {
+        return permissionModes(this.session().state.permissionMode);
+    }
+    async switchTo(next, reason) {
+        const session = await next;
+        this.mapper = this.makeMapper();
+        this.subscribe();
+        if (session instanceof AgentSessionImpl)
+            session.announceStart(reason);
+    }
+    async newSession(params) {
+        this.checkCwd(params);
+        const current = this.session();
+        if (this.freshUnclaimed && current.messages.length === 0) {
+            this.freshUnclaimed = false;
+        }
+        else {
+            this.ensureIdle();
+            await this.switchTo(switchSession(this.runtime, { kind: "new" }), "new");
+        }
+        this.activeId = this.session().state.sessionId;
+        return { sessionId: this.activeId, modes: this.modes() };
+    }
+    async openSession(params, replay) {
+        const id = str(params, "sessionId");
+        this.checkCwd(params);
+        if (this.session().state.sessionId !== id) {
+            this.ensureIdle();
+            try {
+                await this.switchTo(switchSession(this.runtime, { kind: "resume", id }), "resume");
+            }
+            catch (error) {
+                throw new RpcError(RPC_ERRORS.resourceNotFound, `找不到会话 ${id}：${errorText(error)}`);
+            }
+        }
+        this.freshUnclaimed = false;
+        this.activeId = id;
+        if (replay) {
+            this.mapper.replay(this.session().messages);
+            await this.peer.flush();
+        }
+        return { modes: this.modes() };
+    }
+    list() {
+        // 会话目录按 ama 启动时的 cwd 字串分组（不是 realpath）
+        const items = listSessions({
+            sessionDir: this.runtime.paths.sessionDir,
+            cwd: this.runtime.paths.cwd,
+        });
+        return {
+            sessions: items.map((item) => ({
+                sessionId: item.id,
+                cwd: item.cwd,
+                title: item.name ?? item.firstPrompt ?? null,
+                updatedAt: item.modifiedAt,
+            })),
+        };
+    }
+    async close(params) {
+        const id = str(params, "sessionId");
+        if (id === this.activeId) {
+            if (this.session().state.isStreaming)
+                await this.session().abort();
+            this.activeId = undefined;
+        }
+        return {};
+    }
+    ensureIdle() {
+        if (this.session().state.isStreaming)
+            throw new RpcError(RPC_ERRORS.invalidRequest, "当前会话正在运行，先 session/cancel");
+    }
+    async prompt(params) {
+        const id = str(params, "sessionId");
+        if (id !== this.activeId)
+            await this.openSession({ sessionId: id }, false);
+        const { text, images } = promptOf(params["prompt"]);
+        const session = this.session();
+        const before = session.getStats().tokens;
+        this.cancelRequested = false;
+        try {
+            await session.prompt(text, images.length > 0 ? { images } : {});
+        }
+        catch (error) {
+            throw new RpcError(RPC_ERRORS.internalError, errorText(error));
+        }
+        await this.peer.flush();
+        const after = session.getStats().tokens;
+        const usage = {
+            inputTokens: after.input - before.input,
+            outputTokens: after.output - before.output,
+            cachedReadTokens: after.cacheRead - before.cacheRead,
+            cachedWriteTokens: after.cacheWrite - before.cacheWrite,
+            totalTokens: after.total - before.total,
+        };
+        const last = [...session.messages].reverse().find((m) => "role" in m && m.role === "assistant");
+        const reason = last !== undefined && "stopReason" in last ? last.stopReason : "stop";
+        if (this.cancelRequested || reason === "aborted")
+            return { stopReason: "cancelled", usage };
+        if (reason === "error") {
+            const message = last !== undefined && "errorMessage" in last ? last.errorMessage : undefined;
+            throw new RpcError(RPC_ERRORS.internalError, message ?? "模型请求失败");
+        }
+        return { stopReason: reason === "length" ? "max_tokens" : "end_turn", usage };
+    }
+    async cancel(params) {
+        if (params["sessionId"] !== this.activeId)
+            return;
+        this.cancelRequested = true;
+        await this.session()
+            .abort()
+            .catch(() => undefined);
+    }
+    setMode(params) {
+        str(params, "sessionId");
+        const mode = params["modeId"];
+        if (!isPermissionMode(mode))
+            throw new RpcError(RPC_ERRORS.invalidParams, `未知模式：${String(mode)}`);
+        this.session().setPermissionMode(mode);
+        return {};
+    }
+    async askClient(request, signal) {
+        const sessionId = this.activeId;
+        if (sessionId === undefined || !this.peer.isOpen)
+            return undefined;
+        const toolCallId = this.mapper.toolCallIdFor(request.toolName, request.input) ?? request.requestId;
+        const locations = toolLocations(request.input, this.cwd);
+        let answer;
+        try {
+            answer = await this.peer.request(ACP_METHODS.requestPermission, {
+                sessionId,
+                toolCall: {
+                    toolCallId,
+                    title: toolTitle(request.toolName, request.input),
+                    kind: toolKind(request.toolName),
+                    status: "pending",
+                    rawInput: request.input,
+                    ...(locations !== undefined ? { locations } : {}),
+                },
+                options: [
+                    { optionId: "allow_once", name: "允许", kind: "allow_once" },
+                    { optionId: "allow_always", name: "本会话允许", kind: "allow_always" },
+                    { optionId: "reject_once", name: "拒绝", kind: "reject_once" },
+                ],
+            }, signal);
+        }
+        catch {
+            return undefined;
+        }
+        const outcome = answer?.outcome;
+        if (outcome?.outcome !== "selected")
+            return undefined;
+        if (outcome.optionId === "allow_once")
+            return "allow";
+        if (outcome.optionId === "allow_always")
+            return "allow_session";
+        if (outcome.optionId === "reject_once")
+            return "deny";
+        return undefined;
+    }
+}

package/dist/modes/commands-core.d.ts

@@ -8,14 +8,20 @@
  *   `pick`（需要界面弹选择器，参数缺省时）、`exit`。
  *
  * 会话切换（/new /resume /fork）经 `ctx.switchSession`，调用方据返回的新会话重新订阅事件。
+ * `/rewind`（RW-C）：无参数列出回滚点，带参数执行（interactive/rewind-command.ts）；对话变了时
+ * `handled` 带 `draft`（原消息）与 `reload`，界面据此回填输入框、重画消息区。
  */
-import type { AgentSession } from "../agent/types.js";
+import type { AgentSession, RewindDraftText } from "../agent/types.js";
 import type { SwitchRequest } from "../cli/compose-session.js";
 import type { Runtime } from "../cli/runtime.js";
 export { describeSession } from "./session-report.js";
 export type CommandResult = {
     kind: "handled";
     message?: string;
+    draft?: RewindDraftText;
+    reload?: boolean;
+    /** [W5-U] 命令开了一个新回合（`/plan approve`）：line 模式等它跑完再收下一行。 */
+    wait?: boolean;
 } | {
     kind: "prompt";
     text: string;

package/dist/modes/commands-core.js

@@ -8,12 +8,18 @@
  *   `pick`（需要界面弹选择器，参数缺省时）、`exit`。
  *
  * 会话切换（/new /resume /fork）经 `ctx.switchSession`，调用方据返回的新会话重新订阅事件。
+ * `/rewind`（RW-C）：无参数列出回滚点，带参数执行（interactive/rewind-command.ts）；对话变了时
+ * `handled` 带 `draft`（原消息）与 `reload`，界面据此回填输入框、重画消息区。
  */
 import { AgentSessionImpl } from "../agent/session.js";
 import { WARMING_MODES } from "../ai/cache/types.js";
 import { THINKING_LEVELS } from "../ai/thinking.js";
 import { AmaError } from "../errors.js";
 import { PERMISSION_MODE_ORDER, parsePermissionMode, permissionModeLabel, } from "../permissions/modes.js";
+import { pasteImage } from "./interactive/clipboard-paste.js";
+import { planCommand } from "./interactive/plan-command.js";
+import { rewindCommand } from "./interactive/rewind-command.js";
+import { describeAgents, describeTaskOutput, describeTasks, stopTask, } from "./interactive/tasks-report.js";
 import { describeCache, describeFingerprint, describeSession } from "./session-report.js";
 export { describeSession } from "./session-report.js";
 export const BUILTIN_COMMANDS = [
@@ -22,6 +28,11 @@ export const BUILTIN_COMMANDS = [
     { name: "resume", args: "[id]", description: "恢复会话（无 id 时选择）" },
     { name: "fork", args: "[条目 id]", description: "从某条目分叉出新会话" },
     { name: "compact", args: "[说明]", description: "压缩上下文" },
+    {
+        name: "rewind",
+        args: "[n] [both|conversation|code|summarize-from|summarize-up-to]",
+        description: "回滚对话与代码到某条消息之前",
+    },
     { name: "model", args: "[provider/id]", description: "切换模型" },
     {
         name: "thinking",
@@ -41,6 +52,15 @@ export const BUILTIN_COMMANDS = [
         args: "[warm off|streaming|idle | fingerprint]",
         description: "缓存统计；切换本会话保温；打印前缀指纹",
     },
+    { name: "statusline", args: "[full|compact]", description: "底部信息行两行 / 一行（Ctrl+G）" },
+    {
+        name: "plan",
+        args: "[目标] | approve [模式|fresh] | reject",
+        description: "查看计划与状态；带目标进入 Plan 模式；批准 / 放弃待审批的计划",
+    },
+    { name: "tasks", args: "[id] | stop <id>", description: "子 Agent 任务：状态、输出、停止" },
+    { name: "agents", description: "子 Agent 类型与外部 Agent（安装状态、版本）" },
+    { name: "paste", description: "粘贴剪贴板里的图片（Ctrl+V）" },
     { name: "exit", description: "退出" },
 ];
 const ALIASES = { quit: "exit", q: "exit", "?": "help" };
@@ -80,6 +100,20 @@ function cacheCommand(session, args) {
     }
     throw new AmaError("invalid_arguments", "用法：/cache [warm off|streaming|idle | fingerprint]");
 }
+/** `/tasks`、`/tasks <id>`、`/tasks stop <id>`。 */
+async function tasksCommand(sessionId, args) {
+    const [first, second, extra] = args.split(/\s+/).filter((s) => s !== "");
+    const now = Date.now();
+    if (first === undefined)
+        return describeTasks(sessionId, now);
+    if (first === "stop" && second !== undefined && extra === undefined) {
+        await stopTask(sessionId, second);
+        return `已停止 ${second}`;
+    }
+    if (second === undefined)
+        return describeTaskOutput(sessionId, first, now);
+    throw new AmaError("invalid_arguments", "用法：/tasks [id] | /tasks stop <id>");
+}
 export async function runSlashCommand(line, ctx) {
     const parsed = parseSlash(line);
     if (parsed === undefined)
@@ -166,6 +200,27 @@ export async function runSlashCommand(line, ctx) {
             return { kind: "handled", message: describeSession(session) };
         case "cache":
             return { kind: "handled", message: cacheCommand(session, args) };
+        case "rewind":
+            return { kind: "handled", ...(await rewindCommand(session, args)) };
+        case "plan":
+            return planCommand(session, args, ctx);
+        case "tasks":
+            return { kind: "handled", message: await tasksCommand(session.state.sessionId, args) };
+        case "agents":
+            return { kind: "handled", message: describeAgents(session.state.sessionId) };
+        case "paste": {
+            const pasted = await pasteImage(ctx.runtime.paths.dataDir);
+            return pasted.ok
+                ? {
+                    kind: "handled",
+                    message: `已粘贴图片：${pasted.path}`,
+                    draft: { text: `${pasted.ref} ` },
+                }
+                : { kind: "handled", message: pasted.message };
+        }
+        case "statusline":
+            // [W5-A] 交互界面在 commands-core 之前自己处理；line 模式没有底部信息行
+            return { kind: "handled", message: "/statusline 只在交互界面可用" };
         default:
             return undefined;
     }

package/dist/modes/image-input.d.ts

@@ -6,10 +6,13 @@
  *   → 报错，不发请求；
  * - 不带 `@` 的词只在「以图片扩展名结尾且文件存在」时才算附件，当前模型不收图片时静默忽略（用户可能
  *   只是在文字里提到一个文件）；
- * - 与 read 工具共用 image-file.ts 的 MIME 检测与 5 MB 上限。提示文字原样保留。
+ * - 与 read 工具共用 image-file.ts 的 MIME 检测与单图上限（[W5-I] 按当前模型的端点分档，base64 后
+ *   计算，见 ai/image-limits.ts）。提示文字原样保留。
  */
 import type { AgentSession } from "../agent/types.js";
-import type { ImageBlock, Model, ProviderRegistryApi } from "../ai/types.js";
+import type { ImageBlock, Model, ModelRef, ProviderRegistryApi } from "../ai/types.js";
+import type { ImagesConfig } from "../config/types-w5.js";
+import { type ImageFitOptions } from "../tools/image-file.js";
 export interface ImageRef {
     path: string;
     /** `@路径` 或 `--image`：显式附件。 */
@@ -22,6 +25,11 @@ export declare function sessionModel(providers: ProviderRegistryApi, session: Ag
 /**
  * 读出附件：显式附件遇到模型不收图片 → AmaError（提示换模型）；隐式附件此时忽略。
  */
-export declare function loadPromptImages(refs: readonly ImageRef[], model: Model | undefined): Promise<ImageBlock[]>;
+export declare function loadPromptImages(refs: readonly ImageRef[], model: Model | undefined, options?: ImageFitOptions): Promise<ImageBlock[]>;
 /** 提示 + 额外的显式图片路径（`--image`）→ 附件。 */
-export declare function promptImages(text: string, extra: readonly string[], cwd: string, model: Model | undefined): Promise<ImageBlock[]>;
+export declare function promptImages(text: string, extra: readonly string[], cwd: string, model: Model | undefined, options?: ImageFitOptions): Promise<ImageBlock[]>;
+/**
+ * read 工具的单图选项（compose.ts 接线）：按会话当前模型的端点分档（查不到模型时用缺省 5 MB），
+ * 缩放按 `images.resize`。
+ */
+export declare function imageFitOptionsFor(providers: ProviderRegistryApi | undefined, ref: ModelRef | undefined, images?: ImagesConfig): ImageFitOptions;

package/dist/modes/image-input.js

@@ -6,13 +6,15 @@
  *   → 报错，不发请求；
  * - 不带 `@` 的词只在「以图片扩展名结尾且文件存在」时才算附件，当前模型不收图片时静默忽略（用户可能
  *   只是在文字里提到一个文件）；
- * - 与 read 工具共用 image-file.ts 的 MIME 检测与 5 MB 上限。提示文字原样保留。
+ * - 与 read 工具共用 image-file.ts 的 MIME 检测与单图上限（[W5-I] 按当前模型的端点分档，base64 后
+ *   计算，见 ai/image-limits.ts）。提示文字原样保留。
  */
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
 import { formatModelRef } from "../ai/providers/channels.js";
 import { AmaError } from "../errors.js";
+import { imageLimits } from "../ai/image-limits.js";
 import { imageMimeFromPath, loadImageFile } from "../tools/image-file.js";
 const TOKEN = /@?"([^"]+)"|@?'([^']+)'|((?:\\ |\S)+)/g;
 function expand(path, cwd) {
@@ -52,7 +54,7 @@ export function sessionModel(providers, session) {
 /**
  * 读出附件：显式附件遇到模型不收图片 → AmaError（提示换模型）；隐式附件此时忽略。
  */
-export async function loadPromptImages(refs, model) {
+export async function loadPromptImages(refs, model, options = {}) {
     const accepts = model === undefined || model.input.includes("image");
     const wanted = refs.filter((ref) => ref.explicit || accepts);
     if (wanted.length === 0)
@@ -62,17 +64,32 @@ export async function loadPromptImages(refs, model) {
         throw new AmaError("invalid_arguments", `${name} 不接受图片输入（模型 input 没有 image）；换一个支持图像的模型再试` +
             `（ama models list 里标「图片」的，或在配置里给该模型写 "input": ["text", "image"]）`);
     }
+    const fit = {
+        ...(model !== undefined ? { maxBase64Bytes: imageLimits(model).perImageBase64 } : {}),
+        ...options,
+    };
     const blocks = [];
     for (const ref of wanted)
-        blocks.push((await loadImageFile(ref.path)).block);
+        blocks.push((await loadImageFile(ref.path, fit)).block);
     return blocks;
 }
 /** 提示 + 额外的显式图片路径（`--image`）→ 附件。 */
-export async function promptImages(text, extra, cwd, model) {
+export async function promptImages(text, extra, cwd, model, options = {}) {
     const refs = [
         ...extra.map((path) => ({ path: expand(path, cwd), explicit: true })),
         ...findImageRefs(text, cwd),
     ];
     const unique = refs.filter((ref, i) => refs.findIndex((r) => r.path === ref.path) === i);
-    return loadPromptImages(unique, model);
+    return loadPromptImages(unique, model, options);
+}
+/**
+ * read 工具的单图选项（compose.ts 接线）：按会话当前模型的端点分档（查不到模型时用缺省 5 MB），
+ * 缩放按 `images.resize`。
+ */
+export function imageFitOptionsFor(providers, ref, images) {
+    const resize = images?.resize !== undefined ? { resize: images.resize } : {};
+    if (providers === undefined || ref === undefined)
+        return resize;
+    const found = providers.findModel(formatModelRef(ref));
+    return found.ok ? { maxBase64Bytes: imageLimits(found.model).perImageBase64, ...resize } : resize;
 }

package/dist/modes/interactive/agent-panels.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 第五波的消息区面板（左竖条卡片，与 `/session` 同一手法）：`/plan`、`/agents`、`/tasks` 展开的任务输出。
+ * [W5-U] line 模式用 plan-command.ts / tasks-report.ts 的文本版。
+ */
+import type { AgentSession } from "../../agent/types.js";
+import type { PlanController } from "../../plan/controller.js";
+import type { TaskInfo } from "../../tools/types.js";
+import { type Component, type Theme } from "../../tui.js";
+/** `/plan`：当前计划、状态、模式、步骤与待办进度。 */
+export declare function planPanel(controller: PlanController, session: AgentSession, theme: Theme, displayPath?: (path: string) => string): Component;
+/** `/agents`：类型、runner、来源、安装状态与版本、说明。 */
+export declare function agentsPanel(sessionId: string, theme: Theme): Component;
+/** `/tasks` 选中一个任务：状态行 + 输出全文（运行中为已有输出）。 */
+export declare function taskOutputPanel(task: TaskInfo, output: string | undefined, theme: Theme, now: number, displayPath?: (path: string) => string): Component;

package/dist/modes/interactive/agent-panels.js

@@ -0,0 +1,103 @@
+/**
+ * 第五波的消息区面板（左竖条卡片，与 `/session` 同一手法）：`/plan`、`/agents`、`/tasks` 展开的任务输出。
+ * [W5-U] line 模式用 plan-command.ts / tasks-report.ts 的文本版。
+ */
+import { permissionModeLabel } from "../../permissions/modes.js";
+import { executionMode } from "../../plan/store.js";
+import { Card, wrapTextWithAnsi } from "../../tui.js";
+import { Indent, Stack, keyValue } from "./panels.js";
+import { planStatusText, planTitle } from "./plan-command.js";
+import { agentFacts, listAgents, taskFacts } from "./tasks-report.js";
+import { cleanLines } from "./tool-summary.js";
+/** 折行显示的若干行。 */
+class Lines {
+    lines;
+    constructor(lines) {
+        this.lines = lines;
+    }
+    render(width) {
+        return this.lines.flatMap((line) => (line === "" ? [""] : wrapTextWithAnsi(line, width)));
+    }
+    invalidate() { }
+}
+const STATUS_COLOR = {
+    proposed: "warning",
+    approved: "success",
+    rejected: "dim",
+    superseded: "dim",
+};
+/** `/plan`：当前计划、状态、模式、步骤与待办进度。 */
+export function planPanel(controller, session, theme, displayPath = (p) => p) {
+    const plan = controller.current();
+    const mode = session.state.permissionMode;
+    const modeText = mode === "plan"
+        ? `Plan${theme.fg("dim", `（批准后回到 ${permissionModeLabel(executionMode(undefined, controller.prePlanMode()))}）`)}`
+        : permissionModeLabel(mode);
+    if (plan === null) {
+        const hint = mode === "plan"
+            ? "还没有计划：模型给出 <proposed_plan> 后在这里审批"
+            : "没有计划。/plan <目标> 进入 Plan 模式";
+        return new Card(new Lines([theme.fg("muted", hint)]), { theme, title: "计划" });
+    }
+    const rows = [
+        { key: "状态", value: theme.fg(STATUS_COLOR[plan.status], planStatusText(plan.status)) },
+        { key: "模式", value: modeText },
+    ];
+    const todos = controller.todos();
+    if (todos.length > 0) {
+        const done = todos.filter((t) => t.status === "done").length;
+        const current = todos.find((t) => t.status === "in_progress");
+        rows.push({
+            key: "待办",
+            value: `${done}/${todos.length} 完成${current !== undefined ? theme.fg("dim", ` · 进行中 ${current.text}`) : ""}`,
+        });
+    }
+    const parts = [theme.bold(planTitle(plan)), keyValue(rows, theme)];
+    if (plan.steps.length > 0) {
+        parts.push(theme.bold(`步骤（${plan.steps.length}）`));
+        parts.push(new Indent(new Lines(plan.steps.map((s) => `${theme.fg("dim", s.id)} ${s.text}`)), 2));
+    }
+    if (plan.status === "proposed")
+        parts.push(new Lines([
+            theme.fg("dim", "/plan approve [模式|fresh] 批准 · /plan reject 放弃 · 直接输入修改意见"),
+        ]));
+    return new Card(new Stack(parts), {
+        theme,
+        title: `计划 v${plan.version}`,
+        ...(plan.filePath !== undefined ? { subtitle: displayPath(plan.filePath) } : {}),
+    });
+}
+/** `/agents`：类型、runner、来源、安装状态与版本、说明。 */
+export function agentsPanel(sessionId, theme) {
+    const agents = listAgents(sessionId);
+    if (agents.length === 0)
+        return new Card(new Lines([theme.fg("muted", "当前会话没有子 Agent（task 工具未启用）")]), {
+            theme,
+            title: "子 Agent",
+        });
+    const rows = agents.map((agent) => {
+        const facts = agentFacts(agent);
+        const status = facts.map((f) => f === "未安装" ? theme.fg("warning", f) : f.startsWith("已安装") ? theme.fg("success", f) : f);
+        return {
+            key: agent.name,
+            value: `${status.join(theme.fg("dim", " · "))}  ${theme.fg("muted", agent.description.replace(/\s+/g, " "))}`,
+        };
+    });
+    return new Card(keyValue(rows, theme, true), { theme, title: `子 Agent（${agents.length}）` });
+}
+/** `/tasks` 选中一个任务：状态行 + 输出全文（运行中为已有输出）。 */
+export function taskOutputPanel(task, output, theme, now, displayPath = (p) => p) {
+    const body = output === undefined || output.trim() === "" ? [] : cleanLines(output.trimEnd());
+    const lines = [
+        ...(task.description.trim() !== "" ? [theme.fg("muted", task.description.trim())] : []),
+        ...(body.length === 0 ? [theme.fg("dim", "（还没有输出）")] : body),
+    ];
+    if (task.outputFile !== undefined)
+        lines.push(theme.fg("dim", `全文：${displayPath(task.outputFile)}`));
+    const facts = [task.agent, ...taskFacts(task, now), ...(task.background ? ["后台"] : [])];
+    return new Card(new Lines(lines), {
+        theme,
+        title: `任务 ${task.taskId}`,
+        subtitle: facts.join(" · "),
+    });
+}