@pennyfarthing/core 11.1.1 → 11.2.1

package/pennyfarthing-dist/gates/quality-pass.md

@@ -0,0 +1,67 @@
+<gate name="quality-pass" model="haiku">
+
+<purpose>
+Verify that all project quality gates pass locally — lint, type checks, and
+tests — before handing off to the next phase. This gate wraps the check.py
+quality runner to ensure the codebase is clean enough for Reviewer's time.
+</purpose>
+
+<pass>
+Run the quality gate script for the repos listed in the session file:
+
+```bash
+source .venv/bin/activate && python3 .pennyfarthing/scripts/workflow/check.py
+```
+
+The script runs lint, type checks, and tests concurrently. Exit code 0 means
+all checks passed.
+
+If ALL checks pass, return:
+
+```yaml
+GATE_RESULT:
+  status: pass
+  gate: quality-pass
+  message: "All quality gates passing — lint, typecheck, tests clean."
+  checks:
+    - name: lint
+      status: pass
+      detail: "Lint clean"
+    - name: typecheck
+      status: pass
+      detail: "Type checks passing"
+    - name: tests
+      status: pass
+      detail: "All tests passing"
+```
+</pass>
+
+<fail>
+If the script exits non-zero, parse its output to identify which checks failed.
+The script prints `[PASS]` or `[FAIL]` for each check (Lint, Type Check, Tests).
+
+Return with actionable recovery guidance:
+
+```yaml
+GATE_RESULT:
+  status: fail
+  gate: quality-pass
+  message: "Quality gate failed: {summary of failures}"
+  checks:
+    - name: lint
+      status: pass | fail
+      detail: "{lint results or specific failures}"
+    - name: typecheck
+      status: pass | fail
+      detail: "{typecheck results or specific errors}"
+    - name: tests
+      status: pass | fail
+      detail: "{test results or failing test details}"
+  recovery:
+    - "Fix lint errors: run `npm run lint` to see details"
+    - "Fix type errors: run `tsc --noEmit` to see details"
+    - "Fix failing tests: run `pnpm test` to see details"
+```
+</fail>
+
+</gate>

package/pennyfarthing-dist/gates/tests-fail.md

@@ -0,0 +1,84 @@
+<gate name="tests-fail" model="haiku">
+
+<purpose>
+Verify tests are RED — failing tests exist that cover the acceptance
+criteria. TEA has written tests but implementation hasn't started.
+This gate runs after the TEA agent's red phase to confirm the codebase
+has proper test coverage before Dev begins implementation.
+</purpose>
+
+<pass>
+Run these checks and report results:
+
+1. **Failing tests exist:** Run the project test suite for the repos listed in the session file.
+   - For `pennyfarthing` repo: `cd pennyfarthing && python3 -m pytest` or `pnpm test`
+   - Record: total tests, passed, failed, skipped
+   - At least one test MUST be failing (RED state)
+
+2. **Tests cover acceptance criteria:** Read the session file's Acceptance Criteria section.
+   - Cross-reference test names/descriptions against each AC
+   - Each AC should have at least one corresponding test
+
+3. **Tests are committed:** Run `git status --porcelain` to check for uncommitted test files.
+   - All test files should be committed to the branch
+   - No uncommitted test files should exist
+
+If ALL checks pass, return:
+
+```yaml
+GATE_RESULT:
+  status: pass
+  gate: tests-fail
+  message: "{N} failing tests covering {M} acceptance criteria. Tests committed."
+  checks:
+    - name: failing-tests
+      status: pass
+      detail: "{failed}/{total} tests failing (RED state confirmed)"
+    - name: ac-coverage
+      status: pass
+      detail: "All {M} acceptance criteria have test coverage"
+    - name: tests-committed
+      status: pass
+      detail: "All test files committed to branch"
+```
+</pass>
+
+<fail>
+If ANY check fails, diagnose and report:
+
+1. **No failing tests found:** TEA didn't write tests or tests are already passing.
+   - This means implementation may have leaked into the red phase
+   - Or tests are not properly asserting against unimplemented code
+
+2. **Tests don't cover ACs:** Some acceptance criteria lack test coverage.
+   - List which ACs are missing tests
+   - TEA needs to add additional test cases
+
+3. **Tests aren't committed:** Uncommitted test files exist.
+   - List uncommitted test files
+   - TEA needs to commit before handoff
+
+Return with actionable recovery guidance:
+
+```yaml
+GATE_RESULT:
+  status: fail
+  gate: tests-fail
+  message: "Gate failed: {summary of what's missing}"
+  checks:
+    - name: failing-tests
+      status: pass | fail
+      detail: "{description of test state}"
+    - name: ac-coverage
+      status: pass | fail
+      detail: "{list of uncovered ACs}"
+    - name: tests-committed
+      status: pass | fail
+      detail: "{list of uncommitted files}"
+  recovery:
+    - "Write failing tests for: {uncovered ACs}"
+    - "Commit test files: git add {files} && git commit"
+```
+</fail>
+
+</gate>

