prizmkit 1.1.130 → 1.1.131

package/bundled/skills/feature-pipeline-launcher/SKILL.md

@@ -1,346 +1,204 @@
 ---
 name: "feature-pipeline-launcher"
-description: "Launch and manage the dev-pipeline from within an AI CLI session. Start pipeline in background, monitor logs, check status, stop pipeline. Use this skill whenever the user wants to start building features, run the pipeline, check pipeline progress, retry features, or stop the pipeline. Trigger on: 'run pipeline', 'start pipeline', 'start building', 'pipeline status', 'stop pipeline', 'retry feature', 'launch pipeline', 'start implementing', 'check pipeline status', 'stop the pipeline'. (project)"
+description: "Build feature-pipeline commands from a validated .prizmkit/plans/feature-list.json without executing them. Produces foreground or background-daemon start commands plus status, logs, stop, and safe retry commands. Use whenever the user wants to run the feature pipeline, start building from an existing feature list, construct a feature subset command, inspect pipeline status, view logs, stop a run, or retry a feature. Trigger on: 'run pipeline', 'start pipeline', 'start building', 'build feature list', 'pipeline status', 'pipeline logs', 'stop pipeline', 'retry feature', 'clean retry F-001'."
 ---
 
-# Dev-Pipeline Launcher
+# Feature Pipeline Command Builder
 
-Launch the autonomous development pipeline from within an AI CLI conversation. Only Background daemon mode is fully detached and survives AI CLI session closure; Foreground runs in the current session, and Manual prints commands without launching.
+Build commands for the autonomous feature pipeline from within an AI CLI conversation. This skill reads configuration and planning inputs, asks only the choices needed to construct an accurate command, displays the command and its effects, then stops.
 
-Three execution modes are available (Foreground / Background daemon / Manual); they are defined authoritatively in **Intent A, step 5** below.
+## Command-Only Boundary
 
-### When to Use
+This skill:
 
-**Start pipeline** -- User says:
-- "run feature pipeline", "run pipeline", "start building features", "launch feature pipeline"
-- "start implementing", "execute feature list", "build all features"
-- After feature-planner completes: "build them", "start building from the list"
-- Supports running a feature subset (e.g. "run only F-001 to F-005", "run features F-001,F-003").
+- reads a validated feature list and relevant configuration;
+- builds prerequisite-check, start, status, logs, stop, and retry commands;
+- explains command effects and destructive options before returning them;
+- never executes shell commands, starts processes, follows logs, changes pipeline state, implements source code, or runs verification.
 
-**Check status** -- User says:
-- "pipeline status", "feature progress", "check the pipeline", "how's the build going"
+Do not invoke another workflow or implementation skill from this command builder. The user decides where and when to run the returned command.
 
-**Stop pipeline** -- User says:
-- "stop pipeline", "stop the pipeline", "halt pipeline", "pause the build"
+## When to Use
 
-**Show logs** -- User says:
-- "pipeline logs", "show pipeline logs", "what's building"
+Use this skill for:
 
-**Retry single feature** -- User says:
-- "retry F-001", "re-run F-001", "retry this feature"
+- constructing a foreground or background-daemon feature pipeline command;
+- selecting a feature subset such as `F-001:F-005` or `F-001,F-003`;
+- constructing status, logs, stop, or retry commands;
+- translating user-selected runtime options into environment variables.
 
-**Do NOT use this skill when:**
-- User wants to plan features (use `feature-planner` instead)
-- User wants to implement a single feature manually within current session (use `prizmkit-implement`)
-- User wants to define specs/plan (use `prizmkit-plan`)
+Do not use it to:
 
-### Prerequisites
+- create or modify `.prizmkit/plans/feature-list.json` — use `feature-planner`;
+- implement a feature in the current conversation;
+- execute, monitor, or verify a pipeline run.
 
-Before any action, validate:
+## Inputs
 
-1. **dev-pipeline exists**: Confirm `.prizmkit/dev-pipeline/cli.py` is present
-2. **For start**: `.prizmkit/plans/feature-list.json` must exist in `.prizmkit/plans/` (or user-specified path)
-3. **Dependencies**: `python3`, `git`, and the configured AI CLI must be in PATH. Resolve and report the AI CLI from `AI_CLI` env, then `.prizmkit/config.json` `ai_cli`, then fallback to `claude` only when neither is configured. Read `${SKILL_DIR}/references/configuration.md` §Configured AI CLI Prerequisite Check before running the AI CLI check.
-4. **Python version**: Requires Python 3.10+ for the unified dev-pipeline runtime
-5. **Browser tools** (optional): If any feature has `browser_interaction` field, check the corresponding tool is available. Features may specify `tool: "playwright-cli"`, `tool: "opencli"`, or `tool: "auto"` (AI chooses at runtime).
+Default paths:
 
