speccrew 0.7.73 → 0.7.75

package/.speccrew/agents/speccrew-test-manager.md

@@ -49,6 +49,173 @@ Phase 6: Delivery Summary
   └── Summary → User confirmation → Finalize
 ```
 
+## EXECUTION PROTOCOL
+
+**Agent MUST follow this protocol when starting any skill execution:**
+
+1. **Load XML First**: Before ANY other action, locate and read the skill's SKILL.xml:
+   - Skill directory: find the skill folder under the IDE skills directory (e.g., `.qoder/skills/{skill-name}/` or `.speccrew/skills/{skill-name}/`)
+   - Read `SKILL.xml` from that directory immediately
+   - Do NOT explore workspace structure, check files, or run commands before loading XML
+   - If SKILL.xml read fails, report error and ABORT — do NOT attempt to proceed without it
+2. **Announce Workflow**: Log the workflow phases/steps overview from XML structure
+3. **Execute Blocks Sequentially**: Follow SKILL.xml block order strictly — do NOT improvise or skip blocks
+4. **Announce Every Block**: Before executing EVERY block, announce using `[Block ID]` format (see Block Execution Announcement Protocol below)
+5. **Only Pause at HARD STOP**: Only wait for user confirmation at explicitly defined checkpoints (P3.5 Checkpoint A: Test Case Coverage, P4.6 Checkpoint B: Code Review, P6.5 Joint Confirmation)
+
+### ACTION EXECUTION RULES
+
+When executing XML workflow blocks, map actions to IDE tools as follows:
+- `action="run-skill"` → Use **Skill tool** (pass skill name only, do NOT browse for files)
+- `action="dispatch-to-worker"` → Use **Agent tool** (create new `speccrew-task-worker` agent session — NOT Skill tool, NOT direct execution)
+- `action="run-script"` → Use **Bash/Terminal tool**
+- `action="read-file"` → Use **Read tool**
+- `action="write-file"` → Use **Write/Edit tool**
+- `action="log"` → **Output** directly to conversation
+- `action="confirm"` → **Output + Wait** for user response
+
+**FORBIDDEN**: Do NOT manually search directories for SKILL.md files. Do NOT execute worker tasks yourself — always delegate via Agent tool.
+
+**VIOLATION**: Skipping XML loading, improvising steps, or proceeding without step announcements = workflow ABORT.
+
+## MANDATORY: Block Execution Announcement Protocol
+
+Before executing EVERY block in the orchestration workflow, you MUST announce it in this format:
+
+```
+🏷️ Block [{ID}] (type={type}, action={action}) — {desc}
+```
+
+**This is NOT optional.** If you dispatch Workers without announcing each Phase block first, you are violating the execution protocol.
+
+**Correct example:**
+```
+🏷️ Block [P3] (type=task, action=dispatch-to-worker) — Phase 3: Test Case Design
+🔧 Tool: Agent tool → create speccrew-task-worker
+✅ Result: test-cases.md generated
+
+🏷️ Block [P4] (type=task, action=dispatch-to-worker) — Phase 4: Test Code Generation
+🔧 Tool: Agent tool → create speccrew-task-worker
+✅ Result: test code + test-code-plan.md generated
+
+🏷️ Block [P5-B1] (type=task, action=dispatch-to-worker) — Phase 5 Stage 1: Test Runner Dispatch
+🔧 Tool: Agent tool → create speccrew-task-worker (batch)
+✅ Result: 4 workers dispatched
+
+🏷️ Block [P5-B2] (type=task, action=dispatch-to-worker) — Phase 5 Stage 2: Test Reporter Dispatch
+🔧 Tool: Agent tool → create speccrew-task-worker
+✅ Result: test-report.md + bug reports generated
+```
+
+**Incorrect example (❌ FORBIDDEN):**
+```
+Now let me dispatch Phase 3...
+Phase 3 done. Moving to Phase 4...
+```
+
+**Rules:**
+- Announce BEFORE execution begins, not after
+- Use exact block IDs from workflow XML (P0, P0.5, P1, P2, P3, P3.5, P4, P4.4, P4.6, P5, P5-B1, P5-B2, P6, etc.)
+- For gateway blocks, announce which branch is taken
+- For rule blocks, confirm the rule is acknowledged
+
+# 🛑 CRITICAL: dispatch-to-worker Protocol
+
+### Definition
+When `action="dispatch-to-worker"` appears in the orchestration workflow:
+
+**You (Test Manager Agent) MUST:**
+1. Use **Agent tool** to create a new sub-Agent
+2. Specify sub-Agent role as **speccrew-task-worker**
+3. Pass Skill name and all context parameters in the dispatch prompt
+4. **Wait for Worker completion** before proceeding to the next block
+
+**You (Test Manager Agent) MUST NOT:**
+- ❌ Use Skill tool to directly invoke Phase Skill (e.g., speccrew-test-case-design)
+- ❌ Run scripts yourself (including update-progress.js)
+- ❌ Read/write test artifacts yourself (e.g., test-cases.md, test code, test-report.md, bug reports)
+- ❌ Interpret "dispatch" as "execute yourself"
+
+### Correct vs Incorrect Examples
+
+**❌ INCORRECT — Agent executes itself:**
+```
+TM reads Feature Specs → TM generates test-cases.md → TM runs update-progress.js
+```
+
+**✅ CORRECT — Agent dispatches to Worker:**
+```
+TM uses Agent tool to create speccrew-task-worker sub-Agent
+  → Passes: skill=speccrew-test-case-design, context={...}
+  → Worker loads Skill and executes all steps
+  → Worker returns results to TM
+TM continues to next orchestration block
+```
+
+### Scope: ALL Dispatch Phases
+
+| Phase | Skill | dispatch? |
+|-------|-------|----------|
+| Phase 3 | speccrew-test-case-design | ✅ dispatch-to-worker (when 2+ platforms) |
+| Phase 4 | speccrew-test-code-gen | ✅ dispatch-to-worker (when 2+ platforms) |
+| Phase 5 Stage 1 | speccrew-test-runner | ✅ dispatch-to-worker (when 2+ platforms) |
+| Phase 5 Stage 2 | speccrew-test-reporter | ✅ dispatch-to-worker (when 2+ platforms) |
+
+### MANDATORY: Worker Dispatch Prompt Format (Harness Principle 22)
+
+When dispatching Workers via Agent tool, the prompt MUST follow this EXACT format:
+
+```
+Execute skill: {skill_path}
+
+Context:
+  feature_spec_path: {value}
+  platform_id: {value}
+  ... (data parameters only)
+
+IMPORTANT: Follow the skill's SKILL.xml as the authoritative execution plan. Do NOT execute based on this prompt.
+```
+
+**FORBIDDEN in dispatch prompt:**
+- ❌ "执行要求" or "Execution Requirements" section
+- ❌ Step-by-step instructions (e.g., "读取Feature Spec", "生成测试用例")
+- ❌ Output file paths as instructions (e.g., "生成...文件")
+- ❌ "请执行...并返回完成状态" or any execution directive
+- ❌ Any text that tells Worker WHAT to do (the XML workflow defines this)
+
+**ALLOWED in dispatch prompt:**
+- ✅ Skill path reference
+- ✅ Data parameters (paths, IDs, names, flags)
+- ✅ Reminder to follow XML workflow
+
+**Rationale:** Worker Agents MUST read and execute SKILL.xml block-by-block. Dispatch prompts containing execution instructions cause Workers to bypass the XML workflow, leading to inconsistent behavior.
+
+### ⚠️ Parallel Worker Dispatch Protocol (MANDATORY)
+
+When dispatching multiple workers in Phase 3/4/5 batch mode:
+
+1. **COLLECT FIRST**: Iterate through ALL platform combinations BEFORE creating any Worker
+2. **BATCH CREATE**: Create ALL Worker tasks in a **SINGLE message** using **MULTIPLE Agent tool calls in parallel**
+3. **NO SEQUENTIAL WAIT**: Do NOT wait for any Worker to complete before creating the next one
+4. **ONE WORKER PER ITEM**: Each platform = exactly ONE separate Worker with its own context
+
+**CORRECT execution pattern:**
+```
+Dispatch items: [web-vue, mobile-react, backend-node]
+↓
+Turn 1: Agent(web-vue) + Agent(mobile-react) + Agent(backend-node)  ← ALL in ONE turn
+↓
+Turn 2-N: Monitor and collect results as Workers complete
+```
+
+**INCORRECT execution pattern (FORBIDDEN):**
+```
+Turn 1: Create Worker(web-vue) → wait for completion
+Turn 2: Create Worker(mobile-react) → wait for completion
+Turn 3: Create Worker(backend-node) → wait for completion
+...
+```
+
 ---
 
 ## ORCHESTRATOR Rules

package/.speccrew/skills/speccrew-agentflow-manager/SKILL.md

@@ -1,161 +1,18 @@
 ---
 name: speccrew-agentflow-manager
-version: 1.0.0
 description: AgentFlow definition management - create, validate, and refine AgentFlow XML files
 tools: Read, Write, Task, Bash
 ---
 
-> **⚠️ MANDATORY EXECUTION PROTOCOL — READ BEFORE EXECUTING ANY BLOCK**
->
-> **Step 1**: Load XML workflow specification: `${workspace_path}/docs/rules/agentflow-spec.md` — this defines all block types and action-to-tool mappings
->
-> **Step 2**: Execute this SKILL.md's XML workflow **block by block in document order**. For EVERY block, you MUST follow this 3-step cycle:
->
-> ```
-> 🏷️ Block [ID] (action=[action]) — [desc]
-> 🔧 Tool: [which IDE tool to call]
-> ✅ Result: [output or status]
-> ```
->
-> Action-to-tool mapping:
-> - `action="run-script"` → Execute via **Terminal tool** (pass the `<field name="command">` value EXACTLY)
-> - `action="run-skill"` → Invoke via **Skill tool** (pass the `<field name="skill">` value EXACTLY)
-> - `action="read-file"` → Read via **Read tool**
-> - `action="create-file"` → Create via **Write tool** (create_file)
-> - `action="edit-file"` → Edit via **Edit tool** (search_replace)
-> - `action="analyze"` → Perform analysis directly
-> - `action="generate"` → Generate content directly
-> - `action="report"` → Format and output report
->
-> **Step 3**: Execute ALL blocks sequentially without pausing (only stop at explicit `<event action="confirm">` blocks)
->
-> **FORBIDDEN**:
-> - Do NOT skip the block announcement format above — every block must be announced before execution
-> - Do NOT run terminal commands as substitute for Skill tool calls
-> - Do NOT skip blocks or improvise your own commands
+# Trigger Scenarios
 
-# AgentFlow Manager
-
-Manage AgentFlow XML workflow definitions with three operation modes: **create**, **validate**, and **refine**.
-
-## Operation Modes
-
-| Mode | Description | Required Parameters |
-|------|-------------|---------------------|
-| `create` | Create new AgentFlow from natural language SOP | `description`, `parameters`, `skill_dir` |
-| `validate` | Validate existing .agentflow.xml file | `target_file` |
-| `refine` | Auto-fix validation errors in existing file | `target_file` |
-
-## Invocation Method
-
-**CRITICAL**: This skill is a **utility skill** — it MUST be loaded directly via Skill tool.
-
-```xml
-<block type="task" action="run-skill" desc="Invoke AgentFlow manager">
-  <field name="skill">speccrew-agentflow-manager</field>
-  <field name="mode">create</field>
-  <field name="description">Analyze source code and generate documentation</field>
-  <field name="parameters">["source_path", "output_dir"]</field>
-  <field name="skill_dir">/path/to/new-skill</field>
-  <field name="workspace_path">/path/to/workspace</field>
-</block>
-```
-
-## Input Parameters
-
-| Parameter | Type | Required | Description |
-|-----------|------|----------|-------------|
-| `mode` | string | Yes | Operation mode: `create`, `validate`, or `refine` |
-| `description` | string | (create) | Natural language SOP description |
-| `parameters` | array | (create) | Input parameter names (JSON array) |
-| `target_file` | string | (validate/refine) | Path to .agentflow.xml file to validate/refine |
-| `skill_dir` | string | (create) | Target skill directory path for new AgentFlow |
-| `workspace_path` | string | Yes | Current workspace path |
-
-## Output
-
-- **create mode**: Generated `SKILL.xml` and `SKILL.md` skeleton
-- **validate mode**: Validation report with errors and warnings
-- **refine mode**: Fixed file path and fix summary
-
----
+- User requests creation of a new AgentFlow XML from natural language SOP
+- Existing AgentFlow XML file needs validation or refinement
+- AgentFlow specification compliance check required
 
 ## AgentFlow Definition
 
 <!-- @agentflow: SKILL.xml -->
 
----
-
-## Appendix: Reference
-
-### Block Type Quick Reference
-
-| Block Type | Purpose | Required Attributes |
-|------------|---------|---------------------|
-| `input` | Define workflow inputs | Must be first block |
-| `output` | Define workflow outputs | Must be last block |
-| `task` | Execute an action | `action` attribute required |
-| `gateway` | Conditional branching | `mode` attribute required |
-| `loop` | Iterate over collection | `over`, `as` attributes required |
-| `checkpoint` | Persist progress | `name` attribute required |
-| `rule` | Declare constraints | `level` attribute required |
-| `event` | Logging/confirmation | `action` attribute required |
-| `error-handler` | Error handling | `try`, `catch` sub-elements |
-
-### Action Types
-
-| Action | IDE Tool | Usage |
-|--------|----------|-------|
-| `run-skill` | Skill tool | Invoke another skill |
-| `run-script` | Terminal tool | Execute command/script |
-| `read-file` | Read tool | Read file content |
-| `create-file` | Write tool | Create new file |
-| `edit-file` | Edit tool | Modify existing file |
-| `analyze` | Direct execution | Perform analysis |
-| `generate` | Direct execution | Generate content |
-| `report` | Direct execution | Format and output report |
-| `dispatch-to-worker` | Task tool | Create task for worker |
-
-### Variable Reference Syntax
-
-```xml
-<!-- Simple variable -->
-<field name="path" value="${skill_dir}/SKILL.xml"/>
-
-<!-- Object property -->
-<field name="count" value="${validation_result.errors.length}"/>
-
-<!-- Array index -->
-<field name="first" value="${parameters[0]}"/>
-
-<!-- In condition -->
-<case condition="${mode} == 'create'" next="B1"/>
-```
-
-### Checkpoint Verification
-
-```xml
-<block type="checkpoint" id="CP1" name="workflow_created" desc="Verify file was created">
-  <field name="file" value="${skill_dir}/SKILL.xml"/>
-  <field name="verify" value="file_exists(${skill_dir}/SKILL.xml)"/>
-</block>
-```
-
----
-
-## Checklist
-
-- [ ] XML declaration present: `<?xml version="1.0" encoding="UTF-8"?>`
-- [ ] `<workflow>` root element with id, status, version attributes
-- [ ] `<block type="input">` as first block with all required parameters
-- [ ] `<block type="output">` as last block with result definitions
-- [ ] All block IDs are unique (B1, B2, G1, etc.)
-- [ ] All `next` references point to valid block IDs
-- [ ] All variable references use `${}` syntax
-- [ ] All required fields have `required="true"` attribute
-- [ ] Gateway conditions are valid and cover all cases
-- [ ] Checkpoint verification conditions are valid
-
-> **MANDATORY**: All generated AgentFlow XML must strictly comply with the specification in `${workspace_path}/docs/rules/agentflow-spec.md`.
-
-<!-- @agentflow: SKILL.xml -->
+> **REQUIRED**: Before executing this workflow, read the XML workflow specification: speccrew-workspace/docs/rules/agentflow-spec.md
+> Then read and execute the XML workflow in SKILL.xml block-by-block as the authoritative execution plan.

package/.speccrew/skills/speccrew-deploy-build/SKILL.md

@@ -10,66 +10,9 @@ tools: Read, Bash, Glob
 - Deploy Agent needs to verify the application compiles successfully
 - CI/CD pipeline requires a build step verification
 
-# Input Parameters
-
-| Parameter | Required | Type | Description |
-|-----------|----------|------|-------------|
-| `platform_id` | Yes | string | Platform identifier (e.g., backend-spring, frontend-react) |
-| `build_cmd` | Yes | string | Build command from conventions-data/build (e.g., `mvn package -DskipTests`) |
-| `project_root` | Yes | string | Absolute path to the project root directory |
-| `iteration_path` | Yes | string | Current iteration directory path |
-
 ## AgentFlow Definition
 
 <!-- @agentflow: SKILL.xml -->
 
-> **REQUIRED**: Before executing this workflow, read the XML workflow specification: `speccrew-workspace/docs/rules/agentflow-spec.md`
-
-# Task Completion Report
-
-## Success Report
-
-```
-## Task Completion Report
-- **Status**: SUCCESS
-- **Platform**: {platform_id}
-- **Project Root**: {project_root}
-- **Build Duration**: {duration_seconds}s
-- **Build Command**: {build_cmd}
-- **Artifact Paths**:
-  - {artifact_path_1}
-  - {artifact_path_2}
-  - ...
-- **Build Log** (last 20 lines):
-```
-{last_20_lines_of_build_output}
-```
-- **Summary**: Build completed successfully with {artifact_count} artifacts generated
-```
-
-## Failure Report
-
-```
-## Task Completion Report
-- **Status**: FAILED
-- **Platform**: {platform_id}
-- **Project Root**: {project_root}
-- **Build Command**: {build_cmd}
-- **Error Category**: {DEPENDENCY_MISSING | BUILD_FAILURE | VALIDATION_ERROR}
-- **Error**: {detailed error description}
-- **Build Log** (last 30 lines):
-```
-{last_30_lines_of_build_output}
-```
-- **Recovery Hint**: {suggestion for resolving the issue}
-```
-
-# Key Rules
-
-| Rule | Description |
-|------|-------------|
-| **No Hard-coded Commands** | All build commands come from input parameters |
-| **Tool Detection** | Automatically detect and verify build tool availability |
-| **Artifact Verification** | Always verify expected artifacts exist after build |
-| **Duration Tracking** | Record and report build duration |
-| **Log Capture** | Capture and report relevant build output |
+> **REQUIRED**: Before executing this workflow, read the XML workflow specification: speccrew-workspace/docs/rules/agentflow-spec.md
+> Then read and execute the XML workflow in SKILL.xml block-by-block as the authoritative execution plan.

package/.speccrew/skills/speccrew-deploy-migrate/SKILL.md

@@ -10,71 +10,9 @@ tools: Read, Bash, Glob
 - Deploy Agent needs to apply pending schema changes
 - CI/CD pipeline requires database migration verification
 
-# Input Parameters
-
-| Parameter | Required | Type | Description |
-|-----------|----------|------|-------------|
-| `platform_id` | Yes | string | Platform identifier |
-| `migration_cmd` | Yes | string | Migration execution command from conventions-data (e.g., `mvn flyway:migrate`) |
-| `validation_cmd` | No | string | Migration validation command (e.g., `mvn flyway:validate`) |
-| `migration_scripts` | Yes | string | JSON array of migration scripts: `[{"name":"V001__create_user.sql","path":"...","type":"CREATE TABLE"}]` |
-| `project_root` | Yes | string | Absolute path to the project root directory |
-| `iteration_path` | Yes | string | Current iteration directory path |
-
 ## AgentFlow Definition
 
 <!-- @agentflow: SKILL.xml -->
 
-> **REQUIRED**: Before executing this workflow, read the XML workflow specification: `speccrew-workspace/docs/rules/agentflow-spec.md`
-
-# Task Completion Report
-
-## Success Report
-
-```
-## Task Completion Report
-- **Status**: SUCCESS
-- **Platform**: {platform_id}
-- **Project Root**: {project_root}
-- **Migration Command**: {migration_cmd}
-- **Scripts Executed**: {count}
-  - {script_1_name}: {type} ({tables_affected})
-  - {script_2_name}: {type} ({tables_affected})
-  - ...
-- **Tables Affected**:
-  - Created: {table_list}
-  - Modified: {table_list}
-  - Dropped: {table_list}
-- **Validation Status**: {PASSED | SKIPPED}
-- **Execution Duration**: {duration_seconds}s
-- **Summary**: Database migration completed successfully
-```
-
-## Failure Report
-
-```
-## Task Completion Report
-- **Status**: FAILED
-- **Platform**: {platform_id}
-- **Project Root**: {project_root}
-- **Migration Command**: {migration_cmd}
-- **Error Category**: {DEPENDENCY_MISSING | BUILD_FAILURE | VALIDATION_ERROR}
-- **Error**: {detailed error description}
-- **Scripts Attempted**: {count}
-- **Failed Script**: {script_name} (if applicable)
-- **Migration Output** (last 30 lines):
-```
-{last_30_lines_of_migration_output}
-```
-- **Recovery Hint**: {suggestion for resolving the issue}
-```
-
-# Key Rules
-
-| Rule | Description |
-|------|-------------|
-| **Script Verification** | Always verify migration script files exist before execution |
-| **Optional Validation** | Validation step is optional based on validation_cmd presence |
-| **JSON Parsing** | Parse migration_scripts JSON to extract script metadata |
-| **Table Tracking** | Report tables affected by each migration script |
-| **Duration Tracking** | Record and report migration execution duration |
+> **REQUIRED**: Before executing this workflow, read the XML workflow specification: speccrew-workspace/docs/rules/agentflow-spec.md
+> Then read and execute the XML workflow in SKILL.xml block-by-block as the authoritative execution plan.

package/.speccrew/skills/speccrew-deploy-smoke-test/SKILL.md

@@ -10,82 +10,9 @@ tools: Read, Bash, Glob
 - Deploy Agent needs to validate deployment success
 - Post-deployment verification required
 
-# Input Parameters
-
-| Parameter | Required | Type | Description |
-|-----------|----------|------|-------------|
-| `platform_id` | Yes | string | Platform identifier |
-| `base_url` | No | string | Application base URL (e.g., `http://localhost:8080`). Required for `http` mode. |
-| `api_contract_paths` | No | string | Comma-separated paths to API Contract documents. Required for `http` mode. |
-| `iteration_path` | Yes | string | Current iteration directory path |
-| `test_mode` | No | string | Test method: `http` (default, for server apps), `process` (for client apps - verify process runs and exits cleanly), `log` (verify expected log output). Default: `http` |
-| `expected_exit_code` | No | string | Expected process exit code for `process` mode (default: `0`) |
-| `log_file` | No | string | Log file path for `log` mode verification |
-| `expected_log_patterns` | No | string | Comma-separated regex patterns expected in log for `log` mode (e.g., `"DB initialized,UI loaded"`) |
-| `process_name` | No | string | Process name or pattern to check (for `process` mode, e.g., `myapp.exe` or `MyApp`) |
-
 ## AgentFlow Definition
 
 <!-- @agentflow: SKILL.xml -->
 
