conductor-remote 1.129.0 → 1.130.1

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

@@ -1,3 +1,4 @@
+import { freezeAutoModelConfig } from "../../agents/auto-model/config.js";
 import { hasAgentSettings, sendPromptSchema } from "../../contracts/agent-inputs.js";
 import { parseInput } from "../../contracts/validation.js";
 import { attachmentPrompt, writeAttachment } from "../../files/attachments.js";
@@ -71,6 +72,47 @@ export function createPromptsRoutes(services) {
                 : (reads.listWorkspaces().find(w => w.active_session_id === sessionId) ?? null);
             if (!ws)
                 return json(req, res, 404, { error: 'workspace for session not found' });
+            const autoJob = services.autoModels?.get(sessionId, ws.id);
+            const useAuto = body.auto === true ||
+                (body.auto !== false && autoJob?.status === 'draft') ||
+                (!!autoJob && ['waiting', 'selecting', 'failed'].includes(autoJob.status));
+            if (useAuto) {
+                if (!services.autoModels || !services.autoModelConfig || !services.inspectAutoTarget)
+                    return json(req, res, 503, { error: 'Auto is unavailable.' });
+                if (body.queue || requestedAgent)
+                    return json(req, res, 400, {
+                        error: 'Auto selects settings for the first message. Omit manual settings and queue mode.'
+                    });
+                try {
+                    if (!autoJob || ['draft', 'cancelled'].includes(autoJob.status)) {
+                        const target = services.inspectAutoTarget({ workspaceId: ws.id, sessionId });
+                        if (target.error)
+                            return json(req, res, 409, { error: target.error });
+                    }
+                    const job = services.autoModels.accept({
+                        workspaceId: ws.id,
+                        sessionId,
+                        text: rawText,
+                        repo: ws.repo_name ?? '',
+                        config: autoJob && !['draft', 'cancelled'].includes(autoJob.status)
+                            ? autoJob.config
+                            : freezeAutoModelConfig(services.autoModelConfig.read(), modelCache.list())
+                    });
+                    return json(req, res, job.status === 'delivered' ? 200 : 202, {
+                        ok: job.status === 'delivered',
+                        parked: job.status !== 'delivered',
+                        strategy: actuator.name,
+                        queued: services.autoModels.pending().find(p => p.sessionId === sessionId)
+                    });
+                }
+                catch (error) {
+                    return json(req, res, 409, {
+                        error: error instanceof Error ? error.message : 'Auto could not accept this prompt.'
+                    });
+                }
+            }
+            if (autoJob?.status === 'draft' && body.auto === false)
+                services.autoModels?.cancel(sessionId, ws.id);
             // 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);
@@ -338,16 +380,26 @@ export function createPromptsRoutes(services) {
         const forgetFirst = routeParam(routes.dismissFirstPrompt, req.method, pathname);
         if (forgetFirst) {
             const workspaceId = forgetFirst;
-            if (!firstPrompts.forget(workspaceId))
-                return json(req, res, 404, { error: 'no pending prompt' });
+            try {
+                if (!services.autoModels?.cancel(undefined, workspaceId) && !firstPrompts.forget(workspaceId))
+                    return json(req, res, 404, { error: 'no pending prompt' });
+            }
+            catch (error) {
+                return json(req, res, 409, { error: error instanceof Error ? error.message : 'Auto is sending.' });
+            }
             return json(req, res, 200, { ok: true });
         }
         // DELETE /api/sessions/:id/prompt — dismiss whatever is parked for this chat
         const forgetParked = routeParam(routes.dismissParkedPrompt, req.method, pathname);
         if (forgetParked) {
             const sessionId = forgetParked;
-            if (!parkedPrompts.forgetSession(sessionId))
-                return json(req, res, 404, { error: 'no parked prompt' });
+            try {
+                if (!services.autoModels?.cancel(sessionId) && !parkedPrompts.forgetSession(sessionId))
+                    return json(req, res, 404, { error: 'no parked prompt' });
+            }
+            catch (error) {
+                return json(req, res, 409, { error: error instanceof Error ? error.message : 'Auto is sending.' });
+            }
             return json(req, res, 200, { ok: true });
         }
         return NOT_HANDLED;

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

@@ -12,6 +12,14 @@ export function createSessionsRoutes(services) {
     const { json, reads, workflowFrozenError, locateChat, modelCache, readBody, applyAgentPatch, actuator, sleep, attachmentHeaderName, readAttachmentBody } = services;
     return async (req, res, url) => {
         const { pathname } = url;
+        const changingAgent = routeParam(routes.agent, req.method, pathname) ?? routeParam(routes.defaultModel, req.method, pathname);
+        if (changingAgent) {
+            const auto = services.autoModels?.get(changingAgent);
+            if (auto && ['selecting', 'waiting', 'failed'].includes(auto.status))
+                return json(req, res, 409, {
+                    error: 'Auto owns the initial settings until this submission is delivered or dismissed.'
+                });
+        }
         // PWA presentation only: preserve both real tabs and all their original messages.
         const joinHistoryOf = routeParam(routes.joinChatHistory, req.method, pathname);
         if (joinHistoryOf) {

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

@@ -29,9 +29,10 @@ export function createStateRoutes(services) {
             // Prompts parked for the lock screen ride the same way, one list per workspace,
             // each entry naming its chat (src/delivery/parked.ts).
             const parked = parkedPrompts.list();
+            const auto = services.autoModels?.pending() ?? [];
             for (const ws of workspaces) {
-                ws.pending_prompt = firstPrompts.get(ws.id);
-                const mine = parked.filter(p => p.workspaceId === ws.id);
+                ws.pending_prompt = firstPrompts.get(ws.id) ?? auto.find(p => p.workspaceId === ws.id && !p.sessionId);
+                const mine = [...parked, ...auto.filter((p) => !!p.sessionId)].filter(p => p.workspaceId === ws.id);
                 if (mine.length)
                     ws.parked_prompts = mine;
             }

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

@@ -47,6 +47,13 @@ export function createWorkflowsRoutes(services) {
                 throw new WorkflowCoordinatorError('workflow_incompatible_relay', `Workflow is disabled because ${orchestrationUnavailableReason()}.`, { status: 409 });
             }
             const request = parseStartWorkflowRequest(await workflowRequestBody(req));
+            if (request.target.kind === 'existing_session') {
+                const auto = services.autoModels?.get(request.target.sessionId, request.target.workspaceId);
+                if (auto && ['waiting', 'selecting', 'failed'].includes(auto.status))
+                    return json(req, res, 409, { error: 'Dismiss the Auto submission before starting Workflow.' });
+                if (auto?.status === 'draft')
+                    services.autoModels?.cancel(request.target.sessionId, request.target.workspaceId);
+            }
             const replay = orchestration.getIdempotentMutation('start_workflow', request.clientId, {
                 objective: request.objective,
                 target: request.target

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

@@ -28,7 +28,9 @@ export function createWorkspacesRoutes(services) {
                 attachWorkflowState([enriched]);
             const sessionRoles = { ...(roles?.sessions ?? {}), ...(enriched?.session_roles ?? {}) };
             return json(req, res, 200, {
-                sessions: reads.listSessions(listSessionsIn),
+                sessions: reads
+                    .listSessions(listSessionsIn)
+                    .map(session => ({ ...session, auto_model: services.autoModels?.state(session.id, listSessionsIn) })),
                 chat_history: services.chatHistory.forWorkspace(listSessionsIn),
                 ...(Object.keys(sessionRoles).length ? { session_roles: sessionRoles } : {})
             });

package/dist-node/src/http/services/auto-model.js

@@ -0,0 +1,108 @@
+import path from 'node:path';
+import { AutoModelConfigStore } from "../../agents/auto-model/config.js";
+import { chooseAutoModel, routingInput } from "../../agents/auto-model/decision.js";
+import { runRouter } from "../../agents/auto-model/provider.js";
+import { AutoModelQueue } from "../../agents/auto-model/queue.js";
+import { roleModelIssues } from "../../agents/roles.js";
+import { stateDir } from "../../config.js";
+import { materializeStagedAttachments } from "../../files/staged-attachments.js";
+import { modelAgentType } from "../../shared.js";
+import { lockBlocked, screenLocked } from "../../writes/guards.js";
+import { uiTurn, withUiPriority } from "../../writes/ui-lock.js";
+export function createAutoModelServices(services) {
+    const { reads, modelCache, delegationStore, workflowOwningSession, firstPrompts, parkedPrompts, applyAgentPatch, deliverPrompt, STAGED_ATTACHMENTS_DIR } = services;
+    const autoModelConfig = new AutoModelConfigStore(path.join(stateDir(), 'auto-model.json'));
+    const received = (job) => !!(job.sessionId &&
+        job.cursor &&
+        reads.deliveryReceiptSince(job.sessionId, job.text, {
+            rowid: job.cursor.rowid,
+            outboxIds: new Set(job.cursor.outboxIds)
+        }));
+    function inspect(job) {
+        const ws = reads.getWorkspace(job.workspaceId);
+        if (!ws)
+            return { ready: false, error: 'The Auto workspace is no longer available.' };
+        const sessions = reads.listSessions(ws.id);
+        const session = job.sessionId
+            ? sessions.find(s => s.id === job.sessionId)
+            : sessions.length === 1
+                ? sessions[0]
+                : undefined;
+        const target = { ready: ws.state === 'ready', worktree: ws.worktree, sessionId: session?.id };
+        if (!session)
+            return {
+                ...target,
+                error: sessions.length > 1 || job.sessionId ? 'The Auto chat is missing or ambiguous.' : undefined
+            };
+        const roles = delegationStore(ws)?.sessionRoles();
+        if (workflowOwningSession(session.id) || roles?.sessions[session.id] || roles?.warning) {
+            return { ...target, error: 'Auto is unavailable in a chat owned by a Workflow or delegation.' };
+        }
+        if (firstPrompts.get(ws.id) || parkedPrompts.list().some(p => p.sessionId === session.id)) {
+            return { ...target, error: 'Resolve this chat’s pending prompt before using Auto.' };
+        }
+        if (session.last_user_message_at ||
+            (session.status && session.status !== 'idle') ||
+            session.background_tasks.length ||
+            reads.deliveryCursor(session.id).outboxIds.size ||
+            reads.getMessages(session.id).entries.some(entry => entry.role === 'user')) {
+            return { ...target, obsolete: true, error: 'Auto is available only before the first message in an idle chat.' };
+        }
+        return target;
+    }
+    const autoModels = new AutoModelQueue(path.join(stateDir(), 'auto-model-prompts'), {
+        inspect,
+        received,
+        locked: async () => (await screenLocked()) === true,
+        cursor: sessionId => {
+            const cursor = reads.deliveryCursor(sessionId);
+            return { rowid: cursor.rowid, outboxIds: [...cursor.outboxIds] };
+        },
+        materialize: (job, worktree) => materializeStagedAttachments(STAGED_ATTACHMENTS_DIR, worktree, job.attachmentIds),
+        choose: (job, worktree) => chooseAutoModel(job.config, routingInput(job.text, job.repo, worktree), (prompt, images, signal) => runRouter(job.config.router, prompt, images, signal)),
+        deliver: (job, current, dispatch) => withUiPriority('background', () => uiTurn(async () => {
+            if (!current())
+                return { ok: false, error: 'Auto cancelled.' };
+            if (received(job))
+                return { ok: true };
+            const target = inspect(job);
+            if (target.error)
+                return { ok: false, error: target.error, cancelled: target.obsolete };
+            const ws = reads.getWorkspace(job.workspaceId);
+            if (!ws || !job.sessionId || !job.decision || !job.cursor)
+                return { ok: false, error: 'Auto’s saved target is incomplete.' };
+            const { model, effort, fast } = job.decision;
+            // A vanished selected profile must remain a visible failure, never a silent reroute.
+            const issues = roleModelIssues({ version: 1, roles: { selected: { model, effort, fast } } }, modelCache.list());
+            if (issues.length)
+                return {
+                    ok: false,
+                    error: 'The saved Auto model is no longer available. Dismiss this submission and choose another model.'
+                };
+            dispatch();
+            const applied = await applyAgentPatch(ws, job.sessionId, {
+                model,
+                effort,
+                fast,
+                ...(modelAgentType(model) === 'claude' ? { plan: false } : {})
+            });
+            if (!applied.ok)
+                return { ok: false, error: applied.error, blocked: lockBlocked(applied.error) };
+            if (received(job))
+                return { ok: true };
+            const fresh = inspect(job);
+            if (fresh.error || !current())
+                return { ok: false, error: fresh.error ?? 'Auto cancelled.', cancelled: fresh.obsolete };
+            const result = await deliverPrompt(ws, job.sessionId, job.text, undefined, false, {
+                rowid: job.cursor.rowid,
+                outboxIds: new Set(job.cursor.outboxIds)
+            });
+            return { ok: result.ok, error: result.error, blocked: lockBlocked(result.error) };
+        }))
+    });
+    services.setAdditionalStagedReferences(() => autoModels
+        .list()
+        .filter(job => !['delivered', 'cancelled'].includes(job.status))
+        .flatMap(job => job.attachmentIds));
+    return { autoModels, autoModelConfig, inspectAutoTarget: inspect };
+}

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

@@ -292,8 +292,12 @@ export function createDeliveryServices(services) {
     /** Unreferenced pre-workspace uploads get one week for an offline device to reconnect. */
     const STAGED_ATTACHMENT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
     const STAGED_ATTACHMENT_SWEEP_MS = 6 * 60 * 60 * 1000;
+    let additionalStagedReferences = () => [];
+    function setAdditionalStagedReferences(read) {
+        additionalStagedReferences = read;
+    }
     function referencedStagedAttachments() {
-        const referenced = new Set();
+        const referenced = new Set(additionalStagedReferences());
         for (const draft of Object.values(readPrefs().drafts)) {
             if (draft.deleted)
                 continue;
@@ -422,6 +426,7 @@ export function createDeliveryServices(services) {
         sendOnce,
         PARKED_ERROR,
         sweepStagedAttachments,
-        STAGED_ATTACHMENT_SWEEP_MS
+        STAGED_ATTACHMENT_SWEEP_MS,
+        setAdditionalStagedReferences
     };
 }

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

@@ -1,3 +1,4 @@
+import { createAutoModelServices } from "./services/auto-model.js";
 import { createBaseServices } from "./services/base.js";
 import { createDelegationsServices } from "./services/delegations.js";
 import { createDeliveryServices } from "./services/delivery.js";
@@ -17,11 +18,13 @@ export function createRelayServices() {
     const delivery = createDeliveryServices({ ...base });
     const delegations = createDelegationsServices({ ...base, ...delivery });
     const workflowState = createWorkflowStateServices({ ...base, ...responses });
+    const autoModel = createAutoModelServices({ ...base, ...delivery, ...workflowState });
     const workflowProbes = createWorkflowProbesServices({ ...base, ...delivery });
     const workflow = createWorkflowServices({ ...base, ...workflowProbes, ...delivery, ...delegations });
     const files = createFilesServices({ ...responses, ...base });
     return {
         ...base,
+        ...autoModel,
         ...responses,
         ...mcp,
         ...voice,

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

@@ -86,6 +86,8 @@ export function createListReposTool(call) {
 }
 const createWorkspaceInputSchema = createWorkspaceSchema
     .omit({
+    // Auto is selected in the PWA; keep this tool's explicit agent settings contract.
+    auto: true,
     send: true,
     sendImmediately: true,
     attachmentIds: true

package/dist-node/src/prefs.js

@@ -32,6 +32,8 @@ function sanitizeAgent(raw) {
     if (!value)
         return {};
     const agent = {};
+    if (typeof value.auto === 'boolean')
+        agent.auto = value.auto;
     if (typeof value.model === 'string' && value.model.length <= MAX_AGENT_LABEL_LENGTH)
         agent.model = value.model;
     if (isAgentEffort(value.effort))

package/dist-node/src/routes.js

@@ -103,6 +103,8 @@ export const routes = {
     pushTest: flat('POST', '/api/push/test'),
     /** Global picker-backed delegated-role definitions. */
     roles: flat('GET', '/api/roles'),
+    autoModelConfig: flat('GET', '/api/auto-model'),
+    updateAutoModelConfig: flat('PATCH', '/api/auto-model'),
     updateRoles: flat('PATCH', '/api/roles'),
     /** Active and failed jobs; optionally filtered with `?workspaceId=`. */
     delegations: flat('GET', '/api/delegations'),

package/dist-node/src/server.js

@@ -7,7 +7,7 @@ import { createRelayServices } from "./http/services.js";
 import { startNotifier } from "./notifications/notify.js";
 import { voicePort } from "./voice/config.js";
 const services = createRelayServices();
-const { cfg, voiceServer, voiceBroker, voiceHistory, orchestration, relayIdentity, recoverUiLease, wakeWorkflows, actuator, firstPrompts, sweepStagedAttachments, STAGED_ATTACHMENT_SWEEP_MS, parkedPrompts, delegationQueue, liveDelegationStores, devServers, reads, sessionPoller } = services;
+const { cfg, voiceServer, voiceBroker, voiceHistory, orchestration, relayIdentity, recoverUiLease, wakeWorkflows, actuator, firstPrompts, autoModels, sweepStagedAttachments, STAGED_ATTACHMENT_SWEEP_MS, parkedPrompts, delegationQueue, liveDelegationStores, devServers, reads, sessionPoller } = services;
 const server = createRelayServer(services);
 server.listen(cfg.port, cfg.host, () => {
     voiceServer.listen(voicePort(), '127.0.0.1', () => {
@@ -51,6 +51,7 @@ server.listen(cfg.port, cfg.host, () => {
     // Pick up any first prompt the previous process was still holding — an auto-update
     // restart lands mid-setup often enough that this is the normal path, not a rare one.
     firstPrompts.start();
+    autoModels.start();
     // New Workspace uploads are host-side so another device can restore their pills.
     // Sweep only week-old directories absent from both a draft and the delivery queue.
     sweepStagedAttachments();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "conductor-remote",
-	"version": "1.129.0",
+	"version": "1.130.1",
 	"type": "module",
 	"packageManager": "yarn@4.15.0",
 	"description": "Phone control panel for local Conductor agents. Reads ride SQLite + git; prompts ride Conductor's own dispatch path.",