openxiangda 1.0.198 → 1.0.199

package/README.md

@@ -55,6 +55,13 @@ openxiangda environment attach --logical-app example-app --preproduction-target
 openxiangda environment status --json
 # 仅限投产前环境角色重分类：原子交换两个既有应用的角色，应用数据和 Release Head 不移动
 openxiangda environment swap --reason "投产前将现有业务应用调整为正式应用" --confirm-production --profile dev
+# 单独调整一个环境的副作用策略：先只读预览，再按当前 revision 审计式更新；不会交换环境角色
+openxiangda environment policy update preproduction \
+  --side-effect-policy-json '{"organizationWrites":"explicit_capability_only"}' \
+  --reason "为预发真实 UAT 开放受权限保护的组织写入" --dry-run --profile dev
+openxiangda environment policy update preproduction \
+  --side-effect-policy-json '{"organizationWrites":"explicit_capability_only"}' \
+  --reason "为预发真实 UAT 开放受权限保护的组织写入" --profile dev
 openxiangda studio
 # 环境托管应用日常发布：首次命令只部署预发并停止
 openxiangda release ship --change mainline-release --profile dev
@@ -78,6 +85,8 @@ Existing workspaces connect to a server-side environment set with `environment a
 
 `environment swap` is a commissioning/reclassification operation, not a release shortcut. It requires `--confirm-production` and a reason, atomically exchanges the two existing environment roles, preserves each application's data and Release Heads, and remaps local resource IDs by appType. Existing side-effect policies remain restricted unless explicit replacement policy JSON is supplied.
 
+Use `environment policy update <kind|id>` when only one environment's side-effect policy must change. The CLI reads the current revision and shows the exact before/after diff; `--dry-run` performs GET only. The write uses CAS, increments only that environment revision, writes a durable before/after audit, and preserves unspecified fields unless `--full-replace` is explicit. Production writes additionally require `--confirm-production`. `organizationWrites=explicit_capability_only` removes the environment-level deny but still requires `app:organization:manage`; there is no unrestricted bypass mode.
+
 `openxiangda studio` starts a loopback-only local Developer Center with a random session token. It shows target bindings, candidate/deployment status, Git state, test evidence, drift, and the next safe action. Its buttons invoke only registered OpenXiangda operations; it does not expose arbitrary shell execution. Production promotion and rollback still require an explicit production confirmation.
 
 `resource plan` and `resource publish --dry-run` run behind a strict GET/HEAD-only HTTP guard. If a read receives HTTP 401, the command fails with `READ_ONLY_AUTH_REQUIRED` and never calls the token refresh POST from inside the plan. Run `openxiangda auth refresh --profile <name>` (or log in again) before retrying; a plan must not mutate auth state or platform resources.

package/lib/application-environments.js

@@ -3,6 +3,20 @@ const fs = require('fs');
 const path = require('path');
 
 const ENVIRONMENT_KINDS = new Set(['preproduction', 'production']);
+const SIDE_EFFECT_POLICY_ENUMS = Object.freeze({
+  notifications: ['disabled', 'tester_allowlist', 'enabled', 'real'],
+  organizationWrites: ['deny', 'explicit_capability_only'],
+  scheduledAutomations: ['disabled', 'enabled'],
+  externalWrites: ['deny', 'allowlist', 'configured', 'sandbox'],
+  payments: ['deny', 'configured', 'sandbox'],
+  publicIndexing: ['deny', 'configured', 'enabled'],
+});
+const SIDE_EFFECT_POLICY_FIELDS = new Set([
+  ...Object.keys(SIDE_EFFECT_POLICY_ENUMS),
+  'notificationAllowlist',
+  'environmentBanner',
+  'externalDingTalkDepartmentRootId',
+]);
 
 function canonicalJson(value) {
   if (Array.isArray(value)) {
@@ -45,6 +59,114 @@ function cloneJsonValue(value) {
     : JSON.parse(JSON.stringify(value));
 }
 
+function normalizeSideEffectPolicyInput(value, label = 'sideEffectPolicy') {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(`${label} 必须是对象`);
+  }
+  for (const key of Object.keys(value)) {
+    if (!SIDE_EFFECT_POLICY_FIELDS.has(key)) {
+      throw new Error(`${label}.${key} 不是允许的副作用策略字段`);
+    }
+  }
+  const result = {};
+  for (const [key, allowed] of Object.entries(SIDE_EFFECT_POLICY_ENUMS)) {
+    if (!Object.prototype.hasOwnProperty.call(value, key)) continue;
+    const normalized = String(value[key] || '').trim();
+    if (!allowed.includes(normalized)) {
+      throw new Error(`${label}.${key} 必须是 ${allowed.join('、')} 之一`);
+    }
+    result[key] = normalized;
+  }
+  if (Object.prototype.hasOwnProperty.call(value, 'notificationAllowlist')) {
+    if (!Array.isArray(value.notificationAllowlist)) {
+      throw new Error(`${label}.notificationAllowlist 必须是数组`);
+    }
+    if (value.notificationAllowlist.length > 500) {
+      throw new Error(`${label}.notificationAllowlist 最多包含 500 项`);
+    }
+    result.notificationAllowlist = Array.from(
+      new Set(
+        value.notificationAllowlist.map((item, index) => {
+          const normalized = String(item ?? '').trim();
+          if (!normalized || normalized.length > 255) {
+            throw new Error(
+              `${label}.notificationAllowlist[${index}] 必须是 1-255 字符的字符串`,
+            );
+          }
+          return normalized;
+        }),
+      ),
+    );
+  }
+  if (Object.prototype.hasOwnProperty.call(value, 'environmentBanner')) {
+    if (typeof value.environmentBanner !== 'boolean') {
+      throw new Error(`${label}.environmentBanner 必须是布尔值`);
+    }
+    result.environmentBanner = value.environmentBanner;
+  }
+  if (
+    Object.prototype.hasOwnProperty.call(
+      value,
+      'externalDingTalkDepartmentRootId',
+    )
+  ) {
+    const raw = value.externalDingTalkDepartmentRootId;
+    if (
+      !['string', 'number'].includes(typeof raw) ||
+      (typeof raw === 'number' && !Number.isSafeInteger(raw))
+    ) {
+      throw new Error(
+        `${label}.externalDingTalkDepartmentRootId 必须是字符串或安全整数`,
+      );
+    }
+    const normalized = String(raw).trim();
+    if (!/^\d{1,64}$/.test(normalized)) {
+      throw new Error(
+        `${label}.externalDingTalkDepartmentRootId 必须是数字型钉钉部门 ID`,
+      );
+    }
+    result.externalDingTalkDepartmentRootId = normalized;
+  }
+  return result;
+}
+
+function buildSideEffectPolicyDiff(beforeInput, updateInput, options = {}) {
+  const before = normalizeSideEffectPolicyInput(
+    beforeInput || {},
+    'currentSideEffectPolicy',
+  );
+  const update = normalizeSideEffectPolicyInput(
+    updateInput,
+    'sideEffectPolicy',
+  );
+  const fullReplace = options.fullReplace === true;
+  const after = normalizeSideEffectPolicyInput(
+    fullReplace ? update : { ...before, ...update },
+    'nextSideEffectPolicy',
+  );
+  const fields = Array.from(
+    new Set([...Object.keys(before), ...Object.keys(after)]),
+  ).sort();
+  const changes = fields
+    .filter(key => canonicalJson(before[key]) !== canonicalJson(after[key]))
+    .map(key => ({
+      field: key,
+      before: Object.prototype.hasOwnProperty.call(before, key)
+        ? cloneJsonValue(before[key])
+        : null,
+      after: Object.prototype.hasOwnProperty.call(after, key)
+        ? cloneJsonValue(after[key])
+        : null,
+    }));
+  return {
+    fullReplace,
+    changed: changes.length > 0,
+    before,
+    after,
+    changes,
+  };
+}
+
 function normalizeIdentityList(values) {
   return Array.from(
     new Set(
@@ -203,6 +325,10 @@ function bindEnvironmentTarget(state, input) {
       input.sideEffectPolicy === undefined
         ? previous.sideEffectPolicy || {}
         : input.sideEffectPolicy,
+    revision:
+      input.revision === undefined
+        ? previous.revision || null
+        : Number(input.revision),
     resources,
     updatedAt: new Date().toISOString(),
   };
@@ -449,12 +575,14 @@ function isRecoverablePostActivationDeploymentError(error, deployment) {
 
 module.exports = {
   bindEnvironmentTarget,
+  buildSideEffectPolicyDiff,
   buildCandidateBundle,
   canonicalJson,
   isRecoverablePostActivationDeploymentError,
   normalizeEnvironmentKind,
   normalizeManagedChangeSourceBase,
   normalizeManagedReleaseSourceRevision,
+  normalizeSideEffectPolicyInput,
   normalizeTargetName,
   hasStateResourceMappings,
   readCandidate,

package/lib/cli.js

@@ -130,6 +130,7 @@ const { buildDesignReview, renderDesignReview } = require('./design-review');
 const {
   bindEnvironmentTarget,
   buildCandidateBundle,
+  buildSideEffectPolicyDiff,
   isRecoverablePostActivationDeploymentError,
   normalizeEnvironmentKind,
   normalizeManagedChangeSourceBase,
@@ -299,7 +300,7 @@ Usage:
   openxiangda open-api credential list|get|create|update|rotate-secret [id] [--profile name] [--show-secret] [--yes] [--json]
   openxiangda design gates|template|review [--topic code] [--json]
   openxiangda sdd init|migrate|propose|quick|bundle|approve|status|context|verify|sync|archive [change] [--change id] [--json]
-  openxiangda environment init|attach|bind|swap|list|status|diff|use [preproduction|production] [--logical-app code] [--environment target] [--json]
+  openxiangda environment init|attach|bind|swap|policy update|list|status|diff|use [preproduction|production] [--logical-app code] [--environment target] [--json]
   openxiangda release publish|begin|status|integration-status|renew|end [--change id] [--profile name] [--watch] [--json]
   openxiangda release ship|candidate|deploy|test|promote|rollback [--candidate id] [--environment target] [--json]
   openxiangda task status --change <id> [--profile name] [--watch] [--json]
@@ -384,6 +385,7 @@ const SUBCOMMAND_BOOLEAN_FLAGS = new Set([
   '--dry-run',
   '--enabled',
   '--force',
+  '--full-replace',
   '--help',
   '--include-sourcemaps',
   '--json',
@@ -1920,6 +1922,7 @@ function saveEnvironmentWorkspaceState(state, setDetail, environmentDetail, inpu
     displayName: environmentDetail.displayName,
     publicOrigin: environmentDetail.publicOrigin,
     sideEffectPolicy: environmentDetail.sideEffectPolicy,
+    revision: environmentDetail.revision,
     seedResources,
     replaceResources: input.replaceResources,
     seedAppScopedState: input.seedAppScopedState,
@@ -1939,6 +1942,7 @@ async function environment(args) {
       '      openxiangda environment attach --logical-app <code> [--preproduction-target name] [--production-target name] [--profile name]',
       '      openxiangda environment bind preproduction|production --app-type APP_XXX [--target name] [--profile name]',
       '      openxiangda environment swap --reason <text> --confirm-production [--preproduction-side-effect-policy-json <JSON|file>] [--production-side-effect-policy-json <JSON|file>] [--profile name]',
+      '      openxiangda environment policy update preproduction|production --side-effect-policy-json <JSON|file> --reason <text> [--dry-run] [--full-replace] [--confirm-production] [--profile name]',
       '      openxiangda environment list|status|diff [--logical-app code] [--profile name] [--json]',
       '      openxiangda environment use <target|preproduction|production>',
     ].join('\n'));
@@ -2099,6 +2103,133 @@ async function environment(args) {
     Object.values(state.targets || {})[0]?.profile ||
     config.currentProfile;
 
+  if (subcommand === 'policy') {
+    if (positional[0] !== 'update') {
+      fail(
+        '用法: openxiangda environment policy update preproduction|production --side-effect-policy-json <JSON|file> --reason <text> [--dry-run]',
+      );
+    }
+    const selector = positional[1] || flags.environment || flags.target;
+    if (!selector) {
+      fail('environment policy update 必须指定环境 kind、id 或本地 target');
+    }
+    const reason = readStringFlag(flags, 'reason');
+    if (!reason || reason.length < 10) {
+      fail('environment policy update 必须提供至少 10 个字符的 --reason');
+    }
+    const policySource = readStringFlag(flags, 'side-effect-policy-json');
+    if (!policySource) {
+      fail('environment policy update 必须提供 --side-effect-policy-json');
+    }
+    const profile = getProfile(config, selectedProfile);
+    const setDetail = await requestWithAuth(
+      config,
+      profile.profileName,
+      environmentSetApiPath(code),
+    );
+    const localTarget = state.targets?.[selector];
+    const environmentSelector = localTarget?.environmentId || selector;
+    const matches = (setDetail.environments || []).filter(
+      item =>
+        item.id === environmentSelector || item.kind === environmentSelector,
+    );
+    if (matches.length !== 1) {
+      fail(`应用环境不存在或不唯一: ${selector}`);
+    }
+    const environmentDetail = matches[0];
+    const explicitExpectedRevision = readStringFlag(
+      flags,
+      'expected-revision',
+    );
+    const expectedRevision = explicitExpectedRevision
+      ? Number(explicitExpectedRevision)
+      : Number(environmentDetail.revision);
+    if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 1) {
+      fail('environment policy update 缺少有效的环境 revision');
+    }
+    const policyUpdate = readJsonInput(
+      policySource,
+      'side-effect-policy-json',
+    );
+    const diff = buildSideEffectPolicyDiff(
+      environmentDetail.sideEffectPolicy || {},
+      policyUpdate,
+      { fullReplace: Boolean(flags['full-replace']) },
+    );
+    const preview = {
+      logicalApp: {
+        id: setDetail.id,
+        code: setDetail.code,
+      },
+      environment: {
+        id: environmentDetail.id,
+        kind: environmentDetail.kind,
+        appType: environmentDetail.appType,
+        revision: environmentDetail.revision,
+      },
+      expectedRevision,
+      reason,
+      dryRun: Boolean(flags['dry-run']),
+      ...diff,
+    };
+    if (flags['dry-run'] || !diff.changed) {
+      if (flags.json) return writeJson(preview);
+      print(JSON.stringify(preview, null, 2));
+      return;
+    }
+    if (
+      environmentDetail.kind === 'production' &&
+      !flags['confirm-production']
+    ) {
+      fail(
+        'environment policy update 正式环境写入必须提供 --confirm-production；--dry-run 不需要',
+      );
+    }
+    const data = await requestWithAuth(
+      config,
+      profile.profileName,
+      environmentSetApiPath(
+        code,
+        `/environments/${encodeURIComponent(environmentDetail.id)}/policy`,
+      ),
+      {
+        method: 'POST',
+        body: {
+          expectedRevision,
+          sideEffectPolicy: policyUpdate,
+          reason,
+          fullReplace: Boolean(flags['full-replace']),
+          confirmProduction: Boolean(flags['confirm-production']),
+        },
+      },
+    );
+    const previousTarget = Object.values(state.targets || {}).find(
+      target => target.environmentId === environmentDetail.id,
+    );
+    const updatedTarget = saveEnvironmentWorkspaceState(
+      state,
+      setDetail,
+      data.environment,
+      {
+        targetName:
+          previousTarget?.targetName ||
+          localTarget?.targetName ||
+          data.environment.kind,
+        profile: previousTarget?.profile || profile.profileName,
+      },
+    );
+    const result = {
+      ...preview,
+      dryRun: false,
+      environment: data.environment,
+      audit: data.audit,
+      target: updatedTarget,
+    };
+    if (flags.json) return writeJson(result);
+    print(JSON.stringify(result, null, 2));
+    return;
+  }
+
   if (subcommand === 'swap') {
     if (!flags['confirm-production']) {
       fail(
@@ -2240,7 +2371,7 @@ async function environment(args) {
     return;
   }
 
-  fail('用法: openxiangda environment init|attach|bind|swap|list|status|diff|use');
+  fail('用法: openxiangda environment init|attach|bind|swap|policy update|list|status|diff|use');
 }
 
 function buildEnvironmentStatusDiff(status) {
@@ -13947,7 +14078,7 @@ async function commands(args) {
       'open-api credential list|get|create|update|rotate-secret [id]',
       'design gates|template|review [--topic code]',
       'sdd init|migrate|propose|quick|bundle|approve|status|context|verify|sync|archive',
-      'environment init|attach|bind|swap|list|status|diff|use',
+      'environment init|attach|bind|swap|policy update|list|status|diff|use',
       'release ship|candidate|deploy|test|promote|rollback|publish|begin|status|integration-status|renew|end|backend-head|backend-list|backend-detail|backend-diff|backend-rollback|backend-abort|backend-retry|app-capture|app-head|app-list|app-detail|app-diff|app-prepare|app-verify|app-activate|app-finalize|app-rollback|app-abort',
       'studio [--no-open] [--port 0]',
       'env',

package/openxiangda-skills/SKILL.md

@@ -104,7 +104,7 @@ openxiangda release ship --change <release-change> --profile <name> \
   --confirm-production
 ```
 
