bmad-module-skill-forge 1.8.0 → 2.0.0

package/src/skf-campaign/assets/campaign-state-schema.json

@@ -0,0 +1,191 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "campaign-state",
+  "description": "Schema for _campaign-state.yaml — single source of truth for campaign orchestration state",
+  "type": "object",
+  "required": ["campaign", "skills", "dependency_graph"],
+  "additionalProperties": false,
+  "properties": {
+    "campaign": {
+      "type": "object",
+      "required": ["name", "started_at", "last_updated", "current_stage", "quality_gate", "health_findings_queue"],
+      "additionalProperties": false,
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "started_at": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "last_updated": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "current_stage": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 10
+        },
+        "directive_path": {
+          "type": "string"
+        },
+        "quality_gate": {
+          "type": "object",
+          "required": ["hard", "soft_target", "soft_fallback"],
+          "additionalProperties": false,
+          "properties": {
+            "hard": {
+              "type": "string"
+            },
+            "soft_target": {
+              "type": "number"
+            },
+            "soft_fallback": {
+              "type": "number"
+            }
+          }
+        },
+        "health_findings_queue": {
+          "type": "string",
+          "enum": ["local", "improvement"]
+        },
+        "architecture_doc_path": {
+          "type": ["string", "null"],
+          "description": "Path to the architecture document consumed by the verify (Stage 7) and refine (Stage 8) stages. Sourced at setup; null when the campaign runs no verification."
+        },
+        "capstone": {
+          "type": ["object", "null"],
+          "additionalProperties": false,
+          "description": "Capstone (stack) outcome composed from all completed campaign skills (Tier A and Tier B). Campaign-level summary; the composed skill itself lives at skill_path.",
+          "properties": {
+            "skill_path": {
+              "type": ["string", "null"]
+            },
+            "quality_score": {
+              "type": ["number", "null"]
+            },
+            "verified": {
+              "type": ["boolean", "null"]
+            },
+            "completed_at": {
+              "type": ["string", "null"],
+              "format": "date-time"
+            }
+          }
+        },
+        "verification": {
+          "type": ["object", "null"],
+          "additionalProperties": false,
+          "description": "Stage 7 verify-stack summary. Detailed findings live in the external report at report_path.",
+          "properties": {
+            "report_path": {
+              "type": ["string", "null"]
+            },
+            "overall_verdict": {
+              "type": ["string", "null"],
+              "enum": ["Verified", "Plausible", "Risky", "Blocked", null]
+            },
+            "coverage_percentage": {
+              "type": ["number", "null"]
+            },
+            "recommendation_count": {
+              "type": ["integer", "null"]
+            }
+          }
+        },
+        "refinement": {
+          "type": ["object", "null"],
+          "additionalProperties": false,
+          "description": "Stage 8 refine-architecture summary. The refined document lives at refined_path.",
+          "properties": {
+            "refined_path": {
+              "type": ["string", "null"]
+            },
+            "gap_count": {
+              "type": ["integer", "null"]
+            },
+            "issue_count": {
+              "type": ["integer", "null"]
+            },
+            "improvement_count": {
+              "type": ["integer", "null"]
+            }
+          }
+        }
+      }
+    },
+    "skills": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["name", "status", "tier"],
+        "additionalProperties": false,
+        "properties": {
+          "name": {
+            "type": "string"
+          },
+          "status": {
+            "type": "string",
+            "enum": ["pending", "active", "completed", "failed", "skipped"]
+          },
+          "depends_on": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "tier": {
+            "type": "string",
+            "enum": ["A", "B"]
+          },
+          "pin": {
+            "type": ["string", "null"]
+          },
+          "brief_path": {
+            "type": ["string", "null"]
+          },
+          "skill_path": {
+            "type": ["string", "null"]
+          },
+          "quality_score": {
+            "type": ["number", "null"]
+          },
+          "workarounds_applied": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "started_at": {
+            "type": ["string", "null"],
+            "format": "date-time"
+          },
+          "completed_at": {
+            "type": ["string", "null"],
+            "format": "date-time"
+          },
+          "commit_sha": {
+            "type": ["string", "null"]
+          }
+        }
+      }
+    },
+    "dependency_graph": {
+      "type": "object",
+      "required": ["execution_order", "circular_deps_detected"],
+      "additionalProperties": false,
+      "properties": {
+        "execution_order": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "circular_deps_detected": {
+          "type": "boolean"
+        }
+      }
+    }
+  }
+}

