scene-capability-engine 3.6.56 → 3.6.57

package/CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.6.57] - 2026-03-17
+
+### Added
+- Added a read-only `strategy_assessment` advisory to `sce spec gate run --spec <id>` and `sce spec pipeline run --spec <id>` single-Spec output so workflow consumers can see when the current Spec should escalate to `multi-spec-program` or `research-program`.
+
+### Changed
+- Human-readable `spec gate` and `spec pipeline` output now print an explicit strategy advisory for broad or clarification-heavy Specs, without auto-rerouting execution or changing the underlying execution decision itself.
+- Shared project problem projection sync is now idempotent when content does not change, so collaboration governance checks no longer dirty the worktree just by refreshing `generated_at`.
+
 ## [3.6.56] - 2026-03-17
 
 ### Added

package/README.md

@@ -140,6 +140,7 @@ SCE is opinionated by default.
 
 - `studio plan` runs intake and scene/spec governance unless policy explicitly allows bypass.
 - When business scene/module/page/entity context is missing, SCE must route to clarification first; unknown business scope must not be turned into blanket disable.
+- `spec pipeline` and `spec gate` now carry a read-only strategy advisory for single-Spec runs, so broad or clarification-heavy work is surfaced as `multi-spec-program` / `research-program` instead of being blindly forced deeper into one Spec.
 - `verify` and `release` enforce problem-closure and related gates when a spec is bound.
 - Autonomous program execution applies gate evaluation, fallback-chain logic, governance replay, and auto-remediation.
 - Co-work baseline is enabled by default: initialized/adopted SCE projects provision `.sce/config/multi-agent.json` with `enabled=true`, while the central coordinator stays opt-in.
@@ -227,5 +228,5 @@ MIT. See [LICENSE](LICENSE).
 
 ---
 
-**Version**: 3.6.56
+**Version**: 3.6.57
 **Last Updated**: 2026-03-17

package/README.zh.md

@@ -145,6 +145,7 @@ SCE 默认是强治理的。
 
 - `studio plan` 默认执行 intake 与 scene/spec 治理，除非策略显式允许绕过
 - 缺少业务场景/模块/页面/实体上下文时，SCE 必须先进入澄清，而不是把未知业务范围直接变成一刀切禁用
+- 单 spec 的 `spec pipeline` 和 `spec gate` 现在都会附带只读策略建议；当问题已经更适合 `multi-spec-program` / `research-program` 时，SCE 会显式提示，而不是继续把复杂问题盲目压进同一个 spec
 - 当 spec 绑定时，`verify` 和 `release` 默认执行 problem-closure 等相关门禁
 - `close-loop-program` 默认带 gate 评估、fallback-chain、governance replay、auto-remediation
 - co-work 基线默认开启：初始化或接管后的 SCE 项目会落地 `.sce/config/multi-agent.json` 且 `enabled=true`，但中央 coordinator 仍保持按需开启
@@ -232,5 +233,5 @@ MIT，见 [LICENSE](LICENSE)。
 
 ---
 
-**版本**：3.6.56
+**版本**：3.6.57
 **最后更新**：2026-03-17

package/docs/autonomous-control-guide.md

