conductor-remote 1.115.0 → 1.117.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-Dkiq148q.js"></script>
-		<link rel="stylesheet" crossorigin href="/assets/index-DNLdIfZ2.css">
+		<script type="module" crossorigin src="/assets/index-LAm9X7wv.js"></script>
+		<link rel="stylesheet" crossorigin href="/assets/index-ByTwVInL.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 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:"c0864e9c2073eea6a60e6105a3f60865"},{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-Dkiq148q.js",revision:null},{url:"assets/index-DNLdIfZ2.css",revision:null},{url:"assets/PierrePatch-DGi9B1-s.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:"dab5b44cdb5a4ce59b393d684a242633"},{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-LAm9X7wv.js",revision:null},{url:"assets/index-ByTwVInL.css",revision:null},{url:"assets/PierrePatch-D3_YBIAr.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/delegation-intake.js

@@ -0,0 +1,93 @@
+/** Ordinary-chat delegation intake. All validation precedes persistence or UI work. */
+import { randomUUID } from 'node:crypto';
+import { resolveRole } from "./roles.js";
+import { transcriptThrough } from "./transcript.js";
+function refused(code, message) {
+    return { ok: false, error: { code, message, retryable: false } };
+}
+export function delegationHttpStatus(error) {
+    if (['workspace_not_found', 'session_not_found', 'role_not_found', 'delegation_not_found'].includes(error.code)) {
+        return 404;
+    }
+    if (error.code === 'invalid_request')
+        return 400;
+    if (error.code === 'state_invalid')
+        return 500;
+    return 409;
+}
+export function acceptDelegation(parentSessionId, raw, deps) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return refused('invalid_request', 'delegation must be an object');
+    }
+    const allowed = new Set(['role', 'prompt', 'returnMode', 'throughRowid', 'includeThinking']);
+    const unknown = Object.keys(raw).find(field => !allowed.has(field));
+    if (unknown)
+        return refused('invalid_request', `unknown field: ${unknown}`);
+    const body = raw;
+    const roleName = typeof body.role === 'string' ? body.role.trim() : '';
+    const prompt = typeof body.prompt === 'string' ? body.prompt.trim() : '';
+    if (!/^[a-z][a-z0-9_-]{0,63}$/.test(roleName) || !prompt || prompt.length > 1_000_000) {
+        return refused('invalid_request', 'a valid role and focused prompt are required');
+    }
+    if (body.returnMode !== undefined && body.returnMode !== 'queue' && body.returnMode !== 'steer') {
+        return refused('invalid_request', 'returnMode must be queue or steer');
+    }
+    if (body.throughRowid !== undefined && (!Number.isSafeInteger(body.throughRowid) || body.throughRowid < 1)) {
+        return refused('invalid_request', 'throughRowid must be a positive integer');
+    }
+    if (body.includeThinking !== undefined && typeof body.includeThinking !== 'boolean') {
+        return refused('invalid_request', 'includeThinking must be a boolean');
+    }
+    if (deps.ownsSession(parentSessionId)) {
+        return refused('workflow_required', 'This chat belongs to an active Workflow. Delegate from its root with the workflow_id and current phase_capability.');
+    }
+    const workspaceId = deps.sessionWorkspaceId(parentSessionId);
+    if (!workspaceId)
+        return refused('session_not_found', 'parent chat not found');
+    const workspace = deps.getWorkspace(workspaceId);
+    if (!workspace)
+        return refused('workspace_not_found', 'workspace for parent chat not found');
+    if (!workspace.worktree)
+        return refused('worktree_unavailable', 'worktree path unresolved');
+    const parent = deps.getSession(parentSessionId);
+    if (!parent)
+        return refused('session_not_found', 'parent chat not found in that workspace');
+    if (!parent.agent_type)
+        return refused('provider_unknown', 'the parent chat provider is unknown');
+    const storedRoles = deps.readRoles();
+    if (storedRoles.warning)
+        return refused('state_invalid', storedRoles.warning);
+    const resolved = resolveRole(storedRoles.config, roleName, deps.models());
+    if (!resolved.ok)
+        return { ok: false, error: resolved.error };
+    if (resolved.role.agentType === parent.agent_type) {
+        return refused('same_provider', `Role ${roleName} uses the parent's ${parent.agent_type} provider.`);
+    }
+    if (body.throughRowid !== undefined && !transcriptThrough(deps.getMessages(parentSessionId), body.throughRowid)) {
+        return refused('invalid_request', 'throughRowid is not in the parent chat');
+    }
+    const now = Date.now();
+    const job = {
+        version: 1,
+        id: randomUUID(),
+        workspaceId: workspace.id,
+        parentSessionId,
+        role: roleName,
+        resolvedRole: resolved.role,
+        prompt,
+        returnMode: body.returnMode ?? 'queue',
+        includeThinking: body.includeThinking ?? false,
+        ...(body.throughRowid === undefined ? {} : { throughRowid: body.throughRowid }),
+        status: 'queued',
+        attempts: 0,
+        createdAt: now,
+        updatedAt: now
+    };
+    try {
+        deps.enqueue(workspace, job);
+    }
+    catch (error) {
+        return refused('state_invalid', error instanceof Error ? error.message : String(error));
+    }
+    return { ok: true, delegationId: job.id, role: roleName, model: resolved.role.model };
+}