package/src/skf-campaign/customize.toml

@@ -0,0 +1,73 @@
+# DO NOT EDIT -- overwritten on every update.
+#
+# Workflow customization surface for skf-campaign.
+
+[workflow]
+
+# --- Configurable below. Overrides merge per BMad structural rules: ---
+#   scalars: override wins • arrays (persistent_facts, activation_steps_*): append
+#   arrays-of-tables with `code`/`id`: replace matching items, append new ones.
+
+# Steps to run before the standard activation (config load, customization
+# resolve). Overrides append. Use for org-wide pre-flight checks (auth,
+# network, compliance) that must precede any orchestration work.
+
+activation_steps_prepend = []
+
+# Steps to run after activation but before the first stage executes.
+# Overrides append. Use for context loads or banner customization that
+# should run once activation completes successfully.
+
+activation_steps_append = []
+
+# Persistent facts the workflow keeps in mind for the whole campaign
+# (house style, naming conventions, quality guardrails). These are injected
+# into every per-skill kickoff, so project-scoped house facts propagate to
+# the whole campaign. Overrides append.
+#
+# Each entry is either:
+#   - a literal sentence, e.g. "All skills must cite their upstream source."
+#   - a file reference prefixed with `file:`, e.g.
+#     "file:{project-root}/docs/skill-style.md" (globs supported; file
+#     contents are loaded and treated as facts).
+
+persistent_facts = [
+  "file:{project-root}/**/project-context.md",
+]
+
+# --- Workspace path ---
+#
+# Where the campaign keeps its state, backup, brief, batch input, archive,
+# and decision log. Empty string = use the bundled default
+# `{forge_data_folder}/_campaign`. Override to relocate campaign artifacts
+# (e.g. a shared volume) without editing every step file. Resolved once in
+# On Activation as {campaignWorkspacePath}.
+
+campaign_workspace_path = ""
+
+# --- Quality gate ---
+#
+# Campaign-wide quality bar applied to every skill. Scalars override the
+# bundled defaults; the per-campaign brief and any directive `## Quality
+# Overrides` still take precedence at runtime. Override here to change the
+# org-wide default without forking the skill.
+
+quality_gate_hard = "zero-critical-high"
+quality_gate_soft_target = 90
+quality_gate_soft_fallback = 80
+
+# --- Optional template overrides ---
+#
+# Lift the canonical template paths so orgs can substitute house-style copies
+# without forking the skill. Empty string = use the bundled default under
+# `templates/`.
+
+report_template_path = ""
+kickoff_template_path = ""
+brief_template_path = ""
+
+# Optional post-completion hook. When non-empty, the workflow invokes:
+#   <on_complete> --report-path=<path-to-campaign-report.md>
+# after the campaign report is finalized (step-11). Failures are logged to
+# the decision log but never fail the campaign. Empty = no-op.
+on_complete = ""

package/src/skf-campaign/manifest.yaml

@@ -0,0 +1,11 @@
+code: CA
+name: skf-campaign
+description: "Campaign orchestration — multi-library skill production with dependency tracking"
+version: "2.0.0"
+trigger: campaign
+parent_module: skf
+
+config:
+  state_file: "_campaign-state.yaml"
+  backup_file: "_campaign-state.yaml.bak"
+  directive_file: "_campaign-directive.md"

package/src/skf-campaign/references/campaign-directive-spec.md

