@contractspec/lib.execution-lanes 0.1.1

package/dist/runtime/readiness.d.ts

@@ -0,0 +1,16 @@
+import type { ExecutionLaneSpec, LaneKey, LaneRuntimeSnapshot, TerminalReadiness } from '../types';
+export interface LaneReadinessOptions {
+    laneRegistry?: {
+        get(key: LaneKey): ExecutionLaneSpec | undefined;
+    };
+    now?: () => Date;
+}
+export interface LaneReadinessEvaluation {
+    missingArtifacts: string[];
+    missingEvidence: string[];
+    missingApprovals: string[];
+    blockingRisks: string[];
+    missingNextLane: boolean;
+    terminalReadiness: TerminalReadiness;
+}
+export declare function evaluateLaneReadiness(snapshot: LaneRuntimeSnapshot, options?: LaneReadinessOptions): LaneReadinessEvaluation;

package/dist/runtime/role-guard.d.ts

@@ -0,0 +1,12 @@
+import { RoleProfileRegistry } from '../registry/role-profile-registry';
+import type { LaneKey, RoleProfile, RoleToolPermission, RoleWriteScope } from '../types';
+export interface RoleGuardInput {
+    roleKey: string;
+    lane: LaneKey;
+    requiredTools?: RoleToolPermission[];
+    allowedWriteScopes?: RoleWriteScope[];
+}
+export declare function createRoleGuard(registry: RoleProfileRegistry): {
+    get(roleKey: string): RoleProfile;
+    assert(input: RoleGuardInput): RoleProfile;
+};

package/dist/runtime/role-guard.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/selector.d.ts

@@ -0,0 +1,12 @@
+import type { ExecutionPlanPack, LaneKey } from '../types';
+export interface LaneSelectionInput {
+    preferredLane?: LaneKey;
+    hasPlanPack?: boolean;
+    ambiguityScore?: number;
+    parallelizableTaskCount?: number;
+    requiresDurableClosure?: boolean;
+    planPack?: ExecutionPlanPack;
+}
+export declare function createLaneSelector(): {
+    select(input: LaneSelectionInput): LaneKey;
+};

package/dist/runtime/selector.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/state-sync.d.ts

@@ -0,0 +1,5 @@
+import type { ApprovalRecord, CompletionLoopState, TeamRunState } from '../types';
+import type { LaneRuntimeStore } from './store';
+export declare function syncLaneRunFromCompletion(store: LaneRuntimeStore, state: CompletionLoopState, terminalReason?: string): Promise<import("..").LaneRunState | undefined>;
+export declare function syncLaneRunFromTeam(store: LaneRuntimeStore, state: TeamRunState): Promise<import("..").LaneRunState | undefined>;
+export declare function syncLaneApprovalState(store: LaneRuntimeStore, approval: ApprovalRecord): Promise<import("..").LaneRunState | undefined>;

package/dist/runtime/status-views.d.ts

@@ -0,0 +1,5 @@
+import type { CompletionStatusView, LaneRuntimeSnapshot, LaneStatusView, TeamStatusView } from '../types';
+export declare const TEAM_STALE_HEARTBEAT_MS = 90000;
+export declare function buildLaneStatusView(snapshot: LaneRuntimeSnapshot, now?: Date): LaneStatusView;
+export declare function buildCompletionStatusView(snapshot: LaneRuntimeSnapshot, now?: Date): CompletionStatusView | undefined;
+export declare function buildTeamStatusView(snapshot: LaneRuntimeSnapshot, now?: Date): TeamStatusView | undefined;

package/dist/runtime/store.d.ts

