conductor-remote 1.114.0 → 1.116.0

package/dist-node/src/server.js

@@ -11,6 +11,8 @@ import { attachChangeStats } from "./change-stats.js";
 import { isDefaultEffortLevel, readDefaultEfforts, writeDefaultEfforts } from "./conductor-settings.js";
 import { loadConfig, stateDir } from "./config.js";
 import { ConductorDb } from "./db.js";
+import { acceptDelegation, delegationHttpStatus } from "./delegation-intake.js";
+import { delegatedPrompt } from "./delegation-prompt.js";
 import { DelegationQueue, DelegationStore } from "./delegations.js";
 import { DevServerController } from "./dev-server.js";
 import { isAllowedPreviewPath, parseFileReference, parseImageReference } from "./file-preview.js";
@@ -41,6 +43,8 @@ import { readSettings, writeSettings } from "./settings.js";
 import { attachmentTokens, isOpenAIRealtimeVoice, isVoiceLanguage, modelLabel, OPENAI_REALTIME_VOICES, responseErrorMessage, scrubWorkflowSecrets, timestampMs, VIEWING_HEADER, withoutClientWindowEvidence, withoutWindowEvidence, workspaceTitle } from "./shared.js";
 import { discardStagedAttachment, materializeStagedAttachments, pruneStagedAttachments, stageAttachment, stagedAttachments } from "./staged-attachments.js";
 import { driftWarningLines, readExposeMode, tailscaleBin } from "./tailscale.js";
+import { isToolUsageRange } from "./tool-usage.js";
+import { ToolUsageService } from "./tool-usage-service.js";
 import { renderTranscript, transcriptMessage, transcriptThrough } from "./transcript.js";
 import { recoverExpiredUiLease } from "./ui-lease-watchdog.js";
 import { VoiceBriefBoard } from "./voice/brief.js";
@@ -58,7 +62,7 @@ import { autoJoinHotspotMode, currentSsid, looksLikeHotspot, preferredNetworks }
 import { WorkflowCoordinator, WorkflowCoordinatorError } from "./workflow-coordinator.js";
 import { parseConfirmUiStableRequest, parseStartWorkflowRequest, parseWorkflowAdoptRequest, parseWorkflowCompleteRequest, parseWorkflowDelegateRequest, parseWorkflowReplayRequest, parseWorkflowRetryRequest, WorkflowRequestError, workflowClientIsMcp } from "./workflow-http.js";
 import { WorkflowGuardError } from "./workflow-machine.js";
