@phnx-labs/agents-cli 1.22.113 → 1.22.115

package/dist/lib/sync-status.d.ts

@@ -28,7 +28,7 @@ import { type ConfigDrift } from './config-drift.js';
  *  - `missing` — source exists, nothing installed in the version home ('missing').
  *  - `orphan`  — installed in the home with no source ('extra'); prune's job, not sync's.
  */
-export type ResourceSyncStatus = 'synced' | 'drifted' | 'missing' | 'orphan';
+type ResourceSyncStatus = 'synced' | 'drifted' | 'missing' | 'orphan';
 export interface ResourceStatusRow {
     agent: AgentId;
     version: string;
@@ -121,27 +121,13 @@ export declare function formatResidualDrift(residual: ResidualDrift[]): string[]
  * at, and `detail` says what differs when the differ knows.
  */
 export declare function formatDriftRows(v: AgentVersionStatus): string[];
-export interface SyncStatusOptions {
+interface SyncStatusOptions {
     cwd?: string;
     /** Restrict to specific agent ids; undefined = every supported agent. */
     agents?: AgentId[];
     /** Restrict to specific resource kinds; undefined = all. */
     kinds?: DoctorKind[];
 }
-/**
- * Read `.system` repo freshness WITHOUT touching the network. `git status`
- * reports ahead/behind against the remote-tracking ref, which the detached
- * auto-pull worker keeps warm via periodic `git fetch`. This is the same number
- * the menu-bar surfaces; we read it once, here, so every surface agrees.
- */
-export declare function getSystemRepoStatus(): Promise<SystemRepoStatus>;
-/**
- * Detect whether `~/.agents` (the user config layer) is git-backed. A partial
- * install — runtime state present but no `.git` (or no `origin`) — is a distinct
- * drift state that `agents repo sync user` heals by adopting in place (PHNX-3301),
- * surfaced separately from per-version resource gaps. Purely local; no network.
- */
-export declare function getUserRepoStatus(): Promise<UserRepoStatus>;
 /**
  * Compute unified sync status across the fleet. Resolves against non-project
  * layers only (`excludeProject: true`) — the GLOBAL version home is never
@@ -149,3 +135,4 @@ export declare function getUserRepoStatus(): Promise<UserRepoStatus>;
  * "missing" there would be a false gap (matches doctor's overview semantics).
  */
 export declare function computeSyncStatus(options?: SyncStatusOptions): Promise<UnifiedSyncStatus>;
+export {};

package/dist/lib/sync-status.js

@@ -93,7 +93,7 @@ function rowsFromReport(agent, version, report) {
  * auto-pull worker keeps warm via periodic `git fetch`. This is the same number
  * the menu-bar surfaces; we read it once, here, so every surface agrees.
  */
-export async function getSystemRepoStatus() {
+async function getSystemRepoStatus() {
     const dir = getSystemAgentsDir();
     const base = { dir, behind: 0, ahead: 0, branch: null, unknown: true };
     if (!isGitRepo(dir))
@@ -119,7 +119,7 @@ export async function getSystemRepoStatus() {
  * drift state that `agents repo sync user` heals by adopting in place (PHNX-3301),
  * surfaced separately from per-version resource gaps. Purely local; no network.
  */
-export async function getUserRepoStatus() {
+async function getUserRepoStatus() {
     const dir = getUserAgentsDir();
     if (!fs.existsSync(dir))
         return { dir, notGitRepo: false };

package/dist/lib/sync-umbrella.d.ts

@@ -15,6 +15,7 @@
  *               arrives with `agents secrets vault unlock`, #366/#367)
  *   reconcile-> refresh({ skipPrompts }) — re-materialize resources into homes
  */
+import type { ResourceSelection } from './installations/versions.js';
 /** The umbrella flags off `agents sync`. */
 export interface UmbrellaFlags {
     repos?: boolean;
@@ -23,7 +24,7 @@ export interface UmbrellaFlags {
     local?: boolean;
 }
 /** Which stages a given flag combination runs. */
-export interface UmbrellaPlan {
+interface UmbrellaPlan {
     fetchRepos: boolean;
     fetchSecrets: boolean;
     reconcile: boolean;
@@ -41,7 +42,7 @@ export interface UmbrellaPlan {
  * blast radius than the verb should carry by default.
  */
 export declare function planUmbrellaStages(f: UmbrellaFlags): UmbrellaPlan;
-export interface UmbrellaResult {
+interface UmbrellaResult {
     plan: UmbrellaPlan;
     repos?: {
         pulled: number;
@@ -74,7 +75,7 @@ export interface UmbrellaResult {
         version: string;
     }>;
 }
-export interface RunUmbrellaArgs {
+interface RunUmbrellaArgs {
     flags: UmbrellaFlags;
     /** Progress sink (already quiet-aware in the caller). */
     log: (msg: string) => void;
@@ -87,6 +88,10 @@ export interface RunUmbrellaArgs {
      * `agents sync --json` / fleet fan-out leave stdout as a single JSON object.
      */
     quiet?: boolean;
+    /** Optional resource-only reconcile across installed versions. */
+    selection?: ResourceSelection;
+    /** Explicit consent for selected plugins that add executable surfaces. */
+    allowExecSurfaces?: boolean;
 }
 /**
  * Execute the planned stages in order: repos -> secrets -> reconcile.
@@ -94,3 +99,4 @@ export interface RunUmbrellaArgs {
  * reconcile — `agents sync` should make as much current as it can in one pass.
  */
 export declare function runUmbrellaSync(args: RunUmbrellaArgs): Promise<UmbrellaResult>;
+export {};

package/dist/lib/sync-umbrella.js

@@ -53,7 +53,7 @@ export function planUmbrellaStages(f) {
  * reconcile — `agents sync` should make as much current as it can in one pass.
  */
 export async function runUmbrellaSync(args) {
-    const { flags, log, yes, passphrase, quiet = false } = args;
+    const { flags, log, yes, passphrase, quiet = false, selection, allowExecSurfaces = false } = args;
     const plan = planUmbrellaStages(flags);
     const result = { plan, reconciled: false, declined: [], reconciledVersions: [] };
     if (plan.fetchRepos) {
@@ -131,7 +131,13 @@ export async function runUmbrellaSync(args) {
     }
     if (plan.reconcile) {
         const { refresh } = await import('./refresh.js');
-        const refreshed = await refresh({ skipPrompts: yes, quiet });
+        const refreshed = await refresh({
+            skipPrompts: yes,
+            quiet,
+            skipClis: selection !== undefined,
+            selection,
+            allowExecSurfaces,
+        });
         result.reconciled = true;
         result.declined = refreshed.declined;
         result.reconciledVersions = refreshed.reconciled;
@@ -140,14 +146,16 @@ export async function runUmbrellaSync(args) {
         // rather than silently adding them (refresh mode). Soft: a machine without
         // tailscale is a clean no-op, never a sync failure. First-run population is
         // `agents setup` / manual `agents devices sync` (bootstrap).
-        const { runDeviceSync } = await import('./devices/sync.js');
-        const { reconcilePendingSentinels } = await import('./devices/pending.js');
-        const dev = await runDeviceSync({ soft: true, mode: 'refresh' });
-        if (dev.ok)
-            await reconcilePendingSentinels(dev.pending);
-        result.devices = { synced: dev.synced, pending: dev.pending.length, skipped: !dev.ok };
-        if (dev.ok) {
-            log(`devices: ${dev.synced} refreshed${dev.pending.length ? `, ${dev.pending.length} new pending` : ''}`);
+        if (!selection) {
+            const { runDeviceSync } = await import('./devices/sync.js');
+            const { reconcilePendingSentinels } = await import('./devices/pending.js');
+            const dev = await runDeviceSync({ soft: true, mode: 'refresh' });
+            if (dev.ok)
+                await reconcilePendingSentinels(dev.pending);
+            result.devices = { synced: dev.synced, pending: dev.pending.length, skipped: !dev.ok };
+            if (dev.ok) {
+                log(`devices: ${dev.synced} refreshed${dev.pending.length ? `, ${dev.pending.length} new pending` : ''}`);
+            }
         }
     }
     return result;

package/dist/lib/system-run-sync.d.ts

@@ -1,5 +1,5 @@
 import type { AgentId } from './types.js';
-export interface SystemRunSyncResult {
+interface SystemRunSyncResult {
     /** Names rewritten per kind; empty when the sentinel matched (skip-fast). */
     skills: string[];
     subagents: string[];
@@ -9,3 +9,4 @@ export interface SystemRunSyncResult {
  * their source directories changed since the last run for (agent, version).
  */
 export declare function applySystemResourcesAtRun(agent: AgentId, version: string, versionHome: string): SystemRunSyncResult;
+export {};

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

@@ -24,8 +24,6 @@ export declare enum AgentStatus {
  * bug — it swept live `pending` `--after` teammates past the 50-record cap.
  */
 export declare const TERMINAL_STATUSES: ReadonlySet<AgentStatus>;
-/** True when a teammate has reached a terminal (completed/failed/stopped) status. */
-export declare function isTerminalStatus(status: AgentStatus): boolean;
 export type TeammateFailureStage = 'placement' | 'spawn' | 'execution' | 'dependency' | 'cloud';
 /** Durable evidence observed at a concrete teammate lifecycle boundary. */
 export interface TeammateFailure {
@@ -48,7 +46,7 @@ export interface TeammateFailure {
  *     forever". Collapsing GONE into the empty-`.exit` case is exactly the bug
  *     that left a dead `--device` teammate RUNNING indefinitely.
  */
-export interface RemoteLivenessSnapshot {
+interface RemoteLivenessSnapshot {
     alive: boolean;
     exit: string | null;
     exitFilePresent: boolean;
@@ -145,7 +143,7 @@ export declare function checkAllClis(): Record<string, {
  */
 export declare function checkCliSignedIn(agentType: AgentType): Promise<boolean>;
 /** Advisory sign-in status for a `teams doctor` row. */
-export interface SignInAdvisory {
+interface SignInAdvisory {
     /** true / false from the probe, or null when the agent isn't installed. */
     signedIn: boolean | null;
     /** Whether the agent is currently a running teammate. */

package/dist/lib/teams/agents.js

@@ -147,7 +147,7 @@ export const TERMINAL_STATUSES = new Set([
     AgentStatus.STOPPED,
 ]);
 /** True when a teammate has reached a terminal (completed/failed/stopped) status. */
-export function isTerminalStatus(status) {
+function isTerminalStatus(status) {
     return TERMINAL_STATUSES.has(status);
 }
 function safeFailureMessage(message) {

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

@@ -11,7 +11,7 @@ import { type ForEachSpec, type ForEachTeammate } from '../workflows.js';
  * fabricates a phantom teammate. Pure and deterministic — no I/O.
  */
 export declare function parseProducedItems(stdout: string): string[];
-export interface ProduceItemsOptions {
+interface ProduceItemsOptions {
     /** Working directory for the producer command. */
     cwd?: string | null;
     /** Environment for the producer command (defaults to the current process env). */
@@ -49,7 +49,7 @@ export declare function produceItems(spec: ForEachSpec, opts?: ProduceItemsOptio
  */
 export declare function evaluateKeepIf(votes: boolean[], keepIf: 'majority' | 'all' | 'any'): boolean;
 /** Per-item verdict after tallying its verify panel. */
-export interface ForEachItemVerdict {
+interface ForEachItemVerdict {
     /** The produced item this verdict is for. */
     item: string;
     /** Zero-based index in the (capped) produced list. */
@@ -108,3 +108,4 @@ export interface RunForEachResult {
  * `keep_if` gate — that vote-counting lives downstream, not here).
  */
 export declare function runForEach(mgr: AgentManager, teamName: string, spec: ForEachSpec, items: string[], opts?: RunForEachOptions): Promise<RunForEachResult>;
+export {};

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>;