prizmkit 1.1.107 → 1.1.109

package/bundled/dev-pipeline/templates/sections/phase-browser-verification-auto.md

@@ -6,10 +6,8 @@ You MUST attempt this phase. Mark it as skipped only when no usable browser tool
 
 0a. Check which browser tools are available:
 ```bash
-echo "=== playwright-cli ==="
-which playwright-cli 2>/dev/null && playwright-cli --version 2>/dev/null || echo "PLAYWRIGHT_CLI:NOT_INSTALLED"
-echo "=== opencli ==="
-which opencli 2>/dev/null && opencli --version 2>/dev/null || echo "OPENCLI:NOT_INSTALLED"
+{{RUNTIME_HELPER_CMD}} executable version playwright-cli --arg=--version
+{{RUNTIME_HELPER_CMD}} executable version opencli --arg=--version
 ```
 
 0b. Use this single decision tree:
@@ -18,19 +16,15 @@ which opencli 2>/dev/null && opencli --version 2>/dev/null || echo "OPENCLI:NOT_
 3. Else install `playwright-cli` as the default:
    ```bash
    npm install -g @playwright/cli@latest
-   playwright-cli --version
+   {{RUNTIME_HELPER_CMD}} executable version playwright-cli --arg=--version
    ```
 4. If no browser tool is usable after these steps, append `## Browser Verification: SKIPPED — no usable browser tool` to `context-snapshot.md`, then continue to reporting/checkpoint.
 
 Use `opencli` instead of `playwright-cli` only when the scenario requires an existing Chrome login/session or third-party integration cookies.
 
-Record your choice:
-```bash
-BROWSER_TOOL="playwright-cli"   # or "opencli" or "skipped"
-echo "Selected browser tool: $BROWSER_TOOL"
-```
+Record your choice in the Browser Verification report as `Tool: playwright-cli`, `Tool: opencli`, or `Tool: skipped`.
 
-If `BROWSER_TOOL="skipped"`, do NOT start a dev server and do NOT run browser commands. Go directly to Step 4 Reporting and the checkpoint update.
+If tool is `skipped`, do NOT start a dev server and do NOT run browser commands. Go directly to Step 4 Reporting and the checkpoint update.
 
 ---
 
@@ -38,27 +32,15 @@ If `BROWSER_TOOL="skipped"`, do NOT start a dev server and do NOT run browser co
 
 0d. Check if playwright-cli skill is installed for the current AI platform:
 ```bash
-CURRENT_PLATFORM=""
-if which claude >/dev/null 2>&1; then
-  CURRENT_PLATFORM="claude"; SKILL_DIR="$HOME/.claude/skills"
-elif which cbc >/dev/null 2>&1; then
-  CURRENT_PLATFORM="codebuddy"; SKILL_DIR="$HOME/.cbc/skills"
-else
-  CURRENT_PLATFORM="unknown"
-fi
-if [ -d "$SKILL_DIR/playwright-cli" ] || ls "$SKILL_DIR"/playwright* 2>/dev/null | grep -q .; then
-  echo "SKILL_EXISTS"
-else
-  echo "SKILL_MISSING"
-fi
+{{RUNTIME_HELPER_CMD}} platform skill playwright-cli --prefix
 ```
-If `SKILL_MISSING`: run `playwright-cli install --skills`. If current platform is NOT claude, copy installed skill from `$HOME/.claude/skills/playwright-cli` to `$SKILL_DIR/playwright-cli`.
+If `SKILL_MISSING`: run `playwright-cli install --skills`. If current platform is NOT claude, copy installed skill from `$HOME/.claude/skills/playwright-cli` to the path shown by the helper output for the current platform.
 
 0e. Read the installed playwright-cli skill (SKILL.md) for workflow guidance. Learn usage: `playwright-cli --help`.
 
 **Step 1 — Start Dev Server + Open (playwright-cli)**:
-1. Identify and start the dev server (see port detection below)
-2. Open: `playwright-cli open http://localhost:$DEV_PORT`
+1. Identify and start the dev server (see shared helper commands below)
+2. Open: `playwright-cli open http://localhost:<DEV_PORT>`
 3. If auth needed, use playwright-cli to register a test user and log in
 
 **Step 2 — Verification (playwright-cli)**:
@@ -69,18 +51,18 @@ Construct your verification workflow based on: (1) the playwright-cli skill docu
 
 **Step 3 — Cleanup (playwright-cli)**:
 1. `playwright-cli close`
