@lensmcp/protocol-types 1.25.36 → 1.25.38

package/lib/team-library.d.ts

@@ -141,6 +141,8 @@ export interface DashTeamMember {
     /** The model and reasoning effort its file names for its agents (the manager spawns them with these) — none: the spawner's. */
     model?: string;
     effort?: string;
+    /** The client its file names for its launched agents (`codex` | `claude`) — none: the spawner's. */
+    client?: 'codex' | 'claude';
     /** The repository's own rules for it, as tagged sections — empty when it has none. */
     rules: string;
     /** `default`: no file — LensMCP's default (built on its library role); `file`: the repository's file; `design`: a file an accepted team design wrote. */
@@ -205,6 +207,8 @@ export interface DashTeamMemberEdit {
     /** The model (at most 80 characters) and effort (at most 40) its agents run on, in their client's words — empty or left out: none. */
     model?: string;
     effort?: string;
+    /** The client its launched agents run on — left out: none (the spawner's). */
+    client?: 'codex' | 'claude';
     /** Tools added to the base's (one the base has, named again, takes this when). */
     tools?: DashTeamRoleTool[];
     /** Skills added to the base's. */

package/lib/team.d.ts

@@ -89,6 +89,8 @@ export interface DashTeamSession {
     role?: string;
     /** Who it reports to: `user`, or a session id. */
     manager?: string;
+    /** The launch that started it (`agent_spawn`), when a manager launched it. */
+    launch?: string;
     /** Waiting for work (agent_wait). */
     listening?: boolean;
     objective?: string;
@@ -99,6 +101,8 @@ export interface DashTeamSession {
     createdAt: number;
     lastSeenAt: number;
     expiresAt: number;
+    /** Direct messages to it it has not read — an agent reads its messages with agent_sync. None: it read them all. */
+    unread?: number;
 }
 /** A checkout of the repository, as an agent's lens last saw it. */
 export interface DashTeamWorktree {
@@ -127,6 +131,8 @@ export interface DashTeamRole {
     /** The model and reasoning effort its role file asks for — the manager spawns its agents with them (planning/team/03). */
     model?: string;
     effort?: string;
+    /** The client its role file asks its launched agents to run on — none: the spawner's (planning/team/05). */
+    client?: DashTeamLaunchClient;
     /** Claimable now (blocked ones not counted). */
     open: number;
     claimed: number;
@@ -210,6 +216,30 @@ export interface DashTeamMessage {
     kind: 'message' | 'note';
     to?: string;
 }
+/** A message by or to one agent, and whether its recipient read it. */
+export interface DashTeamAgentMessage {
+    id: string;
+    seq: number;
+    /** A session id, or `user`: the person (this page, the operator CLI). */
+    from: string;
+    /** The session it is to; none: to every agent. */
+    to?: string;
+    kind: 'message' | 'note';
+    /** Cut past a few thousand characters. */
+    body: string;
+    createdAt: number;
+    /** Its recipient fetched it (agent_sync). */
+    read: boolean;
+    /** Its recipient acknowledged it. */
+    acked: boolean;
+}
+/** `GET /api/team/messages?session=` — the agent's newest direct messages, by it and to it, and the notes it sent; newest last. */
+export interface DashTeamAgentMessages {
+    sessionId: string;
+    messages: DashTeamAgentMessage[];
+    /** Direct messages to it it has not read — all of them, not only those listed. */
+    unread: number;
+}
 /**
  * What an agent's OWN transcript says (planning/team/03-agent-transcripts.md) — the Codex rollout or the Claude Code
  * transcript its coordination session is linked to: by its hooks' native key, or by the `agent_join` answer that names
@@ -274,6 +304,8 @@ export interface DashTeamAgentDetail extends DashTeamAgentBrief {
     /** The transcript file (absolute). */
     file?: string;
     bytes?: number;
+    /** Too long to read whole: read from this byte on — its newest part; the counts below are of that part. */
+    readFrom?: number;
     threadId?: string;
     parentThreadId?: string;
     /** How it was started: `cli`, `vscode`, `exec`, `subagent` (Codex); the entrypoint (Claude Code). */
@@ -302,7 +334,10 @@ export interface DashTeamAgentDetail extends DashTeamAgentBrief {
         output: number;
         total: number;
     };
-    /** Agents it spawned (Codex subagents; Claude Code subagents), newest last. */
+    /**
+     * Agents it spawned (Codex subagents; Claude Code subagents), newest last — when (`at`), the task name it gave
+     * (`task`) and the start of what it told the agent (`message`), when the transcript says.
+     */
     spawned: Array<{
         threadId: string;
         nickname?: string;
@@ -310,7 +345,210 @@ export interface DashTeamAgentDetail extends DashTeamAgentBrief {
         sessionId?: string;
         model?: string;
         effort?: string;
+        at?: number;
+        task?: string;
+        message?: string;
     }>;
     /** Its newest lines, oldest first. */
     tail: DashTeamAgentLine[];
 }
+/** `who` in a review: a session id, `user` (the person) or `lensmcp` (the team flow, the operator CLI). */
+export type DashTeamReviewActor = string;
+/** A task of the run: the task reviewed (depth 0) or one under it, whole — with its timings. */
+export interface DashTeamReviewTask extends DashTeamTask {
+    /** 0: the task reviewed; 1: its children; … */
+    depth: number;
+    /** The first claim, and when it was completed or cancelled. */
+    claimedAt?: number;
+    closedAt?: number;
+    /** created → first claim; first claim → closed (or now while held) — ms. */
+    waited?: number;
+    worked?: number;
+    /** How many times it was claimed (a recovery or take-back makes a second). */
+    claims: number;
+    /** The task whose outcome the team flow made it from, and the tasks its own outcome made. */
+    handedFrom?: string;
+    handedTo?: string[];
+}
+/** An agent of the run: a session that worked on its tasks, or an agent one of them spawned (with or without a session). */
+export interface DashTeamReviewAgent {
+    /** Its team session — absent: a spawned agent that never joined the team (known from its spawner's transcript). */
+    sessionId?: string;
+    /** Codex thread / Claude Code session or agent id, when its transcript is linked or its spawner named it. */
+    threadId?: string;
+    client: string;
+    name?: string;
+    nickname?: string;
+    /** Its role now, and every role it joined in the window, in order. */
+    role?: string;
+    roles: Array<{
+        role: string;
+        at: number;
+    }>;
+    /** Who it reports to (`user` or a session) and the agent whose transcript spawned it. */
+    manager?: DashTeamReviewActor;
+    spawnedBy?: DashTeamReviewActor;
+    objective?: string;
+    step?: string;
+    createdAt?: number;
+    lastSeenAt?: number;
+    /** In this run: tasks it created, claimed, completed; ms it held tasks; messages it sent and got. */
+    created: number;
+    claimed: number;
+    completed: number;
+    held: number;
+    sent: number;
+    received: number;
+    /** The tasks it claimed, by kind (`build: 2`), and the outcomes it gave. */
+    kinds: Partial<Record<DashTeamKind, number>>;
+    outcomes: Partial<Record<DashTeamOutcome, number>>;
+    /** Its own transcript, folded — `tail` left out (the zip has its lines in the window). */
+    transcript?: Omit<DashTeamAgentDetail, 'tail'>;
+}
+/** One thing that happened, in time order. */
+export interface DashTeamReviewEvent {
+    at: number;
+    kind: 'task.created' | 'task.claimed' | 'task.log' | 'task.handoff' | 'task.completed' | 'task.cancelled' | 'task.recovery' | 'task.checkpoint' | 'message' | 'joined' | 'spawn' | 'model';
+    by?: DashTeamReviewActor;
+    /** The task it is about, the session or thread it went to. */
+    taskId?: string;
+    to?: string;
+    /** One line, at most 400 characters. */
+    text: string;
+}
+/** A message of the run: through LensMCP (agent_message — a note to all when `to` is absent) or between a client's own agents (Codex send_message). */
+export interface DashTeamReviewMessage {
+    at: number;
+    from: DashTeamReviewActor;
+    to?: string;
+    via: 'lensmcp' | 'client';
+    kind: 'message' | 'note';
+    body: string;
+}
+/** Work given to someone else: a task created for a role or an agent, a hand-off, an assignment, a spawned agent, a re-route. */
+export interface DashTeamReviewDelegation {
+    at: number;
+    kind: 'create' | 'assign' | 'handoff' | 'spawn' | 'reroute' | 'take-back' | 'cancel';
+    from: DashTeamReviewActor;
+    /** A session, a thread (spawned), or `role:<id>`. */
+    to: string;
+    taskId?: string;
+    /** For a spawn: the model and effort it was spawned with (absent: its spawner's). */
+    model?: string;
+    effort?: string;
+    text?: string;
+}
+/** What the run says about the process — a hint for the person reviewing it, never a verdict. */
+export interface DashTeamReviewFlag {
+    kind: 'self-review' | 'manager-did-work' | 'same-model' | 'role-model-mismatch' | 'unjoined-agent' | 'long-wait' | 'silent-claim' | 'rework' | 'no-evidence' | 'recovery' | 'open-under-closed' | 'serial' | 'idle-agent';
+    severity: 'info' | 'warn';
+    text: string;
+    taskId?: string;
+    sessionId?: string;
+}
+export interface DashTeamReviewMetrics {
+    /** The window's length — ms. */
+    elapsed: number;
+    tasks: number;
+    byKind: Partial<Record<DashTeamKind, number>>;
+    byState: Partial<Record<DashTeamTaskState, number>>;
+    byOutcome: Partial<Record<DashTeamOutcome, number>>;
+    /** Agents with a session; spawned agents that never joined. */
+    agents: number;
+    unjoined: number;
+    /** The most tasks held at once, and the ms with none held while the run was open. */
+    maxParallel: number;
+    idle: number;
+    /** created → first claim, ms: the median and the longest. */
+    waitMedian?: number;
+    waitMax?: number;
+    /** changes-requested reviews, failed tests, bugs filed, recoveries, hand-offs, messages (direct and notes). */
+    rework: number;
+    failed: number;
+    bugs: number;
+    recoveries: number;
+    handoffs: number;
+    messages: number;
+    notes: number;
+    /** Summed over the agents' whole transcripts (a transcript can span more than this run). */
+    tokens?: number;
+}
+/** `GET /api/team/review?id=` — a task's run whole: the task, the tasks under it, its agents, the flow, messages and delegations. */
+export interface DashTeamReview {
+    version: 1;
+    generatedAt: number;
+    repoId: string;
+    /** The task reviewed — usually a goal. */
+    taskId: string;
+    title: string;
+    /** From 5 minutes before the task was created to 5 minutes after it closed — `open`: still running, to now. */
+    window: {
+        from: number;
+        to: number;
+        open: boolean;
+    };
+    /** The task reviewed first, then the tasks under it in creation order. */
+    tasks: DashTeamReviewTask[];
+    agents: DashTeamReviewAgent[];
+    timeline: DashTeamReviewEvent[];
+    messages: DashTeamReviewMessage[];
+    delegations: DashTeamReviewDelegation[];
+    flags: DashTeamReviewFlag[];
+    metrics: DashTeamReviewMetrics;
+    /** The team as it is now: each role, its cap, model and effort; where the flow came from. */
+    team: {
+        roles: Array<{
+            id: string;
+            title: string;
+            agents?: number;
+            model?: string;
+            effort?: string;
+        }>;
+        flowFrom: string;
+    };
+    /** Items left out past a cap. */
+    truncated?: {
+        timeline?: number;
+        messages?: number;
+        tasks?: number;
+    };
+}
+/** The clients LensMCP launches headless: Codex (`codex exec`) and Claude Code (`claude -p`). */
+export type DashTeamLaunchClient = 'codex' | 'claude';
+/** An agent a manager launched (`agent_spawn`): what it runs, where, and how it is doing. */
+export interface DashTeamLaunch {
+    id: string;
+    role: string;
+    client: DashTeamLaunchClient;
+    model?: string;
+    effort?: string;
+    /** The session that launched it (a manager), and the goal and task it was launched for. */
+    by: string;
+    goalId?: string;
+    taskId?: string;
+    /** The checkout it works in — its goal's worktree — and that worktree's branch. */
+    worktree: string;
+    branch?: string;
+    pid: number;
+    /** `running` until it exits; `stopped` by the person or its deadline; `failed`: it could not start. */
+    state: 'running' | 'exited' | 'stopped' | 'failed';
+    startedAt: number;
+    /** When it is stopped if still running. */
+    deadline: number;
+    endedAt?: number;
+    exitCode?: number;
+    /** Its coordination session once it joined (its hooks name the launch), and its client's thread or session id. */
+    sessionId?: string;
+    threadId?: string;
+    /** The newest lines of its output, readable — what it said before it joined, or why it ended. */
+    tail?: string[];
+}
+/** `GET /api/team/launches` — the repository's launched agents, newest first, and whether launching is on. */
+export interface DashTeamLaunchesAnswer {
+    /** Features › Team launches agents. */
+    enabled: boolean;
+    /** The most launches running at once (Features), and how many run now. */
+    max: number;
+    running: number;
+    launches: DashTeamLaunch[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lensmcp/protocol-types",
-  "version": "1.25.36",
+  "version": "1.25.38",
   "type": "module",
   "main": "./index.js",
   "module": "./index.js",