chord-cli 0.1.0 → 0.1.2

package/src/mcp.ts

@@ -1,54 +0,0 @@
-// Minimal MCP server over stdio: newline-delimited JSON-RPC 2.0, tools only.
-import { createInterface } from 'node:readline';
-
-export interface Tool {
-  name: string;
-  description: string;
-  inputSchema: Record<string, unknown>;
-  handler: (args: Record<string, unknown>) => unknown;
-}
-
-interface Request { jsonrpc: '2.0'; id?: number | string; method: string; params?: Record<string, unknown> }
-
-const PROTOCOL = '2025-06-18';
-
-/** Handle one JSON-RPC message. Returns the response, or undefined for notifications. */
-export function handle(tools: Tool[], req: Request): object | undefined {
-  const { id, method, params = {} } = req;
-  if (id === undefined) return undefined; // notification, e.g. notifications/initialized
-  const ok = (result: unknown) => ({ jsonrpc: '2.0', id, result });
-  const err = (code: number, message: string) => ({ jsonrpc: '2.0', id, error: { code, message } });
-
-  switch (method) {
-    case 'initialize':
-      return ok({ protocolVersion: PROTOCOL, capabilities: { tools: {} }, serverInfo: { name: 'chord', version: '0.0.0' } });
-    case 'ping':
-      return ok({});
-    case 'tools/list':
-      return ok({ tools: tools.map(({ name, description, inputSchema }) => ({ name, description, inputSchema })) });
-    case 'tools/call': {
-      const tool = tools.find(t => t.name === params.name);
-      if (!tool) return err(-32602, `unknown tool: ${String(params.name)}`);
-      try {
-        const out = tool.handler((params.arguments as Record<string, unknown>) ?? {});
-        const text = typeof out === 'string' ? out : JSON.stringify(out, null, 2);
-        return ok({ content: [{ type: 'text', text }] });
-      } catch (e) {
-        return ok({ content: [{ type: 'text', text: (e as Error).message }], isError: true });
-      }
-    }
-    default:
-      return err(-32601, `method not found: ${method}`);
-  }
-}
-
-export function serve(tools: Tool[]): void {
-  const rl = createInterface({ input: process.stdin });
-  rl.on('line', line => {
-    if (!line.trim()) return;
-    let req: Request;
-    try { req = JSON.parse(line); } catch { return; }
-    const res = handle(tools, req);
-    if (res) process.stdout.write(JSON.stringify(res) + '\n');
-  });
-}

package/src/patch.ts

@@ -1,9 +0,0 @@
-/** File paths touched by a Codex apply_patch payload, taken from its header lines. */
-export function patchFiles(patch: string): string[] {
-  const out = new Set<string>();
-  for (const line of patch.split('\n')) {
-    const m = /^\s*\*\*\* (?:Add File|Update File|Delete File|Move to): (.+?)\s*$/.exec(line); // a heredoc may indent the headers
-    if (m) out.add(m[1]);
-  }
-  return [...out];
-}

package/src/project.ts