-Quick check:
-```bash
-command -v python3 >/dev/null && command -v git >/dev/null && echo "Core dependencies OK"
-# AI CLI check: read `${SKILL_DIR}/references/configuration.md` §Configured AI CLI Prerequisite Check.
-# It must print `Configured AI CLI: <name>` and verify that exact executable.
-# Optional: browser interaction support (check both tools — features may use either)
-command -v playwright-cli && echo "playwright-cli OK" || echo "playwright-cli not found (playwright browser verification will be skipped)"
-command -v opencli && echo "opencli OK" || echo "opencli not found (opencli browser verification will be skipped)"
-```
+- Runtime CLI: `.prizmkit/dev-pipeline/cli.py`
+- Feature plan: `.prizmkit/plans/feature-list.json`
 
-If `.prizmkit/plans/feature-list.json` is missing, inform user:
-> "No .prizmkit/plans/feature-list.json found. Run the `feature-planner` skill first to generate one, or provide a path to your feature list."
+Accept a user-specified feature-list path when provided. Read the plan directly to summarize IDs, titles, dependencies, and current statuses. If the plan is missing or malformed, report that a valid feature plan is required and stop without constructing a start command.
 
-### Workflow
+Read `${SKILL_DIR}/references/configuration.md` before constructing prerequisite or runtime option fragments.
 
-Detect user intent from their message, then follow the corresponding workflow:
+## Intent Routing
 
----
+Classify the request before asking configuration questions:
 
-#### Intent A: Start Pipeline
+| Intent | Output |
+|---|---|
+| Start all or selected features | Prerequisite-check command plus one start command |
+| Check status | Daemon status and item-level status commands |
+| Show logs | Recent or follow-log command |
+| Stop | Daemon stop command plus optional status command |
+| Retry one feature | Standard or clean reset-and-run command with safety disclosure |
 
-> **Execution model**: The pipeline processes eligible features one at a time. The `dependencies` field is active: dependencies must complete before dependents are selected, and unrelated eligible items preserve stable list order.
+Only the start intent uses the execution-mode and configuration rounds.
 
-1. **Check prerequisites**:
-   ```bash
-   ls .prizmkit/plans/feature-list.json 2>/dev/null && echo "Found" || echo "Missing"
-   ```
+## Start Command Workflow
 
-2. **Check not already running**:
-   ```bash
-   python3 ./.prizmkit/dev-pipeline/cli.py daemon feature status 2>/dev/null
-   ```
-   If running, inform user and ask: "Pipeline is already running. Want to restart it, check status, or view logs?"
+### Step 1: Resolve inputs
 
-3. **Show feature summary** (so user knows what will be built):
-   ```bash
-   python3 -c "
-   import json
-   with open('.prizmkit/plans/feature-list.json') as f:
-       data = json.load(f)
-   features = data.get('features', [])
-   print(f'Total features: {len(features)}')
-   for f in features:
-       print(f\"  {f['id']}: {f.get('title', 'untitled')}\")
-   "
-   ```
-   If pipeline state already exists, use the status command instead:
-   ```bash
-   python3 ./.prizmkit/dev-pipeline/cli.py feature status .prizmkit/plans/feature-list.json
-   ```
+1. Resolve the feature-list path.
+2. Read the list and summarize total, eligible, blocked, and selected feature IDs.
+3. Preserve an explicit user feature filter. Do not invent a subset.
+4. If an existing run is suspected from user context, include a status command in the output; do not run it.
 
-4. **Run environment preflight checks** (database connectivity, migrations, dev server):
+### Step 2: Ask execution mode
 
-   Run the preflight script to auto-detect the database type, verify env vars, test connectivity, and check migration status:
-   ```bash
-   python3 <feature-pipeline-launcher-skill-dir>/scripts/preflight-check.py .prizmkit/plans/feature-list.json
-   ```
+Use one `AskUserQuestion` call with exactly one question:
 
-   Replace `<feature-pipeline-launcher-skill-dir>` with the resolved skill directory path before running. Do not execute a literal unresolved `${SKILL_DIR}` shell variable.
+- **Foreground (Recommended)** — build `feature run`; output remains attached to the user's terminal.
+- **Background daemon** — build `daemon feature start`; the runtime manages detached execution and logs.
 