package/pennyfarthing-dist/gates/tests-pass.md

@@ -0,0 +1,79 @@
+<gate name="tests-pass" model="haiku">
+
+<purpose>
+Verify that all tests pass and the working tree is clean before handing off
+to the reviewer. This gate runs after the Dev agent's implementation phase
+to confirm the codebase is in a GREEN state.
+</purpose>
+
+<pass>
+Run these checks and report results:
+
+1. **Test suite:** Run the project test suite for the repos listed in the session file.
+   - For `pennyfarthing` repo: `cd pennyfarthing && pnpm test`
+   - For `orchestrator` repo: tests in the orchestrator root if applicable
+   - Record: total tests, passed, failed, skipped
+
+2. **Working tree:** Run `git status --porcelain` in each repo listed in session `**Repos:**`.
+   - Verify no uncommitted or untracked files (empty output = clean)
+
+3. **Branch status:** Run `git branch --show-current` and `git log --oneline -1`.
+   - Confirm on the expected feature branch from session `**Branch:**`
+
+If ALL checks pass, return:
+
+```yaml
+GATE_RESULT:
+  status: pass
+  gate: tests-pass
+  message: "All {N} tests passing. Working tree clean. Branch: {branch}"
+  checks:
+    - name: test-suite
+      status: pass
+      detail: "{passed}/{total} tests passing ({skipped} skipped)"
+    - name: working-tree
+      status: pass
+      detail: "No uncommitted changes"
+    - name: branch-status
+      status: pass
+      detail: "On branch {branch}, HEAD at {short-sha}"
+```
+</pass>
+
+<fail>
+If ANY check fails, diagnose and report:
+
+1. **Failing tests:** List each failing test file and line number.
+   - Run tests with verbose output to capture failure details.
+   - Group failures by file.
+
+2. **Dirty working tree:** List uncommitted and untracked files.
+   - Run `git status --porcelain` and report each file with its status code.
+
+3. **Wrong branch:** Report actual vs expected branch name.
+
+Return with actionable recovery guidance:
+
+```yaml
+GATE_RESULT:
+  status: fail
+  gate: tests-pass
+  message: "Gate failed: {summary of failures}"
+  checks:
+    - name: test-suite
+      status: pass | fail
+      detail: "{description of test results or failures}"
+    - name: working-tree
+      status: pass | fail
+      detail: "{list of uncommitted files, or 'clean'}"
+    - name: branch-status
+      status: pass | fail
+      detail: "{branch info or mismatch details}"
+  recovery:
+    - "Fix failing tests in: {file1}, {file2}"
+    - "Commit or stash uncommitted changes before handoff"
+    - "Switch to correct branch: git checkout {expected-branch}"
+```
+</fail>
+
+</gate>

package/pennyfarthing-dist/guides/agent-behavior.md