-2. `kill $DEV_SERVER_PID 2>/dev/null || true`
-3. `lsof -ti:$DEV_PORT | xargs kill -9 2>/dev/null || true`
+2. `{{RUNTIME_HELPER_CMD}} process cleanup-pid <pid-from-.prizmkit/state/browser-dev-server.pid>`
+3. `{{RUNTIME_HELPER_CMD}} port check <DEV_PORT>`
 
 ---
 
 **If you chose `opencli`**, follow this workflow:
 
-0d. Learn usage: `opencli browser --help 2>/dev/null || opencli --help`
+0d. Learn usage: `opencli browser --help`
 
 **Step 1 — Start Dev Server + Open (opencli)**:
-1. Identify and start the dev server (see port detection below)
-2. Open and inspect: `opencli browser open http://localhost:$DEV_PORT && opencli browser state`
+1. Identify and start the dev server (see shared helper commands below)
+2. Open and inspect: `opencli browser open http://localhost:<DEV_PORT> && opencli browser state`
 3. If auth needed, opencli reuses Chrome cookies — SSO/OAuth may already be active
 
 **Step 2 — Verification (opencli)**:
@@ -95,30 +77,26 @@ Always run `state` after page-changing actions to get fresh indices.
 
 **Step 3 — Cleanup (opencli)**:
 1. `opencli browser close`
-2. `kill $DEV_SERVER_PID 2>/dev/null || true`
-3. `lsof -ti:$DEV_PORT | xargs kill -9 2>/dev/null || true`
+2. `{{RUNTIME_HELPER_CMD}} process cleanup-pid <pid-from-.prizmkit/state/browser-dev-server.pid>`
+3. `{{RUNTIME_HELPER_CMD}} port check <DEV_PORT>`
 
 ---
 
-**Shared: Dev Server Port Detection** (used by both tools):
-
-```bash
-DEV_PORT={{DEV_PORT}}
-if [ "$DEV_PORT" = "{{DEV_PORT}}" ]; then
-  DEV_PORT=$(node -e "const s=require('./package.json').scripts.dev; const m=s.match(/-p\s+(\d+)/); console.log(m?m[1]:'')")
-  if [ -z "$DEV_PORT" ]; then
-    DEV_PORT=$(echo "$NEXT_PUBLIC_SITE_URL" | sed -nE 's|.*:([0-9]+).*|\1|p')
-  fi
-  DEV_PORT=${DEV_PORT:-3000}
-fi
-echo "Detected DEV_PORT=$DEV_PORT"
-```
-
-Verify port available: `lsof -ti:$DEV_PORT 2>/dev/null && echo "PORT_IN_USE" || echo "PORT_FREE"`
+**Shared: Dev Server Port / Process Helpers** (used by both tools):
 
-Start dev server: `<start-command> & DEV_SERVER_PID=$!`
-
-Wait for ready: poll `http://localhost:$DEV_PORT` with `curl -s -o /dev/null -w "%{http_code}"` until 200/302 (max 30s, 2s interval).
+1. Determine `DEV_PORT` from the pipeline value (`{{DEV_PORT}}`) or project config; do not guess.
+2. Verify port available:
+   ```bash
+   {{RUNTIME_HELPER_CMD}} port check <DEV_PORT>
+   ```
+3. Start dev server:
+   ```bash
+   {{RUNTIME_HELPER_CMD}} process start --pid-file .prizmkit/state/browser-dev-server.pid -- <start-command tokens>
+   ```
+4. Wait for ready:
+   ```bash
+   {{RUNTIME_HELPER_CMD}} web wait-ready --url http://localhost:<DEV_PORT> --timeout 30 --interval 2
+   ```
 
 ---
 
@@ -128,7 +106,7 @@ Append results to `context-snapshot.md`:
    ```
    ## Browser Verification
    Tool: <playwright-cli or opencli>
-   URL: http://localhost:$DEV_PORT
+   URL: http://localhost:<DEV_PORT>
    Dev Server Command: <actual command used>
    Tool version: <version>
    Steps executed: [list of commands used]
@@ -140,11 +118,3 @@ Append results to `context-snapshot.md`:
 
 If verification fails, log the failure details but continue to commit. Failures do NOT block the commit, but you MUST attempt verification and MUST clean up the dev server.
 
-
-**Checkpoint update**: Run the update script to set step `browser-verification` to `"completed"`:
-```bash
-python3 $PIPELINE_DIR/scripts/update-checkpoint.py \
-  --checkpoint-path {{CHECKPOINT_PATH}} \
-  --step browser-verification \
-  --status completed
-```

package/bundled/dev-pipeline/templates/sections/phase-browser-verification-opencli.md

@@ -12,13 +12,13 @@ You MUST execute this phase. Do NOT skip it. Do NOT mark it as completed without
 
 0a. Check if `opencli` is installed:
 ```bash
