ai-cli-mcp 2.18.0 → 2.19.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [2.19.0](https://github.com/mkXultra/ai-cli-mcp/compare/v2.18.0...v2.19.0) (2026-04-15)
+
+
+### Features
+
+* peekコマンドにForgeエージェントのベストエフォートサポートを追加 ([7c01958](https://github.com/mkXultra/ai-cli-mcp/commit/7c01958b0c9a8133da07c556b303481abd511b6b))
+
 # [2.18.0](https://github.com/mkXultra/ai-cli-mcp/compare/v2.17.0...v2.18.0) (2026-04-12)
 
 

package/README.ja.md

@@ -297,9 +297,9 @@ ai-cli peek 123 --time 10 --include-tool-calls
 - `peek_started_at` と `events[].ts` は、ai-cli-mcp サーバー側の UTC RFC3339 タイムスタンプです。`peek_started_at` は検証とリスナー登録後に観測ウィンドウが始まった時刻、`events[].ts` は ai-cli-mcp がイベントを観測して受理した時刻です。
 - 観測ウィンドウは `peek_time_sec` が経過するか、対象プロセスがすべて終端状態になった時点で終了します。
 - 観測開始前のイベントは返しません。同じPIDへの同時 `peek` は可能で、それぞれ独立した観測ウィンドウを持つため、イベントが重複して返ることがあります。
-- メッセージイベントは、Codex の `agent_message` text、Claude assistant の text content、OpenCode の `type: "text"` かつ `part.type` が `"text"` のイベント、Gemini stream-json の `role` が `"assistant"` の `message` イベントから認識します。
-- tool call を含める場合、Codex の command/MCP call、Claude の tool use/result、Gemini の tool use/result、OpenCode の完了済み tool use event を正規化した `tool_call` イベントとして返します。tool summary は tool 名と入力メタデータだけから作る短い1行文字列です。raw `stdout` / `stderr`、raw JSONL、tool result output、コマンド出力、`result.response`、stats、token usage、verbose メタデータは除外します。
-- 未知のイベント形状はデフォルトで拒否します。Forge など、まだ明示対応されていない管理対象エージェントは、実際のプロセス状態を返しつつ、`events: []`、`truncated: false`、`error: null` にします。
+- メッセージイベントは、Codex の `agent_message` text、Claude assistant の text content、OpenCode の `type: "text"` かつ `part.type` が `"text"` のイベント、Gemini stream-json の `role` が `"assistant"` の `message` イベント、Forge の `Summary:` または `Completed successfully:` で始まる plain-text 行から best-effort に認識します。
+- tool call を含める場合、Codex の command/MCP call、Claude の tool use/result、Gemini の tool use/result、OpenCode の完了済み tool use event、Forge の低精度な `Execute` / `Finished` marker を正規化した `tool_call` イベントとして返します。tool summary は tool 名と入力メタデータだけから作る短い1行文字列です。Forge のコマンド出力自体は tail せず、公開しません。raw `stdout` / `stderr`、raw JSONL、tool result output、コマンド出力、`result.response`、stats、token usage、verbose メタデータは除外します。
+- 未知のイベント形状はデフォルトで拒否します。まだ明示対応されていない管理対象エージェントは、実際のプロセス状態を返しつつ、`events: []`、`truncated: false`、`error: null` にします。
 - 各PIDごとに、観測ウィンドウ内で最初に観測された50件までを保持します。それ以降のイベントを捨てた場合は `truncated` が `true` になります。
 - `status` は `running`、`completed`、`failed`、`not_found` のいずれかで、観測ウィンドウ終了時点の状態を表します。
 - `agent` は `claude`、`codex`、`gemini`、`forge`、`opencode`、将来追加される追跡済みエージェント文字列、または `null` です。`null` はプロセスが見つからない、またはエージェント種別を判断できない場合を表します。

package/README.md

@@ -294,9 +294,9 @@ ai-cli peek 123 --time 10 --include-tool-calls
 - `peek_started_at` and `events[].ts` are ai-cli-mcp server-side UTC RFC3339 timestamps. `peek_started_at` is when the observation window starts after validation and listener registration; `events[].ts` is when ai-cli-mcp observed and accepted the event.
 - The window ends when `peek_time_sec` elapses or all target processes reach a terminal state, whichever comes first.
 - Events emitted before the window starts are not returned. Concurrent `peek` calls for the same PID are allowed; each has an independent window and may return overlapping events.
-- Message events are recognized from Codex `agent_message` text, Claude assistant text content, OpenCode `type: "text"` events where `part.type` is `"text"`, and Gemini stream-json `message` events where `role` is `"assistant"`.
-- When tool calls are included, `tool_call` events are normalized for Codex command/MCP calls, Claude tool use/results, Gemini tool use/results, and OpenCode completed tool use events. Tool summaries are bounded one-line strings derived from tool names and input metadata only. Raw stdout/stderr, raw JSONL, tool result output, command output, `result.response`, stats, token usage, and verbose metadata are excluded.
-- Unknown event shapes are denied by default. Managed agents without supported extraction, such as Forge until explicitly supported, return their real process status with `events: []`, `truncated: false`, and `error: null`.
+- Message events are recognized from Codex `agent_message` text, Claude assistant text content, OpenCode `type: "text"` events where `part.type` is `"text"`, Gemini stream-json `message` events where `role` is `"assistant"`, and best-effort Forge plain-text lines beginning with `Summary:` or `Completed successfully:`.
+- When tool calls are included, `tool_call` events are normalized for Codex command/MCP calls, Claude tool use/results, Gemini tool use/results, OpenCode completed tool use events, and low-precision Forge `Execute`/`Finished` markers. Tool summaries are bounded one-line strings derived from tool names and input metadata only. Forge command output itself is not tailed or exposed. Raw stdout/stderr, raw JSONL, tool result output, command output, `result.response`, stats, token usage, and verbose metadata are excluded.
+- Unknown event shapes are denied by default. Managed agents without supported extraction return their real process status with `events: []`, `truncated: false`, and `error: null`.
 - Each PID keeps the first 50 events observed in the window. If later events are dropped, `truncated` is `true`.
 - `status` is one of `running`, `completed`, `failed`, or `not_found`, and reflects state when the observation window closes.
 - `agent` is `claude`, `codex`, `gemini`, `forge`, `opencode`, a future tracked string value, or `null` when the process is not found or the agent cannot be determined.

package/dist/__tests__/parsers.test.js

@@ -307,6 +307,152 @@ describe('PeekEventExtractor', () => {
             },
         ]);
     });