@@ -97,6 +97,8 @@ Suggested preflight:
 sce spec strategy assess --goal "broad complex goal" --json
 ```
 
+If you are already inside a single Spec flow, `sce spec gate run --spec <spec-id>` and `sce spec pipeline run --spec <spec-id>` now echo the same strategy concern as a non-blocking advisory when one Spec is no longer the right execution container.
+
 # Controller command: drain queue goals with autonomous close-loop-program runtime
 sce auto close-loop-controller .sce/auto/program-queue.lines \
   --dequeue-limit 2 \

package/docs/command-reference.md

@@ -101,6 +101,10 @@ Spec session governance:
 - When multiple active scenes exist, you must pass `--scene` explicitly.
 - Multi-Spec orchestrate fallback (`--specs ...`) follows the same scene binding and writes per-spec child-session archive records.
 - `sce spec strategy assess` is read-only and should be used when you are not sure whether the current problem still fits one Spec.
+- `sce spec pipeline run --spec <id> --json` now includes the same read-only `strategy_assessment` block for single-Spec runs.
+- `sce spec gate run --spec <id> --json` now includes a read-only `strategy_assessment` block for single-Spec runs.
+- Human-readable `spec gate` output now prints a strategy advisory when the assessed decision is `multi-spec-program` or `research-program`, but it does not auto-reroute execution.
+- Human-readable `spec pipeline` output now prints the same advisory after stage results for single-Spec runs.
 - `spec bootstrap` always generates problem-domain, scene-spec, and `problem-contract` artifacts to force domain-first exploration.
 - `spec gate` now hard-fails when either of the following is missing or structurally incomplete:
   - `.sce/specs/<spec>/custom/problem-domain-map.md`

package/docs/releases/README.md

@@ -9,6 +9,7 @@ This directory stores release-facing documents:
 ## Archived Versions
 
 - [Release checklist](../release-checklist.md)
+- [v3.6.57 release notes](./v3.6.57.md)
 - [v3.6.56 release notes](./v3.6.56.md)
 - [v3.6.55 release notes](./v3.6.55.md)
 - [v3.6.54 release notes](./v3.6.54.md)

package/docs/releases/v3.6.57.md

@@ -0,0 +1,19 @@
+# v3.6.57 Release Notes
+
+Release date: 2026-03-17
+
+## Highlights
+
+- Added a read-only `strategy_assessment` block to single-Spec `sce spec gate run` and `sce spec pipeline run` output.
+- Human-readable gate and pipeline flows now explicitly warn when a problem no longer fits one Spec and should escalate to `multi-spec-program` or `research-program`.
+- Kept the integration conservative: SCE now surfaces the strategy mismatch early, but it does not auto-reroute execution or silently create more Specs.
+- Fixed shared project problem projection sync to be idempotent when payload content is unchanged, preventing release/push governance from dirtying the worktree with timestamp-only rewrites.
+
+## Validation
+
+- `npx jest tests/unit/commands/spec-gate.test.js tests/unit/commands/spec-pipeline.test.js --runInBand`
+- `node scripts/release-doc-version-audit.js --fail-on-error`
+
+## Release Notes
+
+- This patch closes the last obvious gap in the complex-problem strategy line added in `v3.6.56`. SCE could already assess whether a goal or Spec was too broad for one Spec; now the same judgment is visible inside the normal single-Spec execution path, so teams get an explicit warning before continuing blind decomposition in the wrong container. It also fixes a co-work publication edge case where project-shared problem projection refresh could dirty the repository even when nothing meaningful changed.

package/docs/spec-workflow.md

@@ -146,6 +146,8 @@ sce spec bootstrap --specs "spec-a,spec-b" --max-parallel 3
 sce auto close-loop-program "broad complex goal" --program-goals 4 --json
 ```
 
+`sce spec gate run --spec <spec-id>` and `sce spec pipeline run --spec <spec-id>` now both carry a read-only strategy advisory for single-Spec runs. If the current Spec is assessed as `multi-spec-program` or `research-program`, SCE surfaces that explicitly instead of silently pushing more decomposition into the same Spec.
+
 The strategic gap currently being formalized is:
 
 - how SCE should assess this threshold explicitly

package/docs/zh/releases/README.md

@@ -9,6 +9,7 @@
 ## 历史版本归档
 
 - [发布检查清单](../release-checklist.md)
+- [v3.6.57 发布说明](./v3.6.57.md)
 - [v3.6.56 发布说明](./v3.6.56.md)
 - [v3.6.55 发布说明](./v3.6.55.md)
 - [v3.6.54 发布说明](./v3.6.54.md)

package/docs/zh/releases/v3.6.57.md

