@minionry/minion 0.7.36

package/dist/server/services/websocket/plan-execution-handlers.js

@@ -0,0 +1,244 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { handlePlanPrompt, parseModelDirective, parseRunModel } from '../plan/composer.js';
+import { parseBoardDirectory, parsePlanDirectory, resolvePmDir } from '../plan/parser.js';
+import { PM_BOARD_ISSUE_ID, PM_COMPOSER_ISSUE_ID, pmTimelineIssueId } from '../plan/pm-timeline.js';
+import { scopeExecutionDir } from './handler-context.js';
+import { denyIfViewOnly, executorCache, getExecutor } from './plan-helpers.js';
+import { broadcastPmEvent, pmTimelineKey } from './pm-timeline-broadcast.js';
+import { mergePreUploadedAttachments } from './session-handlers.js';
+export function handlePrompt(ctx, ws, msg, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const prompt = msg.data?.prompt;
+    const boardId = msg.data?.boardId;
+    if (!prompt) {
+        ctx.send(ws, { type: 'planError', data: { error: 'Prompt required' } });
+        return;
+    }
+    const executionDir = boardId ? scopeExecutionDir(ctx, boardId) : undefined;
+    const attachments = boardId ? mergePreUploadedAttachments(ctx, boardId, undefined) : undefined;
+    const modelDirective = parseModelDirective(msg.data);
+    const runModel = parseRunModel(msg.data);
+    const agentTabId = msg.data?.agentTabId;
+    handlePlanPrompt(ctx, ws, prompt, workingDir, {
+        boardId,
+        executionDir,
+        attachments,
+        modelDirective,
+        agentTabId,
+        runModel,
+    }).catch(error => {
+        ctx.send(ws, {
+            type: 'planError',
+            data: { error: error instanceof Error ? error.message : String(error) },
+        });
+    });
+}
+export function wireExecutorEvents(executor, ctx, workingDir, boardId, agentTabId, executionDir) {
+    executor.removeAllListeners();
+    const settleDir = executionDir || workingDir;
+    const tag = { boardId: boardId ?? null, ...(agentTabId ? { agentTabId } : {}) };
+    const timelineKey = (issueId) => pmTimelineKey(boardId ?? null, pmTimelineIssueId(issueId));
+    executor.on('statusChanged', (status) => {
+        ctx.broadcastToAll({ type: 'planExecutionProgress', data: { status, ...tag } });
+    });
+    executor.on('issueStarted', (issue) => {
+        ctx.broadcastToAll({
+            type: 'planExecutionProgress',
+            data: { issueId: issue.id, status: 'executing', title: issue.title, ...tag },
+        });
+    });
+    executor.on('output', (data) => {
+        broadcastPmEvent(ctx, timelineKey(data.issueId), 'planExecutionOutput', { ...data, ...tag });
+    });
+    executor.on('issuePrompt', (data) => {
+        broadcastPmEvent(ctx, timelineKey(data.issueId), 'planExecutionPrompt', { ...data, ...tag });
+    });
+    executor.on('toolUse', (data) => {
+        broadcastPmEvent(ctx, timelineKey(data.issueId), 'planExecutionToolUse', { ...data, ...tag });
+    });
+    executor.on('tokenUsage', (data) => {
+        console.log(`[minionry/tokens] issue=${data.issueId} final=${data.usage.isFinal === true} cumIn=${data.usage.inputTokens} cumOut=${data.usage.outputTokens} cumCacheRead=${data.usage.cacheReadTokens} cumCacheWrite=${data.usage.cacheCreationTokens} curTurnIn=${data.usage.currentTurnInputTokens}`);
+        broadcastPmEvent(ctx, timelineKey(data.issueId), 'planExecutionTokens', {
+            boardId: boardId ?? null,
+            issueId: data.issueId,
+            inputTokens: data.usage.inputTokens,
+            outputTokens: data.usage.outputTokens,
+            cacheCreationTokens: data.usage.cacheCreationTokens,
+            cacheReadTokens: data.usage.cacheReadTokens,
+            currentTurnInputTokens: data.usage.currentTurnInputTokens,
+            isFinal: data.usage.isFinal === true,
+        });
+    });
+    executor.on('issueCompleted', (issue) => {
+        if (issue?.id) {
+            broadcastPmEvent(ctx, timelineKey(issue.id), 'planExecutionProgress', {
+                issueId: issue.id, status: 'done', ...tag,
+            });
+        }
+        ctx.broadcastToAll({ type: 'planExecutionMetrics', data: executor.getMetrics() });
+        const fullState = parsePlanDirectory(workingDir);
+        if (fullState) {
+            ctx.broadcastToAll({ type: 'planStateUpdated', data: fullState });
+        }
+    });
+    executor.on('issueError', (data) => {
+        broadcastPmEvent(ctx, timelineKey(data.issueId), 'planExecutionError', { ...data, ...tag });
+    });
+    executor.on('issueTranscript', (data) => {
+        try {
+            const registry = ctx.getRegistry(workingDir);
+            if (!registry.getTab(data.tabId))
+                return;
+            registry.updateTabSession(data.tabId, data.sessionId);
+            registry.markTabPersisted(data.tabId);
+        }
+        catch (err) {
+            console.error(`[plan-execution] Failed to bind tab ${data.tabId} to transcript ${data.sessionId}:`, err);
+        }
+    });
+    executor.on('waveStarted', (data) => {
+        ctx.broadcastToAll({
+            type: 'planExecutionProgress',
+            data: { status: 'wave', issueIds: data.issueIds, ...tag },
+        });
+    });
+    executor.on('waveError', (data) => {
+        ctx.broadcastToAll({ type: 'planExecutionError', data: { ...data, ...tag } });
+    });
+    executor.on('stateUpdated', () => {
+        const fullState = parsePlanDirectory(workingDir);
+        if (fullState) {
+            ctx.broadcastToAll({ type: 'planStateUpdated', data: fullState });
+        }
+    });
+    executor.on('reviewProgress', (data) => {
+        broadcastPmEvent(ctx, timelineKey(data.issueId), 'planReviewProgress', { ...data, ...tag });
+    });
+    executor.on('complete', (reason) => {
+        ctx.broadcastToAll({ type: 'planExecutionComplete', data: { reason, ...tag, metrics: executor.getMetrics() } });
+        ctx.commitSuggestions?.notifyExecutionSettled(settleDir);
+    });
+    executor.on('error', (error) => {
+        ctx.broadcastToAll({ type: 'planExecutionError', data: { error, ...tag } });
+        ctx.commitSuggestions?.notifyExecutionSettled(settleDir);
+    });
+}
+function broadcastBoardRunPrompt(ctx, boardId, prompt) {
+    broadcastPmEvent(ctx, pmTimelineKey(boardId, PM_BOARD_ISSUE_ID), 'planExecutionPrompt', {
+        issueId: PM_BOARD_ISSUE_ID,
+        prompt,
+        boardId,
+    });
+}
+export function maybeStartAutoImplement(ctx, workingDir, boardId) {
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        return;
+    const boardState = parseBoardDirectory(pmDir, boardId);
+    if (!boardState?.board.autoImplement)
+        return;
+    const executor = getExecutor(workingDir);
+    if (executor.getStatus() === 'executing' || executor.getStatus() === 'starting')
+        return;
+    const executionDir = scopeExecutionDir(ctx, boardId);
+    wireExecutorEvents(executor, ctx, workingDir, boardId, undefined, executionDir);
+    broadcastBoardRunPrompt(ctx, boardId, `Auto-implement board ${boardId}`);
+    ctx.broadcastToAll({ type: 'planExecutionStarted', data: { status: 'executing', boardId } });
+    executor.startBoard(boardId, executionDir).catch(error => {
+        ctx.broadcastToAll({
+            type: 'planExecutionError',
+            data: { error: error instanceof Error ? error.message : String(error), boardId },
+        });
+    });
+}
+export function handleExecute(ctx, ws, msg, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const executor = getExecutor(workingDir);
+    if (executor.getStatus() === 'executing' || executor.getStatus() === 'starting') {
+        ctx.send(ws, { type: 'planError', data: { error: 'Execution already in progress' } });
+        return;
+    }
+    const boardId = msg.data?.boardId;
+    const agentTabId = msg.data?.agentTabId;
+    const executionDir = boardId ? scopeExecutionDir(ctx, boardId) : undefined;
+    wireExecutorEvents(executor, ctx, workingDir, boardId, agentTabId, executionDir);
+    if (boardId)
+        broadcastBoardRunPrompt(ctx, boardId, `Implement board ${boardId}`);
+    ctx.broadcastToAll({ type: 'planExecutionStarted', data: { status: 'executing', boardId, ...(agentTabId ? { agentTabId } : {}) } });
+    const startPromise = boardId ? executor.startBoard(boardId, executionDir) : executor.start();
+    startPromise.catch(error => {
+        ctx.send(ws, {
+            type: 'planExecutionError',
+            data: { error: error instanceof Error ? error.message : String(error) },
+        });
+    });
+}
+export function handleExecuteEpic(ctx, ws, msg, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const epicPath = msg.data?.epicPath;
+    if (!epicPath) {
+        ctx.send(ws, { type: 'planError', data: { error: 'Epic path required' } });
+        return;
+    }
+    const executor = getExecutor(workingDir);
+    if (executor.getStatus() === 'executing' || executor.getStatus() === 'starting') {
+        ctx.send(ws, { type: 'planError', data: { error: 'Execution already in progress' } });
+        return;
+    }
+    wireExecutorEvents(executor, ctx, workingDir);
+    ctx.broadcastToAll({ type: 'planExecutionStarted', data: { status: 'executing', epicPath } });
+    executor.startEpic(epicPath).catch(error => {
+        ctx.send(ws, {
+            type: 'planExecutionError',
+            data: { error: error instanceof Error ? error.message : String(error) },
+        });
+    });
+}
+export function handlePause(ctx, ws, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const executor = executorCache.get(workingDir);
+    if (executor)
+        executor.pause();
+}
+export function handleStop(ctx, ws, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const executor = executorCache.get(workingDir);
+    if (executor) {
+        executor.stop();
+        return;
+    }
+    ctx.send(ws, {
+        type: 'planExecutionComplete',
+        data: { reason: 'Stopped (no active run on this machine).', metrics: { issuesCompleted: 0, issuesAttempted: 0, totalDuration: 0 } },
+    });
+}
+export function handleResume(ctx, ws, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const executor = executorCache.get(workingDir);
+    if (executor) {
+        executor.resume().catch(error => {
+            ctx.send(ws, {
+                type: 'planExecutionError',
+                data: { error: error instanceof Error ? error.message : String(error) },
+            });
+        });
+    }
+}
+export function handleGetPmTimeline(ctx, ws, msg) {
+    const boardId = msg.data?.boardId ?? null;
+    const issueId = msg.data?.issueId || PM_COMPOSER_ISSUE_ID;
+    const key = pmTimelineKey(boardId, pmTimelineIssueId(issueId));
+    const seq = ctx.pmEventBuffers.getOrCreate(key).currentSeq();
+    ctx.send(ws, {
+        type: 'pmTimelineSnapshot',
+        pmKey: key,
+        data: ctx.pmTimelines.getOrCreate(key).snapshot(seq),
+    });
+}

