conductor-remote 1.81.0 → 1.83.0

package/dist-node/src/plan-usage.js

@@ -0,0 +1,430 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+function object(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function text(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+function number(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function percent(value) {
+    const parsed = number(value);
+    return parsed === null ? null : Math.max(0, Math.min(100, parsed));
+}
+function timestamp(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        // Codex reports seconds; tolerate milliseconds if the protocol changes.
+        return value < 10_000_000_000 ? value * 1000 : value;
+    }
+    if (typeof value !== 'string')
+        return null;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function codexWindowLabel(duration, slot) {
+    if (duration === 300)
+        return '5-hour limit';
+    if (duration === 1_440)
+        return 'Daily limit';
+    if (duration === 10_080)
+        return 'Weekly limit';
+    if (duration && duration % 1_440 === 0)
+        return `${duration / 1_440}-day limit`;
+    if (duration && duration % 60 === 0)
+        return `${duration / 60}-hour limit`;
+    return slot === 'primary' ? 'Primary limit' : 'Secondary limit';
+}
+function codexWindow(bucketId, slot, raw) {
+    const value = object(raw);
+    const usedPercent = percent(value?.usedPercent);
+    if (!value || usedPercent === null)
+        return null;
+    const duration = number(value.windowDurationMins);
+    return {
+        id: `${bucketId}:${slot}`,
+        label: codexWindowLabel(duration, slot),
+        usedPercent,
+        resetsAt: timestamp(value.resetsAt),
+        windowDurationMins: duration
+    };
+}
+/** Reduce Codex's app-server response to the stable, provider-neutral wire shape. */
+export function parseCodexPlanUsage(raw) {
+    const envelope = object(raw);
+    const payload = object(envelope?.result) ?? envelope;
+    const legacy = object(payload?.rateLimits);
+    const byLimit = object(payload?.rateLimitsByLimitId);
+    const entries = byLimit && Object.keys(byLimit).length ? Object.entries(byLimit) : legacy ? [['codex', legacy]] : [];
+    const buckets = [];
+    let plan = null;
+    for (const [key, candidate] of entries) {
+        const snapshot = object(candidate);
+        if (!snapshot)
+            continue;
+        plan ??= text(snapshot.planType);
+        const id = text(snapshot.limitId) ?? key;
+        const windows = [
+            codexWindow(id, 'primary', snapshot.primary),
+            codexWindow(id, 'secondary', snapshot.secondary)
+        ].filter((window) => window !== null);
+        if (!windows.length)
+            continue;
+        buckets.push({ id, label: text(snapshot.limitName) ?? (id === 'codex' ? 'Codex' : id), windows });
+    }
+    if (!buckets.length) {
+        return {
+            provider: 'codex',
+            label: 'Codex',
+            status: 'unavailable',
+            plan,
+            buckets: [],
+            message: 'Codex returned no rolling plan limits for this account.'
+        };
+    }
+    buckets.sort((a, b) => Number(b.id === 'codex') - Number(a.id === 'codex') || a.label.localeCompare(b.label));
+    return { provider: 'codex', label: 'Codex', status: 'available', plan, buckets };
+}
+function claudeWindowLabel(limit) {
+    const kind = text(limit.kind);
+    const model = text(object(object(limit.scope)?.model)?.display_name);
+    if (kind === 'session')
+        return 'Current session';
+    if (kind === 'weekly_all')
+        return 'Current week';
+    if (kind === 'weekly_scoped' && model)
+        return `Current week (${model})`;
+    if (model)
+        return model;
+    return kind?.replaceAll('_', ' ') ?? 'Plan limit';
+}
+function claudeWindow(id, label, raw, active) {
+    const value = object(raw);
+    const usedPercent = percent(value?.utilization ?? value?.percent);
+    if (!value || usedPercent === null)
+        return null;
+    return {
+        id,
+        label,
+        usedPercent,
+        resetsAt: timestamp(value.resets_at),
+        ...(active === undefined ? {} : { active })
+    };
+}
+/** Reduce Claude's experimental `get_usage` control response; tolerate its older named-window shape. */
+export function parseClaudePlanUsage(raw) {
+    const envelope = object(raw);
+    const control = object(envelope?.response);
+    const payload = object(control?.response) ?? envelope;
+    const plan = text(payload?.subscription_type);
+    if (payload?.rate_limits_available === false) {
+        return {
+            provider: 'claude',
+            label: 'Claude Code',
+            status: 'unavailable',
+            plan,
+            buckets: [],
+            message: 'Plan limits are not available for API-key or third-party-provider sessions.'
+        };
+    }
+    const rateLimits = object(payload?.rate_limits);
+    const windows = [];
+    const limits = Array.isArray(rateLimits?.limits) ? rateLimits.limits : [];
+    for (const [index, candidate] of limits.entries()) {
+        const limit = object(candidate);
+        if (!limit)
+            continue;
+        const kind = text(limit.kind);
+        // These are the rolling plan allowances. Spend/credit records have a different
+        // unit and belong in a future money-shaped control rather than a percentage bar.
+        if (!kind || !['session', 'weekly_all', 'weekly_scoped'].includes(kind))
+            continue;
+        const model = text(object(object(limit.scope)?.model)?.display_name);
+        const parsed = claudeWindow(`claude:${kind}:${model ?? index}`, claudeWindowLabel(limit), limit, limit.is_active === true);
+        if (parsed)
+            windows.push(parsed);
+    }
+    // Claude 2.1 first exposed the same data as named fields. Keep this fallback so an
+    // app update that removes the additive `limits` array does not blank the whole card.
+    if (!windows.length && rateLimits) {
+        const named = [
+            ['five_hour', 'Current session'],
+            ['seven_day', 'Current week'],
+            ['seven_day_opus', 'Current week (Opus)'],
+            ['seven_day_sonnet', 'Current week (Sonnet)']
+        ];
+        for (const [key, label] of named) {
+            const parsed = claudeWindow(`claude:${key}`, label, rateLimits[key]);
+            if (parsed)
+                windows.push(parsed);
+        }
+        const scoped = Array.isArray(rateLimits.model_scoped) ? rateLimits.model_scoped : [];
+        for (const [index, candidate] of scoped.entries()) {
+            const value = object(candidate);
+            const model = text(value?.display_name);
+            const parsed = claudeWindow(`claude:model:${model ?? index}:${index}`, `Current week (${model ?? 'model'})`, value);
+            if (parsed)
+                windows.push(parsed);
+        }
+    }
+    if (!windows.length) {
+        return {
+            provider: 'claude',
+            label: 'Claude Code',
+            status: 'unavailable',
+            plan,
+            buckets: [],
+            message: 'Claude Code returned no rolling plan limits for this account.'
+        };
+    }
+    return {
+        provider: 'claude',
+        label: 'Claude Code',
+        status: 'available',
+        plan,
+        buckets: [{ id: 'claude', label: 'Claude Code', windows }]
+    };
+}
+const BUNDLED_BINARIES = path.join(os.homedir(), 'Library', 'Application Support', 'com.conductor.app', 'agent-binaries');
+/** Prefer the CLI Conductor runs, falling back to the user's PATH for older app installs. */
+function agentBinary(provider) {
+    const root = path.join(BUNDLED_BINARIES, provider);
+    try {
+        const versions = fs
+            .readdirSync(root, { withFileTypes: true })
+            .filter(entry => entry.isDirectory())
+            .map(entry => entry.name)
+            .sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
+        for (const version of versions) {
+            const candidate = path.join(root, version, provider);
+            try {
+                fs.accessSync(candidate, fs.constants.X_OK);
+                return candidate;
+            }
+            catch {
+                // A half-downloaded version is not a CLI; try the next one.
+            }
+        }
+    }
+    catch {
+        // Conductor did not bundle this harness yet; spawn can still resolve the user's CLI.
+    }
+    return provider;
+}
+const MAX_CLI_OUTPUT = 4 * 1024 * 1024;
+function failureMessage(name, stderr, code) {
+    const detail = stderr.trim().slice(-2_000);
+    return new Error(`${name} exited before returning usage${code === null ? '' : ` (${code})`}${detail ? `: ${detail}` : ''}`);
+}
+function codexResponse(binary = agentBinary('codex')) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(binary, ['app-server'], { stdio: ['pipe', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        let requested = false;
+        let settled = false;
+        const finish = (error, result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.kill();
+            if (error)
+                reject(error);
+            else
+                resolve(result);
+        };
+        const timer = setTimeout(() => finish(new Error('Codex plan-usage read timed out')), 8_000);
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        child.stderr.on('data', chunk => {
+            stderr = (stderr + chunk).slice(-MAX_CLI_OUTPUT);
+        });
+        child.stdout.on('data', chunk => {
+            stdout += chunk;
+            if (stdout.length > MAX_CLI_OUTPUT)
+                return finish(new Error('Codex plan-usage response was too large'));
+            let newline = stdout.indexOf('\n');
+            while (newline >= 0) {
+                const line = stdout.slice(0, newline).trim();
+                stdout = stdout.slice(newline + 1);
+                newline = stdout.indexOf('\n');
+                if (!line)
+                    continue;
+                let message;
+                try {
+                    message = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (message.id === 1 && !requested) {
+                    requested = true;
+                    child.stdin.write(`${JSON.stringify({ method: 'initialized' })}\n`);
+                    child.stdin.write(`${JSON.stringify({ id: 2, method: 'account/rateLimits/read', params: null })}\n`);
+                }
+                else if (message.id === 2) {
+                    if (message.error)
+                        return finish(new Error('Codex rejected the plan-usage request'));
+                    return finish(null, message);
+                }
+            }
+        });
+        child.on('error', error => finish(error));
+        child.on('close', code => finish(failureMessage('Codex', stderr, code)));
+        child.stdin.on('error', error => finish(error));
+        child.stdin.write(`${JSON.stringify({
+            id: 1,
+            method: 'initialize',
+            params: { clientInfo: { name: 'conductor-remote', version: '1' } }
+        })}\n`);
+    });
+}
+function claudeResponse(binary = agentBinary('claude')) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(binary, [
+            '-p',
+            '--input-format',
+            'stream-json',
+            '--output-format',
+            'stream-json',
+            '--verbose',
+            '--no-session-persistence',
+            '--safe-mode'
+        ], { stdio: ['pipe', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        const finish = (error, result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.kill();
+            if (error)
+                reject(error);
+            else
+                resolve(result);
+        };
+        const timer = setTimeout(() => finish(new Error('Claude plan-usage read timed out')), 10_000);
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        child.stderr.on('data', chunk => {
+            stderr = (stderr + chunk).slice(-MAX_CLI_OUTPUT);
+        });
+        child.stdout.on('data', chunk => {
+            stdout += chunk;
+            if (stdout.length > MAX_CLI_OUTPUT)
+                return finish(new Error('Claude plan-usage response was too large'));
+            let newline = stdout.indexOf('\n');
+            while (newline >= 0) {
+                const line = stdout.slice(0, newline).trim();
+                stdout = stdout.slice(newline + 1);
+                newline = stdout.indexOf('\n');
+                if (!line)
+                    continue;
+                let message;
+                try {
+                    message = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                const response = object(message.response);
+                if (message.type !== 'control_response' || response?.request_id !== 'plan-usage')
+                    continue;
+                if (response.subtype !== 'success')
+                    return finish(new Error('Claude rejected the structured plan-usage request'));
+                return finish(null, message);
+            }
+        });
+        child.on('error', error => finish(error));
+        child.on('close', code => finish(failureMessage('Claude', stderr, code)));
+        child.stdin.on('error', error => finish(error));
+        child.stdin.end(`${JSON.stringify({
+            type: 'control_request',
+            request_id: 'plan-usage',
+            request: { subtype: 'get_usage' }
+        })}\n`);
+    });
+}
+function unavailable(provider, label, message) {
+    return { provider, label, status: 'unavailable', plan: null, buckets: [], message };
+}
+function failed(provider, label, error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    console.warn(`[relay] ${label} plan usage failed: ${detail}`);
+    const missing = error?.code === 'ENOENT';
+    return {
+        provider,
+        label,
+        status: missing ? 'unavailable' : 'error',
+        plan: null,
+        buckets: [],
+        message: missing ? `${label} is not installed on this Mac.` : `Could not read plan usage from ${label}.`
+    };
+}
+export async function readCodexPlanUsage() {
+    try {
+        return parseCodexPlanUsage(await codexResponse());
+    }
+    catch (error) {
+        return failed('codex', 'Codex', error);
+    }
+}
+export async function readClaudePlanUsage() {
+    try {
+        return parseClaudePlanUsage(await claudeResponse());
+    }
+    catch (error) {
+        return failed('claude', 'Claude Code', error);
+    }
+}
+const DEFAULT_READERS = [
+    { provider: 'claude', label: 'Claude Code', read: readClaudePlanUsage },
+    { provider: 'codex', label: 'Codex', read: readCodexPlanUsage }
+];
+const UNSUPPORTED = [
+    unavailable('cursor', 'Cursor Agent', 'Cursor Agent does not expose plan limits through its CLI.'),
+    unavailable('opencode', 'OpenCode', 'OpenCode reports local token and cost totals, not provider plan limits.')
+];
+/** Coalesced provider reads. `/api/usage` may be opened from several phones at once. */
+export class PlanUsageService {
+    readers;
+    cacheMs;
+    now;
+    cached = null;
+    inFlight = null;
+    constructor(options = {}) {
+        this.readers = options.readers ?? DEFAULT_READERS;
+        this.cacheMs = options.cacheMs ?? 60_000;
+        this.now = options.now ?? Date.now;
+    }
+    read(force = false) {
+        if (!force && this.cached && this.now() - this.cached.fetchedAt < this.cacheMs)
+            return Promise.resolve(this.cached);
+        if (this.inFlight)
+            return this.inFlight;
+        const pending = Promise.all(this.readers.map(async (reader) => {
+            try {
+                return await reader.read();
+            }
+            catch (error) {
+                return failed(reader.provider, reader.label, error);
+            }
+        })).then(providers => {
+            const snapshot = { providers: [...providers, ...UNSUPPORTED], fetchedAt: this.now() };
+            this.cached = snapshot;
+            return snapshot;
+        });
+        this.inFlight = pending;
+        void pending.finally(() => {
+            if (this.inFlight === pending)
+                this.inFlight = null;
+        });
+        return pending;
+    }
+}

package/dist-node/src/routes.js

@@ -46,6 +46,12 @@ export const routes = {
     repos: flat('GET', '/api/repos'),
     /** Picker labels the relay has previously read from Conductor, grouped by harness. */
     modelCatalog: flat('GET', '/api/models'),
+    /** Provider-specific defaults from Conductor's user settings TOML. */
+    modelDefaults: flat('GET', '/api/models/defaults'),
+    /** Update one or both provider defaults in Conductor's user settings TOML. */
+    updateModelDefaults: flat('PATCH', '/api/models/defaults'),
+    /** Rolling subscription limits, read without a model request from each provider CLI. */
+    planUsage: flat('GET', '/api/usage'),
     repoIcon: param('GET', '/api/repos/:repo/icon'),
     /** A temporary image emitted in a chat message, fetched with the phone's auth header. */
     localImage: param('GET', '/api/local-images/:path'),

package/dist-node/src/server.js

@@ -6,6 +6,7 @@ import path from 'node:path';
 import zlib from 'node:zlib';
 import { attachmentPrompt, writeAttachment } from "./attachments.js";
 import { startAutoUpdate, updateStatus } from "./autoupdate.js";
+import { isDefaultEffortLevel, readDefaultEfforts, writeDefaultEfforts } from "./conductor-settings.js";
 import { loadConfig, stateDir } from "./config.js";
 import { ConductorDb } from "./db.js";
 import { DevServerController } from "./dev-server.js";
@@ -20,6 +21,7 @@ import { ModelCache } from "./model-cache.js";
 import { armNoSleep, disarmNoSleep, MAX_SECONDS as NOSLEEP_MAX_SECONDS, nosleepState, watchNoSleepExpiry } from "./nosleep.js";
 import { chatRoute, noteViewing, notifyAll, notifyDevice, pushConfig, startNotifier, subscribeDevice, unsubscribeDevice } from "./notify.js";
 import { ParkedPromptQueue } from "./parked.js";
+import { PlanUsageService } from "./plan-usage.js";
 import { attachPrStatus } from "./pr.js";
 import { readPrefs, writePrefs } from "./prefs.js";
 import { Reads } from "./reads.js";
@@ -30,7 +32,7 @@ import { readSettings, writeSettings } from "./settings.js";
 import { VIEWING_HEADER, withoutWindowEvidence } from "./shared.js";
 import { discardStagedAttachment, materializeStagedAttachments, stageAttachment, stagedAttachments } from "./staged-attachments.js";
 import { driftWarningLines, readExposeMode, tailscaleBin } from "./tailscale.js";
-import { renderTranscript, transcriptThrough } from "./transcript.js";
+import { renderTranscript, transcriptMessage, transcriptThrough } from "./transcript.js";
 import { autoJoinHotspotMode, currentSsid, looksLikeHotspot, preferredNetworks } from "./wifi.js";
 import { archiveWorkspace, createWorkspace, describeActuator, EFFORT_LABELS, listAgentModels, lockBlocked, newChat, pickActuator, restartConductorApp, retryWontHelp, screenLocked, sendNeverStarted, setAgentOptions, setDefaultModel, setRestartGuard, setWorkspaceStatus, stopTurn, UiBusyError, uiQueueDepth, WORKSPACE_STATUS_LABELS, withUiPriority } from "./writes.js";
 // Before anything that logs: from here on every console line is also kept in memory for
@@ -46,6 +48,7 @@ const STAGED_ATTACHMENTS_DIR = path.join(stateDir(), 'attachment-staging');
 // relay state alongside the prompt queues. This lets a brand-new workspace choose
 // from a list before Conductor has created its first chat.
 const modelCache = new ModelCache(path.join(stateDir(), 'model-cache.json'));
+const planUsage = new PlanUsageService();
 // Full-text index over the chat prose, in the relay's own sidecar DB — never in
 // Conductor's (see src/search.ts). It backfills in the background and is disposable:
 // deleting the file rebuilds it on the next start.
@@ -880,6 +883,34 @@ const server = http.createServer(async (req, res) => {
             if (isRoute(routes.modelCatalog, req.method, pathname)) {
                 return json(req, res, 200, { groups: modelCache.list(), defaultModel: modelCache.defaultModel() });
             }
+            // GET/PATCH /api/models/defaults — the live user-wide effort defaults.
+            // These are file-backed settings, not the stale rows conductor.db still carries.
+            if (isRoute(routes.modelDefaults, req.method, pathname)) {
+                return json(req, res, 200, { defaultEfforts: readDefaultEfforts() });
+            }
+            if (isRoute(routes.updateModelDefaults, req.method, pathname)) {
+                const body = JSON.parse((await readBody(req)) || '{}');
+                const patch = {};
+                if (body.claude !== undefined) {
+                    if (!isDefaultEffortLevel(body.claude))
+                        return json(req, res, 400, { error: 'unknown Claude effort level' });
+                    patch.claude = body.claude;
+                }
+                if (body.codex !== undefined) {
+                    if (!isDefaultEffortLevel(body.codex))
+                        return json(req, res, 400, { error: 'unknown Codex effort level' });
+                    patch.codex = body.codex;
+                }
+                if (Object.keys(patch).length === 0)
+                    return json(req, res, 400, { error: 'nothing to change' });
+                return json(req, res, 200, { defaultEfforts: writeDefaultEfforts(patch) });
+            }
+            // GET /api/usage — structured subscription limits from the CLIs Conductor
+            // itself bundles. Both reads are prompt-free and cached; `refresh=1` is the
+            // explicit user action in the sheet, never a background poll.
+            if (isRoute(routes.planUsage, req.method, pathname)) {
+                return json(req, res, 200, await planUsage.read(url.searchParams.get('refresh') === '1'));
+            }
             // GET /api/settings — relay preferences plus what the phone needs to edit them:
             // the SSIDs this Mac already holds credentials for, so the picker offers a choice
             // instead of asking someone to type a network name from memory on a phone keyboard.
@@ -1619,7 +1650,8 @@ const server = http.createServer(async (req, res) => {
                 });
                 return json(req, res, answer.status, answer.body);
             }
-            // POST /api/sessions/:id/split { prompt?, includeThinking?, includeTools?, throughRowid? }
+            // POST /api/sessions/:id/split
+            //      { prompt?, includeThinking?, includeTools?, throughRowid?, onlyRowid? }
             //
             // 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
@@ -1653,14 +1685,25 @@ const server = http.createServer(async (req, res) => {
                 const format = { thinking: body.includeThinking !== false, tools: body.includeTools === true };
                 const { entries } = reads.getMessages(sessionId);
                 const through = body.throughRowid;
+                const only = body.onlyRowid;
                 if (through !== undefined && (!Number.isSafeInteger(through) || through < 1)) {
                     return json(req, res, 400, { error: 'throughRowid must be a positive integer' });
                 }
-                const cut = through === undefined ? { entries, later: 0 } : transcriptThrough(entries, through);
+                if (only !== undefined && (!Number.isSafeInteger(only) || only < 1)) {
+                    return json(req, res, 400, { error: 'onlyRowid must be a positive integer' });
+                }
+                if (through !== undefined && only !== undefined) {
+                    return json(req, res, 400, { error: 'throughRowid and onlyRowid cannot be combined' });
+                }
+                const cut = only !== undefined
+                    ? transcriptMessage(entries, only)
+                    : through === undefined
+                        ? { entries, earlier: 0, later: 0 }
+                        : transcriptThrough(entries, through);
                 if (!cut)
                     return json(req, res, 409, { error: 'that message is not in this chat' });
                 const rendered = renderTranscript(cut.entries, format);
-                const elided = { ...rendered.elided, later: cut.later };
+                const elided = { ...rendered.elided, earlier: 'earlier' in cut ? cut.earlier : 0, later: cut.later };
                 if (!rendered.kept)
                     return json(req, res, 409, { error: 'that chat has nothing to copy yet' });
                 // Conductor's own name for a copied transcript, so the chip reads the same as one
@@ -1669,11 +1712,13 @@ const server = http.createServer(async (req, res) => {
                 const title = source.title?.trim() || 'chat';
                 const carried = [`thinking ${format.thinking ? 'included' : 'omitted'}`];
                 carried.push(`tool calls ${format.tools ? 'included' : 'omitted'}`);
-                const stops = cut.later
-                    ? [
-                        `The copy stops partway through: ${cut.later} later ${cut.later === 1 ? 'entry is' : 'entries are'} not in it.`
-                    ]
-                    : [];
+                const stops = only !== undefined
+                    ? ['The copy contains only the selected source message; all earlier and later messages are omitted.']
+                    : cut.later
+                        ? [
+                            `The copy stops partway through: ${cut.later} later ${cut.later === 1 ? 'entry is' : 'entries are'} not in it.`
+                        ]
+                        : [];
                 const header = [
                     `# Transcript of ${title}`,
                     '',

package/dist-node/src/transcript.js

@@ -278,6 +278,21 @@ export function transcriptThrough(entries, rowid) {
     const kept = entries.filter(entry => entry.rowid <= rowid);
     return { entries: kept, later: entries.length - kept.length };
 }
+/**
+ * Keep one source message and nothing around it.
+ *
+ * One `session_messages` row can produce several transcript entries — prose split by
+ * reasoning or tool calls — so selecting by rowid keeps them together. Treating the
+ * last rendered bubble as the message would silently lose the other prose fragments.
+ */
+export function transcriptMessage(entries, rowid) {
+    const first = entries.findIndex(entry => entry.rowid === rowid);
+    if (first < 0)
+        return null;
+    const kept = entries.filter(entry => entry.rowid === rowid);
+    const last = entries.findLastIndex(entry => entry.rowid === rowid);
+    return { entries: kept, earlier: first, later: entries.length - last - 1 };
+}
 /**
  * A chat as markdown, in Conductor's own transcript layout.
  *

package/package.json

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