scene-capability-engine 3.6.32 → 3.6.37

package/lib/auto/session-query-service.js

@@ -0,0 +1,249 @@
+async function listCloseLoopSessions(projectPath, options = {}, dependencies = {}) {
+  const {
+    readCloseLoopSessionEntries,
+    normalizeStatusFilter,
+    filterEntriesByStatus,
+    normalizeLimit,
+    presentCloseLoopSessionList,
+    buildStatusCounts,
+    getCloseLoopSessionDir
+  } = dependencies;
+  const sessions = await readCloseLoopSessionEntries(projectPath);
+  const statusFilter = normalizeStatusFilter(options.status);
+  const filteredSessions = filterEntriesByStatus(sessions, statusFilter);
+  const limit = normalizeLimit(options.limit, 20);
+  return presentCloseLoopSessionList(
+    projectPath,
+    filteredSessions,
+    statusFilter,
+    limit,
+    buildStatusCounts,
+    getCloseLoopSessionDir
+  );
+}
+
+async function statsCloseLoopSessions(projectPath, options = {}, dependencies = {}) {
+  const {
+    readCloseLoopSessionEntries,
+    normalizeStatsWindowDays,
+    normalizeStatusFilter,
+    filterEntriesByStatus,
+    presentCloseLoopSessionStats,
+    buildStatusCounts,
+    buildMasterSpecCounts,
+    isFailedStatus,
+    getCloseLoopSessionDir,
+    now = () => Date.now()
+  } = dependencies;
+  const sessions = await readCloseLoopSessionEntries(projectPath);
+  const days = normalizeStatsWindowDays(options.days);
+  const statusFilter = normalizeStatusFilter(options.status);
+  const nowMs = typeof now === 'function' ? Number(now()) : Date.now();
+  const cutoffMs = days === null ? null : nowMs - (days * 24 * 60 * 60 * 1000);
+  const withinWindow = sessions.filter((session) => cutoffMs === null || Number(session && session.mtime_ms) >= cutoffMs);
+  const filteredSessions = filterEntriesByStatus(withinWindow, statusFilter);
+  return presentCloseLoopSessionStats(
+    getCloseLoopSessionDir(projectPath),
+    filteredSessions,
+    statusFilter,
+    days,
+    cutoffMs,
+    buildStatusCounts,
+    buildMasterSpecCounts,
+    isFailedStatus
+  );
+}
+
+async function listGovernanceCloseLoopSessions(projectPath, options = {}, dependencies = {}) {
+  const {
+    readGovernanceCloseLoopSessionEntries,
+    normalizeStatusFilter,
+    filterEntriesByStatus,
+    filterGovernanceEntriesByResumeMode,
+    normalizeLimit,
+    presentGovernanceSessionList,
+    buildStatusCounts,
+    getGovernanceCloseLoopSessionDir
+  } = dependencies;
+  const sessions = await readGovernanceCloseLoopSessionEntries(projectPath);
+  const statusFilter = normalizeStatusFilter(options.status);
+  const resumeOnly = Boolean(options.resumeOnly);
+  const statusFiltered = filterEntriesByStatus(sessions, statusFilter);
+  const filteredSessions = filterGovernanceEntriesByResumeMode(statusFiltered, resumeOnly);
+  const limit = normalizeLimit(options.limit, 20);
+  return presentGovernanceSessionList(
+    projectPath,
+    filteredSessions,
+    statusFilter,
+    resumeOnly,
+    buildStatusCounts,
+    getGovernanceCloseLoopSessionDir,
+    limit
+  );
+}
+
+async function statsGovernanceCloseLoopSessions(projectPath, options = {}, dependencies = {}) {
+  const {
+    readGovernanceCloseLoopSessionEntries,
+    normalizeStatsWindowDays,
+    normalizeStatusFilter,
+    filterEntriesByStatus,
+    filterGovernanceEntriesByResumeMode,
+    presentGovernanceSessionStats,
+    normalizeStatusToken,
+    isCompletedStatus,
+    isFailedStatus,
+    calculatePercent,
+    toGovernanceReleaseGateNumber,
+    getGovernanceCloseLoopSessionDir,
+    buildStatusCounts,
+    parseAutoHandoffGateBoolean,
+    now = () => Date.now()
+  } = dependencies;
+  const sessions = await readGovernanceCloseLoopSessionEntries(projectPath);
+  const days = normalizeStatsWindowDays(options.days);
+  const statusFilter = normalizeStatusFilter(options.status);
+  const resumeOnly = Boolean(options.resumeOnly);
+  const nowMs = typeof now === 'function' ? Number(now()) : Date.now();
+  const cutoffMs = days === null ? null : nowMs - (days * 24 * 60 * 60 * 1000);
+  const withinWindow = sessions.filter((session) => cutoffMs === null || Number(session && session.mtime_ms) >= cutoffMs);
+  const statusFiltered = filterEntriesByStatus(withinWindow, statusFilter);
+  const filteredSessions = filterGovernanceEntriesByResumeMode(statusFiltered, resumeOnly);
+  return presentGovernanceSessionStats(projectPath, filteredSessions, {
+    days,
+    status_filter: statusFilter,
+    resume_only: resumeOnly,
+    cutoff_ms: cutoffMs
+  }, {
+    normalizeStatusToken,
+    isCompletedStatus,
+    isFailedStatus,
+    calculatePercent,
+    toGovernanceReleaseGateNumber,
+    getGovernanceCloseLoopSessionDir,
+    buildStatusCounts,
+    parseAutoHandoffGateBoolean
+  });
+}
+
+async function listCloseLoopControllerSessions(projectPath, options = {}, dependencies = {}) {
+  const {
+    readCloseLoopControllerSessionEntries,
+    normalizeStatusFilter,
+    filterEntriesByStatus,
+    normalizeLimit,
+    presentControllerSessionList,
+    buildStatusCounts,
+    getCloseLoopControllerSessionDir
+  } = dependencies;
+  const sessions = await readCloseLoopControllerSessionEntries(projectPath);
+  const statusFilter = normalizeStatusFilter(options.status);
+  const filteredSessions = filterEntriesByStatus(sessions, statusFilter);
+  const limit = normalizeLimit(options.limit, 20);
+  return presentControllerSessionList(
+    projectPath,
+    filteredSessions,
+    statusFilter,
+    limit,
+    buildStatusCounts,
+    getCloseLoopControllerSessionDir
+  );
+}
+
+async function statsCloseLoopControllerSessions(projectPath, options = {}, dependencies = {}) {
+  const {
+    readCloseLoopControllerSessionEntries,
+    normalizeStatsWindowDays,
+    normalizeStatusFilter,
+    filterEntriesByStatus,
+    normalizeStatusToken,
+    isFailedStatus,
+    buildStatusCounts,
+    buildQueueFormatCounts,
+    getCloseLoopControllerSessionDir,
+    now = () => Date.now()
+  } = dependencies;
+  const sessions = await readCloseLoopControllerSessionEntries(projectPath);
+  const days = normalizeStatsWindowDays(options.days);
+  const statusFilter = normalizeStatusFilter(options.status);
+  const nowMs = typeof now === 'function' ? Number(now()) : Date.now();
+  const cutoffMs = days === null ? null : nowMs - (days * 24 * 60 * 60 * 1000);
+  const withinWindow = sessions.filter((session) => cutoffMs === null || Number(session && session.mtime_ms) >= cutoffMs);
+  const filteredSessions = filterEntriesByStatus(withinWindow, statusFilter);
+
+  let completedSessions = 0;
+  let failedSessions = 0;
+  let processedGoalsSum = 0;
+  let pendingGoalsSum = 0;
+  let sessionsWithProcessed = 0;
+  let sessionsWithPending = 0;
+
+  for (const session of filteredSessions) {
+    const status = normalizeStatusToken(session && session.status) || 'unknown';
+    if (status === 'completed') {
+      completedSessions += 1;
+    }
+    if (isFailedStatus(status)) {
+      failedSessions += 1;
+    }
+    const processedGoals = Number(session && session.processed_goals);
+    if (Number.isFinite(processedGoals)) {
+      processedGoalsSum += processedGoals;
+      sessionsWithProcessed += 1;
+    }
+    const pendingGoals = Number(session && session.pending_goals);
+    if (Number.isFinite(pendingGoals)) {
+      pendingGoalsSum += pendingGoals;
+      sessionsWithPending += 1;
+    }
+  }
+
+  const totalSessions = filteredSessions.length;
+  const completionRate = totalSessions > 0 ? Number(((completedSessions / totalSessions) * 100).toFixed(2)) : 0;
+  const failureRate = totalSessions > 0 ? Number(((failedSessions / totalSessions) * 100).toFixed(2)) : 0;
+  const latestSession = totalSessions > 0 ? filteredSessions[0] : null;
+  const oldestSession = totalSessions > 0 ? filteredSessions[totalSessions - 1] : null;
+
+  return {
+    mode: 'auto-controller-session-stats',
+    session_dir: getCloseLoopControllerSessionDir(projectPath),
+    criteria: {
+      days,
+      status_filter: statusFilter,
+      since: cutoffMs === null ? null : new Date(cutoffMs).toISOString()
+    },
+    total_sessions: totalSessions,
+    completed_sessions: completedSessions,
+    failed_sessions: failedSessions,
+    completion_rate_percent: completionRate,
+    failure_rate_percent: failureRate,
+    processed_goals_sum: processedGoalsSum,
+    pending_goals_sum: pendingGoalsSum,
+    average_processed_goals_per_session: sessionsWithProcessed > 0 ? Number((processedGoalsSum / sessionsWithProcessed).toFixed(2)) : 0,
+    average_pending_goals_per_session: sessionsWithPending > 0 ? Number((pendingGoalsSum / sessionsWithPending).toFixed(2)) : 0,
+    status_counts: buildStatusCounts(filteredSessions),
+    queue_format_counts: buildQueueFormatCounts(filteredSessions),
+    latest_updated_at: latestSession ? latestSession.updated_at : null,
+    oldest_updated_at: oldestSession ? oldestSession.updated_at : null,
+    latest_sessions: filteredSessions.slice(0, 10).map((item) => ({
+      id: item.id,
+      status: item.status,
+      queue_file: item.queue_file,
+      queue_format: item.queue_format,
+      processed_goals: item.processed_goals,
+      pending_goals: item.pending_goals,
+      updated_at: item.updated_at,
+      parse_error: item.parse_error
+    }))
+  };
+}
+
+module.exports = {
+  listCloseLoopSessions,
+  statsCloseLoopSessions,
+  listGovernanceCloseLoopSessions,
+  statsGovernanceCloseLoopSessions,
+  listCloseLoopControllerSessions,
+  statsCloseLoopControllerSessions
+};
+