@@ -0,0 +1,19 @@
+# v3.6.57 发布说明
+
+发布日期：2026-03-17
+
+## 重点变化
+
+- 为单 spec 的 `sce spec gate run` 和 `sce spec pipeline run` 输出增加只读 `strategy_assessment` 字段。
+- 当问题已经不适合继续塞进一个 spec，而应升级为 `multi-spec-program` 或 `research-program` 时，gate 和 pipeline 的人类可读输出会明确给出提示。
+- 这次集成保持保守：SCE 会尽早暴露策略不匹配，但不会擅自改道执行，也不会静默创建更多 spec。
+- 修复共享问题投影同步的幂等性；当内容未变化时，不再只因 `generated_at` 刷新就把仓库重新写脏，避免 push / 发版治理被时间戳漂移误伤。
+
+## 验证
+
+- `npx jest tests/unit/commands/spec-gate.test.js tests/unit/commands/spec-pipeline.test.js --runInBand`
+- `node scripts/release-doc-version-audit.js --fail-on-error`
+
+## 发布说明
+
+- 这个补丁版把 `v3.6.56` 刚加上的复杂问题策略评估真正接入到了日常单 spec 主路径。现在 SCE 不只是“能评估”，而是会在正常的 gate / pipeline 过程中显式提醒：当前问题已经不该继续在一个 spec 里盲拆，而应升级为更合适的 program 路径。同时也修掉了 co-work 发布链路上的一个实际阻断点：共享问题投影在内容不变时不应因为时间戳刷新而制造脏工作区。

package/lib/commands/spec-gate.js

@@ -15,9 +15,11 @@ const { ResultEmitter } = require('../spec-gate/result-emitter');
 const { SessionStore } = require('../runtime/session-store');
 const { resolveSpecSceneBinding } = require('../runtime/scene-session-binding');
 const { bindMultiSpecSceneSession } = require('../runtime/multi-spec-scene-session');
+const { assessComplexityStrategy } = require('../spec/complexity-strategy');
 
 async function runSpecGate(options = {}, dependencies = {}) {
   const projectPath = dependencies.projectPath || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
   const sessionStore = dependencies.sessionStore || new SessionStore(projectPath);
   const specTargets = parseSpecTargets(options);
 
@@ -43,7 +45,7 @@ async function runSpecGate(options = {}, dependencies = {}) {
       })
     }, {
       projectPath,
-      fileSystem: dependencies.fileSystem || fs,
+      fileSystem,
       sessionStore
     });
   }
