scene-capability-engine 3.6.10 → 3.6.11

package/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.6.11] - 2026-03-05
+
+### Added
+- Task quality governance commands:
+  - `sce task draft`
+  - `sce task consolidate`
+  - `sce task score`
+  - `sce task promote`
+- Task quality policy support:
+  - `.sce/config/task-quality-policy.json`
+  - policy overrides via `--policy <path>`
+- Task promotion now emits acceptance suggestions when acceptance criteria are missing.
+
 ## [3.6.10] - 2026-03-05
 
 ### Added

package/README.md

@@ -218,5 +218,5 @@ MIT. See [LICENSE](LICENSE).
 
 ---
 
-**Version**: 3.6.10  
+**Version**: 3.6.11  
 **Last Updated**: 2026-03-05

package/README.zh.md

@@ -218,5 +218,5 @@ MIT，见 [LICENSE](LICENSE)。
 
 ---
 
-**版本**：3.6.10  
+**版本**：3.6.11  
 **最后更新**：2026-03-05

package/docs/command-reference.md

@@ -201,6 +201,26 @@ Task references and studio runtime events are persisted in SQLite state store:
 - In-memory fallback is restricted to `NODE_ENV=test` or `SCE_STATE_ALLOW_MEMORY_FALLBACK=1`.
 - If SQLite runtime support is unavailable outside fallback conditions, `task ref/show/rerun` and `studio events` persistence operations fail fast.
 
