@akira-tl/forgerelay 1.0.1 → 1.1.0

package/dist/runtime/config/external-mcp-config.js

@@ -0,0 +1,92 @@
+const MCP_SERVER_NAME_PATTERN = /^[a-z][a-z0-9._-]{0,63}$/;
+const MAX_MCP_SERVERS = 32;
+export function parseExternalMcpServers(value) {
+    if (value === undefined)
+        return {};
+    if (!isRecord(value))
+        throw new Error("mcpServers must be an object keyed by server name.");
+    const entries = Object.entries(value);
+    if (entries.length > MAX_MCP_SERVERS) {
+        throw new Error(`mcpServers may contain at most ${MAX_MCP_SERVERS} configured servers.`);
+    }
+    return Object.fromEntries(entries.map(([name, raw]) => {
+        if (!MCP_SERVER_NAME_PATTERN.test(name)) {
+            throw new Error(`Invalid mcpServers name '${name}'. Use a lowercase stable name.`);
+        }
+        if (!isRecord(raw))
+            throw new Error(`mcpServers.${name} must be an object.`);
+        if (raw.transport === "stdio")
+            return [name, parseStdio(name, raw)];
+        if (raw.transport === "streamable-http")
+            return [name, parseHttp(name, raw)];
+        throw new Error(`mcpServers.${name}.transport must be 'stdio' or 'streamable-http'.`);
+    }));
+}
+function parseStdio(name, value) {
+    const command = requiredString(value.command, `mcpServers.${name}.command`);
+    const args = optionalStringArray(value.args, `mcpServers.${name}.args`);
+    const env = optionalStringRecord(value.env, `mcpServers.${name}.env`);
+    const cwd = optionalString(value.cwd, `mcpServers.${name}.cwd`);
+    rejectUnknownKeys(value, new Set(["transport", "command", "args", "env", "cwd"]), `mcpServers.${name}`);
+    return {
+        transport: "stdio",
+        command,
+        ...(args ? { args } : {}),
+        ...(env ? { env } : {}),
+        ...(cwd ? { cwd } : {}),
+    };
+}
+function parseHttp(name, value) {
+    const url = requiredString(value.url, `mcpServers.${name}.url`);
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new Error(`mcpServers.${name}.url must be a valid HTTP(S) URL.`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error(`mcpServers.${name}.url must use http or https.`);
+    }
+    const headers = optionalStringRecord(value.headers, `mcpServers.${name}.headers`);
+    rejectUnknownKeys(value, new Set(["transport", "url", "headers"]), `mcpServers.${name}`);
+    return {
+        transport: "streamable-http",
+        url: parsed.toString(),
+        ...(headers ? { headers } : {}),
+    };
+}
+function requiredString(value, label) {
+    if (typeof value !== "string" || !value.trim())
+        throw new Error(`${label} must be a non-empty string.`);
+    return value.trim();
+}
+function optionalString(value, label) {
+    if (value === undefined)
+        return undefined;
+    return requiredString(value, label);
+}
+function optionalStringArray(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+        throw new Error(`${label} must be an array of strings.`);
+    }
+    return [...value];
+}
+function optionalStringRecord(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (!isRecord(value) || Object.values(value).some((entry) => typeof entry !== "string")) {
+        throw new Error(`${label} must be an object of string values.`);
+    }
+    return { ...value };
+}
+function rejectUnknownKeys(value, allowed, label) {
+    const unknown = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unknown.length > 0)
+        throw new Error(`${label} contains unsupported fields: ${unknown.join(", ")}.`);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/runtime/testing/server-fixture.js

