@phnx-labs/agents-cli 1.22.55 → 1.22.57

package/dist/lib/session/db.js

@@ -3390,15 +3390,9 @@ export function topSessionsByCost(n, options = {}) {
         durationMs: r.duration_ms ?? 0,
     }));
 }
-/** Look up a single session by its unique ID. */
 /**
- * Batch-resolve session ids to the machine each one runs on, in ONE indexed
- * query. `getActiveSessions` needs only this column for every live row, and
- * `getSessionById` would re-`prepare` a `SELECT *` and materialize a full
- * `SessionMeta` per id to read it — mirrors {@link findSessionsByShortIds}'s
- * single-round-trip pattern. Ids absent from the index are simply absent from
- * the map. Best-effort: an unavailable DB yields an empty map, so the live view
- * still renders (the caller then leaves rows attributed to this box).
+ * Read machine attribution in batches without materializing full sessions.
+ * Failure is best-effort so the live view can still render local attribution.
  */
 export function findSessionMachinesByIds(ids) {
     const out = new Map();
@@ -3429,20 +3423,7 @@ export function getSessionById(id) {
     const row = db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id);
     return row ? rowToMeta(row) : null;
 }
-/**
- * Resolve a full-or-partial session id against the index, exact-first then
- * prefix — the DB-backed equivalent of resolveSessionById() that runs over the
- * SQLite table instead of a pre-loaded array. Matches both the full id and the
- * short id. An exact hit short-circuits so a complete id never also drags in its
- * prefix siblings. `scope` narrows by agent / version / project (cwd) so an
- * ambiguous prefix disambiguates against the caller's context.
- *
- * Routes through the full querySessions existence check (NOT skipExistenceCheck)
- * on purpose (RUSH-2436): that check now KEEPS a file-gone session whose user
- * turns still live in session_text (flagged archived) and only suppresses a
- * contentless phantom — so `agents sessions <id>` resolves an archived session
- * instead of failing with "No session found", while a phantom id still misses.
- */
+/** Exact ids win over prefixes; the normal existence check preserves archived content but excludes phantoms. */
 export function findSessionsById(idQuery, scope = {}) {
     const q = idQuery.trim();
     if (!q)
@@ -3452,19 +3433,7 @@ export function findSessionsById(idQuery, scope = {}) {
         return exact;
     return querySessions({ ...scope, idPrefix: q });
 }
-/**
- * Batch-resolve many 8-char short ids to their sessions in ONE indexed query.
- * The live-scan path (listTmuxAgentSessions) turns every `ag-<agent>-<shortid>`
- * tmux pane name back into a full session id this way, so it pays a single
- * `short_id IN (…)` round-trip per scan instead of N per-pane lookups.
- *
- * Returns a map keyed by short_id (lowercased). Short ids are the first 8 chars
- * of the lowercase session UUID (deriveShortId), so a lowercased `IN` matches and
- * still uses idx_sessions_short_id. When several sessions share a short id — only
- * time-ordered ids (ULID/UUIDv7) ever collide; random UUIDv4 short ids are unique
- * in practice — the most-recently-active one wins (the caller can further
- * disambiguate by cwd).
- */
+/** Batch-resolve pane short ids; on collision the most recently active session wins. */
 export function findSessionsByShortIds(shortIds) {
     const out = new Map();
     const uniq = [...new Set(shortIds.map((s) => s.trim().toLowerCase()).filter(Boolean))];

package/dist/lib/session/discover.d.ts

@@ -54,14 +54,7 @@ export interface DiscoverOptions {
     idExact?: string;
     /** Session id prefix — a targeted indexed lookup with no scan (RUSH-2477). */
     idPrefix?: string;
-    /**
-     * Cold-miss repair: when another live process already holds the scan claim,
-     * wait (bounded) for that in-flight scan to finish before reading the index,
-     * instead of returning the pre-scan snapshot (RUSH-2682). A caller repairing a
-     * "not indexed yet" miss wants the fresh result the concurrent scan is about to
-     * write, not the stale read that just missed. Ignored when THIS process wins
-     * the claim (it scans itself) or no scan is in progress.
-     */
+    /** On a cold miss, briefly await the scan already holding the single-flight claim. */
     waitForScan?: boolean;
 }
 /** Progress report emitted during incremental scanning. */
@@ -181,41 +174,15 @@ export declare function discoverSessions(options?: DiscoverOptions): Promise<Ses
 interface IncrementalScanResult {
     /** True when this process won the single-flight claim and ran the scan. */
     claimed: boolean;
-    /**
-     * Transcripts parsed this scan — i.e. those whose (mtime, size) changed. Zero
-     * is the steady state on an idle box and does NOT mean the scan was skipped;
-     * read `claimed` for that.
-     *
-     * Twelve of the 13 SESSION_AGENTS contribute, including OpenCode, whose
-     * scanner filters to sessions whose own per-session stamp changed and reports
-     * that batch — so a tick whose only changed sessions live there no longer
-     * reports 0 (RUSH-2691). OpenClaw is the exception and contributes nothing:
-     * its scanner has no change detection to report (a TTL gate, a fresh stamp
-     * every run, and an entry list rebuilt as the current inventory), so counting
-     * it would overstate rather than measure. See `scanOpenClawIncremental`.
-     */
+    /** Changed transcripts parsed; zero with `claimed: true` is a successful no-op scan. */
     scanned: number;
 }
-/**
- * The write half of {@link discoverSessions}: claim the single-flight scan slot,
- * incrementally index this host's transcript dirs, and report what was parsed.
- *
- * Split out so a caller that only wants the index refreshed — the daemon's warm
- * tick — can run it WITHOUT the listing query `discoverSessions` ends with. That
- * query is not free: it applies a cwd filter, runs the `archived_at`-writing
- * existence check, and can issue a Linear fetch, none of which index anything
- * (RUSH-2691). Keeping one implementation here is also what stops the tick and
- * the foreground path from drifting apart.
- */
+/** Separate write half so daemon warming does not pay for listing or external enrichment. */
 export declare function scanSessionsIncremental(options?: {
     agent?: SessionAgentId;
     onProgress?: (p: ScanProgress) => void;
 }): Promise<IncrementalScanResult>;
-/**
- * Poll until no live process holds the scan claim, or the bound elapses
- * (RUSH-2682). Bounded so a wedged/slow scan can never hang a foreground preview.
- * Exported for the cold-miss repair test.
- */
+/** Bounded wait so a wedged scan cannot hang a foreground cold-miss repair. */
 export declare function waitForScanToSettle(timeoutMs?: number, pollMs?: number): Promise<boolean>;
 /** Read the current SQLite snapshot without scanning or parsing transcript files. */
 export declare function queryIndexedSessions(options?: DiscoverOptions, indexedOptions?: {
@@ -223,27 +190,8 @@ export declare function queryIndexedSessions(options?: DiscoverOptions, indexedO
     skipExistenceCheck?: boolean;
 }): Promise<SessionMeta[]>;
 /**
- * Resolve a full-or-partial session id against the LOCAL SQLite index only.
- *
- * A plain WAL read through `queryIndexedSessions` — same origin-machine
- * attribution and managed scoping every indexed read gets — with NO incremental
- * discovery scan (so none of `tryClaimScan`/`releaseScan`'s `BEGIN IMMEDIATE`
- * writer lock) and NO fleet SSH fan-out. This is the crash-restart storm path
- * (RUSH-2477): dozens of `sessions resume <id>` at once for a known local id must
- * each be a cheap read, never a writer-lock contender or a dial into the
- * not-yet-up tailnet. Exact id first, then prefix (matching `findSessionsById`),
- * so a complete id never also drags in its prefix siblings. Returns `[]` on a
- * genuine local miss, leaving the caller to fall back to the fleet resolver.
- *
- * The existence check is left ON (`skipExistenceCheck: false`), exactly as the old
- * `discoverSessions` path and `findSessionsById` do (RUSH-2436): it KEEPS a
- * file-gone session whose user turns still live in `session_text` (flagged
- * archived) and SUPPRESSES a contentless phantom — so a phantom id misses here and
- * falls through to the fleet resolver, instead of resolving to a row with no real
- * transcript to resume. For a present transcript — the storm's actual case, since
- * the crashed tabs' files are on disk — the check does no writes, so the lock-free
- * guarantee holds; it only writes to (un)archive a genuinely missing or resurrected
- * file, which is not the 20-at-once resume path.
+ * Resolve locally without scanning or fleet I/O, keeping concurrent crash recovery lock-light.
+ * The existence check preserves archived content while rejecting transcriptless phantoms.
  */
 export declare function resolveIndexedSessionById(idQuery: string): Promise<SessionMeta[]>;
 /**

package/dist/lib/session/discover.js

@@ -131,12 +131,7 @@ async function applyJsonlAppend(filePath, fromOffset, wasDroppingOversizedLine,
  * between `agents sessions` calls but is still being written to.
  */
 const HOT_FILE_WINDOW_MS = 600_000;
-/**
- * Kill-switch: set `AGENTS_SESSIONS_NO_DIR_LEDGER=1` to force the old full-walk
- * path (readdir + per-file stat every dir, every run — the pre-A-2 behavior),
- * skipping the dir_ledger short-circuit entirely. One env var reverts a field
- * regression to today's behavior.
- */
+/** Emergency kill-switch for the directory-ledger optimization. */
 function dirLedgerDisabled() {
     const v = process.env.AGENTS_SESSIONS_NO_DIR_LEDGER;
     return v === '1' || v === 'true';
@@ -175,17 +170,7 @@ export async function discoverSessions(options) {
         skipExistenceCheck: options?.skipExistenceCheck ?? false,
     });
 }
-/**
- * The write half of {@link discoverSessions}: claim the single-flight scan slot,
- * incrementally index this host's transcript dirs, and report what was parsed.
- *
- * Split out so a caller that only wants the index refreshed — the daemon's warm
- * tick — can run it WITHOUT the listing query `discoverSessions` ends with. That
- * query is not free: it applies a cwd filter, runs the `archived_at`-writing
- * existence check, and can issue a Linear fetch, none of which index anything
- * (RUSH-2691). Keeping one implementation here is also what stops the tick and
- * the foreground path from drifting apart.
- */
+/** Separate write half so daemon warming does not pay for listing or external enrichment. */
 export async function scanSessionsIncremental(options) {
     // Touch the DB so the schema is ready and connection is cached for this run.
     getDB();
@@ -222,11 +207,7 @@ export async function scanSessionsIncremental(options) {
         scanned += n;
     return { claimed: true, scanned };
 }
-/**
- * Poll until no live process holds the scan claim, or the bound elapses
- * (RUSH-2682). Bounded so a wedged/slow scan can never hang a foreground preview.
- * Exported for the cold-miss repair test.
- */
+/** Bounded wait so a wedged scan cannot hang a foreground cold-miss repair. */
 export async function waitForScanToSettle(timeoutMs = WAIT_FOR_SCAN_TIMEOUT_MS, pollMs = WAIT_FOR_SCAN_POLL_MS) {
     const deadline = Date.now() + timeoutMs;
     while (scanInProgressByLivePid()) {
@@ -259,27 +240,8 @@ export async function queryIndexedSessions(options, indexedOptions = {}) {
     return scopeToManaged(sessions, agents, options);
 }
 /**
- * Resolve a full-or-partial session id against the LOCAL SQLite index only.
- *
- * A plain WAL read through `queryIndexedSessions` — same origin-machine
- * attribution and managed scoping every indexed read gets — with NO incremental
- * discovery scan (so none of `tryClaimScan`/`releaseScan`'s `BEGIN IMMEDIATE`
- * writer lock) and NO fleet SSH fan-out. This is the crash-restart storm path
- * (RUSH-2477): dozens of `sessions resume <id>` at once for a known local id must
- * each be a cheap read, never a writer-lock contender or a dial into the
- * not-yet-up tailnet. Exact id first, then prefix (matching `findSessionsById`),
- * so a complete id never also drags in its prefix siblings. Returns `[]` on a
- * genuine local miss, leaving the caller to fall back to the fleet resolver.
- *
- * The existence check is left ON (`skipExistenceCheck: false`), exactly as the old
- * `discoverSessions` path and `findSessionsById` do (RUSH-2436): it KEEPS a
- * file-gone session whose user turns still live in `session_text` (flagged
- * archived) and SUPPRESSES a contentless phantom — so a phantom id misses here and
- * falls through to the fleet resolver, instead of resolving to a row with no real
- * transcript to resume. For a present transcript — the storm's actual case, since
- * the crashed tabs' files are on disk — the check does no writes, so the lock-free
- * guarantee holds; it only writes to (un)archive a genuinely missing or resurrected
- * file, which is not the 20-at-once resume path.
+ * Resolve locally without scanning or fleet I/O, keeping concurrent crash recovery lock-light.
+ * The existence check preserves archived content while rejecting transcriptless phantoms.
  */
 export async function resolveIndexedSessionById(idQuery) {
     const q = idQuery.trim();

package/dist/lib/session/parse.d.ts

@@ -28,28 +28,10 @@ export declare function sanitizeEvents(events: SessionEvent[]): void;
  * ERR_STRING_TOO_LONG ceiling.
  */
 export declare function safeReadSessionFile(filePath: string, maxBytes?: number): string;
-/**
- * Auto-detect agent type from file path and parse the session.
- */
 export interface ParseSessionOptions {
     /** Keep normalized tool results compact by default; renderers can request full output. */
     maxToolOutputChars?: number;
-    /**
-     * Emit an `interrupt` event where the transcript records `[Request interrupted`.
-     *
-     * OFF by default, deliberately. That marker is not a user message, and the default
-     * event array is a versioned consumer contract: `agents sessions <id> --json`
-     * serializes it verbatim (see render.ts, issue #743), `computeSummaryStats` folds
-     * every event's timestamp into the session duration, and the live-state reader and
-     * tail renderer inspect fixed-size windows of the last N events. Emitting it
-     * unconditionally changed all four — a measured 12x duration swing on one real
-     * transcript, a new object in a published payload, and an eviction from the
-     * 12-event rate-limit window whose trigger shape (a trailing interrupt) is exactly
-     * a session the user just cancelled.
-     *
-     * `agents insights` opts in: an interruption is a real friction signal, and dropping
-     * it outright is what made it unrecoverable.
-     */
+    /** Opt-in because interrupts are not user messages and would change the published event stream. */
     includeInterrupts?: boolean;
 }
 export declare function parseSession(filePath: string, agent?: SessionAgentId, opts?: ParseSessionOptions): SessionEvent[];

package/dist/lib/session/parse.js

@@ -117,14 +117,7 @@ function truncateNormalizedToolOutput(output, maxChars) {
         return output;
     return `${output.slice(0, maxChars)}\n\n[Output truncated: ${output.length - maxChars} characters omitted.]`;
 }
-/**
- * Registry-dispatch table: each `SessionAgentId` to its offline transcript
- * parser. Replaces the per-harness `switch` — the harness axis of Move 3. Kept
- * as its own table (not on the HarnessAdapter registry) because its id domain is
- * `SessionAgentId`: `rush` is a session agent with no `AgentId`, and the offline
- * transcript reader is a deliberately separate concern from live team events.
- * The `Record` is total, so a new session harness must add an entry here.
- */
+/** Separate from HarnessAdapter because offline transcripts include session-only agents such as Rush. */
 const TRANSCRIPT_PARSERS = {
     claude: (filePath, opts) => parseClaude(filePath, opts),
     codex: (filePath) => parseCodex(filePath),
@@ -146,13 +139,7 @@ export function parseSession(filePath, agent, opts = {}) {
         throw new Error(`Cannot detect agent type from path: ${filePath}`);
     }
     const events = TRANSCRIPT_PARSERS[detected](filePath, opts);
-    // Chokepoint: every string field that originated in an untrusted session
-    // file gets stripped of terminal escapes here, so renderers downstream can
-    // safely splat values into chalk/console output. Same pass flags
-    // harness-injected `role=user` scaffolding (Claude `<bash-input>`/`<bash-stdout>`
-    // from `!`-prefix runs, `<system-reminder>`, etc.) as `_synthetic` so turn
-    // slicing and `--include user` count only genuine user intent — one place,
-    // every harness, instead of per-consumer regex.
+    // Sanitize untrusted strings and identify synthetic user scaffolding once for every consumer.
     const maxToolOutputChars = opts.maxToolOutputChars ?? 500;
     for (const e of events) {
         if (e.type === 'tool_result' && e.output) {

package/dist/lib/share/provision.d.ts

@@ -1,3 +1,4 @@
+import type { WorkerBundle } from './worker-template.js';
 export declare const SHARE_LIFECYCLE_RULE_ID = "agents-share-expire-objects";
 export declare const SHARE_LIFECYCLE_RETENTION_DAYS = 366;
 interface R2LifecycleRule {
@@ -50,7 +51,7 @@ export declare function mergeShareLifecycleRule(existing?: R2LifecycleRule[], ru
 /** Ensure the share bucket self-cleans old objects. Exact per-link expiry is enforced by the Worker. */
 export declare function configureBucketLifecycle(apiToken: string, accountId: string, bucketName: string, opts?: ProvisionOptions): Promise<void>;
 /** Upload the module Worker with an R2 binding (`BUCKET`). Secrets are set via the Workers Secrets API. */
-export declare function deployWorker(apiToken: string, accountId: string, workerName: string, script: string, bucketName: string, opts?: ProvisionOptions): Promise<void>;
+export declare function deployWorker(apiToken: string, accountId: string, workerName: string, worker: string | WorkerBundle, bucketName: string, opts?: ProvisionOptions): Promise<void>;
 /** sha256 of the rendered Worker script, so a deployed endpoint can be compared
  * against the current `worker-template.ts` without redeploying to find out. */
 export declare function hashWorkerScript(script: string): string;
@@ -100,7 +101,7 @@ export type UpdateWorkerOpts = ProvisionOptions & {
  * re-setting the secret to its own value after every deploy gets the same
  * outcome without depending on an unverified upload-time flag.
  */
-export declare function updateWorker(apiToken: string, accountId: string, workerName: string, bucketName: string, script: string, writeToken: string, previousHash: string | undefined, opts?: UpdateWorkerOpts): Promise<UpdateWorkerResult>;
+export declare function updateWorker(apiToken: string, accountId: string, workerName: string, bucketName: string, worker: string | WorkerBundle, writeToken: string, previousHash: string | undefined, opts?: UpdateWorkerOpts): Promise<UpdateWorkerResult>;
 /** Add/update a secret_text binding using Cloudflare's Workers Secrets API. */
 export declare function putWorkerSecret(apiToken: string, accountId: string, workerName: string, name: string, text: string, opts?: ProvisionOptions): Promise<void>;
 /** Add/update the WRITE_TOKEN binding using Cloudflare's Workers Secrets API. */

package/dist/lib/share/provision.js

@@ -77,7 +77,7 @@ export async function configureBucketLifecycle(apiToken, accountId, bucketName,
     });
 }
 /** Upload the module Worker with an R2 binding (`BUCKET`). Secrets are set via the Workers Secrets API. */
-export async function deployWorker(apiToken, accountId, workerName, script, bucketName, opts = {}) {
+export async function deployWorker(apiToken, accountId, workerName, worker, bucketName, opts = {}) {
     const request = opts.request ?? defaultCloudflareRequester;
     const metadata = {
         main_module: 'worker.js',
@@ -88,7 +88,11 @@ export async function deployWorker(apiToken, accountId, workerName, script, buck
     };
     const form = new FormData();
     form.set('metadata', new Blob([JSON.stringify(metadata)], { type: 'application/json' }));
-    form.set('worker.js', new Blob([script], { type: 'application/javascript+module' }), 'worker.js');
+    const bundle = typeof worker === 'string' ? { script: worker, modules: [] } : worker;
+    form.set('worker.js', new Blob([bundle.script], { type: 'application/javascript+module' }), 'worker.js');
+    for (const module of bundle.modules) {
+        form.set(module.name, new Blob([module.contents], { type: module.contentType }), module.name);
+    }
     await request({
         apiToken,
         method: 'PUT',
@@ -130,7 +134,8 @@ export const WORKER_PHOENIX_ID_BASE_SECRET = 'PHOENIX_ID_BASE';
  * re-setting the secret to its own value after every deploy gets the same
  * outcome without depending on an unverified upload-time flag.
  */
-export async function updateWorker(apiToken, accountId, workerName, bucketName, script, writeToken, previousHash, opts = {}) {
+export async function updateWorker(apiToken, accountId, workerName, bucketName, worker, writeToken, previousHash, opts = {}) {
+    const script = typeof worker === 'string' ? worker : worker.script;
     const templateHash = hashWorkerScript(script);
     if (!opts.force && previousHash === templateHash) {
         // Script is current so we skip the upload (which would wipe secrets). A
@@ -142,7 +147,7 @@ export async function updateWorker(apiToken, accountId, workerName, bucketName,
         }
         return { templateHash, skipped: true };
     }
-    await deployWorker(apiToken, accountId, workerName, script, bucketName, opts);
+    await deployWorker(apiToken, accountId, workerName, worker, bucketName, opts);
     // Script upload clears bindings/secrets (see JSDoc above). If re-applying
     // WRITE_TOKEN fails here, the live Worker has no write token — every
     // `agents artifacts share` publish/delete 401s until a re-run of `agents artifacts share update`

package/dist/lib/share/worker-template.d.ts

@@ -1,4 +1,27 @@
-/** Bundle the Worker and its renderer into one uploadable ES module. */
+/**
+ * Render the Worker source. Pure — the R2 binding + token are wired at deploy time.
+ *
+ * The literal below still spells the CLI `agents share` in its provenance comment,
+ * its root response, and its gallery title, even though the command is now
+ * `agents artifacts share` (RUSH-2580). That is deliberate: `hashWorkerScript` of
+ * this exact text is what `shareTemplateStatus` compares a provisioned endpoint's
+ * recorded `templateHash` against, so editing ANY byte here marks every already-
+ * deployed endpoint `outdated` — which makes `agents artifacts share list` refuse
+ * until its owner re-runs `agents artifacts share update`. Cosmetic renames are not
+ * worth that; change this text only alongside a real Worker behavior change.
+ */
+export interface WorkerModule {
+    name: string;
+    contentType: 'application/wasm';
+    contents: Uint8Array<ArrayBuffer>;
+}
+export interface WorkerBundle {
+    script: string;
+    modules: WorkerModule[];
+}
+/** Bundle the Worker renderer into an ES module plus workerd-compiled WASM modules. */
+export declare function renderWorkerBundle(): WorkerBundle;
+/** Single-file representation for direct Node tests, which cannot import compiled WASM modules. */
 export declare function renderWorkerScript(): string;
 /** Unbundled Worker source. Kept separate so esbuild can resolve npm modules. */
 export declare function renderWorkerSource(): string;

package/dist/lib/share/worker-template.js

@@ -1,81 +1,53 @@
 import { buildSync } from 'esbuild';
 import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
-// The Cloudflare Worker that fronts the R2 share bucket.
-//
-// One tiny Worker does both sides:
-//   - PUT  /<username>/<slug>  — write-gated by authorizeWrite's THREE principals
-//     (not a fallback chain — each is a distinct legitimate identity):
-//       1. Static WRITE_TOKEN (BYO Cloudflare) — checked first when the presented
-//          bearer equals env.WRITE_TOKEN. owner = env.SHARE_NAMESPACE or the
-//          path's first segment.
-//       2. Phoenix bearer — otherwise GET ${env.PHOENIX_ID_BASE}/api/v1/auth/me
-//          with that bearer → {userId,email}; 401 if absent/invalid.
-//          customMetadata.owner = userId (stable). The path's first segment MUST
-//          equal handleFromEmail(email) (the public handle, e.g. muqsitnawaz),
-//          so one user cannot write another's prefix (403 namespace mismatch).
-//          A __handles/<handle> claim binds the handle to the first userId that
-//          writes it; a different userId gets 409 handle taken.
-//       3. __share HMAC cookie — the signed-in viewer's identity cookie (same
-//          {userId,email} identityFromCookie verifies for GET). Lets the shared
-//          page's inline visibility control PATCH with credentials:'include' and
-//          no bearer; SameSite=Lax blocks it cross-site, and the same namespace/
-//          owner checks confine it to the holder's own pages. Applies to PUT,
-//          PATCH, and DELETE alike, since all three share authorizeWrite.
-//     A managed deployment sets PHOENIX_ID_BASE; BYO sets WRITE_TOKEN; the
-//     platform endpoint may set both. Fail loud (401) when none authenticates.
-//     Writes the body to R2 via the BUCKET binding, storing visibility
-//     (public|unlisted|me|org), owner, org_domain (org only), an optional
-//     expires-at, plus provenance (agent/session/host/repo/date), a label, and
-//     any `--meta` entries in object metadata. me/org require a Phoenix
-//     identity (BYO WRITE_TOKEN cannot publish them). org from a public inbox
-//     domain is 400. Overwriting an existing slug first copies the current
-//     object to <slug>/rev-<ts>-<rand> (revision history) unless
-//     x-share-no-revision is set.
-//   - PATCH /<username>/<slug> — authenticated metadata-only edit. Rewrites the
-//     exact existing body with all HTTP/custom metadata preserved except the
-//     explicitly requested label/arbitrary metadata changes; never revisions.
-//     Conditional put (onlyIf etagMatches) so a concurrent republish 409s
-//     instead of rolling the body back. Phoenix requires customMetadata.owner
-//     === auth.owner (fail closed when the stamp is missing); WRITE_TOKEN is
-//     the admin repair path.
-//   - GET  /<username>/<slug>  — public|unlisted are anonymous; me requires the
-//     Phoenix owner, org requires a same-domain Phoenix identity (Bearer, then
-//     HMAC cookie, then phoenix_ticket). Unauthenticated me/org 302s to
-//     Phoenix login (or 401 JSON if PHOENIX_ID_BASE is unset). 410s (and lazily
-//     deletes) once its expiry has passed. A bucket lifecycle rule is the durable
-//     sweeper; this is the immediate gate.
-//   - GET  /<username>/<slug>?revisions=json — machine-readable history of the
-//     retained prior versions under that slug, newest first.
-//   - GET  /<username>         — public gallery of that user's shares (HTML).
-//   - GET  /<username>?format=json — public machine-readable listing of that user's
-//     ACTIVE shares (`agents artifacts share list`). Same single-segment path as the HTML
-//     gallery and gated on the SAME "does <username>/ hold any object" check, so it
-//     only intercepts a genuine namespace — a legacy flat slug with ?format=json
-//     still serves its real content, never a fake empty listing.
-//   - GET  /<slug>             — backward-compat flat slug (legacy shares before
-//     per-user namespaces).
-//
-// Emitted as a string, so it compiles into `dist/**` and ships with no
-// package.json#files change. `provision.ts` uploads
-// this verbatim as an ES-module Worker with a BUCKET (R2) binding + a WRITE_TOKEN secret.
-/**
- * Render the Worker source. Pure — the R2 binding + token are wired at deploy time.
- *
- * The literal below still spells the CLI `agents share` in its provenance comment,
- * its root response, and its gallery title, even though the command is now
- * `agents artifacts share` (RUSH-2580). That is deliberate: `hashWorkerScript` of
- * this exact text is what `shareTemplateStatus` compares a provisioned endpoint's
- * recorded `templateHash` against, so editing ANY byte here marks every already-
- * deployed endpoint `outdated` — which makes `agents artifacts share list` refuse
- * until its owner re-runs `agents artifacts share update`. Cosmetic renames are not
- * worth that; change this text only alongside a real Worker behavior change.
- */
-let bundledWorkerScript;
-/** Bundle the Worker and its renderer into one uploadable ES module. */
+let bundledWorker;
+let nodeWorkerScript;
+/** Bundle the Worker renderer into an ES module plus workerd-compiled WASM modules. */
+export function renderWorkerBundle() {
+    if (bundledWorker)
+        return bundledWorker;
+    const result = buildSync({
+        stdin: {
+            contents: renderWorkerSource(),
+            loader: 'js',
+            resolveDir: dirname(fileURLToPath(import.meta.url)),
+            sourcefile: 'agents-share-worker.js',
+        },
+        bundle: true,
+        format: 'esm',
+        platform: 'browser',
+        target: 'es2022',
+        write: false,
+        outdir: 'worker-bundle',
+        assetNames: '[name]-[hash]',
+        minify: true,
+        // Fonts are plain data and can live in JavaScript. WASM must remain a
+        // compiled module: workerd deliberately forbids runtime code generation,
+        // so esbuild's `binary` loader produces a bundle that works in Node but
+        // throws "Wasm code generation disallowed by embedder" in Cloudflare.
+        loader: { '.wasm': 'copy', '.woff': 'binary' },
+    });
+    const script = result.outputFiles.find((output) => output.path.endsWith('.js'));
+    if (!script)
+        throw new Error('Worker bundling produced no JavaScript output.');
+    const modules = result.outputFiles
+        .filter((output) => output.path.endsWith('.wasm'))
+        .map((output) => ({
+        name: output.path.split('/').pop(),
+        contentType: 'application/wasm',
+        contents: new Uint8Array(output.contents),
+    }));
+    if (modules.length !== 2) {
+        throw new Error(`Worker bundling produced ${modules.length} WASM modules; expected yoga and resvg.`);
+    }
+    bundledWorker = { script: script.text, modules };
+    return bundledWorker;
+}
+/** Single-file representation for direct Node tests, which cannot import compiled WASM modules. */
 export function renderWorkerScript() {
-    if (bundledWorkerScript)
-        return bundledWorkerScript;
+    if (nodeWorkerScript)
+        return nodeWorkerScript;
     const result = buildSync({
         stdin: {
             contents: renderWorkerSource(),
@@ -93,9 +65,9 @@ export function renderWorkerScript() {
     });
     const output = result.outputFiles[0];
     if (!output)
-        throw new Error('Worker bundling produced no JavaScript output.');
-    bundledWorkerScript = output.text;
-    return bundledWorkerScript;
+        throw new Error('Worker test bundling produced no JavaScript output.');
+    nodeWorkerScript = output.text;
+    return nodeWorkerScript;
 }
 /** Unbundled Worker source. Kept separate so esbuild can resolve npm modules. */
 export function renderWorkerSource() {
@@ -491,13 +463,22 @@ export default {
 
             const pageHtml = await page.text();
             const meta = page.customMetadata || {};
-            const png = await hooks.renderOgCard({
-              title: meta['og-title'] || extractHtmlMeta(pageHtml, 'title') || meta.label || segments[1],
-              description: meta['og-description'] || extractHtmlMeta(pageHtml, 'description') || '',
-              handle: segments[0],
-              visibility: pageVisibility,
-              orgDomain: meta.org_domain || '',
-            });
+            let png;
+            try {
+              png = await hooks.renderOgCard({
+                title: meta['og-title'] || extractHtmlMeta(pageHtml, 'title') || meta.label || segments[1],
+                description: meta['og-description'] || extractHtmlMeta(pageHtml, 'description') || '',
+                handle: segments[0],
+                visibility: pageVisibility,
+                orgDomain: meta.org_domain || '',
+              });
+            } catch (error) {
+              const detail = error instanceof Error ? error.message : String(error);
+              return new Response('OG card render failed: ' + detail, {
+                status: 500,
+                headers: { 'content-type': 'text/plain; charset=utf-8' },
+              });
+            }
             const beforeStore = await env.BUCKET.get(pagePath);
             if (!beforeStore || beforeStore.etag !== page.etag) { existingCover = null; continue; }
             await env.BUCKET.put(path, png, {

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

@@ -26,7 +26,8 @@ export declare const KNOWN_TOP_LEVEL_COMMANDS: ReadonlySet<string>;
  * (linear-cli) (RUSH-2932). `alias` moved under `agents setup alias` (RUSH-2965).
  * `inbox` was a pure alias of `agents feed` (RUSH-2984). `unshare` nested under
  * `agents artifacts unshare` (RUSH-2989). `audit` nested under `agents events audit`.
- * `trends` nested under `agents insights mix` / `insights trends`. `serve` (the
+ * `trends` was removed with the insights recipe collapse — the one counter
+ * surface is `agents insights mix` (PHNX-3391). `serve` (the
  * read-only local web companion + `--control` anchor) was removed with the
  * unshipped iOS Fleet Cockpit it existed for (RUSH-3001). `apply` nested under
  * `agents fleet apply` / `agents devices apply`. `beta` nested under
@@ -34,7 +35,12 @@ export declare const KNOWN_TOP_LEVEL_COMMANDS: ReadonlySet<string>;
  * removed; `agents auth` returned against Phoenix ID with `auth space` as the
  * team surface (RUSH-2581). `usage` was removed as a duplicate surface of
  * `agents view`, which renders per-account usage with account, version, and
- * auth state beside it (RUSH-3079).
+ * auth state beside it (RUSH-3079). `perf` nested under `agents insights perf`
+ * — performance metrics are an insight, not a top-level noun (PHNX-3391).
+ * `list` was removed — it was a long-deprecated full duplicate of `agents view`
+ * (it already printed "agents list is now agents view"); `agents view` is the
+ * one version-listing surface (PHNX-3391). The `agents trash restore` subcommand
+ * was likewise removed as an exact duplicate of top-level `agents restore`.
  */
 export declare const RETIRED_TOP_LEVEL_COMMANDS: ReadonlySet<string>;
 export declare function isKnownTopLevelCommand(name: string): boolean;

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

@@ -1,11 +1,11 @@
 const LOADED_COMMAND_NAMES = [
     'accounts', 'auth', 'view', 'inspect', 'feedback', 'commands', 'hooks', 'skills', 'rules', 'memory',
-    'permissions', 'mcp', 'clis', 'subagents', 'plugins', 'workflows', 'add', 'use', 'list',
+    'permissions', 'mcp', 'clis', 'subagents', 'plugins', 'workflows', 'add', 'use',
     'remove', 'rm', 'purge', 'update', 'prune', 'import', 'registry', 'search', 'install',
     'routines', 'monitors', 'projects', 'run', 'open', 'reconnect', 'fork', 'config',
     'models', 'modes', 'trash', 'restore', 'doctor',
     'route', 'harness', 'harnesses', 'secrets', 'menubar', 'sync',
-    'refresh-rules', 'factory', 'insights', 'trace', 'perf',
+    'refresh-rules', 'factory', 'insights', 'trace',
     'pty', 'tmux', 'watchdog', 'browser', 'computer', 'logs', 'events',
     'ssh', 'devices', 'fleet', 'repos', 'repo', 'setup', 'uninstall', 'upgrade', 'sessions',
     'teams', 'cloud', 'message', 'send', 'notify', 'feed',
@@ -46,7 +46,8 @@ export const KNOWN_TOP_LEVEL_COMMANDS = new Set([
  * (linear-cli) (RUSH-2932). `alias` moved under `agents setup alias` (RUSH-2965).
  * `inbox` was a pure alias of `agents feed` (RUSH-2984). `unshare` nested under
  * `agents artifacts unshare` (RUSH-2989). `audit` nested under `agents events audit`.
- * `trends` nested under `agents insights mix` / `insights trends`. `serve` (the
+ * `trends` was removed with the insights recipe collapse — the one counter
+ * surface is `agents insights mix` (PHNX-3391). `serve` (the
  * read-only local web companion + `--control` anchor) was removed with the
  * unshipped iOS Fleet Cockpit it existed for (RUSH-3001). `apply` nested under
  * `agents fleet apply` / `agents devices apply`. `beta` nested under
@@ -54,7 +55,12 @@ export const KNOWN_TOP_LEVEL_COMMANDS = new Set([
  * removed; `agents auth` returned against Phoenix ID with `auth space` as the
  * team surface (RUSH-2581). `usage` was removed as a duplicate surface of
  * `agents view`, which renders per-account usage with account, version, and
- * auth state beside it (RUSH-3079).
+ * auth state beside it (RUSH-3079). `perf` nested under `agents insights perf`
+ * — performance metrics are an insight, not a top-level noun (PHNX-3391).
+ * `list` was removed — it was a long-deprecated full duplicate of `agents view`
+ * (it already printed "agents list is now agents view"); `agents view` is the
+ * one version-listing surface (PHNX-3391). The `agents trash restore` subcommand
+ * was likewise removed as an exact duplicate of top-level `agents restore`.
  */
 export const RETIRED_TOP_LEVEL_COMMANDS = new Set([
     'webhook',
@@ -85,6 +91,8 @@ export const RETIRED_TOP_LEVEL_COMMANDS = new Set([
     'trends',
     'apply',
     'beta',
+    'perf',
+    'list',
 ]);
 export function isKnownTopLevelCommand(name) {
     return KNOWN_TOP_LEVEL_COMMANDS.has(name);