@phnx-labs/agents-cli 1.20.44 → 1.20.45

package/dist/lib/hosts/session-index.js

@@ -35,8 +35,10 @@ export function hostSessionMeta(task, ctx) {
         // stale-filter treats as "always live" (see module doc).
         filePath: '',
         topic: ctx.prompt.split('\n')[0]?.slice(0, 120) || undefined,
-        label: `[host/${task.host}]`,
-        name: task.name,
+        // The run's `--name` seeds the label (resolves `agents sessions <name>` and
+        // `agents hosts logs <name>`); an unnamed host run falls back to the
+        // `[host/<name>]` indicator, mirroring the cloud path's `[cloud/<status>]`.
+        label: task.name || `[host/${task.host}]`,
     };
 }
 /**
@@ -55,3 +57,27 @@ export function registerHostSession(task, ctx) {
         /* index write is best-effort; the run is already live on the host */
     }
 }
+/**
+ * Register an interactive host run (no prompt, TTY forwarded over SSH) in the
+ * local session index. Unlike detached host runs, there is no remote log/exit
+ * file and no HostTask; we only need the session id so `agents sessions` can
+ * surface and resume it by id.
+ */
+export function registerInteractiveHostSession(ctx) {
+    if (!SESSION_AGENTS.includes(ctx.agent))
+        return;
+    try {
+        upsertSession({
+            id: ctx.sessionId,
+            shortId: ctx.sessionId.slice(0, 8),
+            agent: ctx.agent,
+            timestamp: ctx.createdAt ?? new Date().toISOString(),
+            cwd: ctx.cwd,
+            filePath: '',
+            label: ctx.name || `[host/${ctx.host}]`,
+        }, '');
+    }
+    catch {
+        /* index write is best-effort; the run is already live on the host */
+    }
+}

package/dist/lib/rotate.d.ts

@@ -56,6 +56,39 @@ export declare function getProjectRunStrategy(agent: AgentId, startPath: string)
 export declare function getConfiguredRunStrategy(agent: AgentId, startPath?: string): RunStrategy;
 /** Persist the global run strategy used by bare `agents run <agent>`. */
 export declare function setGlobalRunStrategy(agent: AgentId, strategy: RunStrategy): void;
