conductor-remote 1.124.0 → 1.125.1

package/dist/index.html

@@ -25,8 +25,8 @@
 		<title>Conductor Remote</title>
 		<!-- Runs before the module bundle so it can catch a stale shell that fails to boot. -->
 		<script src="/self-heal.js"></script>
-		<script type="module" crossorigin src="/assets/index-D0mVtqUh.js"></script>
-		<link rel="stylesheet" crossorigin href="/assets/index-8RMgvUzK.css">
+		<script type="module" crossorigin src="/assets/index-CMkZa4wP.js"></script>
+		<link rel="stylesheet" crossorigin href="/assets/index-CJ_yLSwD.css">
 	<link rel="manifest" href="/manifest.webmanifest"></head>
 	<body>
 		<div id="root"></div>

package/dist/sw.js

@@ -1 +1 @@
-if(!self.define){let e,s={};const i=(i,n)=>(i=new URL(i+".js",n).href,s[i]||new Promise(s=>{if("document"in self){const e=document.createElement("script");e.src=i,e.onload=s,document.head.appendChild(e)}else e=i,importScripts(i),s()}).then(()=>{let e=s[i];if(!e)throw new Error(`Module ${i} didn’t register its module`);return e}));self.define=(n,r)=>{const l=e||("document"in self?document.currentScript.src:"")||location.href;if(s[l])return;let o={};const t=e=>i(e,l),a={module:{uri:l},exports:o,require:t};s[l]=Promise.all(n.map(e=>a[e]||t(e))).then(e=>(r(...e),o))}}define(["./workbox-dcde9eb3"],function(e){"use strict";importScripts("/push-sw.js"),self.addEventListener("message",e=>{e.data&&"SKIP_WAITING"===e.data.type&&self.skipWaiting()}),e.clientsClaim(),e.precacheAndRoute([{url:"self-heal.js",revision:"49bd63adb25a09341f8d2610e8bd3c76"},{url:"push-sw.js",revision:"4e0b714c0ea53e85c167e6d8f5b767aa"},{url:"index.html",revision:"10db79e1e2aa5617d1d0f7b00da03cfe"},{url:"assets/workbox-window.prod.es5-BBnX5xw4.js",revision:null},{url:"assets/pierre-shiki-wasm-C8ETeZem.js",revision:null},{url:"assets/pierre-light-480U9XYS.js",revision:null},{url:"assets/pierre-dark-CyvmCCZW.js",revision:null},{url:"assets/index-D0mVtqUh.js",revision:null},{url:"assets/index-8RMgvUzK.css",revision:null},{url:"assets/PierrePatch-4wYckD3t.js",revision:null},{url:"apple-touch-icon.png",revision:"1127bb396b4648add53dce3f22c92aee"},{url:"icon-192.png",revision:"c5e01ac58768627e18ee7b8b6a9239ef"},{url:"icon-512.png",revision:"a40638c55e310312457a621c9a0002c8"},{url:"icon-maskable-512.png",revision:"a9b0d962686287452216492cd2247499"},{url:"icon.svg",revision:"c1aee186821798733dd477e69a0ef243"},{url:"manifest.webmanifest",revision:"cf88fbc5755108a7fe0616fa160a8a15"}],{}),e.cleanupOutdatedCaches(),e.registerRoute(new e.NavigationRoute(e.createHandlerBoundToURL("/index.html"),{denylist:[/^\/api\//]})),e.registerRoute(({url:e})=>e.pathname.startsWith("/assets/diff-syntax/"),new e.CacheFirst({cacheName:"diff-syntax",plugins:[new e.ExpirationPlugin({maxEntries:32,maxAgeSeconds:31536e3})]}),"GET")});
+if(!self.define){let e,s={};const i=(i,n)=>(i=new URL(i+".js",n).href,s[i]||new Promise(s=>{if("document"in self){const e=document.createElement("script");e.src=i,e.onload=s,document.head.appendChild(e)}else e=i,importScripts(i),s()}).then(()=>{let e=s[i];if(!e)throw new Error(`Module ${i} didn’t register its module`);return e}));self.define=(n,r)=>{const l=e||("document"in self?document.currentScript.src:"")||location.href;if(s[l])return;let o={};const a=e=>i(e,l),t={module:{uri:l},exports:o,require:a};s[l]=Promise.all(n.map(e=>t[e]||a(e))).then(e=>(r(...e),o))}}define(["./workbox-dcde9eb3"],function(e){"use strict";importScripts("/push-sw.js"),self.addEventListener("message",e=>{e.data&&"SKIP_WAITING"===e.data.type&&self.skipWaiting()}),e.clientsClaim(),e.precacheAndRoute([{url:"self-heal.js",revision:"49bd63adb25a09341f8d2610e8bd3c76"},{url:"push-sw.js",revision:"4e0b714c0ea53e85c167e6d8f5b767aa"},{url:"index.html",revision:"b903da08728771741e2d4c47b74f03df"},{url:"assets/workbox-window.prod.es5-BBnX5xw4.js",revision:null},{url:"assets/pierre-shiki-wasm-C8ETeZem.js",revision:null},{url:"assets/pierre-light-480U9XYS.js",revision:null},{url:"assets/pierre-dark-CyvmCCZW.js",revision:null},{url:"assets/index-CMkZa4wP.js",revision:null},{url:"assets/index-CJ_yLSwD.css",revision:null},{url:"assets/PierrePatch-Sohj8IVv.js",revision:null},{url:"apple-touch-icon.png",revision:"1127bb396b4648add53dce3f22c92aee"},{url:"icon-192.png",revision:"c5e01ac58768627e18ee7b8b6a9239ef"},{url:"icon-512.png",revision:"a40638c55e310312457a621c9a0002c8"},{url:"icon-maskable-512.png",revision:"a9b0d962686287452216492cd2247499"},{url:"icon.svg",revision:"c1aee186821798733dd477e69a0ef243"},{url:"manifest.webmanifest",revision:"cf88fbc5755108a7fe0616fa160a8a15"}],{}),e.cleanupOutdatedCaches(),e.registerRoute(new e.NavigationRoute(e.createHandlerBoundToURL("/index.html"),{denylist:[/^\/api\//]})),e.registerRoute(({url:e})=>e.pathname.startsWith("/assets/diff-syntax/"),new e.CacheFirst({cacheName:"diff-syntax",plugins:[new e.ExpirationPlugin({maxEntries:32,maxAgeSeconds:31536e3})]}),"GET")});

package/dist-node/src/contracts/agent-inputs.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { AGENT_EFFORTS } from "../shared.js";
+/** Wire inputs shared by the HTTP handlers and their MCP tools. Browser callers import only their types. */
+const optionalText = z
+    .string()
+    .trim()
+    .transform(value => value || undefined)
+    .optional();
+export const sessionIdSchema = z.string().trim().min(1).describe('The chat id from list_chats / search_chats.');
+const workspaceIdSchema = optionalText.describe('Its workspace. Strongly recommended: it is what the relay asserts against before touching the UI.');
+export const agentPatchSchema = z.object({
+    model: optionalText.describe('A picker label from list_models. An unambiguous prefix is enough.'),
+    effort: z.enum(AGENT_EFFORTS).optional().describe('Reasoning effort applied before the next prompt.'),
+    plan: z.boolean().optional().describe('Conductor’s Plan checkbox.'),
+    fast: z
+        .boolean()
+        .optional()
+        .describe('Fast mode. Only some models offer it; a missing button is reported, not ignored.')
+});
+export const setAgentOptionsSchema = agentPatchSchema.extend({ workspaceId: workspaceIdSchema });
+export const sendPromptSchema = z.object({
+    text: z.string({ error: 'prompt must be a string' }).trim().min(1, 'empty prompt'),
+    workspaceId: workspaceIdSchema,
+    agent: agentPatchSchema.optional(),
+    clientId: z.string().optional(),
+    queue: z.boolean().default(false)
+});
+export const createWorkspaceSchema = agentPatchSchema.extend({
+    repo: z.string().trim().min(1).optional().describe('Exact name from list_repos.'),
+    prompt: optionalText.describe('First prompt for the new agent. Omit to open an empty workspace.'),
+    send: z
+        .boolean()
+        .default(false)
+        .describe('Block until the first prompt is actually delivered (tens of seconds, and longer behind other queued sends). Default false.'),
+    sendImmediately: z
+        .boolean()
+        .default(true)
+        .describe("Send the first prompt without waiting for the worktree to finish building, which is how Conductor's own New workspace box behaves. Default true. Pass false only when the agent's first move needs what the repo's setup script installs."),
+    attachmentIds: z.array(z.string()).default([])
+});
+/** False is an explicit setting; an empty patch inherits the chat's existing controls. */
+export function hasAgentSettings(patch) {
+    return patch.model !== undefined || patch.effort !== undefined || patch.plan !== undefined || patch.fast !== undefined;
+}

package/dist-node/src/contracts/validation.js

@@ -0,0 +1,16 @@
+/** Invalid caller input, distinguished from failures inside the relay. */
+export class InputError extends Error {
+}
+export function parseInput(schema, input) {
+    const result = schema.safeParse(input);
+    if (result.success)
+        return result.data;
+    throw new InputError(result.error.issues
+        .map(issue => {
+        const message = issue.code === 'unrecognized_keys'
+            ? `unknown ${issue.keys.length === 1 ? 'field' : 'fields'}: ${issue.keys.join(', ')}`
+            : issue.message;
+        return issue.path.length ? `${issue.path.join('.')}: ${message}` : message;
+    })
+        .join('; '));
+}

package/dist-node/src/http/input.js

@@ -0,0 +1,9 @@
+import { InputError } from "../contracts/validation.js";
+export function parseJsonBody(text) {
+    try {
+        return JSON.parse(text || '{}');
+    }
+    catch {
+        throw new InputError('request body must be valid JSON');
+    }
+}

package/dist-node/src/http/router.js

@@ -1,4 +1,5 @@
 import http from 'node:http';
+import { InputError } from "../contracts/validation.js";
 import { UiBusyError, uiQueueDepth, withUiPriority } from "../writes/ui-lock.js";
 import { NOT_HANDLED } from "./router-types.js";
 import { createCreateWorkspaceRoutes } from "./routes/create-workspace.js";
@@ -57,6 +58,8 @@ export function createRelayServer(services) {
             catch (err) {
                 if (err instanceof PayloadTooLargeError)
                     return json(req, res, 413, { error: err.message });
+                if (err instanceof InputError)
+                    return json(req, res, 400, { error: err.message });
                 const workflowError = workflowHttpError(err);
                 if (workflowError) {
                     console.warn(`[workflow] ${req.method} ${pathname}: ${workflowError.error.code}: ${workflowError.error.message}`);

package/dist-node/src/http/routes/create-workspace.js

@@ -1,6 +1,8 @@
+import { createWorkspaceSchema, hasAgentSettings } from "../../contracts/agent-inputs.js";
+import { parseInput } from "../../contracts/validation.js";
 import { stagedAttachments } from "../../files/staged-attachments.js";
 import { isRoute, routes } from "../../routes.js";
-import { EFFORT_LABELS } from "../../writes/agent-options.js";
+import { parseJsonBody } from "../input.js";
 import { NOT_HANDLED } from "../router-types.js";
 export function createCreateWorkspaceRoutes(services) {
     const { readBody, json, STAGED_ATTACHMENTS_DIR, reads, createWorkspaceAndRead, firstPrompts } = services;
@@ -9,29 +11,12 @@ export function createCreateWorkspaceRoutes(services) {
         // POST /api/workspaces { repo, prompt, model?/effort?/plan?/fast?, send? }
         // — create a workspace via Conductor's deep link, then configure its first chat.
         if (isRoute(routes.createWorkspace, req.method, pathname)) {
-            const body = JSON.parse((await readBody(req)) || '{}');
-            const attachmentIds = body.attachmentIds ?? [];
-            if ('workflow' in body)
+            const input = parseJsonBody(await readBody(req));
+            if (input && typeof input === 'object' && 'workflow' in input)
                 return json(req, res, 400, { error: 'Workflow starts through POST /api/workflows.' });
-            if (body.model !== undefined && typeof body.model !== 'string')
-                return json(req, res, 400, { error: 'model must be a picker label' });
-            if (body.effort !== undefined && typeof body.effort !== 'string')
-                return json(req, res, 400, { error: 'effort must be a string' });
-            const effort = body.effort?.trim() || undefined;
-            if (effort && !EFFORT_LABELS[effort])
-                return json(req, res, 400, { error: `effort must be one of ${Object.keys(EFFORT_LABELS).join(', ')}` });
-            if (body.plan !== undefined && typeof body.plan !== 'boolean')
-                return json(req, res, 400, { error: 'plan must be a boolean' });
-            if (body.fast !== undefined && typeof body.fast !== 'boolean')
-                return json(req, res, 400, { error: 'fast must be a boolean' });
-            const requestedAgent = {
-                model: body.model?.trim() || undefined,
-                effort,
-                plan: body.plan,
-                fast: body.fast
-            };
-            if (!Array.isArray(attachmentIds) || attachmentIds.some(id => typeof id !== 'string'))
-                return json(req, res, 400, { error: 'attachment ids must be a list of strings' });
+            const body = parseInput(createWorkspaceSchema, input);
+            const { attachmentIds, model, effort, plan, fast } = body;
+            const requestedAgent = { model, effort, plan, fast };
             const attachments = stagedAttachments(STAGED_ATTACHMENTS_DIR, attachmentIds);
             if (!attachments)
                 return json(req, res, 409, { error: 'an attached file is no longer available; add it again' });
@@ -44,7 +29,7 @@ export function createCreateWorkspaceRoutes(services) {
                 return json(req, res, 400, { error: 'need a repo or a prompt' });
             const prompt = objective;
             const agent = requestedAgent;
-            const configureAgent = Object.values(agent).some(value => value !== undefined);
+            const configureAgent = hasAgentSettings(agent);
             // Resolve the repo to a real path: an unmatched `path` would silently land
             // the workspace in whichever repo Conductor happens to list first.
             const repo = body.repo ? reads.listRepos().find(r => r.name === body.repo) : undefined;
@@ -69,7 +54,7 @@ export function createCreateWorkspaceRoutes(services) {
             // callers into waiting.
             // Whatever happens, the prompt is already pre-filled in Conductor's composer.
             const settled = prompt || configureAgent
-                ? firstPrompts.enqueue(created.id, prompt, body.sendImmediately !== false, attachmentIds, configureAgent ? agent : undefined)
+                ? firstPrompts.enqueue(created.id, prompt, body.sendImmediately, attachmentIds, configureAgent ? agent : undefined)
                 : null;
             const failed = settled && body.send === true ? await settled : null;
             settled?.catch(() => undefined); // fire-and-forget: it reports failure, it never rejects

package/dist-node/src/http/routes/prompts.js

@@ -1,3 +1,5 @@
+import { hasAgentSettings, sendPromptSchema } from "../../contracts/agent-inputs.js";
+import { parseInput } from "../../contracts/validation.js";
 import { attachmentPrompt, writeAttachment } from "../../files/attachments.js";
 import { discardStagedAttachment, materializeStagedAttachments, stageAttachment } from "../../files/staged-attachments.js";
 import { captureForkWorkspace, materializeForkWorkspace, releaseForkWorkspace } from "../../git/fork-workspace.js";
@@ -5,8 +7,8 @@ import { acceptDelegation, delegationHttpStatus } from "../../orchestration/dele
 import { WorkflowCoordinatorError } from "../../orchestration/workflow/errors.js";
 import { routeParam, routes } from "../../routes.js";
 import { renderTranscript, transcriptMessage, transcriptThrough } from "../../transcript/parser.js";
-import { EFFORT_LABELS } from "../../writes/agent-options.js";
 import { lockBlocked } from "../../writes/guards.js";
+import { parseJsonBody } from "../input.js";
 import { NOT_HANDLED } from "../router-types.js";
 export function createPromptsRoutes(services) {
     const { orchestration, orchestrationUnavailableReason, readBody, json, workflowOwningSession, reads, roleStore, modelCache, delegationStore, delegationQueue, workflowFrozenError, sendBudget, sendOnce, firstPrompts, actuator, STAGED_ATTACHMENTS_DIR, applyAgentPatch, parkedPrompts, PARKED_ERROR, deliverPrompt, createWorkspaceAndRead, sleep, openChat } = services;
@@ -51,20 +53,13 @@ export function createPromptsRoutes(services) {
         const promptTo = routeParam(routes.sendPrompt, req.method, pathname);
         if (promptTo) {
             const sessionId = promptTo;
-            const body = JSON.parse((await readBody(req)) || '{}');
-            if ('workflow' in body) {
+            const input = parseJsonBody(await readBody(req));
+            if (input && typeof input === 'object' && 'workflow' in input) {
                 return json(req, res, 400, { error: 'Workflow starts through POST /api/workflows.' });
             }
-            if (body.text !== undefined && typeof body.text !== 'string') {
-                return json(req, res, 400, { error: 'prompt must be a string' });
-            }
-            const rawText = (body.text ?? '').trim();
-            if (!rawText)
-                return json(req, res, 400, { error: 'empty prompt' });
-            if (body.agent !== undefined && (!body.agent || typeof body.agent !== 'object' || Array.isArray(body.agent))) {
-                return json(req, res, 400, { error: 'agent must be a settings object' });
-            }
-            const requestedAgent = body.agent && Object.keys(body.agent).length ? body.agent : undefined;
+            const body = parseInput(sendPromptSchema, input);
+            const rawText = body.text;
+            const requestedAgent = body.agent && hasAgentSettings(body.agent) ? body.agent : undefined;
             const frozen = workflowFrozenError(sessionId);
             if (frozen &&
                 requestedAgent &&
@@ -79,10 +74,7 @@ export function createPromptsRoutes(services) {
             // One deadline for the whole request: settings eat into the send's budget
             // rather than extending it past what the phone said it would wait.
             const deadline = Date.now() + sendBudget(req);
-            const queue = body.queue === true;
-            if (requestedAgent?.effort && !EFFORT_LABELS[requestedAgent.effort]) {
-                return json(req, res, 400, { error: `effort must be one of ${Object.keys(EFFORT_LABELS).join(', ')}` });
-            }
+            const queue = body.queue;
             // One prompt per intent (src/delivery/sendonce.ts). Everything that can *say something
             // to Conductor* sits inside, so an answer the phone never heard is replayed
             // rather than re-performed — including the parked branches, since parking the

package/dist-node/src/http/routes/sessions.js

@@ -1,9 +1,12 @@
+import { setAgentOptionsSchema } from "../../contracts/agent-inputs.js";
+import { parseInput } from "../../contracts/validation.js";
 import { writeAttachment } from "../../files/attachments.js";
 import { noteViewing } from "../../notifications/notify.js";
 import { routeParam, routes } from "../../routes.js";
 import { VIEWING_HEADER } from "../../shared.js";
-import { EFFORT_LABELS, listAgentModels, setDefaultModel } from "../../writes/agent-options.js";
+import { listAgentModels, setDefaultModel } from "../../writes/agent-options.js";
 import { closeChat, restoreChat, stopTurn } from "../../writes/chats.js";
+import { parseJsonBody } from "../input.js";
 import { NOT_HANDLED } from "../router-types.js";
 export function createSessionsRoutes(services) {
     const { json, reads, workflowFrozenError, locateChat, modelCache, readBody, applyAgentPatch, actuator, sleep, attachmentHeaderName, readAttachmentBody } = services;
@@ -108,10 +111,7 @@ export function createSessionsRoutes(services) {
         const agentOf = routeParam(routes.agent, req.method, pathname);
         if (agentOf) {
             const sessionId = agentOf;
-            const body = JSON.parse((await readBody(req)) || '{}');
-            if (body.effort && !EFFORT_LABELS[body.effort]) {
-                return json(req, res, 400, { error: `effort must be one of ${Object.keys(EFFORT_LABELS).join(', ')}` });
-            }
+            const body = parseInput(setAgentOptionsSchema, parseJsonBody(await readBody(req)));
             const frozen = workflowFrozenError(sessionId);
             if (frozen && (body.model !== undefined || body.effort !== undefined || body.fast !== undefined)) {
                 return json(req, res, 409, frozen);

package/dist-node/src/http/services/base.js

@@ -177,17 +177,23 @@ export function createBaseServices() {
     /** Fail closed if another UI-capable relay cannot prove it speaks this protocol. */
     async function workflowCompatibilityError() {
         if (!orchestration.writable) {
-            return `Workflow is disabled because ${orchestrationUnavailableReason()}.`;
+            return { kind: 'incompatible', message: `Workflow is disabled because ${orchestrationUnavailableReason()}.` };
         }
         try {
             const processes = await listUiCapableRelayProcesses();
             const incompatible = incompatibleRelayProcesses(processes, orchestration.listRelayInstances(), ORCHESTRATION_PROTOCOL_VERSION);
             if (!incompatible.length)
                 return null;
-            return `Workflow needs every live conductor-remote UI relay on protocol ${ORCHESTRATION_PROTOCOL_VERSION}. Stop incompatible PID${incompatible.length === 1 ? '' : 's'} ${incompatible.map(process => process.pid).join(', ')} and try again.`;
+            return {
+                kind: 'incompatible',
+                message: `Workflow needs every live conductor-remote UI relay on protocol ${ORCHESTRATION_PROTOCOL_VERSION}. Stop incompatible PID${incompatible.length === 1 ? '' : 's'} ${incompatible.map(process => process.pid).join(', ')} and try again.`
+            };
         }
         catch (error) {
-            return `Workflow could not verify the live relay processes: ${error instanceof Error ? error.message : String(error)}`;
+            return {
+                kind: 'unverified',
+                message: `Workflow could not verify the live relay processes: ${error instanceof Error ? error.message : String(error)}`
+            };
         }
     }
     /**

package/dist-node/src/http/services/workflow-notifications.js

@@ -0,0 +1,53 @@
+import { chatRoute, notifyAll } from "../../notifications/notify.js";
+import { workflowBlockMessage } from "../../orchestration/workflow/blocked.js";
+import { scrubWorkflowSecrets, workspaceTitle } from "../../shared.js";
+import { uiTurn } from "../../writes/ui-lock.js";
+export function createWorkflowNotificationServices(services) {
+    const { reads, orchestration, actuator, workflowCompatibilityError, locateChat, confirmDelivery, CONFIRM_WINDOW_MS } = services;
+    function title(notice) {
+        const ws = notice.run.workspaceId ? reads.getWorkspace(notice.run.workspaceId) : null;
+        return scrubWorkflowSecrets(ws ? workspaceTitle(ws) : notice.run.target.kind === 'new_workspace' ? notice.run.target.repo : 'Conductor').slice(0, 160);
+    }
+    return {
+        notifyBlocked: async (notice) => {
+            const { run } = notice;
+            await notifyAll({
+                title: title(notice),
+                body: workflowBlockMessage(notice, title(notice)),
+                tag: `workflow-block-${run.id}-${notice.eventId}`,
+                url: run.workspaceId && run.rootSessionId ? chatRoute(run.workspaceId, run.rootSessionId) : '/',
+                kind: 'error',
+                ts: Date.now()
+            });
+        },
+        sendBlockedNotice: (notice) => uiTurn(async () => {
+            if (await workflowCompatibilityError())
+                return;
+            // Recheck under both UI locks. Recovery or a different failure may have won
+            // while this background send waited behind a phone operation or its probe.
+            const run = orchestration.getWorkflowRun(notice.run.id);
+            const latest = orchestration
+                .listWorkflowEvents(notice.run.id)
+                .findLast(event => event.type === 'workflow_blocked');
+            if (run?.phase !== 'blocked' || latest?.id !== notice.eventId || orchestration.getUiQuarantine().active)
+                return;
+            const ws = run.workspaceId ? reads.getWorkspace(run.workspaceId) : null;
+            const sessionId = run.rootSessionId;
+            if (!ws || !sessionId || !reads.getSession(sessionId) || reads.sessionWorkspaceId(sessionId) !== ws.id)
+                return;
+            const located = locateChat(ws, sessionId);
+            if ('error' in located)
+                return;
+            const text = `${workflowBlockMessage(notice, workspaceTitle(ws))}\n\nFurther Baton sends are paused until this Workflow recovers.`;
+            const before = reads.deliveryCursor(sessionId);
+            const deadline = Date.now() + 25_000;
+            const result = await actuator.send({ workspace: ws, sessionId, tab: located.tab }, text, {
+                queue: true,
+                deadline: deadline - CONFIRM_WINDOW_MS
+            });
+            const receipt = await confirmDelivery(sessionId, text, before, deadline);
+            if (!receipt)
+                throw new Error(result.error ?? 'Conductor did not record the Workflow block notice.');
+        })
+    };
+}

package/dist-node/src/http/services/workflow.js

@@ -1,13 +1,16 @@
 import { materializeStagedAttachments } from "../../files/staged-attachments.js";
 import { WorkflowCoordinator } from "../../orchestration/workflow/coordinator.js";
-import { WorkflowCoordinatorError } from "../../orchestration/workflow/errors.js";
+import { WorkflowCompatibilityReadError, WorkflowCoordinatorError, WorkflowRoleVerificationError } from "../../orchestration/workflow/errors.js";
 import { WorkflowRequestError, workflowClientIsMcp } from "../../orchestration/workflow/http.js";
+import { workflowReportBody } from "../../orchestration/workflow/report.js";
 import { renderTranscript } from "../../transcript/parser.js";
 import { retryWontHelp, screenLocked } from "../../writes/guards.js";
+import { createWorkflowNotificationServices } from "./workflow-notifications.js";
 export function createWorkflowServices(services) {
     const { orchestration, relayIdentity, reads, stagedAttachmentIdsInObjective, STAGED_ATTACHMENTS_DIR, createWorkspaceAndRead, workflowCompatibilityError, actuator, sessionPoller, workflowRootInspection, withWorkflowEffectGate, sessionMatchesWorkflowRole, workflowDeliveryCursor, stableWorkflowAttachment, sendWorkflowPrompt, workflowSessionId, assertWorkflowRootStillPristine, workspaceBaseline, workflowWorkspaceCandidate, sessionBaseline, workflowSessionCandidate, workflowEffectPrompt, readsDeliveryCursor, workflowEffectMarker, applyAgentPatch, openChat, batonText } = services;
     const workflowCoordinator = orchestration.writable
         ? new WorkflowCoordinator(orchestration, relayIdentity, {
+            ...createWorkflowNotificationServices(services),
             captureWorkspaceBaseline: async (repoName) => {
                 const repo = reads.listRepos().find(candidate => candidate.name === repoName);
                 if (!repo) {
@@ -103,9 +106,11 @@ export function createWorkflowServices(services) {
                     throw new WorkflowCoordinatorError('workflow_effect_failed', applied.error ?? 'Conductor rejected the frozen role settings.');
                 }
                 const session = reads.getSession(sessionId);
-                if (!session || !sessionMatchesWorkflowRole(session, role)) {
-                    throw new WorkflowCoordinatorError('workflow_effect_failed', 'Conductor no longer matches every frozen role setting; no fallback was selected.');
+                if (!session) {
+                    throw new WorkflowCoordinatorError('workflow_effect_failed', 'The Workflow chat disappeared after applying its role settings.');
                 }
+                if (!sessionMatchesWorkflowRole(session, role))
+                    throw new WorkflowRoleVerificationError();
                 return {
                     sessionId,
                     agentType: session.agent_type,
@@ -180,6 +185,12 @@ export function createWorkflowServices(services) {
                 return stableWorkflowAttachment(ws.worktree, job.id, `Workflow ${job.role} handoff.md`, body);
             },
             sendPrompt: call => sendWorkflowPrompt(call, false),
+            materializeReport: async ({ run, job, outcome }) => {
+                const ws = run.workspaceId ? reads.getWorkspace(run.workspaceId) : null;
+                if (!ws?.worktree)
+                    throw new Error('The Workflow report worktree is unavailable.');
+                return stableWorkflowAttachment(ws.worktree, `${job.id}:report:${job.attemptCount}`, `Workflow ${job.role} report.md`, workflowReportBody(run, job, outcome));
+            },
             returnBaton: call => sendWorkflowPrompt(call, true),
             resolveDeliveryReceipt: async ({ sessionId, receipt }) => {
                 const current = reads.deliveryReceiptForId(sessionId, receipt.id);
@@ -223,6 +234,8 @@ export function createWorkflowServices(services) {
                 return {
                     kind: 'success',
                     baton: batonText(last.text),
+                    text: last.text,
+                    assistantRowid: last.rowid,
                     evidence: { assistantRowid: last.rowid }
                 };
             },
@@ -329,7 +342,9 @@ export function createWorkflowServices(services) {
             assertCompatibleRelays: async () => {
                 const error = await workflowCompatibilityError();
                 if (error) {
-                    throw new WorkflowCoordinatorError('workflow_incompatible_relay', error, {
+                    if (error.kind === 'unverified')
+                        throw new WorkflowCompatibilityReadError(error.message);
+                    throw new WorkflowCoordinatorError('workflow_incompatible_relay', error.message, {
                         status: 409,
                         retryable: true
                     });

package/dist-node/src/mcp/client.js

@@ -0,0 +1,66 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { stateDir } from "../config.js";
+import { READ_TIMEOUT_MS } from "./protocol.js";
+function relayErrorMessage(error, status) {
+    if (typeof error === 'string' && error)
+        return error;
+    if (error && typeof error === 'object') {
+        const fields = error;
+        const parts = [fields.code, fields.message].filter((part) => typeof part === 'string' && !!part);
+        if (parts.length)
+            return parts.join(': ');
+    }
+    return `HTTP ${status}`;
+}
+export function relayBase() {
+    const port = process.env.RELAY_PORT ?? '8787';
+    // The relay binds loopback (see config.ts); RELAY_HOST only widens who else can
+    // reach it, so 127.0.0.1 is always right for a client on the same Mac.
+    return `http://127.0.0.1:${port}`;
+}
+function relayToken() {
+    if (process.env.RELAY_TOKEN)
+        return process.env.RELAY_TOKEN;
+    try {
+        return readFileSync(path.join(stateDir(), 'token'), 'utf8').trim();
+    }
+    catch {
+        throw new Error(`no relay token at ${path.join(stateDir(), 'token')} — start the relay once (conductor-remote service install), or set RELAY_TOKEN`);
+    }
+}
+export async function call(route, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? READ_TIMEOUT_MS;
+    let res;
+    try {
+        res = await fetch(`${relayBase()}${route}`, {
+            method: opts.method ?? 'GET',
+            signal: AbortSignal.timeout(timeoutMs),
+            headers: {
+                authorization: `Bearer ${relayToken()}`,
+                'content-type': 'application/json',
+                // Marks this caller as an agent: the relay drops it to background priority on
+                // the UI lock, behind anyone using the phone (src/http/router.ts ▸ withUiPriority).
+                'x-relay-client': 'mcp',
+                // The relay retries a failed send inside this budget and never past it, so
+                // stating it here is what stops it outliving us — see src/http/services/delivery.ts ▸ sendBudget.
+                'x-client-timeout-ms': String(timeoutMs)
+            },
+            body: opts.body === undefined ? undefined : JSON.stringify(opts.body)
+        });
+    }
+    catch (err) {
+        if (err instanceof DOMException && err.name === 'TimeoutError')
+            throw new Error(`the relay did not answer within ${Math.round(timeoutMs / 1000)}s`);
+        throw new Error(`cannot reach the relay at ${relayBase()} (${err instanceof Error ? err.message : err}). Is it running? \`conductor-remote service status\``);
+    }
+    const payload = await res.json().catch(() => ({}));
+    if (!res.ok) {
+        // 503 is the UI lock refusing a deep queue, and it is worth naming as such: it
+        // means "retry shortly", not "this failed".
+        const busy = res.status === 503 ? ' (Conductor’s UI is busy — retry shortly)' : '';
+        const error = payload && typeof payload === 'object' && 'error' in payload ? payload.error : undefined;
+        throw new Error(`${relayErrorMessage(error, res.status)}${busy}`);
+    }
+    return payload;
+}

package/dist-node/src/mcp/define-tool.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { parseInput } from "../contracts/validation.js";
+/** Export the caller's input shape and validate it before the tool can make an HTTP call. */
+export function defineTool(definition) {
+    const { inputSchema, run, ...metadata } = definition;
+    return {
+        ...metadata,
+        inputSchema: z.toJSONSchema(inputSchema, { io: 'input' }),
+        run: async (args) => run(parseInput(inputSchema, args))
+    };
+}

package/dist-node/src/mcp/tools/agent-options.js

@@ -1,5 +1,7 @@
+import { hasAgentSettings, sessionIdSchema, setAgentOptionsSchema } from "../../contracts/agent-inputs.js";
 import { routes } from "../../routes.js";
 import { need, str } from "../arguments.js";
+import { defineTool } from "../define-tool.js";
 import { WRITE_TIMEOUT_MS } from "../protocol.js";
 export function createListModelsTool(call) {
     return {
@@ -69,45 +71,25 @@ export function createSetDefaultModelTool(call) {
         }
     };
 }
+const setAgentOptionsInputSchema = setAgentOptionsSchema
+    .omit({ workspaceId: true })
+    .extend({
+    session_id: sessionIdSchema,
+    workspace_id: setAgentOptionsSchema.shape.workspaceId
+})
+    .strict();
 export function createSetAgentOptionsTool(call) {
-    return {
+    return defineTool({
         name: 'set_agent_options',
         description: 'Change how a chat’s agent runs: model, reasoning effort, plan mode, fast mode. Conductor keeps these in its composer and nowhere else, so this is the only way to reach them — a prompt cannot. DRIVES THE REAL UI and steals focus for a few seconds. The change is confirmed against Conductor’s database before this answers. Applies to the NEXT turn, so set it before send_prompt, not during one. Ask the user before re-pointing a chat they did not name at a different model.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string' },
-                workspace_id: {
-                    type: 'string',
-                    description: 'Strongly recommended: it is what the relay asserts against before pressing anything.'
-                },
-                model: { type: 'string', description: 'A label from list_models. An unambiguous prefix is enough.' },
-                effort: { type: 'string', enum: ['none', 'low', 'medium', 'high', 'xhigh', 'max', 'ultracode'] },
-                plan: { type: 'boolean', description: 'Conductor’s Plan checkbox.' },
-                fast: {
-                    type: 'boolean',
-                    description: 'Fast mode. Only some models offer it; a missing button is reported, not ignored.'
-                }
-            },
-            required: ['session_id']
-        },
+        inputSchema: setAgentOptionsInputSchema,
         run: async (args) => {
-            const sessionId = need(args, 'session_id');
-            const patch = {
-                model: str(args.model),
-                effort: str(args.effort),
-                plan: typeof args.plan === 'boolean' ? args.plan : undefined,
-                fast: typeof args.fast === 'boolean' ? args.fast : undefined,
-                workspaceId: str(args.workspace_id)
-            };
-            if (patch.model === undefined &&
-                patch.effort === undefined &&
-                patch.plan === undefined &&
-                patch.fast === undefined)
+            const { session_id: sessionId, workspace_id: workspaceId, ...patch } = args;
+            if (!hasAgentSettings(patch))
                 throw new Error('nothing to change — pass at least one of model, effort, plan, fast');
             const data = await call(routes.agent.path(sessionId), {
                 method: routes.agent.method,
-                body: patch,
+                body: { ...patch, workspaceId },
                 timeoutMs: WRITE_TIMEOUT_MS
             });
             if (!data.ok)
@@ -118,5 +100,5 @@ export function createSetAgentOptionsTool(call) {
                 ? `now: ${[s.model, s.claude_effort_level, s.permission_mode, s.fast_mode ? 'fast' : null].filter(Boolean).join(' · ')}`
                 : 'applied';
         }
-    };
+    });
 }

package/dist-node/src/mcp/tools/chat-actions.js

@@ -1,32 +1,26 @@
+import { z } from 'zod';
+import { sendPromptSchema, sessionIdSchema } from "../../contracts/agent-inputs.js";
 import { routes } from "../../routes.js";
 import { parseChatCursor } from "../../transcript/cursor.js";
-import { need, rejectUnknown, str } from "../arguments.js";
+import { need, str } from "../arguments.js";
+import { defineTool } from "../define-tool.js";
 import { plural } from "../formatters.js";
 import { WRITE_TIMEOUT_MS } from "../protocol.js";
+const sendPromptInputSchema = z.strictObject({
+    session_id: sessionIdSchema,
+    workspace_id: sendPromptSchema.shape.workspaceId,
+    text: sendPromptSchema.shape.text
+});
 export function createSendPromptTool(call) {
-    return {
+    return defineTool({
         name: 'send_prompt',
         description: 'Send a prompt into an existing Conductor chat, exactly as typing it on the Mac would. This DRIVES THE REAL UI: it focuses the workspace, selects the chat tab and presses Enter, so it steals focus for a few seconds. If that chat is already working, the message STEERS the running agent rather than starting a new turn — do not use it to poll or test. Ask the user before sending into a chat they did not name.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                session_id: { type: 'string', description: 'The chat to send to (list_chats / search_chats).' },
-                workspace_id: {
-                    type: 'string',
-                    description: 'Its workspace. Strongly recommended: it is what the relay asserts against before typing.'
-                },
-                text: { type: 'string' }
-            },
-            required: ['session_id', 'text'],
-            additionalProperties: false
-        },
+        inputSchema: sendPromptInputSchema,
         run: async (args) => {
-            rejectUnknown(args, ['session_id', 'workspace_id', 'text']);
-            const sessionId = need(args, 'session_id');
-            const text = need(args, 'text');
+            const { session_id: sessionId, workspace_id: workspaceId, text } = args;
             const data = await call(routes.sendPrompt.path(sessionId), {
                 method: routes.sendPrompt.method,
-                body: { text, workspaceId: str(args.workspace_id) },
+                body: { text, workspaceId },
                 timeoutMs: WRITE_TIMEOUT_MS
             });
             if (data.parked)
@@ -35,7 +29,7 @@ export function createSendPromptTool(call) {
                 throw new Error(data.error ?? 'the send did not land');
             return data.warning ? `sent (${data.warning})` : 'sent';
         }
-    };
+    });
 }
 export function createSplitChatTool(call) {
     return {