scene-capability-engine 3.6.64 → 3.6.67

package/lib/project/target-resolution-service.js

@@ -1,5 +1,7 @@
 const path = require('path');
 const { buildProjectPortfolioProjection } = require('./portfolio-projection-service');
+const { buildProjectChannelProjection } = require('./project-channel-projection');
+const { buildProjectChannelOutput, buildProjectChannelOutputFromProjection } = require('./project-channel-output');
 
 function normalizeString(value) {
   if (typeof value !== 'string') {
@@ -67,28 +69,71 @@ function scoreProjectMatch(requestText, project = {}) {
     workspaceId: project.workspaceId || null,
     projectName: project.projectName || null,
     appKey: project.appKey || null,
+    projectChannelContext: project.projectChannelContext || null,
     confidence: Number(bestScore.toFixed(2)),
     reasonCode
   };
 }
 
-function buildResolutionCallerContext(options = {}, portfolio = {}) {
+function buildCallerProjectChannelBinding(projectId, projectChannelProjection = {}) {
+  const channel = buildProjectChannelOutputFromProjection(projectChannelProjection, {
+    canonicalProjectId: projectId
+  });
+  if (!channel.context_available || !channel.channel_id) {
+    return null;
+  }
+  return channel;
+}
+
+async function buildResolutionCallerContext(options = {}, portfolio = {}, dependencies = {}) {
   const portfolioContext = portfolio && portfolio.callerContext && typeof portfolio.callerContext === 'object'
     ? portfolio.callerContext
     : {};
   const explicitCurrentProject = normalizeString(options.currentProject);
   const explicitDeviceId = normalizeString(options.device);
   const explicitToolInstanceId = normalizeString(options.toolInstanceId);
+  const explicitChannelId = normalizeString(options.channel);
+  const currentProjectId = explicitCurrentProject || normalizeString(portfolioContext.projectId);
+  let projectChannelProjection = null;
+
+  if (currentProjectId) {
+    const currentProject = Array.isArray(portfolio.projects)
+      ? portfolio.projects.find((project) => project.projectId === currentProjectId)
+      : null;
+    if (currentProject && normalizeString(currentProject.projectRoot)) {
+      projectChannelProjection = await buildProjectChannelProjection(currentProject.projectRoot, {
+        preferredProjectIds: [
+          currentProject.projectChannelContext && currentProject.projectChannelContext.contextProjectId,
+          currentProjectId,
+          currentProject.workspaceId
+        ],
+        channelId: explicitChannelId
+      }, dependencies);
+    }
+  }
+
+  const callerProjectChannel = buildCallerProjectChannelBinding(currentProjectId, projectChannelProjection || {});
 
   return {
-    ...(explicitCurrentProject || portfolioContext.projectId
-      ? { currentProjectId: explicitCurrentProject || portfolioContext.projectId }
+    ...(currentProjectId
+      ? { currentProjectId }
       : {}),
     ...(portfolioContext.workspaceId ? { workspaceId: portfolioContext.workspaceId } : {}),
     ...(explicitDeviceId || portfolioContext.deviceId
       ? { deviceId: explicitDeviceId || portfolioContext.deviceId }
       : {}),
-    ...(explicitToolInstanceId ? { toolInstanceId: explicitToolInstanceId } : {})
+    ...(explicitToolInstanceId ? { toolInstanceId: explicitToolInstanceId } : {}),
+    ...(callerProjectChannel && callerProjectChannel.channel_id
+      ? {
+          currentChannelId: callerProjectChannel.channel_id,
+          currentChannelContextAvailable: callerProjectChannel.context_available,
+          currentChannelStorageMode: callerProjectChannel.storage_mode,
+          requestedChannelId: callerProjectChannel.requested_channel_id,
+          focusedChannelId: callerProjectChannel.focused_channel_id,
+          activeScene: callerProjectChannel.active_scene,
+          activeSpecId: callerProjectChannel.active_spec_id
+        }
+      : {})
   };
 }
 
@@ -97,16 +142,32 @@ async function resolveProjectTarget(options = {}, dependencies = {}) {
   const portfolio = await buildProjectPortfolioProjection({
     workspace: options.workspace
   }, dependencies);
-  const callerContext = buildResolutionCallerContext(options, portfolio);
+  const callerContext = await buildResolutionCallerContext(options, portfolio, dependencies);
   const currentProjectId = normalizeString(callerContext.currentProjectId);
   const visibleProjects = Array.isArray(portfolio.projects) ? portfolio.projects : [];
   const currentProject = visibleProjects.find((project) => project.projectId === currentProjectId) || null;
+  const callerProjectChannel = callerContext.currentChannelId
+    ? buildProjectChannelOutput({
+        projectId: currentProjectId || null,
+        canonicalProjectId: currentProjectId || null,
+        requestedChannelId: callerContext.requestedChannelId,
+        contextAvailable: callerContext.currentChannelContextAvailable === true,
+        storageMode: callerContext.currentChannelStorageMode,
+        fallback: {
+          focused_channel_id: callerContext.focusedChannelId,
+          channel_id: callerContext.currentChannelId,
+          active_scene: callerContext.activeScene,
+          active_spec_id: callerContext.activeSpecId
+        }
+      })
+    : null;
 
   if (!requestText) {
     if (currentProject) {
       return {
         resolvedAt: new Date().toISOString(),
         callerContext,
+        ...(callerProjectChannel ? { callerProjectChannel } : {}),
         status: 'current-project',
         currentProjectId,
         resolvedProjectId: currentProjectId,
@@ -117,6 +178,7 @@ async function resolveProjectTarget(options = {}, dependencies = {}) {
     return {
       resolvedAt: new Date().toISOString(),
       callerContext,
+      ...(callerProjectChannel ? { callerProjectChannel } : {}),
       status: 'unresolved',
       ...(currentProjectId ? { currentProjectId } : {}),
       reasonCode: currentProjectId
@@ -139,6 +201,7 @@ async function resolveProjectTarget(options = {}, dependencies = {}) {
     return {
       resolvedAt: new Date().toISOString(),
       callerContext,
+      ...(callerProjectChannel ? { callerProjectChannel } : {}),
       status: 'unresolved',
       ...(currentProjectId ? { currentProjectId } : {}),
       reasonCode: 'target.no_match'
@@ -153,6 +216,7 @@ async function resolveProjectTarget(options = {}, dependencies = {}) {
     return {
       resolvedAt: new Date().toISOString(),
       callerContext,
+      ...(callerProjectChannel ? { callerProjectChannel } : {}),
       status: 'ambiguous',
       ...(currentProjectId ? { currentProjectId } : {}),
       confidence: best.confidence,
@@ -164,6 +228,7 @@ async function resolveProjectTarget(options = {}, dependencies = {}) {
   return {
     resolvedAt: new Date().toISOString(),
     callerContext,
+    ...(callerProjectChannel ? { callerProjectChannel } : {}),
     status: currentProjectId && best.projectId === currentProjectId
       ? 'current-project'
       : 'resolved-other-project',

package/lib/project/visibility-policy.js

@@ -0,0 +1,93 @@
+const path = require('path');
+
+const PROJECT_VISIBILITY_REASON_CODES = {
+  MANAGED: 'project.visibility.managed',
+  EPHEMERAL_ROOT: 'project.visibility.ephemeral_root'
+};
+
+const EXPLICIT_PROBE_NAME_PATTERNS = [
+  /^_codex_import_probe(?:[-_.].*)?$/,
+  /^_mb_tmp_project_import_probe(?:[-_.].*)?$/,
+  /(?:^|[-_.])codex_import_probe(?:[-_.].*)?$/,
+  /(?:^|[-_.])mb_tmp_project_import_probe(?:[-_.].*)?$/,
+  /(?:^|[-_.])tmp_project_import_probe(?:[-_.].*)?$/,
+  /(?:^|[-_.])import_probe(?:[-_.].*)?$/
+];
+
+const TEMP_PATH_PATTERNS = [
+  /\/tmp\//,
+  /\/temp\//,
+  /\/appdata\/local\/temp\//,
+  /\/var\/folders\//
+];
+
+function normalizeString(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+function normalizeText(value) {
+  return normalizeString(value).toLowerCase();
+}
+
+function normalizePath(value) {
+  return normalizeString(value).replace(/\\/g, '/');
+}
+
+function looksLikeExplicitProbeName(value) {
+  const normalized = normalizeText(value);
+  if (!normalized) {
+    return false;
+  }
+  return EXPLICIT_PROBE_NAME_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+
+function looksLikeTempProbePath(projectRoot) {
+  const normalizedRoot = normalizePath(projectRoot).toLowerCase();
+  if (!normalizedRoot) {
+    return false;
+  }
+  const baseName = normalizeText(path.basename(normalizedRoot));
+  if (!baseName.includes('probe')) {
+    return false;
+  }
+  return TEMP_PATH_PATTERNS.some((pattern) => pattern.test(normalizedRoot));
+}
+
+function isEphemeralProjectRoot(input = {}) {
+  const workspaceId = normalizeString(input.workspaceId);
+  const projectRoot = normalizePath(input.projectRoot || input.rootDir);
+  const projectName = normalizeString(input.projectName) || (projectRoot ? path.basename(projectRoot) : '');
+  return looksLikeExplicitProbeName(workspaceId)
+    || looksLikeExplicitProbeName(projectName)
+    || looksLikeTempProbePath(projectRoot);
+}
+
+function classifyProjectVisibility(input = {}) {
+  if (isEphemeralProjectRoot(input)) {
+    return {
+      visibility: 'hidden',
+      lifecycle: 'ephemeral',
+      reasonCode: PROJECT_VISIBILITY_REASON_CODES.EPHEMERAL_ROOT
+    };
+  }
+
+  return {
+    visibility: 'managed',
+    lifecycle: 'persistent',
+    reasonCode: PROJECT_VISIBILITY_REASON_CODES.MANAGED
+  };
+}
+
+function isCallerVisibleProject(input = {}) {
+  return classifyProjectVisibility(input).visibility === 'managed';
+}
+
+module.exports = {
+  PROJECT_VISIBILITY_REASON_CODES,
+  classifyProjectVisibility,
+  isCallerVisibleProject,
+  isEphemeralProjectRoot
+};

package/lib/runtime/multi-spec-scene-session.js

@@ -40,6 +40,8 @@ async function bindMultiSpecSceneSession(options = {}, dependencies = {}) {
   const {
     specTargets = [],
     sceneId = null,
+    projectId = null,
+    collabChannel = null,
     commandName = 'spec-command',
     commandLabel = 'spec-command',
     commandOptions = {},
@@ -60,6 +62,8 @@ async function bindMultiSpecSceneSession(options = {}, dependencies = {}) {
 
   const sceneBinding = await resolveSpecSceneBinding({
     sceneId,
+    projectId,
+    collabChannel,
     allowNoScene: false
   }, {
     projectPath,
@@ -115,7 +119,10 @@ async function bindMultiSpecSceneSession(options = {}, dependencies = {}) {
         scene_session_id: sceneBinding.scene_session_id,
         binding_source: sceneBinding.source,
         multi_spec_child_sessions: specSessions
-      }
+      },
+      ...(sceneBinding.project_channel
+        ? { project_channel: sceneBinding.project_channel }
+        : {})
     };
   } catch (error) {
     if (shouldTrackSessions) {

package/lib/runtime/project-channel-context-store.js

@@ -0,0 +1,387 @@
+const path = require('path');
+const fs = require('fs-extra');
+const {
+  normalizeProjectChannelContext,
+  normalizeChannelState,
+  setFocusedChannel,
+  updateChannelState
+} = require('./project-channel-context');
+
+const PROJECT_CHANNEL_CONTEXT_DIR = path.join('.sce', 'state', 'project-channel-contexts');
+const PROJECT_CHANNEL_INDEX_FILE = 'index.json';
+const PROJECT_CHANNEL_CHANNELS_DIR = 'channels';
+
+function normalizeString(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+function safePathPart(value, fallback) {
+  const normalized = `${value || ''}`
+    .trim()
+    .replace(/[^a-zA-Z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return normalized || fallback;
+}
+
+class ProjectChannelContextStore {
+  constructor(projectPath = process.cwd(), fileSystem = fs, options = {}) {
+    this._projectPath = projectPath;
+    this._fileSystem = fileSystem;
+    this._contextDir = path.join(projectPath, PROJECT_CHANNEL_CONTEXT_DIR);
+    this._contextSyncManager = options.contextSyncManager || null;
+  }
+
+  getContextPath(projectId) {
+    return this.getProjectIndexPath(projectId);
+  }
+
+  getLegacyContextPath(projectId) {
+    const normalizedProjectId = normalizeString(projectId);
+    if (!normalizedProjectId) {
+      throw new Error('projectId is required');
+    }
+    return path.join(this._contextDir, `${safePathPart(normalizedProjectId, 'project')}.json`);
+  }
+
+  getProjectDirectoryPath(projectId) {
+    const normalizedProjectId = normalizeString(projectId);
+    if (!normalizedProjectId) {
+      throw new Error('projectId is required');
+    }
+    return path.join(this._contextDir, safePathPart(normalizedProjectId, 'project'));
+  }
+
+  getProjectIndexPath(projectId) {
+    return path.join(this.getProjectDirectoryPath(projectId), PROJECT_CHANNEL_INDEX_FILE);
+  }
+
+  getChannelContextPath(projectId, channelId) {
+    const normalizedChannelId = normalizeString(channelId);
+    if (!normalizedChannelId) {
+      throw new Error('channelId is required');
+    }
+    return path.join(
+      this.getProjectDirectoryPath(projectId),
+      PROJECT_CHANNEL_CHANNELS_DIR,
+      `${safePathPart(normalizedChannelId, 'channel-default')}.json`
+    );
+  }
+
+  async load(projectId, options = {}) {
+    const normalizedProjectId = normalizeString(projectId);
+    if (!normalizedProjectId) {
+      throw new Error('projectId is required');
+    }
+
+    const indexPayload = await this._readProjectIndex(normalizedProjectId);
+    const contextPayload = indexPayload
+      ? await this._readSplitContext(normalizedProjectId, indexPayload)
+      : await this._readLegacyContext(normalizedProjectId);
+
+    return normalizeProjectChannelContext(contextPayload || { projectId: normalizedProjectId }, {
+      projectId: normalizedProjectId,
+      defaultChannelId: options.defaultChannelId,
+      now: options.now,
+      channelDefaults: options.channelDefaults,
+      allowDefaultChannelSynthesis: options.allowDefaultChannelSynthesis
+    });
+  }
+
+  async hasPersistedContext(projectId) {
+    const normalizedProjectId = normalizeString(projectId);
+    if (!normalizedProjectId) {
+      throw new Error('projectId is required');
+    }
+
+    return (await this.detectPersistedContext(normalizedProjectId)).available;
+  }
+
+  async detectPersistedContext(projectId) {
+    const normalizedProjectId = normalizeString(projectId);
+    if (!normalizedProjectId) {
+      throw new Error('projectId is required');
+    }
+
+    if (await this._fileSystem.pathExists(this.getProjectIndexPath(normalizedProjectId))) {
+      return {
+        available: true,
+        storageMode: 'split'
+      };
+    }
+
+    if (await this._fileSystem.pathExists(this.getLegacyContextPath(normalizedProjectId))) {
+      return {
+        available: true,
+        storageMode: 'legacy'
+      };
+    }
+
+    return {
+      available: false,
+      storageMode: 'none'
+    };
+  }
+
+  async listPersistedContexts() {
+    if (!await this._fileSystem.pathExists(this._contextDir)) {
+      return [];
+    }
+
+    let entries = [];
+    try {
+      entries = await this._fileSystem.readdir(this._contextDir);
+    } catch (_error) {
+      return [];
+    }
+
+    const contexts = new Map();
+    for (const entry of entries) {
+      const candidatePath = path.join(this._contextDir, entry);
+      let stats = null;
+      try {
+        stats = await this._fileSystem.stat(candidatePath);
+      } catch (_error) {
+        continue;
+      }
+
+      if (stats.isDirectory()) {
+        const indexPath = path.join(candidatePath, PROJECT_CHANNEL_INDEX_FILE);
+        if (!await this._fileSystem.pathExists(indexPath)) {
+          continue;
+        }
+        try {
+          const payload = await this._fileSystem.readJson(indexPath);
+          const projectId = normalizeString(payload && payload.projectId);
+          if (projectId) {
+            contexts.set(projectId, {
+              projectId,
+              storageMode: 'split'
+            });
+          }
+        } catch (_error) {
+          // Ignore unreadable split contexts and let projection report partial elsewhere.
+        }
+        continue;
+      }
+
+      if (!stats.isFile() || path.extname(entry).toLowerCase() !== '.json') {
+        continue;
+      }
+
+      try {
+        const payload = await this._fileSystem.readJson(candidatePath);
+        const projectId = normalizeString(payload && payload.projectId);
+        if (projectId && !contexts.has(projectId)) {
+          contexts.set(projectId, {
+            projectId,
+            storageMode: 'legacy'
+          });
+        }
+      } catch (_error) {
+        // Ignore unreadable legacy contexts and let projection report partial elsewhere.
+      }
+    }
+
+    return [...contexts.values()].sort((left, right) => left.projectId.localeCompare(right.projectId));
+  }
+
+  async save(context = {}, options = {}) {
+    const normalized = normalizeProjectChannelContext(context, {
+      projectId: options.projectId,
+      defaultChannelId: options.defaultChannelId,
+      now: options.now,
+      channelDefaults: options.channelDefaults
+    });
+
+    await this._writeFullContext(normalized);
+    await this._cleanupLegacyContext(normalized.projectId);
+
+    if (options.syncCurrentContext === true || this._contextSyncManager) {
+      await this.syncCurrentContext(normalized.projectId, {
+        ...options,
+        projectChannelContext: normalized
+      });
+    }
+
+    return normalized;
+  }
+
+  async updateChannel(projectId, channelId, patch = {}, options = {}) {
+    const current = await this.load(projectId, options);
+    const next = updateChannelState(current, channelId, patch, options);
+
+    await this._writeProjectShell(next.projectId, next.focusedChannelId, Object.keys(next.channels));
+    await this._writeChannelState(next.projectId, next.channels[channelId]);
+    await this._cleanupLegacyContext(next.projectId);
+
+    if (options.syncCurrentContext === true || this._contextSyncManager) {
+      await this.syncCurrentContext(next.projectId, {
+        ...options,
+        projectChannelContext: next
+      });
+    }
+
+    return next;
+  }
+
+  async focusChannel(projectId, channelId, options = {}) {
+    const current = await this.load(projectId, options);
+    const next = setFocusedChannel(current, channelId, options);
+
+    await this._writeProjectShell(next.projectId, next.focusedChannelId, Object.keys(next.channels));
+    if (!current.channels[channelId] && next.channels[channelId]) {
+      await this._writeChannelState(next.projectId, next.channels[channelId]);
+    }
+    await this._cleanupLegacyContext(next.projectId);
+
+    if (options.syncCurrentContext === true || this._contextSyncManager) {
+      await this.syncCurrentContext(next.projectId, {
+        ...options,
+        projectChannelContext: next
+      });
+    }
+
+    return next;
+  }
+
+  async syncCurrentContext(projectId, options = {}) {
+    const manager = options.contextSyncManager
+      || this._contextSyncManager
+      || this._createContextSyncManager();
+    const projectChannelContext = options.projectChannelContext || await this.load(projectId, options);
+    await manager.updateProjectChannelSummary(projectId, projectChannelContext);
+    return { success: true };
+  }
+
+  async _readProjectIndex(projectId) {
+    const indexPath = this.getProjectIndexPath(projectId);
+    if (!await this._fileSystem.pathExists(indexPath)) {
+      return null;
+    }
+
+    try {
+      return await this._fileSystem.readJson(indexPath);
+    } catch (_error) {
+      return null;
+    }
+  }
+
+  async _readSplitContext(projectId, indexPayload = {}) {
+    const normalizedProjectId = normalizeString(projectId);
+    const indexChannels = Array.isArray(indexPayload.channelIds)
+      ? indexPayload.channelIds
+      : [];
+    const channels = {};
+
+    for (const channelId of indexChannels) {
+      const normalizedChannelId = normalizeString(channelId);
+      if (!normalizedChannelId) {
+        continue;
+      }
+
+      const channelPath = this.getChannelContextPath(normalizedProjectId, normalizedChannelId);
+      try {
+        const rawChannel = await this._fileSystem.readJson(channelPath);
+        const channelState = normalizeChannelState(normalizedChannelId, rawChannel, {
+          projectId: normalizedProjectId
+        });
+        channels[channelState.channelId] = channelState;
+      } catch (_error) {
+        // ignore unreadable channel file and let normalizeProjectChannelContext repair focus/defaults
+      }
+    }
+
+    return {
+      projectId: normalizedProjectId,
+      focusedChannelId: normalizeString(indexPayload.focusedChannelId),
+      channels
+    };
+  }
+
+  async _readLegacyContext(projectId) {
+    const legacyPath = this.getLegacyContextPath(projectId);
+    if (!await this._fileSystem.pathExists(legacyPath)) {
+      return null;
+    }
+
+    try {
+      return await this._fileSystem.readJson(legacyPath);
+    } catch (_error) {
+      return null;
+    }
+  }
+
+  async _writeFullContext(context) {
+    const channelIds = Object.keys(context.channels);
+    await this._writeProjectShell(context.projectId, context.focusedChannelId, channelIds);
+
+    for (const channelId of channelIds) {
+      await this._writeChannelState(context.projectId, context.channels[channelId]);
+    }
+
+    await this._deleteRemovedChannelFiles(context.projectId, channelIds);
+  }
+
+  async _writeProjectShell(projectId, focusedChannelId, channelIds) {
+    const indexPath = this.getProjectIndexPath(projectId);
+    await this._fileSystem.ensureDir(path.dirname(indexPath));
+    await this._fileSystem.writeJson(indexPath, {
+      projectId,
+      focusedChannelId,
+      channelIds: [...channelIds].sort((left, right) => left.localeCompare(right))
+    }, { spaces: 2 });
+  }
+
+  async _writeChannelState(projectId, channelState) {
+    const normalizedChannelId = normalizeString(channelState && channelState.channelId);
+    if (!normalizedChannelId) {
+      throw new Error('channelState.channelId is required');
+    }
+    const channelPath = this.getChannelContextPath(projectId, normalizedChannelId);
+    await this._fileSystem.ensureDir(path.dirname(channelPath));
+    await this._fileSystem.writeJson(channelPath, channelState, { spaces: 2 });
+  }
+
+  async _deleteRemovedChannelFiles(projectId, retainedChannelIds = []) {
+    const channelsDir = path.join(this.getProjectDirectoryPath(projectId), PROJECT_CHANNEL_CHANNELS_DIR);
+    if (!await this._fileSystem.pathExists(channelsDir)) {
+      return;
+    }
+
+    const retained = new Set(
+      retainedChannelIds.map((channelId) => this.getChannelContextPath(projectId, channelId))
+    );
+    const entries = await this._fileSystem.readdir(channelsDir);
+    for (const entry of entries) {
+      if (!entry.endsWith('.json')) {
+        continue;
+      }
+      const candidatePath = path.join(channelsDir, entry);
+      if (!retained.has(candidatePath)) {
+        await this._fileSystem.remove(candidatePath);
+      }
+    }
+  }
+
+  async _cleanupLegacyContext(projectId) {
+    const legacyPath = this.getLegacyContextPath(projectId);
+    if (await this._fileSystem.pathExists(legacyPath)) {
+      await this._fileSystem.remove(legacyPath);
+    }
+  }
+
+  _createContextSyncManager() {
+    const { ContextSyncManager } = require('../steering/context-sync-manager');
+    return new ContextSyncManager(this._projectPath);
+  }
+}
+
+module.exports = {
+  ProjectChannelContextStore,
+  PROJECT_CHANNEL_CONTEXT_DIR,
+  PROJECT_CHANNEL_INDEX_FILE,
+  PROJECT_CHANNEL_CHANNELS_DIR
+};