bmad-module-skill-forge 1.9.0 → 2.0.1

package/src/skf-campaign/references/step-08-verify.md

@@ -0,0 +1,75 @@
+---
+nextStepFile: 'step-09-refine.md'
+stateSchemaFile: 'assets/campaign-state-schema.json'
+stateFile: '{campaignWorkspacePath}/_campaign-state.yaml'
+backupFile: '{campaignWorkspacePath}/_campaign-state.yaml.bak'
+validateScript: 'scripts/campaign-validate-state.py'
+---
+
+<!-- Config: communicate in {communication_language}. -->
+
+# Verify
+
+## STEP GOAL:
+
+Invoke VS (skf-verify-stack) in headless mode against all completed campaign skills to produce a feasibility report. The report cross-references generated skills against the project's architecture document, providing coverage analysis and integration verdicts for operator review.
+
+## RULES
+
+- This step uses the **read-backup-modify-write** pattern.
+- Validate state on load via `uv run {validateScript} --state-file {stateFile}`; HALT (exit 3) on non-zero.
+- Update `campaign.last_updated` to current ISO-8601 with timezone on every write.
+- Update `campaign.current_stage` to `7`.
+- If `{headless_mode}` is true, auto-proceed through confirmation gates. VS supports headless via `--headless`.
+
+## TASKS
+
+### §1 — Read + Validate State
+
+Load `{stateFile}`. Run `uv run {validateScript} --state-file {stateFile}`; on non-zero, HALT (exit 3) with the script's `errors[]`.
+
+### §2 — Read Directive
+
+If `campaign.directive_path` is set in state, load the file at that path and apply its contents as campaign-wide context for this stage's processing, per the directive contract in `references/campaign-directive-spec.md`. If the file is not found, continue without error (directive is optional).
+
+### §3 — Locate Architecture Doc
+
+Resolve the architecture document path, preferring the value persisted in state:
+
+1. If `campaign.architecture_doc_path` is set in state and the file exists, use it directly.
+2. Otherwise discover it: check `docs/architecture.md` at `{project-root}` (SKF convention), then `_bmad-output/planning-artifacts/architecture.md` (BMM convention).
+3. If still not found and `{headless_mode}` is false: prompt the operator to provide the architecture doc path.
+4. If still not found and `{headless_mode}` is true: skip VS invocation with a warning — do not HALT. Log that verification was skipped due to missing architecture doc (to the decision log) and proceed to §6.
+
+Once resolved (steps 2–3), persist the path to `campaign.architecture_doc_path` so the refine stage and any resume reuse it without re-prompting. Then proceed to §4 with the resolved path.
+
+### §4 — Invoke VS
+
+Invoke `skf-verify-stack` with `--headless --architecture-doc <path>`, where `<path>` is the architecture doc discovered in §3.
+
+VS discovers skills from its own configured `{skills_output_folder}` — the campaign does NOT pass individual skill paths. Capture the result envelope from stdout:
+
+```
+SKF_VERIFY_STACK_RESULT_JSON: {"status":"…","report_path":"…","report_latest_path":"…","overall_verdict":"…","coverage_percentage":0,"recommendation_count":0,"exit_code":0,"halt_reason":null}
+```
+
+### §5 — Handle VS Outcome
+
+**On success** (exit code 0): persist the summary to `campaign.verification` (detailed findings stay in the external report):
+
+- `campaign.verification.report_path` — `report_latest_path` from the envelope
+- `campaign.verification.overall_verdict` — one of `Verified`, `Plausible`, `Risky`, `Blocked`
+- `campaign.verification.coverage_percentage` — from the envelope
+- `campaign.verification.recommendation_count` — from the envelope
+
+Also set `campaign.capstone.verified` to `true` when `overall_verdict == "Verified"`, otherwise `false` (only if a `campaign.capstone` entry exists from step-07).
+
+**On VS failure** (non-zero exit): log the error (exit code and halt_reason from the envelope or stderr). Verification failure does NOT block the campaign — it produces diagnostic information for operator review. Leave `campaign.verification` unset (or null). Continue to §6 regardless of outcome.
+
+### §6 — Stage Completion
+
+Set `campaign.current_stage` to `7`. Update `campaign.last_updated` to current ISO-8601 with timezone. Backup `{stateFile}` to `{backupFile}`, then write the updated state (including `campaign.architecture_doc_path` from §3 and `campaign.verification` from §5).
+
+## OUTPUT
+
+Display verification summary: overall verdict (or "skipped" if architecture doc was not found), report path (if produced), and coverage percentage. Chain to `{nextStepFile}`.