-which opencli 2>/dev/null && opencli --version 2>/dev/null || echo "NOT_INSTALLED"
+{{RUNTIME_HELPER_CMD}} executable version opencli --arg=--version
 ```
 If output is `NOT_INSTALLED`, install it:
 ```bash
 npm install -g @jackwener/opencli@latest
 ```
-Then verify installation succeeded: `opencli --version`. If installation fails, log `## Browser Verification: SKIPPED — opencli installation failed` in context-snapshot.md and proceed to the next phase.
+Then verify installation succeeded: `{{RUNTIME_HELPER_CMD}} executable version opencli --arg=--version`. If installation fails, log `## Browser Verification: SKIPPED — opencli installation failed` in context-snapshot.md and proceed to the next phase.
 
 0b. Verify Browser Bridge connectivity:
 ```bash
@@ -28,7 +28,7 @@ If `opencli doctor` fails (Chrome not running or extension not installed), log `
 
 0c. Learn opencli browser usage (run once per session):
 ```bash
-opencli browser --help 2>/dev/null || opencli --help
+opencli browser --help
 ```
 
 **Step 1 — Start Dev Server**:
@@ -36,31 +36,22 @@ opencli browser --help 2>/dev/null || opencli --help
 You know this project's tech stack. Detect and start the dev server yourself:
 
 1. Identify the dev server start command from project config (`package.json` scripts, `Makefile`, `docker-compose.yml`, etc.)
-2. **Detect the dev server port** — use the pre-detected port from pipeline if available, otherwise extract from project config. Do NOT hardcode or guess the port:
+2. Determine the dev server port from the pre-detected pipeline value (`{{DEV_PORT}}`) or project config. Do NOT hardcode or guess the port. Record it as `DEV_PORT` in your notes.
+3. Verify the port is available:
    ```bash
-   DEV_PORT={{DEV_PORT}}
-   if [ "$DEV_PORT" = "{{DEV_PORT}}" ]; then
-     DEV_PORT=$(node -e "const s=require('./package.json').scripts.dev; const m=s.match(/-p\s+(\d+)/); console.log(m?m[1]:'')")
-     if [ -z "$DEV_PORT" ]; then
-       DEV_PORT=$(echo "$NEXT_PUBLIC_SITE_URL" | sed -nE 's|.*:([0-9]+).*|\1|p')
-     fi
-     DEV_PORT=${DEV_PORT:-3000}
-   fi
-   echo "Detected DEV_PORT=$DEV_PORT"
+   {{RUNTIME_HELPER_CMD}} port check <DEV_PORT>
    ```
-3. Verify the port is available:
+4. Start the dev server with the runtime helper and capture a PID file:
    ```bash
-   lsof -ti:$DEV_PORT 2>/dev/null && echo "PORT_IN_USE" || echo "PORT_FREE"
+   {{RUNTIME_HELPER_CMD}} process start --pid-file .prizmkit/state/browser-dev-server.pid -- <start-command tokens>
    ```
-4. Start the dev server in background, capture PID:
+5. Wait for server to be ready:
    ```bash
-   <start-command> &
-   DEV_SERVER_PID=$!
+   {{RUNTIME_HELPER_CMD}} web wait-ready --url http://localhost:<DEV_PORT> --timeout 30 --interval 2
    ```
-5. Wait for server to be ready: poll `http://localhost:$DEV_PORT` with `curl -s -o /dev/null -w "%{http_code}"` until it returns 200 or 302 (max 30 seconds, 2s interval)
 6. Open the app in opencli and inspect page state:
    ```bash
-   opencli browser open http://localhost:$DEV_PORT && opencli browser state
+   opencli browser open http://localhost:<DEV_PORT> && opencli browser state
    ```
 7. If the page requires authentication, use opencli browser to interact with login forms (opencli reuses Chrome cookies, so SSO/OAuth may already be active)
 
@@ -82,13 +73,8 @@ Key opencli browser commands for verification:
 
 **Chain commands aggressively with `&&`** to minimize tool calls:
 ```bash
-# GOOD: open + inspect in one call
-opencli browser open http://localhost:$DEV_PORT && opencli browser state
-
-# GOOD: fill form in one call
+opencli browser open http://localhost:<DEV_PORT> && opencli browser state
 opencli browser type 3 "hello" && opencli browser type 4 "world" && opencli browser click 7
-
-# GOOD: click + wait + re-inspect
 opencli browser click 12 && opencli browser wait time 1 && opencli browser state
 ```
 