-   The script:
-   - Reads `global_context.database` from `.prizmkit/plans/feature-list.json` and `.prizmkit/config.json`
-   - Scans `.env.local` / `.env` for connection variables (supports Supabase, PostgreSQL, MySQL, MongoDB, Firebase, and generic `DATABASE_URL`)
-   - Tests connectivity using the appropriate method per database type
-   - Checks migration status (Prisma, Drizzle, Supabase raw SQL, or generic migration directories)
-   - Checks if the dev server is running (from `browser_interaction` URLs)
-   - Outputs `PREFLIGHT ✓` (pass), `PREFLIGHT ⚠` (warning), or `PREFLIGHT ℹ` (info) lines
-   - Exits 0 (all clear), 1 (warnings found), or 2 (error — feature list not found)
+Wait for the response before asking configuration.
 
-   If the script reports `⚠` warnings, present them to the user and ask:
-   > "Environment preflight found issues (listed above). The pipeline can still run, but database-related features may produce code that passes mock tests without real database verification. Continue anyway?"
-
-   Wait for user confirmation. If they want to fix issues first, suggest remediation based on the warnings (apply migrations, configure env vars, check database service status).
-
-   If `global_context.database` is absent and no features mention database keywords, the script skips DB checks automatically.
-
-5. **Ask execution mode** (first user decision):
-
-   **RULE: Ask step 5 and step 6 in separate `AskUserQuestion` calls.** Combining them makes the model merge the questions and skip the mode selection. Ask execution mode ALONE here, wait for the response, THEN proceed to step 6.
-
-   Use `AskUserQuestion` with exactly 1 question:
-
-   **Question 1 — Execution mode** (multiSelect: false):
-   - Foreground (Recommended) — pipeline runs in the current session via `python3 ./.prizmkit/dev-pipeline/cli.py feature run`. Visible output and direct error feedback.
-   - Background daemon — pipeline runs fully detached via `python3 ./.prizmkit/dev-pipeline/cli.py daemon feature start .prizmkit/plans/feature-list.json`. Survives AI CLI session closure.
-   - Manual — display the final assembled commands only. Do not execute anything. User runs them on their own.
-
-   STOP HERE and wait for user response before continuing to step 6.
-
-6. **Ask configuration options** — MANDATORY INTERACTIVE STEP, applies to ALL execution modes (Foreground, Background, AND Manual). This is a SEPARATE `AskUserQuestion` call from step 5 (see the RULE above). You MUST call `AskUserQuestion` with the 4 questions below and WAIT for the user's response before proceeding to step 7. Do NOT assume defaults, do NOT show the command as text and ask "ready?", and do NOT merge step 6 and step 7. If you find yourself writing the final command before the user has answered these 4 questions, STOP — you are violating this rule.
-
-   Use `AskUserQuestion` to present ALL 3 configuration choices:
-
-   **Question 1 — Verbose logging** (multiSelect: false):
-   - On (default) — Detailed AI session logs including tool calls and subagent activity
-   - Off — Minimal logging
-
-   **Question 2 — Max retries** (multiSelect: false):
-   - 3 (default)
-   - 1
-   - 5
-
-   **Question 3 — Advanced config?** (multiSelect: false):
-   - No (default) — Use defaults for failure behavior
-   - Yes — Configure stop-on-failure, deploy-after-completion, and reasoning effort options
-
-   **If user chose "Yes" to Advanced config**, ask a second round of `AskUserQuestion` — see the advanced config questions (stop-on-failure, deploy-after-completion, reasoning effort) in `${SKILL_DIR}/references/configuration.md`.
-
-   Read `${SKILL_DIR}/references/configuration.md` for the current environment-variable mapping and advanced environment-variable tables.
-
-
-7. **Show final command**: After user confirms configuration in step 6, assemble the complete command from execution mode + user-confirmed configuration, and present it to the user.
-
-   **Foreground command:**
-   ```bash
-   VERBOSE=1 python3 ./.prizmkit/dev-pipeline/cli.py feature run .prizmkit/plans/feature-list.json
-   ```
-   Selected-options example:
-   ```bash
-   VERBOSE=1 MAX_RETRIES=5 STOP_ON_FAILURE=1 ENABLE_DEPLOY=1 PRIZMKIT_EFFORT=high \
-     python3 ./.prizmkit/dev-pipeline/cli.py feature run .prizmkit/plans/feature-list.json --features F-001:F-005
-   ```
-
-   **Background daemon command:**
-   ```bash
-   python3 ./.prizmkit/dev-pipeline/cli.py daemon feature start .prizmkit/plans/feature-list.json --env "VERBOSE=1"
-   ```
-   Selected-options example:
-   ```bash
-   python3 ./.prizmkit/dev-pipeline/cli.py daemon feature start .prizmkit/plans/feature-list.json --features F-001:F-005 \
-     --env "VERBOSE=1 MAX_RETRIES=5 STOP_ON_FAILURE=1 ENABLE_DEPLOY=1 PRIZMKIT_EFFORT=high"
-   ```
-
-   **Manual mode**: Print the assembled command(s) and **stop here**. Do not execute anything. Do not proceed to step 8.
-   ```
-   # To run in foreground:
-   VERBOSE=1 python3 ./.prizmkit/dev-pipeline/cli.py feature run .prizmkit/plans/feature-list.json
-
-   # To run in background (detached):
-   python3 ./.prizmkit/dev-pipeline/cli.py daemon feature start .prizmkit/plans/feature-list.json --env "VERBOSE=1"
-
-   # To check status:
-   python3 ./.prizmkit/dev-pipeline/cli.py feature status .prizmkit/plans/feature-list.json
-   ```
+### Step 3: Ask base configuration
 
