mstro-app 0.3.8 → 0.3.9

package/server/cli/improvisation-session-manager.ts

@@ -12,8 +12,9 @@ import { EventEmitter } from 'node:events';
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { AnalyticsEvents, trackEvent } from '../services/analytics.js';
+import { herror, hlog } from './headless/headless-logger.js';
 import { HeadlessRunner } from './headless/index.js';
-import { assessBestResult, assessContextLoss, type ContextLossContext } from './headless/stall-assessor.js';
+import { assessBestResult, assessContextLoss, assessPrematureCompletion, type ContextLossContext } from './headless/stall-assessor.js';
 import type { ExecutionCheckpoint } from './headless/types.js';
 
 export interface ImprovisationOptions {
@@ -302,7 +303,7 @@ export class ImprovisationSessionManager extends EventEmitter {
         writeFileSync(filePath, Buffer.from(attachment.content, 'base64'));
         paths.push(filePath);
       } catch (err) {
-        console.error(`Failed to persist attachment ${attachment.fileName}:`, err);
+        herror(`Failed to persist attachment ${attachment.fileName}:`, err);
       }
     }
 
@@ -503,6 +504,8 @@ export class ImprovisationSessionManager extends EventEmitter {
       if (this.shouldRetrySignalCrash(result, state, maxRetries, promptWithAttachments)) continue;
       if (this.shouldRetryContextLoss(result, state, useResume, nativeTimeouts, maxRetries, promptWithAttachments)) continue;
       if (this.applyToolTimeoutRetry(state, maxRetries, promptWithAttachments)) continue;
+      // Premature completion: model exited normally but task appears incomplete
+      if (await this.shouldRetryPrematureCompletion(result, state, maxRetries)) continue;
       break;
     }
     return result;
@@ -522,7 +525,7 @@ export class ImprovisationSessionManager extends EventEmitter {
         try {
           attachment.content = readFileSync(attachment.filePath).toString('base64');
         } catch (err) {
-          console.error(`Failed to read pre-uploaded image ${attachment.filePath}:`, err);
+          herror(`Failed to read pre-uploaded image ${attachment.filePath}:`, err);
           attachment.isImage = false;
         }
       }
@@ -662,17 +665,17 @@ export class ImprovisationSessionManager extends EventEmitter {
     }
     if (!result.assistantResponse || result.assistantResponse.trim().length === 0) {
       state.contextLost = true;
-      if (this.options.verbose) console.log('[CONTEXT-RECOVERY] Resume context loss: null/empty response');
+      if (this.options.verbose) hlog('[CONTEXT-RECOVERY] Resume context loss: null/empty response');
     } else if (result.resumeBufferedOutput !== undefined) {
       state.contextLost = true;
-      if (this.options.verbose) console.log('[CONTEXT-RECOVERY] Resume context loss: buffer never flushed (no thinking/tools)');
+      if (this.options.verbose) hlog('[CONTEXT-RECOVERY] Resume context loss: buffer never flushed (no thinking/tools)');
     } else if (
       (!result.toolUseHistory || result.toolUseHistory.length === 0) &&
       !result.thinkingOutput &&
       result.assistantResponse.length < 500
     ) {
       state.contextLost = true;
-      if (this.options.verbose) console.log('[CONTEXT-RECOVERY] Resume context loss: no tools, no thinking, short response');
+      if (this.options.verbose) hlog('[CONTEXT-RECOVERY] Resume context loss: no tools, no thinking, short response');
     }
   }
 
@@ -716,7 +719,7 @@ export class ImprovisationSessionManager extends EventEmitter {
     const verdict = await assessContextLoss(contextLossCtx, claudeCmd, this.options.verbose);
     state.contextLost = verdict.contextLost;
     if (this.options.verbose) {
-      console.log(`[CONTEXT-RECOVERY] Haiku verdict: ${state.contextLost ? 'LOST' : 'OK'} — ${verdict.reason}`);
+      hlog(`[CONTEXT-RECOVERY] Haiku verdict: ${state.contextLost ? 'LOST' : 'OK'} — ${verdict.reason}`);
     }
   }
 
@@ -1015,6 +1018,110 @@ export class ImprovisationSessionManager extends EventEmitter {
     return parts.join('\n');
   }
 