@@ -0,0 +1,22 @@
+import type { ApprovalRecord, CompletionLoopState, EvidenceBundleRef, LaneArtifactRecord, LaneEventRecord, LaneRunState, LaneRuntimeSnapshot, LaneTransitionRecord, TeamRunState } from '../types';
+export interface LaneRuntimeStore {
+    createRun(run: LaneRunState): Promise<void>;
+    getRun(runId: string): Promise<LaneRunState | undefined>;
+    updateRun(runId: string, updater: (current: LaneRunState) => LaneRunState): Promise<LaneRunState>;
+    listRuns(): Promise<LaneRunState[]>;
+    saveArtifact(artifact: LaneArtifactRecord): Promise<void>;
+    listArtifacts(runId: string): Promise<LaneArtifactRecord[]>;
+    appendEvent(event: LaneEventRecord): Promise<void>;
+    listEvents(runId: string): Promise<LaneEventRecord[]>;
+    saveTransition(transition: LaneTransitionRecord): Promise<void>;
+    listTransitions(runId: string): Promise<LaneTransitionRecord[]>;
+    saveEvidence(bundle: EvidenceBundleRef): Promise<void>;
+    listEvidence(runId: string): Promise<EvidenceBundleRef[]>;
+    saveApproval(approval: ApprovalRecord): Promise<void>;
+    listApprovals(runId: string): Promise<ApprovalRecord[]>;
+    saveCompletion(state: CompletionLoopState): Promise<void>;
+    getCompletion(runId: string): Promise<CompletionLoopState | undefined>;
+    saveTeam(state: TeamRunState): Promise<void>;
+    getTeam(runId: string): Promise<TeamRunState | undefined>;
+    getSnapshot(runId: string): Promise<LaneRuntimeSnapshot | undefined>;
+}

package/dist/types/completion.d.ts