@@ -49,7 +49,7 @@ On activation, check session file for a `**Tandem:**` line (e.g., `**Tandem:** a
 
 **If tandem is configured:**
 
-1. **Resolve backseat persona** from theme:
+1. **Resolve backseat persona** from theme using the `pf theme`
    ```bash
    THEME=$(yq '.theme' .pennyfarthing/config.local.yaml)
    PARTNER_CHARACTER=$(yq ".agents.{PARTNER}.character" .pennyfarthing/personas/themes/${THEME}.yaml)
@@ -98,16 +98,17 @@ See `.pennyfarthing/guides/tandem-protocol.md` for full protocol details.
 ## Reflector
 
 <critical>
-**EVERY TURN MUST END WITH A CYCLIST MARKER.** Stop hook enforces this.
-
-| Situation | Marker |
-|-----------|--------|
-| Workflow handoff | `<!-- CYCLIST:HANDOFF:/agent -->` |
-| Handoff + context >80% | `<!-- CYCLIST:CONTEXT_CLEAR:/agent -->` |
-| Yes/no question | `<!-- CYCLIST:QUESTION:yesno -->` |
-| Open-ended question | `<!-- CYCLIST:QUESTION:open -->` |
-| Multiple choice | `<!-- CYCLIST:CHOICES:a,b,c -->` |
-| Everything else | `<!-- CYCLIST:CONTINUE -->` |
+**Cyclist only:** EVERY TURN MUST END WITH A CYCLIST MARKER. Stop hook enforces this.
+**CLI mode:** Do NOT emit CYCLIST markers — they are inert outside Cyclist.
+
+| Situation | Cyclist Marker | CLI Behavior |
+|-----------|---------------|--------------|
+| Workflow handoff | `<!-- CYCLIST:HANDOFF:/agent -->` | Use AGENT_COMMAND `action` field |
+| Handoff + context >80% | `<!-- CYCLIST:CONTEXT_CLEAR:/agent -->` | Tell user to `/clear` then run agent |
+| Yes/no question | `<!-- CYCLIST:QUESTION:yesno -->` | Ask user directly |
+| Open-ended question | `<!-- CYCLIST:QUESTION:open -->` | Ask user directly |
+| Multiple choice | `<!-- CYCLIST:CHOICES:a,b,c -->` | Ask user directly |
+| Everything else | `<!-- CYCLIST:CONTINUE -->` | (no marker needed) |
 </critical>
 
 ---
@@ -124,7 +125,12 @@ See `.pennyfarthing/guides/tandem-protocol.md` for full protocol details.
    - If fail → fix issues, retry from step 3 (max 3 retries)
    - If pass → continue
 7. `pf handoff complete-phase {story-id} {workflow} {from} {to} {gate-type}`
-8. `pf handoff marker {next_agent}` → emit marker → EXIT
+8. `pf handoff marker {next_agent}` → AGENT_COMMAND block
+9. **Act on AGENT_COMMAND:**
+   - Has `marker:` field → emit the CYCLIST marker (Cyclist path)
+   - `action: "inline_handoff"` → run `activation_command` via Bash, output result, adopt new agent identity
+   - `action: "tirepump_handoff"` → tell user: "Context is high. Run `/clear` then `{fallback}`"
+   - No action, no marker → output `fallback` text and EXIT
 
 **Agents drive exit directly — no handoff subagent.** Scripts handle routing and session updates atomically.
 </agent-exit-protocol>
@@ -135,14 +141,12 @@ See `.pennyfarthing/guides/tandem-protocol.md` for full protocol details.
 On activation, check if story phase belongs to you:
 
 ```bash
-OWNER=$(.pennyfarthing/scripts/workflow/phase-owner.sh {workflow} {phase})
-# If OWNER != your agent → emit handoff marker and EXIT
+pf handoff phase-check {your_agent_name}
 ```
 
-Output:
-```
-<!-- CYCLIST:HANDOFF:/{OWNER} -->
+If result has `action: "redirect"`:
 
-Run `/pf-{OWNER}` to continue
-```
+- **Cyclist:** Emit `<!-- CYCLIST:HANDOFF:/{phase_owner} -->` and EXIT
+- **CLI + relay ON:** Run `pf agent start {phase_owner} --tier handoff --quiet` via Bash, adopt new identity
+- **CLI + relay OFF:** Output `Run /pf-{phase_owner} to continue` and EXIT
 </wrong-phase-detection>

package/pennyfarthing-dist/guides/agent-tag-taxonomy.md

@@ -175,7 +175,7 @@ Logic for checking if this agent owns the current phase.
 
 Read `**Workflow:**` and `**Phase:**` from session. Query:
 ```bash
-OWNER=$(.pennyfarthing/scripts/workflow/phase-owner.sh {workflow} {phase})
+OWNER=$(pf workflow phase-check {workflow} {phase})
 ```
 
 **If OWNER != "dev":** Run `pf handoff marker $OWNER`, output result, tell user.

package/pennyfarthing-dist/guides/bell-mode.md

@@ -26,7 +26,7 @@ User queues message in Editor
 |------|---------|
 | `packages/cyclist/src/bell-mode.ts` | State management: `isBellModeEnabled()`, `setBellMode()`, `toggleBellMode()` |
 | `packages/cyclist/src/api/bell.ts` | WebSocket broadcast of bell-consumed events |
-| `pennyfarthing-dist/scripts/hooks/bell-mode-hook.sh` | PostToolUse hook — reads queue, returns `additionalContext` |
+| `pf hooks bell-mode` | PostToolUse hook — reads queue, returns `additionalContext` |
 | `packages/cyclist/src/public/hooks/useMessageQueue.ts` | React hook: `queueMessage()`, `dequeueMessage()`, `injectMessage()`, `handleTurnComplete()` |
 | `packages/cyclist/src/public/contexts/MessageQueueContext.tsx` | Shared React context (single queue instance across components) |
 | `packages/cyclist/src/public/components/ControlBar.tsx` | Bell mode toggle button |

package/pennyfarthing-dist/guides/bikerack.md

@@ -92,10 +92,10 @@ Client-side detection is URL-based: the presence of `?panel=X` triggers standalo
 
 | File | Purpose |
 |------|---------|
-| `.bikerack-port` | Port number, written after `server.listen()` — readiness signal |
-| `.bikerack-pid` | WheelHub PID, written by launcher — enables `pf bikerack stop` |
+| `.wheelhub-port` | Port number, written after `server.listen()` — readiness signal |
+| `.wheelhub-pid` | WheelHub PID, written by launcher — enables `pf bikerack stop` |
 
-Both are deleted on shutdown. Separate from Cyclist's `.cyclist-port` and `.cyclist-pid` for coexistence.
+Both are deleted on shutdown. Shared with Cyclist (single WheelHub namespace).
 
 ## Layout Persistence
 

package/pennyfarthing-dist/guides/hooks.md

@@ -4,7 +4,7 @@ Pennyfarthing uses Claude Code hooks to integrate with session lifecycle events
 
 ## Overview
 
-Hooks are shell scripts that Claude Code runs at specific events:
+Hooks are commands that Claude Code runs at specific events:
 
 | Hook Type | When It Runs | Purpose |
 |-----------|--------------|---------|
@@ -16,18 +16,18 @@ Hooks are shell scripts that Claude Code runs at specific events:
 
 ### SessionStart Hooks
 
-#### session-start.sh
+#### pf hooks session-start
 
-**Location:** `.pennyfarthing/scripts/hooks/session-start.sh`
+**Location:** `pf hooks session-start`
 
 Initializes the Pennyfarthing environment:
 - Creates `.session/` directory structure
 - Clears stale agent state from previous sessions
 - Sets `PROJECT_ROOT` and `SESSION_ID` environment variables
 
-#### session-stop.sh
+#### pf hooks session-stop
 
-**Location:** `.pennyfarthing/scripts/hooks/session-stop.sh`
+**Location:** `pf hooks session-stop`
 
 Cleans up session state when Claude Code exits.
 
@@ -44,68 +44,68 @@ Project-specific environment setup. Edit this file to:
 
 **Location:** `.pennyfarthing/scripts/hooks/otel-auto-config.sh`
 
-Auto-configures OTEL telemetry for Cyclist web mode. Checks for a `.cyclist-port` file and sets `OTEL_EXPORTER_OTLP_PROTOCOL` and `OTEL_EXPORTER_OTLP_ENDPOINT` to route Claude Code telemetry to the running Cyclist/BikeRack server.
+Auto-configures OTEL telemetry for Cyclist web mode. Checks for a `.wheelhub-port` file and sets `OTEL_EXPORTER_OTLP_PROTOCOL` and `OTEL_EXPORTER_OTLP_ENDPOINT` to route Claude Code telemetry to the running Cyclist/BikeRack server.
 
-#### welcome-hook.sh
+#### pf hooks session-start (welcome)
 
-**Location:** `.pennyfarthing/scripts/hooks/welcome-hook.sh`
+**Location:** `pf hooks session-start`
 
-Displays a welcome message on session start. In CLI mode, shows ASCII art. In Cyclist mode, sends a WebSocket message to display the logo. Runs once per session (lock file guard).
+Welcome display is now folded into `pf hooks session-start`. In CLI mode, shows ASCII art. In Cyclist mode, sends a WebSocket message to display the logo. Runs once per session (lock file guard).
 
 ### PreToolUse Hooks
 
-#### pre-edit-check.sh
+#### pf hooks pre-edit-check
 
-**Location:** `.pennyfarthing/scripts/hooks/pre-edit-check.sh`
+**Location:** `pf hooks pre-edit-check`
 
 Protects sensitive files from accidental edits:
 - Blocks: `.env`, `.pem`, `.key`, credentials, secrets
 - Blocks: `.git/`, `node_modules/`, `vendor/`
 - Blocks: `.pennyfarthing/*` (managed files)
 
-#### cyclist-pretooluse-hook.sh
+#### pf hooks cyclist-pretooluse
 
-**Location:** `.pennyfarthing/scripts/hooks/cyclist-pretooluse-hook.sh`
+**Location:** `pf hooks cyclist-pretooluse`
 
 Cyclist-specific pre-tool validation. Runs additional safety checks when operating inside Cyclist.
 
-#### context-warning.sh
+#### pf hooks context-warning
 
-**Location:** `.pennyfarthing/scripts/hooks/context-warning.sh`
+**Location:** `pf hooks context-warning`
 
 Warns agents when context usage is high. Outputs a warning at 60% usage and a critical warning at 85%. Never blocks — warning only (always exits 0).
 
-#### context-circuit-breaker.sh
+#### pf hooks context-breaker
 
-**Location:** `.pennyfarthing/scripts/hooks/context-circuit-breaker.sh`
+**Location:** `pf hooks context-breaker`
 
-Hard stop when context reaches 80% (configurable via `CRITICAL_THRESHOLD`). Unlike `context-warning.sh`, this **blocks tool execution** (exit 2). Auto-saves the active agent to a checkpoint so `/pf-session continue` can restore it with FULL tier context.
+Hard stop when context reaches 80% (configurable via `CRITICAL_THRESHOLD`). Unlike `pf hooks context-warning`, this **blocks tool execution** (exit 2). Auto-saves the active agent to a checkpoint so `/pf-session continue` can restore it with FULL tier context.
 
-#### schema-validation.sh
+#### pf hooks schema-validation
 
-**Location:** `.pennyfarthing/scripts/hooks/schema-validation.sh`
+**Location:** `pf hooks schema-validation`
 
 Validates file writes against XML schema rules for agent definitions, workflow files, and other structured content.
 
-#### sprint-yaml-validation.sh
+#### pf hooks sprint-yaml
 
-**Location:** `.pennyfarthing/scripts/hooks/sprint-yaml-validation.sh`
+**Location:** `pf hooks sprint-yaml`
 
 Validates sprint YAML files on write to prevent structural corruption.
 
 ### PostToolUse Hooks
 
-#### bell-mode-hook.sh
+#### pf hooks bell-mode
 
-**Location:** `.pennyfarthing/scripts/hooks/bell-mode-hook.sh`
+**Location:** `pf hooks bell-mode`
 
 Bell mode message injection. Checks the bell mode queue and injects queued messages into the agent's context at the next tool execution. Also handles tandem observation injection.
 
-#### question-reflector-check.sh / question_reflector_check.py
+#### pf hooks reflector-check
 
-**Location:** `.pennyfarthing/scripts/hooks/question-reflector-check.sh`
+**Location:** `pf hooks reflector-check`
 
-Stop hook enforcing that every agent turn ends with a CYCLIST marker. Detects questions, handoff phrases, and validates marker presence. Blocks turns without valid markers in Cyclist mode. The `.sh` file wraps the Python implementation.
+Stop hook enforcing that every agent turn ends with a CYCLIST marker. Detects questions, handoff phrases, and validates marker presence. Blocks turns without valid markers in Cyclist mode.
 
 ### Git Hooks
 
@@ -133,7 +133,7 @@ Hooks are configured in `.claude/settings.local.json`:
         "hooks": [
           {
             "type": "command",
-            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/pennyfarthing/scripts/hooks/session-start.sh"
+            "command": "pf hooks session-start"
           }
         ]
       }