@@ -99,8 +85,14 @@ Construct your verification workflow based on: (1) the `opencli browser --help`
 **Step 3 — Cleanup (REQUIRED — you started it, you stop it)**:
 
 1. Close the opencli browser session: `opencli browser close`
-2. Kill the dev server process: `kill $DEV_SERVER_PID 2>/dev/null || true`
-3. Verify port is released: `lsof -ti:$DEV_PORT | xargs kill -9 2>/dev/null || true`
+2. Stop the dev server process using the PID file written in Step 1:
+   ```bash
+   {{RUNTIME_HELPER_CMD}} process cleanup-pid <pid-from-.prizmkit/state/browser-dev-server.pid>
+   ```
+3. Verify port is released:
+   ```bash
+   {{RUNTIME_HELPER_CMD}} port check <DEV_PORT>
+   ```
 
 **Step 4 — Reporting**:
 
@@ -108,7 +100,7 @@ Append results to `context-snapshot.md`:
    ```
    ## Browser Verification
    Tool: opencli
-   URL: http://localhost:$DEV_PORT
+   URL: http://localhost:<DEV_PORT>
    Dev Server Command: <actual command used>
    opencli version: <version>
    Steps executed: [list of opencli browser commands used]
@@ -120,11 +112,3 @@ Append results to `context-snapshot.md`:
 
 If verification fails, log the failure details but continue to commit. Failures do NOT block the commit, but you MUST attempt verification and MUST clean up the dev server.
 
-
-**Checkpoint update**: Run the update script to set step `browser-verification` to `"completed"`:
-```bash
-python3 $PIPELINE_DIR/scripts/update-checkpoint.py \
-  --checkpoint-path {{CHECKPOINT_PATH}} \
-  --step browser-verification \
-  --status completed
-```

package/bundled/dev-pipeline/templates/sections/phase-browser-verification.md

@@ -10,9 +10,9 @@ You MUST execute this phase. Do NOT skip it. Do NOT mark it as completed without
 
 **Step 0 — Playwright CLI Readiness Check (BLOCKING — must pass before any browser action)**:
 
-0a. Check if `playwright-cli` is installed:
+0a. Check if `playwright-cli` is installed using the runtime helper:
 ```bash
-which playwright-cli 2>/dev/null && playwright-cli --version 2>/dev/null || echo "NOT_INSTALLED"
+{{RUNTIME_HELPER_CMD}} executable version playwright-cli --arg=--version
 ```
 If output is `NOT_INSTALLED`, install it:
 ```bash
@@ -20,7 +20,7 @@ npm install -g @playwright/cli@latest
 ```
 Then verify installation succeeded:
 ```bash
-playwright-cli --version
+{{RUNTIME_HELPER_CMD}} executable version playwright-cli --arg=--version
 ```
 If installation fails, log the error in context-snapshot.md under `## Browser Verification: SKIPPED — playwright-cli installation failed` and proceed to the next phase. Do NOT attempt browser verification without playwright-cli.
 
@@ -32,43 +32,9 @@ Use this output to determine the correct commands for your verification steps. D
 
 0c. Check if playwright-cli skill is installed for the current AI platform:
 ```bash
-# Detect AI CLI platform
-CURRENT_PLATFORM=""
-if which claude >/dev/null 2>&1; then
-  CURRENT_PLATFORM="claude"
-  SKILL_DIR="$HOME/.claude/skills"
-elif which cbc >/dev/null 2>&1; then
-  CURRENT_PLATFORM="codebuddy"
-  SKILL_DIR="$HOME/.cbc/skills"
-else
-  # Try to detect from environment or config
-  CURRENT_PLATFORM="unknown"
-fi
-
-# Check if playwright-cli skill exists
-if [ -d "$SKILL_DIR/playwright-cli" ] || ls "$SKILL_DIR"/playwright* 2>/dev/null | grep -q .; then
-  echo "SKILL_EXISTS"
-else
-  echo "SKILL_MISSING"
-fi
-```
-If `SKILL_MISSING`:
-```bash
-# Install playwright-cli skills (defaults to claude platform)
-playwright-cli install --skills
-```
-If the current platform is NOT claude, move the installed skill files to the correct location:
-```bash
-# Skills are installed to claude's default location — move to current platform's skill dir
-if [ "$CURRENT_PLATFORM" != "claude" ] && [ "$CURRENT_PLATFORM" != "unknown" ]; then
-  CLAUDE_SKILL_DIR="$HOME/.claude/skills"
-  if [ -d "$CLAUDE_SKILL_DIR/playwright-cli" ]; then
-    mkdir -p "$SKILL_DIR"
-    cp -r "$CLAUDE_SKILL_DIR/playwright-cli" "$SKILL_DIR/"
-    echo "Moved playwright-cli skill from claude to $CURRENT_PLATFORM"
-  fi
-fi
+{{RUNTIME_HELPER_CMD}} platform skill playwright-cli --prefix
 ```