@@ -0,0 +1,121 @@
+---
+stateFile: '{campaignWorkspacePath}/_campaign-state.yaml'
+directiveFile: '_campaign-directive.md'
+---
+
+# Campaign Directive Specification
+
+This is the **canonical contract** for the campaign directive. SKILL.md and the
+step files' "Read Directive" sections defer to it rather than re-specifying the
+format — when a step loads `campaign.directive_path`, it applies the contents
+per the sections below.
+
+## Purpose
+
+The campaign directive (`_campaign-directive.md`) is a file-based standing directive that provides campaign-wide policy persisting across context boundaries. It is:
+
+- **Human-readable** — plain markdown, editable with any text editor
+- **Auditable** — version-controllable alongside campaign artifacts
+- **Context-boundary safe** — re-read from disk at each stage transition, with no dependency on LLM memory (NFR-2)
+
+The directive allows the operator to adjust campaign-wide policy without editing the state file or relying on LLM memory.
+
+## File Format
+
+- **Encoding:** UTF-8 markdown
+- **Frontmatter:** not required (plain content is sufficient)
+- **Location:** the path specified by `campaign.directive_path` in the campaign state file
+- **Default filename:** `_campaign-directive.md` (configured in `manifest.yaml` as `config.directive_file`)
+
+## Recognized Sections
+
+All sections are optional. The directive may contain any combination of these, or none at all.
+
+### `## Quality Overrides`
+
+Operator adjustments to quality gates for specific skills or the entire campaign.
+
+Example:
+```markdown
+## Quality Overrides
+
+- Accept 85% for library-x due to incomplete upstream docs
+- Lower soft gate to 70% for experimental-sdk (early-stage repo)
+```
+
+### `## Skip List`
+
+Skills to skip during processing, with rationale.
+
+Example:
+```markdown
+## Skip List
+
+- Skip library-y — upstream repo is in maintenance mode
+- Skip legacy-tool — will be removed in next sprint
+```
+
+### `## Pipeline Flags`
+
+Per-skill or campaign-wide pipeline modifiers.
+
+Example:
+```markdown
+## Pipeline Flags
+
+- Use `--pin main` for all unpinned skills
+- Force forge-auto mode for large-repo-z
+```
+
+### `## Notes`
+
+Free-form operator context for the LLM agent processing the campaign.
+
+Example:
+```markdown
+## Notes
+
+Focus on documentation quality this run — the team is preparing for an external audit.
+Prioritize skills that feed into the public API layer.
+```
+
+## Unrecognized Sections
+
+Any section heading not listed above is treated as general guidance. The LLM agent reads and applies judgment based on the content. This allows operators to add ad-hoc context without modifying the specification.
+
+## Read Contract
+
+The directive is read from the path stored in `campaign.directive_path` (in the campaign state file) at stage entry. Every step that loads state and performs actionable processing checks for and applies the directive.
+
+Steps that read the directive:
+- **step-02-strategy** — applies directive contents as campaign-wide context for strategy processing (e.g. `## Notes` visible while reviewing the computed order; the order itself is computed deterministically by `campaign-deps.py`)
+- **step-05-skill-loop** — directive populates `{{directive_content}}` in kickoff template and provides campaign-wide context for all skill processing
+- **step-06-batch** — operator may want skip/quality overrides for Tier B batch processing
+- **step-08-verify** — operator may want to influence verification focus areas
+- **step-09-refine** — operator may want to guide refinement priorities
+- **step-10-export** — operator may want to exclude specific skills from export
+
+Steps that do NOT read the directive:
+- **step-01-setup** — creates the state file; `directive_path` is collected as input, not read
+- **step-03-pins** — pin validation is deterministic (Python script); directive cannot influence gh API calls
+- **step-04-provenance** — repo access verification is deterministic; directive cannot influence commit SHA recording
+- **step-07-capstone** — SS compose-mode is mechanical aggregation; no operator policy applies
+- **step-11-maintenance** — report generation is templated; health check is autonomous
+- **step-resume** — routing step, not a processing step
+
+## Absence Behavior
+
+- If `campaign.directive_path` is not set in the state file: no error, proceed with defaults
+- If `campaign.directive_path` is set but the file does not exist at that path: no error, proceed with defaults
+- The directive is always optional — a campaign runs identically without one
+
+## Modification Contract
+
+The operator may edit the directive file at any time between stages. The next stage that reads the directive will pick up the updated version. There is no caching — the directive is always read fresh from disk at stage entry.
+
+## Lifecycle
+
+1. **Created:** before or during Stage 0 (setup) — the operator provides the file path, or it defaults to `_campaign-directive.md`
+2. **Read:** at each stage entry by applicable steps (see Read Contract above)
+3. **Modified:** at any time between stages by the operator
+4. **Consumed:** by the LLM agent as campaign-wide context influencing processing decisions