@@ -144,7 +144,7 @@ Hooks are configured in `.claude/settings.local.json`:
         "hooks": [
           {
             "type": "command",
-            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/pennyfarthing/scripts/hooks/pre-edit-check.sh"
+            "command": "pf hooks pre-edit-check"
           }
         ]
       }

package/pennyfarthing-dist/guides/reflector.md

@@ -41,7 +41,7 @@ Marker pattern: /<!--\s*CYCLIST:(\w+)(?::([^>]+?))?\s*-->/gi
 | `packages/cyclist/src/public/components/QuickActions.tsx` | Renders action buttons from detected markers |
 | `packages/cyclist/src/public/hooks/useMarkerActions.ts` | Detects markers, builds action metadata |
 | `pennyfarthing-dist/scripts/hooks/question_reflector_check.py` | Stop hook — enforces marker presence |
-| `pennyfarthing-dist/scripts/hooks/question-reflector-check.sh` | Bash wrapper for stop hook |
+| `pf hooks reflector-check` | CLI entry point for stop hook |
 
 ## Enforcement Hook
 

package/pennyfarthing-dist/guides/tandem-protocol.md

@@ -13,7 +13,7 @@ Primary Agent (Opus)          Backseat Agent (Haiku, background)
      │                              │   .session/{story}-tandem-{partner}.md
      │                              │
      ├── PostToolUse hook fires ────┤