package/src/skf-campaign/references/step-09-refine.md

@@ -0,0 +1,83 @@
+---
+nextStepFile: 'step-10-export.md'
+stateSchemaFile: 'assets/campaign-state-schema.json'
+stateFile: '{campaignWorkspacePath}/_campaign-state.yaml'
+backupFile: '{campaignWorkspacePath}/_campaign-state.yaml.bak'
+validateScript: 'scripts/campaign-validate-state.py'
+---
+
+<!-- Config: communicate in {communication_language}. -->
+
+# Refine
+
+## STEP GOAL:
+
+Invoke RA (skf-refine-architecture) in headless mode with the project's architecture document and VS feasibility report to produce a refined architecture. RA identifies gaps, issues, and improvements based on the generated skills and applies them to the architecture document.
+
+## RULES
+
+- This step uses the **read-backup-modify-write** pattern.
+- Validate state on load via `uv run {validateScript} --state-file {stateFile}`; HALT (exit 3) on non-zero.
+- Update `campaign.last_updated` to current ISO-8601 with timezone on every write.
+- Update `campaign.current_stage` to `8`.
+- If `{headless_mode}` is true, auto-proceed through confirmation gates. RA supports headless via `--headless`.
+
+## TASKS
+
+### §1 — Read + Validate State
+
+Load `{stateFile}`. Run `uv run {validateScript} --state-file {stateFile}`; on non-zero, HALT (exit 3) with the script's `errors[]`.
+
+### §2 — Read Directive
+
+If `campaign.directive_path` is set in state, load the file at that path and apply its contents as campaign-wide context for this stage's processing, per the directive contract in `references/campaign-directive-spec.md`. If the file is not found, continue without error (directive is optional).
+
+### §3 — Locate Inputs
+
+**Architecture doc:** Use the same resolution strategy as step-08:
+
+1. If `campaign.architecture_doc_path` is set in state and the file exists, use it directly (step-08 normally persists it).
+2. Otherwise check `docs/architecture.md` at `{project-root}`, then `_bmad-output/planning-artifacts/architecture.md`.
+3. If still not found and `{headless_mode}` is false: prompt the operator.
+4. If still not found and `{headless_mode}` is true: skip RA invocation with a warning — do not HALT. Log that refinement was skipped due to missing architecture doc (to the decision log) and proceed to §6.
+
+Once resolved (steps 2–3), persist the path to `campaign.architecture_doc_path` if not already set, then proceed to §4 with the resolved path.
+
+**VS feasibility report:** If chaining from step-08, the report path is available from the VS result envelope (`report_latest_path`). On resume, look for `feasibility-report-*-latest.md` in `{forge_data_folder}/`. If no report exists (VS may have failed or been skipped in step-08), proceed without it — RA's VS report input is optional.
+
+### §4 — Invoke RA
+
+Invoke `skf-refine-architecture` with:
+
+```
+skf-refine-architecture --headless --architecture-doc <arch_path> [--vs-report-path <report_path>] [--scope-skills <names>]
+```
+
+- `--architecture-doc`: the architecture doc discovered in §3 (required).
+- `--vs-report-path`: the VS feasibility report path from §3 (omit if not found).
+- `--scope-skills`: comma-separated names of completed campaign skills (from `skills[]` where `status == "completed"`). Optional but improves focus by limiting refinement scope to campaign-relevant skills.
+
+Capture the result envelope from stdout:
+
+```
+SKF_REFINE_ARCHITECTURE_RESULT_JSON: {"status":"…","refined_path":"…","gap_count":0,"issue_count":0,"improvement_count":0,"exit_code":0,"halt_reason":null}
+```
+
+### §5 — Handle RA Outcome
+
+**On success** (exit code 0): persist the summary to `campaign.refinement` (the refined document itself lives at `refined_path`):
+
+- `campaign.refinement.refined_path` — from the envelope
+- `campaign.refinement.gap_count` — from the envelope
+- `campaign.refinement.issue_count` — from the envelope
+- `campaign.refinement.improvement_count` — from the envelope
+
+**On RA failure** (non-zero exit): log the error (exit code and halt_reason from the envelope or stderr). Refinement failure does NOT block the campaign — the campaign continues to export with whatever state exists. Leave `campaign.refinement` unset (or null). Continue to §6 regardless of outcome.
+
+### §6 — Stage Completion
+
+Set `campaign.current_stage` to `8`. Update `campaign.last_updated` to current ISO-8601 with timezone. Backup `{stateFile}` to `{backupFile}`, then write the updated state (including `campaign.refinement` from §5).
+
+## OUTPUT
+
+Display refinement summary: refined architecture path (or "skipped" if architecture doc was not found), gap count, issue count, and improvement count. Chain to `{nextStepFile}`.

