scene-capability-engine 3.3.5 → 3.3.10

package/lib/runtime/steering-contract.js

@@ -0,0 +1,338 @@
+const fs = require('fs-extra');
+const path = require('path');
+const yaml = require('js-yaml');
+const semver = require('semver');
+
+const CONTRACT_SCHEMA_VERSION = '1.0';
+const SCE_STEERING_DIR = path.join('.sce', 'steering');
+const MANIFEST_FILENAME = 'manifest.yaml';
+
+const DEFAULT_LAYER_FILES = Object.freeze({
+  core_principles: 'CORE_PRINCIPLES.md',
+  environment: 'ENVIRONMENT.md',
+  current_context: 'CURRENT_CONTEXT.md',
+  rules_guide: 'RULES_GUIDE.md',
+});
+
+const DEFAULT_MANIFEST = Object.freeze({
+  schema_version: CONTRACT_SCHEMA_VERSION,
+  engine: 'sce',
+  profile: 'default',
+  description: 'SCE universal steering contract for cross-agent orchestration',
+  layers: { ...DEFAULT_LAYER_FILES },
+  compatibility: {
+    codex: '>=0.0.0',
+    claude: '>=0.0.0',
+    cursor: '>=0.0.0',
+    generic: '*',
+  },
+  session: {
+    root: '.sce/sessions',
+    default_status: 'active',
+  },
+});
+
+const TOOL_RUNTIME_PROFILES = Object.freeze({
+  codex: {
+    recommended_command: 'codex exec --sandbox danger-full-access --ask-for-approval never',
+    default_permission_args: ['--sandbox', 'danger-full-access', '--ask-for-approval', 'never'],
+    notes: 'Full runtime permissions with no approval prompts.',
+  },
+  claude: {
+    recommended_command: 'claude --dangerously-skip-permission',
+    default_permission_args: ['--dangerously-skip-permission'],
+    notes: 'Recommended full permission mode for SCE-driven autonomous tasks.',
+  },
+  'claude-code': {
+    recommended_command: 'claude --dangerously-skip-permission',
+    default_permission_args: ['--dangerously-skip-permission'],
+    notes: 'Alias of claude profile.',
+  },
+  cursor: {
+    recommended_command: 'cursor',
+    default_permission_args: [],
+    notes: 'Permission handling depends on Cursor runtime policy.',
+  },
+  generic: {
+    recommended_command: '',
+    default_permission_args: [],
+    notes: 'Provide runtime permission args in the target agent adapter.',
+  },
+});
+
+function normalizeToolName(value) {
+  const raw = `${value || ''}`.trim().toLowerCase();
+  if (!raw) {
+    return 'generic';
+  }
+  if (raw === 'claude-code') {
+    return 'claude';
+  }
+  if (raw === 'codex' || raw === 'claude' || raw === 'cursor') {
+    return raw;
+  }
+  return 'generic';
+}
+
+function toRelativePosix(workspaceRoot, absolutePath) {
+  return path.relative(workspaceRoot, absolutePath).replace(/\\/g, '/');
+}
+
+class SteeringContract {
+  constructor(workspaceRoot) {
+    this._workspaceRoot = workspaceRoot;
+    this._sceSteeringDir = path.join(workspaceRoot, SCE_STEERING_DIR);
+    this._manifestPath = path.join(this._sceSteeringDir, MANIFEST_FILENAME);
+  }
+
+  get manifestPath() {
+    return this._manifestPath;
+  }
+
+  get sceSteeringDir() {
+    return this._sceSteeringDir;
+  }
+
+  async ensureContract() {
+    await fs.ensureDir(this._sceSteeringDir);
+
+    let createdManifest = false;
+    if (!await fs.pathExists(this._manifestPath)) {
+      await fs.writeFile(this._manifestPath, yaml.dump(DEFAULT_MANIFEST, { lineWidth: 120 }), 'utf8');
+      createdManifest = true;
+    }
+
+    const manifest = await this.loadManifest();
+    const preparedLayers = [];
+    for (const [layerName, filename] of Object.entries(manifest.layers)) {
+      const targetPath = path.join(this._sceSteeringDir, filename);
+      if (await fs.pathExists(targetPath)) {
+        preparedLayers.push({ layer: layerName, file: filename, source: 'sce' });
+        continue;
+      }
+
+      await fs.writeFile(targetPath, this._buildDefaultLayerContent(layerName, filename), 'utf8');
+      preparedLayers.push({ layer: layerName, file: filename, source: 'template' });
+    }
+
+    return {
+      createdManifest,
+      manifestPath: toRelativePosix(this._workspaceRoot, this._manifestPath),
+      preparedLayers,
+    };
+  }
+
+  async loadManifest() {
+    let raw = {};
+    try {
+      if (await fs.pathExists(this._manifestPath)) {
+        raw = yaml.load(await fs.readFile(this._manifestPath, 'utf8')) || {};
+      }
+    } catch (_error) {
+      raw = {};
+    }
+    return this._normalizeManifest(raw);
+  }
+
+  async resolveLayerFile(filename) {
+    const scePath = path.join(this._sceSteeringDir, filename);
+    if (await fs.pathExists(scePath)) {
+      return { source: 'sce', path: scePath };
+    }
+    return null;
+  }
+
+  async loadLayerBundle() {
+    const manifest = await this.loadManifest();
+    const layers = {};
+    const sourceSet = new Set();
+
+    for (const [layerName, filename] of Object.entries(manifest.layers)) {
+      const resolved = await this.resolveLayerFile(filename);
+      if (!resolved) {
+        layers[layerName] = {
+          file: filename,
+          source: 'missing',
+          path: null,
+          content: null,
+        };
+        continue;
+      }
+
+      const content = await fs.readFile(resolved.path, 'utf8');
+      sourceSet.add(resolved.source);
+      layers[layerName] = {
+        file: filename,
+        source: resolved.source,
+        path: toRelativePosix(this._workspaceRoot, resolved.path),
+        content: content.trim(),
+      };
+    }
+
+    return {
+      manifest,
+      layers,
+      source_mode: this._resolveSourceMode(sourceSet),
+    };
+  }
+
+  async buildCompilePayload(tool, agentVersion = null) {
+    const normalizedTool = normalizeToolName(tool);
+    const runtime = TOOL_RUNTIME_PROFILES[normalizedTool] || TOOL_RUNTIME_PROFILES.generic;
+    const bundle = await this.loadLayerBundle();
+    const compatibility = this._evaluateCompatibility(bundle.manifest, normalizedTool, agentVersion);
+
+    return {
+      schema_version: CONTRACT_SCHEMA_VERSION,
+      generated_at: new Date().toISOString(),
+      tool: normalizedTool,
+      agent_version: agentVersion ? `${agentVersion}` : null,
+      source_mode: bundle.source_mode,
+      manifest: bundle.manifest,
+      runtime,
+      compatibility,
+      layers: bundle.layers,
+    };
+  }
+
+  renderMarkdown(payload) {
+    const sections = [];
+    sections.push('# SCE Steering Compile');
+    sections.push('');
+    sections.push(`- schema_version: ${payload.schema_version}`);
+    sections.push(`- generated_at: ${payload.generated_at}`);
+    sections.push(`- tool: ${payload.tool}`);
+    sections.push(`- agent_version: ${payload.agent_version || '(not provided)'}`);
+    sections.push(`- source_mode: ${payload.source_mode}`);
+    sections.push('');
+    sections.push('## Runtime Permission Profile');
+    sections.push('');
+    sections.push(`- recommended_command: ${payload.runtime.recommended_command || '(none)'}`);
+    sections.push(`- default_permission_args: ${payload.runtime.default_permission_args.join(' ') || '(none)'}`);
+    sections.push(`- notes: ${payload.runtime.notes}`);
+    sections.push('');
+    sections.push('## Compatibility');
+    sections.push('');
+    sections.push(`- rule: ${payload.compatibility.rule}`);
+    sections.push(`- supported: ${payload.compatibility.supported === null ? 'unknown' : payload.compatibility.supported}`);
+    sections.push(`- reason: ${payload.compatibility.reason}`);
+    sections.push('');
+    sections.push('## Layers');
+    sections.push('');
+
+    for (const [layerName, layer] of Object.entries(payload.layers)) {
+      sections.push(`### ${layerName} (${layer.file})`);
+      sections.push(`- source: ${layer.source}`);
+      sections.push(`- path: ${layer.path || '(missing)'}`);
+      sections.push('');
+      if (layer.content) {
+        sections.push(layer.content);
+      } else {
+        sections.push('(missing)');
+      }
+      sections.push('');
+    }
+
+    return sections.join('\n').trim() + '\n';
+  }
+
+  _normalizeManifest(raw) {
+    const layers = (raw && raw.layers && typeof raw.layers === 'object')
+      ? raw.layers
+      : {};
+    const normalizedLayers = {};
+    for (const [key, filename] of Object.entries(DEFAULT_LAYER_FILES)) {
+      normalizedLayers[key] = typeof layers[key] === 'string' && layers[key].trim()
+        ? layers[key].trim()
+        : filename;
+    }
+
+    return {
+      schema_version: `${raw.schema_version || DEFAULT_MANIFEST.schema_version}`,
+      engine: `${raw.engine || DEFAULT_MANIFEST.engine}`,
+      profile: `${raw.profile || DEFAULT_MANIFEST.profile}`,
+      description: `${raw.description || DEFAULT_MANIFEST.description}`,
+      layers: normalizedLayers,
+      compatibility: this._normalizeCompatibility(raw.compatibility),
+      session: {
+        root: raw.session && typeof raw.session.root === 'string'
+          ? raw.session.root
+          : DEFAULT_MANIFEST.session.root,
+        default_status: raw.session && typeof raw.session.default_status === 'string'
+          ? raw.session.default_status
+          : DEFAULT_MANIFEST.session.default_status,
+      },
+    };
+  }
+
+  _resolveSourceMode(sourceSet) {
+    if (sourceSet.has('sce')) {
+      return 'sce';
+    }
+    return 'empty';
+  }
+
+  _normalizeCompatibility(rawCompatibility) {
+    const input = rawCompatibility && typeof rawCompatibility === 'object'
+      ? rawCompatibility
+      : {};
+    const normalized = {};
+    for (const [tool, defaultRange] of Object.entries(DEFAULT_MANIFEST.compatibility)) {
+      const value = input[tool];
+      normalized[tool] = typeof value === 'string' && value.trim() ? value.trim() : defaultRange;
+    }
+    return normalized;
+  }
+
+  _evaluateCompatibility(manifest, tool, agentVersion) {
+    const rule = manifest.compatibility && manifest.compatibility[tool]
+      ? manifest.compatibility[tool]
+      : (manifest.compatibility && manifest.compatibility.generic) || '*';
+    if (!agentVersion || `${agentVersion}`.trim() === '') {
+      return {
+        rule,
+        supported: null,
+        reason: 'agent version not provided',
+      };
+    }
+    const coerced = semver.coerce(`${agentVersion}`.trim());
+    if (!coerced) {
+      return {
+        rule,
+        supported: null,
+        reason: `unable to parse version: ${agentVersion}`,
+      };
+    }
+    const parsedVersion = semver.valid(coerced.version);
+    const supported = rule === '*' ? true : semver.satisfies(parsedVersion, rule, { includePrerelease: true });
+    return {
+      rule,
+      supported,
+      reason: supported
+        ? `version ${parsedVersion} satisfies ${rule}`
+        : `version ${parsedVersion} does not satisfy ${rule}`,
+    };
+  }
+
+  _buildDefaultLayerContent(layerName, filename) {
+    return [
+      `# ${filename}`,
+      '',
+      `Managed by SCE universal steering contract.`,
+      `Layer: ${layerName}`,
+      '',
+      '- Fill this file with project-specific constraints and guidance.',
+    ].join('\n');
+  }
+}
+
+module.exports = {
+  SteeringContract,
+  CONTRACT_SCHEMA_VERSION,
+  DEFAULT_LAYER_FILES,
+  DEFAULT_MANIFEST,
+  MANIFEST_FILENAME,
+  SCE_STEERING_DIR,
+  TOOL_RUNTIME_PROFILES,
+  normalizeToolName,
+};