-     │   bell-mode-hook.sh detects  │
+     │   pf hooks bell-mode detects │
      │   new observation, injects   │
      │   "[Tandem] Character: ..."  │
      │                              │
@@ -163,8 +163,8 @@ For active, synchronous agent-to-agent questions (as opposed to passive observat
 | `observation-writer.ts` | Built | TypeScript API for observation file I/O |
 | `file-watch.ts` | Built | File system change detection |
 | `tool-watch.ts` | Built | Tool call log monitoring |
-| `bell-mode-hook.sh` | Built | PostToolUse hook with tandem injection |
+| `pf hooks bell-mode` | Built | PostToolUse hook with tandem injection |
 | `bellmode_hook.py` | Built | Python implementation of bell mode hook |
-| `statusline.sh` | Built | CLI statusline with tandem indicator |
+| `pf hooks statusline` | Built | CLI statusline with tandem indicator |
 | `tandem-backseat.md` | Built | Backseat agent prompt template |
 | `agent-behavior.md` | Built | Shared agent behavior with tandem protocol |

package/pennyfarthing-dist/guides/worktree-mode.md

@@ -86,8 +86,8 @@ Ports are stored in the session file and passed to agents.
 | Command | Purpose |
 |---------|---------|
 | `/pf-session parallel` | Start a new parallel work session |
-| `.pennyfarthing/scripts/git/worktree-manager.sh list` | Show active worktrees |
-| `.pennyfarthing/scripts/git/worktree-manager.sh remove <name>` | Clean up a worktree |
+| `pf git worktree list` | Show active worktrees |
+| `pf git worktree remove <name>` | Clean up a worktree |
 
 ## TDD Flow in Worktrees
 
@@ -104,7 +104,7 @@ Agents use worktree paths from session file for all operations.
 When story is complete, SM archives the session and the worktree can be removed:
 
 ```bash
-.pennyfarthing/scripts/git/worktree-manager.sh remove wt-5-3a
+pf git worktree remove wt-5-3a
 ```
 
 This removes:

package/pennyfarthing-dist/guides/xml-tags.md

@@ -124,7 +124,7 @@ Tags used by agents participating in the TDD workflow cycle (SM, TEA, Dev, Revie
 
 **Purpose:** Verify agent owns the current workflow phase before proceeding. Prevents agents from acting on stories they shouldn't own.
 
-**Usage:** SM, TEA, Dev, Reviewer - runs `phase-owner.sh` on activation to determine correct owner.
+**Usage:** SM, TEA, Dev, Reviewer - runs `pf workflow phase-check` on activation to determine correct owner.
 
 ```markdown
 <phase-check>
@@ -132,7 +132,7 @@ Tags used by agents participating in the TDD workflow cycle (SM, TEA, Dev, Revie
 
 Read `**Workflow:**` and `**Phase:**` from session. Query:
 ```bash
-OWNER=$(.pennyfarthing/scripts/workflow/phase-owner.sh {workflow} {phase})
+OWNER=$(pf workflow phase-check {workflow} {phase})
 ```
 
 **If OWNER != "dev":** Run `pf handoff marker $OWNER`, output result, tell user.

package/pennyfarthing-dist/scripts/README.md

@@ -11,7 +11,7 @@ scripts/
 ├── sprint/     # Sprint YAML operations (migrated to pf sprint CLI)
 ├── story/      # Story operations (create-story.sh)
 ├── jira/       # Jira integration (jira-claim-story.sh)
-├── git/        # Git operations (release.sh, worktree-manager.sh)
+├── git/        # Git operations (deprecated shims → pf git CLI)
 ├── theme/      # Theme operations (list-themes.sh)
 ├── test/       # Test infrastructure (test-setup.sh)
 ├── lib/        # Shared bash libraries (common.sh, logging.sh)

package/pennyfarthing-dist/scripts/core/check-context.sh

@@ -12,6 +12,8 @@
 
 set -euo pipefail
 
+echo "DEPRECATED: check-context.sh — use 'pf context' instead" >&2
+
 # Find project root (where pennyfarthing_scripts lives)
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
 
@@ -154,7 +156,7 @@ if last_total:
     status = 'HIGH' if usable_pct > $WARNING_THRESHOLD else 'OK'
     relay = '$RELAY_MODE' == 'true'
     tirepump = (relay or '$PERMISSION_MODE' == 'turbo') and usable_pct > $TIREPUMP_THRESHOLD
-    is_cyclist = os.environ.get('CYCLIST') == '1' or Path('$PROJECT_DIR/packages/cyclist/.cyclist-port').exists()
+    is_cyclist = os.environ.get('CYCLIST') == '1' or Path('$PROJECT_DIR/packages/cyclist/.wheelhub-port').exists()
 
     print(f'CONTEXT_TOKENS={last_total}')
     print(f'CONTEXT_PERCENT={total_pct}')