@akira-tl/forgerelay 0.8.8 → 0.8.9

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable ForgeRelay changes are documented here.
 
 ## [Unreleased]
 
+## [0.8.9] - 2026-09-02
+
+### Changed
+
+- Removed the remaining DevSpace-era runtime compatibility identifiers and migration aliases while retaining upstream MIT attribution in `LICENSE`, `NOTICE.md`, and release provenance checks.
+- Removed bundled Codex, Claude, OpenCode, and Pi executor packages; subagent providers now invoke user-installed external CLIs, while ForgeRelay keeps only protocol/runtime infrastructure it owns.
+- Upgraded `better-sqlite3` to 13.0.3 and replaced Pi-owned file/Skill helpers with ForgeRelay implementations.
+
+### Fixed
+
+- Eliminated the install-time `prebuild-install` and `node-domexception` deprecation chains without dependency overrides.
+
 ## [0.8.8] - 2026-09-02
 
 ### Fixed

package/README.md

@@ -231,7 +231,8 @@ forgerelay hooks list --project /path/to/project
 
 ForgeRelay can delegate work to local coding runtimes through user-defined
 profiles. The current adapter layer supports Codex, Claude, OpenCode, Pi,
-Cursor, and Copilot where the corresponding local integration is available.
+Cursor, and Copilot when the corresponding CLI is installed on the server.
+ForgeRelay does not install or bundle those coding runtimes.
 
 Profiles can live in:
 
@@ -248,12 +249,12 @@ forgerelay agents run <profile-or-provider-or-id> "<prompt>"
 forgerelay agents show <id>
 ```
 
-A first-class MCP subagent interface is planned so a parent agent can use the
-same runtime without going through the CLI.
+MCP hosts delegate through the `subagent.session` Capability Gateway; the CLI
+remains useful for local diagnostics and manual session inspection.
 
-See [Agent Profile Schema](docs/agent-profile-schema.md) for the profile format.
+See [Agent Profile Schema](docs/agents/profile-schema.md) for the profile format.
 
-## Configuration and upgrades from DevSpace
+## Configuration
 
 Configuration uses the `FORGERELAY_*` prefix. For example:
 
@@ -263,15 +264,6 @@ FORGERELAY_PUBLIC_BASE_URL="https://forge.example.com" \
 forgerelay serve
 ```
 
-The rename-era automatic compatibility window has ended. `DEVSPACE_*`
-environment variables are ignored, ForgeRelay no longer auto-selects
-`~/.devspace`, and project `.devspace/agents` profiles are not discovered.
-
-If an older installation still has data under DevSpace-named directories,
-migrate it explicitly or point the canonical ForgeRelay settings at those paths
-while moving the data. Persisted internal identifiers that would otherwise
-orphan existing state remain compatible and are not product-facing configuration.
-
 See [Configuration Reference](docs/configuration.md) for all supported options.
 
 ## Security model
@@ -341,7 +333,7 @@ after all platforms succeed. `npm run release:verify` remains available only whe
 cloud failure needs local reproduction against the pinned Node runtime; it is not a
 release prerequisite.
 
-See [Versioning and Release Management](docs/versioning.md) for the bootstrap and
+See [Versioning and Release Management](docs/reference/versioning.md) for the bootstrap and
 Trusted Publishing setup.
 
 ## Documentation
@@ -351,12 +343,12 @@ Trusted Publishing setup.
 - [Local Debugging and 7677 Acceptance](docs/debugging.md)
 - [ChatGPT Coding Workflow](docs/chatgpt-coding-workflow.md)
 - [Configuration Reference](docs/configuration.md)
-- [Agent Profile Schema](docs/agent-profile-schema.md)
-- [Native File Download](docs/artifact-exchange.md)
+- [Agent Profile Schema](docs/agents/profile-schema.md)
+- [Native File Download](docs/reference/artifact-exchange.md)
 - [Security Model](docs/security.md)
 - [Troubleshooting](docs/gotchas.md)
 - [Roadmap](docs/roadmap.md)