+/**
+ * Whether a specific account can serve a run right now, and — when it can't —
+ * why. `signed_out` covers no-email / invalid-auth; `rate_limited` and
+ * `out_of_credits` name the throttle. Used to pre-warn on a version-pinned
+ * teammate whose account rotation won't route around (a pin IS the target).
+ */
+export type AccountReadiness = {
+    ready: true;
+} | {
+    ready: false;
+    reason: 'rate_limited' | 'out_of_credits' | 'signed_out';
+    email: string | null;
+};
+/**
+ * Pure decision reusing the router's own eligibility gate (`hasUsageAvailable`
+ * + email/auth, i.e. `isRotationEligible`), so a pre-flight warning can NEVER
+ * disagree with what rotation would actually do. The `reason` combines the two
+ * signals `hasUsageAvailable` reads: the live snapshot (session-inclusive
+ * rate-limit) and the coarse cached `usageStatus` (out-of-credits, which a
+ * snapshot never carries). When a live snapshot exists it wins over the cached
+ * status — matching the gate — so a stale `out_of_credits` cache is not
+ * reported while the account is actually serving requests.
+ */
+export declare function readinessFromCandidate(candidate: RotateCandidate): AccountReadiness;
+/**
+ * Readiness for a specific installed (agent, version). Returns `{ ready: true }`
+ * when the version isn't among the collected candidates — absence is the
+ * caller's `isVersionInstalled` concern, not ours; don't cry wolf. Only
+ * meaningful for a version-pinned target: a bare target rotates to a healthy
+ * account on its own, and a profile injects its own auth (a different account
+ * than the version home carries), so neither is checkable here.
+ */
+export declare function checkRunAccountReadiness(agent: AgentId, version: string): Promise<AccountReadiness>;
 /**
  * Pick a healthy candidate using weighted random by remaining capacity.
  *

package/dist/lib/rotate.js

@@ -92,6 +92,43 @@ function hasUsageAvailable(candidate) {
     }
     return true;
 }
+/**
+ * Pure decision reusing the router's own eligibility gate (`hasUsageAvailable`
+ * + email/auth, i.e. `isRotationEligible`), so a pre-flight warning can NEVER
+ * disagree with what rotation would actually do. The `reason` combines the two
+ * signals `hasUsageAvailable` reads: the live snapshot (session-inclusive
+ * rate-limit) and the coarse cached `usageStatus` (out-of-credits, which a
+ * snapshot never carries). When a live snapshot exists it wins over the cached
+ * status — matching the gate — so a stale `out_of_credits` cache is not
+ * reported while the account is actually serving requests.
+ */
+export function readinessFromCandidate(candidate) {
+    if (!candidate.email || !candidate.authValid) {
+        return { ready: false, reason: 'signed_out', email: candidate.email };
+    }
+    if (hasUsageAvailable(candidate)) {
+        return { ready: true };
+    }
+    const snap = candidate.usageSnapshot;
+    const snapRateLimited = !!snap && snap.windows.length > 0 && deriveUsageStatusFromSnapshot(snap) === 'rate_limited';
+    const reason = !snapRateLimited && candidate.usageStatus === 'out_of_credits' ? 'out_of_credits' : 'rate_limited';
+    return { ready: false, reason, email: candidate.email };
+}
+/**
+ * Readiness for a specific installed (agent, version). Returns `{ ready: true }`
+ * when the version isn't among the collected candidates — absence is the
+ * caller's `isVersionInstalled` concern, not ours; don't cry wolf. Only
+ * meaningful for a version-pinned target: a bare target rotates to a healthy
+ * account on its own, and a profile injects its own auth (a different account
+ * than the version home carries), so neither is checkable here.
+ */
+export async function checkRunAccountReadiness(agent, version) {
+    const candidates = await collectRunCandidates(agent);
+    const candidate = candidates.find((c) => c.version === version);
+    if (!candidate)
+        return { ready: true };
+    return readinessFromCandidate(candidate);
+}
 function getRoutingUsedPercent(snapshot) {
     if (!snapshot || snapshot.windows.length === 0)
         return null;

package/dist/lib/secrets/remote.d.ts

@@ -51,6 +51,20 @@ export declare function remoteSecretsRaw(target: string, args: string[], opts?:
     tty?: boolean;
     input?: string;
 }): SshExecResult;
+/**
+ * Run a remote `agents secrets <args>` FOREGROUND, with the local stdio wired
+ * straight through (`stdio: 'inherit'` + `-tt`), and return its exit code.
+ *
+ * Unlike `remoteSecretsRaw` — which pipes stdin, so even with `-tt` the remote
+ * process's `process.stdin.isTTY` is false and a passphrase prompt refuses to
+ * appear (the macOS file-store guard then hard-errors "needs
+ * AGENTS_SECRETS_PASSPHRASE") — this inherits the caller's real terminal, so the
+ * remote sees a genuine TTY and its hidden passphrase prompt surfaces and reads
+ * the keystrokes. This is the transport for `unlock --host`: you type the remote
+ * bundle's passphrase at your own terminal. Output is NOT captured (it streams
+ * to the terminal); only the exit code is returned.
+ */
+export declare function remoteSecretsStream(target: string, args: string[]): number;
 /**
  * Resolve a remote bundle to a plaintext env map by driving the remote's
  * `agents secrets export <bundle> --plaintext --format json`. Values cross over

package/dist/lib/secrets/remote.js

@@ -15,7 +15,7 @@
  * file-backend passphrase travels over ssh stdin (first line) so it never lands
  * in argv / `ps` / remote shell history. Nothing is persisted locally.
  */
-import { sshExec, assertValidSshTarget } from '../ssh-exec.js';
+import { sshExec, sshStream, assertValidSshTarget } from '../ssh-exec.js';
 import { resolveHost } from '../hosts/registry.js';
 import { emit } from '../events.js';
 import { sshTargetFor } from '../hosts/types.js';