-8. **Confirm and launch** (Foreground and Background only — Manual mode ends at step 7):
+Use a separate `AskUserQuestion` call with exactly three questions:
 
-   Use a separate `AskUserQuestion` call: "Ready to launch the pipeline with the above command?"
-   Options:
-   - Launch now (Recommended)
-   - Cancel
+1. **Verbose logging** — On or Off.
+2. **Max retries** — 3, 1, 5, or a user-provided non-negative integer.
+3. **Advanced config** — No or Yes.
 
-   After user confirms, execute the command from step 7.
+If Advanced config is Yes, load the advanced question set from `${SKILL_DIR}/references/configuration.md`. Advanced configuration contains only stop-on-failure and reasoning effort.
 
-9. **Post-launch** (depends on execution mode):
+### Step 4: Build command fragments
 
-   **If foreground**: Pipeline runs to completion in the terminal. After it finishes:
-   - Summarize results: total features, succeeded, failed, skipped
-   - If all succeeded: each feature session has already run `prizmkit-retrospective` internally. Ask user what's next.
-   - If some failed: show failed feature IDs and suggest `python3 ./.prizmkit/dev-pipeline/cli.py reset feature <F-XXX> --clean --run` for a fresh retry
-   - **Browser verification**: If any completed features have `browser_interaction` and the corresponding browser tool (`playwright-cli` or `opencli`) is installed, offer to run browser verification (see Post-Pipeline Browser Verification)
+Map confirmed choices to environment variables using `${SKILL_DIR}/references/configuration.md`.
 
-   **If background daemon**:
-   1. Verify launch:
-      ```bash
-      python3 ./.prizmkit/dev-pipeline/cli.py daemon feature status
-      ```
-   2. Start log monitoring — Use the Bash tool with `run_in_background: true`:
-      ```bash
-      python3 ./.prizmkit/dev-pipeline/cli.py daemon feature logs --follow
-      ```
-   3. Report to user:
-      - Pipeline PID
-      - Log file location
-      - "You can ask me 'pipeline status' or 'show logs' at any time"
-      - "Closing this session will NOT stop the pipeline"
+Build the prerequisite-check command separately from the pipeline command so the user can inspect each action:
 
----
+```bash
+command -v python3 >/dev/null && command -v git >/dev/null && test -f .prizmkit/dev-pipeline/cli.py && python3 -c 'import sys; raise SystemExit(0 if sys.version_info >= (3, 10) else 1)'
+```
 
-#### Intent B: Check Status
+Also include the configured AI CLI check fragment from the reference. These are returned commands, not checks performed by this skill.
 
-1. **Check daemon status**:
-   ```bash
-   python3 ./.prizmkit/dev-pipeline/cli.py daemon feature status
-   ```
+### Step 5: Return the start command
 
-2. **Show feature-level progress**:
-   ```bash
-   python3 ./.prizmkit/dev-pipeline/cli.py feature status .prizmkit/plans/feature-list.json
-   ```
+Foreground template:
 
