mstro-app 0.4.39 → 0.4.44

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

@@ -1,356 +1,41 @@
 // 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;
-}
+import { ResilientRunner } from '../../cli/headless/resilient-runner.js';
+import type { SessionResult } from '../../cli/headless/types.js';
 
 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>;
-  /** Signal to abort execution — when aborted, kills the running HeadlessRunner */
   abortSignal?: AbortSignal;
 }
 
-/**
- * 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"
- */
-/** Build the default "aborted" fallback result. */
-function abortedResult(bestResult: SessionResult | null): SessionResult {
-  return bestResult ?? {
-    completed: false, needsHandoff: false, totalTokens: 0, sessionId: '',
-    error: 'Execution stopped by user',
-  };
-}
-
-/** Create a HeadlessRunner configured for the current retry iteration. */
-function createRunner(
-  config: IssueRunnerConfig,
-  state: IssueRetryState,
-  useResume: boolean,
-  resumeSessionId: string | undefined,
-): HeadlessRunner {
-  return new HeadlessRunner({
+export async function runIssueWithRetry(config: IssueRunnerConfig): Promise<SessionResult> {
+  const runner = new ResilientRunner({
     workingDir: config.workingDir,
-    directPrompt: state.currentPrompt,
+    prompt: config.prompt,
+    policy: 'FULL',
+    maxRetries: 3,
     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;
-    },
+    verbose: true,
     extraEnv: config.extraEnv,
+    abortSignal: config.abortSignal,
+    onRetry: (info) => {
+      config.outputCallback?.(
+        `\n[PM-RETRY] Auto-retry ${info.retryNumber}/${info.maxRetries}: ${info.path} — ${info.reason}\n`,
+      );
+    },
   });
-}
-
-/** Wire the abort signal to clean up the runner. Returns a cleanup function. */
-function wireAbortSignal(
-  runner: HeadlessRunner,
-  abortSignal: AbortSignal | undefined,
-): (() => void) | null {
-  if (!abortSignal) return null;
-
-  const abortHandler = () => { runner.cleanup(); };
-  abortSignal.addEventListener('abort', abortHandler, { once: true });
-  return () => abortSignal.removeEventListener('abort', abortHandler);
-}
-
-/**
- * Run a single iteration: spawn runner, await result, evaluate retry.
- * Returns { result, shouldRetry } — caller loops while shouldRetry is true.
- * Returns null if aborted (caller should return abortedResult).
- */
-async function runSingleAttempt(
-  config: IssueRunnerConfig,
-  state: IssueRetryState,
-): Promise<{ result: SessionResult; shouldRetry: boolean } | null> {
-  state.checkpoint = null;
-
-  const useResume = !!state.lastSessionId;
-  const resumeSessionId = state.lastSessionId;
-  state.lastSessionId = undefined;
-
-  const runner = createRunner(config, state, useResume, resumeSessionId);
-
-  if (config.abortSignal?.aborted) {
-    runner.cleanup();
-    return null;
-  }
-  const removeAbortListener = wireAbortSignal(runner, config.abortSignal);
-
-  const result = await runner.run();
-  removeAbortListener?.();
-
-  if (config.abortSignal?.aborted) return null;
-
-  // Track best result for fallback selection
-  if (!state.bestResult || scoreResult(result) > scoreResult(state.bestResult)) {
-    state.bestResult = result;
-  }
-
-  // Evaluate retry strategies in priority order
-  const shouldRetry =
-    tryToolTimeoutRetry(state, result, config) ||
-    trySignalCrashRetry(state, result, config) ||
-    await tryPrematureCompletionRetry(state, result, config);
-
-  return { result, shouldRetry };
-}
-
-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) {
-    if (config.abortSignal?.aborted) return abortedResult(state.bestResult);
-
-    const attempt = await runSingleAttempt(config, state);
-    if (!attempt) {
-      return state.bestResult ?? result ?? abortedResult(null);
-    }
-
-    result = attempt.result;
-    if (!attempt.shouldRetry) 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;
+  return runner.run();
 }

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

@@ -286,6 +286,7 @@ export function parseIssue(content: string, filePath: string): Issue {
     filesToModify: parseListItems(sections.get('Files to Modify') || ''),
     activity: parseListItems(sections.get('Activity') || ''),
     reviewGate: (['none', 'auto', 'required'].includes(String(fm.review_gate)) ? String(fm.review_gate) : 'auto') as Issue['reviewGate'],
+    outputType: (['code', 'document', 'auto'].includes(String(fm.output_type)) ? String(fm.output_type) : 'auto') as Issue['outputType'],
     outputFile: optionalString(fm.output_file),
     body,
     path: filePath,

package/server/services/plan/review-gate.ts

@@ -11,9 +11,9 @@
 
 import { existsSync, mkdirSync, readdirSync, 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 { ResilientRunner } from '../../cli/headless/resilient-runner.js';
 import { loadAgentPrompt } from './agent-loader.js';
+import { resolveIsCodeTask } from './issue-classification.js';
 import type { Issue, ReviewCheck, ReviewResult } from './types.js';
 
 /** Max review attempts per issue per sprint before giving up */
@@ -46,24 +46,27 @@ export interface ReviewIssueOptions {
  */
 export async function reviewIssue(options: ReviewIssueOptions): Promise<ReviewResult> {
   const { workingDir, issue, pmDir, outputPath, onOutput, logDir, reviewCriteria, boardDir } = options;
-  const isCodeTask = issue.filesToModify.length > 0;
+  const isCodeTask = resolveIsCodeTask(issue);
   const issueType: ReviewResult['issueType'] = isCodeTask ? 'code' : 'non-code';
 
   try {
     const prompt = buildReviewPrompt(issue, pmDir, outputPath, isCodeTask, reviewCriteria, boardDir, workingDir);
 
-    const runner = new HeadlessRunner({
+    const runner = new ResilientRunner({
       workingDir,
-      directPrompt: prompt,
+      prompt,
+      policy: 'STANDARD',
       stallWarningMs: REVIEW_STALL_WARNING_MS,
       stallKillMs: REVIEW_STALL_KILL_MS,
       stallHardCapMs: REVIEW_STALL_HARD_CAP_MS,
       verbose: true,
       outputCallback: onOutput ? (text: string) => onOutput(`Review: ${text}`) : undefined,
       extraEnv: options.extraEnv,
+      logLabel: 'pm-review',
+      logDir,
     });
 
-    const result = await runWithFileLogger('pm-review', () => runner.run(), logDir);
+    const result = await runner.run();
 
     if (result.completed && result.assistantResponse) {
       return parseReviewOutput(issue.id, issueType, result.assistantResponse);

package/server/services/plan/types.ts

@@ -94,6 +94,9 @@ export interface Issue {
   progress: string | null;
   // Review gate mode (none = skip review, auto = AI review, required = human review)
   reviewGate: 'none' | 'auto' | 'required';
+  // What the issue produces — drives prompt construction and review strategy
+  // code = must modify source files, document = produce written artifact, auto = infer from context
+  outputType: 'code' | 'document' | 'auto';
   // Planned output file path (from front matter output_file, relative to working dir)
   outputFile: string | null;
   // Full markdown body

package/server/services/platform-credentials.ts

@@ -24,7 +24,13 @@ export const CLI_VERSION = (() => {
 })()
 
 const MSTRO_DIR = join(homedir(), '.mstro')
-const CREDENTIALS_FILE = join(MSTRO_DIR, 'credentials.json')
+
+function credentialsFile(): string {
+  const env = process.env.MSTRO_ENV || 'production'
+  if (env === 'staging') return join(MSTRO_DIR, 'credentials-staging.json')
+  if (env === 'dev') return join(MSTRO_DIR, 'credentials-dev.json')
+  return join(MSTRO_DIR, 'credentials.json')
+}
 
 /** Refresh token every 30 days */
 export const TOKEN_REFRESH_INTERVAL_MS = 30 * 24 * 60 * 60 * 1000
@@ -42,11 +48,11 @@ export interface StoredCredentials {
  * Get stored credentials from ~/.mstro/credentials.json
  */
 export function getCredentials(): StoredCredentials | null {
-  if (!existsSync(CREDENTIALS_FILE)) {
+  if (!existsSync(credentialsFile())) {
     return null
   }
   try {
-    const content = readFileSync(CREDENTIALS_FILE, 'utf-8')
+    const content = readFileSync(credentialsFile(), 'utf-8')
     const creds = JSON.parse(content)
     if (creds.token && creds.userId && creds.email) {
       return creds
@@ -64,7 +70,7 @@ export function updateCredentials(updates: Partial<StoredCredentials>): void {
   const creds = getCredentials()
   if (!creds) return
 
-  writeFileSync(CREDENTIALS_FILE, JSON.stringify({ ...creds, ...updates }, null, 2), {
+  writeFileSync(credentialsFile(), JSON.stringify({ ...creds, ...updates }, null, 2), {
     mode: 0o600
   })
 }

package/server/services/terminal/pty-manager.ts

@@ -72,7 +72,13 @@ export class PTYManager extends EventEmitter {
       return { shell: existingSession.shell, cwd: existingSession.cwd, isReconnect: true, platform: platform() };
     }
 
-    const shell = requestedShell || detectShell();
+    const ALLOWED_SHELLS = new Set([
+      '/bin/sh', '/bin/bash', '/bin/zsh', '/usr/bin/bash', '/usr/bin/zsh',
+      '/usr/bin/fish', '/usr/local/bin/bash', '/usr/local/bin/zsh', '/usr/local/bin/fish',
+      '/bin/dash', '/usr/bin/dash',
+      'powershell.exe', 'pwsh.exe', 'cmd.exe',
+    ]);
+    const shell = (requestedShell && ALLOWED_SHELLS.has(requestedShell)) ? requestedShell : detectShell();
     const cwd = workingDir || homedir();
 
     try {

package/server/services/websocket/file-search-handlers.ts

@@ -63,6 +63,7 @@ function processRgMatch(
   flushBatch: () => void,
 ): boolean {
   const filePath = relative(workingDir, parsed.data.path.text);
+  if (filePath.startsWith('..')) return false;
   const lineNumber = parsed.data.line_number;
   const lineContent = parsed.data.lines.text.replace(/\n$/, '');
   const column = parsed.data.submatches?.[0]?.start ?? 0;
@@ -91,6 +92,7 @@ function appendRgContext(
   batch: SearchMatch[],
 ): void {
   const filePath = relative(workingDir, parsed.data.path.text);
+  if (filePath.startsWith('..')) return;
   const lineNumber = parsed.data.line_number;
   const lineContent = parsed.data.lines.text.replace(/\n$/, '');
 

package/server/services/websocket/handler-context.ts

@@ -7,6 +7,7 @@ import type { AutocompleteService } from './autocomplete.js';
 import type { FileUploadHandler } from './file-upload-handler.js';
 import type { GitHeadWatcher } from './git-head-watcher.js';
 import type { SessionRegistry } from './session-registry.js';
+import type { SkillsWatcher } from './skill-watcher.js';
 import type { WebSocketResponse, WSContext } from './types.js';
 
 export interface UsageReport {
@@ -35,6 +36,7 @@ export interface HandlerContext {
   usageReporter: UsageReporter | null;
   fileUploadHandler: FileUploadHandler | null;
   gitHeadWatcher: GitHeadWatcher | null;
+  skillsWatcher: SkillsWatcher | null;
 
   // Registry access
   getRegistry(workingDir: string): SessionRegistry;

package/server/services/websocket/handler.ts

@@ -15,7 +15,6 @@ import { dirname, join } from 'node:path';
 import type { ImprovisationSessionManager } from '../../cli/improvisation-session-manager.js';
 import { captureException } from '../sentry.js';
 import { AutocompleteService } from './autocomplete.js';
-import { handleDeployMessage } from './deploy-handlers.js';
 import { handleFileExplorerMessage, handleFileMessage } from './file-explorer-handlers.js';
 import { FileUploadHandler } from './file-upload-handler.js';
 import { handleGitMessage } from './git-handlers.js';
@@ -27,6 +26,7 @@ import { handleHistoryMessage, handleSessionMessage, initializeTab, resumeHistor
 import { SessionRegistry } from './session-registry.js';
 import { generateNotificationSummary, handleGetSettings, handleUpdateSettings } from './settings-handlers.js';
 import { handleListSkills } from './skill-handlers.js';
+import { SkillsWatcher } from './skill-watcher.js';
 import { handleCreateTab, handleGetActiveTabs, handleMarkTabViewed, handleRemoveTab, handleReorderTabs, handleSyncPromptText, handleSyncTabMeta } from './tab-handlers.js';
 import { cleanupTerminalSubscribers, handleTerminalMessage } from './terminal-handlers.js';
 import type { FrecencyData, WebSocketMessage, WebSocketResponse, WSContext } from './types.js';
@@ -48,17 +48,21 @@ export class WebSocketImproviseHandler implements HandlerContext {
   terminalSubscribers: Map<string, Set<WSContext>> = new Map();
   fileUploadHandler: FileUploadHandler | null = null;
   gitHeadWatcher: GitHeadWatcher | null = null;
+  skillsWatcher: SkillsWatcher | null = null;
 
   constructor() {
     this.frecencyPath = join(homedir(), '.mstro', 'autocomplete-frecency.json');
     const frecencyData = this.loadFrecencyData();
     this.autocompleteService = new AutocompleteService(frecencyData);
+    process.on('exit', () => {
+      if (this.frecencySaveTimer) {
+        clearTimeout(this.frecencySaveTimer);
+        this.saveFrecencyData();
+      }
+    });
   }
 
   getRegistry(workingDir: string): SessionRegistry {
-    if (!this.sessionRegistry && workingDir) {
-      this.sessionRegistry = new SessionRegistry(workingDir);
-    }
     if (!this.sessionRegistry) {
       this.sessionRegistry = new SessionRegistry(workingDir);
     }
@@ -113,6 +117,10 @@ export class WebSocketImproviseHandler implements HandlerContext {
       this.gitHeadWatcher = new GitHeadWatcher(workingDir, this);
       this.gitHeadWatcher.start();
     }
+    if (!this.skillsWatcher && workingDir) {
+      this.skillsWatcher = new SkillsWatcher(workingDir, this);
+      this.skillsWatcher.start();
+    }
   }
 
   async handleMessage(
@@ -138,7 +146,7 @@ export class WebSocketImproviseHandler implements HandlerContext {
   }
 
   /** Dispatch table mapping message types to domain handlers. Built once, looked up per message. */
-  private static readonly DISPATCH: Record<string, 'session' | 'history' | 'file' | 'terminal' | 'fileExplorer' | 'git' | 'quality' | 'plan' | 'fileUpload' | 'deploy'> = {
+  private static readonly DISPATCH: Record<string, 'session' | 'history' | 'file' | 'terminal' | 'fileExplorer' | 'git' | 'quality' | 'plan' | 'fileUpload'> = {
     // Session
     execute: 'session', cancel: 'session', getHistory: 'session', new: 'session', approve: 'session', reject: 'session',
     // History
@@ -157,8 +165,6 @@ export class WebSocketImproviseHandler implements HandlerContext {
     planInit: 'plan', planGetState: 'plan', planListIssues: 'plan', planGetIssue: 'plan', planGetSprint: 'plan', planGetMilestone: 'plan', planCreateIssue: 'plan', planUpdateIssue: 'plan', planDeleteIssue: 'plan', planScaffold: 'plan', planPrompt: 'plan', planExecute: 'plan', planExecuteEpic: 'plan', planPause: 'plan', planStop: 'plan', planResume: 'plan', planCreateBoard: 'plan', planUpdateBoard: 'plan', planArchiveBoard: 'plan', planGetBoard: 'plan', planGetBoardState: 'plan', planReorderBoards: 'plan', planSetActiveBoard: 'plan', planGetBoardArtifacts: 'plan', planCreateSprint: 'plan', planActivateSprint: 'plan', planCompleteSprint: 'plan', planGetSprintArtifacts: 'plan', chatToBoard: 'plan',
     // File upload
     fileUploadStart: 'fileUpload', fileUploadChunk: 'fileUpload', fileUploadComplete: 'fileUpload', fileUploadCancel: 'fileUpload',
-    // Deploy management + HTTP relay
-    deployCreate: 'deploy', deployStop: 'deploy', deployResume: 'deploy', deployDelete: 'deploy', deployList: 'deploy', deployGetStatus: 'deploy', deployUpdateConfig: 'deploy', deploySetApiKey: 'deploy', deployValidateApiKey: 'deploy', deployHttpRequest: 'deploy',
   };
 
   private async dispatchMessage(ws: WSContext, msg: WebSocketMessage, tabId: string, workingDir: string, permission?: 'view'): Promise<void> {
@@ -192,6 +198,7 @@ export class WebSocketImproviseHandler implements HandlerContext {
       case 'getSettings':
         return handleGetSettings(this, ws);
       case 'updateSettings':
+        if (permission === 'view') return;
         return handleUpdateSettings(this, ws, msg);
       case 'listSkills':
         return handleListSkills(this, ws, workingDir);
@@ -214,7 +221,6 @@ export class WebSocketImproviseHandler implements HandlerContext {
       case 'quality':    return handleQualityMessage(this, ws, msg, tabId, workingDir, permission);
       case 'plan':       return handlePlanMessage(this, ws, msg, tabId, workingDir, permission);
       case 'fileUpload': return this.handleFileUploadMessage(ws, msg, tabId, workingDir);
-      case 'deploy':     return handleDeployMessage(this, ws, msg, tabId, workingDir, permission);
     }
   }
 
@@ -260,6 +266,10 @@ export class WebSocketImproviseHandler implements HandlerContext {
         this.gitHeadWatcher.stop();
         this.gitHeadWatcher = null;
       }
+      if (this.skillsWatcher) {
+        this.skillsWatcher.stop();
+        this.skillsWatcher = null;
+      }
     }
   }
 

package/server/services/websocket/plan-execution-handlers.ts

@@ -33,7 +33,7 @@ export function handlePrompt(
   });
 }
 
-function wireExecutorEvents(executor: PlanExecutor, ctx: HandlerContext, workingDir: string): void {
+function wireExecutorEvents(executor: PlanExecutor, ctx: HandlerContext, workingDir: string, boardId?: string): void {
   executor.removeAllListeners();
 
   executor.on('statusChanged', (status: string) => {
@@ -48,7 +48,7 @@ function wireExecutorEvents(executor: PlanExecutor, ctx: HandlerContext, working
   });
 
   executor.on('output', (data: { issueId: string; text: string }) => {
-    ctx.broadcastToAll({ type: 'planExecutionOutput', data });
+    ctx.broadcastToAll({ type: 'planExecutionOutput', data: { ...data, boardId: boardId ?? null } });
   });
 
   executor.on('issueCompleted', () => {
@@ -86,7 +86,7 @@ function wireExecutorEvents(executor: PlanExecutor, ctx: HandlerContext, working
   });
 
   executor.on('complete', (reason: string) => {
-    ctx.broadcastToAll({ type: 'planExecutionComplete', data: { reason, metrics: executor.getMetrics() } });
+    ctx.broadcastToAll({ type: 'planExecutionComplete', data: { reason, boardId: boardId ?? null, metrics: executor.getMetrics() } });
   });
 
   executor.on('error', (error: string) => {
@@ -107,11 +107,11 @@ export function handleExecute(
     return;
   }
 
-  wireExecutorEvents(executor, ctx, workingDir);
-
   const boardId = msg.data?.boardId as string | undefined;
+  wireExecutorEvents(executor, ctx, workingDir, boardId);
+
   const executionDir = boardId ? ctx.gitDirectories.get(boardId) : undefined;
-  ctx.send(ws, { type: 'planExecutionStarted', data: { status: 'executing', boardId } });
+  ctx.broadcastToAll({ type: 'planExecutionStarted', data: { status: 'executing', boardId } });
   const startPromise = boardId ? executor.startBoard(boardId, executionDir) : executor.start();
   startPromise.catch(error => {
     ctx.send(ws, {
@@ -142,7 +142,7 @@ export function handleExecuteEpic(
 
   wireExecutorEvents(executor, ctx, workingDir);
 
-  ctx.send(ws, { type: 'planExecutionStarted', data: { status: 'executing', epicPath } });
+  ctx.broadcastToAll({ type: 'planExecutionStarted', data: { status: 'executing', epicPath } });
   executor.startEpic(epicPath).catch(error => {
     ctx.send(ws, {
       type: 'planExecutionError',