@lensmcp/protocol-types 1.25.32 → 1.25.34

package/lib/team.d.ts

@@ -0,0 +1,209 @@
+/**
+ * The Team page (servers/lensmcp-mcp/src/dashboard/team.ts): the repository's agent team as its coordination store
+ * holds it — the agents in their roles, the tasks they take and hand on, each task's work log — and what the person at
+ * the machine changes there. The shapes are the store's (libs/storage coordination), cut to what the page shows: a
+ * task's whole log comes with the task alone (`/api/team/task`), the board carries its newest lines.
+ */
+/**
+ * What kind of work a task is: it names the role that takes it. `goal`: what a manager breaks into the others' tasks;
+ * `marketing`: telling people about the product (launch posts, release notes, landing and store copy).
+ */
+export declare const DASH_TEAM_KINDS: readonly ["goal", "build", "bug", "review", "test", "docs", "marketing", "research", "chore"];
+export type DashTeamKind = (typeof DASH_TEAM_KINDS)[number];
+export type DashTeamTaskState = 'open' | 'claimed' | 'recovery' | 'completed' | 'cancelled';
+export type DashTeamOutcome = 'done' | 'approved' | 'changes-requested' | 'passed' | 'failed' | 'wontfix';
+/** What a task points at in the lens or the repository. */
+export declare const DASH_TEAM_LINK_KINDS: readonly ["task", "flow", "error", "suggestion", "ai-call", "review", "page", "route", "commit", "branch", "worktree", "file"];
+export interface DashTeamLink {
+    kind: (typeof DASH_TEAM_LINK_KINDS)[number];
+    id: string;
+    label?: string;
+}
+/** One line of a task's work log. `by`: a session id, `user` (the person at the machine) or `lensmcp` (the team flow, the store). */
+export interface DashTeamLogLine {
+    at: number;
+    by: string;
+    kind: 'progress' | 'decision' | 'blocker' | 'handoff' | 'note' | 'state';
+    text: string;
+}
+export interface DashTeamTask {
+    id: string;
+    title: string;
+    /** Whole on `/api/team/task`; its first lines on the board. */
+    description: string;
+    kind?: DashTeamKind;
+    /** The role that may claim it; none: any agent. */
+    role?: string;
+    /** 0 (drop everything) … 3 (when there is time). */
+    priority: number;
+    parentId?: string;
+    blockedBy?: string[];
+    /** Of `blockedBy`, the tasks not completed or cancelled yet — an open task with any is blocked. */
+    blockedOn?: string[];
+    links?: DashTeamLink[];
+    /** The whole log on `/api/team/task`; its newest lines on the board. */
+    log: DashTeamLogLine[];
+    /** Every line it ever had, those no longer kept counted. */
+    logCount: number;
+    state: DashTeamTaskState;
+    outcome?: DashTeamOutcome;
+    /** The session holding it. */
+    owner?: string;
+    /** The session that must take it. */
+    to?: string;
+    /** A session id, `user` — the person's tasks (the Team page, an accepted team design) — or `lensmcp`: the team flow's hand-offs, the operator CLI's. */
+    creator: string;
+    origin: 'agent' | 'lensmcp';
+    worktreeId?: string;
+    ownerWorktreeId?: string;
+    createdAt: number;
+    updatedAt: number;
+    leaseUntil?: number;
+    checkpoint?: string;
+    /** What its owner said changed and how to check it, on completion (cut on the board). */
+    result?: string;
+    evidence?: string[];
+    completedHead?: string | null;
+    paths?: string[];
+    tags?: string[];
+}
+/** A task named in another's chain: its parent, its children, a blocker. */
+export interface DashTeamTaskRef {
+    id: string;
+    title: string;
+    kind?: DashTeamKind;
+    role?: string;
+    state: DashTeamTaskState;
+    outcome?: DashTeamOutcome;
+    owner?: string;
+}
+/** A task under another, and the tasks under it — the hand-off chain is a child of the task it came from. */
+export interface DashTeamTreeNode extends DashTeamTaskRef {
+    children: DashTeamTreeNode[];
+}
+/** One coordination session: an agent on the team (a role), or one outside it (no role). */
+export interface DashTeamSession {
+    id: string;
+    client: string;
+    name?: string;
+    role?: string;
+    /** Who it reports to: `user`, or a session id. */
+    manager?: string;
+    /** Waiting for work (agent_wait). */
+    listening?: boolean;
+    objective?: string;
+    step?: string;
+    /** `stale`: active, but not heard from within its lease. */
+    presence: 'active' | 'stale' | 'closed';
+    worktreeId: string;
+    createdAt: number;
+    lastSeenAt: number;
+    expiresAt: number;
+}
+/** A checkout of the repository, as an agent's lens last saw it. */
+export interface DashTeamWorktree {
+    id: string;
+    root: string;
+    branch: string | null;
+    head: string | null;
+    observedAt: number;
+    /** Files changed in it, then. */
+    changed: number;
+    truncated: boolean;
+    error?: string;
+}
+/** One role: its active agents (and how many wait for work), its tasks by state. */
+export interface DashTeamRole {
+    role: string;
+    title: string;
+    /** One line: what the role is for. */
+    summary: string;
+    /** The kinds of task it takes — a task of one goes to it unless the task names another role. */
+    takes: DashTeamKind[];
+    agents: number;
+    listening: number;
+    /** The most agents it takes at once (its role file's `agents`): agent_join refuses one more. None: no limit. */
+    cap?: number;
+    /** Claimable now (blocked ones not counted). */
+    open: number;
+    claimed: number;
+    blocked: number;
+    recovery: number;
+}
+/** A message to everyone, or a note — the board's newest. */
+export interface DashTeamNote {
+    id: string;
+    seq: number;
+    sender: string;
+    origin: 'agent' | 'lensmcp';
+    to?: string;
+    kind: 'message' | 'note';
+    body: string;
+    createdAt: number;
+}
+/** `GET /api/team/board` — `{ same: true, rev }` when `?rev=` is still current. */
+export interface DashTeamBoard {
+    repoId: string;
+    /** The checkout this dashboard serves. */
+    currentWorktreeId: string;
+    /** Changes when anything on the board does: a task, a session, an agent going quiet. */
+    rev: string;
+    /** The store's event sequence. */
+    revision: number;
+    observedAt: number;
+    sessions: DashTeamSession[];
+    worktrees: DashTeamWorktree[];
+    /** Live tasks first, then finished ones, newest first. */
+    tasks: DashTeamTask[];
+    notes: DashTeamNote[];
+    roles: DashTeamRole[];
+    /** More sessions or tasks than the board carries. */
+    truncated: boolean;
+}
+export type DashTeamBoardAnswer = DashTeamBoard | {
+    same: true;
+    rev: string;
+};
+/** `GET /api/team/task?id=` — the task whole, the chain above it (root first), the tasks under it, its blockers. */
+export interface DashTeamTaskWhole {
+    task: DashTeamTask;
+    ancestors: DashTeamTaskRef[];
+    tree: DashTeamTreeNode[];
+    /** More tasks under it than the answer carries. */
+    treeTruncated?: boolean;
+    blockers: DashTeamTaskRef[];
+}
+/** `POST /api/team/task` — a task from the person at the machine. `requestId`: one per submit; a retry sends it again. */
+export interface DashTeamNewTask {
+    requestId: string;
+    title: string;
+    description: string;
+    kind?: DashTeamKind;
+    role?: string;
+    priority?: number;
+    parentId?: string;
+    to?: string;
+    blockedBy?: string[];
+    links?: DashTeamLink[];
+}
+/** `POST /api/team/task/operate` — the person changes a task; each change is a line in its log, by `user`. */
+export interface DashTeamOperate {
+    requestId: string;
+    taskId: string;
+    priority?: number;
+    /** A session id, or null: anyone in its role. */
+    to?: string | null;
+    role?: string;
+    /** Take a held (or abandoned) task back, with why. */
+    release?: string;
+    /** Cancel it, with why. */
+    cancel?: string;
+    note?: string;
+}
+/** `POST /api/team/message` — to one agent, or to everyone (no `to`). */
+export interface DashTeamMessage {
+    requestId: string;
+    body: string;
+    kind: 'message' | 'note';
+    to?: string;
+}

package/lib/team.js

@@ -0,0 +1 @@
+"use strict";export const DASH_TEAM_KINDS=["goal","build","bug","review","test","docs","marketing","research","chore"],DASH_TEAM_LINK_KINDS=["task","flow","error","suggestion","ai-call","review","page","route","commit","branch","worktree","file"];

package/package.json

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