@akira-tl/forgerelay 0.5.1 → 0.5.2

package/CHANGELOG.md

@@ -4,6 +4,17 @@ 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

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

@@ -9,7 +9,39 @@ export class ActivityLifecycle {
         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);
@@ -22,36 +54,31 @@ export class ActivityLifecycle {
             workspace: options.workspace,
             ...(request !== undefined ? { request } : {}),
         });
-        try {
-            const result = await options.operation();
-            const normalizedResult = normalizeAuditValue(result);
-            const outcome = options.outcome?.(result) ?? { type: "succeeded" };
-            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;
-            }
-            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;
+        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;
         }
     }
 }

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

@@ -5,6 +5,7 @@ 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";
@@ -34,11 +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, activityLifecycle);
+    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)]);
@@ -51,6 +53,7 @@ export async function createCodeIntelligenceServerFixture(t, options = {}) {
         await server.close();
         await codeIntelligence.shutdown();
         processSessions.shutdown();
+        bashOutputStore.close();
         auditStore.close();
         store.close();
     };

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,

package/dist/server.js

@@ -16,7 +16,8 @@ import express from "express";
 import * as z from "zod/v4";
 import { applyPatch } from "./apply-patch.js";
 import { ActivityAuditStore } from "./activity/audit-store.js";
-import { ActivityLifecycle } from "./activity/lifecycle.js";
+import { BashOutputStore } from "./activity/bash-output-store.js";
+import { ActivityLifecycle, } from "./activity/lifecycle.js";
 import { buildCapabilityFingerprint } from "./capabilities.js";
 import { CapabilityError, createCapabilityRegistry, } from "./capability-registry.js";
 import { deletePath, renamePath } from "./file-mutations.js";
@@ -468,6 +469,24 @@ async function readWorkspaceAppResource(config, requestedUri, transportSessionId
         throw error;
     }
 }
