mstro-app 0.4.20 → 0.4.22

package/server/services/plan/executor.ts

@@ -20,11 +20,11 @@ import { EventEmitter } from 'node:events';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { runWithFileLogger } from '../../cli/headless/headless-logger.js';
-import { HeadlessRunner } from '../../cli/headless/index.js';
 import { ConfigInstaller } from './config-installer.js';
 import { resolveReadyToWork } from './dependency-resolver.js';
-import { replaceFrontMatterField, setFrontMatterField } from './front-matter.js';
+import { checkAllAcceptanceCriteria, replaceFrontMatterField, setFrontMatterField } from './front-matter.js';
 import { buildIssuePrompt } from './issue-prompt-builder.js';
+import { runIssueWithRetry } from './issue-retry.js';
 import { listExistingDocs, publishOutputs, resolveOutputPath } from './output-manager.js';
 import { parseBoardDirectory, parsePlanDirectory, resolvePmDir } from './parser.js';
 import { appendReviewFeedback, getReviewAttemptCount, MAX_REVIEW_ATTEMPTS, persistReviewResult, reviewIssue } from './review-gate.js';
@@ -62,13 +62,15 @@ export class PlanExecutor extends EventEmitter {
   private epicScope: string | null = null;
   /** Cached PM directory path — resolved once per start(). */
   private pmDir: string | null = null;
-  /** Board directory path (e.g. /path/.pm/boards/BOARD-001). Used for outputs, reviews, progress. */
+  /** Board directory path (e.g. /path/.mstro/pm/boards/BOARD-001). Used for outputs, reviews, progress. */
   private boardDir: string | null = null;
   /** Board ID being executed (e.g. "BOARD-001") */
   private boardId: string | null = null;
   private configInstaller: ConfigInstaller;
   /** Flag to prevent start() from clearing scope set by startBoard/startEpic */
   private _scopeSetByCall = false;
+  /** Extra environment variables forwarded to HeadlessRunner child processes (e.g. API keys) */
+  private extraEnv?: Record<string, string>;
   private metrics: ExecutionMetrics = {
     issuesCompleted: 0,
     issuesAttempted: 0,
@@ -77,9 +79,10 @@ export class PlanExecutor extends EventEmitter {
     currentWaveIds: [],
   };
 
-  constructor(workingDir: string) {
+  constructor(workingDir: string, options?: { extraEnv?: Record<string, string> }) {
     super();
     this.workingDir = workingDir;
+    this.extraEnv = options?.extraEnv;
     this.configInstaller = new ConfigInstaller(workingDir);
   }
 
@@ -223,7 +226,7 @@ export class PlanExecutor extends EventEmitter {
     return completedCount;
   }
 
-  /** Run a single issue via its own headless Claude Code instance. */
+  /** Run a single issue via its own headless Claude Code instance with retry logic. */
   private async runSingleIssue(
     issue: Issue,
     pmDir: string | null,
@@ -240,21 +243,19 @@ export class PlanExecutor extends EventEmitter {
       outputPath,
     });
 
-    const runner = new HeadlessRunner({
+    const boardLogDir = this.boardDir ? join(this.boardDir, 'logs') : undefined;
+    const result = await runWithFileLogger(`pm-issue-${issue.id}`, () => runIssueWithRetry({
       workingDir: this.workingDir,
-      directPrompt: prompt,
+      prompt,
       stallWarningMs: ISSUE_STALL_WARNING_MS,
       stallKillMs: ISSUE_STALL_KILL_MS,
       stallHardCapMs: ISSUE_STALL_HARD_CAP_MS,
       stallMaxExtensions: ISSUE_STALL_MAX_EXTENSIONS,
-      verbose: process.env.MSTRO_VERBOSE === '1',
       outputCallback: (text: string) => {
         this.emit('output', { issueId: issue.id, text });
       },
-    });
-
-    const boardLogDir = this.boardDir ? join(this.boardDir, 'logs') : undefined;
-    const result = await runWithFileLogger(`pm-issue-${issue.id}`, () => runner.run(), boardLogDir);
+      extraEnv: this.extraEnv,
+    }), boardLogDir);
 
     if (!result.completed || result.error) {
       this.emit('output', { issueId: waveLabel, text: `Issue ${issue.id}: ${result.error || 'did not complete'}` });
@@ -317,9 +318,10 @@ export class PlanExecutor extends EventEmitter {
         const statusMatch = content.match(/^status:\s*(\S+)/m);
         const currentStatus = statusMatch?.[1] ?? 'unknown';
 
-        if (currentStatus === 'done') {
+        if (currentStatus === 'in_review' || currentStatus === 'done') {
           if (issue.reviewGate === 'none') {
-            // Skip review gate — accept agent's done status directly
+            // Skip review gate — mark done directly
+            this.updateIssueFrontMatter(issue.path, 'done');
             this.metrics.issuesCompleted++;
             this.emit('issueCompleted', issue);
             completed++;
@@ -364,6 +366,8 @@ export class PlanExecutor extends EventEmitter {
       onOutput: (text) => this.emit('output', { issueId: issue.id, text }),
       logDir: this.boardDir ? join(this.boardDir, 'logs') : undefined,
       reviewCriteria: this.getBoardReviewCriteria(),
+      boardDir: this.boardDir,
+      extraEnv: this.extraEnv,
     });
     persistReviewResult(reviewDir, issue, result);
 
@@ -545,7 +549,15 @@ export class PlanExecutor extends EventEmitter {
     const pmDir = this.pmDir;
     if (!pmDir) return;
     try {
-      setFrontMatterField(join(pmDir, issuePath), 'status', newStatus);
+      const fullPath = join(pmDir, issuePath);
+      setFrontMatterField(fullPath, 'status', newStatus);
+
+      // Check off all acceptance criteria when marking done
+      if (newStatus === 'done') {
+        const content = readFileSync(fullPath, 'utf-8');
+        const updated = checkAllAcceptanceCriteria(content);
+        if (updated !== content) writeFileSync(fullPath, updated, 'utf-8');
+      }
     } catch { /* file may have been moved */ }
   }
 

package/server/services/plan/front-matter.ts

@@ -46,3 +46,26 @@ export function setFrontMatterField(filePath: string, field: string, value: stri
   const updated = replaceFrontMatterField(content, field, value);
   writeFileSync(filePath, updated, 'utf-8');
 }
+
+/**
+ * Check off all unchecked acceptance criteria checkboxes in a markdown string.
+ * Only modifies checkboxes within the "## Acceptance Criteria" section.
+ */
+export function checkAllAcceptanceCriteria(content: string): string {
+  const sectionStart = content.indexOf('## Acceptance Criteria');
+  if (sectionStart === -1) return content;
+
+  const afterHeader = content.indexOf('\n', sectionStart);
+  if (afterHeader === -1) return content;
+
+  const nextSection = content.slice(afterHeader).search(/\n## /);
+  const sectionEnd = nextSection !== -1 ? afterHeader + nextSection : content.length;
+
+  const before = content.slice(0, afterHeader);
+  const section = content.slice(afterHeader, sectionEnd);
+  const after = content.slice(sectionEnd);
+
+  const updatedSection = section.replace(/^([-*]\s+)\[ \]/gm, '$1[x]');
+
+  return before + updatedSection + after;
+}

package/server/services/plan/issue-prompt-builder.ts

@@ -15,7 +15,7 @@ export interface IssuePromptOptions {
   issue: Issue;
   workingDir: string;
   pmDir: string | null;
-  /** Board directory path (e.g. /path/.pm/boards/BOARD-001). */
+  /** Board directory path (e.g. /path/.mstro/pm/boards/BOARD-001). */
   boardDir: string | null;
   existingDocs: string[];
   outputPath: string;
@@ -71,7 +71,7 @@ ${files}${predecessorSection}
 1. Read the full issue spec at ${pmDir ? join(pmDir, issue.path) : issue.path}
 2. Execute all acceptance criteria listed above
 3. Write your output and results to **${outputPath}** — this is the handoff artifact for downstream issues
-4. After writing output, update the issue front matter: change \`status: in_progress\` to \`status: done\`
+4. After writing output, update the issue front matter: change \`status: in_progress\` to \`status: in_review\`
 
 ## Rules
 

package/server/services/plan/issue-retry.ts

@@ -0,0 +1,297 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Issue Retry — Retry loop for PM issue execution.
+ *
+ * Brings the same resilience as Chat view (improvisation-retry.ts) to PM agents:
+ * - Tool timeout checkpoint recovery (preserves completed tools, skips hung tool)
+ * - Signal crash recovery (preserves accumulated results across retries)
+ * - Premature completion handling (max_tokens / end_turn → resume with "continue")
+ *
+ * Unlike Chat's retry system, PM agents don't maintain session continuity across
+ * prompts — each issue is independent — so we skip inter-movement recovery and
+ * simplify the resume strategy.
+ */
+
+import { hlog } from '../../cli/headless/headless-logger.js';
+import { HeadlessRunner } from '../../cli/headless/index.js';
+import { assessPrematureCompletion } from '../../cli/headless/stall-assessor.js';
+import type { ExecutionCheckpoint, SessionResult } from '../../cli/headless/types.js';
+import {
+  buildResumeRetryPrompt,
+  buildRetryPrompt,
+  buildSignalCrashRecoveryPrompt,
+} from '../../cli/prompt-builders.js';
+
+/** Max retries per issue execution (tool timeout, signal crash, premature completion combined) */
+const MAX_ISSUE_RETRIES = 3;
+
+/** Max accumulated tool results to carry across retries */
+const MAX_ACCUMULATED_RESULTS = 50;
+
+/** Lightweight tool record for accumulation across retries */
+interface ToolRecord {
+  toolName: string;
+  toolId: string;
+  toolInput: Record<string, unknown>;
+  result?: string;
+  isError?: boolean;
+  duration?: number;
+}
+
+interface IssueRetryState {
+  currentPrompt: string;
+  retryNumber: number;
+  checkpoint: ExecutionCheckpoint | null;
+  accumulatedToolResults: ToolRecord[];
+  timedOutTools: Array<{ toolName: string; input: Record<string, unknown>; timeoutMs: number }>;
+  /** Session ID from a prior run — enables --resume for premature completion */
+  lastSessionId: string | undefined;
+  bestResult: SessionResult | null;
+}
+
+export interface IssueRunnerConfig {
+  workingDir: string;
+  /** Original enriched prompt for this issue */
+  prompt: string;
+  /** Stall detection timeouts (ms) */
+  stallWarningMs: number;
+  stallKillMs: number;
+  stallHardCapMs: number;
+  stallMaxExtensions: number;
+  /** Callback for streaming output to executor event bus */
+  outputCallback?: (text: string) => void;
+  /** Extra environment variables for spawned Claude processes (e.g. API keys) */
+  extraEnv?: Record<string, string>;
+}
+
+/**
+ * Execute a PM issue with retry logic.
+ *
+ * This wraps HeadlessRunner.run() with the same retry strategies as Chat view:
+ * 1. Tool timeout → checkpoint recovery with accumulated results
+ * 2. Signal crash → fresh start with preserved tool results
+ * 3. Premature completion → resume session with "continue"
+ */
+export async function runIssueWithRetry(config: IssueRunnerConfig): Promise<SessionResult> {
+  const state: IssueRetryState = {
+    currentPrompt: config.prompt,
+    retryNumber: 0,
+    checkpoint: null,
+    accumulatedToolResults: [],
+    timedOutTools: [],
+    lastSessionId: undefined,
+    bestResult: null,
+  };
+
+  let result: SessionResult | undefined;
+
+  while (state.retryNumber <= MAX_ISSUE_RETRIES) {
+    // Clear checkpoint from prior iteration
+    state.checkpoint = null;
+
+    // Determine resume strategy
+    const useResume = !!state.lastSessionId;
+    const resumeSessionId = state.lastSessionId;
+    state.lastSessionId = undefined;
+
+    const runner = new HeadlessRunner({
+      workingDir: config.workingDir,
+      directPrompt: state.currentPrompt,
+      stallWarningMs: config.stallWarningMs,
+      stallKillMs: config.stallKillMs,
+      stallHardCapMs: config.stallHardCapMs,
+      stallMaxExtensions: config.stallMaxExtensions,
+      verbose: true,
+      continueSession: useResume,
+      claudeSessionId: resumeSessionId,
+      outputCallback: config.outputCallback,
+      onToolTimeout: (cp: ExecutionCheckpoint) => {
+        state.checkpoint = cp;
+      },
+      extraEnv: config.extraEnv,
+    });
+
+    result = await runner.run();
+
+    // Track best result for fallback selection
+    if (!state.bestResult || scoreResult(result) > scoreResult(state.bestResult)) {
+      state.bestResult = result;
+    }
+
+    // Evaluate retry strategies in priority order
+    if (tryToolTimeoutRetry(state, result, config)) continue;
+    if (trySignalCrashRetry(state, result, config)) continue;
+    if (await tryPrematureCompletionRetry(state, result, config)) continue;
+
+    // No retry needed — break out
+    break;
+  }
+
+  return result ?? state.bestResult ?? {
+    completed: false,
+    needsHandoff: false,
+    totalTokens: 0,
+    sessionId: '',
+    error: 'No result produced after retries',
+  };
+}
+
+// ========== Retry Strategies ==========
+
+/**
+ * Strategy 1: Tool timeout checkpoint recovery.
+ * When a tool times out, we have a checkpoint with all completed tools.
+ * Build a new prompt injecting those results and skip the hung resource.
+ */
+function tryToolTimeoutRetry(
+  state: IssueRetryState,
+  _result: SessionResult,
+  config: IssueRunnerConfig,
+): boolean {
+  if (!state.checkpoint || state.retryNumber >= MAX_ISSUE_RETRIES) return false;
+
+  const cp = state.checkpoint;
+  state.retryNumber++;
+
+  state.timedOutTools.push({
+    toolName: cp.hungTool.toolName,
+    input: cp.hungTool.input ?? {},
+    timeoutMs: cp.hungTool.timeoutMs,
+  });
+
+  const canResume = cp.inProgressTools.length === 0 && !!cp.claudeSessionId;
+
+  hlog(`[PM-RETRY] Tool timeout: ${cp.hungTool.toolName} after ${Math.round(cp.hungTool.timeoutMs / 1000)}s, ${cp.completedTools.length} tools completed, retry ${state.retryNumber}/${MAX_ISSUE_RETRIES} (${canResume ? 'resume' : 'fresh'})`);
+
+  if (canResume) {
+    state.lastSessionId = cp.claudeSessionId;
+    state.currentPrompt = buildResumeRetryPrompt(cp, state.timedOutTools);
+  } else {
+    state.currentPrompt = buildRetryPrompt(cp, config.prompt, state.timedOutTools);
+  }
+
+  config.outputCallback?.(`\n[PM-RETRY] Auto-retry ${state.retryNumber}/${MAX_ISSUE_RETRIES}: ${canResume ? 'Resuming session' : 'Continuing'} with ${cp.completedTools.length} results, skipping failed ${cp.hungTool.toolName}.\n`);
+
+  return true;
+}
+
+/**
+ * Strategy 2: Signal crash recovery.
+ * Process was killed by signal (SIGTERM/SIGKILL from stall watchdog or OS).
+ * Accumulate completed tools and retry with preserved context.
+ */
+function trySignalCrashRetry(
+  state: IssueRetryState,
+  result: SessionResult,
+  config: IssueRunnerConfig,
+): boolean {
+  const isSignalCrash = !!result.signalName;
+  const exitCodeSignal = !result.completed && !result.signalName && result.error?.match(/exited with code (1[2-9]\d|[2-9]\d{2})/);
+  if ((!isSignalCrash && !exitCodeSignal) || state.retryNumber >= MAX_ISSUE_RETRIES) return false;
+  // Don't double-handle if a checkpoint was already captured (tool timeout takes priority)
+  if (state.checkpoint) return false;
+
+  accumulateToolResults(result, state);
+  state.retryNumber++;
+
+  const signalInfo = result.signalName || 'unknown signal';
+  const useResume = !!result.claudeSessionId && state.retryNumber === 1;
+
+  hlog(`[PM-RETRY] Signal crash: ${signalInfo}, ${state.accumulatedToolResults.length} tools preserved, retry ${state.retryNumber}/${MAX_ISSUE_RETRIES} (${useResume ? 'resume' : 'fresh'})`);
+
+  if (useResume) {
+    state.lastSessionId = result.claudeSessionId;
+    state.currentPrompt = buildSignalCrashRecoveryPrompt(config.prompt, true);
+  } else {
+    state.currentPrompt = buildSignalCrashRecoveryPrompt(
+      config.prompt,
+      false,
+      state.accumulatedToolResults,
+    );
+  }
+
+  config.outputCallback?.(`\n[PM-RETRY] Signal recovery ${state.retryNumber}/${MAX_ISSUE_RETRIES}: ${useResume ? 'Resuming' : 'Restarting'} with ${state.accumulatedToolResults.length} preserved results.\n`);
+
+  return true;
+}
+
+/** Check if an end_turn result is actually incomplete using Haiku assessment. */
+async function isEndTurnIncomplete(result: SessionResult): Promise<boolean> {
+  if (!result.assistantResponse) return false;
+  const claudeCmd = process.env.CLAUDE_COMMAND || 'claude';
+  try {
+    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, true);
+
+    hlog(`[PM-RETRY] Premature completion check: ${verdict.isIncomplete ? 'INCOMPLETE' : 'COMPLETE'} — ${verdict.reason}`);
+    return verdict.isIncomplete;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Strategy 3: Premature completion.
+ * Claude hit max_tokens or ended early without finishing work.
+ * Resume the session with "continue".
+ */
+async function tryPrematureCompletionRetry(
+  state: IssueRetryState,
+  result: SessionResult,
+  config: IssueRunnerConfig,
+): Promise<boolean> {
+  if (!result.completed || result.signalName || state.retryNumber >= MAX_ISSUE_RETRIES) return false;
+  if (state.checkpoint) return false;
+  if (!result.claudeSessionId || !result.stopReason) return false;
+
+  const isMaxTokens = result.stopReason === 'max_tokens';
+  const isEndTurn = result.stopReason === 'end_turn';
+  if (!isMaxTokens && !isEndTurn) return false;
+
+  // max_tokens always continues; end_turn requires AI assessment
+  if (isEndTurn && !(await isEndTurnIncomplete(result))) return false;
+
+  state.retryNumber++;
+  state.lastSessionId = result.claudeSessionId;
+  state.currentPrompt = 'continue';
+
+  const reason = isMaxTokens ? 'Output limit reached' : 'Task appears unfinished';
+  hlog(`[PM-RETRY] Premature completion: ${reason}, resuming session, retry ${state.retryNumber}/${MAX_ISSUE_RETRIES}`);
+  config.outputCallback?.(`\n[PM-RETRY] ${reason} — resuming session (retry ${state.retryNumber}/${MAX_ISSUE_RETRIES}).\n`);
+
+  return true;
+}
+
+// ========== Helpers ==========
+
+function accumulateToolResults(result: SessionResult, state: IssueRetryState): void {
+  if (!result.toolUseHistory) return;
+  for (const t of result.toolUseHistory) {
+    if (t.result !== undefined) {
+      state.accumulatedToolResults.push({
+        toolName: t.toolName,
+        toolId: t.toolId,
+        toolInput: t.toolInput,
+        result: t.result,
+        isError: t.isError,
+        duration: t.duration,
+      });
+    }
+  }
+  if (state.accumulatedToolResults.length > MAX_ACCUMULATED_RESULTS) {
+    state.accumulatedToolResults = state.accumulatedToolResults.slice(-MAX_ACCUMULATED_RESULTS);
+  }
+}
+
+function scoreResult(r: SessionResult): number {
+  const toolCount = r.toolUseHistory?.filter(t => t.result !== undefined && !t.isError).length ?? 0;
+  const responseLen = Math.min((r.assistantResponse?.length ?? 0) / 50, 100);
+  const hasThinking = r.thinkingOutput ? 20 : 0;
+  return toolCount * 10 + responseLen + hasThinking;
+}

package/server/services/plan/output-manager.ts

@@ -23,7 +23,7 @@ export function slugify(text: string): string {
 
 /**
  * Resolve the canonical output path for an issue.
- * Uses sprint sandbox when available, otherwise global .pm/out/.
+ * Uses sprint sandbox when available, otherwise global .mstro/pm/out/.
  */
 export function resolveOutputPath(issue: Issue, workingDir: string, sprintSandboxDir: string | null): string {
   if (sprintSandboxDir) {
@@ -61,7 +61,7 @@ export interface PublishOutputsCallbacks {
 }
 
 /**
- * Copy confirmed-done outputs from .pm/out/ to user-specified output_file paths.
+ * Copy confirmed-done outputs from .mstro/pm/out/ to user-specified output_file paths.
  * Only copies for issues that completed successfully and have output_file set.
  */
 export function publishOutputs(

package/server/services/plan/parser-core.ts

@@ -2,7 +2,7 @@
 // Licensed under the MIT License. See LICENSE file for details.
 
 /**
- * YAML front-matter parsing and entity parsers for PPS (.pm/) files.
+ * YAML front-matter parsing and entity parsers for PPS (.mstro/pm/) files.
  */
 
 import type {
@@ -264,7 +264,7 @@ export function parseIssue(content: string, filePath: string): Issue {
     id: String(fm.id || ''),
     title: String(fm.title || ''),
     type: (fm.type as Issue['type']) || 'issue',
-    status: String(fm.status || 'backlog'),
+    status: String(fm.status || 'todo'),
     priority: String(fm.priority || 'P2'),
     estimate: fm.estimate != null ? fm.estimate as number | string : null,
     labels: toStringArray(fm.labels),

package/server/services/plan/parser-migration.ts

@@ -2,14 +2,14 @@
 // Licensed under the MIT License. See LICENSE file for details.
 
 /**
- * Legacy → Board-centric migration for .pm/ directories.
+ * Legacy → Board-centric migration for .mstro/pm/ directories.
  */
 
 import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { parseFrontMatter } from './parser-core.js';
 
-/** Check whether a .pm/ directory uses the legacy flat format (has backlog/ at root, no boards/). */
+/** Check whether a .mstro/pm/ directory uses the legacy flat format (has backlog/ at root, no boards/). */
 export function isLegacyFormat(pmDir: string): boolean {
   return existsSync(join(pmDir, 'backlog')) && !existsSync(join(pmDir, 'boards'));
 }
@@ -73,10 +73,10 @@ function cleanupMigratedIssues(boardBacklogDir: string): boolean {
     const content = readFileIfExists(join(boardBacklogDir, f));
     if (!content) continue;
     const fm = parseFrontMatter(content).frontMatter;
-    const status = String(fm.status || 'backlog');
+    const status = String(fm.status || 'todo');
     if (status === 'done' || status === 'closed' || status === 'cancelled') {
       rmSync(join(boardBacklogDir, f));
-    } else if (status !== 'backlog') {
+    } else if (status !== 'todo') {
       hasActive = true;
     }
   }
@@ -104,7 +104,7 @@ function writeBoardMetadata(pmDir: string, boardDir: string, boardId: string, sp
   }, null, 2));
 }
 
-/** Migrate a legacy flat .pm/ directory to the board-centric format. */
+/** Migrate a legacy flat .mstro/pm/ directory to the board-centric format. */
 export function migrateToBoards(pmDir: string): void {
   const boardId = 'BOARD-001';
   const boardDir = join(pmDir, 'boards', boardId);

package/server/services/plan/parser.ts

@@ -2,7 +2,7 @@
 // Licensed under the MIT License. See LICENSE file for details.
 
 /**
- * PPS Parser — Public API for reading .pm/ (or legacy .plan/) directories.
+ * PPS Parser — Public API for reading .mstro/pm/ directories.
  *
  * Entity parsing lives in parser-core.ts; migration in parser-migration.ts.
  */
@@ -37,10 +37,6 @@ export function isBoardCentricFormat(pmDir: string): boolean {
 export function resolvePmDir(workingDir: string): string | null {
   const mstroPmDir = join(workingDir, '.mstro', 'pm');
   if (existsSync(mstroPmDir)) return mstroPmDir;
-  const legacyPmDir = join(workingDir, '.pm');
-  if (existsSync(legacyPmDir)) return legacyPmDir;
-  const legacyPlanDir = join(workingDir, '.plan');
-  if (existsSync(legacyPlanDir)) return legacyPlanDir;
   return null;
 }
 
@@ -125,6 +121,9 @@ export function parseBoardDirectory(pmDir: string, boardId: string): BoardFullSt
     issue.blockedBy = issue.blockedBy.map(bp => bp.startsWith('boards/') ? bp : `${boardPrefix}${bp}`);
     issue.blocks = issue.blocks.map(bp => bp.startsWith('boards/') ? bp : `${boardPrefix}${bp}`);
     if (issue.epic && !issue.epic.startsWith('boards/')) issue.epic = `${boardPrefix}${issue.epic}`;
+    if (issue.children.length > 0) {
+      issue.children = issue.children.map(cp => cp.startsWith('boards/') ? cp : `${boardPrefix}${cp}`);
+    }
     return issue;
   });
 

package/server/services/plan/prompt-builder.ts

@@ -15,7 +15,7 @@ export interface CoordinatorPromptOptions {
   issues: Issue[];
   workingDir: string;
   pmDir: string | null;
-  /** Board directory path when executing a board (e.g. /path/.pm/boards/BOARD-001). */
+  /** Board directory path when executing a board (e.g. /path/.mstro/pm/boards/BOARD-001). */
   boardDir: string | null;
   existingDocs: string[];
   resolveOutputPath: (issue: Issue) => string;