-For a workspace registered by `openxiangda environment init` or connected to an existing set with `openxiangda environment attach`, production is never a direct publish target. Use the two-phase `release ship` fast path by default. Its first invocation creates/deploys the immutable candidate to preproduction and always returns `awaiting_production_confirmation`; it cannot promote. A second invocation with `--confirm-production` promotes the exact same candidate hash. Real human acceptance is the recommended normal practice and can be recorded with optional `--acceptance-note`, but do not invent an acceptance note and do not treat it as a universal hard platform gate when the user explicitly authorizes a low-risk or emergency promotion. The lower-level candidate/deploy/test/promote commands are recovery primitives, not the normal agent loop. Preproduction and production keep independent app/resource/data identities in `.openxiangda/state.json`; do not copy IDs between targets. `environment attach` may seed only the matching legacy app binding into preproduction and must leave production empty. Only during authorized commissioning/reclassification may `environment swap --reason "..." --confirm-production` atomically exchange the two existing roles; it preserves each app's data and Release Heads, remaps local resource IDs by appType, and does not enable production side effects by default. Use `openxiangda studio` for the loopback-only developer view of bindings, drift, evidence, and safe next actions.
+For a workspace registered by `openxiangda environment init` or connected to an existing set with `openxiangda environment attach`, production is never a direct publish target. Use the two-phase `release ship` fast path by default. Its first invocation creates/deploys the immutable candidate to preproduction and always returns `awaiting_production_confirmation`; it cannot promote. A second invocation with `--confirm-production` promotes the exact same candidate hash. Real human acceptance is the recommended normal practice and can be recorded with optional `--acceptance-note`, but do not invent an acceptance note and do not treat it as a universal hard platform gate when the user explicitly authorizes a low-risk or emergency promotion. The lower-level candidate/deploy/test/promote commands are recovery primitives, not the normal agent loop. Preproduction and production keep independent app/resource/data identities in `.openxiangda/state.json`; do not copy IDs between targets. `environment attach` may seed only the matching legacy app binding into preproduction and must leave production empty. Only during authorized commissioning/reclassification may `environment swap --reason "..." --confirm-production` atomically exchange the two existing roles; it preserves each app's data and Release Heads, remaps local resource IDs by appType, and does not enable production side effects by default. To change only one environment's side-effect policy, run `environment policy update <kind|id> --side-effect-policy-json <JSON|file> --reason "..." --dry-run` first, then repeat without `--dry-run`; never use swap for this. The update is revision-CAS and patch-preserving unless `--full-replace` is explicit, production needs `--confirm-production`, and `organizationWrites=explicit_capability_only` still requires `app:organization:manage`. Use `openxiangda studio` for the loopback-only developer view of bindings, drift, evidence, and safe next actions.
 
 `resource plan` and publish dry-runs are strictly GET/HEAD-only. `READ_ONLY_AUTH_REQUIRED` means the access token expired; run `openxiangda auth refresh --profile <name>` or log in again before retrying. Never add an automatic refresh POST inside a plan.
 