package/src/skf-campaign/references/health-check.md

@@ -0,0 +1,35 @@
+---
+# Note: `shared/health-check.md` resolves relative to the SKF module root
+# ({project-root}/_bmad/skf/ when installed, {project-root}/src/ during
+# development), NOT relative to this step file.
+nextStepFile: 'shared/health-check.md'
+stateFile: '{campaignWorkspacePath}/_campaign-state.yaml'
+---
+
+<!-- Config: communicate in {communication_language}. -->
+
+# Workflow Health Check
+
+## STEP GOAL:
+
+Apply the operator's findings-routing consent, then chain to the shared workflow self-improvement health check at `{nextStepFile}`. This is the terminal step of skf-campaign — after the shared health check completes, the workflow is fully done.
+
+## Rules
+
+- No user-facing reports, file writes, or result contracts in this step — those belong in step 11.
+- The ONLY processing permitted here is reading the routing preference (below) and carrying it into `{nextStepFile}`; otherwise delegate directly with no additional commentary.
+
+## MANDATORY SEQUENCE
+
+### 1. Apply findings-routing consent
+
+Read `campaign.health_findings_queue` from `{stateFile}` and carry it into the shared health check as the operator's **already-decided** routing consent (so the shared step does not re-prompt, satisfying its "explicit opt-in" requirement for non-bug findings):
+
+- `"improvement"` — the operator opted in at setup: route this campaign's friction/gap findings to the shared improvement queue (the shared step's opt-in is pre-satisfied; do not re-prompt).
+- `"local"` (default) — keep findings in the local queue only; do not submit to the shared queue.
+
+If the state file is unreadable, default to `"local"` (never submit without consent).
+
+### 2. Delegate
+
+Load `{nextStepFile}`, read it fully, then execute it — applying the routing consent from step 1.

package/src/skf-campaign/references/step-01-setup.md