-3. **Show recent log activity** (last 20 lines):
-   ```bash
-   python3 ./.prizmkit/dev-pipeline/cli.py daemon feature logs --lines 20
-   ```
+```bash
+VERBOSE=1 MAX_RETRIES=3 \
+  python3 ./.prizmkit/dev-pipeline/cli.py feature run .prizmkit/plans/feature-list.json
+```
 
-4. **Summarize** to user: total features, completed, in-progress, failed, pending.
+Foreground subset template:
 
----
+```bash
+VERBOSE=1 MAX_RETRIES=3 \
+  python3 ./.prizmkit/dev-pipeline/cli.py feature run .prizmkit/plans/feature-list.json --features F-001:F-005
+```
 
-#### Intent C: Stop Pipeline
+Background template:
 
-1. **Stop the daemon**:
-   ```bash
-   python3 ./.prizmkit/dev-pipeline/cli.py daemon feature stop
-   ```
+```bash
+python3 ./.prizmkit/dev-pipeline/cli.py daemon feature start .prizmkit/plans/feature-list.json \
+  --env "VERBOSE=1 MAX_RETRIES=3"
+```
 
-2. **Verify stopped**:
-   ```bash
-   python3 ./.prizmkit/dev-pipeline/cli.py daemon feature status 2>/dev/null || true
-   ```
+Background subset template:
 
-3. **Inform user**: "Pipeline stopped. State is preserved -- you can resume later with 'start pipeline' and it will pick up where it left off."
+```bash
+python3 ./.prizmkit/dev-pipeline/cli.py daemon feature start .prizmkit/plans/feature-list.json \
+  --features F-001:F-005 --env "VERBOSE=1 MAX_RETRIES=3"
+```
 
----
+Return only the template matching the confirmed mode and options. Explain that the command has not been executed, then stop.
 
-#### Intent D: Show Logs
+## Status Command
 
-1. **Check if running**:
-   ```bash
-   python3 ./.prizmkit/dev-pipeline/cli.py daemon feature status 2>/dev/null
-   ```
+Return both commands when the user asks for overall status:
 
-2. **If running** -- Start live tail with Bash tool `run_in_background: true`:
-   ```bash
-   python3 ./.prizmkit/dev-pipeline/cli.py daemon feature logs --follow
-   ```
+```bash
+python3 ./.prizmkit/dev-pipeline/cli.py daemon feature status
+python3 ./.prizmkit/dev-pipeline/cli.py feature status .prizmkit/plans/feature-list.json
+```
 
-3. **If not running** -- Show last 50 lines:
-   ```bash
-   python3 ./.prizmkit/dev-pipeline/cli.py daemon feature logs --lines 50
-   ```
+Do not infer completion from the plan file alone when runtime state may exist.
 
-4. **For per-feature session logs** (when user asks about a specific feature):
-   ```bash
-   # Check feature status for last session ID
-   cat .prizmkit/state/features/<FEATURE_ID>/status.json 2>/dev/null
-   # Then tail that feature's session log
-   tail -100 .prizmkit/state/features/<FEATURE_ID>/sessions/<SESSION_ID>/logs/session.log
-   ```
+## Logs Command
 
----
+Recent logs:
 
-#### Intent E: Retry Single Feature Node
+```bash
+python3 ./.prizmkit/dev-pipeline/cli.py daemon feature logs --lines 50
+```
 
-When user says "retry F-003" or "clean retry F-003":
+Follow logs:
 
 ```bash
-python3 ./.prizmkit/dev-pipeline/cli.py reset feature F-003 --clean --run .prizmkit/plans/feature-list.json
+python3 ./.prizmkit/dev-pipeline/cli.py daemon feature logs --follow
 ```
 
-Notes:
-- `python3 ./.prizmkit/dev-pipeline/cli.py reset feature <F-XXX> --clean --run .prizmkit/plans/feature-list.json` performs a full clean (deletes session history and artifacts) before retrying the selected feature — this gives a fresh start.
-- Keep pipeline daemon mode for main run management (`python3 ./.prizmkit/dev-pipeline/cli.py daemon feature start`, `python3 ./.prizmkit/dev-pipeline/cli.py daemon feature status`, or `python3 ./.prizmkit/dev-pipeline/cli.py daemon feature stop`).
+When the user names a specific feature, also explain that per-feature session paths can be identified from `.prizmkit/state/features/<FEATURE_ID>/status.json`; do not read or tail them from this skill.
 