+If `SKILL_MISSING`: run `playwright-cli install --skills`. If current platform is NOT claude, copy installed skill from `$HOME/.claude/skills/playwright-cli` to the path shown by the helper output for the current platform.
 
 0d. Read the installed playwright-cli skill for workflow guidance:
 After skill installation, read the skill's SKILL.md to understand recommended workflows and patterns. Use these patterns to construct your verification flow — do NOT invent your own patterns if the skill provides them.
@@ -78,31 +44,20 @@ After skill installation, read the skill's SKILL.md to understand recommended wo
 You know this project's tech stack. Detect and start the dev server yourself:
 
 1. Identify the dev server start command from project config (`package.json` scripts, `Makefile`, `docker-compose.yml`, etc.)
-2. **Detect the dev server port** — use the pre-detected port from pipeline if available, otherwise extract from project config. Do NOT hardcode or guess the port:
+2. Use the pre-detected port if available, otherwise determine the dev server port from project config. Do NOT hardcode or guess the port. Record it as `DEV_PORT` in your notes.
+3. Verify the port is available:
    ```bash
-   # Use pipeline-injected port if available, otherwise extract from package.json
-   DEV_PORT={{DEV_PORT}}
-   # If DEV_PORT is still a placeholder, detect at runtime:
-   if [ "$DEV_PORT" = "{{DEV_PORT}}" ]; then
-     DEV_PORT=$(node -e "const s=require('./package.json').scripts.dev; const m=s.match(/-p\s+(\d+)/); console.log(m?m[1]:'')")
-     if [ -z "$DEV_PORT" ]; then
-       DEV_PORT=$(echo "$NEXT_PUBLIC_SITE_URL" | sed -nE 's|.*:([0-9]+).*|\1|p')
-     fi
-     DEV_PORT=${DEV_PORT:-3000}
-   fi
-   echo "Detected DEV_PORT=$DEV_PORT"
+   {{RUNTIME_HELPER_CMD}} port check {{DEV_PORT}}
    ```
-3. Verify the port is available:
+4. Start the dev server with the runtime helper and capture a PID file:
    ```bash
-   lsof -ti:$DEV_PORT 2>/dev/null && echo "PORT_IN_USE" || echo "PORT_FREE"
+   {{RUNTIME_HELPER_CMD}} process start --pid-file .prizmkit/state/browser-dev-server.pid -- <start-command tokens>
    ```
-4. Start the dev server in background, capture PID:
+5. Wait for server to be ready:
    ```bash
-   <start-command> &
-   DEV_SERVER_PID=$!
+   {{RUNTIME_HELPER_CMD}} web wait-ready --url http://localhost:{{DEV_PORT}} --timeout 30 --interval 2
    ```
-5. Wait for server to be ready: poll `http://localhost:$DEV_PORT` with `curl -s -o /dev/null -w "%{http_code}"` until it returns 200 or 302 (max 30 seconds, 2s interval)
-6. Open the app in playwright-cli: `playwright-cli open http://localhost:$DEV_PORT`
+6. Open the app in playwright-cli: `playwright-cli open http://localhost:{{DEV_PORT}}`
 7. If the page requires authentication, use playwright-cli to register a test user and log in first
 
 **Step 2 — Verification**:
@@ -122,15 +77,21 @@ Take a final screenshot for evidence: `playwright-cli screenshot`
 **Step 3 — Cleanup (REQUIRED — you started it, you stop it)**:
 
 1. Close the playwright-cli browser: `playwright-cli close`