@@ -0,0 +1,122 @@
+---
+nextStepFile: 'step-02-strategy.md'
+stateSchemaFile: 'assets/campaign-state-schema.json'
+stateFile: '{campaignWorkspacePath}/_campaign-state.yaml'
+briefFile: '{campaignWorkspacePath}/campaign-brief.yaml'
+templateFile: '{briefTemplatePath}'
+validateScript: 'scripts/campaign-validate-state.py'
+manifestScript: 'scripts/campaign-parse-manifest.py'
+---
+
+<!-- Config: communicate in {communication_language}. -->
+
+# Setup
+
+## STEP GOAL:
+
+Collect campaign inputs from the operator, create the initial `_campaign-state.yaml`, and generate `campaign-brief.yaml` so the campaign has a persistent starting point that survives context death.
+
+This is the only step that creates the state file (it does not yet exist). All subsequent steps use **read-backup-modify-write** per the State Contract in SKILL.md.
+
+## RULES
+
+- This step creates the state file — there is no existing state to read or back up.
+- Validate the written state with `uv run {validateScript} --state-file {stateFile}` before generating the brief. HALT (exit code 3, `invalid-state`) on non-zero, surfacing the script's `errors[]`.
+- If `{headless_mode}` is true, draw inputs from `--brief`/`--manifest` (On Activation step 4) and auto-proceed through confirmation gates with the default action, logging each auto-decision to the decision log.
+
+## TASKS
+
+### §1 — Collect Inputs
+
+Accept from the operator (or, in headless mode, from the `--brief`/`--manifest` source parsed in On Activation):
+
+- `campaign_name` — string identifier for this campaign run
+- Target libraries — each entry requires:
+  - `name` — skill name
+  - `repo_url` — source repository URL
+  - `tier` — `"A"` (full pipeline) or `"B"` (batch)
+  - `pin` — version pin (string) or `null` for latest
+  - `depends_on` — array of skill names this target depends on (may be empty)
+- `directive_path` (optional) — path to a `_campaign-directive.md` file with operator directives (contract: `references/campaign-directive-spec.md`)
+- `architecture_doc_path` (optional) — path to the architecture document the verify (Stage 7) and refine (Stage 8) stages consume. If omitted here, those stages discover it at runtime (`docs/architecture.md`, then `_bmad-output/planning-artifacts/architecture.md`). Capturing it now persists the choice across resume and avoids re-prompting.
+
+When seeding from `--manifest`, parse it deterministically: `uv run {manifestScript} <manifest-file>`. If the result's `errors[]` is non-empty (exit 1), HALT listing the offending line numbers — never run a partial target set. When seeding from `--brief`, read the existing `campaign-brief.yaml` directly.
+
+If no targets can be collected (empty interactive input or empty `--brief`/`--manifest`), HALT with guidance — a campaign needs at least one target.
+
+### §2 — Health Queue Preference
+
+Default to `"local"` (project-local findings queue). Present the opt-in prompt:
+
+> Send anonymized quality findings to the shared improvement queue? [y/N]
+
+- **y** — set `health_findings_queue` to `"improvement"`
+- **N** (default) — keep `health_findings_queue` as `"local"`
+
+In headless mode: auto-select `"local"` (N) and log the auto-decision.
+
+### §3 — Build State Object
+
+Construct `_campaign-state.yaml` in memory from collected inputs. Use the campaign-wide quality gate resolved in On Activation: `{qualityGateHard}` / `{qualityGateSoftTarget}` / `{qualityGateSoftFallback}`. Note: `repo_url` (collected in §1) is NOT part of the state schema — it belongs in the brief only (§5). The state schema enforces `additionalProperties: false`, so including it would fail validation.
+
+```yaml
+campaign:
+  name: "{campaign_name}"
+  started_at: "{current_iso8601_with_tz}"
+  last_updated: "{current_iso8601_with_tz}"
+  current_stage: 0
+  directive_path: "{directive_path or omit if not provided}"
+  architecture_doc_path: "{architecture_doc_path or omit if not provided}"
+  quality_gate:
+    hard: "{qualityGateHard}"
+    soft_target: {qualityGateSoftTarget}
+    soft_fallback: {qualityGateSoftFallback}
+  health_findings_queue: "{local or improvement}"
+skills:
+  # One entry per target:
+  - name: "{target.name}"
+    status: "pending"
+    depends_on: []            # from target.depends_on
+    tier: "{target.tier}"
+    pin: null                 # from target.pin
+    brief_path: null          # populated in step-05 once BS produces the skill's brief
+    skill_path: null
+    quality_score: null
+    workarounds_applied: []
+    started_at: null
+    completed_at: null
+dependency_graph:
+  execution_order: []         # populated by step-02-strategy
+  circular_deps_detected: false
+```
+
+### §4 — Write + Validate State
+
+1. Ensure the directory `{campaignWorkspacePath}/` exists (create if missing).
+2. Write the constructed state to `{stateFile}`. This is the initial creation — no `.bak` is needed for the first write; all subsequent steps use read-backup-modify-write.
+3. Run `uv run {validateScript} --state-file {stateFile}`. On non-zero (invalid), **HALT** (exit 3) with the script's `errors[]` — do not proceed to brief generation with an invalid state file.
+
+### §5 — Generate Brief
+
+Populate `{templateFile}` with collected inputs and write to `{briefFile}`. Fill in:
+
+- `campaign_name` — from collected input
+- `created_at` — current ISO-8601 timestamp with timezone
+- `targets` — array of target entries with `name`, `repo_url`, `tier`, `pin`, `depends_on`
+- `quality_gate` — `{qualityGateHard}` / `{qualityGateSoftTarget}` / `{qualityGateSoftFallback}`
+- `health_findings_queue` — from the §2 preference decision
+- `architecture_doc_path` — from collected input, or empty string if not provided
+- `notes` — operator-provided context, or empty string
+
+The brief is a machine-readable snapshot enabling fresh-context resume (FR-35).
+
+## OUTPUT
+
+Confirm state file creation and brief generation. Display summary:
+
+- Campaign name
+- Number of targets
+- Tier distribution (count of A vs B)
+- Health queue setting
+
+Chain to `{nextStepFile}`.

package/src/skf-campaign/references/step-02-strategy.md

