feat: Enhance parallel-dev-cycle with prep-package integration

- Added argument parsing and prep package loading in session initialization.
- Implemented validation checks for prep-package.json integrity.
- Integrated prep package data into cycle state, including task refinement and auto-iteration settings.
- Updated agent execution to utilize source references and focus directives from prep package.
- Modified context gathering and test context generation to reference active workflow paths.
- Introduced a new interactive prompt for pre-flight checklist and task quality assessment.
- Created a detailed schema and integration specification for prep-package.json.
- Ensured all relevant phases validate and utilize the prep package effectively.

Author: catlog22

.codex/prompts/prep-cycle.md

@@ -302,11 +302,11 @@ if (!autoYes) {
       options: [
         { label: "Start Execution", description: "Execute all tasks serially" },
         { label: "Adjust Tasks", description: "Modify, reorder, or remove tasks" },
-        { label: "Cancel", description: "Cancel execution, keep execution-plan.jsonl" }
+        { label: "Cancel", description: "Cancel execution, keep tasks.jsonl" }
       ]
     }]
   })
-  // "Adjust Tasks": display task list, user deselects/reorders, regenerate execution-plan.jsonl
+  // "Adjust Tasks": display task list, user deselects/reorders, regenerate tasks.jsonl
   // "Cancel": end workflow, keep artifacts
 }
 ```
@@ -321,7 +321,7 @@ Execute tasks one by one directly using tools (Read, Edit, Write, Grep, Glob, Ba
 
 ```
 For each taskId in executionOrder:
-  ├─ Load task from execution-plan.jsonl
+  ├─ Load task from tasks.jsonl
   ├─ Check dependencies satisfied (all deps completed)
   ├─ Record START event to execution-events.md
   ├─ Execute task directly:

.codex/skills/analyze-with-file/EXECUTE.md

@@ -82,7 +82,7 @@ Step 4: Synthesis & Conclusion
    └─ Offer options: quick execute / create issue / generate task / export / done
 
 Step 5: Quick Execute (Optional - user selects)
-   ├─ Convert conclusions.recommendations → execution-plan.jsonl (with convergence)
+   ├─ Convert conclusions.recommendations → tasks.jsonl (unified JSONL with convergence)
    ├─ Pre-execution analysis (dependencies, file conflicts, execution order)
    ├─ User confirmation
    ├─ Direct inline execution (Read/Edit/Write/Grep/Glob/Bash)
@@ -581,13 +581,13 @@ if (!autoYes) {
 
 **Key Principle**: No additional exploration — analysis phase has already collected all necessary context. No CLI delegation — execute directly using tools.
 
-**Flow**: `conclusions.json → execution-plan.jsonl → User Confirmation → Direct Inline Execution → execution.md + execution-events.md`
+**Flow**: `conclusions.json → tasks.jsonl → User Confirmation → Direct Inline Execution → execution.md + execution-events.md`
 
 **Full specification**: See `EXECUTE.md` for detailed step-by-step implementation.
 
-##### Step 5.1: Generate execution-plan.jsonl
+##### Step 5.1: Generate tasks.jsonl
 
-Convert `conclusions.recommendations` into JSONL execution list. Each line is a self-contained task with convergence criteria:
+Convert `conclusions.recommendations` into unified JSONL task format. Each line is a self-contained task with convergence criteria:
 
 ```javascript
 const conclusions = JSON.parse(Read(`${sessionFolder}/conclusions.json`))
@@ -603,22 +603,28 @@ const tasks = conclusions.recommendations.map((rec, index) => ({
   description: rec.rationale,
   type: inferTaskType(rec),  // fix | refactor | feature | enhancement | testing
   priority: rec.priority,
-  files_to_modify: extractFilesFromEvidence(rec, explorations),
+  effort: inferEffort(rec),  // small | medium | large
+  files: extractFilesFromEvidence(rec, explorations).map(f => ({
+    path: f,
+    action: 'modify'
+  })),
   depends_on: [],
   convergence: {
     criteria: generateCriteria(rec),         // Testable conditions
     verification: generateVerification(rec), // Executable command or steps
     definition_of_done: generateDoD(rec)     // Business language
   },
-  context: {
-    source_conclusions: conclusions.key_conclusions,
-    evidence: rec.evidence || []
+  evidence: rec.evidence || [],
+  source: {
+    tool: 'analyze-with-file',
+    session_id: sessionId,
+    original_id: `TASK-${String(index + 1).padStart(3, '0')}`
   }
 }))
 
 // Validate convergence quality (same as req-plan-with-file)
 // Write one task per line
-Write(`${sessionFolder}/execution-plan.jsonl`, tasks.map(t => JSON.stringify(t)).join('\n'))
+Write(`${sessionFolder}/tasks.jsonl`, tasks.map(t => JSON.stringify(t)).join('\n'))
 ```
 
 ##### Step 5.2: Pre-Execution Analysis
@@ -641,7 +647,7 @@ if (!autoYes) {
       options: [
         { label: "Start Execution", description: "Execute all tasks serially" },
         { label: "Adjust Tasks", description: "Modify, reorder, or remove tasks" },
-        { label: "Cancel", description: "Cancel execution, keep execution-plan.jsonl" }
+        { label: "Cancel", description: "Cancel execution, keep tasks.jsonl" }
       ]
     }]
   })
