npm - conductor-remote - Versions diffs - 1.34.3 → 1.35.0 - Mend

conductor-remote 1.34.3 → 1.35.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/assets/{index-Coq6xLXi.js → index-B6uWo65L.js} +10 -10
package/dist/index.html +1 -1
package/dist/sw.js +1 -1
package/dist-node/src/conductor.applescript +92 -5
package/dist-node/src/firstprompt.js +18 -5
package/dist-node/src/parked.js +200 -0
package/dist-node/src/server.js +136 -31
package/dist-node/src/writes.js +38 -0
package/package.json +1 -1

package/dist/index.html CHANGED Viewed

@@ -13,7 +13,7 @@
 		<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-Coq6xLXi.js"></script>
+		<script type="module" crossorigin src="/assets/index-B6uWo65L.js"></script>
 		<link rel="stylesheet" crossorigin href="/assets/index--7Dp2aq8.css">
 	<link rel="manifest" href="/manifest.webmanifest"></head>
 	<body>

package/dist/sw.js CHANGED Viewed

	@@ -1 +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 o=e\|\|("document"in self?document.currentScript.src:"")\|\|location.href;if(s[o])return;let l={};const c=e=>i(e,o),t={module:{uri:o},exports:l,require:c};s[o]=Promise.all(n.map(e=>t[e]\|\|c(e))).then(e=>(r(...e),l))}}define(["./workbox-9c191d2f"],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:"890f6a70e97d144f4d025254e90892a1"},{url:"index.html",revision:"~~7f1d085ec2fac185f0af409edd3d81c5~~"},{url:"assets/workbox-window.prod.es5-BBnX5xw4.js",revision:null},{url:"assets/index-~~Coq6xLXi~~.js",revision:null},{url:"assets/index--7Dp2aq8.css",revision:null},{url:"apple-touch-icon.png",revision:"2b9301416b880d45d4bb655f2600d1f2"},{url:"icon-192.png",revision:"c5e01ac58768627e18ee7b8b6a9239ef"},{url:"icon-512.png",revision:"a40638c55e310312457a621c9a0002c8"},{url:"icon-maskable-512.png",revision:"a40638c55e310312457a621c9a0002c8"},{url:"icon.svg",revision:"c1aee186821798733dd477e69a0ef243"},{url:"manifest.webmanifest",revision:"cf88fbc5755108a7fe0616fa160a8a15"}],{}),e.cleanupOutdatedCaches(),e.registerRoute(new e.NavigationRoute(e.createHandlerBoundToURL("/index.html"),{denylist:[/^\/api\//]}))});
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 o=e\|\|("document"in self?document.currentScript.src:"")\|\|location.href;if(s[o])return;let l={};const t=e=>i(e,o),c={module:{uri:o},exports:l,require:t};s[o]=Promise.all(n.map(e=>c[e]\|\|t(e))).then(e=>(r(...e),l))}}define(["./workbox-9c191d2f"],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:"890f6a70e97d144f4d025254e90892a1"},{url:"index.html",revision:"9ec60d7e8ea0b3e08851fb81b5a4d2de"},{url:"assets/workbox-window.prod.es5-BBnX5xw4.js",revision:null},{url:"assets/index-B6uWo65L.js",revision:null},{url:"assets/index--7Dp2aq8.css",revision:null},{url:"apple-touch-icon.png",revision:"2b9301416b880d45d4bb655f2600d1f2"},{url:"icon-192.png",revision:"c5e01ac58768627e18ee7b8b6a9239ef"},{url:"icon-512.png",revision:"a40638c55e310312457a621c9a0002c8"},{url:"icon-maskable-512.png",revision:"a40638c55e310312457a621c9a0002c8"},{url:"icon.svg",revision:"c1aee186821798733dd477e69a0ef243"},{url:"manifest.webmanifest",revision:"cf88fbc5755108a7fe0616fa160a8a15"}],{}),e.cleanupOutdatedCaches(),e.registerRoute(new e.NavigationRoute(e.createHandlerBoundToURL("/index.html"),{denylist:[/^\/api\//]}))});

package/dist-node/src/conductor.applescript CHANGED Viewed

@@ -73,10 +73,17 @@ on windowProbe()
 	-- count is -1 when macOS refused the read at all. Everything that wants to
 	-- know about windows goes through here, because "returned 0" and "refused to
 	-- answer" are different facts and only this handler still has both.
+	-- The timeout is load-bearing: a wedged Conductor (seen live after a restart
+	-- collided with a relaunch) answers deep links but hangs every AX read, and
+	-- without a cap this call blocks until the node-side ceiling kills the whole
+	-- run as "took too long" — 28s of silence instead of a named cause. 6s turns
+	-- that into error -1712, which refusalReason maps to words.
 	try
-		tell application "System Events" to tell process "Conductor"
-			set winCount to (count of windows)
-		end tell
+		with timeout of 6 seconds
+			tell application "System Events" to tell process "Conductor"
+				set winCount to (count of windows)
+			end tell
+		end timeout
 		return {winCount, 0, ""}
 	on error errText number errNum
 		return {-1, errNum, errText}
@@ -99,6 +106,7 @@ on refusalReason(probe)
 	set errText to item 3 of probe
 	if errText contains "assistive access" then return "the relay is not trusted for Accessibility - grant it to the node binary running the relay in System Settings > Privacy & Security > Accessibility, then restart the relay (upgrading node silently revokes it). macOS said: " & errText
 	if errNum is -1743 or errText contains "Not authorized" then return "macOS blocked the relay from controlling the UI - grant Automation permission to the node binary running the relay in System Settings > Privacy & Security > Automation. macOS said: " & errText
+	if errNum is -1712 then return "Conductor stopped answering UI reads (the Accessibility query timed out) - the app looks wedged even though it may still process deep links. Force-quit Conductor on your Mac and open it again; if it repeats with a healthy Conductor, System Events is stuck - run: killall 'System Events'"
 	return ""
 end refusalReason
@@ -143,14 +151,62 @@ on menuTitles()
 	end try
 end menuTitles
+on serverWindowCount()
+	-- Second opinion from the window server, because the Accessibility tree only
+	-- shows windows on the *current* Space: a full-screen Conductor (which owns its
+	-- own Space) or a Mac sitting at the lock screen reads as "no window" from AX
+	-- while the window very much exists — and acting on the AX answer alone once
+	-- quit a Conductor whose window the user had left open all along.
+	-- CGWindowListCopyWindowInfo(kCGWindowListOptionAll) sees every Space; owner
+	-- name and layer are readable without the Screen Recording grant (only window
+	-- *titles* are gated). Layer 0 keeps it to real windows. -1 = the probe itself
+	-- failed, which callers must treat as "no opinion", never as "no window".
+	-- The bindFunction is the load-bearing part, twice over: as shipped this read
+	-- "$.CFBridgingRelease(...)", which is an *inline*, not a symbol, and calling it
+	-- through JXA segfaults the osascript child (measured: exit 139) — so this probe
+	-- returned -1 on every call and the veto it feeds never once fired. And without
+	-- the rebind, JXA types the CF return as a bare pointer that deepUnwrap answers
+	-- with undefined — same wrong verdict, silently. Rebinding the function to
+	-- return 'id' makes the array real (verified live: 12 windows, behind a lock).
+	set jxa to "ObjC.import('CoreGraphics'); ObjC.bindFunction('CGWindowListCopyWindowInfo', ['id', ['unsigned int', 'unsigned int']]); const w = ObjC.deepUnwrap($.CGWindowListCopyWindowInfo(0, 0)) || []; w.filter(x => x.kCGWindowOwnerName === 'Conductor' && x.kCGWindowLayer === 0).length"
+	try
+		return (do shell script "osascript -l JavaScript -e " & quoted form of jxa) as integer
+	on error
+		return -1
+	end try
+end serverWindowCount
+on screenLocked()
+	-- "locked" / "unlocked" / "unknown". CGSessionCopyCurrentDictionary carries
+	-- CGSSessionScreenIsLocked = 1 while the lock screen is up and omits the key
+	-- entirely when it is not — same stdlib JXA channel as serverWindowCount.
+	-- This matters because the lock screen is the product's home ground: sends
+	-- come from a phone precisely when nobody is at the Mac, so "is the lock up"
+	-- is the difference between a state a restart can fix and one it provably
+	-- makes worse (see the restart gate in activateConductor).
+	-- Same two traps as serverWindowCount: $.CFBridgingRelease segfaults under JXA,
+	-- and without the rebind deepUnwrap reads the CF dictionary as undefined — which
+	-- the "|| {}" then turned into a confident "unlocked" on a locked Mac. The fixed
+	-- probe was verified against a genuinely locked screen (CGSSessionScreenIsLocked
+	-- true, every session key present).
+	set jxa to "ObjC.import('CoreGraphics'); ObjC.bindFunction('CGSessionCopyCurrentDictionary', ['id', []]); const d = ObjC.deepUnwrap($.CGSessionCopyCurrentDictionary()) || {}; d.CGSSessionScreenIsLocked ? 'locked' : 'unlocked'"
+	try
+		return do shell script "osascript -l JavaScript -e " & quoted form of jxa
+	on error
+		return "unknown"
+	end try
+end screenLocked
 on windowEvidence()
 	-- Zero windows is a dead end without knowing what the AX tree *does* show, and
 	-- guessing the next thing to press has already cost a round trip (there is no
 	-- "New Window" item — Conductor is single-window). So the error carries the
-	-- evidence instead: who macOS thinks Conductor is, and what its menus offer.
+	-- evidence instead: who macOS thinks Conductor is, what its menus offer, how
+	-- many windows the window server counts across all Spaces (AX only sees the
+	-- current one), and whether the lock screen is up.
 	set procs to my processWindowCounts()
 	set titles to my menuTitles()
-	set ev to ""
+	set ev to " [window server: " & my serverWindowCount() & "; screen: " & my screenLocked() & "]"
 	if (count of procs) > 0 then set ev to ev & " [processes: " & my joinList(procs, ", ") & "]"
 	if (count of titles) > 0 then set ev to ev & " [menus: " & my joinList(titles, ", ") & "]"
 	return ev
@@ -253,6 +309,21 @@ on activateConductor()
 	set firstProbe to my windowProbe()
 	set refusal to my refusalReason(firstProbe)
 	if refusal is not "" then error refusal
+	-- The lock ahead of everything else: the lock screen hides the whole session
+	-- from Accessibility, so a locked Mac reads "no window" from every probe below
+	-- and the ladder spends the patience budget, the Dock click and the evidence
+	-- sweeps discovering what one read already knew — measured live (2026-08-14),
+	-- the attempt died at the node-side ceiling as "took too long" and the phone
+	-- never heard the word "locked". Asking here also stops "activate" from
+	-- launching Conductor behind the lock screen, which is where the windowless
+	-- launches that wedged it came from. A probe that already shows a window
+	-- proves the session is unlocked (AX can't see into a locked one), so the
+	-- happy path pays nothing. The error stays retryable on purpose: the caller's
+	-- retry loop polls this cheaply until its deadline, so an unlock mid-budget
+	-- lands the send by itself — that is the observed recovery, not a theory.
+	if (item 1 of firstProbe) < 1 and my screenLocked() is "locked" then
+		error "The Mac is locked - the lock screen hides Conductor from the relay, so a send can't reach it. Unlock the Mac and send again." & my windowEvidence()
+	end if
 	try
 		tell application "Conductor" to activate
 	on error errText
@@ -282,6 +353,22 @@ on activateConductor()
 		-- used to drop it, which made a repeating no-window failure undebuggable
 		-- from the log alone.
 		set ev to my windowEvidence()
+		set lockState to my screenLocked()
+		-- AX saying "no window" is not the same as there being no window: full
+		-- screen on another Space and the lock screen both hide a live window from
+		-- AX, and restarting then destroys a window the user left open (measured
+		-- live: exactly that loop wedged Conductor for a whole evening). Only the
+		-- window server can tell the difference, so a window it CAN see blocks the
+		-- restart — this is a human's problem, said in words, not the relay's.
+		if my serverWindowCount() > 0 then
+			if lockState is "locked" then error "The Mac is locked - Conductor's window is open behind the lock screen, where the relay can't reach it. Unlock the Mac and send again." & ev
+			error "Conductor's window exists but is not reachable - it is probably full screen on another Space. Take Conductor out of full screen, then send again." & ev
+		end if
+		-- No window anywhere and the lock screen up: don't restart. Every relaunch
+		-- fired behind the lock screen in the live incident came up windowless, and
+		-- the last one came up wedged — answering deep links, hanging every AX
+		-- read. A restart here is not a lever, it is how the wreckage happened.
+		if lockState is "locked" then error "The Mac is locked and Conductor has no window. Relaunching behind the lock screen is what leaves it wedged, so the relay won't - unlock the Mac and send again." & ev
 		set restartError to my restartConductor()
 		if restartError is not "" then error restartError & ev
 		error "Conductor was running with no window and ignored both reopen and a Dock click, so the relay restarted it. Give it a few seconds and send again." & ev

package/dist-node/src/firstprompt.js CHANGED Viewed

@@ -120,14 +120,21 @@ export class FirstPromptQueue {
         }
     }
     async step(entry) {
-        if (Date.now() - entry.createdAt > MAX_AGE_MS) {
-            return this.fail(entry, 'the workspace never finished setting up');
-        }
+        // A closed gate (locked Mac) freezes the entry whole: no attempt, and no aging
+        // either — the age cap judges the worktree's setup, and setup doesn't need the
+        // screen, but failing a deliverable prompt because nobody was home to unlock
+        // is exactly the "gave up while you were out" this queue exists to prevent.
+        if (this.deps.gate && !(await this.deps.gate()))
+            return;
         const target = this.deps.inspect(entry.workspaceId);
         // No row yet is normal right after creation, and a workspace that really is
-        // gone falls out through the age cap above rather than being guessed at here.
-        if (!target?.ready || !target.sessionId)
+        // gone falls out through the age cap below rather than being guessed at here.
+        if (!target?.ready || !target.sessionId) {
+            if (Date.now() - entry.createdAt > MAX_AGE_MS) {
+                return this.fail(entry, 'the workspace never finished setting up');
+            }
             return;
+        }
         // It already went — the user sent it from the Mac, where the deep link left it
         // pre-filled in the composer. Sending again would double it.
         if (target.alreadySent)
@@ -137,6 +144,12 @@ export class FirstPromptQueue {
         const result = await this.deps.send(entry.workspaceId, target.sessionId, entry.text);
         if (result.ok)
             return this.delivered(entry);
+        if (result.blocked) {
+            // The gate closed between the check above and the send: hand the attempt back.
+            entry.attempts -= 1;
+            this.save();
+            return;
+        }
         const error = result.error ?? 'the send didn’t land';
         console.warn(`[relay] first prompt for ${entry.workspaceId} failed (attempt ${entry.attempts}): ${error}`);
         if (entry.attempts >= MAX_ATTEMPTS)

package/dist-node/src/parked.js ADDED Viewed

@@ -0,0 +1,200 @@
+/**
+ * Prompts parked because the Mac's screen is locked, delivered by the relay the
+ * moment it unlocks.
+ *
+ * The lock screen hides the whole session's UI from Accessibility, so while it is
+ * up no AppleScript write can land — and the phone's own retry budget (~a minute)
+ * is the wrong tool for a wait that routinely lasts hours. So a send that hits
+ * the lock hands its prompt to this queue and returns at once: the phone shows it
+ * as a queued bubble in the chat (`workspace.parked_prompts` on `/api/state`),
+ * the relay polls the lock and delivers when it lifts, and a push notification
+ * says whether it landed. Same ownership story as `firstprompt.ts`: the relay is
+ * the only deliverer, the phone only watches and can dismiss.
+ *
+ * The same three properties hold it up:
+ *
+ * - **One owner.** The phone never re-sends a parked prompt on its own; a manual
+ *   send of the same text clears the entry server-side (`forgetDelivered`), so
+ *   the two paths can't double it.
+ * - **It survives a restart.** `autoupdate` exits to reload new code mid-wait as
+ *   a matter of course; the JSON file brings the queue back with the process.
+ * - **It gives up in public.** Time spent locked is free — a weekend away is not
+ *   a failure — but once the Mac is unlocked, `MAX_ATTEMPTS` real delivery
+ *   failures flip the entry to `failed` *and it stays*, text and reason visible
+ *   on the phone, one Retry from going again.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+/** Lock-probe cadence while anything waits. One tiny osascript per tick, nothing UI. */
+const POLL_MS = 5000;
+/** Breathing room between failed unlocked sends — Conductor is often still redrawing right after login. */
+const RETRY_DELAY_MS = 5000;
+const MAX_ATTEMPTS = 3;
+/** Failed entries the user never dismissed are still dropped eventually. */
+const KEEP_FAILED_MS = 7 * 24 * 60 * 60 * 1000;
+export const PARKED_REASON = 'Sends when the Mac is unlocked';
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+export class ParkedPromptQueue {
+    // Explicit field assignment, not parameter properties: the dev run type-*strips*
+    // rather than transforms, and parameter properties need a transform (see CLAUDE.md).
+    file;
+    deps;
+    entries;
+    pumping = false;
+    constructor(file, deps) {
+        this.file = file;
+        this.deps = deps;
+        this.entries = this.load();
+    }
+    /** Everything the phone should see, including entries that have already failed. */
+    list() {
+        return this.entries;
+    }
+    /**
+     * Park a prompt (idempotent per chat + text, so a retap while locked revives
+     * the entry instead of doubling it) and start watching for the unlock.
+     */
+    park(workspaceId, sessionId, text, agent) {
+        const existing = this.entries.find(e => e.sessionId === sessionId && e.text.trim() === text.trim());
+        if (existing) {
+            // A re-park is the user asking again: back to waiting with a clean slate.
+            existing.status = 'waiting';
+            existing.attempts = 0;
+            existing.error = undefined;
+            existing.agent = agent ?? existing.agent;
+            this.save();
+            void this.pump();
+            return existing;
+        }
+        const entry = {
+            workspaceId,
+            sessionId,
+            text,
+            agent,
+            status: 'waiting',
+            attempts: 0,
+            createdAt: Date.now(),
+            reason: PARKED_REASON
+        };
+        this.entries = [...this.entries, entry];
+        this.save();
+        void this.pump();
+        return entry;
+    }
+    /** Drop everything parked for a chat — the phone's Dismiss. */
+    forgetSession(sessionId) {
+        if (!this.entries.some(e => e.sessionId === sessionId))
+            return false;
+        this.entries = this.entries.filter(e => e.sessionId !== sessionId);
+        this.save();
+        return true;
+    }
+    /**
+     * A send of this exact text just landed by another path (the phone retried it
+     * by hand once the Mac was unlocked) — delivering it again would double it.
+     */
+    forgetDelivered(sessionId, text) {
+        const before = this.entries.length;
+        this.entries = this.entries.filter(e => !(e.sessionId === sessionId && e.text.trim() === text.trim()));
+        if (this.entries.length !== before)
+            this.save();
+    }
+    /** Resume watching anything left over from a previous process. */
+    start() {
+        const waiting = this.entries.filter(e => e.status === 'waiting').length;
+        if (waiting)
+            console.info(`[relay] resuming ${waiting} prompt(s) parked for the lock screen`);
+        void this.pump();
+    }
+    /**
+     * The watch loop. While anything waits: probe the lock; locked → sleep and
+     * probe again (locked time costs nothing); unlocked or unknown → deliver in
+     * FIFO order, so two prompts parked into one chat arrive as sent. Single-flight,
+     * so a burst of parks can't stack loops.
+     */
+    async pump() {
+        if (this.pumping)
+            return;
+        this.pumping = true;
+        try {
+            while (this.entries.some(e => e.status === 'waiting')) {
+                if ((await this.deps.locked()) === true) {
+                    await sleep(POLL_MS);
+                    continue;
+                }
+                for (const entry of this.entries.filter(e => e.status === 'waiting'))
+                    await this.step(entry);
+                if (this.entries.some(e => e.status === 'waiting'))
+                    await sleep(POLL_MS);
+            }
+        }
+        catch (err) {
+            // A throw here would strand every parked prompt with no loop to retry it.
+            console.error('[relay] parked-prompt delivery loop crashed:', err);
+        }
+        finally {
+            this.pumping = false;
+        }
+    }
+    async step(entry) {
+        const result = await this.deps.deliver(entry);
+        if (result.ok)
+            return this.delivered(entry);
+        // The lock got there first (re-locked between the probe and the send, or the
+        // probe couldn't answer): that is the gate closing, not a delivery failure.
+        if (result.blocked)
+            return;
+        entry.attempts += 1;
+        this.save();
+        const error = result.error ?? 'the send didn’t land';
+        console.warn(`[relay] parked prompt for ${entry.sessionId} failed (attempt ${entry.attempts}): ${error}`);
+        if (entry.attempts >= MAX_ATTEMPTS)
+            return this.fail(entry, error);
+        await sleep(RETRY_DELAY_MS);
+    }
+    /** Delivered: the entry's job is done, so it stops existing — the push is the receipt. */
+    delivered(entry) {
+        this.entries = this.entries.filter(e => e !== entry);
+        this.save();
+        this.deps.notify(entry);
+    }
+    /** Given up on: kept, so the phone can show the text and the reason. */
+    fail(entry, error) {
+        entry.status = 'failed';
+        entry.error = error;
+        this.save();
+        this.deps.notify(entry, error);
+    }
+    load() {
+        let raw;
+        try {
+            raw = fs.readFileSync(this.file, 'utf8');
+        }
+        catch {
+            return []; // nothing parked — the common case
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed))
+                return [];
+            return parsed.filter(e => typeof e?.workspaceId === 'string' &&
+                typeof e.sessionId === 'string' &&
+                typeof e.text === 'string' &&
+                Date.now() - (e.createdAt ?? 0) < KEEP_FAILED_MS);
+        }
+        catch (err) {
+            console.warn(`[relay] ignoring unreadable ${this.file}: ${err instanceof Error ? err.message : err}`);
+            return [];
+        }
+    }
+    save() {
+        try {
+            fs.mkdirSync(path.dirname(this.file), { recursive: true });
+            fs.writeFileSync(this.file, JSON.stringify(this.entries, null, 2));
+        }
+        catch (err) {
+            // Delivery still works this run; only the restart guarantee is lost.
+            console.warn(`[relay] could not persist parked prompts: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+}

package/dist-node/src/server.js CHANGED Viewed

@@ -11,11 +11,12 @@ import { startFunnelWatchdog } from "./funnel-watchdog.js";
 import { workspaceDiff } from "./git.js";
 import { installLogCapture, isManaged, LOG_FILE_NAMES, logFiles, processStartedAt, recentLogs, redactSecrets, tailLogFile } from "./logbuf.js";
 import { mergePr } from "./merge.js";
-import { notifyDevice, pushConfig, startNotifier, subscribeDevice, unsubscribeDevice } from "./notify.js";
+import { notifyAll, notifyDevice, pushConfig, startNotifier, subscribeDevice, unsubscribeDevice } from "./notify.js";
+import { ParkedPromptQueue } from "./parked.js";
 import { attachPrStatus } from "./pr.js";
 import { Reads } from "./reads.js";
 import { driftWarningLines, tailscaleBin } from "./tailscale.js";
-import { createWorkspace, describeActuator, EFFORT_LABELS, listAgentModels, newChat, pickActuator, retryWontHelp, setAgentOptions, setRestartGuard, setWorkspaceStatus, WORKSPACE_STATUS_LABELS } from "./writes.js";
+import { createWorkspace, describeActuator, EFFORT_LABELS, listAgentModels, lockBlocked, newChat, pickActuator, retryWontHelp, screenLocked, setAgentOptions, setRestartGuard, setWorkspaceStatus, WORKSPACE_STATUS_LABELS } from "./writes.js";
 // Before anything that logs: from here on every console line is also kept in memory for
 // `GET /api/logs`, so the phone can read why a send failed without ssh-ing into the Mac.
 installLogCapture();
@@ -179,6 +180,11 @@ async function deliverPrompt(ws, sessionId, text, budgetMs = SEND_BUDGET_MS) {
         }
         if (retryWontHelp(last.error))
             break;
+        // A locked screen isn't worth the rest of the budget either — but for the
+        // opposite reason: the parked-prompt queue (src/parked.ts) waits it out far
+        // past any deadline a phone could hold open, so hand it over at once.
+        if (lockBlocked(last.error))
+            break;
         if (deadline - Date.now() < MIN_ATTEMPT_MS + CONFIRM_WINDOW_MS)
             break;
         // The phone only ever sees the outcome; why a send goes missing lives on this
@@ -216,7 +222,73 @@ const firstPrompts = new FirstPromptQueue(path.join(stateDir(), 'first-prompts.j
         if (!ws)
             return { ok: false, error: 'the workspace is gone' };
         const result = await deliverPrompt(ws, sessionId, text);
-        return { ok: result.ok, error: result.error };
+        return { ok: result.ok, error: result.error, blocked: lockBlocked(result.error) };
+    },
+    // A locked Mac holds first prompts whole — no attempts spent, no aging — instead
+    // of burning all three sends into a lock screen nobody is there to see.
+    gate: async () => (await screenLocked()) !== true
+});
+/**
+ * Apply staged agent settings to a chat — the shared half of `POST …/agent` and
+ * of a send that carries a patch. The `fast` translation lives here because the
+ * UI button only *toggles*: the DB says whether the press is needed at all.
+ */
+async function applyAgentPatch(ws, sessionId, patch) {
+    const located = locateChat(ws, sessionId);
+    if ('error' in located)
+        return { ok: false, error: located.error };
+    const opts = {
+        effort: patch.effort,
+        plan: patch.plan,
+        model: patch.model,
+        toggleFast: patch.fast === undefined ? false : patch.fast !== Boolean(located.session?.fast_mode)
+    };
+    const result = await setAgentOptions({ workspace: ws, sessionId, tab: located.tab }, opts);
+    if (!result.ok)
+        return { ok: false, error: result.error };
+    if (!(await confirmAgentOptions(ws, sessionId, opts))) {
+        return { ok: false, error: 'Conductor didn’t record the change — it may have been asleep. Try again.' };
+    }
+    return { ok: true };
+}
+/** What the phone is told when its prompt is parked instead of failed. */
+const PARKED_ERROR = 'The Mac is locked — the relay parked the prompt and will send it when the Mac is unlocked.';
+/**
+ * Prompts that hit the lock screen, owned by this process until the Mac unlocks
+ * (see parked.ts for why the phone can't wait this out itself).
+ */
+const parkedPrompts = new ParkedPromptQueue(path.join(stateDir(), 'parked-prompts.json'), {
+    locked: screenLocked,
+    deliver: async (entry) => {
+        const ws = reads.getWorkspace(entry.workspaceId);
+        if (!ws)
+            return { ok: false, error: 'the workspace is gone' };
+        // Settings first, prompt only if they stuck — the same order and the same
+        // fail-closed rule as the phone's own send (running the prompt on the model
+        // the user moved away from is the mistake this exists to prevent). A re-run
+        // after a failed prompt re-applies harmlessly: every control is read before
+        // it is pressed, so an already-correct value presses nothing.
+        if (entry.agent) {
+            const applied = await applyAgentPatch(ws, entry.sessionId, entry.agent);
+            if (!applied.ok)
+                return { ok: false, error: applied.error, blocked: lockBlocked(applied.error) };
+        }
+        const result = await deliverPrompt(ws, entry.sessionId, entry.text);
+        return { ok: result.ok, error: result.error, blocked: lockBlocked(result.error) };
+    },
+    notify: (entry, error) => {
+        const ws = reads.getWorkspace(entry.workspaceId);
+        const title = ws?.workspace_name ?? ws?.pr_title ?? ws?.branch ?? 'Conductor';
+        const preview = entry.text.length > 140 ? `${entry.text.slice(0, 140).trimEnd()}…` : entry.text;
+        void notifyAll({
+            title,
+            body: error ? `Parked prompt failed: ${error}` : `Sent after unlock: ${preview}`,
+            // Per chat, so a second parked prompt replaces the first's notification.
+            tag: `parked-${entry.sessionId}`,
+            url: `/w/${entry.workspaceId}`,
+            kind: error ? 'error' : 'done',
+            ts: Date.now()
+        });
     }
 });
 const MIME = {
@@ -327,8 +399,15 @@ const server = http.createServer(async (req, res) => {
             attachPrStatus(workspaces); // colours pr_status from cache; refreshes stale entries in the background
             // An undelivered first prompt rides along with its workspace: the phone renders it
             // in that chat rather than tracking delivery itself (see src/firstprompt.ts).
-            for (const ws of workspaces)
+            // Prompts parked for the lock screen ride the same way, one list per workspace,
+            // each entry naming its chat (src/parked.ts).
+            const parked = parkedPrompts.list();
+            for (const ws of workspaces) {
                 ws.pending_prompt = firstPrompts.get(ws.id);
+                const mine = parked.filter(p => p.workspaceId === ws.id);
+                if (mine.length)
+                    ws.parked_prompts = mine;
+            }
             return json(req, res, 200, {
                 workspaces,
                 actuator: await describeActuator(actuator),
@@ -588,30 +667,14 @@ const server = http.createServer(async (req, res) => {
                 : (reads.listWorkspaces().find(w => w.active_session_id === sessionId) ?? null);
             if (!ws)
                 return json(req, res, 404, { error: 'workspace for session not found' });
-            const located = locateChat(ws, sessionId);
-            if ('error' in located)
-                return json(req, res, 409, { error: located.error });
-            // Fast mode exposes no readable state in the UI, so the DB decides whether
-            // the button actually needs pressing — pressing blindly would toggle it off.
-            const opts = {
-                effort: body.effort,
-                plan: body.plan,
-                model: body.model,
-                toggleFast: body.fast === undefined ? false : body.fast !== Boolean(located.session?.fast_mode)
-            };
-            const result = await setAgentOptions({ workspace: ws, sessionId, tab: located.tab }, opts);
-            if (!result.ok)
-                return json(req, res, 502, result);
-            if (!(await confirmAgentOptions(ws, sessionId, opts))) {
-                return json(req, res, 502, {
-                    ok: false,
-                    strategy: result.strategy,
-                    error: 'Conductor didn’t record the change — it may have been asleep. Try again.'
-                });
-            }
+            const applied = await applyAgentPatch(ws, sessionId, body);
+            if (!applied.ok)
+                return json(req, res, 502, { ok: false, strategy: actuator.name, error: applied.error });
             return json(req, res, 200, { ok: true, session: reads.listSessions(ws.id).find(s => s.id === sessionId) });
         }
-        // POST /api/sessions/:id/prompt  { text }
+        // POST /api/sessions/:id/prompt  { text, agent? } — agent is the phone's staged
+        // settings patch, applied before the prompt so the two can't come apart (and so
+        // both park together when the Mac turns out to be locked).
         m = pathname.match(/^\/api\/sessions\/([^/]+)\/prompt$/);
         if (req.method === 'POST' && m) {
             const sessionId = decodeURIComponent(m[1]);
@@ -624,14 +687,46 @@ const server = http.createServer(async (req, res) => {
                 : (reads.listWorkspaces().find(w => w.active_session_id === sessionId) ?? null);
             if (!ws)
                 return json(req, res, 404, { error: 'workspace for session not found' });
+            // One deadline for the whole request: settings eat into the send's budget
+            // rather than extending it past what the phone said it would wait.
+            const deadline = Date.now() + sendBudget(req);
+            const agent = body.agent && Object.keys(body.agent).length ? body.agent : undefined;
+            if (agent?.effort && !EFFORT_LABELS[agent.effort]) {
+                return json(req, res, 400, { error: `effort must be one of ${Object.keys(EFFORT_LABELS).join(', ')}` });
+            }
+            if (agent) {
+                const applied = await applyAgentPatch(ws, sessionId, agent);
+                if (!applied.ok) {
+                    if (lockBlocked(applied.error)) {
+                        const queued = parkedPrompts.park(ws.id, sessionId, text, agent);
+                        return json(req, res, 202, {
+                            ok: false,
+                            parked: true,
+                            queued,
+                            strategy: actuator.name,
+                            error: PARKED_ERROR
+                        });
+                    }
+                    return json(req, res, 502, { ok: false, strategy: actuator.name, error: applied.error });
+                }
+            }
             // Retries live inside deliverPrompt, confirmed against the transcript each time,
             // and inside the deadline this phone told us it would wait.
-            const result = await deliverPrompt(ws, sessionId, text, sendBudget(req));
-            // Whatever the queue was still holding for this workspace has now been said by
-            // hand — including a failed entry the user retried from the chat.
-            if (result.ok)
+            const result = await deliverPrompt(ws, sessionId, text, deadline - Date.now());
+            if (result.ok) {
+                // Whatever a queue was still holding has now been said by hand — the first
+                // prompt (including a failed entry retried from the chat), and any parked
+                // copy of this exact text, which delivering again would double.
                 firstPrompts.forget(ws.id);
-            return json(req, res, result.ok ? 200 : 502, result);
+                parkedPrompts.forgetDelivered(sessionId, text);
+                return json(req, res, 200, result);
+            }
+            if (lockBlocked(result.error)) {
+                // Settings (if any) already stuck, so the entry parks without them.
+                const queued = parkedPrompts.park(ws.id, sessionId, text);
+                return json(req, res, 202, { ok: false, parked: true, queued, strategy: result.strategy, error: PARKED_ERROR });
+            }
+            return json(req, res, 502, result);
         }
         // DELETE /api/workspaces/:id/prompt — dismiss an undelivered first prompt
         m = pathname.match(/^\/api\/workspaces\/([^/]+)\/prompt$/);
@@ -641,6 +736,14 @@ const server = http.createServer(async (req, res) => {
                 return json(req, res, 404, { error: 'no pending prompt' });
             return json(req, res, 200, { ok: true });
         }
+        // DELETE /api/sessions/:id/prompt — dismiss whatever is parked for this chat
+        m = pathname.match(/^\/api\/sessions\/([^/]+)\/prompt$/);
+        if (req.method === 'DELETE' && m) {
+            const sessionId = decodeURIComponent(m[1]);
+            if (!parkedPrompts.forgetSession(sessionId))
+                return json(req, res, 404, { error: 'no parked prompt' });
+            return json(req, res, 200, { ok: true });
+        }
         return json(req, res, 404, { error: 'no route', pathname });
     }
     catch (err) {
@@ -671,6 +774,8 @@ 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();
+    // Same for prompts parked behind the lock screen — a lock outlives relay restarts.
+    parkedPrompts.start();
     // Keep the managed global daemon current — no-ops for dev checkouts / unmanaged runs (see autoupdate.ts).
     startAutoUpdate();
     // Keep the phone's public URL reachable — re-registers Funnel when its ingress goes stale after a