@prjct.app/pi-team 0.6.1 → 0.7.0

package/src/domain/lease.ts

@@ -0,0 +1,54 @@
+import { Type } from 'typebox';
+import { Value } from 'typebox/value';
+import { EntityIdSchema, TeamIdSchema, TimestampSchema, timestampMillis } from './team.ts';
+
+export type LeaseKind = 'presence' | 'delivery' | 'resource';
+
+export type Lease = {
+  readonly schemaVersion: 2;
+  readonly leaseId: string;
+  readonly teamId: string;
+  readonly kind: LeaseKind;
+  readonly holderId: string;
+  readonly resourceId: string;
+  readonly token: string;
+  readonly generation: number;
+  readonly acquiredAt: string;
+  readonly expiresAt: string;
+  readonly releasedAt?: string;
+};
+
+export const LeaseSchema = Type.Object({
+  schemaVersion: Type.Literal(2),
+  leaseId: EntityIdSchema,
+  teamId: TeamIdSchema,
+  kind: Type.Union([Type.Literal('presence'), Type.Literal('delivery'), Type.Literal('resource')]),
+  holderId: EntityIdSchema,
+  resourceId: Type.String({ minLength: 1, maxLength: 4096 }),
+  token: Type.String({ minLength: 32, maxLength: 256 }),
+  generation: Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER }),
+  acquiredAt: TimestampSchema,
+  expiresAt: TimestampSchema,
+  releasedAt: Type.Optional(TimestampSchema),
+}, { additionalProperties: false });
+
+export function assertLease(value: unknown): asserts value is Lease {
+  if (!Value.Check(LeaseSchema, value)) throw new Error('Invalid Team v2 lease record.');
+  const lease = value as Lease;
+  if (lease.resourceId.includes('\0')) throw new Error('Lease resource ID contains a null byte.');
+  const acquired = timestampMillis(lease.acquiredAt, 'lease acquiredAt');
+  if (timestampMillis(lease.expiresAt, 'lease expiresAt') <= acquired) {
+    throw new Error('Lease expiry must be after acquisition.');
+  }
+  if (lease.releasedAt !== undefined && timestampMillis(lease.releasedAt, 'lease releasedAt') < acquired) {
+    throw new Error('Lease release precedes acquisition.');
+  }
+}
+
+export function leaseExpired(lease: Lease, now = Date.now()): boolean {
+  return lease.releasedAt !== undefined || timestampMillis(lease.expiresAt, 'lease expiresAt') <= now;
+}
+
+export function sameLeaseOwner(lease: Lease, token: string, generation: number): boolean {
+  return lease.token === token && lease.generation === generation;
+}

package/src/domain/member.ts

@@ -0,0 +1,58 @@
+import { isAbsolute } from 'node:path';
+import { Type } from 'typebox';
+import { Value } from 'typebox/value';
+import { EntityIdSchema, TeamIdSchema, TimestampSchema, assertTeamId, timestampMillis, type Team } from './team.ts';
+
+export type MemberKind = 'external' | 'supervised';
+export type MemberState = 'active' | 'left';
+
+export type Member = {
+  readonly schemaVersion: 2;
+  readonly teamId: string;
+  readonly memberId: string;
+  readonly sessionId?: string;
+  readonly alias: string;
+  readonly kind: MemberKind;
+  readonly generation: number;
+  readonly state: MemberState;
+  readonly cwd: string;
+  readonly joinedAt: string;
+  readonly updatedAt: string;
+  readonly leftAt?: string;
+};
+
+export const MemberSchema = Type.Object({
+  schemaVersion: Type.Literal(2),
+  teamId: TeamIdSchema,
+  memberId: EntityIdSchema,
+  sessionId: Type.Optional(EntityIdSchema),
+  alias: TeamIdSchema,
+  kind: Type.Union([Type.Literal('external'), Type.Literal('supervised')]),
+  generation: Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER }),
+  state: Type.Union([Type.Literal('active'), Type.Literal('left')]),
+  cwd: Type.String({ minLength: 1, maxLength: 4096 }),
+  joinedAt: TimestampSchema,
+  updatedAt: TimestampSchema,
+  leftAt: Type.Optional(TimestampSchema),
+}, { additionalProperties: false });
+
+export function assertMember(value: unknown): asserts value is Member {
+  if (!Value.Check(MemberSchema, value)) throw new Error('Invalid Team v2 member record.');
+  const member = value as Member;
+  assertTeamId(member.alias);
+  if (member.cwd.includes('\0') || !isAbsolute(member.cwd)) throw new Error('Member cwd must be an absolute path without null bytes.');
+  const joined = timestampMillis(member.joinedAt, 'member joinedAt');
+  const updated = timestampMillis(member.updatedAt, 'member updatedAt');
+  if (updated < joined) throw new Error('Member updatedAt precedes joinedAt.');
+  if ((member.state === 'left') !== (member.leftAt !== undefined)) {
+    throw new Error('Only a member in the left state has leftAt.');
+  }
+  if (member.leftAt !== undefined) {
+    const left = timestampMillis(member.leftAt, 'member leftAt');
+    if (left < joined || left > updated) throw new Error('Member leftAt falls outside its membership lifetime.');
+  }
+}
+
+export function memberBelongsToTeam(member: Member, team: Pick<Team, 'teamId'>): void {
+  if (member.teamId !== team.teamId) throw new Error('Member team ID does not match its team.');
+}