-2. Kill the dev server process: `kill $DEV_SERVER_PID 2>/dev/null || true`
-3. Verify port is released: `lsof -ti:$DEV_PORT | xargs kill -9 2>/dev/null || true`
+2. Stop the dev server process using the PID file written in Step 1:
+   ```bash
+   {{RUNTIME_HELPER_CMD}} process cleanup-pid <pid-from-.prizmkit/state/browser-dev-server.pid>
+   ```
+3. Verify port is released:
+   ```bash
+   {{RUNTIME_HELPER_CMD}} port check {{DEV_PORT}}
+   ```
 
 **Step 4 — Reporting**:
 
 Append results to `context-snapshot.md`:
 ```
 ## Browser Verification
-URL: http://localhost:$DEV_PORT
+URL: http://localhost:<DEV_PORT>
 Dev Server Command: <actual command used>
 playwright-cli version: <version>
 Steps executed: [list of playwright-cli commands used]
@@ -142,11 +103,3 @@ Browser cleanup: confirmed
 
 If verification fails, log the failure details but continue to commit. Failures do NOT block the commit, but you MUST attempt verification and MUST clean up the dev server.
 
-
-**Checkpoint update**: Run the update script to set step `browser-verification` to `"completed"`:
-```bash
-python3 $PIPELINE_DIR/scripts/update-checkpoint.py \
-  --checkpoint-path {{CHECKPOINT_PATH}} \
-  --step browser-verification \
-  --status completed
-```

package/bundled/dev-pipeline/templates/sections/phase-commit-full.md

@@ -55,20 +55,6 @@ Rules for writing completion notes:
 - If this feature has no downstream dependents, still write the summary (it serves as documentation)
 
 
-**Checkpoint update**: After `/prizmkit-retrospective` completes, run the update script to set step `prizmkit-retrospective` to `"completed"`:
-```bash
-python3 $PIPELINE_DIR/scripts/update-checkpoint.py \
-  --checkpoint-path {{CHECKPOINT_PATH}} \
-  --step prizmkit-retrospective \
-  --status completed
-```
-After `/prizmkit-committer` completes, set step `prizmkit-committer` to `"completed"`:
-```bash
-python3 $PIPELINE_DIR/scripts/update-checkpoint.py \
-  --checkpoint-path {{CHECKPOINT_PATH}} \
-  --step prizmkit-committer \
-  --status completed
-```
 
 ### TERMINAL STOP — Commit Completed
 

package/bundled/dev-pipeline/templates/sections/phase-commit.md

@@ -48,20 +48,6 @@ Rules for writing completion notes:
 - If this feature has no downstream dependents, still write the summary (it serves as documentation)
 
 
-**Checkpoint update**: After `/prizmkit-retrospective` completes, run the update script to set step `prizmkit-retrospective` to `"completed"`:
-```bash
-python3 $PIPELINE_DIR/scripts/update-checkpoint.py \
-  --checkpoint-path {{CHECKPOINT_PATH}} \
-  --step prizmkit-retrospective \
-  --status completed
-```
-After `/prizmkit-committer` completes, set step `prizmkit-committer` to `"completed"`:
-```bash
-python3 $PIPELINE_DIR/scripts/update-checkpoint.py \
-  --checkpoint-path {{CHECKPOINT_PATH}} \
-  --step prizmkit-committer \
-  --status completed
-```
 
 ### TERMINAL STOP — Commit Completed
 

package/bundled/dev-pipeline/templates/sections/phase-context-snapshot-agent-suffix.md

@@ -22,10 +22,3 @@
      - <trap entries extracted from L1/L2 docs>
 
 
-**Checkpoint update**: Run the update script to set step `context-snapshot` to `"completed"`:
-```bash
-python3 $PIPELINE_DIR/scripts/update-checkpoint.py \
-  --checkpoint-path {{CHECKPOINT_PATH}} \
-  --step context-snapshot \
-  --status completed
-```

package/bundled/dev-pipeline/templates/sections/phase-context-snapshot-base.md

@@ -1,7 +1,7 @@
 ### Build Context Snapshot
 
 ```bash
-ls .prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md 2>/dev/null && echo "EXISTS" || echo "MISSING"
+{{RUNTIME_HELPER_CMD}} artifact exists .prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md
 ```
 
 If MISSING — build it now:
@@ -10,5 +10,3 @@ If MISSING — build it now:
 3. Write `.prizmkit/specs/{{FEATURE_SLUG}}/context-snapshot.md`:
    - **Section 1 — Feature Brief**: 2-3 line feature description from Task Contract
    - **Section 2 — Verification Gates**: gate checklist from Task Contract
-   - **Section 3 — Key TRAPS & RULES**: extract only relevant TRAPS/RULES from prizm-docs that apply to files in this scope. Do NOT copy full L0/L1/L2 content.
-   - **Section 4 — File Manifest**: file path, why needed, key interfaces. Format: Files to Modify | Files for Reference tables.

package/bundled/dev-pipeline/templates/sections/phase-context-snapshot-lite-suffix.md

@@ -10,10 +10,3 @@
      |------|-----------|----------------|
 
 
-**Checkpoint update**: Run the update script to set step `context-snapshot` to `"completed"`:
-```bash
-python3 $PIPELINE_DIR/scripts/update-checkpoint.py \
-  --checkpoint-path {{CHECKPOINT_PATH}} \
-  --step context-snapshot \
-  --status completed
-```

package/bundled/dev-pipeline/templates/sections/phase-critic-plan-full.md

@@ -2,7 +2,7 @@
 
 **Guard**: Verify critic agent file exists before spawning:
 ```bash