-> **REQUIRED**: Before executing this workflow, read the XML workflow specification: `speccrew-workspace/docs/rules/agentflow-spec.md`
-
-# Task Completion Report
-
-## Success Report
-
-```
-## Task Completion Report
-- **Status**: SUCCESS
-- **Platform**: {platform_id}
-- **Base URL**: {base_url}
-- **Endpoints Tested**: {total_count}
-- **Pass Rate**: {pass_rate}%
-- **Passed**: {passed_count}
-- **Failed**: {failed_count}
-- **Test Results**:
-
-| Endpoint | Method | Expected | Actual | Status |
-|----------|--------|----------|--------|--------|
-| {endpoint_1} | {method} | {expected} | {actual} | PASS |
-| {endpoint_2} | {method} | {expected} | {actual} | PASS |
-| {endpoint_3} | {method} | {expected} | {actual} | FAIL |
-
-- **Summary**: Smoke test passed with {pass_rate}% success rate
-```
-
-## Failure Report
-
-```
-## Task Completion Report
-- **Status**: FAILED
-- **Platform**: {platform_id}
-- **Base URL**: {base_url}
-- **Endpoints Tested**: {total_count}
-- **Pass Rate**: {pass_rate}%
-- **Failed Endpoints**:
-  - {endpoint_1}: expected {expected}, got {actual}
-  - {endpoint_2}: expected {expected}, got {actual}
-- **Error Category**: {VALIDATION_ERROR | RUNTIME_ERROR}
-- **Error**: {detailed error description}
-- **Recovery Hint**: Verify application is running and API contracts are up to date
-```
-
-# Important Notes
-
-- **Smoke test is NOT integration testing** — it only verifies service availability and endpoint reachability
-- **Pass rate threshold** — If pass rate < 80% → FAILED
-- **Critical GET endpoints** — If any critical GET endpoint returns 404 → FAILED
-- **No business logic testing** — Smoke test does not validate request/response bodies or business rules
-- **Lightweight verification** — Designed for quick post-deployment validation
-
-# Key Rules
-
-| Rule | Description |
-|------|-------------|
-| **HTTP Status Only** | Only verify HTTP status codes, not response bodies |
-| **GET Endpoints** | Must return 200 or redirect (301/302) |
-| **Write Endpoints** | Any status except 404 is acceptable |
-| **80% Pass Rate** | Overall pass rate must be >= 80% |
-| **Critical GET 404** | Any critical GET endpoint returning 404 causes failure |
-| **Contract-Based** | Extract endpoints from API Contract documents |
+> **REQUIRED**: Before executing this workflow, read the XML workflow specification: speccrew-workspace/docs/rules/agentflow-spec.md
+> Then read and execute the XML workflow in SKILL.xml block-by-block as the authoritative execution plan.

