npm - conductor-remote - Versions diffs - 1.46.0 → 1.46.2 - Mend

conductor-remote 1.46.0 → 1.46.2

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 (11) hide show

package/dist/assets/{index-C_IDJcQQ.js → index-Cox9xTfw.js} +28 -28
package/dist/index.html +1 -1
package/dist/sw.js +1 -1
package/dist-node/src/conductor.applescript +19 -4
package/dist-node/src/notify.js +122 -43
package/dist-node/src/reads.js +13 -2
package/dist-node/src/sendonce.js +109 -0
package/dist-node/src/server.js +52 -37
package/dist-node/src/shared.js +8 -0
package/dist-node/src/writes.js +3 -1
package/package.json +5 -2

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-C_IDJcQQ.js"></script>
+		<script type="module" crossorigin src="/assets/index-Cox9xTfw.js"></script>
 		<link rel="stylesheet" crossorigin href="/assets/index-DGZkOBT-.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 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:"e1e682e2e5e88fa03b7808ae9db8e098"},{url:"index.html",revision:"~~53f877045e9ef9cf1f2830e0a520d8fe~~"},{url:"assets/workbox-window.prod.es5-BBnX5xw4.js",revision:null},{url:"assets/index-DGZkOBT-.css",revision:null},{url:"assets/index-~~C_IDJcQQ~~.js",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 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:"e1e682e2e5e88fa03b7808ae9db8e098"},{url:"index.html",revision:"039e5ab1adab0c250569cb906306c5a8"},{url:"assets/workbox-window.prod.es5-BBnX5xw4.js",revision:null},{url:"assets/index-DGZkOBT-.css",revision:null},{url:"assets/index-Cox9xTfw.js",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

@@ -908,6 +908,20 @@ on firstLine(s)
 	return item 1 of parts
 end firstLine
+on pickerShowsModel(popup, wanted)
+	set pickerLabel to my tabLabel(popup)
+	if pickerLabel contains ("(" & wanted & ")") then return true
+	-- The menu can label a newly released model "Opus 5 NEW", while the
+	-- composer deliberately drops that temporary badge and says "Opus 5".
+	-- Treat that exact display form as the same choice; the surrounding
+	-- parentheses keep "Opus 5" distinct from a longer model name.
+	if wanted ends with " NEW" then
+		set baseName to text 1 thru -5 of wanted
+		if pickerLabel contains ("(" & baseName & ")") then return true
+	end if
+	return false
+end pickerShowsModel
 on setModel(wanted)
 	set popup to missing value
 	repeat with entry in my composerControls()
@@ -915,13 +929,14 @@ on setModel(wanted)
 		if my tabLabel(c) contains "Change agent" then set popup to c
 	end repeat
 	if popup is missing value then error "couldn't find the model picker"
-	if (my tabLabel(popup)) contains ("(" & wanted & ")") then return
+	if my pickerShowsModel(popup, wanted) then return
 	tell application "System Events" to tell process "Conductor"
 		perform action "AXPress" of popup
 	end tell
 	delay 1.0
-	-- Menu labels carry badges ("Opus 5 NEW"), so an exact match is preferred but a
-	-- prefix match is accepted — except when it is ambiguous ("Sonnet 4.6" would
+	-- The relay removes a temporary `NEW` badge before it sends this label back,
+	-- so a prefix match resolves that menu item. It is accepted only when unique:
+	-- "Sonnet 4.6" would
 	-- otherwise also match "Sonnet 4.6 1M"), which must fail rather than guess.
 	set chosen to missing value
 	set loose to {}
@@ -954,7 +969,7 @@ on setModel(wanted)
 		if my tabLabel(c) contains "Change agent" then set popup to c
 	end repeat
 	if popup is missing value then error "the model picker vanished"
-	if (my tabLabel(popup)) does not contain ("(" & wanted & ")") then error "the model didn't switch to " & wanted
+	if not my pickerShowsModel(popup, wanted) then error "the model didn't switch to " & wanted
 end setModel
 on listModels()

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

