conductor-remote 1.107.0 → 1.108.0

package/dist-node/src/relay-processes.js

@@ -0,0 +1,230 @@
+import { execFile, execFileSync } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+/**
+ * Decide from argv only. Never ask `ps` for the environment: a Conductor child or
+ * relay process can carry bearer tokens there.
+ */
+export function isUiCapableRelayArgs(args) {
+    const normalized = args.replace(/\s+/g, ' ').trim();
+    if (!/(^|\/)node(?:\s|$)/.test(normalized))
+        return false;
+    if (/\bconductor-remote(?:\/bin\/cli\.js)?\s+(?:mcp|service|config|logs|nosleep)(?:\s|$)/.test(normalized)) {
+        return false;
+    }
+    // `yarn start` and the documented checkout command can leave the script path
+    // relative in `ps` (for example `node bin/cli.js`). Treat a whitespace or path
+    // separator as the same token boundary. Utility subcommands are excluded first
+    // so a relative MCP proxy can never be mistaken for a UI-driving relay.
+    if (/(?:^|\s|\/)(?:conductor-remote\/)?bin\/cli\.js\s+(?:mcp|service|config|logs|nosleep)(?:\s|$)/.test(normalized)) {
+        return false;
+    }
+    if (/(?:^|\s|\/)(?:src\/server\.ts|dist-node\/src\/server\.js)(?:\s|$)/.test(normalized))
+        return true;
+    if (/(?:^|\s|\/)(?:conductor-remote\/)?bin\/cli\.js(?:\s+(?:start))?(?:\s|$)/.test(normalized))
+        return true;
+    return /\bconductor-remote(?:\s+start)?(?:\s|$)/.test(normalized);
+}
+/** Parse macOS `ps -axo pid=,lstart=,args=` without depending on locale words. */
+export function parseUiCapableRelayProcesses(output, ownPid = process.pid) {
+    const found = [];
+    for (const line of output.split('\n')) {
+        // macOS lstart is five fields: weekday month day hh:mm:ss year. Capture by
+        // fields rather than a byte width so single-digit days and locale spacing work.
+        const match = /^\s*(\d+)\s+(\S+\s+\S+\s+\d+\s+\d\d:\d\d:\d\d\s+\d{4})\s+(.+)$/.exec(line);
+        if (!match)
+            continue;
+        const pid = Number(match[1]);
+        if (!Number.isSafeInteger(pid) || pid <= 0 || pid === ownPid)
+            continue;
+        const args = match[3].trim();
+        if (!isUiCapableRelayArgs(args))
+            continue;
+        found.push({ pid, processStartIdentity: match[2].replace(/\s+/g, ' '), args });
+    }
+    return found.sort((a, b) => a.pid - b.pid);
+}
+export async function listUiCapableRelayProcesses(ownPid = process.pid) {
+    const { stdout } = await execFileAsync('/bin/ps', ['-axo', 'pid=,lstart=,args='], {
+        encoding: 'utf8',
+        timeout: 6_000,
+        maxBuffer: 4 * 1024 * 1024
+    });
+    return parseUiCapableRelayProcesses(stdout, ownPid);
+}
+function normalizeStartIdentity(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+const PROCESS_TABLE_ARGS = ['-axo', 'pid=,pgid=,lstart='];
+function parseProcessTable(output) {
+    const entries = [];
+    for (const line of output.split('\n')) {
+        const match = /^\s*(\d+)\s+(\d+)\s+(.+?)\s*$/.exec(line);
+        if (!match)
+            continue;
+        const pid = Number(match[1]);
+        const processGroup = Number(match[2]);
+        if (!Number.isSafeInteger(pid) || pid <= 0 || !Number.isSafeInteger(processGroup) || processGroup <= 0) {
+            continue;
+        }
+        entries.push({ pid, processGroup, processStartedAt: normalizeStartIdentity(match[3]) });
+    }
+    return entries;
+}
+function readProcessTableSync() {
+    try {
+        const output = execFileSync('/bin/ps', [...PROCESS_TABLE_ARGS], {
+            encoding: 'utf8',
+            timeout: 2_000,
+            maxBuffer: 4 * 1024 * 1024
+        });
+        return parseProcessTable(output);
+    }
+    catch {
+        return null;
+    }
+}
+async function readProcessTable() {
+    try {
+        const { stdout } = await execFileAsync('/bin/ps', [...PROCESS_TABLE_ARGS], {
+            encoding: 'utf8',
+            timeout: 2_000,
+            maxBuffer: 4 * 1024 * 1024
+        });
+        return parseProcessTable(stdout);
+    }
+    catch {
+        return null;
+    }
+}
+function exactLeader(entries, identity) {
+    const expectedStart = normalizeStartIdentity(identity.processStartedAt);
+    return entries.find(entry => entry.pid === identity.pid && normalizeStartIdentity(entry.processStartedAt) === expectedStart);
+}
+function validProcessGroup(processGroup) {
+    return Number.isSafeInteger(processGroup) && processGroup > 1;
+}
+function groupAlive(entries, processGroup) {
+    return entries.some(entry => entry.processGroup === processGroup);
+}
+function sameProcess(left, right) {
+    return left.pid === right.pid && left.processStartedAt === right.processStartedAt;
+}
+/**
+ * Exact PID + process-start check, extended for a recorded detached wrapper.
+ * A dead/reused leader is still conservatively alive while any member retains
+ * its process group. Failure to read the process table also fails closed.
+ */
+export function processIdentityAlive(identity) {
+    const entries = readProcessTableSync();
+    if (!entries)
+        return true;
+    if (exactLeader(entries, identity))
+        return true;
+    if (identity.processGroup === undefined)
+        return false;
+    if (!validProcessGroup(identity.processGroup))
+        return true;
+    return groupAlive(entries, identity.processGroup);
+}
+function duration(value, fallback, minimum) {
+    return value === undefined || !Number.isFinite(value) ? fallback : Math.max(minimum, Math.floor(value));
+}
+async function waitForGroupDeath(processGroup, waitMs, pollIntervalMs) {
+    const deadline = Date.now() + waitMs;
+    for (;;) {
+        const entries = await readProcessTable();
+        if (!entries)
+            return false;
+        if (!groupAlive(entries, processGroup))
+            return true;
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+            return false;
+        await new Promise(resolve => setTimeout(resolve, Math.min(pollIntervalMs, remaining)));
+    }
+}
+function signalGroup(processGroup, signal) {
+    try {
+        process.kill(-processGroup, signal);
+        return true;
+    }
+    catch (error) {
+        if (error && typeof error === 'object' && 'code' in error && error.code === 'ESRCH')
+            return true;
+        return false;
+    }
+}
+/**
+ * Terminate a detached wrapper's process group without risking a reused PGID.
+ *
+ * The recorded leader must still have the exact PID/start identity, must still
+ * lead the recorded group, and must not be this relay. Only then is SIGTERM sent.
+ * SIGKILL follows when descendants survive the grace period, unless a reused
+ * leader is observed. `true` means a later process-table snapshot proved that no
+ * member of the recorded group remains; every inspection failure returns false.
+ */
+export async function terminateRecordedProcessGroup(identity, options = {}) {
+    if (!Number.isSafeInteger(identity.pid) ||
+        identity.pid <= 1 ||
+        identity.pid === process.pid ||
+        !validProcessGroup(identity.processGroup) ||
+        identity.processGroup !== identity.pid ||
+        !normalizeStartIdentity(identity.processStartedAt)) {
+        return false;
+    }
+    const termGraceMs = duration(options.termGraceMs, 500, 0);
+    const killWaitMs = duration(options.killWaitMs, 2_000, 0);
+    const pollIntervalMs = duration(options.pollIntervalMs, 25, 1);
+    const initial = await readProcessTable();
+    if (!initial)
+        return false;
+    const leader = exactLeader(initial, identity);
+    if (!leader)
+        return !groupAlive(initial, identity.processGroup);
+    if (leader.processGroup !== identity.processGroup)
+        return false;
+    const initialMembers = initial.filter(entry => entry.processGroup === identity.processGroup);
+    if (!signalGroup(identity.processGroup, 'SIGTERM'))
+        return false;
+    if (await waitForGroupDeath(identity.processGroup, termGraceMs, pollIntervalMs))
+        return true;
+    const beforeKill = await readProcessTable();
+    if (!beforeKill)
+        return false;
+    if (!groupAlive(beforeKill, identity.processGroup))
+        return true;
+    const currentLeader = beforeKill.find(entry => entry.pid === identity.pid);
+    if (currentLeader &&
+        (normalizeStartIdentity(currentLeader.processStartedAt) !== normalizeStartIdentity(identity.processStartedAt) ||
+            currentLeader.processGroup !== identity.processGroup)) {
+        return false;
+    }
+    const survivingMembers = beforeKill.filter(entry => entry.processGroup === identity.processGroup);
+    if (!survivingMembers.some(current => initialMembers.some(initialMember => sameProcess(current, initialMember)))) {
+        return false;
+    }
+    if (!signalGroup(identity.processGroup, 'SIGKILL'))
+        return false;
+    return waitForGroupDeath(identity.processGroup, killWaitMs, pollIntervalMs);
+}
+export function currentProcessStartIdentity(pid = process.pid) {
+    const output = execFileSync('/bin/ps', ['-p', String(pid), '-o', 'lstart='], {
+        encoding: 'utf8',
+        timeout: 2_000,
+        maxBuffer: 64 * 1024
+    });
+    const identity = normalizeStartIdentity(output);
+    if (!identity)
+        throw new Error(`could not read process start identity for PID ${pid}`);
+    return identity;
+}
+/** A live UI-capable process must have a matching registration at this protocol. */
+export function incompatibleRelayProcesses(processes, registrations, protocolVersion) {
+    return processes.filter(candidate => {
+        const registration = registrations.find(entry => entry.canDriveUi &&
+            entry.pid === candidate.pid &&
+            normalizeStartIdentity(entry.processStartedAt) === normalizeStartIdentity(candidate.processStartIdentity));
+        return !registration || registration.protocolVersion !== protocolVersion;
+    });
+}

package/dist-node/src/roles.js

@@ -9,13 +9,35 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { stateDir } from "./config.js";
-import { agentTypeCanExposeEffort, agentTypeCanExposeFastMode, modelAgentType, modelCatalogIncludes, modelPickerLabel } from "./shared.js";
+import { modelAgentType, modelCatalogIncludes, modelPickerLabel, newestModelSnapshot } from "./shared.js";
+export { newestModelSnapshot } from "./shared.js";
 const EFFORTS = new Set(['none', 'low', 'medium', 'high', 'xhigh', 'max', 'ultracode']);
 const ROLE_NAME = /^[a-z][a-z0-9_-]{0,63}$/;
 const MAX_ROLES = 32;
 const MAX_MODEL_LENGTH = 256;
 const MAX_PREAMBLE_LENGTH = 50_000;
 const ROLE_FIELDS = new Set(['model', 'effort', 'fast', 'preamble']);
+/**
+ * Controls verified against Conductor's provider-specific composer UI.
+ *
+ * This is intentionally versioned and deliberately contains only providers whose
+ * controls have been measured. A provider recognized from its model label but absent
+ * here can still be used with its defaults; role configuration must omit controls we
+ * cannot prove Conductor can apply and read back.
+ */
+export const ROLE_CONTROL_CAPABILITIES = {
+    version: 1,
+    providers: {
+        claude: {
+            efforts: ['low', 'medium', 'high', 'xhigh', 'max', 'ultracode'],
+            fast: true
+        },
+        codex: {
+            efforts: ['none', 'low', 'medium', 'high', 'xhigh', 'max', 'ultracode'],
+            fast: true
+        }
+    }
+};
 const batonPreamble = (role) => `You are the ${role} agent for this workspace. End your final answer with a \`## Baton\` section: Decision, Evidence, Files changed, Risks, Suggested next role.`;
 export const DEFAULT_ROLES = {
     version: 1,
@@ -89,25 +111,27 @@ function issue(code, message) {
     return { code, message, retryable: false };
 }
 function controlIssue(name, role, agentType) {
-    if (role.effort !== undefined && !agentTypeCanExposeEffort(agentType)) {
-        return issue('invalid_request', `Role ${name} cannot set effort because Conductor exposes no reasoning control for this provider.`);
+    const controls = ROLE_CONTROL_CAPABILITIES.providers[agentType];
+    if (role.effort !== undefined && !controls) {
+        return issue('invalid_request', `Role ${name} must omit effort because this provider's Conductor reasoning control is not verified.`);
     }
-    if (role.effort === 'none' && agentType !== 'codex') {
-        return issue('invalid_request', `Role ${name} can use None effort only with a Codex model.`);
+    if (role.effort !== undefined && controls && !controls.efforts.includes(role.effort)) {
+        return issue('invalid_request', `Role ${name} cannot use ${role.effort} effort with its configured provider.`);
     }
-    if (role.fast !== undefined && !agentTypeCanExposeFastMode(agentType)) {
-        return issue('invalid_request', `Role ${name} cannot set Fast mode because Conductor exposes no Fast control for this provider.`);
+    if (role.fast !== undefined && !controls?.fast) {
+        return issue('invalid_request', `Role ${name} must omit Fast mode because this provider's Conductor Fast control is not verified.`);
     }
     return null;
 }
 /** Picker validation stays separate from shape decoding so a vanished model remains editable. */
 export function roleModelIssues(config, groups) {
     const issues = [];
+    const snapshot = newestModelSnapshot(groups);
     for (const [name, role] of Object.entries(config.roles)) {
-        if (!modelCatalogIncludes(role.model, groups)) {
+        if (!snapshot || !modelCatalogIncludes(role.model, [snapshot])) {
             issues.push({
                 role: name,
-                error: issue('model_missing', `Role ${name} needs an exact model from Conductor's current picker.`)
+                error: issue('model_missing', `Role ${name} needs an exact model from Conductor's newest picker snapshot; update it in the role editor.`)
             });
             continue;
         }
@@ -130,10 +154,11 @@ export function resolveRole(config, name, groups) {
     const role = config.roles[name];
     if (!role)
         return { ok: false, error: issue('role_not_found', `Unknown delegated role ${name}.`) };
-    if (!modelCatalogIncludes(role.model, groups)) {
+    const snapshot = newestModelSnapshot(groups);
+    if (!snapshot || !modelCatalogIncludes(role.model, [snapshot])) {
         return {
             ok: false,
-            error: issue('model_missing', `Role ${name} needs an exact model from Conductor's current picker.`)
+            error: issue('model_missing', `Role ${name} needs an exact model from Conductor's newest picker snapshot; update it in the role editor.`)
         };
     }
     const agentType = modelAgentType(role.model);
@@ -152,11 +177,36 @@ export function resolveRole(config, name, groups) {
 export class RoleStore {
     file;
     cache = null;
+    cacheStamp;
     constructor(file = path.join(stateDir(), 'roles.json')) {
         this.file = file;
     }
+    fileStamp() {
+        try {
+            const stat = fs.statSync(this.file);
+            return `${stat.mtimeMs}:${stat.size}:${stat.ino}`;
+        }
+        catch (err) {
+            if (err.code === 'ENOENT')
+                return null;
+            throw err;
+        }
+    }
     read() {
-        if (this.cache)
+        let stamp;
+        try {
+            stamp = this.fileStamp();
+        }
+        catch (err) {
+            stamp = null;
+            this.cache = {
+                config: cloneConfig(DEFAULT_ROLES),
+                warning: `Could not inspect roles.json: ${err instanceof Error ? err.message : String(err)}`
+            };
+            this.cacheStamp = undefined;
+            return { ...this.cache, config: cloneConfig(this.cache.config) };
+        }
+        if (this.cache && this.cacheStamp === stamp)
             return { ...this.cache, config: cloneConfig(this.cache.config) };
         try {
             this.cache = { config: decodeRoles(JSON.parse(fs.readFileSync(this.file, 'utf8'))) };
@@ -171,6 +221,7 @@ export class RoleStore {
                 };
             }
         }
+        this.cacheStamp = stamp;
         return { ...this.cache, config: cloneConfig(this.cache.config) };
     }
     write(raw) {
@@ -197,6 +248,7 @@ export class RoleStore {
             return { ok: false, error: `could not persist roles: ${err instanceof Error ? err.message : String(err)}` };
         }
         this.cache = { config };
+        this.cacheStamp = this.fileStamp();
         return { ok: true, config: cloneConfig(config) };
     }
 }

package/dist-node/src/routes.js

@@ -101,6 +101,19 @@ export const routes = {
     delegations: flat('GET', '/api/delegations'),
     /** Dismiss one failed job without touching its chats or session-role identity. */
     dismissDelegation: param('DELETE', '/api/delegations/:delegationId'),
+    /** UI-only intake for a durable Workflow; MCP deliberately exposes no start tool. */
+    workflows: flat('POST', '/api/workflows'),
+    /** Cancel without destructive Conductor UI actions; `clientId` travels in the query. */
+    workflow: param('DELETE', '/api/workflows/:workflowId'),
+    /** The only agent-facing Workflow mutation, authorized by the current phase capability. */
+    workflowDelegation: param('POST', '/api/workflows/:workflowId/delegations'),
+    /** Phone-only, idempotent recovery actions for a blocked Workflow. */
+    workflowRetry: param('POST', '/api/workflows/:workflowId/retry'),
+    workflowAdopt: param('POST', '/api/workflows/:workflowId/adopt'),
+    workflowReplay: param('POST', '/api/workflows/:workflowId/replay'),
+    workflowComplete: param('POST', '/api/workflows/:workflowId/complete'),
+    /** Phone-only acknowledgement that the user inspected Conductor after an ambiguous UI dispatch. */
+    confirmUiStable: flat('POST', '/api/ui-quarantine/confirm'),
     // ── workspaces ──
     createWorkspace: flat('POST', '/api/workspaces'),
     /** One workspace by id, archived included — what `/api/state` deliberately leaves out. */
@@ -140,7 +153,7 @@ export const routes = {
     uploadAttachment: param('POST', '/api/sessions/:sessionId/attachments'),
     /** Copy a chat into a fresh tab beside it, as a Conductor attachment (src/attachments.ts). */
     splitChat: param('POST', '/api/sessions/:sessionId/split'),
-    /** Accept a persisted cross-provider job and return before its UI stages run. */
+    /** Legacy intake retained only to reject new ordinary-chat delegation after migration. */
     delegateTask: param('POST', '/api/sessions/:sessionId/delegate'),
     /** Dismiss a prompt parked behind the lock screen (src/parked.ts). */
     dismissParkedPrompt: param('DELETE', '/api/sessions/:sessionId/prompt')

package/dist-node/src/search-worker.js

@@ -6,7 +6,9 @@ import { ConductorDb } from "./db.js";
 import { HIT_CLOSE, HIT_OPEN, matchQuery } from "./search.js";
 import { parseMessage } from "./transcript.js";
 /** Bump when extraction or an invariant such as one-chunk-per-source changes stored rows. */
-const SCHEMA_VERSION = 2;
+// v3 rebuilds every chunk through WorkflowSecretScrubber so a capability indexed by
+// an older relay cannot survive after the private-envelope boundary is introduced.
+const SCHEMA_VERSION = 3;
 /**
  * Source rows advanced per tick. The cursor moves by *scanned* rowid rather than
  * matched rowid, so a caught-up index re-scans nothing.