oh-my-opencode 4.9.2 → 4.11.0

package/dist/features/team-mode/types.d.ts

@@ -1,343 +1 @@
-import { z } from "zod";
-export declare const MESSAGE_KINDS: readonly ["message", "shutdown_request", "shutdown_approved", "shutdown_rejected", "announcement"];
-export declare const MEMBER_KINDS: readonly ["category", "subagent_type"];
-export declare const TASK_STATUSES: readonly ["pending", "claimed", "in_progress", "completed", "deleted"];
-export declare const RUNTIME_STATUSES: readonly ["creating", "active", "shutdown_requested", "deleting", "deleted", "failed", "orphaned"];
-export declare const CategoryMemberSchema: z.ZodObject<{
-    name: z.ZodString;
-    cwd: z.ZodOptional<z.ZodString>;
-    worktreePath: z.ZodOptional<z.ZodString>;
-    subscriptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    backendType: z.ZodDefault<z.ZodEnum<{
-        tmux: "tmux";
-        "in-process": "in-process";
-    }>>;
-    color: z.ZodOptional<z.ZodString>;
-    isActive: z.ZodDefault<z.ZodBoolean>;
-    kind: z.ZodLiteral<"category">;
-    category: z.ZodString;
-    prompt: z.ZodString;
-}, z.core.$strict>;
-export declare const SubagentMemberSchema: z.ZodObject<{
-    name: z.ZodString;
-    cwd: z.ZodOptional<z.ZodString>;
-    worktreePath: z.ZodOptional<z.ZodString>;
-    subscriptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    backendType: z.ZodDefault<z.ZodEnum<{
-        tmux: "tmux";
-        "in-process": "in-process";
-    }>>;
-    color: z.ZodOptional<z.ZodString>;
-    isActive: z.ZodDefault<z.ZodBoolean>;
-    kind: z.ZodLiteral<"subagent_type">;
-    subagent_type: z.ZodString;
-    prompt: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export declare const MemberSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    name: z.ZodString;
-    cwd: z.ZodOptional<z.ZodString>;
-    worktreePath: z.ZodOptional<z.ZodString>;
-    subscriptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    backendType: z.ZodDefault<z.ZodEnum<{
-        tmux: "tmux";
-        "in-process": "in-process";
-    }>>;
-    color: z.ZodOptional<z.ZodString>;
-    isActive: z.ZodDefault<z.ZodBoolean>;
-    kind: z.ZodLiteral<"category">;
-    category: z.ZodString;
-    prompt: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    name: z.ZodString;
-    cwd: z.ZodOptional<z.ZodString>;
-    worktreePath: z.ZodOptional<z.ZodString>;
-    subscriptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    backendType: z.ZodDefault<z.ZodEnum<{
-        tmux: "tmux";
-        "in-process": "in-process";
-    }>>;
-    color: z.ZodOptional<z.ZodString>;
-    isActive: z.ZodDefault<z.ZodBoolean>;
-    kind: z.ZodLiteral<"subagent_type">;
-    subagent_type: z.ZodString;
-    prompt: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>], "kind">;
-export declare const TeamSpecSchema: z.ZodPipe<z.ZodObject<{
-    version: z.ZodDefault<z.ZodLiteral<1>>;
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    createdAt: z.ZodDefault<z.ZodNumber>;
-    leadAgentId: z.ZodOptional<z.ZodString>;
-    teamAllowedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    sessionPermission: z.ZodOptional<z.ZodString>;
-    members: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        name: z.ZodString;
-        cwd: z.ZodOptional<z.ZodString>;
-        worktreePath: z.ZodOptional<z.ZodString>;
-        subscriptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        backendType: z.ZodDefault<z.ZodEnum<{
-            tmux: "tmux";
-            "in-process": "in-process";
-        }>>;
-        color: z.ZodOptional<z.ZodString>;
-        isActive: z.ZodDefault<z.ZodBoolean>;
-        kind: z.ZodLiteral<"category">;
-        category: z.ZodString;
-        prompt: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        name: z.ZodString;
-        cwd: z.ZodOptional<z.ZodString>;
-        worktreePath: z.ZodOptional<z.ZodString>;
-        subscriptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        backendType: z.ZodDefault<z.ZodEnum<{
-            tmux: "tmux";
-            "in-process": "in-process";
-        }>>;
-        color: z.ZodOptional<z.ZodString>;
-        isActive: z.ZodDefault<z.ZodBoolean>;
-        kind: z.ZodLiteral<"subagent_type">;
-        subagent_type: z.ZodString;
-        prompt: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>], "kind">>;
-}, z.core.$strip>, z.ZodTransform<{
-    version: 1;
-    name: string;
-    createdAt: number;
-    members: ({
-        name: string;
-        backendType: "tmux" | "in-process";
-        isActive: boolean;
-        kind: "category";
-        category: string;
-        prompt: string;
-        cwd?: string | undefined;
-        worktreePath?: string | undefined;
-        subscriptions?: string[] | undefined;
-        color?: string | undefined;
-    } | {
-        name: string;
-        backendType: "tmux" | "in-process";
-        isActive: boolean;
-        kind: "subagent_type";
-        subagent_type: string;
-        cwd?: string | undefined;
-        worktreePath?: string | undefined;
-        subscriptions?: string[] | undefined;
-        color?: string | undefined;
-        prompt?: string | undefined;
-    })[];
-    description?: string | undefined;
-    leadAgentId?: string | undefined;
-    teamAllowedPaths?: string[] | undefined;
-    sessionPermission?: string | undefined;
-}, {
-    version: 1;
-    name: string;
-    createdAt: number;
-    members: ({
-        name: string;
-        backendType: "tmux" | "in-process";
-        isActive: boolean;
-        kind: "category";
-        category: string;
-        prompt: string;
-        cwd?: string | undefined;
-        worktreePath?: string | undefined;
-        subscriptions?: string[] | undefined;
-        color?: string | undefined;
-    } | {
-        name: string;
-        backendType: "tmux" | "in-process";
-        isActive: boolean;
-        kind: "subagent_type";
-        subagent_type: string;
-        cwd?: string | undefined;
-        worktreePath?: string | undefined;
-        subscriptions?: string[] | undefined;
-        color?: string | undefined;
-        prompt?: string | undefined;
-    })[];
-    description?: string | undefined;
-    leadAgentId?: string | undefined;
-    teamAllowedPaths?: string[] | undefined;
-    sessionPermission?: string | undefined;
-}>>;
-export declare const MessageSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    messageId: z.ZodString;
-    from: z.ZodString;
-    to: z.ZodString;
-    kind: z.ZodEnum<{
-        message: "message";
-        shutdown_request: "shutdown_request";
-        shutdown_approved: "shutdown_approved";
-        shutdown_rejected: "shutdown_rejected";
-        announcement: "announcement";
-    }>;
-    body: z.ZodString;
-    summary: z.ZodOptional<z.ZodString>;
-    references: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>>;
-    timestamp: z.ZodNumber;
-    correlationId: z.ZodOptional<z.ZodString>;
-    color: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const TaskSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    id: z.ZodString;
-    subject: z.ZodString;
-    description: z.ZodString;
-    activeForm: z.ZodOptional<z.ZodString>;
-    status: z.ZodEnum<{
-        pending: "pending";
-        in_progress: "in_progress";
-        completed: "completed";
-        deleted: "deleted";
-        claimed: "claimed";
-    }>;
-    owner: z.ZodOptional<z.ZodString>;
-    blocks: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    blockedBy: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    createdAt: z.ZodNumber;
-    updatedAt: z.ZodNumber;
-    claimedAt: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-declare const RuntimeStateMemberSchema: z.ZodObject<{
-    name: z.ZodString;
-    sessionId: z.ZodOptional<z.ZodString>;
-    tmuxPaneId: z.ZodOptional<z.ZodString>;
-    tmuxGridPaneId: z.ZodOptional<z.ZodString>;
-    agentType: z.ZodEnum<{
-        leader: "leader";
-        "general-purpose": "general-purpose";
-    }>;
-    subagent_type: z.ZodOptional<z.ZodString>;
-    category: z.ZodOptional<z.ZodString>;
-    model: z.ZodOptional<z.ZodObject<{
-        providerID: z.ZodString;
-        modelID: z.ZodString;
-        variant: z.ZodOptional<z.ZodString>;
-        reasoningEffort: z.ZodOptional<z.ZodString>;
-        temperature: z.ZodOptional<z.ZodNumber>;
-        top_p: z.ZodOptional<z.ZodNumber>;
-        maxTokens: z.ZodOptional<z.ZodNumber>;
-        thinking: z.ZodOptional<z.ZodObject<{
-            type: z.ZodEnum<{
-                enabled: "enabled";
-                disabled: "disabled";
-            }>;
-            budgetTokens: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-    }, z.core.$strict>>;
-    status: z.ZodEnum<{
-        pending: "pending";
-        completed: "completed";
-        running: "running";
-        idle: "idle";
-        shutdown_approved: "shutdown_approved";
-        errored: "errored";
-    }>;
-    color: z.ZodOptional<z.ZodString>;
-    worktreePath: z.ZodOptional<z.ZodString>;
-    lastInjectedTurnMarker: z.ZodOptional<z.ZodString>;
-    pendingInjectedMessageIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>;
-export declare const RuntimeStateSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    teamRunId: z.ZodString;
-    teamName: z.ZodString;
-    specSource: z.ZodEnum<{
-        user: "user";
-        project: "project";
-    }>;
-    createdAt: z.ZodNumber;
-    status: z.ZodEnum<{
-        active: "active";
-        failed: "failed";
-        deleted: "deleted";
-        creating: "creating";
-        shutdown_requested: "shutdown_requested";
-        deleting: "deleting";
-        orphaned: "orphaned";
-    }>;
-    leadSessionId: z.ZodOptional<z.ZodString>;
-    tmuxLayout: z.ZodOptional<z.ZodObject<{
-        ownedSession: z.ZodBoolean;
-        targetSessionId: z.ZodString;
-        focusWindowId: z.ZodOptional<z.ZodString>;
-        gridWindowId: z.ZodOptional<z.ZodString>;
-        paneIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>>;
-    members: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        sessionId: z.ZodOptional<z.ZodString>;
-        tmuxPaneId: z.ZodOptional<z.ZodString>;
-        tmuxGridPaneId: z.ZodOptional<z.ZodString>;
-        agentType: z.ZodEnum<{
-            leader: "leader";
-            "general-purpose": "general-purpose";
-        }>;
-        subagent_type: z.ZodOptional<z.ZodString>;
-        category: z.ZodOptional<z.ZodString>;
-        model: z.ZodOptional<z.ZodObject<{
-            providerID: z.ZodString;
-            modelID: z.ZodString;
-            variant: z.ZodOptional<z.ZodString>;
-            reasoningEffort: z.ZodOptional<z.ZodString>;
-            temperature: z.ZodOptional<z.ZodNumber>;
-            top_p: z.ZodOptional<z.ZodNumber>;
-            maxTokens: z.ZodOptional<z.ZodNumber>;
-            thinking: z.ZodOptional<z.ZodObject<{
-                type: z.ZodEnum<{
-                    enabled: "enabled";
-                    disabled: "disabled";
-                }>;
-                budgetTokens: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-        }, z.core.$strict>>;
-        status: z.ZodEnum<{
-            pending: "pending";
-            completed: "completed";
-            running: "running";
-            idle: "idle";
-            shutdown_approved: "shutdown_approved";
-            errored: "errored";
-        }>;
-        color: z.ZodOptional<z.ZodString>;
-        worktreePath: z.ZodOptional<z.ZodString>;
-        lastInjectedTurnMarker: z.ZodOptional<z.ZodString>;
-        pendingInjectedMessageIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>>;
-    shutdownRequests: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        memberId: z.ZodString;
-        requesterName: z.ZodString;
-        requestedAt: z.ZodNumber;
-        approvedAt: z.ZodOptional<z.ZodNumber>;
-        rejectedReason: z.ZodOptional<z.ZodString>;
-        rejectedAt: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strict>>>;
-    bounds: z.ZodObject<{
-        maxMembers: z.ZodDefault<z.ZodNumber>;
-        maxParallelMembers: z.ZodDefault<z.ZodNumber>;
-        maxMessagesPerRun: z.ZodDefault<z.ZodNumber>;
-        maxWallClockMinutes: z.ZodDefault<z.ZodNumber>;
-        maxMemberTurns: z.ZodDefault<z.ZodNumber>;
-    }, z.core.$strict>;
-}, z.core.$strip>;
-export declare const AGENT_ELIGIBILITY_REGISTRY: Readonly<Record<string, {
-    verdict: "eligible" | "conditional" | "hard-reject";
-    rejectionMessage?: string;
-}>>;
-export declare function parseMember(input: unknown): Member;
-export type TeamSpec = z.infer<typeof TeamSpecSchema>;
-export type Member = z.infer<typeof MemberSchema>;
-export type CategoryMember = z.infer<typeof CategoryMemberSchema>;
-export type SubagentMember = z.infer<typeof SubagentMemberSchema>;
-export type Message = z.infer<typeof MessageSchema>;
-export type Task = z.infer<typeof TaskSchema>;
-export type RuntimeStateMember = z.infer<typeof RuntimeStateMemberSchema>;
-export type RuntimeState = z.infer<typeof RuntimeStateSchema>;
-export {};
+export * from "@oh-my-opencode/team-core/types";

package/dist/features/tmux-subagent/stale-tmux-resource-sweeper.d.ts

@@ -0,0 +1,12 @@
+import type { TmuxConfig } from "../../config/schema";
+export type StaleTmuxResourceSweepReport = {
+    readonly killed: number;
+    readonly killedAttachPanes: number;
+    readonly killedIsolatedSessions: number;
+};
+export type StaleTmuxResourceSweepDeps = {
+    readonly isolation: TmuxConfig["isolation"];
+    readonly sweepStaleOmoAgentSessions: () => Promise<number>;
+    readonly sweepStaleOmoAttachPanes: () => Promise<number>;
+};
+export declare function sweepStaleTmuxResources(deps: StaleTmuxResourceSweepDeps): Promise<StaleTmuxResourceSweepReport>;

package/dist/features/tool-metadata-store/store.d.ts

@@ -27,6 +27,11 @@ export declare function storeToolMetadata(sessionID: string, callID: string, dat
 /**
  * Consume stored metadata (one-time read, removes from store).
  * Called from tool.execute.after hook.
+ *
+ * For background/child sessions the after-hook's sessionID can diverge
+ * from the execute() sessionID, so an exact-key miss falls back to the
+ * callID alone - but only when exactly one session holds that callID,
+ * declining ambiguous cross-session collisions.
  */
 export declare function consumeToolMetadata(sessionID: string, callID: string): PendingToolMetadata | undefined;
 /**

package/dist/features/tui-sidebar/compute-view.d.ts

@@ -0,0 +1,10 @@
+import type { AgentsState, ConfigState, JobBoardState, LoopState, RosterState, SidebarView } from "./state-types";
+export type ComputeViewSections = {
+    readonly config: ConfigState;
+    readonly roster: RosterState;
+    readonly agents: AgentsState;
+    readonly jobs: JobBoardState;
+    readonly loop: LoopState;
+};
+export declare function computeView(sections: ComputeViewSections): SidebarView;
+export declare function viewKey(view: SidebarView): string;

package/dist/features/tui-sidebar/config-validator.d.ts

@@ -0,0 +1,2 @@
+export type { PluginConfigValidation } from "../../config/validate";
+export { validatePluginConfig } from "../../config/validate";

package/dist/features/tui-sidebar/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const MIRROR_DIR_NAME = "tui-state";
+export declare const MIRROR_SCHEMA_VERSION = 1;
+export declare const STALE_MS = 6000;
+export declare const LOOP_FRESH_MS = 120000;
+export declare const POLL_INTERVAL_MS = 1000;
+export declare const HEARTBEAT_MS = 2000;
+export declare const WRITE_DEBOUNCE_MS = 250;
+export declare const MAX_AGENTS = 12;
+export declare const MAX_JOBS = 12;
+export declare const LABEL_MAX = 24;

package/dist/features/tui-sidebar/derivers.d.ts

@@ -0,0 +1,10 @@
+import type { TuiRuntimeSnapshot } from "./snapshot-schema";
+import type { AgentsState, ConfigState, JobBoardState, LoopState, RosterRow, RosterState } from "./state-types";
+export declare function deriveConfig(v: {
+    readonly valid: boolean;
+    readonly messages: readonly string[];
+}): ConfigState;
+export declare function deriveRoster(rows: readonly RosterRow[]): RosterState;
+export declare function deriveAgents(snap: TuiRuntimeSnapshot | null): AgentsState;
+export declare function deriveJobBoard(snap: TuiRuntimeSnapshot | null): JobBoardState;
+export declare function deriveLoop(snap: TuiRuntimeSnapshot | null): LoopState;

package/dist/features/tui-sidebar/element-helpers.d.ts

@@ -0,0 +1,9 @@
+export type ViewNodeKind = "box" | "text";
+export type ViewNode = {
+    readonly kind: ViewNodeKind;
+    readonly props: Readonly<Record<string, unknown>>;
+    readonly text?: string;
+    readonly children?: readonly ViewNode[];
+};
+export declare function box(props: Readonly<Record<string, unknown>>, children?: readonly ViewNode[]): ViewNode;
+export declare function text(props: Readonly<Record<string, unknown>>, value: string): ViewNode;

package/dist/features/tui-sidebar/loop-reader.d.ts

@@ -0,0 +1,2 @@
+import type { LoopState } from "./state-types";
+export declare function readActiveLoop(projectDir: string): LoopState;

package/dist/features/tui-sidebar/mirror-io.d.ts

@@ -0,0 +1,3 @@
+import type { TuiRuntimeSnapshot } from "./snapshot-schema";
+export declare function writeMirror(projectDir: string, snapshot: TuiRuntimeSnapshot): void;
+export declare function readMirror(projectDir: string): TuiRuntimeSnapshot | null;

package/dist/features/tui-sidebar/mirror-manager.d.ts

@@ -0,0 +1,28 @@
+import type { SessionAgentResolver, SessionStatusMap, TuiBackgroundSnapshotProvider, TuiMirrorClient } from "./snapshot-builder";
+import type { TuiRuntimeSnapshot } from "./snapshot-schema";
+export type TuiStateMirrorInput = {
+    readonly client: TuiMirrorClient;
+    readonly projectDir: string;
+    readonly backgroundManager: TuiBackgroundSnapshotProvider;
+    readonly getStatuses?: () => Promise<SessionStatusMap>;
+    readonly sessionAgentResolver?: SessionAgentResolver;
+    readonly reportFlushError?: (error: Error) => void;
+};
+export declare class TuiStateMirror {
+    private readonly snapshotInput;
+    private readonly reportFlushError;
+    private heartbeatID;
+    private debounceID;
+    private pendingFlush;
+    private resolvePendingFlush;
+    private inFlightFlush;
+    private stopped;
+    constructor(input: TuiStateMirrorInput);
+    buildSnapshot(): Promise<TuiRuntimeSnapshot>;
+    flush(): Promise<void>;
+    onEvent(_event: unknown): void;
+    start(): void;
+    stop(): void;
+    private runFlush;
+    private writeSnapshotNoThrow;
+}

package/dist/features/tui-sidebar/mirror-path.d.ts

@@ -0,0 +1,3 @@
+export declare function mirrorStorageDir(): string;
+export declare function canonicalProjectDir(projectDir: string): string;
+export declare function mirrorFilePath(projectDir: string): string;

package/dist/features/tui-sidebar/render-view.d.ts

@@ -0,0 +1,15 @@
+import type { ViewNode } from "./element-helpers";
+import type { SidebarView } from "./state-types";
+type ThemeLike = {
+    readonly error?: unknown;
+    readonly text?: unknown;
+    readonly textMuted?: unknown;
+    readonly warning?: unknown;
+    readonly success?: unknown;
+    readonly info?: unknown;
+    readonly accent?: unknown;
+    readonly borderSubtle?: unknown;
+};
+export declare function buildViewNodes(view: SidebarView, theme: ThemeLike): ViewNode[];
+export declare function describeView(view: SidebarView): string;
+export {};

package/dist/features/tui-sidebar/roster-resolver.d.ts

@@ -0,0 +1,2 @@
+import type { RosterRow } from "./state-types";
+export declare function resolveRoster(directory: string): RosterRow[];

package/dist/features/tui-sidebar/snapshot-builder.d.ts

@@ -0,0 +1,28 @@
+import type { TuiRuntimeSnapshot } from "./snapshot-schema";
+import type { BackgroundTaskSnapshot } from "../background-agent/types";
+export type TuiMirrorClient = {
+    readonly session: {
+        readonly status: () => Promise<unknown>;
+        readonly messages: (input: {
+            readonly path: {
+                readonly id: string;
+            };
+        }) => Promise<unknown>;
+    };
+};
+export type SessionStatusRow = {
+    readonly type: string;
+};
+export type SessionStatusMap = Record<string, SessionStatusRow>;
+export type TuiBackgroundSnapshotProvider = {
+    readonly getTasksSnapshot: () => readonly BackgroundTaskSnapshot[];
+};
+export type SessionAgentResolver = (sessionID: string, client: TuiMirrorClient) => Promise<string | null>;
+export type BuildTuiRuntimeSnapshotInput = {
+    readonly client: TuiMirrorClient;
+    readonly projectDir: string;
+    readonly backgroundManager: TuiBackgroundSnapshotProvider;
+    readonly getStatuses?: () => Promise<SessionStatusMap>;
+    readonly sessionAgentResolver?: SessionAgentResolver;
+};
+export declare function buildTuiRuntimeSnapshot(input: BuildTuiRuntimeSnapshotInput): Promise<TuiRuntimeSnapshot>;

package/dist/features/tui-sidebar/snapshot-schema.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+export declare const TuiRuntimeSnapshotSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    projectDir: z.ZodString;
+    updatedAt: z.ZodNumber;
+    activeAgents: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            error: "error";
+            busy: "busy";
+            retry: "retry";
+            running: "running";
+            idle: "idle";
+        }>;
+    }, z.core.$strip>>;
+    jobBoard: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        status: z.ZodEnum<{
+            error: "error";
+            running: "running";
+            completed: "completed";
+            pending: "pending";
+            cancelled: "cancelled";
+            interrupt: "interrupt";
+        }>;
+        toolCalls: z.ZodNullable<z.ZodNumber>;
+        lastTool: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    loop: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodLiteral<"live">;
+        goalsDone: z.ZodNumber;
+        goalsTotal: z.ZodNumber;
+        pass: z.ZodNumber;
+        fail: z.ZodNumber;
+        pending: z.ZodNumber;
+        blocked: z.ZodNumber;
+        activeGoal: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type TuiRuntimeSnapshot = z.infer<typeof TuiRuntimeSnapshotSchema>;
+export declare function parseSnapshot(raw: unknown): TuiRuntimeSnapshot | null;

package/dist/features/tui-sidebar/state-types.d.ts

@@ -0,0 +1,72 @@
+import type { BackgroundTaskStatus } from "../background-agent/types";
+export type AgentStatus = "busy" | "idle" | "error" | "running" | "retry";
+export type AgentRow = {
+    readonly name: string;
+    readonly status: AgentStatus;
+};
+export type JobRow = {
+    readonly title: string;
+    readonly status: BackgroundTaskStatus;
+    readonly toolCalls: number | null;
+    readonly lastTool: string | null;
+};
+export type RosterRow = {
+    readonly label: string;
+    readonly model: string;
+};
+export type ConfigState = {
+    readonly kind: "valid";
+} | {
+    readonly kind: "invalid";
+    readonly messages: readonly string[];
+};
+export type RosterState = {
+    readonly kind: "empty";
+} | {
+    readonly kind: "rows";
+    readonly rows: readonly RosterRow[];
+};
+export type AgentsState = {
+    readonly kind: "none";
+} | {
+    readonly kind: "list";
+    readonly agents: readonly AgentRow[];
+};
+export type JobBoardState = {
+    readonly kind: "none";
+} | {
+    readonly kind: "list";
+    readonly jobs: readonly JobRow[];
+};
+export type LoopLive = {
+    readonly kind: "live";
+    readonly goalsDone: number;
+    readonly goalsTotal: number;
+    readonly pass: number;
+    readonly fail: number;
+    readonly pending: number;
+    readonly blocked: number;
+    readonly activeGoal: string | null;
+};
+export type LoopState = {
+    readonly kind: "none";
+} | LoopLive;
+export type ConfigBanner = {
+    readonly kind: "none";
+} | {
+    readonly kind: "invalid";
+};
+export type SidebarView = {
+    readonly kind: "active";
+    readonly loop: LoopState;
+    readonly agents: AgentsState;
+    readonly jobs: JobBoardState;
+    readonly configBanner: ConfigBanner;
+} | {
+    readonly kind: "broken";
+    readonly messages: readonly string[];
+} | {
+    readonly kind: "idle";
+    readonly roster: RosterState;
+};
+export declare function assertNever(value: never): never;

package/dist/hooks/anthropic-context-window-limit-recovery/storage/constants.d.ts

@@ -0,0 +1,3 @@
+export { PART_STORAGE } from "../../../shared";
+export declare const THINKING_TYPES: Set<string>;
+export declare const META_TYPES: Set<string>;

package/dist/hooks/anthropic-context-window-limit-recovery/storage/messages-reader.d.ts

@@ -0,0 +1,6 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { StoredMessageMeta } from "./types";
+type OpencodeClient = PluginInput["client"];
+export declare function readMessages(sessionID: string): StoredMessageMeta[];
+export declare function readMessagesFromSDK(client: OpencodeClient, sessionID: string): Promise<StoredMessageMeta[]>;
+export {};

package/dist/hooks/anthropic-context-window-limit-recovery/storage/part-content.d.ts

@@ -0,0 +1,3 @@
+import type { StoredPart } from "./types";
+export declare function hasContent(part: StoredPart): boolean;
+export declare function messageHasContent(messageID: string): boolean;

package/dist/hooks/anthropic-context-window-limit-recovery/storage/parts-reader.d.ts

@@ -0,0 +1,6 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { StoredPart } from "./types";
+type OpencodeClient = PluginInput["client"];
+export declare function readParts(messageID: string): StoredPart[];
+export declare function readPartsFromSDK(client: OpencodeClient, sessionID: string, messageID: string): Promise<StoredPart[]>;
+export {};