rainskills 0.1.19 → 0.1.20

package/README.md

@@ -67,7 +67,7 @@ Rainskills 安装完成，下一条消息即可直接使用。
 
 每个业务 Skill 都必须先通过相同门禁：
 
-0. 第一步检查 Node.js 是否存在且主版本不低于 18。缺失或低于 18 时，只说明 Rainskills 执行组件需要 Node.js 18 或更高版本并停止；不选择运行环境、不调用 MCP、不猜测替代命令。只有用户或 agent 明确同意后才安装或升级 Node.js，再从同一原始 intent 继续。
+0. 第一步检查 Node.js 是否存在且主版本不低于 18。缺失或低于 18 时，只说明 Rainskills 执行组件需要 Node.js 18 或更高版本并停止；不连接运行环境、不调用 CLI、不猜测替代命令。
 
 固定 launcher 来自当前 `package.json` 版本：
 
@@ -77,12 +77,11 @@ Rainskills 安装完成，下一条消息即可直接使用。
 
 所有调用都把 launcher 与参数合并成 argv 数组后直接执行；不得使用 `rainskills@latest`，不得把参数拼成 shell 字符串。
 
-1. 执行 launcher + `["environment", "list", "--json"]`，先于项目扫描和任何 Rainbond 业务调用。未指定环境时只使用全局默认环境，默认不可用时停止，不自动回退。
-2. 每个请求生成独立 operation UUID，并执行 `operation begin`；显式环境只写入这次 operation。所有 Rainbond 查询和变更都通过 `~/.rainbond/bin/rainskills-tools.js`，并绑定返回的 operation ID。项目不保存环境、团队或应用绑定，同一项目可以部署到多个目标。
-3. 将动作转换为 `runtime-intents.js` 中对应的受限 intent 并完成字段校验。target 只允许 `codex`、`claude`、`pi`、`all`；按用户选择构造 launcher + `["runtime", "connect", "<target>", ...环境参数, "--intent-json", "<JSON.stringify(已校验 intent)>"]`。
-4. 环境参数必须恰好选择一组且互斥：Cloud 用 `["--saas"]`，已有私有环境用 `["--rainbond-url", "<已验证 Console origin>"]`，新建私有环境用 `["--install-private", "--location", "local"]` 或 `["--install-private", "--location", "server"]`。
-5. 安装私有环境时，只消费完成 schema、action、onboarding id 和参数边界校验的 `rainskills.next-action.v1.argv`；拒绝字符串命令和其他输出字段。
-6. 探针失败进入 reconnect。连接或安装完成后执行 launcher + `["intent", "resume", "--onboarding-id", "<同一 onboarding-id>"]`，恢复受保护的原始 intent 和 `resume_step`，不重新猜测用户动作。
+1. 本会话首次使用时执行 launcher + `["runtime", "status", "--json"]`。只有返回 `connected` 且 `usable=true` 才进入业务流程。
+2. 本机只保存一个 Rainbond 运行环境。没有环境时使用 `runtime connect` 连接 Cloud、已有私有 Rainbond，或安装一个私有 Rainbond；重新授权使用 `runtime reconnect <target>`。
+3. 所有 Rainbond 查询和变更都直接通过 `~/.rainbond/bin/rainskills-tools.js`。不配置客户端 MCP，不创建业务 runtime operation，不传环境 ID、operation ID 或 intent JSON。
+4. 写操作仍由 CLI 生成 confirmation ID；只有完全相同的输入追加 `--confirm` 后才执行一次。
+5. 安装私有环境时，只消费完成 schema、action、onboarding id 和参数边界校验的 `rainskills.next-action.v1.argv`；onboarding id 只属于平台安装断点。
 
 `deploy`/`create` 允许先只保存动作类型。选择私有环境后，先完整完成本地单机、服务器单机、主机集群或已有 Kubernetes 的平台安装和验收；此阶段不得询问本地项目路径、Git 仓库 URL、镜像地址或安装包路径。恢复到 `project-analysis` 后才识别当前项目或询问缺失的应用来源。
 
@@ -132,31 +131,35 @@ Rainskills 安装完成，下一条消息即可直接使用。
 5. 指纹和一次服务器密码均由系统 SSH 读取；两种命令都只准备公钥连接，不安装 Rainbond。全部节点处理完后，用户统一回复一次“已完成”。
 6. Agent 使用同一版本、同一 `onboarding-id` 和原安装参数继续。不得重新询问环境、安装模式、节点或应用来源。
 7. 后续传输、安装和验收全部使用免密 SSH；系统终端不会继续安装或授权。
-8. Rainbond 验收通过后只进行一次浏览器授权，随后自动恢复最初的应用任务；不得回到 Agent 后再次授权。
+8. Rainbond 验收通过后只进行一次浏览器授权；授权成功后由当前 Agent 会话继续应用任务。
 
 主机密钥发生变化时直接阻断并要求人工核对，不自动替换 `known_hosts`。聊天中永远不接收密码、私钥或 Token。
 