package/openxiangda-skills/references/openxiangda-api.md

@@ -866,6 +866,10 @@ Binds the missing `preproduction` or `production` app identity. An appType can b
 
 Atomically exchanges the roles of the two existing app identities during an explicitly confirmed commissioning/reclassification operation. The request requires `confirmation=SWAP_PREPRODUCTION_AND_PRODUCTION` and a reason. Application data and Release Heads stay with their appType; local target resources are remapped by appType. Existing side-effect restrictions remain unless the request explicitly supplies replacement policies.
 
+### POST `/environment-sets/:code/environments/:kindOrId/policy`
+
+Updates only one environment's side-effect policy. The request requires `expectedRevision`, `reason`, and a strictly validated `sideEffectPolicy` patch; `fullReplace=true` is the only way to replace rather than merge. Production additionally requires `confirmProduction=true`. A successful transaction increments that environment revision and writes a durable audit containing actor, environment identity, reason, and secret-free before/after policies. It does not change either environment role, business data, or any App/Runtime/Backend/Page/Workflow Release Head. `externalDingTalkDepartmentRootId` accepts a string or safe integer and is stored as a string. `organizationWrites=explicit_capability_only` still requires the normal `app:organization:manage` permission.
+
 ### GET `/environment-sets/:code/status`
 
 Returns each target's active heads, latest deployment, side-effect policy, and candidate drift state for the local Developer Center.

