@akira-tl/forgerelay 0.5.0 → 0.5.2

package/CHANGELOG.md

@@ -4,6 +4,27 @@ All notable ForgeRelay changes are documented here.
 
 ## [Unreleased]
 
+## [0.5.2] - 2026-08-15
+
+### Added
+
+- Added durable Bash output audit streams in ForgeRelay's local SQLite state: complete commands and original stdout/stderr/PTY output are retained under a stable `outputId`, can be retrieved after restart through regular Bash or Codex-compatible process tooling, and remain independent of the bounded in-memory process buffer.
+- Background commands that were previously returned to the Host now produce a separate durable `bash_result` Activity exactly once when their completion is delivered, while the original Bash Activity remains historical `returned` state.
+
+### Changed
+
+- Normal Bash, `exec_command`, and process-control responses now keep Agent context compact by returning only the final 10 output lines plus the stable full-output identifier; explicit output lookup returns the complete persisted process output.
+
+## [0.5.1] - 2026-08-14
+
+### Added
+
+- Routed ForgeRelay's top-level work operations through one persistent Activity lifecycle: read, write, edit, rename, delete, capability, Bash, and Codex-compatible execution/patch operations now record durable started/succeeded/failed/blocked/returned facts without relying on UI inference. Bash/exec process-control follow-ups remain part of the existing semantic operation instead of creating duplicate top-level Activities.
+
+### Fixed
+
+- Activity auditing now treats a shell process as `returned` only after its `processId` can actually be delivered to the Host; Host cancellation during post-tool delivery protection records a failed Activity and discards the undelivered process instead of leaving a false returned history entry.
+
 ## [0.5.0] - 2026-08-14
 
 ### Added

package/dist/activity/audit-store.js

