@sidevoice/uplink 0.4.3 → 0.5.0

package/harness-claude.mjs

@@ -1,227 +0,0 @@
-/** What Claude Code will do with a message we post to a session's inbox, decided before we post it.
- *
- *  A session that bypasses permission prompts holds an injected message for its user's approval
- *  instead of delivering it, and the inbox sends us no receipt to say so — the write looks
- *  identical either way. So the only honest moment to find out is at voice_connect, from the
- *  session's own launch flags and settings. Best effort by design: a managed policy layer we
- *  cannot read could tighten this further, and the result says so rather than pretending.
- *  Documented at https://code.claude.com/docs/en/cross-session-messaging */
-import { execFileSync } from 'node:child_process';
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
-import net from 'node:net';
-import os from 'node:os';
-import path from 'node:path';
-import { defineHarness, envelope, SUPPORTED, tailJsonl } from './harness-contract.mjs';
-
-const configDir = () => process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
-
-function readJson(file) {
-  try { return JSON.parse(readFileSync(file, 'utf8')); } catch { return null; }
-}
-
-/** The record Claude Code keeps for a session, or null. It publishes `status` there and keeps it current. */
-export function sessionRecord(sessionId) {
-  const registry = path.join(configDir(), 'sessions');
-  let entries = [];
-  try { entries = readdirSync(registry).filter(name => name.endsWith('.json')); } catch { return null; }
-  for (const name of entries) {
-    const record = readJson(path.join(registry, name));
-    if (record?.sessionId === sessionId) return record;
-  }
-  return null;
-}
-
-/** Whether that session is working on something right now: true, false, or null when it cannot be told.
- *  This is Claude Code's own bookkeeping, not a published interface: an unknown value answers null rather
- *  than guessing, and the room falls back to what the conversation says about its own replies. */
-export function sessionWorking(sessionId) {
-  const status = sessionRecord(sessionId)?.status;
-  if (status === 'busy') return true;
-  if (status === 'idle' || status === 'ready' || status === 'waiting') return false;
-  return null;
-}
-
-/** The pid of the session with this id, from Claude Code's own session registry. */
-function sessionPid(sessionId) {
-  const registry = path.join(configDir(), 'sessions');
-  let entries = [];
-  try { entries = readdirSync(registry).filter(name => name.endsWith('.json')); } catch { return null; }
-  for (const name of entries) {
-    const record = readJson(path.join(registry, name));
-    if (record?.sessionId === sessionId) return record.pid ?? null;
-  }
-  return null;
-}
-
-/** The launch arguments of a pid, via ps so this works the same on Linux and macOS. */
-function launchArgs(pid) {
-  if (!pid) return '';
-  try { return execFileSync('ps', ['-o', 'args=', '-p', String(pid)], { encoding: 'utf8', timeout: 4000 }).trim(); }
-  catch { return ''; }
-}
-
-function flag(args, name) {
-  const match = args.match(new RegExp(`${name}[= ]('[^']*'|"[^"]*"|\\S+)`));
-  if (!match) return undefined;
-  return match[1].replace(/^['"]|['"]$/g, '');
-}
-
-/** `--settings` takes inline JSON or a path to a file; both may carry crossSessionInbound. */
-function settingsFromFlag(args) {
-  const value = flag(args, '--settings');
-  if (!value) return null;
-  if (value.trim().startsWith('{')) { try { return JSON.parse(value); } catch { return null; } }
-  return readJson(value);
-}
-
-const BYPASS_MODES = new Set(['bypassPermissions']);
-
-/** Which model this conversation runs, read from the session's own launch line — no model is asked to
- *  say what it is. Absent rather than guessed when the launcher did not name one (the CLI's default). */
-export function sessionEngine(sessionId) {
-  const args = launchArgs(sessionPid(sessionId));
-  if (!args) return null;
-  const model = flag(args, '--model'), effort = flag(args, '--effort'), thinking = flag(args, '--thinking');
-  if (!model && !effort) return null;
-  return { model: model || null, effort: effort || null, thinking: thinking || null };
-}
-
-/** Will an injected message be delivered to this Claude session, or held for its user? */
-export function inspectInbound(sessionId) {
-  const pid = sessionPid(sessionId);
-  const args = launchArgs(pid);
-  const user = readJson(path.join(configDir(), 'settings.json')) || {};
-  const flagged = settingsFromFlag(args) || {};
-  const mode = flag(args, '--permission-mode') || user.permissions?.defaultMode || 'default';
-  // Launch flags beat user settings; a managed policy layer could still tighten either.
-  const inbound = flagged.crossSessionInbound ?? user.crossSessionInbound;
-  const bypassing = BYPASS_MODES.has(mode);
-  if (!bypassing) return { ok: true, mode, crossSessionInbound: inbound ?? null };
-  if (inbound === 'accept') return { ok: true, mode, crossSessionInbound: inbound };
-  return {
-    ok: false,
-    mode,
-    crossSessionInbound: inbound ?? null,
-    reason: inbound === 'refuse'
-      ? 'This session refuses messages from other local processes (crossSessionInbound is "refuse").'
-      : 'This session bypasses permission prompts, so Claude Code holds messages from other local '
-        + 'processes for the user to approve instead of delivering them, and it sends no receipt to '
-        + 'say so. Voice will appear to be sent and nothing will arrive.',
-    remedy: inbound === 'refuse'
-      ? 'Change crossSessionInbound from "refuse" to "accept", or start the session in a permission '
-        + 'mode that prompts.'
-      : 'Two ways out. Per session: start it with --settings \'{"crossSessionInbound":"accept"}\'. '
-        + 'For every session on this machine: add "crossSessionInbound": "accept" to '
-        + `${path.join(configDir(), 'settings.json')} — that takes effect immediately, releases any `
-        + 'messages already held, and also lets any other local process post into all your sessions, '
-        + 'which is the safeguard it removes. Or run the conversation in a prompting mode such as '
-        + '--permission-mode auto.',
-    // Said plainly so nothing downstream reports this as certain.
-    confidence: pid ? 'read from the session launch flags and settings' : 'settings only; the session process was not found',
-  };
-}
-
-/** Identity and private inbox inherited by the MCP façade Claude Code spawned. */
-export function sessionIdentity({ env = process.env } = {}) {
-  if (!env.CLAUDE_CODE_SESSION_ID) return null;
-  return {
-    harness: 'claude',
-    thread: env.CLAUDE_CODE_SESSION_ID,
-    ...(env.CLAUDE_CODE_MESSAGING_SOCKET ? { delivery: {
-      kind: 'claude-uds',
-      socket: env.CLAUDE_CODE_MESSAGING_SOCKET,
-      token: env.CLAUDE_CODE_MESSAGING_TOKEN || '',
-    } } : {}),
-  };
-}
-
-/** Claude Code's session inbox sends no acknowledgement. The read receipt comes from watching the
- *  session's own transcript (see observe); this method reports only what the socket itself proves. */
-export function deliver(delivery, event) {
-  if (delivery?.kind !== 'claude-uds') throw new Error(`Unsupported Claude delivery kind: ${delivery?.kind}`);
-  return new Promise((resolve, reject) => {
-    const started = Date.now();
-    const socket = net.createConnection(delivery.socket);
-    let settled = false, wrote = 0, replied = '';
-    const finish = (error, status, detail) => {
-      if (settled) return;
-      settled = true; clearTimeout(timer); socket.destroy();
-      if (error) return reject(error);
-      resolve({ status, detail: `${detail} after ${Date.now() - started}ms${replied ? ', peer said ' + replied.slice(0, 120) : ''}` });
-    };
-    const timer = setTimeout(() => finish(null, 'unknown', 'connection still open, no acknowledgement'), 1500);
-    socket.on('error', error => finish(error));
-    socket.on('data', chunk => { replied += chunk; });
-    socket.on('connect', () => {
-      socket.write(JSON.stringify({ type: 'auth', token: delivery.token }) + '\n');
-      socket.write(JSON.stringify({ type: 'user', message: { role: 'user', content: envelope(event) } }) + '\n');
-      wrote = Date.now();
-    });
-    socket.on('close', () => finish(null, 'rejected', wrote ? 'peer closed the connection' : 'peer closed before the frames were written'));
-  });
-}
-
-/** The transcript Claude Code writes for a session: one JSON-lines file named after the session id, under
- *  the project directory it derives from the launch cwd. Found by name rather than derived, so a renamed
- *  or moved cwd changes nothing. */
-export function transcriptPath(sessionId) {
-  const projects = path.join(configDir(), 'projects');
-  let dirs = [];
-  try { dirs = readdirSync(projects); } catch { return null; }
-  for (const dir of dirs) {
-    const candidate = path.join(projects, dir, sessionId + '.jsonl');
-    if (existsSync(candidate)) return candidate;
-  }
-  return null;
-}
-
-/** The text of a transcript entry that is a user message, or null for anything else (tool results,
- *  attachments, the session's own bookkeeping). */
-export function userMessageText(entry) {
-  if (entry?.type !== 'user' || entry.message?.role !== 'user') return null;
-  const content = entry.message.content;
-  if (typeof content === 'string') return content;
-  if (!Array.isArray(content)) return null;
-  const parts = content.filter(part => part?.type === 'text').map(part => part.text);
-  return parts.length ? parts.join('\n') : null;
-}
-
-const POLL_MS = Number(process.env.SIDEVOICE_WORK_POLL_MS || 400);
-
-/** Watch one session through what Claude Code itself writes about it, and nothing installed in it:
- *  its registry record says whether it is busy, and its transcript records every user message the
- *  moment the session admits it (a message from the inbox is appended as the turn takes it, not when
- *  the socket accepted it — the difference is what the second tick shows). */
-export function observe(sessionId, handlers) {
-  let lastStatus = null;
-  const stopTranscript = tailJsonl(() => transcriptPath(sessionId), entry => {
-    const text = userMessageText(entry);
-    if (text !== null) handlers.userMessage({ text, turn_id: entry.promptId || null });
-  }, { intervalMs: POLL_MS });
-  const timer = setInterval(() => {
-    const working = sessionWorking(sessionId);
-    if (working === null || working === lastStatus) return;
-    lastStatus = working;
-    handlers.working(working, {});
-  }, POLL_MS);
-  timer.unref?.();
-  return () => { clearInterval(timer); stopTranscript(); };
-}
-
-export const claudeHarness = defineHarness({
-  name: 'claude',
-  capabilities: {
-    deliver: SUPPORTED,
-    inspectInbound: SUPPORTED,
-    working: SUPPORTED,
-    endOfTurn: SUPPORTED,
-    sessionIdentity: SUPPORTED,
-  },
-  deliver,
-  inspectInbound,
-  engine: sessionEngine,
-  observe,
-  sessionIdentity,
-});
-
-export default claudeHarness;

package/harness-codex.mjs

@@ -1,126 +0,0 @@
-/** Codex harness implementation.
- *
- * Delivery and identity are available to the stdio MCP façade. Working state and read receipts come
- * from the thread's own rollout file, which Codex appends as the turn runs; nothing is configured in Codex. */
-import { execFile } from 'node:child_process';
-import { existsSync, readdirSync } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { defineHarness, envelope, SUPPORTED, UNSUPPORTED, tailJsonl } from './harness-contract.mjs';
-
-function turnMetadata(meta) {
-  let turn = meta?.['x-codex-turn-metadata'] || {};
-  if (typeof turn === 'string') {
-    try { turn = JSON.parse(turn); } catch { turn = {}; }
-  }
-  return turn;
-}
-
-function sessionIdentity({ meta, env = process.env, payload } = {}) {
-  const turn = turnMetadata(meta);
-  const thread = meta?.['openai/threadId'] || meta?.['openai/thread_id'] || meta?.codexThreadId
-    || meta?.codex_thread_id || turn.thread_id || payload?.session_id || payload?.thread_id
-    || env.CODEX_THREAD_ID;
-  if (!thread) return null;
-  const delivery = env.SIDEVOICE_DELIVERY_URL
-    ? { kind: 'http', url: env.SIDEVOICE_DELIVERY_URL, thread }
-    : { kind: 'codex-queue', thread };
-  return { harness: 'codex', thread, delivery };
-}
-
-function deliver(delivery, event) {
-  if (delivery?.kind === 'http') {
-    return fetch(delivery.url, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ thread_id: delivery.thread, text: event.text, message_id: event.message_id,
-        session_id: event.session_id, revision: event.revision, channel: event.channel || 'voice' }),
-      signal: AbortSignal.timeout(30_000),
-    }).then(async response => {
-      if (!response.ok) throw new Error(`Harness delivery failed (${response.status})`);
-      return { status: 'accepted', detail: `receiver answered ${response.status}` };
-    });
-  }
-  if (delivery?.kind !== 'codex-queue') throw new Error(`Unsupported Codex delivery kind: ${delivery?.kind}`);
-  return new Promise((resolve, reject) => {
-    const binary = process.env.SIDEVOICE_CODEX_BIN || 'codex';
-    const args = ['queue', '--thread', delivery.thread, '--message', envelope(event)];
-    execFile(binary, args, { timeout: 30_000, maxBuffer: 1 << 20 }, (error, stdout, stderr) => {
-      if (error) return reject(new Error((stderr || stdout || error.message).toString().trim().slice(0, 400)));
-      resolve({ status: 'accepted', detail: 'codex queue confirmed the thread' });
-    });
-  });
-}
-
-/** Which model this thread runs, from the launch line of the process that owns it, when it says. */
-function engine(thread, env = process.env) {
-  const named = env.CODEX_MODEL || null;
-  return named ? { model: named, effort: env.CODEX_REASONING_EFFORT || null, thinking: null } : null;
-}
-
-const codexHome = () => process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
-
-/** The rollout Codex writes for a thread: `sessions/YYYY/MM/DD/rollout-<stamp>-<thread id>.jsonl`. Found by
- *  its name, newest day first, so nothing has to be asked of Codex's database. */
-export function rolloutPath(threadId) {
-  const root = path.join(codexHome(), 'sessions');
-  const list = dir => { try { return readdirSync(dir).sort().reverse(); } catch { return []; } };
-  for (const year of list(root)) for (const month of list(path.join(root, year))) for (const day of list(path.join(root, year, month))) {
-    const dir = path.join(root, year, month, day);
-    const file = list(dir).find(name => name.endsWith('-' + threadId + '.jsonl'));
-    if (file) return path.join(dir, file);
-  }
-  return null;
-}
-
-/** What one rollout line says, in the terms of the contract: a working transition, a user message, or nothing. */
-export function interpretRollout(entry, state = {}) {
-  const payload = entry?.payload || {};
-  if (entry?.type === 'event_msg') {
-    if (payload.type === 'task_started' && payload.turn_id) { state.turn_id = payload.turn_id; return { working: true, turn_id: payload.turn_id }; }
-    if ((payload.type === 'task_complete' || payload.type === 'turn_aborted') && payload.turn_id) {
-      if (state.turn_id === payload.turn_id) state.turn_id = null;
-      return { working: false, turn_id: payload.turn_id };
-    }
-    return null;
-  }
-  if (entry?.type === 'response_item' && payload.type === 'message' && payload.role === 'user') {
-    const text = (payload.content || []).filter(part => part?.type === 'input_text').map(part => part.text).join('\n');
-    return text ? { text, turn_id: state.turn_id || null } : null;
-  }
-  return null;
-}
-
-const POLL_MS = Number(process.env.SIDEVOICE_WORK_POLL_MS || 400);
-
-/** Watch one thread through its rollout: task_started/task_complete are the turn, a user message is the
- *  moment the thread took it (a queued message is written when the turn starts on it). What the rollout
- *  already holds is read first, silently, so a turn that was running before we looked is reported as
- *  running — old messages are not re-read. */
-export function observe(threadId, handlers) {
-  const state = {};
-  let working = null;
-  return tailJsonl(() => rolloutPath(threadId), (entry, replayed) => {
-    const seen = interpretRollout(entry, state);
-    if (!seen) return;
-    if (typeof seen.working === 'boolean') { working = seen.working; if (!replayed) handlers.working(seen.working, { turn_id: seen.turn_id }); }
-    else if (!replayed) handlers.userMessage({ text: seen.text, turn_id: seen.turn_id });
-  }, { intervalMs: POLL_MS, catchUp: true, caughtUp: () => { if (working !== null) handlers.working(working, { turn_id: working ? state.turn_id : null }); } });
-}
-
-export const codexHarness = defineHarness({
-  name: 'codex',
-  capabilities: {
-    deliver: SUPPORTED,
-    inspectInbound: UNSUPPORTED,
-    working: SUPPORTED,
-    endOfTurn: SUPPORTED,
-    sessionIdentity: SUPPORTED,
-  },
-  deliver,
-  engine,
-  observe,
-  sessionIdentity,
-});
-
-export default codexHarness;