+const PROCESS_RESPONSE_OUTPUT_LINES = 10;
+function compactProcessOutput(output) {
+    if (!output)
+        return { output: "", truncated: false };
+    const trailingNewline = output.endsWith("\n");
+    const body = trailingNewline ? output.slice(0, -1) : output;
+    const lines = body.split("\n");
+    if (lines.length <= PROCESS_RESPONSE_OUTPUT_LINES)
+        return { output, truncated: false };
+    const compact = lines.slice(-PROCESS_RESPONSE_OUTPUT_LINES).join("\n");
+    return {
+        output: trailingNewline ? `${compact}\n` : compact,
+        truncated: true,
+    };
+}
+function outputIdNotice(outputId) {
+    return outputId ? `Full output ID: ${outputId}.` : "";
+}
 function processResult(snapshot) {
     const status = snapshot.running
         ? `Process running with process ID ${snapshot.processId}.`
@@ -476,7 +495,8 @@ function processResult(snapshot) {
             : snapshot.signal
                 ? `Process exited after signal ${snapshot.signal}.`
                 : `Process exited with code ${snapshot.exitCode ?? "unknown"}.`;
-    return snapshot.output ? `${snapshot.output.replace(/\n$/, "")}\n${status}` : status;
+    const compact = compactProcessOutput(snapshot.output).output.replace(/\n$/, "");
+    return [compact, status, outputIdNotice(snapshot.outputId)].filter(Boolean).join("\n");
 }
 function completedProcessResult(snapshot) {
     const status = snapshot.timedOut
@@ -485,12 +505,14 @@ function completedProcessResult(snapshot) {
             ? `Background process ${snapshot.processId} exited after signal ${snapshot.signal}.`
             : `Background process ${snapshot.processId} exited with code ${snapshot.exitCode ?? "unknown"}.`;
     const command = `Command: ${snapshot.command}`;
-    const output = snapshot.output ? `\n${snapshot.output.replace(/\n$/, "")}` : "";
-    return `${status}\n${command}${output}`;
+    const output = compactProcessOutput(snapshot.output).output.replace(/\n$/, "");
+    return [status, command, output, outputIdNotice(snapshot.outputId)].filter(Boolean).join("\n");
 }
-function attachCompletedProcessNotices(processSessions, workspaceId, result) {
+function attachCompletedProcessNotices(processSessions, workspaceId, result, onCompleted) {
     if (result instanceof Error) {
         const completed = processSessions.takeCompleted(workspaceId);
+        for (const snapshot of completed)
+            onCompleted?.(snapshot);
         if (completed.length > 0) {
             result.message = [
                 result.message,
@@ -513,6 +535,8 @@ function attachCompletedProcessNotices(processSessions, workspaceId, result) {
                 : undefined
         : undefined;
     const completed = processSessions.takeCompleted(workspaceId, undefined, currentProcessId);
+    for (const snapshot of completed)
+        onCompleted?.(snapshot);
     if (completed.length === 0)
         return result;
     return {
@@ -527,6 +551,7 @@ function processOutputSchema() {
     return resultOutputSchema({
         processId: z.number().int().positive().optional().describe("Canonical process handle for bash(action=\"process\") or the active command adapter."),
         sessionId: z.number().int().positive().optional().describe("Deprecated alias of processId for compatibility."),
+        outputId: z.string().optional().describe("Stable local audit identifier for retrieving the complete original process output."),
         running: z.boolean(),
         exitCode: z.number().int().optional(),
         signal: z.string().optional(),
@@ -543,9 +568,10 @@ function readForgeRelayVersion() {
     return packageJson.version;
 }
 function processToolResponse(tool, workspaceId, snapshot, summary) {
+    const compact = compactProcessOutput(snapshot.output);
     const result = processResult(snapshot);
     const content = [textBlock(result)];
-    const outputSummary = textSummary(snapshot.output ? [textBlock(snapshot.output)] : []);
+    const outputSummary = textSummary(compact.output ? [textBlock(compact.output)] : []);
     return {
         content,
         _meta: {
@@ -560,15 +586,111 @@ function processToolResponse(tool, workspaceId, snapshot, summary) {
             result,
             processId: snapshot.processId,
             sessionId: snapshot.sessionId,
+            outputId: snapshot.outputId,
             running: snapshot.running,
             exitCode: snapshot.exitCode,
             signal: snapshot.signal,
             timedOut: snapshot.timedOut,
             wallTimeMs: snapshot.wallTimeMs,
-            outputTruncated: snapshot.outputTruncated,
+            outputTruncated: snapshot.outputTruncated || compact.truncated,
+        },
+    };
+}
+function durableOutputResult(record) {
+    const status = record.status === "running"
+        ? `Process ${record.processId} is still running.`
+        : record.timedOut
+            ? `Process ${record.processId} timed out and was terminated.`
+            : record.signal
+                ? `Process ${record.processId} exited after signal ${record.signal}.`
+                : `Process ${record.processId} exited with code ${record.exitCode ?? "unknown"}.`;
+    return [record.output.replace(/\n$/, ""), status, `Full output ID: ${record.outputId}.`]
+        .filter(Boolean)
+        .join("\n");
+}
+function durableOutputResponse(tool, workspaceId, record) {
+    const result = durableOutputResult(record);
+    const content = [textBlock(result)];
+    const finishedAt = record.finishedAt ? Date.parse(record.finishedAt) : Date.now();
+    const startedAt = Date.parse(record.startedAt);
+    return {
+        content,
+        _meta: {
+            tool,
+            card: {
+                workspaceId,
+                summary: textSummary(record.output ? [textBlock(record.output)] : []),
+                payload: { content },
+            },
+        },
+        structuredContent: {
+            result,
+            processId: record.processId,
+            sessionId: record.processId,
+            outputId: record.outputId,
+            running: record.status === "running",
+            exitCode: record.exitCode,
+            signal: record.signal,
+            timedOut: record.timedOut,
+            wallTimeMs: Math.max(0, Number.isFinite(finishedAt - startedAt) ? finishedAt - startedAt : 0),
+            outputTruncated: false,
         },
     };
 }
+function markReturnedOutput(store, result) {
+    if (typeof result !== "object" || result === null)
+        return;
+    const structured = result.structuredContent;
+    if (typeof structured !== "object" || structured === null)
+        return;
+    const record = structured;
+    if (record.running === true && typeof record.outputId === "string") {
+        store.markReturned(record.outputId);
+    }
+}
+function readWorkspaceBashOutput(store, workspaceId, outputId) {
+    const record = store.read(outputId);
+    if (!record)
+        throw new Error(`Unknown Bash output: ${outputId}`);
+    if (record.workspaceId !== workspaceId) {
+        throw new Error(`Bash output ${outputId} does not belong to workspace ${workspaceId}.`);
+    }
+    return record;
+}
+function bashCompletionError(record) {
+    if (record.error)
+        return record.error;
+    if (record.timedOut)
+        return `Background process ${record.processId} timed out.`;
+    if (record.signal)
+        return `Background process ${record.processId} exited after signal ${record.signal}.`;
+    return `Background process ${record.processId} exited with code ${record.exitCode ?? "unknown"}.`;
+}
+function recordBashCompletion(lifecycle, store, outputId) {
+    if (!outputId)
+        return;
+    const completion = store.claimCompletion(outputId);
+    if (!completion)
+        return;
+    lifecycle.recordLinked({
+        sourceActivityId: completion.activityId,
+        tool: "bash_result",
+        request: {
+            processId: completion.processId,
+            outputId: completion.outputId,
+        },
+        result: {
+            processId: completion.processId,
+            outputId: completion.outputId,
+            exitCode: completion.exitCode,
+            signal: completion.signal,
+            timedOut: completion.timedOut,
+        },
+        outcome: completion.status === "failed"
+            ? { type: "failed", error: bashCompletionError(completion) }
+            : { type: "succeeded" },
+    });
+}
 function workspaceHookInvocation(workspace) {
     return {
         workspaceId: workspace.id,
@@ -669,7 +791,7 @@ function runActivityTool(lifecycle, workspace, requestMeta, tool, request, opera
 function runActivityToolWithHooks(lifecycle, hooks, workspace, requestMeta, request, hookOptions) {
     return runActivityTool(lifecycle, workspace, requestMeta, hookOptions.tool, request, () => runToolWithHooks(hooks, hookOptions));
 }
-function registerProcessTools(server, config, workspaces, processSessions, hooks, activityLifecycle) {
+function registerProcessTools(server, config, workspaces, processSessions, hooks, activityLifecycle, bashOutputStore) {
     if (config.toolMode === "codex") {
         registerAppTool(server, "exec_command", {
             title: "Execute command",
@@ -715,7 +837,7 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
         }, async ({ workspaceId, cmd, tty, columns, rows, workingDirectory, yieldTimeMs, timeoutMs, maxOutputTokens }, extra) => {
             const workspace = workspaces.getWorkspace(workspaceId);
             let undeliveredProcessId;
-            return runActivityTool(activityLifecycle, workspace, extra._meta, "exec_command", { workspaceId, cmd, tty, columns, rows, workingDirectory, yieldTimeMs, timeoutMs, maxOutputTokens }, async () => {
+            const activityResult = await runActivityTool(activityLifecycle, workspace, extra._meta, "exec_command", { workspaceId, cmd, tty, columns, rows, workingDirectory, yieldTimeMs, timeoutMs, maxOutputTokens }, async (activityContext) => {
                 try {
                     const result = await runToolWithHooks(hooks, {
                         signal: extra.signal,
@@ -739,6 +861,7 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
                                 maxOutputTokens,
                                 codexCi: true,
                                 signal: extra.signal,
+                                audit: activityContext,
                             });
                             undeliveredProcessId = snapshot.running ? snapshot.processId : undefined;
                             logToolCall(config, {
@@ -772,17 +895,20 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
                     throw error;
                 }
             }, processActivityOutcome);
+            markReturnedOutput(bashOutputStore, activityResult);
+            return activityResult;
         });
     }
     if (config.toolMode !== "codex")
         return;
     registerAppTool(server, "write_stdin", {
         title: "Write to process",
-        description: "Poll or write characters to a running process returned by bash or exec_command. Omit chars or pass an empty string to poll. Waiting never kills the process; pass \\u0003 to explicitly send Ctrl-C.",
+        description: "Poll or write characters to a running process returned by exec_command, or retrieve complete durable process output by outputId. Omit chars or pass an empty string to poll. Waiting never kills the process; pass \\u0003 to explicitly send Ctrl-C.",
         inputSchema: {
             workspaceId: z.string().describe("Workspace identifier used to start the process."),
             processId: z.number().int().positive().optional().describe("Canonical process identifier returned by bash or exec_command."),
             sessionId: z.number().int().positive().optional().describe("Deprecated alias for processId. Retained for compatibility."),
+            outputId: z.string().optional().describe("Stable output identifier returned by exec_command. When supplied, retrieve the complete durable output instead of controlling a process."),
             chars: z.string().optional().describe("Characters to write. Omit or pass an empty string to poll."),
             columns: z.number().int().min(1).max(1_000).optional().describe("Resize a PTY to this width."),
             rows: z.number().int().min(1).max(1_000).optional().describe("Resize a PTY to this height."),
@@ -804,8 +930,21 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
         outputSchema: processOutputSchema(),
         ...toolWidgetDescriptorMeta(config, "shell"),
         annotations: SHELL_TOOL_ANNOTATIONS,
-    }, async ({ workspaceId, processId, sessionId, chars, columns, rows, yieldTimeMs, maxOutputTokens }, extra) => {
+    }, async ({ workspaceId, processId, sessionId, outputId, chars, columns, rows, yieldTimeMs, maxOutputTokens }, extra) => {
         const workspace = workspaces.getWorkspace(workspaceId);
+        if (outputId !== undefined) {
+            if (processId !== undefined || sessionId !== undefined || chars !== undefined || columns !== undefined ||
+                rows !== undefined || yieldTimeMs !== undefined || maxOutputTokens !== undefined) {
+                throw new Error("write_stdin outputId lookup cannot be combined with process control fields.");
+            }
+            return runToolWithHooks(hooks, {
+                signal: extra.signal,
+                tool: "write_stdin",
+                invocation: workspaceHookInvocation(workspace),
+                payload: { outputId },
+                operation: async () => durableOutputResponse("write_stdin", workspaceId, readWorkspaceBashOutput(bashOutputStore, workspaceId, outputId)),
+            });
+        }
         const resolvedProcessId = resolveProcessId(processId, sessionId);
         return runToolWithHooks(hooks, {
             signal: extra.signal,
@@ -838,20 +977,24 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
                     success: snapshot.running || snapshot.exitCode === 0,
                     durationMs: Math.round(performance.now() - startedAt),
                 });
-                return processToolResponse("write_stdin", workspaceId, snapshot, {
+                const response = processToolResponse("write_stdin", workspaceId, snapshot, {
                     processId: resolvedProcessId,
                     charactersWritten: chars?.length ?? 0,
                     running: snapshot.running,
                     exitCode: snapshot.exitCode,
                     wallTimeMs: snapshot.wallTimeMs,
                 });
+                if (!snapshot.running) {
+                    recordBashCompletion(activityLifecycle, bashOutputStore, snapshot.outputId);
+                }
+                return response;
             },
         });
     });
 }
-export function createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters, codeIntelligence, activityLifecycle) {
+export function createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters, codeIntelligence, activityLifecycle, bashOutputStore) {
     const toolDescriptions = buildToolDescriptions(config);
-    const hooks = new HookRunner(config.hooks, config.logging, process.env, (workspaceId, result) => attachCompletedProcessNotices(processSessions, workspaceId, result));
+    const hooks = new HookRunner(config.hooks, config.logging, process.env, (workspaceId, result) => attachCompletedProcessNotices(processSessions, workspaceId, result, (snapshot) => recordBashCompletion(activityLifecycle, bashOutputStore, snapshot.outputId)));
     const incomingArtifactRegistry = new IncomingArtifactAdapterRegistry(incomingArtifactAdapters);
     const artifactDownloadAvailable = config.artifactsEnabled && isArtifactDownloadSupportedPlatform();
     const reviewChangesAvailable = config.widgets === "changes";
@@ -2045,9 +2188,9 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     .string()
                     .describe("Workspace identifier returned by open_workspace."),
                 action: z
-                    .enum(["run", "process"])
+                    .enum(["run", "process", "output"])
                     .optional()
-                    .describe("Defaults to run. Use process with a returned processId to poll, interact, resize, or interrupt a running command."),
+                    .describe("Defaults to run. Use process with a returned processId to poll/interact, or output with outputId to retrieve complete durable output."),
                 command: z
                     .string()
                     .optional()
@@ -2058,6 +2201,10 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     .positive()
                     .optional()
                     .describe("Process identifier returned by a previous bash action=run call. Required for action=process."),
+                outputId: z
+                    .string()
+                    .optional()
+                    .describe("Stable output identifier returned by a Bash run. Required for action=output."),
                 input: z
                     .string()
                     .optional()
@@ -2113,16 +2260,16 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             outputSchema: processOutputSchema(),
             ...toolWidgetDescriptorMeta(config, "shell"),
             annotations: SHELL_TOOL_ANNOTATIONS,
-        }, async ({ workspaceId, action = "run", command, processId, input, interrupt, tty, columns, rows, workingDirectory, yieldTimeMs, timeoutMs, maxOutputTokens, }, extra) => {
+        }, async ({ workspaceId, action = "run", command, processId, outputId, input, interrupt, tty, columns, rows, workingDirectory, yieldTimeMs, timeoutMs, maxOutputTokens, }, extra) => {
             const workspace = workspaces.getWorkspace(workspaceId);
             if (action === "run") {
                 if (!command)
                     throw new Error("bash action=run requires command.");
-                if (processId !== undefined || input !== undefined || interrupt !== undefined) {
-                    throw new Error("bash action=run does not accept processId, input, or interrupt.");
+                if (processId !== undefined || outputId !== undefined || input !== undefined || interrupt !== undefined) {
+                    throw new Error("bash action=run does not accept processId, outputId, input, or interrupt.");
                 }
                 let undeliveredProcessId;
-                return runActivityTool(activityLifecycle, workspace, extra._meta, toolNames.shell, {
+                const activityResult = await runActivityTool(activityLifecycle, workspace, extra._meta, toolNames.shell, {
                     workspaceId,
                     action,
                     command,
@@ -2133,7 +2280,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     yieldTimeMs,
                     timeoutMs,
                     maxOutputTokens,
-                }, async () => {
+                }, async (activityContext) => {
                     try {
                         const result = await runToolWithHooks(hooks, {
                             signal: extra.signal,
@@ -2161,6 +2308,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                                     timeoutMs,
                                     maxOutputTokens,
                                     signal: extra.signal,
+                                    audit: activityContext,
                                 });
                                 undeliveredProcessId = snapshot.running ? snapshot.processId : undefined;
                                 logToolCall(config, {
@@ -2198,7 +2346,27 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                         throw error;
                     }
                 }, processActivityOutcome);
+                markReturnedOutput(bashOutputStore, activityResult);
+                return activityResult;
             }
+            if (action === "output") {
+                if (!outputId)
+                    throw new Error("bash action=output requires outputId.");
+                if (command !== undefined || processId !== undefined || input !== undefined || interrupt !== undefined ||
+                    tty !== undefined || columns !== undefined || rows !== undefined || workingDirectory !== undefined ||
+                    yieldTimeMs !== undefined || timeoutMs !== undefined || maxOutputTokens !== undefined) {
+                    throw new Error("bash action=output accepts only workspaceId and outputId.");
+                }
+                return runToolWithHooks(hooks, {
+                    signal: extra.signal,
+                    tool: toolNames.shell,
+                    invocation: workspaceHookInvocation(workspace),
+                    payload: { action, outputId },
+                    operation: async () => durableOutputResponse(toolNames.shell, workspaceId, readWorkspaceBashOutput(bashOutputStore, workspaceId, outputId)),
+                });
+            }
+            if (outputId !== undefined)
+                throw new Error("bash action=process does not accept outputId.");
             if (command !== undefined || workingDirectory !== undefined || tty !== undefined || timeoutMs !== undefined) {
                 throw new Error("bash action=process does not accept command, workingDirectory, tty, or timeoutMs.");
             }
@@ -2241,7 +2409,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                         success: snapshot.running || snapshot.exitCode === 0,
                         durationMs: Math.round(performance.now() - startedAt),
                     });
-                    return processToolResponse(toolNames.shell, workspaceId, snapshot, {
+                    const response = processToolResponse(toolNames.shell, workspaceId, snapshot, {
                         action,
                         processId,
                         inputLength: input?.length ?? 0,
@@ -2250,11 +2418,15 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                         exitCode: snapshot.exitCode,
                         wallTimeMs: snapshot.wallTimeMs,
                     });
+                    if (!snapshot.running) {
+                        recordBashCompletion(activityLifecycle, bashOutputStore, snapshot.outputId);
+                    }
+                    return response;
                 },
             });
         });
     }
-    registerProcessTools(server, config, workspaces, processSessions, hooks, activityLifecycle);
+    registerProcessTools(server, config, workspaces, processSessions, hooks, activityLifecycle, bashOutputStore);
     return server;
 }
 export function createServer(config = loadConfig(), options = {}) {
@@ -2282,8 +2454,9 @@ export function createServer(config = loadConfig(), options = {}) {
     const workspaces = new WorkspaceRegistry(config, workspaceStore);
     const activityAuditStore = new ActivityAuditStore(config.stateDir);
     const activityLifecycle = new ActivityLifecycle(activityAuditStore);
+    const bashOutputStore = new BashOutputStore(config.stateDir);
     const reviewCheckpoints = createReviewCheckpointManager();
-    const processSessions = new ProcessManager();
+    const processSessions = new ProcessManager({ outputAudit: bashOutputStore });
     const codeIntelligence = new CodeIntelligenceManager(config);
     const localAgentProviders = config.subagents
         ? getLocalAgentProviderAvailabilitySnapshot()
@@ -2468,7 +2641,7 @@ export function createServer(config = loadConfig(), options = {}) {
                         });
                     }
                 };
-                const server = createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters, codeIntelligence, activityLifecycle);
+                const server = createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters, codeIntelligence, activityLifecycle, bashOutputStore);
                 await server.connect(transport);
             }
             else {
@@ -2500,6 +2673,7 @@ export function createServer(config = loadConfig(), options = {}) {
                 processSessions.shutdown();
                 await codeIntelligence.shutdown();
                 oauthProvider.close();
+                bashOutputStore.close();
                 activityAuditStore.close();
                 workspaceStore.close?.();
             })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akira-tl/forgerelay",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Local development control plane for MCP coding agents.",
   "type": "module",
   "homepage": "https://github.com/Akira-TL/forgerelay#readme",
@@ -44,7 +44,7 @@
     "release:parity": "node scripts/release-parity.mjs",
     "postinstall": "node scripts/fix-node-pty-permissions.mjs",
     "start": "node dist/cli.js serve",
-    "test": "node --test scripts/release-proof.test.mjs && tsx src/config.test.ts && tsx src/lsp/language-server-config.test.ts && tsx src/lsp/normalization/hover.test.ts && tsx src/lsp/references.server.test.ts && tsx src/lsp/operations/document-symbols.server.test.ts && tsx src/lsp/operations/workspace-symbols.server.test.ts && tsx src/lsp/operations/diagnostics-push.server.test.ts && tsx src/lsp/operations/diagnostics-pull.server.test.ts && tsx src/lsp/operations/request-hardening.server.test.ts && tsx src/lsp/operations/recovery.server.test.ts && tsx src/lsp/operations/lifecycle.server.test.ts && tsx src/lsp/runtime/semantic-requests.test.ts && tsx src/logger.test.ts && tsx src/proxy-trust.test.ts && tsx src/mcp-app-template.test.ts && tsx src/hooks.test.ts && tsx src/capability-registry.test.ts && tsx src/mcp/server-instructions.test.ts && tsx src/request-meta.test.ts && tsx src/incoming-artifacts.test.ts && tsx src/artifact-download.test.ts && tsx src/ui/card-types.test.ts && tsx src/ui/patch-display.test.ts && tsx src/ui/tool-display.test.ts && tsx src/apply-patch.test.ts && tsx src/process-platform.test.ts && tsx src/process-sessions.test.ts && tsx src/mcp-sessions.test.ts && tsx src/server-shutdown.test.ts && tsx src/local-agent-runtime.test.ts && tsx src/local-agent-adapters.test.ts && tsx src/local-agent-availability.test.ts && tsx src/local-agent-profiles.test.ts && tsx src/local-agent-targets.test.ts && tsx src/local-agent-store.test.ts && tsx src/roots.test.ts && tsx src/file-mutations.test.ts && tsx src/skills.test.ts && tsx src/workspace-store.test.ts && tsx src/activity/audit-store.test.ts && tsx src/activity/lifecycle.test.ts && tsx src/workspaces.test.ts && tsx src/workspace-conversation.test.ts && tsx src/review-checkpoints.test.ts && tsx src/lsp/code-intelligence.server.test.ts && tsx src/server.test.ts && tsx src/oauth-store.test.ts && tsx src/cli.test.ts",
+    "test": "node --test scripts/release-proof.test.mjs && tsx src/config.test.ts && tsx src/lsp/language-server-config.test.ts && tsx src/lsp/normalization/hover.test.ts && tsx src/lsp/references.server.test.ts && tsx src/lsp/operations/document-symbols.server.test.ts && tsx src/lsp/operations/workspace-symbols.server.test.ts && tsx src/lsp/operations/diagnostics-push.server.test.ts && tsx src/lsp/operations/diagnostics-pull.server.test.ts && tsx src/lsp/operations/request-hardening.server.test.ts && tsx src/lsp/operations/recovery.server.test.ts && tsx src/lsp/operations/lifecycle.server.test.ts && tsx src/lsp/runtime/semantic-requests.test.ts && tsx src/logger.test.ts && tsx src/proxy-trust.test.ts && tsx src/mcp-app-template.test.ts && tsx src/hooks.test.ts && tsx src/capability-registry.test.ts && tsx src/mcp/server-instructions.test.ts && tsx src/request-meta.test.ts && tsx src/incoming-artifacts.test.ts && tsx src/artifact-download.test.ts && tsx src/ui/card-types.test.ts && tsx src/ui/patch-display.test.ts && tsx src/ui/tool-display.test.ts && tsx src/apply-patch.test.ts && tsx src/process-platform.test.ts && tsx src/process-sessions.test.ts && tsx src/mcp-sessions.test.ts && tsx src/server-shutdown.test.ts && tsx src/local-agent-runtime.test.ts && tsx src/local-agent-adapters.test.ts && tsx src/local-agent-availability.test.ts && tsx src/local-agent-profiles.test.ts && tsx src/local-agent-targets.test.ts && tsx src/local-agent-store.test.ts && tsx src/roots.test.ts && tsx src/file-mutations.test.ts && tsx src/skills.test.ts && tsx src/workspace-store.test.ts && tsx src/activity/audit-store.test.ts && tsx src/activity/bash-output-store.test.ts && tsx src/activity/lifecycle.test.ts && tsx src/workspaces.test.ts && tsx src/workspace-conversation.test.ts && tsx src/review-checkpoints.test.ts && tsx src/lsp/code-intelligence.server.test.ts && tsx src/server.test.ts && tsx src/oauth-store.test.ts && tsx src/cli.test.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "release:check": "node scripts/release-version.mjs check",
     "release:tag-check": "node scripts/release-version.mjs tag",