-## 多运行环境
+## 单运行环境
 
-- 第一个连接成功的环境自动成为全局默认环境；以后新增环境不修改默认值。
-- 用户未指定环境时使用默认环境；用户明确指定时只覆盖本次 operation。
-- 环境名称自动生成，可重命名；内部不可变 ID 不随重命名改变。
-- 添加、重命名、重新授权或删除环境不改项目配置，也不需要为每个 Agent 单独配置 MCP。
-- 新增环境直接建立独立连接，不读取或恢复旧版单环境状态；HTTPS 直接进入授权，明文 HTTP 只增加一次可信网络确认。
-- 新增环境与首次部署复用同一套固定选择：先选“云端环境（免费体验）/私有环境（去对接）”；选择私有环境后直接选“部署到本机/部署到独立服务器/部署到已有 Rainbond”，不再出现旧的接入方式中间步骤。
-- Agent 始终执行同一个受保护的本地 Rainskills CLI。CLI 按 `operation_id` 从隔离凭据存储中选择目标 Rainbond；Rainskills 不提供本地 MCP 服务，Agent 也不得绕过 CLI 直接调用 Rainbond MCP。
-- 明确说“团队”表示默认或指定运行环境中的 Rainbond 团队；明确说“运行环境/平台”表示环境。裸名称同时匹配两者时必须询问。
+- 本机只保存一个 Rainbond Console origin 和对应凭据。
+- 更换环境时，新凭据通过 live probe 后才覆盖当前运行环境。
+- 连接和重新授权始终进入浏览器 Device Flow，不复用 Shell 中缓存的 JWT。
+- Agent 始终执行受保护的本地 Rainskills CLI，不配置或直接调用客户端 MCP。
+- 项目的 preview/production 配置仍属于应用配置投影，与本机连接的 Rainbond 运行环境不是同一概念。
 
-常用管理命令：
+业务 CLI 默认忽略 Shell 中遗留的 `RAINBOND_URL` / `RAINBOND_JWT`。CI 需要使用环境变量凭据时，显式设置：
 
 ```bash
-node <已安装的 Skills 根目录>/rainbond-platform-installer/scripts/local-runtime.js environment list --json
-node <已安装的 Skills 根目录>/rainbond-platform-installer/scripts/local-runtime.js environment rename --environment-id <uuid> --name <name>
-node <已安装的 Skills 根目录>/rainbond-platform-installer/scripts/local-runtime.js environment set-default --environment-id <uuid>
-node <已安装的 Skills 根目录>/rainbond-platform-installer/scripts/local-runtime.js environment remove --environment-id <uuid>
+RAINSKILLS_CREDENTIAL_SOURCE=environment \
+RAINBOND_URL=https://rainbond.example.com \
+RAINBOND_JWT="$RAINBOND_JWT" \
+node ~/.rainbond/bin/rainskills-tools.js status --skill-id rainbond-platform-query
 ```
 
-这些本地状态命令不访问 npm 或网络。Agent 从当前已加载 Skill 的同级目录解析实际绝对路径；只有连接或安装运行环境时才调用固定版本的 npx launcher。
+常用命令：
+
+```bash
+node ~/.rainbond/lib/rainskills/bin/rainskills.js runtime status --json
+node ~/.rainbond/lib/rainskills/bin/rainskills.js runtime reconnect codex
+```
+
+`runtime status` 会通过当前唯一环境执行 live probe。业务 Tool 继续通过 `~/.rainbond/bin/rainskills-tools.js` 调用。
 
 ### 已有应用环境选择
 
@@ -164,15 +167,13 @@ node <已安装的 Skills 根目录>/rainbond-platform-installer/scripts/local-r
 
 ### 认证与权限恢复
 
-Rainbond 能力端点经 CLI 返回 401 时，依次执行以下 argv 参数：
+Rainbond CLI 返回 401 时执行：
 
 ```json
-["runtime", "record-failure", "--onboarding-id", "<同一 onboarding-id>", "--step", "<当前固定步骤>", "--reason", "credential-expired"]
-["runtime", "reconnect", "--onboarding-id", "<同一 onboarding-id>"]
-["intent", "resume", "--onboarding-id", "<同一 onboarding-id>"]
+["runtime", "reconnect", "<target>"]
 ```
 
-只允许重新授权一次，并只重试记录的步骤；第二次 401 停止。403 时执行 `["runtime", "record-failure", "--onboarding-id", "<同一 onboarding-id>", "--step", "<当前固定步骤>", "--reason", "permission-denied"]`，随后立即停止，不 reconnect、不重新授权、不自动重试。
+只读调用可在重新授权后重试一次。写调用不得自动重放，必须先查询平台真实状态。403 立即停止，不 reconnect。
 
 凭据只由受保护的本地状态和客户端配置处理。不要在聊天、intent、日志或命令行参数中发送密码、JWT、Token 或私钥。
 
