pluidr 0.4.1 → 0.6.0

package/README.md

@@ -4,94 +4,288 @@
 [![npm downloads](https://img.shields.io/npm/dm/pluidr)](https://www.npmjs.com/package/pluidr)
 [![License](https://img.shields.io/npm/l/pluidr)](https://github.com/funara/pluidr/blob/main/LICENSE)
 
-**Plan · Build · Review · Debug** — opinionated engineering workflow installer for [OpenCode](https://opencode.ai).
+** Plan · Build · Review ** — opinionated engineering workflow installer for [OpenCode](https://opencode.ai).
 
-## How it works
+---
 
-Pluidr sets up a **14-agent** pipeline in OpenCode organized under **4 primary agents**, each with a dedicated tab and exclusive subagents. Every agent has a strict role, scoped permissions, and no shared subagents.
+## What is Pluidr?
 
-### Primary Agents
+Pluidr installs a **17-agent pipeline** into OpenCode — structured around **3 primary agents**, each with their own exclusive subagents, scoped permissions, and enforced workflow rules. No shared subagents. No ad-hoc delegation.
 
-**1. Explorer tab** (optional, research-only) — Brainstorms with you, scans the codebase and web for context, then produces actionable recommendations. No subagents, no file editing. Handoff to Planner when you're ready to formalize.
+| Primary Agent | Purpose | Subagents |
+|---|---|---|
+| **Composer** | Feature work — Explore → Plan → Build | Researcher, Plan-Writer, Plan-Checker, Coder, Tester, Reviewer, Compose-Reporter |
+| **Debugger** | Bug investigation — Investigate → Fix → Report | Inspector, Fixer, Debug-Reporter |
+| **Prober** | Security audit — Trace → Patch → Audit | Tracer, Patcher, Auditor, Probe-Reporter |
 
-**2. Planner tab** — Turns your request into a verified PRD. It researches technical facts via Researcher, writes the spec via Plan-Writer, and validates it for completeness via Plan-Checker. On FAIL, Planner surfaces gap remedies to you via the question tool (you pick the fix direction) — Planner never silently re-routes. After your input, Planner internally delegates to Researcher or Plan-Writer. Max 3 loops, then surfaces to you for direction. Planner never edits files directly.
+---
 
-**3. Builder tab** — Executes a confirmed PRD. It delegates implementation to Coder, tests via Tester, checks traceability with Reviewer, and produces a completion report via Writer. Builder never edits files or runs bash directly.
+## Agent Workflows
 
-**4. Debugger tab** (standalone, user-triggered at any time) — Root-cause analysis using the **Brooks-Lint methodology** (Iron Law + 6 Decay Risks). Delegates investigation to Inspector, fixes to Fixer, and reports to Reporter. Does not depend on Builder — triggered directly by you.
+### 🎼 Composer — Feature Work
 
-### Exclusive Subagents
+Composer is the **single entry point for all feature work**. It runs 3 strict, one-directional phases. Phase direction is one-way — no going back without explicit user instruction.
 
-Each subagent belongs to exactly one primary agent and cannot be invoked by anyone else:
+```
+You describe a feature / idea
+        │
+        ▼
+  ┌─────────────────────────────────────────┐
+  │  EXPLORE PHASE  (mandatory start)       │
+  │                                         │
+  │  Delegate: Researcher                   │
+  │  → deep codebase + web fact-finding     │
+  │  → confirmed_facts / inferred_facts /   │
+  │    unknowns / risks                     │
+  │                                         │
+  │  Composer internally assesses:          │
+  │  Is this feature simple or complex?     │
+  └──────────┬──────────────────────────────┘
+             │
+    ┌────────┴────────┐
+    │ Simple feature  │  Complex feature
+    ▼                 ▼
+GUARDRAIL GATE 1a  GUARDRAIL GATE 1b
+"Build directly?"  "Write a PRD?"
+    │                 │
+    │ Yes             │ Yes
+    │                 ▼
+    │          ┌──────────────────────────────┐
+    │          │  PLAN PHASE                  │
+    │          │                              │
+    │          │  Plan-Writer → docs/plans/   │
+    │          │  Plan-Checker validates PRD  │
+    │          │  PASS/FAIL + gap list only   │
+    │          │                              │
+    │          │  FAIL → surface gaps to you  │
+    │          │  (max 5 loops)               │
+    │          │                              │
+    │          │  PASS → GUARDRAIL GATE 2     │
+    │          │  "Build from this PRD?"      │
+    │          └──────────┬───────────────────┘
+    │                     │ Yes
+    └──────────┬──────────┘
+               ▼
+  ┌────────────────────────────────────────────┐
+  │  BUILD PHASE                               │
+  │                                            │
+  │  Coder → implements from PRD / request     │
+  │     │                                      │
+  │     ▼                                      │
+  │  Tester → PASS/FAIL/BLOCKED                │
+  │     │ FAIL → back to Coder (max 5 loops)   │
+  │     │ PASS ↓                               │
+  │     ▼                                      │
+  │  Reviewer → PASS/FAIL + gap list           │
+  │     │ FAIL → back to Coder (max 5 loops)   │
+  │     │ PASS ↓                               │
+  │     ▼                                      │
+  │  Compose-Reporter → docs/reports/          │
+  └────────────────────────────────────────────┘
+               │
+               ▼
+         You review result
+               │
+  Composer resets → asks: New feature? Debug? Iterate?
+```
+
+**Key rules:**
+- Composer has **no read/write/bash permissions** — all work delegated to subagents
+- Phase transition only via guardrail gates — no skipping
+- `Coder → Coder` loops without Tester verification are forbidden
+- 5 consecutive FAILs from Tester or Reviewer → surfaces to you
+
+---
 
-| Primary | Subagents | Role |
-|---------|-----------|------|
-| Explorer | *(none)* | Research + recommendations only |
-| Planner | Researcher | Technical/codebase fact-finding (confirmed_facts/inferred_facts/unknowns/risks) |
-| Planner | Plan-Writer | Stateless PRD formatter — missing input = TBD |
-| Planner | Plan-Checker | **Gate** — validates PRD against original request, PASS/FAIL + gap list only |
-| Builder | Coder | Writes and edits implementation code |
-| Builder | Tester | Runs tests, reports PASS/FAIL/BLOCKED + coverage gaps |
-| Builder | Reviewer | **Gate** — compares implementation against definition-of-done, PASS/FAIL + gap list only |
-| Builder | Writer | Stateless document formatter — completion reports |
-| Debugger | Inspector | Brooks-Lint RCA (Iron Law + 6 decay risks + 4 review modes) |
-| Debugger | Fixer | Applies minimal, root-cause-targeted fixes |
-| Debugger | Reporter | Stateless diagnosis report formatter (Iron Law structure) |
-
-### Workflow
+### 🐛 Debugger — Bug Investigation
+
+Debugger is a **standalone primary agent** — does not depend on Composer. Trigger it directly from the Debugger tab whenever you find a bug.
 
 ```
-  You describe a feature / idea
-         │
-         ▼
-  (Optional) Explorer → research + recommendations → User decides
-         │
-         ▼
-  Planner → (if needed) Researcher → Plan-Writer writes PRD →
-    Plan-Checker validates → you confirm → handoff to Builder
+You report a bug / defect
+        │
+        ▼
+  ┌─────────────────────────────────────────────┐
+  │  INVESTIGATE PHASE                          │
+  │                                             │
+  │  Delegate: Inspector                        │
+  │  Review mode (Debugger selects):            │
+  │  · PR Review        → classify R1-R6        │
+  │  · Architecture     → dependency analysis   │
+  │  · Tech Debt        → Pain × Spread score   │
+  │  · Test Quality     → classify T1-T6        │
+  │                                             │
+  │  Output: Iron Law chain per finding         │
+  │  Symptom → Source → Consequence → Remedy    │
+  └──────────┬──────────────────────────────────┘
+             │
+    Root cause identified?
+    ┌────────┴────────┐
+    │ Yes             │ No / unknowns remain
+    ▼                 ▼
+  ┌─────────────┐  Halt — surface to you
+  │  FIX PHASE  │  with specific questions
+  │             │
+  │  Delegate:  │
+  │  Fixer      │
+  │  → minimal  │
+  │    fix per  │
+  │  Iron Law   │
+  └──────┬──────┘
          │
          ▼
-  Builder → Coder implements → Tester runs tests →
-    Reviewer checks DoD → Writer produces completion report
+  ┌──────────────────────────────────────┐
+  │  REPORT PHASE                        │
+  │                                      │
+  │  Delegate: Debug-Reporter            │
+  │  → Iron Law diagnosis report         │
+  │  → saved to docs/reports/            │
+  └──────────────────────────────────────┘
          │
          ▼
-  You review the result
+   You review the diagnosis + fix
          │
-  (If bug found at any point → Debugger → Inspector → Fixer →
-   Reporter → you verify)
+  Debugger resets → asks: New bug? Feature work? Re-investigate?
 ```
 
-### Flow Rules
+**Key rules:**
+- Debugger has **no read/write/bash permissions** — all delegated to subagents
+- Never delegates Fixer without Inspector confirming root cause first
+- If unknowns remain after investigation → halts and prompts you, does not guess
+
+---
+
+### 🔍 Prober — Security Audit
+
+Prober is a **standalone primary agent** — does not depend on Composer or Debugger. Trigger it directly from the Prober tab to audit any codebase for security vulnerabilities and quality decay.
+
+```
+You trigger a security audit
+        │
+        ▼
+  ┌───────────────────────────────────────────────────┐
+  │  TRACE PHASE  (mandatory start)                   │
+  │                                                   │
+  │  Delegate: Tracer                                 │
+  │  → WSTG-guided breadth-first recon                │
+  │  → trace data flows: input → path → sink          │
+  │                                                   │
+  │  Output:                                          │
+  │  · Confirmed Vulnerabilities  (OWASP category,    │
+  │    location, data flow)                           │
+  │  · Suspected Vulnerabilities  (manual verify)     │
+  │  · Quality & Decay Risks      (e.g. hardcoded     │
+  │    secrets, missing input validation)             │
+  └──────────┬────────────────────────────────────────┘
+             │
+             ▼
+      GUARDRAIL GATE (question tool):
+      "Audit findings ready. How to proceed?"
+      ├── "Patch all confirmed findings"    → PATCH PHASE
+      ├── "Select specific findings"        → PATCH PHASE (you pick)
+      ├── "Audit only — no patches"         → AUDIT PHASE (skip PATCH)
+      └── "Re-investigate attack surface"  → re-delegate Tracer
+             │
+             ▼
+  ┌──────────────────────────────────────────────────┐
+  │  PATCH PHASE  (skipped if audit-only)            │
+  │                                                  │
+  │  Delegate: Patcher                               │
+  │  → Ponytail mindset: smallest correct diff       │
+  │  → prefer deleting the cause over wrapping it    │
+  │  → escalates to you if patch > 10 lines          │
+  └──────────┬───────────────────────────────────────┘
+             │
+             ▼
+  ┌──────────────────────────────────────────────────┐
+  │  AUDIT PHASE  (max 5 loops)                      │
+  │                                                  │
+  │  Delegate: Auditor                               │
+  │  → verify patch resolved vulnerabilities         │
+  │  → security regression check                     │
+  │  → Ponytail BLOAT analysis (over-engineering)    │
+  │                                                  │
+  │  PASS → proceed to report                        │
+  │  FAIL → re-delegate Patcher with Gap + BLOAT     │
+  │         lists verbatim (max 5 loops, then you)   │
+  │                                                  │
+  │  Delegate: Probe-Reporter                        │
+  │  → security audit report → docs/reports/         │
+  └──────────────────────────────────────────────────┘
+             │
+             ▼
+       You review the audit report
+             │
+  Prober resets → asks: New audit? Feature work? Bug investigation?
+```
+
+**Key rules:**
+- Prober has **no read/write/bash permissions** — all delegated to subagents
+- TRACE phase is always mandatory — no patching without recon first
+- GUARDRAIL GATE required before any patches are applied
+- 5 consecutive AUDIT FAILs → surfaces to you
+
+---
+
+## Subagent Reference
+
+Each subagent belongs to exactly one primary agent and cannot be invoked by anyone else:
+
+| Primary | Phase | Subagent | Role |
+|---------|-------|----------|------|
+| Composer | EXPLORE | Researcher | Fact-finding: confirmed_facts / inferred_facts / unknowns / risks |
+| Composer | PLAN | Plan-Writer | **Formatter** — writes PRD to `docs/plans/`, missing input = TBD |
+| Composer | PLAN | Plan-Checker | **Gate** — PASS/FAIL + gap list only, no suggestions |
+| Composer | BUILD | Coder | Implements code from PRD |
+| Composer | BUILD | Tester | PASS/FAIL/BLOCKED + coverage gaps only |
+| Composer | BUILD | Reviewer | **Gate** — PASS/FAIL + gap list only, no suggestions |
+| Composer | BUILD | Compose-Reporter | **Formatter** — completion report to `docs/reports/` |
+| Debugger | DEBUG | Inspector | Brooks-Lint RCA (Iron Law + 6 decay risks + 4 review modes) |
+| Debugger | DEBUG | Fixer | Minimal, root-cause-targeted fix |
+| Debugger | DEBUG | Debug-Reporter | **Formatter** — Iron Law diagnosis report to `docs/reports/` |
+| Prober | TRACE | Tracer | WSTG recon + vuln path tracing, no remedies |
+| Prober | PATCH | Patcher | Minimal, security-targeted fix (Ponytail, max 10 lines) |
+| Prober | AUDIT | Auditor | **Gate** — PASS/FAIL + Gap List + BLOAT List only |
+| Prober | AUDIT | Probe-Reporter | **Formatter** — security audit report to `docs/reports/` |
+
+---
+
+## Flow Rules
 
 | Rule | Detail |
 |------|--------|
-| **Gate agents** | Plan-Checker and Reviewer output PASS/FAIL + gap list only — no improvement suggestions, no decisions |
-| **Researcher agents** | Researcher and Inspector output confirmed_facts/inferred_facts/unknowns/risks — no recommendations |
-| **Writer agents** | Plan-Writer, Writer, and Reporter are stateless formatters — missing input = TBD, never invent content |
-| **Build gate order** | Coder → Tester → Reviewer → Writer (Builder orchestrates in sequence) |
-| **Planner FAIL loop** | Plan-checker FAIL → Planner surfaces gap remedies to you via question tool (MC options) → you pick → Planner internally routes to Researcher or Plan-Writer. Max 3 loops, then surfaces to you for direction |
-| **Builder FAIL loop** | 3 consecutive FAILs from Tester or Reviewer → Builder surfaces to you |
-| **No shared subagents** | Each subagent belongs to exactly one primary — no cross-primary delegation |
-| **Debugger independence** | Debugger is standalone — does not flow through Builder, triggered directly by you |
+| **Mandatory starts** | Composer always starts in EXPLORE. Prober always starts in TRACE. No skipping. |
+| **Guardrail gates** | Composer: Gate 1 (EXPLORE→PLAN/BUILD), Gate 2 (PLAN→BUILD). Prober: Gate after TRACE. All require user confirmation. |
+| **Gate agents** | Plan-Checker, Reviewer, Auditor — PASS/FAIL + gap list only. No suggestions, no decisions. |
+| **Formatter agents** | Plan-Writer, Compose-Reporter, Debug-Reporter, Probe-Reporter — stateless. Missing input = TBD/NA. Never invent content. |
+| **Fact-finding agents** | Researcher, Inspector, Tracer — facts/inferences/risks only. No recommendations. |
+| **Build gate order** | Coder → Tester → Reviewer → Compose-Reporter. No skipping. No Coder→Coder without verification. |
+| **FAIL loops** | Plan-Checker FAIL: max 5 loops. Build FAIL (Tester/Reviewer): max 5 loops. Prober AUDIT FAIL: max 5 loops. All surface to you after limit. |
+| **Output directories** | PRDs → `docs/plans/`. Reports (Compose-Reporter, Debug-Reporter, Probe-Reporter) → `docs/reports/`. Enforced by permissions. |
+| **Independence** | Debugger and Prober are fully standalone — triggered directly, do not flow through Composer. |
 
-### Brooks-Lint Methodology (Debugger)
+---
 
-The Debugger group uses the [Brooks-Lint](https://hyhmrright.github.io/brooks-lint/guide.html) framework:
+## Brooks-Lint Methodology (Debugger)
+
+The Debugger pipeline uses the [Brooks-Lint](https://hyhmrright.github.io/brooks-lint/guide.html) framework:
 
 - **Iron Law** per finding: Symptom → Source → Consequence → Remedy
-- **6 Decay Risks (R1-R6)**: Cognitive Overload, Change Propagation, Knowledge Duplication, Accidental Complexity, Dependency Disorder, Domain Model Distortion
-- **4 Review Modes**: PR Review (R1-R6), Architecture Audit (dependency analysis), Tech Debt Assessment (Pain × Spread), Test Quality (T1-T6)
-- **T1-T6 Test Risks**: Test Obscurity, Brittleness, Duplication, Mock Abuse, Coverage Illusion, Architecture Mismatch
+- **6 Decay Risks (R1–R6)**: Cognitive Overload, Change Propagation, Knowledge Duplication, Accidental Complexity, Dependency Disorder, Domain Model Distortion
+- **4 Review Modes**: PR Review (R1–R6), Architecture Audit, Tech Debt Assessment (Pain × Spread), Test Quality (T1–T6)
+- **T1–T6 Test Risks**: Test Obscurity, Brittleness, Duplication, Mock Abuse, Coverage Illusion, Architecture Mismatch
+
+## Principle Hierarchy
 
-### Principle Hierarchy
+All agents resolve conflicts using this priority order (defined in `hierarchy.txt`):
 
-Conflict resolution follows a strict priority order (defined in `hierarchy.txt`):
+1. **PRD / Spec** — explicit requirement text
+2. **Verdict** — Reviewer / Plan-Checker / Auditor PASS/FAIL
+3. **Engineering principles** — Fail Fast, Single Responsibility
+4. **Heuristics** — KISS, DRY, SOLID, Law of Demeter
+5. **Local optimization** — style preference
 
-1. **PRD / Spec** (explicit requirement text)
-2. **Verdict** (Reviewer PASS/FAIL, Plan-Checker PASS/FAIL)
-3. **Engineering principles tied to correctness** (Fail Fast, Single Responsibility)
-4. **Heuristics** (KISS, DRY, SOLID, Law of Demeter)
-5. **Local optimization / style preference**
+---
 
 ## Install
 
@@ -109,28 +303,55 @@ npx pluidr init
 
 ### `pluidr init`
 
-Prompts you to select models for two agent tiers, then:
+Prompts you to select models for two agent tiers (reasoning-heavy and fast), then:
 
+- Asks whether to install the pluidr-squeeze plugin (can decline)
 - Builds a complete `opencode.jsonc` config with the chosen models injected into the right agents
-- Backs up any existing config at `~/.config/opencode/opencode.jsonc` to `opencode.jsonc.bak`
+- Backs up any existing config to `opencode.jsonc.bak.*`
 - Writes the new config to `~/.config/opencode/opencode.jsonc`
-- Copies agent system-prompt files into `~/.config/opencode/prompts/`
-- Copies the bundled `parent-session` plugin into `~/.config/opencode/plugins/`
-- Writes a `package.json` into `~/.config/opencode/` declaring `@opencode-ai/plugin` as a dependency (OpenCode installs it automatically on first launch via its bundled Bun runtime)
+- Copies all 18 agent prompt files into `~/.config/opencode/prompts/`
+- Copies `pluidr-flow` and `pluidr-squeeze` plugins into `~/.config/opencode/plugins/`
+- Writes a `package.json` declaring `@opencode-ai/plugin` as a dependency
 
-On completion, prints:
-```
-Pluidr setup complete!
-You can update your agent model settings later in opencode.jsonc
-```
-The filename `opencode.jsonc` (second line) is a clickable terminal hyperlink — Ctrl+click to open the config in your default editor.
+### `pluidr doctor`
+
+Checks installation health and reports ✓/✗ for each component:
+
+- `opencode.jsonc` exists
+- All 18 prompt files present
+- Both plugin files present
+- `package.json` with `@opencode-ai/plugin` dependency
+- squeeze binary available
+- Config is valid JSON
+
+Exits with code `0` if all pass, `1` if any fail.
 
-## Bundled plugins
+### `pluidr update`
 
-Pluidr ships with one plugin: [`parent-session`](src/plugins/README.md), which gives subagents three tools for cross-session context access:
+Re-runs the setup wizard. Warns if existing config is found and asks for confirmation before overwriting.
+
+### `pluidr uninstall`
+
+Restores your previous configuration:
+
+- Finds the latest timestamped backup and restores it to `opencode.jsonc`
+- Removes `prompts/`, `plugins/`, and `bin/` directories
+- Preserves `opencode.jsonc` and `package.json`
+
+---
+
+## Bundled Plugins
+
+### `pluidr-flow`
+
+Provides subagents with cross-session context access:
 
 - `parent_session_messages` — read the parent session's transcript
 - `session_messages(sessionId)` — read any session by ID
 - `session_messages_batch(sessionIds)` — read multiple sessions in one call
 
-`pluidr init` installs the plugin and its dependency declaration automatically — no extra user action. On OpenCode's first launch, the bundled Bun runtime installs `@opencode-ai/plugin` from the generated `package.json`, then the plugin's tools become available to all subagents.
+### `pluidr-squeeze`
+
+Hooks into tool execution to rewrite bash commands through the `squeeze` binary, filtering verbose output and saving **60–90% of tokens** across all agents.
+
+Both plugins and their dependency declaration are installed automatically by `pluidr init` — no extra user action required. On OpenCode's first launch, the bundled Bun runtime installs `@opencode-ai/plugin` from the generated `package.json`.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pluidr",
-  "version": "0.4.1",
-  "description": "Opinionated Engineering Workflow for OpenCode — Plan, Build, Review.",
+  "version": "0.6.0",
+  "description": "Opinionated Engineering Workflow for OpenCode — Explore, Plan, Build, Debug, and Security-Audit.",
   "keywords": [
     "opencode",
     "workflow",
@@ -10,12 +10,17 @@
     "ai-agents",
     "code-review",
     "debugging",
+    "security-audit",
+    "security",
     "planner",
     "builder",
     "cli"
   ],
   "license": "MIT",
   "type": "module",
+  "scripts": {
+    "test": "node --test"
+  },
   "bin": {
     "pluidr": "bin/pluidr.js"
   },

package/src/cli/commands/doctor.js

@@ -0,0 +1,99 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs"
+import { join, dirname } from "node:path"
+import { fileURLToPath } from "node:url"
+import { execFileSync } from "node:child_process"
+import { getConfigDir, getConfigPath, getPromptsDir } from "../../core/paths.js"
+import { findRtkPath } from "../../core/squeezeInstaller.js"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const EXPECTED_PROMPT_COUNT = 18
+const PLUGIN_FILES = ["pluidr-flow.js", "pluidr-squeeze.js"]
+
+export async function runDoctor() {
+  const configDir = getConfigDir()
+  const configPath = getConfigPath()
+  const promptsDir = getPromptsDir()
+  const pluginsDir = join(configDir, "plugins")
+  const packageJsonPath = join(configDir, "package.json")
+  const binDir = join(configDir, "bin")
+
+  const checks = []
+
+  // 1. opencode.jsonc exists
+  const configExists = existsSync(configPath)
+  checks.push({ component: "opencode.jsonc", pass: configExists })
+
+  // 2. All 18 prompt files exist
+  let promptCount = 0
+  if (existsSync(promptsDir)) {
+    try {
+      const files = readdirSync(promptsDir).filter((f) => f.endsWith(".txt"))
+      promptCount = files.length
+    } catch {
+      promptCount = 0
+    }
+  }
+  checks.push({ component: "18 prompt files", pass: promptCount === EXPECTED_PROMPT_COUNT, detail: `${promptCount}/${EXPECTED_PROMPT_COUNT}` })
+
+  // 3. Both plugin files exist
+  let pluginsFound = 0
+  for (const f of PLUGIN_FILES) {
+    if (existsSync(join(pluginsDir, f))) pluginsFound++
+  }
+  checks.push({ component: "plugin files", pass: pluginsFound === PLUGIN_FILES.length, detail: `${pluginsFound}/${PLUGIN_FILES.length}` })
+
+  // 4. package.json with @opencode-ai/plugin dependency
+  let pkgValid = false
+  if (existsSync(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"))
+      pkgValid = !!(pkg.dependencies && pkg.dependencies["@opencode-ai/plugin"])
+    } catch {
+      pkgValid = false
+    }
+  }
+  checks.push({ component: "package.json + plugin dep", pass: pkgValid })
+
+  // 5. RTK binary exists
+  let rtkFound = false
+  const rtkOnPath = findRtkPath()
+  if (rtkOnPath) {
+    rtkFound = true
+  } else {
+    const binName = process.platform === "win32" ? "rtk.exe" : "rtk"
+    rtkFound = existsSync(join(binDir, binName))
+  }
+  checks.push({ component: "squeeze binary", pass: rtkFound })
+
+  // 6. Config is valid JSON/JSONC
+  let configValid = false
+  if (configExists) {
+    try {
+      const content = readFileSync(configPath, "utf-8")
+      const cleaned = content.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g) => g ? "" : m)
+      JSON.parse(cleaned)
+      configValid = true
+    } catch {
+      configValid = false
+    }
+  }
+  checks.push({ component: "config JSON validity", pass: configValid })
+
+  // Print summary table
+  const allPass = checks.every((c) => c.pass)
+  console.log("\nPluidr Doctor — Installation Health Check\n")
+  for (const c of checks) {
+    const icon = c.pass ? "\u2713" : "\u2717"
+    const detail = c.detail ? ` (${c.detail})` : ""
+    console.log(`  ${icon} ${c.component}${detail}`)
+  }
+  console.log("")
+
+  if (allPass) {
+    console.log("All checks passed.")
+  } else {
+    console.log("Some checks failed. Re-run `pluidr init` to repair.")
+  }
+
+  process.exit(allPass ? 0 : 1)
+}

package/src/cli/commands/init.js

@@ -1,29 +1,32 @@
 import { readFileSync } from "node:fs"
 import { resolve, dirname } from "node:path"
 import { fileURLToPath } from "node:url"
+import { confirm, isCancel } from "@clack/prompts"
 import { selectModelTier } from "../wizard/selectModelTier.js"
 import { backupExistingConfig } from "../../core/backup.js"
 import { buildConfig } from "../../core/configBuilder.js"
 import { writeConfig } from "../../core/configWriter.js"
 import { writeAgentPrompts } from "../../core/agentPromptWriter.js"
 import { writePluginBundle, writePluginPackageJson } from "../../core/pluginWriter.js"
+import { installSqueeze } from "../../core/squeezeInstaller.js"
 import { getConfigPath } from "../../core/paths.js"
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const TEMPLATES_DIR = resolve(__dirname, "../../templates")
 
-function makeFileHyperlink(absolutePath, displayText) {
-  const normalized = absolutePath.replace(/\\/g, "/").replace(/^\//, "")
-  const fileUrl = `file:///${normalized}`
-  return `\x1b]8;;${fileUrl}\x1b\\${displayText}\x1b]8;;\x1b\\`
-}
-
 export async function runInit() {
   const defaultsPath = resolve(TEMPLATES_DIR, "model-defaults.json")
   const modelDefaults = JSON.parse(readFileSync(defaultsPath, "utf-8"))
 
   const tierChoices = await selectModelTier(modelDefaults)
 
+  const squeezeAnswer = await confirm({
+    message: "Install pluidr-squeeze plugin? Reduces bash output tokens by 60-90%.",
+    initialValue: true,
+  })
+
+  const installSqueezePlugin = isCancel(squeezeAnswer) ? true : squeezeAnswer
+
   backupExistingConfig()
 
   const configObject = buildConfig(tierChoices, TEMPLATES_DIR)
@@ -31,6 +34,10 @@ export async function runInit() {
   writeAgentPrompts(TEMPLATES_DIR)
   writePluginBundle()
   writePluginPackageJson()
+  if (installSqueezePlugin) {
+    await installSqueeze()
+  }
 
-  console.log(`Pluidr setup complete!\nYou can update your agent model settings later in ${makeFileHyperlink(getConfigPath(), "opencode.jsonc")}`)
+  const path = getConfigPath().replace(/\\/g, "/").replace(/^\//, "")
+  console.log(`Pluidr setup complete!\nYou can update your agent model settings later in \x1b]8;;file:///${path}\x1b\\opencode.jsonc\x1b]8;;\x1b\\`)
 }