claude-code-workflow 7.2.11 → 7.2.12

package/.claude/skills/workflow-tune/phases/04-synthesize.md

@@ -1,257 +0,0 @@
-# Phase 4: Synthesize
-
-> **COMPACT SENTINEL [Phase 4: Synthesize]**
-> This phase contains 4 execution steps (Step 4.1 -- 4.4).
-> If you can read this sentinel but cannot find the full Step protocol below, context has been compressed.
-> Recovery: `Read("phases/04-synthesize.md")`
-
-Synthesize all step analyses into cross-step insights. Evaluates the workflow as a whole: step ordering, handoff quality, redundancy, bottlenecks, and overall coherence.
-
-## Objective
-
-- Read complete process-log.md and all step analyses
-- Build synthesis prompt with full workflow context
-- Execute via ccw cli Gemini with resume chain
-- Generate cross-step optimization insights
-- Write synthesis.md
-
-## Execution
-
-### Step 4.1: Gather All Analyses
-
-```javascript
-// Read process log
-const processLog = Read(`${state.work_dir}/process-log.md`);
-
-// Read all step analysis files
-const stepAnalyses = state.steps.map((step, i) => {
-  const analysisFile = `${state.work_dir}/steps/step-${i + 1}/step-${i + 1}-analysis.md`;
-  try {
-    return { step: step.name, index: i, content: Read(analysisFile) };
-  } catch {
-    return { step: step.name, index: i, content: '[Analysis not available]' };
-  }
-});
-
-// Build score summary
-const scoreSummary = state.steps.map((s, i) =>
-  `Step ${i + 1} (${s.name}): ${s.analysis?.quality_score || '-'}/100 | Issues: ${s.analysis?.issue_count || 0} (${s.analysis?.high_issues || 0} high)`
-).join('\n');
-
-// Compute aggregate stats
-const scores = state.steps.map(s => s.analysis?.quality_score).filter(Boolean);
-const avgScore = scores.length > 0 ? Math.round(scores.reduce((a, b) => a + b, 0) / scores.length) : 0;
-const minScore = scores.length > 0 ? Math.min(...scores) : 0;
-const totalIssues = state.steps.reduce((sum, s) => sum + (s.analysis?.issue_count || 0), 0);
-const totalHighIssues = state.steps.reduce((sum, s) => sum + (s.analysis?.high_issues || 0), 0);
-```
-
-### Step 4.2: Construct Synthesis Prompt
-
-```javascript
-// Ref: templates/synthesis-prompt.md
-
-const synthesisPrompt = `PURPOSE: Synthesize all step analyses into a holistic workflow optimization assessment. Evaluate cross-step concerns: ordering, handoff quality, redundancy, bottlenecks, and overall workflow coherence.
-
-WORKFLOW OVERVIEW:
-Name: ${state.workflow_name}
-Goal: ${state.workflow_context}
-Steps: ${state.steps.length}
-Average Quality: ${avgScore}/100
-Weakest Step: ${minScore}/100
-Total Issues: ${totalIssues} (${totalHighIssues} high severity)
-
-SCORE SUMMARY:
-${scoreSummary}
-
-COMPLETE PROCESS LOG:
-${processLog}
-
-DETAILED STEP ANALYSES:
-${stepAnalyses.map(a => `### ${a.step} (Step ${a.index + 1})\n${a.content}`).join('\n\n---\n\n')}
-
-TASK:
-1. **Workflow Coherence**: Do steps form a logical sequence? Any missing steps?
-2. **Handoff Quality**: Are step outputs well-consumed by subsequent steps? Data format mismatches?
-3. **Redundancy Detection**: Do any steps duplicate work? Overlapping concerns?
-4. **Bottleneck Identification**: Which steps are bottlenecks (lowest quality, longest duration)?
-5. **Step Ordering**: Would reordering steps improve outcomes?
-6. **Missing Steps**: Are there gaps in the pipeline that need additional steps?
-7. **Per-Step Optimization**: Top 3 improvements per underperforming step
-8. **Workflow-Level Optimization**: Structural changes to the overall pipeline
-
-EXPECTED OUTPUT (strict JSON, no markdown):
-{
-  "workflow_score": <0-100>,
-  "coherence": {
-    "score": <0-100>,
-    "assessment": "<logical flow evaluation>",
-    "gaps": ["<missing step or transition>"]
-  },
-  "handoff_quality": {
-    "score": <0-100>,
-    "issues": [
-      { "from_step": "<step name>", "to_step": "<step name>", "issue": "<description>", "fix": "<suggestion>" }
-    ]
-  },
-  "redundancy": {
-    "found": <true|false>,
-    "items": [
-      { "steps": ["<step1>", "<step2>"], "description": "<what overlaps>", "recommendation": "<merge or remove>" }
-    ]
-  },
-  "bottlenecks": [
-    { "step": "<step name>", "reason": "<why it's a bottleneck>", "impact": "high|medium|low", "fix": "<suggestion>" }
-  ],
-  "ordering_suggestions": [
-    { "current": "<current order description>", "proposed": "<new order>", "rationale": "<why>" }
-  ],
-  "per_step_improvements": [
-    { "step": "<step name>", "improvements": [
-      { "priority": "high|medium|low", "description": "<what to change>", "rationale": "<why>" }
-    ]}
-  ],
-  "workflow_improvements": [
-    { "priority": "high|medium|low", "category": "structure|handoff|performance|quality", "description": "<change>", "rationale": "<why>", "affected_steps": ["<step names>"] }
-  ],
-  "summary": "<2-3 sentence executive summary of workflow health and top recommendations>"
-}
-
-CONSTRAINTS: Be specific, reference step names and artifact details, output ONLY JSON`;
-```
-
-### Step 4.3: Execute via ccw cli Gemini with Resume
-
-```javascript
-function escapeForShell(str) {
-  return str.replace(/"/g, '\\"').replace(/\$/g, '\\$').replace(/`/g, '\\`');
-}
-
-let cliCommand = `ccw cli -p "${escapeForShell(synthesisPrompt)}" --tool gemini --mode analysis`;
-
-// Resume from the last step's analysis session
-if (state.analysis_session_id) {
-  cliCommand += ` --resume ${state.analysis_session_id}`;
-}
-
-Bash({
-  command: cliCommand,
-  run_in_background: true,
-  timeout: 300000
-});
-
-// STOP — wait for hook callback
-```
-
-### Step 4.4: Parse Results and Write Synthesis
-
-After CLI completes:
-
-```javascript
-const rawOutput = /* CLI output from callback */;
-const jsonMatch = rawOutput.match(/\{[\s\S]*\}/);
-let synthesis;
-
-if (jsonMatch) {
-  try {
-    synthesis = JSON.parse(jsonMatch[0]);
-  } catch {
-    synthesis = {
-      workflow_score: avgScore,
-      summary: 'Synthesis parsing failed — individual step analyses available',
-      workflow_improvements: [],
-      per_step_improvements: [],
-      bottlenecks: [],
-      handoff_quality: { score: 0, issues: [] },
-      coherence: { score: 0, assessment: 'Parse error' },
-      redundancy: { found: false, items: [] },
-      ordering_suggestions: []
-    };
-  }
-} else {
-  synthesis = {
-    workflow_score: avgScore,
-    summary: 'No synthesis output received',
-    workflow_improvements: [],
-    per_step_improvements: []
-  };
-}
-
-// Write synthesis report
-const synthesisReport = `# Workflow Synthesis
-
-**Workflow Score**: ${synthesis.workflow_score}/100
-**Date**: ${new Date().toISOString()}
-
-## Executive Summary
-${synthesis.summary}
-
-## Coherence (${synthesis.coherence?.score || '-'}/100)
-${synthesis.coherence?.assessment || 'N/A'}
-${(synthesis.coherence?.gaps || []).length > 0 ? '\n### Gaps\n' + synthesis.coherence.gaps.map(g => `- ${g}`).join('\n') : ''}
-
-## Handoff Quality (${synthesis.handoff_quality?.score || '-'}/100)
-${(synthesis.handoff_quality?.issues || []).map(i =>
-  `- **${i.from_step} → ${i.to_step}**: ${i.issue}\n  Fix: ${i.fix}`
-).join('\n') || 'No handoff issues'}
-
-## Redundancy
-${synthesis.redundancy?.found ? (synthesis.redundancy.items || []).map(r =>
-  `- Steps ${r.steps.join(', ')}: ${r.description} → ${r.recommendation}`
-).join('\n') : 'No redundancy detected'}
-
-## Bottlenecks
-${(synthesis.bottlenecks || []).map(b =>
-  `- **${b.step}** [${b.impact}]: ${b.reason}\n  Fix: ${b.fix}`
-).join('\n') || 'No bottlenecks'}
-
-## Ordering Suggestions
-${(synthesis.ordering_suggestions || []).map(o =>
-  `- Current: ${o.current}\n  Proposed: ${o.proposed}\n  Rationale: ${o.rationale}`
-).join('\n') || 'Current ordering is optimal'}
-
-## Per-Step Improvements
-${(synthesis.per_step_improvements || []).map(s =>
-  `### ${s.step}\n` + (s.improvements || []).map(i =>
-    `- [${i.priority}] ${i.description} — ${i.rationale}`
-  ).join('\n')
-).join('\n\n') || 'No per-step improvements'}
-
-## Workflow-Level Improvements
-${(synthesis.workflow_improvements || []).map((w, i) =>
-  `### ${i + 1}. [${w.priority}] ${w.description}\n- Category: ${w.category}\n- Rationale: ${w.rationale}\n- Affected: ${(w.affected_steps || []).join(', ')}`
-).join('\n\n') || 'No workflow-level improvements'}
-`;
-
-Write(`${state.work_dir}/synthesis.md`, synthesisReport);
-
-// Update state
-state.synthesis = {
-  workflow_score: synthesis.workflow_score,
-  summary: synthesis.summary,
-  improvement_count: (synthesis.workflow_improvements || []).length +
-    (synthesis.per_step_improvements || []).reduce((sum, s) => sum + (s.improvements || []).length, 0),
-  high_priority_count: (synthesis.workflow_improvements || []).filter(w => w.priority === 'high').length,
-  bottleneck_count: (synthesis.bottlenecks || []).length,
-  handoff_issue_count: (synthesis.handoff_quality?.issues || []).length,
-  synthesis_file: `${state.work_dir}/synthesis.md`,
-  raw_data: synthesis
-};
-
-state.updated_at = new Date().toISOString();
-Write(`${state.work_dir}/workflow-state.json`, JSON.stringify(state, null, 2));
-```
-
-## Error Handling
-
-| Error | Recovery |
-|-------|----------|
-| CLI timeout | Generate synthesis from individual step analyses only (no cross-step) |
-| Resume fails | Start fresh analysis session |
-| JSON parse fails | Use step-level data to construct minimal synthesis |
-
-## Output
-
-- **Files**: `synthesis.md`
-- **State**: `state.synthesis` updated
-- **Next**: Phase 5 (Optimization Report)