@@ -66,6 +66,11 @@ export class ActivityAuditStore {
                     result = event.result;
                     error = undefined;
                     break;
+                case "returned":
+                    state = "returned";
+                    result = event.result;
+                    error = undefined;
+                    break;
                 case "failed":
                     state = "failed";
                     result = event.result;
@@ -177,6 +182,12 @@ function rowToEvent(row) {
                 type: "succeeded",
                 result: parseJson(row.result_json),
             };
+        case "returned":
+            return {
+                ...base,
+                type: "returned",
+                result: parseJson(row.result_json),
+            };
         case "failed":
             if (!row.error)
                 throw new Error(`Activity audit failed event ${row.id} is missing an error.`);

package/dist/activity/bash-output-store.js

@@ -0,0 +1,127 @@
+import { randomUUID } from "node:crypto";
+import { StringDecoder } from "node:string_decoder";
+import { openDatabase } from "../db/client.js";
+export class BashOutputStore {
+    database;
+    now;
+    nextOutputId;
+    nextSequences = new Map();
+    constructor(stateDir, options = {}) {
+        this.database = openDatabase(stateDir);
+        this.now = options.now ?? (() => new Date());
+        this.nextOutputId = options.outputId ?? (() => `out_${randomUUID().replaceAll("-", "")}`);
+    }
+    begin(input) {
+        const outputId = this.nextOutputId();
+        const startedAt = this.now().toISOString();
+        this.database.sqlite.prepare(`insert into bash_output_streams (
+        id, activity_id, turn_id, conversation_scope_id, process_id,
+        workspace_id, workspace_root, command, tty, status, timed_out, started_at
+      ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, 'running', 0, ?)`).run(outputId, input.activityId, input.turnId, input.conversationScopeId ?? null, input.processId, input.workspaceId, input.workspaceRoot, input.command, input.tty ? 1 : 0, startedAt);
+        this.nextSequences.set(outputId, 1);
+        return outputId;
+    }
+    append(outputId, channel, data) {
+        const bytes = typeof data === "string" ? Buffer.from(data, "utf8") : Buffer.from(data);
+        if (bytes.length === 0)
+            return;
+        const sequence = this.nextSequence(outputId);
+        this.database.sqlite.prepare(`insert into bash_output_chunks (output_id, sequence, channel, data, created_at)
+       values (?, ?, ?, ?, ?)`).run(outputId, sequence, channel, bytes, this.now().toISOString());
+    }
+    markReturned(outputId) {
+        this.database.sqlite.prepare("update bash_output_streams set returned = 1 where id = ?").run(outputId);
+    }
+    claimCompletion(outputId) {
+        const claimedAt = this.now().toISOString();
+        const claimed = this.database.sqlite.prepare(`update bash_output_streams
+       set completion_claimed_at = ?
+       where id = ? and returned = 1 and status != 'running' and completion_claimed_at is null`).run(claimedAt, outputId);
+        return claimed.changes === 1 ? this.read(outputId) : undefined;
+    }
+    finish(outputId, input) {
+        const status = input.error || input.timedOut || input.signal || (input.exitCode !== undefined && input.exitCode !== 0)
+            ? "failed"
+            : "done";
+        this.database.sqlite.prepare(`update bash_output_streams
+       set status = ?, exit_code = ?, signal = ?, timed_out = ?, error = ?, finished_at = ?
+       where id = ?`).run(status, input.exitCode ?? null, input.signal ?? null, input.timedOut ? 1 : 0, input.error ?? null, this.now().toISOString(), outputId);
+    }
+    read(outputId) {
+        const stream = this.database.sqlite.prepare("select * from bash_output_streams where id = ?").get(outputId);
+        if (!stream)
+            return undefined;
+        const rows = this.database.sqlite.prepare(`select * from bash_output_chunks
+       where output_id = ?
+       order by sequence asc`).all(outputId);
+        const decoded = decodeChunks(rows);
+        return {
+            outputId: stream.id,
+            activityId: stream.activity_id,
+            turnId: stream.turn_id,
+            ...(stream.conversation_scope_id ? { conversationScopeId: stream.conversation_scope_id } : {}),
+            processId: stream.process_id,
+            workspaceId: stream.workspace_id,
+            workspaceRoot: stream.workspace_root,
+            command: stream.command,
+            tty: stream.tty === 1,
+            output: decoded.map((chunk) => chunk.data).join(""),
+            chunks: decoded,
+            status: isBashOutputStatus(stream.status) ? stream.status : "failed",
+            ...(stream.exit_code !== null ? { exitCode: stream.exit_code } : {}),
+            ...(stream.signal ? { signal: stream.signal } : {}),
+            timedOut: stream.timed_out === 1,
+            ...(stream.error ? { error: stream.error } : {}),
+            returned: stream.returned === 1,
+            startedAt: stream.started_at,
+            ...(stream.finished_at ? { finishedAt: stream.finished_at } : {}),
+        };
+    }
+    close() {
+        this.database.close();
+    }
+    nextSequence(outputId) {
+        const known = this.nextSequences.get(outputId);
+        if (known !== undefined) {
+            this.nextSequences.set(outputId, known + 1);
+            return known;
+        }
+        const row = this.database.sqlite.prepare("select coalesce(max(sequence), 0) as sequence from bash_output_chunks where output_id = ?").get(outputId);
+        const sequence = row.sequence + 1;
+        this.nextSequences.set(outputId, sequence + 1);
+        return sequence;
+    }
+}
+function decodeChunks(rows) {
+    const decoders = new Map();
+    const chunks = [];
+    const lastChunkIndex = new Map();
+    for (const row of rows) {
+        if (!isBashOutputChannel(row.channel)) {
+            throw new Error(`Unknown Bash output channel: ${row.channel}`);
+        }
+        const decoder = decoders.get(row.channel) ?? new StringDecoder("utf8");
+        decoders.set(row.channel, decoder);
+        const data = decoder.write(row.data);
+        chunks.push({ sequence: row.sequence, channel: row.channel, data });
+        lastChunkIndex.set(row.channel, chunks.length - 1);
+    }
+    for (const [channel, decoder] of decoders) {
+        const tail = decoder.end();
+        if (!tail)
+            continue;
+        const index = lastChunkIndex.get(channel);
+        if (index === undefined)
+            continue;
+        const chunk = chunks[index];
+        if (chunk)
+            chunk.data += tail;
+    }
+    return chunks;
+}
+function isBashOutputChannel(value) {
+    return value === "stdout" || value === "stderr" || value === "pty" || value === "process";
+}
+function isBashOutputStatus(value) {
+    return value === "running" || value === "done" || value === "failed";
+}

package/dist/activity/lifecycle.js

@@ -0,0 +1,138 @@
+import { randomUUID } from "node:crypto";
+import { HookExecutionError } from "../hooks.js";
+export class ActivityLifecycle {
+    auditStore;
+    activityId;
+    turnId;
+    constructor(auditStore, options = {}) {
+        this.auditStore = auditStore;
+        this.activityId = options.activityId ?? newActivityId;
+        this.turnId = options.turnId ?? newTurnId;
+    }
+    record(options) {
+        const context = this.start(options);
+        this.finish(context.activityId, options.result, options.outcome);
+        return context;
+    }
+    recordLinked(options) {
+        const source = this.auditStore.getActivity(options.sourceActivityId);
+        if (!source)
+            throw new Error(`Unknown source Activity: ${options.sourceActivityId}`);
+        const { sourceActivityId: _sourceActivityId, ...record } = options;
+        return this.record({
+            ...record,
+            ...(source.conversationScopeId ? { conversationScopeId: source.conversationScopeId } : {}),
+            workspace: source.workspace,
+        });
+    }
+    async run(options) {
+        const executionContext = this.start(options);
+        const activityId = executionContext.activityId;
+        try {
+            const result = await options.operation(executionContext);
+            this.finish(activityId, result, options.outcome?.(result) ?? { type: "succeeded" });
+            return result;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.auditStore.append(error instanceof HookExecutionError && error.event === "BeforeTool"
+                ? { type: "blocked", activityId, error: message }
+                : { type: "failed", activityId, error: message });
+            throw error;
+        }
+    }
+    start(options) {
+        const activityId = options.activityId ?? this.activityId();
+        const turnId = options.turnId ?? this.turnId();
+        const request = normalizeAuditValue(options.request);
+        this.auditStore.append({
+            type: "started",
+            activityId,
+            turnId,
+            ...(options.conversationScopeId ? { conversationScopeId: options.conversationScopeId } : {}),
+            tool: options.tool,
+            workspace: options.workspace,
+            ...(request !== undefined ? { request } : {}),
+        });
+        return {
+            activityId,
+            turnId,
+            ...(options.conversationScopeId ? { conversationScopeId: options.conversationScopeId } : {}),
+        };
+    }
+    finish(activityId, result, outcome) {
+        const normalizedResult = normalizeAuditValue(result);
+        switch (outcome.type) {
+            case "succeeded":
+            case "returned":
+                this.auditStore.append({
+                    type: outcome.type,
+                    activityId,
+                    ...(normalizedResult !== undefined ? { result: normalizedResult } : {}),
+                });
+                break;
+            case "failed":
+                this.auditStore.append({
+                    type: "failed",
+                    activityId,
+                    ...(normalizedResult !== undefined ? { result: normalizedResult } : {}),
+                    error: outcome.error,
+                });
+                break;
+        }
+    }
+}
+function newActivityId() {
+    return `act_${randomUUID().replaceAll("-", "")}`;
+}
+function newTurnId() {
+    return `turn_${randomUUID().replaceAll("-", "")}`;
+}
+export function normalizeAuditValue(value) {
+    return normalizeAuditValueInternal(value, new WeakSet());
+}
+function normalizeAuditValueInternal(value, seen) {
+    if (value === undefined || typeof value === "function" || typeof value === "symbol")
+        return undefined;
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : String(value);
+    if (typeof value === "bigint")
+        return value.toString();
+    if (value instanceof Date)
+        return value.toISOString();
+    if (value instanceof Error) {
+        return {
+            name: value.name,
+            message: value.message,
+        };
+    }
+    if (value instanceof Uint8Array) {
+        return {
+            type: "bytes",
+            encoding: "base64",
+            data: Buffer.from(value).toString("base64"),
+        };
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => normalizeAuditValueInternal(entry, seen) ?? null);
+    }
+    if (typeof value !== "object")
+        return String(value);
+    if (seen.has(value))
+        return "[Circular]";
+    seen.add(value);
+    try {
+        const normalized = {};
+        for (const [key, entry] of Object.entries(value)) {
+            const next = normalizeAuditValueInternal(entry, seen);
+            if (next !== undefined)
+                normalized[key] = next;
+        }
+        return normalized;
+    }
+    finally {
+        seen.delete(value);
+    }
+}