package/src/domain/message.ts

@@ -0,0 +1,91 @@
+import { Type } from 'typebox';
+import { Value } from 'typebox/value';
+import { EntityIdSchema, TeamIdSchema, TimestampSchema, timestampMillis } from './team.ts';
+
+export const MAX_MESSAGE_BODY_BYTES = 8 * 1024;
+export const MAX_MESSAGE_TTL_MS = 24 * 60 * 60 * 1000;
+
+export type MessageKind = 'info' | 'question' | 'proposal' | 'handoff' | 'blocker' | 'request' | 'reply' | 'cancel';
+export type ReceiptStatus = 'delivered' | 'read' | 'replied' | 'cancelled' | 'expired' | 'failed';
+
+export type Receipt = {
+  readonly schemaVersion: 2;
+  readonly teamId: string;
+  readonly messageId: string;
+  readonly recipientId: string;
+  readonly status: ReceiptStatus;
+  readonly at: string;
+};
+
+export const ReceiptSchema = Type.Object({
+  schemaVersion: Type.Literal(2),
+  teamId: TeamIdSchema,
+  messageId: EntityIdSchema,
+  recipientId: EntityIdSchema,
+  status: Type.Union([
+    Type.Literal('delivered'), Type.Literal('read'), Type.Literal('replied'), Type.Literal('cancelled'),
+    Type.Literal('expired'), Type.Literal('failed'),
+  ]),
+  at: TimestampSchema,
+}, { additionalProperties: false });
+
+export function assertReceipt(value: unknown): asserts value is Receipt {
+  if (!Value.Check(ReceiptSchema, value)) throw new Error('Invalid Team v2 receipt record.');
+  timestampMillis((value as Receipt).at, 'receipt timestamp');
+}
+
+export type Envelope = {
+  readonly schemaVersion: 2;
+  readonly messageId: string;
+  readonly teamId: string;
+  readonly threadId: string;
+  readonly requestId?: string;
+  readonly kind: MessageKind;
+  readonly fromMemberId: string;
+  readonly toMemberId: string;
+  readonly senderGeneration: number;
+  readonly recipientGeneration?: number;
+  readonly createdAt: string;
+  readonly expiresAt: string;
+  readonly body: string;
+};
+
+export const EnvelopeSchema = Type.Object({
+  schemaVersion: Type.Literal(2),
+  messageId: EntityIdSchema,
+  teamId: TeamIdSchema,
+  threadId: EntityIdSchema,
+  requestId: Type.Optional(EntityIdSchema),
+  kind: Type.Union([
+    Type.Literal('info'), Type.Literal('question'), Type.Literal('proposal'), Type.Literal('handoff'),
+    Type.Literal('blocker'), Type.Literal('request'), Type.Literal('reply'), Type.Literal('cancel'),
+  ]),
+  fromMemberId: EntityIdSchema,
+  toMemberId: EntityIdSchema,
+  senderGeneration: Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER }),
+  recipientGeneration: Type.Optional(Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER })),
+  createdAt: TimestampSchema,
+  expiresAt: TimestampSchema,
+  body: Type.String({ maxLength: MAX_MESSAGE_BODY_BYTES }),
+}, { additionalProperties: false });
+
+export function assertEnvelope(value: unknown): asserts value is Envelope {
+  if (!Value.Check(EnvelopeSchema, value)) throw new Error('Invalid Team v2 message envelope.');
+  const message = value as Envelope;
+  if (Buffer.byteLength(message.body, 'utf8') > MAX_MESSAGE_BODY_BYTES) {
+    throw new Error(`Message body exceeds ${MAX_MESSAGE_BODY_BYTES} bytes.`);
+  }
+  const created = timestampMillis(message.createdAt, 'message createdAt');
+  const expires = timestampMillis(message.expiresAt, 'message expiresAt');
+  if (expires <= created || expires - created > MAX_MESSAGE_TTL_MS) {
+    throw new Error('Message expiry must be after creation and within 24 hours.');
+  }
+  const correlated = ['request', 'reply', 'cancel'].includes(message.kind);
+  if (correlated !== (message.requestId !== undefined)) {
+    throw new Error('Request, reply, and cancel messages require requestId; other message kinds must omit it.');
+  }
+}
+
+export function messageExpired(message: Envelope, now = Date.now()): boolean {
+  return timestampMillis(message.expiresAt, 'message expiresAt') <= now;
+}

