@gobius/t3ctl 0.4.0 → 0.6.0

package/t3ctl.mjs

@@ -1,520 +0,0 @@
-#!/usr/bin/env node
-// t3ctl — a controller CLI for T3 Code hosts.
-// Peer of the mobile app: pairs once per host, then reads/controls remotely.
-// Spike scope: host registry + read-only listing.
-
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-const CONFIG_DIR = path.join(os.homedir(), '.config', 't3ctl');
-const HOSTS_FILE = path.join(CONFIG_DIR, 'hosts.json');
-
-const readHosts = () => {
-  if (!fs.existsSync(HOSTS_FILE)) return [];
-  return JSON.parse(fs.readFileSync(HOSTS_FILE, 'utf8')).hosts ?? [];
-};
-
-const writeHosts = (hosts) => {
-  fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
-  fs.writeFileSync(HOSTS_FILE, JSON.stringify({ hosts }, null, 2), { mode: 0o600 });
-};
-
-const snapshot = async (host) => {
-  const res = await fetch(`${host.origin}/api/orchestration/snapshot`, {
-    headers: host.token ? { authorization: `Bearer ${host.token}` } : {},
-    signal: AbortSignal.timeout(host.timeoutMs ?? 15000),
-  });
-  if (!res.ok) throw new Error(`${host.name}: HTTP ${res.status} ${await res.text().catch(() => '')}`.trim());
-  return res.json();
-};
-
-// Derived status. Order matters: most urgent wins.
-const threadStatus = (t) => {
-  if (t.deletedAt) return 'deleted';
-  if (t.archivedAt) return 'archived';
-  if (t.session?.activeTurnId || t.session?.status === 'running') return 'running';
-  if (t.session?.status === 'error' || t.latestTurn?.state === 'error') return 'error';
-  if (t.snoozedUntil && new Date(t.snoozedUntil) > new Date()) return 'snoozed';
-  if (t.proposedPlans?.length) return 'needs-review';
-  if (t.settledAt && !t.unsettledAt) return 'settled';
-  return 'idle';
-};
-
-const ICON = {
-  running: '\x1b[32m●\x1b[0m', error: '\x1b[31m✕\x1b[0m', 'needs-review': '\x1b[33m◆\x1b[0m',
-  snoozed: '\x1b[90m☾\x1b[0m', settled: '\x1b[90m✓\x1b[0m', idle: '\x1b[90m·\x1b[0m',
-  archived: '\x1b[90m▪\x1b[0m', deleted: '\x1b[90m✗\x1b[0m',
-};
-const dim = (s) => `\x1b[90m${s}\x1b[0m`;
-// Usage errors are user errors: print to stderr and exit non-zero so scripts
-// can tell them apart from success.
-const usage = (message) => {
-  console.error(message);
-  process.exitCode = 1;
-};
-const bold = (s) => `\x1b[1m${s}\x1b[0m`;
-
-const collect = async (hosts) => {
-  const results = await Promise.allSettled(hosts.map(async (h) => ({ host: h, snap: await snapshot(h) })));
-  const ok = [], failed = [];
-  results.forEach((r, i) => r.status === 'fulfilled' ? ok.push(r.value) : failed.push({ host: hosts[i], error: r.reason.message }));
-  return { ok, failed };
-};
-
-const cmdLs = async (args) => {
-  const showThreads = args.includes('--threads') || args.includes('-t');
-  const showAll = args.includes('--all') || args.includes('-a');
-  const asJson = args.includes('--json');
-  const hosts = readHosts();
-  if (!hosts.length) return console.error('No hosts registered. Run: t3ctl host add <origin> <token>');
-
-  const { ok, failed } = await collect(hosts);
-
-  if (asJson) {
-    const out = ok.flatMap(({ host, snap }) => snap.projects
-      .filter((p) => showAll || !p.deletedAt)
-      .map((p) => ({
-        host: host.name, id: p.id, title: p.title, workspaceRoot: p.workspaceRoot,
-        threads: snap.threads.filter((t) => t.projectId === p.id)
-          .filter((t) => showAll || (!t.deletedAt && !t.archivedAt))
-          .map((t) => ({ id: t.id, title: t.title, branch: t.branch, status: threadStatus(t), provider: t.session?.providerName ?? null, updatedAt: t.updatedAt })),
-      })));
-    console.log(JSON.stringify({ projects: out, unreachable: failed.map((f) => ({ host: f.host.name, error: f.error })) }, null, 2));
-    return;
-  }
-
-  for (const { host, snap } of ok) {
-    console.log(`\n${bold(host.name)} ${dim(host.origin)}`);
-    const projects = snap.projects.filter((p) => showAll || !p.deletedAt)
-      .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-
-    for (const p of projects) {
-      const threads = snap.threads.filter((t) => t.projectId === p.id)
-        .filter((t) => showAll || (!t.deletedAt && !t.archivedAt))
-        .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-      if (!threads.length && !showAll) continue;
-
-      const counts = {};
-      for (const t of threads) counts[threadStatus(t)] = (counts[threadStatus(t)] ?? 0) + 1;
-      const badge = Object.entries(counts).map(([k, v]) => `${ICON[k] ?? '?'}${v}`).join(' ');
-
-      console.log(`  ${bold(p.title)}  ${badge}  ${dim(p.workspaceRoot.replace(os.homedir(), '~'))}`);
-      if (!showThreads) continue;
-      for (const t of threads) {
-        const s = threadStatus(t);
-        const meta = [t.branch, t.session?.providerName].filter(Boolean).join(' ');
-        console.log(`    ${ICON[s] ?? '?'} ${(t.title || '(untitled)').slice(0, 62).padEnd(62)} ${dim(meta)}`);
-      }
-    }
-  }
-  for (const f of failed) console.error(`\n\x1b[31munreachable\x1b[0m ${f.host.name}: ${f.error}`);
-};
-
-// ---- host registry ------------------------------------------------------
-// The descriptor at /.well-known/t3/environment is UNAUTHENTICATED, so probing
-// it answers "is anyone home, and is it T3 Code?" without a token — a wrong
-// origin fails here instead of as a baffling 401 on the first real call.
-// Schema: ExecutionEnvironmentDescriptor in packages/contracts/src/environment.ts.
-
-const DESCRIPTOR_PATH = '/.well-known/t3/environment';
-
-const probe = async (origin, timeoutMs = 5000) => {
-  let res;
-  try {
-    res = await fetch(`${origin}${DESCRIPTOR_PATH}`, { signal: AbortSignal.timeout(timeoutMs) });
-  } catch (error) {
-    // Node's fetch reports a bare "fetch failed"; the cause carries the real reason.
-    const why = error.name === 'TimeoutError' ? `no response in ${timeoutMs}ms`
-      : (error.cause?.message ?? error.message);
-    throw new Error(`cannot reach ${origin}: ${why}`);
-  }
-  const notT3 = (why) => new Error(`not a T3 Code server (${DESCRIPTOR_PATH} ${why})`);
-  if (!res.ok) throw notT3(`returned HTTP ${res.status}`);
-  let d;
-  try { d = await res.json(); } catch { throw notT3('is not JSON'); }
-  const missing = ['environmentId', 'label', 'serverVersion'].filter((k) => typeof d?.[k] !== 'string' || !d[k]);
-  if (missing.length) throw notT3(`is missing ${missing.join(', ')}`);
-  return { environmentId: d.environmentId, label: d.label, serverVersion: d.serverVersion };
-};
-
-const shortId = (id) => (id ? id.slice(0, 8) : '-');
-const warn = (message) => console.error(`\x1b[33mwarning\x1b[0m ${message}`);
-
-// The name is what you type in --host, so derive a typeable slug from the label
-// rather than using the label verbatim.
-const slugify = (label) => label.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'host';
-
-const uniqueName = (base, hosts) => {
-  if (!hosts.some((h) => h.name === base)) return base;
-  for (let n = 2; ; n++) if (!hosts.some((h) => h.name === `${base}-${n}`)) return `${base}-${n}`;
-};
-
-const isOrigin = (value) => /^https?:\/\//i.test(value ?? '');
-
-// Two accepted shapes, told apart by the scheme:
-//   host add <origin> [token] [--name <n>]     current
-//   host add <name> <origin> <token>           legacy, still works
-const parseHostAdd = (pos) => {
-  if (isOrigin(pos[0])) return { origin: pos[0], token: pos[1] ?? null, legacy: false };
-  if (isOrigin(pos[1])) return { name: pos[0], origin: pos[1], token: pos[2] ?? null, legacy: true };
-  return null;
-};
-
-const HOST_ADD_USAGE = 'usage: t3ctl host add <origin> [token] [--name <name>]\n' +
-  '       an origin needs a scheme, e.g. http://localhost:3773';
-
-const cmdHostAdd = async (pos, flags, hosts) => {
-  // Validate before any network or registry work so a bare `host add` prints
-  // usage instead of stalling on a probe.
-  const parsed = parseHostAdd(pos);
-  if (!parsed) return usage(HOST_ADD_USAGE);
-  if ('name' in flags && !flags.name) return usage(HOST_ADD_USAGE);
-  if (parsed.legacy) warn('"host add <name> <origin> <token>" is deprecated — use: t3ctl host add <origin> [token] [--name <name>]');
-
-  const origin = parsed.origin.replace(/\/$/, '');
-  const descriptor = await probe(origin);
-  const existing = hosts.find((h) => h.origin === origin);
-
-  // A changed environmentId on a known origin means the origin now points at a
-  // different machine — the stored token almost certainly belongs to the old one.
-  if (existing?.environmentId && existing.environmentId !== descriptor.environmentId) {
-    warn(`${origin} is now a DIFFERENT environment\n` +
-      `  was ${existing.environmentId} (${existing.label ?? 'unknown'})\n` +
-      `  now ${descriptor.environmentId} (${descriptor.label})\n` +
-      `  the token stored for "${existing.name}" was issued by the old one and will likely fail`);
-  }
-
-  const name = flags.name ?? parsed.name ?? existing?.name ??
-    uniqueName(slugify(descriptor.label), hosts);
-  const token = parsed.token ?? existing?.token ?? null;
-
-  const others = hosts.filter((h) => h.name !== name && h.origin !== origin && h.serverVersion);
-  const skewed = [...new Set(others.map((h) => h.serverVersion))].filter((v) => v !== descriptor.serverVersion);
-  if (skewed.length) warn(`serverVersion ${descriptor.serverVersion} differs from other hosts: ${skewed.join(', ')}`);
-
-  writeHosts(hosts.filter((h) => h.name !== name && h.origin !== origin).concat({
-    name, origin, token,
-    environmentId: descriptor.environmentId,
-    label: descriptor.label,
-    serverVersion: descriptor.serverVersion,
-  }));
-  console.log(`added ${bold(name)} -> ${origin}\n  label   ${descriptor.label}\n` +
-    `  env     ${descriptor.environmentId}\n  version ${descriptor.serverVersion}`);
-  if (!token) warn(`no token stored for ${name} — reads will fail until you run: t3ctl host add ${origin} <token>`);
-};
-
-const cmdHostsList = async (hosts) => {
-  if (!hosts.length) return console.log('(no hosts)');
-  const probes = await Promise.allSettled(hosts.map((h) => probe(h.origin)));
-  const drifted = [];
-  hosts.forEach((h, i) => {
-    const p = probes[i];
-    const live = p.status === 'fulfilled' ? p.value : null;
-    if (live && h.environmentId && h.environmentId !== live.environmentId) drifted.push({ h, live });
-    const icon = live ? ICON.running : ICON.error;
-    const label = live?.label ?? h.label ?? '-';
-    const env = shortId(live?.environmentId ?? h.environmentId);
-    const version = live?.serverVersion ?? h.serverVersion ?? '-';
-    // Values for an unreachable host are whatever was last stored, so dim the
-    // whole row to keep remembered data visually distinct from probed data.
-    const cell = (text, width) => (live ? text.padEnd(width) : dim(text.padEnd(width)));
-    console.log(`${icon} ${live ? bold(h.name.padEnd(14)) : dim(h.name.padEnd(14))} ${cell(label, 18)} ${dim(env.padEnd(9))} ${cell(version, 28)} ${dim(h.origin)}` +
-      (live ? '' : ` ${dim(p.reason.message)}`));
-  });
-  for (const { h, live } of drifted) {
-    warn(`${h.name} (${h.origin}) is now a DIFFERENT environment\n` +
-      `  was ${h.environmentId} (${h.label ?? 'unknown'})\n  now ${live.environmentId} (${live.label})`);
-  }
-};
-
-const cmdHost = async (args) => {
-  const [sub, ...rest] = args;
-  const { flags, pos } = parseArgs(rest);
-  const hosts = readHosts();
-  if (sub === 'add') return cmdHostAdd(pos, flags, hosts);
-  if (sub === 'rm') {
-    if (!pos[0]) return usage('usage: t3ctl host rm <name>');
-    writeHosts(hosts.filter((h) => h.name !== pos[0]));
-    console.log(`removed ${pos[0]}`);
-    return;
-  }
-  return cmdHostsList(hosts);
-};
-
-
-// ---- writes -------------------------------------------------------------
-// Commands are dispatched directly (no envelope). The CLIENT mints every id;
-// commandId is the idempotency key, so retries are safe.
-// Schemas: packages/contracts/src/orchestration.ts in pingdotgg/t3code.
-
-const VALUE_FLAGS = ['host', 'model', 'branch', 'runtime-mode', 'interaction-mode', 'worktree', 'name'];
-
-const parseArgs = (argv) => {
-  const flags = {}, pos = [];
-  for (let i = 0; i < argv.length; i++) {
-    const a = argv[i];
-    if (!a.startsWith('--')) { pos.push(a); continue; }
-    const k = a.slice(2);
-    flags[k] = VALUE_FLAGS.includes(k) ? argv[++i] : true;
-  }
-  return { flags, pos };
-};
-
-const pickHost = (flags) => {
-  const hosts = readHosts();
-  if (flags.host) {
-    const h = hosts.find((x) => x.name === flags.host);
-    if (!h) throw new Error(`no such host: ${flags.host}`);
-    return h;
-  }
-  if (!hosts.length) throw new Error('no hosts registered — run: t3ctl host add <origin> <token>');
-  if (hosts.length > 1) throw new Error(`multiple hosts; pass --host <${hosts.map((h) => h.name).join('|')}>`);
-  return hosts[0];
-};
-
-const dispatch = async (host, command) => {
-  const res = await fetch(`${host.origin}/api/orchestration/dispatch`, {
-    method: 'POST',
-    headers: { ...(host.token ? { authorization: `Bearer ${host.token}` } : {}), 'content-type': 'application/json' },
-    body: JSON.stringify(command),
-    signal: AbortSignal.timeout(host.timeoutMs ?? 15000),
-  });
-  const body = await res.text();
-  if (!res.ok) throw new Error(`${command.type} failed: HTTP ${res.status} ${body}`);
-  return body ? JSON.parse(body) : {};
-};
-
-const resolveProject = (snap, ref) =>
-  snap.projects.find((p) => p.id === ref) ??
-  snap.projects.find((p) => !p.deletedAt && p.title === ref) ??
-  snap.projects.find((p) => !p.deletedAt && p.workspaceRoot === path.resolve(ref.replace(/^~/, os.homedir())));
-
-
-// Commands whose entire payload is {commandId, threadId}. Verified against
-// packages/contracts/src/orchestration.ts — note `unsettle` is NOT one of
-// these (it carries extra fields), so it is deliberately absent.
-const SIMPLE_THREAD_COMMANDS = ['settle', 'archive', 'unarchive', 'unpin', 'delete'];
-
-const resolveThread = (snap, ref) => {
-  const live = snap.threads.filter((t) => !t.deletedAt);
-  const byId = live.find((t) => t.id === ref);
-  if (byId) return byId;
-  const exact = live.filter((t) => t.title === ref);
-  if (exact.length === 1) return exact[0];
-  const fuzzy = live.filter((t) => (t.title ?? '').toLowerCase().includes(ref.toLowerCase()));
-  if (fuzzy.length === 1) return fuzzy[0];
-  if (fuzzy.length > 1) {
-    throw new Error(`"${ref}" matches ${fuzzy.length} threads:\n` +
-      fuzzy.slice(0, 8).map((t) => `  ${t.id}  ${t.title}`).join('\n'));
-  }
-  throw new Error(`no thread matching "${ref}"`);
-};
-
-
-// thread.turn.start is ONE command carrying the first message inline — this is
-// what the UI fires immediately after thread.create, which is why a thread with
-// no messages is a state the UI never produces. The client-side schema requires
-// runtimeMode/interactionMode explicitly (the server-side one defaults them).
-const cmdThreadStart = async (thread, host, text, flags) => {
-  const command = {
-    type: 'thread.turn.start',
-    commandId: crypto.randomUUID(),
-    threadId: thread.id,
-    message: { messageId: crypto.randomUUID(), role: 'user', text, attachments: [] },
-    runtimeMode: flags['runtime-mode'] ?? thread.runtimeMode ?? 'full-access',
-    interactionMode: flags['interaction-mode'] ?? 'default',
-    createdAt: new Date().toISOString(),
-  };
-  if (flags.model) {
-    const slash = flags.model.indexOf('/');
-    if (slash < 1) throw new Error(`--model must be <instance>/<model>, got "${flags.model}"`);
-    command.modelSelection = { instanceId: flags.model.slice(0, slash), model: flags.model.slice(slash + 1) };
-  } else if (thread.modelSelection) {
-    command.modelSelection = thread.modelSelection;
-  }
-  const { sequence } = await dispatch(host, command);
-  const m = command.modelSelection;
-  console.log(`started ${bold(thread.title || thread.id)}\n  id    ${thread.id}` +
-    (m ? `\n  model ${m.instanceId}/${m.model}` : '') +
-    `\n  mode  ${command.runtimeMode} / ${command.interactionMode}\n  seq   ${sequence}`);
-};
-
-const cmdThreadInterrupt = async (thread, host) => {
-  const { sequence } = await dispatch(host, {
-    type: 'thread.turn.interrupt', commandId: crypto.randomUUID(), threadId: thread.id,
-  });
-  console.log(`interrupted ${bold(thread.title || thread.id)}\n  seq ${sequence}`);
-};
-
-const cmdProject = async (args) => {
-  const [sub, ...rest] = args;
-  const { flags, pos } = parseArgs(rest);
-  if (sub !== 'create') return usage('usage: t3ctl project create <title> <workspace-root> [--host <name>]');
-  const [title, root] = pos;
-  if (!title || !root) return usage('usage: t3ctl project create <title> <workspace-root> [--host <name>]');
-  const host = pickHost(flags);
-  const workspaceRoot = path.resolve(root.replace(/^~/, os.homedir()));
-  if (!fs.existsSync(workspaceRoot)) return console.error(`workspace root does not exist: ${workspaceRoot}`);
-  const projectId = crypto.randomUUID();
-  const { sequence } = await dispatch(host, {
-    type: 'project.create', commandId: crypto.randomUUID(),
-    projectId, title, workspaceRoot, createdAt: new Date().toISOString(),
-  });
-  console.log(`created project ${bold(title)} on ${host.name}\n  id   ${projectId}\n  root ${workspaceRoot}\n  seq  ${sequence}`);
-};
-
-
-// thread.meta.update also accepts regenerateTitle:true, which asks the server to
-// derive a title from the thread's own content instead of taking one from us.
-const cmdThreadRename = async (thread, host, title) => {
-  const { sequence } = await dispatch(host, {
-    type: 'thread.meta.update', commandId: crypto.randomUUID(), threadId: thread.id, title,
-  });
-  console.log(`renamed ${dim(thread.title || thread.id)} -> ${bold(title)}\n  seq ${sequence}`);
-};
-
-// Lighter than the full snapshot; retitle polls this so it does not refetch every
-// thread's history once a second.
-const threadDetail = async (host, threadId) => {
-  const res = await fetch(`${host.origin}/api/orchestration/threads/${threadId}?turnLimit=1`, {
-    headers: { authorization: `Bearer ${host.token}` },
-    signal: AbortSignal.timeout(host.timeoutMs ?? 15000),
-  });
-  if (!res.ok) throw new Error(`${host.name}: HTTP ${res.status}`);
-  return (await res.json()).thread;
-};
-
-// `regenerateTitle` does NOT rename anything by itself. The server records an
-// intent marker (`titleRegeneration: {requestId, startedAt}`) and expects something
-// downstream to generate a title and write it back. Observed on a live server: the
-// marker is sometimes cleared a few seconds later with the title untouched, and no
-// error is reported anywhere — not in the event, the command receipt, or the server
-// trace. So we dispatch, then watch, and say what actually happened.
-const cmdThreadRetitle = async (thread, host, timeoutSeconds) => {
-  const before = thread.title;
-  const { sequence } = await dispatch(host, {
-    type: 'thread.meta.update', commandId: crypto.randomUUID(), threadId: thread.id,
-    regenerateTitle: true,
-  });
-  console.log(`asked the server to retitle ${bold(before || thread.id)}${dim(`  (seq ${sequence})`)}`);
-
-  const deadline = Date.now() + timeoutSeconds * 1000;
-  let sawMarker = false;
-  while (Date.now() < deadline) {
-    await new Promise((r) => setTimeout(r, 1500));
-    const current = await threadDetail(host, thread.id);
-    if (current.title && current.title !== before) {
-      console.log(`retitled -> ${bold(current.title)}`);
-      return;
-    }
-    if (current.titleRegeneration) { sawMarker = true; continue; }
-    if (sawMarker) break; // marker appeared and was cleared, title unchanged
-  }
-
-  console.error(
-    `\x1b[33mno title was generated\x1b[0m — the server ${sawMarker ? 'cleared the request without producing one' : `did not act on it within ${timeoutSeconds}s`}.\n` +
-    `  The title is still "${before}". Set one directly:\n` +
-    `    t3ctl thread rename ${thread.id} <title...>`,
-  );
-  process.exitCode = 1;
-};
-
-const cmdThread = async (args) => {
-  const [sub, ...rest] = args;
-  const { flags, pos } = parseArgs(rest);
-  // `send` is the accurate name: thread.turn.start posts a message to a thread and
-  // runs a turn, which is exactly what the UI does for every message, first or not.
-  // `start` stays as an alias because it shipped in 0.2.0.
-  const isSend = sub === 'send' || sub === 'start';
-
-  if (sub === 'rename' || sub === 'retitle') {
-    const [ref, ...titleParts] = pos;
-    if (!ref) return usage(`usage: t3ctl thread ${sub} <thread>` + (sub === 'rename' ? ' <new title...>' : ''));
-    const title = titleParts.join(' ');
-    if (sub === 'rename' && !title) return usage('usage: t3ctl thread rename <thread> <new title...>');
-    const host = pickHost(flags);
-    const target = resolveThread(await snapshot(host), ref);
-    return sub === 'retitle'
-      ? cmdThreadRetitle(target, host, Number(flags.timeout) > 0 ? Number(flags.timeout) : 30)
-      : cmdThreadRename(target, host, title);
-  }
-
-  if (isSend || sub === 'interrupt') {
-    // Validate arguments before touching the host registry, so `t3ctl thread
-    // send` with no args prints usage instead of "no hosts registered".
-    const [ref, ...rest2] = pos;
-    if (!ref) return usage(`usage: t3ctl thread ${sub} <thread>` + (isSend ? ' <message...>' : ''));
-    if (isSend && rest2.length === 0) return usage(`usage: t3ctl thread ${sub} <thread> <message...>`);
-    const host = pickHost(flags);
-    const thread = resolveThread(await snapshot(host), ref);
-    if (sub === 'interrupt') return cmdThreadInterrupt(thread, host);
-    return cmdThreadStart(thread, host, rest2.join(' '), flags);
-  }
-  if (SIMPLE_THREAD_COMMANDS.includes(sub)) {
-    if (!pos.length) return usage(`usage: t3ctl thread ${sub} <thread>`);
-    const host = pickHost(flags);
-    const thread = resolveThread(await snapshot(host), pos.join(' '));
-    const { sequence } = await dispatch(host, {
-      type: `thread.${sub}`, commandId: crypto.randomUUID(), threadId: thread.id,
-    });
-    console.log(`${sub}d ${bold(thread.title || thread.id)}\n  id  ${thread.id}\n  seq ${sequence}`);
-    return;
-  }
-  if (sub !== 'create') return usage('usage: t3ctl thread create <project> <title> [--model <instance>/<model>] [--branch <b>] [--host <name>]\n       t3ctl thread <settle|archive|unarchive|unpin|delete> <thread>');
-  const [projectRef, ...titleParts] = pos;
-  const title = titleParts.join(' ');
-  if (!projectRef || !title) return usage('usage: t3ctl thread create <project> <title> [--model <instance>/<model>] [--branch <b>] [--host <name>]');
-  const host = pickHost(flags);
-  const project = resolveProject(await snapshot(host), projectRef);
-  if (!project) throw new Error(`no project matching "${projectRef}" on ${host.name}`);
-
-  // instanceId is the segment before the first slash; model keeps the rest
-  // (opencode models look like "github-copilot/gpt-5.4").
-  const raw = flags.model ?? 'claudeAgent/claude-opus-5';
-  const slash = raw.indexOf('/');
-  if (slash < 1) throw new Error(`--model must be <instance>/<model>, got "${raw}"`);
-  const modelSelection = { instanceId: raw.slice(0, slash), model: raw.slice(slash + 1) };
-
-  const threadId = crypto.randomUUID();
-  const { sequence } = await dispatch(host, {
-    type: 'thread.create', commandId: crypto.randomUUID(),
-    threadId, projectId: project.id, title, modelSelection,
-    runtimeMode: flags['runtime-mode'] ?? 'full-access',
-    interactionMode: flags['interaction-mode'] ?? 'default',
-    branch: flags.branch ?? null,
-    worktreePath: flags.worktree ?? null,
-    createdAt: new Date().toISOString(),
-  });
-  console.log(`created thread ${bold(title)} in ${project.title} on ${host.name}\n  id    ${threadId}\n  model ${modelSelection.instanceId}/${modelSelection.model}\n  seq   ${sequence}`);
-};
-
-const [cmd, ...rest] = process.argv.slice(2);
-const commands = { ls: cmdLs, host: cmdHost, hosts: () => cmdHost([]), project: cmdProject, thread: cmdThread };
-if (!commands[cmd]) {
-  console.log(`t3ctl — control T3 Code hosts
-
-  t3ctl ls [-t|--threads] [-a|--all] [--json]   list projects and threads across hosts
-  t3ctl host add <origin> [token] [--name <n>]  register a host (probes it first)
-  t3ctl host rm <name>                          remove a host
-  t3ctl hosts                                   list hosts and probe each one
-
-  t3ctl project create <title> <root>           create a project for an existing dir
-  t3ctl thread create <project> <title>         start a thread (--model inst/model,
-                                                --branch, --host)
-  t3ctl thread send <thread> <message...>       send a message and run the agent
-                                                (alias: start)
-  t3ctl thread rename <thread> <title...>       rename a thread
-  t3ctl thread retitle <thread> [--timeout n]   ask the server to derive a title
-                                                (warns if it produces none)
-  t3ctl thread interrupt <thread>               stop the running turn
-  t3ctl thread settle <thread>                  settle a thread (also: archive,
-                                                unarchive, unpin, delete)`);
-  process.exit(cmd ? 1 : 0);
-}
-try {
-  await commands[cmd](rest);
-} catch (error) {
-  console.error(`\x1b[31merror\x1b[0m ${error instanceof Error ? error.message : String(error)}`);
-  process.exit(1);
-}