@phnx-labs/agents-cli 1.22.42 → 1.22.43

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),
     };
 }
 /**
@@ -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

@@ -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/view-types.d.ts

@@ -24,6 +24,10 @@ export interface ViewJsonVersion {
         usedPercent: number;
         resetsAt: string | null;
     }>;
+    unavailable?: {
+        reason: 'session_limit';
+        resetsAt: string;
+    };
     lastActive: string | null;
     path: string;
     configuredModel?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.42",
+  "version": "1.22.43",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",

package/dist/commands/tickets.d.ts

@@ -1,2 +0,0 @@
-import type { Command } from 'commander';
-export declare function registerTicketsCommand(program: Command): void;

package/dist/commands/tickets.js

@@ -1,43 +0,0 @@
-import { setHelpSections } from '../lib/help.js';
-import { listTickets } from '../lib/tickets/list.js';
-export function registerTicketsCommand(program) {
-    const tickets = program
-        .command('tickets')
-        .description('Read work items from the trackers linked to this workspace.');
-    setHelpSections(tickets, {
-        examples: `
-      agents tickets list --json
-      agents tickets list --github-assigned-only --json
-    `,
-        notes: `
-      The response reports each source's availability explicitly. A failed tracker
-      never makes another tracker's rows disappear.
-    `,
-    });
-    tickets
-        .command('list')
-        .description('List workspace tickets from Linear and GitHub.')
-        .option('--cwd <path>', 'Workspace used to resolve tracker context')
-        .option('--no-linear', 'Exclude Linear tickets')
-        .option('--no-github', 'Exclude GitHub issues')
-        .option('--github-assigned-only', 'Only include GitHub issues assigned to the current user')
-        .option('--json', 'Output machine-readable tickets, cycle metadata, and source availability')
-        .action(async (options) => {
-        const result = await listTickets({
-            cwd: options.cwd ?? process.cwd(),
-            linear: options.linear,
-            github: options.github,
-            githubAssignedOnly: options.githubAssignedOnly === true,
-        });
-        if (options.json) {
-            console.log(JSON.stringify(result, null, 2));
-            return;
-        }
-        console.log(`${result.tickets.length} ticket${result.tickets.length === 1 ? '' : 's'}`);
-        for (const source of ['linear', 'github']) {
-            const status = result.sources[source];
-            if (!status.available && status.error)
-                console.error(`${source}: ${status.error}`);
-        }
-    });
-}

package/dist/lib/observe-aliases.d.ts

@@ -1,30 +0,0 @@
-/**
- * Observe-umbrella aliases (Phase 3 surface consolidation).
- *
- * Thin name → real command expansion. No store merge — feed / sessions / events
- * remain the stores; these are doors that point at the right reader.
- *
- *   inbox    → feed                  (needs-you default)
- *
- * `roster` was removed — use `agents sessions --active`.
- * `timeline` was removed — use `agents feed --filter updates` (RUSH-2692).
- * `audit` is NOT an alias here — `agents audit` is already the tamper-evident
- * run-dispatch log. Ops trail = `agents events` (optionally `--audit`).
- */
-export type ObserveAlias = 'inbox';
-export declare const OBSERVE_ALIASES: readonly ObserveAlias[];
-export interface ObserveExpandResult {
-    /** argv for the real command (no program name): e.g. ['feed', '--filter', 'updates'] */
-    argv: string[];
-    /** One-line note for stderr (optional); empty when silent. */
-    note: string;
-}
-/** True when `rest` already carries a `--filter` / `--filter=…` flag. */
-export declare function hasFilterFlag(rest: readonly string[]): boolean;
-/** True when `rest` already carries `--active`. */
-export declare function hasActiveFlag(rest: readonly string[]): boolean;
-/**
- * Expand an observe alias + remaining user args into the real command argv.
- * Returns null when `alias` is not an observe alias.
- */
-export declare function expandObserveAlias(alias: string, rest?: readonly string[]): ObserveExpandResult | null;

package/dist/lib/observe-aliases.js

@@ -1,38 +0,0 @@
-/**
- * Observe-umbrella aliases (Phase 3 surface consolidation).
- *
- * Thin name → real command expansion. No store merge — feed / sessions / events
- * remain the stores; these are doors that point at the right reader.
- *
- *   inbox    → feed                  (needs-you default)
- *
- * `roster` was removed — use `agents sessions --active`.
- * `timeline` was removed — use `agents feed --filter updates` (RUSH-2692).
- * `audit` is NOT an alias here — `agents audit` is already the tamper-evident
- * run-dispatch log. Ops trail = `agents events` (optionally `--audit`).
- */
-export const OBSERVE_ALIASES = ['inbox'];
-/** True when `rest` already carries a `--filter` / `--filter=…` flag. */
-export function hasFilterFlag(rest) {
-    return rest.some((a) => a === '--filter' || a.startsWith('--filter='));
-}
-/** True when `rest` already carries `--active`. */
-export function hasActiveFlag(rest) {
-    return rest.some((a) => a === '--active');
-}
-/**
- * Expand an observe alias + remaining user args into the real command argv.
- * Returns null when `alias` is not an observe alias.
- */
-export function expandObserveAlias(alias, rest = []) {
-    const tail = [...rest];
-    switch (alias) {
-        case 'inbox':
-            return {
-                argv: ['feed', ...tail],
-                note: 'agents inbox → agents feed (needs-you inbox)',
-            };
-        default:
-            return null;
-    }
-}

package/dist/lib/tickets/list.d.ts

@@ -1,53 +0,0 @@
-export type TicketSource = 'linear' | 'github';
-export interface TicketComment {
-    body: string;
-    createdAt?: string;
-    author?: string;
-}
-export interface TicketRow {
-    id: string;
-    source: TicketSource;
-    title: string;
-    description?: string;
-    status: 'todo' | 'in_progress' | 'done';
-    priority?: 'urgent' | 'high' | 'medium' | 'low';
-    metadata: {
-        identifier?: string;
-        url?: string;
-        labels?: string[];
-        assignee?: string;
-        assigneeKind?: 'user' | 'agent';
-        state?: string;
-        createdAt?: string;
-        dueDate?: string;
-        project?: string;
-        repo?: string;
-        comments?: TicketComment[];
-        images?: string[];
-    };
-}
-export interface TicketListResult {
-    tickets: TicketRow[];
-    cycleInfo: {
-        name: string;
-        startsAt: string;
-        endsAt: string;
-    } | null;
-    sources: {
-        linear: {
-            available: boolean;
-            error?: string;
-        };
-        github: {
-            available: boolean;
-            error?: string;
-        };
-    };
-}
-export interface TicketListOptions {
-    cwd: string;
-    linear: boolean;
-    github: boolean;
-    githubAssignedOnly: boolean;
-}
-export declare function listTickets(options: TicketListOptions): Promise<TicketListResult>;