@@ -30,7 +30,12 @@ export async function fixture(t, options = {}) {
     const project = join(root, "project");
     const agentDir = join(root, "agent");
     const stateDir = join(root, ".state");
+    const configDir = join(root, ".config");
     await mkdir(join(project, ".forgerelay", "agents"), { recursive: true });
+    await mkdir(configDir, { recursive: true });
+    if (options.userConfig) {
+        await writeFile(join(configDir, "config.json"), JSON.stringify(options.userConfig, null, 2) + "\n");
+    }
     await mkdir(agentDir, { recursive: true });
     await writeFile(join(agentDir, "AGENTS.md"), "global instructions\n");
     await writeFile(join(project, "AGENTS.md"), "project instructions\n");
@@ -51,7 +56,7 @@ export async function fixture(t, options = {}) {
         await git(project, ["commit", "-m", "Initial commit"]);
     }
     const loadedConfig = loadConfig({
-        FORGERELAY_CONFIG_DIR: join(root, ".config"),
+        FORGERELAY_CONFIG_DIR: configDir,
         FORGERELAY_STATE_DIR: stateDir,
         FORGERELAY_ALLOWED_ROOTS: root,
         FORGERELAY_WORKTREE_ROOT: join(root, ".worktrees"),

package/dist/server.js

@@ -15,6 +15,7 @@ import { HookRunner } from "./mcp/hooks/hooks.js";
 import { checkHookConfiguration } from "./mcp/hooks/hook-cli.js";
 import { buildExecutionShellContext, buildServerInstructions, buildToolDescriptions, toolNames } from "./mcp/server-instructions.js";
 import { IncomingArtifactAdapterRegistry } from "./mcp/artifacts/incoming-artifacts.js";
+import { createExternalMcpCapabilityRuntime } from "./mcp/operations/external-mcp/external-mcp-runtime.js";
 import { registerProcessTools } from "./mcp/process/tools.js";
 import { attachCompletedProcessNotices, recordBashCompletion } from "./mcp/process/runtime.js";
 import { CompositeActivityCoordinator } from "./workspaces/composite/composite-activity.js";
@@ -46,7 +47,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
     const activityPanelApp = createActivityPanelApp(config, FORGERELAY_VERSION);
     const ownsRemoteWorkspaces = options.remoteWorkspaces === undefined;
     const remoteWorkspaces = options.remoteWorkspaces
-        ?? new RemoteWorkspaceRelay(config.configDir, config.stateDir);
+        ?? new RemoteWorkspaceRelay(config.configDir, config.stateDir, config.mediaMaxBytes);
     const compositeWorkspaces = options.compositeWorkspaces
         ?? new CompositeWorkspaceRegistry(config.stateDir);
     const workspaceTasks = new WorkspaceTaskStore(config.stateDir);
@@ -128,11 +129,13 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
     const incomingArtifactRegistry = new IncomingArtifactAdapterRegistry(incomingArtifactAdapters);
     const artifactDownloadAvailable = config.artifactsEnabled && isArtifactDownloadSupportedPlatform();
     const reviewChangesAvailable = config.widgets === "changes";
+    const externalMcpCapability = createExternalMcpCapabilityRuntime(config);
     let batchExecutor;
     const batchExecuteAvailable = config.toolMode !== "codex";
     const capabilityRegistry = createCapabilityRegistry({
         inspectHooks: (workspaceRoot) => checkHookConfiguration(workspaceRoot, config.hooks),
         ...subagentMcp.registryDependencies,
+        externalMcp: externalMcpCapability,
         workspaceRecovery: {
             available: true,
             run: async (input, context) => ({

package/dist/subagents/sessions/mcp/audit.js

@@ -1,4 +1,19 @@
 export function capabilityActivityAuditRequest(input) {
+    if (input.name === "mcp.external") {
+        const argumentsValue = isAuditRecord(input.arguments) ? input.arguments : {};
+        const callArguments = isAuditRecord(argumentsValue.arguments) ? argumentsValue.arguments : undefined;
+        return {
+            workspaceId: input.workspaceId,
+            name: input.name,
+            action: "run",
+            arguments: {
+                operation: argumentsValue.operation,
+                ...(typeof argumentsValue.server === "string" ? { server: argumentsValue.server } : {}),
+                ...(typeof argumentsValue.tool === "string" ? { tool: argumentsValue.tool } : {}),
+                ...(callArguments ? { argumentKeys: Object.keys(callArguments).sort() } : {}),
+            },
+        };
+    }
     if (input.name !== "subagent.session") {
         return {
             workspaceId: input.workspaceId,
@@ -24,6 +39,23 @@ export function capabilityActivityAuditRequest(input) {
     };
 }
 export function capabilityActivityAuditResult(name, result) {
+    if (name === "mcp.external" && isAuditRecord(result)) {
+        const structuredContent = isAuditRecord(result.structuredContent) ? result.structuredContent : undefined;
+        const capabilityResult = structuredContent && isAuditRecord(structuredContent.result)
+            ? structuredContent.result
+            : undefined;
+        const error = structuredContent && isAuditRecord(structuredContent.error)
+            ? structuredContent.error
+            : undefined;
+        return {
+            name,
+            action: "run",
+            ...(capabilityResult ? { result: summarizeExternalMcpCapabilityResult(capabilityResult) } : {}),
+            ...(error
+                ? { error: { code: error.code } }
+                : {}),
+        };
+    }
     if (name !== "subagent.session" || !isAuditRecord(result))
         return result;
     const structuredContent = isAuditRecord(result.structuredContent) ? result.structuredContent : undefined;
@@ -50,6 +82,55 @@ export function capabilityActivityAuditResult(name, result) {
 function isAuditRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function summarizeExternalMcpCapabilityResult(result) {
+    const summary = {
+        operation: result.operation,
+        ...(typeof result.server === "string" ? { server: result.server } : {}),
+        ...(typeof result.tool === "string" ? { tool: result.tool } : {}),
+    };
+    if (Array.isArray(result.servers)) {
+        summary.servers = result.servers.flatMap((entry) => {
+            if (!isAuditRecord(entry) || typeof entry.name !== "string")
+                return [];
+            return [{ name: entry.name, transport: entry.transport }];
+        });
+    }
+    if (Array.isArray(result.tools)) {
+        summary.tools = result.tools.flatMap((entry) => isAuditRecord(entry) && typeof entry.name === "string" ? [entry.name] : []);
+    }
+    if (Array.isArray(result.content)) {
+        summary.contentTypes = result.content.flatMap((entry) => isAuditRecord(entry) && typeof entry.type === "string" ? [entry.type] : []);
+        const media = result.content.flatMap((entry, index) => {
+            if (!isAuditRecord(entry)
+                || entry.type !== "image"
+                || typeof entry.mimeType !== "string"
+                || typeof entry.bytes !== "number")
+                return [];
+            return [{ index, mimeType: entry.mimeType, bytes: entry.bytes }];
+        });
+        if (media.length > 0)
+            summary.media = media;
+    }
+    if (Array.isArray(result.transforms)) {
+        const transforms = result.transforms.flatMap((entry) => {
+            if (!isAuditRecord(entry)
+                || (entry.phase !== "request" && entry.phase !== "result")
+                || typeof entry.name !== "string"
+                || (entry.scope !== "global" && entry.scope !== "project")
+                || entry.status !== "passed")
+                return [];
+            return [{
+                    phase: entry.phase,
+                    name: entry.name.slice(0, 200),
+                    scope: entry.scope,
+                    status: "passed",
+                }];
+        });
+        if (transforms.length > 0)
+            summary.transforms = transforms;
+    }
+    return summary;
+}
 function summarizeSubagentCapabilityResult(result) {
     const summary = { operation: result.operation };
     const session = isAuditRecord(result.session) ? result.session : undefined;

package/dist/workspaces/relay/result-support.js

@@ -108,6 +108,25 @@ export function toolResultText(result) {
         .map((entry) => entry.text)
         .join("\n") || "remote tool returned an error";
 }
+export function enforceRelayedMediaBudget(result, maxBytes) {
+    let remainingBytes = maxBytes;
+    for (const entry of result.content ?? []) {
+        if (entry.type !== "image")
+            continue;
+        const bytes = Buffer.byteLength(entry.data, "base64");
+        if (bytes > remainingBytes) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Relayed media content exceeds the Gateway media limit of ${maxBytes} bytes.`,
+                    }],
+                isError: true,
+            };
+        }
+        remainingBytes -= bytes;
+    }
+    return result;
+}
 export function remapToolResultWorkspaceId(result, remoteWorkspaceId, gatewayWorkspaceId) {
     return {
         ...result,

package/dist/workspaces/relay/tests/test-support.js

@@ -67,6 +67,8 @@ export async function startForge(t, options) {
         stateDir,
         worktreeRoot: join(options.root, "worktrees"),
         ...(options.taskReminderInterval !== undefined ? { taskReminderInterval: options.taskReminderInterval } : {}),
+        ...(options.mediaMaxBytes !== undefined ? { mediaMaxBytes: options.mediaMaxBytes } : {}),
+        ...(options.mcpServers ? { mcpServers: options.mcpServers } : {}),
         ...(options.hooks ? { hooks: options.hooks } : {}),
     }, null, 2));
     const env = {
@@ -104,6 +106,7 @@ export async function startGatewayClient(t, options) {
     await writeFile(join(options.configDir, "config.json"), JSON.stringify({
         allowedRoots: [options.allowedRoot],
         stateDir,
+        ...(options.mediaMaxBytes !== undefined ? { mediaMaxBytes: options.mediaMaxBytes } : {}),
         ...(options.hooks ? { hooks: options.hooks } : {}),
     }, null, 2));
     const config = loadConfig({

package/dist/workspaces/relay/workspace-relay.js

@@ -7,15 +7,17 @@ import { RemoteMcpConnectionPool } from "./transport/remote-mcp-connection-pool.
 import { withFileLock } from "../../runtime/state/lock/file-lock.js";
 import { withRemoteServiceEndpoint } from "./transport/remote-transport.js";
 import { loadForgeRelayFiles, writeForgeRelayRemote, } from "../../runtime/config/user-config.js";
-import { assertRemoteToolSucceeded, copyBooleanField, copyNumberField, copyStringField, errorMessage, remapToolResultWorkspaceId, replaceExactWorkspaceId, safeManagedWorktreeRecovery, safeTaskSummary, sanitizedRemoteError, stringField, toolResultText, } from "./result-support.js";
+import { assertRemoteToolSucceeded, copyBooleanField, copyNumberField, copyStringField, enforceRelayedMediaBudget, errorMessage, remapToolResultWorkspaceId, replaceExactWorkspaceId, safeManagedWorktreeRecovery, safeTaskSummary, sanitizedRemoteError, stringField, toolResultText, } from "./result-support.js";
 export class RemoteWorkspaceRelay {
+    mediaMaxBytes;
     routes = new Map();
     turnRoutes = new Map();
     authEnv;
     routeStateDir;
     routeStatePath;
     mcpConnections = new RemoteMcpConnectionPool();
-    constructor(configDir, stateDir) {
+    constructor(configDir, stateDir, mediaMaxBytes) {
+        this.mediaMaxBytes = mediaMaxBytes;
         this.authEnv = { FORGERELAY_CONFIG_DIR: configDir };
         this.routeStateDir = stateDir;
         this.routeStatePath = join(stateDir, "remote-workspace-routes.json");
@@ -184,7 +186,7 @@ export class RemoteWorkspaceRelay {
         return result;
     }
     async read(gatewayWorkspaceId, input, conversationScopeId) {
-        return this.callWorkspaceTool(gatewayWorkspaceId, "read", input, conversationScopeId);
+        return enforceRelayedMediaBudget(await this.callWorkspaceTool(gatewayWorkspaceId, "read", input, conversationScopeId), this.mediaMaxBytes);
     }
     async write(gatewayWorkspaceId, input, conversationScopeId) {
         return this.callWorkspaceTool(gatewayWorkspaceId, "write", input, conversationScopeId);
@@ -214,7 +216,7 @@ export class RemoteWorkspaceRelay {
         return this.callWorkspaceTool(gatewayWorkspaceId, "apply_patch", input, conversationScopeId);
     }
     async capability(gatewayWorkspaceId, input, conversationScopeId) {
-        return this.callWorkspaceTool(gatewayWorkspaceId, "capability", input, conversationScopeId);
+        return enforceRelayedMediaBudget(await this.callWorkspaceTool(gatewayWorkspaceId, "capability", input, conversationScopeId), this.mediaMaxBytes);
     }
     async activityPanel(gatewayWorkspaceId, conversationScopeId) {
         const result = await this.callWorkspaceTool(gatewayWorkspaceId, "activity_panel", {}, conversationScopeId);

package/docs/configuration.md

@@ -146,6 +146,45 @@ A single persisted string remains fully supported, so existing configs require n
 migration. For environment configuration, use a comma-separated list in
 `FORGERELAY_PUBLIC_BASE_URL`.
 
+## Media content and external MCP
+
+The existing `read` tool recognizes PNG, JPEG, WebP, and GIF by file signature and returns the original bytes as standard MCP `ImageContent`. Image reads do not use filename extensions for recognition, and text-only `offset` / `limit` arguments are rejected for image targets.
+
+Inline media uses a separate decoded-byte budget:
+
+| Variable | Default | Purpose |
+| --- | --- | --- |
+| `FORGERELAY_MEDIA_MAX_BYTES` | `20971520` | Maximum aggregate decoded image bytes in one Host-facing tool result (20 MiB). |
+
+The same value may be persisted as `mediaMaxBytes` in `config.json`. The budget applies at each ForgeRelay media ingress boundary, including local Read, Workspace Relay Gateway delivery, and configured external MCP results. ForgeRelay fails an oversize result instead of truncating, resizing, recompressing, transcoding, or silently creating an Artifact.
+
+Media content is transient. Image base64 is present only in the live MCP result delivered to the Host; Activity/Audit, structured output, UI state, Workspace state, and logs keep bounded metadata such as MIME type and decoded byte size. Reading or forwarding an image does **not** create an Artifact. Artifact download/materialization remains a separate explicit workflow.
+
+User-configured MCP servers are registered in `config.json` under `mcpServers` and are exposed through the workspace-scoped `mcp.external` Capability rather than becoming new top-level MCP tools. For example:
+
+```json
+{
+  "mcpServers": {
+    "renderer": {
+      "transport": "stdio",
+      "command": "node",
+      "args": ["/opt/renderer/server.mjs"]
+    },
+    "remote-renderer": {
+      "transport": "streamable-http",
+      "url": "https://renderer.example.com/mcp",
+      "headers": {
+        "Authorization": "Bearer <token>"
+      }
+    }
+  }
+}
+```
+
+The Agent explicitly selects the configured server, advertised tool, and arguments through `capability(name="mcp.external", action="run", ...)`. Direct upstream PNG/JPEG/WebP/GIF `ImageContent` is validated and forwarded without decode/re-encode. Text, paths, URLs, `resource_link` values, and other references remain exactly that by default: ForgeRelay does not automatically fetch them, call `read`, infer that they refer to an image, or create an Artifact.
+
+A known server/tool may opt into explicit request/result adaptation with `ExternalMcpBeforeForward` or `ExternalMcpAfterForward` project/global Hooks. These transforms use the structured versioned stdin/stdout protocol described under [Lifecycle hooks](#lifecycle-hooks); ordinary Hook stdout never rewrites MCP data. For example, a project can match one renderer tool whose normal result is a path and deliberately convert that result into `ImageContent`. The Hook command performs any file/network access with its normal local-user authority, and the transformed result still passes through the same MCP shape, MIME/base64, and `mediaMaxBytes` validation before Host delivery.
+
 ## Native artifact download
 
 Native-file download is disabled by default. Enable it with:
@@ -553,7 +592,7 @@ Hooks v1 是自动生命周期规则。规则由用户或 Agent 主动写入；
 
 | 字段 | 含义 |
 | --- | --- |
-| `event` | 必填，九个 Hook event 之一。 |
+| `event` | 必填，当前 Hook event 之一。 |
 | `matcher` | 可选，只在匹配当前生命周期上下文时执行。 |
 | `command` | 必填，本地 shell 命令。 |
 | `timeoutSeconds` | 默认 `30`，范围 `1` 到 `300`。 |
@@ -587,6 +626,11 @@ forgerelay hooks check --project /path/to/project
 | `pathRegex` | 对 payload 中的 `path` 或 `paths` 做正则匹配。 |
 | `provider` | 精确匹配 subagent provider。 |
 | `workspaceMode` | `checkout` 或 `worktree`。 |
+| `capability` | 精确匹配 Capability 名；external MCP transform 使用 `mcp.external`。 |
+| `externalServer` | 精确匹配已经配置的 external MCP server 名。 |
+| `externalTool` | 精确匹配该 server 当前调用的 upstream tool 名。 |
+
+`capability` / `externalServer` / `externalTool` 只匹配当前已选择的 Capability target，不允许 Hook 输出改写 server/tool 或提供新的连接地址、命令、凭据。
 
 Matcher 匹配 ForgeRelay 收到的那次 tool request，不会窥探该命令内部后续启动的子进程。例如 `bash` 参数本身是 `git push origin v0.2.0` 时可以命中；若参数只是 `./release.sh`，而脚本内部再执行 `git push`，ForgeRelay 不会把内部子进程重新解释成新的 Hook 事件。
 
@@ -600,13 +644,17 @@ Matcher 匹配 ForgeRelay 收到的那次 tool request，不会窥探该命令
 | `BeforeTool` | workspace-scoped MCP tool 执行前触发；失败或超时会阻断原操作。`open_workspace` 因执行前还没有 workspace，不走该事件。 |
 | `AfterTool` | tool 成功后触发。 |
 | `AfterToolFailure` | tool 失败或被 `BeforeTool` 拒绝后触发。 |
+| `ExternalMcpBeforeForward` | 已选择 `mcp.external` server/tool 后、upstream 调用前触发；使用 structured transform 协议，可替换当前 request arguments，但不能改写 server/tool。失败会阻止 upstream 调用。 |
+| `ExternalMcpAfterForward` | upstream external MCP 调用成功后触发；使用 structured transform 协议，可替换当前 MCP result。替换结果重新经过标准 MCP/Media 校验。失败会令 Capability 失败，但不会声称回滚 upstream 已发生的副作用。 |
 | `AfterFileChange` | `write`、`edit`、`rename`、`delete`、`apply_patch`、native artifact 等明确文件变更成功后触发；不会推断 shell 的文件副作用。 |
 | `BeforeWorktreeClose` | worktree commit、fast-forward、cleanup 前触发；失败会保留 worktree 并阻断 close。 |
 | `AfterWorktreeClose` | managed worktree 成功关闭后触发；此时从 source checkout 运行。 |
 | `SubagentStart` | 本地 subagent worker 进入执行时触发。 |
 | `SubagentStop` | subagent 完成或进入 error 状态时触发。 |
 
-`BeforeTool` 与 `BeforeWorktreeClose` 是 blocking 事件。其他事件是 observational：失败会被记录并报告，但不会回滚已经完成的文件、Git、进程或网络副作用。Blocking 同样不是事务；Hook 命令自己已经产生的副作用不会因 exit code 非零而撤销。Host 在 blocking Hook 仍运行时取消 MCP request，会终止该 Hook 并阻止原始 tool operation 开始，因此不会出现 Host 已放弃请求后 Hook 又放行后续原始副作用的情况。
+`BeforeTool` 与 `BeforeWorktreeClose` 是普通 lifecycle blocking 事件。`ExternalMcpBeforeForward` 也是 external-MCP forwarding 的前置阻断点；`ExternalMcpAfterForward` 则发生在 upstream 已成功返回之后，因此它只能阻止变换后结果继续交付，不能回滚或伪装撤销 upstream 副作用。其他 after-events 是 observational：失败会被记录并报告，但不会回滚已经完成的文件、Git、进程或网络副作用。Blocking 同样不是事务；Hook 命令自己已经产生的副作用不会因 exit code 非零而撤销。Host 在前置 blocking Hook 仍运行时取消 MCP request，会终止该 Hook 并阻止对应原始 operation 开始。
+
+External MCP transform 的可变数据不通过普通 Hook stdout 约定。ForgeRelay 把一个 `version: 1` JSON envelope 写到 transform Hook 的 stdin，并只接受 stdout 中一个合法 JSON envelope：before-forward 返回 `arguments`，after-forward 返回 `result`。这一协议只对两个 External MCP transform event 生效；现有 lifecycle Hook stdout 仍只是命令输出。
 
 ### Agent 可见报告
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akira-tl/forgerelay",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Local development control plane for MCP coding agents.",
   "type": "module",
   "homepage": "https://github.com/Akira-TL/forgerelay#readme",
@@ -39,6 +39,7 @@
     "dev": "node scripts/debug/serve.mjs",
     "debug:serve": "node scripts/debug/serve.mjs",
     "debug:accept": "node scripts/debug/accept.mjs",
+    "debug:accept:media": "node scripts/debug/accept/media.mjs",
     "debug:accept:relay": "node scripts/debug/relay-accept.mjs",
     "traffic:audit": "node --import tsx scripts/debug/traffic/traffic-audit.mjs",
     "lsp:interop": "node scripts/lsp/interop.mjs",

package/scripts/debug/accept/bootstrap.mjs

@@ -192,6 +192,8 @@ export async function runBootstrapAcceptance({ server, packageJson, ownerToken,
       "capability-guides.read",
       "code.intelligence",
       "workspace.tasks",
+      "workspace.recovery",
+      "workspace.checkpoint",
       "batch.execute",
       ...(process.platform === "linux" ? ["artifact.native-download"] : []),
       "ui.mcp-app",
@@ -203,6 +205,7 @@ export async function runBootstrapAcceptance({ server, packageJson, ownerToken,
     "hooks.check",
     "review.changes",
     "code.intelligence",
+    "workspace.checkpoint",
     "workspace.tasks",
     "batch.execute",
     ...(process.platform === "linux" ? ["artifact.download"] : []),

package/scripts/debug/accept/harness.mjs

@@ -56,7 +56,7 @@ export async function createAcceptanceHarness() {
     encoding: "utf8",
   });
   assert.equal(doctor.status, 0, doctor.stderr);
-  assert.match(doctor.stdout, /Public base URL: http:\/\/127\.0\.0\.1:7677/);
+  assert.match(doctor.stdout, /Client-facing base URL: http:\/\/127\.0\.0\.1:7677/);
   assert.match(doctor.stdout, /Tool mode: full/);
   assert.match(doctor.stdout, /Widgets: changes/);
   assert.match(doctor.stdout, /Trust proxy: off/);