mstro-app 0.4.2 → 0.4.4

package/server/services/plan/composer.ts

@@ -15,7 +15,8 @@ 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';
+import { defaultPmDir, getNextId, parseBoardDirectory, parsePlanDirectory, resolvePmDir } from './parser.js';
+import type { Issue } from './types.js';
 
 const PROMPT_TOOL_MESSAGES: Record<string, string> = {
   Glob: 'Discovering project files...',
@@ -64,57 +65,159 @@ function readFileOrEmpty(path: string): string {
   return '';
 }
 
+interface ComposerContext {
+  boardContext: string;
+  stateContent: string;
+  issues: Issue[];
+  idInfo: string;
+  epicContext: string;
+  issuesSummary: string;
+  boardDir: string;
+  backlogPath: string;
+  effectiveBoardId: string | null;
+}
+
+function buildComposerContext(pmDir: string, workingDir: string, boardId?: string): ComposerContext {
+  const fullState = parsePlanDirectory(workingDir);
+  const effectiveBoardId = boardId ?? fullState?.workspace?.activeBoardId ?? null;
+
+  let boardContext = '';
+  let stateContent = '';
+  let issues: Issue[] = [];
+
+  if (effectiveBoardId) {
+    const boardState = parseBoardDirectory(pmDir, effectiveBoardId);
+    if (boardState) {
+      stateContent = readFileOrEmpty(join(pmDir, 'boards', effectiveBoardId, 'STATE.md'));
+      issues = boardState.issues;
+      boardContext = `\nActive board: ${effectiveBoardId} — "${boardState.board.title}"
+Board status: ${boardState.board.status}
+Board goal: ${boardState.board.goal || '(none set)'}
+Board directory: ${pmDir}/boards/${effectiveBoardId}/
+Backlog directory: ${pmDir}/boards/${effectiveBoardId}/backlog/\n`;
+    }
+  }
+
+  if (!stateContent) stateContent = readFileOrEmpty(join(pmDir, 'STATE.md'));
+  if (issues.length === 0 && fullState) issues = fullState.issues;
+
+  const idInfo = (issues.length > 0 || fullState)
+    ? `Next available IDs: ${getNextId(issues, 'IS')}, ${getNextId(issues, 'BG')}, ${getNextId(issues, 'EP')}`
+    : '';
+
+  const existingEpics = issues.filter(i => i.type === 'epic');
+  const epicContext = existingEpics.length > 0
+    ? `\nExisting epics:\n${existingEpics.map(e => `- ${e.id}: ${e.title} (${e.path}, children: ${e.children.length})`).join('\n')}\n`
+    : '';
+
+  const nonEpicIssues = issues.filter(i => i.type !== 'epic');
+  const issuesSummary = nonEpicIssues.length > 0
+    ? `\nExisting issues on this board:\n${nonEpicIssues.map(i => `- ${i.id}: ${i.title} [${i.status}] (P${i.priority})`).join('\n')}\n`
+    : '';
+
+  const boardDir = effectiveBoardId ? `boards/${effectiveBoardId}` : '';
+  const backlogPath = effectiveBoardId
+    ? `${pmDir}/boards/${effectiveBoardId}/backlog/`
+    : `${pmDir}/backlog/`;
+
+  return { boardContext, stateContent, issues, idInfo, epicContext, issuesSummary, boardDir, backlogPath, effectiveBoardId };
+}
+
 export async function handlePlanPrompt(
   ctx: HandlerContext,
   ws: WSContext,
   userPrompt: string,
   workingDir: string,
+  boardId?: string,
 ): Promise<void> {
-  const pmDir = resolvePmDir(workingDir) ?? join(workingDir, '.pm');
-  const stateContent = readFileOrEmpty(join(pmDir, 'STATE.md'));
+  const pmDir = resolvePmDir(workingDir) ?? defaultPmDir(workingDir);
   const projectContent = readFileOrEmpty(join(pmDir, 'project.md'));
+  const cc = buildComposerContext(pmDir, workingDir, boardId);
 
-  // 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:
-
+  const enrichedPrompt = `You are managing a project using a board-centric PM system (Project Plan Spec v2).
+All issues belong to a board. Each board has its own backlog/, STATE.md, and out/ directory.
+${cc.boardContext}
 <state>
-${stateContent || 'No STATE.md exists yet'}
+${cc.stateContent || 'No STATE.md exists yet'}
 </state>
 
 <project>
 ${projectContent || 'No project.md yet'}
 </project>
 
-${idInfo}
-${epicContext}
+${cc.idInfo}
+${cc.epicContext}
+${cc.issuesSummary}
+
+## Directory structure
 
-Follow these rules:
-- When creating .pm/ files, use YAML front matter + markdown body
+\`\`\`
+${pmDir}/
+├── project.md
+├── workspace.json
+└── boards/
+    └── ${cc.effectiveBoardId || 'BOARD-NNN'}/
+        ├── board.md          # Board metadata
+        ├── STATE.md          # Board execution state
+        ├── backlog/          # Issues, epics, bugs
+        │   ├── EP-*.md
+        │   ├── IS-*.md
+        │   └── BG-*.md
+        ├── out/              # Output artifacts
+        ├── reviews/          # Review gate results
+        └── progress.md       # Execution log
+\`\`\`
+
+## Rules
+
+- ALL new issue files MUST be created in \`${cc.backlogPath}\`
+- Use YAML front matter + markdown body for all files
 - When modifying issues, preserve all existing YAML fields you don't change
-- After any state change, update STATE.md to reflect the new status
+- After any state change, update the board's STATE.md at \`${pmDir}/${cc.boardDir}/STATE.md\`
 - Use the next available ID for new entities
+- Set all new issue statuses to \`todo\` so they appear in the "Ready to Work" section
 - Respond briefly describing what you did
 
-Issue scoping rules (critical for execution quality):
+## Issue format
+
+Each issue file must have this structure:
+\`\`\`markdown
+---
+id: IS-NNN
+title: "Short descriptive title"
+type: issue
+status: todo
+priority: P0|P1|P2|P3
+estimate: 1-5
+labels: []
+epic: backlog/EP-NNN.md    # if part of an epic
+created: "YYYY-MM-DD"
+blocked_by: []             # Use backlog-relative paths: backlog/IS-NNN.md
+blocks: []                 # Use backlog-relative paths: backlog/IS-NNN.md
+review_gate: auto
+output_file: null
+---
+
+# IS-NNN: Title
+
+## Description
+What needs to be done and why.
+
+## Acceptance Criteria
+- [ ] Criterion 1
+- [ ] Criterion 2
+
+## Technical Notes
+Implementation guidance.
+
+## Files to Modify
+- path/to/file.ts
+
+## Activity
+\`\`\`
+
+## 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
@@ -124,8 +227,9 @@ Issue scoping rules (critical for execution quality):
 - 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
+## Epic creation rules
+
+- Create an EP-*.md file in ${cc.backlogPath} 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, ...]
@@ -169,7 +273,8 @@ User request: ${userPrompt}`;
       data: { message: 'Claude is planning your project...' },
     });
 
