fix: promote parallel execution as primary implement strategy and add license display

Restructure spec-implement to make parallel wave execution the primary
execution path (Step 2.3/2.3a) instead of an optional sub-step (2.2b).
Sequential TDD becomes the fallback (2.3b) for dependent tasks.

Rename spec-executor agent to spec-implementer for consistency. Update
workflow-enforcement rule references and README implement phase details.

Update website components: WorkflowSteps highlights parallel sub-agents,
AgentRoster replaces TDD card with IMPLEMENTER/Parallel Executor,
WhatsInside adds parallel execution to spec summary. Add new site
components (AgentRoster, DeploymentFlow, QualifierSection, TechStack)
and update ComparisonSection, HeroSection, PricingSection, Index page.

Add console license display: LicenseRoutes backend endpoint with cached
pilot status, LicenseBadge component with useLicense hook in Topbar,
and test suites for both. Rebuild worker service and viewer bundles.

Update launcher config for seat-based pricing and tool redirect tests.

Author: maxritter

README.md

@@ -63,9 +63,9 @@ There are other AI coding frameworks out there. I tried them. They add complexit
 
 **Pilot optimizes for output quality, not system complexity.** The rules are minimal and focused. There's no big learning curve, no project scaffolding to set up, no state files to manage. You install it, run `pilot`, and the quality guardrails are just there — hooks, TDD, type checking, formatting — enforced automatically on every edit, in every session.
 
-This isn't a vibe coding tool. It's built for developers who ship to production and need code that actually works. Every rule in the system comes from daily professional use: real bugs caught, real regressions prevented, real sessions where the AI cut corners and the hooks stopped it. The rules are continuously refined based on what measurably improves output — not what looks impressive in a README.
+This isn't a vibe coding tool. It's built for developers who ship to production and need code that actually works. Every rule in the system comes from daily professional use: real bugs caught, real regressions prevented, real sessions where the AI cut corners and the hooks stopped it. The rules are continuously refined based on what measurably improves output.
 
-The system stays fast because it stays simple. Quick mode is direct execution with zero overhead — no sub-agents, no plan files, no directory scaffolding. You describe the task and it gets done. `/spec` adds structure only when you need it: plan verification, TDD enforcement, independent code review, parallel execution. Both modes share the same quality hooks. Both modes hand off cleanly across sessions with Endless Mode. The difference is how much planning wraps the work, not whether the work is done right.
+The system stays fast because it stays simple. Quick mode is direct execution with zero overhead — no sub-agents, no plan files, no directory scaffolding. You describe the task and it gets done. `/spec` adds structure only when you need it: plan verification, TDD enforcement, independent code review, parallel execution. Both modes share the same quality hooks. Both modes hand off cleanly across sessions with Endless Mode.
 
 ---
 
@@ -187,10 +187,12 @@ Discuss  →  Plan  →  Approve  →  Implement  →  Verify  →  Done
 <summary><b>Implement Phase</b></summary>
 
 1. Creates an isolated git worktree on a dedicated branch — main branch stays clean
-2. Writes a failing test first (RED phase of TDD)
-3. Implements code to make the test pass (GREEN phase)
-4. Refactors while keeping tests green (REFACTOR phase)
-5. Quality hooks auto-lint, format, and type-check every file edit
+2. Analyzes task graph to detect independent tasks — groups them into parallel waves
+3. Spawns `spec-implementer` sub-agents for each independent task in a wave, executing TDD in parallel with fresh context windows
+4. Falls back to sequential execution only when tasks share files or have linear dependencies
+5. Each task follows strict TDD: write failing test (RED), implement to pass (GREEN), refactor (REFACTOR)
+6. Quality hooks auto-lint, format, and type-check every file edit
+7. After each wave, runs the full test suite to catch cross-task conflicts before proceeding
 
 </details>
 

console/src/services/worker-service.ts

@@ -65,6 +65,7 @@ import { AuthRoutes } from "./worker/http/routes/AuthRoutes.js";
 import { PlanRoutes } from "./worker/http/routes/PlanRoutes.js";
 import { WorktreeRoutes } from "./worker/http/routes/WorktreeRoutes.js";
 import { VexorRoutes } from "./worker/http/routes/VexorRoutes.js";
+import { LicenseRoutes } from "./worker/http/routes/LicenseRoutes.js";
 import { MetricsService } from "./worker/MetricsService.js";
 import { startRetentionScheduler, stopRetentionScheduler } from "./worker/RetentionScheduler.js";
 
@@ -249,6 +250,8 @@ export class WorkerService {
     this.vexorRoutes = new VexorRoutes(this.dbManager);
     this.server.registerRoutes(this.vexorRoutes);
 
+    this.server.registerRoutes(new LicenseRoutes());
+
     startRetentionScheduler(this.dbManager);
   }
 

console/src/services/worker/http/routes/LicenseRoutes.ts