+  /**
+   * Detect premature completion: Claude exited normally (exit code 0, end_turn) but the
+   * response indicates more work was planned. This happens when the model "context-fatigues"
+   * during long multi-step tasks and produces end_turn after completing a subset of the work.
+   *
+   * Two paths:
+   * - max_tokens: always retry (model was forcibly stopped mid-generation)
+   * - end_turn: Haiku assessment determines if the response looks incomplete
+   */
+  private async shouldRetryPrematureCompletion(
+    result: HeadlessRunResult,
+    state: RetryLoopState,
+    maxRetries: number,
+  ): Promise<boolean> {
+    if (!this.isPrematureCompletionCandidate(result, state, maxRetries)) {
+      return false;
+    }
+
+    const stopReason = result.stopReason!;
+    const isMaxTokens = stopReason === 'max_tokens';
+    const isIncomplete = isMaxTokens || await this.assessEndTurnCompletion(result);
+
+    if (!isIncomplete) return false;
+
+    this.applyPrematureCompletionRetry(result, state, maxRetries, stopReason, isMaxTokens);
+    return true;
+  }
+
+  /** Guard checks for premature completion — must pass all to proceed with assessment */
+  private isPrematureCompletionCandidate(
+    result: HeadlessRunResult,
+    state: RetryLoopState,
+    maxRetries: number,
+  ): boolean {
+    // Only trigger for clean exits with a known stop reason
+    if (!result.completed || result.signalName || state.retryNumber >= maxRetries) return false;
+    // Don't re-trigger if other recovery paths already handled this iteration
+    if (state.checkpointRef.value || state.contextLost) return false;
+    // Must have a session ID to resume, and a stop reason to classify
+    if (!result.claudeSessionId || !result.stopReason) return false;
+    // Only act on max_tokens or end_turn
+    return result.stopReason === 'max_tokens' || result.stopReason === 'end_turn';
+  }
+
+  /** Use Haiku to assess whether an end_turn response is genuinely complete */
+  private async assessEndTurnCompletion(result: HeadlessRunResult): Promise<boolean> {
+    if (!result.assistantResponse) return false;
+
+    const claudeCmd = process.env.CLAUDE_COMMAND || 'claude';
+    const verdict = await assessPrematureCompletion({
+      responseTail: result.assistantResponse.slice(-800),
+      successfulToolCalls: result.toolUseHistory?.filter(t => t.result !== undefined && !t.isError).length ?? 0,
+      hasThinking: !!result.thinkingOutput,
+      responseLength: result.assistantResponse.length,
+    }, claudeCmd, this.options.verbose);
+
+    if (this.options.verbose) {
+      hlog(`[PREMATURE-COMPLETION] Haiku verdict: ${verdict.isIncomplete ? 'INCOMPLETE' : 'COMPLETE'} — ${verdict.reason}`);
+    }
+    return verdict.isIncomplete;
+  }
+
+  /** Apply the retry: emit events, update state, set continuation prompt */
+  private applyPrematureCompletionRetry(
+    result: HeadlessRunResult,
+    state: RetryLoopState,
+    maxRetries: number,
+    stopReason: string,
+    isMaxTokens: boolean,
+  ): void {
+    state.retryNumber++;
+    const reason = isMaxTokens ? 'max_tokens hit' : 'incomplete end_turn (Haiku assessment)';
+
+    state.retryLog.push({
+      retryNumber: state.retryNumber,
+      path: 'PrematureCompletion',
+      reason,
+      timestamp: Date.now(),
+    });
+
+    this.emit('onAutoRetry', {
+      retryNumber: state.retryNumber,
+      maxRetries,
+      toolName: `PrematureCompletion(${stopReason})`,
+      completedCount: result.toolUseHistory?.length ?? 0,
+    });
+
+    trackEvent(AnalyticsEvents.IMPROVISE_AUTO_RETRY, {
+      retry_number: state.retryNumber,
+      hung_tool: `premature_completion:${stopReason}`,
+      completed_tools: result.toolUseHistory?.length ?? 0,
+      resume_attempted: true,
+    });
+
+    this.queueOutput(
+      `\n[[MSTRO_AUTO_CONTINUE]] Task incomplete (${reason}) — resuming session (retry ${state.retryNumber}/${maxRetries}).\n`
+    );
+    this.flushOutputQueue();
+
+    state.contextRecoverySessionId = result.claudeSessionId;
+    this.claudeSessionId = result.claudeSessionId;
+    state.currentPrompt = 'continue';
+  }
+
   /** Select the best result across retries using Haiku assessment */
   private async selectBestResult(
     state: RetryLoopState,
@@ -1047,10 +1154,10 @@ export class ImprovisationSessionManager extends EventEmitter {
       }, claudeCmd, this.options.verbose);
 
       if (verdict.winner === 'A') {
-        if (this.options.verbose) console.log(`[BEST-RESULT] Haiku picked earlier attempt: ${verdict.reason}`);
+        if (this.options.verbose) hlog(`[BEST-RESULT] Haiku picked earlier attempt: ${verdict.reason}`);
         return this.mergeResultSessionId(state.bestResult, result.claudeSessionId);
       }
