@akira-tl/forgerelay 0.8.8 → 0.8.10

package/CHANGELOG.md

@@ -4,6 +4,38 @@ All notable ForgeRelay changes are documented here.
 
 ## [Unreleased]
 
+## [0.8.10] - 2026-09-03
+
+### Added
+
+- Added user-controlled managed Language Server installation for TypeScript/JavaScript code intelligence, including private TypeScript SDK wiring, live runtime refresh, and post-mutation diagnostics without restarting ForgeRelay.
+- Added explicit setup flows for local/SSH-only use versus network-exposed ForgeRelay deployments.
+
+### Changed
+
+- Workspace instructions and Skills now stream bounded live deltas after a Workspace is opened, while Agents are prompted to maintain `workspace.tasks` proactively for long-running work instead of querying Tasks mechanically on every open.
+- Agent Bash execution now uses an isolated non-interactive shell environment, and SSH-assisted authentication no longer sources the user's interactive shell configuration.
+- Retired the bundled `subagent-delegation` Skill; required delegation behavior remains in the Subagent capability contract and guide.
+
+### Fixed
+
+- Increased the default foreground process wait and stabilized cancellation/concurrency behavior around Language Server diagnostics.
+- Fixed Windows `.cmd`/`.bat` Language Server launchers and kept ordinary external LSP interoperability independent of ForgeRelay's managed-LSP config directory.
+- Preserved Windows `cmd.exe` command quoting for isolated Agent Bash execution, including commands whose executable path is already quoted.
+- Hardened release verification with pinned publishing tooling and dedicated per-version release notes.
+
+## [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/code-intelligence/GUIDE.md

@@ -1,8 +1,10 @@
 # Code Intelligence
 
-Use the `code.intelligence` Capability for read-only semantic code navigation backed by Language servers that are already installed on the user's machine or explicitly configured for the project.
+Use the `code.intelligence` Capability for semantic code navigation, diagnostics, and optional ForgeRelay-managed Language Server installation.
 
-ForgeRelay does not install Language servers. It discovers supported executables when available and accepts explicit definitions from the global ForgeRelay config or `<workspace>/.forgerelay/language-servers.json`. Project definitions override global definitions, and global definitions override built-in discovery. An explicit definition may disable discovery with `enabled: false`.
+ForgeRelay discovers supported executables from project/global configuration, its private managed Language Server directory, and the inherited process `PATH`. Project definitions override global definitions, while built-in discovery can use ForgeRelay-managed executables before falling back to `PATH`. An explicit definition may disable discovery with `enabled: false`.
+
+`managed.status` reports which ForgeRelay-managed servers are supported and currently installed. `managed.install` can install `typescript` or `pyright` into ForgeRelay's private config directory, but only when the user has explicitly enabled Agent-managed installation during `forgerelay init`. Installation is persistent and network-active, so it is disabled by default. A successful install requires no ForgeRelay restart: the next semantic request resolves executables again, and any changed Language-service command/fingerprint replaces the prior idle service automatically.
 
 ForgeRelay 0.4 LSP v1 exposes `definition`, `hover`, `references`, `documentSymbols`, `workspaceSymbols`, and `diagnostics`. Position-based operations accept a workspace-relative source `path` plus 1-based `line` and `column` values. `documentSymbols` needs only `path` and an optional bounded `limit`. `workspaceSymbols` uses `path` to select the Language project/service and accepts a `query` plus optional `limit`; it does not merge multiple nested Language services. `diagnostics` uses `path` plus an optional bounded `limit`. Columns are Unicode code-point positions; ForgeRelay converts them to the position encoding negotiated with the Language server.
 
@@ -12,6 +14,8 @@ Document symbols preserve hierarchical server responses as a tree and keep flat
 
 Diagnostics use the same normalized result contract for push and pull providers. When a Language server advertises LSP pull diagnostics, ForgeRelay prefers pull, supplies the previous `resultId` when available, and treats an `unchanged` report as a refresh of the same bounded snapshot for the newly synchronized filesystem version. Otherwise ForgeRelay uses traditional `publishDiagnostics` snapshots. Push diagnostics retain only the latest snapshot for each synchronized document: no diagnostic history is accumulated. A result reports `provider`, bounded normalized diagnostics, `returned`/`truncated`/`total`, and `freshness`. `freshness.state` distinguishes fresh, stale, missing, and unknown snapshots; filesystem changes advance ForgeRelay's synchronized document version, making an older push snapshot detectably stale until the Language server publishes a replacement. Pull and push state are bounded independently so a mixed-capability server cannot overwrite pull `resultId` state with an asynchronous push. All diagnostic state is released with the Language service.
 