package/dist/server/services/websocket/plan-handlers.js

@@ -0,0 +1,67 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { can } from '@minionry/roles';
+import { dispatchByType } from './dispatch-util.js';
+import { handleArchiveBoard, handleChatToBoard, handleCreateBoard, handleGetBoard, handleGetBoardArtifacts, handleGetBoardState, handleExportBoard as handlePublishExportBoard, handleReorderBoards, handleRestoreBoard, handleSetActiveBoard, handleUpdateBoard } from './plan-board-handlers.js';
+import { handleExecute, handleExecuteEpic, handleGetPmTimeline, handlePause, handlePrompt, handleResume, handleStop } from './plan-execution-handlers.js';
+import { handleDeleteIssue, handleGetIssue, handleGetMilestone, handleGetSprint, handleListIssues, handlePlanInit, handleScaffold, handleUpdateIssue } from './plan-issue-handlers.js';
+import { handleActivateSprint, handleCompleteSprint, handleCreateSprint, handleGetSprintArtifacts } from './plan-sprint-handlers.js';
+import { handleDownloadBoard, handleImportBoard, handleInstantiateTemplate, handleExportBoard as handleTransferExportBoard } from './plan-transfer-handlers.js';
+import { handleQueueClearComposerPrompts, handleQueueEnqueueComposerPrompt, handleQueueRemoveComposerPrompt } from './prompt-queue-handlers.js';
+export { cleanupPlanResources } from './plan-helpers.js';
+export function buildPlanHandlers(ctx, ws, msg, workingDir, editPlanGate) {
+    return {
+        planInit: () => handlePlanInit(ctx, ws, workingDir),
+        planGetState: () => handlePlanInit(ctx, ws, workingDir),
+        planListIssues: () => handleListIssues(ctx, ws, workingDir),
+        planGetIssue: () => handleGetIssue(ctx, ws, msg, workingDir),
+        planGetSprint: () => handleGetSprint(ctx, ws, msg, workingDir),
+        planGetMilestone: () => handleGetMilestone(ctx, ws, msg, workingDir),
+        planUpdateIssue: () => handleUpdateIssue(ctx, ws, msg, workingDir, editPlanGate),
+        planDeleteIssue: () => handleDeleteIssue(ctx, ws, msg, workingDir, editPlanGate),
+        planScaffold: () => handleScaffold(ctx, ws, msg, workingDir, editPlanGate),
+        planPrompt: () => handlePrompt(ctx, ws, msg, workingDir, editPlanGate),
+        planExecute: () => handleExecute(ctx, ws, msg, workingDir, editPlanGate),
+        planExecuteEpic: () => handleExecuteEpic(ctx, ws, msg, workingDir, editPlanGate),
+        planPause: () => handlePause(ctx, ws, workingDir, editPlanGate),
+        planStop: () => handleStop(ctx, ws, workingDir, editPlanGate),
+        planResume: () => handleResume(ctx, ws, workingDir, editPlanGate),
+        getPmTimeline: () => handleGetPmTimeline(ctx, ws, msg),
+        planCreateBoard: () => handleCreateBoard(ctx, ws, msg, workingDir, editPlanGate),
+        planUpdateBoard: () => handleUpdateBoard(ctx, ws, msg, workingDir, editPlanGate),
+        planArchiveBoard: () => handleArchiveBoard(ctx, ws, msg, workingDir, editPlanGate),
+        planRestoreBoard: () => handleRestoreBoard(ctx, ws, msg, workingDir, editPlanGate),
+        planGetBoard: () => handleGetBoard(ctx, ws, msg, workingDir),
+        planGetBoardState: () => handleGetBoardState(ctx, ws, msg, workingDir),
+        planReorderBoards: () => handleReorderBoards(ctx, ws, msg, workingDir, editPlanGate),
+        planSetActiveBoard: () => handleSetActiveBoard(ctx, ws, msg, workingDir, editPlanGate),
+        planGetBoardArtifacts: () => handleGetBoardArtifacts(ctx, ws, msg, workingDir),
+        planExportBoard: () => msg.data?.requestId
+            ? handleTransferExportBoard(ctx, ws, msg, workingDir, editPlanGate)
+            : handlePublishExportBoard(ctx, ws, msg, workingDir, editPlanGate),
+        planImportBoard: () => handleImportBoard(ctx, ws, msg, workingDir, editPlanGate),
+        planDownloadBoard: () => handleDownloadBoard(ctx, ws, msg, workingDir),
+        planInstantiateTemplate: () => handleInstantiateTemplate(ctx, ws, msg, workingDir, editPlanGate),
+        chatToBoard: () => handleChatToBoard(ctx, ws, msg, workingDir, editPlanGate),
+        planCreateSprint: () => handleCreateSprint(ctx, ws, msg, workingDir, editPlanGate),
+        planActivateSprint: () => handleActivateSprint(ctx, ws, msg, workingDir, editPlanGate),
+        planCompleteSprint: () => handleCompleteSprint(ctx, ws, msg, workingDir, editPlanGate),
+        planGetSprintArtifacts: () => handleGetSprintArtifacts(ctx, ws, msg, workingDir),
+        queueEnqueueComposerPrompt: () => handleQueueEnqueueComposerPrompt(ctx, ws, msg, workingDir, editPlanGate),
+        queueRemoveComposerPrompt: () => handleQueueRemoveComposerPrompt(ctx, ws, msg, workingDir, editPlanGate),
+        queueClearComposerPrompts: () => handleQueueClearComposerPrompts(ctx, ws, msg, workingDir, editPlanGate),
+    };
+}
+export function handlePlanMessage(ctx, ws, msg, _tabId, workingDir, role) {
+    const editPlanGate = can(role, 'editPlan') ? undefined : 'view';
+    const handlers = buildPlanHandlers(ctx, ws, msg, workingDir, editPlanGate);
+    try {
+        dispatchByType(handlers, 'plan', msg.type, (type) => {
+            ctx.send(ws, { type: 'planError', data: { error: `Unknown plan message type: ${type}` } });
+        });
+    }
+    catch (error) {
+        const errMsg = error instanceof Error ? error.message : String(error);
+        ctx.send(ws, { type: 'planError', data: { error: errMsg } });
+    }
+}

