openxiangda 1.0.164 → 1.0.166

package/lib/cli.js

@@ -114,12 +114,14 @@ const {
   verifySddChange,
 } = require('./sdd');
 const {
+  clearSensitiveText,
   fail,
   formatFetchError,
   maskText,
   openBrowser,
   parseArgs,
   print,
+  registerSensitiveText,
   sleep,
   warn,
   writeJson,
@@ -130,6 +132,12 @@ const NPM_PACKAGE_NAME = 'openxiangda';
 const OFFICIAL_NPM_REGISTRY = 'https://registry.npmjs.org';
 const RUNTIME_UPLOAD_DEFAULT_TIMEOUT_MS = 120000;
 const RUNTIME_UPLOAD_CONCURRENCY = 3;
+const APP_FUNCTION_SECRET_CAPABILITIES = Object.freeze({
+  contractVersion: 'app_function_secrets_v1',
+  runtimeContractVersion: 'trusted_node_v2',
+  backendRelease: 'backend_release_v2',
+  atomicActivation: 'atomic_staged_children_v2',
+});
 let readOnlyHttpGuardDepth = 0;
 let readOnlyHttpGuardLabel = null;
 let activePublishRequestContext = null;
@@ -179,6 +187,7 @@ async function mainImpl(argv) {
   if (command === 'public-access') return publicAccess(rest);
   if (command === 'auth-config') return authConfig(rest);
   if (command === 'function') return appFunction(rest);
+  if (command === 'secret') return appSecret(rest);
   if (command === 'connector') return connector(rest);
   if (command === 'notification') return notification(rest);
   if (command === 'organization') return organization(rest);
@@ -256,7 +265,9 @@ Usage:
   openxiangda route list|get|create|update|upsert|delete [--json-file file] [--dry-run] [--write-manifest]
   openxiangda public-access list|get|create|update|upsert|delete|ticket-create|session-test|grant-check [--json-file file]
   openxiangda auth-config list|get|create|update|upsert|delete|methods [--json-file file]
-  openxiangda function list|get|create|update|upsert|delete|invoke [--json-file file]
+  openxiangda function list|get|create|update|upsert|delete|invoke|test [--json-file file]
+  openxiangda secret list|metadata|references|audit|unused [name] --profile <name>
+  openxiangda secret create|update|rotate|delete <name> --profile <name> --change <id> [--expected-revision n] [--value-stdin] [--dry-run]
   openxiangda connector list|get|create|update|upsert|delete|invoke|download-test [--json-file file]
   openxiangda notification template-list|template-get|template-upsert|template-delete|type-list|type-get|type-upsert|type-delete|preview|send|batch-send
   openxiangda organization capabilities|department-list|department-get|department-create|department-update|account-list|account-get|account-create|account-update|account-reset-password
@@ -304,10 +315,12 @@ const SUBCOMMAND_BOOLEAN_FLAGS = new Set([
   '--resources',
   '--skip-resources',
   '--show-secret',
+  '--stage-only',
   '--strict',
   '--sdd-bypass',
   '--summary',
   '--unpublish',
+  '--value-stdin',
   '--write-manifest',
   '--yes',
   '-h',
@@ -370,6 +383,12 @@ async function version(args) {
   const result = {
     name: NPM_PACKAGE_NAME,
     version: CURRENT_VERSION,
+    contracts: {
+      appFunctionSecrets: APP_FUNCTION_SECRET_CAPABILITIES.contractVersion,
+      trustedNode: APP_FUNCTION_SECRET_CAPABILITIES.runtimeContractVersion,
+      backendRelease: APP_FUNCTION_SECRET_CAPABILITIES.backendRelease,
+      atomicActivation: APP_FUNCTION_SECRET_CAPABILITIES.atomicActivation,
+    },
     updateCheckCommand: 'openxiangda update check --json',
   };
   if (flags.json) return writeJson(result);
@@ -971,6 +990,7 @@ async function release(args) {
       );
     }
     const pendingBaseline = getStoredChangeBaseline(target);
+    const newReleaseLifecycle = !stored && !pendingBaseline;
     const clientSessionId =
       existing?.clientSessionId ||
       (pendingBaseline?.changeId === changeId &&
@@ -999,12 +1019,16 @@ async function release(args) {
       throw error;
     }
     const finalizedBaseline = finalizeReleaseBaseline(target, baseline);
+    const stagedResourcesFile = newReleaseLifecycle
+      ? initializeStagedAppReleaseResources(target, changeId)
+      : null;
     const result = {
       ...lease,
       baselineId: finalizedBaseline?.baselineId,
       baselineHeadDigest: finalizedBaseline?.headDigest,
       sourceBase: finalizedBaseline?.sourceBase,
       releaseSourceRevision: finalizedBaseline?.releaseSourceRevision,
+      ...(stagedResourcesFile ? { stagedResourcesFile } : {}),
     };
     if (flags.json) return writeJson(result);
     print(
@@ -1543,6 +1567,285 @@ function readStagedAppReleaseResources(flags = {}) {
   );
 }
 
+function stagedResourcesFileForChange(changeId) {
+  const normalized = String(changeId || '').trim();
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(normalized)) {
+    fail('APP_RELEASE_STAGED_RESOURCES_CHANGE_INVALID: 自动聚合 staged resources 需要有效 --change');
+  }
+  return path.join(
+    process.cwd(),
+    '.openxiangda',
+    'releases',
+    normalized,
+    'staged-resources.json'
+  );
+}
+
+function stagedResourcesContextFileForChange(changeId) {
+  return stagedResourcesFileForChange(changeId).replace(
+    /staged-resources\.json$/,
+    'staged-resources.context.json'
+  );
+}
+
+function currentStagedResourcesContext(target, changeId) {
+  const baseline = getStoredChangeBaseline(target);
+  if (!baseline?.baselineId || baseline.changeId !== changeId) {
+    fail(
+      `APP_RELEASE_STAGED_CONTEXT_REQUIRED: change ${changeId} 缺少当前发布基线`
+    );
+  }
+  return {
+    contractVersion: 'staged_resources_context_v1',
+    appType: target.appType,
+    profile: target.profileName,
+    changeId,
+    baselineId: baseline.baselineId,
+    clientSessionId: baseline.clientSessionId || null,
+  };
+}
+
+function writeStagedResourcesFiles(changeId, resources, context) {
+  const file = stagedResourcesFileForChange(changeId);
+  const contextFile = stagedResourcesContextFileForChange(changeId);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  for (const [targetFile, value] of [
+    [file, resources],
+    [contextFile, context],
+  ]) {
+    const temporary = `${targetFile}.${process.pid}.tmp`;
+    fs.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, {
+      mode: 0o600,
+    });
+    fs.renameSync(temporary, targetFile);
+  }
+  return path.relative(process.cwd(), file).replace(/\\/g, '/');
+}
+
+function initializeStagedAppReleaseResources(target, changeId) {
+  const context = currentStagedResourcesContext(target, changeId);
+  return writeStagedResourcesFiles(changeId, [], {
+    ...context,
+    initializedAt: new Date().toISOString(),
+  });
+}
+
+function assertStagedResourcesContext(target, changeId) {
+  const expected = currentStagedResourcesContext(target, changeId);
+  const contextFile = stagedResourcesContextFileForChange(changeId);
+  if (!fs.existsSync(contextFile)) {
+    if (!fs.existsSync(stagedResourcesFileForChange(changeId))) {
+      initializeStagedAppReleaseResources(target, changeId);
+    }
+  }
+  if (!fs.existsSync(contextFile)) {
+    fail(
+      'APP_RELEASE_STAGED_CONTEXT_REQUIRED: staged resources 缺少当前 release begin 生成的 context；请重新暂存本次 change 的 child releases'
+    );
+  }
+  const actual = JSON.parse(fs.readFileSync(contextFile, 'utf8'));
+  for (const field of [
+    'contractVersion',
+    'appType',
+    'profile',
+    'changeId',
+    'baselineId',
+    'clientSessionId',
+  ]) {
+    if ((actual?.[field] ?? null) !== (expected[field] ?? null)) {
+      fail(
+        `APP_RELEASE_STAGED_CONTEXT_MISMATCH: ${field} 不属于当前 change/baseline/session，请重新暂存 child releases`
+      );
+    }
+  }
+  return actual;
+}
+
+function recordStagedAppReleaseResources(
+  changeId,
+  resources,
+  target
+) {
+  if (!changeId || !Array.isArray(resources) || resources.length === 0) {
+    return null;
+  }
+  const file = stagedResourcesFileForChange(changeId);
+  const context = assertStagedResourcesContext(target, changeId);
+  let existing = [];
+  if (fs.existsSync(file)) {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    existing = Array.isArray(parsed) && parsed.length === 0
+      ? []
+      : normalizeStagedAppReleaseResources(parsed);
+  }
+  const incoming = normalizeStagedAppReleaseResources(resources);
+  const merged = new Map();
+  for (const resource of [...existing, ...incoming]) {
+    const described = describeAppReleaseResource(resource, 0, 'stagedResources');
+    merged.set(described.stableKey, resource);
+  }
+  const output = Array.from(merged.values()).sort((left, right) => {
+    const leftKey = describeAppReleaseResource(left, 0, 'stagedResources').stableKey;
+    const rightKey = describeAppReleaseResource(right, 0, 'stagedResources').stableKey;
+    return leftKey.localeCompare(rightKey);
+  });
+  return writeStagedResourcesFiles(changeId, output, context);
+}
+
+function exactStringSet(left, right) {
+  const normalize = values =>
+    Array.from(
+      new Set((values || []).map(value => String(value || '').trim()).filter(Boolean))
+    ).sort();
+  const a = normalize(left);
+  const b = normalize(right);
+  return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+
+function stagedFormCode(target, resource) {
+  const explicit = String(resource?.metadata?.formCode || '').trim();
+  if (explicit) return explicit;
+  const formUuid = String(resource?.identity?.formUuid || '').trim();
+  for (const bucketName of ['formSettings', 'forms']) {
+    for (const [code, entry] of Object.entries(
+      target.bound.resources?.[bucketName] || {}
+    )) {
+      if (String(entry?.formUuid || '').trim() === formUuid) return code;
+    }
+  }
+  return formUuid;
+}
+
+function assertStagedAppReleaseScope(target, flags, resources) {
+  const changeId = readStringFlag(flags, 'change');
+  if (!changeId) {
+    fail(
+      'APP_RELEASE_STAGED_SCOPE_REQUIRED: staged child activation 必须显式提供 --change'
+    );
+  }
+  assertStagedResourcesContext(target, changeId);
+  let scope;
+  try {
+    scope = getSddChangeScope({
+      cwd: process.cwd(),
+      configText: readWorkspaceConfigText(),
+      changeId,
+    });
+  } catch (error) {
+    if (/SDD 未初始化|change 不存在|ENOENT/i.test(String(error?.message || ''))) {
+      return {
+        changeId,
+        scope: null,
+        resources: normalizeStagedAppReleaseResources(resources),
+        compatibility: 'unmanaged_sdd_scope',
+      };
+    }
+    throw error;
+  }
+  const targets = scope.targets || {};
+  const normalized = normalizeStagedAppReleaseResources(resources);
+  const byKind = kind => normalized.filter(resource => resource.kind === kind);
+  const expectedBackendSelectors = [
+    ...(targets.functions || []).map(code => `function:${code}`),
+    ...(targets.automations || []).map(code => `automation:${code}`),
+  ].sort();
+  const backend = byKind('BackendRelease');
+  if (expectedBackendSelectors.length > 0) {
+    if (
+      backend.length !== 1 ||
+      !exactStringSet(
+        backend[0]?.metadata?.handledSelectors,
+        expectedBackendSelectors
+      )
+    ) {
+      fail(
+        `APP_RELEASE_STAGED_SCOPE_MISMATCH: Backend handledSelectors 必须精确为 ${expectedBackendSelectors.join(',')}`
+      );
+    }
+  } else if (backend.length > 0) {
+    fail('APP_RELEASE_STAGED_SCOPE_MISMATCH: SDD 未授权 BackendRelease child');
+  }
+
+  const expectedForms = (targets.forms || []).map(String).sort();
+  const actualForms = byKind('FormRelease')
+    .map(resource => stagedFormCode(target, resource))
+    .sort();
+  if (!exactStringSet(actualForms, expectedForms)) {
+    fail(
+      `APP_RELEASE_STAGED_SCOPE_MISMATCH: FormRelease 必须精确覆盖 ${expectedForms.join(',') || '(none)'}`
+    );
+  }
+
+  const runtimeCount = byKind('RuntimeRelease').length;
+  if (runtimeCount !== (targets.runtime ? 1 : 0)) {
+    fail(
+      `APP_RELEASE_STAGED_SCOPE_MISMATCH: RuntimeRelease 期望 ${targets.runtime ? 1 : 0} 个，实际 ${runtimeCount} 个`
+    );
+  }
+  const pageCount = byKind('PageRelease').length;
+  const expectsPageRelease = (targets.pages || []).length > 0;
+  if (pageCount !== (expectsPageRelease ? 1 : 0)) {
+    fail(
+      `APP_RELEASE_STAGED_SCOPE_MISMATCH: PageRelease 期望 ${expectsPageRelease ? 1 : 0} 个，实际 ${pageCount} 个`
+    );
+  }
+  return { changeId, scope, resources: normalized };
+}
+
+function changedAppReleaseResources(detailResources, captureResources) {
+  const captured = new Map(
+    (captureResources || []).map((resource, index) => {
+      const described = describeAppReleaseResource(
+        resource,
+        index,
+        'capture.resources'
+      );
+      return [described.stableKey, described];
+    })
+  );
+  return (detailResources || []).filter((resource, index) => {
+    const described = describeAppReleaseResource(
+      resource,
+      index,
+      'release.resources'
+    );
+    const active = captured.get(described.stableKey);
+    return (
+      !active ||
+      active.releaseId !== described.releaseId ||
+      active.hash !== described.hash
+    );
+  });
+}
+
+function assertAppReleaseActualGate(target, flags, scope, command) {
+  assertSddReleaseGate(
+    buildExplicitSddReleasePlan(scope.targets, {
+      files: scope.changedFiles || [],
+      commands: [command],
+      changeId: scope.changeId,
+      actualCommands: true,
+    }),
+    flags,
+    command
+  );
+}
+
+function stagedAppReleaseProtocolVersion(stagedResources) {
+  const hasBackendReleaseV2 = (stagedResources || []).some(
+    resource =>
+      resource.kind === 'BackendRelease' &&
+      String(
+        resource.metadata?.protocolVersion ||
+          resource.revision?.protocolVersion ||
+          ''
+      ) === APP_FUNCTION_SECRET_CAPABILITIES.backendRelease
+  );
+  return hasBackendReleaseV2
+    ? APP_FUNCTION_SECRET_CAPABILITIES.atomicActivation
+    : null;
+}
+
 function overlayAppReleaseResources(capturedResources, stagedResources) {
   if (!Array.isArray(capturedResources)) {
     fail('APP_RELEASE_CAPTURE_INVALID: capture.resources 必须是数组');
@@ -1614,6 +1917,9 @@ async function prepareAppReleaseFromCapture(
     {
       method: 'POST',
       body: appReleaseWriteBody(releaseContext, {
+        ...(flags.__appReleaseProtocolVersion
+          ? { protocolVersion: flags.__appReleaseProtocolVersion }
+          : {}),
         parentReleaseId: capture.parentReleaseId || null,
         resources: clonePlainJson(capture.resources),
         ...(expectedManifestHash ? { expectedManifestHash } : {}),
@@ -1627,7 +1933,8 @@ async function verifyAppReleaseDetail(
   target,
   releaseContext,
   detail,
-  resources
+  resources,
+  options = {}
 ) {
   if (!detail?.id || !/^[a-f0-9]{64}$/i.test(String(detail.manifestHash || ''))) {
     fail('APP_RELEASE_MANIFEST_INVALID: App Release 缺少 id 或 manifestHash');
@@ -1642,6 +1949,9 @@ async function verifyAppReleaseDetail(
     {
       method: 'POST',
       body: appReleaseWriteBody(releaseContext, {
+        ...(options.protocolVersion
+          ? { protocolVersion: options.protocolVersion }
+          : {}),
         manifestHash: detail.manifestHash,
         resources: clonePlainJson(resources),
       }),
@@ -1667,9 +1977,12 @@ async function activateAppReleaseDetail(
       method: 'POST',
       body: appReleaseWriteBody(
         releaseContext,
-        options.activateStagedChildren === true
-          ? { activateStagedChildren: true }
-          : {}
+        stripUndefinedValues({
+          ...(options.activateStagedChildren === true
+            ? { activateStagedChildren: true }
+            : {}),
+          protocolVersion: options.protocolVersion,
+        })
       ),
     }
   );
@@ -1723,6 +2036,15 @@ async function runAppReleaseCommand(
     );
   } else if (subcommand === 'app-prepare') {
     const stagedResources = readStagedAppReleaseResources(flags);
+    if (stagedResources) {
+      assertStagedAppReleaseScope(target, flags, stagedResources);
+    }
+    const protocolVersion = stagedAppReleaseProtocolVersion(stagedResources);
+    if (protocolVersion) {
+      assertAppFunctionSecretCapabilities(
+        await fetchAppFunctionSecretCapabilities(config, target)
+      );
+    }
     const releaseContext = await ensureAppReleasePublishContext(
       config,
       target,
@@ -1739,34 +2061,78 @@ async function runAppReleaseCommand(
       target,
       releaseContext,
       { ...capture, resources },
-      flags
+      {
+        ...flags,
+        __appReleaseProtocolVersion: protocolVersion,
+      }
     );
   } else if (subcommand === 'app-verify') {
     if (!releaseId) {
       fail('用法: openxiangda release app-verify <releaseId> --change <id>');
     }
+    const detail = await requestWithAuth(
+      config,
+      target.profileName,
+      appReleaseApiPath(target, `/${encodeURIComponent(releaseId)}`)
+    );
+    const detailResources = appReleaseManifestResources(detail);
+    const capture = await fetchAppReleaseCapture(config, target, flags);
+    const changedResources = changedAppReleaseResources(
+      detailResources,
+      capture.resources
+    );
+    if (changedResources.length > 0) {
+      assertStagedAppReleaseScope(target, flags, changedResources);
+    }
+    const protocolVersion = String(detail?.protocolVersion || '');
+    if (protocolVersion === APP_FUNCTION_SECRET_CAPABILITIES.atomicActivation) {
+      assertAppFunctionSecretCapabilities(
+        await fetchAppFunctionSecretCapabilities(config, target)
+      );
+    }
     const releaseContext = await ensureAppReleasePublishContext(
       config,
       target,
       flags,
       'App Release verify'
     );
-    const detail = await requestWithAuth(
-      config,
-      target.profileName,
-      appReleaseApiPath(target, `/${encodeURIComponent(releaseId)}`)
-    );
     data = await verifyAppReleaseDetail(
       config,
       target,
       releaseContext,
       detail,
-      appReleaseManifestResources(detail)
+      detailResources,
+      { protocolVersion: protocolVersion || undefined }
     );
   } else if (subcommand === 'app-activate') {
     if (!releaseId) {
       fail('用法: openxiangda release app-activate <releaseId> --change <id>');
     }
+    const detail = await requestWithAuth(
+      config,
+      target.profileName,
+      appReleaseApiPath(target, `/${encodeURIComponent(releaseId)}`)
+    );
+    const protocolVersion = String(detail?.protocolVersion || '');
+    const atomicV2 =
+      protocolVersion === APP_FUNCTION_SECRET_CAPABILITIES.atomicActivation;
+    const activatesStagedChildren =
+      atomicV2 ||
+      flags['activate-staged-children'] === true ||
+      String(flags['activate-staged-children'] || '').toLowerCase() === 'true';
+    if (activatesStagedChildren) {
+      const capture = await fetchAppReleaseCapture(config, target, flags);
+      const changedResources = changedAppReleaseResources(
+        appReleaseManifestResources(detail),
+        capture.resources
+      );
+      assertStagedAppReleaseScope(target, flags, changedResources);
+    }
+    if (atomicV2) {
+      assertAppFunctionSecretCapabilities(
+        await fetchAppFunctionSecretCapabilities(config, target)
+      );
+    }
     const releaseContext = await ensureAppReleasePublishContext(
       config,
       target,
@@ -1780,13 +2146,36 @@ async function runAppReleaseCommand(
       releaseId,
       {
         activateStagedChildren:
-          flags['activate-staged-children'] === true ||
-          String(flags['activate-staged-children'] || '').toLowerCase() ===
-            'true',
+          activatesStagedChildren,
+        protocolVersion: protocolVersion || undefined,
       }
     );
   } else if (subcommand === 'app-finalize') {
     const stagedResources = readStagedAppReleaseResources(flags);
+    let stagedScope = null;
+    if (stagedResources) {
+      stagedScope = assertStagedAppReleaseScope(
+        target,
+        flags,
+        stagedResources
+      );
+      if (stagedScope.scope) {
+        assertAppReleaseActualGate(
+          target,
+          flags,
+          stagedScope.scope,
+          `openxiangda release app-finalize --staged-resources-json ${String(
+            flags['staged-resources-json']
+          )} --profile ${target.profileName} --change ${stagedScope.changeId}`
+        );
+      }
+    }
+    const protocolVersion = stagedAppReleaseProtocolVersion(stagedResources);
+    if (protocolVersion) {
+      assertAppFunctionSecretCapabilities(
+        await fetchAppFunctionSecretCapabilities(config, target)
+      );
+    }
     const releaseContext = await ensureAppReleasePublishContext(
       config,
       target,
@@ -1803,37 +2192,56 @@ async function runAppReleaseCommand(
       sourceRepositoryId: releaseContext.sourceRepositoryId,
       sourceRevision: releaseContext.sourceRevision,
       resources: frozenResources,
+      ...(protocolVersion ? { protocolVersion } : {}),
     });
     const prepared = await prepareAppReleaseFromCapture(
       config,
       target,
       releaseContext,
       { ...capture, resources: frozenResources },
-      flags
+      {
+        ...flags,
+        __appReleaseProtocolVersion: protocolVersion,
+      }
     );
     const verified = await verifyAppReleaseDetail(
       config,
       target,
       releaseContext,
       prepared,
-      frozenResources
+      frozenResources,
+      { protocolVersion }
     );
     const activated = await activateAppReleaseDetail(
       config,
       target,
       releaseContext,
       verified?.id || prepared.id,
-      { activateStagedChildren: Boolean(stagedResources) }
+      {
+        activateStagedChildren: Boolean(stagedResources),
+        protocolVersion,
+      }
     );
+    let stateReconcileWarning = null;
+    try {
+      const appHead = await loadRuntimeHeadApp(config, target);
+      saveRuntimeHeadState(target, appHead);
+    } catch (error) {
+      stateReconcileWarning = {
+        component: 'RuntimeStateReadback',
+        message: error?.message || String(error),
+      };
+    }
     data = {
       activationModel: stagedResources
-        ? 'atomic_staged_children_v1'
+        ? protocolVersion || 'atomic_staged_children_v1'
         : 'retrospective_active_children',
       captureHash: capture.captureHash,
       payloadHash,
       prepared,
       verified,
       activated,
+      ...(stateReconcileWarning ? { stateReconcileWarning } : {}),
     };
   } else if (subcommand === 'app-rollback') {
     if (!releaseId) {
@@ -3873,7 +4281,19 @@ async function workspace(args) {
     if (publishOptions.dryRun) {
       printWorkspaceReleasePlan(sddPlan);
     } else {
-      assertSddReleaseGate(sddPlan, flags, 'openxiangda workspace publish');
+      const actualSddPlan = buildExplicitSddReleasePlan(sddPlan.targets, {
+        files: sddPlan.changedFiles || [],
+        commands: [
+          buildWorkspacePublishCommand(flags, profileName),
+        ],
+        changeId: publishOptions.changeId,
+        actualCommands: true,
+      });
+      assertSddReleaseGate(
+        actualSddPlan,
+        flags,
+        'openxiangda workspace publish'
+      );
     }
     await requestWithAuth(
       config,
@@ -6042,9 +6462,17 @@ async function appFunction(args) {
   const { subcommand, rest } = parseSubcommandArgs(args);
   const { flags, positional } = parseArgs(rest);
   if (wantsSubcommandHelp(subcommand, flags)) {
-    print('用法: openxiangda function list|get|create|update|upsert|delete|invoke [functionCode] [--json-file file]');
+    print([
+      '用法: openxiangda function list|get|create|update|upsert|delete|invoke [functionCode] [--json-file file]',
+      '      openxiangda function test <functionCode> [--input-json JSON|file] [--secret-from-env logical=ENV] [--json]',
+      '说明: function test 只把父进程环境变量中的值通过 stdin 交给隔离测试子进程；不会写入 workspace/cache/state。',
+    ].join('\n'));
     return;
   }
+  if (subcommand === 'test') {
+    return await testAppFunctionLocally(positional, flags);
+  }
+
   const config = loadConfig();
   const target = getWorkspaceTarget(config, flags.profile || config.currentProfile, flags);
 
@@ -6093,6 +6521,11 @@ async function appFunction(args) {
     basePath: `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/functions`,
     manifestDir: path.join('src', 'resources', 'functions'),
     prepareBody: async body => {
+      if (functionManifestDeclaresSecretRefs(body)) {
+        fail(
+          'APP_FUNCTION_SECRET_STAGED_RELEASE_REQUIRED: 带 secretRefs 的 Function 必须使用 resource publish + Backend Release v2，禁止 direct CRUD 绕过原子绑定'
+        );
+      }
       const definitionJson = await resolveManifestJson(
         config,
         target.profileName,
@@ -6100,6 +6533,11 @@ async function appFunction(args) {
         'definitionJson',
         'definitionFile'
       );
+      if (definitionJson?.secretRefs !== undefined) {
+        fail(
+          'APP_FUNCTION_SECRET_STAGED_RELEASE_REQUIRED: secretRefs 必须位于 Function manifest 顶层并通过 Backend Release v2 发布，禁止写入 definitionJson 或 direct CRUD'
+        );
+      }
       applyResourceBindingsToRuntimeDefinition(target.bound, body, definitionJson);
       const code = body.code || body.functionCode || body.resourceCode;
       return stripUndefinedValues({
@@ -6120,67 +6558,1042 @@ async function appFunction(args) {
   });
 }
 
-async function connector(args) {
-  const { subcommand, rest } = parseSubcommandArgs(args);
-  const { flags, positional } = parseArgs(rest);
-  if (wantsSubcommandHelp(subcommand, flags)) {
-    print('用法: openxiangda connector list|get|create|update|upsert|delete|invoke|download-test [connectorCode[.apiCode]] [--json-file file]');
-    return;
-  }
-  const config = loadConfig();
-  const target = getWorkspaceTarget(config, flags.profile || config.currentProfile, flags);
-
-  if (subcommand === 'invoke' || subcommand === 'download-test') {
-    const targetName = positional[0] || flags.connector;
-    if (!targetName) fail(`用法: openxiangda connector ${subcommand} <connectorCode.apiCode> [--body-json file|json]`);
-    const parsed = parseConnectorApiName(targetName, flags);
-    const body = {
-      connector: parsed.connector,
-      api: parsed.api,
-      ...readDirectJsonBody(flags, 'connector invoke', { optional: true }),
-      ...(flags['path-params-json'] ? { pathParams: readJsonArg(flags['path-params-json'], 'path-params-json') } : {}),
-      ...(flags['query-json'] ? { query: readJsonArg(flags['query-json'], 'query-json') } : {}),
-      ...(flags['headers-json'] ? { headers: readJsonArg(flags['headers-json'], 'headers-json') } : {}),
-      ...(flags['request-body-type'] ? { requestBodyType: flags['request-body-type'] } : {}),
-      ...(flags['response-type'] ? { responseType: flags['response-type'] } : {}),
-    };
-    if (subcommand === 'download-test') body.responseType = 'binary';
-    return runDirectRequest(config, target, flags, {
-      method: 'POST',
-      path: `/${encodeURIComponent(target.appType)}/v1/connectors/actions/${subcommand === 'download-test' ? 'download' : 'invoke'}`,
-      body,
-      strictEnvelope: subcommand !== 'download-test',
-    }, { controlPlaneMutation: false });
-  }
+function appSecretApiPath(target, suffix = '') {
+  return `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/secrets${suffix}`;
+}
 
-  return directResourceCrud(config, target, {
-    commandName: 'connector',
-    subcommand,
-    flags,
-    positional,
-    resourceType: 'connector',
-    basePath: `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/connectors`,
-    manifestDir: path.join('src', 'resources', 'connectors'),
-    createMethod: 'POST',
-    createPath: `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/connectors/actions/sync`,
-    createBody: body => ({ connectors: [normalizeConnectorManifest(body)] }),
-    updateMethod: 'POST',
-    updatePath: `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/connectors/actions/sync`,
-    updateBody: body => ({ connectors: [normalizeConnectorManifest(body)] }),
-    normalizeBody: body => normalizeConnectorManifest(body),
-    codeOf: body => body.code || body.methodName,
-    responseData: data => Array.isArray(data?.data) ? data.data[0] : data,
-    saveState: (code, data) => saveConnectorResource(target, code, data?.connector?.id || data?.id, {
-      apis: Object.fromEntries(
-        (data?.apis || []).map(api => [api.code || api.methodName, { apiId: api.id, name: api.name }])
-      ),
-    }),
-  });
+function manifestUsesAppFunctionSecrets(manifest) {
+  return (manifest?.functions || []).some(
+    item => functionManifestDeclaresSecretRefs(item)
+  );
 }
 
-async function notification(args) {
-  const { subcommand, rest } = parseSubcommandArgs(args);
-  const { flags, positional } = parseArgs(rest);
+function collectCapabilityNames(value) {
+  const names = new Set();
+  const visit = item => {
+    if (!item) return;
+    if (typeof item === 'string') {
+      names.add(item.trim().toLowerCase());
+      return;
+    }
+    if (Array.isArray(item)) {
+      item.forEach(visit);
+      return;
+    }
+    if (typeof item === 'object') {
+      for (const [key, enabled] of Object.entries(item)) {
+        if (enabled === true) names.add(String(key).trim().toLowerCase());
+      }
+    }
+  };
+  visit(value?.capabilities);
+  visit(value?.features);
+  visit(value?.contracts);
+  return names;
+}
+
+function appFunctionSecretCapabilityEnabled(capabilities, name) {
+  const normalized = String(name || '').toLowerCase();
+  const camel = normalized.replace(/_([a-z])/g, (_match, char) => char.toUpperCase());
+  return (
+    capabilities?.[normalized] === true ||
+    capabilities?.[camel] === true ||
+    capabilities?.capabilities?.[normalized] === true ||
+    capabilities?.features?.[normalized] === true ||
+    collectCapabilityNames(capabilities).has(normalized)
+  );
+}
+
+async function fetchAppFunctionSecretCapabilities(config, target) {
+  return await requestWithAuth(
+    config,
+    target.profileName,
+    appSecretApiPath(target, '/capabilities')
+  );
+}
+
+function assertAppFunctionSecretCapabilities(capabilities) {
+  const managementReady =
+    capabilities?.enabled === true &&
+    String(capabilities?.contractVersion || '') ===
+      APP_FUNCTION_SECRET_CAPABILITIES.contractVersion &&
+    String(capabilities?.runtimeContractVersion || '') ===
+      APP_FUNCTION_SECRET_CAPABILITIES.runtimeContractVersion;
+  const missing = [];
+  if (!managementReady) missing.push('app_function_secrets_v1/trusted_node_v2');
+  for (const feature of [
+    'app_function_secrets_v1',
+    'trusted_node_v2',
+    APP_FUNCTION_SECRET_CAPABILITIES.backendRelease,
+    APP_FUNCTION_SECRET_CAPABILITIES.atomicActivation,
+  ]) {
+    if (!appFunctionSecretCapabilityEnabled(capabilities, feature)) {
+      missing.push(feature);
+    }
+  }
+  if (missing.length > 0) {
+    const error = new Error(
+      `APP_FUNCTION_SECRET_CAPABILITY_REQUIRED: 平台尚未完整启用 ${unique(missing).join(', ')}；禁止忽略 secretRefs 或降级发布`
+    );
+    error.code = 'APP_FUNCTION_SECRET_CAPABILITY_REQUIRED';
+    error.missingCapabilities = unique(missing);
+    throw error;
+  }
+  return capabilities;
+}
+
+async function assertManifestAppFunctionSecretCapabilities(
+  config,
+  target,
+  manifest
+) {
+  if (!manifestUsesAppFunctionSecrets(manifest)) return null;
+  try {
+    return assertAppFunctionSecretCapabilities(
+      await fetchAppFunctionSecretCapabilities(config, target)
+    );
+  } catch (error) {
+    if (isHttpNotFound(error)) {
+      const missing = new Error(
+        'APP_FUNCTION_SECRET_CAPABILITY_REQUIRED: 当前平台没有 App Function Secret capability endpoint；禁止忽略 secretRefs 或按旧 Function 协议发布'
+      );
+      missing.code = 'APP_FUNCTION_SECRET_CAPABILITY_REQUIRED';
+      throw missing;
+    }
+    throw error;
+  }
+}
+
+const SECRET_RESPONSE_FORBIDDEN_KEYS = new Set([
+  'value',
+  'secretvalue',
+  'plaintext',
+  'ciphertext',
+  'cipher',
+  'encryptedvalue',
+  'encrypteddek',
+  'wrappeddek',
+  'valuehash',
+  'cipherhash',
+  'valuedigest',
+  'cipherdigest',
+  'valuelength',
+  'cipherlength',
+  'plaintextlength',
+  'iv',
+  'nonce',
+  'authtag',
+  'tag',
+]);
+
+function assertSecretMetadataOnly(value, pathParts = []) {
+  if (!value || typeof value !== 'object') return;
+  if (Array.isArray(value)) {
+    value.forEach((item, index) =>
+      assertSecretMetadataOnly(item, [...pathParts, String(index)])
+    );
+    return;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    const normalizedKey = key.replace(/[_-]/g, '').toLowerCase();
+    if (SECRET_RESPONSE_FORBIDDEN_KEYS.has(normalizedKey)) {
+      const error = new Error(
+        `APP_SECRET_RESPONSE_CONTRACT_VIOLATION: Secret API 返回了禁止的明文/密文派生字段 ${[...pathParts, key].join('.')}`
+      );
+      error.code = 'APP_SECRET_RESPONSE_CONTRACT_VIOLATION';
+      throw error;
+    }
+    assertSecretMetadataOnly(child, [...pathParts, key]);
+  }
+}
+
+function outputSecretMetadataOnly(value, flags = {}) {
+  assertSecretMetadataOnly(value);
+  if (flags.json) return writeJson(value);
+  print(JSON.stringify(value, null, 2));
+}
+
+function requireExplicitProfile(flags, label) {
+  const profile = String(flags.profile || '').trim();
+  if (!profile) fail(`${label} 必须显式提供 --profile <name>`);
+  return profile;
+}
+
+function resolveExactSecretName(positional, flags, label) {
+  const selectors = [
+    ...(positional || []),
+    ...splitList(flags.only),
+    ...splitList(flags.code),
+  ]
+    .map(value => String(value || '').trim())
+    .filter(Boolean);
+  const names = unique(selectors);
+  if (names.length !== 1) {
+    fail(`${label} 必须通过位置参数、--only 或 --code 精确选择一个 Secret name`);
+  }
+  if (!/^[A-Za-z][A-Za-z0-9_.-]{0,127}$/.test(names[0])) {
+    fail(`${label}: Secret name 只能包含字母、数字、点、下划线和中划线，并以字母开头`);
+  }
+  return names[0];
+}
+
+function rejectUnsafeSecretValueFlags(flags) {
+  const forbidden = [
+    'value',
+    'value-file',
+    'secret',
+    'secret-file',
+    'json-file',
+    'body-json',
+  ].filter(key => flags[key] !== undefined);
+  if (forbidden.length > 0) {
+    fail(
+      `Secret 明文禁止出现在命令行或文件参数中: ${forbidden
+        .map(key => `--${key}`)
+        .join(', ')}；请使用隐藏 TTY 输入或 --value-stdin`
+    );
+  }
+}
+
+function readSecretValueFromStdin() {
+  const input = fs.readFileSync(0, 'utf8');
+  return input.replace(/\r?\n$/, '');
+}
+
+async function readHiddenSecretValue(promptText = 'Secret value: ') {
+  if (!process.stdin.isTTY || !process.stderr.isTTY) {
+    fail('非交互环境必须使用 --value-stdin；不会从参数或 workspace 文件读取 Secret');
+  }
+  return await new Promise((resolve, reject) => {
+    const input = process.stdin;
+    const previousRaw = Boolean(input.isRaw);
+    let value = '';
+    const cleanup = () => {
+      input.off('data', onData);
+      try {
+        input.setRawMode(previousRaw);
+      } catch {
+        // The TTY may have closed while handling Ctrl-C.
+      }
+      input.pause();
+    };
+    const onData = chunk => {
+      const textValue = String(chunk);
+      for (const char of textValue) {
+        if (char === '\u0003') {
+          cleanup();
+          process.stderr.write('\n');
+          reject(new Error('Secret 输入已取消'));
+          return;
+        }
+        if (char === '\r' || char === '\n') {
+          cleanup();
+          process.stderr.write('\n');
+          resolve(value);
+          return;
+        }
+        if (char === '\u007f' || char === '\b') {
+          value = value.slice(0, -1);
+          continue;
+        }
+        value += char;
+      }
+    };
+    process.stderr.write(promptText);
+    input.setEncoding('utf8');
+    input.setRawMode(true);
+    input.resume();
+    input.on('data', onData);
+  });
+}
+
+async function readSecretValue(flags, label) {
+  rejectUnsafeSecretValueFlags(flags);
+  const value = flags['value-stdin']
+    ? readSecretValueFromStdin()
+    : await readHiddenSecretValue(`${label} value: `);
+  if (!value) fail(`${label}: Secret value 不能为空`);
+  if (Buffer.byteLength(value, 'utf8') > 64 * 1024) {
+    fail(`${label}: Secret value 不能超过 64 KiB`);
+  }
+  registerSensitiveText(value);
+  return value;
+}
+
+function readSecretExpectedRevision(flags, label, options = {}) {
+  const raw = readStringFlag(flags, 'expected-revision');
+  if (options.create && (raw === '' || raw === undefined)) return 0;
+  if (raw === '' || raw === undefined || !/^\d+$/.test(String(raw))) {
+    fail(`${label} 必须提供 --expected-revision <非负整数>`);
+  }
+  const revision = Number(raw);
+  if (!Number.isSafeInteger(revision) || revision < 0) {
+    fail(`${label}: --expected-revision 必须是非负安全整数`);
+  }
+  if (options.create && revision !== 0) {
+    fail(`${label}: create 的 --expected-revision 必须是 0`);
+  }
+  return revision;
+}
+
+function secretMutationControl(context) {
+  return {
+    publishLeaseId: context.publishLeaseId,
+    baselineId: context.changeBaselineId,
+    changeId: context.changeId,
+    clientSessionId: context.clientSessionId,
+  };
+}
+
+function secretClientOperationId(
+  target,
+  control,
+  name,
+  action,
+  expectedRevision,
+  flags = {}
+) {
+  const explicit = String(
+    flags['client-operation-id'] || flags['idempotency-key'] || ''
+  ).trim();
+  if (explicit) return explicit;
+  return `openxiangda-secret-${canonicalJsonSha256({
+    profile: target.profileName,
+    appType: target.appType,
+    name,
+    action,
+    changeId: control.changeId,
+    clientSessionId: control.clientSessionId,
+    expectedRevision,
+  })}`;
+}
+
+async function buildSecretDryRun(config, target, subcommand, name, flags) {
+  return await withReadOnlyHttpGuard('secret --dry-run', async () => {
+    const capabilities = assertAppFunctionSecretCapabilities(
+      await fetchAppFunctionSecretCapabilities(config, target)
+    );
+    const current = name
+      ? await requestOptionalWithAuth(
+          config,
+          target.profileName,
+          appSecretApiPath(target, `/${encodeURIComponent(name)}`)
+        )
+      : null;
+    const result = {
+      dryRun: true,
+      command: `secret ${subcommand}`,
+      profile: target.profileName,
+      appType: target.appType,
+      name,
+      changeId: readStringFlag(flags, 'change'),
+      expectedRevision:
+        subcommand === 'create'
+          ? readSecretExpectedRevision(flags, 'secret create', { create: true })
+          : readSecretExpectedRevision(flags, `secret ${subcommand}`),
+      current,
+      valueRead: false,
+      writes: 0,
+      capabilities: {
+        contractVersion: capabilities.contractVersion,
+        runtimeContractVersion: capabilities.runtimeContractVersion,
+        backend_release_v2: true,
+        atomic_staged_children_v2: true,
+      },
+    };
+    assertSecretMetadataOnly(result);
+    return result;
+  });
+}
+
+async function appSecret(args) {
+  const { subcommand, rest } = parseSubcommandArgs(args);
+  const { flags, positional } = parseArgs(rest);
+  if (wantsSubcommandHelp(subcommand, flags)) {
+    print([
+      '用法: openxiangda secret list|unused --profile <name> [--json]',
+      '      openxiangda secret metadata|references|audit <name> --profile <name> [--json]',
+      '      openxiangda secret create <name> --profile <name> --change <id> [--value-stdin] [--description text] [--expires-at ISO] [--dry-run]',
+      '      openxiangda secret update <name> --profile <name> --change <id> --expected-revision <n> [--description text] [--status active|disabled] [--expires-at ISO] [--dry-run]',
+      '      openxiangda secret rotate <name> --profile <name> --change <id> --expected-revision <n> [--value-stdin] [--reason text] [--dry-run]',
+      '      openxiangda secret delete <name> --profile <name> --change <id> --expected-revision <n> --reason text [--dry-run]',
+      'Secret 明文只接受隐藏 TTY 或 stdin；禁止 --value、文件、workspace/state 和明文回读。',
+    ].join('\n'));
+    return;
+  }
+
+  const profileName = requireExplicitProfile(flags, `secret ${subcommand || ''}`);
+  const config = loadConfig();
+  const target = getWorkspaceTarget(config, profileName, flags);
+  const readOnlyCommands = new Set([
+    'list',
+    'metadata',
+    'get',
+    'references',
+    'audit',
+    'unused',
+  ]);
+  if (readOnlyCommands.has(subcommand)) {
+    assertAppFunctionSecretCapabilities(
+      await fetchAppFunctionSecretCapabilities(config, target)
+    );
+    let pathSuffix = '';
+    if (subcommand === 'unused') pathSuffix = '/unused';
+    else if (subcommand !== 'list') {
+      const name = resolveExactSecretName(positional, flags, `secret ${subcommand}`);
+      pathSuffix = `/${encodeURIComponent(name)}`;
+      if (subcommand === 'references' || subcommand === 'audit') {
+        pathSuffix += `/${subcommand}`;
+      }
+    }
+    const data = await requestWithAuth(
+      config,
+      target.profileName,
+      appSecretApiPath(target, pathSuffix)
+    );
+    return outputSecretMetadataOnly(data, flags);
+  }
+
+  if (!['create', 'update', 'rotate', 'delete'].includes(subcommand)) {
+    fail('用法: openxiangda secret list|metadata|references|audit|unused|create|update|rotate|delete');
+  }
+  requireExplicitProfile(flags, `secret ${subcommand}`);
+  const changeId = String(readStringFlag(flags, 'change') || '').trim();
+  if (!changeId) fail(`secret ${subcommand} 必须提供 --change <id>`);
+  const name = resolveExactSecretName(positional, flags, `secret ${subcommand}`);
+  rejectUnsafeSecretValueFlags(flags);
+  if (flags['dry-run']) {
+    const result = await buildSecretDryRun(
+      config,
+      target,
+      subcommand,
+      name,
+      flags
+    );
+    return outputSecretMetadataOnly(result, flags);
+  }
+
+  assertAppFunctionSecretCapabilities(
+    await fetchAppFunctionSecretCapabilities(config, target)
+  );
+  const context = await ensureDirectMutationPublishContext(
+    config,
+    target,
+    flags,
+    `secret ${subcommand}`
+  );
+  const control = secretMutationControl(context);
+  try {
+  let method;
+  let pathSuffix;
+  let body;
+  if (subcommand === 'create') {
+    const expectedRevision = readSecretExpectedRevision(
+      flags,
+      'secret create',
+      { create: true }
+    );
+    const value = await readSecretValue(flags, 'secret create');
+    method = 'POST';
+    pathSuffix = '';
+    body = stripUndefinedValues({
+      ...control,
+      name,
+      value,
+      description: flags.description,
+      expiresAt: flags['expires-at'],
+      expectedRevision,
+      idempotencyKey: secretClientOperationId(
+        target,
+        control,
+        name,
+        'create',
+        expectedRevision,
+        flags
+      ),
+    });
+  } else if (subcommand === 'update') {
+    method = 'PATCH';
+    pathSuffix = `/${encodeURIComponent(name)}`;
+    body = stripUndefinedValues({
+      ...control,
+      description: flags.description,
+      status: flags.status,
+      expiresAt: flags['expires-at'],
+      expectedRevision: readSecretExpectedRevision(flags, 'secret update'),
+    });
+    if (
+      body.description === undefined &&
+      body.status === undefined &&
+      body.expiresAt === undefined
+    ) {
+      fail('secret update 至少需要 --description、--status 或 --expires-at');
+    }
+  } else if (subcommand === 'rotate') {
+    const expectedRevision = readSecretExpectedRevision(
+      flags,
+      'secret rotate'
+    );
+    const value = await readSecretValue(flags, 'secret rotate');
+    method = 'POST';
+    pathSuffix = `/${encodeURIComponent(name)}/rotate`;
+    body = stripUndefinedValues({
+      ...control,
+      value,
+      expectedRevision,
+      idempotencyKey: secretClientOperationId(
+        target,
+        control,
+        name,
+        'rotate',
+        expectedRevision,
+        flags
+      ),
+      reason: flags.reason,
+    });
+  } else {
+    const reason = String(flags.reason || '').trim();
+    if (reason.length < 8) {
+      fail('secret delete 必须提供至少 8 个字符的 --reason');
+    }
+    method = 'POST';
+    pathSuffix = `/${encodeURIComponent(name)}/delete`;
+    body = {
+      ...control,
+      expectedRevision: readSecretExpectedRevision(flags, 'secret delete'),
+      reason,
+    };
+  }
+  const data = await requestWithAuth(
+    config,
+    target.profileName,
+    appSecretApiPath(target, pathSuffix),
+    { method, body }
+  );
+  return outputSecretMetadataOnly(data, flags);
+  } catch (error) {
+    const safeMessage = maskText(error?.message || String(error));
+    if (error && typeof error === 'object') {
+      error.message = safeMessage;
+      if (typeof error.stack === 'string') error.stack = maskText(error.stack);
+      throw error;
+    }
+    throw new Error(safeMessage);
+  } finally {
+    clearSensitiveText();
+  }
+}
+
+function parseFunctionTestSecretMappings(flags, declaredRefs) {
+  const raw = flags['secret-from-env'];
+  const declared = new Map(declaredRefs.map(ref => [ref.name, ref]));
+  const mappings = new Map();
+  for (const entry of splitList(raw)) {
+    const separator = entry.indexOf('=');
+    const name = separator > 0 ? entry.slice(0, separator).trim() : '';
+    const envName = separator > 0 ? entry.slice(separator + 1).trim() : '';
+    if (!name || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(envName)) {
+      fail(
+        `function test --secret-from-env 格式必须为 logical=ENV_NAME: ${entry}`
+      );
+    }
+    if (!declared.has(name)) {
+      const error = new Error(
+        `FUNCTION_SECRET_REF_UNDECLARED: Function manifest 未声明 secretRef ${name}`
+      );
+      error.code = 'FUNCTION_SECRET_REF_UNDECLARED';
+      throw error;
+    }
+    if (mappings.has(name)) {
+      fail(`function test 重复声明 --secret-from-env ${name}`);
+    }
+    mappings.set(name, envName);
+  }
+  for (const ref of declaredRefs) {
+    const envName = mappings.get(ref.name);
+    if (!envName) {
+      if (ref.required) {
+        const error = new Error(
+          `FUNCTION_SECRET_NOT_CONFIGURED: required secretRef ${ref.name} 缺少 --secret-from-env ${ref.name}=ENV_NAME`
+        );
+        error.code = 'FUNCTION_SECRET_NOT_CONFIGURED';
+        throw error;
+      }
+      continue;
+    }
+  }
+  return mappings;
+}
+
+function readFunctionTestSecretsFromEnv(mappings, declaredRefs) {
+  const secrets = {};
+  for (const ref of declaredRefs) {
+    const envName = mappings.get(ref.name);
+    if (!envName) continue;
+    if (!Object.prototype.hasOwnProperty.call(process.env, envName)) {
+      const error = new Error(
+        `FUNCTION_SECRET_NOT_CONFIGURED: 测试父进程未设置环境变量 ${envName}（secretRef ${ref.name}）`
+      );
+      error.code = 'FUNCTION_SECRET_NOT_CONFIGURED';
+      throw error;
+    }
+    secrets[ref.name] = String(process.env[envName]);
+  }
+  return secrets;
+}
+
+function resolveFunctionTestSource(functionItem, functionCode) {
+  const definition = resolveManifestPlainJson(
+    functionItem,
+    'definitionJson',
+    'definitionFile'
+  );
+  const localPath = definition?.sourceFile?.localPath;
+  if (!localPath) {
+    fail(`Function:${functionCode} 缺少 definitionJson.sourceFile.localPath`);
+  }
+  const fromManifest = path.resolve(functionItem.__dir || process.cwd(), localPath);
+  const fromWorkspace = path.resolve(process.cwd(), localPath);
+  const sourcePath = fs.existsSync(fromManifest) ? fromManifest : fromWorkspace;
+  if (!fs.existsSync(sourcePath)) {
+    fail(`Function:${functionCode} sourceFile 不存在: ${localPath}`);
+  }
+  return { definition, sourcePath };
+}
+
+function isolatedAppFunctionTestBuildRunner() {
+  const { builtinModules } = require('module');
+  const fs = require('fs');
+  const path = require('path');
+  const esbuild = require(process.argv[1]);
+  const sourcePath = process.argv[2];
+  const outfile = process.argv[3];
+  const workspaceRoot = process.argv[4];
+  const resolveWorkspaceAlias = importPath => {
+    const raw = path.join(workspaceRoot, 'src', importPath.replace(/^@\//, ''));
+    const candidates = [
+      raw,
+      `${raw}.ts`,
+      `${raw}.tsx`,
+      `${raw}.js`,
+      `${raw}.mjs`,
+      `${raw}.cjs`,
+      path.join(raw, 'index.ts'),
+      path.join(raw, 'index.tsx'),
+      path.join(raw, 'index.js'),
+    ];
+    return candidates.find(candidate => fs.existsSync(candidate)) || raw;
+  };
+  const external = Array.from(
+    new Set([...builtinModules, ...builtinModules.map(name => `node:${name}`)])
+  );
+  esbuild
+    .build({
+      entryPoints: [sourcePath],
+      outfile,
+      bundle: true,
+      platform: 'node',
+      format: 'cjs',
+      target: ['node20'],
+      sourcemap: false,
+      logLevel: 'silent',
+      external,
+      plugins: [
+        {
+          name: 'openxiangda-function-test-workspace-alias',
+          setup(build) {
+            build.onResolve({ filter: /^@\// }, args => ({
+              path: resolveWorkspaceAlias(args.path),
+            }));
+          },
+        },
+      ],
+    })
+    .catch(error => {
+      process.stderr.write(String(error?.message || error));
+      process.exitCode = 1;
+    });
+}
+
+async function buildIsolatedFunctionTestBundle(
+  sourcePath,
+  workspaceRoot,
+  functionCode,
+  tempRoot
+) {
+  const outfile = path.join(tempRoot, 'bundle', `${functionCode}.cjs`);
+  fs.mkdirSync(path.dirname(outfile), { recursive: true });
+  const build = spawnSync(
+    process.execPath,
+    [
+      '-e',
+      `(${isolatedAppFunctionTestBuildRunner.toString()})()`,
+      require.resolve('esbuild'),
+      sourcePath,
+      outfile,
+      workspaceRoot,
+    ],
+    {
+      cwd: tempRoot,
+      env: stripUndefinedValues({
+        PATH: process.env.PATH,
+        NODE_ENV: 'test-build',
+        HOME: tempRoot,
+        USERPROFILE: tempRoot,
+        TMPDIR: tempRoot,
+      }),
+      encoding: 'utf8',
+      maxBuffer: 8 * 1024 * 1024,
+      timeout: 30000,
+      killSignal: 'SIGKILL',
+    }
+  );
+  if (build.error || build.status !== 0 || !fs.existsSync(outfile)) {
+    fail(
+      `App Function 隔离测试构建失败: ${functionCode}: ${
+        build.error?.message || build.stderr || build.stdout || 'unknown error'
+      }`
+    );
+  }
+  return outfile;
+}
+
+function isolatedAppFunctionTestRunner() {
+  const fs = require('fs');
+  const payload = JSON.parse(fs.readFileSync(0, 'utf8'));
+  const secretValues = Object.values(payload.secrets || {}).map(String);
+  const secretVariants = Array.from(
+    new Set(
+      secretValues.flatMap(secret => {
+        const bytes = Buffer.from(secret, 'utf8');
+        const jsonEscaped = JSON.stringify(secret).slice(1, -1);
+        const base64 = bytes.toString('base64');
+        return [
+          secret,
+          jsonEscaped,
+          encodeURIComponent(secret),
+          base64,
+          base64.replace(/=+$/g, ''),
+          bytes.toString('base64url'),
+          bytes.toString('hex'),
+        ].filter(Boolean);
+      })
+    )
+  ).sort((left, right) => right.length - left.length);
+  let exfiltrationDetected = false;
+  const containsSecretVariant = (value, seen = new WeakSet()) => {
+    const renderings = [];
+    if (Buffer.isBuffer(value)) {
+      renderings.push(value.toString('utf8'), value.toString('base64'), value.toString('hex'));
+    } else if (typeof value === 'string') {
+      renderings.push(value);
+    } else if (ArrayBuffer.isView(value)) {
+      const bytes = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+      renderings.push(bytes.toString('utf8'), bytes.toString('base64'), bytes.toString('hex'));
+    } else if (!value || typeof value !== 'object') {
+      renderings.push(String(value));
+    }
+    if (
+      renderings.some(rendered =>
+        secretVariants.some(variant => variant && String(rendered).includes(variant))
+      )
+    ) {
+      return true;
+    }
+    if (!value || typeof value !== 'object' || seen.has(value)) return false;
+    seen.add(value);
+    const children = Array.isArray(value) ? value : Object.values(value);
+    if (value instanceof Error) {
+      children.push(value.name, value.message, value.stack, value.code, value.cause);
+    }
+    return children.some(child => containsSecretVariant(child, seen));
+  };
+  const redactString = value => {
+    let result = String(value);
+    for (const variant of secretVariants) {
+      if (variant) result = result.split(variant).join('***secret***');
+    }
+    return result;
+  };
+  const sanitize = (value, seen = new WeakSet()) => {
+    if (typeof value === 'string') return redactString(value);
+    if (!value || typeof value !== 'object') return value;
+    if (seen.has(value)) return '[Circular]';
+    seen.add(value);
+    if (Array.isArray(value)) return value.map(item => sanitize(item, seen));
+    return Object.fromEntries(
+      Object.entries(value).map(([key, child]) => [key, sanitize(child, seen)])
+    );
+  };
+  const renderLog = values => {
+    if (values.some(containsSecretVariant)) exfiltrationDetected = true;
+    return redactString(
+      values
+        .map(value =>
+          typeof value === 'string' ? value : JSON.stringify(sanitize(value))
+        )
+        .join(' ')
+    );
+  };
+  const safeConsole = Object.freeze({
+    log: (...values) => process.stderr.write(`${renderLog(values)}\n`),
+    info: (...values) => process.stderr.write(`${renderLog(values)}\n`),
+    warn: (...values) => process.stderr.write(`${renderLog(values)}\n`),
+    error: (...values) => process.stderr.write(`${renderLog(values)}\n`),
+    debug: (...values) => process.stderr.write(`${renderLog(values)}\n`),
+  });
+  global.console = safeConsole;
+  const declaredNames = new Set(
+    (payload.secretRefs || []).map(item => String(item.name || ''))
+  );
+  const secrets = Object.freeze({
+    get: async name => {
+      const normalized = String(name || '');
+      if (!declaredNames.has(normalized)) {
+        const error = new Error(`Function secretRef is not declared: ${normalized}`);
+        error.code = 'FUNCTION_SECRET_REF_UNDECLARED';
+        error.status = 403;
+        throw error;
+      }
+      if (!Object.prototype.hasOwnProperty.call(payload.secrets || {}, normalized)) {
+        const error = new Error(`Function secret is not configured: ${normalized}`);
+        error.code = 'FUNCTION_SECRET_NOT_CONFIGURED';
+        error.status = 424;
+        throw error;
+      }
+      return String(payload.secrets[normalized]);
+    },
+  });
+  const logger = Object.freeze({
+    debug: safeConsole.debug,
+    info: safeConsole.info,
+    warn: safeConsole.warn,
+    error: safeConsole.error,
+  });
+  Promise.resolve()
+    .then(() => {
+      const loaded = require(process.argv[1]);
+      const execute = loaded?.default || loaded;
+      if (typeof execute !== 'function') {
+        const error = new Error('App Function module must export a function');
+        error.code = 'APP_FUNCTION_TEST_EXPORT_INVALID';
+        throw error;
+      }
+      const context = Object.freeze({
+        input: payload.input,
+        secrets,
+        logger,
+        console: safeConsole,
+      });
+      return execute(context, payload.input);
+    })
+    .then(result => {
+      if (containsSecretVariant(result) || exfiltrationDetected) {
+        const error = new Error('App Function attempted to expose a secret');
+        error.code = 'APP_SECRET_EXFILTRATION_BLOCKED';
+        error.status = 500;
+        throw error;
+      }
+      process.stdout.write(
+        JSON.stringify({ ok: true, result: sanitize(result) })
+      );
+    })
+    .catch(error => {
+      const errorCode = String(error?.code || '');
+      const blocked =
+        error?.code === 'APP_SECRET_EXFILTRATION_BLOCKED' ||
+        exfiltrationDetected ||
+        containsSecretVariant(error);
+      const safeErrorCode = /^[A-Z][A-Z0-9_]{0,127}$/.test(errorCode)
+        ? errorCode
+        : 'APP_FUNCTION_TEST_FAILED';
+      process.stdout.write(
+        JSON.stringify({
+          ok: false,
+          error: {
+            code: blocked
+              ? 'APP_SECRET_EXFILTRATION_BLOCKED'
+              : safeErrorCode,
+            status: blocked ? 500 : error?.status,
+            message: blocked
+              ? 'App Function secret exfiltration was blocked'
+              : redactString(error?.message || String(error)),
+          },
+        })
+      );
+      process.exitCode = 1;
+    });
+}
+
+async function testAppFunctionLocally(positional, flags = {}) {
+  rejectUnsafeSecretValueFlags(flags);
+  const functionCode = resolveExactSecretName(
+    positional,
+    flags,
+    'function test'
+  );
+  const typeFilters = new Set(['functions']);
+  const codeFilters = [{ key: 'functions', code: functionCode, raw: functionCode }];
+  const manifest = loadWorkspaceResources({ typeFilters, codeFilters });
+  if (
+    flags['stage-only'] &&
+    (manifest.functions || []).length + (manifest.automations || []).length === 0
+  ) {
+    fail('--stage-only 没有匹配到可冻结的 Function/Automation 资源');
+  }
+  const validation = validateWorkspaceResources(manifest);
+  if (validation.errors.length > 0) {
+    fail(`Function:${functionCode} 本地 manifest 校验失败: ${validation.errors[0]}`);
+  }
+  const functionItem = manifest.functions?.[0];
+  if (!functionItem) fail(`未找到 Function manifest: ${functionCode}`);
+  const secretRefs = functionManifestDeclaresSecretRefs(functionItem)
+    ? normalizeFunctionSecretRefs(functionItem.secretRefs)
+    : [];
+  const secretMappings = parseFunctionTestSecretMappings(flags, secretRefs);
+  const input = flags['input-json']
+    ? readJsonArg(flags['input-json'], 'input-json')
+    : {};
+  const { sourcePath } = resolveFunctionTestSource(
+    functionItem,
+    functionCode
+  );
+  const workspaceRoot = findWorkspaceRoot(sourcePath);
+  const tempRoot = fs.mkdtempSync(
+    path.join(os.tmpdir(), 'openxiangda-function-test-')
+  );
+  try {
+    const bundlePath = await buildIsolatedFunctionTestBundle(
+      sourcePath,
+      workspaceRoot,
+      functionCode,
+      tempRoot
+    );
+    const secrets = readFunctionTestSecretsFromEnv(
+      secretMappings,
+      secretRefs
+    );
+    for (const value of Object.values(secrets)) registerSensitiveText(value);
+    const child = spawnSync(
+      process.execPath,
+      ['-e', `(${isolatedAppFunctionTestRunner.toString()})()`, bundlePath],
+      {
+        cwd: tempRoot,
+        env: stripUndefinedValues({
+          PATH: process.env.PATH,
+          NODE_ENV: 'test',
+          HOME: tempRoot,
+          USERPROFILE: tempRoot,
+          TMPDIR: tempRoot,
+        }),
+        input: JSON.stringify({ input, secretRefs, secrets }),
+        encoding: 'utf8',
+        maxBuffer: 8 * 1024 * 1024,
+        timeout: Number(flags.timeout || 30000),
+        killSignal: 'SIGKILL',
+      }
+    );
+    if (child.error) {
+      const error = new Error(
+        `APP_FUNCTION_SECRET_UNAVAILABLE: 隔离测试子进程失败: ${child.error.message}`
+      );
+      error.code = 'APP_FUNCTION_SECRET_UNAVAILABLE';
+      throw error;
+    }
+    if (child.stderr) process.stderr.write(maskText(child.stderr));
+    let output;
+    try {
+      output = JSON.parse(String(child.stdout || '{}'));
+    } catch (error) {
+      fail(`App Function 隔离测试输出无法解析: ${error.message}`);
+    }
+    const result = {
+      ...output,
+      functionCode,
+      runtimeContractVersion: secretRefs.length
+        ? APP_FUNCTION_SECRET_CAPABILITIES.runtimeContractVersion
+        : 'trusted_node_v1_compat',
+      isolated: true,
+      workspaceWrites: 0,
+      secretValuesPersisted: false,
+    };
+    if (flags.json) writeJson(result);
+    else print(JSON.stringify(result, null, 2));
+    if (child.status !== 0 || output.ok === false) {
+      const error = new Error(
+        `${output.error?.code || 'APP_FUNCTION_TEST_FAILED'}: ${output.error?.message || 'App Function local test failed'}`
+      );
+      error.code = output.error?.code || 'APP_FUNCTION_TEST_FAILED';
+      throw error;
+    }
+    return result;
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+    clearSensitiveText();
+  }
+}
+
+async function connector(args) {
+  const { subcommand, rest } = parseSubcommandArgs(args);
+  const { flags, positional } = parseArgs(rest);
+  if (wantsSubcommandHelp(subcommand, flags)) {
+    print('用法: openxiangda connector list|get|create|update|upsert|delete|invoke|download-test [connectorCode[.apiCode]] [--json-file file]');
+    return;
+  }
+  const config = loadConfig();
+  const target = getWorkspaceTarget(config, flags.profile || config.currentProfile, flags);
+
+  if (subcommand === 'invoke' || subcommand === 'download-test') {
+    const targetName = positional[0] || flags.connector;
+    if (!targetName) fail(`用法: openxiangda connector ${subcommand} <connectorCode.apiCode> [--body-json file|json]`);
+    const parsed = parseConnectorApiName(targetName, flags);
+    const body = {
+      connector: parsed.connector,
+      api: parsed.api,
+      ...readDirectJsonBody(flags, 'connector invoke', { optional: true }),
+      ...(flags['path-params-json'] ? { pathParams: readJsonArg(flags['path-params-json'], 'path-params-json') } : {}),
+      ...(flags['query-json'] ? { query: readJsonArg(flags['query-json'], 'query-json') } : {}),
+      ...(flags['headers-json'] ? { headers: readJsonArg(flags['headers-json'], 'headers-json') } : {}),
+      ...(flags['request-body-type'] ? { requestBodyType: flags['request-body-type'] } : {}),
+      ...(flags['response-type'] ? { responseType: flags['response-type'] } : {}),
+    };
+    if (subcommand === 'download-test') body.responseType = 'binary';
+    return runDirectRequest(config, target, flags, {
+      method: 'POST',
+      path: `/${encodeURIComponent(target.appType)}/v1/connectors/actions/${subcommand === 'download-test' ? 'download' : 'invoke'}`,
+      body,
+      strictEnvelope: subcommand !== 'download-test',
+    }, { controlPlaneMutation: false });
+  }
+
+  return directResourceCrud(config, target, {
+    commandName: 'connector',
+    subcommand,
+    flags,
+    positional,
+    resourceType: 'connector',
+    basePath: `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/connectors`,
+    manifestDir: path.join('src', 'resources', 'connectors'),
+    createMethod: 'POST',
+    createPath: `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/connectors/actions/sync`,
+    createBody: body => ({ connectors: [normalizeConnectorManifest(body)] }),
+    updateMethod: 'POST',
+    updatePath: `/openxiangda-api/v1/apps/${encodeURIComponent(target.appType)}/connectors/actions/sync`,
+    updateBody: body => ({ connectors: [normalizeConnectorManifest(body)] }),
+    normalizeBody: body => normalizeConnectorManifest(body),
+    codeOf: body => body.code || body.methodName,
+    responseData: data => Array.isArray(data?.data) ? data.data[0] : data,
+    saveState: (code, data) => saveConnectorResource(target, code, data?.connector?.id || data?.id, {
+      apis: Object.fromEntries(
+        (data?.apis || []).map(api => [api.code || api.methodName, { apiId: api.id, name: api.name }])
+      ),
+    }),
+  });
+}
+
+async function notification(args) {
+  const { subcommand, rest } = parseSubcommandArgs(args);
+  const { flags, positional } = parseArgs(rest);
   if (wantsSubcommandHelp(subcommand, flags)) {
     print([
       '用法: openxiangda notification template-list|template-get|template-upsert|template-delete|type-list|type-get|type-upsert|type-delete|preview|send|batch-send|capabilities|dingding-preview|dingding-send',
@@ -7242,12 +8655,14 @@ async function resource(args) {
       '  openxiangda resource validate --profile <name>',
       '  openxiangda resource plan [type] --only <code1,code2> --profile <name> --json',
       '  openxiangda resource publish [type] --only <code1,code2> --profile <name>',
+      '  openxiangda resource publish function --only <code> --stage-only --profile <name>',
       '  openxiangda resource publish form-settings --only <code> --activate --profile <name>',
       '  openxiangda resource publish [type] --all --reason "approved app-wide closure" --profile <name>',
       '说明:',
       '  - 读取 src/resources/**；workflowFile 会先走非写入编译校验。',
       '  - publish 默认跳过 plan 判定为 noop 的资源，避免无意义 upsert；需要强制写入时加 --force。',
       '  - Form settings bundle 默认只 stage，不推进线上 Form head；只有显式 --activate 才 CAS 激活。',
+      '  - Function/Automation 可用 --stage-only 只 prepare + verify Backend Release；随后把返回的 stagedResource 交给 release app-finalize 原子激活。',
       '  - publish --dry-run 等价于发布前计划，不会写平台资源。',
       '  - 在线 publish 必须用 --only/--code 精确选择；真正全量发布必须显式 --all --reason，SDD bypass 不能绕过此范围门。',
       '  - 源码依赖触发的 Function/Automation 更新默认只替换 source snapshot，保留线上 bindings/schema/metadata；显式替换 manifest 必须加 --replace-manifest --reason。',
@@ -7284,6 +8699,7 @@ async function resource(args) {
 
   const typeFilters = getResourceTypeFilters(positional, flags);
   const codeFilters = getResourceCodeFilters(flags);
+  assertBackendStageOnlyScope(subcommand, flags, typeFilters);
   assertExplicitResourcePublishScope(subcommand, flags, codeFilters);
   assertExplicitManifestReplacement(flags);
   if (codeFilters && flags.prune) {
@@ -7353,6 +8769,19 @@ async function resource(args) {
     const publishPlan = await telemetry.runPhase('plan', async () =>
       buildResourcePlan(config, target, manifest)
     );
+    if (publishPlan.functionSecretRefs?.valid === false) {
+      const missing = publishPlan.functionSecretRefs.functions
+        .flatMap(item =>
+          item.missingRequired.map(ref => `${item.code}:${ref.name}`)
+        )
+        .sort();
+      const error = new Error(
+        `FUNCTION_SECRET_NOT_CONFIGURED: 以下 Function required secretRefs 尚未配置或未激活: ${missing.join(', ')}`
+      );
+      error.code = 'FUNCTION_SECRET_NOT_CONFIGURED';
+      error.missingSecretRefs = missing;
+      throw error;
+    }
     const pruneCandidates = flags.prune
       ? await telemetry.runPhase('prune-plan', async () =>
           collectPruneResourceCandidates(config, target, manifest)
@@ -7381,8 +8810,16 @@ async function resource(args) {
           resourceTargets,
           {
             files: scopedFiles,
-            commands: [buildResourcePublishCommand(typeFilters, codeFilters, profileName)],
+            commands: [
+              buildResourcePublishCommand(
+                typeFilters,
+                codeFilters,
+                profileName,
+                flags
+              ),
+            ],
             changeId: flags.change,
+            actualCommands: true,
           }
         ),
         flags,
@@ -7426,11 +8863,27 @@ async function resource(args) {
           baseRef: flags.since || 'HEAD',
           replaceManifest: Boolean(flags['replace-manifest']),
           activateFormBundles: Boolean(flags.activate),
+          stageBackendReleaseOnly: Boolean(flags['stage-only']),
         })
     );
     if (changeBaselinePreflight) {
       result.changeBaselinePreflight = changeBaselinePreflight;
     }
+    const stagedResources =
+      Array.isArray(result.stagedResources) && result.stagedResources.length > 0
+        ? result.stagedResources
+        : result.stagedResource
+          ? [result.stagedResource]
+          : [];
+    const stagedChangeId =
+      flags.change || getStoredChangeBaseline(target)?.changeId;
+    if (stagedResources.length > 0 && stagedChangeId) {
+      result.stagedResourcesFile = recordStagedAppReleaseResources(
+        stagedChangeId,
+        stagedResources,
+        target
+      );
+    }
     result.timings = telemetry.stop();
     if (flags.json) return writeJson(result);
     printResourceResult(result);
@@ -7439,6 +8892,23 @@ async function resource(args) {
   }
 }
 
+function assertBackendStageOnlyScope(subcommand, flags, typeFilters) {
+  if (!flags['stage-only']) return;
+  if (subcommand !== 'publish' || flags['dry-run']) {
+    fail('--stage-only 仅适用于在线 resource publish');
+  }
+  if (flags.prune || flags.activate) {
+    fail('--stage-only 不能与 --prune 或 --activate 同时使用');
+  }
+  const normalized = Array.from(typeFilters || []);
+  if (
+    normalized.length === 0 ||
+    normalized.some(type => !['functions', 'automations'].includes(type))
+  ) {
+    fail('--stage-only 必须显式选择 function 或 automation 资源类型');
+  }
+}
+
 function assertExplicitResourcePublishScope(subcommand, flags, codeFilters) {
   if (subcommand !== 'publish' || flags['dry-run']) return;
   if (Array.isArray(codeFilters) && codeFilters.length > 0) return;
@@ -7470,7 +8940,12 @@ function buildResourceManifestSddTargets(manifest, planActions = []) {
         .map(action => action.code)
         .filter(Boolean)
     ).sort();
-  const codeResourceKeys = new Set(['functions', 'automations', 'workflows']);
+  const codeResourceKeys = new Set([
+    'functions',
+    'automations',
+    'workflows',
+    'formSettings',
+  ]);
   const hasGenericResources = RESOURCE_SPECS.some(
     spec => !codeResourceKeys.has(spec.key) && (manifest[spec.key] || []).length > 0
   ) || (planActions || []).some(
@@ -7479,7 +8954,7 @@ function buildResourceManifestSddTargets(manifest, planActions = []) {
       !['function', 'automation', 'workflow'].includes(action.kind)
   );
   return {
-    forms: [],
+    forms: codes('formSettings'),
     pages: [],
     functions: unique([...codes('functions'), ...deletedCodes('function')]).sort(),
     automations: unique([
@@ -7494,20 +8969,51 @@ function buildResourceManifestSddTargets(manifest, planActions = []) {
   };
 }
 
-function buildResourcePublishCommand(typeFilters, codeFilters, profileName) {
+function buildResourcePublishCommand(
+  typeFilters,
+  codeFilters,
+  profileName,
+  flags = {}
+) {
   const args = ['openxiangda resource publish'];
-  if (typeFilters?.size === 1) {
-    args.push(Array.from(typeFilters)[0]);
+  if (typeFilters?.size > 0) {
+    args.push(Array.from(typeFilters).sort().join(','));
   }
   if (codeFilters?.length) {
+    const qualifierAliases = {
+      functions: 'function',
+      automations: 'automation',
+      workflows: 'workflow',
+      formSettings: 'form-setting',
+    };
     const selectors = codeFilters.map(selector =>
       (selector.key || selector.qualifier) && (!typeFilters || typeFilters.size !== 1)
-        ? `${selector.key || selector.qualifier}:${selector.code}`
+        ? `${
+            qualifierAliases[selector.key || selector.qualifier] ||
+            selector.key ||
+            selector.qualifier
+          }:${selector.code}`
         : selector.code
     );
     args.push(`--only ${Array.from(new Set(selectors)).join(',')}`);
   }
   args.push(`--profile ${profileName}`);
+  if (flags.change) args.push(`--change ${flags.change}`);
+  if (flags['stage-only']) args.push('--stage-only');
+  if (flags.activate) args.push('--activate');
+  if (flags['replace-manifest']) args.push('--replace-manifest');
+  if (flags.reason) args.push(`--reason ${JSON.stringify(String(flags.reason))}`);
+  return args.join(' ');
+}
+
+function buildWorkspacePublishCommand(flags = {}, profileName) {
+  const args = ['openxiangda workspace publish', `--profile ${profileName}`];
+  if (flags.change) args.push(`--change ${flags.change}`);
+  if (flags.form) args.push(`--form ${flags.form}`);
+  if (flags.page) args.push(`--page ${flags.page}`);
+  if (flags.only) args.push(`--only ${flags.only}`);
+  if (flags.changed) args.push('--changed');
+  if (flags['include-resources']) args.push('--include-resources');
   return args.join(' ');
 }
 
@@ -7615,9 +9121,10 @@ async function runtime(args) {
           commands: [
             `openxiangda runtime deploy --profile ${target.profileName}${
               flags.change ? ` --change ${flags.change}` : ''
-            }`,
+            }${flags['no-activate'] ? ' --no-activate' : ''}`,
           ],
           changeId: flags.change,
+          actualCommands: true,
         }
       ),
       flags,
@@ -7854,7 +9361,46 @@ async function runtime(args) {
           }
         )
     );
-    saveRuntimeReleaseState(target, data);
+    const runtimeContentHash = String(data?.contentHash || '')
+      .trim()
+      .toLowerCase();
+    const stagedResource = flags['no-activate']
+      ? stripUndefinedValues({
+          kind: 'RuntimeRelease',
+          identity: { releaseId: data?.id },
+          action: 'update',
+          hash: runtimeContentHash,
+          revision: {
+            parentReleaseId:
+              data?.parentReleaseId || runtimeLineage.parentReleaseId || null,
+          },
+          metadata: {
+            buildId: data?.buildId || buildId,
+            releaseStatus: data?.status || 'staged',
+          },
+        })
+      : null;
+    if (
+      flags['no-activate'] &&
+      (!data?.id || !/^[a-f0-9]{64}$/.test(runtimeContentHash))
+    ) {
+      fail(
+        'RUNTIME_RELEASE_STAGED_RESOURCE_INVALID: --no-activate 响应缺少 releaseId 或 64 位 contentHash'
+      );
+    }
+    if (!flags['no-activate']) {
+      saveRuntimeReleaseState(target, data);
+    }
+    const stagedChangeId =
+      flags.change || getStoredChangeBaseline(target)?.changeId;
+    const stagedResourcesFile =
+      stagedResource && stagedChangeId
+        ? recordStagedAppReleaseResources(
+            stagedChangeId,
+            [stagedResource],
+            target
+          )
+        : null;
     const releaseAssetBaseUrl = data?.assetBaseUrl || assetBaseUrl;
     const result = {
       appType: target.appType,
@@ -7876,6 +9422,8 @@ async function runtime(args) {
         releaseFiles.find(file => file.storageProvider)?.storageProvider ||
         null,
       traceId,
+      ...(stagedResource ? { stagedResource } : {}),
+      ...(stagedResourcesFile ? { stagedResourcesFile } : {}),
       timings: telemetry.stop(),
     };
     if (flags.json) return writeJson(result);
@@ -7888,6 +9436,9 @@ async function runtime(args) {
         `traceId: ${traceId}`,
         `assetBase: ${releaseAssetBaseUrl}`,
         `active: ${result.activated ? 'yes' : 'no'}`,
+        ...(stagedResourcesFile
+          ? [`staged resources: ${stagedResourcesFile}`]
+          : []),
       ].join('\n')
     );
     return;
@@ -8368,6 +9919,21 @@ function saveRuntimeReleaseState(target, release) {
   saveProjectState(target.state);
 }
 
+function saveRuntimeHeadState(target, app) {
+  const activeReleaseId =
+    app?.activeRuntimeReleaseId || app?.activeRuntime?.releaseId || null;
+  const activeBuildId =
+    app?.activeRuntimeBuildId || app?.activeRuntime?.buildId || null;
+  if (!activeReleaseId && !activeBuildId) return false;
+  saveRuntimeReleaseState(target, {
+    id: activeReleaseId,
+    buildId: activeBuildId,
+    assetBaseUrl:
+      app?.runtimeAssetBaseUrl || app?.activeRuntime?.assetBaseUrl || null,
+  });
+  return true;
+}
+
 function formatBytes(value) {
   const bytes = Number(value || 0);
   if (bytes < 1024) return `${bytes}B`;
@@ -8493,7 +10059,8 @@ async function commands(args) {
       'route list|get|create|update|upsert|delete',
       'public-access list|get|create|update|upsert|delete|ticket-create|session-test|grant-check',
       'auth-config list|get|create|update|upsert|delete|methods',
-      'function list|get|create|update|upsert|delete|invoke',
+      'function list|get|create|update|upsert|delete|invoke|test',
+      'secret list|metadata|references|audit|unused|create|update|rotate|delete',
       'connector list|get|create|update|upsert|delete|invoke|download-test',
       'notification template-list|template-get|template-upsert|template-delete|type-list|type-get|type-upsert|type-delete|preview|send|batch-send',
       'organization capabilities|department-list|department-get|department-create|department-update|account-list|account-get|account-create|account-update|account-reset-password',
@@ -8514,6 +10081,7 @@ async function commands(args) {
       'public-access is the new React SPA public policy resource for /view/:appType/public/* routes; page code should use PublicAccessGate, and Page SDK hooks must stay inside OpenXiangdaProvider + OpenXiangdaPageProvider.',
       'settings public-access is legacy form public-access compatibility/repair and should not be used for new React SPA apps.',
       'Direct live mutation commands should use --dry-run first and --write-manifest when the repository should remain source of truth.',
+      'App Function Secret values never belong in a manifest or workspace file. Use top-level function secretRefs, ctx.secrets.get(name), and secret create/rotate via hidden TTY or --value-stdin.',
       'OpenXiangda native SDD uses openspec/ records; high-risk publishes require an approved change with coverage.json/release.json verification unless --sdd-bypass --reason is used.',
       'A formal release freezes the clean publish HEAD separately from the change base; after activation merge/fast-forward and push that exact SHA to the authoritative default branch, verify release integration-status, then run release end.',
     ],
@@ -10430,7 +11998,9 @@ function validateResourceItem(kind, item, errors, warnings) {
     if (!item.definitionJson && !item.definitionFile) {
       errors.push(`${label}: 缺少 definitionJson 或 definitionFile`);
     }
+    validateFunctionSecretRefs(label, item, errors);
     validateFunctionRuntimeInvoke(label, item, errors, warnings);
+    validateFunctionPerformancePolicies(label, item, errors);
   }
   if (kind === 'dataViews') {
     const definition = item.definition || item;
@@ -10743,6 +12313,62 @@ function validateFunctionRuntimeInvoke(label, item, errors, warnings) {
   }
 }
 
+function validateFunctionPerformancePolicies(label, item, errors) {
+  const definition = item.definitionJson || {};
+  const responseCache = definition.responseCache;
+  if (responseCache !== undefined) {
+    if (!responseCache || typeof responseCache !== 'object' || Array.isArray(responseCache)) {
+      errors.push(`${label}: responseCache 必须是对象`);
+    } else {
+      if (responseCache.enabled !== undefined && typeof responseCache.enabled !== 'boolean') {
+        errors.push(`${label}: responseCache.enabled 必须是 boolean`);
+      }
+      const ttlSeconds = Number(responseCache.ttlSeconds);
+      if (!Number.isInteger(ttlSeconds) || ttlSeconds < 1 || ttlSeconds > 86400) {
+        errors.push(`${label}: responseCache.ttlSeconds 必须是 1-86400 的整数`);
+      }
+      if (!Array.isArray(responseCache.actions) || responseCache.actions.length === 0) {
+        errors.push(`${label}: responseCache.actions 必须是非空数组`);
+      }
+      if (responseCache.scope !== 'public_policy') {
+        errors.push(`${label}: responseCache.scope 当前仅支持 public_policy`);
+      }
+      if (
+        responseCache.invalidateOnForms !== undefined &&
+        !Array.isArray(responseCache.invalidateOnForms)
+      ) {
+        errors.push(`${label}: responseCache.invalidateOnForms 必须是数组`);
+      }
+      if (responseCache.maxValueBytes !== undefined) {
+        const maxValueBytes = Number(responseCache.maxValueBytes);
+        if (!Number.isInteger(maxValueBytes) || maxValueBytes < 1024 || maxValueBytes > 4194304) {
+          errors.push(`${label}: responseCache.maxValueBytes 必须是 1024-4194304 的整数`);
+        }
+      }
+    }
+  }
+
+  const invocationAudit = definition.invocationAudit;
+  if (invocationAudit !== undefined) {
+    if (!invocationAudit || typeof invocationAudit !== 'object' || Array.isArray(invocationAudit)) {
+      errors.push(`${label}: invocationAudit 必须是对象`);
+    } else {
+      if (
+        invocationAudit.successOutput !== undefined &&
+        !['full', 'summary'].includes(String(invocationAudit.successOutput))
+      ) {
+        errors.push(`${label}: invocationAudit.successOutput 只能是 full 或 summary`);
+      }
+      if (invocationAudit.maxLogBytes !== undefined) {
+        const maxLogBytes = Number(invocationAudit.maxLogBytes);
+        if (!Number.isInteger(maxLogBytes) || maxLogBytes < 1024 || maxLogBytes > 65536) {
+          errors.push(`${label}: invocationAudit.maxLogBytes 必须是 1024-65536 的整数`);
+        }
+      }
+    }
+  }
+}
+
 function validateFunctionRuntimeInvokeAudience(label, value, errors) {
   if (Array.isArray(value)) {
     value.forEach(item => validateFunctionRuntimeInvokeAudience(label, item, errors));
@@ -11412,6 +13038,11 @@ async function publishResourcesForWorkspace(config, profileName, options = {}) {
 
 async function buildResourcePlan(config, target, manifest) {
   return await withReadOnlyHttpGuard('resource plan', async () => {
+  const secretCapabilities = await assertManifestAppFunctionSecretCapabilities(
+    config,
+    target,
+    manifest
+  );
   await prepareManifestJsCodeBundlesForPlan(manifest);
   const existing = await fetchExistingResourceMaps(config, target, manifest);
   const actions = [];
@@ -11438,6 +13069,14 @@ async function buildResourcePlan(config, target, manifest) {
     actions,
     manifest.formSettings || []
   );
+  const functionSecretRefs = secretCapabilities
+    ? await buildAppFunctionSecretRefPlan(
+        config,
+        target,
+        manifest.functions || [],
+        existing.functions
+      )
+    : null;
   return {
     appType: target.appType,
     profile: target.profileName,
@@ -11445,10 +13084,99 @@ async function buildResourcePlan(config, target, manifest) {
     ...(manifest.resourceCodeFilters ? { resourceCodeFilters: manifest.resourceCodeFilters } : {}),
     actions,
     summary: summarizeActions(actions),
+    ...(functionSecretRefs
+      ? {
+          capabilities: {
+            app_function_secrets_v1: true,
+            trusted_node_v2: true,
+            backend_release_v2: true,
+            atomic_staged_children_v2: true,
+          },
+          functionSecretRefs,
+        }
+      : {}),
   };
   });
 }
 
+async function buildAppFunctionSecretRefPlan(
+  config,
+  target,
+  functions,
+  existingFunctions
+) {
+  const declaredFunctions = (functions || []).filter(
+    functionManifestDeclaresSecretRefs
+  );
+  if (declaredFunctions.length === 0) return null;
+  const metadataResponse = await requestWithAuth(
+    config,
+    target.profileName,
+    appSecretApiPath(target)
+  );
+  assertSecretMetadataOnly(metadataResponse);
+  const metadataByName = new Map(
+    normalizeItems(metadataResponse)
+      .filter(item => item?.name)
+      .map(item => [String(item.name), item])
+  );
+  const plans = declaredFunctions.map(item => {
+    const code = item.code || item.functionCode || item.resourceCode;
+    const desired = normalizeFunctionSecretRefs(item.secretRefs);
+    const current = normalizeFunctionSecretRefs(
+      existingFunctions?.get(code)?.secretRefs ??
+        existingFunctions?.get(code)?.secretReferences ??
+        []
+    );
+    const desiredNames = new Set(desired.map(ref => ref.name));
+    const currentNames = new Set(current.map(ref => ref.name));
+    const added = desired
+      .map(ref => ref.name)
+      .filter(name => !currentNames.has(name));
+    const removed = current
+      .map(ref => ref.name)
+      .filter(name => !desiredNames.has(name));
+    const missingRequired = [];
+    const unavailableOptional = [];
+    for (const ref of desired) {
+      const metadata = metadataByName.get(ref.name);
+      let reason = null;
+      if (!metadata) reason = 'missing';
+      else if (String(metadata.status || 'active') !== 'active') {
+        reason = `status:${metadata.status || 'unknown'}`;
+      } else if (metadata.hasValue !== true) {
+        reason = 'value-not-configured';
+      }
+      if (!reason) continue;
+      (ref.required ? missingRequired : unavailableOptional).push({
+        name: ref.name,
+        reason,
+      });
+    }
+    const unusedAfterActivation = removed.filter(name => {
+      const referenceCount = Number(metadataByName.get(name)?.referenceCount);
+      return Number.isFinite(referenceCount) && referenceCount <= 1;
+    });
+    return {
+      code,
+      desired,
+      current,
+      added,
+      removed,
+      missingRequired,
+      unavailableOptional,
+      unusedAfterActivation,
+    };
+  });
+  return {
+    contractVersion: APP_FUNCTION_SECRET_CAPABILITIES.contractVersion,
+    runtimeContractVersion:
+      APP_FUNCTION_SECRET_CAPABILITIES.runtimeContractVersion,
+    functions: plans,
+    valid: plans.every(item => item.missingRequired.length === 0),
+  };
+}
+
 async function prepareManifestJsCodeBundlesForPlan(manifest) {
   const targetsByWorkspace = new Map();
   const seenObjects = new Set();
@@ -11649,19 +13377,19 @@ function collectBackendReleaseCandidates(manifest, options = {}) {
     for (const item of items || []) {
       const code = item.code || item.functionCode || item.resourceCode;
       const action = getPlannedResourceAction(options, planKind, code);
-      if (!action || !['update', 'noop'].includes(action.action)) continue;
+      if (!action || !['create', 'update', 'noop'].includes(action.action)) continue;
       if (action.action === 'noop' && options.skipNoop !== false) continue;
-      if (
-        shouldReplaceResourceManifestItem(
-          item,
-          resourceKey,
-          code,
-          options
-        )
-      ) {
-        continue;
-      }
-      candidates.push({ kind, code, item, plannedAction: action.action });
+      const replaceManifest =
+        action.action !== 'create' &&
+        shouldReplaceResourceManifestItem(item, resourceKey, code, options);
+      candidates.push({
+        kind,
+        code,
+        item,
+        plannedAction: action.action,
+        operation: action.action === 'create' ? 'create' : 'update',
+        mode: replaceManifest ? 'manifest_replacement' : 'source_only',
+      });
     }
   };
   append('Function', 'functions', manifest.functions);
@@ -11833,25 +13561,206 @@ async function buildBackendReleaseResourceInput(
       candidate.item,
       definitionJson
     );
-    return {
+    const secretRefsDeclared = functionManifestDeclaresSecretRefs(
+      candidate.item
+    );
+    const common = {
       kind: 'Function',
       code: candidate.code,
-      source: backendSourcePlane(
+      mode: candidate.mode,
+      operation: candidate.operation,
+      ...(secretRefsDeclared
+        ? {
+            secretRefs: normalizeFunctionSecretRefs(
+              candidate.item.secretRefs
+            ),
+          }
+        : {}),
+    };
+    if (candidate.mode === 'manifest_replacement') {
+      return {
+        ...common,
+        replacement: buildBackendReleaseFunctionReplacementInput(
+          candidate.item,
+          definitionJson
+        ),
+      };
+    }
+    const source = backendSourcePlane(
+      definitionJson,
+      `Function:${candidate.code}`
+    );
+    if (secretRefsDeclared) {
+      source.version = definitionJson.version;
+      source.runtimeContractVersion = definitionJson.runtimeContractVersion;
+    }
+    return {
+      ...common,
+      ...(candidate.operation === 'create'
+        ? {
+            create: buildBackendReleaseFunctionCreateInput(
+              candidate.item,
+              definitionJson
+            ),
+          }
+        : {}),
+      source,
+    };
+  }
+  const viewJson =
+    (await resolveManifestJson(
+      config,
+      target.profileName,
+      candidate.item,
+      'viewJson',
+      'viewFile',
+      true,
+      uploadCache
+    )) ??
+    (await resolveManifestJson(
+      config,
+      target.profileName,
+      candidate.item,
+      'previewJson',
+      'previewFile',
+      true,
+      uploadCache
+    ));
+  const common = {
+    kind: 'Automation',
+    code: candidate.code,
+    mode: candidate.mode,
+    operation: candidate.operation,
+  };
+  if (candidate.mode === 'manifest_replacement') {
+    return {
+      ...common,
+      replacement: buildBackendReleaseAutomationMetadata(
+        target,
+        candidate.item,
         definitionJson,
-        `Function:${candidate.code}`
+        viewJson
       ),
     };
   }
   return {
-    kind: 'Automation',
-    code: candidate.code,
+    ...common,
     sources: buildAutomationBackendReleaseSources(
       definitionJson,
       `Automation:${candidate.code}`
     ),
+    ...(candidate.operation === 'create'
+      ? {
+          create: buildBackendReleaseAutomationMetadata(
+            target,
+            candidate.item,
+            withoutBackendSourcePlanes(definitionJson),
+            viewJson
+          ),
+        }
+      : {}),
   };
 }
 
+function buildBackendReleaseFunctionCreateInput(functionItem, definitionJson) {
+  const baseDefinition = clonePlainJson(definitionJson || {});
+  for (const key of [
+    'sourceFile',
+    'sourceType',
+    'sourceProvenance',
+    'secretRefs',
+  ]) {
+    delete baseDefinition[key];
+  }
+  const code =
+    functionItem.code || functionItem.functionCode || functionItem.resourceCode;
+  return stripUndefinedValues({
+    name: functionItem.name || definitionJson.name || code,
+    description:
+      functionItem.description !== undefined
+        ? functionItem.description
+        : definitionJson.description || '',
+    definitionJson: baseDefinition,
+    resourceBindings: clonePlainJson(definitionJson.resourceBindings || {}),
+    inputSchema: clonePlainJson(
+      functionItem.inputSchema || definitionJson.inputSchema
+    ),
+    outputSchema: clonePlainJson(
+      functionItem.outputSchema || definitionJson.outputSchema
+    ),
+    status: functionItem.status || 'active',
+  });
+}
+
+function buildBackendReleaseFunctionReplacementInput(
+  functionItem,
+  definitionJson
+) {
+  const code =
+    functionItem.code || functionItem.functionCode || functionItem.resourceCode;
+  return stripUndefinedValues({
+    name: functionItem.name || definitionJson.name || code,
+    description:
+      functionItem.description !== undefined
+        ? functionItem.description
+        : definitionJson.description || '',
+    definitionJson: clonePlainJson(definitionJson),
+    resourceBindings: clonePlainJson(definitionJson.resourceBindings || {}),
+    inputSchema: clonePlainJson(
+      functionItem.inputSchema || definitionJson.inputSchema
+    ),
+    outputSchema: clonePlainJson(
+      functionItem.outputSchema || definitionJson.outputSchema
+    ),
+    status: functionItem.status || 'active',
+  });
+}
+
+function buildBackendReleaseAutomationMetadata(
+  target,
+  automationItem,
+  definitionJson,
+  viewJson
+) {
+  const payload = resolveAutomationManifestPayload(target, automationItem);
+  const enabled =
+    automationItem.enable !== undefined
+      ? Boolean(automationItem.enable)
+      : automationItem.isEnabled !== undefined
+        ? Boolean(automationItem.isEnabled)
+        : true;
+  return stripUndefinedValues({
+    name: automationItem.name || automationItem.code,
+    description: automationItem.description || '',
+    formUuid: payload.formUuid,
+    triggerConfig: clonePlainJson(payload.triggerConfig),
+    definitionJson: clonePlainJson(definitionJson),
+    ...(viewJson !== undefined ? { viewJson: clonePlainJson(viewJson) } : {}),
+    isPublished: Boolean(automationItem.publish || automationItem.isPublished),
+    isEnabled: enabled,
+    ...(automationItem.tags !== undefined
+      ? {
+          tags: Array.isArray(automationItem.tags)
+            ? automationItem.tags.join(',')
+            : automationItem.tags,
+        }
+      : {}),
+  });
+}
+
+function withoutBackendSourcePlanes(value) {
+  if (Array.isArray(value)) return value.map(withoutBackendSourcePlanes);
+  if (!value || typeof value !== 'object') return value;
+  return Object.fromEntries(
+    Object.entries(value)
+      .filter(
+        ([key]) =>
+          !['sourceFile', 'sourceType', 'sourceProvenance'].includes(key)
+      )
+      .map(([key, item]) => [key, withoutBackendSourcePlanes(item)])
+  );
+}
+
 function indexCurrentAutomationStates(items, codes) {
   const codeSet = new Set(codes);
   const groups = new Map();
@@ -11938,6 +13847,9 @@ async function applyBackendAutomationStateTransitions(
       if (!current?.id) {
         fail(`Backend Release 激活后缺少 Automation:${candidate.code} 当前版本`);
       }
+      if (candidate.mode === 'manifest_replacement') {
+        return { code: candidate.code, transitions: [] };
+      }
       const plan = getPlannedResourceAction(
         options,
         'automation',
@@ -12051,14 +13963,44 @@ function saveBackendReleaseResourceStates(
   target.bound = nextBound;
 }
 
-function backendReleaseResultSummary(release, stateTransitions = new Map()) {
+function backendReleaseResultSummary(
+  release,
+  stateTransitions = new Map(),
+  protocolVersion = null,
+  handledSelectors = []
+) {
   const resources = release.resources || [];
+  const resolvedProtocolVersion =
+    release.protocolVersion || protocolVersion || undefined;
+  const releaseResource = {
+    kind: 'BackendRelease',
+    identity: { releaseId: release.id },
+    action: 'update',
+    hash: release.verificationHash || release.manifestHash,
+    metadata: resolvedProtocolVersion
+      ? {
+          protocolVersion: resolvedProtocolVersion,
+          mode: release.mode,
+          parentReleaseId: release.parentReleaseId || null,
+          handledSelectors,
+        }
+      : {
+          mode: release.mode,
+          parentReleaseId: release.parentReleaseId || null,
+          handledSelectors,
+        },
+  };
+  const isStaged = ['prepared', 'verified'].includes(
+    String(release.status || '').toLowerCase()
+  );
   return {
     id: release.id,
     status: release.status,
     manifestHash: release.manifestHash,
     verificationHash: release.verificationHash,
     parentReleaseId: release.parentReleaseId || null,
+    mode: release.mode,
+    handledSelectors,
     resourceCount: resources.length,
     updateCount: resources.filter(resource => resource.action === 'update').length,
     noopCount: resources.filter(resource => resource.action === 'noop').length,
@@ -12068,6 +14010,12 @@ function backendReleaseResultSummary(release, stateTransitions = new Map()) {
     ),
     postCommitStatus: release.postCommitStatus,
     postCommit: release.postCommit,
+    ...(resolvedProtocolVersion
+      ? { protocolVersion: resolvedProtocolVersion }
+      : {}),
+    ...(isStaged
+      ? { stagedResource: releaseResource }
+      : { activeResource: releaseResource }),
   };
 }
 
@@ -12079,7 +14027,26 @@ async function publishBackendReleaseResources(
   options = {}
 ) {
   const candidates = collectBackendReleaseCandidates(manifest, options);
-  if (candidates.length === 0) return;
+  if (candidates.length === 0) {
+    if (options.stageBackendReleaseOnly) {
+      fail('--stage-only 没有匹配到可冻结的 Function/Automation 资源');
+    }
+    return;
+  }
+  const protocolVersion = APP_FUNCTION_SECRET_CAPABILITIES.backendRelease;
+  const handledSelectors = candidates
+    .map(candidate =>
+      `${candidate.kind === 'Function' ? 'function' : 'automation'}:${candidate.code}`
+    )
+    .sort();
+  const resourceModes = unique(candidates.map(candidate => candidate.mode));
+  const releaseMode =
+    resourceModes.length > 1 ? 'mixed' : resourceModes[0] || 'source_only';
+  const replacementReason = String(
+    options.publishLeaseFlags?.reason ||
+      options.publishLeaseFlags?.['replace-reason'] ||
+      ''
+  ).trim();
 
   let head;
   try {
@@ -12089,12 +14056,26 @@ async function publishBackendReleaseResources(
       backendReleaseApiPath(target, '/head')
     );
   } catch (error) {
-    if (!isBackendReleaseFeatureAbsent(error)) throw error;
-    const message =
-      '当前平台未提供 Backend Release API（head=404）；本次兼容降级为逐项 source PATCH。升级平台后会自动启用 Function + Automation 单事务发布。';
-    result.warnings.push(message);
-    warn(message);
-    return;
+    if (isBackendReleaseFeatureAbsent(error)) {
+      const secretRefsRequired = candidates.some(
+        candidate =>
+          candidate.kind === 'Function' &&
+          functionManifestDeclaresSecretRefs(candidate.item)
+      );
+      if (!options.stageBackendReleaseOnly && !secretRefsRequired) {
+        const message =
+          '当前平台未提供 Backend Release API（head=404）；非 stage-only 发布兼容降级为逐项写入。升级平台后会自动使用 Backend Release v2。';
+        result.warnings.push(message);
+        warn(message);
+        return;
+      }
+      const missing = new Error(
+        'BACKEND_RELEASE_V2_REQUIRED: 本次 Function/Automation 发布包含 v2 operation/mode，平台必须支持 Backend Release v2，禁止降级为逐项写入'
+      );
+      missing.code = 'BACKEND_RELEASE_V2_REQUIRED';
+      throw missing;
+    }
+    throw error;
   }
 
   const releaseContext = await ensureBackendReleasePublishContext(
@@ -12126,8 +14107,12 @@ async function publishBackendReleaseResources(
       method: 'POST',
       body: {
         ...releaseContext.control,
+        ...(protocolVersion ? { protocolVersion } : {}),
         parentReleaseId: head?.activeBackendReleaseId || null,
-        mode: 'source_only',
+        mode: releaseMode,
+        ...(releaseMode !== 'source_only'
+          ? { replacementReason }
+          : {}),
         sourceRepositoryId: releaseContext.sourceRepositoryId,
         sourceRevision: releaseContext.sourceRevision,
         resources,
@@ -12157,10 +14142,55 @@ async function publishBackendReleaseResources(
       method: 'POST',
       body: {
         ...releaseContext.control,
+        ...(protocolVersion ? { protocolVersion } : {}),
         manifestHash: prepared.manifestHash,
       },
     }
   );
+  if (options.stageBackendReleaseOnly) {
+    const stagedRelease = {
+      ...prepared,
+      ...verified,
+      resources:
+        Array.isArray(verified.resources) && verified.resources.length > 0
+          ? verified.resources
+          : prepared.resources || [],
+    };
+    if (String(stagedRelease.status || '').toLowerCase() !== 'verified') {
+      fail('Backend Release stage-only 未获得 verified 状态，拒绝生成 stagedResource');
+    }
+    const handledKeys = new Set(
+      candidates.map(candidate => `${candidate.kind}:${candidate.code}`)
+    );
+    options.backendReleaseSourceHandledKeys = handledKeys;
+    options.backendReleaseHandledKeys = handledKeys;
+    for (const resource of stagedRelease.resources) {
+      result.published.push({
+        kind: resource.kind === 'Function' ? 'function' : 'automation',
+        code: resource.code,
+        action: resource.action === 'noop' ? 'noop' : 'stage',
+        writeMode: 'backend-release-stage',
+        backendReleaseId: stagedRelease.id,
+        activation: 'staged',
+        id:
+          resource.kind === 'Function'
+            ? resource.desired?.id || resource.resourceId
+            : resource.desired?.id || resource.resourceId,
+      });
+    }
+    result.backendRelease = backendReleaseResultSummary(
+      stagedRelease,
+      new Map(),
+      protocolVersion,
+      handledSelectors
+    );
+    if (!result.backendRelease.stagedResource) {
+      fail('Backend Release stage-only 响应缺少 verified stagedResource');
+    }
+    result.stagedResource = result.backendRelease.stagedResource;
+    result.handledSelectors = handledSelectors;
+    return;
+  }
   const activated = await requestWithAuth(
     config,
     target.profileName,
@@ -12168,7 +14198,13 @@ async function publishBackendReleaseResources(
       target,
       `/${encodeURIComponent(verified.id || prepared.id)}/activate`
     ),
-    { method: 'POST', body: releaseContext.control }
+    {
+      method: 'POST',
+      body: {
+        ...releaseContext.control,
+        ...(protocolVersion ? { protocolVersion } : {}),
+      },
+    }
   );
   options.backendReleaseSourceHandledKeys = new Set(
     candidates.map(candidate => `${candidate.kind}:${candidate.code}`)
@@ -12232,8 +14268,11 @@ async function publishBackendReleaseResources(
   }
   result.backendRelease = backendReleaseResultSummary(
     activated,
-    stateTransitions
+    stateTransitions,
+    protocolVersion,
+    handledSelectors
   );
+  result.handledSelectors = handledSelectors;
 }
 
 async function publishResourceManifest(config, target, manifest, options = {}) {
@@ -12683,9 +14722,15 @@ async function runResourceChangeBaselinePreflight(
     const artifactCache = { ...(baseline.localBaseArtifactHashes || {}) };
     const missingArtifactTargets = targets.filter(targetItem => {
       const frozen = baseline.resourceHeads?.[targetItem.kind]?.[targetItem.code];
+      const cached = artifactCache[
+        resourceBaselineTargetKey(targetItem.kind, targetItem.code)
+      ];
+      const hasStableLineage =
+        frozen?.fields?.sourceLineageHash &&
+        frozen.fields.sourceLineageHash !== canonicalJsonSha256(null);
       return (
         frozen?.fields?.sourceArtifactHash &&
-        !artifactCache[resourceBaselineTargetKey(targetItem.kind, targetItem.code)]
+        (!cached || (hasStableLineage && !cached.sourceHash))
       );
     });
     if (missingArtifactTargets.length > 0) {
@@ -12716,7 +14761,26 @@ async function runResourceChangeBaselinePreflight(
       const artifact = artifactCache[
         resourceBaselineTargetKey(targetItem.kind, targetItem.code)
       ];
-      if (artifact?.artifactHash && fields.sourceArtifactHash) {
+      const hasStableLineage =
+        fields.sourceLineageHash &&
+        fields.sourceLineageHash !== canonicalJsonSha256(null);
+      if (hasStableLineage) {
+        if (!artifact?.sourceHash) {
+          throwSourceBaseDiverged(
+            `Git 基线构建未生成稳定源码血缘: ${targetItem.kind}:${targetItem.code}`,
+            [targetItem]
+          );
+        }
+        fields.sourceLineageHash =
+          targetItem.kind === 'Automation'
+            ? canonicalJsonSha256([
+                {
+                  nodeId: '$definition',
+                  sha256: String(artifact.sourceHash).toLowerCase(),
+                },
+              ])
+            : String(artifact.sourceHash).toLowerCase();
+      } else if (artifact?.artifactHash && fields.sourceArtifactHash) {
         fields.sourceArtifactHash =
           targetItem.kind === 'Automation'
             ? canonicalJsonSha256([
@@ -13218,10 +15282,20 @@ function addPlanActions(actions, kind, desiredItems = [], existingMap, equals) {
 
 function sourceAnalysisPlanFields(item) {
   const analysis = item?.__sourceAnalysis;
-  if (!analysis) return {};
+  const definition = item?.definitionJson || {};
   return {
-    sourceDependencies: analysis.sourceDependencies,
-    resourceReferences: analysis.resourceReferences,
+    ...(analysis
+      ? {
+          sourceDependencies: analysis.sourceDependencies,
+          resourceReferences: analysis.resourceReferences,
+        }
+      : {}),
+    ...(definition.responseCache !== undefined
+      ? { responseCache: clonePlainJson(definition.responseCache) }
+      : {}),
+    ...(definition.invocationAudit !== undefined
+      ? { invocationAudit: clonePlainJson(definition.invocationAudit) }
+      : {}),
   };
 }
 
@@ -13592,6 +15666,54 @@ async function publishFormSettingsResources(
       { frozen, artifactId }
     );
     saveResourceEntry(target, 'formSettings', code, { formUuid });
+    const releaseId = data?.release?.id;
+    const contentHash = String(
+      data?.release?.contentHash || data?.contentHash || ''
+    ).toLowerCase();
+    const stagedResource =
+      data?.staged && !data?.active && releaseId
+        ? {
+            kind: 'FormRelease',
+            identity: { releaseId, formUuid },
+            action: 'update',
+            hash: contentHash,
+            revision: stripUndefinedValues({
+              parentReleaseId:
+                data?.release?.parentReleaseId ||
+                frozen.expectedParent?.releaseId ||
+                null,
+              baseRevision:
+                data?.release?.baseRevision ?? frozen.expectedParent?.revision,
+            }),
+            metadata: {
+              releaseStatus: data?.releaseStatus || 'staged',
+              formCode: code,
+            },
+          }
+        : null;
+    if (
+      !activate &&
+      !data?.noop &&
+      (!data?.staged || data?.active || !releaseId || !stagedResource)
+    ) {
+      fail(
+        `FORM_RELEASE_STAGE_REQUIRED: ${code} 的非激活 bundle 响应必须返回 staged=true、active=false、releaseId 和 contentHash`
+      );
+    }
+    if (stagedResource && !/^[a-f0-9]{64}$/.test(contentHash)) {
+      fail(
+        `FORM_RELEASE_STAGED_RESOURCE_INVALID: ${code} 的 staged FormRelease 缺少 64 位 contentHash`
+      );
+    }
+    if (stagedResource) {
+      result.stagedResources = result.stagedResources || [];
+      result.stagedResources.push(stagedResource);
+      if (result.stagedResources.length === 1) {
+        result.stagedResource = stagedResource;
+      } else {
+        delete result.stagedResource;
+      }
+    }
     result.published.push({
       kind: 'formSetting',
       code,
@@ -13602,7 +15724,9 @@ async function publishFormSettingsResources(
       staged: Boolean(data?.staged),
       active: Boolean(data?.active),
       releaseStatus: data?.releaseStatus,
-      releaseId: data?.release?.id,
+      releaseId,
+      contentHash: contentHash || undefined,
+      ...(stagedResource ? { stagedResource } : {}),
     });
   }
 }
@@ -14117,6 +16241,13 @@ async function publishFunctionResources(config, target, functions, result, optio
     ) {
       continue;
     }
+    if (functionManifestDeclaresSecretRefs(functionItem)) {
+      const error = new Error(
+        `APP_FUNCTION_SECRET_STAGED_RELEASE_REQUIRED: Function:${code} secretRefs 必须由 Backend Release v2 原子发布，禁止 direct/source PATCH 降级`
+      );
+      error.code = 'APP_FUNCTION_SECRET_STAGED_RELEASE_REQUIRED';
+      throw error;
+    }
     if (shouldSkipNoopResource(options, 'function', code)) {
       recordNoopResource(result, 'function', code, options);
       continue;
@@ -15707,6 +17838,9 @@ async function pullResources(config, target) {
       code,
       name: detail.name,
       description: detail.description || '',
+      ...(Array.isArray(detail.secretRefs)
+        ? { secretRefs: normalizeFunctionSecretRefs(detail.secretRefs) }
+        : {}),
       definitionJson: detail.definitionJson,
       resourceBindings: detail.resourceBindings || undefined,
       inputSchema: detail.inputSchema || undefined,
@@ -17262,6 +19396,15 @@ function functionEquals(target, desired, existing) {
     existing.resourceBindingsJson ??
     existing.definitionJson?.resourceBindings ??
     {};
+  const secretRefsEqual = functionManifestDeclaresSecretRefs(desired)
+    ? jsonEqualsForPlan(
+        normalizeFunctionSecretRefs(
+          existing.secretRefs ?? existing.secretReferences ?? []
+        ),
+        normalizeFunctionSecretRefs(desired.secretRefs),
+        desired.__dir
+      )
+    : true;
   return (
     String(existing.code || existing.functionCode || existing.resourceCode || '') === String(desired.code || desired.functionCode || desired.resourceCode || '') &&
     String(existing.name || '') === String(desired.name || desiredDefinition.name || desired.code || '') &&
@@ -17270,10 +19413,94 @@ function functionEquals(target, desired, existing) {
     ) &&
     jsonEqualsForPlan(existing.definitionJson, desiredDefinition, desired.__dir) &&
     jsonEqualsForPlan(existingResourceBindings, desiredDefinition.resourceBindings || {}, desired.__dir) &&
-    String(existing.status || 'active') === desiredStatus
+    String(existing.status || 'active') === desiredStatus &&
+    secretRefsEqual
+  );
+}
+
+function functionManifestDeclaresSecretRefs(functionItem) {
+  return Boolean(
+    functionItem &&
+      Object.prototype.hasOwnProperty.call(functionItem, 'secretRefs')
   );
 }
 
+function normalizeFunctionSecretRefs(value) {
+  if (!Array.isArray(value)) return [];
+  return value
+    .filter(item => item && typeof item === 'object' && !Array.isArray(item))
+    .map(item => ({
+      name: String(item.name || '').trim(),
+      required: item.required !== false,
+    }))
+    .filter(item => item.name)
+    .sort((left, right) => left.name.localeCompare(right.name));
+}
+
+function validateFunctionSecretRefs(label, item, errors) {
+  if (!functionManifestDeclaresSecretRefs(item)) return;
+  if (!Array.isArray(item.secretRefs)) {
+    errors.push(`${label}: secretRefs 必须是数组`);
+    return;
+  }
+  const names = new Set();
+  for (const [index, ref] of item.secretRefs.entries()) {
+    const refLabel = `${label}.secretRefs[${index}]`;
+    if (!ref || typeof ref !== 'object' || Array.isArray(ref)) {
+      errors.push(`${refLabel}: 必须是 {name, required} 对象`);
+      continue;
+    }
+    const extraKeys = Object.keys(ref).filter(
+      key => !['name', 'required'].includes(key)
+    );
+    if (extraKeys.length > 0) {
+      errors.push(
+        `${refLabel}: 仅允许 name/required metadata，禁止 value/file/env 等字段: ${extraKeys.join(', ')}`
+      );
+    }
+    const name = String(ref.name || '').trim();
+    if (!/^[A-Za-z][A-Za-z0-9_.-]{0,127}$/.test(name)) {
+      errors.push(`${refLabel}.name: 格式无效`);
+    } else if (names.has(name)) {
+      errors.push(`${refLabel}.name: 重复声明 ${name}`);
+    } else {
+      names.add(name);
+    }
+    if (typeof ref.required !== 'boolean') {
+      errors.push(`${refLabel}.required: 必须显式为 boolean`);
+    }
+  }
+  let definition = item.definitionJson;
+  if (!definition && item.definitionFile) {
+    try {
+      definition = resolveManifestPlainJson(
+        item,
+        'definitionJson',
+        'definitionFile'
+      );
+    } catch (error) {
+      errors.push(`${label}: 无法校验 secretRefs runtime contract: ${error.message}`);
+      return;
+    }
+  }
+  if (definition?.secretRefs !== undefined) {
+    errors.push(`${label}: secretRefs 必须位于 Function resource 顶层，不能进入 definitionJson/source snapshot`);
+  }
+  if (String(definition?.version || '') !== 'function_v2') {
+    errors.push(`${label}: 声明 secretRefs 时 definitionJson.version 必须是 function_v2`);
+  }
+  if (String(definition?.runtimeMode || '') !== 'trusted_node') {
+    errors.push(`${label}: 声明 secretRefs 时 runtimeMode 必须是 trusted_node`);
+  }
+  if (
+    String(definition?.runtimeContractVersion || '') !== 'trusted_node_v2'
+  ) {
+    errors.push(
+      `${label}: 声明 secretRefs 时 runtimeContractVersion 必须是 trusted_node_v2`
+    );
+  }
+}
+
 function normalizeFunctionDefinitionJson(functionItem, definitionJson) {
   const definition = clonePlainJson(definitionJson || {});
   const functionCode =
@@ -17472,11 +19699,37 @@ function normalizeJsonForPlan(value, baseDir, keyName) {
     result.code = result.code === undefined ? '' : result.code;
     result.runtimeMode = result.runtimeMode || 'trusted_node';
     result.sourceType = result.sourceType || 'file_snapshot';
+    const sourceProvenance = resolveLocalSourceProvenanceForPlan(
+      value.sourceFile.localPath,
+      baseDir
+    );
+    if (sourceProvenance) {
+      result.sourceProvenance = {
+        ...(result.sourceProvenance || {}),
+        ...sourceProvenance,
+      };
+    }
   }
   if (result.code === '') delete result.code;
   return sortObjectForStableJson(result);
 }
 
+function resolveLocalSourceProvenanceForPlan(localPath, baseDir) {
+  const rawLocalPath = String(localPath);
+  const baseResolvedPath = path.resolve(baseDir || process.cwd(), rawLocalPath);
+  const cwdResolvedPath = path.resolve(process.cwd(), rawLocalPath);
+  const resolvedLocalPath = fs.existsSync(baseResolvedPath)
+    ? baseResolvedPath
+    : cwdResolvedPath;
+  const sourceInfo = getJsCodeSourceInfoForPlan(resolvedLocalPath);
+  if (!sourceInfo) return null;
+  return readJsCodeSourceProvenance(
+    sourceInfo.workspaceRoot,
+    sourceInfo.sourceKind,
+    sourceInfo.scriptCode
+  );
+}
+
 function normalizeLocalSourceFileForPlan(localPath, baseDir) {
   const rawLocalPath = String(localPath);
   const baseResolvedPath = path.resolve(baseDir || process.cwd(), rawLocalPath);
@@ -17698,7 +19951,7 @@ async function resolveJsCodeSnapshotFiles(config, profileName, value, baseDir, u
     typeof value.sourceFile === 'object' &&
     value.sourceFile.localPath
   ) {
-    const sourceFile = await uploadJsCodeSnapshotFile(
+    const snapshot = await uploadJsCodeSnapshotFile(
       config,
       profileName,
       value.sourceFile.localPath,
@@ -17708,7 +19961,13 @@ async function resolveJsCodeSnapshotFiles(config, profileName, value, baseDir, u
     );
     value.runtimeMode = value.runtimeMode || 'trusted_node';
     value.sourceType = 'file_snapshot';
-    value.sourceFile = sourceFile;
+    value.sourceFile = snapshot.sourceFile;
+    if (snapshot.sourceProvenance) {
+      value.sourceProvenance = {
+        ...(value.sourceProvenance || {}),
+        ...snapshot.sourceProvenance,
+      };
+    }
     value.code = value.code || '';
   }
 
@@ -17743,6 +20002,14 @@ async function uploadJsCodeSnapshotFile(
   if (uploadCache.has(cacheKey)) return await uploadCache.get(cacheKey);
 
   const buffer = fs.readFileSync(bundlePath);
+  const sourceInfo = getJsCodeSourceInfoForPlan(resolvedLocalPath);
+  const sourceProvenance = sourceInfo
+    ? readJsCodeSourceProvenance(
+        sourceInfo.workspaceRoot,
+        sourceInfo.sourceKind,
+        sourceInfo.scriptCode
+      )
+    : null;
   const pending = requestFormWithAuth(
     config,
     profileName,
@@ -17762,10 +20029,14 @@ async function uploadJsCodeSnapshotFile(
       originalName: uploaded.originalName,
       contentType: uploaded.contentType,
     };
-    uploadCache.set(cacheKey, sourceFile);
+    const snapshot = {
+      sourceFile,
+      ...(sourceProvenance ? { sourceProvenance } : {}),
+    };
+    uploadCache.set(cacheKey, snapshot);
     // Progress belongs on stderr so `--json` keeps stdout machine-readable.
     warn(`已上传JS_CODE快照: ${path.relative(process.cwd(), bundlePath)} (${sourceFile.sha256})`);
-    return sourceFile;
+    return snapshot;
   });
   uploadCache.set(cacheKey, pending);
   try {
@@ -17776,6 +20047,38 @@ async function uploadJsCodeSnapshotFile(
   }
 }
 
+function readJsCodeSourceProvenance(workspaceRoot, sourceKind, scriptCode) {
+  const key = `${sourceKind}/${scriptCode}`;
+  for (const filename of [
+    'build-cache.json',
+    'build-cache.cli-v4.json',
+    'build-cache.cli-v3.json',
+  ]) {
+    try {
+      const cache = JSON.parse(
+        fs.readFileSync(
+          path.join(workspaceRoot, '.openxiangda', filename),
+          'utf8'
+        )
+      );
+      const metadata = cache?.targets?.[key];
+      const sourceHash = String(metadata?.sourceHash || '').toLowerCase();
+      if (!/^[a-f0-9]{64}$/.test(sourceHash)) continue;
+      return {
+        contractVersion: 'source_lineage_v1',
+        sourceHash,
+        entryPath: `src/${sourceKind}/${scriptCode}/index.ts`,
+        dependencies: Array.isArray(metadata.dependencies)
+          ? metadata.dependencies.slice().sort()
+          : [],
+      };
+    } catch {
+      // Custom workspace builders are compatible but may not emit lineage.
+    }
+  }
+  return null;
+}
+
 async function resolveJsCodeBundlePath(localPath, scriptCode) {
   const extension = path.extname(localPath).toLowerCase();
   if (['.js', '.cjs', '.mjs'].includes(extension)) {
@@ -17837,10 +20140,10 @@ async function resolveJsCodeBundlePath(localPath, scriptCode) {
 }
 
 function runWorkspaceJsCodeBuild(workspaceRoot, resolvedScriptCode, sourceKind) {
-  return spawnSync('pnpm', ['build-js-code', '--script', resolvedScriptCode, '--source', sourceKind], {
-    cwd: workspaceRoot,
-    encoding: 'utf8',
-  });
+  return runWorkspaceJsCodeBuildBatch(
+    workspaceRoot,
+    [{ sourceKind, scriptCode: resolvedScriptCode }]
+  );
 }
 
 function isUnsupportedFunctionsBuildScript(result) {
@@ -18154,26 +20457,7 @@ function getChangedManifestResourceCodes(file, resourceKey, baseRef = 'HEAD') {
 }
 
 function shouldReplaceResourceManifestItem(item, resourceKey, code, options = {}) {
-  if (options.replaceManifest) return true;
-  if (!item?.__source) return false;
-  const relativeFile = normalizeWorkspaceRelativePath(
-    path.relative(process.cwd(), path.resolve(item.__source))
-  );
-  const scopedFiles = new Set(
-    (options.scopedFiles || []).map(normalizeWorkspaceRelativePath)
-  );
-  if (!scopedFiles.has(relativeFile)) return false;
-  const changedCodes = getChangedManifestResourceCodes(
-    relativeFile,
-    resourceKey,
-    options.baseRef || 'HEAD'
-  );
-  if (changedCodes.length === 0) {
-    // The SDD/change scope may refer to a committed manifest change that no
-    // longer differs from HEAD inside the release worktree.
-    return true;
-  }
-  return changedCodes.includes(String(code));
+  return options.replaceManifest === true;
 }
 
 function buildAutomationSourcePatchSources(existingDefinition, desiredDefinition) {
@@ -18527,19 +20811,27 @@ function scanWorkspaceReliabilityIssues(files) {
 
 function buildTargetedResourceReleaseCommands(targets, profileArg, changeId) {
   const changeArg = changeId ? ` --change ${changeId}` : '';
-  if (targets.resources || (targets.jsCodeNodes || []).length > 0) {
-    return [`openxiangda resource publish --profile ${profileArg}${changeArg}`];
-  }
   const commands = [];
-  for (const [targetKey, resourceType] of [
-    ['functions', 'function'],
-    ['automations', 'automation'],
-    ['workflows', 'workflow'],
-  ]) {
-    const codes = targets[targetKey] || [];
-    if (codes.length === 0) continue;
+  const functions = targets.functions || [];
+  const automations = targets.automations || [];
+  if (functions.length > 0 || automations.length > 0) {
+    const resourceTypes = [
+      ...(functions.length > 0 ? ['function'] : []),
+      ...(automations.length > 0 ? ['automation'] : []),
+    ];
+    const qualify = resourceTypes.length > 1;
+    const selectors = [
+      ...functions.map(code => (qualify ? `function:${code}` : code)),
+      ...automations.map(code => (qualify ? `automation:${code}` : code)),
+    ];
+    commands.push(
+      `openxiangda resource publish ${resourceTypes.join(',')} --only ${selectors.join(',')} --stage-only --profile ${profileArg}${changeArg}`
+    );
+  }
+  const workflows = targets.workflows || [];
+  if (workflows.length > 0) {
     commands.push(
-      `openxiangda resource publish ${resourceType} --only ${codes.join(',')} --profile ${profileArg}${changeArg}`
+      `openxiangda resource publish workflow --only ${workflows.join(',')} --profile ${profileArg}${changeArg}`
     );
   }
   return commands;
@@ -18555,9 +20847,9 @@ function buildWorkspaceReleaseCommands(targets, runtimeMode, profile, changeId)
     (targets.workflows || []).length > 0 ||
     (targets.jsCodeNodes || []).length > 0;
   if (runtimeMode === 'react-spa') {
-    for (const formCode of targets.forms) {
+    if (targets.forms.length > 0) {
       commands.push(
-        `openxiangda workspace publish --profile ${profileArg} --form ${formCode}${changeId ? ` --change ${changeId}` : ''}`
+        `openxiangda resource publish form-setting --only ${targets.forms.join(',')} --profile ${profileArg}${changeId ? ` --change ${changeId}` : ''}`
       );
     }
     if (hasResourceTargets) {
@@ -18565,7 +20857,17 @@ function buildWorkspaceReleaseCommands(targets, runtimeMode, profile, changeId)
     }
     if (targets.runtime) {
       commands.push(
-        `openxiangda runtime deploy --profile ${profileArg}${changeId ? ` --change ${changeId}` : ''}`
+        `openxiangda runtime deploy --no-activate --profile ${profileArg}${changeId ? ` --change ${changeId}` : ''}`
+      );
+    }
+    if (
+      targets.forms.length > 0 ||
+      (targets.functions || []).length > 0 ||
+      (targets.automations || []).length > 0 ||
+      targets.runtime
+    ) {
+      commands.push(
+        `openxiangda release app-finalize --staged-resources-json .openxiangda/releases/${changeId || 'change'}/staged-resources.json --profile ${profileArg}${changeId ? ` --change ${changeId}` : ''}`
       );
     }
     return commands;
@@ -18629,12 +20931,35 @@ function buildWorkspaceReleasePlan(options = {}) {
       name: issue.rule,
       message: `${issue.file}:${issue.line} ${issue.message}`,
     }));
-  const commands = buildWorkspaceReleaseCommands(
+  const generatedCommands = buildWorkspaceReleaseCommands(
     targets,
     runtimeMode,
     options.profile,
     changeScope?.changeId
   );
+  const commands =
+    changeScope?.commands?.length > 0
+      ? [...changeScope.commands]
+      : generatedCommands;
+  if (!changeScope?.commands?.length && targets.resources) {
+    errors.push({
+      name: 'sdd-release-generic-resource-selector-required',
+      message:
+        '变更包含尚未归一化为 code 的通用资源；已保留可确定的 Function/Automation/Workflow 命令，请在 release.json.commands 中补一条精确 --only/--code 命令覆盖剩余资源。',
+    });
+  }
+  if (
+    !changeScope?.commands?.length &&
+    (targets.jsCodeNodes || []).length > 0 &&
+    (targets.functions || []).length === 0 &&
+    (targets.automations || []).length === 0 &&
+    (targets.workflows || []).length === 0
+  ) {
+    errors.push({
+      name: 'sdd-release-js-code-owner-required',
+      message: `JS_CODE 源码尚未映射到可发布资源: ${targets.jsCodeNodes.join(', ')}；请在 coverage/release 中声明所属 Function、Automation 或 Workflow。`,
+    });
+  }
   const sdd = options.skipSdd
     ? null
       : buildSddGovernanceReport({
@@ -18749,6 +21074,7 @@ function buildExplicitSddReleasePlan(targets, options = {}) {
     commands,
     changeId: options.changeId,
     verifyStage: options.verifyStage || 'prepublish',
+    actualCommands: options.actualCommands === true,
   });
   return {
     targets,
@@ -18760,6 +21086,21 @@ function buildExplicitSddReleasePlan(targets, options = {}) {
 
 function assertSddReleaseGate(plan, flags, command) {
   if (!plan?.sdd || plan.sdd.errors.length === 0) return;
+  const nonBypassable = new Set([
+    'sdd-release-direct-form-schema-forbidden',
+    'sdd-release-direct-form-activation-forbidden',
+    'sdd-release-resource-scope-missing',
+    'sdd-release-runtime-direct-activation-forbidden',
+    'sdd-release-backend-direct-activation-forbidden',
+    'sdd-release-backend-scope-inexact',
+    'sdd-release-form-scope-inexact',
+  ]);
+  const hardFailure = plan.sdd.errors.find(error =>
+    nonBypassable.has(error.name)
+  );
+  if (hardFailure) {
+    fail(`${hardFailure.message}\n该原子发布安全门禁不可通过 --sdd-bypass 绕过。`);
+  }
   if (flags['sdd-bypass']) {
     const bypass = appendBypassLog({
       cwd: process.cwd(),