@@ -0,0 +1,98 @@
+/**
+ * License Routes
+ *
+ * Exposes license status via /api/license endpoint.
+ * Calls `pilot status --json` and caches the result for 5 minutes.
+ */
+
+import express, { Request, Response } from "express";
+import { spawnSync } from "child_process";
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { BaseRouteHandler } from "../BaseRouteHandler.js";
+
+export interface LicenseResponse {
+  valid: boolean;
+  tier: string | null;
+  email: string | null;
+  daysRemaining: number | null;
+  isExpired: boolean;
+}
+
+const FALLBACK_RESPONSE: LicenseResponse = {
+  valid: false,
+  tier: null,
+  email: null,
+  daysRemaining: null,
+  isExpired: false,
+};
+
+const CACHE_TTL_MS = 5 * 60 * 1000;
+
+export class LicenseRoutes extends BaseRouteHandler {
+  private cache: { data: LicenseResponse; expiresAt: number } | null = null;
+
+  setupRoutes(app: express.Application): void {
+    app.get("/api/license", this.handleGetLicense.bind(this));
+  }
+
+  private handleGetLicense = this.wrapHandler((_req: Request, res: Response): void => {
+    res.json(this.getLicenseInfo());
+  });
+
+  getLicenseInfo(): LicenseResponse {
+    if (this.cache && Date.now() < this.cache.expiresAt) {
+      return this.cache.data;
+    }
+
+    const result = this.fetchLicenseFromCLI();
+    this.cache = { data: result, expiresAt: Date.now() + CACHE_TTL_MS };
+    return result;
+  }
+
+  private fetchLicenseFromCLI(): LicenseResponse {
+    const pilotPath = `${homedir()}/.pilot/bin/pilot`;
+
+    if (!existsSync(pilotPath)) {
+      return { ...FALLBACK_RESPONSE };
+    }
+
+    try {
+      const proc = spawnSync(pilotPath, ["status", "--json"], {
+        stdio: "pipe",
+        timeout: 5000,
+      });
+
+      const stdout = proc.stdout?.toString().trim();
+      if (!stdout) {
+        return { ...FALLBACK_RESPONSE };
+      }
+
+      const data = JSON.parse(stdout);
+
+      if (data.success) {
+        return {
+          valid: true,
+          tier: data.tier ?? null,
+          email: data.email ?? null,
+          daysRemaining: data.days_remaining ?? null,
+          isExpired: false,
+        };
+      }
+
+      if (data.error === "No license found") {
+        return { ...FALLBACK_RESPONSE };
+      }
+
+      return {
+        valid: false,
+        tier: data.tier ?? null,
+        email: data.email ?? null,
+        daysRemaining: data.days_remaining ?? null,
+        isExpired: true,
+      };
+    } catch {
+      return { ...FALLBACK_RESPONSE };
+    }
+  }
+}

console/src/ui/viewer/components/LicenseBadge.tsx

@@ -0,0 +1,60 @@
+import React from 'react';
+import { Badge, Tooltip } from './ui';
+import type { LicenseResponse } from '../../../services/worker/http/routes/LicenseRoutes.js';
+
+interface LicenseBadgeProps {
+  license: LicenseResponse | null;
+  isLoading: boolean;
+}
+
+const TIER_CONFIG: Record<string, { label: string; variant: 'primary' | 'accent' | 'warning' | 'error' }> = {
+  solo: { label: 'Solo', variant: 'primary' },
+  team: { label: 'Team', variant: 'accent' },
+  trial: { label: 'Trial', variant: 'warning' },
+  standard: { label: 'Solo', variant: 'primary' },
+  enterprise: { label: 'Team', variant: 'accent' },
+};
+
+function buildTooltipText(license: LicenseResponse): string {
+  const config = TIER_CONFIG[license.tier ?? ''];
+  const parts: string[] = [config?.label ?? license.tier ?? 'Unknown'];
+
+  if (license.email) {
+    parts.push(license.email);
+  }
+
+  if (license.tier === 'trial' && license.daysRemaining != null) {
+    parts.push(`${license.daysRemaining} days remaining`);
+  }
+
+  return parts.join(' · ');
+}
+
+export function LicenseBadge({ license, isLoading }: LicenseBadgeProps) {
+  if (isLoading || !license || !license.tier) {
+    return null;
+  }
+
+  if (license.isExpired) {
+    return (
+      <Tooltip text={buildTooltipText(license)} position="bottom">
+        <Badge variant="error" size="xs">Expired</Badge>
+      </Tooltip>
+    );
+  }
+
+  const config = TIER_CONFIG[license.tier];
+  if (!config) {
+    return null;
+  }
+
+  const label = license.tier === 'trial' && license.daysRemaining != null
+    ? `${config.label} · ${license.daysRemaining}d left`
+    : config.label;
+
+  return (
+    <Tooltip text={buildTooltipText(license)} position="bottom">
+      <Badge variant={config.variant} size="xs">{label}</Badge>
+    </Tooltip>
+  );
+}

console/src/ui/viewer/hooks/useLicense.ts