package/.speccrew/skills/speccrew-deploy-startup/SKILL.md

@@ -10,77 +10,9 @@ tools: Read, Bash
 - Deploy Agent needs to verify application startup
 - Smoke test requires a running application instance
 
-# Input Parameters
-
-| Parameter | Required | Type | Description |
-|-----------|----------|------|-------------|
-| `platform_id` | Yes | string | Platform identifier |
-| `start_cmd` | Yes | string | Application start command from conventions-data (e.g., `java -jar target/app.jar`) |
-| `health_url` | No | string | Health check URL (e.g., `http://localhost:8080/actuator/health`). Required for `http` mode. |
-| `health_timeout` | No | string | Health check timeout, default 60s |
-| `project_root` | Yes | string | Absolute path to the project root directory |
-| `iteration_path` | Yes | string | Current iteration directory path |
-| `verification_mode` | No | string | Verification method: `http` (default, for server apps), `process` (for client/desktop apps), `log` (for apps with log output). Default: `http` |
-| `process_name` | No | string | Process name or pattern to check (for `process` mode, e.g., `myapp.exe` or `MyApp`) |
-| `log_file` | No | string | Path to application log file (for `log` mode) |
-| `success_pattern` | No | string | Regex pattern in log that indicates successful startup (for `log` mode, e.g., `"Application started"` or `"Ready"`) |
-
 ## AgentFlow Definition
 
 <!-- @agentflow: SKILL.xml -->
 
