@akira-tl/forgerelay 1.2.4 → 1.3.0

package/dist/cli.js

@@ -7,12 +7,13 @@ import { readFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import * as prompts from "@clack/prompts";
 import { loadConfig } from "./runtime/config/config.js";
 import { acquireRuntimeLease } from "./runtime/state/runtime-lease.js";
 import { runInit } from "./cli/init.js";
 import { runConfigMigration } from "./cli/config/migrate.js";
 import { runConfigInspection } from "./cli/config/inspect.js";
+import { renderGeneralConfigHelp, runGeneralConfigGet, runGeneralConfigSet, runGeneralConfigUnset } from "./cli/config/general.js";
+import { runConfigDomainCommand } from "./cli/config/domains/domain-cli.js";
 import { runMaintenanceCommand } from "./cli/maintenance.js";
 import { runExternalMcpCommand } from "./cli/mcp/external-mcp.js";
 import { formatExternalMcpDoctor, inspectExternalMcpStatus, resolveExternalMcpScope, } from "./cli/mcp/status.js";
@@ -22,58 +23,42 @@ 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, loadForgeRelayFiles, removeForgeRelayRemote, renameForgeRelayRemote, writeForgeRelayConfig, writeForgeRelayRemote, } from "./runtime/config/user-config.js";
+import { ensureForgeRelayInstanceId, loadForgeRelayFiles, } from "./runtime/config/user-config.js";
 import { shutdownHttpServer } from "./mcp/server/transport/server-shutdown.js";
 import { publicEndpointUrl } from "./mcp/oauth/public-url.js";
 import { assertRuntimePrivilegeAllowed, detectRuntimePrivilege, elevatedRuntimeWarning, formatRuntimePrivilege, } from "./runtime/security/runtime-privilege.js";
 import { formatCommandShellRuntime } from "./runtime/shell/command-shell-runtime.js";
 import { commandShellCompatibilityWarning } from "./cli/shell/setup.js";
