@phnx-labs/agents-cli 1.20.43 → 1.20.45

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. */

package/dist/lib/session/run-names.d.ts

@@ -3,11 +3,12 @@
  * session id of the run it named.
  *
  * `agents run` records `<sessionId>.json` here at launch whenever both a name
- * and a session id are known up front (Claude pre-mints its id — see
- * spawnAgent). The session-discovery pass reads these sidecars and applies the
- * names onto the SQLite index by id (via syncNames), the same idempotent,
- * re-applied-every-scan pattern as Claude `/rename` labels. Names therefore
- * survive transcript rescans without being parsed out of the transcript itself.
+ * and a session id are known up front (Claude pre-mints its id — see spawnAgent;
+ * a teams teammate's Claude session id is its agent id). The session-discovery
+ * pass reads these sidecars and SEEDS the session label by id (via
+ * seedLabelsFromNames) — the launch handle becomes the label, refined later by an
+ * agent-generated title. Idempotent and re-applied every scan, so seeds survive
+ * transcript rescans without being parsed out of the transcript itself.
  *
  * Mirrors the host-task sidecar convention (`~/.agents/.cache/hosts/<id>.json`),
  * one small JSON per run under `~/.agents/.cache/run-names/`.
@@ -26,7 +27,8 @@ export declare function runNamesDir(): string;
  */
 export declare function recordRunName(rec: Omit<RunNameRecord, 'ts'>): void;
 /**
- * Build the sessionId → name map from every run-name sidecar, for syncNames to
- * apply onto the index. Returns an empty map when the dir doesn't exist yet.
+ * Build the sessionId → name map from every run-name sidecar, for
+ * seedLabelsFromNames to apply onto the index as label seeds. Returns an empty
+ * map when the dir doesn't exist yet.
  */
 export declare function buildRunNameMap(): Map<string, string | null>;

package/dist/lib/session/run-names.js

@@ -3,11 +3,12 @@
  * session id of the run it named.
  *
  * `agents run` records `<sessionId>.json` here at launch whenever both a name
- * and a session id are known up front (Claude pre-mints its id — see
- * spawnAgent). The session-discovery pass reads these sidecars and applies the
- * names onto the SQLite index by id (via syncNames), the same idempotent,
- * re-applied-every-scan pattern as Claude `/rename` labels. Names therefore
- * survive transcript rescans without being parsed out of the transcript itself.
+ * and a session id are known up front (Claude pre-mints its id — see spawnAgent;
+ * a teams teammate's Claude session id is its agent id). The session-discovery
+ * pass reads these sidecars and SEEDS the session label by id (via
+ * seedLabelsFromNames) — the launch handle becomes the label, refined later by an
+ * agent-generated title. Idempotent and re-applied every scan, so seeds survive
+ * transcript rescans without being parsed out of the transcript itself.
  *
  * Mirrors the host-task sidecar convention (`~/.agents/.cache/hosts/<id>.json`),
  * one small JSON per run under `~/.agents/.cache/run-names/`.
@@ -37,8 +38,9 @@ export function recordRunName(rec) {
     }
 }
 /**
- * Build the sessionId → name map from every run-name sidecar, for syncNames to
- * apply onto the index. Returns an empty map when the dir doesn't exist yet.
+ * Build the sessionId → name map from every run-name sidecar, for
+ * seedLabelsFromNames to apply onto the index as label seeds. Returns an empty
+ * map when the dir doesn't exist yet.
  */
 export function buildRunNameMap() {
     const map = new Map();

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

@@ -44,6 +44,10 @@ export interface SessionState {
     pr?: DetectedPr;
     worktree?: DetectedWorktree;
     ticket?: DetectedTicket;
+    /** Tracker refs this session CREATED (Linear create_issue / gh issue create). */
+    createdTickets?: string[];
+    /** Team name this session SPAWNED via `agents teams create/add`. */
+    spawnedTeam?: string;
 }
 export interface StateContext {
     /** Session file mtime; drives running-vs-stale. */
@@ -63,6 +67,24 @@ export declare function detectTicket(text?: string, branch?: string): DetectedTi
 export declare function extractPrUrl(output?: string): DetectedPr | undefined;
 /** True when a Bash/exec command string is a `gh pr create`. */
 export declare function isPrCreateCommand(command?: string): boolean;
+/**
+ * The team a session SPAWNED, from an `agents teams create/add <name>` command.
+ * Returns the team name, or undefined if the command isn't a team spawn. Note this
+ * is the opposite of `isTeamOrigin` (which marks sessions spawned BY a team).
+ */
+export declare function detectSpawnedTeam(command?: string): string | undefined;
+/**
+ * True when a tool_use call CREATES a tracker ticket — a Linear MCP `create_issue`
+ * tool, or a Bash `gh issue create`. The created id is then read from the matching
+ * tool_result via {@link extractCreatedTicket}.
+ */
+export declare function isTicketCreateTool(name?: string, command?: string): boolean;
+/**
+ * Pull a created ticket ref out of a create-issue tool_result. Linear returns a
+ * key like `RUSH-1234`; `gh issue create` returns the issue URL, from which we
+ * take `#<number>`. Returns undefined when neither shape is present.
+ */
+export declare function extractCreatedTicket(text?: string): string | undefined;
 /**
  * Infer live activity + a preview from a chronological event slice. `pr` /
  * `ticket` / `worktree` are attached by `inferSessionState`; this focuses on the
@@ -70,13 +92,17 @@ export declare function isPrCreateCommand(command?: string): boolean;
  */
 export declare function inferActivity(events: SessionEvent[], ctx?: StateContext): SessionState;
 /**
- * Scan an event slice for the durable signals (PR opened, ticket) that aren't
- * about the cwd. Correlates each `gh pr create` with the nearest following
- * tool_result URL; keeps the last PR found.
+ * Scan an event slice for the durable signals that aren't about the cwd: the PR
+ * opened, the injected ticket, plus the artifacts the session PRODUCED — tracker
+ * refs it created and any team it spawned. Each `gh pr create` / create-issue tool
+ * call is correlated with the nearest following tool_result; the team name comes
+ * straight off the `agents teams create/add` command.
  */
 export declare function detectDurableSignals(events: SessionEvent[]): {
     pr?: DetectedPr;
     ticket?: DetectedTicket;
+    createdTickets?: string[];
+    spawnedTeam?: string;
 };
 /** Full inference: activity + preview + durable signals + worktree/ticket from ctx. */
 export declare function inferSessionState(events: SessionEvent[], ctx?: StateContext): SessionState;