+    it('emits Forge message events from Summary and Completed successfully prefixes', () => {
+        const extractor = new PeekEventExtractor('forge');
+        const output = [
+            'Summary: Forge finished the task',
+            'Completed successfully: Built the project',
+            'Summary:   ',
+        ].join('\n') + '\n';
+        expect(extractor.push(output, ts)).toEqual([
+            { kind: 'message', ts, text: 'Forge finished the task' },
+            { kind: 'message', ts, text: 'Built the project' },
+        ]);
+    });
+    it('preserves long Forge Summary message text without truncation', () => {
+        const extractor = new PeekEventExtractor('forge');
+        const longText = 'x'.repeat(260);
+        expect(extractor.push(`Summary: ${longText}\n`, ts)).toEqual([
+            { kind: 'message', ts, text: longText },
+        ]);
+    });
+    it('emits Forge Execute tool_call starts when include_tool_calls is true', () => {
+        const extractor = new PeekEventExtractor('forge', { includeToolCalls: true });
+        expect(extractor.push("● [11:28:40] Execute [/bin/zsh] /bin/sh -c 'echo hi'\n", ts)).toEqual([
+            {
+                kind: 'tool_call',
+                ts,
+                phase: 'started',
+                id: 'forge_0',
+                tool: '/bin/zsh',
+                summary: "/bin/sh -c 'echo hi'",
+            },
+        ]);
+    });
+    it('falls back to shell for Forge Execute labels with spaces', () => {
+        const extractor = new PeekEventExtractor('forge', { includeToolCalls: true });
+        expect(extractor.push("● [11:28:40] Execute [local shell] /bin/sh -c 'echo hi'\n", ts)).toEqual([
+            {
+                kind: 'tool_call',
+                ts,
+                phase: 'started',
+                id: 'forge_0',
+                tool: 'shell',
+                summary: "/bin/sh -c 'echo hi'",
+            },
+        ]);
+    });
+    it('suppresses Forge tool_call events when include_tool_calls is false but keeps messages', () => {
+        const extractor = new PeekEventExtractor('forge', { includeToolCalls: false });
+        const output = [
+            "● [11:28:40] Execute [/bin/zsh] /bin/sh -c 'echo hi'",
+            'Summary: done',
+        ].join('\n') + '\n';
+        expect(extractor.push(output, ts)).toEqual([
+            { kind: 'message', ts, text: 'done' },
+        ]);
+    });
+    it('completes a pending Forge tool_call only on anchored Finished markers', () => {
+        const extractor = new PeekEventExtractor('forge', { includeToolCalls: true });
+        const output = [
+            "● [11:28:40] Execute [/bin/zsh] /bin/sh -c 'echo hi'",
+            'This line says Finished but is not a Forge marker',
+            '● [11:28:41] Finished abc123',
+        ].join('\n') + '\n';
+        expect(extractor.push(output, ts)).toEqual([
+            {
+                kind: 'tool_call',
+                ts,
+                phase: 'started',
+                id: 'forge_0',
+                tool: '/bin/zsh',
+                summary: "/bin/sh -c 'echo hi'",
+            },
+            {
+                kind: 'tool_call',
+                ts,
+                phase: 'completed',
+                id: 'forge_0',
+                tool: '/bin/zsh',
+                summary: "/bin/sh -c 'echo hi'",
+                status: 'unknown',
+            },
+        ]);
+    });
+    it('completes a pending Forge tool_call before starting a consecutive Execute marker', () => {
+        const extractor = new PeekEventExtractor('forge', { includeToolCalls: true });
+        const output = [
+            "● [11:28:40] Execute [/bin/zsh] /bin/sh -c 'echo one'",
+            "● [11:28:41] Execute [/bin/zsh] /bin/sh -c 'echo two'",
+        ].join('\n') + '\n';
+        expect(extractor.push(output, ts)).toEqual([
+            {
+                kind: 'tool_call',
+                ts,
+                phase: 'started',
+                id: 'forge_0',
+                tool: '/bin/zsh',
+                summary: "/bin/sh -c 'echo one'",
+            },
+            {
+                kind: 'tool_call',
+                ts,
+                phase: 'completed',
+                id: 'forge_0',
+                tool: '/bin/zsh',
+                summary: "/bin/sh -c 'echo one'",
+                status: 'unknown',
+            },
+            {
+                kind: 'tool_call',
+                ts,
+                phase: 'started',
+                id: 'forge_1',
+                tool: '/bin/zsh',
+                summary: "/bin/sh -c 'echo two'",
+            },
+        ]);
+    });
+    it('does not synthesize Forge completion on non-terminal flush', () => {
+        const extractor = new PeekEventExtractor('forge', { includeToolCalls: true });
+        expect(extractor.push("● [11:28:40] Execute [/bin/zsh] /bin/sh -c 'echo hi'\n", ts)).toHaveLength(1);
+        expect(extractor.flush(ts, { terminal: false })).toEqual([]);
+    });
+    it('synthesizes Forge completion with unknown status on terminal flush', () => {
+        const extractor = new PeekEventExtractor('forge', { includeToolCalls: true });
+        expect(extractor.push("● [11:28:40] Execute [/bin/zsh] /bin/sh -c 'echo hi'\n", ts)).toHaveLength(1);
+        expect(extractor.flush('2026-04-12T02:10:05.000Z', { terminal: true })).toEqual([
+            {
+                kind: 'tool_call',
+                ts: '2026-04-12T02:10:05.000Z',
+                phase: 'completed',
+                id: 'forge_0',
+                tool: '/bin/zsh',
+                summary: "/bin/sh -c 'echo hi'",
+                status: 'unknown',
+            },
+        ]);
+    });
+    it('treats Forge stderr as a no-op source', () => {
+        const extractor = new PeekEventExtractor('forge', { includeToolCalls: true, source: 'stderr' });
+        const output = [
+            'Summary: hidden',
+            "● [11:28:40] Execute [/bin/zsh] /bin/sh -c 'echo hidden'",
+            '● [11:28:41] Finished',
+        ].join('\n') + '\n';
+        expect(extractor.push(output, ts)).toEqual([]);
+        expect(extractor.flush(ts, { terminal: true })).toEqual([]);
+    });
 });
 describe('parseGeminiOutput', () => {
     it('should parse legacy final JSON output', () => {

package/dist/__tests__/process-management.test.js

@@ -334,6 +334,84 @@ describe('Process Management Tests', () => {
             });
             expect(JSON.stringify(response)).not.toContain('secret result');
         });
+        it('should peek Forge plain-text messages and low-precision tool calls without raw command output', async () => {
+            const { handlers } = await setupServer();
+            const mockProcess = new EventEmitter();
+            mockProcess.pid = 12349;
+            mockProcess.stdout = new EventEmitter();
+            mockProcess.stderr = new EventEmitter();
+            mockProcess.kill = vi.fn();
+            mockSpawn.mockReturnValue(mockProcess);
+            const callToolHandler = handlers.get('callTool');
+            await callToolHandler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: 'forge peek prompt',
+                        workFolder: '/tmp',
+                        model: 'forge',
+                    }
+                }
+            });
+            const peekPromise = callToolHandler({
+                params: {
+                    name: 'peek',
+                    arguments: {
+                        pids: [12349],
+                        peek_time_sec: 1,
+                        include_tool_calls: true,
+                    }
+                }
+            });
+            setTimeout(() => {
+                mockProcess.stdout.emit('data', 'Summary: Forge started\n');
+                mockProcess.stdout.emit('data', "● [11:28:40] Execute [/bin/zsh] /bin/sh -c 'echo hi'\n");
+                mockProcess.stdout.emit('data', 'secret child output\n');
+                mockProcess.stderr.emit('data', 'Summary: stderr should be ignored\n');
+                mockProcess.stdout.emit('data', '● [11:28:41] Finished abc123\n');
+                mockProcess.stdout.emit('data', 'Completed successfully: Forge done\n');
+                mockProcess.emit('close', 0);
+            }, 10);
+            const result = await peekPromise;
+            const response = JSON.parse(result.content[0].text);
+            expect(response.processes).toHaveLength(1);
+            expect(response.processes[0]).toMatchObject({
+                pid: 12349,
+                agent: 'forge',
+                status: 'completed',
+                events: [
+                    {
+                        kind: 'message',
+                        ts: expect.any(String),
+                        text: 'Forge started',
+                    },
+                    {
+                        kind: 'tool_call',
+                        phase: 'started',
+                        id: 'forge_0',
+                        tool: '/bin/zsh',
+                        summary: "/bin/sh -c 'echo hi'",
+                    },
+                    {
+                        kind: 'tool_call',
+                        phase: 'completed',
+                        id: 'forge_0',
+                        tool: '/bin/zsh',
+                        summary: "/bin/sh -c 'echo hi'",
+                        status: 'unknown',
+                    },
+                    {
+                        kind: 'message',
+                        ts: expect.any(String),
+                        text: 'Forge done',
+                    },
+                ],
+                truncated: false,
+                error: null,
+            });
+            expect(JSON.stringify(response)).not.toContain('secret child output');
+            expect(JSON.stringify(response)).not.toContain('stderr should be ignored');
+        });
         it('should handle process with model parameter', async () => {
             const { handlers } = await setupServer();
             const mockProcess = new EventEmitter();

package/dist/app/cli.js

@@ -58,7 +58,7 @@ Options:
 export const PEEK_HELP_TEXT = `Usage: ai-cli peek <pid...> [options]
 
 Observe new natural-language agent messages, and optionally tool calls, for a short one-shot window.
-In v1, message extraction is supported for Codex, Claude, OpenCode, and Gemini; Forge returns status with events: [].
+In v1, message extraction is supported for Codex, Claude, OpenCode, Gemini, and best-effort Forge Summary/Completed successfully lines. Forge tool calls are low-precision Execute/Finished markers and never include command output.
 This is not a history API, gapless streaming, or stdout/stderr tailing. No --follow mode is available in v1.
 
 Options:

package/dist/app/mcp.js

@@ -211,7 +211,7 @@ ${getSupportedModelsDescription()}
                 },
                 {
                     name: 'peek',
-                    description: 'One-shot short observation window for running child agents. Returns only natural-language message events, and optionally normalized tool_call events, observed during this call; not a history API, not gapless streaming, and not stdout/stderr tailing. In v1, message extraction is supported for Codex, Claude, OpenCode, and Gemini; Forge returns status with events: []. Tool calls exclude raw tool output.',
+                    description: 'One-shot short observation window for running child agents. Returns only natural-language message events, and optionally normalized tool_call events, observed during this call; not a history API, not gapless streaming, and not stdout/stderr tailing. In v1, message extraction is supported for Codex, Claude, OpenCode, Gemini, and best-effort Forge Summary/Completed successfully lines. Forge tool calls are low-precision Execute/Finished markers and never include command output. Tool calls exclude raw tool output.',
                     inputSchema: {
                         type: 'object',
                         properties: {

package/dist/cli-process-service.js

@@ -201,8 +201,8 @@ export class CliProcessService {
             observers.push({
                 process,
                 result,
-                stdoutExtractor: new PeekEventExtractor(process.toolType, { includeToolCalls }),
-                stderrExtractor: new PeekEventExtractor(process.toolType, { includeToolCalls }),
+                stdoutExtractor: new PeekEventExtractor(process.toolType, { includeToolCalls, source: 'stdout' }),
+                stderrExtractor: new PeekEventExtractor(process.toolType, { includeToolCalls, source: 'stderr' }),
                 stdoutOffset: this.fileSizeSafe(process.stdoutPath),
                 stderrOffset: this.fileSizeSafe(process.stderrPath),
             });
@@ -239,8 +239,9 @@ export class CliProcessService {
         for (const observer of observers) {
             observer.process = this.refreshStatus(this.readProcess(observer.process.pid));
             observer.result.status = observer.process.status;
-            appendPeekEvents(observer.result, observer.stdoutExtractor.flush(flushTs));
-            appendPeekEvents(observer.result, observer.stderrExtractor.flush(flushTs));
+            const terminal = observer.process.status !== 'running';
+            appendPeekEvents(observer.result, observer.stdoutExtractor.flush(flushTs, { terminal }));
+            appendPeekEvents(observer.result, observer.stderrExtractor.flush(flushTs, { terminal }));
         }
         return {
             peek_started_at: startedAt.toISOString(),

package/dist/parsers.js

@@ -1,5 +1,7 @@
 import { debugLog } from './cli-utils.js';
 const PEEK_TOOL_SUMMARY_MAX_LENGTH = 200;
+const FORGE_EXECUTE_PATTERN = /^● \[[^\]]+\] Execute \[([^\]]*)\]\s+(.+)$/;
+const FORGE_FINISHED_PATTERN = /^● \[[^\]]+\] Finished(?:\s+\S+)?\s*$/;
 function isGeminiAssistantMessageEvent(parsed) {
     return parsed.type === 'message' && parsed.role === 'assistant' && typeof parsed.content === 'string';
 }
@@ -253,12 +255,19 @@ export class PeekEventExtractor {
     pending = '';
     geminiAssistantBuffer = '';
     includeToolCalls;
+    source;
     toolMemory = new Map();
+    forgePendingTool = null;
+    forgeToolSequence = 0;
     constructor(agent, options = {}) {
         this.agent = agent;
         this.includeToolCalls = options.includeToolCalls === true;
+        this.source = options.source || 'stdout';
     }
     push(chunk, observedAt = new Date().toISOString()) {
+        if (this.agent === 'forge' && this.source === 'stderr') {
+            return [];
+        }
         if (!chunk) {
             return [];
         }
@@ -266,17 +275,27 @@ export class PeekEventExtractor {
         this.pending = lines.pop() || '';
         return this.extractLines(lines, observedAt);
     }
-    flush(observedAt = new Date().toISOString()) {
+    flush(observedAt = new Date().toISOString(), options = {}) {
+        if (this.agent === 'forge' && this.source === 'stderr') {
+            this.pending = '';
+            return [];
+        }
         const events = [];
         if (this.pending) {
-            const line = this.pending;
-            this.pending = '';
-            events.push(...this.extractLines([line], observedAt));
+            if (this.agent !== 'forge' || options.terminal === true) {
+                const line = this.pending;
+                this.pending = '';
+                events.push(...this.extractLines([line], observedAt));
+            }
         }
         events.push(...this.flushGeminiAssistantBuffer(observedAt));
+        events.push(...this.flushForgePendingTool(observedAt, options.terminal === true));
         return events;
     }
     extractLines(lines, observedAt) {
+        if (this.agent === 'forge') {
+            return this.extractForgeLines(lines, observedAt);
+        }
         const events = [];
         for (const line of lines) {
             if (!line.trim()) {
@@ -292,6 +311,58 @@ export class PeekEventExtractor {
         }
         return events;
     }
+    extractForgeLines(lines, observedAt) {
+        const events = [];
+        for (const line of lines) {
+            if (!line.trim()) {
+                continue;
+            }
+            const summary = this.extractForgeMessage(line, 'Summary:');
+            if (summary !== null) {
+                events.push({ kind: 'message', ts: observedAt, text: summary });
+                continue;
+            }
+            const completed = this.extractForgeMessage(line, 'Completed successfully:');
+            if (completed !== null) {
+                events.push({ kind: 'message', ts: observedAt, text: completed });
+                continue;
+            }
+            if (this.includeToolCalls) {
+                const executeMatch = line.match(FORGE_EXECUTE_PATTERN);
+                if (executeMatch) {
+                    events.push(...this.completeForgePendingTool(observedAt));
+                    const [, rawTool, rawSummary] = executeMatch;
+                    const tool = rawTool.trim() && !/\s/.test(rawTool.trim()) ? rawTool.trim() : 'shell';
+                    const event = createToolCallEvent({
+                        ts: observedAt,
+                        phase: 'started',
+                        id: `forge_${this.forgeToolSequence++}`,
+                        tool,
+                        command: rawSummary,
+                    });
+                    this.forgePendingTool = {
+                        id: event.id,
+                        tool: event.tool,
+                        summary: event.summary,
+                        summary_truncated: event.summary_truncated,
+                    };
+                    events.push(event);
+                    continue;
+                }
+                if (FORGE_FINISHED_PATTERN.test(line)) {
+                    events.push(...this.completeForgePendingTool(observedAt));
+                }
+            }
+        }
+        return events;
+    }
+    extractForgeMessage(line, prefix) {
+        if (!line.startsWith(prefix)) {
+            return null;
+        }
+        const text = line.slice(prefix.length).trim();
+        return text || null;
+    }
     extractParsedEvent(parsed, observedAt) {
         if (this.agent === 'gemini') {
             const events = this.extractGeminiParsedEvent(parsed, observedAt);
@@ -339,6 +410,32 @@ export class PeekEventExtractor {
         }
         return [{ kind: 'message', ts: observedAt, text }];
     }
+    completeForgePendingTool(observedAt) {
+        if (!this.forgePendingTool) {
+            return [];
+        }
+        const pending = this.forgePendingTool;
+        this.forgePendingTool = null;
+        const event = createToolCallEvent({
+            ts: observedAt,
+            phase: 'completed',
+            id: pending.id,
+            tool: pending.tool,
+            status: 'unknown',
+            defaultStatus: 'unknown',
+        });
+        event.summary = pending.summary;
+        if (pending.summary_truncated) {
+            event.summary_truncated = true;
+        }
+        return [event];
+    }
+    flushForgePendingTool(observedAt, terminal) {
+        if (this.agent !== 'forge' || !terminal) {
+            return [];
+        }
+        return this.completeForgePendingTool(observedAt);
+    }
 }
 export class PeekMessageExtractor {
     extractor;
@@ -348,8 +445,8 @@ export class PeekMessageExtractor {
     push(chunk, observedAt = new Date().toISOString()) {
         return this.toMessages(this.extractor.push(chunk, observedAt));
     }
-    flush(observedAt = new Date().toISOString()) {
-        return this.toMessages(this.extractor.flush(observedAt));
+    flush(observedAt = new Date().toISOString(), options = {}) {
+        return this.toMessages(this.extractor.flush(observedAt, options));
     }
     toMessages(events) {
         return events

package/dist/process-service.js

@@ -176,8 +176,8 @@ export class ProcessService {
                 error: null,
             };
             processes.push(result);
-            const stdoutExtractor = new PeekEventExtractor(entry.toolType, { includeToolCalls });
-            const stderrExtractor = new PeekEventExtractor(entry.toolType, { includeToolCalls });
+            const stdoutExtractor = new PeekEventExtractor(entry.toolType, { includeToolCalls, source: 'stdout' });
+            const stderrExtractor = new PeekEventExtractor(entry.toolType, { includeToolCalls, source: 'stderr' });
             const onStdout = (data) => {
                 appendPeekEvents(result, stdoutExtractor.push(data.toString(), new Date().toISOString()));
             };
@@ -210,8 +210,9 @@ export class ProcessService {
             for (const observer of observers) {
                 observer.entry.process.stdout?.off('data', observer.onStdout);
                 observer.entry.process.stderr?.off('data', observer.onStderr);
-                appendPeekEvents(observer.result, observer.stdoutExtractor.flush(flushTs));
-                appendPeekEvents(observer.result, observer.stderrExtractor.flush(flushTs));
+                const terminal = observer.entry.status !== 'running';
+                appendPeekEvents(observer.result, observer.stdoutExtractor.flush(flushTs, { terminal }));
+                appendPeekEvents(observer.result, observer.stderrExtractor.flush(flushTs, { terminal }));
                 observer.result.status = observer.entry.status;
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-cli-mcp",
-  "version": "2.18.0",
+  "version": "2.19.0",
   "mcpName": "io.github.mkXultra/ai-cli-mcp",
   "description": "MCP server for AI CLI tools (Claude, Codex, Gemini, Forge, and OpenCode) with background process management",
   "author": "mkXultra",

package/src/__tests__/parsers.test.ts

@@ -342,6 +342,172 @@ describe('PeekEventExtractor', () => {
       },
     ]);
   });
+
+  it('emits Forge message events from Summary and Completed successfully prefixes', () => {
+    const extractor = new PeekEventExtractor('forge');
+    const output = [
+      'Summary: Forge finished the task',
+      'Completed successfully: Built the project',
+      'Summary:   ',
+    ].join('\n') + '\n';
+
+    expect(extractor.push(output, ts)).toEqual([
+      { kind: 'message', ts, text: 'Forge finished the task' },
+      { kind: 'message', ts, text: 'Built the project' },
+    ]);
+  });
+
+  it('preserves long Forge Summary message text without truncation', () => {
+    const extractor = new PeekEventExtractor('forge');
+    const longText = 'x'.repeat(260);
+
+    expect(extractor.push(`Summary: ${longText}\n`, ts)).toEqual([
+      { kind: 'message', ts, text: longText },
+    ]);
+  });
+
+  it('emits Forge Execute tool_call starts when include_tool_calls is true', () => {
+    const extractor = new PeekEventExtractor('forge', { includeToolCalls: true });
+
+    expect(extractor.push("● [11:28:40] Execute [/bin/zsh] /bin/sh -c 'echo hi'\n", ts)).toEqual([
+      {
+        kind: 'tool_call',
+        ts,
+        phase: 'started',
+        id: 'forge_0',
+        tool: '/bin/zsh',
+        summary: "/bin/sh -c 'echo hi'",
+      },
+    ]);
+  });
+
+  it('falls back to shell for Forge Execute labels with spaces', () => {
+    const extractor = new PeekEventExtractor('forge', { includeToolCalls: true });
+
+    expect(extractor.push("● [11:28:40] Execute [local shell] /bin/sh -c 'echo hi'\n", ts)).toEqual([
+      {
+        kind: 'tool_call',
+        ts,
+        phase: 'started',
+        id: 'forge_0',
+        tool: 'shell',
+        summary: "/bin/sh -c 'echo hi'",
+      },
+    ]);
+  });
+
+  it('suppresses Forge tool_call events when include_tool_calls is false but keeps messages', () => {
+    const extractor = new PeekEventExtractor('forge', { includeToolCalls: false });
+    const output = [
+      "● [11:28:40] Execute [/bin/zsh] /bin/sh -c 'echo hi'",
+      'Summary: done',
+    ].join('\n') + '\n';
+
+    expect(extractor.push(output, ts)).toEqual([
+      { kind: 'message', ts, text: 'done' },
+    ]);
+  });
+
+  it('completes a pending Forge tool_call only on anchored Finished markers', () => {
+    const extractor = new PeekEventExtractor('forge', { includeToolCalls: true });
+    const output = [
+      "● [11:28:40] Execute [/bin/zsh] /bin/sh -c 'echo hi'",
+      'This line says Finished but is not a Forge marker',
+      '● [11:28:41] Finished abc123',
+    ].join('\n') + '\n';
+
+    expect(extractor.push(output, ts)).toEqual([
+      {
+        kind: 'tool_call',
+        ts,
+        phase: 'started',
+        id: 'forge_0',
+        tool: '/bin/zsh',
+        summary: "/bin/sh -c 'echo hi'",
+      },
+      {
+        kind: 'tool_call',
+        ts,
+        phase: 'completed',
+        id: 'forge_0',
+        tool: '/bin/zsh',
+        summary: "/bin/sh -c 'echo hi'",
+        status: 'unknown',
+      },
+    ]);
+  });
+
+  it('completes a pending Forge tool_call before starting a consecutive Execute marker', () => {
+    const extractor = new PeekEventExtractor('forge', { includeToolCalls: true });
+    const output = [
+      "● [11:28:40] Execute [/bin/zsh] /bin/sh -c 'echo one'",
+      "● [11:28:41] Execute [/bin/zsh] /bin/sh -c 'echo two'",
+    ].join('\n') + '\n';
+
+    expect(extractor.push(output, ts)).toEqual([
+      {
+        kind: 'tool_call',
+        ts,
+        phase: 'started',
+        id: 'forge_0',
+        tool: '/bin/zsh',
+        summary: "/bin/sh -c 'echo one'",
+      },
+      {
+        kind: 'tool_call',
+        ts,
+        phase: 'completed',
+        id: 'forge_0',
+        tool: '/bin/zsh',
+        summary: "/bin/sh -c 'echo one'",
+        status: 'unknown',
+      },
+      {
+        kind: 'tool_call',
+        ts,
+        phase: 'started',
+        id: 'forge_1',
+        tool: '/bin/zsh',
+        summary: "/bin/sh -c 'echo two'",
+      },
+    ]);
+  });
+
+  it('does not synthesize Forge completion on non-terminal flush', () => {
+    const extractor = new PeekEventExtractor('forge', { includeToolCalls: true });
+
+    expect(extractor.push("● [11:28:40] Execute [/bin/zsh] /bin/sh -c 'echo hi'\n", ts)).toHaveLength(1);
+    expect(extractor.flush(ts, { terminal: false })).toEqual([]);
+  });
+
+  it('synthesizes Forge completion with unknown status on terminal flush', () => {
+    const extractor = new PeekEventExtractor('forge', { includeToolCalls: true });
+
+    expect(extractor.push("● [11:28:40] Execute [/bin/zsh] /bin/sh -c 'echo hi'\n", ts)).toHaveLength(1);
+    expect(extractor.flush('2026-04-12T02:10:05.000Z', { terminal: true })).toEqual([
+      {
+        kind: 'tool_call',
+        ts: '2026-04-12T02:10:05.000Z',
+        phase: 'completed',
+        id: 'forge_0',
+        tool: '/bin/zsh',
+        summary: "/bin/sh -c 'echo hi'",
+        status: 'unknown',
+      },
+    ]);
+  });
+
+  it('treats Forge stderr as a no-op source', () => {
+    const extractor = new PeekEventExtractor('forge', { includeToolCalls: true, source: 'stderr' });
+    const output = [
+      'Summary: hidden',
+      "● [11:28:40] Execute [/bin/zsh] /bin/sh -c 'echo hidden'",
+      '● [11:28:41] Finished',
+    ].join('\n') + '\n';
+
+    expect(extractor.push(output, ts)).toEqual([]);
+    expect(extractor.flush(ts, { terminal: true })).toEqual([]);
+  });
 });
 
 describe('parseGeminiOutput', () => {

package/src/__tests__/process-management.test.ts

@@ -384,6 +384,92 @@ describe('Process Management Tests', () => {
       expect(JSON.stringify(response)).not.toContain('secret result');
     });
 
+    it('should peek Forge plain-text messages and low-precision tool calls without raw command output', async () => {
+      const { handlers } = await setupServer();
+
+      const mockProcess = new EventEmitter() as any;
+      mockProcess.pid = 12349;
+      mockProcess.stdout = new EventEmitter();
+      mockProcess.stderr = new EventEmitter();
+      mockProcess.kill = vi.fn();
+
+      mockSpawn.mockReturnValue(mockProcess);
+
+      const callToolHandler = handlers.get('callTool')!;
+      await callToolHandler!({
+        params: {
+          name: 'run',
+          arguments: {
+            prompt: 'forge peek prompt',
+            workFolder: '/tmp',
+            model: 'forge',
+          }
+        }
+      });
+
+      const peekPromise = callToolHandler!({
+        params: {
+          name: 'peek',
+          arguments: {
+            pids: [12349],
+            peek_time_sec: 1,
+            include_tool_calls: true,
+          }
+        }
+      });
+
+      setTimeout(() => {
+        mockProcess.stdout.emit('data', 'Summary: Forge started\n');
+        mockProcess.stdout.emit('data', "● [11:28:40] Execute [/bin/zsh] /bin/sh -c 'echo hi'\n");
+        mockProcess.stdout.emit('data', 'secret child output\n');
+        mockProcess.stderr.emit('data', 'Summary: stderr should be ignored\n');
+        mockProcess.stdout.emit('data', '● [11:28:41] Finished abc123\n');
+        mockProcess.stdout.emit('data', 'Completed successfully: Forge done\n');
+        mockProcess.emit('close', 0);
+      }, 10);
+
+      const result = await peekPromise;
+      const response = JSON.parse(result.content[0].text);
+
+      expect(response.processes).toHaveLength(1);
+      expect(response.processes[0]).toMatchObject({
+        pid: 12349,
+        agent: 'forge',
+        status: 'completed',
+        events: [
+          {
+            kind: 'message',
+            ts: expect.any(String),
+            text: 'Forge started',
+          },
+          {
+            kind: 'tool_call',
+            phase: 'started',
+            id: 'forge_0',
+            tool: '/bin/zsh',
+            summary: "/bin/sh -c 'echo hi'",
+          },
+          {
+            kind: 'tool_call',
+            phase: 'completed',
+            id: 'forge_0',
+            tool: '/bin/zsh',
+            summary: "/bin/sh -c 'echo hi'",
+            status: 'unknown',
+          },
+          {
+            kind: 'message',
+            ts: expect.any(String),
+            text: 'Forge done',
+          },
+        ],
+        truncated: false,
+        error: null,
+      });
+      expect(JSON.stringify(response)).not.toContain('secret child output');
+      expect(JSON.stringify(response)).not.toContain('stderr should be ignored');
+    });
+
     it('should handle process with model parameter', async () => {
       const { handlers } = await setupServer();
       

package/src/app/cli.ts

@@ -63,7 +63,7 @@ Options:
 export const PEEK_HELP_TEXT = `Usage: ai-cli peek <pid...> [options]
 
 Observe new natural-language agent messages, and optionally tool calls, for a short one-shot window.
-In v1, message extraction is supported for Codex, Claude, OpenCode, and Gemini; Forge returns status with events: [].
+In v1, message extraction is supported for Codex, Claude, OpenCode, Gemini, and best-effort Forge Summary/Completed successfully lines. Forge tool calls are low-precision Execute/Finished markers and never include command output.
 This is not a history API, gapless streaming, or stdout/stderr tailing. No --follow mode is available in v1.
 
 Options:

package/src/app/mcp.ts

@@ -233,7 +233,7 @@ ${getSupportedModelsDescription()}
         },
         {
           name: 'peek',
-          description: 'One-shot short observation window for running child agents. Returns only natural-language message events, and optionally normalized tool_call events, observed during this call; not a history API, not gapless streaming, and not stdout/stderr tailing. In v1, message extraction is supported for Codex, Claude, OpenCode, and Gemini; Forge returns status with events: []. Tool calls exclude raw tool output.',
+          description: 'One-shot short observation window for running child agents. Returns only natural-language message events, and optionally normalized tool_call events, observed during this call; not a history API, not gapless streaming, and not stdout/stderr tailing. In v1, message extraction is supported for Codex, Claude, OpenCode, Gemini, and best-effort Forge Summary/Completed successfully lines. Forge tool calls are low-precision Execute/Finished markers and never include command output. Tool calls exclude raw tool output.',
           inputSchema: {
             type: 'object',
             properties: {

package/src/cli-process-service.ts

@@ -289,8 +289,8 @@ export class CliProcessService {
       observers.push({
         process,
         result,
-        stdoutExtractor: new PeekEventExtractor(process.toolType, { includeToolCalls }),
-        stderrExtractor: new PeekEventExtractor(process.toolType, { includeToolCalls }),
+        stdoutExtractor: new PeekEventExtractor(process.toolType, { includeToolCalls, source: 'stdout' }),
+        stderrExtractor: new PeekEventExtractor(process.toolType, { includeToolCalls, source: 'stderr' }),
         stdoutOffset: this.fileSizeSafe(process.stdoutPath),
         stderrOffset: this.fileSizeSafe(process.stderrPath),
       });
@@ -335,8 +335,9 @@ export class CliProcessService {
     for (const observer of observers) {
       observer.process = this.refreshStatus(this.readProcess(observer.process.pid));
       observer.result.status = observer.process.status;
-      appendPeekEvents(observer.result, observer.stdoutExtractor.flush(flushTs));
-      appendPeekEvents(observer.result, observer.stderrExtractor.flush(flushTs));
+      const terminal = observer.process.status !== 'running';
+      appendPeekEvents(observer.result, observer.stdoutExtractor.flush(flushTs, { terminal }));
+      appendPeekEvents(observer.result, observer.stderrExtractor.flush(flushTs, { terminal }));
     }
 
     return {

package/src/parsers.ts

@@ -29,6 +29,11 @@ type PeekAgent = 'claude' | 'codex' | string | null;
 
 interface PeekEventExtractorOptions {
   includeToolCalls?: boolean;
+  source?: 'stdout' | 'stderr';
+}
+
+interface PeekFlushOptions {
+  terminal?: boolean;
 }
 
 interface ToolSummary {
@@ -44,7 +49,16 @@ interface ToolCallMemory {
   summary_truncated?: boolean;
 }
 
+interface PendingForgeTool {
+  id: string;
+  tool: string;
+  summary: string;
+  summary_truncated?: boolean;
+}
+
 const PEEK_TOOL_SUMMARY_MAX_LENGTH = 200;
+const FORGE_EXECUTE_PATTERN = /^● \[[^\]]+\] Execute \[([^\]]*)\]\s+(.+)$/;
+const FORGE_FINISHED_PATTERN = /^● \[[^\]]+\] Finished(?:\s+\S+)?\s*$/;
 
 function isGeminiAssistantMessageEvent(parsed: any): boolean {
   return parsed.type === 'message' && parsed.role === 'assistant' && typeof parsed.content === 'string';
@@ -343,13 +357,21 @@ export class PeekEventExtractor {
   private pending = '';
   private geminiAssistantBuffer = '';
   private readonly includeToolCalls: boolean;
+  private readonly source: 'stdout' | 'stderr';
   private readonly toolMemory = new Map<string, ToolCallMemory>();
+  private forgePendingTool: PendingForgeTool | null = null;
+  private forgeToolSequence = 0;
 
   constructor(private readonly agent: PeekAgent, options: PeekEventExtractorOptions = {}) {
     this.includeToolCalls = options.includeToolCalls === true;
+    this.source = options.source || 'stdout';
   }
 
   push(chunk: string, observedAt = new Date().toISOString()): PeekEvent[] {
+    if (this.agent === 'forge' && this.source === 'stderr') {
+      return [];
+    }
+
     if (!chunk) {
       return [];
     }
@@ -359,20 +381,32 @@ export class PeekEventExtractor {
     return this.extractLines(lines, observedAt);
   }
 
-  flush(observedAt = new Date().toISOString()): PeekEvent[] {
+  flush(observedAt = new Date().toISOString(), options: PeekFlushOptions = {}): PeekEvent[] {
+    if (this.agent === 'forge' && this.source === 'stderr') {
+      this.pending = '';
+      return [];
+    }
+
     const events: PeekEvent[] = [];
 
     if (this.pending) {
-      const line = this.pending;
-      this.pending = '';
-      events.push(...this.extractLines([line], observedAt));
+      if (this.agent !== 'forge' || options.terminal === true) {
+        const line = this.pending;
+        this.pending = '';
+        events.push(...this.extractLines([line], observedAt));
+      }
     }
 
     events.push(...this.flushGeminiAssistantBuffer(observedAt));
+    events.push(...this.flushForgePendingTool(observedAt, options.terminal === true));
     return events;
   }
 
   private extractLines(lines: string[], observedAt: string): PeekEvent[] {
+    if (this.agent === 'forge') {
+      return this.extractForgeLines(lines, observedAt);
+    }
+
     const events: PeekEvent[] = [];
 
     for (const line of lines) {
@@ -391,6 +425,67 @@ export class PeekEventExtractor {
     return events;
   }
 
+  private extractForgeLines(lines: string[], observedAt: string): PeekEvent[] {
+    const events: PeekEvent[] = [];
+
+    for (const line of lines) {
+      if (!line.trim()) {
+        continue;
+      }
+
+      const summary = this.extractForgeMessage(line, 'Summary:');
+      if (summary !== null) {
+        events.push({ kind: 'message', ts: observedAt, text: summary });
+        continue;
+      }
+
+      const completed = this.extractForgeMessage(line, 'Completed successfully:');
+      if (completed !== null) {
+        events.push({ kind: 'message', ts: observedAt, text: completed });
+        continue;
+      }
+
+      if (this.includeToolCalls) {
+        const executeMatch = line.match(FORGE_EXECUTE_PATTERN);
+        if (executeMatch) {
+          events.push(...this.completeForgePendingTool(observedAt));
+          const [, rawTool, rawSummary] = executeMatch;
+          const tool = rawTool.trim() && !/\s/.test(rawTool.trim()) ? rawTool.trim() : 'shell';
+          const event = createToolCallEvent({
+            ts: observedAt,
+            phase: 'started',
+            id: `forge_${this.forgeToolSequence++}`,
+            tool,
+            command: rawSummary,
+          });
+          this.forgePendingTool = {
+            id: event.id!,
+            tool: event.tool,
+            summary: event.summary,
+            summary_truncated: event.summary_truncated,
+          };
+          events.push(event);
+          continue;
+        }
+
+        if (FORGE_FINISHED_PATTERN.test(line)) {
+          events.push(...this.completeForgePendingTool(observedAt));
+        }
+      }
+    }
+
+    return events;
+  }
+
+  private extractForgeMessage(line: string, prefix: string): string | null {
+    if (!line.startsWith(prefix)) {
+      return null;
+    }
+
+    const text = line.slice(prefix.length).trim();
+    return text || null;
+  }
+
   private extractParsedEvent(parsed: any, observedAt: string): PeekEvent[] {
     if (this.agent === 'gemini') {
       const events = this.extractGeminiParsedEvent(parsed, observedAt);
@@ -446,6 +541,36 @@ export class PeekEventExtractor {
 
     return [{ kind: 'message', ts: observedAt, text }];
   }
+
+  private completeForgePendingTool(observedAt: string): PeekEvent[] {
+    if (!this.forgePendingTool) {
+      return [];
+    }
+
+    const pending = this.forgePendingTool;
+    this.forgePendingTool = null;
+    const event = createToolCallEvent({
+      ts: observedAt,
+      phase: 'completed',
+      id: pending.id,
+      tool: pending.tool,
+      status: 'unknown',
+      defaultStatus: 'unknown',
+    });
+    event.summary = pending.summary;
+    if (pending.summary_truncated) {
+      event.summary_truncated = true;
+    }
+    return [event];
+  }
+
+  private flushForgePendingTool(observedAt: string, terminal: boolean): PeekEvent[] {
+    if (this.agent !== 'forge' || !terminal) {
+      return [];
+    }
+
+    return this.completeForgePendingTool(observedAt);
+  }
 }
 
 export class PeekMessageExtractor {
@@ -459,8 +584,8 @@ export class PeekMessageExtractor {
     return this.toMessages(this.extractor.push(chunk, observedAt));
   }
 
-  flush(observedAt = new Date().toISOString()): PeekMessage[] {
-    return this.toMessages(this.extractor.flush(observedAt));
+  flush(observedAt = new Date().toISOString(), options: PeekFlushOptions = {}): PeekMessage[] {
+    return this.toMessages(this.extractor.flush(observedAt, options));
   }
 
   private toMessages(events: PeekEvent[]): PeekMessage[] {

package/src/process-service.ts

@@ -256,8 +256,8 @@ export class ProcessService {
       };
       processes.push(result);
 
-      const stdoutExtractor = new PeekEventExtractor(entry.toolType, { includeToolCalls });
-      const stderrExtractor = new PeekEventExtractor(entry.toolType, { includeToolCalls });
+      const stdoutExtractor = new PeekEventExtractor(entry.toolType, { includeToolCalls, source: 'stdout' });
+      const stderrExtractor = new PeekEventExtractor(entry.toolType, { includeToolCalls, source: 'stderr' });
       const onStdout = (data: Buffer | string) => {
         appendPeekEvents(result, stdoutExtractor.push(data.toString(), new Date().toISOString()));
       };
@@ -294,8 +294,9 @@ export class ProcessService {
       for (const observer of observers) {
         observer.entry.process.stdout?.off('data', observer.onStdout);
         observer.entry.process.stderr?.off('data', observer.onStderr);
-        appendPeekEvents(observer.result, observer.stdoutExtractor.flush(flushTs));
-        appendPeekEvents(observer.result, observer.stderrExtractor.flush(flushTs));
+        const terminal = observer.entry.status !== 'running';
+        appendPeekEvents(observer.result, observer.stdoutExtractor.flush(flushTs, { terminal }));
+        appendPeekEvents(observer.result, observer.stderrExtractor.flush(flushTs, { terminal }));
         observer.result.status = observer.entry.status;
       }
     }