scene-capability-engine 3.5.2 → 3.6.2

package/lib/commands/studio.js

@@ -11,6 +11,8 @@ const {
 const { findRelatedSpecs } = require('../spec/related-specs');
 const { captureTimelineCheckpoint } = require('../runtime/project-timeline');
 const { runProblemEvaluation } = require('../problem/problem-evaluator');
+const { TaskRefRegistry } = require('../task/task-ref-registry');
+const { getSceStateStore } = require('../state/sce-state-store');
 const {
   loadStudioIntakePolicy,
   runStudioAutoIntake,
@@ -40,8 +42,7 @@ function resolveStudioPaths(projectPath = process.cwd()) {
     projectPath,
     studioDir,
     jobsDir: path.join(studioDir, 'jobs'),
-    latestFile: path.join(studioDir, 'latest-job.json'),
-    eventsDir: path.join(studioDir, 'events')
+    latestFile: path.join(studioDir, 'latest-job.json')
   };
 }
 
@@ -597,7 +598,6 @@ async function writeStudioReport(projectPath, relativePath, payload, fileSystem
 
 async function ensureStudioDirectories(paths, fileSystem = fs) {
   await fileSystem.ensureDir(paths.jobsDir);
-  await fileSystem.ensureDir(paths.eventsDir);
 }
 
 async function writeLatestJob(paths, jobId, fileSystem = fs) {
@@ -622,10 +622,6 @@ function getJobFilePath(paths, jobId) {
   return path.join(paths.jobsDir, `${jobId}.json`);
 }
 
-function getEventLogFilePath(paths, jobId) {
-  return path.join(paths.eventsDir, `${jobId}.jsonl`);
-}
-
 async function saveJob(paths, job, fileSystem = fs) {
   const jobFile = getJobFilePath(paths, job.job_id);
   await fileSystem.writeJson(jobFile, job, { spaces: 2 });
@@ -640,40 +636,28 @@ async function appendStudioEvent(paths, job, eventType, metadata = {}, fileSyste
     timestamp: nowIso(),
     metadata
   };
-  const eventLine = `${JSON.stringify(event)}\n`;
-  const eventFile = getEventLogFilePath(paths, job.job_id);
-  await fileSystem.appendFile(eventFile, eventLine, 'utf8');
+  const sceneId = normalizeString(job?.scene?.id) || null;
+  const specId = normalizeString(job?.scene?.spec_id) || normalizeString(job?.source?.spec_id) || null;
+  const stateStore = getSceStateStore(paths.projectPath, { fileSystem });
+  const persisted = await stateStore.appendStudioEvent({
+    ...event,
+    scene_id: sceneId,
+    spec_id: specId
+  });
+  if (!persisted) {
+    throw new Error('Failed to persist studio event into sqlite state store');
+  }
   return event;
 }
 
 async function readStudioEvents(paths, jobId, options = {}, fileSystem = fs) {
   const { limit = 50 } = options;
-  const eventFile = getEventLogFilePath(paths, jobId);
-  const exists = await fileSystem.pathExists(eventFile);
-  if (!exists) {
-    return [];
+  const stateStore = getSceStateStore(paths.projectPath, { fileSystem });
+  const events = await stateStore.listStudioEvents(jobId, { limit });
+  if (events === null) {
+    throw new Error('SQLite state backend unavailable while reading studio events');
   }
-
-  const content = await fileSystem.readFile(eventFile, 'utf8');
-  const lines = content
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter(Boolean);
-
-  const parsed = [];
-  for (const line of lines) {
-    try {
-      const payload = JSON.parse(line);
-      parsed.push(payload);
-    } catch (_error) {
-      // Ignore malformed lines to keep event stream robust.
-    }
-  }
-
-  if (limit <= 0) {
-    return parsed;
-  }
-  return parsed.slice(-limit);
+  return events;
 }
 
 async function loadJob(paths, jobId, fileSystem = fs) {
@@ -1333,25 +1317,148 @@ function collectTaskEvidence(job = {}, stageName = '', stageMetadata = {}) {
   if (normalizeString(job && job.job_id)) {
     evidence.push({
       type: 'event-log',
-      ref: `.sce/studio/events/${job.job_id}.jsonl`,
-      detail: 'raw-audit-stream'
+      ref: '.sce/state/sce-state.sqlite',
+      detail: `studio_event_stream:job_id=${job.job_id}`
     });
   }
 
   return normalizeTaskEvidence(evidence);
 }
 
-function buildTaskSummaryLines(job = {}, stageName = '', taskStatus = '', nextAction = '') {
+function buildTaskSummaryLines(job = {}, stageName = '', taskStatus = '', nextAction = '', taskRef = '') {
   const sceneId = normalizeString(job?.scene?.id) || 'scene.n/a';
   const specId = normalizeString(job?.scene?.spec_id) || normalizeString(job?.source?.spec_id) || 'spec.n/a';
   const progress = buildProgress(job);
   return [
-    `Stage: ${stageName || 'plan'} | Status: ${taskStatus || 'unknown'}`,
+    `Stage: ${stageName || 'plan'} | Status: ${taskStatus || 'unknown'}${taskRef ? ` | Ref: ${taskRef}` : ''}`,
     `Scene: ${sceneId} | Spec: ${specId} | Progress: ${progress.completed}/${progress.total}`,
     `Next: ${nextAction || 'n/a'}`
   ];
 }
 
+function truncateTaskText(value = '', maxLength = 96) {
+  const normalized = normalizeString(value).replace(/\s+/g, ' ');
+  if (!normalized) {
+    return '';
+  }
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return `${normalized.slice(0, Math.max(0, maxLength - 3)).trim()}...`;
+}
+
+function dedupeTaskList(items = [], limit = 3) {
+  const seen = new Set();
+  const result = [];
+  for (const item of items) {
+    const normalized = truncateTaskText(item, 120);
+    if (!normalized) {
+      continue;
+    }
+    const key = normalized.toLowerCase();
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    result.push(normalized);
+    if (result.length >= limit) {
+      break;
+    }
+  }
+  return result;
+}
+
+function splitTaskRawRequest(rawRequest = '') {
+  const normalized = normalizeString(rawRequest).replace(/\s+/g, ' ');
+  if (!normalized) {
+    return [];
+  }
+  const chunks = normalized
+    .split(/(?:\r?\n|[;；。!?！？]|(?:\s+\band\b\s+)|(?:\s+\bthen\b\s+)|(?:\s+\balso\b\s+)|(?:\s*并且\s*)|(?:\s*同时\s*)|(?:\s*以及\s*)|(?:\s*然后\s*))/gi)
+    .map((item) => normalizeString(item).replace(/^(?:and|then|also)\s+/i, ''))
+    .filter(Boolean);
+  return dedupeTaskList(chunks, 3);
+}
+
+function deriveTaskIntentShape(rawRequest = '', stageName = '') {
+  const normalizedRaw = normalizeString(rawRequest).replace(/\s+/g, ' ');
+  const clauses = splitTaskRawRequest(normalizedRaw);
+  const hasRaw = normalizedRaw.length > 0;
+  const inferredSubGoals = clauses.length > 1 ? clauses.slice(0, 3) : [];
+  const needsSplit = inferredSubGoals.length > 1;
+  const titleSource = clauses.length > 0
+    ? clauses[0]
+    : (hasRaw ? normalizedRaw : `Studio ${stageName || 'task'} execution`);
+
+  let confidence = hasRaw ? 0.9 : 0.6;
+  if (needsSplit) {
+    confidence = 0.72;
+  }
+  if (normalizeString(stageName) && normalizeString(stageName) !== 'plan') {
+    confidence = Math.min(0.95, confidence + 0.03);
+  }
+
+  return {
+    title_norm: truncateTaskText(titleSource, 96) || `Studio ${stageName || 'task'} execution`,
+    raw_request: hasRaw ? normalizedRaw : null,
+    sub_goals: inferredSubGoals,
+    needs_split: needsSplit,
+    confidence: Number(confidence.toFixed(2))
+  };
+}
+
+function buildTaskAcceptanceCriteria(stageName = '', job = {}, nextAction = '') {
+  const normalizedStage = normalizeString(stageName) || 'task';
+  const artifacts = job && job.artifacts ? job.artifacts : {};
+  const criteriaByStage = {
+    plan: [
+      'Scene/spec binding is resolved and persisted in studio job metadata.',
+      'Plan stage problem evaluation passes with no blockers.',
+      `Next action is executable (${nextAction || 'sce studio generate --job <job-id>'}).`
+    ],
+    generate: [
+      'Patch bundle id is produced for downstream apply stage.',
+      'Generate stage report is written to artifacts.',
+      `Next action is executable (${nextAction || 'sce studio apply --patch-bundle <id> --job <job-id>'}).`
+    ],
+    apply: [
+      'Authorization requirements are satisfied for apply stage.',
+      'Apply stage completes without policy blockers.',
+      `Next action is executable (${nextAction || 'sce studio verify --job <job-id>'}).`
+    ],
+    verify: [
+      'Verification gates finish with no required-step failures.',
+      `Verify report is available (${normalizeString(artifacts.verify_report) || 'artifact pending'}).`,
+      `Next action is executable (${nextAction || 'sce studio release --job <job-id>'}).`
+    ],
+    release: [
+      'Release gates pass under configured release profile.',
+      `Release reference is emitted (${normalizeString(artifacts.release_ref) || 'artifact pending'}).`,
+      `Next action is executable (${nextAction || 'complete'}).`
+    ],
+    rollback: [
+      'Rollback stage transitions job status to rolled_back.',
+      'Rollback evidence is appended to studio event stream.',
+      `Recovery next action is executable (${nextAction || 'sce studio plan --scene <scene-id> --from-chat <session>'}).`
+    ],
+    events: [
+      'Events stream payload is available for task-level audit.',
+      'Task envelope preserves normalized IDs and handoff fields.',
+      `Next action is explicit (${nextAction || 'n/a'}).`
+    ],
+    resume: [
+      'Current job status and stage progress are restored deterministically.',
+      'Task envelope remains schema-compatible for downstream UI.',
+      `Next action is explicit (${nextAction || 'n/a'}).`
+    ]
+  };
+  return criteriaByStage[normalizedStage] || [
+    'Task envelope contains normalized identifiers and task contract fields.',
+    'Task output preserves evidence, command logs, and error bundles.',
+    `Next action is explicit (${nextAction || 'n/a'}).`
+  ];
+}
+
 function buildTaskEnvelope(mode, job, options = {}) {
   const stageName = resolveTaskStage(mode, job, options.stageName);
   const stageState = stageName && job && job.stages && job.stages[stageName]
@@ -1375,11 +1482,14 @@ function buildTaskEnvelope(mode, job, options = {}) {
     || (normalizeString(job && job.job_id)
       ? `${job.job_id}:${stageName || 'task'}`
       : null);
-  const goal = normalizeString(job?.source?.goal)
+  const rawRequest = normalizeString(job?.source?.goal);
+  const goal = rawRequest
     || `Studio ${stageName || 'task'} execution`;
+  const taskIntent = deriveTaskIntentShape(rawRequest, stageName);
   const sessionId = normalizeString(job?.session?.scene_session_id) || null;
   const sceneId = normalizeString(job?.scene?.id) || null;
   const specId = normalizeString(job?.scene?.spec_id) || normalizeString(job?.source?.spec_id) || null;
+  const taskRef = normalizeString(options.taskRef) || null;
 
   const commands = normalizeTaskCommands([
     ...(Array.isArray(stageMetadata.commands) ? stageMetadata.commands : []),
@@ -1401,17 +1511,31 @@ function buildTaskEnvelope(mode, job, options = {}) {
       release_ref: normalizeString(stageMetadata.release_ref) || normalizeString(job?.artifacts?.release_ref) || null
     };
 
+  const normalizedHandoff = {
+    ...handoff,
+    task_ref: taskRef
+  };
+
   return {
     sessionId,
     sceneId,
     specId,
     taskId,
+    taskRef,
     eventId: normalizeString(latestEvent && latestEvent.event_id) || null,
     task: {
+      ref: taskRef,
+      task_ref: taskRef,
+      title_norm: taskIntent.title_norm,
+      raw_request: taskIntent.raw_request,
       goal,
+      sub_goals: taskIntent.sub_goals,
+      acceptance_criteria: buildTaskAcceptanceCriteria(stageName, job, nextAction),
+      needs_split: taskIntent.needs_split,
+      confidence: taskIntent.confidence,
       status: taskStatus,
-      summary: buildTaskSummaryLines(job, stageName, taskStatus, nextAction),
-      handoff,
+      summary: buildTaskSummaryLines(job, stageName, taskStatus, nextAction, taskRef),
+      handoff: normalizedHandoff,
       next_action: nextAction,
       file_changes: fileChanges,
       commands,
@@ -1862,7 +1986,49 @@ function ensureNotRolledBack(job, stageName) {
   }
 }
 
-function buildCommandPayload(mode, job, options = {}) {
+function buildStudioTaskKey(stageName = '') {
+  const normalizedStage = normalizeString(stageName) || 'task';
+  return `studio:${normalizedStage}`;
+}
+
+async function resolveTaskReference(mode, job, options = {}) {
+  const explicitTaskRef = normalizeString(options.taskRef);
+  if (explicitTaskRef) {
+    return explicitTaskRef;
+  }
+
+  const sceneId = normalizeString(job?.scene?.id);
+  const specId = normalizeString(job?.scene?.spec_id) || normalizeString(job?.source?.spec_id);
+  if (!sceneId || !specId) {
+    return null;
+  }
+
+  const stageName = resolveTaskStage(mode, job, options.stageName);
+  const taskKey = normalizeString(options.taskKey) || buildStudioTaskKey(stageName);
+  const projectPath = normalizeString(options.projectPath) || process.cwd();
+  const fileSystem = options.fileSystem || fs;
+  const taskRefRegistry = options.taskRefRegistry || new TaskRefRegistry(projectPath, { fileSystem });
+
+  try {
+    const taskRef = await taskRefRegistry.resolveOrCreateRef({
+      sceneId,
+      specId,
+      taskKey,
+      source: 'studio-stage',
+      metadata: {
+        mode: normalizeString(mode) || null,
+        stage: stageName || null,
+        job_id: normalizeString(job?.job_id) || null
+      }
+    });
+    return taskRef.task_ref;
+  } catch (_error) {
+    return null;
+  }
+}
+
+async function buildCommandPayload(mode, job, options = {}) {
+  const taskRef = await resolveTaskReference(mode, job, options);
   const base = {
     mode,
     success: true,
@@ -1874,7 +2040,10 @@ function buildCommandPayload(mode, job, options = {}) {
   };
   return {
     ...base,
-    ...buildTaskEnvelope(mode, job, options)
+    ...buildTaskEnvelope(mode, job, {
+      ...options,
+      taskRef
+    })
   };
 }
 
@@ -2367,9 +2536,11 @@ async function runStudioPlanCommand(options = {}, dependencies = {}) {
   }, fileSystem);
   await writeLatestJob(paths, jobId, fileSystem);
 
-  const payload = buildCommandPayload('studio-plan', job, {
+  const payload = await buildCommandPayload('studio-plan', job, {
     stageName: 'plan',
-    event: planEvent
+    event: planEvent,
+    projectPath,
+    fileSystem
   });
   payload.scene = {
     id: sceneId,
@@ -2465,9 +2636,11 @@ async function runStudioGenerateCommand(options = {}, dependencies = {}) {
   }, fileSystem);
   await writeLatestJob(paths, jobId, fileSystem);
 
-  const payload = buildCommandPayload('studio-generate', job, {
+  const payload = await buildCommandPayload('studio-generate', job, {
     stageName: 'generate',
-    event: generateEvent
+    event: generateEvent,
+    projectPath,
+    fileSystem
   });
   printStudioPayload(payload, options);
   return payload;
@@ -2535,9 +2708,11 @@ async function runStudioApplyCommand(options = {}, dependencies = {}) {
   }, fileSystem);
   await writeLatestJob(paths, jobId, fileSystem);
 
-  const payload = buildCommandPayload('studio-apply', job, {
+  const payload = await buildCommandPayload('studio-apply', job, {
     stageName: 'apply',
-    event: applyEvent
+    event: applyEvent,
+    projectPath,
+    fileSystem
   });
   printStudioPayload(payload, options);
   return payload;
@@ -2685,9 +2860,11 @@ async function runStudioVerifyCommand(options = {}, dependencies = {}) {
   }, fileSystem);
   await writeLatestJob(paths, jobId, fileSystem);
 
-  const payload = buildCommandPayload('studio-verify', job, {
+  const payload = await buildCommandPayload('studio-verify', job, {
     stageName: 'verify',
-    event: verifyEvent
+    event: verifyEvent,
+    projectPath,
+    fileSystem
   });
   printStudioPayload(payload, options);
   return payload;
@@ -2894,9 +3071,11 @@ async function runStudioReleaseCommand(options = {}, dependencies = {}) {
   }, fileSystem);
   await writeLatestJob(paths, jobId, fileSystem);
 
-  const payload = buildCommandPayload('studio-release', job, {
+  const payload = await buildCommandPayload('studio-release', job, {
     stageName: 'release',
-    event: releaseEvent
+    event: releaseEvent,
+    projectPath,
+    fileSystem
   });
   printStudioPayload(payload, options);
   return payload;
@@ -2916,8 +3095,10 @@ async function runStudioResumeCommand(options = {}, dependencies = {}) {
 
   const job = await loadJob(paths, jobId, fileSystem);
   const events = await readStudioEvents(paths, jobId, { limit: 20 }, fileSystem);
-  const payload = buildCommandPayload('studio-resume', job, {
-    events
+  const payload = await buildCommandPayload('studio-resume', job, {
+    events,
+    projectPath,
+    fileSystem
   });
   payload.success = true;
   printStudioPayload(payload, options);
@@ -2975,9 +3156,11 @@ async function runStudioRollbackCommand(options = {}, dependencies = {}) {
   }, fileSystem);
   await writeLatestJob(paths, jobId, fileSystem);
 
-  const payload = buildCommandPayload('studio-rollback', job, {
+  const payload = await buildCommandPayload('studio-rollback', job, {
     stageName: 'rollback',
-    event: rollbackEvent
+    event: rollbackEvent,
+    projectPath,
+    fileSystem
   });
   payload.rollback = { ...job.rollback };
   printStudioPayload(payload, options);
@@ -3035,7 +3218,11 @@ async function runStudioEventsCommand(options = {}, dependencies = {}) {
     sourceStream = 'openhands';
   }
 
-  const payload = buildCommandPayload('studio-events', job, { events });
+  const payload = await buildCommandPayload('studio-events', job, {
+    events,
+    projectPath,
+    fileSystem
+  });
   payload.limit = limit;
   payload.source_stream = sourceStream;
   if (sourceStream === 'openhands') {