@@ -1,152 +0,0 @@
-// A chord project is the folder `chord` is run in. It contains the git repository as a child
-// directory and a `chord/` directory for agent workspaces; chord's own state lives under ~/.chord.
-import { createHash } from 'node:crypto';
-import { execFileSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { gitEnv } from './db.ts';
-
-export interface Project {
-  dir: string;      // the project folder, absolute
-  repo: string;     // the repository's main checkout, a child of dir
-  repoName: string; // basename of repo
-  stateDir: string; // ~/.chord/projects/<encoded dir>
-}
-
-/** Thrown when the folder is a repository root: chord offers to move it into a child directory. */
-export class NeedsRestructure extends Error {
-  dir: string;
-  suggestedName: string;
-  constructor(dir: string, suggestedName: string) {
-    super(`${dir} is itself a git repository; chord needs the repository in a child directory of the project`);
-    this.dir = dir;
-    this.suggestedName = suggestedName;
-  }
-}
-
-const git = (cwd: string, ...args: string[]) => execFileSync('git', args, { cwd, encoding: 'utf8', env: gitEnv(), stdio: ['ignore', 'pipe', 'ignore'] }).trim();
-
-const same = (a: string, b: string) => (process.platform === 'win32' ? a.toLowerCase() === b.toLowerCase() : a === b);
-
-function repoRootOf(dir: string): string | null {
-  try { return fs.realpathSync.native(git(dir, 'rev-parse', '--show-toplevel')); } catch { return null; }
-}
-
-/** Only a .git *directory* marks a project repository; a .git file is a linked worktree or a submodule. */
-const isRepoDir = (dir: string) => { try { return fs.statSync(path.join(dir, '.git')).isDirectory(); } catch { return false; } };
-
-/** Readable like Claude Code's projects directory (separators and colons become dashes), plus a short hash so
- *  that D:\a-b and D:\a\b do not share one state directory. */
-export function encodeProjectPath(dir: string): string {
-  const key = process.platform === 'win32' ? dir.toLowerCase() : dir;
-  return `${dir.replace(/[\\/:]/g, '-')}-${createHash('sha1').update(key).digest('hex').slice(0, 6)}`;
-}
-
-export const stateDirFor = (dir: string) => path.join(process.env.CHORD_HOME ?? path.join(os.homedir(), '.chord'), 'projects', encodeProjectPath(dir));
-
-/** A repository directory name chord can work with: a single path segment that is not chord's own directory. */
-export function validateRepoName(name: string): string | null {
-  if (!name.trim()) return 'the name is empty';
-  if (/[\\/]/.test(name) || name === '.' || name === '..') return 'the name must be a single directory name';
-  if (name.toLowerCase() === 'chord') return '"chord" is reserved for chord\'s own directory';
-  return null;
-}
-
-/** Default name for the repository directory: the origin remote's name, else the folder's own name. */
-export function suggestedRepoName(repo: string): string {
-  try {
-    const url = git(repo, 'remote', 'get-url', 'origin');
-    const last = url.split(/[\\/:]/).filter(Boolean).pop() ?? '';
-    const name = last.replace(/\.git$/i, '');
-    if (name && !validateRepoName(name)) return name;
-  } catch { /* no origin */ }
-  const own = path.basename(repo);
-  return validateRepoName(own) ? 'repo' : own;
-}
-
-/** The nearest ancestor that already is a chord project, if any. */
-/** Child directories of `dir` that are repository roots. Looked up with stat, so a junction or symlink to a repository
- *  counts (a Dirent reports those as links, not directories). */
-const repoChildren = (dir: string) => fs.readdirSync(dir).filter(n => { const p = path.join(dir, n); try { return fs.statSync(p).isDirectory() && isRepoDir(p); } catch { return false; } });
-
-/** The project `dir` belongs to, when it lies inside one: under the project's chord/ directory (a workspace or a
- *  worktree) or inside its repository. A folder merely beside those, such as a new project created next to an old
- *  one, is not claimed by the ancestor. */
-function enclosingProject(dir: string): string | null {
-  for (let a = path.dirname(dir); a !== path.dirname(a); a = path.dirname(a)) {
-    if (!fs.existsSync(stateDirFor(a)) && !fs.existsSync(path.join(a, 'chord', 'agents'))) continue;
-    const inside = (sub: string) => { const rel = path.relative(path.join(a, sub), dir); return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel)); };
-    if (inside('chord') || repoChildren(a).some(inside)) return a;
-  }
-  return null;
-}
-
-export function resolveProject(cwd: string): Project {
-  const dir = fs.realpathSync.native(cwd);
-  // inside an existing project (its main checkout, a workspace or a worktree): that project is meant
-  const parent = enclosingProject(dir);
-  if (parent) return resolveProject(parent);
-  const enclosing = repoRootOf(dir);
-  if (enclosing) {
-    if (same(enclosing, dir)) throw new NeedsRestructure(dir, suggestedRepoName(dir));
-    throw new Error(`${dir} is inside the repository ${enclosing}; a chord project is the folder that contains the repository, not a folder inside it`);
-  }
-  const children = repoChildren(dir);
-  if (children.some(c => c.toLowerCase() === 'chord')) throw new Error(`${dir}/chord is a git repository, but chord/ is reserved for chord's own directory; rename it`);
-  if (children.length === 0) throw new Error(`${dir} contains no git repository; a chord project is a folder with the repository in a child directory`);
-  if (children.length > 1) throw new Error(`${dir} contains several repositories (${children.join(', ')}); chord supports one per project for now`);
-  const repo = path.join(dir, children[0]);
-  return { dir, repo, repoName: children[0], stateDir: stateDirFor(dir) };
-}
-
-/** Why `dir` (a repository root) must not be moved into a child directory, or null when it is safe. */
-export function restructureBlocker(dir: string): string | null {
-  if (same(fs.realpathSync.native(dir), fs.realpathSync.native(os.homedir()))) return 'refusing to move your home directory';
-  let worktrees = 1;
-  try { worktrees = git(dir, 'worktree', 'list', '--porcelain').split('\n').filter(l => l.startsWith('worktree ')).length; } catch { /* not a repo */ }
-  if (worktrees > 1) return `${dir} has linked worktrees (git worktree list); remove them first, moving the repository would break them`;
-  try { if (git(dir, 'ls-files', '--', 'chord')) return 'the repository tracks a top-level chord/ directory, which chord needs for itself; rename it first'; } catch { /* ignore */ }
-  return null;
-}
-
-/** Move everything in `dir` (except chord/) into `dir/name`, so the repository becomes a child. Rolls back on failure. */
-export function restructure(dir: string, name: string, rename: (from: string, to: string) => void = fs.renameSync): string {
-  const invalid = validateRepoName(name);
-  if (invalid) throw new Error(invalid);
-  const blocker = restructureBlocker(dir);
-  if (blocker) throw new Error(blocker);
-  const target = path.join(dir, name);
-  if (fs.existsSync(target)) throw new Error(`${target} already exists`);
-  const entries = fs.readdirSync(dir).filter(e => e !== 'chord');
-  fs.mkdirSync(target);
-  const moved: string[] = [];
-  try {
-    for (const e of entries) { rename(path.join(dir, e), path.join(target, e)); moved.push(e); }
-  } catch (e) {
-    const stuck: string[] = [];
-    for (const m of moved) { try { rename(path.join(target, m), path.join(dir, m)); } catch { stuck.push(m); } }
-    if (!stuck.length) { try { fs.rmdirSync(target); } catch { /* leave it */ } }
-    const note = stuck.length ? ` Rolling back failed too: ${stuck.join(', ')} are still under ${target}.` : ' Everything was moved back.';
-    throw new Error(`could not move ${dir} into ${target}: ${(e as Error).message}.${note} Close programs that have files open there and try again.`);
-  }
-  return target;
-}
-
-/** Every project that has state under ~/.chord/projects, for `chord ls --all`. */
-export function knownProjects(): { stateDir: string; dbFile: string; dir: string | null }[] {
-  const root = path.dirname(stateDirFor('x'));
-  if (!fs.existsSync(root)) return [];
-  return fs.readdirSync(root).map(name => {
-    const stateDir = path.join(root, name);
-    let dir: string | null = null;
-    try { dir = fs.readFileSync(path.join(stateDir, 'path'), 'utf8').trim(); } catch { /* unknown */ }
-    return { stateDir, dbFile: path.join(stateDir, 'chord.db'), dir };
-  }).filter(p => fs.existsSync(p.dbFile));
-}
-
-/** Create the state directory and remember the project's real path (the encoding is not reversible). */
-export function ensureStateDir(p: Project): void {
-  fs.mkdirSync(p.stateDir, { recursive: true });
-  fs.writeFileSync(path.join(p.stateDir, 'path'), p.dir);
-}

