@phnx-labs/agents-cli 1.22.113 → 1.22.114

package/dist/lib/teams/pr-watch.d.ts

@@ -133,20 +133,12 @@ export declare function parsePrUrl(prUrl: string): {
     repo: string;
     number: number;
 } | null;
-/** Fetch the current CI checks for a PR via `gh pr checks`. Returns [] on any gh error. */
-export declare function fetchPrChecks(prUrl: string): Promise<PrCheck[]>;
-/** Fetch review comments for a PR via `gh api`. Returns [] on any gh error. */
-export declare function fetchPrReviewComments(prUrl: string): Promise<PrReviewComment[]>;
-/** Fetch the failing-run logs for a check via `gh run view --log-failed`. Best-effort, truncated. */
-export declare function fetchCiFailureLogs(check: PrCheck, maxChars?: number): Promise<string>;
-/** Collect a live PR snapshot from `gh`. The poll-mode seam for `runPrWatch`. */
-export declare function pollPrSnapshot(prUrl: string, sourceTeammate: string | null): Promise<PrSnapshot>;
 /** A PR to watch, paired with the teammate that opened it. */
 export interface WatchTarget {
     prUrl: string;
     sourceTeammate: string | null;
 }
-export interface PrWatchDeps {
+interface PrWatchDeps {
     /** Discover which PRs to watch this pass (teammates may open PRs mid-run). */
     resolveTargets: () => Promise<WatchTarget[]>;
     /** Snapshot one PR's CI + review comments. Defaults to `pollPrSnapshot`. */
@@ -192,7 +184,7 @@ export type PrWatchEvent = {
     message: string;
     timestamp: string;
 };
-export interface PrWatchOptions {
+interface PrWatchOptions {
     intervalMs?: number;
     /** Stop after this many polls (0 / undefined = run until signalled). */
     maxPolls?: number;
@@ -205,7 +197,7 @@ export interface PrWatchOptions {
     /** Abort signal — resolves the loop at the next interval boundary. */
     shouldStop?: () => boolean;
 }
-export interface PrWatchResult {
+interface PrWatchResult {
     polls: number;
     spawned: number;
     /** How many PRs escalated to a human (wave budget exhausted). */
@@ -224,3 +216,4 @@ export interface PrWatchResult {
  * and `waves` hard-caps the total spawns per PR (issue #338).
  */
 export declare function runPrWatch(deps: PrWatchDeps, opts?: PrWatchOptions): Promise<PrWatchResult>;
+export {};

package/dist/lib/teams/pr-watch.js

@@ -194,7 +194,7 @@ export function parsePrUrl(prUrl) {
 // PrReviewComment shapes and hand them straight to decidePrActions.
 // ---------------------------------------------------------------------------
 /** Fetch the current CI checks for a PR via `gh pr checks`. Returns [] on any gh error. */
-export async function fetchPrChecks(prUrl) {
+async function fetchPrChecks(prUrl) {
     try {
         const { stdout } = await execFileAsync('gh', ['pr', 'checks', prUrl, '--json', 'name,state,link,workflow'], { maxBuffer: 8 * 1024 * 1024 });
         const raw = JSON.parse(stdout);
@@ -213,7 +213,7 @@ export async function fetchPrChecks(prUrl) {
     }
 }
 /** Fetch review comments for a PR via `gh api`. Returns [] on any gh error. */
-export async function fetchPrReviewComments(prUrl) {
+async function fetchPrReviewComments(prUrl) {
     const parsed = parsePrUrl(prUrl);
     if (!parsed)
         return [];
@@ -239,7 +239,7 @@ export async function fetchPrReviewComments(prUrl) {
     }
 }
 /** Fetch the failing-run logs for a check via `gh run view --log-failed`. Best-effort, truncated. */
-export async function fetchCiFailureLogs(check, maxChars = 8000) {
+async function fetchCiFailureLogs(check, maxChars = 8000) {
     const runId = check.link?.match(/\/runs\/(\d+)/)?.[1] ?? check.link?.match(/\/actions\/runs\/(\d+)/)?.[1];
     if (!runId)
         return '';
@@ -255,7 +255,7 @@ export async function fetchCiFailureLogs(check, maxChars = 8000) {
     }
 }
 /** Collect a live PR snapshot from `gh`. The poll-mode seam for `runPrWatch`. */
-export async function pollPrSnapshot(prUrl, sourceTeammate) {
+async function pollPrSnapshot(prUrl, sourceTeammate) {
     const [checks, comments] = await Promise.all([
         fetchPrChecks(prUrl),
         fetchPrReviewComments(prUrl),

package/dist/lib/teams/registry.d.ts

@@ -34,7 +34,7 @@ export type TeamRegistry = Record<string, TeamMeta>;
  * write, which is exactly the data-loss path we are trying to close.
  */
 export declare function loadTeams(): Promise<TeamRegistry>;
-export interface CreateTeamOptions {
+interface CreateTeamOptions {
     description?: string;
     enableWorktrees?: boolean;
     /** Path to an existing worktree for all teammates to share. */
@@ -52,8 +52,6 @@ export declare function createTeam(name: string, options?: CreateTeamOptions): P
 export declare function ensureTeam(name: string): Promise<TeamMeta>;
 /** Mark a team as disbanded so saveMeta will not resurrect its teammates. */
 export declare function markTeamDisbanded(name: string): Promise<void>;
-/** Clear a disband tombstone — called when the name is re-created. */
-export declare function clearTeamDisbanded(name: string): Promise<void>;
 /** True when the team was disbanded and has not been re-created since. */
 export declare function isTeamDisbanded(name: string): Promise<boolean>;
 /** Remove a team from the registry. Returns false if the team did not exist. */
@@ -62,3 +60,4 @@ export declare function removeTeam(name: string): Promise<boolean>;
 export declare function teamExists(name: string): Promise<boolean>;
 /** Get metadata for a specific team. Returns null if team does not exist. */
 export declare function getTeam(name: string): Promise<TeamMeta | null>;
+export {};

package/dist/lib/teams/registry.js

@@ -151,7 +151,7 @@ export async function markTeamDisbanded(name) {
     await fs.writeFile(disbandedPath(name), JSON.stringify({ team: name, disbanded_at: new Date().toISOString() }), 'utf-8');
 }
 /** Clear a disband tombstone — called when the name is re-created. */
-export async function clearTeamDisbanded(name) {
+async function clearTeamDisbanded(name) {
     try {
         await fs.unlink(disbandedPath(name));
     }

package/dist/lib/teams/remoteWorktree.d.ts

@@ -9,22 +9,6 @@ interface RemoteSshOptions {
  * single-quoted, so odd path characters stay safe.
  */
 export declare function remotePathExpr(p: string): string;
-/**
- * Resolve the ABSOLUTE git top-level for a (possibly `~`-relative) repo path on
- * the host, or null when it isn't a git repo / the host is unreachable. Used by
- * `ensureRemoteRepo` to both VALIDATE and CANONICALIZE a repo location, so every
- * downstream remote command (launch `cd`, worktree create, polling) works from an
- * absolute path with no tilde-expansion hazard.
- */
-export declare function resolveRemoteRepoRoot(target: string, repoPath: string, opts?: RemoteSshOptions): string | null;
-/** True when `repoPath` is a git working tree on the host. */
-export declare function isRemoteGitRepo(target: string, repoPath: string, opts?: RemoteSshOptions): boolean;
-/**
- * Resolve the host repo's default branch name (origin/HEAD → `main`/`master`/…).
- * Falls back to `main` when origin/HEAD isn't set, matching the local recipe's
- * `remote set-head` step.
- */
-export declare function remoteDefaultBranch(target: string, repoPath: string, opts?: RemoteSshOptions): string;
 /**
  * Create a worktree on the host for a teammate, branched off the freshly-fetched
  * default branch. Returns the absolute worktree path on the host.

package/dist/lib/teams/remoteWorktree.js

@@ -40,7 +40,7 @@ export function remotePathExpr(p) {
  * downstream remote command (launch `cd`, worktree create, polling) works from an
  * absolute path with no tilde-expansion hazard.
  */
-export function resolveRemoteRepoRoot(target, repoPath, opts = {}) {
+function resolveRemoteRepoRoot(target, repoPath, opts = {}) {
     assertValidSshTarget(target);
     const cmd = `git -C ${remotePathExpr(repoPath)} rev-parse --show-toplevel 2>/dev/null`;
     const res = sshExec(target, cmd, { timeoutMs: 15000, multiplex: true, extraSshArgs: opts.extraSshArgs });
@@ -57,7 +57,7 @@ function remoteGit(target, repoPath, args, timeoutMs = 60000, opts = {}) {
     return res.stdout.trim();
 }
 /** True when `repoPath` is a git working tree on the host. */
-export function isRemoteGitRepo(target, repoPath, opts = {}) {
+function isRemoteGitRepo(target, repoPath, opts = {}) {
     assertValidSshTarget(target);
     // remotePathExpr so a `~`/`$HOME`-relative path (the canonical repos dir) expands
     // on the host — plain shellQuote would single-quote the tilde into a literal,
@@ -71,7 +71,7 @@ export function isRemoteGitRepo(target, repoPath, opts = {}) {
  * Falls back to `main` when origin/HEAD isn't set, matching the local recipe's
  * `remote set-head` step.
  */
-export function remoteDefaultBranch(target, repoPath, opts = {}) {
+function remoteDefaultBranch(target, repoPath, opts = {}) {
     assertValidSshTarget(target);
     try {
         // Refresh origin/HEAD first so a repo cloned before the default was set resolves.

package/dist/lib/teams/scheduler.d.ts

@@ -31,7 +31,7 @@ export interface DevicePlacementSignal {
     pickerEligible?: boolean;
 }
 /** Team fields the placement cascade reads (a subset of TeamMeta). */
-export interface PlacementTeam {
+interface PlacementTeam {
     devices?: string[];
 }
 /**
@@ -44,7 +44,7 @@ export interface PlacementTeam {
  * honors caps: an explicit pin or a pool of one is the user's own choice and
  * is never second-guessed.
  */
-export interface PlacementOptions {
+interface PlacementOptions {
     /** Worker pool used when the team does not declare an explicit device pool. */
     defaultDevices?: string[];
     maxConcurrent?: Record<string, number>;
@@ -59,7 +59,7 @@ export interface PlacementOptions {
     agentLabel?: string;
     /**
      * Normalized hosts boosted with `auto-launch.preferred` (set by
-     * `agents devices prefer <name>`). A preferred device ranks ahead of a
+     * `agents devices config <name> auto-launch.preferred on`). A preferred device ranks ahead of a
      * non-preferred one among the eligible survivors — after the signed-in tier
      * (a preferred box that can't run the agent is still no use) and before load,
      * so an operator boost overrides load-based ordering without overriding hard
@@ -69,9 +69,9 @@ export interface PlacementOptions {
     preferred?: ReadonlySet<string>;
 }
 /** Why a device was excluded from the viable set, for the fail-loud message. */
-export type ExclusionReason = 'unreachable' | 'probe-timed-out' | 'overloaded' | 'capped' | 'not-installed';
+type ExclusionReason = 'unreachable' | 'probe-timed-out' | 'overloaded' | 'capped' | 'not-installed';
 /** A pool device dropped from the auto-pick, with the reason + live detail. */
-export interface ExcludedDevice {
+interface ExcludedDevice {
     device: string;
     reason: ExclusionReason;
     /** Present for `capped`: `running/cap`. */
@@ -155,3 +155,4 @@ export declare function pickBestDevice(devices: string[], roster: RosterEntry[],
 export declare function resolvePlacement(team: PlacementTeam, explicitDevice: string | null, roster: RosterEntry[], opts?: PlacementOptions): {
     device: string | null;
 };
+export {};

package/dist/lib/teams/scheduler.js

@@ -269,7 +269,7 @@ export function pickBestDevice(devices, roster, opts) {
         const signedIn = (sa?.signedIn === true ? 0 : 1) - (sb?.signedIn === true ? 0 : 1);
         if (signedIn !== 0)
             return signedIn;
-        // (a2) operator-preferred device next — `agents devices prefer <name>`
+        // (a2) operator-preferred device next — `agents devices config <name> auto-launch.preferred on`
         // boosts a box above its load-equal peers, overriding load-based order.
         const preferred = opts?.preferred;
         if (preferred && preferred.size > 0) {

package/dist/lib/teams/supervisor.d.ts

@@ -20,7 +20,7 @@
 import type { AgentManager, AgentProcess } from './agents.js';
 import type { TeamBudgetWatcher } from '../budget/live-team.js';
 import type { BreachInfo } from '../budget/enforce.js';
-export interface WaveSummary {
+interface WaveSummary {
     wave: number;
     timestamp: string;
     team: string;
@@ -31,7 +31,7 @@ export interface WaveSummary {
     failed: number;
     drained: boolean;
 }
-export interface SupervisorOptions {
+interface SupervisorOptions {
     team: string;
     intervalMs?: number;
     maxWaves?: number;
@@ -47,7 +47,7 @@ export interface SupervisorOptions {
     /** Called with the breach details when the budget watcher trips. */
     onBudgetBreach?: (breach: BreachInfo) => void;
 }
-export interface SupervisorResult {
+interface SupervisorResult {
     waves: number;
     stoppedBy: 'drained' | 'max-waves' | 'signal' | 'callback' | 'budget';
     elapsed_ms: number;
@@ -66,3 +66,4 @@ export interface SupervisorResult {
  * returns false from onWave, or SIGINT/SIGTERM arrives.
  */
 export declare function runSupervisor(mgr: AgentManager, opts: SupervisorOptions): Promise<SupervisorResult>;
+export {};

package/dist/lib/teams/worktree.d.ts

@@ -12,15 +12,6 @@ export declare function getGitRoot(dir: string): Promise<string>;
  * Check if a worktree directory has uncommitted changes.
  */
 export declare function hasUncommittedChanges(worktreePath: string): Promise<boolean>;
-/** Default cap on diff text so one giant worktree can't blow up the serve dashboard. */
-export declare const DEFAULT_DIFF_MAX_BYTES = 200000;
-/**
- * Return the uncommitted working-tree diff for a worktree (staged + unstaged,
- * relative to HEAD), capped so a huge diff can't overwhelm the read-only serve
- * dashboard. Read-only: shells out to `git diff HEAD` and never mutates state.
- * Returns '' when the path isn't a git worktree or has no pending changes.
- */
-export declare function gitDiff(worktreePath: string, maxBytes?: number): Promise<string>;
 /**
  * Resolve the repo's default branch name (origin/HEAD → `main`/`master`/…).
  * Refreshes origin/HEAD first so a repo cloned before the default was set resolves.

package/dist/lib/teams/worktree.js

@@ -45,38 +45,6 @@ export async function hasUncommittedChanges(worktreePath) {
         return false;
     }
 }
-/** Default cap on diff text so one giant worktree can't blow up the serve dashboard. */
-export const DEFAULT_DIFF_MAX_BYTES = 200_000;
-/**
- * Return the uncommitted working-tree diff for a worktree (staged + unstaged,
- * relative to HEAD), capped so a huge diff can't overwhelm the read-only serve
- * dashboard. Read-only: shells out to `git diff HEAD` and never mutates state.
- * Returns '' when the path isn't a git worktree or has no pending changes.
- */
-export async function gitDiff(worktreePath, maxBytes = DEFAULT_DIFF_MAX_BYTES) {
-    // Size the capture buffer off the cap (not an arbitrary 1MB floor) so a diff
-    // that overshoots gets TRUNCATED, never silently dropped. A diff larger than
-    // the buffer overflows maxBuffer, but Node still hands us the captured prefix
-    // on the rejection — we truncate that below rather than losing it to ''.
-    const maxBuffer = maxBytes * 4;
-    const truncate = (s) => s.slice(0, maxBytes) + `\n… [diff truncated at ${maxBytes} bytes]`;
-    try {
-        const { stdout } = await execFileAsync('git', ['diff', 'HEAD'], {
-            cwd: worktreePath,
-            maxBuffer,
-        });
-        return stdout.length > maxBytes ? truncate(stdout) : stdout;
-    }
-    catch (err) {
-        // ENOBUFS on an oversized diff still carries the partial capture; truncate
-        // it so the dashboard shows "[diff truncated]" instead of "no changes".
-        // A genuine non-git-worktree error has no stdout → fall through to ''.
-        const partial = err?.stdout;
-        if (typeof partial === 'string' && partial.length > 0)
-            return truncate(partial);
-        return '';
-    }
-}
 /**
  * Resolve the repo's default branch name (origin/HEAD → `main`/`master`/…).
  * Refreshes origin/HEAD first so a repo cloned before the default was set resolves.

package/dist/lib/term-client.d.ts

@@ -0,0 +1,44 @@
+export declare const TERM_NOT_INSTALLED_ERROR = "The standalone `term` CLI is not installed. npm i -g @phnx-labs/term-cli";
+/** JSON response envelope from `term`, mirroring the old PTY sidecar's shape. */
+export interface TermResponse {
+    ok: boolean;
+    error?: string;
+    [key: string]: any;
+}
+/**
+ * Resolve the `term` binary to exec: `$TERM_BIN` first (exact override, used
+ * by tests and by an operator pinning a specific install), else an ordinary
+ * PATH lookup. Returns null when neither resolves — the caller must fail loud
+ * with {@link TERM_NOT_INSTALLED_ERROR} rather than falling back to anything.
+ */
+export declare function resolveTermBin(): string | null;
+export interface TermStartOptions {
+    rows?: number;
+    cols?: number;
+    shell?: string;
+    cwd?: string;
+}
+/** `term start [-r rows] [-c cols] [-s shell] [-d cwd] --json` → the new session id. */
+export declare function termStart(opts?: TermStartOptions): Promise<TermResponse>;
+/** `term exec <id> <command> --json` — send a command, non-blocking. */
+export declare function termExec(id: string, command: string): Promise<TermResponse>;
+/**
+ * `term write <id> <input> --raw --json` — send raw bytes to the session.
+ * `--raw` is load-bearing: the caller here always supplies already-literal
+ * bytes (e.g. `\x1b[B\r` as real control characters from a JS string), never
+ * the `pty write` CLI's `\n`/`\t`/`\e`/`\xHH` textual escape syntax, so `term`
+ * must not re-interpret them.
+ */
+export declare function termWrite(id: string, input: string): Promise<TermResponse>;
+/** `term screen <id> --json` → `{ screen, exited, cols, rows }`. */
+export declare function termScreen(id: string): Promise<TermResponse>;
+/**
+ * `term stop <id>` — end the session and clean up.
+ *
+ * Unlike every other verb, `stop` has no `--json` mode and prints nothing on
+ * success (confirmed against a real built `term` binary — a bare `--json`
+ * flag errors `unknown option '--json'`, and success alone leaves stdout
+ * empty), so this synthesizes the `{ ok }` envelope from the exit code
+ * instead of routing through {@link runTerm}'s stdout-JSON parse.
+ */
+export declare function termStop(id: string): Promise<TermResponse>;

package/dist/lib/term-client.js

@@ -0,0 +1,117 @@
+/**
+ * `term` client — thin subprocess wrapper over the standalone `term` CLI
+ * (published separately as `@phnx-labs/term-cli`), the PTY engine this repo
+ * used to own directly (`agents pty`, removed in PHNX-4091). `term` mirrors the
+ * old `agents pty` verbs/flags/JSON shapes 1:1 (`start`, `exec`, `read`,
+ * `write`, `screen`, `signal`, `resize`, `list`, `stop`, `server start|stop|
+ * status`, hidden `_server`) and owns starting/reusing its own background
+ * sidecar itself — this client never manages that process, it only shells out
+ * to the CLI and parses one line of JSON per call.
+ *
+ * Resolution order:
+ *   1. `$TERM_BIN` — an explicit override (a full path, or a PATH-resolvable
+ *      name other than `term`). Sets the exact binary this client execs; the
+ *      one legitimate use besides pointing at a real install is a test double.
+ *   2. `findInPath('term')` — the ordinary PATH lookup (skips this CLI's own
+ *      shims dir, same as every other native-binary resolution in this repo).
+ *
+ * Neither resolving is the expected state until `@phnx-labs/term-cli` is
+ * published and installed — every call fails loud with
+ * {@link TERM_NOT_INSTALLED_ERROR} rather than silently no-op'ing.
+ */
+import { execFile } from 'node:child_process';
+import { findInPath } from './agent-spec/agents.js';
+export const TERM_NOT_INSTALLED_ERROR = 'The standalone `term` CLI is not installed. npm i -g @phnx-labs/term-cli';
+/**
+ * Resolve the `term` binary to exec: `$TERM_BIN` first (exact override, used
+ * by tests and by an operator pinning a specific install), else an ordinary
+ * PATH lookup. Returns null when neither resolves — the caller must fail loud
+ * with {@link TERM_NOT_INSTALLED_ERROR} rather than falling back to anything.
+ */
+export function resolveTermBin() {
+    const override = process.env.TERM_BIN;
+    if (override && override.trim().length > 0)
+        return override.trim();
+    return findInPath('term');
+}
+/** Run one `term <args>` invocation and parse the trailing JSON line from stdout. */
+function runTerm(args) {
+    return new Promise((resolve, reject) => {
+        const bin = resolveTermBin();
+        if (!bin) {
+            reject(new Error(TERM_NOT_INSTALLED_ERROR));
+            return;
+        }
+        execFile(bin, args, { maxBuffer: 16 * 1024 * 1024, timeout: 30_000 }, (err, stdout, stderr) => {
+            const out = stdout.toString().trim();
+            if (!out) {
+                reject(new Error(`term ${args[0]} produced no output: ${stderr.toString().trim() || (err ? err.message : 'unknown error')}`));
+                return;
+            }
+            // `term` may emit progress on earlier lines; the response is the last line.
+            const line = out.split('\n').pop() ?? '';
+            try {
+                resolve(JSON.parse(line));
+            }
+            catch {
+                reject(new Error(`Invalid JSON from term: ${out.slice(0, 200)}`));
+            }
+        });
+    });
+}
+/** `term start [-r rows] [-c cols] [-s shell] [-d cwd] --json` → the new session id. */
+export function termStart(opts = {}) {
+    const args = ['start', '--json'];
+    if (opts.rows)
+        args.push('-r', String(opts.rows));
+    if (opts.cols)
+        args.push('-c', String(opts.cols));
+    if (opts.shell)
+        args.push('-s', opts.shell);
+    if (opts.cwd)
+        args.push('-d', opts.cwd);
+    return runTerm(args);
+}
+/** `term exec <id> <command> --json` — send a command, non-blocking. */
+export function termExec(id, command) {
+    return runTerm(['exec', id, command, '--json']);
+}
+/**
+ * `term write <id> <input> --raw --json` — send raw bytes to the session.
+ * `--raw` is load-bearing: the caller here always supplies already-literal
+ * bytes (e.g. `\x1b[B\r` as real control characters from a JS string), never
+ * the `pty write` CLI's `\n`/`\t`/`\e`/`\xHH` textual escape syntax, so `term`
+ * must not re-interpret them.
+ */
+export function termWrite(id, input) {
+    return runTerm(['write', id, input, '--raw', '--json']);
+}
+/** `term screen <id> --json` → `{ screen, exited, cols, rows }`. */
+export function termScreen(id) {
+    return runTerm(['screen', id, '--json']);
+}
+/**
+ * `term stop <id>` — end the session and clean up.
+ *
+ * Unlike every other verb, `stop` has no `--json` mode and prints nothing on
+ * success (confirmed against a real built `term` binary — a bare `--json`
+ * flag errors `unknown option '--json'`, and success alone leaves stdout
+ * empty), so this synthesizes the `{ ok }` envelope from the exit code
+ * instead of routing through {@link runTerm}'s stdout-JSON parse.
+ */
+export function termStop(id) {
+    return new Promise((resolve, reject) => {
+        const bin = resolveTermBin();
+        if (!bin) {
+            reject(new Error(TERM_NOT_INSTALLED_ERROR));
+            return;
+        }
+        execFile(bin, ['stop', id], { maxBuffer: 16 * 1024 * 1024, timeout: 30_000 }, (err, _stdout, stderr) => {
+            if (err) {
+                resolve({ ok: false, error: stderr.toString().trim() || err.message });
+                return;
+            }
+            resolve({ ok: true });
+        });
+    });
+}

package/dist/lib/terminal/inject.d.ts

@@ -33,8 +33,6 @@
  *             via System Events keystrokes, stealing focus. The resolver refuses
  *             to route here by default (see resolve.ts); it stays behind an
  *             explicit opt-in.
- *   - pty   → the `agents pty write` sidecar path (ptyRequest). Local-only —
- *             the sidecar is not an engine transport surface.
  *
  * Ink-TUI Enter semantics: Claude's Ink TUI swallows an Enter fused to the text,
  * so the default path delivers the text and the Enter as TWO SEPARATE writes
@@ -45,8 +43,7 @@ import { type HostResolver } from './transport.js';
 import { type LaunchSpec, type EngineContext } from './types.js';
 /**
  * An already-running surface to type into. A superset of the engine's launch
- * `Backend` — it adds `pty` (the sidecar), which the engine can't launch but can
- * be injected into.
+ * `Backend`.
  */
 export type InjectTarget = {
     backend: 'tmux';
@@ -70,9 +67,6 @@ export type InjectTarget = {
 } | {
     backend: 'ghostty';
     window?: string;
-} | {
-    backend: 'pty';
-    id: string;
 };
 export type InjectBackend = InjectTarget['backend'];
 export interface InjectOptions {
@@ -101,10 +95,9 @@ export interface InjectResult {
     /**
      * Delivery is CONFIRMED to have reached the running agent, not merely dispatched.
      *
-     * For tmux / iterm / ghostty / pty, `ok` already means delivered: `tmux
+     * For tmux / iterm / ghostty, `ok` already means delivered: `tmux
      * send-keys` errors on a missing pane, `osascript write text` errors on a bad
-     * session id, and a pty write errors if the sidecar can't reach the fd — so a
-     * successful transport IS the confirmation. For **vscodium**, `ok` only means the
+     * session id — so a successful transport IS the confirmation. For **vscodium**, `ok` only means the
      * editor CLI accepted the `--open-url` hand-off; whether the swarm-ext extension
      * actually parsed the verb and typed anything is unknown from the CLI side (the
      * ext must ack — RUSH follow-up). So vscodium is delivered-but-UNCONFIRMED, and
@@ -117,12 +110,6 @@ export interface InjectResult {
     specs?: LaunchSpec[];
     error?: string;
 }
-/**
- * Whether a successful transport on this backend CONFIRMS delivery to the agent.
- * Everything but vscodium self-confirms (see InjectResult.confirmed); vscodium's
- * `--open-url` is fire-and-forget until the swarm-ext extension acks the verb.
- */
-export declare function backendConfirmsDelivery(backend: InjectBackend): boolean;
 /**
  * argv for `tmux send-keys` targeting a pane by id. Starts with `tmux` (like the
  * engine's `tmuxTabArgv`) so the same transport runs it locally or over SSH. The

package/dist/lib/terminal/inject.js

@@ -33,15 +33,12 @@
  *             via System Events keystrokes, stealing focus. The resolver refuses
  *             to route here by default (see resolve.ts); it stays behind an
  *             explicit opt-in.
- *   - pty   → the `agents pty write` sidecar path (ptyRequest). Local-only —
- *             the sidecar is not an engine transport surface.
  *
  * Ink-TUI Enter semantics: Claude's Ink TUI swallows an Enter fused to the text,
  * so the default path delivers the text and the Enter as TWO SEPARATE writes
  * (swarmify's `sendText(text,false)` then `sendText('\r',false)`). `combined`
  * opts into one fused write for plain shells / REPLs.
  */
-import { ptyRequest } from '../pty-client.js';
 import { appleScriptStr } from './quote.js';
 import { runSpec } from './transport.js';
 import { itermBackend, ghosttyBackend } from './backends/index.js';
@@ -51,7 +48,7 @@ import { currentContext } from './types.js';
  * Everything but vscodium self-confirms (see InjectResult.confirmed); vscodium's
  * `--open-url` is fire-and-forget until the swarm-ext extension acks the verb.
  */
-export function backendConfirmsDelivery(backend) {
+function backendConfirmsDelivery(backend) {
     return backend !== 'vscodium';
 }
 /** Carriage return — what Enter delivers into a raw PTY/tmux byte stream. */
@@ -185,28 +182,6 @@ export function vscodiumInjectUri(scheme, terminalId, text, opts) {
 export function vscodiumInjectSpec(target, text, opts) {
     return { argv: [target.cli, '--open-url', vscodiumInjectUri(target.scheme, target.terminalId, text, opts)] };
 }
-// --- pty --------------------------------------------------------------------
-async function injectPty(target, text, o) {
-    if (o.host && o.host !== 'local') {
-        return { ok: false, confirmed: false, backend: 'pty', writes: 0, error: 'pty injection is local-only (the sidecar is not a remote surface)' };
-    }
-    // Same Ink-safe split as tmux: text write, then a separate CR write.
-    const writes = o.enter && o.combined ? [text + CR] : o.enter ? [text, CR] : [text];
-    if (o.dryRun)
-        return { ok: true, confirmed: true, backend: 'pty', writes: writes.length };
-    try {
-        for (const input of writes) {
-            const res = await ptyRequest('write', target.id, { input });
-            if (!res.ok)
-                return { ok: false, confirmed: false, backend: 'pty', writes: 0, error: res.error ?? 'pty write failed' };
-        }
-        // A successful sidecar write reached the fd — real delivery.
-        return { ok: true, confirmed: true, backend: 'pty', writes: writes.length };
-    }
-    catch (err) {
-        return { ok: false, confirmed: false, backend: 'pty', writes: 0, error: err instanceof Error ? err.message : String(err) };
-    }
-}
 // --- public entry -----------------------------------------------------------
 /**
  * Deliver `text` (+ Enter) into an existing terminal surface. Resolves the
@@ -216,9 +191,6 @@ async function injectPty(target, text, o) {
 export async function injectIntoTerminal(target, text, opts = {}) {
     const enter = opts.enter !== false;
     const combined = opts.combined === true;
-    if (target.backend === 'pty') {
-        return injectPty(target, text, { enter, combined, host: opts.host, dryRun: opts.dryRun });
-    }
     // tmux + AppleScript + editor-CLI backends all run through the engine transport.
     const specs = target.backend === 'tmux'
         ? tmuxInjectSpecs(target, text, { enter, combined, socket: opts.socket })

package/dist/lib/terminal/resolve.d.ts

@@ -11,7 +11,7 @@
  * Resolution reads the agent's INHERITED ENV (via session provenance) plus the
  * IDE's live-terminals registry (off disk) — no cooperation from the agent:
  *
- *   tmux  > iterm > vscodium > pty
+ *   tmux  > iterm > vscodium
  *
  * tmux wins whenever present: a `tmux send-keys -t <pane>` reaches the pane no
  * matter which host app (iTerm / Ghostty / VS Code) is above it, so it's correct
@@ -25,7 +25,7 @@
 import type { ActiveSession } from '../session/active.js';
 import type { InjectTarget } from './inject.js';
 /** A resolved rail, or an honest refusal. The watchdog acts only on `addressable: true`. */
-export type InjectRail = 'tmux' | 'iterm' | 'vscodium' | 'ghostty' | 'pty';
+export type InjectRail = 'tmux' | 'iterm' | 'vscodium' | 'ghostty';
 export type InjectResolution = {
     addressable: true;
     rail: InjectRail;
@@ -43,12 +43,6 @@ export interface ResolveOptions {
      * a Ghostty session with no tmux resolves to un-addressable instead.
      */
     allowGhosttyFocus?: boolean;
-    /**
-     * A known `agents pty` sidecar id for this session, if the caller has one. No
-     * automatic sessionId -> pty mapping exists yet, so pty is only emitted when
-     * supplied here (the lowest-precedence rail).
-     */
-    ptyId?: string;
 }
 /**
  * Human-facing recovery hint for a session the resolver judged un-addressable.
@@ -59,7 +53,7 @@ export declare function addressabilityRecoveryHint(session: ActiveSession, fallb
 /**
  * Resolve a target from an already-fetched ActiveSession. Pure — no I/O — so the
  * precedence logic is unit-testable without the process table. This is where the
- * tmux > iterm > vscodium > pty precedence and the Ghostty refusal live.
+ * tmux > iterm > vscodium precedence and the Ghostty refusal live.
  */
 export declare function resolveInjectTargetForSession(session: ActiveSession, opts?: ResolveOptions): InjectResolution;
 /**

package/dist/lib/terminal/resolve.js

@@ -33,12 +33,12 @@ export function addressabilityRecoveryHint(session, fallbackId) {
     if (session.host) {
         return `Host '${session.host}' has no addressable rail here. ${interactive ? `Enable tmux wrapping with \`${tmuxCmd}\` and re-launch, or ` : ''}use \`${resumeCmd}\` to continue this session.`;
     }
-    return `This session has no addressable terminal rail (not tmux, iTerm, an IDE terminal, or a pty sidecar). ${interactive ? `Enable tmux wrapping with \`${tmuxCmd}\` and re-launch, or ` : ''}use \`${resumeCmd}\` to continue this session.`;
+    return `This session has no addressable terminal rail (not tmux, iTerm, or an IDE terminal). ${interactive ? `Enable tmux wrapping with \`${tmuxCmd}\` and re-launch, or ` : ''}use \`${resumeCmd}\` to continue this session.`;
 }
 /**
  * Resolve a target from an already-fetched ActiveSession. Pure — no I/O — so the
  * precedence logic is unit-testable without the process table. This is where the
- * tmux > iterm > vscodium > pty precedence and the Ghostty refusal live.
+ * tmux > iterm > vscodium precedence and the Ghostty refusal live.
  */
 export function resolveInjectTargetForSession(session, opts = {}) {
     const prov = session.provenance;
@@ -77,11 +77,7 @@ export function resolveInjectTargetForSession(session, opts = {}) {
             target: { backend: 'vscodium', terminalId: session.sessionId, cli: variant.cli, scheme: variant.scheme },
         };
     }
-    // 4. pty — lowest precedence, only when the caller supplied a sidecar id.
-    if (opts.ptyId) {
-        return { addressable: true, rail: 'pty', target: { backend: 'pty', id: opts.ptyId } };
-    }
-    // 5. Ghostty — no per-split addressing exists. Refuse by default; the coarse,
+    // 4. Ghostty — no per-split addressing exists. Refuse by default; the coarse,
     //    focus-stealing window path is opt-in only.
     if (session.host === 'ghostty') {
         if (opts.allowGhosttyFocus) {