conductor-remote 1.106.3 → 1.108.0

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-BiWQQKon.js"></script>
-		<link rel="stylesheet" crossorigin href="/assets/index-BfTQtpd5.css">
+		<script type="module" crossorigin src="/assets/index-DWbWwEOp.js"></script>
+		<link rel="stylesheet" crossorigin href="/assets/index-DM7eCDXg.css">
 	<link rel="manifest" href="/manifest.webmanifest"></head>
 	<body>
 		<div id="root"></div>

package/dist/licenses/vscode-seti.txt

@@ -0,0 +1,48 @@
+VS Code Seti file icon theme
+Source: https://github.com/microsoft/vscode/tree/main/extensions/theme-seti
+
+MIT License
+
+Copyright (c) 2015 - present Microsoft Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+The theme incorporates Seti UI:
+https://github.com/jesseweed/seti-ui
+
+Copyright (c) 2014 Jesse Weed
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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:"e7ef44deca46c0539e6ff7bba5eb815e"},{url:"index.html",revision:"b43f5a48bcca63e18b6da382760d00ce"},{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-BiWQQKon.js",revision:null},{url:"assets/index-BfTQtpd5.css",revision:null},{url:"assets/PierrePatch-CEuLSHL_.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:"e7ef44deca46c0539e6ff7bba5eb815e"},{url:"index.html",revision:"991cad8015a1f151f99868cf55ba55dc"},{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-DWbWwEOp.js",revision:null},{url:"assets/index-DM7eCDXg.css",revision:null},{url:"assets/PierrePatch-DF-STc4J.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/logbuf.js

@@ -21,6 +21,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import util from 'node:util';
+import { scrubWorkflowSecrets } from "./shared.js";
 /** Kept small enough that a phone on a slow link can pull the whole thing; ~a day of a quiet relay. */
 const CAPACITY = 600;
 /** One AppleScript failure can carry a long stack; keep a single entry from crowding out the rest. */
@@ -60,7 +61,7 @@ export function installLogCapture() {
     const wrap = (level, original) => {
         return (...args) => {
             const at = new Date();
-            const text = util.format(...args);
+            const text = scrubWorkflowSecrets(util.format(...args));
             push(level, text, at.getTime());
             original(prefixed(text, level, at));
         };
@@ -142,8 +143,8 @@ export function tailLogFile(name, limit) {
  */
 export function redactSecrets(text, token) {
     const masked = token ? text.split(token).join('<token>') : text;
-    return masked
+    return scrubWorkflowSecrets(masked
         .replace(/\bsk-[A-Za-z0-9_-]{8,}/g, '<openai-key>')
         .replace(/\bwhsec_[A-Za-z0-9+/=_-]{8,}/g, '<webhook-secret>')
-        .replace(/(token=)[^\s&"'`]+/gi, '$1<token>');
+        .replace(/(token=)[^\s&"'`]+/gi, '$1<token>'));
 }

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

@@ -14,11 +14,11 @@
  *
  * Every tool is an HTTP call to the relay, injected as `call`, and that is the
  * load-bearing decision rather than a convenience. Conductor has one shared window,
- * so the only thing that makes writes safe is `writes.ts` ▸ `uiTurn`, and that lock is
- * *process-local*. A tool that drove AppleScript itself would sit outside it, and two
- * agents focusing different workspaces would land each other's prompts — the exact
- * failure every fail-closed assertion cannot catch. Routed through the relay, the
- * phone, both delivery queues and every agent share one lock.
+ * so the only thing that makes writes safe is `writes.ts` ▸ `uiTurn`, backed by the
+ * coordinator's relay-shared mutex. A tool that drove AppleScript itself would sit
+ * outside it, and two agents focusing different workspaces would land each other's
+ * prompts — the exact failure every fail-closed assertion cannot catch. Routed through
+ * the relay, the phone, delivery queues and every agent share the same gate.
  *
  * The in-relay transport calls the relay's own API over loopback rather than reaching
  * into `reads`/`writes` directly. That is a sub-millisecond hop against a 1000-line
@@ -27,11 +27,11 @@
  */
 import { chatCursor, parseChatCursor } from "./chat-cursor.js";
 import { routes } from "./routes.js";
-import { agentTypeCanExposeEffort, agentTypeCanExposeFastMode, HIT_CLOSE, HIT_OPEN, isToolResult, modelAgentType, timestampMs, workspaceTitle } from "./shared.js";
+import { HIT_CLOSE, HIT_OPEN, isToolResult, timestampMs, workspaceTitle } from "./shared.js";
 /** Versions we know how to speak. The client's choice wins when we know it. */
 export const PROTOCOL_VERSIONS = ['2025-06-18', '2025-03-26', '2024-11-05'];
 export const SERVER_INFO = { name: 'conductor-remote', version: '1' };
-export const INSTRUCTIONS = 'Drives local Conductor agents through the conductor-remote relay. search_chats and read_chat reach archived workspaces, which is where most finished work lives. delegate_task later drives the real Mac UI and launches another agent through a persisted cross-provider queue; use it only when the user explicitly asked for delegation. It never uses Conductor Plan mode. create_workspace opens its workspace link without direct UI control; requested agent settings and the first prompt are applied later through Conductor’s UI. Its workflow option is itself an explicit delegation request: the configured planning role owns the root chat and may use delegate_task, still in ordinary chat mode and never Plan mode. plan_usage, dev_server status, dismiss_prompt, keep_awake and relay_logs touch no UI. Use dev_server instead of launching a long-lived development server from a shell: its start/stop actions use Conductor’s configured Run task, drive the real Mac UI and steal focus for a few seconds. send_prompt, split_chat, stop_turn, close_chat, set_agent_options, set_default_model, a live list_models call, set_workspace_status and archive_workspace also drive the real Mac UI and steal focus for a few seconds — confirm with the user before using them on a chat or workspace they did not name. archive_workspace also deletes the worktree and stops whatever is running there.';
+export const INSTRUCTIONS = 'Drives local Conductor agents through the conductor-remote relay. search_chats and read_chat reach archived workspaces, which is where most finished work lives. delegate_task operates only inside a Workflow already authorized from the phone: the current root envelope supplies its workflow id and phase capability, and the relay later drives the real Mac UI to launch the tracked child. MCP cannot start a Workflow, edit its frozen roles, or perform recovery actions. create_workspace opens its workspace link without direct UI control; requested agent settings and the first prompt are applied later through Conductor’s UI. plan_usage, dev_server status, dismiss_prompt, keep_awake and relay_logs touch no UI. Use dev_server instead of launching a long-lived development server from a shell: its start/stop actions use Conductor’s configured Run task, drive the real Mac UI and steal focus for a few seconds. send_prompt, split_chat, stop_turn, close_chat, set_agent_options, set_default_model, a live list_models call, set_workspace_status and archive_workspace also drive the real Mac UI and steal focus for a few seconds — confirm with the user before using them on a chat or workspace they did not name. archive_workspace also deletes the worktree and stops whatever is running there.';
 /** Reads are quick; a UI write is measured in tens of seconds (writes.ts ▸ SEND_ATTEMPT_MS). */
 export const READ_TIMEOUT_MS = 10_000;
 export const WRITE_TIMEOUT_MS = 75_000;
@@ -137,6 +137,12 @@ function need(args, key) {
         throw new Error(`${key} is required`);
     return v;
 }
+function rejectUnknown(args, allowed) {
+    const accepted = new Set(allowed);
+    const unknown = Object.keys(args).filter(key => !accepted.has(key));
+    if (unknown.length)
+        throw new Error(`unknown ${unknown.length === 1 ? 'field' : 'fields'}: ${unknown.join(', ')}`);
+}
 /** Build the tool set against a given relay transport. */
 export function createTools(call) {
     return [
@@ -371,7 +377,7 @@ export function createTools(call) {
         },
         {
             name: 'list_roles',
-            description: 'List the relay’s picker-backed cross-provider roles. A role marked invalid cannot be delegated until its exact model is selected. Delegated roles never enable Conductor Plan mode.',
+            description: 'List the relay’s picker-backed cross-provider roles. A role marked invalid cannot be used by a new Workflow until its exact model is selected. Active Workflows keep their frozen snapshot when this configuration changes.',
             inputSchema: { type: 'object', properties: {} },
             run: async () => {
                 const data = await call(routes.roles.path());
@@ -386,109 +392,41 @@ export function createTools(call) {
                 return lines.join('\n') || 'no delegated roles are configured';
             }
         },
-        {
-            name: 'set_role',
-            description: 'Set one cross-provider delegated role using an exact label from list_models. Effort and Fast are available only when Conductor exposes those controls for the selected provider; omit them for Cursor and OpenCode. This changes relay config only and does not drive Conductor. Plan mode is intentionally not a role option.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    role: { type: 'string', description: 'Lowercase role name, for example exploration.' },
-                    model: { type: 'string', description: 'Exact picker label from list_models.' },
-                    effort: {
-                        type: 'string',
-                        enum: ['none', 'low', 'medium', 'high', 'xhigh', 'max', 'ultracode'],
-                        description: 'Optional Claude/Codex reasoning control. Omit for Cursor and OpenCode.'
-                    },
-                    fast: { type: 'boolean', description: 'Optional Claude/Codex Fast control.' },
-                    preamble: { type: 'string', description: 'Optional instructions prepended to each delegated task.' }
-                },
-                required: ['role', 'model']
-            },
-            run: async (args) => {
-                const name = need(args, 'role');
-                const model = need(args, 'model');
-                const effort = str(args.effort);
-                const efforts = ['none', 'low', 'medium', 'high', 'xhigh', 'max', 'ultracode'];
-                if (effort && !efforts.includes(effort))
-                    throw new Error('effort is invalid');
-                const agentType = modelAgentType(model);
-                if (effort && agentType && !agentTypeCanExposeEffort(agentType)) {
-                    throw new Error('the selected provider has no Conductor reasoning control; omit effort');
-                }
-                if (typeof args.fast === 'boolean' && agentType && !agentTypeCanExposeFastMode(agentType)) {
-                    throw new Error('the selected provider has no Conductor Fast control; omit fast');
-                }
-                const current = await call(routes.roles.path());
-                const prior = current.roles[name];
-                const preserveEffort = agentTypeCanExposeEffort(agentType);
-                const preserveFast = agentTypeCanExposeFastMode(agentType);
-                const role = {
-                    model,
-                    ...(effort
-                        ? { effort: effort }
-                        : preserveEffort && prior?.effort
-                            ? { effort: prior.effort }
-                            : {}),
-                    ...(typeof args.fast === 'boolean'
-                        ? { fast: args.fast }
-                        : preserveFast && prior?.fast !== undefined
-                            ? { fast: prior.fast }
-                            : {}),
-                    ...(typeof args.preamble === 'string'
-                        ? { preamble: args.preamble }
-                        : prior?.preamble !== undefined
-                            ? { preamble: prior.preamble }
-                            : {})
-                };
-                const config = { version: 1, roles: { ...current.roles, [name]: role } };
-                const result = await call(routes.updateRoles.path(), {
-                    method: routes.updateRoles.method,
-                    body: config
-                });
-                if (!result.ok)
-                    throw new Error(`${result.error.code}: ${result.error.message}`);
-                return `${name}: ${[role.model, role.effort, role.fast ? 'fast' : null].filter(Boolean).join(' · ')}`;
-            }
-        },
         {
             name: 'delegate_task',
-            description: 'Queue work in a real sibling Conductor chat using a configured role on a different provider. The relay attaches this chat’s transcript, configures the child without Plan mode, sends the task, waits for a stable answer, and returns its Baton here. Returns immediately with a delegation id; use list_delegations to observe it. Only use it when the user asked for cross-provider delegation because the queue launches a real agent and drives the Mac UI after this call returns.',
+            description: 'Queue a tracked child in the Workflow this root already belongs to. Use only the workflow id and current phase capability delivered in the root’s private orchestration envelope. The relay owns the frozen child settings, transcript boundary, Baton routing, and later Mac UI work. Returns immediately with a delegation id; use list_delegations to observe it. This tool cannot start or recover a Workflow.',
             inputSchema: {
                 type: 'object',
                 properties: {
-                    session_id: { type: 'string', description: 'Parent chat that receives the eventual Baton.' },
-                    workspace_id: { type: 'string', description: 'Optional assertion for the parent workspace.' },
-                    role: { type: 'string', description: 'Exact role name from list_roles.' },
-                    prompt: { type: 'string' },
-                    through: { type: 'string', description: 'Optional cursor from read_chat; later rows are omitted.' },
-                    include_thinking: { type: 'boolean', description: 'Include parent reasoning in the handoff (default true).' },
-                    return_mode: {
+                    workflow_id: { type: 'string', description: 'Workflow id from the private root envelope.' },
+                    phase_capability: {
                         type: 'string',
-                        enum: ['queue', 'steer'],
-                        description: 'Queue a new parent turn by default; steer explicitly injects into a running turn.'
-                    }
+                        description: 'Opaque current-phase capability from that same envelope; never copy it elsewhere.'
+                    },
+                    session_id: { type: 'string', description: 'The persisted Workflow root session.' },
+                    role: { type: 'string', enum: ['exploration', 'implementation'] },
+                    prompt: { type: 'string', description: 'The independent question or implementation brief.' }
                 },
-                required: ['session_id', 'role', 'prompt']
+                required: ['workflow_id', 'phase_capability', 'session_id', 'role', 'prompt'],
+                additionalProperties: false
             },
             run: async (args) => {
+                rejectUnknown(args, ['workflow_id', 'phase_capability', 'session_id', 'role', 'prompt']);
+                const workflowId = need(args, 'workflow_id');
                 const sessionId = need(args, 'session_id');
-                const through = str(args.through);
-                const throughRowid = through ? parseChatCursor(through) : undefined;
-                if (through && throughRowid === null)
-                    throw new Error('through must be a cursor returned by read_chat');
-                const returnMode = str(args.return_mode);
-                if (returnMode && returnMode !== 'queue' && returnMode !== 'steer')
-                    throw new Error('return_mode is invalid');
-                const result = await call(routes.delegateTask.path(sessionId), {
-                    method: routes.delegateTask.method,
-                    body: {
-                        role: need(args, 'role'),
-                        prompt: need(args, 'prompt'),
-                        workspaceId: str(args.workspace_id),
-                        throughRowid,
-                        includeThinking: args.include_thinking === undefined ? undefined : args.include_thinking === true,
-                        returnMode
-                    }
+                const role = need(args, 'role');
+                if (role !== 'exploration' && role !== 'implementation')
+                    throw new Error('role is invalid');
+                const body = {
+                    workflow_id: workflowId,
+                    phase_capability: need(args, 'phase_capability'),
+                    session_id: sessionId,
+                    role,
+                    prompt: need(args, 'prompt')
+                };
+                const result = await call(routes.workflowDelegation.path(workflowId), {
+                    method: routes.workflowDelegation.method,
+                    body
                 });
                 if (!result.ok)
                     throw new Error(`${result.error.code}: ${result.error.message}`);
@@ -517,24 +455,6 @@ export function createTools(call) {
                     .join('\n');
             }
         },
-        {
-            name: 'dismiss_delegation',
-            description: 'Dismiss one failed delegation job. Its parent/child chats and role identity remain.',
-            inputSchema: {
-                type: 'object',
-                properties: { delegation_id: { type: 'string' } },
-                required: ['delegation_id']
-            },
-            run: async (args) => {
-                const id = need(args, 'delegation_id');
-                const result = await call(routes.dismissDelegation.path(id), {
-                    method: routes.dismissDelegation.method
-                });
-                if (!result.ok)
-                    throw new Error(`${result.error.code}: ${result.error.message}`);
-                return `dismissed delegation ${result.delegationId}`;
-            }
-        },
         {
             name: 'workspace_diff',
             description: 'The git diff of a live workspace against its target branch, untracked files included.',
@@ -584,7 +504,7 @@ export function createTools(call) {
         },
         {
             name: 'create_workspace',
-            description: 'Start a new Conductor workspace in a repo, optionally with a first prompt and agent settings. The workspace starts from a Conductor deep link, so creation itself needs no Accessibility. The relay applies requested model, effort, plan, and fast settings through Conductor’s UI after it creates the first chat and before it delivers the prompt. Workflow mode instead configures the root from the planning role and explicitly authorizes cross-provider delegate_task calls; it never enables Conductor Plan mode. Returns as soon as the workspace row exists (~2s), before the worktree is built.',
+            description: 'Start an ordinary new Conductor workspace in a repo, optionally with a first prompt and agent settings. The workspace starts from a Conductor deep link, so creation itself needs no Accessibility. The relay applies requested model, effort, plan, and fast settings through Conductor’s UI after it creates the first chat and before it delivers the prompt. This utility cannot start or join a Workflow. Returns as soon as the workspace row exists (~2s), before the worktree is built.',
             inputSchema: {
                 type: 'object',
                 properties: {
@@ -601,10 +521,6 @@ export function createTools(call) {
                     },
                     plan: { type: 'boolean', description: 'Start the first chat in Conductor’s Plan mode.' },
                     fast: { type: 'boolean', description: 'Set Fast mode before the first prompt.' },
-                    workflow: {
-                        type: 'boolean',
-                        description: 'Start the first prompt as a delegated workflow rooted in the configured planning role. Requires a prompt and cannot be combined with model, effort, plan, or fast. Uses ordinary chat mode, never Conductor Plan mode.'
-                    },
                     wait_for_send: {
                         type: 'boolean',
                         description: 'Block until the first prompt is actually delivered (tens of seconds, and longer behind other queued sends). Default false.'
@@ -614,39 +530,31 @@ export function createTools(call) {
                         description: "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."
                     }
                 },
-                required: ['repo']
+                required: ['repo'],
+                additionalProperties: false
             },
             run: async (args) => {
+                rejectUnknown(args, ['repo', 'prompt', 'model', 'effort', 'plan', 'fast', 'wait_for_send', 'send_immediately']);
                 const repo = need(args, 'repo');
                 const prompt = str(args.prompt);
                 const model = str(args.model);
                 const effort = str(args.effort);
                 const plan = typeof args.plan === 'boolean' ? args.plan : undefined;
                 const fast = typeof args.fast === 'boolean' ? args.fast : undefined;
-                const workflow = args.workflow === true;
                 const explicitAgent = model !== undefined || effort !== undefined || plan !== undefined || fast !== undefined;
-                if (workflow && explicitAgent) {
-                    throw new Error('workflow cannot be combined with model, effort, plan, or fast');
-                }
-                if (workflow && !prompt)
-                    throw new Error('workflow needs a first prompt');
-                const configured = workflow || explicitAgent;
+                const configured = explicitAgent;
                 const send = args.wait_for_send === true;
                 // Default on, matching the relay: an omitted flag must never mean "wait".
                 const sendImmediately = args.send_immediately !== false;
                 const data = await call(routes.createWorkspace.path(), {
                     method: routes.createWorkspace.method,
-                    body: workflow
-                        ? { repo, prompt, workflow: true, send, sendImmediately }
-                        : { repo, prompt, model, effort, plan, fast, send, sendImmediately },
+                    body: { repo, prompt, model, effort, plan, fast, send, sendImmediately },
                     timeoutMs: send ? WRITE_TIMEOUT_MS : 30_000
                 });
                 const lines = [
                     `created ${data.workspace ? workspaceTitle(data.workspace) : data.workspaceId}`,
                     `workspace_id: ${data.workspaceId}`
                 ];
-                if (data.workflow)
-                    lines.push(`workflow root: ${data.workflow.role} · ${data.workflow.model}`);
                 if (data.warning)
                     lines.push(`! ${data.warning}`);
                 else if (data.pendingPrompt && !data.sent)
@@ -671,9 +579,11 @@ export function createTools(call) {
                     },
                     text: { type: 'string' }
                 },
-                required: ['session_id', 'text']
+                required: ['session_id', 'text'],
+                additionalProperties: false
             },
             run: async (args) => {
+                rejectUnknown(args, ['session_id', 'workspace_id', 'text']);
                 const sessionId = need(args, 'session_id');
                 const text = need(args, 'text');
                 const data = await call(routes.sendPrompt.path(sessionId), {

package/dist-node/src/model-cache.js

@@ -42,13 +42,15 @@ export class ModelCache {
             return;
         const key = group(agentType ?? '');
         const selectedDefault = clean(defaultModel ? [defaultModel] : [])[0] ?? this.defaultModel();
+        const now = Date.now();
         const entry = {
             agentType: key,
             // A live menu is authoritative. Replacing its group drops a model Conductor
             // stopped offering instead of leaving a stale choice in a later workspace.
             models: next,
             defaultModel: selectedDefault,
-            updatedAt: Date.now()
+            snapshotAt: now,
+            updatedAt: now
         };
         this.entries = [...this.entries.filter(existing => existing.agentType !== key), entry]
             .map(existing => ({ ...existing, defaultModel: selectedDefault ?? existing.defaultModel }))
@@ -65,6 +67,9 @@ export class ModelCache {
             agentType: key,
             models: clean([...(current?.models ?? []), model]),
             defaultModel: current?.defaultModel ?? this.defaultModel(),
+            // Selecting one row proves that row, not the rest of the picker. Preserve
+            // an existing whole-menu observation but mark a brand-new group partial.
+            snapshotAt: current ? (current.snapshotAt === undefined ? current.updatedAt : current.snapshotAt) : null,
             updatedAt: Date.now()
         };
         this.entries = [...this.entries.filter(existing => existing.agentType !== key), entry].sort((a, b) => a.agentType.localeCompare(b.agentType));
@@ -85,12 +90,22 @@ export class ModelCache {
                 return [];
             return parsed
                 .filter(entry => typeof entry?.agentType === 'string' && Array.isArray(entry.models))
-                .map(entry => ({
-                agentType: group(entry.agentType),
-                models: clean(entry.models.filter((model) => typeof model === 'string')),
-                defaultModel: typeof entry.defaultModel === 'string' ? clean([entry.defaultModel])[0] || undefined : undefined,
-                updatedAt: Number.isFinite(entry.updatedAt) ? entry.updatedAt : 0
-            }))
+                .map(entry => {
+                const snapshotAt = Object.hasOwn(entry, 'snapshotAt')
+                    ? entry.snapshotAt === null
+                        ? null
+                        : Number.isFinite(entry.snapshotAt)
+                            ? Number(entry.snapshotAt)
+                            : null
+                    : undefined;
+                return {
+                    agentType: group(entry.agentType),
+                    models: clean(entry.models.filter((model) => typeof model === 'string')),
+                    defaultModel: typeof entry.defaultModel === 'string' ? clean([entry.defaultModel])[0] || undefined : undefined,
+                    ...(snapshotAt === undefined ? {} : { snapshotAt }),
+                    updatedAt: Number.isFinite(entry.updatedAt) ? entry.updatedAt : 0
+                };
+            })
                 .filter(entry => entry.models.length);
         }
         catch {