@phnx-labs/agents-cli 1.20.44 → 1.20.45

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;

package/dist/lib/session/state.js

@@ -37,6 +37,16 @@ const PR_URL_RE = /https:\/\/github\.com\/[^\s"'()<>]+\/pull\/(\d+)/;
 const WORKTREE_RE = /\/\.agents\/worktrees\/([^/]+)/;
 /** gh invocations that create/open a PR. */
 const GH_PR_CREATE_RE = /\bgh\s+pr\s+(?:create|new)\b/;
+/** gh invocation that opens an issue — the created number is read from its result. */
+const GH_ISSUE_CREATE_RE = /\bgh\s+issue\s+create\b/;
+/** A created GitHub issue URL (…/issues/123) in tool-result output. */
+const GH_ISSUE_URL_RE = /https:\/\/github\.com\/[^\s"'()<>]+\/issues\/(\d+)/;
+/**
+ * `agents teams create <name>` / `agents teams add <team> …` (also the `ag` alias).
+ * The team NAME is the first bareword after the sub-verb, skipping any flags. This
+ * is the structural signal that a session SPAWNED a team (vs. was spawned by one).
+ */
+const TEAMS_SPAWN_RE = /\bag(?:ents)?\s+teams?\s+(?:create|add)\s+(?:--?[a-z][\w-]*(?:[= ]\S+)?\s+)*([A-Za-z0-9][\w-]*)/;
 /** Collapse to a single trimmed line for a one-row preview cell. */
 function oneLine(s) {
     return s.replace(/\s+/g, ' ').trim();
@@ -80,6 +90,46 @@ export function extractPrUrl(output) {
 export function isPrCreateCommand(command) {
     return !!command && GH_PR_CREATE_RE.test(command);
 }
+/**
+ * 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 function detectSpawnedTeam(command) {
+    if (!command)
+        return undefined;
+    const m = command.match(TEAMS_SPAWN_RE);
+    return m ? m[1] : 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 function isTicketCreateTool(name, command) {
+    if (typeof name === 'string' && /linear/i.test(name) && /create[_-]?issue/i.test(name))
+        return true;
+    // Any shell tool (Bash / shell / local_shell) running `gh issue create`.
+    if (!!command && GH_ISSUE_CREATE_RE.test(command))
+        return true;
+    return false;
+}
+/**
+ * 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 function extractCreatedTicket(text) {
+    if (!text)
+        return undefined;
+    const lin = text.match(TICKET_RE);
+    if (lin && !TICKET_DENYLIST.has(lin[1].split('-')[0]))
+        return lin[1];
+    const gh = text.match(GH_ISSUE_URL_RE);
+    if (gh)
+        return `#${gh[1]}`;
+    return undefined;
+}
 /** Does an assistant message read as a question directed at the user? */
 function looksLikeQuestion(text) {
     const t = text.trim();
@@ -181,14 +231,19 @@ export function inferActivity(events, ctx = {}) {
     return base;
 }
 /**
- * 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 function detectDurableSignals(events) {
     let pr;
     let sawPrCreate = false;
     let ticket;
+    let sawTicketCreate = false;
+    let spawnedTeam;
+    const createdTickets = new Set();
     for (const e of events) {
         // Structural PR signal: a real `gh pr create` tool call, then the pull URL
         // from a following tool_result — never a bare URL mentioned in prose.
@@ -201,21 +256,45 @@ export function detectDurableSignals(events) {
                 sawPrCreate = false;
             }
         }
+        // Produced artifacts: a team spawn is read off the command; a created ticket
+        // is a create-issue tool call whose following tool_result carries the new ref.
+        if (e.type === 'tool_use') {
+            if (!spawnedTeam) {
+                const team = detectSpawnedTeam(e.command);
+                if (team)
+                    spawnedTeam = team;
+            }
+            if (isTicketCreateTool(e.tool, e.command))
+                sawTicketCreate = true;
+        }
+        if (sawTicketCreate && e.type === 'tool_result') {
+            const t = extractCreatedTicket(e.output);
+            if (t)
+                createdTickets.add(t);
+            sawTicketCreate = false;
+        }
         if (!ticket && e.type === 'message' && e.role === 'user') {
             ticket = detectTicket(e.content);
         }
     }
-    return { pr, ticket };
+    return {
+        pr,
+        ticket,
+        createdTickets: createdTickets.size > 0 ? [...createdTickets] : undefined,
+        spawnedTeam,
+    };
 }
 /** Full inference: activity + preview + durable signals + worktree/ticket from ctx. */
 export function inferSessionState(events, ctx = {}) {
     const state = inferActivity(events, ctx);
-    const { pr, ticket } = detectDurableSignals(events);
+    const { pr, ticket, createdTickets, spawnedTeam } = detectDurableSignals(events);
     const worktree = detectWorktree(ctx.cwd, ctx.gitBranch);
     return {
         ...state,
         pr: pr ?? state.pr,
         worktree: worktree ?? state.worktree,
         ticket: ticket ?? detectTicket(undefined, ctx.gitBranch) ?? state.ticket,
+        createdTickets,
+        spawnedTeam,
     };
 }

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

@@ -65,16 +65,16 @@ export interface SessionMeta {
     version?: string;
     account?: string;
     topic?: string;
-    /** Custom name the user gave the session (e.g. Claude Code /rename). */
-    label?: string;
     /**
-     * Durable launch handle from `agents run --name <slug>` — an alias chosen at
-     * launch (not derived from the session id), used to resolve the run in
-     * `agents sessions <name>`. Distinct from `label` (post-hoc /rename): a run's
-     * name is immutable; both are searchable. Absent for runs launched without
-     * `--name`.
+     * The session's human-readable name — one field, several sources with a plain
+     * priority: an agent-generated title / Claude `/rename` wins; else the launch
+     * handle seeded from `agents run --name <slug>` (interactive, headless, remote
+     * host, or a teams teammate); else it stays unset and the listing falls back to
+     * `topic`. Searchable via `agents sessions <label>`. (Before v10 the launch
+     * handle lived in a separate immutable `name` column; `--name` now just seeds
+     * this label.)
      */
-    name?: string;
+    label?: string;
     /** Set when this session was spawned by `agents teams`. */
     teamOrigin?: TeamOrigin;
     /** Durable state signals extracted at scan time by the session-state engine. */
@@ -86,6 +86,17 @@ export interface SessionMeta {
     worktreeSlug?: string;
     /** Tracker ticket ref (e.g. RUSH-1234) from the prompt or branch. */
     ticketId?: string;
+    /**
+     * Tracker refs the session CREATED during its run — Linear `create_issue` MCP
+     * calls or `gh issue create` shell commands — read from the tool result. Distinct
+     * from `ticketId` (the injected/worked-on ticket from the prompt or branch).
+     */
+    createdTickets?: string[];
+    /**
+     * Team name this session SPAWNED via `agents teams create/add`. The inverse of
+     * `isTeamOrigin` (which marks sessions spawned BY a team).
+     */
+    spawnedTeam?: string;
     /**
      * True when the session was spawned programmatically (SDK entrypoint) rather
      * than by a human at the Claude CLI. Captured at scan time from the JSONL

package/dist/lib/teams/agents.js

@@ -22,6 +22,7 @@ import { getAgentsDir as getSystemAgentsDir, getShimsDir } from '../state.js';
 import { AGENTS, getAccountInfo } from '../agents.js';
 import { resolveVersion, isVersionInstalled } from '../versions.js';
 import { sanitizeProcessEnv } from '../secrets/bundles.js';
+import { recordRunName } from '../session/run-names.js';
 let lastMemoryWarnAt = 0;
 // On macOS, os.freemem() returns only the truly-free pool and ignores the
 // large inactive+purgeable cache the kernel will reclaim under pressure, so
@@ -1067,6 +1068,14 @@ export class AgentManager {
             throw new Error(`Failed to create agent directory: ${err.message}`);
         }
         this.agents.set(agentId, agent);
+        // Seed the teammate's session label with its friendly team name, so the run
+        // shows up as `<name>` in `agents sessions` and resolves by it — consistent
+        // with `agents run --name`. For Claude the agent id IS the session id (passed
+        // via --session-id in buildCommand); other agents don't expose a launch-time
+        // id, so they're seeded once discovery captures one. Best-effort.
+        if (agentType === 'claude' && name && !isCloudBacked) {
+            recordRunName({ sessionId: agentId, name, agent: agentType, cwd: resolvedCwd ?? undefined });
+        }
         if (isStaged) {
             await agent.saveMeta();
             debug(`Staged ${agentType} teammate '${name}' in team '${taskName}' (after: ${cleanAfter.join(', ')})`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.20.44",
+  "version": "1.20.45",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",