package/lib/scene-runtime/audit-emitter.js

@@ -9,7 +9,7 @@ function createId(prefix) {
 class AuditEmitter {
   constructor(projectRoot = process.cwd(), options = {}) {
     this.projectRoot = projectRoot;
-    this.auditFile = options.auditFile || path.join(projectRoot, '.kiro', 'audit', 'scene-runtime-events.jsonl');
+    this.auditFile = options.auditFile || path.join(projectRoot, '.sce', 'audit', 'scene-runtime-events.jsonl');
   }
 
   async emit(eventType, payload = {}) {

package/lib/scene-runtime/binding-plugin-loader.js

@@ -2,10 +2,10 @@ const path = require('path');
 const fs = require('fs-extra');
 
 const DEFAULT_BINDING_PLUGIN_DIRS = [
-  '.kiro/plugins/scene-bindings',
-  '.kiro/config/scene-bindings'
+  '.sce/plugins/scene-bindings',
+  '.sce/config/scene-bindings'
 ];
-const DEFAULT_BINDING_PLUGIN_MANIFEST = '.kiro/config/scene-binding-plugins.json';
+const DEFAULT_BINDING_PLUGIN_MANIFEST = '.sce/config/scene-binding-plugins.json';
 
 function isPlainObject(value) {
   return value && typeof value === 'object' && !Array.isArray(value);

package/lib/scene-runtime/eval-bridge.js

@@ -1,4 +1,4 @@
-class EvalBridge {
+class EvalBridge {
   buildPayload({ sceneManifest, plan, runResult }) {
     const metrics = {
       success: runResult.status === 'success',

package/lib/scene-runtime/index.js

@@ -1,4 +1,4 @@
-const SceneLoader = require('./scene-loader');
+const SceneLoader = require('./scene-loader');
 const PlanCompiler = require('./plan-compiler');
 const PolicyGate = require('./policy-gate');
 const AuditEmitter = require('./audit-emitter');

package/lib/scene-runtime/moqui-extractor.js

@@ -1838,7 +1838,7 @@ async function discoverResources(client, options = {}) {
 /**
  * Default output directory for extracted templates.
  */
-const DEFAULT_OUT_DIR = '.kiro/templates/extracted';
+const DEFAULT_OUT_DIR = '.sce/templates/extracted';
 
 /**
  * Run the full extraction pipeline.

package/lib/scene-runtime/plan-compiler.js

@@ -1,4 +1,4 @@
-function makeId(prefix) {
+function makeId(prefix) {
   return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
 

package/lib/scene-runtime/policy-gate.js

@@ -1,4 +1,4 @@
-const HIGH_RISK_LEVELS = new Set(['high', 'critical']);
+const HIGH_RISK_LEVELS = new Set(['high', 'critical']);
 
 class PolicyGate {
   evaluate(sceneManifest, runMode = 'dry_run', context = {}) {

package/lib/scene-runtime/runtime-executor.js

@@ -1,4 +1,4 @@
-const PlanCompiler = require('./plan-compiler');
+const PlanCompiler = require('./plan-compiler');
 const PolicyGate = require('./policy-gate');
 const AuditEmitter = require('./audit-emitter');
 const EvalBridge = require('./eval-bridge');

package/lib/scene-runtime/scene-loader.js

@@ -11,7 +11,7 @@ class SceneLoader {
   }
 
   async loadFromSpec(specName, relativePath = 'custom/scene.yaml') {
-    const filePath = path.join(this.projectPath, '.kiro', 'specs', specName, relativePath);
+    const filePath = path.join(this.projectPath, '.sce', 'specs', specName, relativePath);
     return this.loadFromFile(filePath);
   }
 

package/lib/spec/bootstrap/context-collector.js

@@ -7,7 +7,7 @@ class ContextCollector {
   }
 
   async collect() {
-    const kiroDir = path.join(this.projectPath, '.kiro');
+    const kiroDir = path.join(this.projectPath, '.sce');
     const specsDir = path.join(kiroDir, 'specs');
     const hasKiro = await fs.pathExists(kiroDir);
     const existingSpecs = await this._listSpecs(specsDir);

package/lib/spec/pipeline/stage-adapters.js

@@ -6,7 +6,7 @@ const { runSpecGate } = require('../../commands/spec-gate');
 function createDefaultStageAdapters(projectPath = process.cwd()) {
   return {
     requirements: async context => {
-      const specDir = path.join(projectPath, '.kiro', 'specs', context.specId);
+      const specDir = path.join(projectPath, '.sce', 'specs', context.specId);
       const requirementsPath = path.join(specDir, 'requirements.md');
 
       if (!await fs.pathExists(requirementsPath)) {
@@ -37,7 +37,7 @@ function createDefaultStageAdapters(projectPath = process.cwd()) {
     },
 
     design: async context => {
-      const designPath = path.join(projectPath, '.kiro', 'specs', context.specId, 'design.md');
+      const designPath = path.join(projectPath, '.sce', 'specs', context.specId, 'design.md');
       const exists = await fs.pathExists(designPath);
 
       if (!exists) {
@@ -62,7 +62,7 @@ function createDefaultStageAdapters(projectPath = process.cwd()) {
     },
 
     tasks: async context => {
-      const tasksPath = path.join(projectPath, '.kiro', 'specs', context.specId, 'tasks.md');
+      const tasksPath = path.join(projectPath, '.sce', 'specs', context.specId, 'tasks.md');
       const exists = await fs.pathExists(tasksPath);
 
       if (!exists) {

package/lib/spec/pipeline/state-store.js

@@ -8,7 +8,7 @@ class PipelineStateStore {
   }
 
   getStateDir(specId) {
-    return path.join(this.projectPath, '.kiro', 'state', 'spec-pipeline', specId);
+    return path.join(this.projectPath, '.sce', 'state', 'spec-pipeline', specId);
   }
 
   getRunPath(specId, runId) {

package/lib/spec-gate/policy/policy-loader.js

@@ -31,7 +31,7 @@ class PolicyLoader {
         : path.join(this.projectPath, explicitPath);
     }
 
-    const projectPolicy = path.join(this.projectPath, '.kiro', 'config', 'spec-gate-policy.json');
+    const projectPolicy = path.join(this.projectPath, '.sce', 'config', 'spec-gate-policy.json');
     if (fs.existsSync(projectPolicy)) {
       return projectPolicy;
     }

package/lib/spec-gate/rules/default-rules.js

@@ -8,7 +8,7 @@ function createDefaultRules(projectPath = process.cwd()) {
       id: 'mandatory',
       description: 'Verify mandatory Spec files exist',
       async execute(context) {
-        const specPath = path.join(projectPath, '.kiro', 'specs', context.specId);
+        const specPath = path.join(projectPath, '.sce', 'specs', context.specId);
         const requiredFiles = ['requirements.md', 'design.md', 'tasks.md'];
         const checks = await Promise.all(requiredFiles.map(async fileName => {
           const filePath = path.join(specPath, fileName);
@@ -34,7 +34,7 @@ function createDefaultRules(projectPath = process.cwd()) {
       id: 'tests',
       description: 'Verify tasks include explicit validation intent',
       async execute(context) {
-        const tasksPath = path.join(projectPath, '.kiro', 'specs', context.specId, 'tasks.md');
+        const tasksPath = path.join(projectPath, '.sce', 'specs', context.specId, 'tasks.md');
         if (!await fs.pathExists(tasksPath)) {
           return {
             passed: false,
@@ -79,7 +79,7 @@ function createDefaultRules(projectPath = process.cwd()) {
       id: 'config_consistency',
       description: 'Verify project-level sce config baseline exists',
       async execute() {
-        const kiroDir = path.join(projectPath, '.kiro');
+        const kiroDir = path.join(projectPath, '.sce');
         const configDir = path.join(kiroDir, 'config');
         const hasKiro = await fs.pathExists(kiroDir);
         const hasConfig = await fs.pathExists(configDir);
@@ -87,10 +87,10 @@ function createDefaultRules(projectPath = process.cwd()) {
         const ratio = hasKiro && hasConfig ? 1 : hasKiro ? 0.5 : 0;
         const warnings = [];
         if (!hasKiro) {
-          warnings.push('.kiro directory missing');
+          warnings.push('.sce directory missing');
         }
         if (hasKiro && !hasConfig) {
-          warnings.push('.kiro/config directory missing');
+          warnings.push('.sce/config directory missing');
         }
 
         return {
@@ -108,7 +108,7 @@ function createDefaultRules(projectPath = process.cwd()) {
       id: 'traceability',
       description: 'Verify requirement-design-task traceability hints',
       async execute(context) {
-        const specPath = path.join(projectPath, '.kiro', 'specs', context.specId);
+        const specPath = path.join(projectPath, '.sce', 'specs', context.specId);
         const designPath = path.join(specPath, 'design.md');
         const tasksPath = path.join(specPath, 'tasks.md');
 

package/lib/steering/adoption-config.js

@@ -9,7 +9,7 @@ const path = require('path');
 class AdoptionConfig {
   constructor(projectPath) {
     this.projectPath = projectPath;
-    this.configPath = path.join(projectPath, '.kiro', 'adoption-config.json');
+    this.configPath = path.join(projectPath, '.sce', 'adoption-config.json');
   }
 
   /**

package/lib/steering/compliance-error-reporter.js

@@ -19,7 +19,7 @@ class ComplianceErrorReporter {
 
     let message = '\n';
     message += chalk.red.bold('❌ Steering Directory Compliance Check Failed') + '\n\n';
-    message += 'The .kiro/steering/ directory contains files or subdirectories that are not allowed.\n';
+    message += 'The .sce/steering/ directory contains files or subdirectories that are not allowed.\n';
     message += 'This directory is automatically loaded in every AI session, so keeping it clean is critical.\n\n';
 
     message += chalk.yellow.bold('Violations Found:') + '\n';
@@ -45,8 +45,8 @@ class ComplianceErrorReporter {
     message += '  ✓ RULES_GUIDE.md\n';
 
     message += '\n' + chalk.cyan.bold('Fix Suggestions:') + '\n';
-    message += '  • Move analysis reports to: .kiro/specs/{spec-name}/reports/\n';
-    message += '  • Move historical data to: .kiro/specs/{spec-name}/\n';
+    message += '  • Move analysis reports to: .sce/specs/{spec-name}/reports/\n';
+    message += '  • Move historical data to: .sce/specs/{spec-name}/\n';
     message += '  • Move detailed docs to: docs/\n';
     message += '  • Delete temporary files\n';
 

package/lib/steering/context-sync-manager.js

@@ -13,9 +13,9 @@ const fs = require('fs-extra');
 const fsUtils = require('../utils/fs-utils');
 const { MultiAgentConfig } = require('../collab/multi-agent-config');
 
-const STEERING_DIR = '.kiro/steering';
+const STEERING_DIR = '.sce/steering';
 const CONTEXT_FILENAME = 'CURRENT_CONTEXT.md';
-const SPECS_DIR = '.kiro/specs';
+const SPECS_DIR = '.sce/specs';
 
 class ContextSyncManager {
   /**

package/lib/steering/index.js

@@ -44,7 +44,7 @@ async function runSteeringComplianceCheck(options = {}) {
 
     // Perform compliance check with performance measurement
     const startTime = Date.now();
-    const steeringPath = path.join(projectPath, '.kiro', 'steering');
+    const steeringPath = path.join(projectPath, '.sce', 'steering');
     const result = checker.check(steeringPath);
     const duration = Date.now() - startTime;
 

package/lib/steering/spec-steering.js

@@ -1,7 +1,7 @@
 /**
  * SpecSteering - Spec 级 steering.md 管理
  *
- * 负责 `.kiro/specs/{spec-name}/steering.md` 的 CRUD 操作和模板管理。
+ * 负责 `.sce/specs/{spec-name}/steering.md` 的 CRUD 操作和模板管理。
  * 在单 Agent 模式下 createTemplate 为 no-op。
  *
  * Requirements: 1.1, 1.3, 1.4, 7.1, 7.2, 7.3
@@ -13,7 +13,7 @@ const fsUtils = require('../utils/fs-utils');
 const { MultiAgentConfig } = require('../collab/multi-agent-config');
 
 const STEERING_FILENAME = 'steering.md';
-const SPECS_DIR = '.kiro/specs';
+const SPECS_DIR = '.sce/specs';
 
 /**
  * Section headers used in steering.md template.

package/lib/steering/steering-compliance-checker.js

@@ -4,7 +4,7 @@ const path = require('path');
 /**
  * SteeringComplianceChecker - Validates steering directory compliance
  * 
- * Ensures the .kiro/steering/ directory contains only allowed files
+ * Ensures the .sce/steering/ directory contains only allowed files
  * and no subdirectories to prevent context pollution and excessive
  * token consumption in AI sessions.
  */

package/lib/steering/steering-loader.js

@@ -4,7 +4,7 @@
  * L1: CORE_PRINCIPLES.md (通用约束)
  * L2: ENVIRONMENT.md (环境约束)
  * L3: CURRENT_CONTEXT.md (全局上下文)
- * L4: .kiro/specs/{spec-name}/steering.md (Spec 级约束, via SpecSteering)
+ * L4: .sce/specs/{spec-name}/steering.md (Spec 级约束, via SpecSteering)
  *
  * 单 Agent 模式下跳过 L4。
  *
@@ -16,7 +16,7 @@ const fs = require('fs-extra');
 const { SpecSteering } = require('./spec-steering');
 const { MultiAgentConfig } = require('../collab/multi-agent-config');
 
-const STEERING_DIR = '.kiro/steering';
+const STEERING_DIR = '.sce/steering';
 
 const LAYER_FILES = {
   l1: 'CORE_PRINCIPLES.md',
@@ -104,7 +104,6 @@ class SteeringLoader {
   async _loadLayerFile(layerKey) {
     const filename = LAYER_FILES[layerKey];
     const filePath = path.join(this._workspaceRoot, STEERING_DIR, filename);
-
     try {
       const exists = await fs.pathExists(filePath);
       if (!exists) {
@@ -112,9 +111,9 @@ class SteeringLoader {
       }
       return await fs.readFile(filePath, 'utf8');
     } catch (err) {
-      console.warn(`[SteeringLoader] Failed to read ${layerKey} (${filename}): ${err.message}`);
-      return null;
+      console.warn(`[SteeringLoader] Failed to read ${layerKey} (${filename}) from ${STEERING_DIR}: ${err.message}`);
     }
+    return null;
   }
 
   /**