package/dist/server/services/websocket/plan-helpers.js

@@ -0,0 +1,161 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { PlanExecutor } from '../plan/executor.js';
+import { defaultPmDir, resolvePmDir } from '../plan/parser.js';
+import { PlanWatcher } from '../plan/watcher.js';
+export const watcherCache = new Map();
+export const executorCache = new Map();
+export const schedulerCache = new Map();
+export function resolvePlanPath(workingDir, relativePath) {
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        return null;
+    const resolved = resolve(pmDir, relativePath);
+    if (!resolved.startsWith(`${pmDir}/`) && resolved !== pmDir)
+        return null;
+    return resolved;
+}
+export function denyIfViewOnly(ctx, ws, permission) {
+    if (permission === 'view') {
+        ctx.send(ws, { type: 'planError', data: { error: 'Permission denied' } });
+        return true;
+    }
+    return false;
+}
+export function formatYamlValue(value) {
+    if (value === null || value === undefined)
+        return 'null';
+    if (typeof value === 'boolean')
+        return String(value);
+    if (typeof value === 'number')
+        return String(value);
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return '[]';
+        return `[${value.map(v => typeof v === 'string' ? v : String(v)).join(', ')}]`;
+    }
+    return `"${String(value).replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`;
+}
+function buildProjectMarkdown(name) {
+    const today = new Date().toISOString().split('T')[0];
+    const projectId = name.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+    return `---
+name: "${name}"
+id: ${projectId}
+created: "${today}"
+status: active
+estimation: fibonacci
+id_prefixes:
+  epic: EP
+  issue: IS
+  bug: BG
+labels: []
+---
+
+# ${name}
+
+## Goals
+
+## Teams
+
+## Labels
+
+## Workflows
+| Status | Category | Description |
+|---|---|---|
+| todo | ready | Refined and queued for an agent |
+| in_progress | started | An agent is working it now |
+| in_review | started | Agent finished; awaiting the AI review gate |
+| done | completed | Passed review |
+| cancelled | cancelled | Will not be done |
+`;
+}
+function buildStateMarkdown(name) {
+    return `---
+project: "${name}"
+current_sprint: null
+active_milestone: null
+paused: false
+last_session: null
+---
+
+# Project State
+
+## Current Focus
+
+## Ready to Work
+
+## In Progress
+
+## Blocked
+
+## Recently Completed
+
+## Warnings
+`;
+}
+export function getWatcher(workingDir, ctx) {
+    let watcher = watcherCache.get(workingDir);
+    if (!watcher) {
+        watcher = new PlanWatcher(workingDir, ctx);
+        watcherCache.set(workingDir, watcher);
+    }
+    return watcher;
+}
+export function getExecutor(workingDir) {
+    let executor = executorCache.get(workingDir);
+    if (!executor) {
+        executor = new PlanExecutor(workingDir);
+        executorCache.set(workingDir, executor);
+    }
+    return executor;
+}
+export function cleanupPlanResources(workingDir) {
+    const watcher = watcherCache.get(workingDir);
+    if (watcher) {
+        watcher.stop();
+        watcherCache.delete(workingDir);
+    }
+    const executor = executorCache.get(workingDir);
+    if (executor) {
+        executor.stop();
+        executorCache.delete(workingDir);
+    }
+    const scheduler = schedulerCache.get(workingDir);
+    if (scheduler) {
+        scheduler.stop();
+        schedulerCache.delete(workingDir);
+    }
+}
+export function scaffoldPmDirectory(workingDir, name) {
+    const planDir = defaultPmDir(workingDir);
+    const boardId = 'BOARD-001';
+    const boardDir = join(planDir, 'boards', boardId);
+    mkdirSync(join(planDir, 'templates'), { recursive: true });
+    for (const dir of ['backlog', 'out', 'reviews', 'logs']) {
+        mkdirSync(join(boardDir, dir), { recursive: true });
+    }
+    writeFileSync(join(planDir, 'project.md'), buildProjectMarkdown(name), 'utf-8');
+    const workspace = { activeBoardId: boardId, boardOrder: [boardId] };
+    writeFileSync(join(planDir, 'workspace.json'), JSON.stringify(workspace, null, 2), 'utf-8');
+    const today = new Date().toISOString().split('T')[0];
+    writeFileSync(join(boardDir, 'board.md'), `---
+id: ${boardId}
+title: "Board 1"
+status: draft
+created: "${today}"
+completed_at: null
+goal: ""
+---
+
+# Board 1
+
+## Goal
+
+## Notes
+`, 'utf-8');
+    writeFileSync(join(boardDir, 'STATE.md'), buildStateMarkdown(name), 'utf-8');
+    writeFileSync(join(boardDir, 'progress.md'), '# Board Progress\n', 'utf-8');
+}