package/src/domain/request.ts

@@ -0,0 +1,67 @@
+import { Type } from 'typebox';
+import { Value } from 'typebox/value';
+import { MAX_MESSAGE_TTL_MS } from './message.ts';
+import { EntityIdSchema, TeamIdSchema, TimestampSchema, timestampMillis } from './team.ts';
+
+export type RequestState = 'queued' | 'delivered' | 'accepted' | 'replied' | 'cancelled' | 'expired';
+
+export type Request = {
+  readonly schemaVersion: 2;
+  readonly requestId: string;
+  readonly messageId: string;
+  readonly teamId: string;
+  readonly senderMemberId: string;
+  readonly recipientMemberId: string;
+  readonly senderGeneration: number;
+  readonly recipientGeneration?: number;
+  readonly state: RequestState;
+  readonly createdAt: string;
+  readonly updatedAt: string;
+  readonly expiresAt: string;
+};
+
+export const RequestSchema = Type.Object({
+  schemaVersion: Type.Literal(2),
+  requestId: EntityIdSchema,
+  messageId: EntityIdSchema,
+  teamId: TeamIdSchema,
+  senderMemberId: EntityIdSchema,
+  recipientMemberId: EntityIdSchema,
+  senderGeneration: Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER }),
+  recipientGeneration: Type.Optional(Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER })),
+  state: Type.Union([
+    Type.Literal('queued'), Type.Literal('delivered'), Type.Literal('accepted'), Type.Literal('replied'),
+    Type.Literal('cancelled'), Type.Literal('expired'),
+  ]),
+  createdAt: TimestampSchema,
+  updatedAt: TimestampSchema,
+  expiresAt: TimestampSchema,
+}, { additionalProperties: false });
+
+const transitions: Readonly<Record<RequestState, readonly RequestState[]>> = {
+  queued: ['delivered', 'cancelled', 'expired'],
+  delivered: ['accepted', 'cancelled', 'expired'],
+  accepted: ['replied', 'cancelled', 'expired'],
+  replied: [],
+  cancelled: [],
+  expired: [],
+};
+
+export function assertRequest(value: unknown): asserts value is Request {
+  if (!Value.Check(RequestSchema, value)) throw new Error('Invalid Team v2 request record.');
+  const request = value as Request;
+  const created = timestampMillis(request.createdAt, 'request createdAt');
+  const updated = timestampMillis(request.updatedAt, 'request updatedAt');
+  const expires = timestampMillis(request.expiresAt, 'request expiresAt');
+  if (updated < created || expires <= created || expires - created > MAX_MESSAGE_TTL_MS) {
+    throw new Error('Invalid request timestamp ordering or TTL.');
+  }
+}
+
+export function assertRequestTransition(from: RequestState, to: RequestState): void {
+  if (!transitions[from].includes(to)) throw new Error(`Invalid request transition: ${from} → ${to}.`);
+}
+
+export function requestTerminal(state: RequestState): boolean {
+  return transitions[state].length === 0;
+}

package/src/domain/team.ts

