@minionry/minion 0.7.36 → 0.7.39

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

@@ -8,6 +8,23 @@ import { PlanWatcher } from '../plan/watcher.js';
 export const watcherCache = new Map();
 export const executorCache = new Map();
 export const schedulerCache = new Map();
+export const chainEngineCache = new Map();
+export function notifyChainRunEnded(workingDir, boardId, signal) {
+    try {
+        chainEngineCache.get(workingDir)?.notifyRunEnded(boardId, signal);
+    }
+    catch (error) {
+        console.error('[chain] notifyRunEnded failed:', error);
+    }
+}
+export function notifyChainExecutorStatus(workingDir, status) {
+    try {
+        chainEngineCache.get(workingDir)?.notifyExecutorStatus(status);
+    }
+    catch (error) {
+        console.error('[chain] notifyExecutorStatus failed:', error);
+    }
+}
 export function resolvePlanPath(workingDir, relativePath) {
     const pmDir = resolvePmDir(workingDir);
     if (!pmDir)
@@ -68,6 +85,7 @@ labels: []
 | 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 |
+| awaiting_approval | started | Passed AI review; waiting for a person to approve |
 | done | completed | Passed review |
 | cancelled | cancelled | Will not be done |
 `;
@@ -128,6 +146,11 @@ export function cleanupPlanResources(workingDir) {
         scheduler.stop();
         schedulerCache.delete(workingDir);
     }
+    const chainEngine = chainEngineCache.get(workingDir);
+    if (chainEngine) {
+        chainEngine.stop();
+        chainEngineCache.delete(workingDir);
+    }
 }
 export function scaffoldPmDirectory(workingDir, name) {
     const planDir = defaultPmDir(workingDir);

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

@@ -1,13 +1,16 @@
 // 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 { basename, relative, sep } from 'node:path';
+import { resolveBoardDir, tryCompleteBoardIfDone } from '../plan/board-config.js';
 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 { NO_SPECS_DIR_ERROR, parseBoardDirectory, parsePlanDirectory, parseSingleIssue, parseSingleMilestone, parseSingleSprint, planDirExists, resolvePmDir } from '../plan/parser.js';
+import { latestReviewVerdict, writeReviewApproval } from '../plan/review-approval.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';
+import { maybeContinueAfterApproval } from './plan-execution-handlers.js';
+import { denyIfViewOnly, executorCache, formatYamlValue, getWatcher, notifyChainRunEnded, resolvePlanPath, scaffoldPmDirectory } from './plan-helpers.js';
 function restoreBoardScopes(ctx, boardWorktrees) {
     for (const [boardId, entry] of Object.entries(boardWorktrees)) {
         if (hasScopeBinding(ctx, boardId))
@@ -95,7 +98,35 @@ export function handleGetMilestone(ctx, ws, msg, workingDir) {
     }
     ctx.send(ws, { type: 'planMilestone', data: milestone });
 }
-export function handleUpdateIssue(ctx, ws, msg, workingDir, permission) {
+function recordStatusOverrideIfParked(workingDir, path, patchedStatus, decidedBy) {
+    const current = typeof patchedStatus === 'string' ? parseSingleIssue(workingDir, path) : null;
+    if (!current || current.reviewGate !== 'required' || current.status !== 'awaiting_approval')
+        return null;
+    const pmDir = resolvePmDir(workingDir);
+    const boardId = current.path.match(/^boards\/([^/]+)\//)?.[1];
+    const boardDir = pmDir && boardId ? resolveBoardDir(pmDir, boardId) : null;
+    if (!boardDir)
+        return `Could not resolve the board for ${current.id} — nothing was changed`;
+    const decidedAt = new Date();
+    const record = {
+        issueId: current.id,
+        decision: patchedStatus === 'done' ? 'approve' : 'reject',
+        comment: null,
+        decidedAt: decidedAt.toISOString(),
+        decidedBy,
+        via: 'status_override',
+        verdictFile: latestReviewVerdict(boardDir, current.id)?.fileName ?? null,
+    };
+    try {
+        writeReviewApproval(boardDir, record, decidedAt.getTime());
+        return null;
+    }
+    catch (error) {
+        return `Could not record the decision for ${current.id}: ${errorText(error)} — nothing was changed`;
+    }
+}
+export function handleUpdateIssue(ctx, ws, msg, workingDir, permission, 
+decidedBy = { role: 'owner' }) {
     if (denyIfViewOnly(ctx, ws, permission))
         return;
     const { path, fields } = msg.data || {};
@@ -108,6 +139,11 @@ export function handleUpdateIssue(ctx, ws, msg, workingDir, permission) {
         ctx.send(ws, { type: 'planError', data: { error: `File not found: ${path}` } });
         return;
     }
+    const statusOverrideError = recordStatusOverrideIfParked(workingDir, path, fields.status, decidedBy);
+    if (statusOverrideError) {
+        ctx.send(ws, { type: 'planError', data: { error: statusOverrideError } });
+        return;
+    }
     if (!applyIssueFieldUpdates(fullPath, fields)) {
         ctx.send(ws, { type: 'planError', data: { error: 'Invalid file format' } });
         return;
@@ -166,3 +202,124 @@ export function handleScaffold(ctx, ws, msg, workingDir, permission) {
     const fullState = parsePlanDirectory(workingDir);
     ctx.broadcastToAll({ type: 'planScaffolded', data: fullState });
 }
+export function handleReviewDecision(ctx, ws, msg, workingDir, permission, 
+decidedBy = { role: 'owner' }) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const request = parseReviewDecisionRequest(msg.data);
+    if (typeof request === 'string') {
+        ctx.send(ws, { type: 'planError', data: { error: request } });
+        return;
+    }
+    const target = resolveReviewDecisionTarget(workingDir, request);
+    if (typeof target === 'string') {
+        ctx.send(ws, { type: 'planError', data: { error: target } });
+        return;
+    }
+    const decidedAt = new Date();
+    const record = {
+        issueId: target.issue.id,
+        decision: request.decision,
+        comment: request.comment,
+        decidedAt: decidedAt.toISOString(),
+        decidedBy,
+        via: 'review_decision',
+        verdictFile: latestReviewVerdict(target.boardDir, target.issue.id)?.fileName ?? null,
+    };
+    try {
+        writeReviewApproval(target.boardDir, record, decidedAt.getTime());
+    }
+    catch (error) {
+        ctx.send(ws, {
+            type: 'planError',
+            data: { error: `Could not record the decision for ${target.issue.id}: ${errorText(error)} — nothing was changed` },
+        });
+        return;
+    }
+    if (!applyIssueFieldUpdates(target.fullPath, { status: request.decision === 'approve' ? 'done' : 'todo' })) {
+        ctx.send(ws, { type: 'planError', data: { error: `Invalid file format: ${target.relPath}` } });
+        return;
+    }
+    if (request.decision === 'reject' && request.comment) {
+        appendChangesRequested(target.fullPath, request.comment, decidedAt);
+    }
+    void settleReviewDecision(ctx, workingDir, request, target).catch((error) => {
+        ctx.send(ws, {
+            type: 'planError',
+            data: { error: `${target.issue.id} was ${request.decision === 'approve' ? 'approved' : 'sent back'} but the board could not be reconciled: ${errorText(error)}` },
+        });
+    });
+}
+function parseReviewDecisionRequest(data) {
+    const { boardId, path, decision, comment } = (data ?? {});
+    if (typeof boardId !== 'string' || boardId.length === 0)
+        return 'Board id required';
+    if (typeof path !== 'string' || path.length === 0)
+        return 'Issue path required';
+    if (decision !== 'approve' && decision !== 'reject')
+        return "Decision must be 'approve' or 'reject'";
+    const note = typeof comment === 'string' ? comment.trim() : '';
+    if (decision === 'reject' && note.length === 0)
+        return 'A comment is required when requesting changes';
+    return { boardId, path, decision, comment: note.length > 0 ? note : null };
+}
+function resolveReviewDecisionTarget(workingDir, request) {
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        return NO_SPECS_DIR_ERROR;
+    const boardDir = resolveBoardDir(pmDir, request.boardId);
+    if (!boardDir)
+        return `Board not found: ${request.boardId}`;
+    const fullPath = resolvePlanPath(workingDir, request.path);
+    if (!fullPath || !isInsideDir(fullPath, boardDir)) {
+        return `Issue ${request.path} is not on board ${request.boardId}`;
+    }
+    const relPath = relative(pmDir, fullPath);
+    const issue = existsSync(fullPath) ? parseSingleIssue(workingDir, relPath) : null;
+    if (!issue)
+        return `Issue not found: ${relPath}`;
+    if (issue.reviewGate !== 'required') {
+        return `${issue.id} has no approval gate — its review_gate is '${issue.reviewGate}'`;
+    }
+    if (issue.status !== 'awaiting_approval') {
+        return `${issue.id} is not awaiting approval (status: ${issue.status})`;
+    }
+    return { pmDir, boardDir, fullPath, relPath, issue };
+}
+function isInsideDir(candidate, dir) {
+    return candidate.startsWith(`${dir}${sep}`);
+}
+async function settleReviewDecision(ctx, workingDir, request, target) {
+    const updated = parseSingleIssue(workingDir, target.relPath);
+    let epic = null;
+    if (request.decision === 'approve' && updated) {
+        const epicPath = tryCompleteParentEpic(workingDir, updated);
+        epic = epicPath ? parseSingleIssue(workingDir, epicPath) : null;
+        await tryCompleteBoardIfDone(target.pmDir, request.boardId, parseBoardDirectory(target.pmDir, request.boardId)?.issues ?? [], (message) => { console.warn(`[plan-review-decision] ${message}`); });
+        notifyChainRunEnded(workingDir, request.boardId, 'complete');
+    }
+    ctx.broadcastToAll({ type: 'planIssueUpdated', data: updated });
+    if (epic)
+        ctx.broadcastToAll({ type: 'planIssueUpdated', data: epic });
+    const fullState = parsePlanDirectory(workingDir);
+    if (fullState)
+        ctx.broadcastToAll({ type: 'planStateUpdated', data: fullState });
+    if (request.decision === 'approve')
+        maybeContinueAfterApproval(ctx, workingDir, request.boardId);
+}
+const ACTIVITY_HEADING_RE = /^## Activity[^\S\r\n]*$/m;
+function appendChangesRequested(fullPath, comment, decidedAt) {
+    try {
+        const content = readFileSync(fullPath, 'utf-8');
+        const entry = `- Changes requested (${decidedAt.toISOString().split('T')[0]}): ${comment.replace(/\s*\n\s*/g, ' ')}`;
+        const heading = ACTIVITY_HEADING_RE.exec(content);
+        const cut = heading?.index === undefined ? -1 : heading.index + heading[0].length;
+        writeFileSync(fullPath, cut < 0
+            ? `${content}\n\n## Activity\n${entry}`
+            : `${content.slice(0, cut)}\n${entry}${content.slice(cut)}`, 'utf-8');
+    }
+    catch {   }
+}
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}

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