@@ -51,7 +53,7 @@ async function runSpecGate(options = {}, dependencies = {}) {
   const specId = specTargets[0];
 
   const specPath = path.join(projectPath, '.sce', 'specs', specId);
-  if (!await fs.pathExists(specPath)) {
+  if (!await fileSystem.pathExists(specPath)) {
     throw new Error(`Spec not found: ${specId}`);
   }
 
@@ -60,7 +62,7 @@ async function runSpecGate(options = {}, dependencies = {}) {
     allowNoScene: false
   }, {
     projectPath,
-    fileSystem: dependencies.fileSystem || fs,
+    fileSystem,
     sessionStore
   });
   const linked = await sessionStore.startSpecSession({
@@ -83,13 +85,22 @@ async function runSpecGate(options = {}, dependencies = {}) {
       policy
     });
 
-    const result = await engine.evaluate({ specId });
+    const gateResult = await engine.evaluate({ specId });
+    const result = {
+      ...gateResult,
+      strategy_assessment: await buildStrategyAssessment(specId, {
+        projectPath,
+        fileSystem,
+        strategyAssessor: dependencies.strategyAssessor
+      })
+    };
     const emitter = dependencies.emitter || new ResultEmitter(projectPath);
     const emitted = await emitter.emit(result, {
       json: options.json,
       out: options.out,
       silent: options.silent
     });
+    emitStrategyAdvisory(result.strategy_assessment, options);
 
     const decisionStatus = result.decision === 'no-go' ? 'failed' : 'completed';
     await sessionStore.completeSpecSession({
@@ -101,7 +112,8 @@ async function runSpecGate(options = {}, dependencies = {}) {
         spec: specId,
         decision: result.decision,
         score: result.score,
-        report_path: emitted.outputPath || null
+        report_path: emitted.outputPath || null,
+        strategy_decision: result.strategy_assessment ? result.strategy_assessment.decision : null
       }
     });
 
@@ -132,6 +144,43 @@ async function runSpecGate(options = {}, dependencies = {}) {
   }
 }
 
+async function buildStrategyAssessment(specId, dependencies = {}) {
+  const assess = dependencies.strategyAssessor || assessComplexityStrategy;
+  try {
+    return await assess({
+      spec: specId
+    }, {
+      projectPath: dependencies.projectPath,
+      fileSystem: dependencies.fileSystem
+    });
+  } catch (error) {
+    return {
+      decision: 'assessment-unavailable',
+      decision_reason: error.message,
+      advisory_only: true
+    };
+  }
+}
+
+function emitStrategyAdvisory(strategyAssessment, options = {}) {
+  if (!strategyAssessment || options.json || options.silent) {
+    return;
+  }
+
+  if (!['multi-spec-program', 'research-program'].includes(strategyAssessment.decision)) {
+    return;
+  }
+
+  console.log();
+  console.log(chalk.yellow('⚠ Strategy Advisory'));
+  console.log(`  ${strategyAssessment.decision}: ${strategyAssessment.decision_reason}`);
+  if (Array.isArray(strategyAssessment.next_actions)) {
+    strategyAssessment.next_actions.forEach(action => {
+      console.log(`  - ${action}`);
+    });
+  }
+}
+
 async function generateSpecGatePolicyTemplate(options = {}, dependencies = {}) {
   const projectPath = dependencies.projectPath || process.cwd();
   const loader = dependencies.policyLoader || new PolicyLoader(projectPath);
@@ -220,5 +269,7 @@ module.exports = {
   registerSpecGateCommand,
   runSpecGate,
   generateSpecGatePolicyTemplate,
-  _parseSpecTargets
+  _parseSpecTargets,
+  buildStrategyAssessment,
+  emitStrategyAdvisory
 };

package/lib/commands/spec-pipeline.js

@@ -13,9 +13,11 @@ const { createDefaultStageAdapters } = require('../spec/pipeline/stage-adapters'
 const { SessionStore } = require('../runtime/session-store');
 const { resolveSpecSceneBinding } = require('../runtime/scene-session-binding');
 const { bindMultiSpecSceneSession } = require('../runtime/multi-spec-scene-session');
+const { buildStrategyAssessment, emitStrategyAdvisory } = require('./spec-gate');
 
 async function runSpecPipeline(options = {}, dependencies = {}) {
   const projectPath = dependencies.projectPath || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
   const sessionStore = dependencies.sessionStore || new SessionStore(projectPath);
   const specTargets = parseSpecTargets(options);
   if (specTargets.length === 0) {
@@ -40,7 +42,7 @@ async function runSpecPipeline(options = {}, dependencies = {}) {
       })
     }, {
       projectPath,
-      fileSystem: dependencies.fileSystem || fs,
+      fileSystem,
       sessionStore
     });
   }
@@ -48,7 +50,7 @@ async function runSpecPipeline(options = {}, dependencies = {}) {
   const specId = specTargets[0];
 
   const specPath = path.join(projectPath, '.sce', 'specs', specId);
-  if (!await fs.pathExists(specPath)) {
+  if (!await fileSystem.pathExists(specPath)) {
     throw new Error(`Spec not found: ${specId}`);
   }
 
@@ -57,7 +59,7 @@ async function runSpecPipeline(options = {}, dependencies = {}) {
     allowNoScene: false
   }, {
     projectPath,
-    fileSystem: dependencies.fileSystem || fs,
+    fileSystem,
     sessionStore
   });
 
@@ -130,6 +132,11 @@ async function runSpecPipeline(options = {}, dependencies = {}) {
     status: execution.status,
     stage_results: execution.stageResults,
     failure: execution.failure,
+    strategy_assessment: await buildStrategyAssessment(specId, {
+      projectPath,
+      fileSystem,
+      strategyAssessor: dependencies.strategyAssessor
+    }),
     next_actions: buildNextActions(execution),
     state_file: path.relative(projectPath, stateStore.getRunPath(specId, state.run_id)),
     scene_session: sceneBinding
@@ -156,7 +163,8 @@ async function runSpecPipeline(options = {}, dependencies = {}) {
         spec: specId,
         run_id: state.run_id,
         pipeline_status: execution.status,
-        failure: execution.failure || null
+        failure: execution.failure || null,
+        strategy_decision: result.strategy_assessment ? result.strategy_assessment.decision : null
       }
     });
   }
