praxis-agent 0.37.0 → 0.38.0

package/README.md

@@ -38,6 +38,10 @@ Praxis does not use Claude subscription authentication. Claude Code
 interoperability covers local sessions, configuration, permissions, memory,
 skills, hooks, agents, plugins, and MCP data.
 
+Claude Team compatibility is explicit and fail-closed: supported delete/send
+wire shapes route through native Team operations, while lossy or unsupported
+Team surfaces are rejected rather than silently simplified.
+
 ## Install
 
 ```sh
@@ -123,7 +127,9 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   `Ctrl+V` text/image clipboard paste, `Ctrl+Z` shell suspension and `fg`
   recovery, permission-gated `!` shell turns, navigable current/per-turn Git
   diff views, semantic plan/question decision panels with complete
-  screen-reader actions, and measured context budgets; print mode,
+  screen-reader actions, semantic screen projection across selectable surfaces,
+  deterministic resize-aware URL/form elicitation rendering, and measured
+  context budgets; print mode,
   structured JSON/JSONL, context compaction, tool loops, and bounded execution.
 - **Built-in tools** — read, write, edit, glob, search, shell, notebook, PDF,
   image, web, scheduled prompts, workflows, and worktrees.
@@ -166,7 +172,15 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   and shutdown-drain budgets.
   Child permissions can only tighten the parent; concurrent asks form one FIFO
   Lead Decision queue with provenance. Coordinator leads are restricted to
-  orchestration, and custom Team agents receive no MCP capability.
+  orchestration, and custom Team agents receive no MCP capability. The native
+  CLI also exposes `praxis team status`, `logs`, and `attach` in human or JSON
+  form; durable-local attach does not require tmux. The Claude Team adapter is
+  removable and currently limited to fixture-verified delete/send; Claude create
+  is decoded but rejected when the payload cannot represent native roster/task
+  claims,
+  shutdown, and plan-response shapes; native task, notification, context, and
+  Team resume/inbox seams are implemented, while their Claude-facing zero-skip
+  qualification remains explicitly separate.
 - **Claude-compatible ecosystem** — shared instructions with recursive `@`
   imports, memory, skills, commands, agents, hooks, settings, MCP servers,
   plugins, and transcript data.
@@ -254,9 +268,19 @@ npm ci
 npm run check
 ```
 
-`npm run build:native` compiles the current Praxis-owned core, provider
-adapters, and native data-plane slice without the Claude compatibility adapter.
+`npm run build:native` compiles the implemented Praxis-owned core, provider,
+native transcript, and session profile without the Claude compatibility adapter.
+`npm run test:native:deletion` adds an emitted-output deletion gate. These are
+implemented profile checks, not qualification of the full native package.
+Native transcript migration remains explicit and recoverable. The built-CLI
+smoke gate `npm run verify:native-migration-cli` exercises all-session dry-run,
+publication, text/JSON idempotence, rollback, and Claude-data-plane exclusion.
+The isolated active-stream regression proof is available through
+`npm run test:performance:active-stream`; the product p95 budget remains 50 ms.
 `npm run check` also enforces the corresponding source dependency direction.
+`npm run test:core-completion` runs the 56-story #402 audit and reports
+implemented, qualified, blocked, deferred, and out-of-scope states separately;
+it never treats missing live prerequisites as a pass.
 
 Contributions use Conventional Commit pull-request titles and the protected
 squash-merge workflow. Read

package/dist/application/session-service.d.ts

@@ -28,7 +28,8 @@ import type { ClaudeInteractiveToolManager } from '../tools/claude-interactive-t
 import type { ClaudePermissionMode } from '../permissions/claude-permission-resolver.js';
 import type { ClaudeMcpRuntime, ClaudeMcpServerStatus, ClaudeMcpToolInspection } from '../mcp/claude-mcp-tools.js';
 import type { TeamLeadOperations } from './team-lead-operations.js';
