sequant 2.3.0 → 2.5.0

package/dist/src/ui/tui/App.js

@@ -1,8 +1,10 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useRef, useState } from "react";
-import { Box, useStdout } from "ink";
+import { Box, Text, useStdout } from "ink";
 import { Header } from "./Header.js";
 import { IssueBox } from "./IssueBox.js";
+import { selectVisibleIssues } from "./row-cap.js";
+import { ROLLUP_COLOR } from "./theme.js";
 const POLL_MS = 100; // 10 Hz
 /**
  * Root TUI component.
@@ -37,5 +39,9 @@ export function App({ getSnapshot, onDone, }) {
     }, []);
     const columns = stdout?.columns ?? 80;
     const boxWidth = Math.min(columns - 2, 100);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { snapshot: snapshot }), snapshot.issues.map((issue, i) => (_jsx(IssueBox, { state: issue, slot: i, width: boxWidth, now: now }, issue.number)))] }));
+    // #699 AC-4: clamp the number of boxes to the terminal height so a large
+    // batch on a short terminal can't overflow the frame (parity with the plain
+    // renderer's #624 row cap). Older completed issues collapse into `✔ N done`.
+    const { visible, rolledUpDoneCount } = selectVisibleIssues(snapshot.issues, stdout?.rows);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { snapshot: snapshot }), visible.map((issue, i) => (_jsx(IssueBox, { state: issue, slot: i, width: boxWidth, now: now }, issue.number))), rolledUpDoneCount > 0 ? (_jsx(Text, { color: ROLLUP_COLOR, children: `✔ ${rolledUpDoneCount} done` })) : null] }));
 }

package/dist/src/ui/tui/IssueBox.js

@@ -20,7 +20,7 @@ export function IssueBox({ state, slot, width, now, }) {
     const displayPhaseN = activePhaseIndex >= 0 ? activePhaseIndex + 1 : doneCount;
     const total = state.phases.length;
     const headerTitle = truncateToWidth(`#${state.number}  ${state.title}`, Math.max(10, innerWidth - 20));
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: border, paddingX: 1, marginBottom: 1, width: width, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { color: border, children: headerTitle }), _jsxs(Text, { color: DIVIDER_COLOR, children: ["phase ", displayPhaseN, "/", total, " \u2022", " ", _jsx(ElapsedTimer, { startedAt: state.startedAt })] })] }), _jsx(Divider, { width: innerWidth, borderColor: border }), _jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: DIVIDER_COLOR, children: "branch " }), _jsx(Text, { children: truncateToWidth(state.branch, innerWidth - 8) })] }), _jsx(PhaseProgression, { phases: state.phases, borderColor: border }), state.currentPhase?.logPath ? (_jsxs(Box, { children: [_jsx(Text, { color: DIVIDER_COLOR, children: "log " }), _jsx(Text, { children: truncateToWidth(state.currentPhase.logPath, innerWidth - 8) })] })) : null] }), _jsx(Divider, { width: innerWidth, borderColor: border }), _jsx(Box, { flexDirection: "column", children: state.currentPhase ? (_jsxs(_Fragment, { children: [_jsxs(Box, { children: [_jsx(Text, { color: DIVIDER_COLOR, children: "now " }), _jsx(Spinner, { color: border }), _jsxs(Text, { children: ["  ", truncateToWidth(state.currentPhase.nowLine, innerWidth - 12)] })] }), _jsx(Box, { children: _jsxs(Text, { color: DIVIDER_COLOR, children: ["        └ last activity ", formatSinceActivity(now, state.currentPhase.lastActivityAt)] }) })] })) : (_jsx(Text, { color: DIVIDER_COLOR, children: statusLine(state) })) })] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: border, paddingX: 1, marginBottom: 1, width: width, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { color: border, children: headerTitle }), _jsxs(Text, { color: DIVIDER_COLOR, children: ["phase ", displayPhaseN, "/", total, " \u2022", " ", _jsx(ElapsedTimer, { startedAt: state.startedAt })] })] }), _jsx(Divider, { width: innerWidth }), _jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: DIVIDER_COLOR, children: "branch " }), _jsx(Text, { children: truncateToWidth(state.branch, innerWidth - 8) })] }), _jsx(PhaseProgression, { phases: state.phases, borderColor: border }), state.currentPhase?.logPath ? (_jsxs(Box, { children: [_jsx(Text, { color: DIVIDER_COLOR, children: "log " }), _jsx(Text, { children: truncateToWidth(state.currentPhase.logPath, innerWidth - 8) })] })) : null] }), _jsx(Divider, { width: innerWidth }), _jsx(Box, { flexDirection: "column", children: state.currentPhase ? (_jsxs(_Fragment, { children: [_jsxs(Box, { children: [_jsx(Text, { color: DIVIDER_COLOR, children: "now " }), _jsx(Spinner, { color: border }), _jsxs(Text, { children: ["  ", truncateToWidth(state.currentPhase.nowLine, innerWidth - 12)] })] }), _jsx(Box, { children: _jsxs(Text, { color: DIVIDER_COLOR, children: ["        └ last activity ", formatSinceActivity(now, state.currentPhase.lastActivityAt)] }) })] })) : (_jsx(Text, { color: DIVIDER_COLOR, children: statusLine(state) })) })] }));
 }
 function statusLine(state) {
     switch (state.status) {
@@ -34,9 +34,8 @@ function statusLine(state) {
             return "failed";
     }
 }
-function Divider({ width, borderColor, }) {
-    const mid = "─".repeat(Math.max(0, width - 2));
-    return (_jsxs(Text, { children: [_jsx(Text, { color: borderColor, children: "\u251C" }), _jsx(Text, { color: DIVIDER_COLOR, children: mid }), _jsx(Text, { color: borderColor, children: "\u2524" })] }));
+function Divider({ width }) {
+    return _jsx(Text, { color: DIVIDER_COLOR, children: "─".repeat(Math.max(0, width)) });
 }
 function PhaseProgression({ phases, borderColor, }) {
     return (_jsxs(Box, { flexWrap: "wrap", children: [_jsx(Text, { color: DIVIDER_COLOR, children: "phases " }), phases.map((p, i) => {

package/dist/src/ui/tui/index.d.ts

@@ -1,15 +1,24 @@
 /**
  * Experimental multi-issue TUI entry point.
  *
- * Mounts an `ink` app that polls `RunOrchestrator.getSnapshot()` at 10 Hz.
- * Unmounts when the orchestrator reports `done` so the shell returns
+ * Mounts an `ink` app that polls a snapshot provider's `getSnapshot()` at
+ * 10 Hz. Unmounts when the snapshot reports `done` so the shell returns
  * cleanly. Only safe to call when `process.stdout.isTTY` is true.
+ *
+ * The provider is structural (`{ getSnapshot(): RunSnapshot }`) so any source
+ * of run state can drive the TUI — `RunOrchestrator` for `sequant run`, or the
+ * single-issue adapter `sequant ready` owns (#699). The TUI only ever reads
+ * `getSnapshot()`, never the orchestrator's batch lifecycle.
  */