package/harness-contract.mjs

@@ -1,116 +0,0 @@
-/** The harness boundary. A known harness declares every capability; callers never infer support
- *  from a missing method. Missing or malformed declarations remain unknown, never false. */
-
-export const CAPABILITIES = Object.freeze([
-  'deliver',
-  'inspectInbound',
-  'working',
-  'endOfTurn',
-  'sessionIdentity',
-]);
-
-export const SUPPORTED = 'supported';
-export const UNSUPPORTED = 'unsupported';
-export const UNKNOWN = 'unknown';
-const DECLARED_STATES = new Set([SUPPORTED, UNSUPPORTED]);
-
-export function capabilityState(harness, capability) {
-  const state = harness?.capabilities?.[capability];
-  return DECLARED_STATES.has(state) ? state : UNKNOWN;
-}
-
-export function advertisedCapabilities(harness) {
-  return Object.fromEntries(CAPABILITIES.map(capability => [capability, capabilityState(harness, capability)]));
-}
-
-/** `working` and `endOfTurn` are both answered by observation: a harness that supports either
- *  implements `observe(thread, handlers)`, which watches what the harness itself writes about that
- *  conversation and calls back — `working(bool, { turn_id })` on every transition it can see, and
- *  `userMessage({ text, turn_id })` for every user message the conversation admits. It returns a
- *  function that stops watching. Nothing is installed in the harness for this to work. */
-export function defineHarness(definition) {
-  if (!definition?.name) throw new Error('A harness needs a name');
-  for (const capability of CAPABILITIES) {
-    const state = definition.capabilities?.[capability];
-    if (!DECLARED_STATES.has(state)) throw new Error(`${definition.name} must declare ${capability}`);
-    const implemented = capability === 'working' || capability === 'endOfTurn' ? definition.observe : definition[capability];
-    if (state === SUPPORTED && typeof implemented !== 'function') {
-      throw new Error(`${definition.name} declares ${capability} supported but does not implement it`);
-    }
-  }
-  return Object.freeze({ ...definition, capabilities: Object.freeze({ ...definition.capabilities }) });
-}
-
-/** The header before the user's literal words, and — for a voice message — the note after them that
- *  asks the conversation to speak first. The note travels inside the message because it is the only
- *  thing every harness delivers without anything installed; the instructions name it as not the user's. */
-export function envelope(event) {
-  const header = {
-    channel: event.channel === 'room-control' ? 'room-control' : 'voice',
-    session_id: event.session_id,
-    revision: event.revision,
-    message_id: event.message_id,
-  };
-  const note = header.channel === 'voice' ? '\n\n' + nudge(header) : '';
-  return JSON.stringify(header) + '\n\n' + event.text + note;
-}
-
-/** What the conversation is asked at the moment it reads a voice message: one line that points at the
- *  server's instructions, which are already in context — not a copy of them. The harness adds its own
- *  wrapper around a cross-session message; ours stays small. */
-export function nudge(header) {
-  return `[Sidevoice] Voice from the room: acknowledge with voice_say (session_id "${header.session_id}", revision ${header.revision}) before any other tool, then work and reply by voice, as the sidevoice server's instructions say.`;
-}
-
-/** The header at the front of a delivered message, or null when the text is not one of ours. Works on
- *  the text as a harness stores it, which may put its own line before the header. */
-export function voiceEnvelope(text) {
-  if (typeof text !== 'string') return null;
-  const start = text.indexOf('{"channel":');
-  if (start < 0) return null;
-  const end = text.indexOf('}', start);
-  if (end < 0) return null;
-  let header;
-  try { header = JSON.parse(text.slice(start, end + 1)); } catch { return null; }
-  if (!header || (header.channel !== 'voice' && header.channel !== 'room-control') || !header.message_id || !header.session_id || !Number.isInteger(header.revision)) return null;
-  return { channel: header.channel, message_id: header.message_id, session_id: header.session_id, revision: header.revision };
-}
-
-/** Follows a JSON-lines file the harness appends to: each complete new line is handed to `onLine` as
- *  parsed JSON. From where the file is now, unless `catchUp` is set — then what is already there is
- *  read first, with `replayed = true`, so a watcher can learn the current state without mistaking old
- *  lines for news. The file may not exist yet — `locate` is asked again until it does. */
-export function tailJsonl(locate, onLine, { intervalMs = 400, catchUp = false, caughtUp = () => {} } = {}) {
-  let file = null, offset = null, remainder = '', replaying = false;
-  const poll = async () => {
-    const { statSync, openSync, readSync, closeSync } = await import('node:fs');
-    if (!file) { file = locate(); if (!file) return; }
-    let size;
-    try { size = statSync(file).size; } catch { file = null; offset = null; return; }
-    if (offset === null) {
-      if (!catchUp) { offset = size; return; }                // start at the end: only what happens from now on
-      offset = 0; replaying = true;
-    }
-    if (size < offset) { offset = 0; remainder = ''; }        // rewritten: read it again from the top
-    if (size === offset) return;
-    const fd = openSync(file, 'r');
-    try {
-      const buffer = Buffer.alloc(size - offset);
-      readSync(fd, buffer, 0, buffer.length, offset);
-      offset = size;
-      remainder += buffer.toString('utf8');
-    } finally { closeSync(fd); }
-    let index;
-    while ((index = remainder.indexOf('\n')) >= 0) {
-      const line = remainder.slice(0, index); remainder = remainder.slice(index + 1);
-      if (!line.trim()) continue;
-      let parsed; try { parsed = JSON.parse(line); } catch { continue; }
-      try { onLine(parsed, replaying); } catch {}
-    }
-    if (replaying) { replaying = false; try { caughtUp(); } catch {} }
-  };
-  const timer = setInterval(() => { poll().catch(() => {}); }, intervalMs);
-  timer.unref?.();
-  poll().catch(() => {});
-  return () => clearInterval(timer);
-}