-import { authenticateRemote, defaultRemoteAlias, isRemoteMcpUnauthorized, normalizeRemoteServiceTarget, refreshRemoteAuthentication, verifyRemoteMcp, } from "./workspaces/relay/auth/remote-auth.js";
-import { defaultSshRouteAlias, parseSshRoute, readRemoteOwnerToken, withRemoteServiceEndpoint, } from "./workspaces/relay/transport/remote-transport.js";
-import { assertSupportedNode, checkGitAvailable, checkSqliteNative, nodeVersionStatus, normalizeOptionalPublicBaseUrl, } from "./cli/setup-support.js";
+import { renderCliRootHelp, renderServeHelp, resolveCliRootRoute, routeArguments, } from "./cli/core/command-tree.js";
+import { parseServeCommandArgs } from "./cli/core/serve-options.js";
+import { runRelayCommand } from "./cli/connect/relay.js";
+import { runSystemStatus } from "./cli/system/status.js";
+import { assertSupportedNode, checkGitAvailable, checkSqliteNative, nodeVersionStatus, } from "./cli/setup-support.js";
 const require = createRequire(import.meta.url);
 async function main(argv) {
     assertSupportedNode();
     const [rawCommand, ...rest] = argv;
-    const defaultServeFlag = rawCommand === "--allow-elevated";
-    const command = defaultServeFlag ? "serve" : normalizeCommand(rawCommand);
-    const args = defaultServeFlag ? argv : rest;
-    switch (command) {
-        case "serve": {
-            const serveOptions = parseServeCommandArgs(args);
-            const runtimePrivilege = detectRuntimePrivilege();
-            assertRuntimePrivilegeAllowed(runtimePrivilege, serveOptions.allowElevated);
-            if (serveOptions.allowElevated)
-                console.warn(elevatedRuntimeWarning(runtimePrivilege));
-            await ensureConfigured();
-            await serve(runtimePrivilege);
+    const route = resolveCliRootRoute(rawCommand);
+    const args = routeArguments(route, rest);
+    if (route.compatibilityHandler) {
+        await runCompatibilityRootCommand(route.compatibilityHandler, args);
+        return;
+    }
+    switch (route.handler) {
+        case "serve":
+            await runServeCommand(args);
             return;
-        }
-        case "init": {
-            const initOptions = parseInitCommandArgs(args);
-            await runInit({ ...initOptions, version: installedForgeRelayVersion() });
-            return;
-        }
-        case "doctor":
-            await runDoctor();
+        case "init":
+            await runInitCommand(args);
             return;
         case "config":
-            await runConfigCommand(args);
+            await runConfigRootCommand(args);
             return;
-        case "hooks":
-            await runHooksCommand(args);
+        case "connect":
+            await runConnectCommand(args);
             return;
-        case "agents":
-            await runAgentsCommand(args);
-            return;
-        case "auth":
-            await runAuthCommand(args);
-            return;
-        case "mcp":
-            await runExternalMcpCommand(args);
-            return;
-        case "maintenance":
-            runMaintenanceCommand(args);
+        case "system":
+            await runSystemCommand(args);
             return;
         case "help":
             printHelp();
@@ -83,16 +68,83 @@ async function main(argv) {
             return;
     }
 }
-function normalizeCommand(command) {
-    if (!command || command === "serve" || command === "start")
-        return "serve";
-    if (command === "init" || command === "doctor" || command === "config" || command === "hooks" || command === "agents" || command === "auth" || command === "mcp" || command === "maintenance")
-        return command;
-    if (command === "help" || command === "--help" || command === "-h")
-        return "help";
-    if (command === "version" || command === "--version" || command === "-v")
-        return "version";
-    throw new Error(`Unknown command: ${command}`);
+async function runCompatibilityRootCommand(handler, args) {
+    switch (handler) {
+        case "agents":
+            await runAgentsCommand(args);
+            return;
+    }
+}
+async function runServeCommand(args) {
+    if (args.length === 1 && (args[0] === "--help" || args[0] === "-h")) {
+        console.log(renderServeHelp());
+        return;
+    }
+    const serveOptions = parseServeCommandArgs(args);
+    const runtimePrivilege = detectRuntimePrivilege();
+    assertRuntimePrivilegeAllowed(runtimePrivilege, serveOptions.allowElevated);
+    if (serveOptions.allowElevated)
+        console.warn(elevatedRuntimeWarning(runtimePrivilege));
+    await ensureConfigured();
+    await serve(runtimePrivilege, serveOptions.runtimeOverrides);
+}
+async function runInitCommand(args) {
+    const initOptions = parseInitCommandArgs(args);
+    await runInit({ ...initOptions, version: installedForgeRelayVersion() });
+}
+async function runConfigRootCommand(args) {
+    const [domain, ...rest] = args;
+    if (domain === "hooks" && rest[0] === "--compat") {
+        await runHooksCommand(rest.slice(1));
+        return;
+    }
+    if (domain && await runConfigDomainCommand(domain, rest))
+        return;
+    if (domain === "hooks") {
+        await runHooksCommand(rest);
+        return;
+    }
+    await runConfigCommand(args);
+}
+async function runConnectCommand(args) {
+    const [domain, ...rest] = args;
+    if (domain === "relay") {
+        await runRelayCommand(rest);
+        return;
+    }
+    if (domain === "mcp") {
+        await runExternalMcpCommand(rest);
+        return;
+    }
+    if (!domain || domain === "help" || domain === "--help" || domain === "-h") {
+        printConnectHelp();
+        return;
+    }
+    throw new Error(`Unknown connect command: ${domain}`);
+}
+async function runSystemCommand(args) {
+    const [subcommand, ...rest] = args;
+    if (subcommand === "doctor") {
+        if (rest.length > 0)
+            throw new Error("forgerelay system doctor does not accept additional arguments.");
+        await runDoctor();
+        return;
+    }
+    if (subcommand === "status") {
+        if (rest.length > 0)
+            throw new Error("forgerelay system status does not accept additional arguments.");
+        runSystemStatus();
+        return;
+    }
+    if (subcommand === "inspect" || subcommand === "prune") {
+        runMaintenanceCommand([subcommand, ...rest]);
+        return;
+    }
+    if (!subcommand || subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+        printSystemHelp();
+        return;
+    }
+    throw new Error(`Unknown system command: ${subcommand}`);
 }
 function parseInitCommandArgs(args) {
     let force = false;
@@ -109,19 +161,6 @@ function parseInitCommandArgs(args) {
     }
     return { force, advanced };
 }
-function parseServeCommandArgs(args) {
-    let allowElevated = false;
-    for (const arg of args) {
-        if (arg === "--allow-elevated") {
-            if (allowElevated)
-                throw new Error("--allow-elevated may only be supplied once.");
-            allowElevated = true;
-            continue;
-        }
-        throw new Error(`Unknown serve option: ${arg}`);
-    }
-    return { allowElevated };
-}
 async function ensureConfigured() {
     const files = loadForgeRelayFiles();
     if (files.configExists && files.authExists) {
@@ -144,7 +183,7 @@ async function ensureConfigured() {
     }
     await runInit({ force: false, advanced: false, version: installedForgeRelayVersion() });
 }
-async function serve(runtimePrivilege) {
+async function serve(runtimePrivilege, runtimeOverrides = {}) {
     const sqliteStatus = checkSqliteNative();
     if (sqliteStatus !== "ok") {
         throw new Error([
@@ -156,7 +195,7 @@ async function serve(runtimePrivilege) {
         ].join("\n"));
     }
     const { createServer } = await import("./server.js");
-    const config = loadConfig();
+    const config = loadConfig(process.env, { runtimeOverrides });
     config.runtimePrivilege = runtimePrivilege;
     const runtimeLease = acquireRuntimeLease(config.stateDir);
     let server;
@@ -209,165 +248,6 @@ async function serve(runtimePrivilege) {
     process.once("SIGINT", handleShutdown);
     process.once("SIGTERM", handleShutdown);
 }
-function parseAuthCommandArgs(args) {
-    let target;
-    let alias;
-    let ownerToken;
-    let sshRoute;
-    let sshAuth = false;
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg === "--alias") {
-            alias = args[++index];
-            if (!alias)
-                throw new Error("Missing value for --alias.");
-            continue;
-        }
-        if (arg === "--token") {
-            ownerToken = args[++index];
-            if (!ownerToken)
-                throw new Error("Missing value for --token.");
-            continue;
-        }
-        if (arg === "-J") {
-            const route = args[++index];
-            if (!route)
-                throw new Error("Missing value for -J.");
-            sshRoute = parseSshRoute(route);
-            continue;
-        }
-        if (arg === "--ssh-auth") {
-            sshAuth = true;
-            continue;
-        }
-        if (arg.startsWith("-"))
-            throw new Error(`Unknown auth option: ${arg}`);
-        if (target)
-            throw new Error(`Unexpected auth argument: ${arg}`);
-        target = arg;
-    }
-    if (!target)
-        throw new Error("Missing remote service target.");
-    if (sshAuth && !sshRoute)
-        throw new Error("--ssh-auth requires -J <ssh-route>.");
-    if (sshAuth && ownerToken)
-        throw new Error("--ssh-auth and --token cannot be used together.");
-    return { target, alias, ownerToken, sshRoute, sshAuth };
-}
-async function resolveAuthOwnerToken(ownerToken) {
-    if (ownerToken)
-        return ownerToken;
-    if (!input.isTTY || !output.isTTY) {
-        throw new Error("Missing owner token. Pass --token, use --ssh-auth with -J, or run in an interactive terminal.");
-    }
-    const result = await prompts.password({
-        message: "Remote ForgeRelay owner token",
-        validate: (value) => value?.trim() ? undefined : "Enter the remote owner token.",
-    });
-    if (prompts.isCancel(result))
-        throw new Error("Remote authentication cancelled.");
-    return String(result);
-}
-function localOwnerToken() {
-    const token = process.env.FORGERELAY_OAUTH_OWNER_TOKEN
-        ?? loadForgeRelayFiles().auth.ownerToken;
-    if (!token)
-        throw new Error("ForgeRelay owner token is not configured on this machine.");
-    return token;
-}
-async function runAuthCommand(args) {
-    const [subcommand, ...rest] = args;
-    if (subcommand === "__owner-token") {
-        if (rest.length > 0)
-            throw new Error("Internal owner-token command does not accept arguments.");
-        process.stdout.write(`${localOwnerToken()}\n`);
-        return;
-    }
-    if (subcommand === "list") {
-        if (rest.length > 0)
-            throw new Error("forgerelay auth list does not accept additional arguments.");
-        const remotes = loadForgeRelayFiles().auth.remotes ?? {};
-        if (Object.keys(remotes).length === 0) {
-            console.log("No remote ForgeRelay instances registered.");
-            return;
-        }
-        for (const [alias, remote] of Object.entries(remotes).sort(([left], [right]) => left.localeCompare(right))) {
-            console.log(`${alias}\t${remote.target}\t${remote.instanceId}`);
-        }
-        return;
-    }
-    if (subcommand === "rename") {
-        const [fromAlias, toAlias, ...extra] = rest;
-        if (!fromAlias || !toAlias || extra.length > 0) {
-            throw new Error("Usage: forgerelay auth rename <old-alias> <new-alias>");
-        }
-        await renameForgeRelayRemote(fromAlias, toAlias);
-        console.log(`Renamed remote ${fromAlias} to ${toAlias}.`);
-        return;
-    }
-    if (subcommand === "remove") {
-        const [alias, ...extra] = rest;
-        if (!alias || extra.length > 0)
-            throw new Error("Usage: forgerelay auth remove <alias>");
-        await removeForgeRelayRemote(alias);
-        console.log(`Removed remote ${alias}.`);
-        return;
-    }
-    if (subcommand === "test") {
-        const [alias, ...extra] = rest;
-        if (!alias || extra.length > 0)
-            throw new Error("Usage: forgerelay auth test <alias>");
-        const files = loadForgeRelayFiles();
-        const storedRemote = files.auth.remotes?.[alias];
-        if (!storedRemote)
-            throw new Error(`Unknown remote alias: ${alias}`);
-        let remote = storedRemote;
-        await withRemoteServiceEndpoint(remote.target, remote.sshRoute, async (endpoint) => {
-            let refreshed = false;
-            if (remote.accessTokenExpiresAt <= Math.floor(Date.now() / 1000)) {
-                remote = await refreshRemoteAuthentication(remote, endpoint);
-                await writeForgeRelayRemote(alias, remote);
-                refreshed = true;
-            }
-            try {
-                await verifyRemoteMcp(remote, endpoint);
-            }
-            catch (error) {
-                if (refreshed || !isRemoteMcpUnauthorized(error))
-                    throw error;
-                remote = await refreshRemoteAuthentication(remote, endpoint);
-                await writeForgeRelayRemote(alias, remote);
-                await verifyRemoteMcp(remote, endpoint);
-            }
-        });
-        console.log(`${alias}\tok\t${remote.instanceId}`);
-        return;
-    }
-    const parsed = parseAuthCommandArgs(args);
-    const target = normalizeRemoteServiceTarget(parsed.target);
-    const authenticated = await withRemoteServiceEndpoint(target, parsed.sshRoute, async (endpoint) => {
-        const ownerToken = parsed.sshAuth
-            ? await readRemoteOwnerToken(parsed.sshRoute ?? [])
-            : await resolveAuthOwnerToken(parsed.ownerToken);
-        return authenticateRemote(endpoint, ownerToken);
-    });
-    const remote = {
-        ...authenticated,
-        target,
-        ...(parsed.sshRoute ? { sshRoute: parsed.sshRoute } : {}),
-    };
-    const files = loadForgeRelayFiles();
-    const existingAlias = Object.entries(files.auth.remotes ?? {}).find(([, record]) => record.instanceId === remote.instanceId)?.[0];
-    const defaultAlias = parsed.sshRoute
-        ? defaultSshRouteAlias(parsed.sshRoute)
-        : defaultRemoteAlias(remote.target);
-    const alias = parsed.alias?.trim() || existingAlias || defaultAlias;
-    if (!files.auth.instanceId) {
-        await ensureForgeRelayInstanceId();
-    }
-    await writeForgeRelayRemote(alias, remote);
-    console.log(`Authenticated remote ${alias} (${remote.instanceId}).`);
-}
 async function runDoctor() {
     const files = loadForgeRelayFiles();
     console.log(`Config dir: ${files.dir}`);
@@ -413,7 +293,11 @@ async function runDoctor() {
     }
 }
 async function runConfigCommand(args) {
-    const [subcommand, key, ...rest] = args;
+    const [subcommand] = args;
+    if (subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+        console.log(renderGeneralConfigHelp());
+        return;
+    }
     if (subcommand === "migrate") {
         await runConfigMigration(args.slice(1));
         return;
@@ -422,65 +306,41 @@ async function runConfigCommand(args) {
         process.exitCode = await runConfigInspection(args);
         return;
     }
-    const files = loadForgeRelayFiles();
     if (!subcommand || subcommand === "get") {
-        console.log(JSON.stringify(files.config, null, 2));
+        await runGeneralConfigGet(subcommand ? args.slice(1) : []);
         return;
     }
-    if (subcommand !== "set") {
-        throw new Error(`Unknown config command: ${subcommand}`);
+    if (subcommand === "set") {
+        await runGeneralConfigSet(args.slice(1));
+        return;
     }
-    if (key !== "publicBaseUrl") {
-        throw new Error("Only `forgerelay config set publicBaseUrl <url[,url...]|null>` is supported right now.");
+    if (subcommand === "unset") {
+        await runGeneralConfigUnset(args.slice(1));
+        return;
     }
-    const value = rest.join(" ").trim();
-    if (!value)
-        throw new Error("Missing publicBaseUrl value.");
-    writeForgeRelayConfig({
-        ...files.config,
-        publicBaseUrl: normalizeOptionalPublicBaseUrl(value),
-    });
-    console.log(`Updated ${files.configPath}`);
+    throw new Error(`Unknown config command: ${subcommand}`);
 }
 function printHelp() {
+    console.log(renderCliRootHelp());
+}
+function printConnectHelp() {
     console.log([
-        "ForgeRelay",
+        "ForgeRelay connect",
         "",
         "Usage:",
-        "  forgerelay                 Run first-time setup if needed, then start the server",
-        "  forgerelay serve           Start the server",
-        "  forgerelay serve --allow-elevated",
-        "                            Explicitly allow this invocation to run with elevated/unknown OS privilege",
-        "  forgerelay init            Run minimal first-time setup",
-        "  forgerelay init --advanced Configure common advanced runtime options",
-        "  forgerelay init --force     Update setup-owned fields without migrating legacy config",
-        "  forgerelay doctor          Show config, runtime, and native dependency status",
-        "  forgerelay config get      Print persisted config",
-        "  forgerelay config set publicBaseUrl <url[,url...]|null>",
-        "  forgerelay config check [--global|--project <path>] [--json]",
-        "  forgerelay config sources [--global|--project <path>] [--json]",
-        "  forgerelay config explain <logical-path> [--global|--project <path>] [--json]",
-        "  forgerelay config migrate [--dry-run] [--global|--project <path>]",
-        "  forgerelay hooks list [--project <path>]",
-        "  forgerelay hooks check [--project <path>]",
-        "  forgerelay agents ls       List subagent sessions",
-        "  forgerelay agents run <profile-or-provider-or-id> [--model <model>] <prompt>",
-        "  forgerelay agents show <id>",
-        "  forgerelay auth <target> [--alias <name>] [--token <owner-token>]",
-        "  forgerelay auth -J <ssh-route> <target> [--alias <name>] [--token <owner-token>|--ssh-auth]",
-        "  forgerelay auth list",
-        "  forgerelay auth test <alias>",
-        "  forgerelay auth rename <old-alias> <new-alias>",
-        "  forgerelay auth remove <alias>",
-        "  forgerelay mcp list [--project <path>|--global]",
-        "  forgerelay mcp test <server> [--project <path>|--global]",
-        "  forgerelay mcp auth <server> [--project <path>|--global]",
-        "  forgerelay mcp logout <server> [--project <path>|--global]",
-        "  forgerelay maintenance inspect [--json]",
-        "  forgerelay -v, --version   Print the installed version",
+        "  forgerelay connect relay ...",
+        "  forgerelay connect mcp ...",
+    ].join("\n"));
+}
+function printSystemHelp() {
+    console.log([
+        "ForgeRelay system",
         "",
-        "For temporary tunnels:",
-        "  FORGERELAY_PUBLIC_BASE_URL=https://example.trycloudflare.com/forgerelay/debug forgerelay serve",
+        "Usage:",
+        "  forgerelay system doctor",
+        "  forgerelay system status",
+        "  forgerelay system inspect [--json]",
+        "  forgerelay system prune [--json]",
     ].join("\n"));
 }
 async function runAgentsCommand(args) {

package/dist/mcp/operations/external-mcp/external-mcp-oauth.js

@@ -361,10 +361,10 @@ function isCredentialReauthorizationError(error) {
     ].includes(error.code);
 }
 function authRequired(server) {
-    return new ExternalMcpOAuthError("auth_required", `External MCP ${server} requires OAuth authorization. Run: forgerelay mcp auth ${server}`);
+    return new ExternalMcpOAuthError("auth_required", `External MCP ${server} requires OAuth authorization. Run: forgerelay connect mcp auth ${server}`);
 }
 function reauthorizationRequired(server, reason) {
-    return new ExternalMcpOAuthError("reauthorization_required", `${reason} Run: forgerelay mcp auth ${server}`);
+    return new ExternalMcpOAuthError("reauthorization_required", `${reason} Run: forgerelay connect mcp auth ${server}`);
 }
 function sameServerUrl(left, right) {
     try {

package/dist/mcp/server/core/schemas.js

@@ -1,4 +1,5 @@
 import * as z from "zod/v4";
+import { redactSkillDiagnosticMessage } from "../../../workspaces/resources/skills.js";
 export function resultOutputSchema(extra = {}) {
     return {
         result: z
@@ -21,18 +22,9 @@ export const workspaceSkillDiagnosticOutputSchema = z.object({
 });
 export function redactSkillDiagnosticPaths(diagnostics) {
     return diagnostics.map((diagnostic) => {
-        let message = diagnostic.message;
-        const hiddenPaths = [
-            diagnostic.path,
-            diagnostic.collision?.winnerPath,
-            diagnostic.collision?.loserPath,
-        ].filter((path) => Boolean(path));
-        for (const path of hiddenPaths) {
-            message = message.split(path).join("<skill-path>");
-        }
         return {
             type: diagnostic.type,
-            message,
+            message: redactSkillDiagnosticMessage(diagnostic),
             ...(diagnostic.collision
                 ? {
                     collision: {

package/dist/mcp/server/operations/runtime/operation-runtime.js

@@ -16,10 +16,14 @@ import { assertWorkspaceInstructionsLoadedBeforeSideEffect, auditToolResultWitho
 import { appendAutomaticMutationDiagnostics } from "./mutation-diagnostics.js";
 export function createOperationRuntime(options) {
     const { config, workspaces, activityLifecycle, hooks, processSessions, bashOutputStore, capabilityRegistry, codeIntelligence, hostScopeIdFor, } = options;
+    const refreshedWorkspace = async (workspaceId) => {
+        await workspaces.refreshContextSources(workspaceId);
+        return workspaces.getWorkspace(workspaceId);
+    };
     const coreOperations = createCoreOperationExecutor({
         read: async (input, context) => {
             const { workspaceId, ...readInput } = input;
-            const workspace = workspaces.getWorkspace(workspaceId);
+            const workspace = await refreshedWorkspace(workspaceId);
             return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context), activityRequestFor(input, context), {
                 signal: context.signal,
                 tool: toolNames.read,
@@ -95,7 +99,7 @@ export function createOperationRuntime(options) {
         },
         write: async (input, context) => {
             const { workspaceId, ...writeInput } = input;
-            const workspace = workspaces.getWorkspace(workspaceId);
+            const workspace = await refreshedWorkspace(workspaceId);
             return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context), activityRequestFor(input, context), {
                 signal: context.signal,
                 tool: toolNames.write,
@@ -156,7 +160,7 @@ export function createOperationRuntime(options) {
         },
         edit: async (input, context) => {
             const { workspaceId, ...editInput } = input;
-            const workspace = workspaces.getWorkspace(workspaceId);
+            const workspace = await refreshedWorkspace(workspaceId);
             return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context), activityRequestFor(input, context), {
                 signal: context.signal,
                 tool: toolNames.edit,
@@ -218,7 +222,7 @@ export function createOperationRuntime(options) {
         },
         rename: async (input, context) => {
             const { workspaceId, path, newPath } = input;
-            const workspace = workspaces.getWorkspace(workspaceId);
+            const workspace = await refreshedWorkspace(workspaceId);
             return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context), activityRequestFor(input, context), {
                 signal: context.signal,
                 tool: toolNames.rename,
@@ -277,7 +281,7 @@ export function createOperationRuntime(options) {
         },
         delete: async (input, context) => {
             const { workspaceId, path, recursive } = input;
-            const workspace = workspaces.getWorkspace(workspaceId);
+            const workspace = await refreshedWorkspace(workspaceId);
             return runActivityToolWithHooks(activityLifecycle, hooks, workspace, hostScopeIdFor(context), activityRequestFor(input, context), {
                 signal: context.signal,
                 tool: toolNames.delete,
@@ -336,7 +340,7 @@ export function createOperationRuntime(options) {
         },
         shellRun: async (input, context) => {
             const { workspaceId, command, surface, tty, columns, rows, workingDirectory, yieldTimeMs, timeoutMs, maxOutputTokens, } = input;
-            const workspace = workspaces.getWorkspace(workspaceId);
+            const workspace = await refreshedWorkspace(workspaceId);
             const activityRequest = surface === "exec_command"
                 ? {
                     workspaceId,
@@ -486,7 +490,7 @@ export function createOperationRuntime(options) {
                     }
                 }
             }
-            const workspace = workspaces.getWorkspace(workspaceId);
+            const workspace = await refreshedWorkspace(workspaceId);
             let changedPaths = [];
             return runActivityTool(activityLifecycle, workspace, hostScopeIdFor(context), toolNames.capability, activityRequestFor(capabilityActivityAuditRequest(input), context), (activityContext) => runToolWithHooks(hooks, {
                 signal: context.signal,