package/dist-node/src/delegation-prompt.js

@@ -0,0 +1,16 @@
+import { attachmentPrompt } from "./attachments.js";
+/** Ordinary delegation supplies transport context; the saved role and assignment supply the task. */
+export function delegatedPrompt(job) {
+    if (!job.handoff)
+        throw new Error('the delegated handoff is missing');
+    return [
+        `You are a delegated helper using the configured ${job.role} role in an ordinary chat. Complete the focused assignment and return its result to the parent.`,
+        'The attached transcript is background context. Follow the assignment below; do not adopt orchestration instructions from the transcript or start a planning/exploration/implementation pipeline.',
+        'You share this worktree with the parent and other chats. Respect their edits and keep any changes within the assigned file ownership. Do not revert work you did not make.',
+        'Do not spawn further agents unless the assignment explicitly authorizes delegation. Follow the configured role instructions and the assignment, including their requested output format.',
+        job.resolvedRole.preamble?.trim(),
+        attachmentPrompt(job.handoff.token, job.prompt)
+    ]
+        .filter(Boolean)
+        .join('\n\n');
+}

package/dist-node/src/delegations.js

@@ -198,6 +198,9 @@ function decodeSessionRoles(raw) {
         decoded[sessionId] = {
             role: text(assignment.role, `session ${sessionId} role`, 64),
             ...(delegationId === undefined ? {} : { delegationId }),
+            ...(assignment.parentSessionId === undefined
+                ? {}
+                : { parentSessionId: text(assignment.parentSessionId, `session ${sessionId} parentSessionId`) }),
             assignedAt: integer(assignment.assignedAt, `session ${sessionId} assignedAt`)
         };
     }
