scene-capability-engine 3.5.0 → 3.5.2

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.2",
   "description": "SCE (Scene Capability Engine) - A CLI tool and npm package for spec-driven development with AI coding assistants.",
   "main": "index.js",
   "bin": {