@@ -0,0 +1,60 @@
+import type { EvidenceGateResult, VerificationPolicy, VerificationPolicySource } from './evidence';
+import type { ExecutionLaneFailureClass, ExecutionLaneFailureClassInput } from './failures';
+export type CompletionLoopPhase = 'initialized' | 'working' | 'waiting_for_evidence' | 'remediating' | 'awaiting_signoff' | 'completed' | 'blocked' | 'failed' | 'aborted';
+export type CompletionFailureClass = ExecutionLaneFailureClass;
+export type CompletionFailureClassInput = ExecutionLaneFailureClassInput;
+export interface CompletionLoopSpec {
+    id: string;
+    ownerRole: string;
+    sourcePlanPackId?: string;
+    snapshotRef: string;
+    iterationLimit?: number;
+    delegateRoles: string[];
+    progressLedgerRef: string;
+    verificationPolicy: VerificationPolicySource;
+    signoff: {
+        verifierRole: string;
+        requireArchitectReview: boolean;
+        requireHumanApproval?: boolean;
+    };
+    terminalConditions: Array<'done' | 'blocked' | 'failed' | 'aborted'>;
+}
+export interface CompletionLedgerEntry {
+    id: string;
+    iteration: number;
+    createdAt: string;
+    message: string;
+    classification?: CompletionFailureClass;
+    metadata?: Record<string, unknown>;
+}
+export interface CompletionLoopState {
+    runId: string;
+    spec: Omit<CompletionLoopSpec, 'verificationPolicy'> & {
+        verificationPolicy: VerificationPolicy;
+    };
+    phase: CompletionLoopPhase;
+    iteration: number;
+    retryCount: number;
+    progressLedger: CompletionLedgerEntry[];
+    evidenceBundleIds: string[];
+    pendingApprovalRoles: string[];
+    contextSnapshotArtifactId?: string;
+    progressLedgerArtifactId?: string;
+    loopStateArtifactId?: string;
+    signoffArtifactId?: string;
+    terminalRecordArtifactId?: string;
+    lastGateResult?: EvidenceGateResult;
+    lastFailureClass?: CompletionFailureClass;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CompletionRecord {
+    runId: string;
+    status: Extract<CompletionLoopPhase, 'completed' | 'blocked' | 'failed' | 'aborted'>;
+    completedAt: string;
+    iterationCount: number;
+    evidenceBundleIds: string[];
+    approvalIds: string[];
+    unresolvedRisks: string[];
+    terminalReason?: string;
+}

package/dist/types/core.d.ts

@@ -0,0 +1,19 @@
+export type LaneKey = 'clarify' | 'plan.consensus' | 'complete.persistent' | 'team.coordinated';
+export type ExecutionScopeClass = 'small' | 'medium' | 'large' | 'high-risk';
+export type LaneParallelism = 'none' | 'bounded' | 'durable';
+export type LanePersistence = 'ephemeral' | 'checkpointed' | 'durable';
+export type LaneRunStatus = 'initialized' | 'running' | 'waiting' | 'paused' | 'completed' | 'blocked' | 'failed' | 'aborted' | 'superseded';
+export type LaneTerminalStatus = Extract<LaneRunStatus, 'completed' | 'blocked' | 'failed' | 'aborted' | 'superseded'>;
+export type ApprovalVerdict = 'approve' | 'acknowledge';
+export interface AuthorityContextRefs {
+    policyRefs: string[];
+    ruleContextRefs: string[];
+    approvalRefs?: string[];
+}
+export interface RuntimeContextRefs {
+    sessionId?: string;
+    traceId?: string;
+    workflowId?: string;
+    checkpointId?: string;
+    snapshotRef?: string;
+}

package/dist/types/evidence.d.ts

@@ -0,0 +1,64 @@
+import type { ApprovalVerdict } from './core';
+import type { ExecutionLaneArtifactIdentifier, ExecutionLaneEvidenceIdentifier } from './identifiers';
+export interface EvidenceBundleRef {
+    id: string;
+    runId: string;
+    artifactIds: string[];
+    classes: ExecutionLaneEvidenceIdentifier[];
+    createdAt: string;
+    freshUntil?: string;
+    replayBundleUri?: string;
+    summary?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ApprovalRequirement {
+    role: string;
+    verdict: ApprovalVerdict;
+}
+export interface VerificationPolicy {
+    key: string;
+    requiredEvidence: ExecutionLaneEvidenceIdentifier[];
+    minimumApprovals: ApprovalRequirement[];
+    failOnMissingEvidence: boolean;
+    allowConditionalCompletion: boolean;
+    maxEvidenceAgeMinutes?: number;
+}
+export type VerificationPolicySource = string | VerificationPolicy;
+export type ApprovalState = 'requested' | 'approved' | 'rejected' | 'expired' | 'superseded';
+export type TerminalReadiness = 'ready' | 'missing_artifact' | 'missing_evidence' | 'missing_approval' | 'stale_evidence' | 'blocked' | 'cleanup_pending' | 'not_ready';
+export interface ApprovalRecord {
+    id: string;
+    runId: string;
+    role: string;
+    verdict: ApprovalVerdict;
+    state: ApprovalState;
+    comment?: string;
+    requestedAt: string;
+    decidedAt?: string;
+    decidedBy?: string;
+}
+export interface LaneArtifactRecord {
+    id: string;
+    runId: string;
+    artifactType: ExecutionLaneArtifactIdentifier;
+    createdAt: string;
+    body: unknown;
+    summary?: string;
+}
+export interface LaneEventRecord {
+    id: string;
+    runId: string;
+    type: string;
+    createdAt: string;
+    phase?: string;
+    message?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface EvidenceGateResult {
+    passed: boolean;
+    conditionallyPassed?: boolean;
+    missingEvidence: string[];
+    missingApprovals: string[];
+    staleEvidence: string[];
+    blockingRisks: string[];
+}

package/dist/types/failures.d.ts

@@ -0,0 +1,8 @@
+export declare const EXECUTION_LANE_FAILURE_CLASSES: readonly ["missing_evidence", "failing_evidence", "policy_blocked", "approval_denied", "runtime_failure", "worker_timeout", "lease_conflict"];
+export type ExecutionLaneFailureClass = (typeof EXECUTION_LANE_FAILURE_CLASSES)[number];
+export type LegacyExecutionLaneFailureAlias = 'retryable' | 'blocked' | 'fatal';
+export type ExecutionLaneFailureClassInput = ExecutionLaneFailureClass | LegacyExecutionLaneFailureAlias;
+export declare function normalizeExecutionLaneFailureClass(value: ExecutionLaneFailureClassInput): ExecutionLaneFailureClass;
+export declare function isExecutionLaneFailureClass(value: string): value is ExecutionLaneFailureClass;
+export declare function isRetryableExecutionLaneFailureClass(value: ExecutionLaneFailureClassInput): boolean;
+export declare function isBlockingExecutionLaneFailureClass(value: ExecutionLaneFailureClassInput): boolean;

package/dist/types/failures.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/identifiers.d.ts

@@ -0,0 +1,12 @@
+export declare const EXECUTION_LANE_ARTIFACT_TYPES: readonly ["architect_review", "clarification_artifact", "completion_record", "context_snapshot", "critique_verdict", "evidence_bundle_ref", "evidence_gate_result", "loop_state", "operator_action", "plan_pack", "planner_draft", "planner_revision", "progress_ledger", "signoff_record", "signoff_request", "team_cleanup_state", "team_snapshot", "terminal_state", "tradeoff_record", "verification_lane_evidence"];
+export type ExecutionLaneArtifactType = (typeof EXECUTION_LANE_ARTIFACT_TYPES)[number];
+export type ExecutionLaneArtifactIdentifier = ExecutionLaneArtifactType | (string & {});
+export declare const EXECUTION_LANE_EVIDENCE_CLASSES: readonly ["architect_review", "clarification_artifact", "completion_record", "critique_verdict", "plan_pack", "progress_ledger", "signoff_record", "team_snapshot", "tradeoff_record", "verification_lane_evidence", "verification_results"];
+export type ExecutionLaneEvidenceClass = (typeof EXECUTION_LANE_EVIDENCE_CLASSES)[number];
+export type ExecutionLaneEvidenceIdentifier = ExecutionLaneEvidenceClass | (string & {});
+export declare function normalizeExecutionLaneArtifactType(value: string): ExecutionLaneArtifactIdentifier;
+export declare function normalizeExecutionLaneEvidenceClass(value: string): ExecutionLaneEvidenceIdentifier;
+export declare function normalizeExecutionLaneArtifactTypes(values: readonly string[]): ExecutionLaneArtifactIdentifier[];
+export declare function normalizeExecutionLaneEvidenceClasses(values: readonly string[]): ExecutionLaneEvidenceIdentifier[];
+export declare function isExecutionLaneArtifactType(value: string): value is ExecutionLaneArtifactType;
+export declare function isExecutionLaneEvidenceClass(value: string): value is ExecutionLaneEvidenceClass;

package/dist/types/index.d.ts

@@ -0,0 +1,10 @@
+export * from './completion';
+export * from './core';
+export * from './evidence';
+export * from './failures';
+export * from './identifiers';
+export * from './lanes';
+export * from './plan';
+export * from './roles';
+export * from './runtime';
+export * from './team';

package/dist/types/index.js

@@ -0,0 +1,2 @@
+// @bun
+var n=["missing_evidence","failing_evidence","policy_blocked","approval_denied","runtime_failure","worker_timeout","lease_conflict"],i={retryable:"runtime_failure",blocked:"policy_blocked",fatal:"runtime_failure"};function r(e){return a(e)?e:i[e]}function a(e){return n.includes(e)}function g(e){switch(r(e)){case"missing_evidence":case"failing_evidence":case"runtime_failure":case"worker_timeout":case"lease_conflict":return!0;default:return!1}}function m(e){switch(r(e)){case"policy_blocked":case"approval_denied":return!0;default:return!1}}var o=["architect_review","clarification_artifact","completion_record","context_snapshot","critique_verdict","evidence_bundle_ref","evidence_gate_result","loop_state","operator_action","plan_pack","planner_draft","planner_revision","progress_ledger","signoff_record","signoff_request","team_cleanup_state","team_snapshot","terminal_state","tradeoff_record","verification_lane_evidence"],s=["architect_review","clarification_artifact","completion_record","critique_verdict","plan_pack","progress_ledger","signoff_record","team_snapshot","tradeoff_record","verification_lane_evidence","verification_results"],c={"architect-review":"architect_review","clarification-artifact":"clarification_artifact","completion-record":"completion_record","context-snapshot":"context_snapshot","critic-review":"critique_verdict","evidence-bundle-ref":"evidence_bundle_ref","evidence-gate-result":"evidence_gate_result","execution-plan-pack":"plan_pack","loop-state":"loop_state","operator-action":"operator_action","plan-pack":"plan_pack","planner-draft":"planner_draft","planner-revision":"planner_revision","progress-ledger":"progress_ledger","review-record":"architect_review","signoff-record":"signoff_record","signoff-request":"signoff_request","team-cleanup-state":"team_cleanup_state","team-completion-snapshot":"team_snapshot","team-snapshot":"team_snapshot","terminal-record":"completion_record","terminal-state":"terminal_state","tradeoff-record":"tradeoff_record","verification-lane-evidence":"verification_lane_evidence"},d={"architect-review":"architect_review","clarification-artifact":"clarification_artifact","completion-record":"completion_record","critic-review":"critique_verdict","execution-plan-pack":"plan_pack","plan-pack":"plan_pack","progress-ledger":"progress_ledger","signoff-record":"signoff_record","team-completion-snapshot":"team_snapshot","team-snapshot":"team_snapshot","terminal-record":"completion_record","tradeoff-record":"tradeoff_record","verification-lane-evidence":"verification_lane_evidence","verification-results":"verification_results"};function p(e){return c[e]??e}function l(e){return d[e]??e}function f(e){return e.map((t)=>p(t))}function R(e){return e.map((t)=>l(t))}function x(e){return o.includes(e)}function y(e){return s.includes(e)}export{r as normalizeExecutionLaneFailureClass,R as normalizeExecutionLaneEvidenceClasses,l as normalizeExecutionLaneEvidenceClass,f as normalizeExecutionLaneArtifactTypes,p as normalizeExecutionLaneArtifactType,g as isRetryableExecutionLaneFailureClass,a as isExecutionLaneFailureClass,y as isExecutionLaneEvidenceClass,x as isExecutionLaneArtifactType,m as isBlockingExecutionLaneFailureClass,n as EXECUTION_LANE_FAILURE_CLASSES,s as EXECUTION_LANE_EVIDENCE_CLASSES,o as EXECUTION_LANE_ARTIFACT_TYPES};

package/dist/types/lanes.d.ts

@@ -0,0 +1,65 @@
+import type { AuthorityContextRefs, ExecutionScopeClass, LaneKey, LaneParallelism, LanePersistence, LaneRunStatus, RuntimeContextRefs } from './core';
+import type { VerificationPolicySource } from './evidence';
+import type { ExecutionLaneArtifactIdentifier } from './identifiers';
+export interface ExecutionLaneSpec {
+    key: LaneKey;
+    description: string;
+    entryCriteria: string[];
+    exitCriteria: string[];
+    allowedTransitions: LaneKey[];
+    compatibleRoles: string[];
+    requiredArtifacts: ExecutionLaneArtifactIdentifier[];
+    verificationPolicy: VerificationPolicySource;
+    capabilities: {
+        parallelism: LaneParallelism;
+        persistence: LanePersistence;
+        approvals: boolean;
+        mailbox: boolean;
+        taskLeasing: boolean;
+    };
+}
+export interface ClarificationArtifact {
+    meta: {
+        id: string;
+        createdAt: string;
+        sourceRequest: string;
+        scopeClass: ExecutionScopeClass;
+        ambiguityScore: number;
+        recommendedNextLane: LaneKey;
+    };
+    objective: string;
+    constraints: string[];
+    assumptions: string[];
+    openQuestions: string[];
+    conflictSignals: string[];
+    authorityContext: AuthorityContextRefs;
+}
+export interface LaneTransitionRecord {
+    id: string;
+    runId: string;
+    from?: LaneKey;
+    to: LaneKey;
+    reason: string;
+    createdAt: string;
+    actorId?: string;
+}
+export interface LaneRunState {
+    runId: string;
+    lane: LaneKey;
+    objective: string;
+    sourceRequest: string;
+    scopeClass: ExecutionScopeClass;
+    status: LaneRunStatus;
+    currentPhase: string;
+    ownerRole: string;
+    authorityContext: AuthorityContextRefs;
+    verificationPolicyKey: string;
+    blockingRisks: string[];
+    pendingApprovalRoles: string[];
+    evidenceBundleIds: string[];
+    runtimeContext?: RuntimeContextRefs;
+    createdAt: string;
+    updatedAt: string;
+    terminalReason?: string;
+    recommendedNextLane?: LaneKey;
+}

package/dist/types/plan.d.ts

@@ -0,0 +1,46 @@
+import type { AuthorityContextRefs, ExecutionScopeClass, LaneKey } from './core';
+export interface ExecutionPlanTradeoff {
+    topic: string;
+    tension: string;
+    chosenDirection: string;
+    rejectedAlternatives: string[];
+}
+export interface ExecutionPlanStep {
+    id: string;
+    title: string;
+    description: string;
+    acceptanceCriteria: string[];
+    dependencies?: string[];
+    roleHints?: string[];
+}
+export interface ExecutionPlanPack {
+    meta: {
+        id: string;
+        createdAt: string;
+        sourceRequest: string;
+        scopeClass: ExecutionScopeClass;
+    };
+    objective: string;
+    constraints: string[];
+    assumptions: string[];
+    nonGoals: string[];
+    tradeoffs: ExecutionPlanTradeoff[];
+    staffing: {
+        availableRoleProfiles: string[];
+        recommendedLanes: Array<{
+            lane: LaneKey;
+            why: string;
+        }>;
+        handoffRecommendation: {
+            nextLane: LaneKey;
+            launchHints: string[];
+        };
+    };
+    planSteps: ExecutionPlanStep[];
+    verification: {
+        requiredEvidence: string[];
+        requiredApprovals: string[];
+        blockingRisks: string[];
+    };
+    authorityContext: AuthorityContextRefs;
+}

package/dist/types/roles.d.ts

@@ -0,0 +1,24 @@
+import type { LaneKey } from './core';
+import type { ExecutionLaneEvidenceIdentifier } from './identifiers';
+export type RoleRoutingRole = 'leader' | 'specialist' | 'executor' | 'reviewer';
+export type RolePosture = 'orchestrator' | 'critic' | 'builder' | 'verifier' | 'researcher';
+export type RoleToolPermission = 'read' | 'analyze' | 'execute' | 'network' | 'review';
+export type RoleWriteScope = 'none' | 'artifacts-only' | 'workspace' | 'scoped-worktree';
+export interface RoleProfile {
+    key: string;
+    description: string;
+    routingRole: RoleRoutingRole;
+    posture: RolePosture;
+    allowedTools: RoleToolPermission[];
+    writeScope: RoleWriteScope;
+    laneCompatibility: LaneKey[];
+    evidenceObligations: ExecutionLaneEvidenceIdentifier[];
+    escalationTriggers: string[];
+    modelProfileHint?: string;
+}
+export interface StaffingRecommendation {
+    lane: LaneKey;
+    roleKeys: string[];
+    launchHints: string[];
+    why: string;
+}

package/dist/types/runtime.d.ts

@@ -0,0 +1,123 @@
+import type { CompletionLoopState } from './completion';
+import type { LaneKey, LaneRunStatus } from './core';
+import type { ApprovalRecord, EvidenceBundleRef, LaneArtifactRecord, LaneEventRecord, TerminalReadiness } from './evidence';
+import type { LaneRunState, LaneTransitionRecord } from './lanes';
+import type { TeamCleanupStatus, TeamHeartbeatRecord, TeamLeaseRecord, TeamMailboxMessage, TeamRunState, TeamTaskRecord, TeamWorkerState } from './team';
+export interface LaneRuntimeSnapshot {
+    run: LaneRunState;
+    events: LaneEventRecord[];
+    transitions: LaneTransitionRecord[];
+    artifacts: LaneArtifactRecord[];
+    evidence: EvidenceBundleRef[];
+    approvals: ApprovalRecord[];
+    completion?: CompletionLoopState;
+    team?: TeamRunState;
+}
+export interface LanePersistenceBundle {
+    exportedAt: string;
+    run: LaneRunState;
+    state: {
+        completion?: CompletionLoopState;
+        team?: TeamRunState;
+    };
+    events: LaneEventRecord[];
+    transitions: LaneTransitionRecord[];
+    artifacts: LaneArtifactRecord[];
+    evidence: EvidenceBundleRef[];
+    approvals: ApprovalRecord[];
+}
+export interface TeamPersistenceStateSlice {
+    runId: TeamRunState['runId'];
+    spec: TeamRunState['spec'];
+    status: TeamRunState['status'];
+    cleanup: TeamRunState['cleanup'];
+    evidenceBundleIds: TeamRunState['evidenceBundleIds'];
+    createdAt: TeamRunState['createdAt'];
+    updatedAt: TeamRunState['updatedAt'];
+    terminalReason?: TeamRunState['terminalReason'];
+    terminalStateArtifactId?: TeamRunState['terminalStateArtifactId'];
+}
+export interface LanePersistenceStateFile {
+    completion?: CompletionLoopState;
+    team?: TeamPersistenceStateSlice;
+}
+export interface TeamTaskLeaseFileRecord {
+    taskId: TeamTaskRecord['taskId'];
+    lease: TeamLeaseRecord;
+}
+export type TeamTaskFileRecord = Omit<TeamTaskRecord, 'lease'>;
+export interface LanePersistenceFiles {
+    'laneRun.json': string;
+    'state.json': string;
+    'events.ndjson': string;
+    'artifacts.json': string;
+    'evidence.json': string;
+    'approvals.json': string;
+    'transitions.json': string;
+    'workers.json'?: string;
+    'tasks.json'?: string;
+    'leases.json'?: string;
+    'mailbox.ndjson'?: string;
+    'heartbeats.ndjson'?: string;
+    'terminal-state.json'?: string;
+}
+export interface LanePersistenceHydrationPayload {
+    run: LaneRunState;
+    state: LanePersistenceStateFile;
+    events: LaneEventRecord[];
+    transitions: LaneTransitionRecord[];
+    artifacts: LaneArtifactRecord[];
+    evidence: EvidenceBundleRef[];
+    approvals: ApprovalRecord[];
+    workers: TeamWorkerState[];
+    tasks: TeamTaskFileRecord[];
+    leases: TeamTaskLeaseFileRecord[];
+    mailbox: TeamMailboxMessage[];
+    heartbeats: TeamHeartbeatRecord[];
+    terminalState: unknown;
+}
+export interface LaneStatusView {
+    runId: string;
+    lane: LaneKey;
+    objective: string;
+    status: LaneRunStatus;
+    currentPhase: string;
+    ownerRole: string;
+    evidenceCompleteness: number;
+    missingArtifacts: string[];
+    pendingApprovals: string[];
+    missingEvidence: string[];
+    missingApprovals: string[];
+    blockingRisks: string[];
+    terminalReadiness: TerminalReadiness;
+    recommendedNextLane?: LaneKey;
+    updatedAt: string;
+}
+export interface TeamStatusView {
+    runId: string;
+    status: TeamRunState['status'];
+    totalTasks: number;
+    completedTasks: number;
+    activeWorkers: number;
+    staleWorkers: number;
+    staleLeaseCount: number;
+    staleWorkerIds: string[];
+    pendingEvidence: number;
+    queueSkew: number;
+    verificationReady: boolean;
+    cleanupStatus: TeamCleanupStatus;
+    updatedAt: string;
+}
+export interface CompletionStatusView {
+    runId: string;
+    phase: CompletionLoopState['phase'];
+    iteration: number;
+    retryCount: number;
+    snapshotRef: string;
+    pendingApprovals: string[];
+    evidenceBundles: number;
+    lastFailureClass?: CompletionLoopState['lastFailureClass'];
+    missingEvidence: string[];
+    terminalReadiness: TerminalReadiness;
+    updatedAt: string;
+}