@phnx-labs/agents-cli 1.20.78 → 1.20.83

package/dist/lib/activity.d.ts

@@ -7,6 +7,28 @@ export type MilestoneEvent = 'plan.created' | 'pr.opened' | 'pr.merged' | 'workt
 export type ActivityKind = 'file.edited';
 export type ActivityEventKind = MilestoneEvent | ActivityKind;
 export type ActivityTier = 'milestone' | 'activity';
+/** Well-known attachment kinds; the field is an open string, not an enum. */
+export type AttachmentKind = 'link' | 'file' | 'image' | 'audio' | 'video';
+/**
+ * A generic artifact carried by a progress update — a rendered plan, an audio
+ * take, a preview URL. Deliberately domain-agnostic: `kind` is an open string,
+ * and `meta` is an open bag (duration, width, …) so any producer can attach
+ * anything without a schema change.
+ */
+export interface Attachment {
+    /** Coarse kind for glyph/rendering; open string, not a closed enum. */
+    kind: AttachmentKind | string;
+    /** https:// URL, an absolute path, or a history-relative path. */
+    href: string;
+    /** Display name (defaults to basename(href) at render time). */
+    name?: string;
+    /** MIME type when known (e.g. `audio/wav`). */
+    mediaType?: string;
+    /** Size in bytes for local files, when stat succeeded. */
+    bytes?: number;
+    /** Open bag for kind-specific facts (duration, width, height, …). */
+    meta?: Record<string, string | number>;
+}
 /** The set of milestone events, for tier classification and ordering. */
 export declare const MILESTONE_EVENTS: readonly MilestoneEvent[];
 export declare function tierForEvent(event: string): ActivityTier;