-type TeamLeadToolRegistryFactory = (base: ToolRegistry, operations: TeamLeadOperations, sessionId: string, enabledTools: readonly string[]) => ToolRegistry;
+import type { ClaudeTeamCompatibilityPort } from '../tools/team-lead-tools.js';
+type TeamLeadToolRegistryFactory = (base: ToolRegistry, operations: TeamLeadOperations, sessionId: string, enabledTools: readonly string[], compatibilityPort?: ClaudeTeamCompatibilityPort) => ToolRegistry;
 export interface ClaudeSessionServiceOptions {
     configRoot: string;
     /** `claude` preserves the legacy shared layout; the CLI selects `native` by default. */
@@ -113,6 +114,7 @@ export interface ClaudeSessionServiceOptions {
     teamLeadOperations?: TeamLeadOperations;
     /** Lazily supplied Team tool wrapper, so disabled runs do not load Team code. */
     teamLeadToolRegistryFactory?: TeamLeadToolRegistryFactory;
+    teamLeadCompatibilityPort?: ClaudeTeamCompatibilityPort;
 }
 export interface SessionRunResult {
     sessionId: string;

package/dist/application/session-service.js

@@ -5545,7 +5545,7 @@ export class ClaudeSessionService {
                     return;
                 if (snapshot.entries.length === 0)
                     return;
-                const entries = mergeClaudeDurableMetadataSnapshot(this.durableMetadataSnapshots.get(sessionId) ?? [], snapshot.tailEntries, sessionId);
+                const entries = mergeClaudeDurableMetadataSnapshot(this.durableMetadataSnapshots.get(sessionId) ?? [], snapshot.tailEntries, sessionId).filter((entry) => entry.type !== 'worktree-state');
                 if (entries.length === 0)
                     return;
                 const appended = await lease.appendMetadataSnapshot(snapshot.tail, entries);
@@ -5919,7 +5919,7 @@ export class ClaudeSessionService {
         if (!factory) {
             throw new Error('Team lead operations require a Team lead tool registry factory');
         }
-        return factory(base, operations, sessionId, enabledTools);
+        return factory(base, operations, sessionId, enabledTools, this.options.teamLeadCompatibilityPort);
     }
     async append(lease, tail, entry) {
         const result = await lease.append(tail, entry);

package/dist/application/team-agent-runtime.d.ts

@@ -4,6 +4,7 @@ import type { ClaudeExtensionCatalog } from '../extensions/claude-extensions.js'
 import type { ClaudeHookRunner } from '../hooks/claude-hooks.js';
 import { type AgentPermissionMode } from './subagent-service.js';
 import type { TeamAgentRuntime } from './team-manager.js';
+import { type TeamLeadDecisionSurface } from './team-lead-decision-surface.js';
 export interface ClaudeTeamAgentRuntimeOptions {
     readonly nativeRoot: string;
     readonly configRoot: string;
@@ -16,9 +17,11 @@ export interface ClaudeTeamAgentRuntimeOptions {
     readonly permissionResolverForMode?: (mode: AgentPermissionMode) => PermissionResolver;
     readonly eventSink?: RuntimeEventSink;
     readonly approveTool?: (call: ModelToolCall, originalCall?: ModelToolCall, decision?: PermissionDecision) => PermissionApproval | Promise<PermissionApproval>;
+    readonly decisionSurface?: TeamLeadDecisionSurface;
 }
 export declare class ClaudeTeamAgentRuntime implements TeamAgentRuntime {
     private readonly options;
+    private readonly decisionSurface;
     constructor(options: ClaudeTeamAgentRuntimeOptions);
     run(input: Parameters<TeamAgentRuntime['run']>[0]): Promise<{
         status: 'completed' | 'failed' | 'orphaned';

package/dist/application/team-agent-runtime.js

@@ -5,6 +5,7 @@ import { resolveProjectIdentity } from '../platform/project-identity.js';
 import { sanitizeProjectPath } from '../platform/project-path-key.js';
 import { ClaudeSubagentExecutor, } from './subagent-service.js';
 import { teamMailboxMessageId } from './team-mailbox.js';
+import { SerializedTeamLeadDecisionSurface, } from './team-lead-decision-surface.js';
 function digest(value) {
     return createHash('sha256').update(value).digest('hex');
 }
@@ -41,8 +42,14 @@ function taskPrompt(input) {
 }
 export class ClaudeTeamAgentRuntime {
     options;
+    decisionSurface;
     constructor(options) {
         this.options = options;
+        this.decisionSurface =
+            options.decisionSurface ??
+                (options.approveTool
+                    ? new SerializedTeamLeadDecisionSurface(options.approveTool)
+                    : undefined);
     }
     async run(input) {
         if (this.options.provider.capabilities.usage !== true)
@@ -51,7 +58,7 @@ export class ClaudeTeamAgentRuntime {
         const identity = executionIdentity(projectIdentity, input.teamId, input.task.id, input.generation);
         const transcriptDirectory = join(this.options.nativeRoot, 'state', 'team-executions', sanitizeProjectPath(projectIdentity), `team-${digest(input.teamId).slice(0, 16)}`, identity.taskDirectory);
         await mkdir(transcriptDirectory, { recursive: true });
-        const approveTool = this.options.approveTool;
+        const decisionSurface = this.decisionSurface;
         const executor = new ClaudeSubagentExecutor({
             configRoot: this.options.configRoot,
             dataPlane: 'native',
@@ -86,7 +93,7 @@ export class ClaudeTeamAgentRuntime {
                     });
                 this.options.eventSink?.(event);
             },
-            ...(approveTool
+            ...(decisionSurface
                 ? {
                     approveTool: (call, originalCall, decision) => {
                         const wrapped = decision?.behavior === 'ask'
@@ -102,7 +109,17 @@ export class ClaudeTeamAgentRuntime {
                                 },
                             }
                             : decision;
-                        return approveTool(call, originalCall, wrapped);
+                        if (wrapped?.behavior !== 'ask')
+                            return { behavior: 'allow' };
+                        return decisionSurface.request({
+                            call,
+                            ...(originalCall ? { originalCall } : {}),
+                            decision: wrapped,
+                            teamId: input.teamId,
+                            member: input.member.name,
+                            taskId: input.task.id,
+                            generation: input.generation,
+                        });
                     },
                 }
                 : {}),

package/dist/application/team-lead-decision-surface.d.ts

@@ -0,0 +1,22 @@
+import type { ModelToolCall, PermissionApproval, PermissionDecision } from '../core/runtime.js';
+export interface TeamLeadDecisionRequest {
+    readonly call: ModelToolCall;
+    readonly originalCall?: ModelToolCall;
+    readonly decision: PermissionDecision;
+    readonly teamId: string;
+    readonly member: string;
+    readonly taskId: string;
+    readonly generation: number;
+}
+export interface TeamLeadDecisionSurface {
+    request(input: TeamLeadDecisionRequest): PermissionApproval | Promise<PermissionApproval>;
+}
+export type TeamLeadApproveTool = (call: ModelToolCall, originalCall?: ModelToolCall, decision?: PermissionDecision) => PermissionApproval | Promise<PermissionApproval>;
+/** Serializes Team child permission prompts while allowing later prompts after failure. */
+export declare class SerializedTeamLeadDecisionSurface implements TeamLeadDecisionSurface {
+    private readonly approve;
+    private tail;
+    constructor(approve: TeamLeadApproveTool);
+    request(input: TeamLeadDecisionRequest): Promise<PermissionApproval>;
+}
+//# sourceMappingURL=team-lead-decision-surface.d.ts.map

package/dist/application/team-lead-decision-surface.js

@@ -0,0 +1,16 @@
+/** Serializes Team child permission prompts while allowing later prompts after failure. */
+export class SerializedTeamLeadDecisionSurface {
+    approve;
+    tail = Promise.resolve();
+    constructor(approve) {
+        this.approve = approve;
+    }
+    request(input) {
+        const run = this.tail
+            .catch(() => undefined)
+            .then(() => this.approve(input.call, input.originalCall, input.decision));
+        this.tail = run.then(() => undefined, () => undefined);
+        return run;
+    }
+}
+//# sourceMappingURL=team-lead-decision-surface.js.map

package/dist/application/team-observability.d.ts

@@ -0,0 +1,113 @@
+import { type TeamMailboxMessage } from '../core/team-mailbox.js';
+import type { TeamSnapshot, TeamTask } from '../core/team-ownership.js';
+export interface TeamDashboard {
+    readonly team: {
+        id: string;
+        name: string;
+        projectIdentity: string;
+        leadPolicy: string;
+        executionPolicy: string;
+        commitPolicy: string;
+        lifecycle: string;
+        revision: number;
+        createdAt: string;
+        updatedAt: string;
+    };
+    readonly agents: readonly {
+        name: string;
+        agentType: string;
+        access: string;
+        lifecycle: string;
+        taskId: string | null;
+        generation: number;
+        usage: {
+            totalTokens: number;
+            durationMs: number;
+        };
+    }[];
+    readonly tasks: readonly {
+        id: string;
+        description: string;
+        assignee: string;
+        blockedBy: readonly string[];
+        state: string;
+        claims: TeamTask['claims'];
+        generation: number;
+        usage: {
+            totalTokens: number;
+            durationMs: number;
+        };
+        acceptance: 'pending' | 'accepted' | 'rejected' | 'not-applicable';
+    }[];
+    readonly worktrees: readonly {
+        taskId: string;
+        path: string | null;
+        branch: string | null;
+        access: string;
+        present: boolean;
+    }[];
+    readonly mailbox: {
+        totalRecords: number;
+        retainedRecords: number;
+        pendingByRecipient: Readonly<Record<string, number>>;
+        highestSequence: number;
+        prunedThrough: number;
+    };
+    readonly budgets: {
+        configured: {
+            maxTokens: number;
+            maxDurationMs: number;
+        };
+        used: {
+            totalTokens: number;
+            durationMs: number;
+        };
+        exhaustedReason: string | null;
+    };
+    readonly health: {
+        status: 'healthy' | 'idle' | 'blocked' | 'degraded' | 'stopping';
+        blockers: readonly string[];
+        activeCount: number;
+    };
+    readonly events: readonly {
+        kind: string;
+        at: string;
+        summary: string;
+        detail?: string;
+    }[];
+}
+export interface TeamObservabilityOptions {
+    readonly mailbox?: TeamMailboxAudit;
+    readonly worktrees?: readonly TeamWorktreeEvidence[];
+    readonly maxEvents?: number;
+}
+export interface TeamMailboxAudit {
+    readonly totalRecords: number;
+    readonly retainedRecords: number;
+    readonly pendingByRecipient: Readonly<Record<string, number>>;
+    readonly highestSequence: number;
+    readonly prunedThrough: number;
+    readonly records: readonly TeamMailboxMessage[];
+}
+export interface TeamWorktreeEvidence {
+    readonly taskId: string;
+    readonly path: string;
+    readonly branch: string | null;
+    readonly access: string;
+    readonly present: boolean;
+}
+export declare function projectTeamDashboard(snapshot: TeamSnapshot, options?: TeamObservabilityOptions): TeamDashboard;
+export declare function renderTeamSummary(dashboard: TeamDashboard): string;
+export declare function renderTeamAudit(dashboard: TeamDashboard): string;
+export declare function readTeamMailboxAudit(input: {
+    nativeRoot: string;
+    snapshot: TeamSnapshot;
+    maxRecords?: number;
+    maxBytes?: number;
+}): Promise<TeamMailboxAudit>;
+export declare function readTeamWorktreeEvidence(input: {
+    nativeRoot: string;
+    snapshot: TeamSnapshot;
+    maxEntries?: number;
+}): Promise<readonly TeamWorktreeEvidence[]>;
+//# sourceMappingURL=team-observability.d.ts.map

package/dist/application/team-observability.js

@@ -0,0 +1,312 @@
+import { readFile, lstat } from 'node:fs/promises';
+import { createReadStream } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { resolve, join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { parseTeamMailboxMessage, } from '../core/team-mailbox.js';
+import { sanitizeProjectPath } from '../platform/project-path-key.js';
+function freeze(value) {
+    return Object.freeze(value);
+}
+function taskState(task) {
+    return (task.execution?.state ?? (task.blockedBy.length ? 'blocked' : 'pending'));
+}
+export function projectTeamDashboard(snapshot, options = {}) {
+    const tasks = snapshot.tasks.map((task) => ({
+        id: task.id,
+        description: task.description,
+        assignee: task.assignee,
+        blockedBy: freeze([...task.blockedBy]),
+        claims: task.claims,
+        state: taskState(task),
+        generation: task.usage.generation,
+        usage: {
+            totalTokens: task.usage.totalTokens,
+            durationMs: task.usage.durationMs,
+        },
+        acceptance: task.execution?.acceptance ?? 'not-applicable',
+    }));
+    const taskByAgent = new Map(tasks.map((task) => [task.assignee, task]));
+    const agents = snapshot.roster.map((member) => {
+        const task = taskByAgent.get(member.name);
+        return {
+            name: member.name,
+            agentType: member.agentType,
+            access: member.access,
+            lifecycle: task?.state ?? 'idle',
+            taskId: task?.id ?? null,
+            generation: task?.generation ?? 0,
+            usage: task?.usage ?? { totalTokens: 0, durationMs: 0 },
+        };
+    });
+    const active = tasks.filter((task) => ['queued', 'running', 'waiting', 'cancelling'].includes(task.state)).length;
+    const blockers = tasks
+        .filter((task) => task.state === 'blocked' || task.state === 'failed')
+        .map((task) => `${task.id}: ${task.state}`);
+    if (snapshot.usage.exhausted)
+        blockers.push(`budget exhausted: ${snapshot.usage.exhausted.reason}`);
+    const lifecycle = snapshot.usage.exhausted
+        ? 'stopping'
+        : active
+            ? 'active'
+            : 'idle';
+    const status = snapshot.usage.exhausted
+        ? 'stopping'
+        : blockers.length
+            ? 'blocked'
+            : active
+                ? 'healthy'
+                : 'idle';
+    const mailboxEvents = (options.mailbox?.records ?? []).map((record) => ({
+        kind: 'mailbox',
+        at: record.createdAt,
+        summary: `${record.sender} -> ${record.recipients.join(',')} ${record.payload.kind}${'phase' in record.payload ? `/${record.payload.phase}` : ''}`,
+    }));
+    const events = (options.maxEvents === undefined ? 32 : options.maxEvents) <= 0
+        ? []
+        : [
+            {
+                kind: 'team',
+                at: snapshot.updatedAt,
+                summary: `${snapshot.name} revision ${snapshot.revision}`,
+            },
+            ...blockers.map((detail) => ({
+                kind: 'blocker',
+                at: snapshot.updatedAt,
+                summary: detail,
+            })),
+            ...mailboxEvents,
+        ].slice(0, options.maxEvents ?? 32);
+    return freeze({
+        team: {
+            id: snapshot.teamId,
+            name: snapshot.name,
+            projectIdentity: snapshot.projectIdentity,
+            leadPolicy: snapshot.policy.lead,
+            executionPolicy: snapshot.policy.execution,
+            commitPolicy: snapshot.policy.commit,
+            lifecycle,
+            revision: snapshot.revision,
+            createdAt: snapshot.createdAt,
+            updatedAt: snapshot.updatedAt,
+        },
+        agents: freeze(agents),
+        tasks: freeze(tasks),
+        worktrees: freeze((options.worktrees ?? []).map((entry) => ({ ...entry }))),
+        mailbox: options.mailbox
+            ? {
+                totalRecords: options.mailbox.totalRecords,
+                retainedRecords: options.mailbox.retainedRecords,
+                pendingByRecipient: options.mailbox.pendingByRecipient,
+                highestSequence: options.mailbox.highestSequence,
+                prunedThrough: options.mailbox.prunedThrough,
+            }
+            : {
+                totalRecords: 0,
+                retainedRecords: 0,
+                pendingByRecipient: {},
+                highestSequence: 0,
+                prunedThrough: 0,
+            },
+        budgets: {
+            configured: {
+                maxTokens: snapshot.budgets.maxTokens,
+                maxDurationMs: snapshot.budgets.maxDurationMs,
+            },
+            used: {
+                totalTokens: snapshot.usage.totalTokens,
+                durationMs: snapshot.usage.durationMs,
+            },
+            exhaustedReason: snapshot.usage.exhausted?.reason ?? null,
+        },
+        health: { status, blockers: freeze(blockers), activeCount: active },
+        events: freeze(events),
+    });
+}
+export function renderTeamSummary(dashboard) {
+    const h = dashboard.health;
+    const base = `${dashboard.team.name} (${dashboard.team.id}): ${h.status}, ${h.activeCount} active, ${dashboard.tasks.length} tasks`;
+    return h.blockers.length
+        ? `${base} — ${h.blockers.slice(0, 3).join('; ')}`
+        : base;
+}
+export function renderTeamAudit(dashboard) {
+    return dashboard.events
+        .map((event) => `${event.at} [${event.kind}] ${event.summary}${event.detail ? ` — ${event.detail}` : ''}`)
+        .join('\n');
+}
+export async function readTeamMailboxAudit(input) {
+    const maxRecords = input.maxRecords ?? 64;
+    const maxBytes = input.maxBytes ?? 256 * 1024;
+    if (!Number.isSafeInteger(maxRecords) || maxRecords <= 0)
+        throw new Error('Invalid Team mailbox maxRecords');
+    if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0)
+        throw new Error('Invalid Team mailbox maxBytes');
+    const mailboxDir = join(resolve(input.nativeRoot), 'state', 'teams', sanitizeProjectPath(input.snapshot.projectIdentity), input.snapshot.teamId, 'mailbox');
+    const messagesPath = join(mailboxDir, 'messages.jsonl');
+    const statePath = join(mailboxDir, 'state.json');
+    try {
+        await lstat(messagesPath);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return {
+                totalRecords: 0,
+                retainedRecords: 0,
+                pendingByRecipient: Object.fromEntries(['lead', ...input.snapshot.roster.map((member) => member.name)].map((member) => [member, 0])),
+                highestSequence: 0,
+                prunedThrough: 0,
+                records: [],
+            };
+        throw error;
+    }
+    let prunedThrough = 0;
+    let cursors = {};
+    try {
+        const state = JSON.parse(await readFile(statePath, 'utf8'));
+        if (state.teamId !== input.snapshot.teamId ||
+            state.projectIdentity !== input.snapshot.projectIdentity ||
+            !Number.isSafeInteger(state.prunedThrough) ||
+            state.prunedThrough < 0 ||
+            typeof state.cursors !== 'object' ||
+            state.cursors === null)
+            throw new Error('Invalid Team mailbox state');
+        prunedThrough = state.prunedThrough;
+        cursors = state.cursors;
+        for (const cursor of Object.values(cursors))
+            if (!Number.isSafeInteger(cursor) || cursor < 0)
+                throw new Error('Invalid Team mailbox cursor');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw new Error(`Corrupt Team mailbox record: ${statePath}`, {
+                cause: error,
+            });
+    }
+    const retainedRows = [];
+    const retainedSizes = [];
+    let retainedBytes = 0;
+    let totalRecords = 0;
+    let highestSequence = 0;
+    let previous = prunedThrough;
+    const pendingByRecipient = {};
+    for (const member of ['lead', ...input.snapshot.roster.map((m) => m.name)])
+        pendingByRecipient[member] = 0;
+    const reader = createInterface({
+        input: createReadStream(messagesPath, { encoding: 'utf8' }),
+        crlfDelay: Infinity,
+    });
+    try {
+        for await (const line of reader) {
+            if (!line)
+                continue;
+            const bytes = Buffer.byteLength(line, 'utf8') + 1;
+            let record;
+            try {
+                record = parseTeamMailboxMessage(JSON.parse(line));
+            }
+            catch (error) {
+                throw new Error(`Corrupt Team mailbox record: ${messagesPath}`, {
+                    cause: error,
+                });
+            }
+            if (record.teamId !== input.snapshot.teamId ||
+                record.sequence <= previous)
+                throw new Error(`Corrupt Team mailbox record: ${messagesPath}`);
+            previous = record.sequence;
+            totalRecords += 1;
+            highestSequence = record.sequence;
+            for (const recipient of record.recipients)
+                if (recipient in pendingByRecipient &&
+                    record.sequence > (cursors[recipient] ?? prunedThrough))
+                    pendingByRecipient[recipient] =
+                        (pendingByRecipient[recipient] ?? 0) + 1;
+            retainedRows.push(record);
+            retainedSizes.push(bytes);
+            retainedBytes += bytes;
+            while (retainedRows.length > maxRecords || retainedBytes > maxBytes) {
+                retainedBytes -= retainedSizes.shift() ?? 0;
+                retainedRows.shift();
+            }
+        }
+    }
+    finally {
+        reader.close();
+    }
+    /*
+     * The stream above deliberately keeps only the bounded tail while still
+     * validating ordering and counting pending messages across the file.
+     */
+    return {
+        totalRecords,
+        retainedRecords: retainedRows.length,
+        pendingByRecipient,
+        highestSequence,
+        prunedThrough,
+        records: freeze(retainedRows),
+    };
+}
+export async function readTeamWorktreeEvidence(input) {
+    const root = join(resolve(input.nativeRoot), 'state', 'team-worktrees', sanitizeProjectPath(input.snapshot.projectIdentity), input.snapshot.teamId);
+    try {
+        const rootStat = await lstat(root);
+        if (rootStat.isSymbolicLink())
+            throw new Error(`Unsafe Team worktree symlink: ${root}`);
+        if (!rootStat.isDirectory())
+            return [];
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+    const result = [];
+    const limit = input.maxEntries ?? 64;
+    if (!Number.isSafeInteger(limit) || limit <= 0)
+        throw new Error('Invalid Team worktree maxEntries');
+    const members = new Map(input.snapshot.roster.map((member) => [member.name, member]));
+    for (const task of input.snapshot.tasks) {
+        if (result.length >= limit)
+            break;
+        if (task.usage.generation <= 0)
+            continue;
+        const member = members.get(task.assignee);
+        if (!member || member.access !== 'write')
+            continue;
+        const hash = createHash('sha256')
+            .update(`${input.snapshot.projectIdentity}\0${input.snapshot.teamId}\0${task.id}\0${task.usage.generation}`)
+            .digest('hex')
+            .slice(0, 24);
+        const path = join(root, hash);
+        let stat;
+        try {
+            stat = await lstat(path);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                continue;
+            throw error;
+        }
+        if (stat.isSymbolicLink())
+            throw new Error(`Unsafe Team worktree symlink: ${path}`);
+        if (!stat.isDirectory())
+            continue;
+        let branch = null;
+        try {
+            branch =
+                (await readFile(join(path, '.praxis-branch'), 'utf8')).trim() || null;
+        }
+        catch {
+            /* optional metadata */
+        }
+        result.push({
+            taskId: task.id,
+            path,
+            branch: branch ?? `praxis/team/${input.snapshot.teamId}/${hash}`,
+            access: 'write',
+            present: true,
+        });
+    }
+    return freeze(result);
+}
+//# sourceMappingURL=team-observability.js.map