scene-capability-engine 3.5.0 → 3.5.1

package/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.5.1] - 2026-03-03
+
+### Added
+- Studio historical scene backfill command:
+  - `sce studio backfill-spec-scenes`
+  - supports active-only/default batch backfill and writes `.sce/spec-governance/spec-scene-overrides.json`
+  - optionally refreshes governance artifacts after apply
+
+### Changed
+- Studio intake/governance policy is now stricter by default:
+  - `allow_manual_spec_override=false` blocks `--manual-spec` bypass unless explicitly enabled
+  - `governance.require_auto_on_plan=true` blocks `--no-spec-governance` bypass unless explicitly enabled
+- Spec governance and related-spec lookup now read scene override mappings from `.sce/spec-governance/spec-scene-overrides.json`.
+- Takeover/adoption baseline now provisions the stricter intake policy and backfill defaults.
+
 ## [3.5.0] - 2026-03-02
 
 ### Added

package/README.md

@@ -108,6 +108,8 @@ Hard rule defaults:
 - After two failed rounds on the same problem fingerprint, debug evidence is required in subsequent attempts.
 - `studio verify/release` run `problem-closure-gate` by default when a spec is bound.
 - `studio plan` auto-runs goal intake (`bind existing spec` or `create spec`) and writes scene portfolio governance snapshots by default.
+- `studio plan --manual-spec` and `--no-spec-governance` are blocked by default policy; use policy overrides only when absolutely necessary.
+- Historical specs can be scene-governed incrementally via `sce studio backfill-spec-scenes --apply` (writes `.sce/spec-governance/spec-scene-overrides.json`).
 
 ---
 
@@ -130,6 +132,7 @@ SCE is tool-agnostic and works with Codex, Claude Code, Cursor, Windsurf, VS Cod
 
 ## Important Version Changes
 
+- `3.5.1`: Enforced stricter Studio intake defaults (`--manual-spec` and `--no-spec-governance` blocked unless policy override), added historical spec scene backfill command (`sce studio backfill-spec-scenes`) and persisted override mapping (`.sce/spec-governance/spec-scene-overrides.json`) for portfolio/related-spec alignment.
 - `3.5.0`: Added Studio automatic goal intake + scene spec portfolio governance (`sce studio intake`, `sce studio portfolio`), including default intake policy baseline and governance artifacts for bounded scene spec growth.
 - `3.4.6`: Added default `problem-closure-gate` + `problem-contract` baseline and strengthened mandatory problem evaluation dimensions (`problem_contract`/`ontology_alignment`/`convergence`) for verify/release convergence control.
 - `3.4.5`: `git-managed-gate` now treats worktree checks as advisory in default relaxed CI mode (`CI/GITHUB_ACTIONS`, non-strict), preventing false release blocking.
@@ -177,5 +180,5 @@ MIT. See [LICENSE](LICENSE).
 
 ---
 
-**Version**: 3.5.0  
-**Last Updated**: 2026-03-02
+**Version**: 3.5.1  
+**Last Updated**: 2026-03-03

package/README.zh.md

@@ -108,6 +108,8 @@ SCE 默认按“问题域闭环”推进诊断与修复：
 - 同一问题指纹失败两轮后，后续尝试必须补充 debug 证据。
 - 当 spec 绑定时，`studio verify/release` 默认执行 `problem-closure-gate`。
 - `studio plan` 默认执行目标 intake（自动绑定已有 spec 或新建 spec），并自动写入 scene 维度的 spec 治理快照。
+- 默认策略会阻断 `studio plan --manual-spec` 与 `--no-spec-governance`（仅在确有必要且策略显式放开时可绕过）。
+- 历史 spec 可通过 `sce studio backfill-spec-scenes --apply` 分批回填到 scene 治理映射（写入 `.sce/spec-governance/spec-scene-overrides.json`）。
 
 ---
 
@@ -130,6 +132,7 @@ SCE 对工具无锁定，可接入 Codex、Claude Code、Cursor、Windsurf、VS
 
 ## 重要版本变更
 
+- `3.5.1`：默认强化 Studio intake 治理（`--manual-spec`、`--no-spec-governance` 在未显式放开策略时会被阻断），新增历史 spec 场景回填命令 `sce studio backfill-spec-scenes`，并写入 `.sce/spec-governance/spec-scene-overrides.json` 以统一 portfolio 与 related-spec 的场景映射。
 - `3.5.0`：新增 Studio 目标自动 intake + 场景 spec 组合治理（`sce studio intake`、`sce studio portfolio`），并默认启用 intake 策略基线与治理快照产物，控制场景内 spec 无序增长。
 - `3.4.6`：新增默认 `problem-closure-gate` + `problem-contract` 基线，并强化问题评估强制维度（`problem_contract`/`ontology_alignment`/`convergence`），提升 verify/release 收敛控制。
 - `3.4.5`：`git-managed-gate` 在默认 CI 放宽模式下（`CI/GITHUB_ACTIONS` 且非 strict）对工作区变更改为告警，不再误阻断发布。
@@ -177,5 +180,5 @@ MIT，见 [LICENSE](LICENSE)。
 
 ---
 
-**版本**：3.5.0  
-**最后更新**：2026-03-02
+**版本**：3.5.1  
+**最后更新**：2026-03-03

package/docs/command-reference.md

@@ -523,8 +523,6 @@ Curated quality policy (`宁缺毋滥，优胜略汰`) defaults:
 sce studio plan --scene scene.customer-order-inventory --from-chat session-20260226 --goal "customer+order+inventory demo" --json
 # Recommended: bind spec explicitly so Studio can ingest problem-domain-chain deterministically
 sce studio plan --scene scene.customer-order-inventory --spec 01-00-customer-order-inventory --from-chat session-20260226 --goal "customer+order+inventory demo" --json
