@akira-tl/forgerelay 0.8.4 → 0.8.6

package/CHANGELOG.md

@@ -4,6 +4,36 @@ All notable ForgeRelay changes are documented here.
 
 ## [Unreleased]
 
+## [0.8.6] - 2026-09-02
+
+### Added
+
+- Added `release:push-ready` as the canonical release-ready branch push, atomically advancing the remote main/release refs and synchronizing the local `main` only after divergence safety checks pass.
+
+### Changed
+
+- Retired rename-era DevSpace public compatibility adapters that are well beyond the migration window: `DEVSPACE_*` environment fallbacks, automatic `~/.devspace` config/state/worktree reuse, `.devspace/agents` profile discovery, and old DevSpace package-path special cases. Persisted storage/protocol identifiers remain compatible where renaming them would orphan existing state.
+
+### Fixed
+
+- Reduced Activity Panel wire amplification with state-only collapsed polling, lazy revisioned Activity indexes, cursor-based Bash output, adaptive polling, and persistent Relay connections.
+- Restored the Workspace overview without reintroducing large repeated payloads by keeping Skills, instructions, and agent presentation metadata bounded.
+
+## [0.8.5] - 2026-08-31
+
+### Added
+
+- Added source-controlled GitHub Wiki pages with validation and publishing tooling.
+
+### Changed
+
+- Relayed checkout and managed-worktree Workspaces now preserve stable Gateway identity and Execution-owned Task/lifecycle semantics across close, reopen, delete, inspection, and Composite member routing.
+
+### Fixed
+
+- Task reminders and relayed/Composite runtime state now survive independent MCP transport sessions instead of resetting or presenting stale session-local state.
+- Managed-worktree Relay acceptance now tolerates Git-native LF/CRLF checkout normalization, keeping the release matrix portable across Linux, macOS, and Windows.
+
 ## [0.8.4] - 2026-08-31
 
 ### Added

package/README.md

@@ -255,7 +255,7 @@ See [Agent Profile Schema](docs/agent-profile-schema.md) for the profile format.
 
 ## Configuration and upgrades from DevSpace
 
-New configuration uses the `FORGERELAY_*` prefix. For example:
+Configuration uses the `FORGERELAY_*` prefix. For example:
 
 ```bash
 FORGERELAY_ALLOWED_ROOTS="$HOME/projects" \
@@ -263,16 +263,14 @@ FORGERELAY_PUBLIC_BASE_URL="https://forge.example.com" \
 forgerelay serve
 ```
 
-Existing `DEVSPACE_*` variables are still accepted as fallbacks during the
-rename transition. When both names are present, `FORGERELAY_*` wins.
+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.
 
-The same rule applies to persisted configuration. ForgeRelay prefers
-`~/.forgerelay`, but if that directory does not exist and an existing
-`~/.devspace` setup does, ForgeRelay keeps using the legacy directory rather
-than orphaning OAuth credentials, workspace state, or managed worktrees.
-
-Project-level `.devspace/agents` profiles are also still readable for migration
-compatibility. New project configuration should use `.forgerelay`.
+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.
 
@@ -348,6 +346,7 @@ Trusted Publishing setup.
 
 ## Documentation
 
