scene-capability-engine 3.6.64 → 3.6.67

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

@@ -0,0 +1,406 @@
+const DEFAULT_PROJECT_ID = 'project';
+const DEFAULT_CHANNEL_ID = 'channel-default';
+const DEFAULT_ACTIVE_SCENE = 'scene.default';
+const DEFAULT_ACTIVE_SPEC_ID = 'spec.generic';
+const DEFAULT_ACTIVE_DOC = 'requirements';
+const DEFAULT_RUN_STATE = 'idle';
+const RUN_STATE_VALUES = new Set(['idle', 'running', 'blocked', 'completed', 'failed']);
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function normalizeString(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+function normalizeDraftInput(value) {
+  if (value == null) {
+    return '';
+  }
+  return typeof value === 'string' ? value : `${value}`;
+}
+
+function normalizeStringArray(values) {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+
+  const seen = new Set();
+  const normalized = [];
+  for (const value of values) {
+    const item = normalizeString(value);
+    if (!item || seen.has(item)) {
+      continue;
+    }
+    seen.add(item);
+    normalized.push(item);
+  }
+  return normalized;
+}
+
+function safePathSegment(value, fallback) {
+  const normalized = `${value || ''}`
+    .trim()
+    .replace(/[^a-zA-Z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return normalized || fallback;
+}
+
+function normalizeRunState(value, fallback = DEFAULT_RUN_STATE) {
+  const normalized = normalizeString(value).toLowerCase();
+  if (!RUN_STATE_VALUES.has(normalized)) {
+    return fallback;
+  }
+  return normalized;
+}
+
+function normalizeDateTime(value, fallback = null) {
+  const candidate = normalizeString(value);
+  if (!candidate) {
+    return fallback || nowIso();
+  }
+
+  const parsed = Date.parse(candidate);
+  if (!Number.isFinite(parsed)) {
+    return fallback || nowIso();
+  }
+  return new Date(parsed).toISOString();
+}
+
+function pickFirstString(candidates = [], fallback = '') {
+  for (const candidate of candidates) {
+    const normalized = normalizeString(candidate);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  return fallback;
+}
+
+function normalizeAgentRuntime(agentRuntime) {
+  if (!agentRuntime || typeof agentRuntime !== 'object') {
+    return null;
+  }
+
+  const agentId = normalizeString(agentRuntime.agentId);
+  const backendProfile = normalizeString(agentRuntime.backendProfile);
+  const runtimeSessionId = normalizeString(agentRuntime.runtimeSessionId);
+
+  if (!agentId || !backendProfile || !runtimeSessionId) {
+    return null;
+  }
+
+  return {
+    agentId,
+    backendProfile,
+    runtimeSessionId
+  };
+}
+
+function buildDefaultSessionPath(projectId, channelId) {
+  const safeProjectId = safePathSegment(projectId, DEFAULT_PROJECT_ID);
+  const safeChannelId = safePathSegment(channelId, DEFAULT_CHANNEL_ID);
+  return `.sce/sessions/${safeProjectId}/${safeChannelId}/session.json`;
+}
+
+function createDefaultChannelState(channelId, options = {}) {
+  const defaults = options.defaults && typeof options.defaults === 'object'
+    ? options.defaults
+    : {};
+  const normalizedChannelId = pickFirstString([channelId, defaults.channelId], DEFAULT_CHANNEL_ID);
+  const projectId = pickFirstString([options.projectId, defaults.projectId], DEFAULT_PROJECT_ID);
+  const activeSpecId = pickFirstString(
+    [options.activeSpecId, defaults.activeSpecId],
+    DEFAULT_ACTIVE_SPEC_ID
+  );
+  const activeDoc = pickFirstString(
+    [options.activeDoc, defaults.activeDoc],
+    DEFAULT_ACTIVE_DOC
+  );
+  const updatedAt = normalizeDateTime(
+    options.updatedAt || defaults.updatedAt,
+    normalizeDateTime(options.now)
+  );
+
+  const state = {
+    channelId: normalizedChannelId,
+    activeScene: pickFirstString(
+      [options.activeScene, defaults.activeScene],
+      DEFAULT_ACTIVE_SCENE
+    ),
+    activeSpecId,
+    activeDoc,
+    activeSessionPath: pickFirstString(
+      [options.activeSessionPath, defaults.activeSessionPath],
+      buildDefaultSessionPath(projectId, normalizedChannelId)
+    ),
+    openedTabs: normalizeStringArray(
+      options.openedTabs !== undefined ? options.openedTabs : defaults.openedTabs
+    ),
+    selectedTreeNodeId: pickFirstString(
+      [options.selectedTreeNodeId, defaults.selectedTreeNodeId],
+      `spec:${activeSpecId}`
+    ),
+    draftInput: normalizeDraftInput(
+      options.draftInput !== undefined ? options.draftInput : defaults.draftInput
+    ),
+    runState: normalizeRunState(
+      options.runState !== undefined ? options.runState : defaults.runState,
+      DEFAULT_RUN_STATE
+    ),
+    updatedAt
+  };
+
+  const agentRuntime = normalizeAgentRuntime(
+    options.agentRuntime !== undefined ? options.agentRuntime : defaults.agentRuntime
+  );
+  if (agentRuntime) {
+    state.agentRuntime = agentRuntime;
+  }
+
+  return state;
+}
+
+function normalizeChannelState(channelId, state = {}, options = {}) {
+  const payload = state && typeof state === 'object' ? state : {};
+  const defaults = options.defaults && typeof options.defaults === 'object'
+    ? options.defaults
+    : {};
+  const normalizedChannelId = pickFirstString(
+    [payload.channelId, channelId, defaults.channelId],
+    DEFAULT_CHANNEL_ID
+  );
+
+  const mergedAgentRuntime = payload.agentRuntime && defaults.agentRuntime
+    ? {
+      ...defaults.agentRuntime,
+      ...payload.agentRuntime
+    }
+    : (payload.agentRuntime || defaults.agentRuntime);
+
+  return createDefaultChannelState(normalizedChannelId, {
+    projectId: options.projectId,
+    now: options.now,
+    defaults,
+    activeScene: payload.activeScene,
+    activeSpecId: payload.activeSpecId,
+    activeDoc: payload.activeDoc,
+    activeSessionPath: payload.activeSessionPath,
+    openedTabs: payload.openedTabs,
+    selectedTreeNodeId: payload.selectedTreeNodeId,
+    draftInput: payload.draftInput,
+    runState: payload.runState,
+    updatedAt: payload.updatedAt,
+    agentRuntime: mergedAgentRuntime
+  });
+}
+
+function chooseFocusedChannelId(channels, focusedChannelId, preferredChannelId = '') {
+  if (!channels || typeof channels !== 'object') {
+    return '';
+  }
+
+  const ids = Object.keys(channels).filter(Boolean);
+  if (ids.length === 0) {
+    return '';
+  }
+
+  const normalizedFocused = normalizeString(focusedChannelId);
+  if (normalizedFocused && channels[normalizedFocused]) {
+    return normalizedFocused;
+  }
+
+  const normalizedPreferred = normalizeString(preferredChannelId);
+  if (normalizedPreferred && channels[normalizedPreferred]) {
+    return normalizedPreferred;
+  }
+
+  return [...ids].sort((left, right) => left.localeCompare(right))[0];
+}
+
+function normalizeProjectChannelContext(context = {}, options = {}) {
+  const payload = context && typeof context === 'object' ? context : {};
+  const projectId = pickFirstString(
+    [payload.projectId, options.projectId],
+    DEFAULT_PROJECT_ID
+  );
+  const allowDefaultChannelSynthesis = options.allowDefaultChannelSynthesis !== false;
+  const defaultChannelId = pickFirstString(
+    [options.defaultChannelId, payload.focusedChannelId],
+    DEFAULT_CHANNEL_ID
+  );
+  const channelDefaults = options.channelDefaults && typeof options.channelDefaults === 'object'
+    ? options.channelDefaults
+    : {};
+
+  const nextChannels = {};
+  const sourceChannels = payload.channels && typeof payload.channels === 'object'
+    ? payload.channels
+    : {};
+
+  for (const [channelKey, rawState] of Object.entries(sourceChannels)) {
+    const resolvedDefaults = channelDefaults[channelKey] && typeof channelDefaults[channelKey] === 'object'
+      ? channelDefaults[channelKey]
+      : {};
+    const channelState = normalizeChannelState(channelKey, rawState, {
+      projectId,
+      now: options.now,
+      defaults: resolvedDefaults
+    });
+    nextChannels[channelState.channelId] = channelState;
+  }
+
+  if (Object.keys(nextChannels).length === 0 && allowDefaultChannelSynthesis) {
+    const resolvedDefaults = channelDefaults[defaultChannelId] && typeof channelDefaults[defaultChannelId] === 'object'
+      ? channelDefaults[defaultChannelId]
+      : {};
+    const defaultState = createDefaultChannelState(defaultChannelId, {
+      projectId,
+      now: options.now,
+      defaults: resolvedDefaults
+    });
+    nextChannels[defaultState.channelId] = defaultState;
+  }
+
+  const focusedChannelId = chooseFocusedChannelId(
+    nextChannels,
+    payload.focusedChannelId,
+    defaultChannelId
+  );
+
+  return {
+    projectId,
+    focusedChannelId,
+    channels: nextChannels
+  };
+}
+
+function listChannelIds(context = {}) {
+  const normalized = normalizeProjectChannelContext(context);
+  return Object.keys(normalized.channels).sort((left, right) => left.localeCompare(right));
+}
+
+function getChannelState(context = {}, channelId) {
+  const normalized = normalizeProjectChannelContext(context);
+  const normalizedChannelId = normalizeString(channelId);
+  if (!normalizedChannelId || !normalized.channels[normalizedChannelId]) {
+    return null;
+  }
+  return normalized.channels[normalizedChannelId];
+}
+
+function getFocusedChannelState(context = {}) {
+  const normalized = normalizeProjectChannelContext(context);
+  return normalized.channels[normalized.focusedChannelId] || null;
+}
+
+function setFocusedChannel(context = {}, channelId, options = {}) {
+  const requestedChannelId = normalizeString(channelId);
+  if (!requestedChannelId) {
+    throw new Error('channelId is required');
+  }
+
+  const normalized = normalizeProjectChannelContext(context, {
+    projectId: options.projectId,
+    defaultChannelId: options.defaultChannelId,
+    now: options.now,
+    channelDefaults: options.channelDefaults
+  });
+
+  const nextChannels = { ...normalized.channels };
+  if (!nextChannels[requestedChannelId]) {
+    if (options.createIfMissing !== true) {
+      throw new Error(`Channel not found: ${requestedChannelId}`);
+    }
+
+    const defaults = options.channelDefaults && options.channelDefaults[requestedChannelId]
+      ? options.channelDefaults[requestedChannelId]
+      : (options.channelState || {});
+    nextChannels[requestedChannelId] = normalizeChannelState(requestedChannelId, defaults, {
+      projectId: normalized.projectId,
+      now: options.now,
+      defaults
+    });
+  }
+
+  return {
+    projectId: normalized.projectId,
+    focusedChannelId: requestedChannelId,
+    channels: nextChannels
+  };
+}
+
+function updateChannelState(context = {}, channelId, patch = {}, options = {}) {
+  const requestedChannelId = pickFirstString([channelId, patch && patch.channelId], '');
+  if (!requestedChannelId) {
+    throw new Error('channelId is required');
+  }
+
+  const normalized = normalizeProjectChannelContext(context, {
+    projectId: options.projectId,
+    defaultChannelId: options.defaultChannelId,
+    now: options.now,
+    channelDefaults: options.channelDefaults
+  });
+  const currentState = normalized.channels[requestedChannelId] || null;
+  const rawPatch = patch && typeof patch === 'object' ? patch : {};
+
+  const mergedState = currentState
+    ? {
+      ...currentState,
+      ...rawPatch,
+      channelId: requestedChannelId,
+      updatedAt: rawPatch.updatedAt !== undefined ? rawPatch.updatedAt : (options.now || currentState.updatedAt),
+      agentRuntime: rawPatch.agentRuntime && currentState.agentRuntime
+        ? { ...currentState.agentRuntime, ...rawPatch.agentRuntime }
+        : (rawPatch.agentRuntime !== undefined ? rawPatch.agentRuntime : currentState.agentRuntime)
+    }
+    : {
+      ...rawPatch,
+      channelId: requestedChannelId,
+      updatedAt: rawPatch.updatedAt !== undefined ? rawPatch.updatedAt : options.now
+    };
+
+  const defaults = options.channelDefaults && options.channelDefaults[requestedChannelId]
+    ? options.channelDefaults[requestedChannelId]
+    : {};
+  const nextChannelState = normalizeChannelState(requestedChannelId, mergedState, {
+    projectId: normalized.projectId,
+    now: options.now,
+    defaults
+  });
+
+  return {
+    projectId: normalized.projectId,
+    focusedChannelId: normalized.focusedChannelId,
+    channels: {
+      ...normalized.channels,
+      [requestedChannelId]: nextChannelState
+    }
+  };
+}
+
+module.exports = {
+  DEFAULT_PROJECT_ID,
+  DEFAULT_CHANNEL_ID,
+  DEFAULT_ACTIVE_SCENE,
+  DEFAULT_ACTIVE_SPEC_ID,
+  DEFAULT_ACTIVE_DOC,
+  DEFAULT_RUN_STATE,
+  RUN_STATE_VALUES,
+  buildDefaultSessionPath,
+  chooseFocusedChannelId,
+  createDefaultChannelState,
+  getChannelState,
+  getFocusedChannelState,
+  listChannelIds,
+  normalizeAgentRuntime,
+  normalizeChannelState,
+  normalizeProjectChannelContext,
+  setFocusedChannel,
+  updateChannelState
+};

package/lib/runtime/scene-session-binding.js

@@ -1,6 +1,7 @@
 const path = require('path');
 const fs = require('fs-extra');
 const { SessionStore } = require('./session-store');
+const { buildProjectChannelOutput } = require('../project/project-channel-output');
 
 function normalizeString(value) {
   if (typeof value !== 'string') {
@@ -44,6 +45,8 @@ async function resolveSpecSceneBinding(options = {}, dependencies = {}) {
   const fileSystem = dependencies.fileSystem || fs;
   const sessionStore = dependencies.sessionStore || new SessionStore(projectPath);
   const explicitSceneId = normalizeString(options.sceneId || options.scene);
+  const projectId = normalizeString(options.projectId);
+  const collabChannel = normalizeString(options.collabChannel || options.channelId || options.channel);
   const allowNoScene = options.allowNoScene !== false;
 
   if (explicitSceneId) {
@@ -60,6 +63,49 @@ async function resolveSpecSceneBinding(options = {}, dependencies = {}) {
     };
   }
 
+  if (projectId || collabChannel) {
+    if (!projectId || !collabChannel) {
+      throw new Error('Both projectId and collabChannel are required for project-channel scene binding.');
+    }
+
+    const resolved = await sessionStore.getProjectChannelSession(projectId, collabChannel);
+    if (!resolved.contextAvailable) {
+      throw new Error(`Project channel context unavailable: ${projectId} / ${collabChannel}.`);
+    }
+    if (!resolved.channel) {
+      throw new Error(`Project channel unavailable: ${projectId} / ${collabChannel}.`);
+    }
+
+    const activeScene = normalizeString(resolved.channel.activeScene);
+    if (!activeScene) {
+      throw new Error(`Project channel has no active scene: ${projectId} / ${collabChannel}.`);
+    }
+
+    const active = await sessionStore.getActiveSceneSession(activeScene);
+    if (!active) {
+      throw new Error(`Project channel points to scene "${activeScene}" but no active scene session exists. Run "sce studio plan --project-id ${projectId} --collab-channel ${collabChannel} --from-chat <session>" first.`);
+    }
+
+    return {
+      source: 'project-channel',
+      scene_id: activeScene,
+      scene_cycle: active.scene_cycle,
+      scene_session_id: active.session.session_id,
+      scene_session: active.session,
+      project_channel: buildProjectChannelOutput({
+        projectId,
+        canonicalProjectId: projectId,
+        requestedChannelId: collabChannel,
+        storageMode: resolved.storageMode,
+        contextAvailable: resolved.contextAvailable,
+        context: resolved.context,
+        channel: resolved.channel,
+        session: resolved.session,
+        resolvedChannelId: resolved.resolvedChannelId
+      })
+    };
+  }
+
   const studioJob = await loadLatestStudioJob(projectPath, fileSystem);
   const studioSceneId = normalizeString(studioJob && studioJob.scene && studioJob.scene.id);
   const studioSceneSessionId = normalizeString(studioJob && studioJob.session && studioJob.session.scene_session_id);

package/lib/runtime/session-store.js

@@ -2,6 +2,7 @@ const fs = require('fs-extra');
 const path = require('path');
 const { SteeringContract, normalizeToolName } = require('./steering-contract');
 const { getSceStateStore } = require('../state/sce-state-store');
+const { ProjectChannelContextStore } = require('./project-channel-context-store');
 
 const SESSION_SCHEMA_VERSION = '1.0';
 const SESSION_DIR = path.join('.sce', 'sessions');
@@ -43,6 +44,46 @@ function nextSnapshotId(session) {
   return `snap-${snapshots.length + 1}`;
 }
 
+function normalizeString(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+function mapSessionStatusToChannelRunState(status) {
+  const normalized = normalizeString(status).toLowerCase();
+  if (!normalized) {
+    return 'idle';
+  }
+  if (normalized === 'active' || normalized === 'running') {
+    return 'running';
+  }
+  if (normalized === 'paused' || normalized === 'blocked') {
+    return 'blocked';
+  }
+  if (normalized === 'completed') {
+    return 'completed';
+  }
+  if (normalized === 'failed' || normalized === 'timeout' || normalized === 'rolled_back') {
+    return 'failed';
+  }
+  return 'idle';
+}
+
+function toSessionFileRelativePath(sessionId) {
+  return path.join(SESSION_DIR, `${sessionId}.json`).replace(/\\/g, '/');
+}
+
+function sessionIdFromRelativePath(sessionPath) {
+  const normalized = normalizeString(sessionPath);
+  if (!normalized) {
+    return '';
+  }
+  const parsed = path.posix.parse(normalized.replace(/\\/g, '/'));
+  return parsed.ext === '.json' ? parsed.name : '';
+}
+
 class SessionStore {
   constructor(workspaceRoot, steeringContract = null, options = {}) {
     this._workspaceRoot = workspaceRoot;
@@ -57,6 +98,8 @@ class SessionStore {
       env: this._env,
       sqliteModule: options.sqliteModule
     });
+    this._projectChannelContextStore = options.projectChannelContextStore
+      || new ProjectChannelContextStore(workspaceRoot, this._fileSystem);
     this._preferSqliteSceneReads = options.preferSqliteSceneReads !== undefined
       ? options.preferSqliteSceneReads === true
       : true;
@@ -197,6 +240,149 @@ class SessionStore {
     return records;
   }
 
+  async bindSessionToProjectChannel(sessionRef = 'latest', options = {}) {
+    const projectId = normalizeString(options.projectId);
+    const channelId = normalizeString(options.channelId);
+    if (!projectId) {
+      throw new Error('projectId is required for bindSessionToProjectChannel');
+    }
+    if (!channelId) {
+      throw new Error('channelId is required for bindSessionToProjectChannel');
+    }
+
+    const { session } = await this._resolveSession(sessionRef);
+    const updatedAt = normalizeString(session.updated_at) || nowIso();
+    const patch = {
+      activeSessionPath: toSessionFileRelativePath(session.session_id),
+      activeScene: normalizeString(options.activeScene)
+        || normalizeString(session && session.scene && session.scene.id),
+      activeSpecId: normalizeString(options.activeSpecId)
+        || normalizeString(session && session.scene && session.scene.spec_id),
+      activeDoc: normalizeString(options.activeDoc),
+      selectedTreeNodeId: normalizeString(options.selectedTreeNodeId),
+      draftInput: options.draftInput !== undefined ? options.draftInput : undefined,
+      openedTabs: Array.isArray(options.openedTabs) ? options.openedTabs : undefined,
+      runState: normalizeString(options.runState) || mapSessionStatusToChannelRunState(session.status),
+      updatedAt
+    };
+
+    const sanitizedPatch = {};
+    for (const [key, value] of Object.entries(patch)) {
+      if (value !== undefined && value !== '') {
+        sanitizedPatch[key] = value;
+      }
+    }
+
+    let context = await this._projectChannelContextStore.updateChannel(
+      projectId,
+      channelId,
+      sanitizedPatch,
+      {
+        now: updatedAt,
+        syncCurrentContext: false
+      }
+    );
+
+    const shouldFocus = options.focus !== false;
+    if (shouldFocus) {
+      context = await this._projectChannelContextStore.focusChannel(projectId, channelId, {
+        syncCurrentContext: false
+      });
+    }
+
+    if (options.syncCurrentContext === true) {
+      await this._projectChannelContextStore.syncCurrentContext(projectId, {
+        projectChannelContext: context
+      });
+    }
+
+    return {
+      session,
+      context,
+      channel: context.channels[channelId]
+    };
+  }
+
+  async getProjectChannelSession(projectId, channelId = null, options = {}) {
+    const normalizedProjectId = normalizeString(projectId);
+    const requestedChannelId = normalizeString(channelId) || null;
+    if (!normalizedProjectId) {
+      throw new Error('projectId is required for getProjectChannelSession');
+    }
+
+    const detection = await this._projectChannelContextStore.detectPersistedContext(normalizedProjectId);
+    if (!detection.available) {
+      return {
+        projectId: normalizedProjectId,
+        requestedChannelId,
+        resolvedChannelId: null,
+        contextAvailable: false,
+        storageMode: detection.storageMode,
+        context: null,
+        channel: null,
+        session: null
+      };
+    }
+
+    const context = await this._projectChannelContextStore.load(normalizedProjectId, {
+      ...options,
+      allowDefaultChannelSynthesis: false
+    });
+    const resolvedChannelId = requestedChannelId || normalizeString(context.focusedChannelId);
+    if (!resolvedChannelId || !context.channels[resolvedChannelId]) {
+      return {
+        projectId: normalizedProjectId,
+        requestedChannelId,
+        resolvedChannelId: null,
+        contextAvailable: true,
+        storageMode: detection.storageMode,
+        context,
+        channel: null,
+        session: null
+      };
+    }
+
+    const channel = context.channels[resolvedChannelId];
+    const sessionId = sessionIdFromRelativePath(channel.activeSessionPath);
+    if (!sessionId) {
+      return {
+        projectId: normalizedProjectId,
+        requestedChannelId,
+        resolvedChannelId,
+        contextAvailable: true,
+        storageMode: detection.storageMode,
+        context,
+        channel,
+        session: null
+      };
+    }
+
+    try {
+      const session = await this.getSession(sessionId);
+      return {
+        projectId: normalizedProjectId,
+        requestedChannelId,
+        resolvedChannelId,
+        contextAvailable: true,
+        storageMode: detection.storageMode,
+        context,
+        channel,
+        session
+      };
+    } catch (_error) {
+      return {
+        projectId: normalizedProjectId,
+        requestedChannelId,
+        resolvedChannelId,
+        contextAvailable: true,
+        storageMode: detection.storageMode,
+        context,
+        channel,
+        session: null
+      };
+    }
+  }
+
   async beginSceneSession(options = {}) {
     const sceneId = `${options.sceneId || ''}`.trim();
     if (!sceneId) {

package/lib/runtime/steering-contract.js

@@ -24,6 +24,7 @@ const DEFAULT_MANIFEST = Object.freeze({
     codex: '>=0.0.0',
     claude: '>=0.0.0',
     cursor: '>=0.0.0',
+    'sce-native': '*',
     generic: '*',
   },
   session: {
@@ -58,6 +59,11 @@ const TOOL_RUNTIME_PROFILES = Object.freeze({
     default_permission_args: [],
     notes: 'Provide runtime permission args in the target agent adapter.',
   },
+  'sce-native': {
+    recommended_command: 'sce native start',
+    default_permission_args: [],
+    notes: 'Native SCE semantic runtime with no embedded host dependency.',
+  },
 });
 
 function normalizeToolName(value) {
@@ -68,7 +74,7 @@ function normalizeToolName(value) {
   if (raw === 'claude-code') {
     return 'claude';
   }
-  if (raw === 'codex' || raw === 'claude' || raw === 'cursor') {
+  if (raw === 'codex' || raw === 'claude' || raw === 'cursor' || raw === 'sce-native') {
     return raw;
   }
   return 'generic';