@@ -29,6 +51,13 @@ export interface ActivityEvent {
     runtime: string;
     /** Working directory at event time -- the join key to a project/git repo. */
     cwd?: string;
+    /**
+     * Project/repo name stamped by the writer (basename of cwd, worktree-aware),
+     * so a progress post carries its project even without a live-session join.
+     * Read-time enrichment ({@link enrichActivityEvents}) still fills it for
+     * hook-written events that lack it.
+     */
+    project?: string;
     /** Agent that produced the event (claude, codex, ...). */
     agent?: string;
     /** Tool that triggered the event (Bash, Task, ExitPlanMode, feed.post, ...). */
@@ -45,7 +74,15 @@ export interface ActivityEvent {
     terminalId?: string;
     /** `$TMUX_PANE` at launch when recorded. */
     tmuxPane?: string;
+    /** Generic artifacts attached to a deliberate progress post. */
+    attachments?: Attachment[];
 }
+/**
+ * Coerce an unknown value into a clean {@link Attachment}[] — a fail-open reader
+ * over user/agent-written JSON. Drops entries without a usable `href`, clamps
+ * `kind` to a string, and keeps only primitive `meta` values.
+ */
+export declare function sanitizeAttachments(value: unknown): Attachment[] | undefined;
 /**
  * Append one event to a session's activity log. Primarily the Python hook
  * writes these at runtime; this TS writer exists for tests and any in-process
@@ -111,6 +148,125 @@ export declare function styleForEvent(event: string): {
 export declare function formatActivityLine(ev: ActivityEvent, opts?: {
     showHost?: boolean;
 }): string;
+/** Glyph per attachment kind, so an artifact row reads at a glance. */
+export declare const ATTACHMENT_GLYPH: Record<string, string>;
+export declare function attachmentGlyph(kind: string): string;
+/** Display name for an attachment: its `name`, else the basename of its href. */
+export declare function attachmentName(att: Attachment): string;
+/**
+ * Short session id for a chip: strip a known prefix (`session_`, `ses_`) then
+ * take the first 8 chars — enough to disambiguate, matching `ag sessions`.
+ */
+export declare function shortSessionId(sessionId: string): string;
+/** Extra identity resolved at display time by joining the session index. */
+export interface ProgressJoin {
+    ticketId?: string;
+    prUrl?: string;
+    label?: string;
+}
+/**
+ * Render a deliberate progress update (`status.posted`) as an operator-facing,
+ * multi-line row with full identity — not a 60-char one-liner. Shape:
+ *
+ * ```
+ *   ▸ update · 3m ago
+ *     grok · 0108441e · yosemite-s1 · agents
+ *     "CHANGELOG pushed; watching CI"
+ *     ♪ draft.wav   🖼 cover.png
+ *     ↳ ag focus 0108441e · ag sessions 0108441e
+ * ```
+ *
+ * Chips (agent, short session id, host, project, optional joined ticket/label)
+ * are shown only when known. Non-progress milestones keep {@link formatActivityLine}.
+ */
+export declare function formatProgressUpdate(ev: ActivityEvent, opts?: {
+    joined?: ProgressJoin;
+}): string;
+/** An activity event with the session-derived facts joined on at read time. */
+export interface EnrichedActivityEvent extends ActivityEvent {
+    /** Resolved project/repo name (from cwd or the session join), not the raw path. */
+    project?: string;
+    /** Tracker ticket the owning session is tied to (e.g. `RUSH-1234`). */
+    ticket?: string;
+    /** Machine the event actually ran on — session `provenance.host`, else `host`. */
+    executionHost?: string;
+}
+/**
+ * Facts pulled off a live session to enrich its activity events. Keyed by
+ * `sessionId`; every field optional so callers pass whatever they resolved.
+ */
+export interface ActivitySessionHint {
+    sessionId?: string | null;
+    /** Tracker ticket id (from `ActiveSession.ticket`). */
+    ticket?: string | null;
+    /** Machine the session executes on (`provenance.host` / `machine`). */
+    executionHost?: string | null;
+    /** Resolved project/repo slug from the session cwd. */
+    project?: string | null;
+}
+/**
+ * Resolve a stable project/repo name from a working directory. A worktree cwd
+ * (`…/<repo>/.agents/worktrees/<slug>[/sub]`) resolves to the repo dir name so
+ * a worktree session groups with its own repo; any other path resolves to its
+ * basename. Pure — no filesystem access, so it works for remote events too.
+ */
+export declare function projectFromCwd(cwd?: string | null): string | undefined;
+/**
+ * Join session facts (ticket / project / execution host) onto each event by
+ * `sessionId`. A hint wins; otherwise pre-baked enriched fields (from a remote
+ * peer that already enriched its own stream) are preserved, and project/host
+ * fall back to what the event itself carries (`cwd`, `host`). Pure.
+ */
+export declare function enrichActivityEvents(events: EnrichedActivityEvent[], hints: ActivitySessionHint[]): EnrichedActivityEvent[];
+/**
+ * Validate + host-tag one peer's `activity --json` payload for the fan-out
+ * merge. Mirrors {@link parseLine}: skip anything missing `event`/`sessionId`/
+ * `ts`, drop corrupt items. The event's own `host` is the execution host and is
+ * authoritative; only fall back to the dialed peer's `machine` when it's absent.
+ * Enriched fields the peer stamped (project/ticket/executionHost) ride through.
+ */
+export declare function parseActivityPayload(stdout: string, machine: string): EnrichedActivityEvent[];
+/**
+ * Merge local + remote event lists, keeping the first copy of a given
+ * host/session/ts/event and sorting newest first. Cross-machine activity dirs
+ * can sync in a peer's own events, so the identity key dedupes those (mirrors
+ * `mergeFeedBlocks`).
+ */
+export declare function mergeActivityEvents(...groups: EnrichedActivityEvent[][]): EnrichedActivityEvent[];
+export type ActivityGroupBy = 'project' | 'device' | 'agent';
+/** One bucket of the grouped view. */
+export interface ActivityGroup {
+    /** Grouping value; empty string for the "unknown" bucket. */
+    key: string;
+    /** Display label. */
+    label: string;
+    events: EnrichedActivityEvent[];
+}
+/** The (key, label) an event sorts under for a given grouping dimension. */
+export declare function activityGroupKey(ev: EnrichedActivityEvent, by: ActivityGroupBy): {
+    key: string;
+    label: string;
+};
+/**
+ * Bucket events by project, device, or agent. Groups are ordered by event count
+ * (desc) then label; the "unknown" bucket always sorts last. Input order is
+ * preserved within a group, so newest-first survives when the input is sorted.
+ */
+export declare function groupActivity(events: EnrichedActivityEvent[], by: ActivityGroupBy): ActivityGroup[];
+/**
+ * Narrow events to those whose project, device/host, agent, event kind, or
+ * ticket contains `filter` (case-insensitive substring). An empty filter is a
+ * no-op. Pure.
+ */
+export declare function filterActivityEvents(events: EnrichedActivityEvent[], filter: string): EnrichedActivityEvent[];
+/** One rendered enriched line: the base activity line + `· project · ticket` tags. */
+export declare function formatEnrichedActivityLine(ev: EnrichedActivityEvent, opts?: {
+    showHost?: boolean;
+    showProject?: boolean;
+    indent?: string;
+}): string;
+/** Human header for one grouped bucket: `<label> · N events · M milestones`. */
+export declare function formatActivityGroupHeader(group: ActivityGroup): string;
 /**
  * The activity-log hook (Python), sibling to 10-feed-publish.py. Classifies
  * PreToolUse/PostToolUse payloads into activity events and appends one JSONL

package/dist/lib/activity.js

@@ -23,6 +23,7 @@ import * as yaml from 'yaml';
 import chalk from 'chalk';
 import { relTime, truncate } from './format.js';
 import { getActivityDir, getUserAgentsDir } from './state.js';
+import { normalizeHost } from './machine-id.js';
 /** The set of milestone events, for tier classification and ordering. */
 export const MILESTONE_EVENTS = [
     'plan.created',
@@ -42,6 +43,45 @@ const MILESTONE_SET = new Set(MILESTONE_EVENTS);
 export function tierForEvent(event) {
     return MILESTONE_SET.has(event) ? 'milestone' : 'activity';
 }
+/**
+ * Coerce an unknown value into a clean {@link Attachment}[] — a fail-open reader
+ * over user/agent-written JSON. Drops entries without a usable `href`, clamps
+ * `kind` to a string, and keeps only primitive `meta` values.
+ */
+export function sanitizeAttachments(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const out = [];
+    for (const raw of value) {
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const a = raw;
+        const href = typeof a.href === 'string' ? a.href.trim() : '';
+        if (!href)
+            continue;
+        const att = {
+            kind: typeof a.kind === 'string' && a.kind.trim() ? a.kind.trim() : 'link',
+            href,
+        };
+        if (typeof a.name === 'string' && a.name.trim())
+            att.name = a.name.trim();
+        if (typeof a.mediaType === 'string' && a.mediaType.trim())
+            att.mediaType = a.mediaType.trim();
+        if (typeof a.bytes === 'number' && Number.isFinite(a.bytes) && a.bytes >= 0)
+            att.bytes = a.bytes;
+        if (a.meta && typeof a.meta === 'object' && !Array.isArray(a.meta)) {
+            const meta = {};
+            for (const [k, v] of Object.entries(a.meta)) {
+                if (typeof v === 'string' || typeof v === 'number')
+                    meta[k] = v;
+            }
+            if (Object.keys(meta).length > 0)
+                att.meta = meta;
+        }
+        out.push(att);
+    }
+    return out.length > 0 ? out : undefined;
+}
 function activityPath(root, sessionId) {
     const safe = sessionId.replace(/[^A-Za-z0-9._-]/g, '-');
     if (!safe)
@@ -81,6 +121,7 @@ function parseLine(line) {
             host: parsed.host ?? 'unknown',
             runtime: parsed.runtime ?? 'headless',
             cwd: parsed.cwd,
+            project: parsed.project,
             agent: parsed.agent,
             tool: parsed.tool,
             detail: parsed.detail,
@@ -89,6 +130,7 @@ function parseLine(line) {
             launchId: parsed.launchId,
             terminalId: parsed.terminalId,
             tmuxPane: parsed.tmuxPane,
+            attachments: sanitizeAttachments(parsed.attachments),
         };
     }
     catch {
@@ -217,9 +259,11 @@ export function activityEventToRecord(ev) {
         detail: ev.detail,
         url: ev.url,
         tier: ev.tier,
+        ...(ev.project ? { project: ev.project } : {}),
         ...(ev.launchId ? { launchId: ev.launchId } : {}),
         ...(ev.terminalId ? { terminalId: ev.terminalId } : {}),
         ...(ev.tmuxPane ? { tmuxPane: ev.tmuxPane } : {}),
+        ...(ev.attachments?.length ? { attachments: ev.attachments } : {}),
     };
 }
 /** Read recent activity across sessions as unified {@link EventRecord}s. */
@@ -262,6 +306,244 @@ export function formatActivityLine(ev, opts = {}) {
     return `  ${when}  ${host}${label}${detail}${agent}${url}`;
 }
 // ---------------------------------------------------------------------------
+// Rich progress render (RUSH-2014): `status.posted` posts are the deliberate,
+// operator-facing announcements — a single truncated line under-serves them.
+// `formatProgressUpdate` renders each as a multi-line row with full identity
+// chips (agent · session · host · project) and any attached artifacts.
+// ---------------------------------------------------------------------------
+/** Glyph per attachment kind, so an artifact row reads at a glance. */
+export const ATTACHMENT_GLYPH = {
+    image: '🖼',
+    audio: '♪',
+    video: '▶',
+    file: '📎',
+    link: '↗',
+};
+export function attachmentGlyph(kind) {
+    return ATTACHMENT_GLYPH[kind] ?? '📎';
+}
+/** Display name for an attachment: its `name`, else the basename of its href. */
+export function attachmentName(att) {
+    if (att.name && att.name.trim())
+        return att.name.trim();
+    const href = att.href.replace(/[/\\]+$/, '');
+    const slash = Math.max(href.lastIndexOf('/'), href.lastIndexOf('\\'));
+    const base = slash >= 0 ? href.slice(slash + 1) : href;
+    return base || href;
+}
+/**
+ * Short session id for a chip: strip a known prefix (`session_`, `ses_`) then
+ * take the first 8 chars — enough to disambiguate, matching `ag sessions`.
+ */
+export function shortSessionId(sessionId) {
+    const stripped = sessionId.replace(/^(session_|ses_)/, '');
+    return stripped.slice(0, 8) || sessionId.slice(0, 8);
+}
+/**
+ * Render a deliberate progress update (`status.posted`) as an operator-facing,
+ * multi-line row with full identity — not a 60-char one-liner. Shape:
+ *
+ * ```
+ *   ▸ update · 3m ago
+ *     grok · 0108441e · yosemite-s1 · agents
+ *     "CHANGELOG pushed; watching CI"
+ *     ♪ draft.wav   🖼 cover.png
+ *     ↳ ag focus 0108441e · ag sessions 0108441e
+ * ```
+ *
+ * Chips (agent, short session id, host, project, optional joined ticket/label)
+ * are shown only when known. Non-progress milestones keep {@link formatActivityLine}.
+ */
+export function formatProgressUpdate(ev, opts = {}) {
+    const shortId = shortSessionId(ev.sessionId);
+    const lines = [];
+    lines.push(`  ${chalk.white('▸ update')} ${chalk.gray(`· ${relTime(ev.ts)}`)}`);
+    const chips = [
+        ev.agent,
+        shortId,
+        ev.host && ev.host !== 'unknown' ? ev.host : undefined,
+        ev.project,
+        opts.joined?.ticketId,
+        opts.joined?.label,
+    ].filter((c) => Boolean(c));
+    if (chips.length > 0)
+        lines.push(`    ${chalk.gray(chips.join(' · '))}`);
+    if (ev.detail)
+        lines.push(`    ${chalk.white(`"${ev.detail}"`)}`);
+    if (ev.attachments?.length) {
+        const parts = ev.attachments.map((a) => `${attachmentGlyph(a.kind)} ${chalk.cyan(attachmentName(a))}`);
+        lines.push(`    ${parts.join('   ')}`);
+    }
+    if (opts.joined?.prUrl)
+        lines.push(`    ${chalk.gray(opts.joined.prUrl)}`);
+    lines.push(`    ${chalk.dim(`↳ ag focus ${shortId} · ag sessions ${shortId}`)}`);
+    return lines.join('\n');
+}
+/**
+ * Resolve a stable project/repo name from a working directory. A worktree cwd
+ * (`…/<repo>/.agents/worktrees/<slug>[/sub]`) resolves to the repo dir name so
+ * a worktree session groups with its own repo; any other path resolves to its
+ * basename. Pure — no filesystem access, so it works for remote events too.
+ */
+export function projectFromCwd(cwd) {
+    if (!cwd)
+        return undefined;
+    const norm = cwd.replace(/\\/g, '/').replace(/\/+$/, '');
+    if (!norm)
+        return undefined;
+    const wtIdx = norm.indexOf('/.agents/worktrees/');
+    if (wtIdx > 0) {
+        const repoPath = norm.slice(0, wtIdx);
+        const base = repoPath.slice(repoPath.lastIndexOf('/') + 1);
+        if (base)
+            return base;
+    }
+    const base = norm.slice(norm.lastIndexOf('/') + 1);
+    return base || undefined;
+}
+/**
+ * Join session facts (ticket / project / execution host) onto each event by
+ * `sessionId`. A hint wins; otherwise pre-baked enriched fields (from a remote
+ * peer that already enriched its own stream) are preserved, and project/host
+ * fall back to what the event itself carries (`cwd`, `host`). Pure.
+ */
+export function enrichActivityEvents(events, hints) {
+    const bySession = new Map();
+    for (const h of hints)
+        if (h.sessionId)
+            bySession.set(h.sessionId, h);
+    return events.map((ev) => {
+        const hint = ev.sessionId ? bySession.get(ev.sessionId) : undefined;
+        const project = hint?.project ?? ev.project ?? projectFromCwd(ev.cwd);
+        const ticket = hint?.ticket ?? ev.ticket ?? undefined;
+        const executionHost = hint?.executionHost ?? ev.executionHost
+            ?? (ev.host && ev.host !== 'unknown' ? ev.host : undefined);
+        return {
+            ...ev,
+            ...(project ? { project } : {}),
+            ...(ticket ? { ticket } : {}),
+            ...(executionHost ? { executionHost } : {}),
+        };
+    });
+}
+/**
+ * Validate + host-tag one peer's `activity --json` payload for the fan-out
+ * merge. Mirrors {@link parseLine}: skip anything missing `event`/`sessionId`/
+ * `ts`, drop corrupt items. The event's own `host` is the execution host and is
+ * authoritative; only fall back to the dialed peer's `machine` when it's absent.
+ * Enriched fields the peer stamped (project/ticket/executionHost) ride through.
+ */
+export function parseActivityPayload(stdout, machine) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(parsed))
+        return [];
+    const out = [];
+    for (const item of parsed) {
+        if (!item || typeof item !== 'object' || Array.isArray(item))
+            continue;
+        const ev = item;
+        if (!ev.event || !ev.sessionId || !ev.ts)
+            continue;
+        const host = ev.host && ev.host !== 'unknown' ? ev.host : machine;
+        out.push({ ...ev, host });
+    }
+    return out;
+}
+/**
+ * Merge local + remote event lists, keeping the first copy of a given
+ * host/session/ts/event and sorting newest first. Cross-machine activity dirs
+ * can sync in a peer's own events, so the identity key dedupes those (mirrors
+ * `mergeFeedBlocks`).
+ */
+export function mergeActivityEvents(...groups) {
+    const byKey = new Map();
+    for (const ev of groups.flat()) {
+        const key = `${normalizeHost(ev.host)}\0${ev.sessionId}\0${ev.ts}\0${ev.event}`;
+        if (!byKey.has(key))
+            byKey.set(key, ev);
+    }
+    return [...byKey.values()].sort((a, b) => Date.parse(b.ts) - Date.parse(a.ts));
+}
+/** The (key, label) an event sorts under for a given grouping dimension. */
+export function activityGroupKey(ev, by) {
+    if (by === 'project') {
+        const p = ev.project ?? projectFromCwd(ev.cwd);
+        return p ? { key: p, label: p } : { key: '', label: 'unknown project' };
+    }
+    if (by === 'device') {
+        const h = ev.executionHost ?? (ev.host && ev.host !== 'unknown' ? ev.host : undefined);
+        return h ? { key: h, label: h } : { key: '', label: 'unknown device' };
+    }
+    const a = ev.agent;
+    return a ? { key: a, label: a } : { key: '', label: 'unknown agent' };
+}
+/**
+ * Bucket events by project, device, or agent. Groups are ordered by event count
+ * (desc) then label; the "unknown" bucket always sorts last. Input order is
+ * preserved within a group, so newest-first survives when the input is sorted.
+ */
+export function groupActivity(events, by) {
+    const byKey = new Map();
+    for (const ev of events) {
+        const { key, label } = activityGroupKey(ev, by);
+        const g = byKey.get(key);
+        if (g)
+            g.events.push(ev);
+        else
+            byKey.set(key, { key, label, events: [ev] });
+    }
+    return [...byKey.values()].sort((a, b) => {
+        if (!a.key && b.key)
+            return 1;
+        if (!b.key && a.key)
+            return -1;
+        if (b.events.length !== a.events.length)
+            return b.events.length - a.events.length;
+        return a.label.localeCompare(b.label);
+    });
+}
+/**
+ * Narrow events to those whose project, device/host, agent, event kind, or
+ * ticket contains `filter` (case-insensitive substring). An empty filter is a
+ * no-op. Pure.
+ */
+export function filterActivityEvents(events, filter) {
+    const needle = filter.trim().toLowerCase();
+    if (!needle)
+        return events;
+    return events.filter((ev) => {
+        const fields = [ev.project, ev.executionHost, ev.host, ev.agent, ev.event, ev.ticket];
+        return fields.some((f) => typeof f === 'string' && f.toLowerCase().includes(needle));
+    });
+}
+/** One rendered enriched line: the base activity line + `· project · ticket` tags. */
+export function formatEnrichedActivityLine(ev, opts = {}) {
+    const base = formatActivityLine(ev, { showHost: opts.showHost });
+    const tags = [];
+    if (opts.showProject && ev.project)
+        tags.push(ev.project);
+    if (ev.ticket)
+        tags.push(ev.ticket);
+    const suffix = tags.length > 0 ? chalk.gray(`  · ${tags.join(' · ')}`) : '';
+    return `${opts.indent ?? ''}${base}${suffix}`;
+}
+/** Human header for one grouped bucket: `<label> · N events · M milestones`. */
+export function formatActivityGroupHeader(group) {
+    const { milestones } = collapseActivity(group.events);
+    const n = group.events.length;
+    const m = milestones.length;
+    const parts = [`${n} event${n === 1 ? '' : 's'}`];
+    if (m > 0)
+        parts.push(`${m} milestone${m === 1 ? '' : 's'}`);
+    return `${group.label} · ${parts.join(' · ')}`;
+}
+// ---------------------------------------------------------------------------
 // Hook installation
 // ---------------------------------------------------------------------------
 /**

package/dist/lib/agents.d.ts

@@ -32,13 +32,17 @@ export declare function findInPath(command: string): string | null;
  * single source of truth for agent metadata consumed throughout the codebase.
  */
 export declare const AGENTS: Record<AgentId, AgentConfig>;
-/** All registered agent IDs derived from the AGENTS registry. */
+/** All current and legacy agent IDs derived from the AGENTS registry. */
 export declare const ALL_AGENT_IDS: AgentId[];
+/** Agents retained only for legacy reads, not install/import/sync targets. */
+export declare const HARD_DEPRECATED_AGENT_IDS: AgentId[];
+/** Agents that can receive managed installs, imports, and resource sync writes. */
+export declare const MANAGED_AGENT_IDS: AgentId[];
 /**
  * A self-updating agent is a single global binary installed by an official
  * `curl … | sh` / `brew install` script that carries NO version token — the
  * installer can only ever fetch the *current* release, and the binary then keeps
- * itself up to date in place (droid, grok, antigravity, cursor, hermes, forge,
+ * itself up to date in place (droid, grok, antigravity, cursor, hermes,
  * kiro, goose). There is no semver to pin, so agents-cli must not model these as
  * having multiple installable version-homes the way it does for npm-packaged
  * agents (claude, codex, kimi, …).
@@ -55,6 +59,7 @@ export declare const ALL_AGENT_IDS: AgentId[];
  * never a scattered `agent === 'droid'`.
  */
 export declare function isSelfUpdatingAgent(agent: AgentId): boolean;
+export declare function isAgentHardDeprecated(agent: AgentId): boolean;
 /** Get the chalk color function for an agent. Works for any AgentId or SessionAgentId. */
 export declare function colorAgent(agentId: string): (s: string) => string;
 /** Return the agent's display name, colored. */
@@ -383,6 +388,8 @@ export declare function isAgentName(input: string): boolean;
  * capturing stdout. Lines are plain (uncolored) text.
  */
 export declare function deprecationNotice(agent: AgentId): string[] | null;
+export declare function hardDeprecationNotice(agent: AgentId): string[] | null;
+export declare function hardDeprecationError(agent: AgentId): string;
 /**
  * Print a deprecation warning (yellow) if the agent's registry entry carries a
  * `deprecated` marker; no-op otherwise. Call from any user entry point that