package/src/skf-campaign/references/step-10-export.md

@@ -0,0 +1,106 @@
+---
+nextStepFile: 'step-11-maintenance.md'
+stateSchemaFile: 'assets/campaign-state-schema.json'
+stateFile: '{campaignWorkspacePath}/_campaign-state.yaml'
+backupFile: '{campaignWorkspacePath}/_campaign-state.yaml.bak'
+validateScript: 'scripts/campaign-validate-state.py'
+---
+
+<!-- Config: communicate in {communication_language}. -->
+
+# Export
+
+## STEP GOAL:
+
+Present all completed skills for operator review and gate the export behind explicit confirmation. This is the only campaign step that requires manual approval before proceeding — no files are written until the operator confirms.
+
+## RULES
+
+- This step uses the **read-backup-modify-write** pattern.
+- Validate state on load via `uv run {validateScript} --state-file {stateFile}`; HALT (exit 3) on non-zero.
+- Update `campaign.last_updated` to current ISO-8601 with timezone on every write.
+- Update `campaign.current_stage` to `9`.
+- If `{headless_mode}` is true, auto-proceed past the write-gate with `[E]` and log: "headless: auto-proceed past export write-gate".
+
+## TASKS
+
+### §1 — Read + Validate State
+
+Load `{stateFile}`. Run `uv run {validateScript} --state-file {stateFile}`; on non-zero, HALT (exit 3) with the script's `errors[]`.
+
+### §2 — Read Directive
+
+If `campaign.directive_path` is set in state, load the file at that path and apply its contents as campaign-wide context for this stage's processing, per the directive contract in `references/campaign-directive-spec.md`. If the file is not found, continue without error (directive is optional).
+
+### §3 — Collect Export Candidates
+
+Gather all skills from `skills[]` with `status == "completed"`. These are the export candidates.
+
+If no completed skills exist, display a warning and proceed directly to §6 (stage completion) — there is nothing to export.
+
+Present a summary table of export candidates:
+
+| # | Name | Tier | Quality Score | Skill Path |
+|---|------|------|---------------|------------|
+| 1 | {name} | {tier} | {quality_score} | {skill_path} |
+| ... | ... | ... | ... | ... |
+
+Display: "**{N} skill(s) ready for export.**"
+
+### §4 — Write-Gate HALT
+
+Present the export confirmation gate:
+
+"**Export Gate — Confirm before writing files**
+
+{N} completed skill(s) will be exported via `skf-export-skill`:
+
+{summary table from §3}
+
+- **[E]xport all** — invoke `skf-export-skill` for each completed skill
+- **[C]ancel** — halt the campaign gracefully (no files written, resume later)
+
+Choose [E] or [C]:"
+
+**HALT and wait for operator input.**
+
+**Headless mode:** auto-proceed with `[E]` and log: "headless: auto-proceed past export write-gate".
+
+#### On `[C]ancel`:
+
+Display: "Export cancelled by operator. Campaign halted gracefully — no files written. Resume later to retry export."
+
+Log the cancellation to the decision log, then HALT with exit code 11 (`export-cancelled`). Do NOT mark the campaign as failed — this is a graceful, resumable halt; the operator may resume later.
+
+#### On `[E]xport`:
+
+Log the export decision to the decision log, then proceed to §5.
+
+### §5 — Invoke EX
+
+For each completed skill (from §3), invoke `skf-export-skill` in headless mode:
+
+```
+skf-export-skill {skill_name} --headless
+```
+
+Capture the result envelope `SKF_EXPORT_RESULT_JSON` per skill.
+
+**On per-skill EX success** (exit code 0): log the result and continue.
+
+**On per-skill EX failure** (non-zero exit): log the error (exit code, envelope if available, or stderr). Continue with remaining skills — per-skill failure does not block remaining exports.
+
+After all exports complete, display a summary:
+
+"**Export Results:**
+- Exported: {success_count} skill(s)
+- Failed: {fail_count} skill(s)
+{list of failed skills if any}"
+
+### §6 — Stage Completion
+
+Set `campaign.current_stage` to `9`. Update `campaign.last_updated` to current ISO-8601 with timezone. Backup `{stateFile}` to `{backupFile}`, then write the updated state.
+
+## OUTPUT
+
+Display export summary: skills exported count, failures count (if any), and per-skill results. Chain to `{nextStepFile}`.