@@ -0,0 +1,71 @@
+import { Type } from 'typebox';
+import { Value } from 'typebox/value';
+
+export const TEAM_ID_PATTERN = /^[a-z][a-z0-9-]{0,47}$/;
+export const ENTITY_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+export const ISO_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+
+export const TeamIdSchema = Type.String({ pattern: TEAM_ID_PATTERN.source });
+export const EntityIdSchema = Type.String({ pattern: ENTITY_ID_PATTERN.source });
+export const TimestampSchema = Type.String({ pattern: ISO_TIMESTAMP_PATTERN.source });
+
+export type TeamState = 'open' | 'closing' | 'closing_blocked' | 'closed';
+
+const transitions: Readonly<Record<TeamState, readonly TeamState[]>> = {
+  open: ['closing'],
+  closing: ['closing_blocked', 'closed'],
+  closing_blocked: ['closing', 'closed'],
+  closed: [],
+};
+
+export type Team = {
+  readonly schemaVersion: 2;
+  readonly teamId: string;
+  readonly state: TeamState;
+  readonly createdAt: string;
+  readonly updatedAt: string;
+};
+
+export const TeamSchema = Type.Object({
+  schemaVersion: Type.Literal(2),
+  teamId: TeamIdSchema,
+  state: Type.Union([
+    Type.Literal('open'),
+    Type.Literal('closing'),
+    Type.Literal('closing_blocked'),
+    Type.Literal('closed'),
+  ]),
+  createdAt: TimestampSchema,
+  updatedAt: TimestampSchema,
+}, { additionalProperties: false });
+
+export function assertTeamId(value: string): string {
+  if (!TEAM_ID_PATTERN.test(value)) {
+    throw new Error('Invalid team ID. Use 1–48 lowercase letters, digits, or hyphens, starting with a letter.');
+  }
+  return value;
+}
+
+export function assertEntityId(value: string, label = 'entity ID'): string {
+  if (!ENTITY_ID_PATTERN.test(value)) throw new Error(`Invalid ${label}.`);
+  return value;
+}
+
+export function timestampMillis(value: string, label = 'timestamp'): number {
+  if (!ISO_TIMESTAMP_PATTERN.test(value)) throw new Error(`Invalid ${label}.`);
+  const millis = Date.parse(value);
+  if (!Number.isFinite(millis) || new Date(millis).toISOString() !== value) throw new Error(`Invalid ${label}.`);
+  return millis;
+}
+
+export function assertTeam(value: unknown): asserts value is Team {
+  if (!Value.Check(TeamSchema, value)) throw new Error('Invalid Team v2 record.');
+  const team = value as Team;
+  if (timestampMillis(team.updatedAt, 'team updatedAt') < timestampMillis(team.createdAt, 'team createdAt')) {
+    throw new Error('Team updatedAt precedes createdAt.');
+  }
+}
+
+export function assertTeamTransition(from: TeamState, to: TeamState): void {
+  if (from !== to && !transitions[from].includes(to)) throw new Error(`Invalid team transition: ${from} → ${to}.`);
+}

package/src/dynamic/domain.ts