package/lib/auto/spec-protection.js

@@ -0,0 +1,141 @@
+function normalizeStatusToken(statusCandidate) {
+  return String(statusCandidate || '').trim().toLowerCase();
+}
+
+function collectSpecNamesFromBatchSummary(summary) {
+  const names = new Set();
+  const results = Array.isArray(summary && summary.results) ? summary.results : [];
+  for (const item of results) {
+    const masterSpec = String(item && item.master_spec ? item.master_spec : '').trim();
+    if (masterSpec) {
+      names.add(masterSpec);
+    }
+  }
+  return [...names];
+}
+
+function collectSpecNamesFromCloseLoopSessionPayload(payload) {
+  const names = new Set();
+  const portfolio = payload && payload.portfolio && typeof payload.portfolio === 'object'
+    ? payload.portfolio
+    : {};
+  const masterSpec = String(portfolio.master_spec || '').trim();
+  if (masterSpec) {
+    names.add(masterSpec);
+  }
+  const subSpecs = Array.isArray(portfolio.sub_specs) ? portfolio.sub_specs : [];
+  for (const item of subSpecs) {
+    const specName = String(item || '').trim();
+    if (specName) {
+      names.add(specName);
+    }
+  }
+  return names;
+}
+
+function collectSpecNamesFromBatchSummaryPayload(payload, includeCompleted = false) {
+  const names = new Set();
+  const results = Array.isArray(payload && payload.results) ? payload.results : [];
+  for (const item of results) {
+    const status = normalizeStatusToken(item && item.status);
+    if (!includeCompleted && status === 'completed') {
+      continue;
+    }
+    const masterSpec = String(item && item.master_spec ? item.master_spec : '').trim();
+    if (masterSpec) {
+      names.add(masterSpec);
+    }
+  }
+  return names;
+}
+
+function createProtectionReasonRecord() {
+  return {
+    additional: 0,
+    collaboration_active: 0,
+    close_loop_session_recent_or_incomplete: 0,
+    batch_summary_recent_or_incomplete: 0,
+    controller_session_recent_or_incomplete: 0,
+    total_references: 0
+  };
+}
+
+function ensureProtectionReasonRecord(reasonMap, specName) {
+  const key = String(specName || '').trim();
+  if (!key) {
+    return null;
+  }
+  if (!reasonMap.has(key)) {
+    reasonMap.set(key, createProtectionReasonRecord());
+  }
+  return reasonMap.get(key);
+}
+
+function incrementProtectionReason(reasonMap, specName, reasonKey, delta = 1) {
+  if (!Number.isFinite(delta) || delta <= 0) {
+    return;
+  }
+  const record = ensureProtectionReasonRecord(reasonMap, specName);
+  if (!record) {
+    return;
+  }
+  const normalizedReason = String(reasonKey || '').trim();
+  if (!normalizedReason || !Object.prototype.hasOwnProperty.call(record, normalizedReason)) {
+    return;
+  }
+  record[normalizedReason] += delta;
+  record.total_references += delta;
+}
+
+function buildProtectionRanking(reasonMap) {
+  const entries = [];
+  for (const [spec, reasons] of reasonMap.entries()) {
+    entries.push({
+      spec,
+      total_references: Number(reasons.total_references) || 0,
+      reasons: {
+        additional: Number(reasons.additional) || 0,
+        collaboration_active: Number(reasons.collaboration_active) || 0,
+        close_loop_session_recent_or_incomplete: Number(reasons.close_loop_session_recent_or_incomplete) || 0,
+        batch_summary_recent_or_incomplete: Number(reasons.batch_summary_recent_or_incomplete) || 0,
+        controller_session_recent_or_incomplete: Number(reasons.controller_session_recent_or_incomplete) || 0
+      }
+    });
+  }
+  entries.sort((left, right) => {
+    if (right.total_references !== left.total_references) {
+      return right.total_references - left.total_references;
+    }
+    return left.spec.localeCompare(right.spec);
+  });
+  return entries;
+}
+
+function buildSpecProtectionReasonPayload(specName, reasonMap) {
+  if (!reasonMap || typeof reasonMap.get !== 'function') {
+    return null;
+  }
+  const record = reasonMap.get(specName);
+  if (!record) {
+    return null;
+  }
+  return {
+    total_references: Number(record.total_references) || 0,
+    additional: Number(record.additional) || 0,
+    collaboration_active: Number(record.collaboration_active) || 0,
+    close_loop_session_recent_or_incomplete: Number(record.close_loop_session_recent_or_incomplete) || 0,
+    batch_summary_recent_or_incomplete: Number(record.batch_summary_recent_or_incomplete) || 0,
+    controller_session_recent_or_incomplete: Number(record.controller_session_recent_or_incomplete) || 0
+  };
+}
+
+module.exports = {
+  collectSpecNamesFromBatchSummary,
+  collectSpecNamesFromCloseLoopSessionPayload,
+  collectSpecNamesFromBatchSummaryPayload,
+  createProtectionReasonRecord,
+  ensureProtectionReasonRecord,
+  incrementProtectionReason,
+  buildProtectionRanking,
+  buildSpecProtectionReasonPayload
+};

