scene-capability-engine 3.6.64 → 3.6.67

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

@@ -12,6 +12,11 @@ const path = require('path');
 const fs = require('fs-extra');
 const fsUtils = require('../utils/fs-utils');
 const { MultiAgentConfig } = require('../collab/multi-agent-config');
+const {
+  getFocusedChannelState,
+  listChannelIds,
+  normalizeProjectChannelContext
+} = require('../runtime/project-channel-context');
 
 const STEERING_DIR = '.sce/steering';
 const CONTEXT_FILENAME = 'CURRENT_CONTEXT.md';
@@ -44,7 +49,7 @@ class ContextSyncManager {
       return { success: true };
     }
 
-    await this._steeringFileLock.withLock(CONTEXT_FILENAME, async () => {
+    await this._withContextLock(async () => {
       const context = await this.readContext();
       context.specs[specName] = {
         status: entry.status,
@@ -57,16 +62,39 @@ class ContextSyncManager {
     return { success: true };
   }
 
+  /**
+   * Update CURRENT_CONTEXT project/channel summary without overwriting richer context sections.
+   *
+   * @param {string} projectId
+   * @param {object} projectChannelContext
+   * @returns {Promise<{success: boolean}>}
+   */
+  async updateProjectChannelSummary(projectId, projectChannelContext) {
+    const normalizedProjectId = `${projectId || ''}`.trim();
+    if (!normalizedProjectId) {
+      throw new Error('projectId is required');
+    }
+
+    const summary = this._summarizeProjectChannelContext(projectChannelContext, normalizedProjectId);
+    await this._withContextLock(async () => {
+      const context = await this.readContext();
+      context.projectChannels[normalizedProjectId] = summary;
+      await this.writeContext(context);
+    });
+
+    return { success: true };
+  }
+
   /**
    * Read and parse CURRENT_CONTEXT.md into a structured object.
    * Returns default empty object if file doesn't exist.
    *
-   * @returns {Promise<{version: string|null, globalStatus: string|null, specs: object}>}
+   * @returns {Promise<object>}
    */
   async readContext() {
     const exists = await fs.pathExists(this._contextPath);
     if (!exists) {
-      return { version: null, globalStatus: null, specs: {} };
+      return this._createEmptyContext();
     }
 
     try {
@@ -74,7 +102,7 @@ class ContextSyncManager {
       return this.parseContext(content);
     } catch (err) {
       console.warn(`[ContextSyncManager] Failed to read ${this._contextPath}: ${err.message}`);
-      return { version: null, globalStatus: null, specs: {} };
+      return this._createEmptyContext();
     }
   }
 
@@ -82,7 +110,7 @@ class ContextSyncManager {
    * Write a structured context object back to CURRENT_CONTEXT.md.
    * Uses atomic write for file integrity.
    *
-   * @param {{version: string|null, globalStatus: string|null, specs: object}} context
+   * @param {object} context
    * @returns {Promise<void>}
    */
   async writeContext(context) {
@@ -117,52 +145,162 @@ class ContextSyncManager {
 
   /**
    * Parse CURRENT_CONTEXT.md Markdown content into a structured object.
-   * Handles both old single-agent format and new multi-agent table format.
+   * Handles both old single-agent format and richer multi-section format.
    *
    * @param {string} content
-   * @returns {{version: string|null, globalStatus: string|null, specs: object}}
+   * @returns {object}
    */
   parseContext(content) {
-    const result = { version: null, globalStatus: null, specs: {} };
+    const result = this._createEmptyContext();
 
     if (!content || typeof content !== 'string') {
       return result;
     }
 
     const lines = content.split('\n');
+    let activeListKey = null;
+    let inSpecTable = false;
+    let inProjectChannelTable = false;
 
     for (const line of lines) {
       const trimmed = line.trim();
 
-      // Parse version line: **版本**: ...
-      const versionMatch = trimmed.match(/^\*\*版本\*\*:\s*(.+)$/);
+      if (!trimmed) {
+        activeListKey = null;
+        continue;
+      }
+
+      const versionMatch = trimmed.match(/^\*\*版本\*\*[:：]\s*(.+)$/);
       if (versionMatch) {
         result.version = versionMatch[1].trim();
         continue;
       }
 
-      // Parse global status line: **状态**: ...
-      const statusMatch = trimmed.match(/^\*\*状态\*\*:\s*(.+)$/);
+      const statusMatch = trimmed.match(/^\*\*状态\*\*[:：]\s*(.+)$/);
       if (statusMatch) {
         result.globalStatus = statusMatch[1].trim();
         continue;
       }
 
-      // Parse table rows for Spec progress
-      // Format: | spec-name | status | progress% | summary |
-      if (trimmed.startsWith('|') && !trimmed.startsWith('|---') && !trimmed.startsWith('| Spec')) {
-        const cells = trimmed.split('|').map(c => c.trim()).filter(c => c.length > 0);
+      const mainlineMatch = trimmed.match(/^\*\*当前主线\*\*[:：]\s*(.+)$/);
+      if (mainlineMatch) {
+        result.currentMainline = mainlineMatch[1].trim();
+        continue;
+      }
+
+      const collaborationMatch = trimmed.match(/^\*\*当前协作模型\*\*[:：]\s*(.+)$/);
+      if (collaborationMatch) {
+        result.collaborationModel = collaborationMatch[1].trim();
+        continue;
+      }
+
+      if (trimmed === '**本轮重点**:') {
+        activeListKey = 'highlights';
+        inSpecTable = false;
+        inProjectChannelTable = false;
+        continue;
+      }
+
+      if (trimmed === '**后续候选主线**:') {
+        activeListKey = 'nextCandidates';
+        inSpecTable = false;
+        inProjectChannelTable = false;
+        continue;
+      }
+
+      if (trimmed === '## Spec 进度') {
+        activeListKey = null;
+        inSpecTable = false;
+        inProjectChannelTable = false;
+        continue;
+      }
+
+      if (trimmed === '## 项目通道快照') {
+        activeListKey = null;
+        inSpecTable = false;
+        inProjectChannelTable = false;
+        continue;
+      }
+
+      if (activeListKey && trimmed.startsWith('- ')) {
+        result[activeListKey].push(trimmed.slice(2).trim());
+        continue;
+      }
+
+      if (trimmed === '| Spec | 状态 | 进度 | 摘要 |') {
+        activeListKey = null;
+        inSpecTable = true;
+        inProjectChannelTable = false;
+        continue;
+      }
+
+      if (
+        trimmed === '| Project | Focused Channel | Active Scene | Active Spec | Active Doc | Channels | Updated |'
+        || trimmed === '| Project | Focused Channel | Active Spec | Active Doc | Channels | Updated |'
+      ) {
+        activeListKey = null;
+        inSpecTable = false;
+        inProjectChannelTable = true;
+        continue;
+      }
+
+      if (inSpecTable && trimmed.startsWith('|') && !trimmed.startsWith('|---')) {
+        const cells = trimmed.split('|').map((cell) => cell.trim()).filter((cell) => cell.length > 0);
         if (cells.length >= 4) {
           const specName = cells[0];
           const status = cells[1];
-          const progressStr = cells[2].replace('%', '');
-          const progress = parseInt(progressStr, 10);
+          const progress = parseInt(cells[2].replace('%', ''), 10);
           const summary = cells[3];
 
-          if (specName && status && !isNaN(progress)) {
+          if (specName && status && !Number.isNaN(progress)) {
             result.specs[specName] = { status, progress, summary };
           }
         }
+        continue;
+      }
+
+      if (inProjectChannelTable && trimmed.startsWith('|') && !trimmed.startsWith('|---')) {
+        const cells = trimmed.split('|').map((cell) => cell.trim()).filter((cell) => cell.length > 0);
+        if (cells.length >= 7) {
+          const projectId = cells[0];
+          const channels = cells[5]
+            .split(',')
+            .map((item) => item.trim())
+            .filter(Boolean);
+          if (projectId) {
+            result.projectChannels[projectId] = {
+              projectId,
+              focusedChannelId: cells[1],
+              activeScene: cells[2],
+              activeSpecId: cells[3],
+              activeDoc: cells[4],
+              channelCount: channels.length,
+              channels,
+              updatedAt: cells[6]
+            };
+          }
+          continue;
+        }
+
+        if (cells.length >= 6) {
+          const projectId = cells[0];
+          const channels = cells[4]
+            .split(',')
+            .map((item) => item.trim())
+            .filter(Boolean);
+          if (projectId) {
+            result.projectChannels[projectId] = {
+              projectId,
+              focusedChannelId: cells[1],
+              activeScene: '',
+              activeSpecId: cells[2],
+              activeDoc: cells[3],
+              channelCount: channels.length,
+              channels,
+              updatedAt: cells[5]
+            };
+          }
+        }
       }
     }
 
@@ -172,23 +310,54 @@ class ContextSyncManager {
   /**
    * Format a structured context object into CURRENT_CONTEXT.md Markdown.
    *
-   * @param {{version: string|null, globalStatus: string|null, specs: object}} context
+   * @param {object} context
    * @returns {string}
    */
   formatContext(context) {
+    const normalized = this._normalizeContext(context);
     const lines = [];
 
     lines.push('# 当前场景');
     lines.push('');
 
-    if (context.version) {
-      lines.push(`**版本**: ${context.version}`);
+    if (normalized.version) {
+      lines.push(`**版本**: ${normalized.version}`);
     }
-    if (context.globalStatus) {
-      lines.push(`**状态**: ${context.globalStatus}`);
+    if (normalized.globalStatus) {
+      lines.push(`**状态**: ${normalized.globalStatus}`);
+    }
+    if (normalized.currentMainline) {
+      lines.push(`**当前主线**: ${normalized.currentMainline}`);
+    }
+    if (normalized.collaborationModel) {
+      lines.push(`**当前协作模型**: ${normalized.collaborationModel}`);
+    }
+
+    if (normalized.highlights.length > 0) {
+      lines.push('');
+      lines.push('**本轮重点**:');
+      for (const item of normalized.highlights) {
+        lines.push(`- ${item}`);
+      }
+    }
+
+    const projectChannelEntries = Object.values(normalized.projectChannels)
+      .sort((left, right) => left.projectId.localeCompare(right.projectId));
+    if (projectChannelEntries.length > 0) {
+      lines.push('');
+      lines.push('## 项目通道快照');
+      lines.push('');
+      lines.push('| Project | Focused Channel | Active Scene | Active Spec | Active Doc | Channels | Updated |');
+      lines.push('|---------|-----------------|--------------|-------------|------------|----------|---------|');
+
+      for (const entry of projectChannelEntries) {
+        lines.push(
+          `| ${entry.projectId} | ${entry.focusedChannelId || ''} | ${entry.activeScene || ''} | ${entry.activeSpecId || ''} | ${entry.activeDoc || ''} | ${(entry.channels || []).join(', ')} | ${entry.updatedAt || ''} |`
+        );
+      }
     }
 
-    const specEntries = Object.entries(context.specs || {});
+    const specEntries = Object.entries(normalized.specs || {});
     if (specEntries.length > 0) {
       lines.push('');
       lines.push('## Spec 进度');
@@ -204,6 +373,14 @@ class ContextSyncManager {
       }
     }
 
+    if (normalized.nextCandidates.length > 0) {
+      lines.push('');
+      lines.push('**后续候选主线**:');
+      for (const item of normalized.nextCandidates) {
+        lines.push(`- ${item}`);
+      }
+    }
+
     lines.push('');
     lines.push('---');
     lines.push('');
@@ -217,6 +394,80 @@ class ContextSyncManager {
 
   // ── Private helpers ──────────────────────────────────────────────
 
+  _createEmptyContext() {
+    return {
+      version: null,
+      globalStatus: null,
+      currentMainline: null,
+      collaborationModel: null,
+      highlights: [],
+      nextCandidates: [],
+      specs: {},
+      projectChannels: {}
+    };
+  }
+
+  _normalizeContext(context = {}) {
+    const payload = context && typeof context === 'object' ? context : {};
+
+    const normalizeText = (value) => {
+      if (typeof value !== 'string') {
+        return null;
+      }
+      const trimmed = value.trim();
+      return trimmed || null;
+    };
+
+    const normalizeList = (values) => {
+      if (!Array.isArray(values)) {
+        return [];
+      }
+      return values
+        .map((item) => (typeof item === 'string' ? item.trim() : ''))
+        .filter(Boolean);
+    };
+
+    return {
+      version: normalizeText(payload.version),
+      globalStatus: normalizeText(payload.globalStatus),
+      currentMainline: normalizeText(payload.currentMainline),
+      collaborationModel: normalizeText(payload.collaborationModel),
+      highlights: normalizeList(payload.highlights),
+      nextCandidates: normalizeList(payload.nextCandidates),
+      specs: payload.specs && typeof payload.specs === 'object' ? payload.specs : {},
+      projectChannels: payload.projectChannels && typeof payload.projectChannels === 'object'
+        ? payload.projectChannels
+        : {}
+    };
+  }
+
+  async _withContextLock(work) {
+    if (this._steeringFileLock && typeof this._steeringFileLock.withLock === 'function') {
+      return this._steeringFileLock.withLock(CONTEXT_FILENAME, work);
+    }
+    return work();
+  }
+
+  _summarizeProjectChannelContext(projectChannelContext, projectId) {
+    const normalized = normalizeProjectChannelContext(projectChannelContext, {
+      projectId,
+      allowDefaultChannelSynthesis: false
+    });
+    const focused = getFocusedChannelState(normalized);
+    const channels = listChannelIds(normalized);
+
+    return {
+      projectId: normalized.projectId,
+      focusedChannelId: normalized.focusedChannelId,
+      activeScene: focused && focused.activeScene ? focused.activeScene : '',
+      activeSpecId: focused && focused.activeSpecId ? focused.activeSpecId : '',
+      activeDoc: focused && focused.activeDoc ? focused.activeDoc : '',
+      channelCount: channels.length,
+      channels,
+      updatedAt: focused && focused.updatedAt ? focused.updatedAt : new Date().toISOString()
+    };
+  }
+
   /**
    * Compute progress from tasks.md content.
    * Counts only leaf tasks (lines with checkbox patterns that have no sub-tasks).

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

@@ -21,6 +21,23 @@ const DEFAULT_STUDIO_SCENE_BACKFILL_RULES = Object.freeze([
     scene_id: 'scene.moqui-core',
     keywords: ['moqui']
   },
+  {
+    id: 'semantic-kernel',
+    scene_id: 'scene.sce-semantic-kernel',
+    keywords: [
+      'semantic',
+      'dialogue',
+      'conversation',
+      'reply',
+      'prompt',
+      'self-eval',
+      'simulation',
+      'codex cli',
+      'claude code',
+      'kiro',
+      'standalone sce'
+    ]
+  },
   {
     id: 'orchestration',
     scene_id: 'scene.sce-orchestration',
@@ -692,6 +709,10 @@ async function runStudioAutoIntake(options = {}, dependencies = {}) {
   const fileSystem = dependencies.fileSystem || fs;
   const sceneId = normalizeText(options.scene_id || options.sceneId);
   const goal = normalizeText(options.goal);
+  const supremeAssessment = options.supreme_principles && typeof options.supreme_principles === 'object'
+    ? options.supreme_principles
+    : null;
+  const effectiveGoal = normalizeText(supremeAssessment && supremeAssessment.effective_text) || goal;
   const fromChat = normalizeText(options.from_chat || options.fromChat);
   const explicitSpecId = normalizeText(options.explicit_spec_id || options.spec_id || options.specId);
   const apply = options.apply === true;
@@ -702,9 +723,9 @@ async function runStudioAutoIntake(options = {}, dependencies = {}) {
     : await loadStudioIntakePolicy(projectPath, fileSystem);
 
   const policy = loadedPolicy.policy;
-  const intent = classifyStudioGoalIntent(goal, policy);
+  const intent = classifyStudioGoalIntent(effectiveGoal, policy);
   const decision = resolveStudioSpecIntakeDecision({
-    goal,
+    goal: effectiveGoal,
     explicit_spec_id: explicitSpecId,
     domain_chain_binding: options.domain_chain_binding || {},
     related_specs: options.related_specs || {},
@@ -721,6 +742,8 @@ async function runStudioAutoIntake(options = {}, dependencies = {}) {
     scene_id: sceneId || null,
     from_chat: fromChat || null,
     goal: goal || null,
+    effective_goal: effectiveGoal || null,
+    supreme_principles: supremeAssessment,
     intent,
     decision: {
       ...decision
@@ -749,6 +772,19 @@ async function runStudioAutoIntake(options = {}, dependencies = {}) {
     return payload;
   }
 
+  if (supremeAssessment && normalizeText(supremeAssessment.action) === 'refuse') {
+    payload.decision = {
+      action: 'refuse',
+      reason: normalizeText(supremeAssessment.message) || 'blocked by supreme principles',
+      confidence: 'high',
+      spec_id: null,
+      source: 'supreme-principles',
+      intent
+    };
+    payload.selected_spec_id = null;
+    return payload;
+  }
+
   if (decision.action === 'create_spec') {
     const existingSpecIds = await listExistingSpecIds(projectPath, fileSystem);
     const autoSpecId = createAutoSpecId(sceneId, goal, existingSpecIds, policy);
@@ -758,7 +794,7 @@ async function runStudioAutoIntake(options = {}, dependencies = {}) {
       const createdSpec = await materializeIntakeSpec(projectPath, {
         scene_id: sceneId,
         from_chat: fromChat,
-        goal,
+        goal: effectiveGoal,
         spec_id: autoSpecId
       }, {
         fileSystem

package/lib/studio/task-envelope.js

@@ -3,6 +3,31 @@ function buildStudioTaskKey(stageName = '') {
   return 'studio:' + normalizedStage;
 }
 
+function extractProjectChannel(job = {}, normalizeString) {
+  const binding = job && job.session && job.session.project_channel && typeof job.session.project_channel === 'object'
+    ? job.session.project_channel
+    : null;
+  if (!binding) {
+    return null;
+  }
+
+  const projectChannel = {
+    project_id: normalizeString(binding.project_id) || null,
+    channel_id: normalizeString(binding.channel_id) || null,
+    focused_channel_id: normalizeString(binding.focused_channel_id) || null,
+    active_session_path: normalizeString(binding.active_session_path) || null,
+    active_scene: normalizeString(binding.active_scene) || null,
+    active_spec_id: normalizeString(binding.active_spec_id) || null,
+    active_doc: normalizeString(binding.active_doc) || null
+  };
+
+  if (!projectChannel.project_id && !projectChannel.channel_id) {
+    return null;
+  }
+
+  return projectChannel;
+}
+
 async function resolveTaskReference(mode, job, options = {}, dependencies = {}) {
   const normalizeString = dependencies.normalizeString;
   const resolveTaskStage = dependencies.resolveTaskStage;
@@ -23,6 +48,7 @@ async function resolveTaskReference(mode, job, options = {}, dependencies = {})
   const taskKey = normalizeString(options.taskKey) || buildStudioTaskKey(stageName);
   const projectPath = normalizeString(options.projectPath) || process.cwd();
   const taskRefRegistry = options.taskRefRegistry || new TaskRefRegistry(projectPath, { fileSystem });
+  const projectChannel = extractProjectChannel(job, normalizeString);
 
   try {
     const taskRef = await taskRefRegistry.resolveOrCreateRef({
@@ -33,7 +59,10 @@ async function resolveTaskReference(mode, job, options = {}, dependencies = {})
       metadata: {
         mode: normalizeString(mode) || null,
         stage: stageName || null,
-        job_id: normalizeString(job && job.job_id) || null
+        job_id: normalizeString(job && job.job_id) || null,
+        project_id: projectChannel ? projectChannel.project_id : null,
+        channel_id: projectChannel ? projectChannel.channel_id : null,
+        project_channel: projectChannel
       }
     });
     return taskRef.task_ref;
@@ -183,6 +212,7 @@ function buildTaskEnvelope(mode, job, options = {}, dependencies = {}) {
   const sceneId = normalizeString(job && job.scene && job.scene.id) || null;
   const specId = normalizeString(job && job.scene && job.scene.spec_id) || normalizeString(job && job.source && job.source.spec_id) || null;
   const taskRef = normalizeString(options.taskRef) || null;
+  const projectChannel = extractProjectChannel(job, normalizeString);
 
   const commands = normalizeTaskCommands([
     ...(Array.isArray(stageMetadata.commands) ? stageMetadata.commands : []),
@@ -206,7 +236,8 @@ function buildTaskEnvelope(mode, job, options = {}, dependencies = {}) {
 
   const normalizedHandoff = {
     ...handoff,
-    task_ref: taskRef
+    task_ref: taskRef,
+    project_channel: projectChannel
   };
 
   return {
@@ -215,6 +246,7 @@ function buildTaskEnvelope(mode, job, options = {}, dependencies = {}) {
     specId,
     taskId,
     taskRef,
+    project_channel: projectChannel,
     eventId: normalizeString(latestEvent && latestEvent.event_id) || null,
     task: {
       ref: taskRef,
@@ -228,6 +260,7 @@ function buildTaskEnvelope(mode, job, options = {}, dependencies = {}) {
       confidence: taskIntent.confidence,
       status: taskStatus,
       summary: buildTaskSummaryLines(job, stageName, taskStatus, nextAction, taskRef, dependencies.buildProgress),
+      project_channel: projectChannel,
       handoff: normalizedHandoff,
       next_action: nextAction,
       file_changes: fileChanges,