-      if (this.options.verbose) console.log(`[BEST-RESULT] Haiku picked final attempt: ${verdict.reason}`);
+      if (this.options.verbose) hlog(`[BEST-RESULT] Haiku picked final attempt: ${verdict.reason}`);
       return result;
     } catch {
       return this.fallbackBestResult(state.bestResult, result);
@@ -1061,7 +1168,7 @@ export class ImprovisationSessionManager extends EventEmitter {
   private fallbackBestResult(bestResult: HeadlessRunResult, result: HeadlessRunResult): HeadlessRunResult {
     if (scoreRunResult(bestResult) > scoreRunResult(result)) {
       if (this.options.verbose) {
-        console.log(`[BEST-RESULT] Haiku unavailable, numeric fallback: earlier attempt (score ${scoreRunResult(bestResult)} vs ${scoreRunResult(result)})`);
+        hlog(`[BEST-RESULT] Haiku unavailable, numeric fallback: earlier attempt (score ${scoreRunResult(bestResult)} vs ${scoreRunResult(result)})`);
       }
       return this.mergeResultSessionId(bestResult, result.claudeSessionId);
     }
@@ -1497,7 +1604,7 @@ export class ImprovisationSessionManager extends EventEmitter {
         const data = readFileSync(this.historyPath, 'utf-8');
         return JSON.parse(data);
       } catch (error) {
-        console.error('Failed to load history:', error);
+        herror('Failed to load history:', error);
       }
     }
 

package/server/mcp/bouncer-cli.ts

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Bouncer CLI — stdin/stdout wrapper for Claude Code PreToolUse hooks.
+ *
+ * Reads a tool use request from stdin (JSON), runs it through the full
+ * 2-layer bouncer (pattern matching + Haiku AI), and writes the decision
+ * to stdout in the format Claude Code hooks expect.
+ *
+ * Input format (from Claude Code hook):
+ *   { "tool_name": "Bash", "input": { "command": "rm -rf /" } }
+ *
+ * Output format (to Claude Code hook):
+ *   { "decision": "allow"|"deny", "reason": "..." }
+ */
+
+import type { BouncerReviewRequest } from './bouncer-integration.js';
+import { reviewOperation } from './bouncer-integration.js';
+
+function buildOperation(toolName: string, toolInput: Record<string, unknown>): string {
+  const prefix = `${toolName}: `;
+  if (toolName === 'Bash' && toolInput.command) return prefix + String(toolInput.command);
+  if (toolName === 'Edit' && toolInput.file_path) return prefix + String(toolInput.file_path);
+  if (toolName === 'Write' && toolInput.file_path) return prefix + String(toolInput.file_path);
+  return prefix + JSON.stringify(toolInput).slice(0, 500);
+}
+
+async function evaluate(rawInput: string): Promise<{ decision: string; reason: string }> {
+  if (!rawInput.trim()) {
+    return { decision: 'allow', reason: 'Empty input' };
+  }
+
+  let parsed: { tool_name?: string; toolName?: string; input?: Record<string, unknown>; toolInput?: Record<string, unknown> };
+  try {
+    parsed = JSON.parse(rawInput);
+  } catch {
+    return { decision: 'allow', reason: 'Invalid JSON input' };
+  }
+
+  const toolName = parsed.tool_name || parsed.toolName || 'unknown';
+  const toolInput = parsed.input || parsed.toolInput || {};
+
+  const request: BouncerReviewRequest = {
+    operation: buildOperation(toolName, toolInput),
+    context: {
+      purpose: 'Tool use request from Claude Code hook',
+      workingDirectory: process.cwd(),
+      toolName,
+      toolInput,
+    },
+  };
+
+  const result = await reviewOperation(request);
+  return {
+    decision: result.decision === 'deny' ? 'deny' : 'allow',
+    reason: result.reasoning,
+  };
+}
+
+async function main(): Promise<void> {
+  let rawInput = '';
+  for await (const chunk of process.stdin) {
+    rawInput += chunk;
+  }
+  const result = await evaluate(rawInput);
+  console.log(JSON.stringify(result));
+}
+
+main().catch(() => {
+  console.log(JSON.stringify({ decision: 'allow', reason: 'Bouncer crash' }));
+});

package/server/services/plan/composer.ts

@@ -0,0 +1,199 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Plan Composer — Handles natural language prompts for PPS creation/editing.
+ *
+ * When a planPrompt message arrives, this builds a context-enriched prompt
+ * against the .pm/ (or legacy .plan/) directory and spawns a scoped
+ * HeadlessRunner session to execute it.
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { runWithFileLogger } from '../../cli/headless/headless-logger.js';
+import { HeadlessRunner, type ToolUseEvent } from '../../cli/headless/index.js';
+import type { HandlerContext } from '../websocket/handler-context.js';
+import type { WSContext } from '../websocket/types.js';
+import { getNextId, parsePlanDirectory, resolvePmDir } from './parser.js';
+
+const PROMPT_TOOL_MESSAGES: Record<string, string> = {
+  Glob: 'Discovering project files...',
+  Read: 'Reading project structure...',
+  Grep: 'Searching codebase...',
+  Write: 'Creating project files...',
+  Edit: 'Updating project files...',
+  Bash: 'Running commands...',
+};
+
+function getPromptToolCompleteMessage(event: ToolUseEvent): string | null {
+  const input = event.completeInput;
+  if (!input) return null;
+  if (event.toolName === 'Write' && input.file_path) {
+    const filename = String(input.file_path).split('/').pop() ?? '';
+    return `Created ${filename}`;
+  }
+  if (event.toolName === 'Edit' && input.file_path) {
+    const filename = String(input.file_path).split('/').pop() ?? '';
+    return `Updated ${filename}`;
+  }
+  if (event.toolName === 'Read' && input.file_path) {
+    return `Read ${String(input.file_path).split('/').slice(-2).join('/')}`;
+  }
+  return null;
+}
+
+function createPromptProgressTracker() {
+  const seenToolStarts = new Set<string>();
+
+  return (event: ToolUseEvent): string | null => {
+    if (event.type === 'tool_start' && event.toolName) {
+      if (seenToolStarts.has(event.toolName)) return null;
+      seenToolStarts.add(event.toolName);
+      return PROMPT_TOOL_MESSAGES[event.toolName] ?? null;
+    }
+    if (event.type === 'tool_complete') return getPromptToolCompleteMessage(event);
+    return null;
+  };
+}
+
+function readFileOrEmpty(path: string): string {
+  try {
+    if (existsSync(path)) return readFileSync(path, 'utf-8');
+  } catch { /* skip */ }
+  return '';
+}
+
+export async function handlePlanPrompt(
+  ctx: HandlerContext,
+  ws: WSContext,
+  userPrompt: string,
+  workingDir: string,
+): Promise<void> {
+  const pmDir = resolvePmDir(workingDir) ?? join(workingDir, '.pm');
+  const stateContent = readFileOrEmpty(join(pmDir, 'STATE.md'));
+  const projectContent = readFileOrEmpty(join(pmDir, 'project.md'));
+
+  // Compute next available IDs
+  const fullState = parsePlanDirectory(workingDir);
+  let idInfo = '';
+  if (fullState) {
+    const nextIS = getNextId(fullState.issues, 'IS');
+    const nextBG = getNextId(fullState.issues, 'BG');
+    const nextEP = getNextId(fullState.issues, 'EP');
+    idInfo = `Next available IDs: ${nextIS}, ${nextBG}, ${nextEP}`;
+  }
+
+  // Read existing epic files to provide context
+  let epicContext = '';
+  if (fullState) {
+    const existingEpics = fullState.issues.filter((i: { type: string }) => i.type === 'epic');
+    if (existingEpics.length > 0) {
+      epicContext = `\nExisting epics:\n${existingEpics.map((e: { id: string; title: string; path: string; children: string[] }) => `- ${e.id}: ${e.title} (${e.path}, children: ${e.children.length})`).join('\n')}\n`;
+    }
+  }
+
+  const enrichedPrompt = `You are managing a project in the .pm/ directory format (Project Plan Spec).
+The project's current state is:
+
+<state>
+${stateContent || 'No STATE.md exists yet'}
+</state>
+
+<project>
+${projectContent || 'No project.md yet'}
+</project>
+
+${idInfo}
+${epicContext}
+
+Follow these rules:
+- When creating .pm/ files, use YAML front matter + markdown body
+- When modifying issues, preserve all existing YAML fields you don't change
+- After any state change, update STATE.md to reflect the new status
+- Use the next available ID for new entities
+- Respond briefly describing what you did
+
+Issue scoping rules (critical for execution quality):
+- Each issue is executed by a single AI agent with its own context window
+- Issues estimated at 1-3 story points execute well (focused, single concern)
+- Issues at 5 story points are viable if scoped to one subsystem
+- Issues at 8+ story points MUST be decomposed into smaller sub-issues
+- Issues at 13+ story points MUST become an epic with child issues
+- Each issue should touch one logical concern (one component, one service, one data flow)
+- If an issue requires work across multiple subsystems, split it into one issue per subsystem with blocked_by edges between them
+- Research/investigation issues should be separate from implementation issues
+
+Epic creation rules (when user asks for a feature with sub-tasks or an epic):
+- Create an EP-*.md file in .pm/backlog/ with type: epic and a children: [] field in front matter
+- Create individual IS-*.md (or BG-*.md) files for each child issue
+- Each child issue must have epic: backlog/EP-XXX.md in its front matter
+- The epic's children field must list all child paths: [backlog/IS-001.md, backlog/IS-002.md, ...]
+- Set blocked_by between child issues where there are natural dependencies
+- Give each child issue clear acceptance criteria and files to modify when possible
+- Set appropriate priorities (P0-P3) based on the issue's importance within the epic
+
+User request: ${userPrompt}`;
+
+  try {
+    ctx.broadcastToAll({
+      type: 'planPromptProgress',
+      data: { message: 'Starting project planning...' },
+    });
+
+    const runner = new HeadlessRunner({
+      workingDir,
+      directPrompt: enrichedPrompt,
+      outputCallback: (text: string) => {
+        ctx.send(ws, {
+          type: 'planPromptStreaming',
+          data: { token: text },
+        });
+      },
+      toolUseCallback: (() => {
+        const getProgressMessage = createPromptProgressTracker();
+        return (event: ToolUseEvent) => {
+          const message = getProgressMessage(event);
+          if (message) {
+            ctx.broadcastToAll({
+              type: 'planPromptProgress',
+              data: { message },
+            });
+          }
+        };
+      })(),
+    });
+
+    ctx.broadcastToAll({
+      type: 'planPromptProgress',
+      data: { message: 'Claude is planning your project...' },
+    });
+
+    const result = await runWithFileLogger('pm-compose', () => runner.run());
+
+    ctx.broadcastToAll({
+      type: 'planPromptProgress',
+      data: { message: 'Finalizing project plan...' },
+    });
+
+    ctx.send(ws, {
+      type: 'planPromptResponse',
+      data: {
+        response: result.completed ? 'Prompt executed successfully.' : (result.error || 'Unknown error'),
+        success: result.completed,
+        error: result.error || null,
+      },
+    });
+
+    // Re-parse and broadcast updated state
+    const updatedState = parsePlanDirectory(workingDir);
+    if (updatedState) {
+      ctx.broadcastToAll({ type: 'planStateUpdated', data: updatedState });
+    }
+  } catch (error) {
+    ctx.send(ws, {
+      type: 'planError',
+      data: { error: error instanceof Error ? error.message : String(error) },
+    });
+  }
+}

package/server/services/plan/dependency-resolver.ts

@@ -0,0 +1,179 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Dependency Resolver — Validates and computes the dependency DAG.
+ *
+ * Builds adjacency list from blocked_by/blocks fields, detects cycles,
+ * and computes the "ready to work" set.
+ */
+
+import type { Issue } from './types.js';
+
+/**
+ * Detect cycles in the dependency graph.
+ * Returns the first cycle found as an array of issue IDs, or null if acyclic.
+ */
+export function detectCycles(issues: Issue[]): string[] | null {
+  const issueByPath = new Map<string, Issue>();
+  for (const issue of issues) {
+    issueByPath.set(issue.path, issue);
+  }
+
+  // DFS with coloring: 0=white, 1=gray, 2=black
+  const color = new Map<string, number>();
+  const parent = new Map<string, string>();
+
+  for (const issue of issues) {
+    color.set(issue.path, 0);
+  }
+
+  for (const issue of issues) {
+    if (color.get(issue.path) === 0) {
+      const cycle = dfs(issue.path, issueByPath, color, parent);
+      if (cycle) return cycle;
+    }
+  }
+
+  return null;
+}
+
+function dfs(
+  path: string,
+  issueByPath: Map<string, Issue>,
+  color: Map<string, number>,
+  parent: Map<string, string>,
+): string[] | null {
+  color.set(path, 1); // Gray
+  const issue = issueByPath.get(path);
+  if (!issue) {
+    color.set(path, 2);
+    return null;
+  }
+
+  for (const dep of issue.blocks) {
+    if (!issueByPath.has(dep)) continue;
+    const depColor = color.get(dep);
+    if (depColor === 1) {
+      // Found cycle — reconstruct
+      const cycle = [dep, path];
+      let cur = path;
+      while (parent.has(cur) && parent.get(cur) !== dep) {
+        cur = parent.get(cur)!;
+        cycle.push(cur);
+      }
+      return cycle.map(p => issueByPath.get(p)?.id || p);
+    }
+    if (depColor === 0) {
+      parent.set(dep, path);
+      const cycle = dfs(dep, issueByPath, color, parent);
+      if (cycle) return cycle;
+    }
+  }
+
+  color.set(path, 2); // Black
+  return null;
+}
+
+/**
+ * Compute the set of issues that are ready to work on.
+ * An issue is ready if:
+ * - It's not an epic
+ * - Its status is backlog or todo (not started, done, or cancelled)
+ * - All its blocked_by items are done or cancelled
+ *
+ * If epicScope is provided, only returns issues belonging to that epic.
+ */
+export function resolveReadyToWork(issues: Issue[], epicScope?: string): Issue[] {
+  const issueByPath = new Map<string, Issue>();
+  for (const issue of issues) {
+    issueByPath.set(issue.path, issue);
+  }
+
+  const readyStatuses = new Set(['backlog', 'todo']);
+  const doneStatuses = new Set(['done', 'cancelled']);
+
+  const priorityOrder: Record<string, number> = { P0: 0, P1: 1, P2: 2, P3: 3 };
+
+  // Build set of child paths for epic scoping
+  let epicChildPaths: Set<string> | null = null;
+  if (epicScope) {
+    const epic = issueByPath.get(epicScope);
+    if (epic) {
+      epicChildPaths = new Set(epic.children);
+      // Also include issues that reference this epic via their epic field
+      for (const issue of issues) {
+        if (issue.epic === epicScope) epicChildPaths.add(issue.path);
+      }
+    }
+  }
+
+  return issues
+    .filter(issue => {
+      if (issue.type === 'epic') return false;
+      if (!readyStatuses.has(issue.status)) return false;
+
+      // If scoped to an epic, only include that epic's children
+      if (epicChildPaths && !epicChildPaths.has(issue.path)) return false;
+
+      // Check all blockers are resolved
+      if (issue.blockedBy.length > 0) {
+        const allResolved = issue.blockedBy.every(bp => {
+          const blocker = issueByPath.get(bp);
+          return blocker && doneStatuses.has(blocker.status);
+        });
+        if (!allResolved) return false;
+      }
+
+      return true;
+    })
+    .sort((a, b) => {
+      // Sort by priority (P0 first)
+      return (priorityOrder[a.priority] ?? 9) - (priorityOrder[b.priority] ?? 9);
+    });
+}
+
+/**
+ * Compute the critical path through incomplete issues.
+ * Returns the longest chain of dependent issues.
+ */
+export function computeCriticalPath(issues: Issue[]): Issue[] {
+  const issueByPath = new Map<string, Issue>();
+  for (const issue of issues) {
+    issueByPath.set(issue.path, issue);
+  }
+
+  const doneStatuses = new Set(['done', 'cancelled']);
+  const incompleteIssues = issues.filter(i => !doneStatuses.has(i.status) && i.type !== 'epic');
+
+  // Compute longest path using DFS with memoization
+  const longestFrom = new Map<string, Issue[]>();
+
+  function getLongest(path: string): Issue[] {
+    if (longestFrom.has(path)) return longestFrom.get(path)!;
+
+    const issue = issueByPath.get(path);
+    if (!issue || doneStatuses.has(issue.status)) {
+      longestFrom.set(path, []);
+      return [];
+    }
+
+    let best: Issue[] = [];
+    for (const dep of issue.blocks) {
+      const sub = getLongest(dep);
+      if (sub.length > best.length) best = sub;
+    }
+
+    const result = [issue, ...best];
+    longestFrom.set(path, result);
+    return result;
+  }
+
+  let criticalPath: Issue[] = [];
+  for (const issue of incompleteIssues) {
+    const path = getLongest(issue.path);
+    if (path.length > criticalPath.length) criticalPath = path;
+  }
+
+  return criticalPath;
+}