@@ -0,0 +1,26 @@
+import { useState, useEffect } from 'react';
+import type { LicenseResponse } from '../../../services/worker/http/routes/LicenseRoutes.js';
+
+interface UseLicenseResult {
+  license: LicenseResponse | null;
+  isLoading: boolean;
+}
+
+export function useLicense(): UseLicenseResult {
+  const [license, setLicense] = useState<LicenseResponse | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+
+  useEffect(() => {
+    fetch('/api/license')
+      .then((res) => res.json())
+      .then((data: LicenseResponse) => {
+        setLicense(data);
+        setIsLoading(false);
+      })
+      .catch(() => {
+        setIsLoading(false);
+      });
+  }, []);
+
+  return { license, isLoading };
+}

console/src/ui/viewer/layouts/Topbar/index.tsx

@@ -1,4 +1,6 @@
 import { Icon } from '../../components/ui';
+import { LicenseBadge } from '../../components/LicenseBadge';
+import { useLicense } from '../../hooks/useLicense';
 import { TopbarActions } from './TopbarActions';
 
 interface TopbarProps {
@@ -8,6 +10,8 @@ interface TopbarProps {
 }
 
 export function Topbar({ theme, onToggleTheme, onToggleLogs }: TopbarProps) {
+  const { license, isLoading } = useLicense();
+
   return (
     <header className="h-14 bg-base-100 border-b border-base-300/50 flex items-center justify-between px-6 gap-4">
       <div className="flex items-center gap-2 text-xs text-base-content/40">
@@ -35,6 +39,8 @@ export function Topbar({ theme, onToggleTheme, onToggleLogs }: TopbarProps) {
             Max Ritter
           </a>
         </span>
+        {!isLoading && license?.tier && <span className="text-base-content/20">|</span>}
+        <LicenseBadge license={license} isLoading={isLoading} />
       </div>
       <TopbarActions theme={theme} onToggleTheme={onToggleTheme} onToggleLogs={onToggleLogs} />
     </header>

console/tests/ui/license-badge.test.ts

@@ -0,0 +1,123 @@
+/**
+ * Tests for LicenseBadge component
+ *
+ * Tests rendering of license badge for each tier state:
+ * solo, team, trial, expired, and null (hidden).
+ */
+import { describe, it, expect } from "bun:test";
+import React from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { LicenseBadge } from "../../src/ui/viewer/components/LicenseBadge.js";
+import type { LicenseResponse } from "../../src/services/worker/http/routes/LicenseRoutes.js";
+
+function renderBadge(license: LicenseResponse | null, isLoading = false) {
+  return renderToStaticMarkup(
+    React.createElement(LicenseBadge, { license, isLoading }),
+  );
+}
+
+describe("LicenseBadge", () => {
+  it("should render Solo badge with primary variant", () => {
+    const html = renderBadge({
+      valid: true,
+      tier: "solo",
+      email: "user@example.com",
+      daysRemaining: null,
+      isExpired: false,
+    });
+
+    expect(html).toContain("Solo");
+    expect(html).toContain("badge-primary");
+  });
+
+  it("should render Team badge with accent variant", () => {
+    const html = renderBadge({
+      valid: true,
+      tier: "team",
+      email: "team@example.com",
+      daysRemaining: null,
+      isExpired: false,
+    });
+
+    expect(html).toContain("Team");
+    expect(html).toContain("badge-accent");
+  });
+
+  it("should render Trial badge with warning variant and days remaining", () => {
+    const html = renderBadge({
+      valid: true,
+      tier: "trial",
+      email: "trial@example.com",
+      daysRemaining: 7,
+      isExpired: false,
+    });
+
+    expect(html).toContain("Trial");
+    expect(html).toContain("7d left");
+    expect(html).toContain("badge-warning");
+  });
+
+  it("should render expired badge with error variant", () => {
+    const html = renderBadge({
+      valid: false,
+      tier: "trial",
+      email: "trial@example.com",
+      daysRemaining: null,
+      isExpired: true,
+    });
+
+    expect(html).toContain("Expired");
+    expect(html).toContain("badge-error");
+  });
+
+  it("should render nothing when tier is null (no license or no binary)", () => {
+    const html = renderBadge({
+      valid: false,
+      tier: null,
+      email: null,
+      daysRemaining: null,
+      isExpired: false,
+    });
+
+    expect(html).toBe("");
+  });
+
+  it("should render nothing when license is null (loading state)", () => {
+    const html = renderBadge(null);
+    expect(html).toBe("");
+  });
+
+  it("should render nothing when isLoading is true", () => {
+    const html = renderBadge(
+      { valid: true, tier: "solo", email: "user@example.com", daysRemaining: null, isExpired: false },
+      true,
+    );
+    expect(html).toBe("");
+  });
+
+  it("should include tooltip with tier and email", () => {
+    const html = renderBadge({
+      valid: true,
+      tier: "solo",
+      email: "user@example.com",
+      daysRemaining: null,
+      isExpired: false,
+    });
+
+    expect(html).toContain("tooltip");
+    expect(html).toContain("Solo");
+    expect(html).toContain("user@example.com");
+  });
+
+  it("should include days remaining in tooltip for trial tier", () => {
+    const html = renderBadge({
+      valid: true,
+      tier: "trial",
+      email: "trial@example.com",
+      daysRemaining: 5,
+      isExpired: false,
+    });
+
+    expect(html).toContain("5 days remaining");
+  });
+});