@@ -0,0 +1,110 @@
+import { Type, type Static } from 'typebox';
+import { Value } from 'typebox/value';
+import { StringEnum } from '@earendil-works/pi-ai';
+import { EntityIdSchema, TimestampSchema } from '../domain/team.ts';
+
+export const LIMITS = { runs: 64, assignments: 128, experts: 16, history: 32, concurrent: 3, recordBytes: 2 * 1024 * 1024 } as const;
+const text = (maxLength: number) => Type.String({ maxLength });
+const strict = { additionalProperties: false } as const;
+const tag = Type.String({ pattern: '^[a-z][a-z0-9-]{0,31}$' });
+export const PolicySchema = Type.Object({
+  tools: Type.Array(StringEnum(['read', 'grep', 'find', 'ls', 'edit', 'write', 'bash']), { maxItems: 7, uniqueItems: true }),
+}, strict);
+export const DispatchSchema = Type.Object({
+  role: text(64), capabilities: Type.Array(text(64), { maxItems: 16, minItems: 1 }),
+  task: text(8192), instructions: Type.Optional(text(4096)), policy: PolicySchema,
+}, strict);
+export type Dispatch = Static<typeof DispatchSchema>;
+export type Policy = Static<typeof PolicySchema>;
+export const ExpertSchema = Type.Object({
+  id: EntityIdSchema, role: tag, capabilities: Type.Array(tag, { maxItems: 16, uniqueItems: true }),
+  instructions: text(4096), policy: PolicySchema, sessionRef: EntityIdSchema,
+  generation: Type.Integer({ minimum: 0 }), status: StringEnum(['idle', 'busy', 'blocked']),
+  memory: text(4096), history: Type.Array(EntityIdSchema, { maxItems: LIMITS.history }),
+  createdAt: TimestampSchema, updatedAt: TimestampSchema,
+}, strict);
+export const RunSchema = Type.Object({
+  id: EntityIdSchema, objective: text(8192), summary: text(4096),
+  status: StringEnum(['queued', 'active', 'completed', 'cancelled', 'interrupted']),
+  createdAt: TimestampSchema, updatedAt: TimestampSchema, startedAt: Type.Optional(TimestampSchema), endedAt: Type.Optional(TimestampSchema),
+}, strict);
+export const AssignmentSchema = Type.Object({
+  id: EntityIdSchema, runId: EntityIdSchema, expertId: EntityIdSchema,
+  generation: Type.Integer({ minimum: 0 }), ownerEpoch: Type.Integer({ minimum: 1 }),
+  status: StringEnum(['queued', 'running', 'completed', 'failed', 'cancelled', 'cancelled_waiting']),
+  task: text(8192), result: text(4096), error: text(512),
+  createdAt: TimestampSchema, updatedAt: TimestampSchema, endedAt: Type.Optional(TimestampSchema),
+}, strict);
+export const OwnerSchema = Type.Object({
+  sessionId: EntityIdSchema, instanceId: EntityIdSchema, epoch: Type.Integer({ minimum: 1 }),
+  processPid: Type.Integer({ minimum: 2 }), processGroupId: Type.Integer({ minimum: 2 }), processStartToken: text(256),
+}, strict);
+export const StateSchema = Type.Object({
+  schemaVersion: Type.Literal(1), teamId: Type.String({ pattern: '^p-[a-f0-9]{40}$' }), projectPath: text(4096),
+  epoch: Type.Integer({ minimum: 0 }), owner: Type.Optional(OwnerSchema),
+  orchestrator: Type.Object({ summary: text(4096), lastSessionId: Type.Optional(EntityIdSchema) }, strict),
+  experts: Type.Array(ExpertSchema, { maxItems: LIMITS.experts }),
+  runs: Type.Array(RunSchema, { maxItems: LIMITS.runs }),
+  assignments: Type.Array(AssignmentSchema, { maxItems: LIMITS.assignments }),
+  createdAt: TimestampSchema, updatedAt: TimestampSchema,
+}, strict);
+export type Expert = Static<typeof ExpertSchema>;
+export type Run = Static<typeof RunSchema>;
+export type Assignment = Static<typeof AssignmentSchema>;
+export type Owner = Static<typeof OwnerSchema>;
+export type TeamState = Static<typeof StateSchema>;
+export const terminalRun = (run: Run): boolean => !['active', 'queued'].includes(run.status);
+export const terminalAssignment = (assignment: Assignment): boolean => !['running', 'queued'].includes(assignment.status);
+
+export function bounded(value: string, bytes: number, label = 'text'): string {
+  if (Buffer.byteLength(value, 'utf8') > bytes) throw new Error(`${label} exceeds ${bytes} UTF-8 bytes.`);
+  return value;
+}
+
+// Metadata must never contain credentials. This is best-effort redaction, not a secret detector.
+export function metadata(value: string, bytes = 4096): string {
+  const safe = value.replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, '')
+    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '')
+    .replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f\u202a-\u202e\u2066-\u2069]/g, '')
+    .replace(/\b(?:sk-[A-Za-z0-9_-]{8,}|Bearer\s+[^\s]+|[a-f0-9]{64})\b/gi, '[redacted]')
+    .replace(/\b(password|secret|token|api[_-]?key)\s*[:=]\s*[^\s,;]+/gi, '$1=[redacted]');
+  const chars: string[] = [];
+  const size = { value: 0 };
+  for (const char of safe) {
+    size.value += Buffer.byteLength(char, 'utf8');
+    if (size.value > bytes) break;
+    chars.push(char);
+  }
+  return chars.join('');
+}
+
+export function normalizeTag(value: string): string {
+  const normalized = value.trim().toLowerCase().replace(/[\s_]+/g, '-');
+  if (!/^[a-z][a-z0-9-]{0,31}$/.test(normalized)) throw new Error('Role/capability must normalize to a short lowercase tag.');
+  return normalized;
+}
+
+export function assertState(value: unknown): asserts value is TeamState {
+  if (!Value.Check(StateSchema, value)) throw new Error('Invalid dynamic Team record.');
+  const state = value as TeamState;
+  bounded(state.projectPath, 4096);
+  bounded(state.orchestrator.summary, 4096);
+  for (const expert of state.experts) { bounded(expert.instructions, 4096); bounded(expert.memory, 4096); }
+  for (const run of state.runs) { bounded(run.objective, 8192); bounded(run.summary, 4096); }
+  for (const a of state.assignments) { bounded(a.task, 8192); bounded(a.result, 4096); bounded(a.error, 512); }
+  if (state.runs.filter(run => run.status === 'active').length > 1) throw new Error('Multiple active Runs.');
+  for (const values of [state.runs, state.experts, state.assignments]) {
+    if (new Set(values.map(value => value.id)).size !== values.length) throw new Error('Duplicate record identity.');
+  }
+  if (new Set(state.experts.map(expert => expert.role)).size !== state.experts.length) throw new Error('Duplicate role capacity.');
+  if (state.assignments.filter(a => a.status === 'running').length > LIMITS.concurrent) throw new Error('Concurrency limit exceeded.');
+  for (const a of state.assignments) {
+    const expert = state.experts.find(e => e.id === a.expertId);
+    const run = state.runs.find(r => r.id === a.runId);
+    if (!expert || !run) throw new Error('Dangling assignment.');
+    if (a.status === 'running' && (run.status !== 'active' || a.generation !== expert.generation || expert.status !== 'busy')) throw new Error('Invalid active assignment.');
+  }
+  for (const expert of state.experts) {
+    if (state.assignments.filter(a => a.expertId === expert.id && a.status === 'running').length > 1) throw new Error('Expert is double booked.');
+  }
+}