----
+## Stop Command
+
+Return:
+
+```bash
+python3 ./.prizmkit/dev-pipeline/cli.py daemon feature stop
+```
 
-#### Post-Pipeline Browser Verification
+Optionally include the daemon status command for the user to run afterward. Do not claim the pipeline stopped until runtime output confirms it.
 
-After pipeline completion, if features have `browser_interaction` fields and the corresponding browser tool (`playwright-cli` or `opencli`) is installed:
+## Retry Command
 
-If list status may be stale, use the runtime status command as the source of truth for completion state:
-`python3 ./.prizmkit/dev-pipeline/cli.py feature status .prizmkit/plans/feature-list.json`.
+A reset can discard uncommitted changes when the target task branch is currently checked out. Clean reset additionally deletes the task branch and clears its task history/artifacts. Never hide these effects behind the word “retry.”
 
-1. **Check which completed features have browser verification configured**:
-   - Read `browser_interaction` configuration from `.prizmkit/plans/feature-list.json`.
-   - Use the runtime status command output to decide which configured features are actually completed.
-   - Do not rely on list-file `status` alone when runtime state exists, because daemon/foreground bookkeeping may be newer than the plan file.
+Use `AskUserQuestion` before constructing a retry command:
 
-2. **Ask user**: "N features have browser verification configured. Run browser verification now? (Y/n)"
+- **Standard retry (Recommended)** — reset task status and rerun while preserving a non-current task branch; warn that an active task branch may still have uncommitted changes discarded by reset.
+- **Clean retry** — perform the standard reset and also delete the task branch and clear task history/artifacts.
+- **Cancel** — return no reset command.
 
-3. **If yes**, for each qualifying feature:
-   - Start dev server if `setup_command` is specified
-   - Select browser tool based on `browser_interaction.tool`:
-     - `"playwright-cli"` → Use `playwright-cli snapshot` to discover element refs, then verify each goal in `verify_steps`
-     - `"opencli"` → Use `opencli browser` to interact with Chrome's logged-in session (ideal for OAuth/third-party verification)
-     - `"auto"` → AI chooses the appropriate tool based on context (default: `playwright-cli` for local dev, `opencli` for authenticated flows)
-   - Take a screenshot after verification
-   - Close browser and stop dev server
+Standard template:
+
+```bash
+python3 ./.prizmkit/dev-pipeline/cli.py reset feature F-001 --run .prizmkit/plans/feature-list.json
+```
 
-4. **Report results**:
-   - For each feature: URL opened, tool used, steps executed, screenshot path
-   - If any step fails: flag as verification failure
+Clean template:
 
-**Important**: Browser verification is best-effort — failures here do NOT change the feature's pipeline status. They serve as visual confirmation aids for the user.
+```bash
+python3 ./.prizmkit/dev-pipeline/cli.py reset feature F-001 --clean --run .prizmkit/plans/feature-list.json
+```
 
----
+For clean retry, require explicit acknowledgement of branch deletion and possible uncommitted-change loss before displaying the command.
 
-### Error Handling
+## Output Contract
 
-Read `${SKILL_DIR}/references/configuration.md` for the full error handling table covering feature-list, dependency checks, pipeline state, browser tooling, permission, and deploy failures.
+For every request, return:
 
-### Integration Notes
+1. Intent and resolved target.
+2. Input plan path and selected IDs, when applicable.
+3. Assumptions and safety warnings.
+4. Exact command block.
+5. `Command execution: not performed by this skill.`
 
-- **After feature-planner**: This is the natural next step. When user finishes planning and has `.prizmkit/plans/feature-list.json`, suggest launching the pipeline.
-- **Session independence**: Only Background daemon mode runs detached. Foreground runs in the current AI CLI session, and Manual mode prints commands without launching.
-- **Single instance per family**: Only one feature pipeline can run at a time. Different pipeline families may coexist because they use separate daemon metadata and state directories.
-- **Pipeline coexistence**: Feature, bugfix, and refactor pipelines use separate state directories (`.prizmkit/state/features/`, `.prizmkit/state/bugfix/`, `.prizmkit/state/refactor/`), so all three can run simultaneously without conflict.
-- **State preservation**: Stopping and restarting the pipeline resumes from where it left off -- completed features are not re-run.
-- **HANDOFF**: After pipeline completes all features, each session has already run `prizmkit-retrospective` internally. Ask user what's next.
+Never report command success, process IDs, log locations, task completion, verification results, or state changes unless the user later supplies authoritative runtime output for explanation.

