conductor-remote 1.92.2 → 1.93.0

package/dist-node/src/run-configs.js

@@ -0,0 +1,337 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const fileCache = new Map();
+/** Remove a TOML comment without treating a `#` inside a quoted string as one. */
+function withoutComment(line) {
+    let quote = null;
+    let escaped = false;
+    for (let i = 0; i < line.length; i++) {
+        const char = line[i];
+        if (quote === '"' && escaped) {
+            escaped = false;
+            continue;
+        }
+        if (quote === '"' && char === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === '"' || char === "'")
+            quote = char;
+        else if (char === '#')
+            return line.slice(0, i);
+    }
+    return line;
+}
+/** Strip comments from a value that can span several physical TOML lines. */
+function withoutComments(value) {
+    return value
+        .split(/\r?\n/)
+        .map(line => withoutComment(line))
+        .join('\n');
+}
+function tomlString(raw) {
+    const value = withoutComment(raw).trim();
+    if (value.startsWith("'") && value.endsWith("'") && !value.startsWith("'''"))
+        return value.slice(1, -1);
+    if (!(value.startsWith('"') && value.endsWith('"')) || value.startsWith('"""'))
+        return null;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+/** Split a TOML dotted key, retaining dots inside quoted components. */
+function dottedKey(raw) {
+    const parts = [];
+    let start = 0;
+    let quote = null;
+    let escaped = false;
+    for (let i = 0; i < raw.length; i++) {
+        const char = raw[i];
+        if (quote === '"' && escaped) {
+            escaped = false;
+            continue;
+        }
+        if (quote === '"' && char === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === '"' || char === "'")
+            quote = char;
+        else if (char === '.') {
+            parts.push(raw.slice(start, i));
+            start = i + 1;
+        }
+    }
+    if (quote)
+        return null;
+    parts.push(raw.slice(start));
+    const decoded = parts.map(part => {
+        const value = part.trim();
+        if (!value)
+            return null;
+        if (value.startsWith('"') || value.startsWith("'"))
+            return tomlString(value);
+        return /^[A-Za-z0-9_-]+$/.test(value) ? value : null;
+    });
+    return decoded.every((part) => part !== null) ? decoded : null;
+}
+function tablePath(line) {
+    const clean = withoutComment(line).trim();
+    if (clean.startsWith('[['))
+        return null;
+    const match = clean.match(/^\[([^\]]+)]$/);
+    return match ? dottedKey(match[1]) : null;
+}
+function assignment(line) {
+    const clean = withoutComment(line);
+    let quote = null;
+    let escaped = false;
+    for (let i = 0; i < clean.length; i++) {
+        const char = clean[i];
+        if (quote === '"' && escaped) {
+            escaped = false;
+            continue;
+        }
+        if (quote === '"' && char === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === '"' || char === "'")
+            quote = char;
+        else if (char === '=') {
+            const key = dottedKey(clean.slice(0, i));
+            if (key?.length !== 1)
+                return null;
+            return { key: key[0], value: clean.slice(i + 1).trim() };
+        }
+    }
+    return null;
+}
+function multilineDelimiter(value) {
+    const trimmed = value.trimStart();
+    for (const delimiter of ['"""', "'''"]) {
+        if (!trimmed.startsWith(delimiter))
+            continue;
+        return trimmed.indexOf(delimiter, delimiter.length) < 0 ? delimiter : null;
+    }
+    return null;
+}
+function stringValue(value) {
+    if (tomlString(value) !== null)
+        return true;
+    const trimmed = withoutComments(value).trim();
+    return ((trimmed.startsWith('"""') && trimmed.indexOf('"""', 3) >= 3) ||
+        (trimmed.startsWith("'''") && trimmed.indexOf("'''", 3) >= 3));
+}
+function arrayOpen(value) {
+    let depth = 0;
+    let quote = null;
+    let escaped = false;
+    for (const char of withoutComments(value)) {
+        if (quote === '"' && escaped) {
+            escaped = false;
+            continue;
+        }
+        if (quote === '"' && char === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === '"' || char === "'")
+            quote = char;
+        else if (char === '[')
+            depth++;
+        else if (char === ']')
+            depth--;
+    }
+    return depth > 0;
+}
+function stringList(raw) {
+    const scalar = tomlString(raw);
+    if (scalar !== null)
+        return [scalar];
+    const value = withoutComments(raw).trim();
+    if (!value.startsWith('[') || !value.endsWith(']'))
+        return null;
+    const values = [];
+    let start = 1;
+    let quote = null;
+    let escaped = false;
+    for (let i = 1; i < value.length - 1; i++) {
+        const char = value[i];
+        if (quote === '"' && escaped) {
+            escaped = false;
+            continue;
+        }
+        if (quote === '"' && char === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === '"' || char === "'")
+            quote = char;
+        else if (char === ',') {
+            const item = tomlString(value.slice(start, i));
+            if (item === null)
+                return null;
+            values.push(item);
+            start = i + 1;
+        }
+    }
+    const tail = value.slice(start, -1).trim();
+    if (tail) {
+        const item = tomlString(tail);
+        if (item === null)
+            return null;
+        values.push(item);
+    }
+    return values;
+}
+function displayName(id) {
+    return id
+        .replace(/[-\s]+/g, ' ')
+        .trim()
+        .replace(/(^| )([a-z])/g, (_whole, prefix, letter) => `${prefix}${letter.toUpperCase()}`);
+}
+function parseLayer(text) {
+    const configs = new Map();
+    let kind = null;
+    let section = [];
+    let multiline = null;
+    const lines = text.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (multiline) {
+            if (line.includes(multiline))
+                multiline = null;
+            continue;
+        }
+        const header = tablePath(line);
+        if (header) {
+            section = header;
+            if (section.length === 3 && section[0] === 'scripts' && section[1] === 'run') {
+                kind = 'named';
+                const id = section[2];
+                if (!configs.has(id))
+                    configs.set(id, { id });
+            }
+            continue;
+        }
+        const found = assignment(line);
+        if (!found)
+            continue;
+        multiline = multilineDelimiter(found.value);
+        if (section.length === 1 && section[0] === 'scripts' && found.key === 'run') {
+            if (stringValue(found.value) || multiline)
+                kind = 'legacy';
+            continue;
+        }
+        if (section.length !== 3 || section[0] !== 'scripts' || section[1] !== 'run')
+            continue;
+        const config = configs.get(section[2]) ?? { id: section[2] };
+        configs.set(config.id, config);
+        if (found.key === 'command' && (stringValue(found.value) || multiline))
+            config.command = true;
+        else if (found.key === 'hide' && /^(?:true|false)$/.test(found.value))
+            config.hide = found.value === 'true';
+        else if (found.key === 'available_in') {
+            let value = found.value;
+            while (arrayOpen(value) && i + 1 < lines.length)
+                value += `\n${lines[++i]}`;
+            const available = stringList(value);
+            if (available)
+                config.availableIn = available;
+        }
+    }
+    return { kind, configs: [...configs.values()] };
+}
+function resolveLayers(layers) {
+    let kind = null;
+    const resolved = new Map();
+    for (const layer of layers) {
+        if (layer.kind === 'legacy') {
+            kind = 'legacy';
+            resolved.clear();
+            continue;
+        }
+        if (layer.kind !== 'named')
+            continue;
+        if (kind === 'legacy')
+            resolved.clear();
+        kind = 'named';
+        for (const patch of layer.configs) {
+            const previous = resolved.get(patch.id) ?? { id: patch.id };
+            resolved.set(patch.id, { ...previous, ...patch });
+        }
+    }
+    if (kind !== 'named')
+        return [];
+    return [...resolved.values()].flatMap(config => {
+        if (!config.command || config.hide || (config.availableIn && !config.availableIn.includes('local')))
+            return [];
+        return [{ id: config.id, name: displayName(config.id) }];
+    });
+}
+/** Resolve lower-to-higher-priority TOML layers using Conductor's per-ID merge. */
+export function resolveRunConfigs(layers) {
+    return resolveLayers(layers.map(parseLayer));
+}
+function readLayer(file) {
+    try {
+        const stat = fs.statSync(file);
+        const cached = fileCache.get(file);
+        if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size)
+            return cached.value;
+        const source = fs.readFileSync(file, 'utf8');
+        const value = parseLayer(source);
+        fileCache.set(file, { mtimeMs: stat.mtimeMs, size: stat.size, value });
+        return value;
+    }
+    catch {
+        fileCache.delete(file);
+        return null;
+    }
+}
+/** Read the same user -> shared -> local -> managed settings layers Conductor resolves. */
+export function runConfigsFor(workspace) {
+    const shared = workspace.worktree
+        ? path.join(workspace.worktree, '.conductor', 'settings.toml')
+        : workspace.repo_root
+            ? path.join(workspace.repo_root, '.conductor', 'settings.toml')
+            : null;
+    const files = [
+        path.join(os.homedir(), '.conductor', 'settings.toml'),
+        shared,
+        workspace.repo_root ? path.join(workspace.repo_root, '.conductor', 'settings.local.toml') : null,
+        workspace.worktree ? path.join(workspace.worktree, '.conductor', 'settings.local.toml') : null,
+        path.join(os.homedir(), '.conductor', 'settings.managed.toml')
+    ];
+    return resolveLayers(files.flatMap(file => (file ? [readLayer(file)].filter((layer) => layer !== null) : [])));
+}