-import type { RunOrchestrator } from "../../lib/workflow/run-orchestrator.js";
+import type { RunSnapshot } from "../../lib/workflow/run-state.js";
+/** Minimal structural contract the TUI needs from its state source. */
+export interface SnapshotProvider {
+    getSnapshot(): RunSnapshot;
+}
 export interface TuiHandle {
     /** Promise that resolves when the TUI unmounts. */
     done: Promise<void>;
     /** Force-unmount (e.g., on SIGINT fallback). */
     unmount: () => void;
 }
-export declare function renderTui(orchestrator: RunOrchestrator): TuiHandle;
+export declare function renderTui(provider: SnapshotProvider): TuiHandle;

package/dist/src/ui/tui/index.js

@@ -1,25 +1,39 @@
 /**
  * Experimental multi-issue TUI entry point.
  *
- * Mounts an `ink` app that polls `RunOrchestrator.getSnapshot()` at 10 Hz.
- * Unmounts when the orchestrator reports `done` so the shell returns
+ * Mounts an `ink` app that polls a snapshot provider's `getSnapshot()` at
+ * 10 Hz. Unmounts when the snapshot reports `done` so the shell returns
  * cleanly. Only safe to call when `process.stdout.isTTY` is true.
+ *
+ * The provider is structural (`{ getSnapshot(): RunSnapshot }`) so any source
+ * of run state can drive the TUI — `RunOrchestrator` for `sequant run`, or the
+ * single-issue adapter `sequant ready` owns (#699). The TUI only ever reads
+ * `getSnapshot()`, never the orchestrator's batch lifecycle.
  */
 import { createElement } from "react";
 import { render } from "ink";
 import { App } from "./App.js";