-- [Versioning and Release Management](docs/versioning.md)
+- [Versioning and Release Management](docs/reference/versioning.md)
 - [GitHub Wiki Maintenance](docs/maintenance/wiki.md)
 - [Changelog](CHANGELOG.md)
 - [Attribution Notice](NOTICE.md)

package/capabilities/host-integration/GUIDE.md

@@ -25,7 +25,7 @@ ForgeRelay 本地监听一个 HTTP origin，MCP endpoint 是 `/mcp`。当 Host
 
 ## OAuth owner flow
 
-ForgeRelay 使用 single-user Owner-password OAuth approval flow。新安装的 owner secret 通常保存在 `~/.forgerelay/auth.json`；迁移安装可能继续使用旧 `.devspace` 配置目录。不要把 owner token、refresh token 或 `auth.json` 内容放进 Agent 输出、项目文件或日志。
+ForgeRelay 使用 single-user Owner-password OAuth approval flow。owner secret 通常保存在 `~/.forgerelay/auth.json`。不要把 owner token、refresh token 或 `auth.json` 内容放进 Agent 输出、项目文件或日志。
 
 Host 可通过这些 metadata endpoint 发现授权配置：
 
@@ -34,7 +34,7 @@ Host 可通过这些 metadata endpoint 发现授权配置：
 /.well-known/oauth-authorization-server
 ```
 
-默认 redirect hosts 包含 `chatgpt.com`、`localhost`、`127.0.0.1`。其他 MCP client 需要显式加入 `FORGERELAY_OAUTH_ALLOWED_REDIRECT_HOSTS`。OAuth scope 默认仍使用 legacy-compatible internal identifier `devspace`，这是协议兼容值，不是产品名回退。
+默认 redirect hosts 包含 `chatgpt.com`、`localhost`、`127.0.0.1`。其他 MCP client 需要显式加入 `FORGERELAY_OAUTH_ALLOWED_REDIRECT_HOSTS`。OAuth scope 默认使用 `forgerelay`。
 
 Owner password 不被接受时先用 `forgerelay doctor` 确认实际 auth/config 路径；只有用户明确要重建配置时才使用 `forgerelay init --force`。
 

package/dist/activity/{audit-store.js → history/audit-store.js}

@@ -1,11 +1,18 @@
 import { randomUUID } from "node:crypto";
-import { openDatabase } from "../db/client.js";
+import { openDatabase } from "../../runtime/state/db/client.js";
+import { SegmentedLogStore } from "../storage/segmented-log.js";
+import { activityEventLogPrefix } from "../storage/paths.js";
 export class ActivityAuditStore {
     database;
     now;
+    stateDir;
+    payloads;
     constructor(stateDir, options = {}) {
         this.database = openDatabase(stateDir);
         this.now = options.now ?? (() => new Date());
+        this.stateDir = stateDir;
+        this.payloads = new SegmentedLogStore(stateDir);
+        this.migrateLegacyPayloads();
     }
     append(input) {
         return this.database.sqlite.transaction(() => {
@@ -30,7 +37,14 @@ export class ActivityAuditStore {
             const sequence = existing.length + 1;
             const id = `evt_${randomUUID().replaceAll("-", "")}`;
             const createdAt = this.now().toISOString();
-            const row = eventInputToRow(input, { id, sequence, createdAt });
+            const workspace = input.type === "started"
+                ? input.workspace
+                : workspaceFromStartedRow(existing[0]);
+            const payload = eventPayload(input);
+            const payloadRef = payload === undefined
+                ? undefined
+                : this.payloads.append(activityEventLogPrefix(this.stateDir, workspace), Buffer.from(JSON.stringify(payload), "utf8"));
+            const row = eventInputToRow(input, { id, sequence, createdAt }, payloadRef);
             this.database.sqlite.prepare(`insert into activity_audit_events (
           id,
           activity_id,
@@ -49,13 +63,16 @@ export class ActivityAuditStore {
           request_json,
           result_json,
           error,
+          payload_file,
+          payload_offset,
+          payload_length,
           created_at
-        ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.id, row.activity_id, row.sequence, row.event_type, row.turn_id, row.parent_activity_id, row.conversation_scope_id, row.tool, row.workspace_id, row.workspace_root, row.workspace_mode, row.workspace_source_root, row.workspace_branch, row.workspace_target_branch, row.request_json, row.result_json, row.error, row.created_at);
-            return rowToEvent(row);
+        ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.id, row.activity_id, row.sequence, row.event_type, row.turn_id, row.parent_activity_id, row.conversation_scope_id, row.tool, row.workspace_id, row.workspace_root, row.workspace_mode, row.workspace_source_root, row.workspace_branch, row.workspace_target_branch, row.request_json, row.result_json, row.error, row.payload_file, row.payload_offset, row.payload_length, row.created_at);
+            return this.rowToEvent(row);
         })();
     }
     listEvents(activityId) {
-        return this.readRows(activityId).map(rowToEvent);
+        return this.readRows(activityId).map((row) => this.rowToEvent(row));
     }
     listActivitiesByTurn(turnId) {
         const rows = this.database.sqlite.prepare(`select activity_id from activity_audit_events
@@ -164,6 +181,13 @@ export class ActivityAuditStore {
             updatedAt,
         };
     }
+    deleteWorkspace(workspaceId) {
+        this.database.sqlite.prepare(`delete from activity_audit_events
+       where activity_id in (
+         select activity_id from activity_audit_events
+         where event_type = 'started' and workspace_id = ?
+       )`).run(workspaceId);
+    }
     close() {
         this.database.close();
     }
@@ -172,8 +196,51 @@ export class ActivityAuditStore {
        where activity_id = ?
        order by sequence asc`).all(activityId);
     }