package/harness-http.mjs

@@ -1,39 +0,0 @@
-/** Generic HTTP harness used by explicitly configured external receivers. */
-import { defineHarness, SUPPORTED, UNSUPPORTED } from './harness-contract.mjs';
-
-async function deliver(delivery, event) {
-  if (delivery?.kind !== 'http') throw new Error(`Unsupported HTTP delivery kind: ${delivery?.kind}`);
-  const response = await fetch(delivery.url, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json' },
-    body: JSON.stringify({ thread_id: delivery.thread, text: event.text, message_id: event.message_id,
-      session_id: event.session_id, revision: event.revision, channel: event.channel || 'voice' }),
-    signal: AbortSignal.timeout(30_000),
-  });
-  if (!response.ok) throw new Error(`Harness delivery failed (${response.status})`);
-  return { status: 'accepted', detail: `receiver answered ${response.status}` };
-}
-
-function sessionIdentity({ env = process.env } = {}) {
-  if (!env.SIDEVOICE_THREAD || !env.SIDEVOICE_DELIVERY_URL) return null;
-  return {
-    harness: env.SIDEVOICE_HARNESS || 'http',
-    thread: env.SIDEVOICE_THREAD,
-    delivery: { kind: 'http', url: env.SIDEVOICE_DELIVERY_URL, thread: env.SIDEVOICE_THREAD },
-  };
-}
-
-export const httpHarness = defineHarness({
-  name: 'http',
-  capabilities: {
-    deliver: SUPPORTED,
-    inspectInbound: UNSUPPORTED,
-    working: UNSUPPORTED,
-    endOfTurn: UNSUPPORTED,
-    sessionIdentity: SUPPORTED,
-  },
-  deliver,
-  sessionIdentity,
-});
-
-export default httpHarness;

package/harnesses.mjs

@@ -1,19 +0,0 @@
-/** Registry and selection for the harness modules. The façade and connector ask this registry;
- *  neither contains harness-name branches. */
-import { claudeHarness } from './harness-claude.mjs';
-import { codexHarness } from './harness-codex.mjs';
-import { httpHarness } from './harness-http.mjs';
-
-export const harnesses = Object.freeze({ claude: claudeHarness, codex: codexHarness, http: httpHarness });
-
-export function harnessFor(name) {
-  return harnesses[name] || httpHarness;
-}
-
-export function identifyHarness(meta, env = process.env) {
-  for (const harness of [claudeHarness, codexHarness, httpHarness]) {
-    const identity = harness.sessionIdentity({ meta, env });
-    if (identity?.delivery) return { ...identity, module: harness };
-  }
-  throw new Error('Cannot tell which conversation this is: not launched by Claude Code or Codex, and no SIDEVOICE_THREAD/SIDEVOICE_DELIVERY_URL set');
-}