-export function renderTui(orchestrator) {
+import { composeTeardownSummary } from "./teardown.js";
+export function renderTui(provider) {
     let resolveDone;
     const done = new Promise((resolve) => {
         resolveDone = resolve;
     });
     const instance = render(createElement(App, {
-        getSnapshot: () => orchestrator.getSnapshot(),
+        getSnapshot: () => provider.getSnapshot(),
         onDone: () => {
             instance.unmount();
         },
     }), { exitOnCtrlC: false });
-    instance.waitUntilExit().then(() => resolveDone());
+    instance.waitUntilExit().then(() => {
+        // #699 AC-5: ink leaves no per-issue history on unmount, so write a durable
+        // `✔/✘` transcript from the final snapshot into scrollback. Runs before
+        // `done` resolves so the caller's own report (e.g. `ready`'s) prints after.
+        const summary = composeTeardownSummary(provider.getSnapshot());
+        if (summary)
+            process.stdout.write(summary + "\n");
+        resolveDone();
+    });
     return {
         done,
         unmount: () => {

package/dist/src/ui/tui/row-cap.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Row cap + frame-height clamp for the Ink TUI (#699 AC-4).
+ *
+ * Parity with the plain renderer's #624 behavior (`run-renderer.ts`
+ * `applyRowCap` / `effectiveRowCap`): N issues must never render more boxes
+ * than the terminal can hold. Keep every active (queued/running) issue, fill
+ * the remaining slots with the most-recently-completed issues, and roll older
+ * completed issues into a single `✔ N done` summary line.
+ *
+ * The TUI difference is vertical density: each plain-grid issue is ~3 lines,
+ * but a full Ink box is ~9–11 lines (round border + 3 cells + 2 dividers +
+ * bottom margin). `LINES_PER_BOX` is sized accordingly so the dynamic cap
+ * reflects how many boxes actually fit.
+ */
+import type { IssueRuntimeState } from "../../lib/workflow/run-state.js";
+/** Static row cap (matches the plain renderer's default). */
+export declare const DEFAULT_TUI_ROW_CAP = 10;
+/**
+ * Approximate height of one rendered Ink box, in terminal rows: round border
+ * top/bottom (2) + header (1) + two dividers (2) + context cell (~3) +
+ * activity cell (~2) + bottom margin (1) ≈ 11.
+ */
+export declare const TUI_LINES_PER_BOX = 11;
+/**
+ * Effective cap: the smaller of the static cap and a dynamic terminal-height
+ * ceiling. Mirrors `run-renderer.ts` `effectiveRowCap`, but with a box-height
+ * `linesPerBox` rather than the plain grid's 3.
+ *
+ * When `rows` is unknown (no TTY size), trust the static cap directly rather
+ * than guessing a height — the same "don't over-clamp" intent as the plain
+ * renderer's tall default, without picking an arbitrary fallback row count.
+ *
+ * @internal Exported for testing.
+ */
+export declare function effectiveTuiRowCap(rows: number | undefined, staticCap?: number, linesPerBox?: number): number;
+export interface VisibleSelection {
+    /** Boxes to render, in order: active issues first, then recent done. */
+    visible: IssueRuntimeState[];
+    /** Older completed issues collapsed into the `✔ N done` summary (0 if none). */
+    rolledUpDoneCount: number;
+}
+/**
+ * Select which issue boxes to render so the frame never exceeds the terminal
+ * height. Parity with `run-renderer.ts` `applyRowCap`.
+ *
+ * - Under the cap → render everything, no rollup.
+ * - Over the cap → keep all active issues; fill remaining slots (minus one
+ *   reserved for the rollup line) with the most-recently-completed issues;
+ *   the rest roll up into `rolledUpDoneCount`.
+ */
+export declare function selectVisibleIssues(issues: IssueRuntimeState[], rows: number | undefined, staticCap?: number, linesPerBox?: number): VisibleSelection;

package/dist/src/ui/tui/row-cap.js

@@ -0,0 +1,76 @@
+/**
+ * Row cap + frame-height clamp for the Ink TUI (#699 AC-4).
+ *
+ * Parity with the plain renderer's #624 behavior (`run-renderer.ts`
+ * `applyRowCap` / `effectiveRowCap`): N issues must never render more boxes
+ * than the terminal can hold. Keep every active (queued/running) issue, fill
+ * the remaining slots with the most-recently-completed issues, and roll older
+ * completed issues into a single `✔ N done` summary line.
+ *
+ * The TUI difference is vertical density: each plain-grid issue is ~3 lines,
+ * but a full Ink box is ~9–11 lines (round border + 3 cells + 2 dividers +
+ * bottom margin). `LINES_PER_BOX` is sized accordingly so the dynamic cap
+ * reflects how many boxes actually fit.
+ */
+/** Static row cap (matches the plain renderer's default). */
+export const DEFAULT_TUI_ROW_CAP = 10;
+/**
+ * Approximate height of one rendered Ink box, in terminal rows: round border
+ * top/bottom (2) + header (1) + two dividers (2) + context cell (~3) +
+ * activity cell (~2) + bottom margin (1) ≈ 11.
+ */
+export const TUI_LINES_PER_BOX = 11;
+/**
+ * Fixed vertical overhead outside the issue boxes: the Header block plus the
+ * rolled-up `✔ N done` summary line.
+ */
+const FIXED_OVERHEAD = 4;
+/** A queued or running issue is "active"; passed/failed are terminal. */
+function isActive(issue) {
+    return issue.status === "queued" || issue.status === "running";
+}
+/**
+ * Effective cap: the smaller of the static cap and a dynamic terminal-height
+ * ceiling. Mirrors `run-renderer.ts` `effectiveRowCap`, but with a box-height
+ * `linesPerBox` rather than the plain grid's 3.
+ *
+ * When `rows` is unknown (no TTY size), trust the static cap directly rather
+ * than guessing a height — the same "don't over-clamp" intent as the plain
+ * renderer's tall default, without picking an arbitrary fallback row count.
+ *
+ * @internal Exported for testing.
+ */
+export function effectiveTuiRowCap(rows, staticCap = DEFAULT_TUI_ROW_CAP, linesPerBox = TUI_LINES_PER_BOX) {
+    if (!rows || rows <= 0)
+        return staticCap;
+    const dynamicCap = Math.max(1, Math.floor((rows - FIXED_OVERHEAD) / Math.max(1, linesPerBox)));
+    return Math.min(staticCap, dynamicCap);
+}
+/**
+ * Select which issue boxes to render so the frame never exceeds the terminal
+ * height. Parity with `run-renderer.ts` `applyRowCap`.
+ *
+ * - Under the cap → render everything, no rollup.
+ * - Over the cap → keep all active issues; fill remaining slots (minus one
+ *   reserved for the rollup line) with the most-recently-completed issues;
+ *   the rest roll up into `rolledUpDoneCount`.
+ */
+export function selectVisibleIssues(issues, rows, staticCap = DEFAULT_TUI_ROW_CAP, linesPerBox = TUI_LINES_PER_BOX) {
+    const cap = effectiveTuiRowCap(rows, staticCap, linesPerBox);
+    if (issues.length <= cap) {
+        return { visible: issues, rolledUpDoneCount: 0 };
+    }
+    const active = issues.filter(isActive);
+    const done = issues
+        .filter((i) => !isActive(i))
+        .sort((a, b) => (b.completedAt?.getTime() ?? 0) - (a.completedAt?.getTime() ?? 0));
+    // Reserve one slot for the rollup line; the rest go to visible boxes.
+    const visibleSlots = Math.max(1, cap - 1);
+    const remainingForDone = Math.max(0, visibleSlots - active.length);
+    const visibleDone = done.slice(0, remainingForDone);
+    const rolledUpDoneCount = done.length - visibleDone.length;
+    return {
+        visible: [...active, ...visibleDone],
+        rolledUpDoneCount,
+    };
+}

package/dist/src/ui/tui/teardown.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Durable teardown summary for the Ink TUI (#699 AC-5).
+ *
+ * Ink repaints a live region in place; unlike the plain renderer it appends no
+ * per-issue `✔/✘` history when it unmounts. So on teardown we compose a compact
+ * transcript line per issue from the final snapshot and write it to stdout
+ * (outside ink's managed region) so a completed run leaves a record in
+ * scrollback. Emitting it here in the shared entry point means both `run` and
+ * `sequant ready` inherit it.
+ */
+import type { RunSnapshot } from "../../lib/workflow/run-state.js";
+/**
+ * Compose the durable teardown summary from a final snapshot.
+ *
+ * Returns a newline-joined block of one line per issue, or an empty string when
+ * there are no issues (nothing to record).
+ *
+ * @internal Exported for testing.
+ */
+export declare function composeTeardownSummary(snapshot: RunSnapshot): string;

package/dist/src/ui/tui/teardown.js

@@ -0,0 +1,29 @@
+/**
+ * Durable teardown summary for the Ink TUI (#699 AC-5).
+ *
+ * Ink repaints a live region in place; unlike the plain renderer it appends no
+ * per-issue `✔/✘` history when it unmounts. So on teardown we compose a compact
+ * transcript line per issue from the final snapshot and write it to stdout
+ * (outside ink's managed region) so a completed run leaves a record in
+ * scrollback. Emitting it here in the shared entry point means both `run` and
+ * `sequant ready` inherit it.
+ */
+/** One transcript line per issue, e.g. `✔ #699 Upgrade ready to the Ink TUI`. */
+function issueLine(issue) {
+    const glyph = issue.status === "failed" ? "✘" : "✔";
+    const title = issue.title ? ` ${issue.title}` : "";
+    return `${glyph} #${issue.number}${title}`;
+}
+/**
+ * Compose the durable teardown summary from a final snapshot.
+ *
+ * Returns a newline-joined block of one line per issue, or an empty string when
+ * there are no issues (nothing to record).
+ *
+ * @internal Exported for testing.
+ */
+export function composeTeardownSummary(snapshot) {
+    if (!snapshot.issues.length)
+        return "";
+    return snapshot.issues.map(issueLine).join("\n");
+}

package/dist/src/ui/tui/theme.d.ts

@@ -11,6 +11,9 @@ export declare const BORDER_ROTATION: readonly ["cyan", "magenta", "blue", "yell
 export type BorderColor = (typeof BORDER_ROTATION)[number] | "green" | "red" | "gray";
 /** Gray used for horizontal dividers inside each box. */
 export declare const DIVIDER_COLOR: "gray";
+/** Green used for the rolled-up `✔ N done` summary line (#699, parity with the
+ *  plain renderer's #624 rollup). */
+export declare const ROLLUP_COLOR: "green";
 /**
  * Pick the border color for an issue.
  * Failed / passed states win over rotation; otherwise rotate by slot.

package/dist/src/ui/tui/theme.js

@@ -9,6 +9,9 @@
 export const BORDER_ROTATION = ["cyan", "magenta", "blue", "yellow"];
 /** Gray used for horizontal dividers inside each box. */
 export const DIVIDER_COLOR = "gray";
+/** Green used for the rolled-up `✔ N done` summary line (#699, parity with the
+ *  plain renderer's #624 rollup). */
+export const ROLLUP_COLOR = "green";
 /**
  * Pick the border color for an issue.
  * Failed / passed states win over rotation; otherwise rotate by slot.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sequant",
-  "version": "2.3.0",
-  "description": "Quantize your development workflow - Sequential AI phases with quality gates",
+  "version": "2.5.0",
+  "description": "AI coding agent orchestrator — resolve GitHub issues end-to-end with isolated git worktrees, quality gates, and an MCP server. Works with Claude Code or Aider.",
   "type": "module",
   "bin": {
     "sequant": "dist/bin/cli.js"
@@ -26,6 +26,7 @@
     "test": "vitest run",
     "lint": "eslint src/ bin/ --max-warnings 0",
     "sync:skills": "cp -r templates/skills/* .claude/skills/",
+    "sync:hooks": "bash scripts/sync-hooks.sh",
     "validate:skills": "for skill in templates/skills/*/; do npx skills-ref validate \"$skill\"; done",
     "lint:skill-calls": "npx tsx scripts/lint-skill-calls.ts",
     "prepare:marketplace": "npx tsx scripts/prepare-marketplace.ts",
@@ -33,26 +34,37 @@
     "prepublishOnly": "npm run build"
   },
   "keywords": [
-    "ai",
     "claude",
     "claude-code",
+    "claude-code-plugin",
     "aider",
     "mcp",
+    "mcp-server",
     "cli",
+    "headless",
+    "ci",
     "workflow",
     "automation",
+    "parallel",
     "coding-agent",
-    "agent",
+    "ai-coding-agent",
+    "agent-orchestrator",
+    "autonomous-agent",
+    "agentic",
     "github",
     "github-issues",
+    "pull-request",
+    "issue-resolution",
+    "spec-driven",
+    "acceptance-criteria",
+    "human-in-the-loop",
+    "code-review",
     "quality-gates",
     "code-quality",
     "orchestrator",
+    "git-worktree",
     "developer-tools",
-    "anthropic",
-    "llm",
-    "ai-coding",
-    "copilot"
+    "ai-coding"
   ],
   "author": "Sequant Contributors",
   "license": "MIT",
@@ -65,7 +77,7 @@
   },
   "homepage": "https://sequant.io",
   "engines": {
-    "node": ">=20.19.0"
+    "node": ">=22.12.0"
   },
   "peerDependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1"
@@ -76,7 +88,7 @@
     }
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.11",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.142",
     "@hono/node-server": "^2.0.0",
     "boxen": "^8.0.1",
     "chalk": "^5.3.0",
@@ -87,7 +99,7 @@
     "gradient-string": "^3.0.0",
     "hono": "^4.12.1",
     "ink": "^7.0.1",
-    "inquirer": "^13.3.0",
+    "inquirer": "^14.0.1",
     "log-update": "^7.0.1",
     "open": "^11.0.0",
     "ora": "^9.3.0",

package/templates/hooks/post-tool.sh

@@ -227,6 +227,60 @@ if [[ "$TOOL_NAME" == "Bash" ]] && echo "$TOOL_INPUT" | grep -qE '(npm run build
     fi
 fi
 
+# === TEST COVERAGE ANALYSIS (P3) ===
+# Opt-in: Set CLAUDE_HOOKS_COVERAGE=true to enable
+# Automatically appends coverage analysis to npm test output
+# Logs which changed files have/don't have corresponding tests
+if [[ "${CLAUDE_HOOKS_COVERAGE:-}" == "true" ]]; then
+    if [[ "$TOOL_NAME" == "Bash" ]] && echo "$TOOL_INPUT" | grep -qE '(npm (test|run test)|bun (test|run test)|yarn (test|run test)|pnpm (test|run test))'; then
+        # Only run if tests passed (don't clutter failure output)
+        if ! echo "$TOOL_OUTPUT" | grep -qE '(FAIL|failed|Error:)'; then
+            COVERAGE_LOG="${_LOG_DIR}/claude-coverage.log"
+
+            # Get changed source files (excluding tests)
+            changed_files=$(git diff main...HEAD --name-only 2>/dev/null | grep -E '\.(ts|tsx|js|jsx)$' | grep -v -E '\.test\.|\.spec\.|__tests__' || true)
+
+            if [[ -n "$changed_files" ]]; then
+                echo "$(date +%H:%M:%S) COVERAGE_ANALYSIS: Checking test coverage for changed files" >> "$QUALITY_LOG"
+
+                files_with_tests=0
+                files_without_tests=0
+                critical_without_tests=""
+
+                while IFS= read -r file; do
+                    [[ -z "$file" ]] && continue
+                    base=$(basename "$file" .ts | sed 's/\.tsx$//')
+
+                    # Check for test file
+                    if find . -name "${base}.test.*" -o -name "${base}.spec.*" 2>/dev/null | grep -q .; then
+                        ((files_with_tests++))
+                    else
+                        ((files_without_tests++))
+                        # Check if critical path
+                        if echo "$file" | grep -qE 'auth|payment|security|server-action|middleware|admin'; then
+                            critical_without_tests="$critical_without_tests $file"
+                        fi
+                    fi
+                done <<< "$changed_files"
+
+                total=$((files_with_tests + files_without_tests))
+
+                # Log coverage summary
+                echo "$(date +%H:%M:%S) COVERAGE: $files_with_tests/$total changed files have tests" >> "$COVERAGE_LOG"
+
+                if [[ -n "$critical_without_tests" ]]; then
+                    echo "$(date +%H:%M:%S) ⚠️ CRITICAL_NO_TESTS:$critical_without_tests" >> "$COVERAGE_LOG"
+                    echo "$(date +%H:%M:%S) CRITICAL_NO_TESTS:$critical_without_tests" >> "$QUALITY_LOG"
+                fi
+
+                if [[ $files_without_tests -gt 0 ]]; then
+                    echo "$(date +%H:%M:%S) COVERAGE_GAP: $files_without_tests files without tests" >> "$QUALITY_LOG"
+                fi
+            fi
+        fi
+    fi
+fi
+
 # === SMART TEST RUNNING (P3) ===
 # Opt-in: Set CLAUDE_HOOKS_SMART_TESTS=true to enable
 # Runs related tests asynchronously after file edits
@@ -311,4 +365,31 @@ if [[ -n "${CLAUDE_HOOKS_WEBHOOK_URL:-}" ]]; then
     fi
 fi
 
+# === POST-MERGE WORKTREE CLEANUP ===
+# Clean up worktree AFTER `gh pr merge` succeeds (not before).
+# Previous approach removed worktree pre-merge, which lost work if merge failed.
+if [[ "$TOOL_NAME" == "Bash" ]] && echo "$TOOL_INPUT" | grep -qE 'gh pr merge'; then
+    # Only clean up if merge succeeded (output contains merge confirmation)
+    if echo "$TOOL_OUTPUT" | grep -qiE '(merged|Merged pull request|Pull request .* merged)'; then
+        PR_NUM=$(echo "$TOOL_INPUT" | grep -oE 'gh pr merge [0-9]+' | grep -oE '[0-9]+')
+
+        if [[ -n "$PR_NUM" ]]; then
+            BRANCH_NAME=$(gh pr view "$PR_NUM" --json headRefName --jq '.headRefName' 2>/dev/null || true)
+
+            if [[ -n "$BRANCH_NAME" ]]; then
+                # Note: worktree line is 2 lines before branch line in porcelain output
+                WORKTREE_PATH=$(git worktree list --porcelain 2>/dev/null | grep -B2 "branch refs/heads/$BRANCH_NAME" | grep "^worktree " | sed 's/^worktree //' || true)
+
+                if [[ -n "$WORKTREE_PATH" && -d "$WORKTREE_PATH" ]]; then
+                    git worktree remove "$WORKTREE_PATH" --force 2>/dev/null || true
+                    echo "POST-MERGE: Removed worktree $WORKTREE_PATH for branch $BRANCH_NAME" >> "${_LOG_DIR}/claude-hook.log"
+                fi
+
+                # Clean up local branch
+                git branch -D "$BRANCH_NAME" 2>/dev/null || true
+            fi
+        fi
+    fi
+fi
+
 exit 0