+    rowToEvent(row) {
+        return rowToEvent(row, this.readPayload(row));
+    }
+    readPayload(row) {
+        if (row.payload_file !== null && row.payload_offset !== null && row.payload_length !== null) {
+            return JSON.parse(this.payloads.read({
+                prefix: row.payload_file,
+                offset: row.payload_offset,
+                length: row.payload_length,
+            }).toString("utf8"));
+        }
+        return legacyPayload(row);
+    }
+    migrateLegacyPayloads() {
+        const rows = this.database.sqlite.prepare(`select * from activity_audit_events
+       where payload_file is null
+         and (request_json is not null or result_json is not null or error is not null)
+       order by rowid asc`);
+        const workspaceByActivity = new Map();
+        const update = this.database.sqlite.prepare(`update activity_audit_events
+          set payload_file = ?, payload_offset = ?, payload_length = ?,
+              request_json = null, result_json = null, error = null
+        where id = ?`);
+        for (const row of rows.iterate()) {
+            const payload = legacyPayload(row);
+            if (payload === undefined)
+                continue;
+            let workspace = workspaceByActivity.get(row.activity_id);
+            if (!workspace) {
+                const started = row.event_type === "started"
+                    ? row
+                    : this.database.sqlite.prepare(`select * from activity_audit_events
+               where activity_id = ? and event_type = 'started'
+               order by sequence asc limit 1`).get(row.activity_id);
+                if (!started)
+                    continue;
+                workspace = workspaceFromStartedRow(started);
+                workspaceByActivity.set(row.activity_id, workspace);
+            }
+            const reference = this.payloads.append(activityEventLogPrefix(this.stateDir, workspace), Buffer.from(JSON.stringify(payload), "utf8"));
+            update.run(reference.prefix, reference.offset, reference.length, row.id);
+        }
+    }
 }