package/src/skf-campaign/references/step-11-maintenance.md

@@ -0,0 +1,84 @@
+---
+nextStepFile: 'health-check.md'
+stateSchemaFile: 'assets/campaign-state-schema.json'
+stateFile: '{campaignWorkspacePath}/_campaign-state.yaml'
+backupFile: '{campaignWorkspacePath}/_campaign-state.yaml.bak'
+reportFile: '{campaignWorkspacePath}/campaign-report.md'
+reportScript: 'scripts/campaign-report.py'
+reportTemplate: '{reportTemplatePath}'
+validateScript: 'scripts/campaign-validate-state.py'
+---
+
+<!-- Config: communicate in {communication_language}. -->
+
+# Maintenance
+
+## STEP GOAL:
+
+Generate a comprehensive campaign report from the accumulated state, emit the headless result envelope, and chain to the shared health check as the campaign's terminal step.
+
+## RULES
+
+- This step uses the **read-backup-modify-write** pattern.
+- Validate state on load via `uv run {validateScript} --state-file {stateFile}`; HALT (exit 3) on non-zero.
+- Update `campaign.last_updated` to current ISO-8601 with timezone on every write.
+- Update `campaign.current_stage` to `10`.
+- If `{headless_mode}` is true, auto-proceed through confirmation gates. Emit the headless envelope on stdout.
+
+## TASKS
+
+### §1 — Read + Validate State
+
+Load `{stateFile}`. Run `uv run {validateScript} --state-file {stateFile}`; on non-zero, HALT (exit 3) with the script's `errors[]`.
+
+### §2 — Generate Campaign Report
+
+Invoke the campaign report script:
+
+```
+uv run {reportScript} \
+    --state-file {stateFile} \
+    --template-file {reportTemplate} \
+    --output-file {reportFile}
+```
+
+Capture the JSON result from stdout — it carries `skills_completed`, `skills_failed`, `quality_scores`, and `duration` already computed. Do not recompute these by hand in §3.
+
+**On success** (exit code 0): log the report path and summary stats from the result JSON.
+
+**On failure** (exit code 2): the campaign itself has already completed — do NOT discard it over a missing summary artifact. Display the error from stderr, log "report generation failed (degraded): {error}" to the decision log, set the envelope's `campaign_report_path` to `null`, and CONTINUE to §3. Surface `report-failure` only as a degraded signal in the envelope (`status:"error"`, `exit_code:10`), never as a hard halt that throws away a finished campaign.
+
+Display: "**Campaign report generated:** `{reportFile}`" (or, on degrade, "**Campaign complete — report generation failed (see decision log); state is intact.**")
+
+**Optional post-completion hook:** if `{onComplete}` (resolved in On Activation) is non-empty, invoke `{onComplete} --report-path={reportFile}`. Log the outcome to the decision log; a hook failure is recorded but never fails the campaign.
+
+### §3 — Emit Headless Envelope
+
+When `{headless_mode}` is true, emit the campaign result envelope on stdout, copying the counts, `quality_scores`, and `duration` straight from the §2 report-script result (do not recompute):
+
+```
+SKF_CAMPAIGN_RESULT_JSON: {"status":"success","skills_completed":N,"skills_failed":N,"quality_scores":{...},"campaign_report_path":"{reportFile}","decision_log":"{campaignWorkspacePath}/_campaign-decision-log.md","duration":"..."}
+```
+
+- `status`: "success" if the campaign completed normally (HARD HALTs emit the error variant per the "Result Contract on HARD HALT" in `references/campaign-contracts.md`)
+- `skills_completed` / `skills_failed` / `quality_scores` / `duration`: from the §2 report-script result JSON
+- `campaign_report_path`: `{reportFile}`
+- `decision_log`: path to the append-only decision log
+
+When not in headless mode, skip this section silently.
+
+### §4 — Stage Completion
+
+Set `campaign.current_stage` to `10`. Update `campaign.last_updated` to current ISO-8601 with timezone. Backup `{stateFile}` to `{backupFile}`, then write the updated state.
+
+### §5 — Chain to Health Check
+
+The operator's findings-routing consent (`campaign.health_findings_queue`) is applied by the terminal health-check step: `references/health-check.md` §1 reads it from state and carries it into the shared health check as the pre-decided opt-in (`"improvement"` → route non-bug findings to the shared improvement queue without re-prompting; `"local"` → local queue only). Surface the active setting here.
+
+Display: "**Campaign complete.** Report at `{reportFile}`. Findings routing: {campaign.health_findings_queue}. Chaining to health check..."
+
+Chain to `{nextStepFile}` (shared/health-check.md).
+
+## OUTPUT
+
+Display campaign completion summary: skills completed, skills failed, report path, total duration. Chain to `{nextStepFile}`.

