@openrig/cli 0.5.0 → 0.5.2

package/node_modules/@openrig/daemon/dist/domain/types.d.ts

@@ -0,0 +1,1595 @@
+export interface Rig {
+    id: string;
+    name: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface Pod {
+    id: string;
+    rigId: string;
+    namespace: string;
+    label: string;
+    summary: string | null;
+    continuityPolicyJson: string | null;
+    createdAt: string;
+}
+export interface ContinuityState {
+    podId: string;
+    nodeId: string;
+    status: "healthy" | "degraded" | "restoring";
+    artifactsJson: string | null;
+    lastSyncAt: string | null;
+    updatedAt: string;
+}
+export interface Node {
+    id: string;
+    rigId: string;
+    logicalId: string;
+    role: string | null;
+    runtime: string | null;
+    model: string | null;
+    codexConfigProfile?: string | null;
+    /** OPR.0.4.8.3 Seam B: attached permission_policy REF (builtin:<name> or spec-relative custom
+     *  path), or null when none is attached (= the floor). */
+    permissionPolicy?: string | null;
+    cwd: string | null;
+    surfaceHint: string | null;
+    workspace: string | null;
+    restorePolicy: string | null;
+    packageRefs: string[];
+    podId: string | null;
+    agentRef: string | null;
+    profile: string | null;
+    label: string | null;
+    resolvedSpecName: string | null;
+    resolvedSpecVersion: string | null;
+    resolvedSpecHash: string | null;
+    occupantLifecycle: OccupantLifecycle | null;
+    continuityOutcome: ContinuityOutcome | null;
+    handoverResult: HandoverResult;
+    previousOccupant: string | null;
+    handoverAt: string | null;
+    createdAt: string;
+}
+export interface Edge {
+    id: string;
+    rigId: string;
+    sourceId: string;
+    targetId: string;
+    kind: string;
+    createdAt: string;
+}
+export interface Binding {
+    id: string;
+    nodeId: string;
+    attachmentType?: "tmux" | "external_cli";
+    tmuxSession: string | null;
+    tmuxWindow: string | null;
+    tmuxPane: string | null;
+    externalSessionName?: string | null;
+    cmuxWorkspace: string | null;
+    cmuxSurface: string | null;
+    updatedAt: string;
+}
+export interface Session {
+    id: string;
+    nodeId: string;
+    sessionName: string;
+    status: string;
+    resumeType: string | null;
+    resumeToken: string | null;
+    resumeProvenance?: string | null;
+    resumeLastVerified?: string | null;
+    resumeLastProbeStatus?: string | null;
+    restorePolicy: string;
+    lastSeenAt: string | null;
+    createdAt: string;
+    origin: "launched" | "claimed";
+    startupStatus: "pending" | "ready" | "attention_required" | "failed";
+    startupCompletedAt: string | null;
+}
+export type RigEvent = {
+    type: "event.delivery_poisoned";
+    poisonedSeq: number;
+    error: string;
+    payloadSha: string;
+} | {
+    type: "rig.created";
+    rigId: string;
+} | {
+    type: "seat.model_divergence";
+    rigId: string;
+    nodeId: string;
+    sessionName: string;
+    runtime: string | null;
+    pinnedModel: string;
+    effectiveModel: string;
+    diagnosis: string | null;
+    channels: Array<{
+        channel: string;
+        target: string | null;
+        status: string;
+        detail?: string;
+    }>;
+} | {
+    type: "rig.deleted";
+    rigId: string;
+} | {
+    type: "node.added";
+    rigId: string;
+    nodeId: string;
+    logicalId: string;
+} | {
+    type: "node.removed";
+    rigId: string;
+    nodeId: string;
+} | {
+    type: "binding.updated";
+    rigId: string;
+    nodeId: string;
+} | {
+    type: "session.status_changed";
+    rigId: string;
+    nodeId: string;
+    status: string;
+} | {
+    type: "session.detached";
+    rigId: string;
+    nodeId: string;
+    sessionName: string;
+} | {
+    type: "node.launched";
+    rigId: string;
+    nodeId: string;
+    logicalId: string;
+    sessionName: string;
+} | {
+    type: "snapshot.created";
+    rigId: string;
+    snapshotId: string;
+    kind: string;
+} | {
+    type: "restore.started";
+    rigId: string;
+    snapshotId: string;
+} | {
+    type: "restore.completed";
+    rigId: string;
+    snapshotId: string;
+    result: RestoreResult;
+} | {
+    type: "restore.subset_completed";
+    rigId: string;
+    snapshotId: string;
+    result: RestoreResult;
+} | {
+    type: "node.held";
+    rigId: string;
+    nodeId: string;
+    logicalId: string;
+    reason: string;
+} | {
+    type: "restore.outcome_reconciled";
+    rigId: string;
+    nodeId: string;
+    attemptId: number;
+    from: "failed" | "attention_required";
+    to: "operator_recovered";
+    evidence: {
+        tmux: boolean;
+        fgProcess: "claude" | "codex" | string;
+        resumeTokenUsed: boolean;
+        paneState: "usable";
+    } | {
+        source: string;
+        reason?: string;
+        kind?: string;
+        state?: string;
+        runtimeCwdVerified?: boolean;
+    };
+} | {
+    type: "agent.activity";
+    rigId: string;
+    nodeId: string;
+    sessionName: string;
+    runtime: string | null;
+    activity: AgentActivity;
+} | {
+    type: "transport.prompt_override";
+    rigId: string;
+    nodeId: string;
+    sessionName: string;
+    actorSession: string | null;
+    detectedState: string;
+    detectedReason: string;
+    evidenceSource: string;
+    overrideReason: string | null;
+} | {
+    type: "agent.session_identity";
+    rigId: string;
+    nodeId: string;
+    sessionName: string;
+    runtime: string;
+    sessionId: string;
+    provenance: "hook" | "scrape" | "rpc";
+} | {
+    type: "session.resume_token_set";
+    rigId: string;
+    nodeId: string;
+    sessionName: string;
+    sessionId: string;
+    resumeType: string;
+    previousProvenance: "hook" | "scrape" | "operator" | null;
+    newProvenance: "operator" | "scrape";
+    source: "operator_set" | "reconcile_capture";
+    reason?: string;
+    operator?: string;
+    redacted: true;
+} | {
+    type: "session.resume_token_captured";
+    rigId: string;
+    nodeId: string;
+    sessionName: string;
+    sessionId: string;
+    runtime: string;
+    outcome: "captured" | "preserved" | "skipped";
+    resumeType?: string;
+    provenance?: "adoption";
+    reason?: "missing_sidecar" | "parse_error" | "probe_timeout" | "invalid_token" | "higher_rank_present";
+    redacted: true;
+} | {
+    type: "seat.attention_cleared";
+    rigId: string;
+    nodeId: string;
+    sessionName: string;
+    from: string;
+    to: "ready";
+    clearedBy: "evidence" | "operator_attestation";
+    evidence?: {
+        kind: string;
+        state?: string;
+        reason?: string;
+    };
+    reason?: string;
+    previousError: string | null;
+} | {
+    type: "rig.imported";
+    rigId: string;
+    specName: string;
+    specVersion: string;
+} | {
+    type: "package.validated";
+    packageName: string;
+    valid: boolean;
+} | {
+    type: "package.planned";
+    packageName: string;
+    actionable: number;
+    deferred: number;
+    conflicts: number;
+} | {
+    type: "package.installed";
+    packageName: string;
+    packageVersion: string;
+    installId: string;
+    applied: number;
+    deferred: number;
+} | {
+    type: "package.rolledback";
+    installId: string;
+    restored: number;
+} | {
+    type: "package.install_failed";
+    packageName: string;
+    code: string;
+    message: string;
+} | {
+    type: "bootstrap.planned";
+    runId: string;
+    sourceRef: string;
+    stages: number;
+} | {
+    type: "bootstrap.started";
+    runId: string;
+    sourceRef: string;
+} | {
+    type: "bootstrap.completed";
+    runId: string;
+    rigId: string;
+    sourceRef: string;
+} | {
+    type: "bootstrap.partial";
+    runId: string;
+    sourceRef: string;
+    rigId?: string;
+    completed: number;
+    failed: number;
+} | {
+    type: "bootstrap.failed";
+    runId: string;
+    sourceRef: string;
+    error: string;
+} | {
+    type: "session.discovered";
+    discoveredId: string;
+    tmuxSession: string;
+    tmuxPane: string;
+    runtimeHint: string;
+    confidence: string;
+} | {
+    type: "session.vanished";
+    tmuxSession: string;
+    tmuxPane: string;
+} | {
+    type: "node.claimed";
+    rigId: string;
+    nodeId: string;
+    logicalId: string;
+    discoveredId: string;
+} | {
+    type: "node.reconciled";
+    rigId: string;
+    nodeId: string;
+    logicalId: string;
+    sessionName: string;
+} | {
+    type: "seat.handover_completed";
+    rigId: string;
+    nodeId: string;
+    logicalId: string;
+    previousOccupant: string;
+    currentOccupant: string;
+    source: string;
+    reason: string;
+    operator: string | null;
+} | {
+    type: "bundle.created";
+    bundleName: string;
+    bundleVersion: string;
+    archiveHash: string;
+} | {
+    type: "rig.stopped";
+    rigId: string;
+} | {
+    type: "rig.archived";
+    rigId: string;
+} | {
+    type: "rig.unarchived";
+    rigId: string;
+} | {
+    type: "pod.created";
+    rigId: string;
+    podId: string;
+    namespace: string;
+    label: string;
+} | {
+    type: "pod.deleted";
+    rigId: string;
+    podId: string;
+} | {
+    type: "node.startup_pending";
+    rigId: string;
+    nodeId: string;
+} | {
+    type: "node.startup_ready";
+    rigId: string;
+    nodeId: string;
+} | {
+    type: "node.startup_failed";
+    rigId: string;
+    nodeId: string;
+    error: string;
+} | {
+    type: "node.startup_challenged";
+    rigId: string;
+    nodeId: string;
+    challengeId: string;
+    contractHash: string;
+} | {
+    type: "node.startup_proof_verified";
+    rigId: string;
+    nodeId: string;
+    sessionId: string;
+    challengeId: string;
+    contractHash: string;
+} | {
+    type: "node.startup_proof_rejected";
+    rigId: string;
+    nodeId: string;
+    challengeId: string | null;
+    reason: "identity_unbound" | "identity_mismatch" | "challenge_stale" | "contract_mismatch" | "bare_ack";
+} | {
+    type: "continuity.sync";
+    rigId: string;
+    podId: string;
+    nodeId: string;
+} | {
+    type: "continuity.degraded";
+    rigId: string;
+    podId: string;
+    nodeId: string;
+    reason: string;
+} | {
+    type: "kernel.agent.degraded";
+    agents: Array<{
+        sessionName: string;
+        runtime: string;
+        startupStatus: string;
+    }>;
+    firstUnreadySince: string | null;
+    detail: string | null;
+} | {
+    type: "chat.message";
+    rigId: string;
+    messageId: string;
+    sender: string;
+    kind: string;
+    body: string;
+    topic?: string;
+} | {
+    type: "rig.expanded";
+    rigId: string;
+    podId: string;
+    podNamespace: string;
+    nodes: Array<{
+        logicalId: string;
+        status: string;
+    }>;
+    status: string;
+} | {
+    type: "stream.emitted";
+    streamItemId: string;
+    sourceSession: string;
+    hintDestination: string | null;
+    hintType: string | null;
+    hintUrgency: string | null;
+    interrupt: boolean;
+} | {
+    type: "queue.created";
+    qitemId: string;
+    sourceSession: string;
+    destinationSession: string;
+    priority: string;
+    tier: string | null;
+    summary: string | null;
+} | {
+    type: "queue.handed_off";
+    qitemId: string;
+    fromSession: string;
+    toSession: string;
+    closureReason: "handed_off_to";
+    summary: string | null;
+} | {
+    type: "queue.claimed";
+    qitemId: string;
+    destinationSession: string;
+    claimedAt: string;
+    closureRequiredAt: string | null;
+    summary: string | null;
+} | {
+    type: "queue.unclaimed";
+    qitemId: string;
+    destinationSession: string;
+    reason: string;
+    summary: string | null;
+} | {
+    type: "qitem.fallback_routed";
+    qitemId: string;
+    originalDestination: string;
+    rerouteDestination: string;
+    reason: string;
+} | {
+    type: "qitem.closure_overdue";
+    qitemId: string;
+    destinationSession: string;
+    closureRequiredAt: string;
+    overdueSince: string;
+} | {
+    type: "inbox.absorbed";
+    inboxId: string;
+    destinationSession: string;
+    senderSession: string;
+    promotedQitemId: string;
+} | {
+    type: "inbox.denied";
+    inboxId: string;
+    destinationSession: string;
+    senderSession: string;
+    reason: string;
+} | {
+    type: "queue.updated";
+    qitemId: string;
+    fromState: string;
+    toState: string;
+    closureReason: string | null;
+    closureTarget: string | null;
+    actorSession: string;
+    summary: string | null;
+} | {
+    type: "project.classified";
+    projectId: string;
+    streamItemId: string;
+    classifierSession: string;
+    classificationType: string | null;
+    classificationDestination: string | null;
+} | {
+    type: "classifier.lease_acquired";
+    leaseId: string;
+    classifierSession: string;
+    acquiredAt: string;
+    expiresAt: string;
+} | {
+    type: "classifier.lease_expired";
+    leaseId: string;
+    classifierSession: string;
+    expiredAt: string;
+} | {
+    type: "classifier.dead";
+    leaseId: string;
+    classifierSession: string;
+    lastHeartbeat: string;
+    detectedAt: string;
+} | {
+    type: "classifier.reclaimed";
+    leaseId: string;
+    previousClassifierSession: string;
+    reclaimedBySession: string;
+    reason: string;
+    reclaimedAt: string;
+} | {
+    type: "view.changed";
+    viewName: string;
+    cause: string;
+} | {
+    type: "watchdog.evaluation_fired";
+    jobId: string;
+    policy: string;
+    targetSession: string;
+    deliveryStatus: string;
+} | {
+    type: "watchdog.evaluation_skipped";
+    jobId: string;
+    policy: string;
+    skipReason: string;
+} | {
+    type: "watchdog.evaluation_terminal";
+    jobId: string;
+    policy: string;
+    terminalReason: string;
+} | {
+    type: "watchdog.job_registered";
+    jobId: string;
+    policy: string;
+    targetSession: string;
+    registeredBy: string;
+} | {
+    type: "watchdog.job_stopped";
+    jobId: string;
+    reason: string;
+} | {
+    type: "workflow.instantiated";
+    instanceId: string;
+    workflowName: string;
+    workflowVersion: string;
+    createdBy: string;
+} | {
+    type: "workflow.step_closed";
+    instanceId: string;
+    stepId: string;
+    closureReason: string;
+    actorSession: string;
+    priorQitemId: string;
+} | {
+    type: "workflow.next_qitem_projected";
+    instanceId: string;
+    nextQitemId: string;
+    nextOwner: string;
+    nextStepId: string;
+} | {
+    type: "workflow.completed";
+    instanceId: string;
+    workflowName: string;
+} | {
+    type: "workflow.failed";
+    instanceId: string;
+    workflowName: string;
+    reason: string;
+} | {
+    type: "workflow.resumed";
+    instanceId: string;
+    workflowName: string;
+    stepId: string;
+    resumedBy: string;
+    decision: string | null;
+    resumeCount: number;
+} | {
+    type: "workflow.routing_table_changed";
+    rigName: string;
+    cause: string;
+    instanceId?: string;
+    stepId?: string | null;
+    from?: string;
+    to?: string;
+} | {
+    type: "workflow_spec.removed";
+    sourcePath: string;
+    specId: string | null;
+    specName: string | null;
+    specVersion: string | null;
+    reason: "file_disappeared";
+} | {
+    type: "mission_control.action_executed";
+    actionId: string;
+    actionVerb: string;
+    qitemId: string | null;
+    actorSession: string;
+} | {
+    type: "mission_control.cli_drift_detected";
+    rigName: string;
+    missingField: string;
+    observedAt: string;
+} | {
+    type: "mission_control.view_refreshed";
+    viewName: string;
+    cause: string;
+} | {
+    type: "mission_control.notification_sent";
+    mechanism: string;
+    target: string;
+    qitemId: string | null;
+    sentAt: string;
+} | {
+    type: "mission_control.notification_failed";
+    mechanism: string;
+    target: string;
+    qitemId: string | null;
+    error: string;
+    failedAt: string;
+};
+export type PersistedEvent = RigEvent & {
+    seq: number;
+    createdAt: string;
+};
+export interface NodeWithBinding extends Node {
+    binding: Binding | null;
+}
+export interface RigWithRelations {
+    rig: Rig;
+    nodes: NodeWithBinding[];
+    edges: Edge[];
+}
+export interface PersistedProjectionEntry {
+    category: string;
+    effectiveId: string;
+    sourceSpec: string;
+    sourcePath: string;
+    resourcePath: string;
+    absolutePath: string;
+    resourceType?: string;
+    mergeStrategy?: string;
+    target?: string;
+}
+export interface NodeStartupSnapshot {
+    projectionEntries: PersistedProjectionEntry[];
+    resolvedStartupFiles: import("./runtime-adapter.js").ResolvedStartupFile[];
+    startupActions: StartupAction[];
+    runtime: string;
+}
+export interface SnapshotData {
+    rig: Rig;
+    nodes: NodeWithBinding[];
+    edges: Edge[];
+    sessions: Session[];
+    checkpoints: Record<string, Checkpoint | null>;
+    pods?: Pod[];
+    continuityStates?: ContinuityState[];
+    nodeStartupContext?: Record<string, NodeStartupSnapshot | null>;
+    envReceipt?: EnvReceipt | null;
+}
+export interface Snapshot {
+    id: string;
+    rigId: string;
+    kind: string;
+    status: string;
+    data: SnapshotData;
+    createdAt: string;
+}
+export interface Checkpoint {
+    id: string;
+    nodeId: string;
+    summary: string;
+    currentTask: string | null;
+    nextStep: string | null;
+    blockedOn: string | null;
+    keyArtifacts: string[];
+    confidence: string | null;
+    podId: string | null;
+    continuitySource: string | null;
+    continuityArtifactsJson: string | null;
+    createdAt: string;
+}
+export interface RestoreResult {
+    snapshotId: string;
+    preRestoreSnapshotId: string | null;
+    rigResult: RestoreRigResult;
+    nodes: RestoreNodeResult[];
+    warnings: string[];
+    blockers?: RestoreValidationBlocker[];
+}
+export type RestoreRigResult = "fully_restored" | "partially_restored" | "failed" | "not_attempted";
+export interface RestoreValidationBlocker {
+    code: string;
+    severity: "critical";
+    nodeId?: string;
+    logicalId?: string;
+    target?: string;
+    path?: string;
+    message: string;
+    remediation: string;
+}
+export interface RestoreNodeResult {
+    nodeId: string;
+    logicalId: string;
+    status: "resumed" | "rebuilt" | "fresh" | "fresh-primed" | "awaiting-decision" | "failed" | "attention_required" | "operator_recovered";
+    error?: string;
+    /** Pane evidence captured when status is `attention_required` (L3, optional). */
+    attentionEvidence?: string | null;
+}
+export type RestoreOutcome = {
+    ok: true;
+    result: RestoreResult;
+} | {
+    ok: false;
+    code: "snapshot_not_found";
+    message: string;
+} | {
+    ok: false;
+    code: "rig_not_found";
+    message: string;
+} | {
+    ok: false;
+    code: "rig_not_stopped";
+    message: string;
+} | {
+    ok: false;
+    code: "restore_error";
+    message: string;
+} | {
+    ok: false;
+    code: "restore_in_progress";
+    message: string;
+} | {
+    ok: false;
+    code: "service_boot_failed";
+    message: string;
+} | {
+    ok: false;
+    code: "pre_restore_validation_failed";
+    message: string;
+    result: RestoreResult;
+};
+export type NodeRestoreOutcome = "resumed" | "rebuilt" | "fresh" | "fresh-primed" | "awaiting-decision" | "failed" | "attention_required" | "operator_recovered" | "n-a";
+export type NodeOriented = "verified" | "missing" | "rejected" | "n-a";
+export type OccupantLifecycle = "active" | "retiring" | "retired" | "context_walled" | "compacted" | "crashed" | "unknown";
+export type ContinuityOutcome = "resumed" | "rebuilt" | "forked" | "fresh" | "failed";
+export type HandoverResult = "complete" | "unchanged" | "partial" | "failed" | null;
+export type AgentActivityState = "running" | "needs_input" | "idle" | "unknown";
+export type AgentActivityEvidenceSource = "runtime_hook" | "pane_heuristic"
+/** ACTIVITY D1+D2 — tmux `#{window_activity}` motion (SeatActivityService). A fact about BYTES on
+ *  the pane, so it is runtime-AGNOSTIC: it sees a generating Codex seat and a generating Claude
+ *  seat identically, where a TUI-string matcher has to be re-taught on every provider reskin. The
+ *  UI has called this source `terminal_activity` since slice 15 (activity-visuals.ts); the daemon
+ *  reports under the SAME name rather than minting a second word for one signal. */
+ | "terminal_activity" | "tmux_session" | "external_cli" | "session_registry";
+export interface AgentActivity {
+    state: AgentActivityState;
+    reason: string;
+    evidenceSource: AgentActivityEvidenceSource;
+    sampledAt: string;
+    evidence: string | null;
+    eventAt?: string | null;
+    rawEvent?: string | null;
+    rawSubtype?: string | null;
+    runtime?: string | null;
+    fallback?: boolean;
+    stale?: boolean;
+    /** W2a-1 — the occupant-tenure generation_uuid in force when this claim was recorded — the per-tenure
+     *  occupant identity that CHANGES for a new occupant (a handover/swap to a different occupant mints a
+     *  new generation) and persists only WITHIN a single tenure (a same-native-session relaunch is a
+     *  continuation, same generation); null = UNKNOWN at record time. node_id, NOT this, is what is stable
+     *  across handover — that is exactly why comparing generation detects a dead tenure. */
+    generation?: string | null;
+    /** W2a-1 — the read-side provenance verdict for the occupant generation (present only when the
+     *  read resolved through an injected generation resolver): `resolved` = both the recorded and the
+     *  live generation were known (equal here; a KNOWN mismatch returns state:"unknown" instead);
+     *  `unresolved` = null on either side, so the claim is DELIVERED carrying this honest label rather
+     *  than dropped or bare-attributed (pm ruling 2026-08-08, the P21 claimed-era pattern). Absent when
+     *  no resolver is wired (legacy clock-only path). */
+    generationProvenance?: "resolved" | "unresolved";
+}
+export interface NodeRecoveryGuidance {
+    summary: string;
+    commands: string[];
+    notes: string[];
+}
+export type NodeLifecycleState = "running" | "detached" | "recoverable" | "attention_required";
+/**
+ * OPR.0.4.3.19 — the liveness identity verdict for a managed seat.
+ *
+ * A THIRD axis, orthogonal to slice-15's `terminalActive` (tmux output
+ * recency) and `hasAssignedWork` (queue-derived). It answers: does the process
+ * currently in the seat's registered tmux pane match the seat we are reporting?
+ * Computed by the periodic SeatIdentityReconciler from the pane PID/command vs
+ * the registered `bindings.tmux_pane`, NEVER from queue/classifier/hook
+ * heartbeats. Only `mismatch` and `pane_missing` down-rank a `running`
+ * projection; `verified` and `tmux_unavailable` (and an absent verdict) leave
+ * it unchanged.
+ */
+export type SeatIdentityVerdictKind = "verified" | "mismatch" | "pane_missing" | "tmux_unavailable";
+export interface SeatIdentityVerdict {
+    nodeId: string;
+    verdict: SeatIdentityVerdictKind;
+    /** Which observation axis produced the verdict. Null for `verified`. */
+    evidenceSource: "pane_process" | "tmux_session" | null;
+    /** The specific reason for a non-verified verdict. Null for `verified`. */
+    reason: "process_identity_mismatch" | "pane_pid_gone" | "session_missing" | "tmux_unavailable" | null;
+    evidence: {
+        registeredPane: string | null;
+        observedPid: number | null;
+        observedCommand: string | null;
+        matchedLayer: number | null;
+    };
+    sessionName: string | null;
+    observedAt: string;
+}
+/**
+ * OPR.0.4.3.19 — the two verdict kinds that down-rank a `running`/`active`
+ * projection to a non-green state. `verified`, `tmux_unavailable`, and an
+ * ABSENT verdict all leave the projection unchanged (fail-open on unknown).
+ */
+export declare function identityVerdictDownranksRunning(verdict: SeatIdentityVerdictKind | null | undefined): boolean;
+export type RigLifecycleState = "running" | "recoverable" | "stopped" | "degraded" | "attention_required";
+export interface NodeInventoryEntry {
+    rigId: string;
+    rigName: string;
+    logicalId: string;
+    podId: string | null;
+    podNamespace?: string | null;
+    /**
+     * OPR.0.4.6.FAC1: the seat's declared role (`nodes.role`, written by
+     * the pod-member path). The workflow binding layer's role→seat
+     * candidate filter reads exactly this. null = role-less.
+     */
+    role: string | null;
+    canonicalSessionName: string | null;
+    attachmentType?: "tmux" | "external_cli" | null;
+    nodeKind: "agent" | "infrastructure";
+    runtime: string | null;
+    sessionStatus: string | null;
+    startupStatus: "pending" | "ready" | "attention_required" | "failed" | null;
+    restoreOutcome: NodeRestoreOutcome;
+    oriented: NodeOriented;
+    lifecycleState: NodeLifecycleState;
+    occupantLifecycle: OccupantLifecycle;
+    continuityOutcome: ContinuityOutcome | null;
+    handoverResult: HandoverResult;
+    previousOccupant: string | null;
+    handoverAt: string | null;
+    tmuxAttachCommand: string | null;
+    resumeCommand: string | null;
+    recoveryGuidance: NodeRecoveryGuidance | null;
+    latestError: string | null;
+    model: string | null;
+    agentRef: string | null;
+    profile: string | null;
+    codexConfigProfile?: string | null;
+    /** OPR.0.4.8.3 Seam B: attached permission_policy REF, or null when none is attached. */
+    permissionPolicy?: string | null;
+    resolvedSpecName: string | null;
+    resolvedSpecVersion: string | null;
+    resolvedSpecHash: string | null;
+    cwd: string | null;
+    restorePolicy: string | null;
+    resumeType: string | null;
+    resumeToken: string | null;
+    startupCompletedAt: string | null;
+    agentActivity?: AgentActivity;
+    contextUsage?: ContextUsage;
+    /** Health of the daemon-owned transcript capture for this seat. */
+    transcriptIngest?: import("./transcript-store.js").TranscriptIngestHealth & {
+        runtime: string | null;
+    };
+    /**
+     * Slice 15 — `terminal-active` primitive (tmux byte-stream).
+     *
+     *   true  → seat is currently producing tmux output (window_activity
+     *           timestamp within the silence window)
+     *   false → seat is silent past the threshold
+     *   null  → no signal (not tmux-bound, or transient read error).
+     *           Distinct from `false`: consumers
+     *           treat `null` as "no observation right now", not "definitely
+     *           idle".
+     *
+     * MUST NOT be derived from `hasAssignedWork` or queue/assignment state.
+     * The non-inference contract (slice 15 README + IMPL-PRD §2.3) is the
+     * core correctness item: this field is computed independently from
+     * `hasAssignedWork`.
+     */
+    terminalActive?: boolean | null;
+    /**
+     * ARCH RULING 3a947fb1 (FR-7 additive) — the seat's RAW `lastActivityAt`
+     * fact (SeatActivity.lastActivityAt), projected per-seat alongside
+     * `terminalActive`. ISO string when an observation exists; `null` when
+     * the seat has no observation (never polled / non-tmux); `undefined`
+     * when no SeatActivityService is wired — exactly the honest-absence
+     * ladder `terminalActive` uses. NO `ageSeconds` sibling: age is a VIEW
+     * derived at the renderer from this fact + a reader clock (C3).
+     */
+    lastActivityAt?: string | null;
+    /**
+     * Slice 15 — `has-work-to-do` primitive. Derived from queue/assignment
+     * projection (pending qitems whose `destination_session` matches this
+     * seat's `canonicalSessionName`).
+     *
+     * MUST NOT be derived from `terminalActive` or tmux output. Two
+     * orthogonal primitives, never one inferred from the other.
+     */
+    hasAssignedWork?: boolean;
+    /** Optional count of pending qitems assigned to this seat (cheap aggregate). */
+    pendingWorkCount?: number;
+    /**
+     * OPR.0.4.3.19 — liveness identity verdict (the THIRD axis). Present when
+     * the SeatIdentityReconciler has recorded a verdict for this node; absent
+     * (undefined) when never polled. A `mismatch`/`pane_missing` verdict
+     * down-ranks the node's `lifecycleState`/`occupantLifecycle` away from
+     * running/active and carries the evidence. MUST NOT be derived from
+     * `terminalActive`, `hasAssignedWork`, or any queue/classifier/hook
+     * heartbeat — process identity only.
+     */
+    identityVerdict?: SeatIdentityVerdict | null;
+    /** OPR.0.3.4.11 — held reason derived from the latest `node.held` event.
+     *  Null when no held event, or superseded by a running session / later launch. */
+    heldReason?: string | null;
+    /** PL-007: per-node workspace block when the rig declares a workspace.
+     *  workspaceRoot mirrors RigSpec.workspace.workspaceRoot. activeRepo is
+     *  the repo whose path contains the node's cwd, or RigSpec.workspace.
+     *  defaultRepo when no containing repo is found. kind is the kind of
+     *  the active repo, or `knowledge` when cwd is under knowledgeRoot.
+     *  null when the rig does not declare a workspace. */
+    workspace?: NodeWorkspaceInfo | null;
+}
+/**
+ * Slice 15 — `terminal-active` observation for a single seat's pane.
+ *
+ * Sourced from tmux's `#{window_activity}` format (Unix-epoch-seconds
+ * timestamp of the last output on the window). The producing service
+ * polls the timestamp at a configurable cadence and compares it
+ * against the silence window threshold; `isActiveWithinWindow` is true
+ * when the most recent activity is within that window. The
+ * The daemon no longer configures tmux's `monitor-silence` option at
+ * launch (removed OPR.0.4.0.18); `window_activity` is the sole source.
+ */
+export interface SeatActivity {
+    /** tmux pane id OR canonical session name — whatever the daemon binds. */
+    paneId: string;
+    /** True ⟺ pane has produced output within `silenceWindowSeconds`. */
+    isActiveWithinWindow: boolean;
+    /** Configured threshold at observation time. */
+    silenceWindowSeconds: number;
+    /** ISO timestamp of the most recent observation. */
+    lastObservedAt: string;
+    /**
+     * ARCH RULING 3a947fb1 (FR-7 additive) — the RAW `window_activity`
+     * timestamp (last output on the pane), as ISO. This is the input the
+     * service already reads to derive active/idle; surfaced verbatim so
+     * consumers can compute a fresh idle-age = f(fact, reader-clock).
+     *
+     * RAW FACT, never clamped: clock skew can put this slightly AHEAD of
+     * `lastObservedAt` (the service reads negative age as active); the
+     * value is stored as observed and renderers clamp for display only.
+     * Distinct from `lastObservedAt` (when WE looked) — this is when the
+     * pane last produced output. A record only exists when tmux returned a
+     * signal, so this is always present on a record (absence = no record).
+     */
+    lastActivityAt: string;
+}
+export interface NodeWorkspaceInfo {
+    workspaceRoot: string;
+    activeRepo: string | null;
+    kind: WorkspaceKind | null;
+}
+export interface NodeDetailPeer {
+    logicalId: string;
+    canonicalSessionName: string | null;
+    attachmentType?: "tmux" | "external_cli" | null;
+    runtime: string | null;
+}
+export interface NodeDetailEdge {
+    kind: string;
+    to?: {
+        logicalId: string;
+        sessionName: string | null;
+    };
+    from?: {
+        logicalId: string;
+        sessionName: string | null;
+    };
+}
+export interface NodeDetailTranscript {
+    enabled: boolean;
+    path: string | null;
+    tailCommand: string | null;
+}
+export interface NodeDetailCompactSpec {
+    name: string | null;
+    version: string | null;
+    profile: string | null;
+    skillCount: number;
+    guidanceCount: number;
+}
+export interface NodeDetailEntry extends NodeInventoryEntry {
+    /** W3 opt-in single-seat diagnostic; never populated on inventory lists. */
+    permissionDrift?: import("./permission-drift.js").PermissionDriftDiagnostic | null;
+    binding: Binding | null;
+    startupFiles: Array<{
+        path: string;
+        deliveryHint: string;
+        required: boolean;
+    }>;
+    startupActions: Array<{
+        type: string;
+        value: string;
+    }>;
+    installedResources: Array<{
+        id: string;
+        category: string;
+        targetPath: string;
+    }>;
+    recentEvents: Array<{
+        type: string;
+        createdAt: string;
+        payload: Record<string, unknown>;
+    }>;
+    infrastructureStartupCommand: string | null;
+    peers: NodeDetailPeer[];
+    edges: {
+        outgoing: NodeDetailEdge[];
+        incoming: NodeDetailEdge[];
+    };
+    transcript: NodeDetailTranscript;
+    compactSpec: NodeDetailCompactSpec;
+}
+export interface ImportSpec {
+    ref: string;
+    version?: string;
+}
+export interface StartupFile {
+    /** Startup artifacts are files; context packs are composed separately. */
+    kind?: "file";
+    path: string;
+    deliveryHint: "auto" | "guidance_merge" | "skill_install" | "send_text";
+    required: boolean;
+    appliesOn: ("fresh_start" | "restore")[];
+}
+export interface StartupAction {
+    type: "slash_command" | "send_text";
+    value: string;
+    phase: "after_files" | "after_ready";
+    appliesOn: ("fresh_start" | "restore")[];
+    idempotent: boolean;
+    builtin?: "session_identity";
+}
+export interface StartupBlock {
+    files: StartupFile[];
+    actions: StartupAction[];
+}
+export interface LifecycleDefaults {
+    executionMode: "interactive_resident";
+    compactionStrategy: "harness_native" | "pod_continuity";
+    restorePolicy: "resume_if_possible" | "relaunch_fresh" | "checkpoint_only";
+}
+export interface SkillResource {
+    id: string;
+    path: string;
+}
+export interface GuidanceResource {
+    id: string;
+    path: string;
+    target: string;
+    merge: "managed_block" | "append";
+}
+export interface SubagentResource {
+    id: string;
+    path: string;
+}
+export interface RuntimeResource {
+    id: string;
+    path: string;
+    runtime: string;
+    type: string;
+}
+export type PluginSource = {
+    kind: "local";
+    path: string;
+};
+export interface PluginResource {
+    id: string;
+    source: PluginSource;
+    pluginType?: "claude" | "codex" | "auto";
+}
+export interface AgentResources {
+    skills: SkillResource[];
+    guidance: GuidanceResource[];
+    subagents: SubagentResource[];
+    plugins: PluginResource[];
+    runtimeResources: RuntimeResource[];
+}
+export interface ProfileSpec {
+    summary?: string;
+    preferences?: {
+        runtime?: string;
+        model?: string;
+    };
+    startup?: StartupBlock;
+    lifecycle?: LifecycleDefaults;
+    uses: {
+        skills: string[];
+        guidance: string[];
+        subagents: string[];
+        plugins: string[];
+        runtimeResources: string[];
+    };
+    /**
+     * Per-seat activity-detection tuning. `silenceWindowSeconds` is the
+     * threshold below which terminal output reads as "terminal-active".
+     * Currently inert: the live SeatActivityService poller uses the global
+     * 3s default and does not read per-seat windows. Retained for a future
+     * per-seat-poller decision. Invalid values are dropped at normalize time.
+     */
+    activity?: {
+        silenceWindowSeconds?: number;
+    };
+}
+export interface AgentSpec {
+    version: string;
+    name: string;
+    summary?: string;
+    imports: ImportSpec[];
+    defaults?: {
+        runtime?: string;
+        model?: string;
+        lifecycle?: LifecycleDefaults;
+    };
+    startup: StartupBlock;
+    resources: AgentResources;
+    profiles: Record<string, ProfileSpec>;
+}
+export interface LegacyRigSpec {
+    schemaVersion: number;
+    name: string;
+    version: string;
+    nodes: LegacyRigSpecNode[];
+    edges: LegacyRigSpecEdge[];
+}
+export interface LegacyRigSpecNode {
+    id: string;
+    runtime: string;
+    role?: string;
+    model?: string;
+    cwd?: string;
+    surfaceHint?: string;
+    workspace?: string;
+    restorePolicy?: string;
+    packageRefs?: string[];
+}
+export interface LegacyRigSpecEdge {
+    from: string;
+    to: string;
+    kind: string;
+}
+export interface ContinuityPolicySpec {
+    enabled: boolean;
+    syncTriggers?: string[];
+    artifacts?: {
+        sessionLog?: boolean;
+        restoreBrief?: boolean;
+        quiz?: boolean;
+    };
+    restoreProtocol?: {
+        peerDriven?: boolean;
+        verifyViaQuiz?: boolean;
+    };
+}
+/**
+ * Member-level launch input for declaring how a new managed seat should
+ * derive its starting context. Discriminated union over `mode`:
+ *
+ * - `fork` — start from a prior native runtime conversation source
+ *   (Claude `--fork-session` / Codex `fork`); persists a NEW post-fork
+ *   token; identity-honest (parent token is NEVER persisted onto the
+ *   new seat). v1 supports `ref.kind: "native_id"` only.
+ *
+ * - `rebuild` — fresh-launch a new seat seeded with operator-declared
+ *   artifacts (CULTURE, role doc, handover packet, queue files, session
+ *   logs). NO native-runtime resume or fork; NO `resumeToken` on the
+ *   resulting seat; `continuityOutcome` is `"rebuilt"` (NEVER `"fresh"`,
+ *   `"resumed"`, or `"forked"`). v1 supports `ref.kind: "artifact_set"`
+ *   only, with `ref.value` as a non-empty array of file paths in
+ *   operator-declared trust-precedence order.
+ */
+export type SessionSourceSpec = SessionSourceForkSpec | SessionSourceRebuildSpec | SessionSourceAgentImageSpec;
+export interface SessionSourceForkSpec {
+    mode: "fork";
+    ref: {
+        kind: "native_id" | "artifact_path" | "name" | "last";
+        value?: string;
+    };
+}
+export interface SessionSourceRebuildSpec {
+    mode: "rebuild";
+    ref: {
+        kind: "artifact_set";
+        value: string[];
+    };
+}
+/**
+ * PL-016 Item 4 — agent_image session source.
+ * The instantiator looks up the named image in the
+ * AgentImageLibraryService, captures the runtime resume token from the
+ * manifest, and dispatches the launch through the existing fork code
+ * path (forkSource: { kind: "native_id", value: <resumeToken> }) so
+ * `nativeResumeProbe` semantics are preserved.
+ *
+ * v0 supports `ref.kind: "image_name"` only; `image_id` and
+ * `image_hash` are NAMED v1+ triggers per PRD § v0 Out.
+ */
+export interface SessionSourceAgentImageSpec {
+    mode: "agent_image";
+    ref: {
+        kind: "image_name";
+        value: string;
+        /** Optional version selector; defaults to "1" at consumption
+         *  time (matches the manifest convention). */
+        version?: string;
+    };
+}
+/**
+ * Reference to a named agent-starter registry entry. Artifact-seeded
+ * fresh-launch context: the starter's curated artifacts are added to the
+ * member's startup-file chain at launch time. Composes additively with
+ * `sessionSource` (independent semantics: starter_ref seeds context;
+ * session_source declares the runtime-source mode). v0 schema constraint:
+ * `starter_ref` MAY combine with `session_source.mode: "rebuild"` (both
+ * apply on `fresh_start`) but MAY NOT combine with `session_source.mode:
+ * "fork"` (the v1+ "Real native-fork-from-registered-thread-id starter
+ * proof" trigger covers that composition).
+ */
+export interface StarterRefSpec {
+    /** Registry key. Matches an entry at `<registryRoot>/<name>.yaml`. */
+    name: string;
+}
+export interface RigSpecPodMember {
+    id: string;
+    label?: string;
+    agentRef: string;
+    profile: string;
+    runtime: string;
+    codexConfigProfile?: string;
+    model?: string;
+    /**
+     * OPR.0.4.6.FAC1: optional seat-side role declaration (writes the
+     * existing `nodes.role` column via createMemberNode → addNode). The
+     * workflow binding layer resolves workflow roles to seats by this
+     * dimension. Opt-in: a role-less member is never role-resolved and
+     * stays reachable only via explicit preferred_targets.
+     */
+    role?: string;
+    /** OPR.0.4.8.3 Seam B: optional per-seat permission_policy REF (builtin:<name> or a spec-relative
+     *  custom path). Absent = the floor. Overrides the rig-level ref. */
+    permissionPolicy?: string;
+    cwd: string;
+    restorePolicy?: string;
+    startup?: StartupBlock;
+    /**
+     * Optional fork source declaration. v1 MVP: mode="fork" with
+     * ref.kind="native_id". Validated by `rigspec-schema.ts` and translated
+     * to the runtime adapter's `forkSource` opt at launch time.
+     */
+    sessionSource?: SessionSourceSpec;
+    /**
+     * Optional reference to a named starter registry entry.
+     * See {@link StarterRefSpec}. Resolved by `AgentStarterResolver` at
+     * launch time; resolved artifacts seed the STARTER layer of the
+     * member's startup-file chain. Mutually exclusive with
+     * `sessionSource.mode: "fork"` per v0 schema (validateStarterRef).
+     */
+    starterRef?: StarterRefSpec;
+}
+export interface RigSpecPodEdge {
+    kind: string;
+    from: string;
+    to: string;
+}
+export interface RigSpecCrossPodEdge {
+    kind: string;
+    from: string;
+    to: string;
+}
+export interface RigSpecPod {
+    id: string;
+    label: string;
+    summary?: string;
+    continuityPolicy?: ContinuityPolicySpec;
+    startup?: StartupBlock;
+    members: RigSpecPodMember[];
+    edges: RigSpecPodEdge[];
+}
+export interface RigSpecDoc {
+    path: string;
+}
+/**
+ * PL-007 Workspace Primitive — typed workspace kinds enum. Reserved set
+ * at v0; adding a sixth kind is a v1+ amendment per the PL-007 product
+ * spec. Each kind has folder shape + frontmatter contract + ownership
+ * rules (see `frontmatter-validator.ts` for the per-kind required-field
+ * map).
+ */
+export declare const WORKSPACE_KINDS: readonly ["user", "project", "knowledge", "lab", "delivery"];
+export type WorkspaceKind = (typeof WORKSPACE_KINDS)[number];
+/** PL-007 — RigSpec.workspace.repos[] entry (typed). */
+export interface WorkspaceRepoSpec {
+    name: string;
+    /** Absolute path after normalization. Authors may declare a path relative to
+     *  `workspaceRoot` in YAML; the codec resolves to absolute at parse time. */
+    path: string;
+    kind: WorkspaceKind;
+}
+/** PL-007 — Optional RigSpec.workspace block. Rigs without it stay valid;
+ *  whoami / node-inventory return a null workspace block in that case. */
+export interface WorkspaceSpec {
+    workspaceRoot: string;
+    repos: WorkspaceRepoSpec[];
+    defaultRepo?: string;
+    /** Optional knowledge-canon root (e.g., a shared docs repo path).
+     *  Treated as kind=knowledge when surfaced through whoami / UI. */
+    knowledgeRoot?: string;
+}
+export interface RigSpec {
+    version: string;
+    name: string;
+    summary?: string;
+    cultureFile?: string;
+    /** OPR.0.4.8.3 Seam B: optional rig-level permission_policy REF (builtin:<name> or a
+     *  spec-relative custom path). Absent = the floor. A per-member ref overrides this. */
+    permissionPolicy?: string;
+    docs?: RigSpecDoc[];
+    startup?: StartupBlock;
+    services?: RigServicesSpec;
+    /** PL-007 Workspace Primitive — optional typed workspace declaration. */
+    workspace?: WorkspaceSpec;
+    pods: RigSpecPod[];
+    edges: RigSpecCrossPodEdge[];
+}
+export interface RigServicesWaitTarget {
+    service?: string;
+    condition?: "healthy";
+    url?: string;
+    tcp?: string;
+}
+export interface RigServicesSurfaceUrl {
+    name: string;
+    url: string;
+}
+export interface RigServicesSurfaceCommand {
+    name: string;
+    command: string;
+}
+export interface RigServicesSurface {
+    urls?: RigServicesSurfaceUrl[];
+    commands?: RigServicesSurfaceCommand[];
+}
+export interface RigServicesCheckpointHook {
+    id: string;
+    exportCommand: string;
+    importCommand?: string;
+}
+export interface RigServicesSpec {
+    kind: "compose";
+    composeFile: string;
+    projectName?: string;
+    profiles?: string[];
+    downPolicy?: "leave_running" | "down" | "down_and_volumes";
+    waitFor?: RigServicesWaitTarget[];
+    surfaces?: RigServicesSurface;
+    checkpoints?: RigServicesCheckpointHook[];
+}
+export interface EnvReceipt {
+    kind: "compose";
+    composeFile: string;
+    projectName: string;
+    services: Array<{
+        name: string;
+        status: string;
+        health?: string | null;
+    }>;
+    waitFor: Array<{
+        target: RigServicesWaitTarget;
+        status: "healthy" | "unhealthy" | "pending";
+        detail?: string | null;
+    }>;
+    capturedAt: string;
+}
+export interface EnvCheckpoint {
+    kind: "compose";
+    capturedAt: string;
+    artifactsJson: string;
+}
+export interface RigServicesRecordInput {
+    kind: "compose";
+    specJson: string;
+    rigRoot: string;
+    composeFile: string;
+    projectName?: string;
+    latestReceiptJson?: string | null;
+}
+export interface RigServicesRecord {
+    rigId: string;
+    kind: "compose";
+    specJson: string;
+    rigRoot: string;
+    composeFile: string;
+    projectName: string;
+    latestReceiptJson: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+export interface PreflightResult {
+    ready: boolean;
+    warnings: string[];
+    errors: string[];
+}
+export type InstantiateOutcome = {
+    ok: true;
+    result: InstantiateResult;
+} | {
+    ok: false;
+    code: "validation_failed";
+    errors: string[];
+} | {
+    ok: false;
+    code: "preflight_failed";
+    errors: string[];
+    warnings: string[];
+} | {
+    ok: false;
+    code: "instantiate_error";
+    message: string;
+} | {
+    ok: false;
+    code: "cycle_error";
+    message: string;
+} | {
+    ok: false;
+    code: "service_boot_failed";
+    message: string;
+} | {
+    ok: false;
+    code: "attention_required";
+    message: string;
+    rigId: string;
+    attentionNodes: AttentionNode[];
+};
+export interface AttentionNode {
+    logicalId: string;
+    sessionName: string;
+    evidence?: string;
+    reason: string;
+}
+export interface InstantiateResult {
+    rigId: string;
+    specName: string;
+    specVersion: string;
+    nodes: {
+        logicalId: string;
+        status: "launched" | "failed" | "attention_required";
+        error?: string;
+        sessionName?: string;
+        evidence?: string;
+    }[];
+    warnings?: string[];
+}
+export interface ExpansionPodFragment {
+    id: string;
+    label: string;
+    summary?: string;
+    members: Array<{
+        id: string;
+        runtime: string;
+        agentRef?: string;
+        profile?: string;
+        cwd?: string;
+        model?: string;
+        codexConfigProfile?: string;
+        /** OPR.0.4.8.3 Seam B: per-seat permission_policy REF — threaded through the
+         *  expansion ingress exactly like role (never silently dropped). Typed UNKNOWN
+         *  (R2 at 4ac243c3): the ingress preserves RAW presence — including null and other
+         *  invalid shapes — so the ONE canonical RigSpec validator rejects present-invalid
+         *  values; the normalizer must never erase presence into absence/floor. */
+        permissionPolicy?: unknown;
+        restorePolicy?: string;
+        label?: string;
+        /**
+         * OPR.0.4.6.FAC1: optional seat-side role; threaded through
+         * buildExpansionSpecObject → the pod-member schema → nodes.role
+         * (a provided role is never silently dropped — the sibling-layer
+         * rule).
+         */
+        role?: string;
+        /** Optional session source declaration; threaded through to launch. */
+        sessionSource?: SessionSourceSpec;
+        /**
+         * Optional reference to a named starter registry entry; threaded
+         * through expansion → buildSyntheticSpec → daemon instantiation,
+         * matching the pass-through shape of `sessionSource`.
+         */
+        starterRef?: StarterRefSpec;
+    }>;
+    edges: Array<{
+        from: string;
+        to: string;
+        kind: string;
+    }>;
+}
+export interface ExpansionRequest {
+    rigId: string;
+    pod: ExpansionPodFragment;
+    crossPodEdges?: Array<{
+        from: string;
+        to: string;
+        kind: string;
+    }>;
+    rigRoot?: string;
+}
+export interface ExpansionNodeOutcome {
+    logicalId: string;
+    nodeId: string;
+    status: "launched" | "failed" | "attention_required";
+    error?: string;
+    sessionName?: string;
+}
+export type ExpansionResult = {
+    ok: true;
+    status: "ok" | "partial" | "failed";
+    podId: string;
+    podNamespace: string;
+    nodes: ExpansionNodeOutcome[];
+    warnings: string[];
+    retryTargets: string[];
+} | {
+    ok: false;
+    code: string;
+    error: string;
+};
+export type ContextAvailability = "known" | "unknown";
+export type ContextUnknownReason = "unsupported_runtime" | "not_managed" | "missing_sidecar" | "parse_error" | "stale" | "session_mismatch" | "stale_generation" | "no_data";
+export interface ContextUsage {
+    availability: ContextAvailability;
+    reason: ContextUnknownReason | null;
+    source: "claude_statusline_json" | "codex_token_count_jsonl" | null;
+    usedPercentage: number | null;
+    remainingPercentage: number | null;
+    contextWindowSize: number | null;
+    totalInputTokens: number | null;
+    totalOutputTokens: number | null;
+    currentUsage: string | null;
+    transcriptPath: string | null;
+    sessionId: string | null;
+    sessionName: string | null;
+    sampledAt: string | null;
+    fresh: boolean;
+}
+//# sourceMappingURL=types.d.ts.map