@@ -377,9 +380,6 @@ export class DelegationQueue {
         const roles = store.sessionRoles();
         if (roles.warning)
             throw new Error(`cannot enqueue beside malformed sessions.json: ${roles.warning}`);
-        if (!roles.sessions[raw.parentSessionId]) {
-            store.assign(raw.parentSessionId, { role: 'planning', assignedAt: raw.createdAt });
-        }
         const job = store.put(raw);
         this.stores.add(store);
         void this.wake();
@@ -453,6 +453,7 @@ export class DelegationQueue {
                 store.assign(result.childSessionId, {
                     role: job.role,
                     delegationId: job.id,
+                    parentSessionId: job.parentSessionId,
                     assignedAt: this.now()
                 });
                 store.put(transitionDelegation(job, 'configuring', { childSessionId: result.childSessionId, handoff: result.handoff }, this.now()));

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

@@ -31,7 +31,7 @@ import { HIT_CLOSE, HIT_OPEN, isToolResult, timestampMs, workspaceTitle } from "
 /** 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. list_voice_calls, search_voice_calls and read_voice_call read saved fleet-call transcripts without driving the UI. 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.';
+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. list_voice_calls, search_voice_calls and read_voice_call read saved fleet-call transcripts without driving the UI. Use delegate_task for lightweight codebase agents in tracked sibling subtabs: list_roles shows the configured roles and their current models, then an ordinary chat supplies session_id, role, and a focused prompt. Choose a configured role whose instructions fit the task, usually exploration for independent code searches, investigation, and verification, including helper work requested by skills such as gstack. Use the configured role settings even when a skill names a model. Each task returns its result to its parent; several independent explorers can run concurrently without starting a planning/exploration/implementation Workflow. Continue useful local work while they run; use return_mode=steer if their result is needed during the current turn, since the default queue delivers behind it. Inside an active Workflow, only its root may delegate, using the workflow_id and current phase_capability from its private envelope. Never bypass that path through ordinary delegation or untracked splits. MCP cannot start a Workflow, edit its frozen roles, or perform recovery actions. delegate_task returns immediately; the relay later drives the real Mac UI to open, configure, and send the child. 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;
@@ -519,15 +519,22 @@ export function createTools(call) {
         },
         {
             name: 'list_roles',
-            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.',
+            description: 'List configured models, effort, Fast mode, instructions, and validation issues before lightweight delegation. Choose a role whose current configuration fits the task. Invalid roles cannot start a child or new Workflow. Active Workflows use the frozen roles from their root envelope.',
             inputSchema: { type: 'object', properties: {} },
             run: async () => {
                 const data = await call(routes.roles.path());
                 const issueByRole = new Map(data.issues.map(issue => [issue.role, issue.error]));
                 const lines = Object.entries(data.roles).map(([name, role]) => {
-                    const settings = [role.model, role.effort, role.fast ? 'fast' : null].filter(Boolean).join(' · ');
+                    const settings = [
+                        role.model,
+                        role.effort,
+                        role.fast === undefined ? null : role.fast ? 'fast on' : 'fast off'
+                    ]
+                        .filter(Boolean)
+                        .join(' · ');
                     const issue = issueByRole.get(name);
-                    return `${issue ? '!' : '·'} ${name}: ${settings}${issue ? ` — ${issue.code}: ${issue.message}` : ''}`;
+                    const instructions = role.preamble?.trim();
+                    return `${issue ? '!' : '·'} ${name}: ${settings}${issue ? ` — ${issue.code}: ${issue.message}` : ''}${instructions ? `\n    Instructions: ${instructions.replaceAll('\n', '\n    ')}` : ''}`;
                 });
                 if (data.warning)
                     lines.unshift(`! ${data.warning}`);
@@ -536,23 +543,66 @@ export function createTools(call) {
         },
         {
             name: 'delegate_task',
-            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.',
+            description: 'Spawn one lightweight tracked sibling chat in a subtab. From an ordinary chat, pass session_id, a valid role from list_roles, and a focused prompt. Choose a configured role whose instructions fit the task; repeat for independent questions so children can run concurrently. This does not start a Workflow or turn the parent into a planner. The role must use a different provider than the parent. The child follows the configured preamble and assignment, receives a transcript attachment, and returns its result. Queue mode delivers behind the current turn by default; use steer if the result is needed during this turn. Keep working and integrate the result. For an active Workflow, only its root may call with workflow_id and current phase_capability from the private envelope; its frozen settings, role restrictions, transcript boundary, and Baton routing apply. Returns immediately with a delegation id; list_delegations observes progress. The relay later opens/configures/sends the child through the Mac UI. This tool cannot start or recover a Workflow.',
             inputSchema: {
                 type: 'object',
                 properties: {
-                    workflow_id: { type: 'string', description: 'Workflow id from the private root envelope.' },
+                    workflow_id: { type: 'string', description: 'Active Workflow only: id from the private root envelope.' },
                     phase_capability: {
                         type: 'string',
                         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.' }
+                    session_id: { type: 'string', description: 'Parent chat id; an active Workflow requires its root session.' },
+                    role: { type: 'string', description: 'Configured role name. Workflows allow exploration or implementation.' },
+                    prompt: {
+                        type: 'string',
+                        description: 'The independent question or implementation brief, including file ownership for edits.'
+                    },
+                    return_mode: {
+                        type: 'string',
+                        enum: ['queue', 'steer'],
+                        description: 'Ordinary chats only. Queue the Baton behind this turn (default), or steer it into a running turn.'
+                    },
+                    through: {
+                        type: 'string',
+                        description: 'Ordinary chats only. Optional read_chat cursor bounding the transcript handoff.'
+                    },
+                    include_thinking: {
+                        type: 'boolean',
+                        description: 'Ordinary chats only. Include parent reasoning in the handoff (default false).'
+                    }
                 },
-                required: ['workflow_id', 'phase_capability', 'session_id', 'role', 'prompt'],
+                required: ['session_id', 'role', 'prompt'],
                 additionalProperties: false
             },
             run: async (args) => {
+                if (!Object.hasOwn(args, 'workflow_id') && !Object.hasOwn(args, 'phase_capability')) {
+                    rejectUnknown(args, ['session_id', 'role', 'prompt', 'return_mode', 'through', 'include_thinking']);
+                    const sessionId = need(args, 'session_id');
+                    if (args.return_mode !== undefined && args.return_mode !== 'queue' && args.return_mode !== 'steer') {
+                        throw new Error('return_mode must be queue or steer');
+                    }
+                    if (args.include_thinking !== undefined && typeof args.include_thinking !== 'boolean') {
+                        throw new Error('include_thinking must be a boolean');
+                    }
+                    const through = args.through === undefined ? undefined : parseChatCursor(need(args, 'through'));
+                    if (through === null)
+                        throw new Error('through must be a read_chat cursor');
+                    const body = {
+                        role: need(args, 'role'),
+                        prompt: need(args, 'prompt'),
+                        ...(args.return_mode === undefined ? {} : { returnMode: args.return_mode }),
+                        ...(through === undefined ? {} : { throughRowid: through }),
+                        ...(args.include_thinking === undefined ? {} : { includeThinking: args.include_thinking })
+                    };
+                    const result = await call(routes.delegateTask.path(sessionId), {
+                        method: routes.delegateTask.method,
+                        body
+                    });
+                    if (!result.ok)
+                        throw new Error(`${result.error.code}: ${result.error.message}`);
+                    return `delegation ${result.delegationId} queued · ${result.role} · ${result.model}`;
+                }
                 rejectUnknown(args, ['workflow_id', 'phase_capability', 'session_id', 'role', 'prompt']);
                 const workflowId = need(args, 'workflow_id');
                 const sessionId = need(args, 'session_id');

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

@@ -29,7 +29,12 @@ export class ModelCache {
         this.entries = this.load();
     }
     list() {
-        return this.entries.map(entry => ({ ...entry, models: [...entry.models] }));
+        return this.entries.map(entry => ({
+            ...entry,
+            models: [...entry.models],
+            ...(entry.snapshotModels ? { snapshotModels: [...entry.snapshotModels] } : {}),
+            ...(entry.selections ? { selections: entry.selections.map(selection => ({ ...selection })) } : {})
+        }));
     }
     /** The newest live picker read wins when upgrading from caches that disagree. */
     defaultModel() {
@@ -50,6 +55,7 @@ export class ModelCache {
             models: next,
             defaultModel: selectedDefault,
             snapshotAt: now,
+            snapshotModels: next,
             updatedAt: now
         };
         this.entries = [...this.entries.filter(existing => existing.agentType !== key), entry]
@@ -61,16 +67,29 @@ export class ModelCache {
     rememberModel(agentType, model) {
         if (!model)
             return;
+        const selected = clean([model])[0];
+        if (!selected)
+            return;
         const key = group(agentType ?? '');
         const current = this.entries.find(entry => entry.agentType === key);
+        const now = Date.now();
+        const selections = current?.selections ??
+            (current?.snapshotAt == null
+                ? (current?.models ?? []).map(model => ({ model, selectedAt: current?.updatedAt ?? now }))
+                : []);
         const entry = {
             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()
+            snapshotAt: current?.snapshotAt ?? null,
+            ...(current?.snapshotAt == null ? {} : { snapshotModels: current.snapshotModels ?? [...current.models] }),
+            selections: [
+                ...selections.filter(selection => selection.model !== selected),
+                { model: selected, selectedAt: now }
+            ],
+            updatedAt: now
         };
         this.entries = [...this.entries.filter(existing => existing.agentType !== key), entry].sort((a, b) => a.agentType.localeCompare(b.agentType));
         this.save();
@@ -103,6 +122,21 @@ export class ModelCache {
                     models: clean(entry.models.filter((model) => typeof model === 'string')),
                     defaultModel: typeof entry.defaultModel === 'string' ? clean([entry.defaultModel])[0] || undefined : undefined,
                     ...(snapshotAt === undefined ? {} : { snapshotAt }),
+                    ...(Array.isArray(entry.snapshotModels)
+                        ? {
+                            snapshotModels: clean(entry.snapshotModels.filter((model) => typeof model === 'string'))
+                        }
+                        : {}),
+                    ...(Array.isArray(entry.selections)
+                        ? {
+                            selections: entry.selections.flatMap(selection => {
+                                if (typeof selection?.model !== 'string' || !Number.isFinite(selection.selectedAt))
+                                    return [];
+                                const model = clean([selection.model])[0];
+                                return model ? [{ model, selectedAt: selection.selectedAt }] : [];
+                            })
+                        }
+                        : {}),
                     updatedAt: Number.isFinite(entry.updatedAt) ? entry.updatedAt : 0
                 };
             })

package/dist-node/src/roles.js

@@ -9,7 +9,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { stateDir } from "./config.js";
-import { modelAgentType, modelCatalogIncludes, modelPickerLabel, newestModelSnapshot } from "./shared.js";
+import { currentModelCatalog, modelAgentType, modelPickerLabel } from "./shared.js";
 export { newestModelSnapshot } from "./shared.js";
 const EFFORTS = new Set(['none', 'low', 'medium', 'high', 'xhigh', 'max', 'ultracode']);
 const ROLE_NAME = /^[a-z][a-z0-9_-]{0,63}$/;
@@ -126,12 +126,12 @@ function controlIssue(name, role, agentType) {
 /** Picker validation stays separate from shape decoding so a vanished model remains editable. */
 export function roleModelIssues(config, groups) {
     const issues = [];
-    const snapshot = newestModelSnapshot(groups);
+    const models = currentModelCatalog(groups);
     for (const [name, role] of Object.entries(config.roles)) {
-        if (!snapshot || !modelCatalogIncludes(role.model, [snapshot])) {
+        if (!models.includes(modelPickerLabel(role.model))) {
             issues.push({
                 role: name,
-                error: issue('model_missing', `Role ${name} needs an exact model from Conductor's newest picker snapshot; update it in the role editor.`)
+                error: issue('model_missing', `Role ${name} needs an exact model from Conductor's current picker catalog; update it in the role editor.`)
             });
             continue;
         }
@@ -151,14 +151,14 @@ export function roleModelIssues(config, groups) {
 }
 /** Resolve and freeze the provider encoded by an exact cached picker label. */
 export function resolveRole(config, name, groups) {
-    const role = config.roles[name];
-    if (!role)
+    if (!Object.hasOwn(config.roles, name)) {
         return { ok: false, error: issue('role_not_found', `Unknown delegated role ${name}.`) };
-    const snapshot = newestModelSnapshot(groups);
-    if (!snapshot || !modelCatalogIncludes(role.model, [snapshot])) {
+    }
+    const role = config.roles[name];
+    if (!currentModelCatalog(groups).includes(modelPickerLabel(role.model))) {
         return {
             ok: false,
-            error: issue('model_missing', `Role ${name} needs an exact model from Conductor's newest picker snapshot; update it in the role editor.`)
+            error: issue('model_missing', `Role ${name} needs an exact model from Conductor's current picker catalog; update it in the role editor.`)
         };
     }
     const agentType = modelAgentType(role.model);

package/dist-node/src/routes.js

@@ -162,7 +162,7 @@ export const routes = {
     uploadAttachment: param('POST', '/api/sessions/:sessionId/attachments'),
     /** Copy a chat into a fresh tab beside it, as a Conductor attachment (src/attachments.ts). */
     splitChat: param('POST', '/api/sessions/:sessionId/split'),
-    /** Legacy intake retained only to reject new ordinary-chat delegation after migration. */
+    /** Lightweight tracked delegation from a chat outside an active Workflow. */
     delegateTask: param('POST', '/api/sessions/:sessionId/delegate'),
     /** Dismiss a prompt parked behind the lock screen (src/parked.ts). */
     dismissParkedPrompt: param('DELETE', '/api/sessions/:sessionId/prompt')

package/dist-node/src/server.js

@@ -11,6 +11,8 @@ import { attachChangeStats } from "./change-stats.js";
 import { isDefaultEffortLevel, readDefaultEfforts, writeDefaultEfforts } from "./conductor-settings.js";
 import { loadConfig, stateDir } from "./config.js";
 import { ConductorDb } from "./db.js";
+import { acceptDelegation, delegationHttpStatus } from "./delegation-intake.js";
+import { delegatedPrompt } from "./delegation-prompt.js";
 import { DelegationQueue, DelegationStore } from "./delegations.js";
 import { DevServerController } from "./dev-server.js";
 import { isAllowedPreviewPath, parseFileReference, parseImageReference } from "./file-preview.js";
@@ -855,13 +857,6 @@ async function configureDelegation(job) {
     }
     return { ok: true };
 }
-function delegatedPrompt(job) {
-    const handoff = job.handoff;
-    if (!handoff)
-        throw new Error('the delegated handoff is missing');
-    const task = attachmentPrompt(handoff.token, job.prompt);
-    return job.resolvedRole.preamble?.trim() ? `${job.resolvedRole.preamble.trim()}\n\n${task}` : task;
-}
 async function sendDelegation(job) {
     const ws = reads.getWorkspace(job.workspaceId);
     if (!ws)
@@ -1208,9 +1203,6 @@ function workflowFrozenError(sessionId) {
         }
     };
 }
-function intakeError(code, message, retryable = false) {
-    return { ok: false, error: { code, message, retryable } };
-}
 function workflowHttpError(error) {
     if (error instanceof WorkflowRequestError || error instanceof WorkflowGuardError) {
         return { status: error.status, error: { code: error.code, message: error.message, retryable: false } };
@@ -2445,7 +2437,7 @@ const server = http.createServer(async (req, res) => {
                 });
                 return json(req, res, 202, { workflow: accepted.workflow });
             }
-            // POST /api/workflows/:id/delegations — the sole agent mutation. The
+            // POST /api/workflows/:id/delegations — managed delegation. The
             // capability, exact root, frozen role, and phase barrier are checked together.
             const workflowDelegation = routeParam(routes.workflowDelegation, req.method, pathname);
             if (workflowDelegation) {
@@ -3565,7 +3557,37 @@ const server = http.createServer(async (req, res) => {
             }
             const delegateFrom = routeParam(routes.delegateTask, req.method, pathname);
             if (delegateFrom) {
-                return json(req, res, 409, intakeError('workflow_required', 'delegate_task is available only inside a UI-authorized Workflow.'));
+                if (!orchestration.writable) {
+                    throw new WorkflowCoordinatorError('workflow_incompatible_relay', orchestrationUnavailableReason(), {
+                        status: 409
+                    });
+                }
+                let body;
+                try {
+                    body = JSON.parse((await readBody(req)) || '{}');
+                }
+                catch {
+                    return json(req, res, 400, {
+                        ok: false,
+                        error: { code: 'invalid_request', message: 'delegation must be valid JSON', retryable: false }
+                    });
+                }
+                const result = acceptDelegation(delegateFrom, body, {
+                    ownsSession: sessionId => workflowOwningSession(sessionId) !== null,
+                    sessionWorkspaceId: sessionId => reads.sessionWorkspaceId(sessionId),
+                    getSession: sessionId => reads.getSession(sessionId),
+                    getWorkspace: workspaceId => reads.getWorkspace(workspaceId),
+                    getMessages: sessionId => reads.getMessages(sessionId).entries,
+                    readRoles: () => roleStore.read(),
+                    models: () => modelCache.list(),
+                    enqueue: (workspace, job) => {
+                        const store = delegationStore(workspace);
+                        if (!store)
+                            throw new Error('worktree path unresolved');
+                        delegationQueue.enqueue(store, job);
+                    }
+                });
+                return json(req, res, result.ok ? 202 : delegationHttpStatus(result.error), result);
             }
             // POST /api/sessions/:id/prompt { text, agent? } — ordinary staged settings
             // are applied before the prompt so the two cannot come apart.