package/src/dynamic/memory.ts

@@ -0,0 +1,38 @@
+/**
+ * Project memory for an Expert, read by the orchestrator's process.
+ *
+ * An Expert starts without extensions, so it cannot open memory itself.
+ * pi-memory publishes a read-only view on a well-known process symbol that
+ * filters by stance: facts about the terrain reach everyone, decisions reach
+ * only those who must obey them, and a reviewer gets rules and procedures only
+ * so it judges from scratch. Absent pi-memory, an Expert simply starts without.
+ */
+export type ExpertStance = 'worker' | 'explorer' | 'reviewer';
+
+const WRITE_TOOLS = ['edit', 'write', 'bash'];
+const REVIEWING = /review|qa|audit|verif|critic|check|test/;
+
+/**
+ * Roles are free-form, so the stance is read from what the Expert may do.
+ * A writer is a worker. A reader named for judging is a reviewer. Any other
+ * reader is an explorer. Unsure falls to the stricter side: a reader.
+ */
+export function expertStance(role: string, tools: readonly string[]): ExpertStance {
+  if (tools.some(tool => WRITE_TOOLS.includes(tool))) return 'worker';
+  return REVIEWING.test(role.toLowerCase()) ? 'reviewer' : 'explorer';
+}
+
+type ChildMemoryView = (request: { role: ExpertStance; query?: string }) => Promise<{ text: string }>;
+const MEMORY_KEY = Symbol.for('prjct.memory');
+const DEADLINE_MS = 5_000;
+export const MAX_MEMORY_BYTES = 4096;
+
+/** The rendered memory for a stance and a task; '' when there is none, it fails, or it is slow. */
+export async function expertMemory(stance: ExpertStance, query: string): Promise<string> {
+  const host = (globalThis as unknown as Record<symbol, { childView?: ChildMemoryView } | undefined>)[MEMORY_KEY];
+  if (typeof host?.childView !== 'function') return '';
+  const timeout = new Promise<string>(resolve => { setTimeout(resolve, DEADLINE_MS, '').unref?.(); });
+  const text = await Promise.race([host.childView({ role: stance, query: query.slice(0, 1000) })
+    .then(view => view.text).catch(() => ''), timeout]);
+  return Buffer.byteLength(text, 'utf8') <= MAX_MEMORY_BYTES ? text : '';
+}

package/src/dynamic/panel.ts

