@phnx-labs/agents-cli 1.22.62 → 1.22.64

package/dist/lib/exec.js

@@ -14,7 +14,7 @@ import { parseTimeout } from './scheduling/routines.js';
 import { compareVersions, getBinaryPath, getVersionHomePath, isVersionInstalled, listInstalledVersions, resolveVersion } from './installations/versions.js';
 import { resolveModel, buildReasoningFlags } from './models.js';
 import { isTierToken, resolveTier } from './model-tiers.js';
-import { createTimer, redactPrompt, redactArgs } from './feed/events.js';
+import { emit, createTimer, redactPrompt, redactArgs } from './feed/events.js';
 import { sanitizeProcessEnv } from './secrets/bundles.js';
 import { resolveActor, actorEnv } from './actor.js';
 import { expandLocalHome } from './project-root.js';
@@ -1151,6 +1151,12 @@ export async function execShimPassthrough(agent, rawArgs, cwd, pinnedVersion) {
     // buildExecEnv — `installations/shims.ts` generateShimScript).
     const env = buildExecEnv({ agent, version, cwd, mode: defaultModeFor(agent), effort: 'auto', env: { AGENT_LAUNCH_ID: launchId } });
     const { command, args, shell } = resolveShimSpawn(process.platform, binary, [...launchArgs, ...rawArgs]);
+    // Pre-launch marker for the SECOND live launch path: the Windows generated
+    // `.cmd` shim delegates here and spawns the harness directly, so without this
+    // a pinned, logged-out version launched via the shim would be invisible —
+    // exactly the blind spot this event closes. Best-effort; re-derives the
+    // signed-in verdict from the pinned version home (no rotated pick here).
+    await emitRunLaunch({ agent, version, resolvedVia: 'shim' });
     return new Promise((resolve) => {
         const child = spawn(command, args, { cwd, stdio: 'inherit', env, shell });
         // Record the launch so `ag sessions --active` can attribute the agent
@@ -1633,15 +1639,88 @@ function emitResolvedSessionId(options, launchId, childPid) {
         process.stdout.write(sessionIdMarkerLine(sessionId));
 }
 /**
- * Spawn an agent process and return its exit code plus a tee'd copy of stderr.
+ * Build the `run.launch` event payload. Pure and exported so the signedIn ->
+ * launchedLoggedOut mapping is unit-testable without spawning. Mirrors the
+ * buildRotationDecisionEvent / emitRotationDecision split in rotate.ts.
  *
- * Stderr is always piped so the caller can inspect it (e.g., for rate-limit
- * detection) while also forwarding every chunk to process.stderr in real time --
- * the user sees the same output they would with stdio: 'inherit'. Stdout keeps
- * the original behavior: 'pipe' when downstream output is piped (so `agents
- * run ... | ...` composes cleanly), otherwise 'inherit' so TTY output is
- * unbuffered.
+ * `launchedLoggedOut` is the headline flag — true ONLY when `signedIn` was
+ * resolved to false (a launch into a logged-out version, the yosemite-m3 2.1.219
+ * incident). An UNKNOWN verdict (`signedIn === null`) is never treated as
+ * logged out.
  */
+export function buildRunLaunchPayload(input) {
+    return {
+        module: 'run',
+        agent: input.agent,
+        ...(input.harnessName ? { harnessName: input.harnessName } : {}),
+        // Omitted only when no version could be resolved at all — the typed `version`
+        // field can't carry null, and an absent version is honest.
+        version: input.version,
+        strategy: input.strategy ?? null,
+        signedIn: input.signedIn,
+        launchedLoggedOut: input.signedIn === false,
+        email: input.email,
+        ...(input.resolvedVia ? { resolvedVia: input.resolvedVia } : {}),
+    };
+}
+/**
+ * Emit the pre-launch `run.launch` observability event just before the harness
+ * child is spawned. Best-effort by construction — the whole point is that it can
+ * NEVER break a launch, so every step (the signed-in probe, the emit itself) is
+ * wrapped and a failure is swallowed. Mirrors the non-fatal pattern of
+ * recordDispatchedRun and emitRotationDecision.
+ *
+ * The `signedIn` verdict is for the SPECIFIC launched version on THIS device, so
+ * `launchedLoggedOut` catches a launch into a logged-out version that
+ * `--device auto` readiness let through (the yosemite-m3 2.1.219 incident). It is
+ * REUSED from `ctx.launchSignedIn` when the caller already computed it via the
+ * identical gate (the rotated pick — no double fs read, no disagreement window),
+ * and only otherwise re-derived via {@link isVersionLaunchableHere} (dynamically
+ * imported so the spawn path takes on no static dependency on the accounting
+ * layer).
+ */
+async function emitRunLaunch(ctx) {
+    try {
+        let signedIn;
+        let email;
+        if (ctx.launchSignedIn !== undefined) {
+            // Caller already computed the verdict for this exact version via the same
+            // gate — reuse it verbatim.
+            signedIn = ctx.launchSignedIn;
+            email = ctx.launchEmail ?? null;
+        }
+        else {
+            // Pinned-default / shim paths: probe the version home now. Without a
+            // concrete version we cannot probe, so leave the verdict unknown (null)
+            // rather than guess.
+            signedIn = null;
+            email = null;
+            if (ctx.version) {
+                try {
+                    const { isVersionLaunchableHere } = await import('./accounting/rotate.js');
+                    const state = await isVersionLaunchableHere(ctx.agent, ctx.version);
+                    signedIn = state.launchable;
+                    email = state.email;
+                }
+                catch {
+                    /* probe unavailable — record the launch without the signed-in verdict */
+                }
+            }
+        }
+        emit('run.launch', buildRunLaunchPayload({
+            agent: ctx.agent,
+            harnessName: ctx.harnessName,
+            version: ctx.version,
+            strategy: ctx.strategy,
+            signedIn,
+            email,
+            resolvedVia: ctx.resolvedVia,
+        }));
+    }
+    catch {
+        /* observability must never break a launch */
+    }
+}
 async function spawnAgent(options) {
     // Assign a known session id up front for agents that accept one, so the
     // launcher can record an EXACT pid -> session mapping (see pid-registry) —
@@ -1758,6 +1837,23 @@ async function spawnAgent(options) {
         timer.end({ exitCode: 1, status: 'failed', error: 'remote interactive run has no tmux for durability' });
         return { exitCode: 1, stdout: '', stderr: msg };
     }
+    // Pre-launch marker (`run.launch`), fired on THIS device right before the
+    // harness child is spawned — for BOTH the tmux-wrapped and bare paths below,
+    // and only once the undurable refusal above has passed (a refused run never
+    // spawns). Unlike `run.dispatched` (recordDispatchedRun, at FINALIZE), this
+    // records a launch that then sits stuck at a login screen and never finalizes,
+    // so a launch into a logged-out version is visible instead of silent. The
+    // signed-in verdict is REUSED from the rotated pick when the command threaded
+    // it (options.launchSignedIn), else re-derived from the version home.
+    await emitRunLaunch({
+        agent: options.agent,
+        harnessName: options.harnessName,
+        version: options.version ?? resolveVersion(options.agent, options.cwd || process.cwd()) ?? undefined,
+        strategy: options.strategy,
+        resolvedVia: options.resolvedVia,
+        launchSignedIn: options.launchSignedIn,
+        launchEmail: options.launchEmail,
+    });
     if (tmuxWrap.kind === 'wrap') {
         timer.mark('startup');
         try {

package/dist/lib/feed/events.d.ts

@@ -13,7 +13,7 @@
  */
 import type { ActorKind } from '../actor.js';
 export type EventLevel = 'audit' | 'warn' | 'info' | 'debug';
-export type EventType = 'agent.run.start' | 'agent.run.end' | 'agent.spawn.start' | 'agent.spawn.end' | 'run.dispatched' | 'daemon.start' | 'daemon.stop' | 'daemon.error' | 'daemon.info' | 'routine.start' | 'routine.end' | 'watchdog.action' | 'version.install' | 'version.switch' | 'version.remove' | 'skill.install' | 'skill.remove' | 'browser.launch' | 'browser.close' | 'browser.navigate' | 'browser.screenshot' | 'computer.action' | 'secrets.get' | 'secrets.unlocked' | 'secrets.create' | 'secrets.import' | 'secrets.export' | 'secrets.view' | 'secrets.lease-denied' | 'secrets.lease-expire' | 'secrets.set' | 'secrets.delete' | 'secrets.rename' | 'cloud.dispatch' | 'cloud.complete' | 'cloud.cancel' | 'cloud.message' | 'teams.create' | 'teams.add' | 'teams.start' | 'teams.complete' | 'teams.disband' | 'hook.fire' | 'hook.complete' | 'hook.error' | 'mcp.add' | 'mcp.remove' | 'mcp.register' | 'resource.sync' | 'rotation.resolved' | 'rotation.unresolved' | 'command.start' | 'command.end' | 'perf.timing' | 'session.start' | 'session.end' | 'webhook.received' | 'webhook.authorized' | 'webhook.rejected' | 'webhook.matched' | 'webhook.fired' | 'webhook.failed' | 'webhook.handler.start' | 'webhook.handler.end' | 'plan.created' | 'pr.opened' | 'pr.merged' | 'worktree.created' | 'worktree.removed' | 'commit.created' | 'pushed' | 'subagent.spawned' | 'artifact.created' | 'task.completed' | 'checklist.created' | 'status.posted' | 'file.edited' | 'factory.command' | 'factory.action' | 'factory.uri' | 'factory.launch' | 'friction' | 'error' | 'warn' | 'info' | 'debug';
+export type EventType = 'agent.run.start' | 'agent.run.end' | 'agent.spawn.start' | 'agent.spawn.end' | 'run.dispatched' | 'run.launch' | 'daemon.start' | 'daemon.stop' | 'daemon.error' | 'daemon.info' | 'routine.start' | 'routine.end' | 'watchdog.action' | 'version.install' | 'version.switch' | 'version.remove' | 'skill.install' | 'skill.remove' | 'browser.launch' | 'browser.close' | 'browser.navigate' | 'browser.screenshot' | 'computer.action' | 'secrets.get' | 'secrets.unlocked' | 'secrets.create' | 'secrets.import' | 'secrets.export' | 'secrets.view' | 'secrets.lease-denied' | 'secrets.lease-expire' | 'secrets.set' | 'secrets.delete' | 'secrets.rename' | 'cloud.dispatch' | 'cloud.complete' | 'cloud.cancel' | 'cloud.message' | 'teams.create' | 'teams.add' | 'teams.start' | 'teams.complete' | 'teams.disband' | 'hook.fire' | 'hook.complete' | 'hook.error' | 'mcp.add' | 'mcp.remove' | 'mcp.register' | 'resource.sync' | 'rotation.resolved' | 'rotation.unresolved' | 'command.start' | 'command.end' | 'perf.timing' | 'session.start' | 'session.end' | 'webhook.received' | 'webhook.authorized' | 'webhook.rejected' | 'webhook.matched' | 'webhook.fired' | 'webhook.failed' | 'webhook.handler.start' | 'webhook.handler.end' | 'plan.created' | 'pr.opened' | 'pr.merged' | 'worktree.created' | 'worktree.removed' | 'commit.created' | 'pushed' | 'subagent.spawned' | 'artifact.created' | 'task.completed' | 'checklist.created' | 'status.posted' | 'file.edited' | 'factory.command' | 'factory.action' | 'factory.uri' | 'factory.launch' | 'friction' | 'error' | 'warn' | 'info' | 'debug';
 /** Every known event kind. Derived from {@link EVENT_TYPE_TABLE}, never hand-listed. */
 export declare const EVENT_TYPES: readonly EventType[];
 /** Runtime guard for an event kind arriving from outside this process. */

package/dist/lib/feed/events.js

@@ -121,6 +121,7 @@ const FILE_MODE = 0o600;
 const EVENT_TYPE_TABLE = {
     'agent.run.start': true, 'agent.run.end': true, 'agent.spawn.start': true, 'agent.spawn.end': true,
     'run.dispatched': true,
+    'run.launch': true,
     'daemon.start': true, 'daemon.stop': true, 'daemon.error': true, 'daemon.info': true,
     'routine.start': true, 'routine.end': true,
     'watchdog.action': true,
@@ -158,6 +159,10 @@ export function isEventType(value) {
 const AUDIT_EVENTS = new Set([
     'command.start', 'command.end',
     'run.dispatched',
+    // Sibling of run.dispatched, and the MORE reliable signal for a stuck /
+    // logged-out launch (it fires pre-spawn, before an agent can hang at a login
+    // screen and never finalize). Must surface under --level audit --include runs.
+    'run.launch',
     'secrets.get', 'secrets.unlocked', 'secrets.create', 'secrets.import', 'secrets.export', 'secrets.view', 'secrets.lease-denied', 'secrets.lease-expire',
     'secrets.set', 'secrets.delete', 'secrets.rename',
     'teams.create', 'teams.add', 'teams.start', 'teams.complete', 'teams.disband',

package/dist/lib/feed-broadcast.d.ts

@@ -21,6 +21,13 @@ export interface FeedSinkConfig {
     channel?: string;
     /** Recipient for a `channel` sink. Required unless `channel` is the `owner` alias. */
     to?: string;
+    /**
+     * Optional channel body template. Uses the same placeholders as `command`
+     * argv (`{message}`, `{ticket}`, `{project}`, ...). Defaults to `{message}`.
+     * A missing placeholder skips the sink, which lets a `{ticket}` template
+     * declare that only ticket-backed posts belong in that destination.
+     */
+    message?: string;
     /** Lowest post level that reaches this sink. Defaults to `milestone` (all posts). */
     minLevel?: FeedPostLevel;
 }
@@ -150,6 +157,8 @@ export declare function composeBroadcastMessage(ctx: FeedBroadcastContext): stri
  * would otherwise comment on nothing.
  */
 export declare function renderSinkArgv(template: string[], ctx: FeedBroadcastContext): string[] | undefined;
+/** Render one channel-message template with the same fail-closed placeholder contract as argv. */
+export declare function renderSinkMessage(template: string, ctx: FeedBroadcastContext): string | undefined;
 /**
  * Which sinks this post reaches, in config order. Pure — the dry-run listing and
  * the real fan-out plan through here, so what `--dry-run` shows is what runs.

package/dist/lib/feed-broadcast.js

@@ -38,6 +38,7 @@ import { isOwnerAlias, readOwnerDest, resolveSendEnvelope, deliverEnvelope } fro
 import { lookupTransport } from './channels/resolve.js';
 import { registerBuiltinProviders } from './channels/providers/index.js';
 import { sendToOwner } from './notify.js';
+import { forwardOwnerNotifyToPeer } from './channels/owner-forward.js';
 const LEVEL_RANK = { milestone: 0, important: 1 };
 /** Parse a `--level` value; anything unrecognized is a usage error, not a default. */
 export function parseFeedPostLevel(raw) {
@@ -324,6 +325,23 @@ export function renderSinkArgv(template, ctx) {
     }
     return argv.length > 0 ? argv : undefined;
 }
+/** Render one channel-message template with the same fail-closed placeholder contract as argv. */
+export function renderSinkMessage(template, ctx) {
+    const vars = templateVars(ctx);
+    let missing = false;
+    const rendered = template.replace(PLACEHOLDER, (whole, key) => {
+        const value = vars[key];
+        if (value === undefined || value === '') {
+            missing = true;
+            return whole;
+        }
+        return value;
+    });
+    if (missing)
+        return undefined;
+    const text = rendered.trim();
+    return text || undefined;
+}
 /**
  * Which sinks this post reaches, in config order. Pure — the dry-run listing and
  * the real fan-out plan through here, so what `--dry-run` shows is what runs.
@@ -350,11 +368,14 @@ export function planFeedBroadcast(config, ctx) {
             // placeholder below).
             if (!isOwnerAlias(channel) && !sink.to?.trim())
                 continue;
+            const text = renderSinkMessage(sink.message ?? '{message}', ctx);
+            if (!text)
+                continue;
             planned.push({
                 name,
                 channel,
                 to: isOwnerAlias(channel) ? undefined : sink.to.trim(),
-                text: composeBroadcastMessage(ctx),
+                text,
             });
             continue;
         }
@@ -480,6 +501,14 @@ async function runChannelSink(sink, meta) {
     const result = await deliverEnvelope(resolved.envelope, meta);
     if (result.ok)
         return { name, ok: true };
+    // Explicit rush-backed channel sinks need the same cross-device handoff as
+    // the owner alias. Linux workers do not carry the macOS Keychain-bound Rush
+    // transport, but feed posts originate on those workers routinely. Keep the
+    // destination explicit so the peer delivers exactly this sink once instead
+    // of expanding the owner's multi-channel policy.
+    const forwarded = await forwardOwnerNotifyToPeer(resolved.envelope.text, resolved.envelope.channel, resolved.envelope.to, meta);
+    if (forwarded?.ok)
+        return { name, ok: true };
     return { name, ok: false, error: result.error };
 }
 /**

package/dist/lib/identity/client.d.ts

@@ -17,11 +17,12 @@
 /**
  * Where the account backend lives. Config, never a literal at a call site.
  *
- * The default is the deployed Phoenix ID Worker. It is a `workers.dev` URL
- * rather than a vanity hostname because no custom domain is attached yet — and
- * a default naming an unregistered domain is worse than an ugly one: every
- * `agents auth login` would fail DNS with nothing to point at.
+ * The default is Phoenix ID's branded custom domain. The legacy workers.dev
+ * hostname remains live for already-released clients, but new clients and
+ * managed Workers must share this canonical base so token verification cannot
+ * drift across the release boundary.
  */
+export declare const DEFAULT_PHOENIX_ID_BASE = "https://id.byphoenix.com";
 export declare const PHOENIX_ID_BASE: string;
 /** Our own session file. agents-cli never reads another product's credentials. */
 export declare function sessionFilePath(): string;

package/dist/lib/identity/client.js

@@ -20,12 +20,13 @@ import { getRuntimeStateDir } from '../state.js';
 /**
  * Where the account backend lives. Config, never a literal at a call site.
  *
- * The default is the deployed Phoenix ID Worker. It is a `workers.dev` URL
- * rather than a vanity hostname because no custom domain is attached yet — and
- * a default naming an unregistered domain is worse than an ugly one: every
- * `agents auth login` would fail DNS with nothing to point at.
+ * The default is Phoenix ID's branded custom domain. The legacy workers.dev
+ * hostname remains live for already-released clients, but new clients and
+ * managed Workers must share this canonical base so token verification cannot
+ * drift across the release boundary.
  */
-export const PHOENIX_ID_BASE = process.env.PHOENIX_ID_BASE ?? 'https://phoenix-id.muqsitnawaz.workers.dev';
+export const DEFAULT_PHOENIX_ID_BASE = 'https://id.byphoenix.com';
+export const PHOENIX_ID_BASE = process.env.PHOENIX_ID_BASE ?? DEFAULT_PHOENIX_ID_BASE;
 /** Our own session file. agents-cli never reads another product's credentials. */
 export function sessionFilePath() {
     return path.join(getRuntimeStateDir(), 'phoenix-session.json');

package/dist/lib/resource-inventory.d.ts

@@ -1,6 +1,6 @@
 /**
  * Resource inventory — the single chokepoint for "what does this agent@version
- * have" (RUSH-2238, parent RUSH-2236; spec: openspec/specs/resource-inventory).
+ * have" (RUSH-2238, parent RUSH-2236). Contract: cli/docs/specifications.md.
  *
  * One API answers four orthogonal questions per (agent, version, kind):
  *

package/dist/lib/resource-inventory.js

@@ -1,6 +1,6 @@
 /**
  * Resource inventory — the single chokepoint for "what does this agent@version
- * have" (RUSH-2238, parent RUSH-2236; spec: openspec/specs/resource-inventory).
+ * have" (RUSH-2238, parent RUSH-2236). Contract: cli/docs/specifications.md.
  *
  * One API answers four orthogonal questions per (agent, version, kind):
  *

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

@@ -55,7 +55,7 @@ export declare function attributedSetLostPids(prev: Set<number>, next: Set<numbe
 export declare function filterCachedUnattributed(sessions: ActiveSession[], attributed: Set<number>, alive: (pid: number, startedAtMs?: number) => boolean): ActiveSession[];
 type ActiveContext = 'terminal' | 'teams' | 'cloud' | 'headless';
 /** The SessionMeta fields the live-row backfill reads — the enrichment a running process cannot report. */
-export type BackfillMeta = Pick<SessionMeta, 'version' | 'account' | 'timestamp' | 'label' | 'ticketId' | 'prUrl' | 'prNumber' | 'origin' | 'routineName' | 'harness'>;
+export type BackfillMeta = Pick<SessionMeta, 'version' | 'account' | 'timestamp' | 'label' | 'ticketId' | 'prUrl' | 'prNumber' | 'origin' | 'routineName' | 'harness' | 'tokenCount' | 'durationMs' | 'subAgentCount'>;
 export declare function backfillActiveRowsFromMeta(sessions: ActiveSession[], metaById: Map<string, BackfillMeta>): void;
 export declare function backfillActiveRowsFromIndex(sessions: ActiveSession[]): void;
 export declare function isRunningLiveSession(s: ActiveSession): boolean;
@@ -205,6 +205,15 @@ export interface ActiveSession {
     spawnedTeam?: string;
     /** Files/screenshots attached to the session prompt. */
     attachments?: SessionAttachment[];
+    /** Total tokens and elapsed duration from the indexed transcript. */
+    tokenCount?: number;
+    durationMs?: number;
+    /** Number of subagents launched, persisted by the index scanner. */
+    subAgentCount?: number;
+    /** Durable documents created in the live transcript tail. */
+    artifacts?: import('./highlights.js').ProducedArtifact[];
+    /** Created plan document singled out for plan-first consumers. */
+    planFile?: string;
     sessionFile?: string;
     startedAtMs?: number;
     /**

package/dist/lib/session/active.js

@@ -164,6 +164,12 @@ export function backfillActiveRowsFromMeta(sessions, metaById) {
             s.routineName = m.routineName;
         if (!s.harness && m.harness)
             s.harness = m.harness;
+        if (s.tokenCount == null && m.tokenCount != null)
+            s.tokenCount = m.tokenCount;
+        if (s.durationMs == null && m.durationMs != null)
+            s.durationMs = m.durationMs;
+        if (s.subAgentCount == null && m.subAgentCount != null)
+            s.subAgentCount = m.subAgentCount;
     }
 }
 function loadBackfillMetaFor(sessions) {
@@ -851,6 +857,8 @@ function applyState(base, state, fallbackFile, pidAlive) {
         createdTickets: state.createdTickets,
         spawnedTeam: state.spawnedTeam,
         attachments: state.attachments,
+        artifacts: state.artifacts,
+        planFile: state.planFile,
         rateLimited: state.rateLimited,
     };
 }

package/dist/lib/session/digest.js

@@ -98,9 +98,15 @@ export function classifyFileChanges(events) {
             deleted.delete(p); // a write after a delete recreates the file
         }
         else if (EDIT_TOOLS.has(tool)) {
-            modified.add(p);
+            if (args.patch_op === 'Add')
+                created.add(p);
+            else if (args.patch_op === 'Delete')
+                deleted.add(p);
+            else
+                modified.add(p);
             seen.add(p);
-            deleted.delete(p);
+            if (args.patch_op !== 'Delete')
+                deleted.delete(p);
         }
     }
     const out = [];

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

@@ -70,6 +70,10 @@ export declare function parseCodex(filePath: string): SessionEvent[];
  * Returns every path in order (a multi-file patch emits multiple paths so
  * artifact discovery sees each file — RUSH-1410). Empty when unparseable.
  */
+export declare function applyPatchTargets(input: string): Array<{
+    path: string;
+    op: 'Add' | 'Update' | 'Delete';
+}>;
 export declare function applyPatchTargetPaths(input: string): string[];
 /**
  * Parse Codex JSONL *content* (already read into a string) into normalized

package/dist/lib/session/parse.js

@@ -555,15 +555,18 @@ export function parseCodex(filePath) {
  * Returns every path in order (a multi-file patch emits multiple paths so
  * artifact discovery sees each file — RUSH-1410). Empty when unparseable.
  */
-export function applyPatchTargetPaths(input) {
-    const paths = [];
-    const re = /^\*\*\* (?:Update|Add|Delete) File: (.+)$/gm;
+export function applyPatchTargets(input) {
+    const targets = [];
+    const re = /^\*\*\* (Update|Add|Delete) File: (.+)$/gm;
     for (const m of input.matchAll(re)) {
-        const p = m[1].trim();
+        const p = m[2].trim();
         if (p)
-            paths.push(p);
+            targets.push({ path: p, op: m[1] });
     }
-    return paths;
+    return targets;
+}
+export function applyPatchTargetPaths(input) {
+    return applyPatchTargets(input).map((target) => target.path);
 }
 /** @deprecated Prefer applyPatchTargetPaths — kept for single-file call sites. */
 function applyPatchTargetPath(input) {
@@ -724,13 +727,15 @@ export function parseCodexContent(content) {
                 const execCommand = rawName === 'exec' ? codexExecCommand(input) : undefined;
                 // Multi-file patches: one tool_use per file so artifact discovery sees
                 // every path (RUSH-1410). Single-file / non-patch keep one event.
-                const patchPaths = isApplyPatch ? applyPatchTargetPaths(input) : [];
+                const patchTargets = isApplyPatch ? applyPatchTargets(input) : [];
                 const tool = isApplyPatch ? 'Edit' : rawName;
                 const truncatedInput = input.length > 500 ? input.slice(0, 497) + '...' : input;
-                const emitOne = (patchPath) => {
+                const emitOne = (patchPath, patchOp) => {
                     const args = { input: truncatedInput };
                     if (patchPath)
                         args.file_path = patchPath;
+                    if (patchOp)
+                        args.patch_op = patchOp;
                     if (execCommand)
                         args.command = execCommand;
                     const callId = payload.call_id || payload.id;
@@ -747,9 +752,9 @@ export function parseCodexContent(content) {
                         path: patchPath,
                     });
                 };
-                if (isApplyPatch && patchPaths.length > 0) {
-                    for (const p of patchPaths)
-                        emitOne(p);
+                if (isApplyPatch && patchTargets.length > 0) {
+                    for (const target of patchTargets)
+                        emitOne(target.path, target.op);
                 }
                 else {
                     emitOne(undefined);

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

@@ -15,6 +15,7 @@
  * shape + mtime — same function, driven off the normalized events.
  */
 import type { SessionAttachment, SessionEvent, TodoItem, TodoProgress } from './types.js';
+import { type ProducedArtifact } from './highlights.js';
 export type { TodoItem, TodoProgress };
 export type SessionActivity = 'working' | 'waiting_input' | 'idle';
 export type AwaitingReason = 'question' | 'plan_review' | 'permission';
@@ -95,6 +96,10 @@ export interface SessionState {
      * checklist, notably for remote/device-dispatched agents with no local stream.
      */
     todos?: TodoProgress;
+    /** Durable documents created in the bounded transcript slice. */
+    artifacts?: ProducedArtifact[];
+    /** First created plan document, for consumers that give plans special treatment. */
+    planFile?: string;
     /** Last few assistant turns (most-recent last), one line each — panel context. */
     tail?: string[];
     lastActivityMs?: number;

package/dist/lib/session/state.js

@@ -17,6 +17,8 @@
 import * as path from 'path';
 import { isCompletedTodoStatus, SNAPSHOT_TODO_TOOLS, summarizeToolUse } from './parse.js';
 import { isShellExecTool } from './shell-programs.js';
+import { classifyFileChanges } from './digest.js';
+import { extractArtifacts } from './highlights.js';
 /**
  * Detect per-session rate-limit / usage-limit signals in assistant or error
  * text (RUSH-1523). Matches the same shapes the ext's prewarm detectBlockingPrompt
@@ -626,6 +628,8 @@ export function inferSessionState(events, ctx = {}) {
     const state = inferActivity(events, ctx);
     const { pr, ticket, createdTickets, spawnedTeam, attachments } = detectDurableSignals(events);
     const worktree = detectWorktree(ctx.cwd, ctx.gitBranch);
+    const artifacts = extractArtifacts(classifyFileChanges(events));
+    const planFile = artifacts.find((artifact) => artifact.bucket === 'plans')?.path;
     // Rate-limit: scan the most recent assistant messages + tool errors (tail-first).
     let rateLimited = false;
     for (let i = events.length - 1; i >= 0 && i >= events.length - 12; i--) {
@@ -651,6 +655,8 @@ export function inferSessionState(events, ctx = {}) {
         createdTickets,
         spawnedTeam,
         attachments,
+        artifacts: artifacts.length > 0 ? artifacts : undefined,
+        planFile,
         rateLimited: rateLimited || undefined,
     };
 }