package/lib/commands/adopt.js

@@ -449,7 +449,7 @@ async function adoptInteractive(projectPath, options) {
       // Prompt for strategy
       steeringStrategy = await steeringManager.promptStrategy(detection.steeringDetection);
       
-      if (steeringStrategy === 'use-kse') {
+      if (steeringStrategy === 'use-sce') {
         // Backup existing steering files
         console.log(chalk.blue('📦 Backing up existing steering files...'));
         const backupResult = await steeringManager.backupSteering(projectPath);
@@ -460,7 +460,7 @@ async function adoptInteractive(projectPath, options) {
           
           // Install sce steering files
           console.log(chalk.blue('📝 Installing sce steering files...'));
-          const installResult = await steeringManager.installKseSteering(projectPath);
+          const installResult = await steeringManager.installSceSteering(projectPath);
           
           if (installResult.success) {
             console.log(chalk.green(`✅ Installed ${installResult.filesInstalled} sce steering file(s)`));
@@ -711,7 +711,7 @@ async function adoptInteractive(projectPath, options) {
  * 
  * @param {string} projectPath - Project root path
  */
-async function setupKiroMcpConfig(projectPath) {
+async function setupSceMcpConfig(projectPath) {
   const mcpConfigPath = path.join(projectPath, '.sce', 'settings', 'mcp.json');
   
   // Don't overwrite existing config
@@ -767,7 +767,7 @@ async function offerAutomationSetup(projectPath) {
     
     // If AI IDE detected, create default MCP settings
     if (toolDetection.primaryTool === 'SCE') {
-      await setupKiroMcpConfig(projectPath);
+      await setupSceMcpConfig(projectPath);
     }
   } catch (toolError) {
     // Tool detection is optional, don't fail adoption if it errors