@phnx-labs/agents-cli 1.20.33 → 1.20.35

package/dist/lib/ssh-tunnel.js

@@ -22,7 +22,6 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { randomBytes } from 'crypto';
-import { Transform } from 'stream';
 import { sshExec, SSH_OPTS } from './ssh-exec.js';
 import { encodePowerShell } from './browser/drivers/ssh.js';
 import { getDevice } from './devices/registry.js';
@@ -30,19 +29,18 @@ import { sshTargetFor } from './devices/connect.js';
 import { hostNameFor } from './devices/ssh-config.js';
 import { getCacheDir } from './state.js';
 import { openComputerClient, resolveTcpEndpoint } from './computer-rpc.js';
-/** Build the ssh argv (after the `ssh` program name) for an `-L` tunnel. Pure. */
+/** Build the ssh argv (after the `ssh` program name) for an `-L` tunnel. Pure.
+ *
+ * Composes the shared hardened baseline (`SSH_OPTS`) rather than re-listing it,
+ * so the tunnel inherits the same options — crucially the keepalive, which lets
+ * a dropped `-N` tunnel exit instead of lingering as a zombie on the laptop. */
 export function buildTunnelArgs(user, host, localPort, remotePort) {
     return [
         '-L',
         `${localPort}:127.0.0.1:${remotePort}`,
         `${user}@${host}`,
         '-N',
-        '-o',
-        'StrictHostKeyChecking=accept-new',
-        '-o',
-        'BatchMode=yes',
-        '-o',
-        'ConnectTimeout=10',
+        ...SSH_OPTS,
     ];
 }
 /**
@@ -150,10 +148,15 @@ export async function resolveRemoteDevice(name) {
     return { device, target, user, host };
 }
 /**
- * PowerShell that streams base64 from stdin, decodes it incrementally to
- * %LOCALAPPDATA%\agents\computer-helper-win.exe, and stops any running instance
- * first so the file isn't locked. The CryptoStream/FromBase64Transform decode
- * is streaming — the ~156MB exe never lands in memory whole on the remote.
+ * Single-quote a string for embedding inside a PowerShell literal.
+ */
+function psSingleQuote(s) {
+    return "'" + s.replace(/'/g, "''") + "'";
+}
+/**
+ * PowerShell that resolves the destination under %LOCALAPPDATA%\agents and
+ * stops any running instance first so the file is not locked. The caller copies
+ * the exe with scp and then verifies the byte count separately.
  */
 export function buildPushScript() {
     return [
@@ -161,15 +164,18 @@ export function buildPushScript() {
         `New-Item -ItemType Directory -Force -Path $dir | Out-Null`,
         `$dst = Join-Path $dir '${WIN_HELPER_EXE}'`,
         `Get-Process -Name 'computer-helper-win' -ErrorAction SilentlyContinue | Stop-Process -Force -ErrorAction SilentlyContinue`,
-        `$si = [Console]::OpenStandardInput()`,
-        `$t = New-Object Security.Cryptography.FromBase64Transform`,
-        `$cs = New-Object Security.Cryptography.CryptoStream($si, $t, [Security.Cryptography.CryptoStreamMode]::Read)`,
-        `$fs = [IO.File]::Create($dst)`,
-        `$cs.CopyTo($fs)`,
-        `$fs.Close(); $cs.Close()`,
         `Write-Output $dst`,
     ].join('; ');
 }
+/** PowerShell that verifies scp wrote the expected number of bytes. */
+export function buildVerifyPushScript(remotePath, expectedBytes) {
+    return [
+        `$dst = ${psSingleQuote(remotePath)}`,
+        `$item = Get-Item -LiteralPath $dst -ErrorAction Stop`,
+        `if ($item.Length -ne ${expectedBytes}) { throw "helper copy length mismatch: expected ${expectedBytes}, got $($item.Length)" }`,
+        `Write-Output "$dst $($item.Length)"`,
+    ].join('; ');
+}
 /**
  * PowerShell that registers the daemon as a LOGON scheduled task. Interactive
  * logon type + Highest run level so the daemon runs in the real desktop session
@@ -195,51 +201,32 @@ export function buildUnregisterTaskScript(taskName) {
         `Get-Process -Name 'computer-helper-win' -ErrorAction SilentlyContinue | Stop-Process -Force -ErrorAction SilentlyContinue`,
     ].join('; ');
 }
+/** Convert a Windows path returned by PowerShell into the scp/SFTP path form. */
+export function scpRemotePath(remotePath) {
+    return remotePath.replace(/\\/g, '/');
+}
 /**
- * `setup --host`: push the exe, then register + start the LOGON task. Both hops
- * go through `sshExec` (BatchMode key auth — the same hardening the browser
- * driver and `agents ssh` use). Throws with the remote stderr on any failure.
- */
-/**
- * Base64-encode a byte stream in 3-byte-aligned chunks so the concatenated
- * output is valid (every chunk boundary lands on a base64 quantum).
+ * Build the scp argv used for the helper exe transfer. Exported so tests can
+ * assert the real binary copy path keeps BatchMode and does not route bytes
+ * through a PowerShell decoder.
  */
-class Base64Encode extends Transform {
-    leftover = Buffer.alloc(0);
-    _transform(chunk, _enc, cb) {
-        const buf = this.leftover.length ? Buffer.concat([this.leftover, chunk]) : chunk;
-        const usable = buf.length - (buf.length % 3);
-        this.leftover = Buffer.from(buf.subarray(usable));
-        if (usable > 0)
-            this.push(buf.subarray(0, usable).toString('base64'));
-        cb();
-    }
-    _flush(cb) {
-        if (this.leftover.length)
-            this.push(this.leftover.toString('base64'));
-        cb();
-    }
+export function buildScpArgs(target, remotePath, filePath) {
+    return [...SSH_OPTS, filePath, `${target}:${scpRemotePath(remotePath)}`];
 }
 /**
- * Stream a local file to a remote command's stdin over ssh, base64-encoded on
- * the fly. Async spawn + piping honors backpressure; the previous
- * `spawnSync({ input })` blob deadlocked once the ssh socket buffer filled
- * (~4MB) on large files (the 157MB Windows helper reproduced this reliably),
- * and worse, reported a false success leaving a 0-byte remote file. Rejects on
- * any pipe error so a broken transfer fails loudly instead.
+ * Copy a local file to the remote destination with scp. This is a binary
+ * transfer; no base64 transform runs on either side.
  */
-function streamFileOverSsh(target, remoteCmd, filePath, timeoutMs = 600_000) {
+function copyFileOverScp(target, remotePath, filePath, timeoutMs = 600_000) {
     return new Promise((resolve, reject) => {
-        const child = spawn('ssh', [...SSH_OPTS, target, remoteCmd], {
-            stdio: ['pipe', 'pipe', 'pipe'],
+        const child = spawn('scp', buildScpArgs(target, remotePath, filePath), {
+            stdio: ['ignore', 'ignore', 'pipe'],
         });
         let stderr = '';
-        let stdout = '';
         child.stderr.on('data', (d) => (stderr += d.toString()));
-        child.stdout.on('data', (d) => (stdout += d.toString()));
         const timer = setTimeout(() => {
             child.kill('SIGKILL');
-            reject(new Error(`ssh push to ${target} timed out after ${timeoutMs}ms`));
+            reject(new Error(`scp push to ${target} timed out after ${timeoutMs}ms`));
         }, timeoutMs);
         const fail = (e) => {
             clearTimeout(timer);
@@ -247,30 +234,41 @@ function streamFileOverSsh(target, remoteCmd, filePath, timeoutMs = 600_000) {
             reject(e);
         };
         child.on('error', fail);
-        child.stdin.on('error', fail); // EPIPE if the remote decoder dies mid-stream
         child.on('close', (code) => {
             clearTimeout(timer);
-            resolve({ code, stderr: stderr || stdout });
+            resolve({ code, stderr });
         });
-        const src = fs.createReadStream(filePath);
-        src.on('error', fail);
-        // disk -> aligned base64 -> ssh stdin; .pipe() applies backpressure
-        src.pipe(new Base64Encode()).pipe(child.stdin);
     });
 }
+/**
+ * `setup --host`: push the exe, then register + start the LOGON task. Remote
+ * PowerShell hops go through `sshExec` (BatchMode key auth — the same hardening
+ * the browser driver and `agents ssh` use), and the large exe rides a binary
+ * scp transfer. Throws with the remote stderr on any failure.
+ */
 export async function setupRemoteHelper(name) {
     const { target } = await resolveRemoteDevice(name);
     const exe = resolveWinHelperExe();
     if (!exe) {
         throw new Error(`Windows helper exe not built. Run: bash scripts/build-win.sh`);
     }
-    // Push: stream the exe from disk, base64-encoded on the fly, to the remote
-    // decoder. Streaming (vs a single spawnSync `input` blob) honors ssh socket
-    // backpressure — the blob path deadlocks once the socket buffer fills (~4MB).
-    const push = await streamFileOverSsh(target, encodePowerShell(buildPushScript()), exe);
+    const prep = sshExec(target, encodePowerShell(buildPushScript()), { timeoutMs: 60_000 });
+    if (prep.code !== 0) {
+        throw new Error(`preparing helper exe path on '${name}' failed (exit ${prep.code ?? 'null'}): ${prep.stderr.trim() || prep.stdout.trim()}`);
+    }
+    const remotePath = prep.stdout.trim().split(/\r?\n/).filter(Boolean).at(-1);
+    if (!remotePath) {
+        throw new Error(`preparing helper exe path on '${name}' did not return a destination path`);
+    }
+    const push = await copyFileOverScp(target, remotePath, exe);
     if (push.code !== 0) {
         throw new Error(`pushing helper exe to '${name}' failed (exit ${push.code ?? 'null'}): ${push.stderr.trim()}`);
     }
+    const expectedBytes = fs.statSync(exe).size;
+    const verify = sshExec(target, encodePowerShell(buildVerifyPushScript(remotePath, expectedBytes)), { timeoutMs: 60_000 });
+    if (verify.code !== 0) {
+        throw new Error(`verifying helper exe on '${name}' failed (exit ${verify.code ?? 'null'}): ${verify.stderr.trim() || verify.stdout.trim()}`);
+    }
     // Register + start the LOGON task.
     const reg = sshExec(target, encodePowerShell(buildRegisterTaskScript(REMOTE_HELPER_PORT, REMOTE_TASK_NAME)), {
         timeoutMs: 60_000,

package/dist/lib/staleness/writers/hooks.js

@@ -32,7 +32,7 @@ function buildHooksWriter(agent) {
             }
             // Native hook registration in settings.json/hooks.json. Grok auto-
             // discovers from ~/.grok/hooks/ so the file copy is sufficient.
-            if (agent === 'claude' || agent === 'codex' || agent === 'gemini' || agent === 'antigravity' || agent === 'kimi') {
+            if (agent === 'claude' || agent === 'codex' || agent === 'gemini' || agent === 'antigravity' || agent === 'kimi' || agent === 'droid') {
                 registerHooksToSettings(agent, versionHome);
             }
             return { synced };

package/dist/lib/startup/command-registry.d.ts

@@ -49,6 +49,7 @@ export declare const loadPrune: ModuleLoader;
 export declare const loadTrash: ModuleLoader;
 export declare const loadRestore: ModuleLoader;
 export declare const loadDoctor: ModuleLoader;
+export declare const loadStatus: ModuleLoader;
 export declare const loadProfiles: ModuleLoader;
 export declare const loadSecrets: ModuleLoader;
 export declare const loadWallet: ModuleLoader;
@@ -68,6 +69,8 @@ export declare const loadTmux: ModuleLoader;
 export declare const loadBrowser: ModuleLoader;
 export declare const loadComputer: ModuleLoader;
 export declare const loadHosts: ModuleLoader;
+export declare const loadLogs: ModuleLoader;
+export declare const loadEvents: ModuleLoader;
 export declare const loadSsh: ModuleLoader;
 export declare const loadPull: ModuleLoader;
 export declare const loadPush: ModuleLoader;

package/dist/lib/startup/command-registry.js

@@ -27,6 +27,7 @@ export const loadPrune = async () => (await import('../../commands/prune.js')).r
 export const loadTrash = async () => (await import('../../commands/trash.js')).registerTrashCommands;
 export const loadRestore = async () => (await import('../../commands/trash.js')).registerRestoreCommand;
 export const loadDoctor = async () => (await import('../../commands/doctor.js')).registerDoctorCommand;
+export const loadStatus = async () => (await import('../../commands/status.js')).registerStatusCommand;
 export const loadProfiles = async () => (await import('../../commands/profiles.js')).registerProfilesCommands;
 export const loadSecrets = async () => (await import('../../commands/secrets.js')).registerSecretsCommands;
 export const loadWallet = async () => (await import('../../commands/wallet.js')).registerWalletCommands;
@@ -46,6 +47,8 @@ export const loadTmux = async () => (await import('../../commands/tmux.js')).reg
 export const loadBrowser = async () => (await import('../../commands/browser.js')).registerBrowserCommand;
 export const loadComputer = async () => (await import('../../commands/computer.js')).registerComputerCommand;
 export const loadHosts = async () => (await import('../../commands/hosts.js')).registerHostsCommand;
+export const loadLogs = async () => (await import('../../commands/logs.js')).registerLogsCommand;
+export const loadEvents = async () => (await import('../../commands/events.js')).registerEventsCommand;
 export const loadSsh = async () => (await import('../../commands/ssh.js')).registerSshCommands;
 export const loadPull = async () => (await import('../../commands/pull.js')).registerPullCommand;
 export const loadPush = async () => (await import('../../commands/push.js')).registerPushCommand;
@@ -110,6 +113,7 @@ export const COMMAND_LOADERS = {
     trash: [loadTrash],
     restore: [loadRestore],
     doctor: [loadDoctor],
+    status: [loadStatus],
     profiles: [loadProfiles],
     secrets: [loadSecrets],
     wallet: [loadWallet],
@@ -129,6 +133,8 @@ export const COMMAND_LOADERS = {
     browser: [loadBrowser],
     computer: [loadComputer],
     hosts: [loadHosts],
+    logs: [loadLogs],
+    events: [loadEvents],
     ssh: [loadSsh],
     devices: [loadSsh],
     pull: [loadPull],

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

@@ -0,0 +1,102 @@
+/**
+ * Unified sync-status engine — the SINGLE source of truth for "is this resource
+ * synced to this agent version?" consumed by `agents doctor`, `agents view`, the
+ * menu-bar app, and any Agency surface.
+ *
+ * Why this exists: before this module there were four different notions of
+ * "synced" living in four files:
+ *   - doctor:  isStale() vs .sync-manifest.json  — catches SOURCE drift only.
+ *   - view:    git working-tree state of ~/.agents/ — a resource can show green
+ *              while its installed copy is stale/deleted/corrupted (false positive).
+ *   - lists:   file-exists-in-home — never reports content drift at all.
+ *   - menubar: read doctor --json (so it inherited doctor's source-only blind spot).
+ *
+ * The reliable signal is diffVersionResources() (src/lib/doctor-diff.ts): it reads
+ * the ACTUAL version home and compares it to the resolved sources, so it catches
+ * every drift class — source-side changes AND home-side rot (deleted / corrupted /
+ * hand-edited installed copies) AND orphans. This module wraps it once, maps its
+ * per-resource DiffStatus onto one stable enum, folds in `.system` repo freshness,
+ * and lets every surface render the same warnings instead of re-deriving them.
+ */
+import { AgentId } from './types.js';
+import { type DoctorKind } from './doctor-diff.js';
+/**
+ * One stable status per resource, unified across every surface.
+ *  - `synced`  — installed copy matches the resolved source (DiffStatus 'ok').
+ *  - `drifted` — installed copy exists but differs from source (DiffStatus 'diff').
+ *  - `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';
+export interface ResourceStatusRow {
+    agent: AgentId;
+    version: string;
+    kind: DoctorKind;
+    name: string;
+    status: ResourceSyncStatus;
+    /** Human-readable specifics for a drifted row (e.g. plugin version delta). */
+    detail?: string;
+}
+export interface AgentVersionStatus {
+    agent: AgentId;
+    version: string;
+    isDefault: boolean;
+    /** False = no .sync-manifest.json: this version was never synced (cold). */
+    everSynced: boolean;
+    counts: {
+        synced: number;
+        drifted: number;
+        missing: number;
+        orphan: number;
+    };
+    /** drifted + missing > 0 — a real reconcile is owed. Orphans do NOT set this
+     * (heal never deletes; orphan removal is `agents prune cleanup`). */
+    needsSync: boolean;
+    resources: ResourceStatusRow[];
+}
+export interface SystemRepoStatus {
+    dir: string;
+    /** Commits the local `.system` checkout is behind its tracking branch, as of
+     * the last background fetch (no network is performed here). 0 = up to date. */
+    behind: number;
+    ahead: number;
+    branch: string | null;
+    /** True when the dir isn't a git repo or has no upstream — behind is unknown. */
+    unknown: boolean;
+}
+export interface UnifiedSyncStatus {
+    system: SystemRepoStatus;
+    agents: AgentVersionStatus[];
+    totals: {
+        drifted: number;
+        missing: number;
+        orphan: number;
+        /** Versions with a manifest that are behind on content. */
+        versionsNeedingSync: number;
+        /** Versions that were never synced at all. */
+        versionsNeverSynced: number;
+        /** Distinct agent ids that own at least one version needing sync. */
+        agentsNeedingSync: number;
+    };
+}
+export 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>;
+/**
+ * Compute unified sync status across the fleet. Resolves against non-project
+ * layers only (`excludeProject: true`) — the GLOBAL version home is never
+ * reconciled against per-cwd `<cwd>/.agents/` resources, so counting them as
+ * "missing" there would be a false gap (matches doctor's overview semantics).
+ */
+export declare function computeSyncStatus(options?: SyncStatusOptions): Promise<UnifiedSyncStatus>;

package/dist/lib/sync-status.js

@@ -0,0 +1,135 @@
+/**
+ * Unified sync-status engine — the SINGLE source of truth for "is this resource
+ * synced to this agent version?" consumed by `agents doctor`, `agents view`, the
+ * menu-bar app, and any Agency surface.
+ *
+ * Why this exists: before this module there were four different notions of
+ * "synced" living in four files:
+ *   - doctor:  isStale() vs .sync-manifest.json  — catches SOURCE drift only.
+ *   - view:    git working-tree state of ~/.agents/ — a resource can show green
+ *              while its installed copy is stale/deleted/corrupted (false positive).
+ *   - lists:   file-exists-in-home — never reports content drift at all.
+ *   - menubar: read doctor --json (so it inherited doctor's source-only blind spot).
+ *
+ * The reliable signal is diffVersionResources() (src/lib/doctor-diff.ts): it reads
+ * the ACTUAL version home and compares it to the resolved sources, so it catches
+ * every drift class — source-side changes AND home-side rot (deleted / corrupted /
+ * hand-edited installed copies) AND orphans. This module wraps it once, maps its
+ * per-resource DiffStatus onto one stable enum, folds in `.system` repo freshness,
+ * and lets every surface render the same warnings instead of re-deriving them.
+ */
+import simpleGit from 'simple-git';
+import { ALL_AGENT_IDS } from './agents.js';
+import { diffVersionResources, } from './doctor-diff.js';
+import { listInstalledVersions, getGlobalDefault } from './versions.js';
+import { loadManifest } from './staleness/index.js';
+import { getSystemAgentsDir } from './state.js';
+import { isGitRepo } from './git.js';
+const STATUS_MAP = {
+    ok: 'synced',
+    diff: 'drifted',
+    missing: 'missing',
+    extra: 'orphan',
+};
+function rowsFromReport(agent, version, report) {
+    const out = [];
+    for (const list of Object.values(report.kinds)) {
+        for (const r of list) {
+            out.push({
+                agent,
+                version,
+                kind: r.kind,
+                name: r.name,
+                status: STATUS_MAP[r.status],
+                ...(r.detail ? { detail: r.detail } : {}),
+            });
+        }
+    }
+    return out;
+}
+/**
+ * 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 async function getSystemRepoStatus() {
+    const dir = getSystemAgentsDir();
+    const base = { dir, behind: 0, ahead: 0, branch: null, unknown: true };
+    if (!isGitRepo(dir))
+        return base;
+    try {
+        const status = await simpleGit(dir).status();
+        return {
+            dir,
+            behind: status.behind ?? 0,
+            ahead: status.ahead ?? 0,
+            branch: status.tracking ?? status.current ?? null,
+            // Without a tracking branch there's no upstream to compare against.
+            unknown: !status.tracking,
+        };
+    }
+    catch {
+        return base;
+    }
+}
+/**
+ * Compute unified sync status across the fleet. Resolves against non-project
+ * layers only (`excludeProject: true`) — the GLOBAL version home is never
+ * reconciled against per-cwd `<cwd>/.agents/` resources, so counting them as
+ * "missing" there would be a false gap (matches doctor's overview semantics).
+ */
+export async function computeSyncStatus(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const agentIds = options.agents ?? ALL_AGENT_IDS;
+    const agents = [];
+    for (const agent of agentIds) {
+        const def = getGlobalDefault(agent);
+        for (const version of listInstalledVersions(agent)) {
+            const report = diffVersionResources(agent, version, {
+                cwd,
+                excludeProject: true,
+                ...(options.kinds ? { kinds: options.kinds } : {}),
+            });
+            const resources = rowsFromReport(agent, version, report);
+            const counts = { synced: 0, drifted: 0, missing: 0, orphan: 0 };
+            for (const r of resources)
+                counts[r.status]++;
+            agents.push({
+                agent,
+                version,
+                isDefault: version === def,
+                everSynced: loadManifest(agent, version) !== null,
+                counts,
+                needsSync: counts.drifted + counts.missing > 0,
+                resources,
+            });
+        }
+    }
+    const system = await getSystemRepoStatus();
+    const agentsNeedingSync = new Set();
+    let drifted = 0, missing = 0, orphan = 0, versionsNeedingSync = 0, versionsNeverSynced = 0;
+    for (const v of agents) {
+        drifted += v.counts.drifted;
+        missing += v.counts.missing;
+        orphan += v.counts.orphan;
+        if (!v.everSynced)
+            versionsNeverSynced++;
+        if (v.needsSync) {
+            versionsNeedingSync++;
+            agentsNeedingSync.add(v.agent);
+        }
+    }
+    return {
+        system,
+        agents,
+        totals: {
+            drifted,
+            missing,
+            orphan,
+            versionsNeedingSync,
+            versionsNeverSynced,
+            agentsNeedingSync: agentsNeedingSync.size,
+        },
+    };
+}

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

@@ -68,6 +68,30 @@ export declare function checkAllClis(): Record<string, {
     path: string | null;
     error: string | null;
 }>;
+/**
+ * Advisory sign-in probe for a teammate's agent. Reads the account-global login
+ * (no `home` → active config) via `getAccountInfo`. Deliberately best-effort:
+ * sign-in detection is UNRELIABLE for opaque-credential agents (Kimi/Antigravity
+ * store an OAuth/JWT with no email claim) and for keychain-probed agents, so a
+ * `false` here is often a false negative. Callers must WARN and continue — never
+ * block a team on this result. Never throws (returns false on any error).
+ */
+export declare function checkCliSignedIn(agentType: AgentType): Promise<boolean>;
+/** Advisory sign-in status for a `teams doctor` row. */
+export 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. */
+    running: boolean;
+}
+/**
+ * Resolve the advisory sign-in status shown by `teams doctor`. An agent that is
+ * currently RUNNING in a team is live proof it works, so it overrides a
+ * (frequently false-negative) sign-in probe — doctor must never report a
+ * working agent as logged out. Not installed → `signedIn: null` (nothing to
+ * probe). Never flips the authoritative installed/ready column.
+ */
+export declare function resolveSignInAdvisory(installed: boolean, running: boolean, probeSignedIn: boolean): SignInAdvisory;
 /** Resolve and cache the base directory where teammate process data is stored. */
 export declare function getAgentsDir(): Promise<string>;
 /**

package/dist/lib/teams/agents.js

@@ -19,7 +19,7 @@ import { normalizeEvents } from './parsers.js';
 import { debug } from './debug.js';
 import { setGeminiAutoUpdateDisabled, updateGeminiSettings } from '../gemini-settings.js';
 import { getAgentsDir as getSystemAgentsDir, getShimsDir } from '../state.js';
-import { AGENTS } from '../agents.js';
+import { AGENTS, getAccountInfo } from '../agents.js';
 import { sanitizeProcessEnv } from '../secrets/bundles.js';
 let lastMemoryWarnAt = 0;
 // On macOS, os.freemem() returns only the truly-free pool and ignores the
@@ -353,6 +353,35 @@ export function checkAllClis() {
     }
     return results;
 }
+/**
+ * Advisory sign-in probe for a teammate's agent. Reads the account-global login
+ * (no `home` → active config) via `getAccountInfo`. Deliberately best-effort:
+ * sign-in detection is UNRELIABLE for opaque-credential agents (Kimi/Antigravity
+ * store an OAuth/JWT with no email claim) and for keychain-probed agents, so a
+ * `false` here is often a false negative. Callers must WARN and continue — never
+ * block a team on this result. Never throws (returns false on any error).
+ */
+export async function checkCliSignedIn(agentType) {
+    try {
+        const info = await getAccountInfo(agentType);
+        return info.signedIn;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolve the advisory sign-in status shown by `teams doctor`. An agent that is
+ * currently RUNNING in a team is live proof it works, so it overrides a
+ * (frequently false-negative) sign-in probe — doctor must never report a
+ * working agent as logged out. Not installed → `signedIn: null` (nothing to
+ * probe). Never flips the authoritative installed/ready column.
+ */
+export function resolveSignInAdvisory(installed, running, probeSignedIn) {
+    if (!installed)
+        return { signedIn: null, running: false };
+    return { signedIn: running ? true : probeSignedIn, running };
+}
 let AGENTS_DIR = null;
 /** Resolve and cache the base directory where teammate process data is stored. */
 export async function getAgentsDir() {

package/dist/lib/teams/registry.js

@@ -13,6 +13,7 @@ import * as path from 'path';
 import { randomBytes } from 'crypto';
 import lockfile from 'proper-lockfile';
 import { getTeamsRegistryPath } from '../state.js';
+import { emit } from '../events.js';
 async function registryPath() {
     return getTeamsRegistryPath();
 }
@@ -98,39 +99,50 @@ export async function createTeam(name, options) {
         throw new Error('Cannot use both --enable-worktrees and --use-worktree. Pick one.');
     }
     const p = await registryPath();
-    return withRegistryLock(p, async () => {
+    const meta = await withRegistryLock(p, async () => {
         const reg = await loadTeams();
         if (reg[name]) {
             throw new Error(`Team '${name}' already exists`);
         }
-        const meta = {
+        const m = {
             created_at: new Date().toISOString(),
             ...(options?.description ? { description: options.description } : {}),
             ...(options?.enableWorktrees ? { enable_worktrees: true } : {}),
             ...(options?.useWorktree ? { use_worktree: options.useWorktree } : {}),
         };
-        reg[name] = meta;
+        reg[name] = m;
         await saveTeams(reg);
-        return meta;
+        return m;
     });
+    // Audit the lifecycle boundary, not the CLI shell — captures every creation
+    // path (create + ensure) with team metadata the generic command log lacks.
+    emit('teams.create', { module: 'teams', team: name, worktrees: Boolean(options?.enableWorktrees || options?.useWorktree) });
+    return meta;
 }
 /** Return existing team metadata or create a new team if it does not exist. */
 export async function ensureTeam(name) {
     const p = await registryPath();
-    return withRegistryLock(p, async () => {
+    let created = false;
+    const meta = await withRegistryLock(p, async () => {
         const reg = await loadTeams();
         if (reg[name])
             return reg[name];
-        const meta = { created_at: new Date().toISOString() };
-        reg[name] = meta;
+        const m = { created_at: new Date().toISOString() };
+        reg[name] = m;
         await saveTeams(reg);
-        return meta;
+        created = true;
+        return m;
     });
+    // `teams add` auto-creates the team on first teammate — audit that creation
+    // too, but only when it actually happened (not the get-existing path).
+    if (created)
+        emit('teams.create', { module: 'teams', team: name, worktrees: false });
+    return meta;
 }
 /** Remove a team from the registry. Returns false if the team did not exist. */
 export async function removeTeam(name) {
     const p = await registryPath();
-    return withRegistryLock(p, async () => {
+    const existed = await withRegistryLock(p, async () => {
         const reg = await loadTeams();
         if (!reg[name])
             return false;
@@ -138,6 +150,10 @@ export async function removeTeam(name) {
         await saveTeams(reg);
         return true;
     });
+    // "Disband" — only fires when a real team was removed, not a no-op.
+    if (existed)
+        emit('teams.disband', { module: 'teams', team: name });
+    return existed;
 }
 /** Check whether a team with the given name exists in the registry. */
 export async function teamExists(name) {

package/dist/lib/terminal/backends/ghostty.d.ts

@@ -0,0 +1,6 @@
+import type { TerminalBackend, SplitDirection } from '../types.js';
+/** AppleScript that opens a Ghostty tab (a window if none is open). */
+export declare function ghosttyTabScript(cwd: string, command: string[]): string;
+/** AppleScript that splits the current Ghostty surface (a window if none is open). */
+export declare function ghosttySplitScript(cwd: string, command: string[], direction: SplitDirection): string;
+export declare const ghosttyBackend: TerminalBackend;