-function eventInputToRow(input, identity) {
+function eventInputToRow(input, identity, payloadRef) {
     if (input.type === "started") {
         return {
             id: identity.id,
@@ -190,9 +257,12 @@ function eventInputToRow(input, identity) {
             workspace_source_root: input.workspace.sourceRoot ?? null,
             workspace_branch: input.workspace.branch ?? null,
             workspace_target_branch: input.workspace.targetBranch ?? null,
-            request_json: serializeJson(input.request),
+            request_json: null,
             result_json: null,
             error: null,
+            payload_file: payloadRef?.prefix ?? null,
+            payload_offset: payloadRef?.offset ?? null,
+            payload_length: payloadRef?.length ?? null,
             created_at: identity.createdAt,
         };
     }
@@ -212,12 +282,15 @@ function eventInputToRow(input, identity) {
         workspace_branch: null,
         workspace_target_branch: null,
         request_json: null,
-        result_json: "result" in input ? serializeJson(input.result) : null,
-        error: "error" in input ? input.error : null,
+        result_json: null,
+        error: null,
+        payload_file: payloadRef?.prefix ?? null,
+        payload_offset: payloadRef?.offset ?? null,
+        payload_length: payloadRef?.length ?? null,
         created_at: identity.createdAt,
     };
 }
-function rowToEvent(row) {
+function rowToEvent(row, payload) {
     const base = {
         id: row.id,
         activityId: row.activity_id,
@@ -244,47 +317,82 @@ function rowToEvent(row) {
                     ...(row.workspace_branch ? { branch: row.workspace_branch } : {}),
                     ...(row.workspace_target_branch ? { targetBranch: row.workspace_target_branch } : {}),
                 },
-                ...(row.request_json !== null ? { request: parseJson(row.request_json) } : {}),
+                ...(payload?.request !== undefined ? { request: payload.request } : {}),
             };
         case "succeeded":
             return {
                 ...base,
                 type: "succeeded",
-                result: parseJson(row.result_json),
+                ...(payload?.result !== undefined ? { result: payload.result } : {}),
             };
         case "returned":
             return {
                 ...base,
                 type: "returned",
-                result: parseJson(row.result_json),
+                ...(payload?.result !== undefined ? { result: payload.result } : {}),
             };
         case "failed":
-            if (!row.error)
+            if (!payload?.error)
                 throw new Error(`Activity audit failed event ${row.id} is missing an error.`);
             return {
                 ...base,
                 type: "failed",
-                result: parseJson(row.result_json),
-                error: row.error,
+                ...(payload.result !== undefined ? { result: payload.result } : {}),
+                error: payload.error,
             };
         case "blocked":
-            if (!row.error)
+            if (!payload?.error)
                 throw new Error(`Activity audit blocked event ${row.id} is missing an error.`);
             return {
                 ...base,
                 type: "blocked",
-                error: row.error,
+                error: payload.error,
             };
         default:
             throw new Error(`Unknown Activity audit event type: ${row.event_type}`);
     }
 }
+function eventPayload(input) {
+    if (input.type === "started") {
+        return input.request === undefined ? undefined : { request: input.request };
+    }
+    if (input.type === "blocked")
+        return { error: input.error };
+    if (input.type === "failed") {
+        return {
+            ...(input.result !== undefined ? { result: input.result } : {}),
+            error: input.error,
+        };
+    }
+    return input.result === undefined ? undefined : { result: input.result };
+}
+function legacyPayload(row) {
+    const request = parseJson(row.request_json);
+    const result = parseJson(row.result_json);
+    if (request === undefined && result === undefined && row.error === null)
+        return undefined;
+    return {
+        ...(request !== undefined ? { request } : {}),
+        ...(result !== undefined ? { result } : {}),
+        ...(row.error !== null ? { error: row.error } : {}),
+    };
+}
+function workspaceFromStartedRow(row) {
+    if (!row.workspace_root || !isWorkspaceMode(row.workspace_mode)) {
+        throw new Error(`Activity audit start event ${row.id} is missing Workspace context.`);
+    }
+    return {
+        ...(row.workspace_id ? { id: row.workspace_id } : {}),
+        root: row.workspace_root,
+        mode: row.workspace_mode,
+        ...(row.workspace_source_root ? { sourceRoot: row.workspace_source_root } : {}),
+        ...(row.workspace_branch ? { branch: row.workspace_branch } : {}),
+        ...(row.workspace_target_branch ? { targetBranch: row.workspace_target_branch } : {}),
+    };
+}
 function isWorkspaceMode(value) {
     return value === "checkout" || value === "worktree";
 }
-function serializeJson(value) {
-    return value === undefined ? null : JSON.stringify(value);
-}
 function parseJson(value) {
     return value === null ? undefined : JSON.parse(value);
 }

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

@@ -0,0 +1,250 @@
+import { randomUUID } from "node:crypto";
+import { openDatabase } from "../../runtime/state/db/client.js";
+import { SegmentedLogStore } from "../storage/segmented-log.js";
+import { bashOutputLogPrefix, bashOutputMetadataPrefix, stateRelativePath } from "../storage/paths.js";
+const DEFAULT_FLUSH_BYTES = 256 * 1024;
+const DEFAULT_FLUSH_INTERVAL_MS = 500;
+export class BashOutputStore {
+    database;
+    now;
+    nextOutputId;
+    stateDir;
+    logs;
+    pending = new Map();
+    flushBytes;
+    flushTimer;
+    constructor(stateDir, options = {}) {
+        this.database = openDatabase(stateDir);
+        this.now = options.now ?? (() => new Date());
+        this.nextOutputId = options.outputId ?? (() => `out_${randomUUID().replaceAll("-", "")}`);
+        this.stateDir = stateDir;
+        this.logs = new SegmentedLogStore(stateDir);
+        this.flushBytes = positiveInteger(options.flushBytes, DEFAULT_FLUSH_BYTES, "Bash output flushBytes");
+        const flushIntervalMs = positiveInteger(options.flushIntervalMs, DEFAULT_FLUSH_INTERVAL_MS, "Bash output flushIntervalMs");
+        this.migrateLegacyStreams();
+        this.migrateLegacyMetadata();
+        this.flushTimer = setInterval(() => this.flushPending(), flushIntervalMs);
+        this.flushTimer.unref();
+    }
+    begin(input) {
+        const outputId = this.nextOutputId();
+        const startedAt = this.now().toISOString();
+        const workspace = { id: input.workspaceId, root: input.workspaceRoot, mode: "checkout" };
+        const logPrefix = stateRelativePath(this.stateDir, bashOutputLogPrefix(this.stateDir, workspace, outputId));
+        const commandRef = this.logs.append(bashOutputMetadataPrefix(this.stateDir, workspace, outputId, "command"), Buffer.from(input.command, "utf8"));
+        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,
+        log_file, output_bytes, command_file, command_offset, command_length
+      ) values (?, ?, ?, ?, ?, ?, ?, '', ?, 'running', 0, ?, ?, 0, ?, ?, ?)`).run(outputId, input.activityId, input.turnId, input.conversationScopeId ?? null, input.processId, input.workspaceId, input.workspaceRoot, input.tty ? 1 : 0, startedAt, logPrefix, commandRef.prefix, commandRef.offset, commandRef.length);
+        return outputId;
+    }
+    append(outputId, _channel, data) {
+        const bytes = typeof data === "string" ? Buffer.from(data, "utf8") : Buffer.from(data);
+        if (bytes.length === 0)
+            return;
+        const pending = this.pending.get(outputId) ?? { buffers: [], bytes: 0 };
+        pending.buffers.push(bytes);
+        pending.bytes += bytes.length;
+        this.pending.set(outputId, pending);
+        if (pending.bytes >= this.flushBytes)
+            this.flushOutput(outputId);
+    }
+    markReturned(outputId) {
+        this.flushOutput(outputId);
+        this.database.sqlite.prepare("update bash_output_streams set returned = 1 where id = ?").run(outputId);
+    }
+    claimCompletion(outputId) {
+        this.flushOutput(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.readMetadata(outputId) : undefined;
+    }
+    finish(outputId, input) {
+        this.flushOutput(outputId);
+        const row = this.requireStream(outputId);
+        const status = input.error || input.timedOut || input.signal || (input.exitCode !== undefined && input.exitCode !== 0)
+            ? "failed"
+            : "done";
+        const errorRef = input.error
+            ? this.logs.append(bashOutputMetadataPrefix(this.stateDir, { id: row.workspace_id, root: row.workspace_root, mode: "checkout" }, outputId, "error"), Buffer.from(input.error, "utf8"))
+            : undefined;
+        this.database.sqlite.prepare(`update bash_output_streams
+       set status = ?, exit_code = ?, signal = ?, timed_out = ?, error = null, finished_at = ?,
+           error_file = ?, error_offset = ?, error_length = ?
+       where id = ?`).run(status, input.exitCode ?? null, input.signal ?? null, input.timedOut ? 1 : 0, this.now().toISOString(), errorRef?.prefix ?? null, errorRef?.offset ?? null, errorRef?.length ?? null, outputId);
+    }
+    read(outputId) {
+        const metadata = this.readMetadata(outputId);
+        if (!metadata)
+            return undefined;
+        const row = this.requireStream(outputId);
+        const prefix = this.ensureFileBacked(row);
+        const output = this.logs.readRange(prefix, 0, metadata.outputBytes).toString("utf8");
+        return { ...metadata, output };
+    }
+    readSince(outputId, cursor = 0) {
+        const metadata = this.readMetadata(outputId);
+        if (!metadata)
+            return undefined;
+        if (!Number.isSafeInteger(cursor) || cursor < 0) {
+            throw new Error(`Bash output cursor must be a non-negative integer: ${cursor}.`);
+        }
+        const start = Math.min(cursor, metadata.outputBytes);
+        const row = this.requireStream(outputId);
+        const prefix = this.ensureFileBacked(row);
+        const output = this.logs.readRange(prefix, start, metadata.outputBytes).toString("utf8");
+        return { ...metadata, output, cursor: metadata.outputBytes };
+    }
+    readMetadata(outputId) {
+        this.flushOutput(outputId);
+        const row = this.readStream(outputId);
+        if (!row)
+            return undefined;
+        this.ensureFileBacked(row);
+        const refreshed = this.requireStream(outputId);
+        return this.rowToMetadata(refreshed);
+    }
+    deleteWorkspace(workspaceId) {
+        const rows = this.database.sqlite.prepare("select id from bash_output_streams where workspace_id = ?").all(workspaceId);
+        for (const row of rows) {
+            this.flushOutput(row.id);
+            this.pending.delete(row.id);
+        }
+        this.database.sqlite.prepare("delete from bash_output_streams where workspace_id = ?").run(workspaceId);
+    }
+    close() {
+        clearInterval(this.flushTimer);
+        this.flushPending();
+        this.database.close();
+    }
+    flushPending() {
+        for (const outputId of [...this.pending.keys()])
+            this.flushOutput(outputId);
+    }
+    flushOutput(outputId) {
+        const pending = this.pending.get(outputId);
+        if (!pending || pending.bytes === 0)
+            return;
+        const row = this.requireStream(outputId);
+        const prefix = this.ensureFileBacked(row);
+        const onDiskBytes = this.logs.logicalLength(prefix);
+        if (onDiskBytes < row.output_bytes) {
+            throw new Error(`Bash output ${outputId} metadata references ${row.output_bytes} bytes but only ${onDiskBytes} are on disk.`);
+        }
+        const data = Buffer.concat(pending.buffers, pending.bytes);
+        // File first, index second. If SQLite updating fails after the write, the
+        // next access reconciles output_bytes from the append-only log rather than
+        // re-emitting the already-written payload.
+        this.logs.appendAt(prefix, onDiskBytes, data);
+        this.pending.delete(outputId);
+        this.database.sqlite.prepare("update bash_output_streams set output_bytes = ? where id = ?").run(onDiskBytes + data.length, outputId);
+    }
+    ensureFileBacked(row) {
+        let prefix = row.log_file;
+        if (!prefix) {
+            prefix = stateRelativePath(this.stateDir, bashOutputLogPrefix(this.stateDir, { id: row.workspace_id, root: row.workspace_root, mode: "checkout" }, row.id));
+            let logicalOffset = this.logs.logicalLength(prefix);
+            const legacyRows = this.database.sqlite.prepare(`select data from bash_output_chunks
+         where output_id = ?
+         order by sequence asc`);
+            for (const legacy of legacyRows.iterate(row.id)) {
+                this.logs.appendAt(prefix, logicalOffset, legacy.data);
+                logicalOffset += legacy.data.length;
+            }
+            this.database.sqlite.transaction(() => {
+                this.database.sqlite.prepare("update bash_output_streams set log_file = ?, output_bytes = ? where id = ?").run(prefix, logicalOffset, row.id);
+                this.database.sqlite.prepare("delete from bash_output_chunks where output_id = ?").run(row.id);
+            }).immediate();
+            row.log_file = prefix;
+            row.output_bytes = logicalOffset;
+            return prefix;
+        }
+        const onDiskBytes = this.logs.logicalLength(prefix);
+        if (onDiskBytes < row.output_bytes) {
+            throw new Error(`Bash output ${row.id} index is ahead of its segmented log (${row.output_bytes} > ${onDiskBytes}).`);
+        }
+        if (onDiskBytes > row.output_bytes) {
+            this.database.sqlite.prepare("update bash_output_streams set output_bytes = ? where id = ?").run(onDiskBytes, row.id);
+            row.output_bytes = onDiskBytes;
+        }
+        return prefix;
+    }
+    migrateLegacyStreams() {
+        const rows = this.database.sqlite.prepare("select * from bash_output_streams where log_file is null order by started_at asc");
+        for (const row of rows.iterate()) {
+            this.ensureFileBacked(row);
+        }
+    }
+    migrateLegacyMetadata() {
+        const rows = this.database.sqlite.prepare(`select * from bash_output_streams
+       where command_file is null or (error is not null and error_file is null)
+       order by started_at asc`);
+        const update = this.database.sqlite.prepare(`update bash_output_streams
+       set command = '', error = null,
+           command_file = ?, command_offset = ?, command_length = ?,
+           error_file = ?, error_offset = ?, error_length = ?
+       where id = ?`);
+        for (const row of rows.iterate()) {
+            const workspace = { id: row.workspace_id, root: row.workspace_root, mode: "checkout" };
+            const commandRef = row.command_file
+                ? undefined
+                : this.logs.append(bashOutputMetadataPrefix(this.stateDir, workspace, row.id, "command"), Buffer.from(row.command, "utf8"));
+            const errorRef = row.error && !row.error_file
+                ? this.logs.append(bashOutputMetadataPrefix(this.stateDir, workspace, row.id, "error"), Buffer.from(row.error, "utf8"))
+                : undefined;
+            update.run(commandRef?.prefix ?? row.command_file, commandRef?.offset ?? row.command_offset, commandRef?.length ?? row.command_length, errorRef?.prefix ?? row.error_file, errorRef?.offset ?? row.error_offset, errorRef?.length ?? row.error_length, row.id);
+        }
+    }
+    rowToMetadata(stream) {
+        const command = this.readMetadataField(stream.command_file, stream.command_offset, stream.command_length, stream.command);
+        const error = this.readMetadataField(stream.error_file, stream.error_offset, stream.error_length, stream.error ?? undefined);
+        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,
+            tty: stream.tty === 1,
+            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,
+            ...(error ? { error } : {}),
+            returned: stream.returned === 1,
+            outputBytes: stream.output_bytes,
+            startedAt: stream.started_at,
+            ...(stream.finished_at ? { finishedAt: stream.finished_at } : {}),
+        };
+    }
+    readMetadataField(file, offset, length, fallback) {
+        if (file !== null && offset !== null && length !== null) {
+            return this.logs.read({ prefix: file, offset, length }).toString("utf8");
+        }
+        return fallback ?? "";
+    }
+    readStream(outputId) {
+        return this.database.sqlite.prepare("select * from bash_output_streams where id = ?").get(outputId);
+    }
+    requireStream(outputId) {
+        const row = this.readStream(outputId);
+        if (!row)
+            throw new Error(`Unknown Bash output: ${outputId}.`);
+        return row;
+    }
+}
+function isBashOutputStatus(value) {
+    return value === "running" || value === "done" || value === "failed";
+}
+function positiveInteger(value, fallback, label) {
+    const resolved = value ?? fallback;
+    if (!Number.isSafeInteger(resolved) || resolved <= 0) {
+        throw new Error(`${label} must be a positive integer.`);
+    }
+    return resolved;
+}

package/dist/activity/{host-turn-store.js → history/host-turn-store.js}

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { openDatabase } from "../db/client.js";
+import { openDatabase } from "../../runtime/state/db/client.js";
 export class HostTurnStore {
     database;
     now;
@@ -34,6 +34,9 @@ export class HostTurnStore {
        limit 1`).get(conversationScopeId, workspaceId);
         return row ? rowToTurn(row) : undefined;
     }
+    deleteWorkspace(workspaceId) {
+        this.database.sqlite.prepare("delete from activity_host_turns where workspace_id = ?").run(workspaceId);
+    }
     close() {
         this.database.close();
     }

package/dist/activity/{query-service.js → history/query-service.js}

@@ -1,3 +1,4 @@
+import { deleteWorkspaceActivityHistory } from "../storage/history.js";
 export class ActivityQueryService {
     turns;
     audit;
@@ -7,6 +8,15 @@ export class ActivityQueryService {
         this.audit = audit;
         this.outputs = outputs;
     }
+    deleteWorkspaceHistory(stateDir, workspaceId) {
+        deleteWorkspaceActivityHistory({
+            stateDir,
+            workspaceId,
+            audit: this.audit,
+            outputs: this.outputs,
+            turns: this.turns,
+        });
+    }
     beginTurn(conversationScopeId, workspaceId) {
         const turn = this.turns.begin(conversationScopeId, workspaceId);
         return this.state(turn.turnId);
@@ -73,7 +83,7 @@ export class ActivityQueryService {
     }
     bashOutput(turnId, outputId, cursor = 0) {
         this.requireTurn(turnId);
-        const output = this.outputs.read(outputId);
+        const output = this.outputs.readSince(outputId, cursor);
         if (!output)
             throw new Error(`Unknown Bash output: ${outputId}.`);
         const activities = this.audit.listActivitiesByTurn(turnId);
@@ -81,17 +91,13 @@ export class ActivityQueryService {
         if (!visible) {
             throw new Error(`Bash output ${outputId} is not part of Host Turn ${turnId}.`);
         }
-        const latestCursor = output.chunks.at(-1)?.sequence ?? 0;
         return {
             outputId: output.outputId,
             activityId: output.activityId,
             processId: output.processId,
             command: output.command,
-            output: output.chunks
-                .filter((chunk) => chunk.sequence > cursor)
-                .map((chunk) => chunk.data)
-                .join(""),
-            cursor: latestCursor,
+            output: output.output,
+            cursor: output.cursor,
             status: output.status,
             ...(output.exitCode !== undefined ? { exitCode: output.exitCode } : {}),
             ...(output.signal !== undefined ? { signal: output.signal } : {}),