+Successful `write`, `edit`, `rename`, and Codex `apply_patch` mutations automatically request diagnostics for the affected code files and append non-empty results to the same mutation response. This post-mutation validation does not create a second Activity. Files with no matching Language Server are skipped silently; a Language Server validation failure never rolls back an already-successful file mutation, but ForgeRelay appends a bounded validation warning so the Agent can react instead of forgetting to check.
+
 Semantic locations may identify External code locations outside the Workspace, but that does not expand ForgeRelay's allowed roots or grant the file tools permission to read those paths.
 
 Language-server definitions use structured process configuration rather than shell command strings. A project configuration entry may contain `command`, `args`, `env`, `languages`, `extensions`, `languageIdByExtension`, `projectMarkers`, and `enabled` fields. Use `languageIdByExtension` when one server definition covers multiple language IDs whose extensions do not map one-to-one by array position. The server command is launched directly without a shell.
@@ -22,4 +26,4 @@ An unexpected Language-server process exit fails its pending JSON-RPC work immed
 
 Language services are shared by physical Language project identity rather than logical Workspace id, so multiple conversations over the same checkout do not multiply server processes. Idle services are reclaimed after a bounded TTL, and the global service cap evicts the least-recently-used truly idle service; a request that has returned to the Host but whose server ignored cancellation still counts as active until the underlying LSP request settles. Managed-worktree finalization releases idle Language services rooted in that worktree before removing it and refuses finalization while semantic work is still active. Debug runtime telemetry reports only aggregate service/process/request/document/diagnostic/stderr counts and never source contents.
 
-The built-in discovery candidates are `typescript-language-server`, `pyright-langserver`, `rust-analyzer`, `gopls`, and `clangd`. Contributors can run `npm run lsp:interop` to exercise any of those executables that are already present on `PATH`; each detected server is tested through built-in discovery and real stdio LSP, while absent servers are reported as explicit skips. The interoperability check never downloads or installs a Language server.
+The built-in discovery candidates are `typescript-language-server`, `pyright-langserver`, `rust-analyzer`, `gopls`, and `clangd`. `forgerelay init` can install TypeScript/JavaScript (`typescript-language-server` plus TypeScript) and Python (Pyright) into the ForgeRelay config directory without modifying global npm. Rust Analyzer, `gopls`, and `clangd` remain external toolchain/system installations. Contributors can run `npm run lsp:interop` to exercise detected executables through real stdio LSP; the interoperability check itself never downloads or installs a Language server.

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/capabilities/subagents/GUIDE.md

@@ -2,6 +2,15 @@
 
 当任务需要委派给另一个本地 coding agent、获取第二意见、并行调查，或用户明确点名 Subagent/provider 时读取本指南。
 
+## 委派策略与透明性
+
+- 只在用户明确要求委派、点名 Subagent/provider、要求第二意见或并行调查，或任务本身明确需要另一个独立 coding agent 时使用 Subagent；不要因为 profile 存在就静默委派普通工作。
+- 使用 Subagent 时应让用户知道正在委派给哪个 profile/provider；不要隐藏 Subagent 的参与。
+- 不要通过 `bash` 直接启动 `codex`、`claude`、`opencode`、`pi`、`cursor-agent` 或 `copilot` 来绕过 ForgeRelay 的 Session ownership、审计与结果交付。正常 Host 委派使用 `subagent.session`。
+- delegated prompt 必须自包含：说明目标、相关 Workspace/文件、关键约束与验收标准。Subagent 不会自动继承主 Agent 未显式传递的隐含上下文。
+- `reviewer` 适合第二意见/风险/测试缺口，`explorer` 适合只读调查，`implementer` 只在用户允许委派写入工作时使用。
+- Subagent 返回值不是已经验证的最终答案。主 Agent 必须核对关键事实；写入任务检查真实 diff 并运行相关测试，只读调查核对关键路径/符号证据。最终向用户说明使用的 profile/provider、结论、已做验证与剩余风险。
+
 ## 当前接口
 
 启用 Subagent 后，`open_workspace` 会在 `capabilityCatalog` 中公开 `subagent.session`，同时返回紧凑的 provider/profile 元数据。不要为 Subagent 寻找或假设额外的 Core MCP tool；长期可见 Core tool surface 保持不变。

package/capabilities/{workspace-tasks → workspace/workspace-tasks}/GUIDE.md

@@ -10,6 +10,12 @@
 - Task 状态只有 `pending`、`in_progress`、`completed`。`content` 保存继续工作真正需要的要求、阻塞点、结论或下一步，而不是日志或对话转录。
 - Task/List ID 创建后保持稳定。完成 Task 不会删除它；删除必须显式执行。
 
+## 主动维护
+
+把 `workspace.tasks` 当作需要跨多个步骤、较长工作过程或跨会话续接时的轻量工作记忆：当存在值得保留的下一步、阻塞点或当前进展时，主动创建或更新 Task；完成后及时标记 `completed`。不要因为刚执行了 `open_workspace` 就机械查询 Task。
+
+需要续接相关未完成工作时，再从 summary 开始渐进读取；只有 summary 表明确有相关未完成 Task，才继续读取 headers/detail。
+
 ## 渐进式读取
 
 Task 读取默认使用渐进式披露，不会一次返回所有 `content`：

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);
 }