@@ -4,6 +4,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { replaceFrontMatterField } from '../plan/front-matter.js';
 import { defaultPmDir, getNextSprintId, parsePlanDirectory, parseSingleSprint, parseSprintArtifacts, resolvePmDir } from '../plan/parser.js';
+import { broadcastPlanStateIfChanged } from '../plan/watcher.js';
 import { denyIfViewOnly, resolvePlanPath } from './plan-helpers.js';
 function buildSprintMarkdown(id, title, goal, start, end, issueRefs) {
     const issuesYaml = issueRefs.length > 0
@@ -114,7 +115,7 @@ export function handleActivateSprint(ctx, ws, msg, workingDir, permission) {
     ctx.broadcastToAll({ type: 'planSprintUpdated', data: updatedSprint });
     const updatedState = parsePlanDirectory(workingDir);
     if (updatedState) {
-        ctx.broadcastToAll({ type: 'planStateUpdated', data: updatedState });
+        broadcastPlanStateIfChanged(ctx, workingDir, updatedState);
     }
 }
 export function handleCompleteSprint(ctx, ws, msg, workingDir, permission) {
@@ -172,7 +173,7 @@ export function handleCompleteSprint(ctx, ws, msg, workingDir, permission) {
     ctx.broadcastToAll({ type: 'planSprintCompleted', data: updatedSprint });
     const updatedState = parsePlanDirectory(workingDir);
     if (updatedState) {
-        ctx.broadcastToAll({ type: 'planStateUpdated', data: updatedState });
+        broadcastPlanStateIfChanged(ctx, workingDir, updatedState);
     }
 }
 export function handleGetSprintArtifacts(ctx, ws, msg, workingDir) {

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

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: LicenseRef-Minionry-Software
 import { can } from '@minionry/roles';
 import { NO_SPECS_DIR_ERROR, resolvePmDir } from '../plan/parser.js';
-import { cleanupScheduleSource, isValidTiming, parseCreateSourceWire, parseUpdatePatch, resolveCreateSource, } from '../schedule/schedule-wire.js';
+import { cleanupScheduleSource, isValidTiming, parseCreateSourceWire, parseMaxLatenessMs, parseUpdatePatch, resolveCreateSource, } from '../schedule/schedule-wire.js';
 import { getScheduler } from '../schedule/scheduler.js';
 import { previewTemplateSource } from '../schedule/template-source.js';
 import { dispatchByType } from './dispatch-util.js';
@@ -46,6 +46,11 @@ function handleScheduleCreate(ctx, ws, msg, workingDir, permission) {
         reply({ success: false, error: 'Invalid timing' });
         return;
     }
+    const maxLateness = parseMaxLatenessMs(data.maxLatenessMs);
+    if (!maxLateness.ok) {
+        reply({ success: false, error: 'Invalid maxLatenessMs (integer >= 60000)' });
+        return;
+    }
     const pmDir = resolvePmDir(workingDir);
     if (!pmDir) {
         reply({ success: false, error: NO_SPECS_DIR_ERROR });
@@ -70,6 +75,7 @@ function handleScheduleCreate(ctx, ws, msg, workingDir, permission) {
         input: data.input,
         timing: data.timing,
         enabled: data.enabled,
+        maxLatenessMs: maxLateness.value,
     });
     notifySchedulerAndBroadcast(ctx, workingDir);
     reply({
@@ -127,7 +133,7 @@ function handleScheduleUpdate(ctx, ws, msg, workingDir, permission) {
     }
     const safePatch = parseUpdatePatch(patch);
     if (!safePatch) {
-        reply({ success: false, error: 'Invalid timing' });
+        reply({ success: false, error: 'Invalid timing or maxLatenessMs' });
         return;
     }
     const store = getScheduleStore(ctx, workingDir);

package/dist/server/services/websocket/sdk-agent-host.js

@@ -78,8 +78,12 @@ function createAppAgentRun(ctx, start) {
             }
             : {}),
     });
-    if (model)
+    if (model) {
         session.applyOverrides({ engine: model.engine, model: model.value });
+    }
+    else if (selection) {
+        session.applyOverrides({ engine: selection.engine, ...(selection.model ? { model: selection.model } : {}) });
+    }
     setupSessionListeners(ctx, session, APP_HOST_WS, tabId);
     const sessionId = session.getSessionInfo().sessionId;
     ctx.sessions.set(sessionId, session);

package/dist/server/services/websocket/sdk-agent-schedule-host.js

@@ -0,0 +1,30 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { getAgentScheduler } from '../schedule/agent-scheduler.js';
+import { setSdkAgentScheduleHost } from '../sdk/agent-schedule.js';
+export function installSdkAgentScheduleHost(ctx) {
+    const host = {
+        getStore(workingDir) {
+            const engine = getAgentScheduler(workingDir, ctx);
+            engine.start();
+            return engine.getStore();
+        },
+        notifyAndBroadcast(workingDir) {
+            const engine = getAgentScheduler(workingDir, ctx);
+            engine.tick();
+            const store = engine.getStore();
+            if (store)
+                ctx.broadcastToAll({ type: 'agentSchedulesChanged', data: { schedules: store.list() } });
+        },
+        fireNow(workingDir, scheduleId) {
+            const engine = getAgentScheduler(workingDir, ctx);
+            engine.start();
+            const result = engine.fireNow(scheduleId);
+            const store = engine.getStore();
+            if (store)
+                ctx.broadcastToAll({ type: 'agentSchedulesChanged', data: { schedules: store.list() } });
+            return result;
+        },
+    };
+    setSdkAgentScheduleHost(host);
+}

package/dist/server/services/websocket/sdk-browser-host.js

@@ -23,7 +23,7 @@ export function installSdkBrowserHost(ctx) {
         navigate: async ({ url, tabId }) => {
             await (await ensureReady(ctx)).navigate(url, tabId);
         },
-        open: async ({ url, reuseOrigin }) => {
+        open: async ({ url, reuseOrigin, opener }) => {
             const live = await ensureReady(ctx);
             if (reuseOrigin) {
                 const match = live.getTabsSnapshot().tabs.find((t) => sameOrigin(t.url, reuseOrigin));
@@ -32,7 +32,7 @@ export function installSdkBrowserHost(ctx) {
                     return { tabId: match.id };
                 }
             }
-            const tab = await live.openTab(url);
+            const tab = await live.openTab(url, { kind: 'app', appId: opener.appId, origin: opener.origin });
             return { tabId: tab.id };
         },
         close: async ({ tabId }) => {
@@ -75,7 +75,8 @@ export function installSdkBrowserHost(ctx) {
                     onEvent(event);
                 },
                 broadcastToAll: (response) => ctx.broadcastToAll(response),
-            });
+            }, 
+            initiator ? { kind: 'app', appId: initiator.appId, origin: initiator.origin } : undefined);
             return {
                 agentId: run.agentId,
                 approve: (verdict) => resolveProposal(verdict),
@@ -130,11 +131,17 @@ async function runSdkPreflight(ctx) {
     }
     return toBrowserPreflightPayload(result, { chromiumInstalling: false });
 }
+function withoutOpener(tab) {
+    const { opener, ...sdkTab } = tab;
+    void opener;
+    return sdkTab;
+}
 function withOwners(payload) {
     const driverState = getBrowserDriverState();
     return {
         currentTabId: payload.currentTabId,
-        tabs: payload.tabs.map((tab) => {
+        tabs: payload.tabs.map((nativeTab) => {
+            const tab = withoutOpener(nativeTab);
             const owner = driverState.getOwner(tab.id);
             if (!owner)
                 return tab;

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

@@ -2,12 +2,15 @@
 // SPDX-License-Identifier: LicenseRef-Minionry-Software
 import { join } from 'node:path';
 import { parsePlanDirectory, resolvePmDir } from '../plan/parser.js';
+import { broadcastPlanStateIfChanged } from '../plan/watcher.js';
 import { injectGatherIssue, writeRunInputFile } from '../schedule/run-bootstrap.js';
 import { resolveSdkConsent } from '../sdk/connect.js';
 import { runSdkPipeline } from '../sdk/pipeline.js';
 import { setSdkPmHost } from '../sdk/pm.js';
 import { handleChatToBoard } from './plan-board-handlers.js';
 import { executorCache, getWatcher } from './plan-helpers.js';
+import { installSdkAgentScheduleHost } from './sdk-agent-schedule-host.js';
+import { installSdkPmChainHost } from './sdk-pm-chain-host.js';
 import { installSdkPmExecutionHost } from './sdk-pm-execution-host.js';
 import { installSdkPmScheduleHost } from './sdk-pm-schedule-host.js';
 import { installSdkQualityScheduleHost } from './sdk-quality-schedule-host.js';
@@ -116,7 +119,7 @@ function installSdkPmHost(ctx) {
             getWatcher(workingDir, ctx).start();
             const fullState = parsePlanDirectory(workingDir);
             if (fullState)
-                ctx.broadcastToAll({ type: 'planStateUpdated', data: fullState });
+                broadcastPlanStateIfChanged(ctx, workingDir, fullState);
         },
         stopExecutorIfRunning: (workingDir, boardId) => {
             const executor = executorCache.get(workingDir);
@@ -191,7 +194,9 @@ export async function handleSdkMessage(ctx, ws, msg, tabId, workingDir, role, vi
     installSdkPmHost(ctx);
     installSdkPmExecutionHost(ctx);
     installSdkPmScheduleHost(ctx);
+    installSdkPmChainHost(ctx);
     installSdkQualityScheduleHost();
+    installSdkAgentScheduleHost(ctx);
     if (msg.type === 'sdkConsentDecision') {
         handleSdkConsentDecision(msg, role, viewerId);
         return;

package/dist/server/services/websocket/sdk-pm-chain-host.js

@@ -0,0 +1,20 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { broadcastChainsChanged, getChainEngine } from '../chain/chain-engine.js';
+import { setSdkPmChainHost } from '../sdk/pm-chain.js';
+export function installSdkPmChainHost(ctx) {
+    const host = {
+        getStore(workingDir) {
+            const engine = getChainEngine(workingDir, ctx);
+            engine.start();
+            return engine.getStore();
+        },
+        notifyAndBroadcast(workingDir) {
+            const engine = getChainEngine(workingDir, ctx);
+            const store = engine.getStore();
+            if (store)
+                broadcastChainsChanged(ctx, store);
+        },
+    };
+    setSdkPmChainHost(host);
+}

package/dist/server/services/websocket/sdk-pm-execution-host.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: LicenseRef-Minionry-Software
 import { setSdkPmExecutionHost } from '../sdk/pm-execute.js';
 import { scopeExecutionDir } from './handler-context.js';
-import { wireExecutorEvents } from './plan-execution-handlers.js';
+import { broadcastBoardRunPrompt, wireExecutorEvents } from './plan-execution-handlers.js';
 import { executorCache, getExecutor } from './plan-helpers.js';
 const currentRunByWorkingDir = new Map();
 function mintRunId() {
@@ -13,6 +13,25 @@ function clearCurrentRun(workingDir, runId) {
     if (current?.runId === runId)
         currentRunByWorkingDir.delete(workingDir);
 }
+export function startFreshBoardRun(ctx, workingDir, boardId, options) {
+    const executor = getExecutor(workingDir);
+    const runId = mintRunId();
+    currentRunByWorkingDir.set(workingDir, { runId, boardId });
+    const executionDir = scopeExecutionDir(ctx, boardId);
+    wireExecutorEvents(executor, ctx, workingDir, boardId, undefined, executionDir);
+    executor.on('complete', () => clearCurrentRun(workingDir, runId));
+    executor.on('error', () => clearCurrentRun(workingDir, runId));
+    if (options?.launchPrompt)
+        broadcastBoardRunPrompt(ctx, boardId, options.launchPrompt);
+    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 },
+        });
+    });
+    return { runId };
+}
 export function installSdkPmExecutionHost(ctx) {
     const host = {
         attach(workingDir, boardId) {
@@ -28,19 +47,7 @@ export function installSdkPmExecutionHost(ctx) {
             if (alreadyRunningThisBoard) {
                 return { runId: current.runId, on: (event, cb) => executor.on(event, cb), off: (event, cb) => executor.off(event, cb) };
             }
-            const runId = mintRunId();
-            currentRunByWorkingDir.set(workingDir, { runId, boardId });
-            const executionDir = scopeExecutionDir(ctx, boardId);
-            wireExecutorEvents(executor, ctx, workingDir, boardId, undefined, executionDir);
-            executor.on('complete', () => clearCurrentRun(workingDir, runId));
-            executor.on('error', () => clearCurrentRun(workingDir, runId));
-            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 },
-                });
-            });
+            const { runId } = startFreshBoardRun(ctx, workingDir, boardId);
             return { runId, on: (event, cb) => executor.on(event, cb), off: (event, cb) => executor.off(event, cb) };
         },
         pause(workingDir, boardId) {

package/dist/server/services/websocket/sdk-pm-schedule-host.js

@@ -16,6 +16,15 @@ export function installSdkPmScheduleHost(ctx) {
             if (store)
                 ctx.broadcastToAll({ type: 'planSchedulesChanged', data: { schedules: store.list() } });
         },
+        fireNow(workingDir, scheduleId) {
+            const engine = getScheduler(workingDir, ctx);
+            engine.start();
+            const result = engine.fireNow(scheduleId);
+            const store = engine.getStore();
+            if (store)
+                ctx.broadcastToAll({ type: 'planSchedulesChanged', data: { schedules: store.list() } });
+            return result;
+        },
     };
     setSdkPmScheduleHost(host);
 }

package/dist/server/services/websocket/sdk-terminal-host.js

@@ -23,6 +23,7 @@ export function notifySdkTerminalSessionOpened(terminalId) {
 }
 export function resetSdkTerminalNotifications() {
     sessionListeners.clear();
+    exitBroadcastCtx = null;
     if (managerExitCleanup) {
         managerExitCleanup();
         managerExitCleanup = null;
@@ -44,17 +45,23 @@ function summarizeSession(id) {
     };
 }
 let managerExitCleanup = null;
+let exitBroadcastCtx = null;
 function wireManagerExitListener() {
     if (managerExitCleanup)
         return;
     const ptyManager = getPTYManager();
     const onExit = (terminalId) => {
+        const ownerLabel = ptyManager.getSessionInfo(terminalId)?.ownerLabel;
+        if (ownerLabel !== undefined) {
+            exitBroadcastCtx?.broadcastToAll({ type: 'terminalClosed', data: { terminalId, ownerLabel } });
+        }
         notifySessionChange({ kind: 'closed', id: terminalId });
     };
     ptyManager.on('exit', onExit);
     managerExitCleanup = () => ptyManager.off('exit', onExit);
 }
 export function installSdkTerminalHost(ctx) {
+    exitBroadcastCtx = ctx;
     wireManagerExitListener();
     const host = {
         async ensurePtyAvailable() {

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

@@ -1,13 +1,10 @@
 // Copyright (c) 2025-present Minionry, Inc.
 // SPDX-License-Identifier: LicenseRef-Minionry-Software
 import { spawn } from 'node:child_process';
-import { existsSync, mkdirSync, unlinkSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { resolveClaudeCommand } from '../../engines/claude/claude-command.js';
+import { resolveClaudeCommand, TOOL_LESS_CLAUDE_ARGS } from '../../engines/claude/claude-command.js';
 import { computeClassifierHealth } from '../../mcp/classifier/health.js';
 import { getModelCatalog } from '../model-catalog.js';
 import { clearBouncerClassifierOverride, getCurrentSpaceIdentity, getSettings, setBouncerClassifier, setBouncerClassifierOverride, setEffortLevel, setEngine, setFastMode, setMaxConcurrentSessions, setMaxUploadSizeMb, setModel, setQualityEffortLevel, setQualityEngine, setQualityFastMode, setQualityModel, setSubagentModel, setSubagentModelForce, } from '../settings.js';
-import { spacePath } from '../space-layout.js';
 import { createSystemPrompt, deleteSystemPromptProfile, listSystemPromptProfiles, readSystemPromptFile, saveSystemPromptFile, systemPromptsDir, } from '../system-prompts.js';
 import { isEngineId } from './types.js';
 function buildSystemPromptProfilesMessage() {
@@ -173,10 +170,6 @@ export async function handleGetModelCatalog(ctx, ws, msg) {
 }
 export async function generateNotificationSummary(ctx, ws, tabId, userPrompt, output, workingDir) {
     try {
-        const tempDir = spacePath(workingDir, 'tmp');
-        if (!existsSync(tempDir)) {
-            mkdirSync(tempDir, { recursive: true });
-        }
         let truncatedOutput = output;
         if (output.length > 4000) {
             const firstPart = output.slice(0, 2000);
@@ -201,19 +194,19 @@ Generate a notification summary following these rules:
 6. No emojis, no markdown, just plain text
 
 Respond with ONLY the summary text, nothing else.`;
-        const promptFile = join(tempDir, `notif-summary-${Date.now()}.txt`);
-        writeFileSync(promptFile, summaryPrompt);
         const systemPrompt = 'You are a notification summary assistant. Respond with only the summary text, no preamble or explanation.';
         const args = [
             '--print',
             '--model', 'haiku',
-            '--system-prompt', systemPrompt,
-            promptFile
+            ...TOOL_LESS_CLAUDE_ARGS,
+            '--system-prompt', systemPrompt
         ];
         const claude = spawn(resolveClaudeCommand(), args, {
             cwd: workingDir,
-            stdio: ['ignore', 'pipe', 'pipe']
+            stdio: ['pipe', 'pipe', 'pipe']
         });
+        claude.stdin?.on('error', () => { });
+        claude.stdin?.end(summaryPrompt);
         let stdout = '';
         let stderr = '';
         let responseSent = false;
@@ -234,11 +227,6 @@ Respond with ONLY the summary text, nothing else.`;
             stderr += data.toString();
         });
         claude.on('close', (code) => {
-            try {
-                unlinkSync(promptFile);
-            }
-            catch {
-            }
             if (code === 0 && stdout.trim()) {
                 sendSummaryOnce(stdout.trim().slice(0, 150));
             }

package/dist/server/services/websocket/tab-broadcast.js

@@ -2,13 +2,17 @@
 // SPDX-License-Identifier: LicenseRef-Minionry-Software
 import { mirrorTabEventToSdk } from '../sdk/agents.js';
 import { isTimelineTabEvent } from '../timeline/index.js';
+import { isHighFrequencyTabEvent } from './viewer-interest.js';
 export function broadcastTabEvent(ctx, tabId, type, data, engine) {
     const buffer = ctx.tabEventBuffers.getOrCreate(tabId);
     const seq = buffer.record(type, data);
     const envelope = { type, tabId, data, seq };
     if (engine)
         envelope.engine = engine;
-    ctx.broadcastToAll(envelope);
+    if (isHighFrequencyTabEvent(type) && ctx.broadcastStream)
+        ctx.broadcastStream(envelope);
+    else
+        ctx.broadcastToAll(envelope);
     mirrorTabEventToSdk(tabId, type, data, (response) => ctx.broadcastToAll(response));
     assembleTabTimeline(ctx, tabId, type, data, engine);
     return seq;