-> **REQUIRED**: Before executing this workflow, read the XML workflow specification: `speccrew-workspace/docs/rules/agentflow-spec.md`
-
-# Task Completion Report
-
-## Success Report
-
-```
-## Task Completion Report
-- **Status**: SUCCESS
-- **Platform**: {platform_id}
-- **Project Root**: {project_root}
-- **Service URL**: {service_url}
-- **Health URL**: {health_url}
-- **Health Status**: UP
-- **Startup Duration**: {duration_seconds}s
-- **Process ID (PID)**: {pid}
-- **Start Command**: {start_cmd}
-- **Summary**: Application started successfully and passed health check
-```
-
-## Failure Report
-
-```
-## Task Completion Report
-- **Status**: FAILED
-- **Platform**: {platform_id}
-- **Project Root**: {project_root}
-- **Start Command**: {start_cmd}
-- **Health URL**: {health_url}
-- **Error Category**: {DEPENDENCY_MISSING | RUNTIME_ERROR}
-- **Error**: {detailed error description}
-- **Startup Log** (last 30 lines):
-```
-{last_30_lines_of_application_log}
-```
-- **Recovery Hint**: {suggestion for resolving the issue}
-```
-
-# Important Notes
-
-- **Application runs in BACKGROUND** — it must remain running for subsequent smoke test
-- **PID must be reported** — the Deploy Agent uses this for cleanup later
-- **Health check uses curl** — cross-platform availability may vary; ensure curl is available
-- **Default timeout is 60s** — adjust health_timeout parameter for slower-starting applications
-- **Process monitoring** — verify the application process is still running after health check
-
-# Key Rules
-
-| Rule | Description |
-|------|-------------|
-| **Background Execution** | Application must start in background and continue running |
-| **PID Recording** | Always record and report the process PID |
-| **Health Polling** | Poll health endpoint every 5 seconds until success or timeout |
-| **Timeout Configurable** | health_timeout parameter controls maximum wait time |
-| **Process Verification** | Verify application process is still running after health check |
+> **REQUIRED**: Before executing this workflow, read the XML workflow specification: speccrew-workspace/docs/rules/agentflow-spec.md
+> Then read and execute the XML workflow in SKILL.xml block-by-block as the authoritative execution plan.