@@ -228,7 +229,7 @@ node ~/.rainbond/lib/rainskills/bin/rainskills.js platform install --onboarding-
 
 Rainskills 会在用户下一次发起业务动作时，由本地运行时立即返回环境查询结果，并另行启动后台任务静默检查更新。更新只跟随 npm `latest` 指向的正式版。当前版本是 RC 或其他预发布版本时不会查询、不会自动升级；npm 上的新 RC 版本也不参与正式版自动升级。
 
-发现更高的正式版后，后台任务只委托到经过校验的精确版本，例如 `rainskills@0.1.19`，不会执行浮动的 `@latest` 业务代码。新版本原子刷新已经安装的 Rainskills Skills；当前业务继续使用启动时已经加载的版本，最迟从下一条新任务开始使用新版。npm 超时、版本检查失败、安装位置不安全或文件迁移失败时会保留旧版本，且不会阻塞或改变当前操作。
+发现更高的正式版后，后台任务只委托到经过校验的精确版本，例如 `rainskills@0.1.20`，不会执行浮动的 `@latest` 业务代码。新版本原子刷新已经安装的 Rainskills Skills；当前业务继续使用启动时已经加载的版本，最迟从下一条新任务开始使用新版。npm 超时、版本检查失败、安装位置不安全或文件迁移失败时会保留旧版本，且不会阻塞或改变当前操作。
 
 升级只更新 Rainskills 自身，不触发 Rainbond 安装、运行环境选择、登录授权或重新对接，也不会新增 Agent MCP 配置。更新内容仅包括 Skills 和本地 CLI。原始业务操作会继续执行；只有该业务操作本身需要运行环境时，才按既有门禁检查当前连接。可用连接直接复用，401 只重新授权一次，403 立即停止，从未连接过运行环境时才进入环境选择。
 

package/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: rainskills
-description: Use when a user asks to install, set up, initialize, update, repair, start using Rainskills, or list, add, rename, remove, reconnect, or change the default Rainskills runtime environment.
+description: Use when a user asks to install, set up, initialize, update, repair, start using Rainskills, or connect, reconnect, inspect, or replace the single Rainskills runtime.
 ---
 
 # Rainskills
@@ -18,7 +18,7 @@ If the adjacent installer is missing, check the local Node.js version before cho
 
 Skills-only 安装不需要 Node.js；CDN fallback 只负责安装 Skill 文件，不代表运行环境连接、应用部署或平台安装已经可执行。用户首次提出需要运行环境的动作时，对应业务 Skill 才检查 Node.js；固定 Rainskills launcher 需要 Node.js 18 或更高版本。缺失或版本过低时保留原始 intent 并停止，等待用户或 agent 明确同意安装或升级 Node.js，安装完成消息不得提前提示 Node.js。
 
-执行优化：同一会话内只检查一次 Node.js（首次使用本地 CLI 前）；仅在 Node.js 或 Rainskills 安装、升级，或 PATH 变更后失效。固定 launcher 和 argv 已在本 Skill 中，禁止读取、搜索或探测 `rainskills.js`，也禁止执行 `npm root -g`。每个新的业务操作仍需要刷新一次环境列表；带已有 `operation_id` 或 `onboarding-id` 的续接复用已绑定的环境 ID，不重复枚举环境。
+执行优化：同一会话内只检查一次 Node.js 和运行环境状态；仅在 Node.js、Rainskills 或唯一运行环境发生变化后失效。固定 launcher 和 argv 已在本 Skill 中，禁止读取、搜索或探测 `rainskills.js`，也禁止执行 `npm root -g`。
 
 ## Completion Message
 