+#### Task Quality Governance (draft -> score -> promote)
+
+```bash
+# Create draft from dialogue
+sce task draft --scene scene.customer-order --input "Fix checkout timeout and add retry dashboard" --json
+
+# Consolidate drafts for a scene
+sce task consolidate --scene scene.customer-order --json
+
+# Score draft quality
+sce task score --draft <draft-id> --json
+
+# Promote into tasks.md (quality gate enforced unless --force)
+sce task promote --draft <draft-id> --spec 02-00-checkout-optimization --json
+```
+
+Policy file:
+- `.sce/config/task-quality-policy.json`
+- Fields: `min_quality_score`, `require_acceptance_criteria`, `allow_needs_split`, `auto_suggest_acceptance`, `max_sub_goals`
+
 ### Context & Prompts
 
 ```bash

package/lib/commands/task.js

@@ -12,6 +12,16 @@ const TaskClaimer = require('../task/task-claimer');
 const WorkspaceManager = require('../workspace/workspace-manager');
 const { TaskRefRegistry } = require('../task/task-ref-registry');
 const { ensureWriteAuthorization } = require('../security/write-authorization');
+const {
+  buildDraft,
+  scoreDraft,
+  appendDraft,
+  updateDraft,
+  consolidateDrafts,
+  loadDraftStore,
+  promoteDraftToTasks
+} = require('../task/task-quality');
+const { loadTaskQualityPolicy } = require('../task/task-quality-policy');
 
 function normalizeString(value) {
   if (typeof value !== 'string') {
@@ -32,6 +42,195 @@ function resolveStudioStageFromTaskKey(taskKey) {
   return normalizeString(normalized.slice('studio:'.length));
 }
 
+async function runTaskDraftCommand(options = {}) {
+  const projectPath = process.cwd();
+  const sceneId = normalizeString(options.scene);
+  const specId = normalizeString(options.spec);
+  const inputText = normalizeString(options.input);
+  const inputFile = normalizeString(options.inputFile);
+  const policyConfig = await loadTaskQualityPolicy(projectPath, options.policy, fs);
+  const policy = policyConfig.policy;
+
+  if (!sceneId) {
+    throw new Error('scene is required');
+  }
+
+  let rawRequest = inputText;
+  if (!rawRequest && inputFile) {
+    rawRequest = await fs.readFile(inputFile, 'utf8');
+  }
+  if (!rawRequest) {
+    throw new Error('input text is required (use --input or --input-file)');
+  }
+
+  const draft = buildDraft(rawRequest, {
+    scene_id: sceneId,
+    spec_id: specId,
+    acceptance_criteria: options.acceptance ? String(options.acceptance).split('|') : [],
+    confidence: options.confidence,
+    policy
+  });
+  const quality = scoreDraft(draft, policy);
+  draft.quality_score = quality.score;
+  draft.quality_breakdown = quality.breakdown;
+  draft.quality_issues = quality.issues;
+  draft.quality_passed = quality.passed;
+
+  const result = await appendDraft(projectPath, draft, fs);
+  const payload = {
+    mode: 'task-draft',
+    draft: draft,
+    store_path: result.store_path
+  };
+
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return;
+  }
+
+  console.log(chalk.green('✅ Draft created'));
+  console.log(chalk.gray(`  id: ${draft.draft_id}`));
+  console.log(chalk.gray(`  score: ${draft.quality_score}`));
+}
+
+async function runTaskConsolidateCommand(options = {}) {
+  const projectPath = process.cwd();
+  const sceneId = normalizeString(options.scene);
+  const specId = normalizeString(options.spec);
+  if (!sceneId) {
+    throw new Error('scene is required');
+  }
+  const result = await consolidateDrafts(projectPath, {
+    scene_id: sceneId,
+    spec_id: specId
+  }, fs);
+
+  const payload = {
+    mode: 'task-consolidate',
+    scene_id: sceneId,
+    spec_id: specId || null,
+    merged: result.merged,
+    drafts: result.drafts,
+    store_path: result.store_path
+  };
+
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return;
+  }
+
+  console.log(chalk.green('✅ Drafts consolidated'));
+  console.log(chalk.gray(`  merged: ${result.merged.length}`));
+}
+
+async function runTaskScoreCommand(options = {}) {
+  const projectPath = process.cwd();
+  const draftId = normalizeString(options.draft);
+  const all = Boolean(options.all);
+  const policyConfig = await loadTaskQualityPolicy(projectPath, options.policy, fs);
+  const policy = policyConfig.policy;
+  const store = await loadDraftStore(projectPath, fs);
+  const drafts = Array.isArray(store.payload.drafts) ? store.payload.drafts : [];
+
+  const targets = all
+    ? drafts
+    : drafts.filter((draft) => draft.draft_id === draftId);
+
+  if (!all && targets.length === 0) {
+    throw new Error(`draft not found: ${draftId}`);
+  }
+
+  const scored = [];
+  for (const draft of targets) {
+    const quality = scoreDraft(draft, policy);
+    const updated = await updateDraft(projectPath, draft.draft_id, (current) => ({
+      ...current,
+      quality_score: quality.score,
+      quality_breakdown: quality.breakdown,
+      quality_issues: quality.issues,
+      quality_passed: quality.passed
+    }), fs);
+    if (updated) {
+      scored.push(updated);
+    }
+  }
+
+  const payload = {
+    mode: 'task-score',
+    draft_id: draftId || null,
+    total: scored.length,
+    drafts: scored
+  };
+
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return;
+  }
+
+  console.log(chalk.green('✅ Draft scoring complete'));
+  console.log(chalk.gray(`  scored: ${scored.length}`));
+}
+
+async function runTaskPromoteCommand(options = {}) {
+  const projectPath = process.cwd();
+  const draftId = normalizeString(options.draft);
+  const specId = normalizeString(options.spec);
+  const policyConfig = await loadTaskQualityPolicy(projectPath, options.policy, fs);
+  const policy = policyConfig.policy;
+  if (!draftId) {
+    throw new Error('draft id is required');
+  }
+  if (!specId) {
+    throw new Error('spec is required to promote draft');
+  }
+
+  const store = await loadDraftStore(projectPath, fs);
+  const drafts = Array.isArray(store.payload.drafts) ? store.payload.drafts : [];
+  const draft = drafts.find((item) => item.draft_id === draftId);
+  if (!draft) {
+    throw new Error(`draft not found: ${draftId}`);
+  }
+  const quality = scoreDraft(draft, policy);
+  if (!quality.passed && !options.force) {
+    throw new Error('draft quality gate failed; use --force to override');
+  }
+
+  const promoted = await promoteDraftToTasks(projectPath, {
+    ...draft,
+    spec_id: specId
+  }, fs);
+
+  const updated = await updateDraft(projectPath, draftId, (current) => ({
+    ...current,
+    spec_id: specId,
+    status: 'promoted',
+    quality_score: quality.score,
+    quality_breakdown: quality.breakdown,
+    quality_issues: quality.issues,
+    quality_passed: quality.passed,
+    promoted_at: new Date().toISOString(),
+    promoted_task_id: promoted.task_id,
+    promoted_tasks_path: promoted.tasks_path
+  }), fs);
+
+  const payload = {
+    mode: 'task-promote',
+    draft_id: draftId,
+    spec_id: specId,
+    task_id: promoted.task_id,
+    tasks_path: toRelativePosix(projectPath, promoted.tasks_path),
+    draft: updated
+  };
+
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return;
+  }
+
+  console.log(chalk.green('✅ Draft promoted to tasks.md'));
+  console.log(chalk.gray(`  task: ${promoted.task_id}`));
+}
+
 function isStudioTaskRef(lookup = {}) {
   const source = normalizeString(lookup.source);
   if (source === 'studio-stage') {
@@ -771,6 +970,74 @@ function registerTaskCommands(program) {
         process.exitCode = 1;
       }
     });
+
+  task
+    .command('draft')
+    .description('Create a task draft from dialogue input')
+    .requiredOption('--scene <scene-id>', 'Scene identifier')
+    .option('--spec <spec-id>', 'Spec identifier')
+    .option('--input <text>', 'Raw task input text')
+    .option('--input-file <path>', 'File containing raw task input')
+    .option('--acceptance <items>', 'Pipe-delimited acceptance criteria')
+    .option('--confidence <score>', 'Manual confidence (0-1)')
+    .option('--policy <path>', 'Task quality policy path override')
+    .option('--json', 'Print machine-readable JSON output')
+    .action(async (options) => {
+      try {
+        await runTaskDraftCommand(options);
+      } catch (error) {
+        console.error(chalk.red(`Task draft failed: ${error.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  task
+    .command('consolidate')
+    .description('Consolidate task drafts by scene/spec')
+    .requiredOption('--scene <scene-id>', 'Scene identifier')
+    .option('--spec <spec-id>', 'Spec identifier')
+    .option('--json', 'Print machine-readable JSON output')
+    .action(async (options) => {
+      try {
+        await runTaskConsolidateCommand(options);
+      } catch (error) {
+        console.error(chalk.red(`Task consolidate failed: ${error.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  task
+    .command('score')
+    .description('Score task draft quality')
+    .option('--draft <draft-id>', 'Draft identifier')
+    .option('--all', 'Score all drafts')
+    .option('--policy <path>', 'Task quality policy path override')
+    .option('--json', 'Print machine-readable JSON output')
+    .action(async (options) => {
+      try {
+        await runTaskScoreCommand(options);
+      } catch (error) {
+        console.error(chalk.red(`Task score failed: ${error.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  task
+    .command('promote')
+    .description('Promote a task draft into spec tasks.md')
+    .requiredOption('--draft <draft-id>', 'Draft identifier')
+    .requiredOption('--spec <spec-id>', 'Spec identifier')
+    .option('--force', 'Override quality gate')
+    .option('--policy <path>', 'Task quality policy path override')
+    .option('--json', 'Print machine-readable JSON output')
+    .action(async (options) => {
+      try {
+        await runTaskPromoteCommand(options);
+      } catch (error) {
+        console.error(chalk.red(`Task promote failed: ${error.message}`));
+        process.exitCode = 1;
+      }
+    });
 }
 
 module.exports = {
@@ -780,5 +1047,9 @@ module.exports = {
   runTaskRefCommand,
   runTaskShowCommand,
   runTaskRerunCommand,
+  runTaskDraftCommand,
+  runTaskConsolidateCommand,
+  runTaskScoreCommand,
+  runTaskPromoteCommand,
   registerTaskCommands
 };

package/lib/task/task-quality-policy.js

@@ -0,0 +1,109 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+const DEFAULT_POLICY_PATH = path.join('.sce', 'config', 'task-quality-policy.json');
+
+const DEFAULT_TASK_QUALITY_POLICY = Object.freeze({
+  schema_version: '1.0',
+  min_quality_score: 70,
+  require_acceptance_criteria: true,
+  allow_needs_split: false,
+  auto_suggest_acceptance: true,
+  max_sub_goals: 3
+});
+
+function normalizeText(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+function normalizeBoolean(value, fallback) {
+  if (typeof value === 'boolean') {
+    return value;
+  }
+  const normalized = normalizeText(`${value || ''}`).toLowerCase();
+  if (!normalized) {
+    return fallback;
+  }
+  if (['1', 'true', 'yes', 'y', 'on'].includes(normalized)) {
+    return true;
+  }
+  if (['0', 'false', 'no', 'n', 'off'].includes(normalized)) {
+    return false;
+  }
+  return fallback;
+}
+
+function toPositiveInteger(value, fallback) {
+  const parsed = Number.parseInt(`${value}`, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return fallback;
+  }
+  return parsed;
+}
+
+function normalizePolicy(payload = {}) {
+  const policy = payload && typeof payload === 'object' ? payload : {};
+  return {
+    schema_version: normalizeText(policy.schema_version) || DEFAULT_TASK_QUALITY_POLICY.schema_version,
+    min_quality_score: toPositiveInteger(
+      policy.min_quality_score,
+      DEFAULT_TASK_QUALITY_POLICY.min_quality_score
+    ),
+    require_acceptance_criteria: normalizeBoolean(
+      policy.require_acceptance_criteria,
+      DEFAULT_TASK_QUALITY_POLICY.require_acceptance_criteria
+    ),
+    allow_needs_split: normalizeBoolean(
+      policy.allow_needs_split,
+      DEFAULT_TASK_QUALITY_POLICY.allow_needs_split
+    ),
+    auto_suggest_acceptance: normalizeBoolean(
+      policy.auto_suggest_acceptance,
+      DEFAULT_TASK_QUALITY_POLICY.auto_suggest_acceptance
+    ),
+    max_sub_goals: toPositiveInteger(
+      policy.max_sub_goals,
+      DEFAULT_TASK_QUALITY_POLICY.max_sub_goals
+    )
+  };
+}
+
+async function loadTaskQualityPolicy(projectPath, policyPath, fileSystem = fs) {
+  const resolvedPath = normalizeText(policyPath) || DEFAULT_POLICY_PATH;
+  const absolutePath = path.isAbsolute(resolvedPath)
+    ? resolvedPath
+    : path.join(projectPath, resolvedPath);
+
+  if (!await fileSystem.pathExists(absolutePath)) {
+    return {
+      policy: normalizePolicy(DEFAULT_TASK_QUALITY_POLICY),
+      path: resolvedPath,
+      loaded_from: 'default'
+    };
+  }
+
+  try {
+    const payload = await fileSystem.readJson(absolutePath);
+    return {
+      policy: normalizePolicy(payload),
+      path: resolvedPath,
+      loaded_from: 'file'
+    };
+  } catch (_error) {
+    return {
+      policy: normalizePolicy(DEFAULT_TASK_QUALITY_POLICY),
+      path: resolvedPath,
+      loaded_from: 'default'
+    };
+  }
+}
+
+module.exports = {
+  DEFAULT_POLICY_PATH,
+  DEFAULT_TASK_QUALITY_POLICY,
+  normalizePolicy,
+  loadTaskQualityPolicy
+};

package/lib/task/task-quality.js

@@ -0,0 +1,378 @@
+const fs = require('fs-extra');
+const path = require('path');
+const TaskClaimer = require('./task-claimer');
+const { DEFAULT_TASK_QUALITY_POLICY } = require('./task-quality-policy');
+
+const DEFAULT_TASK_GOVERNANCE_DIR = '.sce/task-governance';
+const DEFAULT_DRAFTS_FILE = 'drafts.json';
+const DEFAULT_SCHEMA_VERSION = '1.0';
+
+function normalizeText(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((item) => normalizeText(item)).filter(Boolean);
+}
+
+function toNonNegativeInteger(value, fallback = 0) {
+  const parsed = Number.parseInt(`${value}`, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return fallback;
+  }
+  return parsed;
+}
+
+function toPositiveInteger(value, fallback = 1) {
+  const parsed = Number.parseInt(`${value}`, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return fallback;
+  }
+  return parsed;
+}
+
+function buildDraftId() {
+  const now = Date.now();
+  const random = Math.random().toString(36).slice(2, 8);
+  return `draft-${now}-${random}`;
+}
+
+function splitGoals(text) {
+  const normalized = normalizeText(text);
+  if (!normalized) {
+    return [];
+  }
+  const separators = /[;；\n]|(?:\s+and\s+)|(?:\s+then\s+)|(?:\s+also\s+)|(?:\s+plus\s+)|、|，|,|并且|同时|然后|以及|并/;
+  const parts = normalized.split(separators).map((item) => normalizeText(item)).filter(Boolean);
+  if (parts.length <= 1) {
+    return parts;
+  }
+  const unique = [];
+  for (const part of parts) {
+    if (!unique.some((item) => item === part)) {
+      unique.push(part);
+    }
+  }
+  return unique;
+}
+
+function normalizeTitle(text) {
+  const goals = splitGoals(text);
+  const base = goals.length > 0 ? goals[0] : normalizeText(text);
+  if (!base) {
+    return 'Untitled task';
+  }
+  return base.length > 120 ? `${base.slice(0, 117)}...` : base;
+}
+
+function suggestAcceptanceCriteria(goal) {
+  const normalized = normalizeText(goal);
+  if (!normalized) {
+    return [];
+  }
+  return [
+    `Define completion criteria for: ${normalized}`,
+    'Verify no regressions in related flows',
+    'Add/confirm validation evidence in tasks.md'
+  ];
+}
+
+function buildDraft(rawRequest, options = {}) {
+  const now = new Date().toISOString();
+  const normalizedRaw = normalizeText(rawRequest);
+  const goals = splitGoals(normalizedRaw);
+  const subGoals = goals.length > 1 ? goals.slice(1, 4) : [];
+  const needsSplit = goals.length > 1;
+  const acceptanceCriteria = normalizeStringArray(options.acceptance_criteria);
+  const acceptanceSuggestions = acceptanceCriteria.length === 0
+    ? suggestAcceptanceCriteria(goals.length > 0 ? goals[0] : normalizedRaw)
+    : [];
+  const confidenceBase = options.confidence !== undefined
+    ? Number(options.confidence)
+    : 0.55;
+  const confidence = Math.max(0.1, Math.min(0.95, confidenceBase + (acceptanceCriteria.length > 0 ? 0.1 : -0.05)));
+
+  return {
+    draft_id: buildDraftId(),
+    scene_id: normalizeText(options.scene_id),
+    spec_id: normalizeText(options.spec_id),
+    raw_request: normalizedRaw,
+    title_norm: normalizeTitle(normalizedRaw),
+    goal: goals.length > 0 ? goals[0] : normalizedRaw,
+    sub_goals: subGoals,
+    acceptance_criteria: acceptanceCriteria,
+    acceptance_suggestions: acceptanceSuggestions,
+    needs_split: needsSplit,
+    confidence,
+    status: 'draft',
+    created_at: now,
+    updated_at: now
+  };
+}
+
+function scoreDraft(draft, policy = DEFAULT_TASK_QUALITY_POLICY) {
+  const issues = [];
+  const goal = normalizeText(draft.goal);
+  const title = normalizeText(draft.title_norm);
+  const acceptance = normalizeStringArray(draft.acceptance_criteria);
+  const needsSplit = Boolean(draft.needs_split);
+  const requireAcceptance = policy ? policy.require_acceptance_criteria !== false : true;
+  const allowSplit = policy ? policy.allow_needs_split === true : false;
+
+  let clarity = 100;
+  if (!title || title.length < 4) {
+    clarity -= 30;
+    issues.push('title too short or missing');
+  }
+  if (needsSplit) {
+    clarity -= 25;
+    issues.push('multiple goals detected; split required');
+  }
+
+  let verifiability = 90;
+  if (requireAcceptance && acceptance.length === 0) {
+    verifiability = 45;
+    issues.push('acceptance criteria missing');
+  }
+
+  let executability = goal ? 85 : 40;
+  if (!goal) {
+    issues.push('goal missing');
+  }
+  if (!normalizeText(draft.spec_id)) {
+    executability -= 20;
+    issues.push('spec_id missing');
+  }
+
+  let risk = 40;
+  if (needsSplit) {
+    risk = 65;
+  }
+
+  clarity = Math.max(0, Math.min(100, Math.round(clarity)));
+  verifiability = Math.max(0, Math.min(100, Math.round(verifiability)));
+  executability = Math.max(0, Math.min(100, Math.round(executability)));
+  risk = Math.max(0, Math.min(100, Math.round(risk)));
+
+  const overall = Math.round(
+    (clarity * 0.3)
+    + (verifiability * 0.3)
+    + (executability * 0.3)
+    + ((100 - risk) * 0.1)
+  );
+
+  const minScore = policy && Number.isFinite(policy.min_quality_score)
+    ? Math.max(1, Math.min(100, Math.round(policy.min_quality_score)))
+    : 70;
+  const acceptancePassed = requireAcceptance ? acceptance.length > 0 : true;
+  const splitPassed = allowSplit ? true : !needsSplit;
+  const passed = overall >= minScore && acceptancePassed && splitPassed;
+
+  return {
+    score: overall,
+    passed,
+    breakdown: {
+      clarity,
+      verifiability,
+      executability,
+      risk
+    },
+    issues
+  };
+}
+
+async function loadDraftStore(projectPath, fileSystem = fs) {
+  const storePath = path.join(projectPath, DEFAULT_TASK_GOVERNANCE_DIR, DEFAULT_DRAFTS_FILE);
+  if (!await fileSystem.pathExists(storePath)) {
+    return {
+      path: storePath,
+      payload: {
+        schema_version: DEFAULT_SCHEMA_VERSION,
+        updated_at: new Date().toISOString(),
+        drafts: []
+      }
+    };
+  }
+
+  const payload = await fileSystem.readJson(storePath);
+  return {
+    path: storePath,
+    payload: payload && typeof payload === 'object'
+      ? payload
+      : {
+          schema_version: DEFAULT_SCHEMA_VERSION,
+          updated_at: new Date().toISOString(),
+          drafts: []
+        }
+  };
+}
+
+async function saveDraftStore(store, fileSystem = fs) {
+  const next = {
+    schema_version: store.payload.schema_version || DEFAULT_SCHEMA_VERSION,
+    updated_at: new Date().toISOString(),
+    drafts: Array.isArray(store.payload.drafts) ? store.payload.drafts : []
+  };
+  await fileSystem.ensureDir(path.dirname(store.path));
+  await fileSystem.writeJson(store.path, next, { spaces: 2 });
+  return { path: store.path, payload: next };
+}
+
+async function appendDraft(projectPath, draft, fileSystem = fs) {
+  const store = await loadDraftStore(projectPath, fileSystem);
+  store.payload.drafts = Array.isArray(store.payload.drafts) ? store.payload.drafts : [];
+  store.payload.drafts.push(draft);
+  await saveDraftStore(store, fileSystem);
+  return { draft, store: store.payload, store_path: store.path };
+}
+
+async function updateDraft(projectPath, draftId, updater, fileSystem = fs) {
+  const store = await loadDraftStore(projectPath, fileSystem);
+  const drafts = Array.isArray(store.payload.drafts) ? store.payload.drafts : [];
+  const index = drafts.findIndex((item) => item.draft_id === draftId);
+  if (index < 0) {
+    return null;
+  }
+  const updated = updater({ ...drafts[index] });
+  updated.updated_at = new Date().toISOString();
+  drafts[index] = updated;
+  store.payload.drafts = drafts;
+  await saveDraftStore(store, fileSystem);
+  return updated;
+}
+
+function consolidateDraftGroup(group) {
+  const merged = { ...group[0] };
+  const now = new Date().toISOString();
+  merged.status = 'consolidated';
+  merged.updated_at = now;
+  const rawRequests = group.map((item) => normalizeText(item.raw_request)).filter(Boolean);
+  const subGoals = group.flatMap((item) => normalizeStringArray(item.sub_goals));
+  const acceptance = group.flatMap((item) => normalizeStringArray(item.acceptance_criteria));
+  const suggestions = group.flatMap((item) => normalizeStringArray(item.acceptance_suggestions));
+  merged.raw_request = rawRequests.join(' | ');
+  merged.sub_goals = Array.from(new Set(subGoals));
+  merged.acceptance_criteria = Array.from(new Set(acceptance));
+  merged.acceptance_suggestions = Array.from(new Set(suggestions));
+  merged.needs_split = merged.sub_goals.length > 0;
+  return merged;
+}
+
+async function consolidateDrafts(projectPath, options = {}, fileSystem = fs) {
+  const store = await loadDraftStore(projectPath, fileSystem);
+  const drafts = Array.isArray(store.payload.drafts) ? store.payload.drafts : [];
+  const sceneId = normalizeText(options.scene_id);
+  const specId = normalizeText(options.spec_id);
+
+  const candidates = drafts.filter((draft) => {
+    if (sceneId && normalizeText(draft.scene_id) !== sceneId) {
+      return false;
+    }
+    if (specId && normalizeText(draft.spec_id) !== specId) {
+      return false;
+    }
+    return draft.status === 'draft' || draft.status === 'consolidated';
+  });
+
+  const groups = new Map();
+  candidates.forEach((draft) => {
+    const key = normalizeTitle(draft.raw_request || draft.title_norm);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+    }
+    groups.get(key).push(draft);
+  });
+
+  const mergedDrafts = [];
+  const mergedLog = [];
+  for (const [key, group] of groups.entries()) {
+    if (group.length === 1) {
+      mergedDrafts.push(group[0]);
+      continue;
+    }
+    const merged = consolidateDraftGroup(group);
+    mergedDrafts.push(merged);
+    mergedLog.push({
+      title_norm: key,
+      draft_ids: group.map((item) => item.draft_id),
+      merged_id: merged.draft_id
+    });
+  }
+
+  const untouched = drafts.filter((draft) => {
+    if (sceneId && normalizeText(draft.scene_id) !== sceneId) {
+      return true;
+    }
+    if (specId && normalizeText(draft.spec_id) !== specId) {
+      return true;
+    }
+    return false;
+  });
+
+  store.payload.drafts = [...untouched, ...mergedDrafts];
+  await saveDraftStore(store, fileSystem);
+
+  return {
+    merged: mergedLog,
+    drafts: mergedDrafts,
+    store_path: store.path
+  };
+}
+
+function parseTaskIdValue(taskId) {
+  if (!taskId) {
+    return 0;
+  }
+  const token = `${taskId}`.split('.')[0];
+  return toNonNegativeInteger(token, 0);
+}
+
+async function promoteDraftToTasks(projectPath, draft, fileSystem = fs) {
+  const specId = normalizeText(draft.spec_id);
+  if (!specId) {
+    throw new Error('spec_id is required to promote draft to tasks.md');
+  }
+  const tasksPath = path.join(projectPath, '.sce', 'specs', specId, 'tasks.md');
+  if (!await fileSystem.pathExists(tasksPath)) {
+    throw new Error(`tasks.md not found: ${tasksPath}`);
+  }
+
+  const claimer = new TaskClaimer();
+  const tasks = await claimer.parseTasks(tasksPath);
+  const maxId = tasks.reduce((max, task) => {
+    const value = parseTaskIdValue(task.taskId);
+    return Math.max(max, value);
+  }, 0);
+  const nextId = maxId + 1;
+  const title = normalizeText(draft.title_norm) || normalizeText(draft.goal) || 'New task';
+  const line = `- [ ] ${nextId}. ${title}`;
+
+  const content = await fileSystem.readFile(tasksPath, 'utf8');
+  const nextContent = content.trimEnd() + '\n' + line + '\n';
+  await fileSystem.writeFile(tasksPath, nextContent, 'utf8');
+
+  return {
+    task_id: `${nextId}`,
+    tasks_path: tasksPath
+  };
+}
+
+module.exports = {
+  DEFAULT_TASK_GOVERNANCE_DIR,
+  DEFAULT_DRAFTS_FILE,
+  buildDraft,
+  suggestAcceptanceCriteria,
+  scoreDraft,
+  loadDraftStore,
+  saveDraftStore,
+  appendDraft,
+  updateDraft,
+  consolidateDrafts,
+  promoteDraftToTasks
+};

package/package.json

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

package/template/.sce/config/task-quality-policy.json

@@ -0,0 +1,8 @@
+{
+  "schema_version": "1.0",
+  "min_quality_score": 70,
+  "require_acceptance_criteria": true,
+  "allow_needs_split": false,
+  "auto_suggest_acceptance": true,
+  "max_sub_goals": 3
+}