@phnx-labs/agents-cli 1.22.41 → 1.22.43

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

@@ -1,14 +1,14 @@
 const LOADED_COMMAND_NAMES = [
-    'accounts', 'view', 'inspect', 'feedback', 'commands', 'hooks', 'skills', 'rules', 'memory',
+    'accounts', 'auth', 'org', 'view', 'inspect', 'feedback', 'commands', 'hooks', 'skills', 'rules', 'memory',
     'permissions', 'mcp', 'clis', 'subagents', 'plugins', 'workflows', 'add', 'use', 'list',
     'remove', 'rm', 'purge', 'update', 'prune', 'import', 'registry', 'search', 'install',
     'routines', 'monitors', 'projects', 'run', 'open', 'reconnect', 'fork', 'config',
-    'models', 'modes', 'trash', 'restore', 'doctor', 'apply', 'status',
+    'models', 'modes', 'trash', 'restore', 'doctor', 'apply',
     'route', 'harness', 'harnesses', 'secrets', 'menubar', 'beta', 'sync',
     'refresh-rules', 'factory', 'usage', 'insights', 'perf', 'trends',
-    'alias', 'pty', 'tmux', 'watchdog', 'browser', 'computer', 'logs', 'events',
+    'pty', 'tmux', 'watchdog', 'browser', 'computer', 'logs', 'events',
     'ssh', 'devices', 'fleet', 'repos', 'repo', 'setup', 'uninstall', 'upgrade', 'sessions',
-    'teams', 'tickets', 'cloud', 'message', 'send', 'notify', 'feed', 'inbox',
+    'teams', 'cloud', 'message', 'send', 'notify', 'feed',
     'mailboxes', 'mailbox', 'serve', 'artifacts', 'unshare', 'audit', 'webhooks',
     'humans', 'daemon',
 ];