package/openxiangda-skills/references/workspace-state.md

@@ -68,9 +68,16 @@ Environment-managed workspaces add a logical application and target-specific bin
       "environmentId": "PRE_ENV_UUID",
       "kind": "preproduction",
       "appType": "APP_PRE",
+      "revision": 4,
       "sideEffectPolicy": {
-        "notificationsEnabled": false,
-        "scheduledAutomationsEnabled": false
+        "notifications": "tester_allowlist",
+        "notificationAllowlist": [],
+        "organizationWrites": "deny",
+        "scheduledAutomations": "disabled",
+        "externalWrites": "allowlist",
+        "payments": "deny",
+        "publicIndexing": "deny",
+        "environmentBanner": true
       },
       "resources": {}
     },
@@ -102,4 +109,5 @@ Environment-managed workspaces add a logical application and target-specific bin
 - A prod publish must not read dev IDs.
 - Never copy target resource bindings. Use `openxiangda environment use <target>` or pass `--environment <target>` and let the CLI populate that target from its own deployment.
 - Managed targets cannot use direct `release publish`; use two-phase `release ship`. The first invocation only prepares preproduction and stops; after confirming the preproduction result, a separate invocation with `--confirm-production` promotes the same candidate. Human acceptance is recommended and may be recorded with optional `--acceptance-note`.