-    const result = await runWithFileLogger('pm-compose', () => runner.run());
+    const boardLogDir = cc.effectiveBoardId ? join(pmDir, 'boards', cc.effectiveBoardId, 'logs') : undefined;
+    const result = await runWithFileLogger('pm-compose', () => runner.run(), boardLogDir);
 
     ctx.broadcastToAll({
       type: 'planPromptProgress',

package/server/services/plan/config-installer.ts

@@ -0,0 +1,187 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Config Installer — Manages temporary config file modifications for Agent Teams.
+ *
+ * Installs teammate permissions in .claude/settings.json and bouncer MCP config
+ * in .mcp.json before wave execution, then restores originals afterward.
+ */
+
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { generateMcpConfig } from '../../cli/headless/mcp-config.js';
+
+/** Tools that teammates may need during execution */
+const REQUIRED_PERMISSIONS = [
+  'Bash',
+  'Read',
+  'Edit',
+  'Write',
+  'Glob',
+  'Grep',
+  'WebFetch',
+  'WebSearch',
+  'Agent',
+];
+
+/** Restore a file from a .pm-backup, handling the __NONE__ sentinel for files that didn't exist. */
+function restoreFromBackup(backupPath: string, targetPath: string): void {
+  try {
+    if (!existsSync(backupPath)) return;
+    const backup = readFileSync(backupPath, 'utf-8');
+    if (backup === '__NONE__') {
+      if (existsSync(targetPath)) unlinkSync(targetPath);
+    } else {
+      writeFileSync(targetPath, backup);
+    }
+    unlinkSync(backupPath);
+  } catch { /* best effort */ }
+}
+
+export class ConfigInstaller {
+  private savedClaudeSettings: string | null = null;
+  private claudeSettingsInstalled = false;
+  private savedMcpJson: string | null = null;
+  private mcpJsonInstalled = false;
+
+  constructor(private workingDir: string) {
+    // Recover from prior crash: if backup files exist, restore them
+    this.recoverFromCrash();
+  }
+
+  /** Restore .claude/settings.json and .mcp.json from backups left by a previous crash. */
+  private recoverFromCrash(): void {
+    restoreFromBackup(
+      join(this.workingDir, '.claude', 'settings.json.pm-backup'),
+      join(this.workingDir, '.claude', 'settings.json'),
+    );
+    restoreFromBackup(
+      join(this.workingDir, '.mcp.json.pm-backup'),
+      join(this.workingDir, '.mcp.json'),
+    );
+  }
+
+  /**
+   * Pre-approve tools in .claude/settings.json so Agent Teams
+   * teammates can work without interactive permission prompts.
+   */
+  installTeammatePermissions(): void {
+    const claudeDir = join(this.workingDir, '.claude');
+    const settingsPath = join(claudeDir, 'settings.json');
+
+    if (!existsSync(claudeDir)) {
+      mkdirSync(claudeDir, { recursive: true });
+    }
+
+    const backupPath = join(claudeDir, 'settings.json.pm-backup');
+    try {
+      if (existsSync(settingsPath)) {
+        this.savedClaudeSettings = readFileSync(settingsPath, 'utf-8');
+        writeFileSync(backupPath, this.savedClaudeSettings);
+        const existing = JSON.parse(this.savedClaudeSettings);
+
+        if (!existing.permissions) existing.permissions = {};
+        if (!existing.permissions.allow) existing.permissions.allow = [];
+
+        for (const tool of REQUIRED_PERMISSIONS) {
+          if (!existing.permissions.allow.includes(tool)) {
+            existing.permissions.allow.push(tool);
+          }
+        }
+
+        writeFileSync(settingsPath, JSON.stringify(existing, null, 2));
+      } else {
+        this.savedClaudeSettings = null;
+        writeFileSync(backupPath, '__NONE__');
+        writeFileSync(settingsPath, JSON.stringify({
+          permissions: { allow: REQUIRED_PERMISSIONS },
+        }, null, 2));
+      }
+      this.claudeSettingsInstalled = true;
+    } catch {
+      // Non-fatal — teammates may hit permission prompts
+    }
+  }
+
+  /** Restore original .claude/settings.json after wave execution. */
+  uninstallTeammatePermissions(): void {
+    if (!this.claudeSettingsInstalled) return;
+    const settingsPath = join(this.workingDir, '.claude', 'settings.json');
+    const backupPath = join(this.workingDir, '.claude', 'settings.json.pm-backup');
+
+    try {
+      if (this.savedClaudeSettings !== null) {
+        writeFileSync(settingsPath, this.savedClaudeSettings);
+      } else {
+        unlinkSync(settingsPath);
+      }
+    } catch {
+      // Best effort
+    }
+
+    // Remove backup — successful restore means crash recovery is no longer needed
+    try { if (existsSync(backupPath)) unlinkSync(backupPath); } catch { /* ok */ }
+
+    this.savedClaudeSettings = null;
+    this.claudeSettingsInstalled = false;
+  }
+
+  /**
+   * Write .mcp.json so Agent Teams teammates auto-discover the bouncer MCP server.
+   * Also generates ~/.mstro/mcp-config.json for the team lead (--mcp-config).
+   */
+  installBouncerForSubagents(): void {
+    const mcpJsonPath = join(this.workingDir, '.mcp.json');
+
+    const backupPath = join(this.workingDir, '.mcp.json.pm-backup');
+    try {
+      const generatedPath = generateMcpConfig(this.workingDir);
+      if (!generatedPath) return;
+
+      const mcpConfig = readFileSync(generatedPath, 'utf-8');
+
+      if (existsSync(mcpJsonPath)) {
+        this.savedMcpJson = readFileSync(mcpJsonPath, 'utf-8');
+        writeFileSync(backupPath, this.savedMcpJson);
+
+        const existing = JSON.parse(this.savedMcpJson);
+        const generated = JSON.parse(mcpConfig);
+        existing.mcpServers = {
+          ...existing.mcpServers,
+          'mstro-bouncer': generated.mcpServers['mstro-bouncer'],
+        };
+        writeFileSync(mcpJsonPath, JSON.stringify(existing, null, 2));
+      } else {
+        writeFileSync(backupPath, '__NONE__');
+        writeFileSync(mcpJsonPath, mcpConfig);
+      }
+
+      this.mcpJsonInstalled = true;
+    } catch {
+      // Non-fatal: parent has MCP via --mcp-config, teammates fall back to PreToolUse hooks
+    }
+  }
+
+  /** Restore or remove .mcp.json after execution. */
+  uninstallBouncerForSubagents(): void {
+    if (!this.mcpJsonInstalled) return;
+    const mcpJsonPath = join(this.workingDir, '.mcp.json');
+    const backupPath = join(this.workingDir, '.mcp.json.pm-backup');
+
+    try {
+      if (this.savedMcpJson !== null) {
+        writeFileSync(mcpJsonPath, this.savedMcpJson);
+      } else {
+        unlinkSync(mcpJsonPath);
+      }
+    } catch {
+      // Best effort cleanup
+    }
+
+    try { if (existsSync(backupPath)) unlinkSync(backupPath); } catch { /* ok */ }
+
+    this.savedMcpJson = null;
+    this.mcpJsonInstalled = false;
+  }
+}

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

@@ -84,7 +84,7 @@ function dfs(
  *
  * If epicScope is provided, only returns issues belonging to that epic.
  */
-export function resolveReadyToWork(issues: Issue[], epicScope?: string): Issue[] {
+export function resolveReadyToWork(issues: Issue[], epicScope?: string, sprintScope?: string): Issue[] {
   const issueByPath = new Map<string, Issue>();
   for (const issue of issues) {
     issueByPath.set(issue.path, issue);
@@ -116,6 +116,9 @@ export function resolveReadyToWork(issues: Issue[], epicScope?: string): Issue[]
       // If scoped to an epic, only include that epic's children
       if (epicChildPaths && !epicChildPaths.has(issue.path)) return false;
 
+      // If scoped to a sprint, only include issues assigned to that sprint
+      if (sprintScope && issue.sprint !== sprintScope) return false;
+
       // Check all blockers are resolved
       if (issue.blockedBy.length > 0) {
         const allResolved = issue.blockedBy.every(bp => {