@@ -664,7 +670,7 @@ For each task in execution order:
 
 - Update `execution.md` with final summary (statistics, task results table)
 - Finalize `execution-events.md` with session footer
-- Update `execution-plan.jsonl` with execution results per task
+- Update `tasks.jsonl` with `_execution` state per task
 
 ```javascript
 if (!autoYes) {
@@ -685,7 +691,7 @@ if (!autoYes) {
 ```
 
 **Success Criteria**:
-- `execution-plan.jsonl` generated with convergence criteria per task
+- `tasks.jsonl` generated with convergence criteria and source provenance per task
 - `execution.md` contains plan overview, task table, pre-execution analysis, final summary
 - `execution-events.md` contains chronological event stream with convergence verification
 - All tasks executed (or explicitly skipped) via direct inline execution
@@ -704,7 +710,7 @@ if (!autoYes) {
 ├── explorations.json          # Phase 2: Single perspective aggregated findings
 ├── perspectives.json          # Phase 2: Multi-perspective findings with synthesis
 ├── conclusions.json           # Phase 4: Final synthesis with recommendations
-├── execution-plan.jsonl       # Phase 5: JSONL execution list with convergence (if quick execute)
+├── tasks.jsonl                # Phase 5: Unified JSONL with convergence + source (if quick execute)
 ├── execution.md               # Phase 5: Execution overview + task table + summary (if quick execute)
 └── execution-events.md        # Phase 5: Chronological event log (if quick execute)
 ```
@@ -717,7 +723,7 @@ if (!autoYes) {
 | `explorations.json` | 2 | Single perspective aggregated findings |
 | `perspectives.json` | 2 | Multi-perspective findings with cross-perspective synthesis |
 | `conclusions.json` | 4 | Final synthesis: conclusions, recommendations, open questions |
-| `execution-plan.jsonl` | 5 | JSONL execution list from recommendations, each line with convergence criteria |
+| `tasks.jsonl` | 5 | Unified JSONL from recommendations, each line with convergence criteria and source provenance |
 | `execution.md` | 5 | Execution overview: plan source, task table, pre-execution analysis, final summary |
 | `execution-events.md` | 5 | Chronological event stream with task details and convergence verification |
 
@@ -861,7 +867,7 @@ Remaining questions or areas for investigation
 | Session folder conflict | Append timestamp suffix | Create unique folder and continue |
 | Quick execute: task fails | Record failure in execution-events.md | User can retry, skip, or abort |
 | Quick execute: verification fails | Mark criterion as unverified, continue | Note in events, manual check |
-| Quick execute: no recommendations | Cannot generate execution-plan.jsonl | Suggest using lite-plan instead |
+| Quick execute: no recommendations | Cannot generate tasks.jsonl | Suggest using lite-plan instead |
 
 ## Best Practices
 

.codex/skills/analyze-with-file/SKILL.md

@@ -74,6 +74,15 @@ Each agent **maintains one main document** (e.g., requirements.md, plan.json, im
 
 When `--auto`: Run all phases sequentially without user confirmation between iterations. Use recommended defaults for all decisions. Automatically continue iteration loop until tests pass or max iterations reached.
 
+## Prep Package Integration
+
+When `prep-package.json` exists at `{projectRoot}/.workflow/.cycle/prep-package.json`, Phase 1 consumes it to:
+- Use refined task description instead of raw TASK
+- Apply auto-iteration config (convergence criteria, phase gates)
+- Inject per-iteration agent focus directives (0→1 vs 1→100)
+
+Prep packages are generated by the interactive prompt `/prompts:prep-cycle`. See [phases/00-prep-checklist.md](phases/00-prep-checklist.md) for schema.
+
 ## Execution Flow
 
 ```

.codex/skills/parallel-dev-cycle/SKILL.md

@@ -0,0 +1,191 @@
+# Prep Package Schema & Integration Spec
+
+Schema definition for `prep-package.json` and integration points with the parallel-dev-cycle skill.
+
+## File Location
+
+```
+{projectRoot}/.workflow/.cycle/prep-package.json
+```
+
+Generated by: `/prompts:prep-cycle` (interactive prompt)
+Consumed by: Phase 1 (Session Initialization)
+
+## JSON Schema
+
+```json
+{
+  "version": "1.0.0",
+  "generated_at": "ISO8601",
+  "prep_status": "ready | needs_refinement | blocked",
+
+  "environment": {
+    "project_root": "/path/to/project",
+    "prerequisites": {
+      "required_passed": true,
+      "recommended_passed": true,
+      "warnings": ["string"]
+    },
+    "tech_stack": "string (e.g. Express.js + TypeORM + PostgreSQL)",
+    "test_framework": "string (e.g. jest, vitest, pytest)",
+    "has_project_tech": true,
+    "has_project_guidelines": true
+  },
+
+  "task": {
+    "original": "raw user input",
+    "refined": "enhanced task description with all 5 dimensions",
+    "quality_score": 8,
+    "dimensions": {
+      "objective": { "score": 2, "value": "..." },
+      "success_criteria": { "score": 2, "value": "..." },
+      "scope": { "score": 2, "value": "..." },
+      "constraints": { "score": 1, "value": "..." },
+      "context": { "score": 1, "value": "..." }
+    },
+    "source_refs": [
+      {
+        "path": "docs/prd.md",
+        "type": "local_file | url | auto_detected",
+        "status": "verified | linked | not_found",
+        "preview": "first ~20 lines (local_file only)"
+      }
+    ]
+  },
+
+  "auto_iteration": {
+    "enabled": true,
+    "no_confirmation": true,
+    "max_iterations": 5,
+    "timeout_per_iteration_ms": 1800000,
+    "convergence": {
+      "test_pass_rate": 90,
+      "coverage": 80,
+      "max_critical_bugs": 0,
+      "max_open_issues": 3
+    },
+    "phase_gates": {
+      "zero_to_one": {
+        "iterations": [1, 2],
+        "exit_criteria": {
+          "code_compiles": true,
+          "core_test_passes": true,
+          "min_requirements_implemented": 1
+        }
+      },
+      "one_to_hundred": {
+        "iterations": [3, 4, 5],
+        "exit_criteria": {
+          "test_pass_rate": 90,
+          "coverage": 80,
+          "critical_bugs": 0
+        }
+      }
+    },
+    "agent_focus": {
+      "zero_to_one": {
+        "ra": "core_requirements_only",
+        "ep": "minimal_viable_architecture",
+        "cd": "happy_path_first",
+        "vas": "smoke_tests_only"
+      },
+      "one_to_hundred": {
+        "ra": "full_requirements_with_nfr",
+        "ep": "refined_architecture_with_risks",
+        "cd": "complete_implementation_with_error_handling",
+        "vas": "full_test_suite_with_coverage"
+      }
+    }
+  }
+}
+```
+
+## Phase 1 Integration (Consume & Check)
+
+Phase 1 对 prep-package.json 执行 **6 项验证**，全部通过才加载，任一失败回退默认行为：
+
+| # | 检查项 | 条件 | 失败处理 |
+|---|--------|------|----------|
+| 1 | prep_status | `=== "ready"` | 跳过 prep |
+| 2 | project_root | 与当前 projectRoot 一致 | 跳过 prep（防错误项目） |
+| 3 | quality_score | `>= 6` | 跳过 prep（任务质量不达标） |
+| 4 | 时效性 | generated_at 在 24h 以内 | 跳过 prep（可能过期） |
+| 5 | 必需字段 | task.refined, convergence, phase_gates, agent_focus 全部存在 | 跳过 prep |
+| 6 | 收敛值合法 | test_pass_rate/coverage 为 0-100 的数字 | 跳过 prep |
+
+```javascript
+// In 01-session-init.md, Step 1.1:
+const prepPath = `${projectRoot}/.workflow/.cycle/prep-package.json`
+if (fs.existsSync(prepPath)) {
+  const raw = JSON.parse(Read(prepPath))
+  const checks = validatePrepPackage(raw, projectRoot)
+
+  if (checks.valid) {
+    prepPackage = raw
+    task = prepPackage.task.refined
+    // Inject into state:
+    state.convergence = prepPackage.auto_iteration.convergence
+    state.phase_gates = prepPackage.auto_iteration.phase_gates
+    state.agent_focus = prepPackage.auto_iteration.agent_focus
+    state.max_iterations = prepPackage.auto_iteration.max_iterations
+  } else {
+    console.warn('Prep package validation failed, using defaults')
+    // prepPackage remains null → no convergence/phase_gates/agent_focus
+  }
+}
+```
+
+## Phase 2 Integration (Agent Focus Directives)
+
+```javascript
+// Before spawning each agent, append focus directive:
+function getAgentFocusDirective(agentName, state) {
+  if (!state.phase_gates) return ""
+  const iteration = state.current_iteration
+  const isZeroToOne = state.phase_gates.zero_to_one.iterations.includes(iteration)
+  const focus = isZeroToOne
+    ? state.agent_focus.zero_to_one[agentName]
+    : state.agent_focus.one_to_hundred[agentName]
+
+  const directives = {
+    core_requirements_only: "Focus ONLY on core functional requirements. Skip NFRs and edge cases.",
+    minimal_viable_architecture: "Design the simplest working architecture. Skip optimization.",
+    happy_path_first: "Implement ONLY the happy path. Skip error handling and edge cases.",
+    smoke_tests_only: "Run smoke tests only. Skip coverage analysis and exhaustive validation.",
+    full_requirements_with_nfr: "Complete requirements including NFRs, edge cases, security.",
+    refined_architecture_with_risks: "Refine architecture with risk mitigation and scalability.",
+    complete_implementation_with_error_handling: "Complete all tasks with error handling and validation.",
+    full_test_suite_with_coverage: "Full test suite with coverage report and quality audit."
+  }
+  return `\n## FOCUS DIRECTIVE (${isZeroToOne ? '0→1' : '1→100'})\n${directives[focus] || ''}\n`
+}
+```
+
+## Phase 3 Integration (Convergence Evaluation)
+
+```javascript
+// In 03-result-aggregation.md, Step 3.4:
+function evaluateConvergence(parsedResults, state) {
+  if (!state.phase_gates) {
+    // No prep package: use default issue detection
+    return { converged: !parsedResults.vas.issues?.length, phase: "default" }
+  }
+  const iteration = state.current_iteration
+  const isZeroToOne = state.phase_gates.zero_to_one.iterations.includes(iteration)
+
+  if (isZeroToOne) {
+    return {
+      converged: parsedResults.cd.status !== 'failed'
+                 && (parsedResults.vas.test_pass_rate > 0 || parsedResults.cd.tests_passing),
+      phase: "0→1"
+    }
+  }
+  const conv = state.convergence
+  return {
+    converged: (parsedResults.vas.test_pass_rate || 0) >= conv.test_pass_rate
+               && (parsedResults.vas.coverage || 0) >= conv.coverage
+               && (parsedResults.vas.critical_issues || 0) <= conv.max_critical_bugs,
+    phase: "1→100"
+  }
+}
+```