+- Change a single target's side-effect policy with `openxiangda environment policy update <kind|id> --side-effect-policy-json <JSON|file> --reason "..." --dry-run`, inspect the exact diff, then repeat without `--dry-run`. The write uses the server revision as CAS and updates local `revision`; it does not swap roles or alter Release Heads. Omitted fields are preserved unless `--full-replace` is explicit, and production additionally requires `--confirm-production`.
 - Before publishing to another platform, run `openxiangda workspace bind --profile <name> --app-type <APP_XXX>`.

package/openxiangda-skills/skills/openxiangda-core/SKILL.md

@@ -105,7 +105,7 @@ openxiangda release ship --change <release-change> --profile <name> \
   --confirm-production
 ```
 
-Once `environment init` registers a logical application, or `environment attach` connects an existing workspace, `preproduction` and `production` are separate target bindings with separate app/resource/data IDs. Never copy IDs between them. Existing legacy resource mappings may seed only the target whose appType matches (normally preproduction); production stays empty. The normal path is the two-phase `release ship`. Its first invocation creates and deploys the immutable candidate only to preproduction and stops at `awaiting_production_confirmation`. A different, later invocation with `--confirm-production` promotes the exact same candidate and fresh deployment-bound evidence. Human acceptance is recommended and an optional `--acceptance-note` records it, but it is not a universal hard platform gate for explicitly authorized low-risk or emergency releases. Direct `release publish` to either managed target fails closed. Only authorized commissioning/reclassification may run `environment swap --reason "..." --confirm-production`; the atomic operation preserves each app's data and Release Heads, remaps local resources by appType, and keeps existing side-effect restrictions unless explicit replacement policies are supplied. `openxiangda studio` is the local loopback-only developer view and exposes only registered safe actions.
+Once `environment init` registers a logical application, or `environment attach` connects an existing workspace, `preproduction` and `production` are separate target bindings with separate app/resource/data IDs. Never copy IDs between them. Existing legacy resource mappings may seed only the target whose appType matches (normally preproduction); production stays empty. The normal path is the two-phase `release ship`. Its first invocation creates and deploys the immutable candidate only to preproduction and stops at `awaiting_production_confirmation`. A different, later invocation with `--confirm-production` promotes the exact same candidate and fresh deployment-bound evidence. Human acceptance is recommended and an optional `--acceptance-note` records it, but it is not a universal hard platform gate for explicitly authorized low-risk or emergency releases. Direct `release publish` to either managed target fails closed. Only authorized commissioning/reclassification may run `environment swap --reason "..." --confirm-production`; the atomic operation preserves each app's data and Release Heads, remaps local resources by appType, and keeps existing side-effect restrictions unless explicit replacement policies are supplied. A single environment policy change uses `environment policy update <kind|id>` with a GET-only `--dry-run` first; it uses revision CAS, preserves omitted fields unless `--full-replace` is explicit, and never swaps roles or Release Heads. Production writes require `--confirm-production`. `organizationWrites=explicit_capability_only` only removes the environment deny and never bypasses `app:organization:manage`. `openxiangda studio` is the local loopback-only developer view and exposes only registered safe actions.
 
 `release publish` is the normal whole-app entrypoint for legacy unmanaged workspaces: it verifies SDD without mutating reviewed files, waits for the promotion lease, freezes one App capture, stages the exact Form/Backend/Runtime children, resumes from a private execution journal, finalizes once, and releases the lease. Managed applications use two-phase `release ship` and its deployment-scoped journal. Individual candidate/deploy/test/promote commands are recovery/diagnostic primitives.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openxiangda",
-  "version": "1.0.198",
+  "version": "1.0.199",
   "description": "OpenXiangda CLI, workspace build tools, runtime SDK, and form components.",
   "private": false,
   "bin": {
@@ -64,7 +64,7 @@
     "build:sdk": "tsup --config packages/sdk/tsup.config.ts",
     "check": "node --check bin/openxiangda.js && node --check lib/*.js && node --check packages/sdk/src/build-source/src/cli.mjs && node --check packages/sdk/src/build-source/scripts/*.mjs && node --check packages/sdk/src/build-source/scripts/utils/*.mjs",
     "test": "npm run test:fast",
-    "test:fast": "npm run check && node scripts/http-proxy-smoke.mjs && node scripts/form-export-cli-smoke.mjs && node scripts/open-api-cli-smoke.mjs && node scripts/release-plan-smoke.mjs && node scripts/typed-resource-plan-smoke.mjs && node scripts/integration-bundle-smoke.mjs && node scripts/content-cache-smoke.mjs && node scripts/dependency-capsule-smoke.mjs && node scripts/sdd-stages-smoke.mjs && node scripts/environment-swap-cli-smoke.mjs",
+    "test:fast": "npm run check && node scripts/http-proxy-smoke.mjs && node scripts/form-export-cli-smoke.mjs && node scripts/open-api-cli-smoke.mjs && node scripts/release-plan-smoke.mjs && node scripts/typed-resource-plan-smoke.mjs && node scripts/integration-bundle-smoke.mjs && node scripts/content-cache-smoke.mjs && node scripts/dependency-capsule-smoke.mjs && node scripts/sdd-stages-smoke.mjs && node scripts/environment-swap-cli-smoke.mjs && node scripts/environment-policy-cli-smoke.mjs",
     "test:changed": "npm run check && node scripts/run-test-suite.mjs --changed --evidence",
     "test:contract": "npm run check && node scripts/run-test-suite.mjs --contract --evidence",
     "test:release": "npm run check && node scripts/run-test-suite.mjs --release --evidence",
@@ -114,6 +114,7 @@
     "test:application-environments": "node scripts/application-environments-smoke.mjs",
     "test:release-ship": "node scripts/release-ship-gate-smoke.mjs",
     "test:environment-swap": "node scripts/environment-swap-cli-smoke.mjs",
+    "test:environment-policy": "node scripts/environment-policy-cli-smoke.mjs",
     "test:developer-center": "node scripts/developer-center-smoke.mjs",
     "test:form-release-cas": "node scripts/form-release-cas-smoke.mjs",
     "test:source-dependencies": "node scripts/source-dependencies-smoke.mjs",

package/templates/openxiangda-react-spa/AGENTS.md

@@ -52,7 +52,7 @@ openxiangda commands --json
 
 模板已停用无范围的 `pnpm deploy` 聚合入口。日常变更必须使用 `resource plan|publish <type> --only <codes>`（单资源可用 `--code <code>`）。Form bundle、Backend Release 和 Runtime 都先暂存；CLI 会按 `--change` 自动聚合 `.openxiangda/releases/<change>/staged-resources.json`，最后只由一次 Root App finalize 原子激活。不要使用 `workspace publish --form`、单独 `runtime activate`、`pnpm publish:all`、`pnpm openxiangda:publish` 或 `lowcode-workspace publish-all`。
 
-工作区一旦通过 `environment init` 登记，或通过 `environment attach` 接入已有环境组，`release publish` 即不再是入口。日常使用两段式 `release ship`：第一次冻结不可变 candidate 并只部署到 preproduction，停止在 `awaiting_production_confirmation`；确认预发结果后，第二次命令提供 `--confirm-production`，把同一 candidate 晋级 production，不会重新构建。真实人工验收是默认建议，可用可选的 `--acceptance-note` 留痕；但用户明确授权的低风险或紧急发布不受僵硬审批门禁阻塞。两套环境的 appType、资源 ID、数据和副作用策略完全独立；旧单目标资源映射只允许迁移到 appType 相同的预发 target，正式 target 必须为空。仅在用户明确授权的投产前重分类中使用 `environment swap --reason "..." --confirm-production` 原子交换两个既有应用的环境角色；数据和 Release Head 不移动，副作用默认不放开。`openxiangda studio` 提供仅本机访问的开发者页面，用于查看绑定、漂移、候选、部署、证据和下一安全动作。
+工作区一旦通过 `environment init` 登记，或通过 `environment attach` 接入已有环境组，`release publish` 即不再是入口。日常使用两段式 `release ship`：第一次冻结不可变 candidate 并只部署到 preproduction，停止在 `awaiting_production_confirmation`；确认预发结果后，第二次命令提供 `--confirm-production`，把同一 candidate 晋级 production，不会重新构建。真实人工验收是默认建议，可用可选的 `--acceptance-note` 留痕；但用户明确授权的低风险或紧急发布不受僵硬审批门禁阻塞。两套环境的 appType、资源 ID、数据和副作用策略完全独立；旧单目标资源映射只允许迁移到 appType 相同的预发 target，正式 target 必须为空。仅在用户明确授权的投产前重分类中使用 `environment swap --reason "..." --confirm-production` 原子交换两个既有应用的环境角色；数据和 Release Head 不移动，副作用默认不放开。单独调整某个环境的副作用策略时，先运行 `environment policy update <kind|id> ... --dry-run` 查看差异，再按 CAS revision 写入；不得借用 swap，遗漏字段默认保留，正式写入另需 `--confirm-production`。`organizationWrites=explicit_capability_only` 仍强制 `app:organization:manage`。`openxiangda studio` 提供仅本机访问的开发者页面，用于查看绑定、漂移、候选、部署、证据和下一安全动作。
 
 `resource plan` 与 publish dry-run 严格只允许 GET/HEAD。遇到 `READ_ONLY_AUTH_REQUIRED` 时，先执行 `openxiangda auth refresh --profile <name>` 或重新登录再重试；不得在 plan 内自动 POST 刷新 token。
 

package/templates/sy-lowcode-app-workspace/AGENTS.md

@@ -57,7 +57,7 @@
 - ✅ `resource plan` 与 publish dry-run 严格只允许 GET/HEAD；遇到 `READ_ONLY_AUTH_REQUIRED` 时先执行 `openxiangda auth refresh --profile <name>` 或重新登录，不得在 plan 内自动 POST 刷新 token。
 - ✅ Function/Automation 使用 Backend Release v2；正式多资源发布用精确 `--only/--code` 加 `--stage-only` 暂存，同一 child 可混合 create、source-only update 和显式 manifest replacement，再由 Root App finalize 原子激活。整包 manifest 替换必须另加 `--replace-manifest --reason "..."`。
 - ✅ 未登记环境的旧工作区，正式 promotion 先聚合 mainline bundle 并 commit/push，再运行 `release publish --change <id> --profile <name>`。
-- ✅ 已通过 `environment init` 登记或 `environment attach` 接入的工作区默认使用两段式 `release ship`。第一次命令只冻结 candidate 并部署 preproduction，停止等待正式晋级确认；确认预发结果后，另一次命令提供 `--confirm-production`，即可晋级同一 candidate。人工验收是默认建议，可用可选的 `--acceptance-note` 留痕，但不是所有低风险或紧急发布的硬审批门禁。preproduction / production 的 appType、资源 ID、数据和副作用策略完全隔离，严禁跨环境复制 ID 或直接 `release publish`。旧单目标映射只允许按相同 appType 迁移到预发。仅在用户明确授权的投产前重分类中使用 `environment swap --reason "..." --confirm-production` 原子交换两个既有应用的环境角色；数据和 Release Head 不移动，副作用默认不放开。
+- ✅ 已通过 `environment init` 登记或 `environment attach` 接入的工作区默认使用两段式 `release ship`。第一次命令只冻结 candidate 并部署 preproduction，停止等待正式晋级确认；确认预发结果后，另一次命令提供 `--confirm-production`，即可晋级同一 candidate。人工验收是默认建议，可用可选的 `--acceptance-note` 留痕，但不是所有低风险或紧急发布的硬审批门禁。preproduction / production 的 appType、资源 ID、数据和副作用策略完全隔离，严禁跨环境复制 ID 或直接 `release publish`。旧单目标映射只允许按相同 appType 迁移到预发。仅在用户明确授权的投产前重分类中使用 `environment swap --reason "..." --confirm-production` 原子交换两个既有应用的环境角色；数据和 Release Head 不移动，副作用默认不放开。单环境副作用策略用 `environment policy update <kind|id> ... --dry-run` 预览后按 revision CAS 写入，禁止借用 swap；默认保留未指定字段，正式写入需 `--confirm-production`，且 `organizationWrites=explicit_capability_only` 不绕过 `app:organization:manage`。
 - ✅ 本地开发者可运行 `openxiangda studio` 查看两套环境、差异、候选、部署和测试证据；该页面只监听回环地址且只暴露注册动作，生产操作仍需显式确认。
 
 ## 严禁