@@ -41,7 +41,10 @@ export const KNOWN_TOP_LEVEL_COMMANDS = new Set([
  * under `agents artifacts share` (RUSH-2580). login/logout/budget/bench/mine/
  * cost/output/profiles/snapshot/cp/resume/roster moved under nested homes
  * (cli-surface-consolidate). `timeline` was removed as a duplicated surface —
- * use `agents feed --filter updates` (RUSH-2692).
+ * use `agents feed --filter updates` (RUSH-2692). `status` moved under
+ * `agents sync status` (RUSH-2864). `tickets` was removed — use `linear`
+ * (linear-cli) (RUSH-2932). `alias` moved under `agents setup alias` (RUSH-2965).
+ * `inbox` was a pure alias of `agents feed` (RUSH-2984).
  */
 export const RETIRED_TOP_LEVEL_COMMANDS = new Set([
     'webhook',
@@ -60,6 +63,10 @@ export const RETIRED_TOP_LEVEL_COMMANDS = new Set([
     'set',
     'share',
     'timeline',
+    'status',
+    'tickets',
+    'alias',
+    'inbox',
 ]);
 export function isKnownTopLevelCommand(name) {
     return KNOWN_TOP_LEVEL_COMMANDS.has(name);

package/dist/lib/teams/agents.js

@@ -34,6 +34,7 @@ import { resolveRemoteOsSync } from '../hosts/remote-os.js';
 import { pullRemoteLogDelta, REMOTE_MIRROR_MAX_BYTES } from '../hosts/progress.js';
 import { createRemoteWorktree, ensureRemoteRepo } from './remoteWorktree.js';
 import { getTeam, isTeamDisbanded } from './registry.js';
+import { atomicWriteJsonSync } from '../fs-atomic.js';
 import { resolvePlacement, classifyExclusions, NoViableDeviceError } from './scheduler.js';
 import { probePoolSignals } from './placement-probe.js';
 import { readMaxConcurrentCaps } from '../device-config.js';
@@ -321,24 +322,6 @@ function extractTimestamp(raw) {
     }
     return null;
 }
-/**
- * Atomic JSON write: writes to a unique sibling tmp file then renames over the
- * target. rename(2) is atomic on POSIX, so a process killed mid-write leaves
- * either the previous valid meta.json or the new one, never a torn,
- * unparseable file (RUSH-2429). Mirrors the identical pattern already used by
- * `teams/registry.ts`'s `atomicWriteJson`.
- */
-async function atomicWriteJson(p, data) {
-    const tmp = `${p}.tmp.${process.pid}.${randomUUID()}`;
-    await fs.writeFile(tmp, JSON.stringify(data, null, 2));
-    try {
-        await fs.rename(tmp, p);
-    }
-    catch (err) {
-        await fs.unlink(tmp).catch(() => { });
-        throw err;
-    }
-}
 /** Resolve a mode string to a validated Mode, falling back to the given default. */
 export function resolveMode(requestedMode, defaultMode = 'plan') {
     const normalizedDefault = normalizeModeValue(defaultMode);
@@ -1011,7 +994,7 @@ export class AgentProcess {
             remote_log_offset: this.remoteLogOffset,
         };
         const metaPath = await this.getMetaPath();
-        await atomicWriteJson(metaPath, meta);
+        atomicWriteJsonSync(metaPath, meta);
     }
     /**
      * Rename an unreadable meta.json out of the way so it stops silently

package/dist/lib/teams/parsers.js

@@ -9,34 +9,28 @@
 import { extractFileOpsFromBash } from './file_ops.js';
 const claudeToolUseMap = new Map();
 const droidToolUseMap = new Map();
+/**
+ * Registry-dispatch table: each teams `AgentType` to its live team-event
+ * normalizer. Replaces the per-type name-chain — the harness axis of Move 3.
+ * warp (and any unlisted type) is absent, so it falls through to the generic
+ * unknown-event shape below, exactly as the old `else` did.
+ */
+const TEAM_EVENT_NORMALIZERS = {
+    codex: normalizeCodex,
+    cursor: normalizeCursor,
+    gemini: normalizeGemini,
+    claude: normalizeClaude,
+    opencode: normalizeOpencode,
+    grok: normalizeGrok,
+    antigravity: normalizeAntigravity,
+    kimi: normalizeKimi,
+    droid: normalizeDroid,
+};
 /** Normalize a raw JSON event from any agent type into an array of unified event objects. */
 export function normalizeEvents(agentType, raw) {
-    if (agentType === 'codex') {
-        return normalizeCodex(raw);
-    }
-    else if (agentType === 'cursor') {
-        return normalizeCursor(raw);
-    }
-    else if (agentType === 'gemini') {
-        return normalizeGemini(raw);
-    }
-    else if (agentType === 'claude') {
-        return normalizeClaude(raw);
-    }
-    else if (agentType === 'opencode') {
-        return normalizeOpencode(raw);
-    }
-    else if (agentType === 'grok') {
-        return normalizeGrok(raw);
-    }
-    else if (agentType === 'antigravity') {
-        return normalizeAntigravity(raw);
-    }
-    else if (agentType === 'kimi') {
-        return normalizeKimi(raw);
-    }
-    else if (agentType === 'droid') {
-        return normalizeDroid(raw);
+    const normalizer = TEAM_EVENT_NORMALIZERS[agentType];
+    if (normalizer) {
+        return normalizer(raw);
     }
     const timestamp = new Date().toISOString();
     return [{

package/dist/lib/teams/placement-probe.js

@@ -26,7 +26,7 @@ import { probeFleetStats, headroom } from '../devices/health.js';
 import { loadDevicesSync } from '../devices/registry.js';
 import { buildSshInvocation, writeAskpassShim } from '../devices/connect.js';
 import { buildReadyProbeCommand, parseReadyProbe, viewAgentSignedIn, viewHasAgent, } from '../hosts/ready.js';
-import { localMachineId } from '../session/origin-machine.js';
+import { localMachineId } from '../origin-machine.js';
 import { normalizeHost } from '../machine-id.js';
 import { checkCliAvailable, checkCliSignedIn } from './agents.js';
 /** Per-remote readiness probe budget — matches the health probe's short window

package/dist/lib/teams/registry.js

@@ -10,32 +10,13 @@
 import * as fs from 'fs/promises';
 import * as fsSync from 'fs';
 import * as path from 'path';
-import { randomBytes } from 'crypto';
 import lockfile from 'proper-lockfile';
 import { getTeamsRegistryPath } from '../state.js';
 import { emit } from '../feed/events.js';
+import { atomicWriteJsonSync } from '../fs-atomic.js';
 async function registryPath() {
     return getTeamsRegistryPath();
 }
-/**
- * Atomic JSON write: writes to a unique sibling tmp file then renames over
- * the target. rename(2) is atomic on POSIX, so a crashed write leaves the
- * old file untouched instead of producing a half-written registry that
- * loadTeams() would reject.
- */
-async function atomicWriteJson(p, data) {
-    await fs.mkdir(path.dirname(p), { recursive: true });
-    const tmp = `${p}.tmp.${process.pid}.${randomBytes(4).toString('hex')}`;
-    const body = JSON.stringify(data, null, 2);
-    await fs.writeFile(tmp, body);
-    try {
-        await fs.rename(tmp, p);
-    }
-    catch (err) {
-        await fs.unlink(tmp).catch(() => { });
-        throw err;
-    }
-}
 /**
  * Run `fn` while holding an exclusive cross-process lock on the registry
  * file. proper-lockfile requires the target to exist, so we touch it first.
@@ -91,7 +72,7 @@ export async function loadTeams() {
 }
 async function saveTeams(reg) {
     const p = await registryPath();
-    await atomicWriteJson(p, reg);
+    atomicWriteJsonSync(p, reg);
 }
 /** Create a new team. Throws if a team with the same name already exists. */
 export async function createTeam(name, options) {

package/dist/lib/teams/scheduler.js

@@ -34,7 +34,7 @@
  * resolves to a null placement so the existing local spawn path runs unchanged,
  * letting the local machine participate in a pool as just another member.
  */
-import { machineId } from '../session/sync/config.js';
+import { machineId } from '../machine-id.js';
 /**
  * No device in the pool can host the teammate. Carries the per-device reasons so
  * the caller can print exactly why the pool is unusable instead of silently

package/dist/lib/text/relative-time.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Human-readable "time since" formatting for session timestamps. Lives here (not
+ * inline in `sessions.ts`) so both the session list renderer and the remote
+ * offline-cache banner (`remote.ts`) share one formatter — `sessions.ts` imports
+ * `remote.ts`, so a back-import would cycle.
+ */
+export declare function formatRelativeTime(isoTimestamp: string): string;
+/**
+ * Compact age — `now`, `45m`, `3h`, `2d`, then the calendar date. This is the
+ * *creation* half of a session's time cell: it renders right next to the long
+ * last-activity label, and one row can afford one long form, not two.
+ */
+export declare function formatCompactAge(isoTimestamp: string): string;
+/** The two time fields a session listing shows for one row. */
+export interface SessionAgeParts {
+    /**
+     * Compact age of the session's creation, set only when the session ran long
+     * enough (>= a minute) for it to say something `last` does not.
+     */
+    created?: string;
+    /** Last-activity label — the long relative form the listing sorts by. */
+    last: string;
+}
+/**
+ * Split a session's timestamps into the two fields a listing renders: when it
+ * was created and when it was last active. One last-activity label answers
+ * neither "is this the old session I'm looking for" nor "how long did it run" —
+ * a session touched an hour ago may have started last week.
+ */
+export declare function sessionAgeParts(createdIso: string, lastActivityIso?: string): SessionAgeParts;
+/**
+ * Parse a time filter string (relative like '7d' or an ISO timestamp) into epoch
+ * milliseconds. Backs `--since` on `sessions`, `cost`, `teams`, and `output`, and
+ * `--unused` on `secrets list`.
+ *
+ * It lives here, in a module with no imports, rather than in `discover.ts` where
+ * it started: `discover.ts` loads `../sqlite.js`, so importing this one function
+ * from there pulls `node:sqlite` into the caller's module graph and Node prints
+ * `ExperimentalWarning: SQLite …` on stderr. That is invisible in a command that
+ * already touches the session DB, and a broken contract in one that doesn't —
+ * `monitors --json` asserts a clean stderr. `discover.ts` re-exports it, so
+ * existing importers are unaffected.
+ */
+export declare function parseTimeFilter(input: string): number;

package/dist/lib/text/relative-time.js

@@ -0,0 +1,120 @@
+/**
+ * Human-readable "time since" formatting for session timestamps. Lives here (not
+ * inline in `sessions.ts`) so both the session list renderer and the remote
+ * offline-cache banner (`remote.ts`) share one formatter — `sessions.ts` imports
+ * `remote.ts`, so a back-import would cycle.
+ */
+const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+/**
+ * Calendar label for a timestamp older than the relative window. A 2-digit year
+ * is appended outside the current year so "Jun 28" is never ambiguous across
+ * years (e.g. "Jun 28 '25").
+ */
+function calendarLabel(thenMs, nowMs) {
+    const d = new Date(thenMs);
+    const label = `${MONTHS[d.getMonth()]} ${d.getDate()}`;
+    return d.getFullYear() === new Date(nowMs).getFullYear()
+        ? label
+        : `${label} '${String(d.getFullYear()).slice(-2)}`;
+}
+export function formatRelativeTime(isoTimestamp) {
+    const now = Date.now();
+    const then = new Date(isoTimestamp).getTime();
+    if (isNaN(then))
+        return isoTimestamp;
+    const diffMs = now - then;
+    const diffMin = Math.floor(diffMs / 60_000);
+    const diffHrs = Math.floor(diffMs / 3_600_000);
+    const diffDays = Math.floor(diffMs / 86_400_000);
+    if (diffMin < 1)
+        return 'just now';
+    if (diffMin < 60)
+        return `${diffMin} min ago`;
+    if (diffHrs < 24)
+        return `${diffHrs} hour${diffHrs === 1 ? '' : 's'} ago`;
+    if (diffDays < 7)
+        return `${diffDays} day${diffDays === 1 ? '' : 's'} ago`;
+    // Older: show the date.
+    return calendarLabel(then, now);
+}
+/**
+ * Compact age — `now`, `45m`, `3h`, `2d`, then the calendar date. This is the
+ * *creation* half of a session's time cell: it renders right next to the long
+ * last-activity label, and one row can afford one long form, not two.
+ */
+export function formatCompactAge(isoTimestamp) {
+    const now = Date.now();
+    const then = new Date(isoTimestamp).getTime();
+    if (isNaN(then))
+        return isoTimestamp;
+    const diffMs = now - then;
+    const diffMin = Math.floor(diffMs / 60_000);
+    const diffHrs = Math.floor(diffMs / 3_600_000);
+    const diffDays = Math.floor(diffMs / 86_400_000);
+    if (diffMin < 1)
+        return 'now';
+    if (diffMin < 60)
+        return `${diffMin}m`;
+    if (diffHrs < 24)
+        return `${diffHrs}h`;
+    if (diffDays < 7)
+        return `${diffDays}d`;
+    return calendarLabel(then, now);
+}
+/**
+ * Shortest creation→last-activity gap worth rendering as two fields. Below it
+ * both halves name the same minute, so the row would carry a duplicate instead
+ * of information.
+ */
+const SPAN_MIN_MS = 60_000;
+/**
+ * Split a session's timestamps into the two fields a listing renders: when it
+ * was created and when it was last active. One last-activity label answers
+ * neither "is this the old session I'm looking for" nor "how long did it run" —
+ * a session touched an hour ago may have started last week.
+ */
+export function sessionAgeParts(createdIso, lastActivityIso) {
+    const lastIso = lastActivityIso ?? createdIso;
+    const last = formatRelativeTime(lastIso);
+    const createdMs = new Date(createdIso).getTime();
+    const lastMs = new Date(lastIso).getTime();
+    if (isNaN(createdMs) || isNaN(lastMs) || lastMs - createdMs < SPAN_MIN_MS)
+        return { last };
+    return { created: formatCompactAge(createdIso), last };
+}
+/**
+ * Parse a time filter string (relative like '7d' or an ISO timestamp) into epoch
+ * milliseconds. Backs `--since` on `sessions`, `cost`, `teams`, and `output`, and
+ * `--unused` on `secrets list`.
+ *
+ * It lives here, in a module with no imports, rather than in `discover.ts` where
+ * it started: `discover.ts` loads `../sqlite.js`, so importing this one function
+ * from there pulls `node:sqlite` into the caller's module graph and Node prints
+ * `ExperimentalWarning: SQLite …` on stderr. That is invisible in a command that
+ * already touches the session DB, and a broken contract in one that doesn't —
+ * `monitors --json` asserts a clean stderr. `discover.ts` re-exports it, so
+ * existing importers are unaffected.
+ */
+export function parseTimeFilter(input) {
+    // Units: m=minute, h=hour, d=day, w=week, mo=month(30d), y=year(365d). `mo`
+    // must precede the single-letter alternatives so "1mo" isn't read as "1m"+"o".
+    const relativeMatch = input.match(/^(\d+)(mo|[mhdwy])$/i);
+    if (relativeMatch) {
+        const value = parseInt(relativeMatch[1], 10);
+        const unit = relativeMatch[2].toLowerCase();
+        if (unit === 'm')
+            return Date.now() - value * 60_000;
+        if (unit === 'h')
+            return Date.now() - value * 3_600_000;
+        if (unit === 'd')
+            return Date.now() - value * 86_400_000;
+        if (unit === 'w')
+            return Date.now() - value * 7 * 86_400_000;
+        if (unit === 'mo')
+            return Date.now() - value * 30 * 86_400_000;
+        if (unit === 'y')
+            return Date.now() - value * 365 * 86_400_000;
+    }
+    const ts = new Date(input).getTime();
+    return Number.isNaN(ts) ? 0 : ts;
+}

package/dist/lib/text/short-id.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Canonical derivation of a session's 8-char `shortId`.
+ *
+ * Every session parser used to inline `id.slice(0, 8)` — some with a
+ * `.replace(prefix, '')` strip first (`session_`, `api-`, `ses_`). That strip is
+ * the bug: an id that is *only* its prefix (a bare `session_` directory, an id of
+ * exactly `api-`) strips to `''`, and `''.slice(0, 8)` is still `''`. An empty
+ * shortId then passes the `short_id TEXT NOT NULL` constraint (empty string is not
+ * NULL) yet matches nothing in the `short_id LIKE ?` picker lookups — a silently
+ * corrupt index row.
+ *
+ * This helper is the single source of truth: it strips the optional prefix, takes
+ * the first 8 chars, and — the whole point — guarantees a NON-EMPTY result by
+ * falling back to the unstripped id when the strip empties it, so a row always
+ * stays addressable by its shortId.
+ */
+export declare function deriveShortId(id: string, stripPrefix?: RegExp): string;

package/dist/lib/text/short-id.js

@@ -0,0 +1,20 @@
+/**
+ * Canonical derivation of a session's 8-char `shortId`.
+ *
+ * Every session parser used to inline `id.slice(0, 8)` — some with a
+ * `.replace(prefix, '')` strip first (`session_`, `api-`, `ses_`). That strip is
+ * the bug: an id that is *only* its prefix (a bare `session_` directory, an id of
+ * exactly `api-`) strips to `''`, and `''.slice(0, 8)` is still `''`. An empty
+ * shortId then passes the `short_id TEXT NOT NULL` constraint (empty string is not
+ * NULL) yet matches nothing in the `short_id LIKE ?` picker lookups — a silently
+ * corrupt index row.
+ *
+ * This helper is the single source of truth: it strips the optional prefix, takes
+ * the first 8 chars, and — the whole point — guarantees a NON-EMPTY result by
+ * falling back to the unstripped id when the strip empties it, so a row always
+ * stays addressable by its shortId.
+ */
+export function deriveShortId(id, stripPrefix) {
+    const stripped = stripPrefix ? id.replace(stripPrefix, '') : id;
+    return stripped.slice(0, 8) || id.slice(0, 8) || id;
+}

package/dist/lib/text/width.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Terminal display-width helpers.
+ *
+ * `String.length` is the wrong ruler for a terminal: it over-counts ANSI colour
+ * escapes (chalk output) and under-counts wide glyphs (CJK, emoji) which occupy
+ * two cells. The result is the drifting, wrapping session-table line users see
+ * under tmux and over `--device` SSH. Every renderer that sizes a session-table
+ * cell measures and truncates through this module so alignment is computed once,
+ * correctly, from the same source of truth.
+ */
+/** Strip SGR colour + OSC-8 hyperlink escapes so width is measured on visible characters only. */
+export declare function stripAnsi(s: string): string;
+/** Visible display width of a string, ANSI-aware and wide-char-aware. */
+export declare function stringWidth(s: string): number;
+/**
+ * Truncate to a target display width, appending '…' when shortened. Operates on
+ * the visible (ANSI-stripped) string; callers colour the result afterwards so
+ * the ellipsis is never inserted mid-escape.
+ */
+export declare function truncateToWidth(s: string, max: number): string;
+/** Right-pad with spaces to a target display width. Never truncates. */
+export declare function padToWidth(s: string, width: number): string;
+/**
+ * Effective terminal width. Reads `$COLUMNS` first so it survives tmux and
+ * `--device` SSH (where `process.stdout.columns` is unset or wrong), falls back to
+ * the TTY's reported width, then to `fallback`. Clamped to a sane band so a
+ * bogus value can't produce a 0-wide or absurdly long table.
+ */
+export declare function terminalWidth(fallback?: number): number;

package/dist/lib/text/width.js

@@ -0,0 +1,101 @@
+/**
+ * Terminal display-width helpers.
+ *
+ * `String.length` is the wrong ruler for a terminal: it over-counts ANSI colour
+ * escapes (chalk output) and under-counts wide glyphs (CJK, emoji) which occupy
+ * two cells. The result is the drifting, wrapping session-table line users see
+ * under tmux and over `--device` SSH. Every renderer that sizes a session-table
+ * cell measures and truncates through this module so alignment is computed once,
+ * correctly, from the same source of truth.
+ */
+/** SGR colour sequences emitted by chalk (e.g. `\x1b[32m`). */
+const SGR_REGEX = /\x1b\[[0-9;]*m/g;
+/**
+ * OSC-8 hyperlink sequences (`\x1b]8;;<url>\x1b\\` … `\x1b]8;;\x1b\\`, or with a
+ * BEL `\x07` terminator) emitted by `osc8()` in render.ts for clickable
+ * ticket/PR/path badges. These carry the URL, which is NOT visible — leaving it
+ * in over-counts width and, worse, lets a truncation land *inside* the escape and
+ * corrupt it. Stripping both the opener and closer leaves only the visible label
+ * between them, so width is measured on what the user sees and `truncateToWidth`
+ * can never cut a hyperlink in half.
+ */
+const OSC8_REGEX = /\x1b\]8;[^;]*;.*?(?:\x1b\\|\x07)/g;
+/** Strip SGR colour + OSC-8 hyperlink escapes so width is measured on visible characters only. */
+export function stripAnsi(s) {
+    return s.replace(OSC8_REGEX, '').replace(SGR_REGEX, '');
+}
+/**
+ * Display cells for one code point: 0 for zero-width combining/ZWJ/variation
+ * selectors, 2 for East-Asian-wide and emoji ranges, 1 otherwise. Compact and
+ * dependency-free — covers the glyphs that actually show up in prompts/titles.
+ */
+function charWidth(cp) {
+    if (cp === 0)
+        return 0;
+    // Zero-width: combining marks, zero-width joiner, variation selectors.
+    if ((cp >= 0x0300 && cp <= 0x036f) ||
+        cp === 0x200b || cp === 0x200d ||
+        (cp >= 0xfe00 && cp <= 0xfe0f))
+        return 0;
+    // Wide (2 cells): CJK, Hangul, fullwidth forms, emoji & pictographs.
+    if ((cp >= 0x1100 && cp <= 0x115f) || // Hangul Jamo
+        (cp >= 0x2e80 && cp <= 0xa4cf) || // CJK radicals … Yi
+        (cp >= 0xac00 && cp <= 0xd7a3) || // Hangul syllables
+        (cp >= 0xf900 && cp <= 0xfaff) || // CJK compatibility ideographs
+        (cp >= 0xfe30 && cp <= 0xfe4f) || // CJK compatibility forms
+        (cp >= 0xff00 && cp <= 0xff60) || // Fullwidth forms
+        (cp >= 0xffe0 && cp <= 0xffe6) || // Fullwidth signs
+        (cp >= 0x1f300 && cp <= 0x1faff) || // emoji & symbols
+        (cp >= 0x20000 && cp <= 0x3fffd) // CJK Ext-B and beyond
+    )
+        return 2;
+    return 1;
+}
+/** Visible display width of a string, ANSI-aware and wide-char-aware. */
+export function stringWidth(s) {
+    const plain = stripAnsi(s);
+    let w = 0;
+    for (const ch of plain)
+        w += charWidth(ch.codePointAt(0));
+    return w;
+}
+/**
+ * Truncate to a target display width, appending '…' when shortened. Operates on
+ * the visible (ANSI-stripped) string; callers colour the result afterwards so
+ * the ellipsis is never inserted mid-escape.
+ */
+export function truncateToWidth(s, max) {
+    if (max <= 0)
+        return '';
+    const plain = stripAnsi(s);
+    if (stringWidth(plain) <= max)
+        return plain;
+    let w = 0;
+    let out = '';
+    for (const ch of plain) {
+        const cw = charWidth(ch.codePointAt(0));
+        if (w + cw > max - 1)
+            break; // reserve one cell for the ellipsis
+        out += ch;
+        w += cw;
+    }
+    return out + '…';
+}
+/** Right-pad with spaces to a target display width. Never truncates. */
+export function padToWidth(s, width) {
+    const pad = width - stringWidth(s);
+    return pad > 0 ? s + ' '.repeat(pad) : s;
+}
+/**
+ * Effective terminal width. Reads `$COLUMNS` first so it survives tmux and
+ * `--device` SSH (where `process.stdout.columns` is unset or wrong), falls back to
+ * the TTY's reported width, then to `fallback`. Clamped to a sane band so a
+ * bogus value can't produce a 0-wide or absurdly long table.
+ */
+export function terminalWidth(fallback = 100) {
+    const env = Number.parseInt(process.env.COLUMNS ?? '', 10);
+    const raw = Number.isFinite(env) && env > 0
+        ? env
+        : (process.stdout.columns || fallback);
+    return Math.max(60, Math.min(200, raw));
+}

package/dist/lib/triggers/handlers.d.ts

@@ -116,6 +116,13 @@ export interface SlackMessageContext {
     user: string;
     /** Slash command name (`/agents`), or '' for an event delivery. */
     command: string;
+    /**
+     * Slash-command reply URL (`https://hooks.slack.com/commands/…`), or '' for an
+     * event delivery. Slack accepts a POST here for 30 minutes with no token and no
+     * channel membership, so it is the only reply path that works before the app has
+     * been invited to a channel.
+     */
+    response_url: string;
 }
 /**
  * Split a Slack message into a `{{slack.*}}` context. Strips a leading bot

package/dist/lib/triggers/handlers.js

@@ -294,6 +294,7 @@ export function parseSlackMessage(payload) {
         thread_ts: asString(payload.thread_ts),
         user: asString(payload.user),
         command: asString(payload.command),
+        response_url: asString(payload.response_url),
     };
 }
 /**
@@ -352,7 +353,7 @@ function dispatchDefault(config) {
     // Import lazily so the runner module (heavy) is only loaded when a handler
     // actually needs to spawn. Tests inject dispatch functions, so this path is
     // not exercised in unit tests.
-    return import('../runner.js').then((m) => m.executeJobDetached(config));
+    return import('../daemon/runner.js').then((m) => m.executeJobDetached(config));
 }
 /**
  * Execute a handler's action. Runs the configured agent/workflow/command or
@@ -414,6 +415,13 @@ async function executeHandlerAction(handler, webhook, context, opts) {
             ...(substitutedCwd ? { cwd: substitutedCwd } : {}),
             ...(hostFields.host ? { host: hostFields.host } : {}),
             ...(hostFields.hostStrategy ? { hostStrategy: hostFields.hostStrategy } : {}),
+            // A handler is not a routine, so its name can never appear in this device's
+            // routine activation manifest — without this marker the gate answered "not
+            // activated here" and every delivery was skipped while the receiver logged
+            // `fired` (the same shape as RUSH-2681's monitor bug). The `routine:`
+            // delegate below deliberately omits it: that fires a REAL routine, which
+            // keeps its own activation gate.
+            dispatchedBy: 'webhook',
         };
         const dispatch = handler.run.agent
             ? (opts.dispatchAgent ?? dispatchDefault)

package/dist/lib/triggers/webhook.d.ts

@@ -237,6 +237,7 @@ export interface WebhookServerOptions {
  * Start a localhost-bound receiver. It accepts only:
  *   POST /hooks/github  with X-Hub-Signature-256
  *   POST /hooks/linear  with Linear-Signature + fresh webhookTimestamp
+ *   POST /hooks/slack   with X-Slack-Signature + fresh X-Slack-Request-Timestamp
  *
  * **The ack is asynchronous (RUSH-2548).** Once a delivery has passed signature
  * verification, freshness, dedup, and rate limiting, the receiver writes

package/dist/lib/triggers/webhook.js

@@ -16,7 +16,7 @@ import * as fs from 'fs';
 import * as http from 'http';
 import * as path from 'path';
 import { jobRunsOnThisDevice, listJobs, substituteWebhookPrompt } from '../scheduling/routines.js';
-import { executeJobDetached } from '../runner.js';
+import { executeJobDetached } from '../daemon/runner.js';
 import { emit } from '../feed/events.js';
 import { listHandlers, handlerMatchesWebhook, executeHandler, buildWebhookContext, } from './handlers.js';
 /** Read `repository.full_name` (`owner/name`) from a webhook payload, if present. */
@@ -516,6 +516,7 @@ export function waitForListening(server) {
  * Start a localhost-bound receiver. It accepts only:
  *   POST /hooks/github  with X-Hub-Signature-256
  *   POST /hooks/linear  with Linear-Signature + fresh webhookTimestamp
+ *   POST /hooks/slack   with X-Slack-Signature + fresh X-Slack-Request-Timestamp
  *
  * **The ack is asynchronous (RUSH-2548).** Once a delivery has passed signature
  * verification, freshness, dedup, and rate limiting, the receiver writes
@@ -689,7 +690,7 @@ export function startWebhookServer(options) {
                     inFlight.add(slackId);
                     res.writeHead(200, { 'content-type': 'application/json' });
                     res.end(slack.type === 'slash_command'
-                        ? JSON.stringify({ response_type: 'ephemeral', text: 'On it — replying in this thread.' })
+                        ? JSON.stringify({ response_type: 'ephemeral', text: 'On it — replying in this channel.' })
                         : '');
                     void settleDelivery(slackWebhook, slackId).finally(() => inFlight.delete(slackId));
                     return;

package/dist/lib/uninstall.js

@@ -19,7 +19,7 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { AGENTS, ALL_AGENT_IDS } from './agents.js';
-import { getAgentConfigPath, getConfigSymlinkVersion, stripShimPathLines, releaseAdoptedLauncher, } from './shims.js';
+import { getAgentConfigPath, getConfigSymlinkVersion, stripShimPathLines, releaseAdoptedLauncher, } from './installations/shims.js';
 import { moveDirCrossDevice, copyDirStrippingAgentsSymlinks } from './config-transfer.js';
 import { getUserAgentsDir, getBackupsDir, getHistoryDir, getShimsDir, getLegacySystemAgentsDir, } from './state.js';
 /** Home dir honoring the AGENTS_REAL_HOME test/override, mirroring shims.ts. */

package/dist/lib/version.d.ts

@@ -43,8 +43,15 @@ export declare function resolveInstalledLayout(): InstallLayout | null;
  * binary can't read its own bundled package.json), fall back to the on-disk
  * install found via the launcher symlink so callers like the menu bar don't see
  * a bogus `unknown`.
+ *
+ * `pkgJsonPath` is an optional override of the shipping package.json path,
+ * accepted by both this function and {@link getCliVersionFresh}. Every
+ * production call site uses the zero-argument form and gets the real on-disk
+ * path below; the parameter exists only so a unit test can point both
+ * functions at a fixture package.json instead of the real one shared by every
+ * parallel test fork.
  */
-export declare function getCliVersion(): string;
+export declare function getCliVersion(pkgJsonPath?: string): string;
 /**
  * Read the version from package.json on disk every call, bypassing the cache.
  *
@@ -55,4 +62,4 @@ export declare function getCliVersion(): string;
  * is now stale and should reload onto the new code (self-healing). Returns
  * 'unknown' on any error.
  */
-export declare function getCliVersionFresh(): string;
+export declare function getCliVersionFresh(pkgJsonPath?: string): string;