package/dist/activity/process-output-audit.js

@@ -0,0 +1 @@
+export {};

package/dist/db/migrations.js

@@ -39,6 +39,11 @@ const migrations = [
         name: "activity-audit",
         up: migrateActivityAudit,
     },
+    {
+        version: 9,
+        name: "bash-output-audit",
+        up: migrateBashOutputAudit,
+    },
 ];
 export function migrateDatabase(sqlite) {
     const migrate = sqlite.transaction(() => {
@@ -248,6 +253,49 @@ function migrateActivityAudit(sqlite) {
       on activity_audit_events(created_at);
   `);
 }
+function migrateBashOutputAudit(sqlite) {
+    sqlite.exec(`
+    create table if not exists bash_output_streams (
+      id text primary key,
+      activity_id text not null,
+      turn_id text not null,
+      conversation_scope_id text,
+      process_id integer not null,
+      workspace_id text not null,
+      workspace_root text not null,
+      command text not null,
+      tty integer not null default 0,
+      status text not null default 'running',
+      exit_code integer,
+      signal text,
+      timed_out integer not null default 0,
+      error text,
+      returned integer not null default 0,
+      completion_claimed_at text,
+      started_at text not null,
+      finished_at text
+    );
+
+    create index if not exists bash_output_streams_activity_idx
+      on bash_output_streams(activity_id);
+
+    create index if not exists bash_output_streams_workspace_idx
+      on bash_output_streams(workspace_id, started_at);
+
+    create table if not exists bash_output_chunks (
+      output_id text not null,
+      sequence integer not null,
+      channel text not null,
+      data blob not null,
+      created_at text not null,
+      primary key (output_id, sequence),
+      foreign key (output_id) references bash_output_streams(id) on delete cascade
+    );
+
+    create index if not exists bash_output_chunks_output_idx
+      on bash_output_chunks(output_id, sequence);
+  `);
+}
 function addColumnIfMissing(sqlite, table, column, definition) {
     const columns = sqlite.prepare(`pragma table_info(${table})`).all();
     if (columns.some((existingColumn) => existingColumn.name === column))

package/dist/db/schema.js

@@ -1,4 +1,4 @@
-import { index, integer, primaryKey, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+import { blob, index, integer, primaryKey, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
 export const workspaceSessions = sqliteTable("workspace_sessions", {
     id: text("id").primaryKey(),
     root: text("root").notNull(),
@@ -97,6 +97,41 @@ export const activityAuditEvents = sqliteTable("activity_audit_events", {
     index("activity_audit_events_turn_idx").on(table.turnId, table.createdAt),
     index("activity_audit_events_created_idx").on(table.createdAt),
 ]);
+export const bashOutputStreams = sqliteTable("bash_output_streams", {
+    id: text("id").primaryKey(),
+    activityId: text("activity_id").notNull(),
+    turnId: text("turn_id").notNull(),
+    conversationScopeId: text("conversation_scope_id"),
+    processId: integer("process_id").notNull(),
+    workspaceId: text("workspace_id").notNull(),
+    workspaceRoot: text("workspace_root").notNull(),
+    command: text("command").notNull(),
+    tty: integer("tty", { mode: "boolean" }).notNull().default(false),
+    status: text("status").notNull().default("running"),
+    exitCode: integer("exit_code"),
+    signal: text("signal"),
+    timedOut: integer("timed_out", { mode: "boolean" }).notNull().default(false),
+    error: text("error"),
+    returned: integer("returned", { mode: "boolean" }).notNull().default(false),
+    completionClaimedAt: text("completion_claimed_at"),
+    startedAt: text("started_at").notNull(),
+    finishedAt: text("finished_at"),
+}, (table) => [
+    index("bash_output_streams_activity_idx").on(table.activityId),
+    index("bash_output_streams_workspace_idx").on(table.workspaceId, table.startedAt),
+]);
+export const bashOutputChunks = sqliteTable("bash_output_chunks", {
+    outputId: text("output_id")
+        .notNull()
+        .references(() => bashOutputStreams.id, { onDelete: "cascade" }),
+    sequence: integer("sequence").notNull(),
+    channel: text("channel").notNull(),
+    data: blob("data", { mode: "buffer" }).notNull(),
+    createdAt: text("created_at").notNull(),
+}, (table) => [
+    primaryKey({ columns: [table.outputId, table.sequence] }),
+    index("bash_output_chunks_output_idx").on(table.outputId, table.sequence),
+]);
 export const localAgentSessions = sqliteTable("local_agent_sessions", {
     id: text("id").primaryKey(),
     workspaceId: text("workspace_id"),

package/dist/lsp/test-support/server-fixture.js

@@ -4,6 +4,9 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { ActivityAuditStore } from "../../activity/audit-store.js";
+import { BashOutputStore } from "../../activity/bash-output-store.js";
+import { ActivityLifecycle } from "../../activity/lifecycle.js";
 import { loadConfig } from "../../config.js";
 import { createReviewCheckpointManager } from "../../review-checkpoints.js";
 import { ProcessManager } from "../../process-sessions.js";
@@ -32,9 +35,12 @@ export async function createCodeIntelligenceServerFixture(t, options = {}) {
     });
     const store = new SqliteWorkspaceStore(stateDir);
     const workspaces = new WorkspaceRegistry(config, store);
-    const processSessions = new ProcessManager();
+    const auditStore = new ActivityAuditStore(stateDir);
+    const bashOutputStore = new BashOutputStore(stateDir);
+    const processSessions = new ProcessManager({ outputAudit: bashOutputStore });
+    const activityLifecycle = new ActivityLifecycle(auditStore);
     const codeIntelligence = new CodeIntelligenceManager(config, options.codeIntelligenceOptions);
-    const server = createMcpServer(config, workspaces, createReviewCheckpointManager(), processSessions, [], [], codeIntelligence);
+    const server = createMcpServer(config, workspaces, createReviewCheckpointManager(), processSessions, [], [], codeIntelligence, activityLifecycle, bashOutputStore);
     const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
     const client = new Client({ name: "forgerelay-code-intelligence-test-client", version: "1.0.0" });
     await Promise.all([client.connect(clientTransport), server.connect(serverTransport)]);
@@ -47,6 +53,8 @@ export async function createCodeIntelligenceServerFixture(t, options = {}) {
         await server.close();
         await codeIntelligence.shutdown();
         processSessions.shutdown();
+        bashOutputStore.close();
+        auditStore.close();
         store.close();
     };
     t.after(async () => {

package/dist/process-sessions.js

@@ -209,6 +209,7 @@ export class ProcessManager {
     completedProcessTtlMs;
     maxStartYieldMs;
     monotonicNow;
+    outputAudit;
     nextProcessId = 1;
     constructor(options = {}) {
         this.maxBufferCharacters = options.maxBufferCharacters ?? DEFAULT_BUFFER_CHARACTERS;
@@ -225,6 +226,7 @@ export class ProcessManager {
             ?? COMPLETED_PROCESS_TTL_MS;
         this.maxStartYieldMs = options.maxStartYieldMs ?? MAX_START_YIELD_MS;
         this.monotonicNow = options.monotonicNow ?? (() => performance.now());
+        this.outputAudit = options.outputAudit;
     }
     async start(input) {
         input.signal?.throwIfAborted();
@@ -241,6 +243,10 @@ export class ProcessManager {
                 this.startPipe(processEntry, input);
         }
         catch (error) {
+            this.finishAudit(processEntry, {
+                timedOut: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
             this.processes.delete(processEntry.id);
             throw error;
         }
@@ -349,8 +355,14 @@ export class ProcessManager {
     shutdown() {
         for (const processEntry of this.processes.values()) {
             this.clearProcessTimers(processEntry);
-            if (processEntry.running)
+            if (processEntry.running) {
+                this.finishAudit(processEntry, {
+                    signal: "shutdown",
+                    timedOut: false,
+                    error: "ForgeRelay shut down while the process was still running.",
+                });
                 processEntry.process?.kill("SIGTERM");
+            }
         }
         this.processes.clear();
         this.completedByWorkspace.clear();
@@ -389,10 +401,25 @@ export class ProcessManager {
         const exitPromise = new Promise((resolve) => {
             resolveExit = resolve;
         });
+        const id = this.nextProcessId++;
+        const outputId = this.outputAudit && input.audit
+            ? this.outputAudit.begin({
+                activityId: input.audit.activityId,
+                turnId: input.audit.turnId,
+                ...(input.audit.conversationScopeId ? { conversationScopeId: input.audit.conversationScopeId } : {}),
+                processId: id,
+                workspaceId: input.workspaceId,
+                workspaceRoot: input.workspaceRoot ?? input.cwd,
+                command: input.command,
+                tty: input.tty === true,
+            })
+            : undefined;
         return {
-            id: this.nextProcessId++,
+            id,
             workspaceId: input.workspaceId,
             command: input.command,
+            ...(outputId ? { outputId } : {}),
+            auditFinished: false,
             startedAtMonotonic: this.monotonicNow(),
             columns: terminalSize(input.columns, DEFAULT_COLUMNS),
             rows: terminalSize(input.rows, DEFAULT_ROWS),
@@ -426,9 +453,9 @@ export class ProcessManager {
             kill: (signal = "SIGTERM") => terminateProcessTree(child, signal, detached),
             resize: input.tty ? () => undefined : undefined,
         };
-        child.stdout.on("data", (data) => this.append(processEntry, data.toString("utf8")));
-        child.stderr.on("data", (data) => this.append(processEntry, data.toString("utf8")));
-        child.on("error", (error) => this.append(processEntry, `${error.message}\n`));
+        child.stdout.on("data", (data) => this.append(processEntry, "stdout", data));
+        child.stderr.on("data", (data) => this.append(processEntry, "stderr", data));
+        child.on("error", (error) => this.append(processEntry, "process", `${error.message}\n`));
         child.on("close", (code, signal) => this.finish(processEntry, code ?? undefined, signal ?? undefined));
     }
     async startPty(processEntry, input) {
@@ -462,7 +489,7 @@ export class ProcessManager {
             kill: (signal) => pty.kill(signal),
             resize: (columns, rows) => pty.resize(columns, rows),
         };
-        pty.onData((data) => this.append(processEntry, data));
+        pty.onData((data) => this.append(processEntry, "pty", data));
         pty.onExit(({ exitCode, signal }) => {
             this.finish(processEntry, exitCode, signal === 0 ? undefined : String(signal));
         });
@@ -475,6 +502,11 @@ export class ProcessManager {
         processEntry.signal = signal;
         processEntry.finishedAtMonotonic = this.monotonicNow();
         processEntry.process = undefined;
+        this.finishAudit(processEntry, {
+            ...(exitCode !== undefined ? { exitCode } : {}),
+            ...(signal ? { signal } : {}),
+            timedOut: processEntry.timedOut,
+        });
         if (processEntry.executionTimeoutTimer)
             clearTimeout(processEntry.executionTimeoutTimer);
         if (processEntry.forceKillTimer)
@@ -512,8 +544,17 @@ export class ProcessManager {
         processEntry.cleanupTimer = setTimeout(() => this.removeProcess(processEntry.id), remainingMs);
         processEntry.cleanupTimer.unref();
     }
-    append(processEntry, output) {
-        processEntry.buffer.append(output);
+    append(processEntry, channel, output) {
+        if (processEntry.outputId && !processEntry.auditFinished) {
+            this.outputAudit?.append(processEntry.outputId, channel, output);
+        }
+        processEntry.buffer.append(typeof output === "string" ? output : Buffer.from(output).toString("utf8"));
+    }
+    finishAudit(processEntry, input) {
+        if (!processEntry.outputId || processEntry.auditFinished)
+            return;
+        processEntry.auditFinished = true;
+        this.outputAudit?.finish(processEntry.outputId, input);
     }
     consume(processEntry, maxOutputTokens) {
         const limit = boundedInteger(maxOutputTokens, DEFAULT_MAX_OUTPUT_TOKENS, 100_000);
@@ -526,6 +567,7 @@ export class ProcessManager {
         return {
             processId,
             sessionId: processId,
+            ...(processEntry.outputId ? { outputId: processEntry.outputId } : {}),
             output: buffered.output,
             outputTruncated: processEntry.outputWasTruncated,
             running: processEntry.running,