package/src/pty.ts

@@ -1,251 +0,0 @@
-// Run the agent under a pseudo-terminal: pass the user's keyboard through, and when the
-// agent is idle with unread messages, type a nudge in as if the user had.
-import fs from 'node:fs';
-import path from 'node:path';
-import { StringDecoder } from 'node:string_decoder';
-import pty from 'node-pty';
-import * as db from './db.ts';
-import type { Tool } from './hooks.ts';
-import { withNodeOnPath, type Launch } from './launch.ts';
-
-/** First PATH entry holding `<tool>.exe` or `<tool>.cmd`. Pure Node: `where.exe` output is in the OEM code page. */
-export function whereIs(tool: string, pathVar = process.env.PATH ?? '', exists: (p: string) => boolean = p => fs.existsSync(p)): string | undefined {
-  for (const dir of pathVar.split(path.delimiter).filter(Boolean)) {
-    for (const ext of ['.exe', '.cmd']) { const p = path.join(dir, tool + ext); if (exists(p)) return p; }
-  }
-  return undefined;
-}
-
-/** Executable and leading args for a tool. On Windows an npm .cmd shim is unwrapped to
- *  `node <script>` so JSON arguments reach the process intact instead of going through cmd.exe. */
-export function resolveCommand(tool: string, readFile = (f: string) => fs.readFileSync(f, 'utf8'), lookup = whereIs): { file: string; args: string[] } {
-  if (process.platform !== 'win32') return { file: tool, args: [] };
-  const hit = lookup(tool);
-  if (!hit) throw new Error(`${tool} not found on PATH`);
-  if (!/\.cmd$/i.test(hit)) return { file: hit, args: [] };
-  const m = /"%~?dp0%?\\([^"]+\.(?:js|mjs|cjs))"/.exec(readFile(hit)); // npm writes %dp0%\, pnpm and yarn %~dp0\
-  if (!m) throw new Error(`cannot read the script path from ${hit}`);
-  return { file: process.execPath, args: [path.join(path.dirname(hit), m[1])] };
-}
-
-const ESC_KEY = '';   // a decoded Esc key, kept apart from escape sequences while they are stripped
-const SOFT_NL = '';   // Shift+Enter: a newline inside the draft, not a submit
-
-/**
- * Characters the user typed, out of a raw stdin chunk. Under ConPTY keys arrive in win32-input-mode,
- * `ESC [ Vk ; Sc ; Uc ; KeyDown ; Ctrl ; Repeat _`, one event per key press and release, and a chunk may
- * end mid-sequence; `hold` receives such a tail to prepend to the next chunk. Other escape sequences
- * (arrows, mouse reports, terminal replies to queries) are dropped: they are not a draft.
- */
-export function decodeKeys(data: string, hold: (rest: string) => void): string {
-  if (data === '\x1b') { hold(''); return '\x1b'; } // a bare Esc key outside win32-input-mode
-  const lastEsc = data.lastIndexOf('\x1b');
-  if (lastEsc >= 0) {
-    const tail = data.slice(lastEsc);
-    const complete = /^\x1b(\[[0-9;?<>=]*[ -/]*[@-~]|\][^\x07\x1b]*(\x07|\x1b\\)|P[^\x1b]*\x1b\\|O.|[^[\]PO\x1b])/.test(tail) || tail === '\x1b\x1b';
-    if (!complete) { hold(tail); data = data.slice(0, lastEsc); } else hold('');
-  } else hold('');
-  return data
-    .replace(/\x1b\[(\d+);(\d+);(\d+);(\d+);(\d+);(\d+)_/g, (_, _vk, _sc, uc, down, ctrl) => {
-      if (down !== '1' || Number(uc) === 0) return '';
-      const code = Number(uc);
-      if (code === 27) return ESC_KEY;
-      if (code === 13 && (Number(ctrl) & 0x10)) return SOFT_NL; // SHIFT_PRESSED
-      return String.fromCharCode(code);
-    })
-    .replace(/\x1b\][^\x07\x1b]*(\x07|\x1b\\)/g, '')  // OSC (terminal replies, titles)
-    .replace(/\x1bP[^\x1b]*\x1b\\/g, '')               // DCS (e.g. XTVERSION replies)
-    .replace(/\x1b\[[0-9;?<>=]*[ -/]*[@-~]/g, '')      // CSI (arrows, mouse, replies)
-    .replace(/\x1bO./g, '')                            // SS3 (application-mode arrows)
-    .replace(/\x1b\x1b/g, ESC_KEY)                     // Esc pressed twice outside win32 mode
-    .replace(/\x1b[^\x1b]/g, '')                       // Alt+key and other two-byte sequences
-    .replaceAll(ESC_KEY, '\x1b');
-}
-
-/** Decide whether chord may type into the terminal right now, by tracking what the user has typed but not sent.
- *  The user's interaction always wins: while anything they typed is still in the input box, chord stays out,
- *  however long they take. Messages wait in the inbox until they submit or clear it. */
-export class InputGate {
-  private draftLen = 0;
-  private pending = '';
-  private inPaste = false;
-  private lastKeyAt = -Infinity; // never
-  private lastEscAt = -Infinity;
-  onUserInput(data: string, now = Date.now()): void {
-    // bracketed paste: its newlines are content, not submits, and a long paste arrives in several chunks
-    const pasted = this.inPaste || data.includes('\x1b[200~');
-    const open = data.lastIndexOf('\x1b[200~'), close = data.lastIndexOf('\x1b[201~');
-    if (open >= 0 || close >= 0) this.inPaste = open > close;
-    const text = decodeKeys(this.pending + data, rest => { this.pending = rest; });
-    if (!text) return;
-    this.lastKeyAt = now;
-    if (text.includes('\x1b')) this.lastEscAt = now;
-    for (const ch of text) {
-      if (ch === '\x15' || ch === '\x03') this.draftLen = 0;                              // Ctrl+U, Ctrl+C clear the line
-      else if (ch === '\x7f' || ch === '\x08') this.draftLen = Math.max(0, this.draftLen - 1); // Backspace
-      else if ((ch === '\r' || ch === '\n') && !pasted) this.draftLen = 0;                // submitted
-      else if (ch !== '\x1b') this.draftLen++;
-      // Esc is neither: in Claude Code one press closes a menu or interrupts, in Codex it never empties the box, so the
-      // draft is assumed to be still there (erring towards leaving the user alone)
-    }
-  }
-  /** True when the input box is believed empty. */
-  clear(): boolean {
-    // ponytail: cannot see the real input box; count keystrokes since the last submit as the draft
-    return this.draftLen === 0;
-  }
-  /** True when the user has not touched the keyboard for a while: three seconds after any key, ten after Esc. A
-   *  submit takes the hook up to a second to show as busy, and after an interrupt the user is about to type a
-   *  correction; chord must not slip its text in between. */
-  settled(now = Date.now()): boolean {
-    return now - this.lastKeyAt >= 3000 && now - this.lastEscAt >= 10_000;
-  }
-}
-
-export const NUDGE = '[chord] You have new messages from other agents; they are attached to this prompt. Handle them, replying with the chord send tool where needed.';
-
-/** Terminal output with escape sequences removed (OSC, CSI, DCS, charset selection, other two-byte sequences). */
-export function stripAnsi(s: string): string {
-  return s
-    .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '')
-    .replace(/\x1bP[^\x1b]*\x1b\\/g, '')
-    .replace(/\x1b\[[0-9;?<>=]*[ -\/]*[@-~]/g, '')
-    .replace(/\x1b[()][0-9A-Za-z]/g, '')
-    .replace(/\x1b./g, '');
-}
-
-/** What `chord stop` types to quit the tool, once the agent is idle and the input box is empty. */
-export const EXIT_COMMAND: Record<Tool, string> = { claude: '/exit', codex: '/quit' };
-
-/** Did the TUI echo the typed text into its input box? A dialog, picker or any other mode that swallows keystrokes
- *  does not echo them, so this is the test before Enter is pressed: Enter in a dialog picks the default answer. Only
- *  the opening characters are checked, with whitespace ignored, so wrapping and re-rendering do not matter. */
-export function typedEchoed(output: string, text: string): boolean {
-  const squash = (s: string) => stripAnsi(s).replace(/\s+/g, '');
-  return squash(output).includes(squash(text).slice(0, 25));
-}
-
-/** The terminal title is chord's: "chord <agent> · <task>", so a window or tab can be matched to a `chord ls` row.
- *  The tools set their own titles (Claude Code its session summary, Codex the folder name), so their title
- *  sequences (OSC 0, 1, 2) are removed from the forwarded output; everything else, including Codex's OSC 7501
- *  state reports, passes through. A sequence split across two chunks is held until it completes. */
-export class TitleFilter {
-  private pending = '';
-  push(chunk: string): string {
-    let s = this.pending + chunk;
-    this.pending = '';
-    s = s.replace(/\x1b\][012];[^\x07\x1b]*(?:\x07|\x1b\\)/g, '');
-    const i = s.lastIndexOf('\x1b]');
-    if (i !== -1 && /^\x1b\](?:[012](?:;[^\x07\x1b]*\x1b?)?)?$/.test(s.slice(i))) { this.pending = s.slice(i); s = s.slice(0, i); }
-    return s;
-  }
-}
-
-export function titleFor(name: string, task: string | null | undefined): string {
-  const t = (task ?? '').replace(/\s+/g, ' ').trim();
-  return `chord ${name}${t ? ` · ${t.length > 80 ? `${t.slice(0, 79)}…` : t}` : ''}`;
-}
-export const titleSequence = (title: string) => `\x1b]0;${title.replace(/[\x00-\x1f\x7f]/g, ' ')}\x07`;
-
-export type Typed = 'nudge' | 'stop';
-export type Action = Typed | 'enter' | null;
-
-/** What the idle-wake loop should do this tick: type the nudge (unread messages), type the exit command (`chord
- *  stop`), press Enter once more, or nothing. Messages stay in the inbox until a hook takes them, so a lost
- *  keystroke is retried, never dropped. `typed`/`typedAt` say what was last typed and when; `echoed` whether the TUI
- *  showed it; `enters` how many times Enter was pressed for it and `enteredAt` when last. Enter is pressed at most
- *  twice per typed text, never when the text was not echoed, and nothing new is typed while the last text is fresh. */
-export function nextAction(s: { status: string | undefined; unread: boolean; stop: boolean; gateClear: boolean; typed: Typed | null; typedAt: number; echoed: boolean; enters: number; enteredAt: number }, now: number): Action {
-  if (s.status !== 'idle' || !s.gateClear) return null;
-  const want: Typed | null = s.stop ? 'stop' : s.unread ? 'nudge' : null;
-  if (!want) return null;
-  if (!s.typedAt || now - s.typedAt > 30_000) return want; // first try, or the typed text was lost or swallowed
-  if (s.typed !== want) return null; // something else is still in the input box; wait for it to go through or expire
-  if (!s.echoed || s.enters !== 1) return null; // swallowed: hands off; never pressed: the user got there first; pressed twice: enough
-  if (now - s.enteredAt > 5_000) return 'enter'; // typed and echoed but not submitted: press Enter once more
-  return null;
-}
-
-/** Codex reports its state to the terminal as OSC 7501 ("state=idle" / "state=working"); Claude Code does not. */
-export function oscState(chunk: string): 'idle' | 'busy' | null {
-  const m = /\x1b\]7501;state=(\w+)/g;
-  let last: 'idle' | 'busy' | null = null;
-  for (const x of chunk.matchAll(m)) last = x[1] === 'idle' ? 'idle' : 'busy';
-  return last;
-}
-
-export function run(tool: Tool, launch: Launch, extraArgs: string[]): Promise<number> {
-  const { file, args } = resolveCommand(tool);
-  const env: Record<string, string> = withNodeOnPath({ ...process.env as Record<string, string>, ...launch.env });
-  for (const k of Object.keys(env)) if (/^CLAUDECODE/.test(k)) delete env[k]; // allow launching from inside a Claude session
-  const term = pty.spawn(file, [...args, ...launch.args, ...extraArgs], {
-    name: 'xterm-256color', cols: process.stdout.columns || 120, rows: process.stdout.rows || 40, cwd: launch.cwd, env,
-  });
-  const d = db.openDb(launch.dbFile);
-  db.addAgent(d, { name: launch.name, tool, pid: term.pid, cwd: launch.cwd, worktree: launch.worktree, heartbeat: true });
-
-  let outTail = '', echoBuf = '', awaitingEcho = false;
-  const titles = new TitleFilter();
-  let title = titleFor(launch.name, null);
-  process.stdout.write(titleSequence(title));
-  term.onData(x => {
-    process.stdout.write(titles.push(x));
-    if (awaitingEcho) echoBuf = (echoBuf + x).slice(-16000);
-    if (tool === 'codex') { // the hooks set status too; the terminal report catches turns the hooks miss (Esc, untrusted hooks)
-      const state = oscState(outTail + x);
-      if (state) db.setStatus(d, launch.name, state);
-      outTail = x.slice(-64);
-    }
-  });
-  const gate = new InputGate();
-  const decoder = new StringDecoder('utf8'); // a multi-byte character may straddle two stdin chunks
-  const onKey = (x: Buffer) => { const s = decoder.write(x); if (!s) return; if (process.env.CHORD_DEBUG_STDIN) db.log(`stdin ${JSON.stringify(s)}`); gate.onUserInput(s); term.write(s); };
-  if (process.stdin.isTTY) process.stdin.setRawMode(true);
-  process.stdin.resume();
-  process.stdin.on('data', onKey);
-  const onResize = () => term.resize(process.stdout.columns || 120, process.stdout.rows || 40);
-  process.stdout.on('resize', onResize);
-
-  Object.assign(process.env, launch.env); // so the wrapper writes to the same chord.db.log as the hooks
-  let typed: Typed | null = null, typedAt = 0, enteredAt = 0, enters = 0, echoed = false, lastState = '';
-  const timer = setInterval(() => {
-    db.heartbeat(d, launch.name);
-    const me = db.getAgent(d, launch.name);
-    const wanted = titleFor(launch.name, me?.task);
-    if (wanted !== title) { title = wanted; process.stdout.write(titleSequence(title)); }
-    const status = me?.status;
-    if (status !== 'idle') { typed = null; typedAt = enteredAt = enters = 0; echoed = false; }
-    const s = { status, unread: db.hasUnread(d, launch.name), stop: !!me?.stop_requested_at, gateClear: gate.clear() && gate.settled(), typed, typedAt, echoed, enters, enteredAt };
-    const action = nextAction(s, Date.now());
-    const state = `${status}/${s.unread}/${s.stop}/${s.gateClear}/${action}`;
-    if (state !== lastState) { db.log(`wake loop: status=${status} unread=${s.unread} stop=${s.stop} gateClear=${s.gateClear} action=${action}`); lastState = state; }
-    if (!action) return;
-    if (action === 'enter') { enteredAt = Date.now(); enters++; term.write('\r'); return; }
-    const text = action === 'stop' ? EXIT_COMMAND[tool] : NUDGE;
-    typed = action; typedAt = Date.now(); enteredAt = enters = 0; echoed = false;
-    echoBuf = ''; awaitingEcho = true;
-    term.write(text);
-    // Enter must arrive separately or the TUI treats it as pasted text. It is only pressed once the TUI has echoed
-    // the text (so a dialog or picker, which swallows keystrokes, never gets an Enter) and the user has not typed.
-    setTimeout(() => {
-      awaitingEcho = false;
-      echoed = typedEchoed(echoBuf, text);
-      if (!echoed) { db.log(`wake loop: ${action} text was not echoed, something other than the prompt has the keyboard; not pressing Enter`); return; }
-      if (!gate.clear() || !gate.settled()) { db.log('wake loop: the user typed meanwhile; not pressing Enter'); return; }
-      term.write('\r'); enteredAt = Date.now(); enters = 1;
-    }, 1500);
-  }, 1000);
-
-  return new Promise(resolve => {
-    term.onExit(({ exitCode }) => {
-      clearInterval(timer);
-      process.stdin.off('data', onKey);
-      process.stdout.off('resize', onResize);
-      if (process.stdin.isTTY) process.stdin.setRawMode(false);
-      process.stdin.pause();
-      db.setStatus(d, launch.name, 'offline');
-      db.releaseAll(d, launch.name, 'exit');
-      resolve(exitCode);
-    });
-  });
-}