-# Disable auto intake for emergency/manual mode
-sce studio plan --scene scene.customer-order-inventory --from-chat session-20260226 --goal "customer+order+inventory demo" --manual-spec --json
 
 # Analyze intake decision only (no write by default)
 sce studio intake --scene scene.customer-order-inventory --from-chat session-20260226 --goal "optimize checkout retry flow" --json
@@ -560,6 +558,11 @@ sce studio rollback --job <job-id> --reason "manual-check-failed" --json
 sce studio portfolio --json
 sce studio portfolio --scene scene.customer-order-inventory --strict --json
 
+# Backfill historical spec scene bindings into override map (active-only by default)
+sce studio backfill-spec-scenes --apply --json
+# Backfill a bounded batch from unassigned scene and refresh governance snapshot
+sce studio backfill-spec-scenes --scene scene.unassigned --limit 20 --apply --json
+
 # Enforce authorization for a protected action
 SCE_STUDIO_REQUIRE_AUTH=1 SCE_STUDIO_AUTH_PASSWORD=top-secret sce studio apply --job <job-id> --auth-password top-secret --json
 ```
@@ -570,12 +573,17 @@ Stage guardrails are enforced by default:
   - detect goal intent (`change_request` vs `analysis_only`)
   - resolve spec via explicit binding / scene latest / related specs / auto-create
   - auto-create spec artifacts when no suitable spec is found and policy requires tracking
+- `plan --manual-spec` is blocked by default (`allow_manual_spec_override=false`)
+- `plan --no-spec-governance` is blocked by default (`governance.require_auto_on_plan=true`)
 - `plan --spec <id>` (recommended) ingests `.sce/specs/<spec>/custom/problem-domain-chain.json` into studio job context
 - when `--spec` is omitted, `plan` auto-resolves the latest matching spec chain by `scene_id` when available
 - `plan` auto-searches related historical specs by `scene + goal` and writes top candidates into job metadata (`source.related_specs`)
 - `plan` auto-runs scene spec governance snapshot and writes:
   - `.sce/spec-governance/scene-portfolio.latest.json`
   - `.sce/spec-governance/scene-index.json`
+- historical spec scene backfill can be managed via:
+  - `sce studio backfill-spec-scenes --apply`
+  - writes `.sce/spec-governance/spec-scene-overrides.json`
 - successful `release` auto-archives current scene session and auto-opens the next scene cycle session
 - `generate` requires `plan`
 - `generate` consumes the plan-stage domain-chain context and writes chain-aware metadata/report (`.sce/reports/studio/generate-<job-id>.json`)
@@ -657,13 +665,21 @@ Studio intake policy file (default, recommended to commit): `.sce/config/studio-
   "enabled": true,
   "auto_create_spec": true,
   "force_spec_for_studio_plan": true,