@@ -235,53 +235,132 @@ function oneLine(text) {
         .trim(), BODY_CHARS);
 }
 // --- the watcher ---
-/** Last seen status per session. Null means "re-baseline on the next tick" (nobody was subscribed). */
-let previous = null;
-/** Transitions seen once and awaiting a second tick's confirmation. */
-const armed = new Map();
-function tick(reads) {
-    if (deviceCount() === 0) {
-        // Nothing to notify. Forget the snapshot so re-enabling starts from the world as
-        // it is then, rather than replaying every turn that ended while nobody listened.
-        previous = null;
-        armed.clear();
-        return;
-    }
-    const states = reads.listSessionStates();
-    const current = new Map(states.map(s => [s.sessionId, s.status ?? null]));
-    if (previous === null) {
-        previous = current;
-        return;
+/**
+ * Everything this chat records about a person having asked for something, as one
+ * comparable string — the turn head *and* the last user message, because steering a
+ * running turn moves only the second (`queue_order` is null on a steering message, see
+ * reads.ts). Empty when the chat records neither, which is what `selfScheduled` reads
+ * as "no evidence" rather than as "nobody asked".
+ */
+function askedBy(state) {
+    if (!state.turnStartedAt && !state.lastUserMessageAt)
+        return '';
+    return `${state.turnStartedAt ?? ''}|${state.lastUserMessageAt ?? ''}`;
+}
+/**
+ * The status state machine, kept apart from the store and the network so it can be
+ * driven a tick at a time by `scripts/check-notify.ts`. Every rule in it is a rule
+ * about *not* notifying, and each one is a nuisance or a silence that nothing in the
+ * type system can catch.
+ */
+export class TurnWatcher {
+    /** Last seen status per chat. Null means "re-baseline on the next step" (nobody was subscribed). */
+    previous = null;
+    /** Transitions seen once and awaiting a second step's confirmation. */
+    armed = new Map();
+    /**
+     * Who-asked, as of the last turn we said "done" about, per chat — what makes a
+     * self-scheduled turn quiet.
+     *
+     * `working → idle` is still the only signal Conductor gives, and it is still the right
+     * one for a turn *someone asked for*. It is the wrong one for a turn the agent
+     * scheduled itself: a `/loop` starts a fresh turn every few minutes for as long as it
+     * runs, each one ends properly, and each one is news to nobody. Measured on this Mac —
+     * one looping chat pushed roughly every five minutes from early evening until past
+     * midnight, and again all morning, which was most of the notifications the phone got
+     * at all.
+     *
+     * The tell is in the data rather than in a guess about intent. A turn is headed by a
+     * `session_messages` row with `queue_order` set and a loop's next lap writes nothing
+     * at all, so `askedBy` below sits still while `status` cycles. The first lap after you
+     * type something notifies. Every lap the agent gave itself is quiet, until you say the
+     * next thing. An `error` is exempt — a loop that breaks is worth hearing about however
+     * it started.
+     *
+     * A chat with nothing to compare (no turn head *and* no user message — dormant since
+     * before `queue_order` landed in May 2026) notifies every time, which is the old
+     * behaviour: with no evidence either way, silence is the dangerous default.
+     */
+    notifiedTurn = new Map();
+    /**
+     * Nobody is subscribed. Forget the snapshot so re-enabling starts from the world as
+     * it is then, rather than replaying every turn that ended while nobody listened.
+     */
+    reset() {
+        this.previous = null;
+        this.armed.clear();
+        this.notifiedTurn.clear();
     }
-    const baseline = previous;
-    for (const state of states) {
-        const now = state.status ?? null;
-        const before = baseline.get(state.sessionId);
-        const pendingKind = armed.get(state.sessionId);
-        if (pendingKind) {
-            armed.delete(state.sessionId);
-            // Confirmed only if the new status held for a second tick; a flap just drops the arm.
-            if ((pendingKind === 'done' && now === 'idle') || (pendingKind === 'error' && now === 'error')) {
-                void fire(reads, state.sessionId, pendingKind, state);
+    /** One poll of every live chat, in; the notifications it earned, out. */
+    step(states) {
+        const current = new Map(states.map(s => [s.sessionId, s.status ?? null]));
+        if (this.previous === null) {
+            this.previous = current;
+            return [];
+        }
+        const baseline = this.previous;
+        const due = [];
+        for (const state of states) {
+            const now = state.status ?? null;
+            const before = baseline.get(state.sessionId);
+            const pendingKind = this.armed.get(state.sessionId);
+            if (pendingKind) {
+                this.armed.delete(state.sessionId);
+                // Confirmed only if the new status held for a second step; a flap just drops the arm.
+                const held = (pendingKind === 'done' && now === 'idle') || (pendingKind === 'error' && now === 'error');
+                if (held && !(pendingKind === 'done' && this.selfScheduled(state))) {
+                    const asked = askedBy(state);
+                    if (pendingKind === 'done' && asked)
+                        this.notifiedTurn.set(state.sessionId, asked);
+                    due.push({ state, kind: pendingKind });
+                }
+                continue;
             }
-            continue;
+            // A chat we've never seen (a new one, or the first step after re-baselining)
+            // contributes its status to the snapshot but is never itself news.
+            if (before === undefined)
+                continue;
+            if (before === 'working' && now === 'idle')
+                this.armed.set(state.sessionId, 'done');
+            else if (before !== 'error' && now === 'error')
+                this.armed.set(state.sessionId, 'error');
         }
-        // A session we've never seen (a new chat, or the first tick after re-baselining)
-        // contributes its status to the snapshot but is never itself news.
-        if (before === undefined)
-            continue;
-        if (before === 'working' && now === 'idle')
-            armed.set(state.sessionId, 'done');
-        else if (before !== 'error' && now === 'error')
-            armed.set(state.sessionId, 'error');
+        // A chat armed on the last step can vanish before this one (its workspace was
+        // archived mid-turn). Nothing above touches it, so drop it here rather than keep
+        // the key forever — and never notify about a workspace that no longer exists.
+        for (const sessionId of this.armed.keys())
+            if (!current.has(sessionId))
+                this.armed.delete(sessionId);
+        for (const sessionId of this.notifiedTurn.keys())
+            if (!current.has(sessionId))
+                this.notifiedTurn.delete(sessionId);
+        this.previous = current;
+        return due;
+    }
+    /**
+     * Did this chat end a turn nobody asked for? See `notifiedTurn`.
+     *
+     * The first `working → idle` a chat shows us always notifies, whatever started it: the
+     * relay may have only just come up, or the phone only just subscribed, and staying
+     * quiet about a turn we have no history for would lose the one notification that
+     * mattered. It is the *repeat* on an unchanged turn head that is the loop.
+     */
+    selfScheduled(state) {
+        const asked = askedBy(state);
+        if (!asked)
+            return false;
+        const last = this.notifiedTurn.get(state.sessionId);
+        return last !== undefined && last === asked;
+    }
+}
+const watcher = new TurnWatcher();
+function tick(reads) {
+    if (deviceCount() === 0) {
+        watcher.reset();
+        return;
     }
-    // A session armed on the last tick can vanish before this one (its workspace was
-    // archived mid-turn). Nothing above touches it, so drop it here rather than keep
-    // the key forever — and never notify about a workspace that no longer exists.
-    for (const sessionId of armed.keys())
-        if (!current.has(sessionId))
-            armed.delete(sessionId);
-    previous = current;
+    for (const due of watcher.step(reads.listSessionStates()))
+        void fire(reads, due.state.sessionId, due.kind, due.state);
 }
 async function fire(reads, sessionId, kind, state) {
     const said = reads.lastAssistantText(sessionId);

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

@@ -248,10 +248,19 @@ export class Reads {
      * `setting_up` workspaces are excluded; their chat isn't the user's turn yet.
      */
     listSessionStates() {
-        const rows = this.db.query(`SELECT s.id, s.status, s.title, s.workspace_id,
+        const rows = this.db.query(
+        // These two together are the notifier's record of whether a *person* had
+        // anything to do with the turn that just ended. An agent that schedules its own
+        // next turn (a `/loop`) writes no message at all, so both stay put while
+        // `status` cycles working → idle on every lap. Both are needed: `turn_started_at`
+        // only moves for a message that *heads* a turn, so steering into a running one
+        // would look like a lap nobody asked for. See src/notify.ts.
+        `SELECT s.id, s.status, s.title, s.workspace_id, s.last_user_message_at,
 			        w.workspace_name, w.pr_title, w.branch, w.directory_name,
 			        r.name AS repo_name,
-			        (SELECT COUNT(*) FROM sessions t WHERE t.workspace_id = w.id AND COALESCE(t.is_hidden, 0) = 0) AS tab_count
+			        (SELECT COUNT(*) FROM sessions t WHERE t.workspace_id = w.id AND COALESCE(t.is_hidden, 0) = 0) AS tab_count,
+			        (SELECT MAX(m.sent_at) FROM session_messages m
+			          WHERE m.session_id = s.id AND m.queue_order IS NOT NULL AND m.sent_at IS NOT NULL) AS turn_started_at
 			 FROM sessions s
 			 JOIN workspaces w ON w.id = s.workspace_id
 			 LEFT JOIN repos r ON r.id = w.repository_id
@@ -260,6 +269,8 @@ export class Reads {
             sessionId: r.id,
             workspaceId: r.workspace_id,
             status: r.status,
+            turnStartedAt: r.turn_started_at,
+            lastUserMessageAt: r.last_user_message_at,
             workspaceTitle: workspaceTitle({ ...r, id: r.workspace_id }),
             repoName: r.repo_name,
             // A single-tab workspace's chat title is just the workspace again — only name it when it disambiguates.

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

@@ -0,0 +1,109 @@
+/**
+ * One prompt per intent, however many requests carry it.
+ *
+ * `deliverPrompt` already makes a send safe to repeat *within* a request: it
+ * snapshots the transcript cursor, runs, and watches for the matching user row, so
+ * a run that landed late is reported as delivered rather than typed again. What that
+ * cannot see is a copy landed by a **different request**, because the snapshot is
+ * taken when the request starts and the earlier copy is behind it.
+ *
+ * Which is the duplicate the chats here actually hold. The failure is not the relay
+ * fumbling a send, it is the *answer* going missing: the funnel ingress goes stale on
+ * a network change (a documented failure on this setup), or the phone is suspended,
+ * or the 75s client budget runs out while the relay is still inside its own 55s one.
+ * The prompt is in Conductor, the phone never hears so, the bubble flips to failed,
+ * and Retry is right there. Two rows, seconds apart, and nothing in relay.log —
+ * every retry the relay *did* log landed exactly once, which is how the two were told
+ * apart.
+ *
+ * So the phone names the intent instead. `PendingMessage.id` already exists and the
+ * Retry button already reuses it (a fresh send makes a fresh one), so it is a UUID
+ * per thing-the-user-meant-to-say, and that is the key here. Deliberately saying
+ * "yes" twice is two ids and still two prompts; tapping Retry on one failed bubble is
+ * one id and stays one prompt. Nothing is matched on text, which is what keeps this
+ * from swallowing a repeat someone meant.
+ *
+ * Three properties:
+ *
+ * - **A failure is never remembered.** Retry after a send that really didn't land
+ *   must run again. Memoising failures would turn one bad minute into a Retry button
+ *   that does nothing for as long as the entry lives, which is worse than the
+ *   duplicate this exists to stop. `keep` decides, and it is given the outcome.
+ * - **In flight counts as delivered-in-progress.** The phone gives up at 75s and the
+ *   relay's own budget is 55s, so a Retry can arrive while the first run is still
+ *   holding `uiTurn`. A second run would then queue behind the first and type the
+ *   same prompt again the moment it finished. Joining the first is both the correct
+ *   answer and the faster one.
+ * - **No key, no memo.** An MCP caller or an older cached PWA sends none, and gets
+ *   exactly today's behaviour rather than a guess about what it meant.
+ */
+/**
+ * How long a delivered outcome stays worth answering with. It only has to outlast
+ * the gap between a lost answer and the tap that follows it — the phone's 75s budget,
+ * then however long it takes someone to look at their screen. Generous is free here:
+ * the key is a UUID, so an entry can never match an intent it didn't come from, and
+ * the only cost of keeping one is the row in the map.
+ */
+const DEFAULT_TTL_MS = 10 * 60 * 1000;
+/**
+ * Runs keyed work at most once per key: concurrent callers share one run, and a
+ * kept outcome answers later ones without running at all.
+ */
+export class SendOnce {
+    inFlight = new Map();
+    settled = new Map();
+    ttlMs;
+    keep;
+    constructor(opts) {
+        this.keep = opts.keep;
+        this.ttlMs = opts.ttlMs ?? DEFAULT_TTL_MS;
+    }
+    /**
+     * `key` undefined runs `fn` plainly — see "No key, no memo" above. Otherwise the
+     * first caller runs it, callers arriving while it runs await that same run, and
+     * callers arriving after a *kept* outcome get it back without running.
+     */
+    async run(key, fn) {
+        if (!key)
+            return fn();
+        const remembered = this.recall(key);
+        if (remembered)
+            return remembered.value;
+        const running = this.inFlight.get(key);
+        if (running)
+            return running;
+        // Wrapped rather than called bare, so a synchronous throw leaves no entry behind
+        // and reaches the caller as a rejection like every other failure.
+        const started = (async () => fn())();
+        this.inFlight.set(key, started);
+        try {
+            const value = await started;
+            if (this.keep(value)) {
+                this.prune();
+                this.settled.set(key, { at: Date.now(), value });
+            }
+            return value;
+        }
+        finally {
+            this.inFlight.delete(key);
+        }
+    }
+    /** Whether this key already has an outcome worth answering with — the test's window in. */
+    recall(key) {
+        const found = this.settled.get(key);
+        if (!found)
+            return null;
+        if (Date.now() - found.at > this.ttlMs) {
+            this.settled.delete(key);
+            return null;
+        }
+        return found;
+    }
+    /** Entries expire on their own; this is what stops the map outliving them. */
+    prune() {
+        const cutoff = Date.now() - this.ttlMs;
+        for (const [key, entry] of this.settled)
+            if (entry.at <= cutoff)
+                this.settled.delete(key);
+    }
+}

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

@@ -20,6 +20,7 @@ import { attachPrStatus } from "./pr.js";
 import { Reads } from "./reads.js";
 import { isRoute, routeParam, routes } from "./routes.js";
 import { foldHits, queryTokens, SearchIndex } from "./search.js";
+import { SendOnce } from "./sendonce.js";
 import { readSettings, writeSettings } from "./settings.js";
 import { driftWarningLines, tailscaleBin } from "./tailscale.js";
 import { renderTranscript } from "./transcript.js";
@@ -325,6 +326,16 @@ async function applyAgentPatch(ws, sessionId, patch) {
     }
     return { ok: true };
 }
+/**
+ * One prompt per tap, however many requests carry it (src/sendonce.ts). Keyed on the
+ * phone's own `PendingMessage.id`, which Retry reuses and a fresh send re-rolls, so a
+ * repeat someone meant still goes twice. Only an answer the phone would treat as final
+ * is remembered: a real failure has to stay retryable, or Retry does nothing for ten
+ * minutes and the prompt is lost for good rather than merely doubled.
+ */
+const sendOnce = new SendOnce({
+    keep: answer => answer.status === 200 || answer.status === 202
+});
 /** 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.';
 /**
@@ -993,45 +1004,49 @@ const server = http.createServer(async (req, res) => {
                 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
-                            });
+                // One prompt per intent (src/sendonce.ts). Everything that can *say something
+                // to Conductor* sits inside, so an answer the phone never heard is replayed
+                // rather than re-performed — including the parked branches, since parking the
+                // same intent twice queues the same prompt twice for the unlock.
+                if (body.clientId && sendOnce.recall(body.clientId)) {
+                    console.info(`[relay] send to ${ws.branch ?? ws.id} already delivered for this tap — answering, not resending`);
+                }
+                const answer = await sendOnce.run(body.clientId, async () => {
+                    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 {
+                                    status: 202,
+                                    body: { ok: false, parked: true, queued, strategy: actuator.name, error: PARKED_ERROR }
+                                };
+                            }
+                            return { status: 502, body: { ok: false, strategy: actuator.name, error: applied.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, 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);
-                    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);
+                    // 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, 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);
+                        parkedPrompts.forgetDelivered(sessionId, text);
+                        return { status: 200, body: 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 {
+                            status: 202,
+                            body: { ok: false, parked: true, queued, strategy: result.strategy, error: PARKED_ERROR }
+                        };
+                    }
+                    return { status: 502, body: result };
+                });
+                return json(req, res, answer.status, answer.body);
             }
             // POST /api/sessions/:id/split { prompt?, includeThinking?, includeTools? }
             //

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

@@ -50,6 +50,14 @@ export function workspaceTitle(w) {
 export function queryTokens(raw) {
     return raw.toLowerCase().match(/[\p{L}\p{N}_]+/gu) ?? [];
 }
+/**
+ * A temporary `NEW` marker in Conductor's picker is a badge, not part of the
+ * model name. The relay and phone use this value for the visible label and for
+ * a later selection, so both sides must remove it in the same way.
+ */
+export function modelPickerLabel(label) {
+    return label.endsWith(' NEW') ? label.slice(0, -4) : label;
+}
 /**
  * Markers the relay wraps search hits in (src/search.ts, via FTS5 `snippet()`). They
  * are control characters, so they must never reach the DOM: an unsplit snippet renders

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

@@ -3,6 +3,7 @@ import { execFile } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
 import { promisify } from 'node:util';
+import { modelPickerLabel } from "./shared.js";
 import { sidecarAvailable, sidecarSendUserMessage } from "./sidecar.js";
 const exec = promisify(execFile);
 /** Waiting runs past this are refused rather than queued. */
@@ -584,8 +585,9 @@ return my listModels()`.trim();
         const models = stdout
             .split('\n')
             .map(s => s.trim())
+            .map(modelPickerLabel)
             .filter(Boolean);
-        return { ok: true, models };
+        return { ok: true, models: [...new Set(models)] };
     }
     catch (err) {
         return { ok: false, error: osaError(err) };

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
 	"name": "conductor-remote",
-	"version": "1.46.0",
+	"version": "1.46.2",
 	"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.",
@@ -50,13 +50,16 @@
 		"typecheck": "tsc -p tsconfig.json",
 		"lint": "biome check .",
 		"fix": "biome check . --fix",
-		"verify": "yarn typecheck && yarn lint && yarn check:imports && yarn check:routes && yarn check:attachments && yarn check:applescript && yarn check:nosleep && yarn check:uilock && yarn check:firstprompt",
+		"verify": "yarn typecheck && yarn lint && yarn check:imports && yarn check:routes && yarn check:attachments && yarn check:applescript && yarn check:model-labels && yarn check:nosleep && yarn check:uilock && yarn check:firstprompt && yarn check:sendonce && yarn check:notify",
 		"release": "semantic-release",
 		"prepack": "yarn build && yarn build:node",
 		"postinstall": "husky || true",
 		"check:attachments": "node scripts/check-attachments.ts",
 		"check:applescript": "node scripts/check-applescript.ts",
 		"check:firstprompt": "node scripts/check-firstprompt.ts",
+		"check:model-labels": "node scripts/check-model-labels.ts",
+		"check:sendonce": "node scripts/check-sendonce.ts",
+		"check:notify": "node scripts/check-notify.ts",
 		"check:imports": "node scripts/check-imports.ts",
 		"check:nosleep": "node scripts/check-nosleep.ts",
 		"check:routes": "node scripts/check-routes.ts",