+- [GitHub Wiki](https://github.com/Akira-TL/forgerelay/wiki) — 面向用户的使用指南、概念说明与故障排查入口。
 - [Setup Guide](docs/setup.md)
 - [Local Debugging and 7677 Acceptance](docs/debugging.md)
 - [ChatGPT Coding Workflow](docs/chatgpt-coding-workflow.md)
@@ -358,6 +357,7 @@ Trusted Publishing setup.
 - [Troubleshooting](docs/gotchas.md)
 - [Roadmap](docs/roadmap.md)
 - [Versioning and Release Management](docs/versioning.md)
+- [GitHub Wiki Maintenance](docs/maintenance/wiki.md)
 - [Changelog](CHANGELOG.md)
 - [Attribution Notice](NOTICE.md)
 

package/dist/activity/audit-store.js

@@ -67,13 +67,51 @@ export class ActivityAuditStore {
         });
     }
     turnRevision(turnId) {
-        const row = this.database.sqlite.prepare(`select count(*) as revision
-       from activity_audit_events
-       where activity_id in (
-         select activity_id from activity_audit_events
+        return this.turnState(turnId).revision;
+    }
+    turnState(turnId) {
+        const row = this.database.sqlite.prepare(`with turn_activities as (
+         select activity_id
+         from activity_audit_events
          where event_type = 'started' and turn_id = ?
-       )`).get(turnId);
-        return row.revision;
+       ), turn_events as (
+         select event.rowid, event.activity_id, event.event_type
+         from activity_audit_events event
+         join turn_activities turn_activity on turn_activity.activity_id = event.activity_id
+       ), latest_events as (
+         select event.event_type
+         from turn_events event
+         join (
+           select activity_id, max(rowid) as rowid
+           from turn_events
+           group by activity_id
+         ) latest on latest.rowid = event.rowid
+       )
+       select
+         (select count(*) from turn_events) as revision,
+         count(*) as total,
+         coalesce(sum(case when event_type = 'started' then 1 else 0 end), 0) as working,
+         coalesce(sum(case when event_type in ('failed', 'blocked') then 1 else 0 end), 0) as error
+       from latest_events`).get(turnId);
+        return row;
+    }
+    activityIdsSinceTurnRevision(turnId, knownRevision) {
+        const offset = Math.max(0, Math.floor(knownRevision));
+        const rows = this.database.sqlite.prepare(`select activity_id, min(rowid) as first_rowid
+       from (
+         select event.rowid, event.activity_id
+         from activity_audit_events event
+         where event.activity_id in (
+           select activity_id
+           from activity_audit_events
+           where event_type = 'started' and turn_id = ?
+         )
+         order by event.rowid asc
+         limit -1 offset ?
+       )
+       group by activity_id
+       order by first_rowid asc`).all(turnId, offset);
+        return rows.map((row) => row.activity_id);
     }
     getActivity(activityId) {
         const events = this.listEvents(activityId);

package/dist/activity/mcp-query-tools.js

@@ -35,13 +35,15 @@ const activitySummarySchema = z.object({
         error: z.number().int().nonnegative(),
     }).optional(),
 });
-const snapshotOutputSchema = {
+const stateOutputSchema = {
     turnId: z.string(),
     revision: z.number().int().nonnegative(),
     changed: z.boolean(),
     state: z.enum(["working", "done", "error"]),
+};
+const indexOutputSchema = {
+    ...stateOutputSchema,
     activities: z.array(activitySummarySchema),
-    [ACTIVITY_PANEL_WORKSPACE_META_KEY]: z.record(z.string(), z.unknown()).optional(),
 };
 export function registerActivityQueryTools(server, queries, connectionScopeId, panelMeta = {}, panelDefaultExpanded = false, logging, workspacePanelState, relay) {
     const panelUi = typeof panelMeta.ui === "object" && panelMeta.ui !== null
@@ -53,7 +55,7 @@ export function registerActivityQueryTools(server, queries, connectionScopeId, p
         inputSchema: {
             workspaceId: z.string().min(1).describe("Workspace identifier returned by open_workspace for the project work in this Host Turn."),
         },
-        outputSchema: snapshotOutputSchema,
+        outputSchema: stateOutputSchema,
         _meta: {
             ...panelMeta,
             ui: {
@@ -80,10 +82,6 @@ export function registerActivityQueryTools(server, queries, connectionScopeId, p
                     [ACTIVITY_PANEL_DEFAULT_EXPANDED_META_KEY]: panelDefaultExpanded,
                     [ACTIVITY_PANEL_WORKSPACE_META_KEY]: workspace,
                 },
-                structuredContent: {
-                    ...(relayed.structuredContent ?? {}),
-                    [ACTIVITY_PANEL_WORKSPACE_META_KEY]: workspace,
-                },
             };
         }
         const snapshot = queries.beginTurn(conversationScopeId, workspaceId);
@@ -92,7 +90,6 @@ export function registerActivityQueryTools(server, queries, connectionScopeId, p
                 turnId: snapshot.turnId,
                 revision: snapshot.revision,
                 state: snapshot.state,
-                activities: snapshot.activities.length,
                 workspaceId,
                 transportSessionIdPrefix: transportSessionIdPrefix(extra.sessionId),
             });
@@ -106,21 +103,18 @@ export function registerActivityQueryTools(server, queries, connectionScopeId, p
                     type: "text",
                     text: `Started ForgeRelay Panel Host Turn ${snapshot.turnId} for ${workspaceId}.`,
                 }],
-            structuredContent: {
-                ...snapshot,
-                [ACTIVITY_PANEL_WORKSPACE_META_KEY]: workspace,
-            },
+            structuredContent: { ...snapshot },
         };
     });
     registerAppTool(server, "activity_snapshot", {
         title: "Read Activity snapshot",
-        description: "App-only data source for lightweight Activity summaries in one durable Host Turn.",
+        description: "App-only state source for one durable Host Turn. Returns only revision/change/state; Activity rows are fetched separately through activity_index when the Panel is expanded.",
         inputSchema: {
             turnId: z.string().optional().describe("Existing Host Turn identifier. Omit only for initial App bootstrap; ForgeRelay then resolves the current Host Turn from conversation metadata."),
             workspaceId: z.string().min(1).optional().describe("Workspace identifier used by the App during initial bootstrap so ForgeRelay can restore the Workspace section."),
             knownRevision: z.number().int().nonnegative().optional(),
         },
-        outputSchema: snapshotOutputSchema,
+        outputSchema: stateOutputSchema,
         _meta: { ui: { visibility: ["app"] } },
         annotations: READ_ONLY_ANNOTATIONS,
     }, async ({ turnId, workspaceId, knownRevision }, extra) => {
@@ -139,10 +133,6 @@ export function registerActivityQueryTools(server, queries, connectionScopeId, p
                         [ACTIVITY_PANEL_DEFAULT_EXPANDED_META_KEY]: panelDefaultExpanded,
                         [ACTIVITY_PANEL_WORKSPACE_META_KEY]: workspace,
                     },
-                    structuredContent: {
-                        ...(relayed.structuredContent ?? {}),
-                        [ACTIVITY_PANEL_WORKSPACE_META_KEY]: workspace,
-                    },
                 }
                 : relayed;
         }