-ls {{CRITIC_SUBAGENT_PATH}} 2>/dev/null && echo "CRITIC:READY" || echo "CRITIC:MISSING"
+{{RUNTIME_HELPER_CMD}} artifact exists {{CRITIC_SUBAGENT_PATH}} --exists-marker CRITIC:READY --missing-marker CRITIC:MISSING
 ```
 If CRITIC:MISSING — skip this phase entirely and proceed. Log: "Critic agent not installed — skipping Plan Challenge."
 
@@ -26,13 +26,18 @@ If CRITIC:MISSING — skip this phase entirely and proceed. Log: "Critic agent n
 | subagent_type | prizm-dev-team-critic |
 | mode | plan |
 | run_in_background | false |
+| isolation | default/no worktree; do not request worktree isolation |
+
+No-worktree boundary: this prevents AI tool-created `.claude/worktrees/...` subagent worktrees. It does not disable PrizmKit pipeline-managed linked git worktrees under `.prizmkit/state/worktrees/...`, which are controlled separately by `USE_WORKTREE`.
 
 **Prompt**:
 > {{AGENT_PROMPT_CRITIC_PLAN_CHALLENGE}}
 
 **If {{CRITIC_COUNT}} = 3 → Multi-Critic Voting** (skip Single Critic above):
 
-Spawn 3 Critic agents in PARALLEL (issue all 3 Agent tool calls in the SAME message turn). Do NOT wait for one before spawning the next. Each with mode="plan", run_in_background=false:
+Spawn 3 Critic agents in PARALLEL (issue all 3 Agent tool calls in the SAME message turn). Do NOT wait for one before spawning the next. Each with mode="plan", run_in_background=false, and default/no worktree isolation; do not request worktree isolation.
+
+No-worktree boundary: default/no worktree isolation prevents AI tool-created `.claude/worktrees/...` subagent worktrees. It does not disable PrizmKit pipeline-managed linked git worktrees under `.prizmkit/state/worktrees/...`, which are controlled separately by `USE_WORKTREE`.
 
 Critic-A prompt (append to base prompt above):
 > "**Focus Lens: Architecture & Scalability.** Prioritize: architectural pattern fit, scalability implications, over-engineering risks, component boundary design.
@@ -54,10 +59,3 @@ After all critics return, read all 3 reports:
 **CP-2.5**: Plan challenges reviewed and resolved.
 
 
-**Checkpoint update**: Run the update script to set step `critic-plan-review` to `"completed"`:
-```bash
-python3 $PIPELINE_DIR/scripts/update-checkpoint.py \
-  --checkpoint-path {{CHECKPOINT_PATH}} \
-  --step critic-plan-review \
-  --status completed
-```

package/bundled/dev-pipeline/templates/sections/phase-critic-plan.md

@@ -2,7 +2,7 @@
 
 **Guard**: Verify critic agent file exists before spawning:
 ```bash