package/bundled/skills/feature-pipeline-launcher/references/configuration.md

@@ -1,50 +1,28 @@
-# Configuration Reference — Feature Pipeline Launcher
+# Configuration Reference — Feature Pipeline Command Builder
 
-Environment variable mappings for the feature launcher.
+Use this reference only to translate confirmed user choices into command fragments. The skill returns commands; it does not execute them.
 
-## Advanced Config Questions (second AskUserQuestion round)
+## Configured AI CLI Prerequisite Command
 
-Asked only when the user chose "Yes" to Advanced config in step 6.
+Runtime AI CLI selection is config-driven. Resolve the executable in this order:
 
-**Question 1 — Stop on failure** (multiSelect: false):
-- Off (default) — Pipeline continues to next task after failure
-- On — Pipeline halts immediately when a task exhausts all retries (`STOP_ON_FAILURE=1`)
+1. `AI_CLI` environment variable.
+2. `.prizmkit/config.json` `ai_cli`.
+3. `claude` only when neither is configured.
 
-**Question 2 — Deploy after completion?** (multiSelect: false):
-- No (default) — Skip deployment after pipeline completes
-- Yes — Run /prizmkit-deploy automatically after all features complete successfully (`ENABLE_DEPLOY=1`). Deployment is blocked if any feature did not complete successfully (status not 'completed' or manually 'skipped').
+Return this check command as part of start-command preparation:
 
-**Question 3 — Reasoning effort** (multiSelect: false):
-- Default (none) — Use CLI default
-- low — Minimize reasoning, fastest output (`PRIZMKIT_EFFORT=low`)
-- medium — Moderate reasoning (`PRIZMKIT_EFFORT=medium`)
-- high — Thorough reasoning for complex tasks (`PRIZMKIT_EFFORT=high`)
-- xhigh — Extensive reasoning (`PRIZMKIT_EFFORT=xhigh`)
-- max — Maximum reasoning, Claude Code only (`PRIZMKIT_EFFORT=max`)
-
-## Configured AI CLI Prerequisite Check
-
-Read this section during launcher prerequisite validation before reporting AI CLI availability.
-
-Runtime AI CLI selection is config-driven. Resolve the executable name in this order:
-1. `AI_CLI` environment variable when set.
-2. `.prizmkit/config.json` `ai_cli` when present.
-3. `claude` fallback only when neither is configured.
-
-Run this quick check from the project root:
 ```bash
-command -v python3 >/dev/null && command -v git >/dev/null || { echo "python3 or git missing"; exit 1; }
 AI_CLI="$(
   python3 - <<'PY'
 import json, os, shlex
 from pathlib import Path
 cli = os.environ.get("AI_CLI", "").strip()
 if not cli:
-    config_path = Path(".prizmkit/config.json")
-    if config_path.is_file():
+    path = Path(".prizmkit/config.json")
+    if path.is_file():
         try:
-            data = json.loads(config_path.read_text(encoding="utf-8"))
-            cli = str(data.get("ai_cli") or "").strip()
+            cli = str(json.loads(path.read_text(encoding="utf-8")).get("ai_cli") or "").strip()
         except (OSError, json.JSONDecodeError):
             cli = ""
 cli = cli or "claude"
@@ -55,56 +33,37 @@ except ValueError:
 PY
 )"
 printf 'Configured AI CLI: %s\n' "$AI_CLI"
-command -v "$AI_CLI" >/dev/null && printf 'AI CLI OK: %s\n' "$(command -v "$AI_CLI")" || { printf 'AI CLI not found: %s\n' "$AI_CLI"; exit 1; }
-echo "All dependencies OK"
+command -v "$AI_CLI" >/dev/null
 ```
 
-Report the configured executable, for example `Configured AI CLI: claude`. Do not report the first arbitrary PATH match such as `cbc` when project config selects a different AI CLI.
+Do not claim the configured executable exists until the user supplies successful command output.
 
-## Environment Variable Mapping
+## Base Configuration Mapping
 
-Translating user responses to env vars:
+| Choice | Command fragment |
+|---|---|
+| Verbose Off | `VERBOSE=0` |
+| Verbose On | `VERBOSE=1` |
+| Max retries N | `MAX_RETRIES=N` |
 