package/src/skf-campaign/references/step-resume.md

@@ -0,0 +1,115 @@
+---
+stateSchemaFile: 'assets/campaign-state-schema.json'
+stateFile: '{campaignWorkspacePath}/_campaign-state.yaml'
+backupFile: '{campaignWorkspacePath}/_campaign-state.yaml.bak'
+validateScript: 'scripts/campaign-validate-state.py'
+statusScript: 'scripts/campaign-status.py'
+---
+
+<!-- Config: communicate in {communication_language}. -->
+
+# Resume
+
+## STEP GOAL:
+
+Validate campaign state integrity, determine the resume point, and chain to the appropriate stage step file. This is a read-only routing step — it does not modify state.
+
+## RULES
+
+- This step is **read-only by default** — it does NOT modify `{stateFile}` except in the one recovery case below (restoring a valid `.bak` over a corrupt primary), which is the State Contract's advertised safety net.
+- Validate state on load via `uv run {validateScript} --state-file {stateFile}`; the recovery path in §1 governs what happens on failure.
+- The chain target is determined dynamically from state — there is no fixed `nextStepFile`.
+- If `{headless_mode}` is true, auto-proceed through any confirmation gates with the default action and log each auto-decision.
+
+## TASKS
+
+### §1 — Read + Validate State (with `.bak` recovery)
+
+Load `{stateFile}`. If the file does not exist, HALT (exit code 2, `invalid-input`): "No campaign state found. Run `campaign` to start a new campaign."
+
+Run `uv run {validateScript} --state-file {stateFile}`. If it succeeds (exit 0), proceed to §2.
+
+If it fails (primary missing/corrupt YAML/schema-invalid), **attempt automatic recovery from the backup** rather than dead-halting — this is exactly the crash-during-write case the State Contract promises `.bak` covers:
+
+1. If `{backupFile}` exists, run `uv run {validateScript} --state-file {backupFile}`.
+2. If the backup is valid: copy `{backupFile}` over `{stateFile}`, log to the decision log "primary corrupt — recovered from backup as of {bak.last_updated}", inform the operator, and continue with the recovered state.
+3. If the backup is missing or also invalid: HALT with exit code 9 (`corrupt-state`), reporting both the primary and backup validation errors so the operator knows neither is usable.
+
+### §2 — Backup Consistency Check
+
+Check if `{backupFile}` exists.
+
+**If `.bak` does not exist:** warn "No backup file found — campaign may have been created but never modified." Continue.
+
+**If `.bak` exists** (and §1 did not already recover from it):
+
+1. Run `uv run {validateScript} --state-file {backupFile}`. If invalid, warn: "Backup file fails validation — cannot use for recovery." Continue with the primary.
+2. Compare primary vs backup deterministically: run `uv run {statusScript} --state-file {stateFile} --backup-file {backupFile}` and read `backup_comparison.primary_behind` (the script does the ISO-8601 timestamp and `current_stage` compares — do not order the timestamps by hand). If it is `true`, the primary looks behind the backup (possible crash during last write). Present a recovery choice:
+   - `[R]ecover` — copy `{backupFile}` over `{stateFile}` and resume from the backup's state.
+   - `[K]eep` — keep the primary as authoritative (the default).
+
+   In headless mode, default to `[K]eep` and log the auto-decision (a behind-backup primary may be intentional; never silently overwrite without a clear corruption signal — that case is handled in §1). Otherwise the primary is authoritative.
+
+### §3 — Determine Resume Point
+
+Two paths based on whether `--from=<skill>` was provided in the invocation:
+
+**With `--from=<skill>`:**
+
+1. Find the named skill in `skills[]` by `name`.
+2. If not found → HALT (exit code 2, `invalid-input`): "Unknown skill '{name}'. Known skills: {comma-separated list of all skill names from state}."
+3. If the skill's `status` is `"completed"`, `"failed"`, or `"skipped"`, the operator may have meant to re-run it (e.g. it passed with a low score) rather than skip past it. Present a choice:
+   - `[R]e-run` — reset the named skill to `"pending"` and resume from its stage. (Read-only step caveat: this single status reset follows read-backup-modify-write — back up first.)
+   - `[N]ext` — find the next skill in `dependency_graph.execution_order` after the named one whose `status` is `"pending"` or `"active"` and resume there. If none found → HALT (exit code 0, campaign already complete): "All remaining skills are complete. Run `campaign` to start a new campaign."
+   - `[H]alt` — stop without resuming.
+
+   In headless mode, default to `[N]ext` and log the auto-decision. Log the chosen action to the decision log.
+4. If an active skill already exists in `skills[]` AND it is a different skill from the `--from` target, warn: "Skill '{active_name}' is currently active — honoring explicit --from override."
+5. Determine the target step file:
+   - Tier A skill with status `"pending"` or `"active"` → stage 4 (`step-05-skill-loop.md`)
+   - Tier B skill with status `"pending"` or `"active"` → stage 5 (`step-06-batch.md`)
+
+**Without `--from`:**
+
+1. Scan `skills[]` for any skill with `status == "active"`.
+   - If found and `tier == "A"` → resume target is stage 4 (`step-05-skill-loop.md`). The skill loop's §4 will skip completed skills until it reaches the active one.
+   - If found and `tier == "B"` → resume target is stage 5 (`step-06-batch.md`). The batch step processes Tier B skills.
+2. If no active skill → the next stage to run is `campaign.current_stage + 1`, because `current_stage` records the highest **completed** stage (each stage writes its own number only after its work and gates finish, so a mid-stage halt leaves the previous stage's number on disk). **Terminal cap:** if `campaign.current_stage` is `10`, the resolved stage is `10` itself (`step-11-maintenance.md`) — never `11`; the existing terminal-HALT check in §4 governs whether a stage-10 campaign is already done.
+3. Map the resolved stage number to the corresponding step file using the stage table in §4.
+
+### §4 — Resume Routing
+
+Map the resolved stage number to its step file. Both §3 branches feed this table an **already-resolved** stage number: the active-skill branch supplies stage 4 or 5 directly (and BYPASSES the `+1`), while the no-active-skill branch supplies `current_stage + 1` (terminal-capped at 10). Do not apply the `+1` again here.
+
+| Stage | Step File |
+|-------|-----------|
+| 0 | step-01-setup.md |
+| 1 | step-02-strategy.md |
+| 2 | step-03-pins.md |
+| 3 | step-04-provenance.md |
+| 4 | step-05-skill-loop.md |
+| 5 | step-06-batch.md |
+| 6 | step-07-capstone.md |
+| 7 | step-08-verify.md |
+| 8 | step-09-refine.md |
+| 9 | step-10-export.md |
+| 10 | step-11-maintenance.md |
+
+Derive the skill counts deterministically — `uv run {statusScript} --state-file {stateFile}` returns `completed`, `total`, and the per-status counts (`pending` / `active` / `failed` / `skipped`); do not hand-count `skills[]`. Display a resume summary before chaining:
+
+```
+CAMPAIGN RESUME: {campaign.name}
+
+  Resuming from: Stage {stage_number} — {stage_name}
+  Target skill:  {skill_name} (if --from was used, otherwise "auto-detected" or "N/A")
+  Skills completed: {completed} / {total}
+  Skills remaining: {pending} pending, {active} active, {failed} failed, {skipped} skipped
+  Last updated:  {campaign.last_updated}
+```
+
+If `campaign.current_stage` is `10` and all skills have status `"completed"`, `"failed"`, or `"skipped"`:
+HALT (exit code 0, campaign already complete): "Campaign has reached its final stage. All skills have been processed."
+
+## OUTPUT
+
+Chain to the determined step file.