scene-capability-engine 3.6.28 → 3.6.32

package/lib/studio/task-envelope.js

@@ -0,0 +1,269 @@
+function buildStudioTaskKey(stageName = '') {
+  const normalizedStage = (typeof stageName === 'string' ? stageName.trim() : '') || 'task';
+  return 'studio:' + normalizedStage;
+}
+
+async function resolveTaskReference(mode, job, options = {}, dependencies = {}) {
+  const normalizeString = dependencies.normalizeString;
+  const resolveTaskStage = dependencies.resolveTaskStage;
+  const TaskRefRegistry = dependencies.TaskRefRegistry;
+  const fileSystem = dependencies.fileSystem;
+  const explicitTaskRef = normalizeString(options.taskRef);
+  if (explicitTaskRef) {
+    return explicitTaskRef;
+  }
+
+  const sceneId = normalizeString(job && job.scene && job.scene.id);
+  const specId = normalizeString(job && job.scene && job.scene.spec_id) || normalizeString(job && job.source && 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 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.job_id) || null
+      }
+    });
+    return taskRef.task_ref;
+  } catch (_error) {
+    return null;
+  }
+}
+
+function collectTaskFileChanges(job = {}, stageName = '', stageMetadata = {}, dependencies = {}) {
+  const normalizeString = dependencies.normalizeString;
+  const normalizeTaskFileChanges = dependencies.normalizeTaskFileChanges;
+  const fileChanges = [];
+  if (Array.isArray(stageMetadata && stageMetadata.file_changes)) {
+    fileChanges.push(...stageMetadata.file_changes);
+  }
+
+  const createdSpec = job && job.source && job.source.intake && job.source.intake.created_spec;
+  const createdSpecId = createdSpec && createdSpec.created
+    ? normalizeString(createdSpec.spec_id)
+    : '';
+  if (stageName === 'plan' && createdSpecId) {
+    fileChanges.push(
+      { path: '.sce/specs/' + createdSpecId + '/requirements.md', line: 1 },
+      { path: '.sce/specs/' + createdSpecId + '/design.md', line: 1 },
+      { path: '.sce/specs/' + createdSpecId + '/tasks.md', line: 1 },
+      { path: '.sce/specs/' + createdSpecId + '/custom/problem-domain-chain.json', line: 1 },
+      { path: '.sce/specs/' + createdSpecId + '/custom/problem-contract.json', line: 1 }
+    );
+  }
+
+  const artifacts = job && job.artifacts ? job.artifacts : {};
+  if (stageName === 'plan') {
+    if (normalizeString(artifacts.spec_portfolio_report)) {
+      fileChanges.push({ path: artifacts.spec_portfolio_report, line: 1 });
+    }
+    if (normalizeString(artifacts.spec_scene_index)) {
+      fileChanges.push({ path: artifacts.spec_scene_index, line: 1 });
+    }
+  }
+  if (stageName === 'generate' && normalizeString(artifacts.generate_report)) {
+    fileChanges.push({ path: artifacts.generate_report, line: 1 });
+  }
+  if (stageName === 'verify' && normalizeString(artifacts.verify_report)) {
+    fileChanges.push({ path: artifacts.verify_report, line: 1 });
+  }
+  if (stageName === 'release' && normalizeString(artifacts.release_report)) {
+    fileChanges.push({ path: artifacts.release_report, line: 1 });
+  }
+  return normalizeTaskFileChanges(fileChanges);
+}
+
+function collectTaskEvidence(job = {}, stageName = '', stageMetadata = {}, dependencies = {}) {
+  const normalizeString = dependencies.normalizeString;
+  const normalizeTaskEvidence = dependencies.normalizeTaskEvidence;
+  const evidence = [];
+  const stageReport = normalizeString(stageMetadata && stageMetadata.report);
+  if (stageReport) {
+    evidence.push({ type: 'stage-report', ref: stageReport, detail: stageName });
+  }
+
+  const artifacts = job && job.artifacts ? job.artifacts : {};
+  if (stageName && artifacts.problem_eval_reports && artifacts.problem_eval_reports[stageName]) {
+    evidence.push({
+      type: 'problem-evaluation-report',
+      ref: artifacts.problem_eval_reports[stageName],
+      detail: stageName
+    });
+  }
+
+  if (normalizeString(job && job.source && job.source.domain_chain && job.source.domain_chain.chain_path)) {
+    evidence.push({
+      type: 'domain-chain',
+      ref: job.source.domain_chain.chain_path,
+      detail: stageName
+    });
+  }
+  if (normalizeString(job && job.source && job.source.problem_contract_path)) {
+    evidence.push({
+      type: 'problem-contract',
+      ref: job.source.problem_contract_path,
+      detail: stageName
+    });
+  }
+  if (Array.isArray(stageMetadata && stageMetadata.auto_errorbook_records)) {
+    for (const item of stageMetadata.auto_errorbook_records) {
+      const entryId = normalizeString(item && item.entry_id);
+      if (!entryId) {
+        continue;
+      }
+      evidence.push({
+        type: 'errorbook-entry',
+        ref: entryId,
+        detail: normalizeString(item && item.step_id) || null
+      });
+    }
+  }
+
+  if (normalizeString(job && job.job_id)) {
+    evidence.push({
+      type: 'event-log',
+      ref: '.sce/state/sce-state.sqlite',
+      detail: 'studio_event_stream:job_id=' + job.job_id
+    });
+  }
+
+  return normalizeTaskEvidence(evidence);
+}
+
+function buildTaskEnvelope(mode, job, options = {}, dependencies = {}) {
+  const resolveTaskStage = dependencies.resolveTaskStage;
+  const resolveNextAction = dependencies.resolveNextAction;
+  const normalizeString = dependencies.normalizeString;
+  const normalizeTaskCommands = dependencies.normalizeTaskCommands;
+  const normalizeTaskErrors = dependencies.normalizeTaskErrors;
+  const extractCommandsFromStageMetadata = dependencies.extractCommandsFromStageMetadata;
+  const extractErrorsFromStageMetadata = dependencies.extractErrorsFromStageMetadata;
+  const deriveTaskIntentShape = dependencies.deriveTaskIntentShape;
+  const buildTaskSummaryLines = dependencies.buildTaskSummaryLines;
+  const buildTaskAcceptanceCriteria = dependencies.buildTaskAcceptanceCriteria;
+
+  const stageName = resolveTaskStage(mode, job, options.stageName);
+  const stageState = stageName && job && job.stages && job.stages[stageName]
+    ? job.stages[stageName]
+    : {};
+  const stageMetadata = stageState && typeof stageState.metadata === 'object' && stageState.metadata
+    ? stageState.metadata
+    : {};
+  const nextAction = resolveNextAction(job);
+
+  const events = Array.isArray(options.events)
+    ? options.events
+    : (options.event ? [options.event] : []);
+  const latestEvent = events.length > 0 ? events[events.length - 1] : null;
+
+  const taskStatus = normalizeString(stageState && stageState.status)
+    || (stageName === 'rollback' && normalizeString(job && job.status) === 'rolled_back'
+      ? 'completed'
+      : normalizeString(job && job.status) || 'unknown');
+  const taskId = normalizeString(options.taskId)
+    || (normalizeString(job && job.job_id)
+      ? job.job_id + ':' + (stageName || 'task')
+      : null);
+  const rawRequest = normalizeString(job && job.source && job.source.goal);
+  const goal = rawRequest || ('Studio ' + (stageName || 'task') + ' execution');
+  const taskIntent = deriveTaskIntentShape(rawRequest, stageName);
+  const sessionId = normalizeString(job && job.session && job.session.scene_session_id) || null;
+  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 commands = normalizeTaskCommands([
+    ...(Array.isArray(stageMetadata.commands) ? stageMetadata.commands : []),
+    ...extractCommandsFromStageMetadata(stageMetadata)
+  ]);
+  const errors = normalizeTaskErrors(
+    extractErrorsFromStageMetadata(stageState, stageMetadata)
+  );
+  const fileChanges = collectTaskFileChanges(job, stageName, stageMetadata, dependencies);
+  const evidence = collectTaskEvidence(job, stageName, stageMetadata, dependencies);
+
+  const handoff = stageMetadata.handoff && typeof stageMetadata.handoff === 'object'
+    ? stageMetadata.handoff
+    : {
+      stage: stageName,
+      status: taskStatus,
+      completed_at: normalizeString(stageState && stageState.completed_at) || null,
+      report: normalizeString(stageMetadata.report) || null,
+      release_ref: normalizeString(stageMetadata.release_ref) || normalizeString(job && job.artifacts && 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, taskRef, dependencies.buildProgress),
+      handoff: normalizedHandoff,
+      next_action: nextAction,
+      file_changes: fileChanges,
+      commands,
+      errors,
+      evidence
+    },
+    event: events
+  };
+}
+
+async function buildCommandPayload(mode, job, options = {}, dependencies = {}) {
+  const taskRef = await resolveTaskReference(mode, job, options, dependencies);
+  const base = {
+    mode,
+    success: true,
+    job_id: job.job_id,
+    status: job.status,
+    progress: dependencies.buildProgress(job),
+    next_action: dependencies.resolveNextAction(job),
+    artifacts: { ...job.artifacts }
+  };
+  return dependencies.attachTaskFeedbackModel({
+    ...base,
+    ...buildTaskEnvelope(mode, job, {
+      ...options,
+      taskRef
+    }, dependencies)
+  });
+}
+
+module.exports = {
+  buildStudioTaskKey,
+  resolveTaskReference,
+  collectTaskFileChanges,
+  collectTaskEvidence,
+  buildTaskEnvelope,
+  buildCommandPayload
+};