-| Config choice | Environment variable |
-|-----------|---------------------|
-| Verbose: Off | `VERBOSE=0` |
-| Verbose: On | `VERBOSE=1` |
-| Max retries: N | `MAX_RETRIES=N` |
-| Stop on failure: On | `STOP_ON_FAILURE=1` |
-| Deploy: Yes | `ENABLE_DEPLOY=1` |
-| Effort: value | `PRIZMKIT_EFFORT=<value>` |
+## Advanced Configuration Questions
 
-## Advanced Environment Variables
+Ask only when the user selected Advanced config.
 
-Not exposed in interactive menu, pass via `--env`:
+1. **Stop on failure**
+   - Off (default) — continue to other eligible tasks after a task exhausts retries.
+   - On — add `STOP_ON_FAILURE=1`.
+2. **Reasoning effort**
+   - Default — omit `PRIZMKIT_EFFORT`.
+   - `low`, `medium`, `high`, `xhigh`, or `max` — add `PRIZMKIT_EFFORT=<value>` after confirming the configured AI CLI supports it.
 
-| Variable | Default | Purpose |
-|----------|---------|---------|
-| `MODEL` | (none) | AI model override (e.g. `claude-opus-4.6`) |
-| `AUTO_PUSH` | `0` | Auto-push to remote after successful feature (`1` to enable) |
-| `DEV_BRANCH` | auto-generated | Custom dev branch name (default: `dev/{feature_id}-YYYYMMDDHHmm`) |
-| `HEARTBEAT_INTERVAL` | `30` | Heartbeat log interval in seconds |
-| `HEARTBEAT_STALE_THRESHOLD` | `600` | Max seconds without heartbeat before marking stale |
-| `PIPELINE_MODE` | (none) | Override mode for all features: `lite`\|`standard`\|`full` |
+These are the complete advanced choices for this command builder.
 
-## Error Handling
+## Command Construction Rules
 
-| Error | Action |
-|-------|--------|
-| `.prizmkit/plans/feature-list.json` not found | Tell user to run `feature-planner` skill first |
-| `python3` not installed | Install Python 3.10+ and rerun the Python runtime command |
-| `git` not installed | Install git; the Python runtime uses git for branch/worktree/status operations |
-| Configured AI CLI not in PATH | Install the executable selected by `AI_CLI` or `.prizmkit/config.json` `ai_cli`, or update the config to a CLI available in PATH. |
-| Pipeline already running | Show status, ask if user wants to stop and restart |
-| PID file stale (process dead) | `python3 ./.prizmkit/dev-pipeline/cli.py daemon feature start .prizmkit/plans/feature-list.json` auto-cleans, retry start |
-| Launch failed (process died immediately) | Show last 20 lines of log: `python3 ./.prizmkit/dev-pipeline/cli.py daemon feature logs --lines 20` |
-| Feature stuck/blocked | Use `python3 ./.prizmkit/dev-pipeline/cli.py reset feature <F-XXX> --clean --run` for a fresh retry |
-| All features blocked/failed | Show status, suggest daemon-safe recovery: `python3 ./.prizmkit/dev-pipeline/cli.py reset feature <F-XXX> --clean --run .prizmkit/plans/feature-list.json` |
-| `playwright-cli` not installed | Browser verification skipped for playwright features (non-blocking). Suggest: `npm install -g @playwright/cli@latest && playwright-cli install --skills` |
-| `opencli` not installed | Browser verification skipped for opencli features (non-blocking). Install opencli for Chrome session-based browser verification |
-| Permission denied running Python CLI | Ensure Python is installed and the command uses `python3 ./.prizmkit/dev-pipeline/cli.py ...` |
-| Pipeline stop failed (process won't die) | Process may be stuck in I/O wait. Try `kill -9 <PID>` manually. Check for orphaned child processes with `ps aux \| grep claude` |
-| Deploy session failed | Pipeline completed but deploy session exited non-zero. Check `.prizmkit/state/features/deploy/<session_id>/logs/session.log`. Retry manually: `/prizmkit-deploy`. |
-| `.env.local` missing or incomplete | Warn: database connection variables not found. Suggest creating env file with required connection variables for the project's database |
-| Database unreachable | Warn: database features will produce mock-only tests. Suggest checking database service status and connection credentials |
-| Migrations not applied | Warn: tables or schema referenced in migration files not found in database. Suggest applying pending migrations |
+- Foreground: place environment assignments before `python3`.
+- Background daemon: place assignments inside one `--env "..."` value.
+- Include only confirmed options.
+- Preserve the user-provided list path and feature filter.
+- Shell-quote custom paths and values.
+- Return one start command for the selected mode, never both.