+  "allow_manual_spec_override": false,
   "prefer_existing_scene_spec": true,
   "related_spec_min_score": 45,
   "governance": {
     "auto_run_on_plan": true,
+    "require_auto_on_plan": true,
     "max_active_specs_per_scene": 3,
     "stale_days": 14,
     "duplicate_similarity_threshold": 0.66
+  },
+  "backfill": {
+    "enabled": true,
+    "active_only_default": true,
+    "default_scene_id": "scene.sce-core",
+    "override_file": ".sce/spec-governance/spec-scene-overrides.json"
   }
 }
 ```

package/lib/commands/studio.js

@@ -12,8 +12,10 @@ const { findRelatedSpecs } = require('../spec/related-specs');
 const { captureTimelineCheckpoint } = require('../runtime/project-timeline');
 const { runProblemEvaluation } = require('../problem/problem-evaluator');
 const {
+  loadStudioIntakePolicy,
   runStudioAutoIntake,
-  runStudioSpecGovernance
+  runStudioSpecGovernance,
+  runStudioSceneBackfill
 } = require('../studio/spec-intake-governor');
 
 const STUDIO_JOB_API_VERSION = 'sce.studio.job/v0.1';
@@ -1358,6 +1360,20 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
     throw new Error('--scene is required');
   }
 
+  const intakePolicyBundle = await loadStudioIntakePolicy(projectPath, fileSystem);
+  const intakePolicy = intakePolicyBundle.policy || {};
+  const governancePolicy = intakePolicy.governance || {};
+  if (manualSpecMode && intakePolicy.allow_manual_spec_override !== true) {
+    throw new Error(
+      '--manual-spec is disabled by studio intake policy (allow_manual_spec_override=false)'
+    );
+  }
+  if (skipSpecGovernance && governancePolicy.require_auto_on_plan !== false) {
+    throw new Error(
+      '--no-spec-governance is disabled by studio intake policy (governance.require_auto_on_plan=true)'
+    );
+  }
+
   let domainChainBinding = await resolveDomainChainBinding({
     sceneId,
     specId,
@@ -2383,6 +2399,19 @@ function printStudioPortfolioPayload(payload, options = {}) {
   console.log(`  Overflow scenes: ${summary.overflow_scenes || 0}`);
 }
 
+function printStudioBackfillPayload(payload, options = {}) {
+  if (options.json) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+  console.log(chalk.blue('Studio scene backfill'));
+  console.log(`  Source scene: ${payload.source_scene || 'scene.unassigned'}`);
+  console.log(`  Candidates: ${payload.summary ? payload.summary.candidate_count : 0}`);
+  console.log(`  Changed: ${payload.summary ? payload.summary.changed_count : 0}`);
+  console.log(`  Apply: ${payload.apply ? 'yes' : 'no'}`);
+  console.log(`  Override file: ${payload.override_file || 'n/a'}`);
+}
+
 async function runStudioPortfolioCommand(options = {}, dependencies = {}) {
   const projectPath = dependencies.projectPath || process.cwd();
   const fileSystem = dependencies.fileSystem || fs;
@@ -2404,6 +2433,29 @@ async function runStudioPortfolioCommand(options = {}, dependencies = {}) {
   return payload;
 }
 
+async function runStudioBackfillSpecScenesCommand(options = {}, dependencies = {}) {
+  const projectPath = dependencies.projectPath || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
+  const backfillOptions = {
+    scene: normalizeString(options.scene),
+    all: options.all === true,
+    limit: options.limit,
+    apply: options.apply === true,
+    refresh_governance: options.refreshGovernance !== false
+  };
+  if (options.activeOnly === true) {
+    backfillOptions.active_only = true;
+  }
+
+  const payload = await runStudioSceneBackfill(backfillOptions, {
+    projectPath,
+    fileSystem
+  });
+
+  printStudioBackfillPayload(payload, options);
+  return payload;
+}
+
 async function runStudioCommand(handler, options, stageName = '') {
   try {
     const stage = normalizeString(stageName) || 'unknown';
@@ -2447,9 +2499,9 @@ function registerStudioCommands(program) {
     .requiredOption('--from-chat <session>', 'Chat session identifier or transcript reference')
     .option('--spec <spec-id>', 'Optional spec binding for domain-chain context ingestion')
     .option('--goal <goal>', 'Optional goal summary')
-    .option('--manual-spec', 'Disable auto intake and only use explicit --spec or existing scene binding')
+    .option('--manual-spec', 'Legacy bypass flag (disabled by default policy)')
     .option('--target <target>', 'Target integration profile', 'default')
-    .option('--no-spec-governance', 'Skip auto portfolio governance snapshot on plan stage')
+    .option('--no-spec-governance', 'Legacy bypass flag (disabled by default policy)')
     .option('--job <job-id>', 'Reuse an explicit studio job id')
     .option('--json', 'Print machine-readable JSON output')
     .action(async (options) => runStudioCommand(runStudioPlanCommand, options, 'plan'));
@@ -2462,7 +2514,7 @@ function registerStudioCommands(program) {
     .option('--spec <spec-id>', 'Optional explicit spec id')
     .option('--goal <goal>', 'Goal text used for intent classification')
     .option('--apply', 'Create spec when decision is create_spec')
-    .option('--manual-spec', 'Disable auto intake and keep explicit/manual binding only')
+    .option('--manual-spec', 'Legacy bypass flag (disabled by default policy)')
     .option('--json', 'Print machine-readable JSON output')
     .action(async (options) => runStudioCommand(runStudioIntakeCommand, options, 'intake'));
 
@@ -2475,6 +2527,18 @@ function registerStudioCommands(program) {
     .option('--json', 'Print machine-readable JSON output')
     .action(async (options) => runStudioCommand(runStudioPortfolioCommand, options, 'portfolio'));
 
+  studio
+    .command('backfill-spec-scenes')
+    .description('Backfill scene bindings for historical specs (writes override mapping when --apply)')
+    .option('--scene <scene-id>', 'Source scene filter (default: scene.unassigned)')
+    .option('--all', 'Include completed/stale specs (default uses active-only policy)')
+    .option('--active-only', 'Force active-only filtering')
+    .option('--limit <n>', 'Maximum number of specs to process')
+    .option('--apply', 'Write mapping to .sce/spec-governance/spec-scene-overrides.json')
+    .option('--no-refresh-governance', 'Skip portfolio refresh after apply')
+    .option('--json', 'Print machine-readable JSON output')
+    .action(async (options) => runStudioCommand(runStudioBackfillSpecScenesCommand, options, 'backfill-spec-scenes'));
+
   studio
     .command('generate')
     .description('Generate patch bundle metadata for a planned studio job (scene inherited from plan)')
@@ -2567,6 +2631,7 @@ module.exports = {
   runStudioRollbackCommand,
   runStudioEventsCommand,
   runStudioPortfolioCommand,
+  runStudioBackfillSpecScenesCommand,
   runStudioResumeCommand,
   registerStudioCommands
 };

package/lib/spec/related-specs.js

@@ -1,6 +1,10 @@
 const path = require('path');
 const fs = require('fs-extra');
 const { DOMAIN_CHAIN_RELATIVE_PATH } = require('./domain-modeling');
+const {
+  loadSceneBindingOverrides,
+  resolveSceneIdFromOverrides
+} = require('./scene-binding-overrides');
 
 function normalizeText(value) {
   if (typeof value !== 'string') {
@@ -70,6 +74,8 @@ async function resolveSpecSearchEntries(projectPath, fileSystem = fs) {
     return [];
   }
 
+  const overrideContext = await loadSceneBindingOverrides(projectPath, {}, fileSystem);
+  const overrides = overrideContext.overrides;
   const names = await fileSystem.readdir(specsRoot);
   const entries = [];
 
@@ -106,7 +112,10 @@ async function resolveSpecSearchEntries(projectPath, fileSystem = fs) {
     ]);
 
     const sceneId = normalizeText(
-      (domainChain && domainChain.scene_id) || extractSceneIdFromSceneSpec(sceneSpecContent) || ''
+      (domainChain && domainChain.scene_id)
+      || extractSceneIdFromSceneSpec(sceneSpecContent)
+      || resolveSceneIdFromOverrides(specId, overrides)
+      || ''
     ) || null;
     const problemStatement = normalizeText(
       (domainChain && domainChain.problem && domainChain.problem.statement) || ''
@@ -257,4 +266,3 @@ module.exports = {
   calculateSpecRelevance,
   findRelatedSpecs
 };
-

package/lib/spec/scene-binding-overrides.js

@@ -0,0 +1,115 @@
+const path = require('path');
+const fs = require('fs-extra');
+
+const DEFAULT_SPEC_SCENE_OVERRIDE_PATH = '.sce/spec-governance/spec-scene-overrides.json';
+
+function normalizeText(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+function normalizeOverrideEntry(specId, payload = {}) {
+  const normalizedSpecId = normalizeText(specId);
+  if (!normalizedSpecId) {
+    return null;
+  }
+
+  if (typeof payload === 'string') {
+    const sceneId = normalizeText(payload);
+    if (!sceneId) {
+      return null;
+    }
+    return {
+      spec_id: normalizedSpecId,
+      scene_id: sceneId,
+      source: 'override',
+      rule_id: null,
+      updated_at: null
+    };
+  }
+
+  const sceneId = normalizeText(payload && payload.scene_id);
+  if (!sceneId) {
+    return null;
+  }
+  return {
+    spec_id: normalizedSpecId,
+    scene_id: sceneId,
+    source: normalizeText(payload.source) || 'override',
+    rule_id: normalizeText(payload.rule_id) || null,
+    updated_at: normalizeText(payload.updated_at) || null
+  };
+}
+
+function normalizeSceneBindingOverrides(raw = {}) {
+  const payload = raw && typeof raw === 'object' ? raw : {};
+  const mappingsRaw = payload.mappings && typeof payload.mappings === 'object'
+    ? payload.mappings
+    : {};
+  const mappings = {};
+  for (const [specId, entry] of Object.entries(mappingsRaw)) {
+    const normalized = normalizeOverrideEntry(specId, entry);
+    if (!normalized) {
+      continue;
+    }
+    mappings[normalized.spec_id] = {
+      scene_id: normalized.scene_id,
+      source: normalized.source,
+      rule_id: normalized.rule_id,
+      updated_at: normalized.updated_at
+    };
+  }
+  return {
+    schema_version: normalizeText(payload.schema_version) || '1.0',
+    generated_at: normalizeText(payload.generated_at) || null,
+    updated_at: normalizeText(payload.updated_at) || null,
+    mappings
+  };
+}
+
+async function loadSceneBindingOverrides(projectPath = process.cwd(), options = {}, fileSystem = fs) {
+  const overridePath = normalizeText(options.override_path || options.overridePath)
+    || DEFAULT_SPEC_SCENE_OVERRIDE_PATH;
+  const absolutePath = path.join(projectPath, overridePath);
+  let payload = {};
+  let loadedFrom = 'default';
+  if (await fileSystem.pathExists(absolutePath)) {
+    try {
+      payload = await fileSystem.readJson(absolutePath);
+      loadedFrom = 'file';
+    } catch (_error) {
+      payload = {};
+      loadedFrom = 'default';
+    }
+  }
+  return {
+    override_path: overridePath,
+    absolute_path: absolutePath,
+    loaded_from: loadedFrom,
+    overrides: normalizeSceneBindingOverrides(payload)
+  };
+}
+
+function resolveSceneIdFromOverrides(specId, overrides = {}) {
+  const normalizedSpecId = normalizeText(specId);
+  if (!normalizedSpecId) {
+    return null;
+  }
+  const mappings = overrides && typeof overrides === 'object' && overrides.mappings
+    ? overrides.mappings
+    : {};
+  const entry = mappings[normalizedSpecId];
+  if (!entry || typeof entry !== 'object') {
+    return null;
+  }
+  return normalizeText(entry.scene_id) || null;
+}
+
+module.exports = {
+  DEFAULT_SPEC_SCENE_OVERRIDE_PATH,
+  normalizeSceneBindingOverrides,
+  loadSceneBindingOverrides,
+  resolveSceneIdFromOverrides
+};

package/lib/studio/spec-intake-governor.js

@@ -2,17 +2,63 @@ const path = require('path');
 const fs = require('fs-extra');
 const { DraftGenerator } = require('../spec/bootstrap/draft-generator');
 const { ensureSpecDomainArtifacts } = require('../spec/domain-modeling');
+const {
+  DEFAULT_SPEC_SCENE_OVERRIDE_PATH,
+  loadSceneBindingOverrides,
+  normalizeSceneBindingOverrides,
+  resolveSceneIdFromOverrides
+} = require('../spec/scene-binding-overrides');
 
 const DEFAULT_STUDIO_INTAKE_POLICY_PATH = '.sce/config/studio-intake-policy.json';
 const DEFAULT_STUDIO_GOVERNANCE_DIR = '.sce/spec-governance';
 const DEFAULT_STUDIO_PORTFOLIO_REPORT = `${DEFAULT_STUDIO_GOVERNANCE_DIR}/scene-portfolio.latest.json`;
 const DEFAULT_STUDIO_SCENE_INDEX = `${DEFAULT_STUDIO_GOVERNANCE_DIR}/scene-index.json`;
+const DEFAULT_STUDIO_SCENE_OVERRIDE_PATH = DEFAULT_SPEC_SCENE_OVERRIDE_PATH;
+
+const DEFAULT_STUDIO_SCENE_BACKFILL_RULES = Object.freeze([
+  {
+    id: 'moqui-core',
+    scene_id: 'scene.moqui-core',
+    keywords: ['moqui']
+  },
+  {
+    id: 'orchestration',
+    scene_id: 'scene.sce-orchestration',
+    keywords: ['orchestrate', 'runtime', 'controller', 'batch', 'parallel']
+  },
+  {
+    id: 'template-registry',
+    scene_id: 'scene.sce-template-registry',
+    keywords: ['template', 'scene-package', 'registry', 'catalog', 'scene-template']
+  },
+  {
+    id: 'spec-governance',
+    scene_id: 'scene.sce-spec-governance',
+    keywords: ['spec', 'gate', 'ontology', 'governance', 'policy']
+  },
+  {
+    id: 'quality',
+    scene_id: 'scene.sce-quality',
+    keywords: ['test', 'quality', 'stability', 'jest', 'coverage']
+  },
+  {
+    id: 'docs',
+    scene_id: 'scene.sce-docs',
+    keywords: ['document', 'documentation', 'onboarding', 'guide']
+  },
+  {
+    id: 'platform',
+    scene_id: 'scene.sce-platform',
+    keywords: ['adopt', 'upgrade', 'workspace', 'repo', 'environment', 'devops', 'release', 'github', 'npm']
+  }
+]);
 
 const DEFAULT_STUDIO_INTAKE_POLICY = Object.freeze({
   schema_version: '1.0',
   enabled: true,
   auto_create_spec: true,
   force_spec_for_studio_plan: true,
+  allow_manual_spec_override: false,
   prefer_existing_scene_spec: true,
   related_spec_min_score: 45,
   allow_new_spec_when_goal_diverges: true,
@@ -33,9 +79,17 @@ const DEFAULT_STUDIO_INTAKE_POLICY = Object.freeze({
   },
   governance: {
     auto_run_on_plan: true,
+    require_auto_on_plan: true,
     max_active_specs_per_scene: 3,
     stale_days: 14,
     duplicate_similarity_threshold: 0.66
+  },
+  backfill: {
+    enabled: true,
+    active_only_default: true,
+    default_scene_id: 'scene.sce-core',
+    override_file: DEFAULT_STUDIO_SCENE_OVERRIDE_PATH,
+    rules: DEFAULT_STUDIO_SCENE_BACKFILL_RULES
   }
 });
 
@@ -87,6 +141,30 @@ function normalizeTextList(value = []) {
     .filter(Boolean);
 }
 
+function normalizeBackfillRules(value = []) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const rules = [];
+  for (const item of value) {
+    if (!item || typeof item !== 'object') {
+      continue;
+    }
+    const id = normalizeText(item.id);
+    const sceneId = normalizeText(item.scene_id || item.sceneId);
+    const keywords = normalizeTextList(item.keywords || item.match_any_keywords || item.matchAnyKeywords);
+    if (!id || !sceneId || keywords.length === 0) {
+      continue;
+    }
+    rules.push({
+      id,
+      scene_id: sceneId,
+      keywords
+    });
+  }
+  return rules;
+}
+
 function toRelativePosix(projectPath, absolutePath) {
   return path.relative(projectPath, absolutePath).replace(/\\/g, '/');
 }
@@ -169,6 +247,8 @@ function normalizeStudioIntakePolicy(raw = {}) {
   const payload = raw && typeof raw === 'object' ? raw : {};
   const specId = payload.spec_id && typeof payload.spec_id === 'object' ? payload.spec_id : {};
   const governance = payload.governance && typeof payload.governance === 'object' ? payload.governance : {};
+  const backfill = payload.backfill && typeof payload.backfill === 'object' ? payload.backfill : {};
+  const normalizedBackfillRules = normalizeBackfillRules(backfill.rules);
 
   return {
     schema_version: normalizeText(payload.schema_version) || DEFAULT_STUDIO_INTAKE_POLICY.schema_version,
@@ -178,6 +258,10 @@ function normalizeStudioIntakePolicy(raw = {}) {
       payload.force_spec_for_studio_plan,
       DEFAULT_STUDIO_INTAKE_POLICY.force_spec_for_studio_plan
     ),
+    allow_manual_spec_override: normalizeBoolean(
+      payload.allow_manual_spec_override,
+      DEFAULT_STUDIO_INTAKE_POLICY.allow_manual_spec_override
+    ),
     prefer_existing_scene_spec: normalizeBoolean(
       payload.prefer_existing_scene_spec,
       DEFAULT_STUDIO_INTAKE_POLICY.prefer_existing_scene_spec
@@ -224,6 +308,10 @@ function normalizeStudioIntakePolicy(raw = {}) {
         governance.auto_run_on_plan,
         DEFAULT_STUDIO_INTAKE_POLICY.governance.auto_run_on_plan
       ),
+      require_auto_on_plan: normalizeBoolean(
+        governance.require_auto_on_plan,
+        DEFAULT_STUDIO_INTAKE_POLICY.governance.require_auto_on_plan
+      ),
       max_active_specs_per_scene: normalizeInteger(
         governance.max_active_specs_per_scene,
         DEFAULT_STUDIO_INTAKE_POLICY.governance.max_active_specs_per_scene,
@@ -243,6 +331,23 @@ function normalizeStudioIntakePolicy(raw = {}) {
           DEFAULT_STUDIO_INTAKE_POLICY.governance.duplicate_similarity_threshold
         ))
       )
+    },
+    backfill: {
+      enabled: normalizeBoolean(
+        backfill.enabled,
+        DEFAULT_STUDIO_INTAKE_POLICY.backfill.enabled
+      ),
+      active_only_default: normalizeBoolean(
+        backfill.active_only_default,
+        DEFAULT_STUDIO_INTAKE_POLICY.backfill.active_only_default
+      ),
+      default_scene_id: normalizeText(backfill.default_scene_id)
+        || DEFAULT_STUDIO_INTAKE_POLICY.backfill.default_scene_id,
+      override_file: normalizeText(backfill.override_file)
+        || DEFAULT_STUDIO_INTAKE_POLICY.backfill.override_file,
+      rules: normalizedBackfillRules.length > 0
+        ? normalizedBackfillRules
+        : normalizeBackfillRules(DEFAULT_STUDIO_INTAKE_POLICY.backfill.rules)
     }
   };
 }
@@ -611,6 +716,12 @@ async function runStudioAutoIntake(options = {}, dependencies = {}) {
     created_spec: null
   };
 
+  if (skip && policy.allow_manual_spec_override !== true) {
+    throw new Error(
+      'manual spec override is disabled by studio intake policy (allow_manual_spec_override=false)'
+    );
+  }
+
   if (skip) {
     payload.enabled = false;
     payload.decision = {
@@ -705,6 +816,10 @@ async function scanSpecPortfolio(projectPath = process.cwd(), options = {}, depe
     return [];
   }
   const staleDays = normalizeInteger(options.stale_days, 14, 1, 3650);
+  const overrideContext = await loadSceneBindingOverrides(projectPath, {
+    overridePath: options.override_file || DEFAULT_STUDIO_SCENE_OVERRIDE_PATH
+  }, fileSystem);
+  const sceneOverrides = normalizeSceneBindingOverrides(overrideContext.overrides || {});
   const entries = await fileSystem.readdir(specsRoot);
   const records = [];
 
@@ -733,9 +848,12 @@ async function scanSpecPortfolio(projectPath = process.cwd(), options = {}, depe
       readFileSafe(tasksPath, fileSystem)
     ]);
 
-    const sceneId = normalizeText(
-      chain && chain.scene_id ? chain.scene_id : ''
-    ) || 'scene.unassigned';
+    const sceneFromChain = normalizeText(chain && chain.scene_id ? chain.scene_id : '');
+    const sceneFromOverride = resolveSceneIdFromOverrides(entry, sceneOverrides);
+    const sceneId = sceneFromChain || sceneFromOverride || 'scene.unassigned';
+    const sceneSource = sceneFromChain
+      ? 'domain-chain'
+      : (sceneFromOverride ? 'override' : 'unassigned');
     const problemStatement = normalizeText(
       (chain && chain.problem && chain.problem.statement)
       || (contract && contract.issue_statement)
@@ -767,6 +885,7 @@ async function scanSpecPortfolio(projectPath = process.cwd(), options = {}, depe
       tasks_progress: taskProgress.ratio,
       lifecycle_state: lifecycle.state,
       age_days: lifecycle.age_days,
+      scene_source: sceneSource,
       tokens
     });
   }
@@ -889,6 +1008,202 @@ function buildSceneGovernanceReport(records = [], policy = DEFAULT_STUDIO_INTAKE
   };
 }
 
+function classifyBackfillRule(record = {}, backfillPolicy = {}) {
+  const rules = Array.isArray(backfillPolicy.rules) ? backfillPolicy.rules : [];
+  const defaultSceneId = normalizeText(backfillPolicy.default_scene_id) || 'scene.sce-core';
+  const searchText = [
+    normalizeText(record.spec_id).toLowerCase(),
+    normalizeText(record.problem_statement).toLowerCase()
+  ].join(' ');
+  const searchTokens = new Set(tokenizeText(searchText));
+  let bestMatch = null;
+
+  for (const rule of rules) {
+    const ruleId = normalizeText(rule.id);
+    const sceneId = normalizeText(rule.scene_id);
+    const keywords = normalizeTextList(rule.keywords).map((item) => item.toLowerCase());
+    if (!ruleId || !sceneId || keywords.length === 0) {
+      continue;
+    }
+
+    const matchedKeywords = [];
+    for (const keyword of keywords) {
+      if (!keyword) {
+        continue;
+      }
+      if (searchText.includes(keyword) || searchTokens.has(keyword)) {
+        matchedKeywords.push(keyword);
+      }
+    }
+    if (matchedKeywords.length === 0) {
+      continue;
+    }
+
+    const score = matchedKeywords.length;
+    if (!bestMatch || score > bestMatch.score) {
+      bestMatch = {
+        rule_id: ruleId,
+        scene_id: sceneId,
+        matched_keywords: matchedKeywords,
+        score
+      };
+    }
+  }
+
+  if (!bestMatch) {
+    return {
+      scene_id: defaultSceneId,
+      rule_id: 'default',
+      matched_keywords: [],
+      confidence: 'low',
+      source: 'default'
+    };
+  }
+
+  return {
+    scene_id: bestMatch.scene_id,
+    rule_id: bestMatch.rule_id,
+    matched_keywords: bestMatch.matched_keywords,
+    confidence: bestMatch.score >= 2 ? 'high' : 'medium',
+    source: 'rule'
+  };
+}
+
+function clampBackfillLimit(value, fallback = 0, max = 1000) {
+  if (value === undefined || value === null || value === '') {
+    return fallback;
+  }
+  const parsed = Number.parseInt(String(value), 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return fallback;
+  }
+  return Math.min(parsed, max);
+}
+
+async function runStudioSceneBackfill(options = {}, dependencies = {}) {
+  const projectPath = dependencies.projectPath || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
+  const loaded = options.policy && typeof options.policy === 'object'
+    ? { policy: normalizeStudioIntakePolicy(options.policy), policy_path: '(inline)', loaded_from: 'inline' }
+    : await loadStudioIntakePolicy(projectPath, fileSystem);
+  const policy = loaded.policy;
+  const backfillPolicy = policy.backfill || DEFAULT_STUDIO_INTAKE_POLICY.backfill;
+  const apply = options.apply === true;
+  const refreshGovernance = options.refresh_governance !== false && options.refreshGovernance !== false;
+  const sourceScene = normalizeText(options.source_scene || options.sourceScene || options.scene) || 'scene.unassigned';
+  const includeAll = options.all === true || options.active_only === false || options.activeOnly === false;
+  const activeOnly = includeAll ? false : (options.active_only === true || options.activeOnly === true || backfillPolicy.active_only_default !== false);
+  const limit = clampBackfillLimit(options.limit, 0, 2000);
+  const overrideFile = normalizeText(backfillPolicy.override_file) || DEFAULT_STUDIO_SCENE_OVERRIDE_PATH;
+
+  const records = await scanSpecPortfolio(projectPath, {
+    stale_days: policy.governance && policy.governance.stale_days,
+    override_file: overrideFile
+  }, {
+    fileSystem
+  });
+
+  let candidates = records.filter((item) => normalizeText(item.scene_id) === sourceScene);
+  if (activeOnly) {
+    candidates = candidates.filter((item) => item.lifecycle_state === 'active');
+  }
+  if (limit > 0) {
+    candidates = candidates.slice(0, limit);
+  }
+
+  const assignmentPlan = candidates.map((record) => {
+    const decision = classifyBackfillRule(record, backfillPolicy);
+    return {
+      spec_id: record.spec_id,
+      from_scene_id: sourceScene,
+      to_scene_id: decision.scene_id,
+      lifecycle_state: record.lifecycle_state,
+      rule_id: decision.rule_id,
+      source: decision.source,
+      confidence: decision.confidence,
+      matched_keywords: decision.matched_keywords
+    };
+  });
+
+  const overrideContext = await loadSceneBindingOverrides(projectPath, {
+    overridePath: overrideFile
+  }, fileSystem);
+  const existingOverrides = normalizeSceneBindingOverrides(overrideContext.overrides || {});
+  const nextOverrides = normalizeSceneBindingOverrides(existingOverrides);
+  const now = new Date().toISOString();
+  let changedCount = 0;
+
+  for (const item of assignmentPlan) {
+    const existing = existingOverrides.mappings[item.spec_id];
+    const currentScene = normalizeText(existing && existing.scene_id);
+    if (currentScene === item.to_scene_id) {
+      continue;
+    }
+    nextOverrides.mappings[item.spec_id] = {
+      scene_id: item.to_scene_id,
+      source: 'scene-backfill',
+      rule_id: item.rule_id,
+      updated_at: now
+    };
+    changedCount += 1;
+  }
+
+  const totalsByTargetScene = {};
+  for (const item of assignmentPlan) {
+    totalsByTargetScene[item.to_scene_id] = (totalsByTargetScene[item.to_scene_id] || 0) + 1;
+  }
+
+  const payload = {
+    mode: 'studio-scene-backfill',
+    success: true,
+    generated_at: now,
+    policy_path: loaded.policy_path,
+    policy_loaded_from: loaded.loaded_from,
+    source_scene: sourceScene,
+    active_only: activeOnly,
+    apply,
+    refresh_governance: refreshGovernance,
+    override_file: overrideFile,
+    summary: {
+      candidate_count: assignmentPlan.length,
+      changed_count: changedCount,
+      target_scene_count: Object.keys(totalsByTargetScene).length
+    },
+    targets: totalsByTargetScene,
+    assignments: assignmentPlan
+  };
+
+  if (apply) {
+    const overrideAbsolutePath = path.join(projectPath, overrideFile);
+    await fileSystem.ensureDir(path.dirname(overrideAbsolutePath));
+    const serialized = {
+      schema_version: '1.0',
+      generated_at: nextOverrides.generated_at || now,
+      updated_at: now,
+      source: 'studio-scene-backfill',
+      mappings: nextOverrides.mappings
+    };
+    await fileSystem.writeJson(overrideAbsolutePath, serialized, { spaces: 2 });
+    payload.override_written = overrideFile;
+    if (refreshGovernance) {
+      const refreshed = await runStudioSpecGovernance({
+        apply: true
+      }, {
+        projectPath,
+        fileSystem
+      });
+      payload.governance = {
+        status: refreshed.summary ? refreshed.summary.status : null,
+        alert_count: refreshed.summary ? Number(refreshed.summary.alert_count || 0) : 0,
+        report_file: refreshed.report_file || null,
+        scene_index_file: refreshed.scene_index_file || null
+      };
+    }
+  }
+
+  return payload;
+}
+
 async function runStudioSpecGovernance(options = {}, dependencies = {}) {
   const projectPath = dependencies.projectPath || process.cwd();
   const fileSystem = dependencies.fileSystem || fs;
@@ -897,11 +1212,14 @@ async function runStudioSpecGovernance(options = {}, dependencies = {}) {
     : await loadStudioIntakePolicy(projectPath, fileSystem);
   const policy = loaded.policy;
   const governance = policy.governance || DEFAULT_STUDIO_INTAKE_POLICY.governance;
+  const backfill = policy.backfill || DEFAULT_STUDIO_INTAKE_POLICY.backfill;
   const apply = options.apply !== false;
   const sceneFilter = normalizeText(options.scene_id || options.sceneId || options.scene);
+  const overrideFile = normalizeText(backfill.override_file) || DEFAULT_STUDIO_SCENE_OVERRIDE_PATH;
 
   const records = await scanSpecPortfolio(projectPath, {
-    stale_days: governance.stale_days
+    stale_days: governance.stale_days,
+    override_file: overrideFile
   }, {
     fileSystem
   });
@@ -920,7 +1238,10 @@ async function runStudioSpecGovernance(options = {}, dependencies = {}) {
     policy_path: loaded.policy_path,
     policy_loaded_from: loaded.loaded_from,
     policy: {
-      governance
+      governance,
+      backfill: {
+        override_file: overrideFile
+      }
     },
     summary: {
       scene_count: summary.scene_count,
@@ -974,6 +1295,7 @@ async function runStudioSpecGovernance(options = {}, dependencies = {}) {
 module.exports = {
   DEFAULT_STUDIO_INTAKE_POLICY_PATH,
   DEFAULT_STUDIO_INTAKE_POLICY,
+  DEFAULT_STUDIO_SCENE_OVERRIDE_PATH,
   DEFAULT_STUDIO_PORTFOLIO_REPORT,
   DEFAULT_STUDIO_SCENE_INDEX,
   normalizeStudioIntakePolicy,
@@ -986,6 +1308,7 @@ module.exports = {
   parseTasksProgress,
   scanSpecPortfolio,
   buildSceneGovernanceReport,
+  runStudioSceneBackfill,
   runStudioSpecGovernance,
   tokenizeText,
   computeJaccard

package/lib/workspace/takeover-baseline.js

@@ -92,6 +92,7 @@ const STUDIO_INTAKE_POLICY_DEFAULTS = Object.freeze({
   enabled: true,
   auto_create_spec: true,
   force_spec_for_studio_plan: true,
+  allow_manual_spec_override: false,
   prefer_existing_scene_spec: true,
   related_spec_min_score: 45,
   allow_new_spec_when_goal_diverges: true,
@@ -112,9 +113,25 @@ const STUDIO_INTAKE_POLICY_DEFAULTS = Object.freeze({
   },
   governance: {
     auto_run_on_plan: true,
+    require_auto_on_plan: true,
     max_active_specs_per_scene: 3,
     stale_days: 14,
     duplicate_similarity_threshold: 0.66
+  },
+  backfill: {
+    enabled: true,
+    active_only_default: true,
+    default_scene_id: 'scene.sce-core',
+    override_file: '.sce/spec-governance/spec-scene-overrides.json',
+    rules: [
+      { id: 'moqui-core', scene_id: 'scene.moqui-core', keywords: ['moqui'] },
+      { id: 'orchestration', scene_id: 'scene.sce-orchestration', keywords: ['orchestrate', 'runtime', 'controller', 'batch', 'parallel'] },
+      { id: 'template-registry', scene_id: 'scene.sce-template-registry', keywords: ['template', 'scene-package', 'registry', 'catalog', 'scene-template'] },
+      { id: 'spec-governance', scene_id: 'scene.sce-spec-governance', keywords: ['spec', 'gate', 'ontology', 'governance', 'policy'] },
+      { id: 'quality', scene_id: 'scene.sce-quality', keywords: ['test', 'quality', 'stability', 'jest', 'coverage'] },
+      { id: 'docs', scene_id: 'scene.sce-docs', keywords: ['document', 'documentation', 'onboarding', 'guide'] },
+      { id: 'platform', scene_id: 'scene.sce-platform', keywords: ['adopt', 'upgrade', 'workspace', 'repo', 'environment', 'devops', 'release', 'github', 'npm'] }
+    ]
   }
 });
 
@@ -172,6 +189,7 @@ const TAKEOVER_DEFAULTS = Object.freeze({
     enabled: true,
     auto_create_spec: true,
     force_spec_for_studio_plan: true,
+    allow_manual_spec_override: false,
     prefer_existing_scene_spec: true,
     related_spec_min_score: 45,
     allow_new_spec_when_goal_diverges: true,
@@ -179,9 +197,16 @@ const TAKEOVER_DEFAULTS = Object.freeze({
     goal_missing_strategy: 'create_for_tracking',
     governance: {
       auto_run_on_plan: true,
+      require_auto_on_plan: true,
       max_active_specs_per_scene: 3,
       stale_days: 14,
       duplicate_similarity_threshold: 0.66
+    },
+    backfill: {
+      enabled: true,
+      active_only_default: true,
+      default_scene_id: 'scene.sce-core',
+      override_file: '.sce/spec-governance/spec-scene-overrides.json'
     }
   },
   debug_policy: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scene-capability-engine",
-  "version": "3.5.0",
+  "version": "3.5.1",
   "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/config/studio-intake-policy.json

@@ -3,6 +3,7 @@
   "enabled": true,
   "auto_create_spec": true,
   "force_spec_for_studio_plan": true,
+  "allow_manual_spec_override": false,
   "prefer_existing_scene_spec": true,
   "related_spec_min_score": 45,
   "allow_new_spec_when_goal_diverges": true,
@@ -61,8 +62,93 @@
   },
   "governance": {
     "auto_run_on_plan": true,
+    "require_auto_on_plan": true,
     "max_active_specs_per_scene": 3,
     "stale_days": 14,
     "duplicate_similarity_threshold": 0.66
+  },
+  "backfill": {
+    "enabled": true,
+    "active_only_default": true,
+    "default_scene_id": "scene.sce-core",
+    "override_file": ".sce/spec-governance/spec-scene-overrides.json",
+    "rules": [
+      {
+        "id": "moqui-core",
+        "scene_id": "scene.moqui-core",
+        "keywords": [
+          "moqui"
+        ]
+      },
+      {
+        "id": "orchestration",
+        "scene_id": "scene.sce-orchestration",
+        "keywords": [
+          "orchestrate",
+          "runtime",
+          "controller",
+          "batch",
+          "parallel"
+        ]
+      },
+      {
+        "id": "template-registry",
+        "scene_id": "scene.sce-template-registry",
+        "keywords": [
+          "template",
+          "scene-package",
+          "registry",
+          "catalog",
+          "scene-template"
+        ]
+      },
+      {
+        "id": "spec-governance",
+        "scene_id": "scene.sce-spec-governance",
+        "keywords": [
+          "spec",
+          "gate",
+          "ontology",
+          "governance",
+          "policy"
+        ]
+      },
+      {
+        "id": "quality",
+        "scene_id": "scene.sce-quality",
+        "keywords": [
+          "test",
+          "quality",
+          "stability",
+          "jest",
+          "coverage"
+        ]
+      },
+      {
+        "id": "docs",
+        "scene_id": "scene.sce-docs",
+        "keywords": [
+          "document",
+          "documentation",
+          "onboarding",
+          "guide"
+        ]
+      },
+      {
+        "id": "platform",
+        "scene_id": "scene.sce-platform",
+        "keywords": [
+          "adopt",
+          "upgrade",
+          "workspace",
+          "repo",
+          "environment",
+          "devops",
+          "release",
+          "github",
+          "npm"
+        ]
+      }
+    ]
   }
 }