@@ -150,7 +140,7 @@ export function registerActivityQueryTools(server, queries, connectionScopeId, p
         if (!resolvedTurnId) {
             throw new Error("Activity snapshot bootstrap could not resolve the current Host Turn from conversation and workspace metadata.");
         }
-        const snapshot = queries.snapshot(resolvedTurnId, knownRevision);
+        const snapshot = queries.state(resolvedTurnId, knownRevision);
         if (logging) {
             logEvent(logging, "debug", "activity_snapshot_call", {
                 turnId: resolvedTurnId,
@@ -159,7 +149,6 @@ export function registerActivityQueryTools(server, queries, connectionScopeId, p
                 revision: snapshot.revision,
                 changed: snapshot.changed,
                 state: snapshot.state,
-                activities: snapshot.activities.length,
                 transportSessionIdPrefix: transportSessionIdPrefix(extra.sessionId),
             });
         }
@@ -172,16 +161,40 @@ export function registerActivityQueryTools(server, queries, connectionScopeId, p
                 [ACTIVITY_PANEL_DEFAULT_EXPANDED_META_KEY]: panelDefaultExpanded,
                 ...(workspace ? { [ACTIVITY_PANEL_WORKSPACE_META_KEY]: workspace } : {}),
             },
-            content: [{
-                    type: "text",
-                    text: snapshot.changed
-                        ? `Activity snapshot ${resolvedTurnId} revision ${snapshot.revision}.`
-                        : `Activity snapshot ${resolvedTurnId} unchanged at revision ${snapshot.revision}.`,
-                }],
-            structuredContent: {
-                ...snapshot,
-                ...(workspace ? { [ACTIVITY_PANEL_WORKSPACE_META_KEY]: workspace } : {}),
-            },
+            content: [],
+            structuredContent: { ...snapshot },
+        };
+    });
+    registerAppTool(server, "activity_index", {
+        title: "Read Activity index",
+        description: "App-only lazy Activity-row source for an expanded Panel. Pass knownRevision to receive only rows changed since the previous index read.",
+        inputSchema: {
+            turnId: z.string(),
+            knownRevision: z.number().int().nonnegative().optional(),
+        },
+        outputSchema: indexOutputSchema,
+        _meta: { ui: { visibility: ["app"] } },
+        annotations: READ_ONLY_ANNOTATIONS,
+    }, async ({ turnId, knownRevision }, extra) => {
+        const conversationScopeId = hostConversationScopeId(extra._meta, extra.sessionId, connectionScopeId);
+        const relayed = await relay?.index(turnId, knownRevision, conversationScopeId);
+        if (relayed)
+            return relayed;
+        const index = queries.index(turnId, knownRevision);
+        if (logging) {
+            logEvent(logging, "debug", "activity_index_call", {
+                turnId,
+                knownRevision,
+                revision: index.revision,
+                changed: index.changed,
+                state: index.state,
+                activities: index.activities.length,
+                transportSessionIdPrefix: transportSessionIdPrefix(extra.sessionId),
+            });
+        }
+        return {
+            content: [],
+            structuredContent: { ...index },
         };
     });
     registerAppTool(server, "activity_detail", {
@@ -216,16 +229,17 @@ export function registerActivityQueryTools(server, queries, connectionScopeId, p
             });
         }
         return {
-            content: [{ type: "text", text: `Activity detail ${activityId}.` }],
+            content: [],
             structuredContent: { ...detail },
         };
     });
     registerAppTool(server, "activity_output", {
         title: "Read Bash output",
-        description: "App-only lazy data source for complete durable Bash command/output by stable outputId.",
+        description: "App-only lazy data source for durable Bash command/output by stable outputId. Pass the returned cursor on follow-up reads to receive only newly appended output.",
         inputSchema: {
             turnId: z.string(),
             outputId: z.string(),
+            cursor: z.number().int().nonnegative().optional(),
         },
         outputSchema: {
             outputId: z.string(),
@@ -233,6 +247,7 @@ export function registerActivityQueryTools(server, queries, connectionScopeId, p
             processId: z.number().int().positive(),
             command: z.string(),
             output: z.string(),
+            cursor: z.number().int().nonnegative(),
             status: z.enum(["running", "done", "failed"]),
             exitCode: z.number().int().optional(),
             signal: z.string().optional(),
@@ -242,16 +257,18 @@ export function registerActivityQueryTools(server, queries, connectionScopeId, p
         },
         _meta: { ui: { visibility: ["app"] } },
         annotations: READ_ONLY_ANNOTATIONS,
-    }, async ({ turnId, outputId }, extra) => {
+    }, async ({ turnId, outputId, cursor }, extra) => {
         const conversationScopeId = hostConversationScopeId(extra._meta, extra.sessionId, connectionScopeId);
-        const relayed = await relay?.output(turnId, outputId, conversationScopeId);
+        const relayed = await relay?.output(turnId, outputId, conversationScopeId, cursor);
         if (relayed)
             return relayed;
-        const output = queries.bashOutput(turnId, outputId);
+        const output = queries.bashOutput(turnId, outputId, cursor);
         if (logging) {
             logEvent(logging, "debug", "activity_output_call", {
                 turnId,
                 outputId,
+                cursor,
+                nextCursor: output.cursor,
                 activityId: output.activityId,
                 processId: output.processId,
                 status: output.status,
@@ -260,7 +277,7 @@ export function registerActivityQueryTools(server, queries, connectionScopeId, p
             });
         }
         return {
-            content: [{ type: "text", text: `Bash output ${outputId}.` }],
+            content: [],
             structuredContent: { ...output },
         };
     });

package/dist/activity/query-service.js

@@ -9,25 +9,50 @@ export class ActivityQueryService {
     }
     beginTurn(conversationScopeId, workspaceId) {
         const turn = this.turns.begin(conversationScopeId, workspaceId);
-        return this.snapshot(turn.turnId);
+        return this.state(turn.turnId);
     }
     currentTurnId(conversationScopeId, workspaceId) {
         return this.turns.current(conversationScopeId, workspaceId)?.turnId;
     }
-    snapshot(turnId, knownRevision) {
+    state(turnId, knownRevision) {
         this.requireTurn(turnId);
-        const revision = this.audit.turnRevision(turnId);
-        const activities = this.summaries(turnId);
-        const state = aggregateState(activities);
-        const changed = knownRevision === undefined || knownRevision !== revision;
+        const aggregate = this.audit.turnState(turnId);
+        const state = aggregate.total === 0 || aggregate.working > 0
+            ? "working"
+            : aggregate.error > 0
+                ? "error"
+                : "done";
         return {
             turnId,
-            revision,
-            changed,
+            revision: aggregate.revision,
+            changed: knownRevision === undefined || knownRevision !== aggregate.revision,
             state,
-            activities: changed ? activities : [],
         };
     }
+    index(turnId, knownRevision) {
+        const state = this.state(turnId, knownRevision);
+        if (!state.changed)
+            return { ...state, activities: [] };
+        const activities = this.summaries(turnId);
+        if (knownRevision === undefined || knownRevision < 0 || knownRevision > state.revision) {
+            return { ...state, activities };
+        }
+        const changedIds = new Set(this.audit.activityIdsSinceTurnRevision(turnId, knownRevision));
+        if (changedIds.size === 0)
+            return { ...state, activities: [] };
+        for (const activity of activities) {
+            if (changedIds.has(activity.activityId) && activity.parentActivityId) {
+                changedIds.add(activity.parentActivityId);
+            }
+        }
+        return {
+            ...state,
+            activities: activities.filter((activity) => changedIds.has(activity.activityId)),
+        };
+    }
+    snapshot(turnId, knownRevision) {
+        return this.index(turnId, knownRevision);
+    }
     detail(turnId, activityId) {
         this.requireTurn(turnId);
         const record = this.audit.getActivity(activityId);
@@ -46,7 +71,7 @@ export class ActivityQueryService {
             ...(record.error !== undefined ? { error: record.error } : {}),
         };
     }
-    bashOutput(turnId, outputId) {
+    bashOutput(turnId, outputId, cursor = 0) {
         this.requireTurn(turnId);
         const output = this.outputs.read(outputId);
         if (!output)
@@ -56,12 +81,17 @@ 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.output,
+            output: output.chunks
+                .filter((chunk) => chunk.sequence > cursor)
+                .map((chunk) => chunk.data)
+                .join(""),
+            cursor: latestCursor,
             status: output.status,
             ...(output.exitCode !== undefined ? { exitCode: output.exitCode } : {}),
             ...(output.signal !== undefined ? { signal: output.signal } : {}),

package/dist/cli.js

@@ -17,7 +17,7 @@ import { SubagentDeliveryMailbox } from "./subagents/sessions/delivery-mailbox.j
 import { SubagentSessionManager } from "./subagents/sessions/manager.js";
 import { formatSubagentProviderAvailabilitySummary } from "./subagents/providers/availability.js";
 import { parseSubagentRunArgs } from "./subagents/cli-target.js";
-import { ensureForgeRelayInstanceId, generateInstanceId, generateOwnerToken, loadDevspaceFiles, removeForgeRelayRemote, renameForgeRelayRemote, resolveSubagentsFlag, writeDevspaceAuth, writeDevspaceConfig, writeForgeRelayRemote, } from "./user-config.js";
+import { ensureForgeRelayInstanceId, generateInstanceId, generateOwnerToken, loadForgeRelayFiles, removeForgeRelayRemote, renameForgeRelayRemote, resolveSubagentsFlag, writeForgeRelayAuth, writeForgeRelayConfig, writeForgeRelayRemote, } from "./user-config.js";
 import { expandHomePath } from "./roots.js";
 import { shutdownHttpServer } from "./server-shutdown.js";
 import { publicEndpointUrl } from "./oauth/public-url.js";
@@ -72,12 +72,12 @@ function normalizeCommand(command) {
     throw new Error(`Unknown command: ${command}`);
 }
 async function ensureConfigured() {
-    const files = loadDevspaceFiles();
+    const files = loadForgeRelayFiles();
     if (files.configExists && files.authExists) {
         ensureForgeRelayInstanceId();
         return;
     }
-    if (process.env.FORGERELAY_OAUTH_OWNER_TOKEN ?? process.env.DEVSPACE_OAUTH_OWNER_TOKEN) {
+    if (process.env.FORGERELAY_OAUTH_OWNER_TOKEN) {
         ensureForgeRelayInstanceId();
         return;
     }
@@ -94,7 +94,7 @@ async function ensureConfigured() {
     await runInit({ force: false });
 }
 async function runInit({ force }) {
-    const files = loadDevspaceFiles();
+    const files = loadForgeRelayFiles();
     if (!force && files.configExists && files.authExists) {
         prompts.log.info(`ForgeRelay is already configured at ${files.dir}`);
         prompts.log.info("Run `forgerelay init --force` to update it.");
@@ -155,8 +155,8 @@ async function runInit({ force }) {
             ownerToken: files.auth.ownerToken ?? generateOwnerToken(),
             instanceId: files.auth.instanceId ?? generateInstanceId(),
         };
-        const configPath = writeDevspaceConfig(config);
-        const authPath = writeDevspaceAuth(auth);
+        const configPath = writeForgeRelayConfig(config);
+        const authPath = writeForgeRelayAuth(auth);
         const lines = [
             `Config: ${configPath}`,
             `Auth: ${authPath}`,
@@ -285,8 +285,7 @@ async function resolveAuthOwnerToken(ownerToken) {
 }
 function localOwnerToken() {
     const token = process.env.FORGERELAY_OAUTH_OWNER_TOKEN
-        ?? process.env.DEVSPACE_OAUTH_OWNER_TOKEN
-        ?? loadDevspaceFiles().auth.ownerToken;
+        ?? loadForgeRelayFiles().auth.ownerToken;
     if (!token)
         throw new Error("ForgeRelay owner token is not configured on this machine.");
     return token;
@@ -302,7 +301,7 @@ async function runAuthCommand(args) {
     if (subcommand === "list") {
         if (rest.length > 0)
             throw new Error("forgerelay auth list does not accept additional arguments.");
-        const remotes = loadDevspaceFiles().auth.remotes ?? {};
+        const remotes = loadForgeRelayFiles().auth.remotes ?? {};
         if (Object.keys(remotes).length === 0) {
             console.log("No remote ForgeRelay instances registered.");
             return;
@@ -333,7 +332,7 @@ async function runAuthCommand(args) {
         const [alias, ...extra] = rest;
         if (!alias || extra.length > 0)
             throw new Error("Usage: forgerelay auth test <alias>");
-        const files = loadDevspaceFiles();
+        const files = loadForgeRelayFiles();
         const storedRemote = files.auth.remotes?.[alias];
         if (!storedRemote)
             throw new Error(`Unknown remote alias: ${alias}`);
@@ -372,7 +371,7 @@ async function runAuthCommand(args) {
         target,
         ...(parsed.sshRoute ? { sshRoute: parsed.sshRoute } : {}),
     };
-    const files = loadDevspaceFiles();
+    const files = loadForgeRelayFiles();
     const existingAlias = Object.entries(files.auth.remotes ?? {}).find(([, record]) => record.instanceId === remote.instanceId)?.[0];
     const defaultAlias = parsed.sshRoute
         ? defaultSshRouteAlias(parsed.sshRoute)
@@ -385,7 +384,7 @@ async function runAuthCommand(args) {
     console.log(`Authenticated remote ${alias} (${remote.instanceId}).`);
 }
 async function runDoctor() {
-    const files = loadDevspaceFiles();
+    const files = loadForgeRelayFiles();
     console.log(`Config dir: ${files.dir}`);
     console.log(`Config file: ${files.configExists ? files.configPath : "missing"}`);
     console.log(`Auth file: ${files.authExists ? files.authPath : "missing"}`);
@@ -416,7 +415,7 @@ async function runDoctor() {
 }
 function runConfigCommand(args) {
     const [subcommand, key, ...rest] = args;
-    const files = loadDevspaceFiles();
+    const files = loadForgeRelayFiles();
     if (!subcommand || subcommand === "get") {
         console.log(JSON.stringify(files.config, null, 2));
         return;
@@ -430,7 +429,7 @@ function runConfigCommand(args) {
     const value = rest.join(" ").trim();
     if (!value)
         throw new Error("Missing publicBaseUrl value.");
-    writeDevspaceConfig({
+    writeForgeRelayConfig({
         ...files.config,
         publicBaseUrl: normalizeOptionalPublicBaseUrl(value),
     });
@@ -517,7 +516,7 @@ async function runAgentsRun(args) {
         const started = existing
             ? manager.resume({ sessionId: existing.id, prompt: parsed.prompt })
             : await manager.start({
-                workspaceId: process.env.FORGERELAY_WORKSPACE_ID ?? process.env.DEVSPACE_WORKSPACE_ID,
+                workspaceId: process.env.FORGERELAY_WORKSPACE_ID,
                 workspaceRoot,
                 target: parsed.target,
                 prompt: parsed.prompt,
@@ -609,11 +608,11 @@ function writeSubagentPromptFile(prompt) {
     return filePath;
 }
 function resolveCurrentWorkspaceRoot() {
-    return resolve(process.env.FORGERELAY_WORKSPACE_ROOT ?? process.env.DEVSPACE_WORKSPACE_ROOT ?? process.cwd());
+    return resolve(process.env.FORGERELAY_WORKSPACE_ROOT ?? process.cwd());
 }
 function resolveCurrentWorkspaceScope() {
     return {
-        workspaceId: process.env.FORGERELAY_WORKSPACE_ID ?? process.env.DEVSPACE_WORKSPACE_ID,
+        workspaceId: process.env.FORGERELAY_WORKSPACE_ID,
         workspaceRoot: resolveCurrentWorkspaceRoot(),
     };
 }