@@ -93,6 +93,23 @@ export function remoteSecretsRaw(target, args, opts = {}) {
         extraSshArgs: opts.tty ? ['-tt'] : undefined,
     });
 }
+/**
+ * Run a remote `agents secrets <args>` FOREGROUND, with the local stdio wired
+ * straight through (`stdio: 'inherit'` + `-tt`), and return its exit code.
+ *
+ * Unlike `remoteSecretsRaw` — which pipes stdin, so even with `-tt` the remote
+ * process's `process.stdin.isTTY` is false and a passphrase prompt refuses to
+ * appear (the macOS file-store guard then hard-errors "needs
+ * AGENTS_SECRETS_PASSPHRASE") — this inherits the caller's real terminal, so the
+ * remote sees a genuine TTY and its hidden passphrase prompt surfaces and reads
+ * the keystrokes. This is the transport for `unlock --host`: you type the remote
+ * bundle's passphrase at your own terminal. Output is NOT captured (it streams
+ * to the terminal); only the exit code is returned.
+ */
+export function remoteSecretsStream(target, args) {
+    const remoteCmd = buildRemoteAgentsInvocation(['secrets', ...args], undefined, osForTarget(target));
+    return sshStream(target, remoteCmd, { tty: true });
+}
 /**
  * Resolve a remote bundle to a plaintext env map by driving the remote's
  * `agents secrets export <bundle> --plaintext --format json`. Values cross over

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

@@ -36,6 +36,10 @@ export interface ActiveSession {
     worktree?: DetectedWorktree;
     /** Tracker ticket the session is tied to. */
     ticket?: DetectedTicket;
+    /** Tracker refs the session CREATED (Linear create_issue / gh issue create). */
+    createdTickets?: string[];
+    /** Team name the session SPAWNED via `agents teams create/add`. */
+    spawnedTeam?: string;
     sessionFile?: string;
     startedAtMs?: number;
     status: ActiveStatus;

package/dist/lib/session/active.js

@@ -241,6 +241,8 @@ function applyState(base, state, fallbackFile) {
         pr: state.pr,
         worktree: state.worktree,
         ticket: state.ticket,
+        createdTickets: state.createdTickets,
+        spawnedTeam: state.spawnedTeam,
     };
 }
 /**

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

@@ -22,7 +22,6 @@ export interface SessionRow {
     git_branch: string | null;
     topic: string | null;
     label: string | null;
-    name: string | null;
     message_count: number | null;
     token_count: number | null;
     cost_usd: number | null;
@@ -130,15 +129,23 @@ export declare function upsertSessionsBatch(entries: Array<{
  */
 export declare function syncLabels(labelMap: Map<string, string | null>): number;
 /**
- * Sync `agents run --name` handles for a set of sessions, keyed by session id.
- * The name's source of truth lives outside the transcript (host task sidecars,
- * run-name sidecars written at launch), so — like {@link syncLabels} — it is
- * re-applied by id every scan rather than parsed per-file. Updates only
- * `sessions.name` (names resolve via a direct column tier in ftsSearch, not
- * FTS, so there's no session_text column to touch). Only writes when the value
- * differs; cheap to call every run. Returns the number of rows updated.
+ * Seed session labels from `agents run --name` handles, keyed by session id.
+ *
+ * `--name` is the universal launch-time way to set a session's label — the same
+ * field an agent later refines with a generated title (`syncLabels`) or the user
+ * with `/rename`. The seed's source of truth lives outside the transcript (host
+ * task sidecars, run-name sidecars written at launch), so it is re-applied by id
+ * every scan rather than parsed per-file. It only fills a label that is still
+ * EMPTY — an agent-generated title always wins over the seed, so a Claude run's
+ * `--name` shows until Claude titles it, and a non-Claude run keeps its `--name`
+ * as the label. Writes both `sessions.label` and the FTS5 label column so a
+ * seeded name is fuzzy-searchable. Cheap to call every run; returns rows updated.
+ *
+ * Ordering matters: this runs AFTER the per-agent scans (which apply
+ * agent-generated titles via {@link syncLabels}), so it never overwrites a real
+ * title — it only backfills the gap the seed was meant to cover.
  */