@@ -38,18 +38,20 @@ Rainskills 安装完成，下一条消息即可直接使用。
 也可以直接告诉我你想部署什么应用。
 ```
 
-## Manage Runtime Environments
+## Manage the Single Runtime
 
 受限沙箱（包括 Codex）执行本地状态命令时，必须申请用户级受保护目录访问权限；在 Codex 中使用 `require_escalated`。不得修改 `~/.rainbond` 权限、复制受保护状态到工作区，或因沙箱权限错误建议重装。
 
 涉及浏览器或设备授权的 `runtime connect`，以及恢复/安装场景中的 `rainskills <target> --self-hosted`，必须在附加交互终端（TTY）中运行；在 Codex 中设置 `tty: true` 并保持进程附着直到授权完成。禁止通过非交互命令要求用户粘贴 JWT；非交互模式只可复用已存在的受保护凭据。
 
-环境是全局列表，不是项目绑定。本地状态命令必须定位已安装的同级 `rainbond-platform-installer/scripts/local-runtime.js`，解析为绝对路径后通过 `node` 以 argv 数组执行；不得为了查询本地环境访问 npm。只有连接或安装环境时才使用与当前技能包一致的固定 launcher `node <home>/.rainbond/lib/rainskills/bin/rainskills.js`（运行包版本 `rainskills@0.1.19`）。
+Rainskills 只保存一个全局运行环境，不维护环境列表、名称、默认值或环境 ID。使用固定 launcher `node <home>/.rainbond/lib/rainskills/bin/rainskills.js`（运行包版本 `rainskills@0.1.20`）：
 
-- 列表：用本地 launcher 执行 `environment list --json`，只展示名称、类型、状态、是否默认和最近验证时间。
-- 重命名：用本地 launcher 执行 `environment rename --environment-id <uuid> --name <name>`。
-- 设为默认：用本地 launcher 执行 `environment set-default --environment-id <uuid>`。只影响之后未指定环境的新操作。
-- 删除：用本地 launcher 执行 `environment remove --environment-id <uuid>`；默认环境或活动操作使用中的环境必须先阻断。
-- 添加：新增环境时直接生成 operation UUID，以 `{"type":"environment-add"}` 执行 runtime connect。先原样展示 `runtime message --id add-environment-location`。选择云端环境时直接执行 `--saas` route；选择私有环境时立即原样展示 `runtime message --id private-deployment-location`，并与首次部署保持完全相同的路径：选择 1（部署到本机）执行 `--install-private --location local`，选择 2（部署到独立服务器）执行 `--install-private --location server`，选择 3（部署到已有 Rainbond）原样展示 `runtime message --id private-console-origin`，收到地址后执行 `--rainbond-url <已验证 Console origin>`。不得展示任何额外的接入方式中间步骤。授权成功后必须把 launcher 返回的 `user_message` 中完整环境列表原样展示给用户，再按用户要求重命名并执行 `operation complete --operation-id <uuid>`。第二个环境不得自动改成默认环境。不得先执行 `runtime status`，不得检查、迁移、备份、删除或修复旧的 `runtime-connection-v1.json`；旧 runtime 状态不是新增环境的前置条件，连接失败时只执行 launcher 返回的固定恢复 argv，不得自行设计恢复流程。
+- 状态：执行 `runtime status --json`。
+- 首次连接：执行 `runtime connect <target> --saas` 或 `runtime connect <target> --rainbond-url <Console origin>`。
+- 安装私有环境：执行 `runtime connect <target> --install-private --location local|server`。
+- 重新授权：执行 `runtime reconnect <target>`；必须进入浏览器 Device Flow，不复用 Shell 中缓存的 JWT。
+- 更换环境：明确告知用户会替换当前唯一环境；新授权和 live probe 成功后再覆盖凭据。
 
-用户在一次业务请求中明确指定运行环境时，只把该环境 ID 传给本次 `operation begin`；同一项目可以部署到任意多个环境和团队。明确“团队”表示环境内团队；明确“运行环境/平台”表示环境；裸名称同时匹配两者时必须询问，不能靠名称中是否含“环境”二字猜测。
+所有 Rainbond 查询和变更继续通过 `~/.rainbond/bin/rainskills-tools.js`。不得配置客户端 MCP，也不得恢复环境枚举、业务 operation 生命周期、环境 ID 或 intent 恢复协议。
+
+业务 CLI 默认只读取受保护的唯一运行环境文件，忽略 Shell 中遗留的 `RAINBOND_URL` / `RAINBOND_JWT`。CI 若要显式使用环境变量凭据，必须同时设置 `RAINSKILLS_CREDENTIAL_SOURCE=environment`。

package/bin/rainskills-tools.js

@@ -17,8 +17,6 @@ const PROTOCOL_VERSION = "2025-03-26";
 const ENDPOINT_PATH = "/console/mcp/rainskills/api/query";
 const CLI_VERSION = "2.1.0";
 const CONFIG_DIRECTORY = ".rainbond";
-const CREDENTIALS_FILENAME = "credentials.env";
-const LEGACY_CREDENTIALS_FILENAME = "mcp.env";
 const CATALOG_FILENAME = "capabilities.json";
 const OPERATIONS_DIRECTORY = "operations";
 const SKILL_MANIFEST_FILENAME = "rainskills-skill-manifest.json";
@@ -76,62 +74,6 @@ class BridgeError extends Error {
   }
 }
 
-function parseShellValue(value) {
-  let offset = 0;
-  let result = "";
-  while (offset < value.length) {
-    const quote = value[offset];
-    if (quote === "'") {
-      const end = value.indexOf("'", offset + 1);
-      if (end === -1) return null;
-      result += value.slice(offset + 1, end);
-      offset = end + 1;
-      continue;
-    }
-    if (quote === '"') {
-      const end = value.indexOf('"', offset + 1);
-      if (end === -1) return null;
-      result += value.slice(offset + 1, end).replace(/\\([\\"$`])/g, "$1");
-      offset = end + 1;
-      continue;
-    }
-    const match = value.slice(offset).match(/^[^\s'"#]+/);
-    if (!match) return null;
-    result += match[0];
-    offset += match[0].length;
-  }
-  return result;
-}
-
-function parseEnvFile(contents) {
-  const values = {};
-  for (const line of contents.split(/\r?\n/)) {
-    const match = line.match(/^\s*(?:export\s+)?(RAINBOND_URL|RAINBOND_JWT|RAINBOND_ALLOW_INSECURE_HTTP)\s*=\s*(.*?)\s*$/);
-    if (!match) continue;
-    const parsed = parseShellValue(match[2]);
-    if (parsed !== null) values[match[1]] = parsed;
-  }
-  return values;
-}
-
-function readPrivateEnvFile(configPath) {
-  let stat;
-  try {
-    stat = fs.lstatSync(configPath);
-  } catch (error) {
-    if (error.code === "ENOENT") return {};
-    throw new BridgeError("unable to inspect Rainbond configuration", EXIT.CONFIG);
-  }
-  if (!stat.isFile() || stat.isSymbolicLink() || (stat.mode & 0o077) !== 0) {
-    throw new BridgeError("Rainbond configuration must be a private regular file", EXIT.CONFIG);
-  }
-  try {
-    return parseEnvFile(fs.readFileSync(configPath, "utf8"));
-  } catch (_error) {
-    throw new BridgeError("unable to read Rainbond configuration", EXIT.CONFIG);
-  }
-}
-
 function requireRuntimeModule(filename) {
   const candidates = [
     path.resolve(__dirname, "..", "rainbond-platform-installer", "scripts", filename),
@@ -166,69 +108,25 @@ function requireRuntimeFile(...segments) {
   throw new BridgeError("installed Rainskills package upload helper is incomplete", EXIT.CONFIG);
 }
 
-function loadOperationConfig({ homeDir, operationId, includeRuntime }) {
-  let operationStore;
-  const { createEnvironmentRegistry } = requireRuntimeModule("environment-registry.js");
-  const { createEnvironmentCredentialStore } = requireRuntimeModule("environment-credentials.js");
-  const { createRuntimeOperationStore } = requireRuntimeModule("runtime-operations.js");
-  const registry = createEnvironmentRegistry({
-    home: homeDir,
-    activeOperationIds: (environmentId) => operationStore?.activeOperationIds(environmentId) || [],
-  });
-  operationStore = createRuntimeOperationStore({ home: homeDir, registry });
-  const operation = operationStore.read(operationId);
-  if (!operation || !["active", "interrupted"].includes(operation.stage)) {
-    throw new BridgeError("protected runtime operation is missing or inactive", EXIT.CONFIG);
-  }
-  const environment = registry.get(operation.environment_id);
-  if (!environment || environment.connection_state !== "connected") {
-    throw new BridgeError("the operation environment is unavailable", EXIT.CONFIG);
-  }
-  const credential = createEnvironmentCredentialStore({ home: homeDir }).read({
-    environmentId: environment.id,
-    expectedOrigin: environment.console_origin,
-  });
-  const parsed = new URL(environment.console_origin);
-  const { INTENT_DEFINITIONS } = requireRuntimeModule("runtime-intents.js");
-  const requiredSkillId = INTENT_DEFINITIONS[operation.intent.type]?.skillId;
-  if (!requiredSkillId) {
-    throw new BridgeError("the protected runtime intent has no Skill binding", EXIT.CONFIG);
-  }
-  return {
-    baseUrl: environment.console_origin,
-    jwt: credential.token,
-    operationId: operation.operation_id,
-    environmentId: environment.id,
-    intent: operation.intent,
-    requiredSkillId,
-    operationStore,
-    ...(includeRuntime ? {
-      homeDir,
-      allowInsecureHttp: parsed.protocol === "http:",
-      isInsecureHttp: parsed.protocol === "http:",
-    } : {}),
-  };
-}
-
 function loadConfig({
   env = process.env,
   homeDir = os.homedir(),
   includeRuntime = false,
-  operationId,
 } = {}) {
-  if (operationId) return loadOperationConfig({ homeDir, operationId, includeRuntime });
-  const configDirectory = path.join(homeDir, CONFIG_DIRECTORY);
-  const credentialsPath = path.join(configDirectory, CREDENTIALS_FILENAME);
-  const legacyCredentialsPath = path.join(configDirectory, LEGACY_CREDENTIALS_FILENAME);
-  const fileValues = readPrivateEnvFile(credentialsPath);
-  const legacyValues = Object.keys(fileValues).length === 0
-    ? readPrivateEnvFile(legacyCredentialsPath)
-    : {};
-
-  const baseUrl = env.RAINBOND_URL || fileValues.RAINBOND_URL || legacyValues.RAINBOND_URL;
-  const jwt = env.RAINBOND_JWT || fileValues.RAINBOND_JWT || legacyValues.RAINBOND_JWT;
+  const hasEnvironmentOverride = env.RAINSKILLS_CREDENTIAL_SOURCE === "environment";
+  if (hasEnvironmentOverride && !(env.RAINBOND_URL && env.RAINBOND_JWT)) {
+    throw new BridgeError(
+      "RAINBOND_URL and RAINBOND_JWT must be provided together",
+      EXIT.CONFIG
+    );
+  }
+  const stored = hasEnvironmentOverride
+    ? null
+    : requireRuntimeModule("single-runtime.js").createSingleRuntimeStore({ home: homeDir }).read();
+  const baseUrl = hasEnvironmentOverride ? env.RAINBOND_URL : stored?.console_origin;
+  const jwt = hasEnvironmentOverride ? env.RAINBOND_JWT : stored?.token;
   if (!baseUrl || !jwt) {
-    throw new BridgeError("RAINBOND_URL and RAINBOND_JWT are required", EXIT.CONFIG);
+    throw new BridgeError("no Rainbond runtime is configured", EXIT.CONFIG);
   }
 
   let parsed;
@@ -241,9 +139,9 @@ function loadConfig({
     parsed.password || parsed.search || parsed.hash) {
     throw new BridgeError("RAINBOND_URL must be a safe HTTP(S) URL", EXIT.CONFIG);
   }
-  const allowInsecureHttp = (env.RAINBOND_ALLOW_INSECURE_HTTP ||
-    fileValues.RAINBOND_ALLOW_INSECURE_HTTP ||
-    legacyValues.RAINBOND_ALLOW_INSECURE_HTTP) === "true";
+  const allowInsecureHttp = hasEnvironmentOverride
+    ? env.RAINBOND_ALLOW_INSECURE_HTTP === "true"
+    : stored.allow_insecure_http;
   if (parsed.protocol === "http:" && !allowInsecureHttp) {
     throw new BridgeError(
       "RAINBOND_URL must use HTTPS; explicitly authorize insecure HTTP during installation",
@@ -262,101 +160,31 @@ function loadConfig({
   return config;
 }
 
-function loadEnvironmentConfig({
-  homeDir = os.homedir(),
-  environmentId,
-} = {}) {
-  const { createEnvironmentRegistry } = requireRuntimeModule("environment-registry.js");
-  const { createEnvironmentCredentialStore } = requireRuntimeModule("environment-credentials.js");
-  const registry = createEnvironmentRegistry({ home: homeDir });
-  const snapshot = registry.read();
-  const selectedId = environmentId || snapshot.default_environment_id;
-  if (!selectedId) {
-    throw new BridgeError("no default Rainbond environment is configured", EXIT.CONFIG);
-  }
-  const environment = snapshot.environments.find((entry) => entry.id === selectedId);
-  if (!environment || environment.connection_state !== "connected") {
-    throw new BridgeError("the selected Rainbond environment is unavailable", EXIT.CONFIG);
-  }
-  let credential;
-  try {
-    credential = createEnvironmentCredentialStore({ home: homeDir }).read({
-      environmentId: environment.id,
-      expectedOrigin: environment.console_origin,
-    });
-  } catch (_error) {
-    throw new BridgeError("the selected Rainbond environment credential is unavailable", EXIT.CONFIG);
-  }
-  const parsed = new URL(environment.console_origin);
-  return {
-    baseUrl: environment.console_origin,
-    jwt: credential.token,
-    environmentId: environment.id,
-    homeDir,
-    allowInsecureHttp: parsed.protocol === "http:",
-    isInsecureHttp: parsed.protocol === "http:",
-  };
-}
-
 function parseCommand(args) {
-  if (args[0] === "query") {
-    const toolName = args[1];
-    if (!Object.hasOwn(PLATFORM_QUERY_TO_RESOURCE, toolName || "")) {
-      throw new BridgeError("platform query tool is not allowed", EXIT.USAGE);
-    }
-    let environmentId;
-    let input;
-    for (let index = 2; index < args.length; index += 2) {
-      const option = args[index];
-      const value = args[index + 1];
-      if (!value || value.startsWith("--")) {
-        throw new BridgeError("platform query option requires a value", EXIT.USAGE);
-      }
-      if (option === "--environment-id" && !environmentId && OPERATION_ID_PATTERN.test(value)) {
-        environmentId = value;
-      } else if (option === "--input" && input === undefined && value === "-") {
-        input = value;
-      } else {
-        throw new BridgeError("invalid platform query command", EXIT.USAGE);
-      }
-    }
-    if (input !== "-") throw new BridgeError("platform query requires --input -", EXIT.USAGE);
-    return { command: "query", toolName, input, environmentId };
+  if (args.includes("--operation-id") || args.includes("--environment-id")) {
+    throw new BridgeError("--operation-id and --environment-id are no longer supported", EXIT.USAGE);
   }
-  const operationIndex = args.indexOf("--operation-id");
-  if (
-    operationIndex < 0
-    || !OPERATION_ID_PATTERN.test(args[operationIndex + 1] || "")
-    || args.indexOf("--operation-id", operationIndex + 1) !== -1
-  ) {
-    throw new BridgeError("every tools command requires --operation-id <uuid>", EXIT.USAGE);
-  }
-  const operationId = args[operationIndex + 1];
-  const operationArgs = [
-    ...args.slice(0, operationIndex),
-    ...args.slice(operationIndex + 2),
-  ];
-  const skillIndex = operationArgs.indexOf("--skill-id");
+  const skillIndex = args.indexOf("--skill-id");
   if (
     skillIndex < 0
-    || !SKILL_ID_PATTERN.test(operationArgs[skillIndex + 1] || "")
-    || operationArgs.indexOf("--skill-id", skillIndex + 1) !== -1
+    || !SKILL_ID_PATTERN.test(args[skillIndex + 1] || "")
+    || args.indexOf("--skill-id", skillIndex + 1) !== -1
   ) {
     throw new BridgeError(
       "every tools command requires --skill-id <active-skill-id>",
       EXIT.USAGE
     );
   }
-  const skillId = operationArgs[skillIndex + 1];
+  const skillId = args[skillIndex + 1];
   const remaining = [
-    ...operationArgs.slice(0, skillIndex),
-    ...operationArgs.slice(skillIndex + 2),
+    ...args.slice(0, skillIndex),
+    ...args.slice(skillIndex + 2),
   ];
   const command = remaining[0];
-  const context = { operationId, skillId };
+  const context = { skillId };
   if (
     command === "context"
-    && ["resolve", "select"].includes(remaining[1])
+    && remaining[1] === "resolve"
     && remaining.length === 4
     && remaining[2] === "--input"
     && remaining[3] === "-"
@@ -368,6 +196,18 @@ function parseCommand(args) {
       ...context,
     };
   }
+  if (
+    command === "query"
+    && Object.hasOwn(PLATFORM_QUERY_TO_RESOURCE, remaining[1] || "")
+    && remaining.length === 4
+    && remaining[2] === "--input"
+    && remaining[3] === "-"
+  ) {
+    return { command, toolName: remaining[1], input: remaining[3], ...context };
+  }
+  if (command === "query") {
+    throw new BridgeError("platform query tool is not allowed", EXIT.USAGE);
+  }
   if (command === "status" && remaining.length === 1) return { command, ...context };
   if (command === "list") {
     if (remaining.length === 1) return { command, ...context };
@@ -434,11 +274,7 @@ function platformQueryIntent(toolName, argumentsValue) {
     }
     intent.app_id = String(value);
   }
-  try {
-    return requireRuntimeModule("runtime-intents.js").validateIntent(intent);
-  } catch (_error) {
-    throw new BridgeError("platform query intent is invalid", EXIT.USAGE);
-  }
+  return intent;
 }
 
 async function resolvePlatformQueryArguments(toolName, argumentsValue, config) {
@@ -602,9 +438,6 @@ function skillManifestPath(config) {
 }
 
 function loadSkillBinding(config, skillId, rootSkillId) {
-  if (skillId !== config.requiredSkillId) {
-    throw new BridgeError("Skill does not match the protected runtime operation intent", EXIT.CONFIG);
-  }
   const target = skillManifestPath(config);
   let manifest;
   try {
@@ -725,7 +558,6 @@ function prepareOperation(config, toolName, operationClass, argumentsValue, skil
     tool_name: toolName,
     operation_class: operationClass,
     arguments_digest: argumentsDigest(argumentsValue),
-    runtime_operation_id: config.operationId,
     skill_id: skillBinding.skillId,
     root_skill_id: skillBinding.rootSkillId,
     skill_package_version: skillBinding.packageVersion,
@@ -752,7 +584,6 @@ function confirmOperation(
   if (!record || record.status !== "awaiting_confirmation" || record.tool_name !== toolName ||
     record.operation_class !== operationClass ||
     record.arguments_digest !== argumentsDigest(argumentsValue) ||
-    record.runtime_operation_id !== config.operationId ||
     record.skill_id !== skillBinding.skillId ||
     record.root_skill_id !== skillBinding.rootSkillId ||
     record.skill_package_version !== skillBinding.packageVersion ||
@@ -1182,28 +1013,82 @@ async function validateToolArguments(config, toolName, argumentsValue) {
   if (validationError) throw new BridgeError(validationError, EXIT.USAGE);
 }
 
-async function execute(command, config) {
-  if (command.command === "context") {
-    const { createRuntimeContextResolver } = requireRuntimeModule("runtime-context-resolver.js");
-    const resolver = createRuntimeContextResolver({
-      operationStore: config.operationStore,
-      queryTool: async (toolName, argumentsValue) => execute({
-        command: "read",
-        toolName,
-        argumentsValue,
-      }, config),
-    });
-    if (command.action === "resolve") {
-      return resolver.resolve({
-        operationId: config.operationId,
-        required: command.argumentsValue.required,
+function boundedContextString(value) {
+  return typeof value === "string"
+    && value.length > 0
+    && value.length <= 128
+    && !/[\u0000-\u001f\u007f-\u009f]/u.test(value)
+    ? value
+    : null;
+}
+
+async function resolveStatelessContext(input, config) {
+  const required = input?.required;
+  if (!Array.isArray(required)
+    || required.some((item) => !["enterprise", "workspace"].includes(item))) {
+    throw new BridgeError("context required dimensions are invalid", EXIT.USAGE);
+  }
+  const identity = await execute({
+    command: "read",
+    toolName: "rainbond_get_current_user",
+    argumentsValue: {},
+  }, config);
+  const enterpriseId = boundedContextString(identity?.enterprise_id);
+  if (required.includes("enterprise") && !enterpriseId) {
+    return { state: "blocked", reason: "no-current-enterprise" };
+  }
+  if (!required.includes("workspace")) {
+    return { state: "resolved", context: { enterprise_id: enterpriseId } };
+  }
+  const teams = await execute({
+    command: "read",
+    toolName: "rainbond_query_teams",
+    argumentsValue: enterpriseId ? { enterprise_id: enterpriseId } : {},
+  }, config);
+  const options = [];
+  for (const item of Array.isArray(teams?.items) ? teams.items : []) {
+    const teamId = boundedContextString(item?.team_id || item?.tenant_id);
+    const teamName = boundedContextString(item?.team_name || item?.tenant_name);
+    const teamAlias = boundedContextString(item?.team_alias || item?.tenant_alias);
+    if (!teamId || !teamName || !Array.isArray(item.region_list)) continue;
+    for (const region of item.region_list) {
+      const regionName = boundedContextString(region?.region_name);
+      if (!regionName) continue;
+      const regionLabel = boundedContextString(region.region_alias) || regionName;
+      const workspaceLabel = teamAlias && teamAlias !== teamName
+        ? `${teamAlias}（${teamName}）`
+        : teamName;
+      options.push({
+        id: `${teamId}:${regionName}`,
+        label: `${workspaceLabel} / ${regionLabel}`,
+        team_id: teamId,
+        team_name: teamName,
+        region_name: regionName,
       });
+      if (options.length > 256) {
+        throw new BridgeError("workspace candidate set is too large", EXIT.TOOL);
+      }
     }
-    return resolver.select({
-      operationId: config.operationId,
-      selectionId: command.argumentsValue.selection_id,
-      optionId: command.argumentsValue.option_id,
-    });
+  }
+  if (options.length === 0) return { state: "blocked", reason: "no-accessible-workspace" };
+  if (options.length === 1) {
+    const option = options[0];
+    return {
+      state: "resolved",
+      context: {
+        enterprise_id: enterpriseId,
+        team_id: option.team_id,
+        team_name: option.team_name,
+        region_name: option.region_name,
+      },
+    };
+  }
+  return { state: "needs-selection", dimension: "workspace-region", options };
+}
+
+async function execute(command, config) {
+  if (command.command === "context") {
+    return resolveStatelessContext(command.argumentsValue, config);
   }
   if (command.command === "package-upload") {
     return executePackageUpload(command, config);
@@ -1214,8 +1099,6 @@ async function execute(command, config) {
     return {
       status: "ok",
       cli_version: CLI_VERSION,
-      operation_id: config.operationId,
-      environment_id: config.environmentId,
       tool_count: tools.length,
       catalog_age_ms: cached ? Math.max(0, Math.round(cached.age)) : 0,
     };
@@ -1327,7 +1210,7 @@ async function main(args = process.argv.slice(2)) {
       argumentRedactions = collectArgumentRedactions(argumentsValue);
     }
     if (command.command === "query") {
-      config = loadEnvironmentConfig({ environmentId: command.environmentId });
+      config = loadConfig({ includeRuntime: true });
       command.argumentsValue = await resolvePlatformQueryArguments(
         command.toolName,
         command.argumentsValue,
@@ -1348,14 +1231,7 @@ async function main(args = process.argv.slice(2)) {
     }
     config = loadConfig({
       includeRuntime: true,
-      operationId: command.operationId,
     });
-    if (command.skillId !== config.requiredSkillId) {
-      throw new BridgeError(
-        "Skill does not match the protected runtime operation intent",
-        EXIT.CONFIG
-      );
-    }
     if (config.isInsecureHttp) {
       process.stderr.write('{"warning":"using insecure HTTP transport"}\n');
     }
@@ -1382,10 +1258,8 @@ module.exports = {
   loadConfig,
   executePackageUpload,
   packageUploadEnvironment,
-  parseEnvFile,
   parseCommand,
   platformQueryIntent,
-  loadEnvironmentConfig,
   rpcRequest,
   validateSchemaValue,
   validateToolArguments,