cli-setu 0.1.0

package/README.md

@@ -0,0 +1,40 @@
+# cli-setu
+
+Bridge your terminal to your phone. Run Claude Code, Codex, or any plain shell on your laptop, and approve prompts, type, and watch the live output from the [CLIसेतु](https://clisetu.com) app on your phone.
+
+## Install
+
+```bash
+npm install -g cli-setu
+```
+
+## Usage
+
+```bash
+setu              # bridges the current folder as a plain shell session
+setu --cli claude # same, but runs Claude Code inside the bridged session
+setu --cli codex  # or Codex
+```
+
+The first time you run it, `setu` prints a QR code (and an 8-digit fallback code) - scan it with the CLIसेतु app to pair this computer and start watching the session live.
+
+Once paired, running `setu` in any folder just works - no QR code needed again, unless this is a device you haven't paired before.
+
+## Other commands
+
+```bash
+setu pair      # pair this computer, without starting a session
+setu status    # show pairing status and any sessions currently running
+setu stop      # stop a running session
+setu --update  # check for and install the latest version
+setu --version # print the installed version
+setu --help    # show all commands
+```
+
+## How it works
+
+`setu` spawns your real terminal (or Claude Code/Codex) inside a PTY, same as any terminal emulator. Every byte it produces streams live to the CLIसेतु app over a secure relay; anything you type on the phone writes back into that same PTY, exactly like a local keystroke. Permission prompts (file edits, shell commands, etc.) are detected and relayed as structured approve/reject cards instead of raw text, when the adapter for your CLI supports it.
+
+## License
+
+MIT

package/bin/setu.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+// Command dispatcher for the `setu` CLI. Kept deliberately thin - each
+// real subcommand's logic lives in src/, this file only parses argv and
+// calls the right one.
+const AUTH_SERVER = process.env.CLI_SETU_SERVER || 'https://api.clisetu.com';
+const AUTH_SERVER_PUBLIC = process.env.CLI_SETU_SERVER_PUBLIC || AUTH_SERVER;
+
+// Real bug found by testing: this used to switch on process.argv[2]
+// directly against the subcommand list (pair/status/stop), with any
+// other value (including a real --flag, e.g. `setu --cli claude`)
+// falling through to "Unknown command" and exiting immediately - the
+// whole multi-CLI feature (claude/codex/shell adapters) was unreachable
+// through the real `setu` command this entire time, only ever testable
+// by calling node src/supervisor.js --cli claude directly. Flags
+// (anything starting with "-") are no longer mistaken for subcommand
+// names - they're checked first, and anything left over (bare `setu`, or
+// `setu --cli claude`/other flags meant for the bridged session itself)
+// falls through to the same "watch this session" path as before, which
+// still parses --cli on its own further down the line (supervisor.js) -
+// this dispatcher doesn't need to understand every flag supervisor.js
+// accepts, only recognize that a leading "-" means "not a subcommand."
+const args = process.argv.slice(2);
+const firstArg = args[0];
+const isSubcommand = firstArg && !firstArg.startsWith('-');
+
+async function main() {
+  if (args.includes('--version') || args.includes('-v')) {
+    console.log(require('../package.json').version);
+    return;
+  }
+
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp();
+    return;
+  }
+
+  if (args.includes('--update')) {
+    const { update } = require('../src/update');
+    await update();
+    return;
+  }
+
+  if (isSubcommand) {
+    switch (firstArg) {
+      case 'pair': {
+        const { pair } = require('../src/pair');
+        await pair(AUTH_SERVER, AUTH_SERVER_PUBLIC);
+        return;
+      }
+      case 'status': {
+        const { status } = require('../src/status');
+        await status(AUTH_SERVER);
+        return;
+      }
+      case 'stop': {
+        const { stop } = require('../src/stop');
+        await stop();
+        return;
+      }
+      default:
+        console.error(`[setu] Unknown command: ${firstArg}`);
+        printHelp();
+        process.exit(1);
+    }
+  }
+
+  // Bare `setu` (or `setu --cli <name>`, `setu --cli <name> <workingDir>`,
+  // etc. - real flags meant for the bridged session itself, parsed by
+  // supervisor.js) - watch the current directory as a session. Real
+  // product requirement: a brand-new user should be able to run just
+  // `setu` (no separate `setu pair` step to discover first) and see the
+  // QR/8-digit code immediately, the same "first run pairs AND starts
+  // watching this session in one step" behavior the original
+  // proof-of-concept had. Only pairs if not already paired - an
+  // already-paired computer skips straight to watching, unchanged.
+  const { readConfig } = require('../src/config');
+  const config = readConfig();
+  if (!config || !config.deviceToken) {
+    const { pair } = require('../src/pair');
+    await pair(AUTH_SERVER, AUTH_SERVER_PUBLIC);
+  }
+  require('../src/supervisor');
+}
+
+function printHelp() {
+  console.log(`[setu] Bridge your terminal to your phone.
+
+Usage:
+  setu                   Watch this folder as a session (pairs first if needed)
+  setu --cli <name>       Same, but run a specific CLI inside the bridged
+                          session instead of the default plain shell
+                          (e.g. --cli claude, --cli codex)
+  setu pair               Pair this computer with your phone, nothing else
+  setu status             Show pairing status and any sessions running now
+  setu stop               Stop a running session
+  setu --version, -v      Print the installed version
+  setu --update           Check for and install the latest version
+  setu --help, -h         Show this help`);
+}
+
+main().catch((err) => {
+  console.error('[setu] Error:', err.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "cli-setu",
+  "version": "0.1.0",
+  "description": "Bridge your terminal to your phone — run and approve Claude Code, Codex CLI and other AI coding agents from anywhere.",
+  "type": "commonjs",
+  "bin": {
+    "setu": "bin/setu.js"
+  },
+  "main": "src/config.js",
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "keywords": [
+    "cli",
+    "claude-code",
+    "claude",
+    "codex",
+    "terminal",
+    "remote",
+    "mobile",
+    "pty",
+    "ssh"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Evyasys-Software-Solutions/clisetuapp.git",
+    "directory": "cli"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "dependencies": {
+    "@xterm/headless": "^6.0.0",
+    "node-pty": "^1.1.0",
+    "qrcode-terminal": "^0.12.0",
+    "ws": "^8.21.3"
+  }
+}

package/src/cli-adapters/README.md

@@ -0,0 +1,74 @@
+# CLI adapters
+
+Every CLI this app can supervise (Claude Code, Codex, or one nobody's
+written an adapter for yet) implements this same shape. supervisor-qr.js
+never has CLI-specific logic in it directly - it only ever calls through
+whichever adapter `--cli <name>` selected (see cli-adapters/index.js).
+
+The only thing every adapter MUST provide is enough to spawn the CLI in a
+PTY and mirror its raw output to a phone - that's what makes an unknown,
+never-integrated CLI still usable (via `generic.js`) instead of refusing
+to run at all. Everything past that (structured approval prompts, real
+token/cost numbers) is optional per adapter, because different CLIs
+genuinely expose different amounts of machine-readable surface:
+
+  - Claude Code: no live token API for an interactive session, but DOES
+    have a hook system (PermissionRequest) that reports an approval
+    BEFORE it's shown, and a `/cost` slash command whose rendered text
+    can be scraped for a cost/token estimate.
+  - Codex: no hook system for an interactive PTY session, but `codex exec
+    --json` emits clean structured JSONL (including a real `usage` object
+    per turn) - a completely different mechanism, not scraped text.
+  - Some future CLI: maybe neither - `generic.js` is what such a CLI gets,
+    and that's a deliberate, permanent, first-class outcome, not a
+    placeholder waiting to be filled in.
+
+## Shape
+
+```js
+{
+  id: 'claude',                 // matches devices.cli_type in Postgres
+  displayName: 'Claude Code',
+
+  // Required - how supervisor-qr.js spawns this CLI in a PTY.
+  spawn: { command, args: (workingDir) => [...] },
+
+  // Optional - null means "this CLI has no known way to report an
+  // approval prompt before it happens; the human sees it live in the
+  // mirrored terminal instead, with no structured Confirmations card."
+  //
+  // cwd -> the queue-file/event-source location this adapter should
+  // watch (adapter-specific meaning - Claude Code's is a hook queue
+  // file keyed by cwd; another adapter might not need cwd at all).
+  approvals: null | {
+    // Called on supervisor-qr.js's existing poll loop. Returns an array
+    // of NEW raw events since last call (adapter decides what "raw"
+    // means - Claude Code's is one parsed hook-queue JSON line).
+    pollNewEvents(cwd) -> event[],
+    // Turns one raw event into what the phone actually shows.
+    describePrompt(event) -> string,
+    getDialogOptions(event) -> [{ label, keystroke, style }],
+  },
+
+  // Optional - null means "no usage/cost reporting available for a live
+  // interactive session with this CLI."
+  usage: null | {
+    // How to ask the running session for a fresh usage report (e.g.
+    // injecting '/cost\r' into the PTY) - supervisor-qr.js calls this on
+    // a timer, then feeds subsequent PTY output through parseFromOutput.
+    triggerKeystrokes: string | null,
+    // Given a chunk of raw PTY output (after triggerKeystrokes was sent),
+    // try to pull a usage snapshot out of it. Returns null if this chunk
+    // doesn't contain one (adapter's own regex decides).
+    parseFromOutput(chunk) -> { totalTokens, contextUsedPct, raw } | null,
+  },
+}
+```
+
+Codex's real usage numbers don't come from PTY scraping at all (see
+codex.js) - its adapter's `usage.parseFromOutput` is unused, and instead
+supervisor-qr.js special-cases adapters that set `usage.mode: 'exec-json'`
+to run `codex exec resume` as a side process instead of scraping the PTY.
+This is the one place the interface leaks a CLI-specific detail, because
+Codex's actual model (spawn-per-turn, not a persistent PTY at all) has no
+honest way to look identical to Claude Code's from the outside.

package/src/cli-adapters/claude.js

@@ -0,0 +1,304 @@
+// Claude Code adapter. Ported straight out of supervisor-qr.js's old
+// hardcoded describePrompt/getDialogOptions - behavior unchanged, just
+// moved behind the adapter interface so supervisor-qr.js can treat this
+// as one of N CLIs instead of the only one it knows about.
+//
+// Approval detection: Claude Code's PermissionRequest hook
+// (onPermissionRequest.js, wired via .claude/settings.json) writes one
+// JSON line per prompt to a queue file THIS adapter knows how to read -
+// not a generic mechanism, a Claude-Code-specific one. No other CLI here
+// is expected to share this exact file-based queue approach; it's an
+// implementation detail of the hook wiring already built for Claude Code,
+// preserved as-is rather than generalized prematurely.
+//
+// Usage: Claude Code has no live token API for an interactive session
+// (see cli-adapters/README.md) - the closest available signal is its own
+// `/cost` slash command's rendered TUI output, which this adapter parses
+// on a best-effort basis. This is fragile by nature (breaks if a future
+// Claude Code version changes that output's wording) - see parseFromOutput's
+// regex for exactly what shape it expects today.
+const fs = require('fs');
+const path = require('path');
+
+function queueFileFor(baseDir, cwd) {
+  const safeName = cwd.replace(/[\\/:]/g, '_');
+  return path.join(baseDir, `pending-requests.${safeName}.json`);
+}
+
+// Real bug found by testing: this only ever described Write/Edit/Bash -
+// AskUserQuestion (Claude's own "let me ask you something" tool, a REAL,
+// commonly-used tool_name, not an edge case) fell through to the generic
+// `${tool_name}: ${JSON.stringify(tool_input)}` branch, showing raw JSON
+// instead of the actual question text Claude Code itself renders.
+// PowerShell is Windows Claude Code's own tool_name for shell commands
+// (distinct from Bash, which is what WSL/macOS/Linux sessions use for the
+// exact same kind of prompt) - previously undetected here entirely, so it
+// fell through to the same raw-JSON fallback Bash used to.
+function describePrompt(event) {
+  const { tool_name, tool_input } = event;
+  if (tool_name === 'Write' && tool_input?.file_path) return `Create ${tool_input.file_path.split(/[\\/]/).pop()}?`;
+  if (tool_name === 'Edit' && tool_input?.file_path) return `Edit ${tool_input.file_path.split(/[\\/]/).pop()}?`;
+  if ((tool_name === 'Bash' || tool_name === 'PowerShell') && tool_input?.command) {
+    return tool_input.description ? `${tool_input.description}?\n${tool_input.command}` : `Run: ${tool_input.command}`;
+  }
+  if (tool_name === 'AskUserQuestion' && tool_input?.questions?.[0]) {
+    return tool_input.questions[0].question || tool_input.questions[0].header || 'Claude has a question';
+  }
+  return `${tool_name}: ${JSON.stringify(tool_input)}`;
+}
+
+// Real bug found by testing: every option set here was a HARDCODED guess
+// keyed off tool_name, never the real options Claude Code actually
+// offered - correct by coincidence for Write/Edit/Bash's own fixed
+// 3-choice menu (verified against real captured PermissionRequest
+// payloads), but silently WRONG for AskUserQuestion, whose real options
+// (with real, meaningful labels like "Just delete existing file" or
+// "Overwrite then delete") are sitting right there in
+// tool_input.questions[0].options and were never read at all - the app
+// showed a generic "Approve/Reject" for a prompt that actually offered 4
+// distinct real choices. keystroke is the exact digit Claude Code's own
+// numbered menu expects (1-indexed, matching the real on-screen "1.", "2."
+// list) - this MUST match what's actually rendered, since supervisor.js
+// injects this keystroke directly with no translation.
+function getDialogOptions(event) {
+  if (event.tool_name === 'AskUserQuestion' && event.tool_input?.questions?.[0]?.options?.length) {
+    // Real payload verified live: tool_input.questions[0].options only
+    // ever lists the REAL answer choices Claude proposed (e.g. "Just
+    // delete existing file", "Overwrite then delete") - none of them is a
+    // "reject". The on-screen "N. Type something." and "N+1. Chat about
+    // this" the user actually sees are UI chrome this tool always appends
+    // itself, at fixed positions right after the real options, and are
+    // NOT present in this payload at all - added here explicitly (with
+    // their own real, correct keystrokes) rather than silently missing
+    // from the phone's choices, since without them there'd be no reject-
+    // equivalent option at all for this tool.
+    const opts = event.tool_input.questions[0].options;
+    const real = opts.map((o, i) => ({ label: o.label, keystroke: String(i + 1), style: i === 0 ? 'approve' : 'approve-alt' }));
+    return [
+      ...real,
+      { label: 'Type something', keystroke: String(opts.length + 1), style: 'reject' },
+    ];
+  }
+  if (event.tool_name === 'Write' || event.tool_name === 'Edit') {
+    return [
+      { label: 'Yes', keystroke: '1', style: 'approve' },
+      { label: 'Yes, and accept edits automatically for this session', keystroke: '2', style: 'approve-alt' },
+      { label: 'No', keystroke: '3', style: 'reject' },
+    ];
+  }
+  if (event.tool_name === 'Bash' || event.tool_name === 'PowerShell') {
+    return [
+      { label: 'Yes', keystroke: '1', style: 'approve' },
+      { label: "Yes, don't ask again for this command in this project", keystroke: '2', style: 'approve-alt' },
+      { label: 'No', keystroke: '3', style: 'reject' },
+    ];
+  }
+  return [
+    { label: 'Yes', keystroke: '1', style: 'approve' },
+    { label: 'No', keystroke: '3', style: 'reject' },
+  ];
+}
+
+// Real bug found by testing: getDialogOptions' Write/Edit/Bash/PowerShell
+// branches above are a HARDCODED GUESS at Claude Code's own menu, since
+// the PermissionRequest hook payload never includes the real options for
+// those tool types (confirmed live - only AskUserQuestion's payload
+// carries real options at all). That guess drifted the moment Claude Code
+// added a 4th choice ("switch to auto mode") to its Bash/Write menu - the
+// phone showed 3 buttons for a real 4-option prompt. This reads the ACTUAL
+// rendered menu directly from the terminal instead of guessing - the one
+// source of truth for what the user can really pick, immune to Claude
+// Code changing its wording or option COUNT in a future version.
+const ANSI_RE = /\x1b\[[0-9;?]*[a-zA-Z]/g;
+function stripAnsi(text) {
+  return text.replace(ANSI_RE, '');
+}
+
+const PROCEED_RE = /do you want to (?:proceed|create|make this edit)\??/i;
+const ESC_FOOTER_RE = /esc to cancel/i;
+// A real numbered option line: "1. Yes", "❯ 2. Yes, and always allow...".
+// Real bug found by testing: the currently-highlighted option's pointer
+// glyph (❯) is NOT wrapped in its own ANSI color code the way the
+// original comment here assumed - it's a plain literal character sitting
+// before the digit, confirmed against a real captured "❯ 1. Yes" line -
+// so \s* alone (whitespace only) never matched it, silently dropping
+// EXACTLY the currently-selected option (always index 0) out of the
+// parsed list every single time. [^\d\n]* explicitly allows that glyph
+// (or any other non-digit marker Claude Code might use) before the
+// number, without allowing it to swallow a real digit from a different
+// line entirely (multiline mode - ^ anchors per line, not per string).
+const OPTION_LINE_RE = /^[^\d\n]*(\d+)\.\s+(.+)$/;
+
+// Reads the real, live menu straight from a trailing scrollback window.
+// Returns null (not a guess) if the window doesn't contain a complete
+// menu yet - supervisor.js retries a few times as the PTY catches up
+// before ever falling back to the static guess above.
+function parseLiveOptions(scrollbackWindow) {
+  const clean = stripAnsi(scrollbackWindow);
+  const startMatch = clean.match(PROCEED_RE);
+  if (!startMatch) return null;
+  const endMatch = clean.slice(startMatch.index).match(ESC_FOOTER_RE);
+  if (!endMatch) return null; // menu still rendering - not a complete capture yet
+
+  const section = clean.slice(startMatch.index, startMatch.index + endMatch.index);
+  const options = [];
+  // Real bug found by testing: Claude Code's real terminal output uses
+  // \r\n line endings, and splitting on '\n' alone leaves a trailing \r
+  // on every line. JavaScript's `.` does NOT match \r (confirmed - only
+  // \n is excluded from `.` in most regex engines, but V8 excludes \r
+  // too), so (.+)$ could never reach real end-of-line and OPTION_LINE_RE
+  // silently matched ZERO option lines, not just the pointer-marked one -
+  // this is what actually caused parseLiveOptions to return null on every
+  // real menu, not just a pointer-glyph edge case. Stripping stray \r
+  // before splitting is the fix that generalizes to any future capture,
+  // not just this one.
+  for (const line of section.replace(/\r/g, '').split('\n')) {
+    const m = line.match(OPTION_LINE_RE);
+    if (m) options.push({ number: Number(m[1]), label: m[2].trim() });
+  }
+  if (options.length === 0) return null;
+
+  // Real, observed shape: the LAST numbered option is always the decline
+  // ("No") - every live capture so far (3-option AND the newer 4-option
+  // menu) confirms this holds regardless of how many "Yes, and also..."
+  // variants sit in between. keystroke is the option's own real number as
+  // rendered, not a re-numbered index - this is what makes this immune to
+  // Claude Code adding/removing/reordering middle options.
+  return options.map((o, i) => ({
+    label: o.label,
+    keystroke: String(o.number),
+    style: i === options.length - 1 ? 'reject' : i === 0 ? 'approve' : 'approve-alt',
+  }));
+}
+
+// Corrected against REAL `/cost` output (Claude Code CLI, captured live -
+// see project chat history for the exact screenshot), not guessed - the
+// actual shape is:
+//   Total cost:            $0.0000
+//   ...
+//   Usage:                 0 input, 0 output, 0 cache read, 0 cache write
+//   ...
+//   Current session
+//   ████████████████████████████▉                      58% used
+//   Resets 8:20pm (Asia/Kolkata)
+// Two real surprises the first version of this regex got wrong: (1) the
+// line is literally "Usage:", not "Total tokens used:" - a guess that
+// never matched; (2) input/output here reflects only recent API calls,
+// not cumulative session usage - it read 0/0 on a hours-old session in
+// testing. The "Current session ... % used" context-window bar is the
+// actually-meaningful, reliably-nonzero signal for "how much of this
+// session have I used", so that's captured too and is what Devices/
+// Profile should lead with - raw input/output tokens are kept as a
+// secondary field since they're real numbers, just not the useful ones
+// for "how much have I used up" the user actually asked for.
+//
+// Wording/format has changed across Claude Code versions before and will
+// again - these regexes are intentionally loose (case-insensitive,
+// tolerant of box-drawing/ANSI noise around the numbers) but there's no
+// guarantee they survive the next release. If they stop matching,
+// parseFromOutput just keeps returning null (see supervisor-qr.js's
+// caller) - the rest of the app degrades to "no usage data," not a crash.
+const USAGE_LINE_RE = /usage:\s*([\d,]+)\s*input,\s*([\d,]+)\s*output,\s*([\d,]+)\s*cache read,\s*([\d,]+)\s*cache write/i;
+const COST_RE = /total cost:\s*\$([\d.]+)/i;
+// "Current session" and "Current week (all models)" each have their own
+// "NN% used" + "Resets ..." pair right below them - captured as separate
+// regexes (not one generic loop) since the two sections' reset-time
+// format actually differs (session: bare time "8:20pm (TZ)"; week: date +
+// time "Sep 19, 2:30am (TZ)") - confirmed against the real captured
+// output, not assumed to be the same shape.
+const SESSION_PCT_RE = /current session[\s\S]{0,200}?(\d{1,3})%\s*used/i;
+const SESSION_RESET_RE = /current session[\s\S]{0,300}?resets\s+([^\n(]+(?:\([^)]+\))?)/i;
+const WEEK_PCT_RE = /current week[^\n]*[\s\S]{0,200}?(\d{1,3})%\s*used/i;
+const WEEK_RESET_RE = /current week[^\n]*[\s\S]{0,300}?resets\s+([^\n(]+(?:\([^)]+\))?)/i;
+
+function parseFromOutput(chunk) {
+  const usageMatch = chunk.match(USAGE_LINE_RE);
+  const costMatch = chunk.match(COST_RE);
+  const pctMatch = chunk.match(SESSION_PCT_RE);
+  const sessionResetMatch = chunk.match(SESSION_RESET_RE);
+  const weekPctMatch = chunk.match(WEEK_PCT_RE);
+  const weekResetMatch = chunk.match(WEEK_RESET_RE);
+  if (!usageMatch && !costMatch && !pctMatch && !weekPctMatch) return null;
+
+  const inputTokens = usageMatch ? Number(usageMatch[1].replace(/,/g, '')) : null;
+  const outputTokens = usageMatch ? Number(usageMatch[2].replace(/,/g, '')) : null;
+  return {
+    totalTokens: inputTokens != null && outputTokens != null ? inputTokens + outputTokens : null,
+    inputTokens,
+    outputTokens,
+    cacheReadTokens: usageMatch ? Number(usageMatch[3].replace(/,/g, '')) : null,
+    cacheWriteTokens: usageMatch ? Number(usageMatch[4].replace(/,/g, '')) : null,
+    costUsd: costMatch ? Number(costMatch[1]) : null,
+    sessionContextUsedPct: pctMatch ? Number(pctMatch[1]) : null,
+    sessionResetsAt: sessionResetMatch ? sessionResetMatch[1].trim() : null,
+    weekUsedPct: weekPctMatch ? Number(weekPctMatch[1]) : null,
+    weekResetsAt: weekResetMatch ? weekResetMatch[1].trim() : null,
+    raw: chunk,
+  };
+}
+
+module.exports = {
+  id: 'claude',
+  displayName: 'Claude Code',
+  // Adapter-declared icon (see README.md) - the app's Devices tab reads
+  // this instead of hardcoding "if cliType === 'claude'" anywhere in the
+  // UI, so a future third adapter just declares its own icon here too,
+  // with no UI changes needed. No official Anthropic logo asset is
+  // bundled (real brand marks need to be properly sourced by whoever
+  // owns this app, not fabricated) - a distinct, well-chosen generic
+  // icon + color stands in until a real logo image is supplied.
+  icon: { name: 'sparkles', color: '#D97757' }, // Anthropic's own public brand accent is a terracotta/orange - approximated here, not an official value
+  spawn: {
+    command:
+      process.platform === 'win32'
+        ? 'C:\\Users\\hp\\AppData\\Roaming\\npm\\claude.cmd'
+        : 'claude',
+    args: () => ['--permission-mode', 'default'],
+  },
+  approvals: {
+    queueFileFor,
+    describePrompt,
+    getDialogOptions,
+    parseLiveOptions,
+    // Real gap found by testing: a PTY-text-scan for Claude Code's own
+    // "Interrupted..." wording (resolvedLocallyPattern) was tried and
+    // removed - real captured terminal output across several live
+    // rejection tests never actually contained that literal text in a
+    // form a regex could reliably match. This is a different, more
+    // robust signal: it doesn't care WHAT replaced the menu (an
+    // "Interrupted" message, a follow-up question, plain output - Claude
+    // Code's exact wording can drift freely) - only whether the SAME
+    // "Do you want to proceed?" style menu PROCEED_RE matched is still
+    // physically on screen. supervisor.js polls this for a few seconds
+    // right after relaying a prompt; once it stops matching, the prompt
+    // is gone - approved, rejected, or interrupted, any of those means a
+    // decision happened, so this is a fully reliable resolution signal
+    // for the Bash/Write/PowerShell prompts that only ever get options
+    // via parseLiveOptions in the first place (AskUserQuestion already
+    // resolves correctly via PostToolUse+resolveIfPending's exact
+    // question-text match - this is not used for that tool_name at all).
+    isMenuStillOnScreen: (scrollbackWindow) => PROCEED_RE.test(stripAnsi(scrollbackWindow)),
+  },
+  usage: {
+    // '/cost' + Enter - a real, visible command in the user's own
+    // terminal (see supervisor-qr.js's usage-polling comment for why this
+    // is opt-in-by-default rather than silent).
+    triggerKeystrokes: '/cost\r',
+    parseFromOutput,
+  },
+  // Remote slash-command palette (Section 15 roadmap item #6). Each entry
+  // is just a label + the literal keystrokes to write into the PTY - the
+  // SAME primitive terminal.input already uses for free-typed text (see
+  // supervisor-qr.js's ws.on('message') handler), just named and one tap
+  // instead of typing it out. Deliberately NOT a structured remote
+  // sub-menu: /model opens Claude Code's own interactive picker on the
+  // laptop's real screen, which the phone then sees via the existing
+  // live terminal mirror (Phase 6) and can navigate with the same
+  // quick-action arrow/Enter keys already in the Terminal tab - no new
+  // blind multi-step remote flow being invented here.
+  commands: [
+    { id: 'cost', label: 'Check usage', keystrokes: '/cost\r' },
+    { id: 'model', label: 'Switch model', keystrokes: '/model\r' },
+    { id: 'compact', label: 'Compact context', keystrokes: '/compact\r' },
+  ],
+};