-export declare function syncNames(nameMap: Map<string, string | null>): number;
+export declare function seedLabelsFromNames(nameMap: Map<string, string | null>): number;
 /**
  * Sync topics (session titles) for a set of sessions, keyed by id. For agents
  * whose human-readable title lives in a side index that updates independently

package/dist/lib/session/db.js

@@ -13,7 +13,7 @@ import { getSessionsDir, getSessionsDbPath } from '../state.js';
 const SESSIONS_DIR = getSessionsDir();
 const DB_PATH = getSessionsDbPath();
 /** Current schema version; bumped when migrations are added. */
-const SCHEMA_VERSION = 9;
+const SCHEMA_VERSION = 10;
 /**
  * Canonicalize a file path for use as a scan_ledger key. The same physical
  * session file is reachable via multiple aliases — `~/.claude/projects/x.jsonl`
@@ -52,7 +52,6 @@ CREATE TABLE IF NOT EXISTS sessions (
   git_branch TEXT,
   topic TEXT,
   label TEXT,
-  name TEXT,
   message_count INTEGER,
   token_count INTEGER,
   cost_usd REAL,
@@ -198,6 +197,22 @@ function migrateSchema(db, fromVersion) {
         if (!cols.some(c => c.name === 'name'))
             db.exec(`ALTER TABLE sessions ADD COLUMN name TEXT`);
     }
+    if (fromVersion < 10) {
+        // v9 → v10: `name` and `label` unify into a single `label`. `--name` now
+        // SEEDS the label at launch (refined later by an agent-generated title)
+        // instead of living in a separate immutable `name` column. Fold any existing
+        // name into label where the label is empty, mirror it into the FTS row, then
+        // drop the redundant column. Seeds re-apply from the run-name sidecars every
+        // scan (seedLabelsFromNames), so no rescan is required.
+        const cols = db.prepare(`PRAGMA table_info(sessions)`).all();
+        if (cols.some(c => c.name === 'name')) {
+            db.exec(`UPDATE sessions SET label = name
+               WHERE (label IS NULL OR label = '') AND name IS NOT NULL AND name != ''`);
+            db.exec(`UPDATE session_text SET label = COALESCE(
+                 (SELECT label FROM sessions WHERE sessions.id = session_text.session_id), '')`);
+            db.exec(`ALTER TABLE sessions DROP COLUMN name`);
+        }
+    }
 }
 /** Open (or return the cached) sessions database, applying migrations as needed. */
 export function getDB() {
@@ -411,13 +426,13 @@ export function recordScans(entries) {
 const upsertSessionStmt = (db) => db.prepare(`
   INSERT INTO sessions (
     id, short_id, agent, version, account, timestamp, last_activity,
-    project, cwd, git_branch, topic, label, name, message_count, token_count,
+    project, cwd, git_branch, topic, label, message_count, token_count,
     cost_usd, duration_ms,
     file_path, file_mtime_ms, file_size, scanned_at, is_team_origin,
     pr_url, pr_number, worktree_slug, ticket_id
   ) VALUES (
     @id, @short_id, @agent, @version, @account, @timestamp, @last_activity,
-    @project, @cwd, @git_branch, @topic, @label, @name, @message_count, @token_count,
+    @project, @cwd, @git_branch, @topic, @label, @message_count, @token_count,
     @cost_usd, @duration_ms,
     @file_path, @file_mtime_ms, @file_size, @scanned_at, @is_team_origin,
     @pr_url, @pr_number, @worktree_slug, @ticket_id
@@ -481,7 +496,6 @@ export function upsertSession(meta, content, scan) {
         git_branch: meta.gitBranch ?? null,
         topic: meta.topic ?? null,
         label: meta.label ?? null,
-        name: meta.name ?? null,
         message_count: meta.messageCount ?? null,
         token_count: meta.tokenCount ?? null,
         cost_usd: meta.costUsd ?? null,
@@ -570,7 +584,6 @@ export function upsertSessionsBatch(entries) {
                     git_branch: meta.gitBranch ?? null,
                     topic: meta.topic ?? null,
                     label: meta.label ?? null,
-                    name: meta.name ?? null,
                     message_count: meta.messageCount ?? null,
                     token_count: meta.tokenCount ?? null,
                     cost_usd: meta.costUsd ?? null,
@@ -639,15 +652,23 @@ export function syncLabels(labelMap) {
     return updates.length;
 }
 /**
- * Sync `agents run --name` handles for a set of sessions, keyed by session id.
- * The name's source of truth lives outside the transcript (host task sidecars,
- * run-name sidecars written at launch), so — like {@link syncLabels} — it is
- * re-applied by id every scan rather than parsed per-file. Updates only
- * `sessions.name` (names resolve via a direct column tier in ftsSearch, not
- * FTS, so there's no session_text column to touch). Only writes when the value
- * differs; cheap to call every run. Returns the number of rows updated.
+ * Seed session labels from `agents run --name` handles, keyed by session id.
+ *
+ * `--name` is the universal launch-time way to set a session's label — the same
+ * field an agent later refines with a generated title (`syncLabels`) or the user
+ * with `/rename`. The seed's source of truth lives outside the transcript (host
+ * task sidecars, run-name sidecars written at launch), so it is re-applied by id
+ * every scan rather than parsed per-file. It only fills a label that is still
+ * EMPTY — an agent-generated title always wins over the seed, so a Claude run's
+ * `--name` shows until Claude titles it, and a non-Claude run keeps its `--name`
+ * as the label. Writes both `sessions.label` and the FTS5 label column so a
+ * seeded name is fuzzy-searchable. Cheap to call every run; returns rows updated.
+ *
+ * Ordering matters: this runs AFTER the per-agent scans (which apply
+ * agent-generated titles via {@link syncLabels}), so it never overwrites a real
+ * title — it only backfills the gap the seed was meant to cover.
  */
-export function syncNames(nameMap) {
+export function seedLabelsFromNames(nameMap) {
     if (nameMap.size === 0)
         return 0;
     const db = getDB();
@@ -658,21 +679,25 @@ export function syncNames(nameMap) {
         const chunk = ids.slice(i, i + CHUNK);
         const placeholders = chunk.map(() => '?').join(',');
         const rows = db
-            .prepare(`SELECT id, name FROM sessions WHERE id IN (${placeholders})`)
+            .prepare(`SELECT id, label FROM sessions WHERE id IN (${placeholders})`)
             .all(...chunk);
         for (const row of rows) {
-            const live = nameMap.get(row.id) ?? null;
-            if ((live ?? '') !== (row.name ?? '')) {
-                updates.push({ id: row.id, name: live });
+            const seed = nameMap.get(row.id);
+            // Only fill an empty label; a real agent title (non-empty) always wins.
+            if (seed && !(row.label ?? '').trim()) {
+                updates.push({ id: row.id, label: seed });
             }
         }
     }
     if (updates.length === 0)
         return 0;
-    const upd = db.prepare(`UPDATE sessions SET name = ? WHERE id = ?`);
+    const updSessions = db.prepare(`UPDATE sessions SET label = ? WHERE id = ?`);
+    const updFts = db.prepare(`UPDATE session_text SET label = ? WHERE session_id = ?`);
     const txn = db.transaction((items) => {
-        for (const { id, name } of items)
-            upd.run(name, id);
+        for (const { id, label } of items) {
+            updSessions.run(label, id);
+            updFts.run(label, id);
+        }
     });
     txn(updates);
     return updates.length;
@@ -739,7 +764,6 @@ function rowToMeta(row) {
         account: row.account ?? undefined,
         topic: row.topic ?? undefined,
         label: row.label ?? undefined,
-        name: row.name ?? undefined,
         isTeamOrigin: row.is_team_origin === 1,
         prUrl: row.pr_url ?? undefined,
         prNumber: row.pr_number ?? undefined,
@@ -1009,33 +1033,31 @@ export function ftsSearch(input, limit = 200) {
     const seen = new Set();
     const hits = [];
     // Tier 1-3: handle-based matches, ordered by exactness. A session's handle is
-    // its /rename `label` OR its `agents run --name` handle — both are user-chosen
-    // aliases and rank identically, so typing either the renamed title or the run
-    // name resolves the session ahead of any FTS content hit.
+    // its `label` — set by an agent title / `/rename`, or seeded at launch from
+    // `agents run --name`. Typing it resolves the session ahead of any FTS content
+    // hit.
     const labelRows = db.prepare(`
-    SELECT id, label, name FROM sessions
-    WHERE (label IS NOT NULL AND LOWER(label) LIKE ?)
-       OR (name  IS NOT NULL AND LOWER(name)  LIKE ?)
-  `).all(`%${lower}%`, `%${lower}%`);
+    SELECT id, label FROM sessions
+    WHERE label IS NOT NULL AND LOWER(label) LIKE ?
+  `).all(`%${lower}%`);
     let hasExactLabelMatch = false;
     for (const row of labelRows) {
-        // Score against whichever handle matches best (exact > prefix > contains).
+        // Score the label by match quality (exact > prefix > contains).
         let score = 0;
-        for (const handle of [row.label, row.name]) {
-            if (!handle)
-                continue;
+        const handle = row.label;
+        if (handle) {
             const h = handle.toLowerCase();
-            if (!h.includes(lower))
-                continue;
-            if (h === lower) {
-                score = Math.max(score, 1_000_000);
-                hasExactLabelMatch = true;
-            }
-            else if (h.startsWith(lower)) {
-                score = Math.max(score, 900_000);
-            }
-            else {
-                score = Math.max(score, 800_000);
+            if (h.includes(lower)) {
+                if (h === lower) {
+                    score = 1_000_000;
+                    hasExactLabelMatch = true;
+                }
+                else if (h.startsWith(lower)) {
+                    score = 900_000;
+                }
+                else {
+                    score = 800_000;
+                }
             }
         }
         if (score === 0)

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

@@ -64,6 +64,10 @@ interface ClaudeSessionScan {
     prNumber?: number;
     worktreeSlug?: string;
     ticketId?: string;
+    /** Tracker refs the session CREATED (Linear create_issue / gh issue create). */
+    createdTickets?: string[];
+    /** Team name this session SPAWNED via `agents teams create/add` (not team-of-origin). */
+    spawnedTeam?: string;
 }
 /**
  * Discover sessions. Scans only files whose (mtime, size) have changed since

package/dist/lib/session/discover.js

@@ -21,11 +21,11 @@ import { getConfigSymlinkVersion } from '../shims.js';
 import { SESSION_AGENTS } from './types.js';
 import { extractSessionTopic } from './prompt.js';
 import { parseAntigravity } from './parse.js';
-import { extractPrUrl, detectWorktree, detectTicket, isPrCreateCommand } from './state.js';
+import { extractPrUrl, detectWorktree, detectTicket, isPrCreateCommand, detectSpawnedTeam, isTicketCreateTool, extractCreatedTicket } from './state.js';
 import { costOfUsage } from '../pricing/index.js';
 import { machineId } from './sync/config.js';
 import { mapBounded } from '../concurrency.js';
-import { getDB, getScanStampByPath, getScanStampsForPaths, recordScans, syncLabels, syncNames, syncTopics, upsertSessionsBatch, querySessions, countSessions, ftsSearch, tryClaimScan, releaseScan, } from './db.js';
+import { getDB, getScanStampByPath, getScanStampsForPaths, recordScans, syncLabels, seedLabelsFromNames, syncTopics, upsertSessionsBatch, querySessions, countSessions, ftsSearch, tryClaimScan, releaseScan, } from './db.js';
 import { buildRunNameMap } from './run-names.js';
 const HOME = os.homedir();
 // Versions can live under either repo: the user repo (current canonical
@@ -64,9 +64,11 @@ export async function discoverSessions(options) {
             // reads to behavioral EDR (CrowdStrike Falcon) as a ransomware-style bulk
             // file-enumeration sweep. Same dirs, same results — just not all at once.
             await scanAgentsBounded(agents, agent => dispatchAgentScan(agent, onProgress));
-            // Apply `agents run --name` handles onto the freshly-scanned rows by id —
-            // the same idempotent, re-applied-every-scan pattern as /rename labels.
-            syncNames(buildRunNameMap());
+            // Seed labels from `agents run --name` handles onto the freshly-scanned
+            // rows by id. Runs AFTER the per-agent scans (which applied agent-generated
+            // titles via syncLabels), so a real title always wins and the seed only
+            // backfills sessions that would otherwise be unnamed.
+            seedLabelsFromNames(buildRunNameMap());
         }
         finally {
             releaseScan(process.pid);
@@ -481,6 +483,8 @@ async function readClaudeMeta(filePath, sessionId, account, label) {
             prNumber: scan.prNumber,
             worktreeSlug: scan.worktreeSlug,
             ticketId: scan.ticketId,
+            createdTickets: scan.createdTickets,
+            spawnedTeam: scan.spawnedTeam,
         };
     }
     else {
@@ -504,6 +508,8 @@ async function readClaudeMeta(filePath, sessionId, account, label) {
             prNumber: scan.prNumber,
             worktreeSlug: scan.worktreeSlug,
             ticketId: scan.ticketId,
+            createdTickets: scan.createdTickets,
+            spawnedTeam: scan.spawnedTeam,
         };
     }
     return { meta, content: scan.contentText || '' };
@@ -715,6 +721,8 @@ export async function readCodexMeta(filePath, resolveAccount, currentVersion) {
         prNumber: scan.prNumber,
         worktreeSlug: scan.worktreeSlug,
         ticketId: scan.ticketId,
+        createdTickets: scan.createdTickets,
+        spawnedTeam: scan.spawnedTeam,
     };
     return { meta, content: scan.contentText || '' };
 }
@@ -1756,6 +1764,12 @@ export async function scanClaudeSession(filePath) {
     let sawPrCreate = false;
     let prUrl;
     let prNumber;
+    // Artifacts the session PRODUCED: tracker refs it created and any team it spawned.
+    // Ticket creation spans two events — a create_issue tool_use, then the tool_result
+    // carrying the new id — so we hold the pending tool_use ids until their result lands.
+    const createdTickets = new Set();
+    const pendingTicketTools = new Set();
+    let spawnedTeam;
     try {
         for await (const line of rl) {
             if (!line.trim())
@@ -1772,6 +1786,39 @@ export async function scanClaudeSession(filePath) {
             if (!entrypoint && typeof parsed.entrypoint === 'string') {
                 entrypoint = parsed.entrypoint;
             }
+            // Produced-artifact signals, structurally (independent of the PR gate below):
+            //   - a Bash `agents teams create/add` command → the team it spawned
+            //   - a Linear create_issue / `gh issue create` tool_use → its result carries
+            //     the new ticket ref, read from the matching tool_result.
+            if (parsed.type === 'assistant' && Array.isArray(parsed.message?.content)) {
+                for (const b of parsed.message.content) {
+                    if (b?.type !== 'tool_use')
+                        continue;
+                    if (!spawnedTeam && typeof b?.input?.command === 'string') {
+                        const team = detectSpawnedTeam(b.input.command);
+                        if (team)
+                            spawnedTeam = team;
+                    }
+                    if (typeof b?.id === 'string' && isTicketCreateTool(b?.name, b?.input?.command)) {
+                        pendingTicketTools.add(b.id);
+                    }
+                }
+            }
+            if (pendingTicketTools.size > 0 && parsed.type === 'user' && Array.isArray(parsed.message?.content)) {
+                for (const b of parsed.message.content) {
+                    if (b?.type !== 'tool_result' || typeof b?.tool_use_id !== 'string')
+                        continue;
+                    if (!pendingTicketTools.has(b.tool_use_id))
+                        continue;
+                    pendingTicketTools.delete(b.tool_use_id);
+                    const text = typeof b.content === 'string'
+                        ? b.content
+                        : Array.isArray(b.content) ? b.content.map((c) => c?.text || '').join('\n') : '';
+                    const t = extractCreatedTicket(text);
+                    if (t)
+                        createdTickets.add(t);
+                }
+            }
             // PR signal, structurally: a Bash tool_use whose command is `gh pr create`
             // marks intent; the pull URL is then read from a tool_result's output.
             if (!prUrl) {
@@ -1900,6 +1947,8 @@ export async function scanClaudeSession(filePath) {
         prNumber,
         worktreeSlug: worktree?.slug,
         ticketId: ticket?.id,
+        createdTickets: createdTickets.size > 0 ? [...createdTickets] : undefined,
+        spawnedTeam,
     };
 }
 /** Stream a Codex JSONL file and extract scan-level metadata (session ID, cwd, topic, tokens). */
@@ -1922,6 +1971,10 @@ async function scanCodexSession(filePath) {
     let sawPrCreate = false;
     let prUrl;
     let prNumber;
+    // Produced artifacts (mirror of the Claude scan): created tracker refs + spawned team.
+    const createdTickets = new Set();
+    const pendingTicketTools = new Set();
+    let spawnedTeam;
     try {
         for await (const line of rl) {
             if (!line.trim())
@@ -1935,23 +1988,39 @@ async function scanCodexSession(filePath) {
             }
             // PR signal, structurally: a Codex `function_call` whose command is
             // `gh pr create`, then the pull URL from a `function_call_output`.
-            if (!prUrl && parsed.type === 'response_item') {
+            if (parsed.type === 'response_item') {
                 const p = parsed.payload || {};
-                if (!sawPrCreate && p.type === 'function_call') {
+                if (p.type === 'function_call') {
                     let cmd = '';
                     try {
                         const args = typeof p.arguments === 'string' ? JSON.parse(p.arguments) : (p.arguments || {});
                         cmd = String(args.command || args.cmd || '');
                     }
                     catch { /* non-JSON args */ }
-                    if (isPrCreateCommand(cmd))
+                    if (!prUrl && !sawPrCreate && isPrCreateCommand(cmd))
                         sawPrCreate = true;
+                    if (!spawnedTeam) {
+                        const team = detectSpawnedTeam(cmd);
+                        if (team)
+                            spawnedTeam = team;
+                    }
+                    if (typeof p.call_id === 'string' && isTicketCreateTool(p.name, cmd)) {
+                        pendingTicketTools.add(p.call_id);
+                    }
                 }
-                if (sawPrCreate && p.type === 'function_call_output') {
-                    const pr = extractPrUrl(String(p.output || ''));
-                    if (pr) {
-                        prUrl = pr.url;
-                        prNumber = pr.number;
+                if (p.type === 'function_call_output') {
+                    if (!prUrl && sawPrCreate) {
+                        const pr = extractPrUrl(String(p.output || ''));
+                        if (pr) {
+                            prUrl = pr.url;
+                            prNumber = pr.number;
+                        }
+                    }
+                    if (typeof p.call_id === 'string' && pendingTicketTools.has(p.call_id)) {
+                        pendingTicketTools.delete(p.call_id);
+                        const t = extractCreatedTicket(String(p.output || ''));
+                        if (t)
+                            createdTickets.add(t);
                     }
                 }
             }
@@ -2044,6 +2113,8 @@ async function scanCodexSession(filePath) {
         prNumber,
         worktreeSlug: worktree?.slug,
         ticketId: ticket?.id,
+        createdTickets: createdTickets.size > 0 ? [...createdTickets] : undefined,
+        spawnedTeam,
     };
 }
 /** Resolve the working directory for an OpenClaw agent from its workspace config. */