package/dist-node/src/server.js

@@ -13,6 +13,7 @@ import { ConductorDb } from "./db.js";
 import { DevServerController } from "./dev-server.js";
 import { isAllowedPreviewPath, parseFileReference } from "./file-preview.js";
 import { FirstPromptQueue } from "./firstprompt.js";
+import { captureForkWorkspace, materializeForkWorkspace, releaseForkWorkspace } from "./fork-workspace.js";
 import { startFunnelWatchdog } from "./funnel-watchdog.js";
 import { listSourceFiles, workspaceDiff } from "./git.js";
 import { installLogCapture, isManaged, LOG_FILE_NAMES, logFiles, processStartedAt, recentLogs, redactSecrets, tailLogFile } from "./logbuf.js";
@@ -94,6 +95,41 @@ const mcpTools = createTools(async (route, opts = {}) => {
 // the phone opening the app and the send landing.
 setRestartGuard(() => !reads.listWorkspaces().some(w => w.session_status === 'working'));
 const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+/**
+ * A deep link has no request id to correlate with the workspace row it creates. Keep
+ * relay-originated creations single-flight until that row appears, or two simultaneous
+ * requests can each claim the other's workspace. Manual desktop creation can still
+ * happen in the gap, so callers also narrow the fresh row to the requested repo.
+ */
+let workspaceCreationTail = Promise.resolve();
+async function createWorkspaceAndRead(prompt, repoPath, repoName) {
+    const previous = workspaceCreationTail;
+    let release = () => { };
+    workspaceCreationTail = new Promise(resolve => {
+        release = resolve;
+    });
+    await previous;
+    try {
+        const before = new Set(reads.listWorkspaces().map(w => w.id));
+        const result = await createWorkspace(prompt, repoPath);
+        if (!result.ok)
+            return { result };
+        // The deep link is fire-and-forget, so the new row is the only proof it worked.
+        // Creating a worktree takes a beat longer than opening a chat does.
+        for (let attempt = 0; attempt < 40; attempt++) {
+            await sleep(500);
+            const created = reads
+                .listWorkspaces()
+                .find(workspace => !before.has(workspace.id) && (!repoName || workspace.repo_name === repoName));
+            if (created)
+                return { result, created };
+        }
+        return { result };
+    }
+    finally {
+        release();
+    }
+}
 /**
  * Has Conductor taken ownership of the prompt yet? The receipt everything below is
  * built on. The AppleScript actuator reports `ok` on `osascript` exit 0 — which only
@@ -1188,17 +1224,9 @@ const server = http.createServer(async (req, res) => {
                     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 before = new Set(reads.listWorkspaces().map(w => w.id));
-                const result = await createWorkspace(prompt, repo?.root_path ?? null);
+                const { result, created } = await createWorkspaceAndRead(prompt, repo?.root_path ?? null, repo?.name);
                 if (!result.ok)
                     return json(req, res, 502, result);
-                // The deep link is fire-and-forget, so the new row is the only proof it worked.
-                // Creating a worktree takes a beat longer than opening a chat does.
-                let created;
-                for (let attempt = 0; attempt < 40 && !created; attempt++) {
-                    await sleep(500);
-                    created = reads.listWorkspaces().find(w => !before.has(w.id));
-                }
                 if (!created) {
                     return json(req, res, 502, {
                         ok: false,
@@ -1463,9 +1491,9 @@ const server = http.createServer(async (req, res) => {
                 }
                 return json(req, res, 200, { ok: true, strategy: result.strategy, workspace: archived });
             }
-            // The selected Conductor Run task plus a tailnet-only HTTPS forward for
-            // its allocated port. Reads never touch Conductor's UI; start/stop use the
-            // same Accessibility lock and target assertion as every other UI write.
+            // Conductor's Run configs plus tailnet-only HTTPS forwards for the active
+            // one's ports. Reads never touch Conductor's UI; start/stop use the same
+            // Accessibility lock and target assertion as every other UI write.
             const devServerOf = routeParam(routes.devServer, req.method, pathname);
             if (devServerOf) {
                 const ws = reads.getWorkspace(devServerOf);
@@ -1478,7 +1506,11 @@ const server = http.createServer(async (req, res) => {
                 const ws = reads.getWorkspace(startDevServerIn);
                 if (!ws)
                     return json(req, res, 404, { error: 'workspace not found' });
-                const result = await devServers.start(ws);
+                const body = JSON.parse((await readBody(req)) || '{}');
+                if (body.runConfigId !== undefined && (typeof body.runConfigId !== 'string' || !body.runConfigId.trim())) {
+                    return json(req, res, 400, { error: 'runConfigId must be a non-empty string' });
+                }
+                const result = await devServers.start(ws, body.runConfigId);
                 return json(req, res, result.ok ? 200 : result.available ? 502 : 409, result);
             }
             const stopDevServerIn = routeParam(routes.stopDevServer, req.method, pathname);
@@ -1811,11 +1843,13 @@ const server = http.createServer(async (req, res) => {
                 return json(req, res, answer.status, answer.body);
             }
             // POST /api/sessions/:id/split
-            //      { prompt?, includeThinking?, includeTools?, throughRowid?, onlyRowid? }
+            //      { prompt?, includeThinking?, includeTools?, throughRowid?, onlyRowid?, destination? }
             //
-            // Conductor's own "Fork to new tab" resumes the agent's real session. This copies
-            // the conversation instead, as a Conductor attachment, which is the cut that
-            // survives being read by a *different* agent: prose and reasoning, no tool churn.
+            // Conductor's own tab fork resumes the agent's real session. This copies the
+            // conversation instead, as a Conductor attachment, which is the cut that survives
+            // being read by a *different* agent: prose and reasoning, no tool churn. Its
+            // destination can be another tab over the same files, or a new workspace whose
+            // Git layers are restored from the source's current worktree snapshot.
             // Two reasons it exists at all. A tangent asked inside a running chat leaves three
             // conversations interleaved in one tab, which reads badly for everyone afterwards;
             // and Conductor's fork lives on a hover menu over one message, which an agent
@@ -1823,9 +1857,10 @@ const server = http.createServer(async (req, res) => {
             // gets more expensive the longer the chat is.
             //
             // It stops before sending. The composed prompt goes out through the ordinary send
-            // route so it inherits the retry loop, the transcript confirm and the parked queue
-            // — and because ⌘T plus a send is two UI turns, which together outlast any caller's
-            // budget (28s + 55s against the MCP client's 75s).
+            // route so it inherits the retry loop, the transcript confirm and the parked queue.
+            // For a tab, that also keeps ⌘T plus a send from becoming two UI turns inside one
+            // request (28s + 55s against the MCP client's 75s); for a workspace it leaves the
+            // staged handoff as the same editable draft the phone already presents for a tab.
             const splitFrom = routeParam(routes.splitChat, req.method, pathname);
             if (splitFrom) {
                 const sessionId = splitFrom;
@@ -1842,6 +1877,10 @@ const server = http.createServer(async (req, res) => {
                 const source = reads.listSessions(ws.id).find(s => s.id === sessionId);
                 if (!source)
                     return json(req, res, 404, { error: 'chat not found in that workspace' });
+                const destination = body.destination ?? 'chat';
+                if (destination !== 'chat' && destination !== 'workspace') {
+                    return json(req, res, 400, { error: 'destination must be chat or workspace' });
+                }
                 const format = { thinking: body.includeThinking !== false, tools: body.includeTools === true };
                 const { entries } = reads.getMessages(sessionId);
                 const through = body.throughRowid;
@@ -1888,10 +1927,90 @@ const server = http.createServer(async (req, res) => {
                     '',
                     ''
                 ].join('\n');
-                const attachment = writeAttachment(ws.worktree, `Transcript of ${title}.md`, header + rendered.text);
+                const transcript = header + rendered.text;
+                if (destination === 'workspace') {
+                    if (!(ws.repo_name && ws.repo_root)) {
+                        return json(req, res, 409, { error: 'the source workspace has no repository checkout to fork' });
+                    }
+                    let snapshot;
+                    try {
+                        snapshot = await captureForkWorkspace(ws.worktree);
+                    }
+                    catch (err) {
+                        const reason = err instanceof Error ? err.message : 'Git could not capture the worktree';
+                        return json(req, res, 502, { error: `Could not snapshot the source workspace: ${reason}` });
+                    }
+                    let staged;
+                    let materialized = false;
+                    let created;
+                    try {
+                        staged = stageAttachment(STAGED_ATTACHMENTS_DIR, `Transcript of ${title}.md`, Buffer.from(transcript));
+                        const creation = await createWorkspaceAndRead('', ws.repo_root, ws.repo_name);
+                        if (!creation.result.ok)
+                            return json(req, res, 502, creation.result);
+                        created = creation.created;
+                        if (!created) {
+                            return json(req, res, 502, {
+                                error: 'Conductor didn’t create the fork workspace — check it’s running and not showing a dialog.'
+                            });
+                        }
+                        // The DB row can precede `.git` by a tick. Install the snapshot at the
+                        // first verified worktree path, before Conductor starts the new agent.
+                        let target = reads.getWorkspace(created.id) ?? created;
+                        for (let attempt = 0; attempt < 20 && !target.worktree; attempt++) {
+                            await sleep(250);
+                            target = reads.getWorkspace(created.id) ?? target;
+                        }
+                        if (!target.worktree)
+                            throw new Error('the new workspace worktree path never became available');
+                        await materializeForkWorkspace(snapshot, target.worktree);
+                        materializeStagedAttachments(STAGED_ATTACHMENTS_DIR, target.worktree, [staged.stageId]);
+                        materialized = true;
+                        discardStagedAttachment(STAGED_ATTACHMENTS_DIR, staged.stageId);
+                        let destinationSession = reads.listSessions(created.id)[0];
+                        for (let attempt = 0; attempt < 12 && !destinationSession; attempt++) {
+                            await sleep(250);
+                            destinationSession = reads.listSessions(created.id)[0];
+                        }
+                        return json(req, res, 200, {
+                            ok: true,
+                            destination,
+                            sessionId: destinationSession?.id ?? null,
+                            workspaceId: created.id,
+                            text: attachmentPrompt(staged.token, body.prompt),
+                            attachment: {
+                                name: staged.name,
+                                path: staged.path,
+                                bytes: staged.bytes,
+                                kept: rendered.kept,
+                                elided
+                            }
+                        });
+                    }
+                    catch (err) {
+                        const reason = err instanceof Error ? err.message : 'the current files could not be copied';
+                        return json(req, res, 502, {
+                            error: created
+                                ? `Workspace ${created.id} was created, but its code fork failed: ${reason}`
+                                : `Could not create the code fork: ${reason}`
+                        });
+                    }
+                    finally {
+                        if (staged && !materialized)
+                            discardStagedAttachment(STAGED_ATTACHMENTS_DIR, staged.stageId);
+                        await releaseForkWorkspace(snapshot).catch(err => {
+                            console.warn(`[relay] could not release fork snapshot ${snapshot.ref}: ${err instanceof Error ? err.message : err}`);
+                        });
+                    }
+                }
+                const attachment = writeAttachment(ws.worktree, `Transcript of ${title}.md`, transcript);
                 const opened = await openChat(ws);
                 if ('error' in opened) {
-                    return json(req, res, 502, { ...opened.result, attachment: { ...attachment, ...rendered, elided } });
+                    return json(req, res, 502, {
+                        ...opened.result,
+                        destination,
+                        attachment: { ...attachment, ...rendered, elided }
+                    });
                 }
                 // The token is what Conductor turns into the attachment chip and supplies to the
                 // receiving agent. Do not repeat `attachment.relPath` in prose: that renders a
@@ -1899,6 +2018,7 @@ const server = http.createServer(async (req, res) => {
                 const text = attachmentPrompt(attachment.token, body.prompt);
                 return json(req, res, 200, {
                     ok: true,
+                    destination,
                     sessionId: opened.sessionId,
                     workspaceId: ws.id,
                     text,

package/dist-node/src/writes.js

@@ -962,27 +962,35 @@ end tell`.trim();
     }
 }
 /**
- * Start or stop the selected workspace Run task through Conductor's own toolbar.
+ * Start one exact workspace Run task, or stop the running one, through Conductor's toolbar.
  *
  * The task stays owned by Conductor — it appears in the Run panel, inherits the
  * repository's run mode and environment, and Conductor performs its normal
- * process-group shutdown. The relay only presses the same Run/Stop button a
- * person would, after focusing and asserting the target workspace.
+ * process-group shutdown. A named start selects that item from Conductor's own
+ * Run menu; an unnamed legacy start proceeds only when the live menu contains one
+ * task. Every path focuses and asserts the target workspace before touching it.
  */
-export async function setRunTask(workspace, running) {
+export async function setRunTask(workspace, running, runTaskName) {
     if (!focusQuery(workspace))
         return { ok: false, error: 'workspace has no branch to focus' };
     const script = `
 ${CONDUCTOR_HANDLERS}
 
 set wantRunning to (system attribute "RELAY_RUN_WANTED") is "1"
-return my setRunTask(wantRunning)`.trim();
+set wantedTask to do shell script "cat " & quoted form of (system attribute "RELAY_RUN_TASK_FILE")
+return my setRunTask(wantRunning, wantedTask)`.trim();
+    const os = await import('node:os');
+    const fs = await import('node:fs/promises');
+    const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'relay-run-task-'));
+    const taskFile = path.join(directory, 'name');
     try {
+        await fs.writeFile(taskFile, runTaskName ?? '', 'utf8');
         const { stdout } = await withTargetEnvironment({ workspace, sessionId: workspace.active_session_id }, targetEnvironment => uiTurn(() => exec('osascript', ['-e', script], {
             env: {
                 ...process.env,
                 ...targetEnvironment,
-                RELAY_RUN_WANTED: running ? '1' : '0'
+                RELAY_RUN_WANTED: running ? '1' : '0',
+                RELAY_RUN_TASK_FILE: taskFile
             },
             timeout: SEND_ATTEMPT_MS
         })));
@@ -998,6 +1006,9 @@ return my setRunTask(wantRunning)`.trim();
     catch (err) {
         return { ok: false, error: osaError(err, 'Conductor took too long to change the Run task') };
     }
+    finally {
+        await fs.rm(directory, { recursive: true, force: true }).catch(() => undefined);
+    }
 }
 export function pickActuator(strategy) {
     return strategy === 'sidecar' ? new SidecarActuator() : new AppleScriptActuator();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "conductor-remote",
-	"version": "1.92.2",
+	"version": "1.93.0",
 	"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.",