package/.claude/skills/workflow-tune/phases/05-optimize-report.md

@@ -1,246 +0,0 @@
-# Phase 5: Optimization Report
-
-> **COMPACT SENTINEL [Phase 5: Report]**
-> This phase contains 4 execution steps (Step 5.1 -- 5.4).
-> If you can read this sentinel but cannot find the full Step protocol below, context has been compressed.
-> Recovery: `Read("phases/05-optimize-report.md")`
-
-Generate the final optimization report and optionally apply high-priority fixes.
-
-## Objective
-
-- Read complete state, process log, synthesis
-- Generate structured final report
-- Optionally apply auto-fix (if enabled)
-- Write final-report.md
-- Display summary to user
-
-## Execution
-
-### Step 5.1: Read Complete State
-
-```javascript
-const state = JSON.parse(Read(`${state.work_dir}/workflow-state.json`));
-const processLog = Read(`${state.work_dir}/process-log.md`);
-const synthesis = state.synthesis;
-state.status = 'completed';
-state.updated_at = new Date().toISOString();
-```
-
-### Step 5.2: Generate Report
-
-```javascript
-// Compute stats
-const scores = state.steps.map(s => s.analysis?.quality_score).filter(Boolean);
-const avgScore = scores.length > 0 ? Math.round(scores.reduce((a, b) => a + b, 0) / scores.length) : 0;
-const minStep = state.steps.reduce((min, s) =>
-  (s.analysis?.quality_score || 100) < (min.analysis?.quality_score || 100) ? s : min
-, state.steps[0]);
-
-const totalIssues = state.steps.reduce((sum, s) => sum + (s.analysis?.issue_count || 0), 0);
-const totalHighIssues = state.steps.reduce((sum, s) => sum + (s.analysis?.high_issues || 0), 0);
-
-// Step quality table (with requirement match)
-const stepTable = state.steps.map((s, i) => {
-  const reqPass = s.analysis?.requirement_pass;
-  const reqStr = reqPass === true ? 'PASS' : reqPass === false ? 'FAIL' : '-';
-  return `| ${i + 1} | ${s.name} | ${s.type} | ${s.execution?.success ? 'OK' : 'FAIL'} | ${reqStr} | ${s.analysis?.quality_score || '-'} | ${s.analysis?.issue_count || 0} | ${s.analysis?.high_issues || 0} |`;
-}).join('\n');
-
-// Collect all improvements (workflow-level + per-step)
-const allImprovements = [];
-if (synthesis?.raw_data?.workflow_improvements) {
-  synthesis.raw_data.workflow_improvements.forEach(w => {
-    allImprovements.push({
-      scope: 'workflow',
-      priority: w.priority,
-      description: w.description,
-      rationale: w.rationale,
-      category: w.category,
-      affected: w.affected_steps || []
-    });
-  });
-}
-if (synthesis?.raw_data?.per_step_improvements) {
-  synthesis.raw_data.per_step_improvements.forEach(s => {
-    (s.improvements || []).forEach(imp => {
-      allImprovements.push({
-        scope: s.step,
-        priority: imp.priority,
-        description: imp.description,
-        rationale: imp.rationale,
-        category: 'step',
-        affected: [s.step]
-      });
-    });
-  });
-}
-
-// Sort by priority
-const priorityOrder = { high: 0, medium: 1, low: 2 };
-allImprovements.sort((a, b) => (priorityOrder[a.priority] || 2) - (priorityOrder[b.priority] || 2));
-
-const report = `# Workflow Tune — Final Report
-
-## Summary
-
-| Field | Value |
-|-------|-------|
-| **Workflow** | ${state.workflow_name} |
-| **Goal** | ${state.workflow_context} |
-| **Steps** | ${state.steps.length} |
-| **Workflow Score** | ${synthesis?.workflow_score || avgScore}/100 |
-| **Average Step Quality** | ${avgScore}/100 |
-| **Weakest Step** | ${minStep.name} (${minStep.analysis?.quality_score || '-'}/100) |
-| **Total Issues** | ${totalIssues} (${totalHighIssues} high severity) |
-| **Analysis Depth** | ${state.analysis_depth} |
-| **Started** | ${state.started_at} |
-| **Completed** | ${state.updated_at} |
-
-## Step Quality Matrix
-
-| # | Step | Type | Exec | Req Match | Quality | Issues | High |
-|---|------|------|------|-----------|---------|--------|------|
-${stepTable}
-
-## Workflow Flow Assessment
-
-### Coherence: ${synthesis?.raw_data?.coherence?.score || '-'}/100
-${synthesis?.raw_data?.coherence?.assessment || 'Not evaluated'}
-
-### Handoff Quality: ${synthesis?.raw_data?.handoff_quality?.score || '-'}/100
-${(synthesis?.raw_data?.handoff_quality?.issues || []).map(i =>
-  `- **${i.from_step} → ${i.to_step}**: ${i.issue}`
-).join('\n') || 'No handoff issues'}
-
-### Bottlenecks
-${(synthesis?.raw_data?.bottlenecks || []).map(b =>
-  `- **${b.step}** [${b.impact}]: ${b.reason}`
-).join('\n') || 'No bottlenecks identified'}
-
-## Optimization Recommendations
-
-### Priority: HIGH
-${allImprovements.filter(i => i.priority === 'high').map((i, idx) =>
-  `${idx + 1}. **[${i.scope}]** ${i.description}\n   - Rationale: ${i.rationale}\n   - Affected: ${i.affected.join(', ')}`
-).join('\n') || 'None'}
-
-### Priority: MEDIUM
-${allImprovements.filter(i => i.priority === 'medium').map((i, idx) =>
-  `${idx + 1}. **[${i.scope}]** ${i.description}\n   - Rationale: ${i.rationale}`
-).join('\n') || 'None'}
-
-### Priority: LOW
-${allImprovements.filter(i => i.priority === 'low').map((i, idx) =>
-  `${idx + 1}. **[${i.scope}]** ${i.description}`
-).join('\n') || 'None'}
-
-## Process Documentation
-
-Full process log: \`${state.work_dir}/process-log.md\`
-Synthesis: \`${state.work_dir}/synthesis.md\`
-
-### Per-Step Analysis Files
-
-| Step | Analysis File |
-|------|---------------|
-${state.steps.map((s, i) =>
-  `| ${s.name} | \`${state.work_dir}/steps/step-${i + 1}/step-${i + 1}-analysis.md\` |`
-).join('\n')}
-
-## Artifact Locations
-
-| Path | Description |
-|------|-------------|
-| \`${state.work_dir}/workflow-state.json\` | Complete state |
-| \`${state.work_dir}/process-log.md\` | Accumulated process log |
-| \`${state.work_dir}/synthesis.md\` | Cross-step synthesis |
-| \`${state.work_dir}/final-report.md\` | This report |
-`;
-
-Write(`${state.work_dir}/final-report.md`, report);
-```
-
-### Step 5.3: Optional Auto-Fix
-
-```javascript
-if (state.auto_fix && allImprovements.filter(i => i.priority === 'high').length > 0) {
-  const highPriorityFixes = allImprovements.filter(i => i.priority === 'high');
-
-  // ★ Safety: confirm with user before applying auto-fixes
-  const fixList = highPriorityFixes.map((f, i) =>
-    `${i + 1}. [${f.scope}] ${f.description}\n   Affected: ${f.affected.join(', ')}`
-  ).join('\n');
-
-  const autoFixConfirm = AskUserQuestion({
-    questions: [{
-      question: `以下 ${highPriorityFixes.length} 项高优先级优化将被自动应用：\n\n${fixList}\n\n确认应用？`,
-      header: "Auto-Fix Confirmation",
-      multiSelect: false,
-      options: [
-        { label: "Apply (应用)", description: "自动应用以上高优先级修复" },
-        { label: "Skip (跳过)", description: "跳过自动修复，仅保留报告" }
-      ]
-    }]
-  });
-
-  if (autoFixConfirm["Auto-Fix Confirmation"].startsWith("Skip")) {
-    // Skip auto-fix, just log it
-    state.auto_fix_skipped = true;
-  } else {
-
-  Agent({
-    subagent_type: 'general-purpose',
-    run_in_background: false,
-    description: 'Apply high-priority workflow optimizations',
-    prompt: `## Task: Apply High-Priority Workflow Optimizations
-
-You are applying the top optimization suggestions from a workflow analysis.
-
-## Improvements to Apply (HIGH priority only)
-${highPriorityFixes.map((f, i) =>
-  `${i + 1}. [${f.scope}] ${f.description}\n   Rationale: ${f.rationale}\n   Affected: ${f.affected.join(', ')}`
-).join('\n')}
-
-## Workflow Steps
-${state.steps.map((s, i) => `${i + 1}. ${s.name} (${s.type}): ${s.command}`).join('\n')}
-
-## Rules
-1. Read each affected file BEFORE modifying
-2. Apply ONLY the high-priority suggestions
-3. Preserve existing code style
-4. Write a changes summary to: ${state.work_dir}/auto-fix-changes.md
-`
-  });
-
-  } // end Apply branch
-}
-```
-
-### Step 5.4: Display Summary
-
-Output to user:
-
-```
-Workflow Tune Complete!
-
-Workflow: {name}
-Steps: {count}
-Workflow Score: {score}/100
-Average Step Quality: {avgScore}/100
-Weakest Step: {name} ({score}/100)
-
-Step Scores: {step1}={score1} → {step2}={score2} → ... → {stepN}={scoreN}
-
-Issues: {total} ({high} high priority)
-Improvements: {count} ({highCount} high priority)
-
-Full report: {workDir}/final-report.md
-Process log: {workDir}/process-log.md
-```
-
-## Output
-
-- **Files**: `final-report.md`, optionally `auto-fix-changes.md`
-- **State**: `status = completed`
-- **Next**: Workflow complete. Return control to user.

package/.claude/skills/workflow-tune/specs/workflow-eval-criteria.md

@@ -1,57 +0,0 @@
-# Workflow Evaluation Criteria
-
-Workflow 调优评估标准，由 Phase 03 (Analyze Step) 和 Phase 04 (Synthesize) 引用。
-
-## Per-Step Dimensions
-
-| Dimension | Description |
-|-----------|-------------|
-| Execution Success | 命令是否成功执行，退出码是否正确 |
-| Output Completeness | 产物是否齐全，预期文件是否生成 |
-| Artifact Quality | 产物内容质量 — 非空、格式正确、内容有意义 |
-| Handoff Readiness | 产物是否满足下一步的输入要求，格式兼容性 |
-
-## Per-Step Scoring Guide
-
-| Range | Level | Description |
-|-------|-------|-------------|
-| 90-100 | Excellent | 执行完美，产物高质量，下游可直接消费 |
-| 80-89 | Good | 执行成功，产物基本完整，微调即可衔接 |
-| 70-79 | Adequate | 执行成功但产物有缺失或质量一般 |
-| 60-69 | Needs Work | 部分失败或产物质量差，衔接困难 |
-| 0-59 | Poor | 执行失败或产物无法使用 |
-
-## Workflow-Level Dimensions
-
-| Dimension | Description |
-|-----------|-------------|
-| Coherence | 步骤间的逻辑顺序是否合理，是否形成完整流程 |
-| Handoff Quality | 步骤间的数据传递是否顺畅，格式是否匹配 |
-| Redundancy | 是否存在步骤间的工作重叠或重复 |
-| Efficiency | 整体流程是否高效，有无不必要的步骤 |
-| Completeness | 是否覆盖所有必要环节，有无遗漏 |
-
-## Analysis Depth Profiles
-
-### Quick
-- 每步 3-5 要点
-- 关注: 执行成功、产出完整、明显问题
-- 跨步骤: 基本衔接检查
-
-### Standard
-- 每步详细评估
-- 关注: 执行质量、产出完整性、产物质量、衔接就绪度、潜在问题
-- 跨步骤: 衔接质量、冗余检测、瓶颈识别
-
-### Deep
-- 每步深度审查
-- 关注: 执行质量、产出正确性、结构质量、衔接完整性、错误处理、性能信号、架构影响、边界情况
-- 跨步骤: 全面流程优化、重排建议、缺失步骤检测、架构改进
-
-## Issue Severity Guide
-
-| Severity | Description | Example |
-|----------|-------------|---------|
-| High | 阻断流程或导致错误结果 | 步骤执行失败、产物格式不兼容、关键数据丢失 |
-| Medium | 影响质量但不阻断 | 产物不完整、衔接需手动调整、冗余步骤 |
-| Low | 可改进但不影响功能 | 输出格式不一致、可优化的步骤顺序 |

package/.claude/skills/workflow-tune/templates/step-analysis-prompt.md

@@ -1,88 +0,0 @@
-# Step Analysis Prompt Template
-
-Phase 03 使用此模板构造 ccw cli 提示词，让 Gemini 分析单个步骤的执行结果和产物质量。
-
-## Template
-
-```
-PURPOSE: Analyze the output of workflow step "${stepName}" (step ${stepIndex}/${totalSteps}) to assess quality, identify issues, and evaluate handoff readiness for the next step.
-
-WORKFLOW CONTEXT:
-Name: ${workflowName}
-Goal: ${workflowContext}
-Step Chain:
-${stepChainContext}
-
-CURRENT STEP:
-Name: ${stepName}
-Type: ${stepType}
-Command: ${stepCommand}
-${successCriteria}
-
-EXECUTION RESULT:
-${execSummary}
-
-${handoffContext}
-
-STEP ARTIFACTS:
-${artifactSummary}
-
-ANALYSIS DEPTH: ${analysisDepth}
-${depthInstructions}
-
-TASK:
-1. Assess step execution quality (did it succeed? complete output?)
-2. Evaluate artifact quality (content correctness, completeness, format)
-3. Check handoff readiness (can the next step consume this output?)
-4. Identify issues, risks, or optimization opportunities
-5. Rate overall step quality 0-100
-
-EXPECTED OUTPUT (strict JSON, no markdown):
-{
-  "quality_score": <0-100>,
-  "execution_assessment": {
-    "success": <true|false>,
-    "completeness": "<complete|partial|failed>",
-    "notes": "<brief assessment>"
-  },
-  "artifact_assessment": {
-    "count": <number>,
-    "quality": "<high|medium|low>",
-    "key_outputs": ["<main output 1>", "<main output 2>"],
-    "missing_outputs": ["<expected but missing>"]
-  },
-  "handoff_assessment": {
-    "ready": <true|false>,
-    "next_step_compatible": <true|false|null>,
-    "handoff_notes": "<what next step should know>"
-  },
-  "issues": [
-    { "severity": "high|medium|low", "description": "<issue>", "suggestion": "<fix>" }
-  ],
-  "optimization_opportunities": [
-    { "area": "<area>", "description": "<opportunity>", "impact": "high|medium|low" }
-  ],
-  "step_summary": "<1-2 sentence summary for process log>"
-}
-
-CONSTRAINTS: Be specific, reference artifact content where possible, output ONLY JSON
-```
-
-## Variable Substitution
-
-| Variable | Source | Description |
-|----------|--------|-------------|
-| `${stepName}` | workflow-state.json | 当前步骤名称 |
-| `${stepIndex}` | orchestrator loop | 当前步骤序号 (1-based) |
-| `${totalSteps}` | workflow-state.json | 总步骤数 |
-| `${workflowName}` | workflow-state.json | Workflow 名称 |
-| `${workflowContext}` | workflow-state.json | Workflow 目标描述 |
-| `${stepChainContext}` | Phase 03 builds | 所有步骤状态概览 |
-| `${stepType}` | workflow-state.json | 步骤类型 (skill/ccw-cli/command) |
-| `${stepCommand}` | workflow-state.json | 步骤命令 |
-| `${successCriteria}` | workflow-state.json | 成功标准 (如有) |
-| `${execSummary}` | Phase 03 builds | 执行结果摘要 |
-| `${handoffContext}` | Phase 03 builds | 上一步的产出摘要 (非首步) |
-| `${artifactSummary}` | Phase 03 builds | 产物内容摘要 |
-| `${analysisDepth}` | workflow-state.json | 分析深度 (quick/standard/deep) |
-| `${depthInstructions}` | Phase 03 maps | 对应深度的分析指令 |