gsd-lite 0.2.1 → 0.3.2

package/src/server.js

@@ -2,7 +2,11 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { pathToFileURL } from 'node:url';
+import { createRequire } from 'node:module';
 import { init, read, update, phaseComplete } from './tools/state.js';
+
+const _require = createRequire(import.meta.url);
+const PKG_VERSION = _require('../package.json').version;
 import {
   handleDebuggerResult,
   handleExecutorResult,
@@ -12,13 +16,13 @@ import {
 } from './tools/orchestrator.js';
 
 const server = new Server(
-  { name: 'gsd-lite', version: '0.2.0' },
+  { name: 'gsd', version: PKG_VERSION },
   { capabilities: { tools: {} } }
 );
 
 const TOOLS = [
   {
-    name: 'gsd-health',
+    name: 'health',
     description: 'Health check: returns server status and whether .gsd state exists',
     inputSchema: {
       type: 'object',
@@ -26,7 +30,7 @@ const TOOLS = [
     },
   },
   {
-    name: 'gsd-state-init',
+    name: 'state-init',
     description: 'Initialize .gsd/ directory with state.json, plan.md, and phases/*.md',
     inputSchema: {
       type: 'object',
@@ -38,9 +42,25 @@ const TOOLS = [
           items: {
             type: 'object',
             properties: {
-              name: { type: 'string' },
-              tasks: { type: 'array' },
+              name: { type: 'string', description: 'Phase name' },
+              tasks: {
+                type: 'array',
+                description: 'Task definitions',
+                items: {
+                  type: 'object',
+                  properties: {
+                    name: { type: 'string', description: 'Task name (required)' },
+                    index: { type: 'number', description: 'Task index within phase (default: auto)' },
+                    level: { type: 'string', description: 'Complexity level: L0/L1/L2/L3 (default: L1)' },
+                    requires: { type: 'array', description: 'Dependency list (default: [])' },
+                    review_required: { type: 'boolean', description: 'Whether review is needed (default: true)' },
+                    verification_required: { type: 'boolean', description: 'Whether verification is needed (default: true)' },
+                  },
+                  required: ['name'],
+                },
+              },
             },
+            required: ['name'],
           },
         },
         research: { type: 'boolean', description: 'Whether research directory is needed' },
@@ -49,7 +69,7 @@ const TOOLS = [
     },
   },
   {
-    name: 'gsd-state-read',
+    name: 'state-read',
     description: 'Read state.json, optionally filtering to specific fields',
     inputSchema: {
       type: 'object',
@@ -63,7 +83,7 @@ const TOOLS = [
     },
   },
   {
-    name: 'gsd-state-update',
+    name: 'state-update',
     description: 'Update state.json canonical fields with lifecycle validation',
     inputSchema: {
       type: 'object',
@@ -77,7 +97,7 @@ const TOOLS = [
     },
   },
   {
-    name: 'gsd-phase-complete',
+    name: 'phase-complete',
     description: 'Mark a phase as complete after verifying handoff gate conditions',
     inputSchema: {
       type: 'object',
@@ -100,7 +120,7 @@ const TOOLS = [
     },
   },
   {
-    name: 'gsd-orchestrator-resume',
+    name: 'orchestrator-resume',
     description: 'Resume the minimal orchestration loop from workflow_mode/current_phase state',
     inputSchema: {
       type: 'object',
@@ -108,7 +128,7 @@ const TOOLS = [
     },
   },
   {
-    name: 'gsd-orchestrator-handle-executor-result',
+    name: 'orchestrator-handle-executor-result',
     description: 'Persist an executor result and determine the next orchestration action',
     inputSchema: {
       type: 'object',
@@ -119,7 +139,7 @@ const TOOLS = [
     },
   },
   {
-    name: 'gsd-orchestrator-handle-debugger-result',
+    name: 'orchestrator-handle-debugger-result',
     description: 'Persist a debugger result and determine the next orchestration action',
     inputSchema: {
       type: 'object',
@@ -130,7 +150,7 @@ const TOOLS = [
     },
   },
   {
-    name: 'gsd-orchestrator-handle-researcher-result',
+    name: 'orchestrator-handle-researcher-result',
     description: 'Persist a researcher result, write .gsd/research artifacts, and continue orchestration',
     inputSchema: {
       type: 'object',
@@ -143,7 +163,7 @@ const TOOLS = [
     },
   },
   {
-    name: 'gsd-orchestrator-handle-reviewer-result',
+    name: 'orchestrator-handle-reviewer-result',
     description: 'Persist a reviewer result, update task lifecycles, and determine next orchestration action',
     inputSchema: {
       type: 'object',
@@ -162,12 +182,12 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
 async function dispatchToolCall(name, args) {
   let result;
   switch (name) {
-    case 'gsd-health': {
+    case 'health': {
       const stateResult = await read(args || {});
       result = {
         status: 'ok',
-        server: 'gsd-lite',
-        version: '0.2.0',
+        server: 'gsd',
+        version: PKG_VERSION,
         state_exists: !stateResult.error,
         ...(stateResult.error ? {} : {
           project: stateResult.project,
@@ -178,31 +198,31 @@ async function dispatchToolCall(name, args) {
       };
       break;
     }
-    case 'gsd-state-init':
+    case 'state-init':
       result = await init(args);
       break;
-    case 'gsd-state-read':
+    case 'state-read':
       result = await read(args || {});
       break;
-    case 'gsd-state-update':
+    case 'state-update':
       result = await update(args);
       break;
-    case 'gsd-phase-complete':
+    case 'phase-complete':
       result = await phaseComplete(args);
       break;
-    case 'gsd-orchestrator-resume':
+    case 'orchestrator-resume':
       result = await resumeWorkflow(args || {});
       break;
-    case 'gsd-orchestrator-handle-executor-result':
+    case 'orchestrator-handle-executor-result':
       result = await handleExecutorResult(args || {});
       break;
-    case 'gsd-orchestrator-handle-debugger-result':
+    case 'orchestrator-handle-debugger-result':
       result = await handleDebuggerResult(args || {});
       break;
-    case 'gsd-orchestrator-handle-researcher-result':
+    case 'orchestrator-handle-researcher-result':
       result = await handleResearcherResult(args || {});
       break;
-    case 'gsd-orchestrator-handle-reviewer-result':
+    case 'orchestrator-handle-reviewer-result':
       result = await handleReviewerResult(args || {});
       break;
     default:

package/src/tools/orchestrator.js

@@ -27,7 +27,7 @@ function parseTimestamp(value) {
 }
 
 async function readContextHealth(basePath) {
-  const gsdDir = getGsdDir(basePath);
+  const gsdDir = await getGsdDir(basePath);
   if (!gsdDir) return null;
   try {
     const raw = await readFile(join(gsdDir, '.context-health'), 'utf-8');
@@ -75,7 +75,7 @@ async function detectPlanDrift(basePath, lastSession) {
   const lastSessionTs = parseTimestamp(lastSession);
   if (lastSessionTs === null) return [];
 
-  const gsdDir = getGsdDir(basePath);
+  const gsdDir = await getGsdDir(basePath);
   if (!gsdDir) return [];
 
   const candidates = [join(gsdDir, 'plan.md')];
@@ -106,41 +106,37 @@ async function evaluatePreflight(state, basePath) {
     return { override: null };
   }
 
-  const currentGitHead = getGitHead(basePath);
+  const hints = [];
+
+  const currentGitHead = await getGitHead(basePath);
   if (state.git_head && currentGitHead && state.git_head !== currentGitHead) {
-    return {
-      override: {
-        workflow_mode: 'reconcile_workspace',
-        action: 'await_manual_intervention',
-        updates: { workflow_mode: 'reconcile_workspace' },
-        saved_git_head: state.git_head,
-        current_git_head: currentGitHead,
-        message: 'Saved git_head does not match the current workspace HEAD',
-      },
-    };
+    hints.push({
+      workflow_mode: 'reconcile_workspace',
+      action: 'await_manual_intervention',
+      updates: { workflow_mode: 'reconcile_workspace' },
+      saved_git_head: state.git_head,
+      current_git_head: currentGitHead,
+      message: 'Saved git_head does not match the current workspace HEAD',
+    });
   }
 
   const changed_files = await detectPlanDrift(basePath, state.context?.last_session);
   if (changed_files.length > 0) {
-    return {
-      override: {
-        workflow_mode: 'replan_required',
-        action: 'await_manual_intervention',
-        updates: { workflow_mode: 'replan_required' },
-        changed_files,
-        message: 'Plan artifacts changed after the last recorded session',
-      },
-    };
-  }
-
-  if (state.workflow_mode === 'awaiting_user' && state.current_review?.stage === 'direction_drift') {
-    return { override: null };
+    hints.push({
+      workflow_mode: 'replan_required',
+      action: 'await_manual_intervention',
+      updates: { workflow_mode: 'replan_required' },
+      changed_files,
+      message: 'Plan artifacts changed after the last recorded session',
+    });
   }
 
-  const driftPhase = getDirectionDriftPhase(state);
-  if (driftPhase) {
-    return {
-      override: {
+  const skipDirectionDrift = state.workflow_mode === 'awaiting_user'
+    && state.current_review?.stage === 'direction_drift';
+  if (!skipDirectionDrift) {
+    const driftPhase = getDirectionDriftPhase(state);
+    if (driftPhase) {
+      hints.push({
         workflow_mode: 'awaiting_user',
         action: 'awaiting_user',
         updates: {
@@ -155,24 +151,27 @@ async function evaluatePreflight(state, basePath) {
         },
         drift_phase: { id: driftPhase.id, name: driftPhase.name },
         message: `Direction drift detected for phase ${driftPhase.id}; user decision required before resuming`,
-      },
-    };
+      });
+    }
   }
 
   const expired_research = collectExpiredResearch(state);
   if (expired_research.length > 0) {
-    return {
-      override: {
-        workflow_mode: 'research_refresh_needed',
-        action: 'dispatch_researcher',
-        updates: { workflow_mode: 'research_refresh_needed' },
-        expired_research,
-        message: 'Research cache expired and must be refreshed before execution resumes',
-      },
-    };
+    hints.push({
+      workflow_mode: 'research_refresh_needed',
+      action: 'dispatch_researcher',
+      updates: { workflow_mode: 'research_refresh_needed' },
+      expired_research,
+      message: 'Research cache expired and must be refreshed before execution resumes',
+    });
   }
 
-  return { override: null };
+  if (hints.length === 0) return { override: null };
+
+  return {
+    override: hints[0],
+    hints: hints.length > 1 ? hints.map(h => h.message) : undefined,
+  };
 }
 
 function getCurrentPhase(state) {
@@ -386,6 +385,7 @@ async function resumeExecutingTask(state, basePath) {
   if (state.current_task) {
     const currentTask = getTaskById(phase, state.current_task);
     if (currentTask?.lifecycle === 'running') {
+      const isRetrying = (currentTask.retry_count || 0) > 0;
       const persistError = await persist(basePath, {
         workflow_mode: 'executing_task',
         current_task: currentTask.id,
@@ -394,7 +394,12 @@ async function resumeExecutingTask(state, basePath) {
       if (persistError) return persistError;
       return buildExecutorDispatch(state, phase, currentTask, {
         resumed: true,
-        interruption_recovered: true,
+        interruption_recovered: !isRetrying,
+        ...(isRetrying ? {
+          retry_after_failure: true,
+          retry_count: currentTask.retry_count,
+          last_failure_summary: currentTask.last_failure_summary,
+        } : {}),
       });
     }
   }
@@ -419,11 +424,16 @@ async function resumeExecutingTask(state, basePath) {
 
   if (selection.mode === 'trigger_review') {
     const current_review = { scope: 'phase', scope_id: phase.id };
-    const persistError = await persist(basePath, {
+    const updates = {
       workflow_mode: 'reviewing_phase',
       current_task: null,
       current_review,
-    });
+    };
+    // Auto-advance phase lifecycle to 'reviewing' if currently 'active'
+    if (phase.lifecycle === 'active') {
+      updates.phases = [{ id: phase.id, lifecycle: 'reviewing' }];
+    }
+    const persistError = await persist(basePath, updates);
     if (persistError) return persistError;
 
     return {
@@ -492,6 +502,7 @@ export async function resumeWorkflow({ basePath = process.cwd() } = {}) {
       ...(preflight.override.current_git_head ? { current_git_head: preflight.override.current_git_head } : {}),
       ...(preflight.override.changed_files ? { changed_files: preflight.override.changed_files } : {}),
       ...(preflight.override.expired_research ? { expired_research: preflight.override.expired_research } : {}),
+      ...(preflight.hints ? { pending_issues: preflight.hints } : {}),
     };
   }
 
@@ -562,6 +573,7 @@ export async function resumeWorkflow({ basePath = process.cwd() } = {}) {
           id: task.id,
           level: task.level,
           checkpoint_commit: task.checkpoint_commit || null,
+          files_changed: task.files_changed || [],
         })),
       };
     }
@@ -688,8 +700,9 @@ export async function handleExecutorResult({ result, basePath = process.cwd() }
       }
     }
 
-    // L0 auto-accept: promote checkpointed → accepted in a second persist
-    if (isL0) {
+    // Auto-accept: L0 tasks or tasks with review_required: false
+    const autoAccept = isL0 || task.review_required === false;
+    if (autoAccept) {
       const acceptError = await persist(basePath, {
         phases: [{
           id: phase.id,
@@ -707,7 +720,7 @@ export async function handleExecutorResult({ result, basePath = process.cwd() }
       task_id: task.id,
       review_level: reviewLevel,
       current_review,
-      auto_accepted: isL0,
+      auto_accepted: autoAccept,
     };
   }
 
@@ -813,6 +826,18 @@ export async function handleDebuggerResult({ result, basePath = process.cwd() }
 
   if (result.outcome === 'failed' || result.architecture_concern === true) {
     const phaseFailed = result.architecture_concern === true;
+
+    // Determine effective workflow mode: if no tasks can make progress, escalate
+    let effectiveWorkflowMode;
+    if (phaseFailed) {
+      effectiveWorkflowMode = 'failed';
+    } else {
+      const hasProgressable = (phase.todo || []).some(t =>
+        t.id !== task.id && !['accepted', 'failed'].includes(t.lifecycle),
+      );
+      effectiveWorkflowMode = hasProgressable ? 'executing_task' : 'awaiting_user';
+    }
+
     const phasePatch = { id: phase.id };
     if (phaseFailed) {
       phasePatch.lifecycle = 'failed';
@@ -820,7 +845,7 @@ export async function handleDebuggerResult({ result, basePath = process.cwd() }
     phasePatch.todo = [{ id: task.id, lifecycle: 'failed', debug_context }];
 
     const persistError = await persist(basePath, {
-      workflow_mode: phaseFailed ? 'failed' : 'executing_task',
+      workflow_mode: effectiveWorkflowMode,
       current_task: null,
       current_review: null,
       phases: [phasePatch],
@@ -830,7 +855,7 @@ export async function handleDebuggerResult({ result, basePath = process.cwd() }
     return {
       success: true,
       action: phaseFailed ? 'phase_failed' : 'task_failed',
-      workflow_mode: phaseFailed ? 'failed' : 'executing_task',
+      workflow_mode: effectiveWorkflowMode,
       phase_id: phase.id,
       task_id: task.id,
     };
@@ -880,6 +905,7 @@ export async function handleReviewerResult({ result, basePath = process.cwd() }
 
   const taskPatches = [];
   let doneIncrement = 0;
+  let doneDecrement = 0;
 
   // Accept tasks
   for (const taskId of (result.accepted_tasks || [])) {
@@ -896,10 +922,16 @@ export async function handleReviewerResult({ result, basePath = process.cwd() }
     const task = getTaskById(phase, taskId);
     if (!task) continue;
     if (task.lifecycle === 'checkpointed' || task.lifecycle === 'accepted') {
+      if (task.lifecycle === 'accepted') doneDecrement += 1;
       taskPatches.push({ id: taskId, lifecycle: 'needs_revalidation', evidence_refs: [] });
     }
   }
 
+  // Snapshot accepted task IDs before propagation (for done counter adjustment)
+  const acceptedBeforePropagation = new Set(
+    (phase.todo || []).filter(t => t.lifecycle === 'accepted').map(t => t.id),
+  );
+
   // Propagation for critical issues with invalidates_downstream
   for (const issue of (result.critical_issues || [])) {
     if (issue.invalidates_downstream && issue.task_id) {
@@ -911,6 +943,9 @@ export async function handleReviewerResult({ result, basePath = process.cwd() }
   for (const task of (phase.todo || [])) {
     if (task.lifecycle === 'needs_revalidation' && !taskPatches.some((p) => p.id === task.id)) {
       taskPatches.push({ id: task.id, lifecycle: 'needs_revalidation', evidence_refs: [] });
+      if (acceptedBeforePropagation.has(task.id)) {
+        doneDecrement += 1;
+      }
     }
   }
 
@@ -919,7 +954,7 @@ export async function handleReviewerResult({ result, basePath = process.cwd() }
 
   const phaseUpdates = {
     id: phase.id,
-    done: (phase.done || 0) + doneIncrement,
+    done: Math.max(0, (phase.done || 0) + doneIncrement - doneDecrement),
     phase_review: {
       status: reviewStatus,
       ...(hasCritical ? { retry_count: (phase.phase_review?.retry_count || 0) + 1 } : {}),

package/src/tools/state.js

@@ -2,7 +2,7 @@
 
 import { join, dirname } from 'node:path';
 import { stat } from 'node:fs/promises';
-import { ensureDir, readJson, writeJson, writeAtomic, getStatePath, getGitHead } from '../utils.js';
+import { ensureDir, readJson, writeJson, writeAtomic, getStatePath, getGitHead, isPlainObject } from '../utils.js';
 import {
   CANONICAL_FIELDS,
   TASK_LIFECYCLE,
@@ -25,10 +25,6 @@ function withStateLock(fn) {
   return p;
 }
 
-function isPlainObject(value) {
-  return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-
 function inferWorkflowModeAfterResearch(state) {
   if (state.current_review?.scope === 'phase') return 'reviewing_phase';
   if (state.current_review?.scope === 'task') return 'reviewing_task';
@@ -73,7 +69,8 @@ export async function init({ project, phases, research, force = false, basePath
   }
 
   const state = createInitialState({ project, phases });
-  state.git_head = getGitHead(basePath);
+  if (state.error) return state;
+  state.git_head = await getGitHead(basePath);
 
   // Create plan.md placeholder (atomic write)
   await writeAtomic(
@@ -104,7 +101,7 @@ export async function init({ project, phases, research, force = false, basePath
  * Read state.json, optionally filtering to specific fields.
  */
 export async function read({ fields, basePath = process.cwd() } = {}) {
-  const statePath = getStatePath(basePath);
+  const statePath = await getStatePath(basePath);
   if (!statePath) {
     return { error: true, message: 'No .gsd directory found' };
   }
@@ -146,7 +143,7 @@ export async function update({ updates, basePath = process.cwd() } = {}) {
     };
   }
 
-  const statePath = getStatePath(basePath);
+  const statePath = await getStatePath(basePath);
   if (!statePath) {
     return { error: true, message: 'No .gsd directory found' };
   }
@@ -239,7 +236,6 @@ export async function update({ updates, basePath = process.cwd() } = {}) {
  */
 function verificationPassed(verification) {
   if (!verification || typeof verification !== 'object') return false;
-  if ('passed' in verification) return verification.passed === true;
   return ['lint', 'typecheck', 'test'].every((key) => (
     verification[key]
     && typeof verification[key].exit_code === 'number'
@@ -274,7 +270,7 @@ export async function phaseComplete({
   if (direction_ok !== undefined && typeof direction_ok !== 'boolean') {
     return { error: true, message: 'direction_ok must be a boolean when provided' };
   }
-  const statePath = getStatePath(basePath);
+  const statePath = await getStatePath(basePath);
   if (!statePath) {
     return { error: true, message: 'No .gsd directory found' };
   }
@@ -361,10 +357,11 @@ export async function phaseComplete({
       }
       await writeJson(statePath, state);
       return {
-        error: true,
-        message: 'Handoff gate not met: direction drift detected, awaiting user decision',
+        success: true,
+        action: 'direction_drift',
         workflow_mode: 'awaiting_user',
         phase_id: phase.id,
+        message: 'Direction drift detected; awaiting user decision before phase can complete',
       };
     }
 
@@ -388,7 +385,7 @@ export async function phaseComplete({
 
     // Update git_head to current commit
     const gsdDir = dirname(statePath);
-    state.git_head = getGitHead(dirname(gsdDir));
+    state.git_head = await getGitHead(dirname(gsdDir));
 
     // Prune evidence from old phases (in-memory to avoid double read/write)
     await _pruneEvidenceFromState(state, state.current_phase, gsdDir);
@@ -413,7 +410,7 @@ export async function addEvidence({ id, data, basePath = process.cwd() }) {
     return { error: true, message: 'data.scope must be a string' };
   }
 
-  const statePath = getStatePath(basePath);
+  const statePath = await getStatePath(basePath);
   if (!statePath) {
     return { error: true, message: 'No .gsd directory found' };
   }
@@ -475,7 +472,7 @@ async function _pruneEvidenceFromState(state, currentPhase, gsdDir) {
  * Scope format is "task:X.Y" where X is the phase number.
  */
 export async function pruneEvidence({ currentPhase, basePath = process.cwd() }) {
-  const statePath = getStatePath(basePath);
+  const statePath = await getStatePath(basePath);
   if (!statePath) {
     return { error: true, message: 'No .gsd directory found' };
   }
@@ -524,6 +521,11 @@ export function selectRunnableTask(phase, state, { maxRetry = DEFAULT_MAX_RETRY
   if (!phase || !Array.isArray(phase.todo)) {
     return { error: true, message: 'Phase todo must be an array' };
   }
+  // D-4: Zero-task phase — immediately trigger review so phase can advance
+  if (phase.todo.length === 0) {
+    return { mode: 'trigger_review' };
+  }
+
   const runnableTasks = [];
 
   for (const task of phase.todo) {
@@ -557,6 +559,12 @@ export function selectRunnableTask(phase, state, { maxRetry = DEFAULT_MAX_RETRY
     return { mode: 'trigger_review' };
   }
 
+  // All tasks accepted → trigger phase review if not already reviewed
+  const allAccepted = phase.todo.length > 0 && phase.todo.every(t => t.lifecycle === 'accepted');
+  if (allAccepted && phase.phase_review?.status !== 'accepted') {
+    return { mode: 'trigger_review' };
+  }
+
   const blockedTasks = phase.todo.filter(t => t.lifecycle === 'blocked');
   if (blockedTasks.length > 0) {
     return { mode: 'awaiting_user', blockers: blockedTasks.map(t => ({ id: t.id, reason: t.blocked_reason })) };
@@ -720,7 +728,8 @@ export function reclassifyReviewLevel(task, executorResult) {
 
   // Check for explicit [LEVEL-UP] in decisions
   const hasLevelUp = (executorResult.decisions || []).some(d =>
-    typeof d === 'string' && d.includes('[LEVEL-UP]')
+    (typeof d === 'string' && d.includes('[LEVEL-UP]'))
+    || (d && typeof d === 'object' && typeof d.summary === 'string' && d.summary.includes('[LEVEL-UP]'))
   );
   if (hasLevelUp) return 'L2';
 
@@ -864,7 +873,7 @@ export async function storeResearch({ result, artifacts, decision_index, basePat
     return { error: true, message: `Invalid research decision_index: ${decisionIndexValidation.errors.join('; ')}` };
   }
 
-  const statePath = getStatePath(basePath);
+  const statePath = await getStatePath(basePath);
   if (!statePath) {
     return { error: true, message: 'No .gsd directory found' };
   }
@@ -898,10 +907,12 @@ export async function storeResearch({ result, artifacts, decision_index, basePat
       ? applyResearchRefresh(state, nextResearch)
       : { warnings: [] };
 
+    // D-2: Compute merged decision_index explicitly before spread to avoid key-ordering fragility
+    const mergedDecisionIndex = state.research?.decision_index || decision_index;
     state.research = {
       ...(state.research || {}),
       ...nextResearch,
-      decision_index: state.research?.decision_index || decision_index,
+      decision_index: mergedDecisionIndex,
     };
 
     if (state.workflow_mode === 'research_refresh_needed') {

package/src/tools/verify.js

@@ -65,13 +65,16 @@ export async function runLint(pm, cwd) {
   return runCommand(pm, ['run', 'lint'], cwd);
 }
 
-export async function runTypeCheck(cwd) {
+export async function runTypeCheck(pm, cwd) {
   // M-8: Only run tsc if tsconfig.json exists
   try {
     await stat(join(cwd, 'tsconfig.json'));
   } catch {
     return { exit_code: 0, summary: 'skipped: no tsconfig.json found' };
   }
+  if (pm === 'pnpm') return runCommand('pnpm', ['exec', 'tsc', '--noEmit'], cwd);
+  if (pm === 'yarn') return runCommand('yarn', ['tsc', '--noEmit'], cwd);
+  if (pm === 'bun') return runCommand('bun', ['run', 'tsc', '--noEmit'], cwd);
   return runCommand('npx', ['tsc', '--noEmit'], cwd);
 }
 
@@ -81,9 +84,10 @@ export async function runAll(cwd = process.cwd()) {
     const errResult = { exit_code: -1, summary: 'No package manager detected' };
     return { lint: errResult, typecheck: errResult, test: errResult };
   }
-  return {
-    lint: await runLint(pm, cwd),
-    typecheck: await runTypeCheck(cwd),
-    test: await runTests(pm, cwd),
-  };
+  const [lint, typecheck, test] = await Promise.all([
+    runLint(pm, cwd),
+    runTypeCheck(pm, cwd),
+    runTests(pm, cwd),
+  ]);
+  return { lint, typecheck, test };
 }