package/lib/studio/task-intent.js

@@ -0,0 +1,149 @@
+function normalizeString(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+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 buildTaskSummaryLines(job = {}, stageName = '', taskStatus = '', nextAction = '', taskRef = '', buildProgress) {
+  const sceneId = normalizeString(job && job.scene && job.scene.id) || 'scene.n/a';
+  const specId = normalizeString(job && job.scene && job.scene.spec_id) || normalizeString(job && job.source && job.source.spec_id) || 'spec.n/a';
+  const progress = typeof buildProgress === 'function' ? buildProgress(job) : { completed: 0, total: 0 };
+  return [
+    'Stage: ' + (stageName || 'plan') + ' | Status: ' + (taskStatus || 'unknown') + (taskRef ? (' | Ref: ' + taskRef) : ''),
+    'Scene: ' + sceneId + ' | Spec: ' + specId + ' | Progress: ' + progress.completed + '/' + progress.total,
+    'Next: ' + (nextAction || 'n/a')
+  ];
+}
+
+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') + ').'
+  ];
+}
+
+module.exports = {
+  deriveTaskIntentShape,
+  buildTaskSummaryLines,
+  buildTaskAcceptanceCriteria,
+  truncateTaskText,
+  dedupeTaskList,
+  splitTaskRawRequest
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scene-capability-engine",
-  "version": "3.6.28",
+  "version": "3.6.32",
   "description": "SCE (Scene Capability Engine) - A CLI tool and npm package for spec-driven development with AI coding assistants.",
   "main": "index.js",
   "bin": {