conductor-remote 1.129.0 → 1.130.0

package/dist-node/src/agents/auto-model/queue.js

@@ -0,0 +1,266 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { atomicJson } from "./config.js";
+const pending = (job) => ['selecting', 'waiting', 'failed'].includes(job.status);
+/** One durable file per target; a process lease also keeps dev and installed relays from routing twice. */
+export class AutoModelQueue {
+    running = false;
+    now;
+    directory;
+    deps;
+    constructor(directory, deps) {
+        this.directory = directory;
+        this.deps = deps;
+        this.now = deps.now ?? Date.now;
+        fs.mkdirSync(directory, { recursive: true });
+    }
+    file(job) {
+        return path.join(this.directory, `${job.id}.json`);
+    }
+    list() {
+        return fs
+            .readdirSync(this.directory)
+            .filter(name => /^[a-f0-9]{64}\.json$/.test(name))
+            .map(name => {
+            const job = JSON.parse(fs.readFileSync(path.join(this.directory, name), 'utf8'));
+            if (!job.id || !job.config || typeof job.text !== 'string')
+                throw new Error('An Auto submission could not be read.');
+            return job;
+        });
+    }
+    get(sessionId, workspaceId) {
+        return this.list().find(job => (sessionId && job.sessionId === sessionId) || (workspaceId && job.workspaceId === workspaceId && !job.sessionId));
+    }
+    state(sessionId, workspaceId) {
+        const job = this.get(sessionId, workspaceId);
+        return (job && { status: job.status, decision: job.status === 'cancelled' ? undefined : job.decision, error: job.error });
+    }
+    pending() {
+        return this.list()
+            .filter(pending)
+            .map(job => ({
+            workspaceId: job.workspaceId,
+            sessionId: job.sessionId,
+            text: job.text,
+            createdAt: job.createdAt,
+            status: job.status === 'failed' ? 'failed' : 'waiting',
+            attempts: job.attempts,
+            reason: job.reason,
+            error: job.error,
+            autoModel: true,
+            agent: job.decision && { model: job.decision.model, effort: job.decision.effort, fast: job.decision.fast }
+        }));
+    }
+    accept(input) {
+        const existing = this.get(input.sessionId, input.workspaceId);
+        if (existing && existing.status !== 'draft' && existing.status !== 'cancelled') {
+            if (existing.text !== input.text)
+                throw new Error('This chat already has an Auto submission. Dismiss it before sending another.');
+            if (existing.status === 'failed') {
+                existing.status = 'waiting';
+                existing.attempts = 0;
+                existing.earlyAttempts = 0;
+                existing.lastAttemptAt = undefined;
+                existing.error = undefined;
+                existing.reason = 'Retrying with the saved model choice';
+                this.save(existing);
+            }
+            return existing;
+        }
+        const job = {
+            ...input,
+            config: structuredClone(input.config),
+            id: existing?.id ??
+                crypto
+                    .createHash('sha256')
+                    .update(`${input.workspaceId}:${input.sessionId ?? 'first'}`)
+                    .digest('hex'),
+            attachmentIds: input.attachmentIds ?? [],
+            sendImmediately: input.sendImmediately !== false,
+            createdAt: Math.max(this.now(), (existing?.createdAt ?? 0) + 1),
+            attempts: 0,
+            earlyAttempts: 0,
+            status: input.text ? 'waiting' : 'draft',
+            reason: 'Choosing a model…'
+        };
+        if (existing)
+            this.save(job);
+        else {
+            try {
+                fs.writeFileSync(this.file(job), JSON.stringify(job), { flag: 'wx', mode: 0o600 });
+            }
+            catch (error) {
+                if (error.code === 'EEXIST')
+                    return this.accept(input);
+                throw error;
+            }
+        }
+        return job;
+    }
+    cancel(sessionId, workspaceId) {
+        const job = this.get(sessionId, workspaceId);
+        if (!job || !['draft', 'selecting', 'waiting', 'failed'].includes(job.status))
+            return false;
+        const lease = this.readLease(job);
+        if (lease?.dispatching && this.alive(lease.pid))
+            throw new Error('Auto is sending this prompt now. Wait for its receipt before dismissing it.');
+        job.status = 'cancelled';
+        job.reason = 'Auto cancelled';
+        this.save(job);
+        return true;
+    }
+    save(job) {
+        atomicJson(this.file(job), job);
+    }
+    current(job) {
+        const saved = JSON.parse(fs.readFileSync(this.file(job), 'utf8'));
+        return saved.createdAt === job.createdAt && saved.text === job.text && pending(saved) && saved.status !== 'failed';
+    }
+    alive(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (error) {
+            return error.code !== 'ESRCH';
+        }
+    }
+    readLease(job) {
+        try {
+            return JSON.parse(fs.readFileSync(`${this.file(job)}.lock`, 'utf8'));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    lease(job) {
+        const existing = this.readLease(job);
+        if (existing) {
+            if (this.alive(existing.pid))
+                return false;
+            fs.rmSync(`${this.file(job)}.lock`, { force: true });
+        }
+        try {
+            fs.writeFileSync(`${this.file(job)}.lock`, JSON.stringify({ pid: process.pid, dispatching: false }), {
+                flag: 'wx',
+                mode: 0o600
+            });
+            return true;
+        }
+        catch (error) {
+            if (error.code === 'EEXIST')
+                return false;
+            throw error;
+        }
+    }
+    async tick() {
+        if (this.running)
+            return;
+        this.running = true;
+        try {
+            for (const candidate of this.list()) {
+                if (!pending(candidate) || candidate.status === 'failed' || !this.lease(candidate))
+                    continue;
+                const job = JSON.parse(fs.readFileSync(this.file(candidate), 'utf8'));
+                try {
+                    if (this.current(job))
+                        await this.step(job);
+                }
+                catch (error) {
+                    if (this.current(job)) {
+                        job.status = 'failed';
+                        job.error = error instanceof Error ? error.message : 'Auto could not deliver the prompt.';
+                        this.save(job);
+                    }
+                }
+                finally {
+                    fs.rmSync(`${this.file(job)}.lock`, { force: true });
+                }
+            }
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    async step(job) {
+        if (job.sessionId && job.cursor && this.deps.received(job)) {
+            job.status = 'delivered';
+            this.save(job);
+            return;
+        }
+        if (await this.deps.locked()) {
+            if (!this.current(job))
+                return;
+            job.reason = 'Waiting for the Mac to unlock';
+            job.lastAttemptAt = this.now();
+            this.save(job);
+            return;
+        }
+        if (!this.current(job))
+            return;
+        const target = this.deps.inspect(job);
+        if (target.obsolete) {
+            job.status = 'cancelled';
+            job.reason = 'The chat started before Auto could send.';
+            this.save(job);
+            return;
+        }
+        if (target.error)
+            throw new Error(target.error);
+        if (!target.sessionId || !target.worktree || (!target.ready && (!job.sendImmediately || job.earlyAttempts >= 2))) {
+            if (this.now() - (job.lastAttemptAt ?? job.createdAt) > 15 * 60_000)
+                throw new Error('The workspace did not become ready for Auto. Retry when setup finishes.');
+            return;
+        }
+        if (job.lastAttemptAt && this.now() - job.lastAttemptAt < 5000)
+            return;
+        job.sessionId = target.sessionId;
+        this.deps.materialize(job, target.worktree);
+        job.cursor ??= this.deps.cursor(job.sessionId);
+        this.save(job);
+        if (!job.decision) {
+            job.status = 'selecting';
+            job.reason = 'Choosing a model…';
+            this.save(job);
+            const decision = await this.deps.choose(job, target.worktree);
+            if (!this.current(job))
+                return;
+            job.decision = decision;
+            job.status = 'waiting';
+            job.reason = `${decision.model} selected · ${decision.reason}`;
+            this.save(job); // Decision is durable before any UI write.
+        }
+        const result = await this.deps.deliver(job, () => this.current(job), () => {
+            atomicJson(`${this.file(job)}.lock`, { pid: process.pid, dispatching: true });
+        });
+        if (!this.current(job))
+            return;
+        if (result.cancelled)
+            job.status = 'cancelled';
+        else if (result.ok)
+            job.status = 'delivered';
+        else if (result.blocked)
+            job.reason = 'Waiting for the Mac to unlock';
+        else {
+            if (target.ready)
+                job.attempts++;
+            else
+                job.earlyAttempts++;
+            job.error = result.error ?? 'The prompt was not accepted.';
+            job.reason = job.error;
+            if (job.attempts >= 3)
+                job.status = 'failed';
+        }
+        job.lastAttemptAt = this.now();
+        this.save(job);
+    }
+    start() {
+        const tick = () => void this.tick().catch(error => console.error('[auto-model] queue failed:', error));
+        const timer = setInterval(tick, 1000);
+        timer.unref();
+        tick();
+        return () => clearInterval(timer);
+    }
+}

package/dist-node/src/agents/auto-model/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -19,6 +19,7 @@ export const agentPatchSchema = z.object({
 });
 export const setAgentOptionsSchema = agentPatchSchema.extend({ workspaceId: workspaceIdSchema });
 export const sendPromptSchema = z.object({
+    auto: z.boolean().optional().describe('Select a configured model from this pristine chat’s first message.'),
     text: z.string({ error: 'prompt must be a string' }).trim().min(1, 'empty prompt'),
     workspaceId: workspaceIdSchema,
     agent: agentPatchSchema.optional(),
@@ -26,6 +27,7 @@ export const sendPromptSchema = z.object({
     queue: z.boolean().default(false)
 });
 export const createWorkspaceSchema = agentPatchSchema.extend({
+    auto: z.boolean().optional().describe('Use Auto to select the initial model. Omit manual agent settings.'),
     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

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

@@ -2,6 +2,7 @@ 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 { createAutoModelRoutes } from "./routes/auto-model.js";
 import { createCreateWorkspaceRoutes } from "./routes/create-workspace.js";
 import { createFilesRoutes } from "./routes/files.js";
 import { createPromptsRoutes } from "./routes/prompts.js";
@@ -14,6 +15,7 @@ import { createWorkspacesRoutes } from "./routes/workspaces.js";
 export function createRelayServer(services) {
     const { handleMcpHttp, serveStatic, authed, json, PayloadTooLargeError, workflowHttpError } = services;
     const handlers = [
+        createAutoModelRoutes(services),
         createStateRoutes(services),
         createWorkflowsRoutes(services),
         createVoiceRoutes(services),

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

@@ -0,0 +1,26 @@
+import { autoModelIssues, decodeAutoModelConfig } from "../../agents/auto-model/config.js";
+import { isRoute, routes } from "../../routes.js";
+import { NOT_HANDLED } from "../router-types.js";
+export function createAutoModelRoutes(services) {
+    const { autoModelConfig, modelCache, readBody, json } = services;
+    return async (req, res, url) => {
+        if (isRoute(routes.autoModelConfig, req.method, url.pathname)) {
+            const config = autoModelConfig.read();
+            return json(req, res, 200, { config, issues: autoModelIssues(config, modelCache.list()) });
+        }
+        if (isRoute(routes.updateAutoModelConfig, req.method, url.pathname)) {
+            try {
+                const config = decodeAutoModelConfig(JSON.parse(await readBody(req)));
+                const issues = autoModelIssues(config, modelCache.list());
+                if (issues.length)
+                    return json(req, res, 400, { error: issues.join(' ') });
+                autoModelConfig.write(config);
+                return json(req, res, 200, { config, issues: [] });
+            }
+            catch {
+                return json(req, res, 400, { error: 'Invalid Auto settings. Check the profiles, fallback, and router.' });
+            }
+        }
+        return NOT_HANDLED;
+    };
+}

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

@@ -1,3 +1,4 @@
+import { freezeAutoModelConfig } from "../../agents/auto-model/config.js";
 import { createWorkspaceSchema, hasAgentSettings } from "../../contracts/agent-inputs.js";
 import { parseInput } from "../../contracts/validation.js";
 import { stagedAttachments } from "../../files/staged-attachments.js";
@@ -17,6 +18,21 @@ export function createCreateWorkspaceRoutes(services) {
             const body = parseInput(createWorkspaceSchema, input);
             const { attachmentIds, model, effort, plan, fast } = body;
             const requestedAgent = { model, effort, plan, fast };
+            if (body.auto && [body.model, body.effort, body.fast, body.plan].some(value => value !== undefined))
+                return json(req, res, 400, {
+                    error: 'Auto chooses the agent settings. Omit manual model, effort, Fast, and Plan.'
+                });
+            let autoConfig;
+            if (body.auto) {
+                if (!services.autoModels || !services.autoModelConfig || !services.modelCache)
+                    return json(req, res, 503, { error: 'Auto is unavailable.' });
+                try {
+                    autoConfig = freezeAutoModelConfig(services.autoModelConfig.read(), services.modelCache.list());
+                }
+                catch (error) {
+                    return json(req, res, 409, { error: error instanceof Error ? error.message : 'Invalid Auto settings.' });
+                }
+            }
             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' });
@@ -37,7 +53,7 @@ export function createCreateWorkspaceRoutes(services) {
                 return json(req, res, 404, { error: `unknown repo ${body.repo}` });
             if (repo && !repo.root_path)
                 return json(req, res, 409, { error: `${repo.name} has no checkout path` });
-            const { result, created } = await createWorkspaceAndRead(prompt, repo?.root_path ?? null, repo?.name);
+            const { result, created } = await createWorkspaceAndRead(prompt, repo?.root_path ?? null, repo?.name, !!body.auto);
             if (!result.ok)
                 return json(req, res, 502, result);
             if (!created) {
@@ -47,6 +63,25 @@ export function createCreateWorkspaceRoutes(services) {
                     error: 'Conductor didn’t create a workspace — check it’s running and not showing a dialog.'
                 });
             }
+            if (autoConfig && services.autoModels) {
+                const sessions = reads.listSessions(created.id);
+                services.autoModels.accept({
+                    workspaceId: created.id,
+                    sessionId: sessions.length === 1 ? sessions[0].id : undefined,
+                    text: prompt,
+                    repo: created.repo_name ?? body.repo ?? '',
+                    config: autoConfig,
+                    attachmentIds,
+                    sendImmediately: body.sendImmediately
+                });
+                return json(req, res, 200, {
+                    ok: true,
+                    workspaceId: created.id,
+                    workspace: created,
+                    pendingPrompt: prompt || undefined,
+                    sent: false
+                });
+            }
             // Return as soon as the row exists (~2s) — waiting for delivery would block the
             // request through Conductor's whole setup, measured at 30s+ on a real repo and
             // past any budget a phone should hold a request open for. The queue delivers on

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
     };
 }