@@ -174,6 +182,7 @@ async function runSpecPipeline(options = {}, dependencies = {}) {
     console.log(JSON.stringify(result, null, 2));
   } else {
     printResult(result);
+    emitStrategyAdvisory(result.strategy_assessment, options);
   }
 
   return result;

package/lib/problem/project-problem-projection.js

@@ -82,6 +82,31 @@ function toRelativePosix(projectPath, absolutePath) {
   return path.relative(projectPath, absolutePath).replace(/\\/g, '/');
 }
 
+function sortKeysDeep(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => sortKeysDeep(item));
+  }
+  if (!value || typeof value !== 'object') {
+    return value;
+  }
+  const sorted = {};
+  Object.keys(value).sort().forEach((key) => {
+    sorted[key] = sortKeysDeep(value[key]);
+  });
+  return sorted;
+}
+
+function toComparableProjection(payload) {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    return null;
+  }
+  const clone = {
+    ...payload
+  };
+  delete clone.generated_at;
+  return sortKeysDeep(clone);
+}
+
 async function buildProjectSharedProblemProjection(projectPath = process.cwd(), options = {}, dependencies = {}) {
   const fileSystem = dependencies.fileSystem || fs;
   const studioIntakePolicy = dependencies.studioIntakePolicy || await loadStudioIntakePolicy(projectPath, fileSystem);
@@ -212,6 +237,24 @@ async function syncProjectSharedProblemProjection(projectPath = process.cwd(), o
     ...dependencies,
     problemClosurePolicyBundle: closurePolicy
   });
+  const existing = await readJsonSafe(absolutePath, fileSystem);
+  const existingComparable = toComparableProjection(existing);
+  const nextComparable = toComparableProjection(payload);
+
+  if (
+    existingComparable
+    && nextComparable
+    && JSON.stringify(existingComparable) === JSON.stringify(nextComparable)
+  ) {
+    return {
+      mode: 'project-problem-projection-sync',
+      enabled: true,
+      file: absolutePath,
+      scope: projectionConfig.scope,
+      total_entries: Number(payload.summary.total_entries || payload.entries.length || 0),
+      refreshed: false
+    };
+  }
 
   await fileSystem.ensureDir(path.dirname(absolutePath));
   await fileSystem.writeJson(absolutePath, payload, { spaces: 2 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scene-capability-engine",
-  "version": "3.6.56",
+  "version": "3.6.57",
   "description": "SCE (Scene Capability Engine) - A CLI tool and npm package for spec-driven development with AI coding assistants.",
   "main": "index.js",
   "bin": {

package/template/.sce/README.md

@@ -243,6 +243,6 @@ A Spec is a complete feature definition with three parts:
 ---
 
 **Project Type**: Spec-driven development  
-**sce Version**: 3.6.56  
+**sce Version**: 3.6.57  
 **Last Updated**: 2026-03-17  
 **Purpose**: Guide AI tools to work effectively with this project