package/dist/server/services/websocket/plan-issue-handlers.js

@@ -0,0 +1,168 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { basename } from 'node:path';
+import { getPlanningStatus } from '../plan/composer.js';
+import { checkAllAcceptanceCriteria, replaceFrontMatterField } from '../plan/front-matter.js';
+import { parsePlanDirectory, parseSingleIssue, parseSingleMilestone, parseSingleSprint, planDirExists } from '../plan/parser.js';
+import { tryCompleteParentEpic } from '../plan/state-reconciler.js';
+import { hasScopeBinding, setScopeRepo, setScopeWorktree } from './handler-context.js';
+import { denyIfViewOnly, executorCache, formatYamlValue, getWatcher, resolvePlanPath, scaffoldPmDirectory } from './plan-helpers.js';
+function restoreBoardScopes(ctx, boardWorktrees) {
+    for (const [boardId, entry] of Object.entries(boardWorktrees)) {
+        if (hasScopeBinding(ctx, boardId))
+            continue;
+        if (entry.path && entry.branch) {
+            setScopeWorktree(ctx, boardId, entry.path);
+            ctx.gitBranches.set(boardId, entry.branch);
+        }
+        if (entry.repoPath)
+            setScopeRepo(ctx, boardId, entry.repoPath);
+    }
+}
+export function handlePlanInit(ctx, ws, workingDir) {
+    if (!planDirExists(workingDir)) {
+        const projectName = basename(workingDir) || 'My Project';
+        scaffoldPmDirectory(workingDir, projectName);
+    }
+    const fullState = parsePlanDirectory(workingDir);
+    if (!fullState) {
+        ctx.send(ws, { type: 'planNotFound', data: {} });
+        return;
+    }
+    if (fullState.workspace?.boardWorktrees)
+        restoreBoardScopes(ctx, fullState.workspace.boardWorktrees);
+    const planning = getPlanningStatus(workingDir);
+    const executionSnapshot = executorCache.get(workingDir)?.getExecutionSnapshot()
+        ?? { status: 'idle', boardId: null };
+    ctx.send(ws, {
+        type: 'planState',
+        data: {
+            ...fullState,
+            activePlanningBoardIds: planning.activeBoardIds,
+            lastPlanningResponseByBoard: planning.lastResponseByBoard,
+            composerPromptQueues: ctx.getRegistry(workingDir).getAllBoardQueues(),
+            executionSnapshot,
+        },
+    });
+    const watcher = getWatcher(workingDir, ctx);
+    watcher.start();
+}
+export function handleListIssues(ctx, ws, workingDir) {
+    const fullState = parsePlanDirectory(workingDir);
+    if (!fullState) {
+        ctx.send(ws, { type: 'planNotFound', data: {} });
+        return;
+    }
+    ctx.send(ws, { type: 'planIssueList', data: { issues: fullState.issues } });
+}
+export function handleGetIssue(ctx, ws, msg, workingDir) {
+    const path = msg.data?.path;
+    if (!path || !resolvePlanPath(workingDir, path)) {
+        ctx.send(ws, { type: 'planError', data: { error: 'Invalid issue path' } });
+        return;
+    }
+    const issue = parseSingleIssue(workingDir, path);
+    if (!issue) {
+        ctx.send(ws, { type: 'planError', data: { error: `Issue not found: ${path}` } });
+        return;
+    }
+    ctx.send(ws, { type: 'planIssue', data: issue });
+}
+export function handleGetSprint(ctx, ws, msg, workingDir) {
+    const path = msg.data?.path;
+    if (!path || !resolvePlanPath(workingDir, path)) {
+        ctx.send(ws, { type: 'planError', data: { error: 'Invalid sprint path' } });
+        return;
+    }
+    const sprint = parseSingleSprint(workingDir, path);
+    if (!sprint) {
+        ctx.send(ws, { type: 'planError', data: { error: `Sprint not found: ${path}` } });
+        return;
+    }
+    ctx.send(ws, { type: 'planSprint', data: sprint });
+}
+export function handleGetMilestone(ctx, ws, msg, workingDir) {
+    const path = msg.data?.path;
+    if (!path || !resolvePlanPath(workingDir, path)) {
+        ctx.send(ws, { type: 'planError', data: { error: 'Invalid milestone path' } });
+        return;
+    }
+    const milestone = parseSingleMilestone(workingDir, path);
+    if (!milestone) {
+        ctx.send(ws, { type: 'planError', data: { error: `Milestone not found: ${path}` } });
+        return;
+    }
+    ctx.send(ws, { type: 'planMilestone', data: milestone });
+}
+export function handleUpdateIssue(ctx, ws, msg, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const { path, fields } = msg.data || {};
+    if (!path || !fields) {
+        ctx.send(ws, { type: 'planError', data: { error: 'Path and fields required' } });
+        return;
+    }
+    const fullPath = resolvePlanPath(workingDir, path);
+    if (!fullPath || !existsSync(fullPath)) {
+        ctx.send(ws, { type: 'planError', data: { error: `File not found: ${path}` } });
+        return;
+    }
+    if (!applyIssueFieldUpdates(fullPath, fields)) {
+        ctx.send(ws, { type: 'planError', data: { error: 'Invalid file format' } });
+        return;
+    }
+    const issue = parseSingleIssue(workingDir, path);
+    ctx.broadcastToAll({ type: 'planIssueUpdated', data: issue });
+    if (issue) {
+        const epicPath = tryCompleteParentEpic(workingDir, issue);
+        if (epicPath) {
+            const epic = parseSingleIssue(workingDir, epicPath);
+            if (epic)
+                ctx.broadcastToAll({ type: 'planIssueUpdated', data: epic });
+        }
+    }
+}
+export function handleDeleteIssue(ctx, ws, msg, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const path = msg.data?.path;
+    if (!path) {
+        ctx.send(ws, { type: 'planError', data: { error: 'Path required' } });
+        return;
+    }
+    const fullPath = resolvePlanPath(workingDir, path);
+    if (!fullPath || !deleteIssueFile(fullPath)) {
+        ctx.send(ws, { type: 'planError', data: { error: `File not found: ${path}` } });
+        return;
+    }
+    ctx.broadcastToAll({ type: 'planIssueDeleted', data: { path } });
+}
+export function applyIssueFieldUpdates(fullPath, fields) {
+    let content = readFileSync(fullPath, 'utf-8');
+    if (!content.match(/^---\n/))
+        return false;
+    for (const [key, value] of Object.entries(fields)) {
+        const yamlKey = key.replace(/([A-Z])/g, '_$1').toLowerCase();
+        content = replaceFrontMatterField(content, yamlKey, formatYamlValue(value));
+    }
+    if (fields.status === 'done') {
+        content = checkAllAcceptanceCriteria(content);
+    }
+    writeFileSync(fullPath, content, 'utf-8');
+    return true;
+}
+export function deleteIssueFile(fullPath) {
+    if (!existsSync(fullPath))
+        return false;
+    unlinkSync(fullPath);
+    return true;
+}
+export function handleScaffold(ctx, ws, msg, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const name = msg.data?.name || 'My Project';
+    scaffoldPmDirectory(workingDir, name);
+    const fullState = parsePlanDirectory(workingDir);
+    ctx.broadcastToAll({ type: 'planScaffolded', data: fullState });
+}