@@ -0,0 +1,155 @@
+import { SYMBOL, ago, type PanelAction, type PanelItem, type PanelSpec, type Tone } from '@prjct.app/pi-tui-kit';
+import { LIMITS, metadata, type Assignment, type Expert, type Run, type TeamState } from './domain.ts';
+import { peerLine, type PeerEntry } from './peer-log.ts';
+
+/** What the /team panel can ask of the extension. */
+export type TeamOps = Readonly<{
+  load(): Promise<TeamState | undefined>;
+  /** Whether this session owns the project Team and may cancel Runs. */
+  isOwner(): boolean;
+  cancel(runId: string): Promise<string>;
+  /** Close the panel and put "/team " in the editor for a new objective. */
+  compose(): void;
+  /** Direct Expert-to-Expert messages, newest last. */
+  messages?(): Promise<readonly PeerEntry[]>;
+}>;
+
+const TEAM = 'team';
+const RUN = 'run:';
+const EXPERT = 'expert:';
+const one = (text: string, max = 160): string => metadata(text, max).replace(/\s+/g, ' ').trim();
+const time = (iso: string | undefined): number | undefined => {
+  const parsed = iso ? Date.parse(iso) : Number.NaN;
+  return Number.isFinite(parsed) ? parsed : undefined;
+};
+const RUN_TONE: Record<Run['status'], [string, Tone]> = {
+  active: [SYMBOL.active, 'accent'], queued: [SYMBOL.idle, 'muted'], completed: [SYMBOL.ok, 'success'],
+  cancelled: [SYMBOL.idle, 'dim'], interrupted: [SYMBOL.attention, 'warning'],
+};
+const EXPERT_TONE: Record<Expert['status'], [string, Tone]> = {
+  busy: [SYMBOL.active, 'accent'], idle: [SYMBOL.idle, 'muted'], blocked: [SYMBOL.attention, 'warning'],
+};
+const ASSIGNMENT_MARK: Record<Assignment['status'], string> = {
+  queued: SYMBOL.idle, running: SYMBOL.active, completed: SYMBOL.ok, failed: SYMBOL.error, cancelled: SYMBOL.idle, cancelled_waiting: SYMBOL.attention,
+};
+
+/** Runs (newest first) and Experts, with every assignment traceable from both sides. */
+export function teamPanelSpec(ops: TeamOps, initial: TeamState | undefined): PanelSpec {
+  const state = { team: initial, talk: [] as readonly PeerEntry[] };
+  const listeners = new Set<() => void>();
+  const reload = async (): Promise<void> => {
+    state.team = await ops.load();
+    state.talk = await ops.messages?.() ?? [];
+    for (const listener of listeners) listener();
+  };
+  void reload().catch(() => undefined);
+  const run = (item: PanelItem | undefined) => item?.id.startsWith(RUN) ? state.team?.runs.find(entry => entry.id === item.id.slice(RUN.length)) : undefined;
+  const expert = (id: string) => state.team?.experts.find(entry => entry.id === id);
+  const assignmentLine = (assignment: Assignment, by: 'run' | 'expert'): string => {
+    const who = by === 'run' ? expert(assignment.expertId)?.role ?? assignment.expertId : state.team?.runs.find(entry => entry.id === assignment.runId)?.id ?? assignment.runId;
+    const outcome = assignment.error ? ` · ${one(assignment.error, 80)}` : assignment.result ? ` · ${one(assignment.result, 80)}` : '';
+    return `${ASSIGNMENT_MARK[assignment.status]} ${assignment.status.padEnd(9)} ${one(who, 32)} · ${one(assignment.task, 60)}${outcome}`;
+  };
+
+  const actions: PanelAction[] = [
+    { key: 'n', label: 'New objective', run: (_item, panel) => { panel.close(); ops.compose(); } },
+    {
+      key: 'c', label: 'Cancel run', confirm: true,
+      when: item => { const found = run(item); return !!found && ['active', 'queued'].includes(found.status) && ops.isOwner(); },
+      run: async (item, panel) => { const text = await ops.cancel(run(item)!.id); await reload(); panel.notice(text, 'success'); },
+    },
+  ];
+
+  return {
+    title: 'Team',
+    summary: () => {
+      const team = state.team;
+      if (!team) return 'no Team yet';
+      const active = team.runs.filter(entry => entry.status === 'active').length;
+      const queued = team.runs.filter(entry => entry.status === 'queued').length;
+      const busy = team.experts.filter(entry => entry.status === 'busy').length;
+      return `${active} active · ${queued} queued · ${busy}/${team.experts.length} experts busy`;
+    },
+    items: () => {
+      const team = state.team;
+      if (!team) return [];
+      const blocked = team.experts.filter(entry => entry.status === 'blocked').length;
+      return [
+        { id: TEAM, label: 'team', symbol: blocked ? SYMBOL.attention : SYMBOL.active, tone: blocked ? 'warning' : 'success', meta: team.owner ? 'owned' : 'no owner' },
+        ...[...team.runs].reverse().map((entry): PanelItem => {
+          const [symbol, tone] = RUN_TONE[entry.status];
+          return { id: `${RUN}${entry.id}`, label: one(entry.objective, 60), symbol, tone, meta: `${entry.status} · ${ago(time(entry.updatedAt))}`, search: entry.id };
+        }),
+        ...team.experts.map((entry): PanelItem => {
+          const [symbol, tone] = EXPERT_TONE[entry.status];
+          return { id: `${EXPERT}${entry.id}`, label: `expert · ${one(entry.role, 40)}`, symbol, tone, meta: entry.status, search: entry.capabilities.join(' ') };
+        }),
+      ];
+    },
+    detail: item => {
+      const team = state.team!;
+      const found = run(item);
+      if (found) {
+        const work = team.assignments.filter(entry => entry.runId === found.id).reverse();
+        return {
+          title: one(found.objective, 200),
+          subtitle: found.status, subtitleTone: RUN_TONE[found.status][1],
+          fields: [
+            { label: 'run', value: found.id },
+            { label: 'started', value: found.startedAt ? ago(time(found.startedAt)) : 'not yet' },
+            ...(found.endedAt ? [{ label: 'ended', value: ago(time(found.endedAt)) }] : []),
+            ...(found.summary ? [{ label: 'summary', value: one(found.summary, 600) }] : []),
+          ],
+          sections: [{ title: `Assignments (${work.length})`, lines: work.map(entry => assignmentLine(entry, 'run')) }],
+        };
+      }
+      if (item.id.startsWith(EXPERT)) {
+        const person = expert(item.id.slice(EXPERT.length))!;
+        const work = team.assignments.filter(entry => entry.expertId === person.id).reverse();
+        const talk = [...state.talk].reverse().filter(entry => entry.from === person.role || entry.to === person.role);
+        return {
+          title: one(person.role, 80),
+          subtitle: person.status, subtitleTone: EXPERT_TONE[person.status][1],
+          fields: [
+            { label: 'expert', value: person.id },
+            { label: 'can', value: person.capabilities.join(', ') || '—' },
+            { label: 'generation', value: String(person.generation) },
+            { label: 'updated', value: ago(time(person.updatedAt)) },
+            ...(person.memory ? [{ label: 'memory', value: one(person.memory, 400) }] : []),
+          ],
+          sections: [
+            { title: `Assignments (${work.length})`, lines: work.map(entry => assignmentLine(entry, 'expert')) },
+            { title: 'Messages', lines: talk.map(entry => `${ago(time(entry.at))}  ${peerLine(entry)}`) },
+          ],
+        };
+      }
+      const blocked = team.experts.filter(entry => entry.status === 'blocked').length;
+      return {
+        title: 'team',
+        subtitle: blocked ? `${blocked} blocked expert${blocked === 1 ? '' : 's'} need manual process verification.` : 'Healthy.',
+        subtitleTone: blocked ? 'warning' : 'success',
+        fields: [
+          { label: 'team', value: team.teamId },
+          { label: 'owner', value: team.owner ? `recorded · epoch ${team.epoch} (not a liveness guarantee)` : 'none' },
+          { label: 'this session', value: ops.isOwner() ? 'owner' : 'observer' },
+          { label: 'parallel', value: `up to ${LIMITS.concurrent} experts` },
+          { label: 'runs', value: String(team.runs.length) },
+          { label: 'experts', value: String(team.experts.length) },
+        ],
+        sections: [
+          ...(team.orchestrator.summary ? [{ title: 'Orchestrator', lines: [one(team.orchestrator.summary, 800)] }] : []),
+          { title: 'Recent assignments', lines: team.assignments.slice(-10).reverse().map(entry => assignmentLine(entry, 'run')) },
+          { title: 'Experts talking directly', lines: [...state.talk].reverse().map(entry => `${ago(time(entry.at))}  ${peerLine(entry)}`) },
+        ],
+      };
+    },
+    actions,
+    empty: 'No Team for this project yet. Press n, or type /team <objective>.',
+    subscribe: listener => {
+      listeners.add(listener);
+      const timer = setInterval(() => { void reload().catch(() => undefined); }, 2000);
+      timer.unref?.();
+      return () => { listeners.delete(listener); clearInterval(timer); };
+    },
+  };
+}