-ls {{CRITIC_SUBAGENT_PATH}} 2>/dev/null && echo "CRITIC:READY" || echo "CRITIC:MISSING"
+{{RUNTIME_HELPER_CMD}} artifact exists {{CRITIC_SUBAGENT_PATH}} --exists-marker CRITIC:READY --missing-marker CRITIC:MISSING
 ```
 If CRITIC:MISSING — skip this phase entirely and proceed. Log: "Critic agent not installed — skipping Plan Challenge."
 
@@ -12,6 +12,9 @@ If CRITIC:MISSING — skip this phase entirely and proceed. Log: "Critic agent n
 | subagent_type | prizm-dev-team-critic |
 | mode | plan |
 | run_in_background | false |
+| isolation | default/no worktree; do not request worktree isolation |
+
+No-worktree boundary: this prevents AI tool-created `.claude/worktrees/...` subagent worktrees. It does not disable PrizmKit pipeline-managed linked git worktrees under `.prizmkit/state/worktrees/...`, which are controlled separately by `USE_WORKTREE`.
 
 **Prompt**:
 > {{AGENT_PROMPT_CRITIC_PLAN_CHALLENGE}}
@@ -33,10 +36,3 @@ Wait for Critic to return.
 **CP-2.5**: Plan challenges reviewed and resolved.
 
 
-**Checkpoint update**: Run the update script to set step `critic-plan-review` to `"completed"`:
-```bash
-python3 $PIPELINE_DIR/scripts/update-checkpoint.py \
-  --checkpoint-path {{CHECKPOINT_PATH}} \
-  --step critic-plan-review \
-  --status completed
-```

package/bundled/dev-pipeline/templates/sections/phase-implement-agent.md

@@ -43,10 +43,3 @@ For each Verification Gate from the Task Contract, write one evidence line to Im
 
 **CP-2**: All tasks `[x]`, Implementation Log written with Gate Evidence, and blocked gates documented in `failure-log.md`. Test execution is deferred until after code review.
 
-**Checkpoint update**:
-```bash
-python3 $PIPELINE_DIR/scripts/update-checkpoint.py \
-  --checkpoint-path {{CHECKPOINT_PATH}} \
-  --step prizmkit-implement \
-  --status completed
-```

package/bundled/dev-pipeline/templates/sections/phase-implement-full.md

@@ -43,10 +43,3 @@ For each Verification Gate from the Task Contract, write one evidence line to Im
 
 **CP-2**: All tasks `[x]`, Implementation Log written with Gate Evidence, and blocked gates documented in `failure-log.md`. Test execution is deferred until after code review.
 
-**Checkpoint update**:
-```bash
-python3 $PIPELINE_DIR/scripts/update-checkpoint.py \
-  --checkpoint-path {{CHECKPOINT_PATH}} \
-  --step prizmkit-implement \
-  --status completed
-```

package/bundled/dev-pipeline/templates/sections/phase-implement-lite.md

@@ -21,10 +21,3 @@
 **CP-2**: Implementation may proceed only when all tasks are `[x]` and blocked gates are documented in `failure-log.md`. Test execution is deferred until after code review.
 
 
-**Checkpoint update**: Run the update script to set step `prizmkit-implement` to `"completed"`:
-```bash
-python3 $PIPELINE_DIR/scripts/update-checkpoint.py \
-  --checkpoint-path {{CHECKPOINT_PATH}} \
-  --step prizmkit-implement \
-  --status completed
-```

package/bundled/dev-pipeline/templates/sections/phase-plan-agent.md

@@ -1,27 +1,20 @@
 ### Plan & Tasks
 
 ```bash
-ls .prizmkit/specs/{{FEATURE_SLUG}}/plan.md 2>/dev/null
+{{RUNTIME_HELPER_CMD}} artifact exists .prizmkit/specs/{{FEATURE_SLUG}}/plan.md
 ```
 
 If missing, run `/prizmkit-plan` with `artifact_dir=.prizmkit/specs/{{FEATURE_SLUG}}/` to generate `plan.md`:
 - The plan.md should include: architecture — components, interfaces, data flow, files to create/modify, testing approach, and a Tasks section with `[ ]` checkboxes ordered by dependency.
-- Resolve any `[NEEDS CLARIFICATION]` markers using the feature description — do NOT pause for interactive input.
+- Resolve uncertain requirements from the feature description, existing code, and conservative existing-project patterns.
 
 **Database Design Gate** (if feature involves data persistence — new tables, schema changes, new entities):
 Before proceeding past CP-1, verify:
 1. Plan.md Data Model section references existing schema/model files (scan for `*.prisma`, `*.sql`, `migrations/`, `models/`, `*.entity.*` files; read them if not already in context-snapshot)
 2. All new tables/fields follow existing naming conventions, ID strategy, timestamp patterns, and constraint style
-3. No `[NEEDS CLARIFICATION]` remains in Data Model section — resolve by reading existing code and making a conservative choice that matches existing patterns. Document the resolution in plan.md.
+3. No unresolved data model uncertainty remains in the Data Model section — resolve by reading existing code and making a conservative choice that matches existing patterns. Document the resolution in plan.md.
 4. If a DB design decision genuinely cannot be resolved from existing code alone, document the assumption made and flag it in the Implementation Log for user review.
 
 **CP-1**: plan.md exists with Tasks section.
 
 
-**Checkpoint update**: Run the update script to set step `prizmkit-plan` to `"completed"`:
-```bash
-python3 $PIPELINE_DIR/scripts/update-checkpoint.py \
-  --checkpoint-path {{CHECKPOINT_PATH}} \
-  --step prizmkit-plan \
-  --status completed
-```