@elbow-dev/acp 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,4 @@
+Copyright (c) 2026 Keyholdr, Inc. All rights reserved.
+
+This software is provided to use with an Elbow account (https://elbow.dev), under your agreement with
+Keyholdr, Inc. It may not be copied, modified or redistributed except as that agreement allows.

package/acp.mjs

@@ -0,0 +1,623 @@
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import readline from 'node:readline';
+import { pathToFileURL } from 'node:url';
+
+// Elbow's own harness (server/vm/agent.mjs) as an Agent Client Protocol agent on stdio, for apps that run one, such as
+// T3 Code's "Local ACP command" (`elbow acp`). Protocol version 1: https://agentclientprotocol.com. Stdout carries only
+// the protocol; anything else goes to stderr.
+
+const KINDS = { read_file: 'read', write_file: 'edit', edit_file: 'edit', search: 'search', bash: 'execute' };
+const EDITS = new Set(['write_file', 'edit_file']);
+const OUTPUT_CHARS = 16_384;
+// A running command's output reaches the app at most this often.
+const LIVE_MS = 250;
+// Elbow counts a request's cost as it logs it, a moment after the reply ends.
+const COST_SETTLE_MS = 400;
+const MODE_NAMES = { elbow: 'Balanced' };
+// The coordinator's mode is tuned for the coordinator's own tools, not for coding.
+const HIDDEN = new Set(['elbow-coordinator']);
+// T3's Plan toggle picks the mode called plan.
+const SESSION_MODES = [
+  { id: 'build', name: 'Build', description: 'Reads, edits and runs commands.' },
+  { id: 'plan', name: 'Plan', description: 'Reads and plans; changes no files.' },
+];
+const PLAN_TASK =
+  '\n\n(Plan mode: read what you need, then reply with a plan for this. Change no files; the person will switch to Build to carry it out.)';
+const PLAN_REFUSAL =
+  'This conversation is in Plan mode, so files stay as they are. Put the change in your plan instead.';
+
+const titleOf = (tool, input = {}) => {
+  if (tool === 'read_file') return `Read ${input.path}`;
+  if (tool === 'write_file') return `Write ${input.path}`;
+  if (tool === 'edit_file') return `Edit ${input.path ?? input.edits?.[0]?.path ?? ''}`.trim();
+  if (tool === 'search') return input.pattern ? `Search ${input.pattern}` : 'List files';
+  if (tool === 'bash') return String(input.command ?? '').split('\n')[0].slice(0, 120);
+  return tool;
+};
+
+const modeName = (id) =>
+  MODE_NAMES[id] ??
+  id
+    .replace(/^elbow-/, '')
+    .replace(/-/g, ' ')
+    .replace(/^./, (c) => c.toUpperCase());
+
+const text = (value) => ({ type: 'content', content: { type: 'text', text: String(value ?? '').slice(-OUTPUT_CHARS) } });
+
+// What the person sent, as the harness takes a task: text, with images apart and files the app attached inlined.
+const taskOf = (prompt = []) => {
+  const parts = [];
+  const images = [];
+  for (const block of prompt) {
+    if (block.type === 'text') parts.push(block.text);
+    else if (block.type === 'image' && block.data)
+      images.push({ media_type: block.mimeType, data: block.data });
+    else if (block.type === 'resource_link') parts.push(`@${block.name ?? block.uri} (${block.uri})`);
+    else if (block.type === 'resource' && typeof block.resource?.text === 'string')
+      parts.push(`<file path="${block.resource.uri}">\n${block.resource.text}\n</file>`);
+  }
+  return { task: parts.join('\n\n'), images };
+};
+
+// A stopped turn can end on tool calls that never got results, which the next request may not carry.
+const settled = (messages) => {
+  while (
+    messages.at(-1)?.role === 'assistant' &&
+    Array.isArray(messages.at(-1).content) &&
+    messages.at(-1).content.some((b) => b.type === 'tool_use')
+  )
+    messages.pop();
+  return messages;
+};
+
+const blocksOf = (content) => (typeof content === 'string' ? [{ type: 'text', text: content }] : (content ?? []));
+
+// ACP's "authentication required": the app offers its sign-in methods.
+const SIGN_IN = -32000;
+const signIn = () => Object.assign(new Error('Sign in to Elbow first.'), { code: SIGN_IN });
+const invalid = (message) => Object.assign(new Error(message), { code: -32602 });
+
+// T3 runs the agent's own command again with these arguments in a terminal of its own, then reconnects.
+const AUTH_METHODS = [
+  {
+    type: 'terminal',
+    id: 'elbow-login',
+    name: 'Sign in to Elbow',
+    description: 'Confirm this machine in your browser, as elbow login does.',
+    args: ['--login'],
+  },
+];
+
+// The modes this key may use: Balanced for everyone, the hidden ones for Elbow's own people. A key Elbow refuses
+// (signed out, or a revoked token) means signing in again.
+const modesOf = async (url, key) => {
+  if (!key) throw signIn();
+  let res;
+  try {
+    res = await fetch(`${url}/v1/models?hidden=1`, { headers: { 'x-api-key': key } });
+  } catch {
+    return ['elbow'];
+  }
+  if (res.status === 401) throw signIn();
+  try {
+    const { data = [] } = await res.json();
+    const ids = data
+      .map((m) => m.id)
+      .filter((id) => (id === 'elbow' || id.startsWith('elbow-')) && !HIDDEN.has(id));
+    return ids.includes('elbow') ? ids : ['elbow', ...ids];
+  } catch {
+    return ['elbow'];
+  }
+};
+
+// What the dashboard calls the session's repository: the checkout's folder, as `elbow claude` names it.
+const repoOf = async (box, cwd) => {
+  const { code, output } = await box
+    .run(['git', 'rev-parse', '--show-toplevel'], { cwd, seconds: 5 })
+    .catch(() => ({ code: 1 }));
+  const name = code ? '' : path.basename(output.trim()).replace(/[^\w.-]/g, '_').slice(0, 100);
+  return name || null;
+};
+
+// `saved` is the folder sessions are kept in, so a thread survives the app restarting; without it they last as long as
+// the process.
+export const serve = ({ input, output, url, key, agent, box, saved = null, version = 'dev' }) => {
+  const sessions = new Map();
+  const waiting = new Map();
+  // Costs still being counted after a turn, which the process waits for before it exits.
+  const counting = new Set();
+  let modes;
+  let asked = 0;
+  const write = (message) => output.write(`${JSON.stringify({ jsonrpc: '2.0', ...message })}\n`);
+  const notify = (sessionId, update) =>
+    write({ method: 'session/update', params: { sessionId, update } });
+  const request = (method, params) =>
+    new Promise((resolve, reject) => {
+      asked += 1;
+      waiting.set(asked, { resolve, reject });
+      write({ id: asked, method, params });
+    });
+
+  const options = (session) => [
+    {
+      id: 'model',
+      name: 'Mode',
+      category: 'model',
+      type: 'select',
+      currentValue: session.model,
+      options: modes.map((value) => ({ value, name: modeName(value) })),
+    },
+  ];
+  const modeState = (session) => ({ currentModeId: session.mode, availableModes: SESSION_MODES });
+  const commands = () => [
+    { name: 'compact', description: 'Summarize the conversation so far, to free up context' },
+    {
+      name: 'mode',
+      description: "Switch Elbow's mode",
+      input: { hint: modes.map((m) => modeName(m).toLowerCase()).join(' | ') },
+    },
+  ];
+
+  const fileOf = (id) => saved && path.join(saved, `${id.replace(/[^\w-]/g, '')}.json`);
+  const save = async (id, session) => {
+    if (!saved) return;
+    await fs.mkdir(saved, { recursive: true, mode: 0o700 });
+    const { cwd, model, mode, title, messages, cost, updatedAt } = session;
+    const body = JSON.stringify({ sessionId: id, cwd, model, mode, title, updatedAt, cost, messages });
+    await fs.writeFile(`${fileOf(id)}.part`, body, { mode: 0o600 });
+    await fs.rename(`${fileOf(id)}.part`, fileOf(id));
+  };
+  const savedSession = async (id) => {
+    const body = saved && (await fs.readFile(fileOf(id), 'utf8').catch(() => null));
+    if (!body) throw invalid(`No session ${id}.`);
+    return JSON.parse(body);
+  };
+
+  const sessionOf = (id) => {
+    const session = sessions.get(id);
+    if (!session) throw invalid(`No session ${id}.`);
+    return session;
+  };
+
+  const choose = (session, value) => {
+    if (!modes.includes(value)) throw invalid(`${value} isn't a mode this key can use.`);
+    session.model = value;
+  };
+
+  const open = async (id, body) => {
+    modes ??= await modesOf(url, key);
+    const workspace = path.resolve(body.cwd);
+    const session = {
+      cwd: workspace,
+      repo: await repoOf(box, workspace),
+      model: modes.includes(body.model) ? body.model : modes[0],
+      mode: body.mode === 'plan' ? 'plan' : 'build',
+      title: body.title ?? null,
+      messages: body.messages ?? [],
+      cost: body.cost ?? { base: 0, last: 0 },
+      updatedAt: body.updatedAt ?? new Date().toISOString(),
+      allowed: new Set(),
+      controller: null,
+      turn: 0,
+    };
+    sessions.set(id, session);
+    // After the reply, so the app has the session before it hears about it.
+    setImmediate(() => {
+      notify(id, { sessionUpdate: 'available_commands_update', availableCommands: commands() });
+      report(id, session);
+    });
+    return session;
+  };
+  const opened = (session) => ({ modes: modeState(session), configOptions: options(session) });
+
+  // The context Elbow last reported against where the harness compacts, and what the session has cost. Elbow's count
+  // starts again when the API restarts, so a count that drops is added on top of the one before.
+  const report = (sessionId, session) =>
+    notify(sessionId, {
+      sessionUpdate: 'usage_update',
+      used: session.tokens ?? 0,
+      size: agent.COMPACT_TOKENS,
+      cost: { amount: +(session.cost.base + session.cost.last).toFixed(4), currency: 'USD' },
+    });
+  const priced = async (sessionId, session) => {
+    try {
+      const res = await fetch(`${url}/v1/usage?session=${encodeURIComponent(sessionId)}`, {
+        headers: { 'x-api-key': key },
+      });
+      const { cost_usd: now } = await res.json();
+      if (typeof now !== 'number') return;
+      if (now < session.cost.last) session.cost.base += session.cost.last;
+      session.cost.last = now;
+    } catch {}
+  };
+
+  // The history of a reopened thread, as the app shows a live one.
+  const replay = (sessionId, messages) => {
+    const results = new Map(
+      messages
+        .flatMap((m) => blocksOf(m.content))
+        .filter((b) => b.type === 'tool_result')
+        .map((b) => [b.tool_use_id, b]),
+    );
+    for (const m of messages) {
+      const blocks = blocksOf(m.content);
+      if (m.role === 'user') {
+        if (blocks.some((b) => b.type === 'tool_result')) continue;
+        for (const b of blocks)
+          if (b.type === 'text')
+            notify(sessionId, { sessionUpdate: 'user_message_chunk', content: { type: 'text', text: b.text } });
+        continue;
+      }
+      for (const b of blocks) {
+        if (b.type === 'text')
+          notify(sessionId, { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: b.text } });
+        else if (b.type === 'tool_use') {
+          const result = results.get(b.id);
+          notify(sessionId, {
+            sessionUpdate: 'tool_call',
+            toolCallId: b.id,
+            title: titleOf(b.name, b.input),
+            kind: KINDS[b.name] ?? 'other',
+            status: result?.is_error ? 'failed' : 'completed',
+            rawInput: b.input ?? {},
+            ...(result && { content: [text(result.content)] }),
+          });
+        }
+      }
+    }
+  };
+
+  const approve = (sessionId, session, signal) => async (use, call) => {
+    if (session.mode === 'plan' && EDITS.has(use.name)) return PLAN_REFUSAL;
+    if (session.allowed.has(use.name)) return true;
+    const asking = request('session/request_permission', {
+      sessionId,
+      toolCall: {
+        toolCallId: `call-${session.turn}-${call}`,
+        title: titleOf(use.name, use.input),
+        kind: KINDS[use.name] ?? 'other',
+        status: 'pending',
+        rawInput: use.input ?? {},
+      },
+      options: [
+        { optionId: 'allow', name: 'Allow', kind: 'allow_once' },
+        { optionId: 'always', name: `Always allow ${use.name}`, kind: 'allow_always' },
+        { optionId: 'reject', name: 'Reject', kind: 'reject_once' },
+      ],
+    });
+    const stopped = new Promise((resolve) =>
+      signal.addEventListener('abort', () => resolve({ outcome: { outcome: 'cancelled' } }), {
+        once: true,
+      }),
+    );
+    const { outcome } = await Promise.race([asking, stopped]);
+    if (outcome?.outcome !== 'selected' || outcome.optionId === 'reject') return false;
+    if (outcome.optionId === 'always') session.allowed.add(use.name);
+    return true;
+  };
+
+  const say = (sessionId, words) =>
+    notify(sessionId, { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: words } });
+
+  // `/compact` and `/mode <name>`, the commands the app lists in its / menu.
+  const command = async (sessionId, session, task, signal) => {
+    const [, name, rest = ''] = /^\/(\w+)\s*([\s\S]*)$/.exec(task.trim()) ?? [];
+    if (name === 'mode') {
+      const wanted = rest.trim().toLowerCase();
+      const found = modes.find((m) => m === wanted || modeName(m).toLowerCase() === wanted);
+      if (!found) {
+        say(sessionId, `Elbow's modes here: ${modes.map(modeName).join(', ')}.`);
+        return true;
+      }
+      session.model = found;
+      notify(sessionId, { sessionUpdate: 'config_option_update', configOptions: options(session) });
+      say(sessionId, `Mode: ${modeName(found)}.`);
+      return true;
+    }
+    if (name !== 'compact') return false;
+    const summary = await agent
+      .compactConversation({
+        url,
+        key,
+        model: session.model,
+        run: sessionId,
+        workspace: session.cwd,
+        box,
+        messages: session.messages,
+        signal,
+        instructions: agent.chatSystem,
+        headers: { 'x-elbow-agent': 'elbow', ...(session.repo && { 'x-elbow-repo': session.repo }) },
+      })
+      .catch((e) => e);
+    if (signal.aborted) return true;
+    if (!session.messages.length) say(sessionId, 'Nothing to compact yet.');
+    else if (typeof summary === 'string') {
+      session.tokens = Math.ceil(summary.length / 4);
+      say(sessionId, 'Compacted the conversation; it goes on from a summary.');
+    } else say(sessionId, `Couldn't compact the conversation${summary?.message ? `: ${summary.message}` : '.'}`);
+    return true;
+  };
+
+  const prompt = async ({ sessionId, prompt: blocks }) => {
+    const session = sessionOf(sessionId);
+    session.controller?.abort();
+    const controller = new AbortController();
+    session.controller = controller;
+    session.turn += 1;
+    const { turn } = session;
+    const { task, images } = taskOf(blocks);
+    session.title ??= task.split('\n')[0].slice(0, 80) || null;
+    session.updatedAt = new Date().toISOString();
+    const keep = () =>
+      save(sessionId, session).catch((e) => console.error(`Couldn't save the session: ${e.message}`));
+    const finish = async (stopReason) => {
+      settled(session.messages);
+      if (session.controller === controller) session.controller = null;
+      await keep();
+      // After the reply, so the turn doesn't wait on the count.
+      const counted = new Promise((ok) => setTimeout(ok, COST_SETTLE_MS))
+        .then(() => priced(sessionId, session))
+        .then(() => {
+          report(sessionId, session);
+          return keep();
+        })
+        .finally(() => counting.delete(counted));
+      counting.add(counted);
+      return { stopReason };
+    };
+    if (task.trim().startsWith('/') && (await command(sessionId, session, task, controller.signal)))
+      return finish(controller.signal.aborted ? 'cancelled' : 'end_turn');
+
+    let spoke = false;
+    // Text after a tool call or another model turn starts a paragraph of its own.
+    let apart = false;
+    let limited = false;
+    let ended = null;
+    const speak = (words) => {
+      say(sessionId, spoke && apart ? `\n\n${words}` : words);
+      spoke = true;
+      apart = false;
+    };
+    const stream = ({ type, text: words }) => {
+      if (type === 'text') speak(words);
+      else
+        notify(sessionId, {
+          sessionUpdate: 'agent_thought_chunk',
+          content: { type: 'text', text: words },
+        });
+    };
+    // What each edit changed, for the app's diff view; and the command running now, whose output it shows as it comes.
+    const diffs = new Map();
+    const written = new Map();
+    let live = null;
+    const watched = {
+      ...box,
+      write: async (file, data) => {
+        const before = await box.read(file).then(String, () => null);
+        await box.write(file, data);
+        written.set(file, { oldText: before, newText: String(data) });
+      },
+      run: (args, o) =>
+        box.run(args, {
+          ...o,
+          onOutput: (chunk) => {
+            if (!live) return;
+            live.output += chunk;
+            if (live.timer) return;
+            live.timer = setTimeout(() => {
+              if (!live) return;
+              live.timer = null;
+              notify(sessionId, {
+                sessionUpdate: 'tool_call_update',
+                toolCallId: live.id,
+                content: [text(live.output)],
+              });
+            }, LIVE_MS);
+          },
+        }),
+    };
+    const record = (receipt) => {
+      apart = true;
+      const id = `call-${turn}-${receipt.call}`;
+      if (receipt.event === 'tool_started') {
+        const file = receipt.input?.path;
+        if (receipt.tool === 'bash') live = { id, output: '', timer: null };
+        notify(sessionId, {
+          sessionUpdate: 'tool_call',
+          toolCallId: id,
+          title: titleOf(receipt.tool, receipt.input),
+          kind: KINDS[receipt.tool] ?? 'other',
+          status: 'in_progress',
+          rawInput: receipt.input ?? {},
+          ...(typeof file === 'string' && { locations: [{ path: path.resolve(session.cwd, file) }] }),
+        });
+      } else if (receipt.event === 'write_completed') {
+        const full = path.resolve(session.cwd, receipt.path);
+        const change = written.get(full);
+        written.delete(full);
+        if (!change) return;
+        diffs.set(id, [...(diffs.get(id) ?? []), { type: 'diff', path: full, ...change }]);
+        notify(sessionId, { sessionUpdate: 'tool_call_update', toolCallId: id, content: diffs.get(id) });
+      } else if (receipt.event === 'tool_completed') {
+        if (live?.id === id) {
+          clearTimeout(live.timer);
+          live = null;
+        }
+        const ok = receipt.outcome === 'ok';
+        notify(sessionId, {
+          sessionUpdate: 'tool_call_update',
+          toolCallId: id,
+          status: ok ? 'completed' : 'failed',
+          content: ok && diffs.has(id) ? diffs.get(id) : [text(receipt.output)],
+        });
+      } else if (receipt.event === 'limit') limited = true;
+      else if (receipt.event === 'run_completed') ended = receipt;
+    };
+    await agent.runAgent({
+      url,
+      key,
+      model: session.model,
+      // One session per thread, so Elbow keeps its turns together on the dashboard.
+      run: sessionId,
+      task: session.mode === 'plan' ? `${task}${PLAN_TASK}` : task,
+      images,
+      workspace: session.cwd,
+      checks: [],
+      record,
+      signal: controller.signal,
+      box: watched,
+      instructions: agent.chatSystem,
+      conversation: session.messages,
+      approve: approve(sessionId, session, controller.signal),
+      // Only the warning that calls are running out: a question needs no push to start editing.
+      nudge: (counts) => {
+        const note = agent.nudgeOf(counts);
+        return note && /calls left/.test(note) ? note : null;
+      },
+      headers: { 'x-elbow-agent': 'elbow', ...(session.repo && { 'x-elbow-repo': session.repo }) },
+      stream,
+      measured: (tokens) => {
+        session.tokens = tokens;
+        report(sessionId, session);
+        priced(sessionId, session);
+      },
+    });
+    if (controller.signal.aborted) return finish('cancelled');
+    if (limited) return finish('max_turn_requests');
+    if (ended?.outcome === 'error') {
+      if (/out of output tokens/.test(ended.error)) return finish('max_tokens');
+      speak(`Elbow stopped: ${ended.error}`);
+    }
+    return finish('end_turn');
+  };
+
+  const methods = {
+    initialize: () => ({
+      protocolVersion: 1,
+      agentCapabilities: {
+        loadSession: !!saved,
+        promptCapabilities: { image: true, embeddedContext: true },
+        ...(saved && { sessionCapabilities: { list: {}, resume: {} } }),
+      },
+      agentInfo: { name: 'elbow', title: 'Elbow', version },
+      authMethods: AUTH_METHODS,
+    }),
+    authenticate: () => ({}),
+    'session/new': async ({ cwd }) => {
+      const sessionId = `acp_${randomUUID()}`;
+      return { sessionId, ...opened(await open(sessionId, { cwd })) };
+    },
+    'session/load': async ({ sessionId, cwd }) => {
+      const body = await savedSession(sessionId);
+      const session = await open(sessionId, { ...body, cwd: cwd ?? body.cwd });
+      replay(sessionId, session.messages);
+      return opened(session);
+    },
+    'session/resume': async ({ sessionId, cwd }) => {
+      const body = await savedSession(sessionId);
+      return opened(await open(sessionId, { ...body, cwd: cwd ?? body.cwd }));
+    },
+    'session/list': async ({ cwd }) => {
+      const names = saved ? await fs.readdir(saved).catch(() => []) : [];
+      const all = await Promise.all(
+        names
+          .filter((n) => n.endsWith('.json'))
+          .map((n) =>
+            fs
+              .readFile(path.join(saved, n), 'utf8')
+              .then((b) => JSON.parse(b))
+              .catch(() => null),
+          ),
+      );
+      const sessionsHere = all
+        .filter((s) => s && (!cwd || path.resolve(cwd) === s.cwd))
+        .sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt)))
+        .map(({ sessionId, cwd: dir, title, updatedAt }) => ({ sessionId, cwd: dir, title, updatedAt }));
+      return { sessions: sessionsHere };
+    },
+    'session/set_mode': ({ sessionId, modeId }) => {
+      const session = sessionOf(sessionId);
+      if (!SESSION_MODES.some((m) => m.id === modeId)) throw invalid(`No mode ${modeId}.`);
+      session.mode = modeId;
+      notify(sessionId, { sessionUpdate: 'current_mode_update', currentModeId: modeId });
+      return {};
+    },
+    'session/set_config_option': ({ sessionId, configId, value }) => {
+      const session = sessionOf(sessionId);
+      if (configId !== 'model') throw invalid(`No option ${configId}.`);
+      choose(session, value);
+      return { configOptions: options(session) };
+    },
+    'session/set_model': ({ sessionId, modelId }) => {
+      choose(sessionOf(sessionId), modelId);
+      return {};
+    },
+    'session/prompt': prompt,
+  };
+
+  const answer = async ({ id, method, params }) => {
+    try {
+      if (!methods[method])
+        throw Object.assign(new Error(`Elbow doesn't support ${method}.`), { code: -32601 });
+      write({ id, result: await methods[method](params ?? {}) });
+    } catch (e) {
+      write({ id, error: { code: e.code ?? -32603, message: e.message } });
+    }
+  };
+
+  const lines = readline.createInterface({ input });
+  lines.on('line', (line) => {
+    if (!line.trim()) return;
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return write({ id: null, error: { code: -32700, message: 'Not JSON.' } });
+    }
+    if (message.method && message.id != null) return answer(message);
+    if (message.method === 'session/cancel')
+      return sessions.get(message.params?.sessionId)?.controller?.abort();
+    if (message.method) return;
+    const pending = waiting.get(message.id);
+    if (!pending) return;
+    waiting.delete(message.id);
+    if (message.error) pending.reject(new Error(message.error.message));
+    else pending.resolve(message.result ?? {});
+  });
+  return new Promise((resolve) =>
+    lines.on('close', () => Promise.allSettled([...counting]).then(() => resolve())),
+  );
+};
+
+// Runs the agent with the person's own environment for their commands; `key`, when given, never reaches them.
+export const start = async ({ agent, key, url, version, saved }) => {
+  const env = { ...process.env };
+  delete env.ELBOW_KEY;
+  const box = {
+    ...agent.local,
+    run: ([command, ...args], o) => agent.sh(command, args, { ...o, env }),
+  };
+  await serve({ input: process.stdin, output: process.stdout, url, key, agent, box, saved, version });
+  process.exit(0);
+};
+
+// `elbow acp` starts this with the harness's path, the key (empty when signed out) and the sessions folder in the
+// environment; the key leaves the environment before anything the agent runs could see it.
+const main = async () => {
+  const agent = await import(pathToFileURL(path.resolve(process.argv[2])));
+  const key = process.env.ELBOW_KEY;
+  const url = process.env.ELBOW_URL ?? 'https://api.elbow.dev';
+  const version = process.env.ELBOW_VERSION;
+  const saved = process.env.ELBOW_ACP_SESSIONS || null;
+  for (const name of ['ELBOW_KEY', 'ELBOW_VERSION', 'ELBOW_ACP_SESSIONS']) delete process.env[name];
+  await start({ agent, key, url, version, saved });
+};
+
+// Node resolves module symlinks, including macOS's /var -> /private/var, before setting import.meta.url.
+const entry = await fs.realpath(process.argv[1] ?? '').catch(() => null);
+if (
+  import.meta.url === pathToFileURL(process.argv[1] ?? '').href ||
+  (entry && import.meta.url === pathToFileURL(entry).href)
+) main();