@@ -0,0 +1,97 @@
+---
+nextStepFile: 'step-03-pins.md'
+stateSchemaFile: 'assets/campaign-state-schema.json'
+stateFile: '{campaignWorkspacePath}/_campaign-state.yaml'
+backupFile: '{campaignWorkspacePath}/_campaign-state.yaml.bak'
+depsScript: 'scripts/campaign-deps.py'
+validateScript: 'scripts/campaign-validate-state.py'
+---
+
+<!-- Config: communicate in {communication_language}. -->
+
+# Strategy
+
+## STEP GOAL:
+
+Compute the execution order from dependency edges, detect circular dependencies, and present a human-readable strategy view to the operator so the campaign plan is visible before execution begins.
+
+## RULES
+
+- This step uses the **read-backup-modify-write** pattern (state file exists from step-01).
+- Validate state on load via `uv run {validateScript} --state-file {stateFile}`; HALT (exit 3) on non-zero.
+- Write `execution_order` and `circular_deps_detected` to `dependency_graph`.
+- Update `campaign.current_stage` to `1`.
+- Update `campaign.last_updated` to current ISO-8601 with timezone on every write.
+- If `{headless_mode}` is true, auto-proceed through confirmation gates with the default action and log each auto-decision.
+
+## 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 — Backup State
+
+Copy `{stateFile}` to `{backupFile}` before any modification.
+
+### §3 — 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).
+
+### §4 — Compute Execution Order
+
+Run the deterministic topological sort — do not hand-compute it:
+
+```
+uv run {depsScript} --compute --state-file {stateFile}
+```
+
+Parse the JSON output: `execution_order` (the ordered skill names — Kahn's sort with Tier A placed before Tier B within a dependency level), `circular_deps_detected` (bool), and `cycle_participants` (the unplaced skills when a cycle exists, else null). Exit code 1 from the script signals a cycle or a dangling dependency reference; exit code 2 signals a state/parse error — surface either and HALT.
+
+### §5 — Handle Circular Dependencies
+
+If `circular_deps_detected` is `true`, HALT (exit code 4, `circular-deps`) with a clear error listing `cycle_participants` and their mutual `depends_on` edges. Do NOT proceed — circular dependencies make execution order impossible.
+
+### §6 — Write State
+
+Set `dependency_graph.execution_order` to the computed order. Set `dependency_graph.circular_deps_detected` to the detection result. Set `campaign.current_stage` to `1`. Set `campaign.last_updated` to current ISO-8601 with timezone. Write to `{stateFile}`.
+
+### §7 — Present Strategy View
+
+Display a human-readable strategy summary to the operator (not written to a file — display only):
+
+```
+CAMPAIGN STRATEGY: {campaign_name}
+
+EXECUTION ORDER:
+  1. {skill_name} [Tier {tier}] {pin or "latest"}
+  2. {skill_name} [Tier {tier}] {pin or "latest"} ← depends on: {dep1, dep2}
+  ...
+
+DEPENDENCY MAP:
+  {skill_a} → {skill_b}, {skill_c}
+  {skill_d} → (no dependencies)
+  ...
+
+QUALITY GATE:
+  Hard gate: {quality_gate.hard}
+  Soft target: {quality_gate.soft_target}%
+  Soft fallback: {quality_gate.soft_fallback}%
+
+TIER DISTRIBUTION:
+  Tier A (full pipeline): {count}
+  Tier B (QS batch): {count}
+```
+
+### §8 — Plan Confirmation Gate
+
+The strategy view is the last review surface before a potentially long, mostly-unattended run begins. Present a confirmation gate:
+
+- `[P]roceed` — begin execution (chain to `{nextStepFile}`).
+- `[C]ancel` — stop now with exit code 12 (`user-cancelled`); state is intact and resumable. To change targets, edit the campaign brief (`{campaignWorkspacePath}/campaign-brief.yaml`) or re-run `campaign` (overwrite), then start again.
+
+**HALT and wait for operator input.** In headless mode, auto-proceed with `[P]` and log "headless: auto-proceed past plan-confirmation gate" to the decision log.
+
+## OUTPUT
+
+Confirm strategy computed, display the strategy view, and resolve the §8 gate. Chain to `{nextStepFile}`.