-import { archiveWorkspace, closeChat, configureSharedUiLeaseProvider, continueWorkspace, createWorkspace, describeActuator, EFFORT_LABELS, listAgentModels, lockBlocked, newChat, pickActuator, restartConductorApp, retryWontHelp, screenLocked, sendNeverStarted, setAgentOptions, setDefaultModel, setRestartGuard, setWorkspaceStatus, stopTurn, UiBusyError, uiBusy, uiQueueDepth, uiTurn, WORKSPACE_STATUS_LABELS, withGatedUiCommand, withUiPriority } from "./writes.js";
+import { archiveWorkspace, closeChat, configureSharedUiLeaseProvider, continueWorkspace, createWorkspace, describeActuator, EFFORT_LABELS, listAgentModels, lockBlocked, newChat, pickActuator, restartConductorApp, restoreChat, retryWontHelp, screenLocked, sendNeverStarted, setAgentOptions, setDefaultModel, setRestartGuard, setWorkspaceStatus, stopTurn, UiBusyError, uiBusy, uiQueueDepth, uiTurn, WORKSPACE_STATUS_LABELS, withGatedUiCommand, withUiPriority } 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();
@@ -92,6 +96,7 @@ function stagedAttachmentIdsInObjective(objective) {
 // from a list before Conductor has created its first chat.
 const modelCache = new ModelCache(path.join(stateDir(), 'model-cache.json'));
 const planUsage = new PlanUsageService();
+const toolUsage = new ToolUsageService(cfg.dbPath);
 const roleStore = new RoleStore(path.join(stateDir(), 'roles.json'));
 const orchestration = new OrchestrationDb(path.join(stateDir(), 'orchestration.db'), {
     processProbe: processIdentityAlive
@@ -852,13 +857,6 @@ async function configureDelegation(job) {
     }
     return { ok: true };
 }
-function delegatedPrompt(job) {
-    const handoff = job.handoff;
-    if (!handoff)
-        throw new Error('the delegated handoff is missing');
-    const task = attachmentPrompt(handoff.token, job.prompt);
-    return job.resolvedRole.preamble?.trim() ? `${job.resolvedRole.preamble.trim()}\n\n${task}` : task;
-}
 async function sendDelegation(job) {
     const ws = reads.getWorkspace(job.workspaceId);
     if (!ws)
@@ -1205,9 +1203,6 @@ function workflowFrozenError(sessionId) {
         }
     };
 }
-function intakeError(code, message, retryable = false) {
-    return { ok: false, error: { code, message, retryable } };
-}
 function workflowHttpError(error) {
     if (error instanceof WorkflowRequestError || error instanceof WorkflowGuardError) {
         return { status: error.status, error: { code: error.code, message: error.message, retryable: false } };
@@ -2340,6 +2335,12 @@ const server = http.createServer(async (req, res) => {
             if (isRoute(routes.planUsage, req.method, pathname)) {
                 return json(req, res, 200, await planUsage.read(url.searchParams.get('refresh') === '1'));
             }
+            if (isRoute(routes.toolUsage, req.method, pathname)) {
+                const range = url.searchParams.get('range') ?? '24h';
+                if (!isToolUsageRange(range))
+                    return json(req, res, 400, { error: 'Choose 24h, 7d, or 30d for tool usage.' });
+                return json(req, res, 200, await toolUsage.read(range, url.searchParams.get('refresh') === '1'));
+            }
             if (isRoute(routes.roles, req.method, pathname)) {
                 const stored = roleStore.read();
                 return json(req, res, 200, {
@@ -2436,7 +2437,7 @@ const server = http.createServer(async (req, res) => {
                 });
                 return json(req, res, 202, { workflow: accepted.workflow });
             }
-            // POST /api/workflows/:id/delegations — the sole agent mutation. The
+            // POST /api/workflows/:id/delegations — managed delegation. The
             // capability, exact root, frozen role, and phase barrier are checked together.
             const workflowDelegation = routeParam(routes.workflowDelegation, req.method, pathname);
             if (workflowDelegation) {
@@ -3059,6 +3060,12 @@ const server = http.createServer(async (req, res) => {
                     ...(Object.keys(sessionRoles).length ? { session_roles: sessionRoles } : {})
                 });
             }
+            const closedSessionsIn = routeParam(routes.closedSessions, req.method, pathname);
+            if (closedSessionsIn) {
+                if (!reads.getAnyWorkspace(closedSessionsIn))
+                    return json(req, res, 404, { error: 'workspace not found' });
+                return json(req, res, 200, { sessions: reads.listClosedSessions(closedSessionsIn) });
+            }
             // POST /api/workspaces/:id/sessions — open a new chat (Cmd+T) in the workspace
             const newChatIn = routeParam(routes.newChat, req.method, pathname);
             if (newChatIn) {
@@ -3422,6 +3429,23 @@ const server = http.createServer(async (req, res) => {
                     session: reads.listSessions(ws.id).find(s => s.id === sessionId)
                 });
             }
+            const restoreChatId = routeParam(routes.restoreChat, req.method, pathname);
+            if (restoreChatId) {
+                const body = JSON.parse((await readBody(req)) || '{}');
+                const ownerId = reads.sessionWorkspaceId(restoreChatId);
+                if (!ownerId)
+                    return json(req, res, 404, { error: 'chat not found' });
+                if (body.workspaceId && body.workspaceId !== ownerId) {
+                    return json(req, res, 409, { error: 'chat is not in that workspace' });
+                }
+                if (!reads.getWorkspace(ownerId)) {
+                    return json(req, res, 409, { error: 'Restore this workspace in Conductor before restoring its tabs.' });
+                }
+                const result = await restoreChat(ownerId, restoreChatId, () => reads.getSession(restoreChatId) !== null);
+                if (!result.ok)
+                    return json(req, res, 502, result);
+                return json(req, res, 200, { ...result, session: reads.getSession(restoreChatId) });
+            }
             // DELETE /api/sessions/:id { workspaceId?, closeRunning? } — Conductor's
             // reversible Close tab action (Command-W). A running chat gets the same
             // explicit "Close anyway" gate as the desktop app.
@@ -3533,7 +3557,37 @@ const server = http.createServer(async (req, res) => {
             }
             const delegateFrom = routeParam(routes.delegateTask, req.method, pathname);
             if (delegateFrom) {
-                return json(req, res, 409, intakeError('workflow_required', 'delegate_task is available only inside a UI-authorized Workflow.'));
+                if (!orchestration.writable) {
+                    throw new WorkflowCoordinatorError('workflow_incompatible_relay', orchestrationUnavailableReason(), {
+                        status: 409
+                    });
+                }
+                let body;
+                try {
+                    body = JSON.parse((await readBody(req)) || '{}');
+                }
+                catch {
+                    return json(req, res, 400, {
+                        ok: false,
+                        error: { code: 'invalid_request', message: 'delegation must be valid JSON', retryable: false }
+                    });
+                }
+                const result = acceptDelegation(delegateFrom, body, {
+                    ownsSession: sessionId => workflowOwningSession(sessionId) !== null,
+                    sessionWorkspaceId: sessionId => reads.sessionWorkspaceId(sessionId),
+                    getSession: sessionId => reads.getSession(sessionId),
+                    getWorkspace: workspaceId => reads.getWorkspace(workspaceId),
+                    getMessages: sessionId => reads.getMessages(sessionId).entries,
+                    readRoles: () => roleStore.read(),
+                    models: () => modelCache.list(),
+                    enqueue: (workspace, job) => {
+                        const store = delegationStore(workspace);
+                        if (!store)
+                            throw new Error('worktree path unresolved');
+                        delegationQueue.enqueue(store, job);
+                    }
+                });
+                return json(req, res, result.ok ? 202 : delegationHttpStatus(result.error), result);
             }
             // POST /api/sessions/:id/prompt { text, agent? } — ordinary staged settings
             // are applied before the prompt so the two cannot come apart.

package/dist-node/src/shared.js

@@ -261,9 +261,8 @@ export function modelCatalogIncludes(model, groups) {
     return groups.some(group => group.models.some(candidate => modelPickerLabel(candidate) === wanted));
 }
 /**
- * Complete picker reads are whole-menu observations, not provider slices. Ignore
- * groups learned only from a successful single-model selection, then use the
- * newest complete observation to describe what Conductor can select.
+ * Return the latest observed menu, ignoring groups learned only from selections.
+ * A menu can expose only some providers; use currentModelCatalog for role choices.
  */
 export function newestModelSnapshot(groups) {
     let newest = null;
@@ -279,6 +278,41 @@ export function newestModelSnapshot(groups) {
     }
     return newest;
 }
+/**
+ * Only an explicit whole-menu observation can retire a provider's older labels.
+ * Legacy entries have unknown provenance: successful selections used to look like
+ * menus too. They and known partial entries prove individual choices, never absence
+ * of other choices. A later real menu supersedes that positive evidence per provider.
+ * agentType names the chat that exposed the menu, not every model's provider.
+ */
+export function currentModelCatalog(groups) {
+    const providers = new Map();
+    for (const group of groups) {
+        if (group.snapshotAt == null)
+            continue;
+        const observedAt = group.snapshotAt;
+        for (const provider of groupModelPickerLabels([...(group.snapshotModels ?? group.models)])) {
+            const current = providers.get(provider.label);
+            if (!current || observedAt >= current.observedAt) {
+                providers.set(provider.label, { observedAt, models: provider.models });
+            }
+        }
+    }
+    const models = new Set([...providers.values()].flatMap(provider => provider.models));
+    for (const group of groups) {
+        const selections = group.selections ??
+            (group.snapshotAt == null ? group.models.map(model => ({ model, selectedAt: group.updatedAt })) : []);
+        for (const selection of selections) {
+            const model = modelPickerLabel(selection.model).trim();
+            if (!model)
+                continue;
+            const menu = providers.get(modelProvider(model));
+            if (!menu || selection.selectedAt > menu.observedAt)
+                models.add(model);
+        }
+    }
+    return [...models].sort((a, b) => a.localeCompare(b));
+}
 /** Stable, case-insensitive grouping shared by every model selector. */
 export function groupModelPickerLabels(models) {
     const grouped = new Map();

package/dist-node/src/tool-usage-service.js

@@ -0,0 +1,61 @@
+import { Worker } from 'node:worker_threads';
+const CACHE_MS = 60_000;
+const READ_TIMEOUT_MS = 60_000;
+/**
+ * History can be large: keep SQLite and JSON parsing off the HTTP event loop.
+ * One disposable worker at a time reads a range; cached/in-flight reads are shared
+ * across phones. Nothing runs until Models requests it, and no index is persisted.
+ */
+export class ToolUsageService {
+    dbPath;
+    cache = new Map();
+    pending = new Map();
+    queue = Promise.resolve();
+    constructor(dbPath) {
+        this.dbPath = dbPath;
+    }
+    read(range, refresh = false) {
+        const running = this.pending.get(range);
+        if (running)
+            return running;
+        const cached = this.cache.get(range);
+        if (!refresh && cached && Date.now() - cached.fetchedAt < CACHE_MS)
+            return Promise.resolve(cached);
+        const read = this.queue.then(() => this.scan(range));
+        this.pending.set(range, read);
+        this.queue = read.catch(() => { });
+        void read.then(data => {
+            this.cache.set(range, data);
+            this.pending.delete(range);
+        }, () => this.pending.delete(range));
+        return read;
+    }
+    scan(range) {
+        return new Promise((resolve, reject) => {
+            const module = import.meta.url.endsWith('.ts') ? './tool-usage-worker.ts' : './tool-usage-worker.js';
+            const worker = new Worker(new URL(module, import.meta.url), {
+                workerData: { dbPath: this.dbPath, range },
+                // Node's watch supervisor expands process flags that workers reject.
+                // These modules need only Node's built-in type stripping, not the
+                // parent's process-level V8, inspector, or watch configuration.
+                execArgv: ['--disable-warning=ExperimentalWarning']
+            });
+            let settled = false;
+            const finish = (error, data) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                void worker.terminate();
+                if (error)
+                    reject(error);
+                else if (data)
+                    resolve(data);
+            };
+            const timeout = setTimeout(() => finish(new Error('Tool usage took too long to read. Try a shorter range.')), READ_TIMEOUT_MS);
+            worker.once('message', (data) => finish(undefined, data));
+            worker.once('error', error => finish(error));
+            worker.once('exit', () => finish(new Error('Could not read tool usage. Try again.')));
+        });
+    }
+}

package/dist-node/src/tool-usage-worker.js

@@ -0,0 +1,6 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import { ConductorDb } from "./db.js";
+import { readToolUsage } from "./tool-usage.js";
+const { dbPath, range } = workerData;
+const db = new ConductorDb(dbPath);
+parentPort?.postMessage(readToolUsage(db, range));

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

@@ -0,0 +1,109 @@
+import { contextBlockBytes, parseContextFrame } from "./context-breakdown.js";
+export function isToolUsageRange(value) {
+    return value === '24h' || value === '7d' || value === '30d';
+}
+/**
+ * Join calls and results within one chat, never across chats with reused call IDs.
+ * Older calls supply names only, so a result crossing the window's start still has
+ * an owner. Repeated snapshots of a call/result use the largest saved payload once.
+ * No prompts, arguments, or output text leave this accumulator.
+ */
+export class ToolUsageAccumulator {
+    calls = new Map();
+    add(row) {
+        const frame = parseContextFrame(row);
+        if (!frame || frame.parent_tool_use_id || !Array.isArray(frame.message?.content))
+            return;
+        for (const [index, raw] of frame.message.content.entries()) {
+            if (!raw || typeof raw !== 'object')
+                continue;
+            const block = raw;
+            const isCall = block.type === 'tool_use';
+            if (!isCall && (block.type !== 'tool_result' || !row.in_range))
+                continue;
+            const rawId = isCall ? block.id : block.tool_use_id;
+            const id = typeof rawId === 'string' && rawId ? `id:${rawId}` : `row:${row.rowid}:${index}`;
+            const call = this.calls.get(id) ?? { name: null, inputBytes: 0, outputBytes: 0 };
+            if (isCall && typeof block.name === 'string' && block.name.trim())
+                call.name = block.name.trim();
+            if (row.in_range) {
+                const key = isCall ? 'inputBytes' : 'outputBytes';
+                call[key] = Math.max(call[key], contextBlockBytes(block));
+            }
+            this.calls.set(id, call);
+        }
+    }
+    tools() {
+        const tools = new Map();
+        for (const call of this.calls.values()) {
+            if (!call.inputBytes && !call.outputBytes)
+                continue;
+            const inputTokens = Math.ceil(call.inputBytes / 4);
+            const outputTokens = Math.ceil(call.outputBytes / 4);
+            mergeToolUsage(tools, {
+                name: call.name,
+                calls: 1,
+                inputTokens,
+                outputTokens,
+                totalTokens: inputTokens + outputTokens,
+                largestCallTokens: inputTokens + outputTokens
+            });
+        }
+        return [...tools.values()].sort((a, b) => b.totalTokens - a.totalTokens);
+    }
+}
+function mergeToolUsage(tools, row) {
+    const previous = tools.get(row.name);
+    if (!previous) {
+        tools.set(row.name, { ...row });
+        return;
+    }
+    previous.calls += row.calls;
+    previous.inputTokens += row.inputTokens;
+    previous.outputTokens += row.outputTokens;
+    previous.totalTokens += row.totalTokens;
+    previous.largestCallTokens = Math.max(previous.largestCallTokens, row.largestCallTokens);
+}
+/** On-demand worker read. Includes archived workspaces and hidden chats. */
+export function readToolUsage(db, range, now = Date.now()) {
+    const days = range === '24h' ? 1 : range === '7d' ? 7 : 30;
+    const since = new Date(now - days * 86_400_000).toISOString();
+    const until = new Date(now).toISOString();
+    const sessions = db.query(`SELECT id, agent_type FROM sessions WHERE julianday(updated_at) >= julianday(?)`, [since]);
+    const providers = new Map();
+    for (const session of sessions) {
+        const accumulator = new ToolUsageAccumulator();
+        // Conductor has a session_id index, but no global message-time index. Scope
+        // each scan to a recently active chat and keep large historical results out of
+        // JS. Prior calls are retained only to name results that cross the lower bound.
+        // julianday handles Conductor's mixture of SQLite and ISO timestamp formats.
+        const rows = db.query(`SELECT rowid, role, content, julianday(created_at) >= julianday(?) AS in_range
+			 FROM session_messages
+			 WHERE session_id = ? AND julianday(created_at) <= julianday(?)
+			   AND (instr(content, '"tool_use"') > 0
+			        OR (julianday(created_at) >= julianday(?) AND instr(content, '"tool_result"') > 0))
+			 ORDER BY rowid ASC`, [since, session.id, until, since]);
+        for (const row of rows)
+            accumulator.add(row);
+        const tools = accumulator.tools();
+        if (!tools.length)
+            continue;
+        const provider = session.agent_type === 'acp' ? 'opencode' : (session.agent_type ?? 'unknown');
+        const group = providers.get(provider) ?? { sessionCount: 0, tools: new Map() };
+        group.sessionCount++;
+        for (const tool of tools)
+            mergeToolUsage(group.tools, tool);
+        providers.set(provider, group);
+    }
+    return {
+        range,
+        since,
+        until,
+        fetchedAt: now,
+        providers: [...providers].map(([provider, group]) => ({
+            provider,
+            sessionCount: group.sessionCount,
+            tools: [...group.tools.values()].sort((a, b) => b.totalTokens - a.totalTokens)
+        }))
+    };
+}

package/dist-node/src/workflow-coordinator.js

@@ -168,10 +168,10 @@ function promptRole(role) {
     return role;
 }
 export class WorkflowCoordinator {
+    waking = new Map();
     db;
     relay;
     deps;
-    waking = new Map();
     constructor(db, relay, deps) {
         this.db = db;
         this.relay = relay;

package/dist-node/src/writes.js

@@ -3,7 +3,7 @@ import { execFile } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
 import { promisify } from 'node:util';
-import { isLockedError, modelPickerLabel } from "./shared.js";
+import { isLockedError, MAC_LOCKED, modelPickerLabel } from "./shared.js";
 import { sidecarAvailable, sidecarSendUserMessage } from "./sidecar.js";
 import { runGatedWorkflowCommand, WorkflowGatedCommandError } from "./workflow-effect-runner.js";
 const execDirect = promisify(execFile);
@@ -412,9 +412,9 @@ const CONDUCTOR_SCHEME = process.env.RELAY_CONDUCTOR_SCHEME || 'conductor';
  *
  * `session` is optional and names a chat by `sessions.id`, the same id the relay
  * already serves; omitted, Conductor opens whichever tab that workspace had.
- * A hidden chat (`sessions.is_hidden`) has no tab, and Conductor keeps the
- * workspace's current one rather than reporting anything, so the caller's own
- * tab assertion is still what catches it.
+ * Current Conductor builds also unhide a session named by this route, through
+ * their own session service. `restoreChat` uses that behavior and confirms the
+ * exact id became visible; older builds may ignore it, so opening is no receipt.
  *
  * The https form Conductor copies for sharing —
  * `https://app.conductor.build/workspace/<id>?session=<chat>` — reaches the same
@@ -681,6 +681,37 @@ return "ok"`.trim();
         return { ok: false, strategy: 'applescript', error: osaError(err) };
     }
 }
+/**
+ * Conductor's workspace route restores a hidden session before selecting it.
+ * Keep the UI lease through the DB receipt: another focus operation must not
+ * navigate away while Conductor's asynchronous route handler is unhiding it.
+ * The callback is deliberately exact-id and read-only, supplied by the server.
+ */
+export async function restoreChat(workspaceId, sessionId, isVisible) {
+    return uiTurn(async () => {
+        if (isVisible())
+            return { ok: true, strategy: 'deep-link', alreadyOpen: true };
+        if ((await screenLocked()) === true) {
+            return { ok: false, strategy: 'deep-link', error: `${MAC_LOCKED}. Unlock it, then try again.` };
+        }
+        try {
+            await exec('open', [workspaceLink(workspaceId, sessionId)], { timeout: 5_000 });
+            for (let attempt = 0; attempt < 40; attempt++) {
+                await new Promise(resolve => setTimeout(resolve, 250));
+                if (isVisible())
+                    return { ok: true, strategy: 'deep-link' };
+            }
+            return {
+                ok: false,
+                strategy: 'deep-link',
+                error: 'Conductor has not restored this tab yet. Try again, or update Conductor on your Mac.'
+            };
+        }
+        catch (error) {
+            return { ok: false, strategy: 'deep-link', error: osaError(error) };
+        }
+    });
+}
 /**
  * Press the Wi-Fi menu's row for a personal hotspot — Instant Hotspot, the same
  * button a human clicks. `networksetup` can only join a network that is

package/package.json

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