@h-rig/contracts 0.0.6-alpha.77 → 0.0.6-alpha.79

package/dist/src/git.d.ts

@@ -0,0 +1,144 @@
+import { Schema } from "effect";
+export declare const GitStackedAction: Schema.Literals<readonly ["commit", "commit_push", "commit_push_pr"]>;
+export type GitStackedAction = typeof GitStackedAction.Type;
+export declare const GitBranch: Schema.Struct<{
+    readonly name: Schema.Trim;
+    readonly isRemote: Schema.optional<Schema.Boolean>;
+    readonly remoteName: Schema.optional<Schema.Trim>;
+    readonly current: Schema.Boolean;
+    readonly isDefault: Schema.Boolean;
+    readonly worktreePath: Schema.NullOr<Schema.Trim>;
+}>;
+export type GitBranch = typeof GitBranch.Type;
+export declare const GitStatusInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+}>;
+export type GitStatusInput = typeof GitStatusInput.Type;
+export declare const GitPullInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+}>;
+export type GitPullInput = typeof GitPullInput.Type;
+export declare const GitReadWorkingTreePatchInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly relativePath: Schema.optional<Schema.Trim>;
+}>;
+export type GitReadWorkingTreePatchInput = typeof GitReadWorkingTreePatchInput.Type;
+export declare const GitRunStackedActionInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly action: Schema.Literals<readonly ["commit", "commit_push", "commit_push_pr"]>;
+    readonly commitMessage: Schema.optional<Schema.Trim>;
+    readonly featureBranch: Schema.optional<Schema.Boolean>;
+}>;
+export type GitRunStackedActionInput = typeof GitRunStackedActionInput.Type;
+export declare const GitListBranchesInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+}>;
+export type GitListBranchesInput = typeof GitListBranchesInput.Type;
+export declare const GitCreateWorktreeInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly branch: Schema.Trim;
+    readonly newBranch: Schema.Trim;
+    readonly path: Schema.NullOr<Schema.Trim>;
+}>;
+export type GitCreateWorktreeInput = typeof GitCreateWorktreeInput.Type;
+export declare const GitRemoveWorktreeInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly path: Schema.Trim;
+    readonly force: Schema.optional<Schema.Boolean>;
+}>;
+export type GitRemoveWorktreeInput = typeof GitRemoveWorktreeInput.Type;
+export declare const GitCreateBranchInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly branch: Schema.Trim;
+}>;
+export type GitCreateBranchInput = typeof GitCreateBranchInput.Type;
+export declare const GitCheckoutInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly branch: Schema.Trim;
+}>;
+export type GitCheckoutInput = typeof GitCheckoutInput.Type;
+export declare const GitInitInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+}>;
+export type GitInitInput = typeof GitInitInput.Type;
+export declare const GitStatusResult: Schema.Struct<{
+    readonly branch: Schema.NullOr<Schema.Trim>;
+    readonly hasWorkingTreeChanges: Schema.Boolean;
+    readonly workingTree: Schema.Struct<{
+        readonly files: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.Trim;
+            readonly insertions: Schema.Int;
+            readonly deletions: Schema.Int;
+        }>>;
+        readonly insertions: Schema.Int;
+        readonly deletions: Schema.Int;
+    }>;
+    readonly hasUpstream: Schema.Boolean;
+    readonly aheadCount: Schema.Int;
+    readonly behindCount: Schema.Int;
+    readonly pr: Schema.NullOr<Schema.Struct<{
+        readonly number: Schema.Int;
+        readonly title: Schema.Trim;
+        readonly url: Schema.String;
+        readonly baseBranch: Schema.Trim;
+        readonly headBranch: Schema.Trim;
+        readonly state: Schema.Literals<readonly ["open", "closed", "merged"]>;
+    }>>;
+}>;
+export type GitStatusResult = typeof GitStatusResult.Type;
+export declare const GitListBranchesResult: Schema.Struct<{
+    readonly branches: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.Trim;
+        readonly isRemote: Schema.optional<Schema.Boolean>;
+        readonly remoteName: Schema.optional<Schema.Trim>;
+        readonly current: Schema.Boolean;
+        readonly isDefault: Schema.Boolean;
+        readonly worktreePath: Schema.NullOr<Schema.Trim>;
+    }>>;
+    readonly isRepo: Schema.Boolean;
+}>;
+export type GitListBranchesResult = typeof GitListBranchesResult.Type;
+export declare const GitCreateWorktreeResult: Schema.Struct<{
+    readonly worktree: Schema.Struct<{
+        readonly path: Schema.Trim;
+        readonly branch: Schema.Trim;
+    }>;
+}>;
+export type GitCreateWorktreeResult = typeof GitCreateWorktreeResult.Type;
+export declare const GitRunStackedActionResult: Schema.Struct<{
+    readonly action: Schema.Literals<readonly ["commit", "commit_push", "commit_push_pr"]>;
+    readonly branch: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["created", "skipped_not_requested"]>;
+        readonly name: Schema.optional<Schema.Trim>;
+    }>;
+    readonly commit: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["created", "skipped_no_changes"]>;
+        readonly commitSha: Schema.optional<Schema.Trim>;
+        readonly subject: Schema.optional<Schema.Trim>;
+    }>;
+    readonly push: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["pushed", "skipped_not_requested", "skipped_up_to_date"]>;
+        readonly branch: Schema.optional<Schema.Trim>;
+        readonly upstreamBranch: Schema.optional<Schema.Trim>;
+        readonly setUpstream: Schema.optional<Schema.Boolean>;
+    }>;
+    readonly pr: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["created", "opened_existing", "skipped_not_requested"]>;
+        readonly url: Schema.optional<Schema.String>;
+        readonly number: Schema.optional<Schema.Int>;
+        readonly baseBranch: Schema.optional<Schema.Trim>;
+        readonly headBranch: Schema.optional<Schema.Trim>;
+        readonly title: Schema.optional<Schema.Trim>;
+    }>;
+}>;
+export type GitRunStackedActionResult = typeof GitRunStackedActionResult.Type;
+export declare const GitPullResult: Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["pulled", "skipped_up_to_date"]>;
+    readonly branch: Schema.Trim;
+    readonly upstreamBranch: Schema.NullOr<Schema.Trim>;
+}>;
+export type GitPullResult = typeof GitPullResult.Type;
+export declare const GitReadWorkingTreePatchResult: Schema.Struct<{
+    readonly diff: Schema.String;
+}>;
+export type GitReadWorkingTreePatchResult = typeof GitReadWorkingTreePatchResult.Type;

package/dist/src/graph.d.ts

@@ -0,0 +1,39 @@
+import { Schema } from "effect";
+export declare const TaskStatus: Schema.Literals<readonly ["draft", "open", "ready", "queued", "running", "in_progress", "under_review", "blocked", "unknown", "completed", "failed", "cancelled", "closed"]>;
+export type TaskStatus = typeof TaskStatus.Type;
+export declare const GraphSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "GraphId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly title: Schema.Trim;
+    readonly description: Schema.NullOr<Schema.String>;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+}>;
+export type GraphSummary = typeof GraphSummary.Type;
+export declare const TaskSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "TaskId">;
+    readonly workspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+    readonly graphId: Schema.NullOr<Schema.brand<Schema.Trim, "GraphId">>;
+    readonly externalId: Schema.NullOr<Schema.Trim>;
+    readonly title: Schema.Trim;
+    readonly description: Schema.String;
+    readonly status: Schema.Literals<readonly ["draft", "open", "ready", "queued", "running", "in_progress", "under_review", "blocked", "unknown", "completed", "failed", "cancelled", "closed"]>;
+    readonly priority: Schema.NullOr<Schema.Int>;
+    readonly role: Schema.NullOr<Schema.Trim>;
+    readonly scope: Schema.$Array<Schema.Trim>;
+    readonly validationKeys: Schema.$Array<Schema.Trim>;
+    readonly sourceIssueId: Schema.optional<Schema.NullOr<Schema.Trim>>;
+    readonly dependencies: Schema.optional<Schema.$Array<Schema.Trim>>;
+    readonly parentChildDeps: Schema.optional<Schema.$Array<Schema.Trim>>;
+    readonly metadata: Schema.Unknown;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+}>;
+export type TaskSummary = typeof TaskSummary.Type;
+export declare const QueueEntry: Schema.Struct<{
+    readonly taskId: Schema.brand<Schema.Trim, "TaskId">;
+    readonly score: Schema.Int;
+    readonly unblockCount: Schema.Int;
+    readonly position: Schema.Int;
+}>;
+export type QueueEntry = typeof QueueEntry.Type;

package/dist/src/index.d.ts

@@ -0,0 +1,33 @@
+export * from "./baseSchemas";
+export * from "./workspace";
+export * from "./graph";
+export * from "./runtime";
+export * from "./run-journal";
+export * from "./conversation";
+export * from "./plugin";
+export * from "./plugin-hooks";
+export * from "./config";
+export * from "./policy";
+export * from "./validation";
+export * from "./review";
+export * from "./artifact";
+export * from "./engine";
+export * from "./rig";
+export * from "./remote";
+export * from "./ipc";
+export * from "./terminal";
+export * from "./provider";
+export * from "./providerRuntime";
+export * from "./model";
+export * from "./ws";
+export * from "./keybindings";
+export * from "./server";
+export * from "./serviceFabric";
+export * from "./git";
+export * from "./orchestration";
+export * from "./editor";
+export * from "./project";
+export * from "./task-source";
+export * from "./cli-output";
+export * from "./pi-session";
+export * from "./protocol-version";

package/dist/src/ipc.d.ts

@@ -0,0 +1,247 @@
+import type { GitCheckoutInput, GitCreateBranchInput, GitCreateWorktreeInput, GitCreateWorktreeResult, GitInitInput, GitListBranchesInput, GitListBranchesResult, GitPullInput, GitPullResult, GitReadWorkingTreePatchInput, GitReadWorkingTreePatchResult, GitRemoveWorktreeInput, GitRunStackedActionInput, GitRunStackedActionResult, GitStatusInput, GitStatusResult } from "./git";
+import type { ProjectListDirectoryInput, ProjectListDirectoryResult, ProjectSearchEntriesInput, ProjectSearchEntriesResult, ProjectReadFileInput, ProjectReadFileResult, ProjectWriteFileInput, ProjectWriteFileResult } from "./project";
+import type { ServerConfig } from "./server";
+import type { RigCreateAdhocRunInput, RigCreateTaskRunInput, RigDeleteRunInput, RigEnqueueTaskInput, RigGetRunLogsInput, RigGetRunLogsResult, RigGetTaskArtifactsResult, RigRunLogAppendedPayload, RigGetWorkspaceInput, RigGetWorkspaceResult, RigListWorkspacesResult, RigMutationResult, RigInterruptRunInput, RigResumeRunInput, RigResolveApprovalInput, RigResolveUserInputInput, RigSnapshot, RigStopRunInput, RigSubmitRunMessageInput } from "./rig";
+import type { TerminalClearInput, TerminalCloseInput, TerminalEvent, TerminalOpenInput, TerminalResizeInput, TerminalSessionSnapshot, TerminalWriteInput } from "./terminal";
+import type { ServerUpsertKeybindingInput, ServerUpsertKeybindingResult } from "./server";
+import type { ClientOrchestrationCommand, OrchestrationGetFullThreadDiffInput, OrchestrationGetFullThreadDiffResult, OrchestrationGetTurnDiffInput, OrchestrationGetTurnDiffResult, OrchestrationEvent, OrchestrationReadModel } from "./orchestration";
+import type { EngineEvent } from "./engine";
+import { EditorId } from "./editor";
+export interface ContextMenuItem<T extends string = string> {
+    id: T;
+    label: string;
+    destructive?: boolean;
+}
+export type DesktopUpdateStatus = "disabled" | "idle" | "checking" | "up-to-date" | "available" | "downloading" | "downloaded" | "error";
+export interface DesktopUpdateState {
+    enabled: boolean;
+    status: DesktopUpdateStatus;
+    currentVersion: string;
+    availableVersion: string | null;
+    downloadedVersion: string | null;
+    downloadPercent: number | null;
+    checkedAt: string | null;
+    message: string | null;
+    errorContext: "check" | "download" | "install" | null;
+    canRetry: boolean;
+}
+export interface DesktopUpdateActionResult {
+    accepted: boolean;
+    completed: boolean;
+    state: DesktopUpdateState;
+}
+export type RigProjectConfigStatus = "rig-config-ts" | "rig-config-json" | "legacy-task-config" | "missing";
+export interface DesktopRigSetupState {
+    rootPath: string | null;
+    ready: boolean;
+    wsUrl: string | null;
+    /**
+     * What kind of Rig configuration the project at `rootPath` has. The
+     * desktop main process probes the filesystem at boot and on
+     * `setRigRoot`; the renderer reads this to decide whether to show an
+     * onboarding banner ("Run `rig init`") or the normal dashboard.
+     */
+    configStatus: RigProjectConfigStatus;
+}
+export interface RigConfigWriteResult {
+    ok: boolean;
+    /** Absolute path to the file that was written. */
+    configPath: string;
+    /** Filesystem error message when `ok === false`. */
+    error?: string;
+    /** Updated setup state — `configStatus` reflects the post-write probe. */
+    setup: DesktopRigSetupState;
+}
+export interface RigConfigReadResult {
+    /** The raw rig.config.{ts,json} source, or null if none exists. */
+    source: string | null;
+    /** Which file was read; null when no config exists. */
+    configPath: string | null;
+}
+export interface ProjectGitRemoteInfo {
+    /** The raw origin URL, e.g. `git@github.com:humanity-org/humanwork.git`. */
+    url: string;
+    /** Parsed host, e.g. `github.com`. */
+    host: string | null;
+    /** Parsed owner/org, e.g. `humanity-org`. */
+    owner: string | null;
+    /** Parsed repository name (no `.git` suffix), e.g. `humanwork`. */
+    repo: string | null;
+}
+export interface DesktopBridge {
+    getWsUrl: () => string | null;
+    getRigSetup: () => Promise<DesktopRigSetupState>;
+    setRigRoot: (rootPath: string) => Promise<DesktopRigSetupState>;
+    /**
+     * Read the raw rig.config.{ts,json} from the project at `rootPath`.
+     * Returns `{ source: null }` when no config exists. Used by the in-app
+     * Settings screen to populate the form from the existing file.
+     */
+    readRigConfigRaw: (rootPath: string) => Promise<RigConfigReadResult>;
+    /**
+     * Write rig.config.ts to the project root atomically (temp-file + rename).
+     * Refreshes the cached setup state and returns it post-write so callers
+     * can route past the setup gate. Used by both the in-app setup wizard
+     * and the Settings → Project section.
+     */
+    writeRigConfig: (rootPath: string, source: string) => Promise<RigConfigWriteResult>;
+    /**
+     * Inspect the project's git origin to auto-fill setup wizard fields.
+     * Runs `git -C <rootPath> remote get-url origin` and parses owner/repo.
+     * Returns null when the project isn't a git repo, has no origin, or the
+     * URL doesn't match a recognized GitHub-style pattern. The wizard uses
+     * this to prefill the GitHub owner/repo step instead of making the
+     * operator type values that are already in `.git/config`.
+     */
+    getProjectGitRemote: (rootPath: string) => Promise<ProjectGitRemoteInfo | null>;
+    pickFolder: () => Promise<string | null>;
+    confirm: (message: string) => Promise<boolean>;
+    showContextMenu: <T extends string>(items: readonly ContextMenuItem<T>[], position?: {
+        x: number;
+        y: number;
+    }) => Promise<T | null>;
+    openExternal: (url: string) => Promise<boolean>;
+    onMenuAction: (listener: (action: string) => void) => () => void;
+    getUpdateState: () => Promise<DesktopUpdateState>;
+    downloadUpdate: () => Promise<DesktopUpdateActionResult>;
+    installUpdate: () => Promise<DesktopUpdateActionResult>;
+    onUpdateState: (listener: (state: DesktopUpdateState) => void) => () => void;
+}
+export interface NativeApi {
+    dialogs: {
+        pickFolder: () => Promise<string | null>;
+        confirm: (message: string) => Promise<boolean>;
+    };
+    terminal: {
+        open: (input: TerminalOpenInput) => Promise<TerminalSessionSnapshot>;
+        write: (input: TerminalWriteInput) => Promise<void>;
+        resize: (input: TerminalResizeInput) => Promise<void>;
+        clear: (input: TerminalClearInput) => Promise<void>;
+        restart: (input: TerminalOpenInput) => Promise<TerminalSessionSnapshot>;
+        close: (input: TerminalCloseInput) => Promise<void>;
+        onEvent: (callback: (event: TerminalEvent) => void) => () => void;
+    };
+    projects: {
+        listDirectory: (input: ProjectListDirectoryInput) => Promise<ProjectListDirectoryResult>;
+        searchEntries: (input: ProjectSearchEntriesInput) => Promise<ProjectSearchEntriesResult>;
+        readFile: (input: ProjectReadFileInput) => Promise<ProjectReadFileResult>;
+        writeFile: (input: ProjectWriteFileInput) => Promise<ProjectWriteFileResult>;
+    };
+    shell: {
+        openInEditor: (cwd: string, editor: EditorId) => Promise<void>;
+        openExternal: (url: string) => Promise<void>;
+    };
+    git: {
+        listBranches: (input: GitListBranchesInput) => Promise<GitListBranchesResult>;
+        createWorktree: (input: GitCreateWorktreeInput) => Promise<GitCreateWorktreeResult>;
+        removeWorktree: (input: GitRemoveWorktreeInput) => Promise<void>;
+        createBranch: (input: GitCreateBranchInput) => Promise<void>;
+        checkout: (input: GitCheckoutInput) => Promise<void>;
+        init: (input: GitInitInput) => Promise<void>;
+        pull: (input: GitPullInput) => Promise<GitPullResult>;
+        status: (input: GitStatusInput) => Promise<GitStatusResult>;
+        readWorkingTreePatch: (input: GitReadWorkingTreePatchInput) => Promise<GitReadWorkingTreePatchResult>;
+        runStackedAction: (input: GitRunStackedActionInput) => Promise<GitRunStackedActionResult>;
+    };
+    contextMenu: {
+        show: <T extends string>(items: readonly ContextMenuItem<T>[], position?: {
+            x: number;
+            y: number;
+        }) => Promise<T | null>;
+    };
+    server: {
+        getConfig: () => Promise<ServerConfig>;
+        upsertKeybinding: (input: ServerUpsertKeybindingInput) => Promise<ServerUpsertKeybindingResult>;
+    };
+    rig: {
+        getSnapshot: () => Promise<RigSnapshot>;
+        listWorkspaces: () => Promise<RigListWorkspacesResult>;
+        getWorkspace: (input: RigGetWorkspaceInput) => Promise<RigGetWorkspaceResult>;
+        getRunLogs: (input: RigGetRunLogsInput) => Promise<RigGetRunLogsResult>;
+        replayEvents: (fromSequenceExclusive: number) => Promise<EngineEvent[]>;
+        createAdhocRun: (input: RigCreateAdhocRunInput) => Promise<RigMutationResult>;
+        createTaskRun: (input: RigCreateTaskRunInput) => Promise<RigMutationResult>;
+        deleteRun: (input: RigDeleteRunInput) => Promise<RigMutationResult>;
+        enqueueTask: (input: RigEnqueueTaskInput) => Promise<RigMutationResult>;
+        resumeRun: (input: RigResumeRunInput) => Promise<RigMutationResult>;
+        submitRunMessage: (input: RigSubmitRunMessageInput) => Promise<RigMutationResult>;
+        interruptRun: (input: RigInterruptRunInput) => Promise<RigMutationResult>;
+        stopRun: (input: RigStopRunInput) => Promise<RigMutationResult>;
+        resolveApproval: (input: RigResolveApprovalInput) => Promise<RigMutationResult>;
+        resolveUserInput: (input: RigResolveUserInputInput) => Promise<RigMutationResult>;
+        getTaskArtifacts: (taskId: string) => Promise<RigGetTaskArtifactsResult>;
+        onEvent: (callback: (event: EngineEvent) => void) => () => void;
+        onRunLogAppended: (callback: (payload: RigRunLogAppendedPayload) => void) => () => void;
+    };
+    orchestration: {
+        getSnapshot: () => Promise<OrchestrationReadModel>;
+        dispatchCommand: (command: ClientOrchestrationCommand) => Promise<{
+            sequence: number;
+        }>;
+        getTurnDiff: (input: OrchestrationGetTurnDiffInput) => Promise<OrchestrationGetTurnDiffResult>;
+        getFullThreadDiff: (input: OrchestrationGetFullThreadDiffInput) => Promise<OrchestrationGetFullThreadDiffResult>;
+        replayEvents: (fromSequenceExclusive: number) => Promise<OrchestrationEvent[]>;
+        onDomainEvent: (callback: (event: OrchestrationEvent) => void) => () => void;
+    };
+    remote: {
+        testEndpoint: (input: {
+            host: string;
+            port: number;
+            token?: string;
+        }) => Promise<{
+            latencyMs: number;
+        }>;
+        listEndpoints: () => Promise<unknown[]>;
+        registerEndpoint: (input: {
+            alias: string;
+            host: string;
+            port: number;
+            token?: string;
+            autoConnect?: boolean;
+        }) => Promise<unknown>;
+        removeEndpoint: (input: {
+            endpointId: string;
+        }) => Promise<void>;
+        connect: (input: {
+            endpointId: string;
+        }) => Promise<void>;
+        disconnect: (input: {
+            endpointId: string;
+        }) => Promise<void>;
+        createRunForTask: (input: {
+            endpointId: string;
+            taskId: string;
+            runId: string;
+            workspaceId: string;
+            runtimeMode?: string;
+            interactionMode?: string;
+        }) => Promise<{
+            ok: boolean;
+        }>;
+        terminalOpen: (input: {
+            endpointId: string;
+            threadId: string;
+            terminalId: string;
+            cwd?: string;
+            env?: Record<string, string>;
+        }) => Promise<unknown>;
+        terminalWrite: (input: {
+            endpointId: string;
+            threadId: string;
+            terminalId: string;
+            data: string;
+        }) => Promise<void>;
+        terminalResize: (input: {
+            endpointId: string;
+            threadId: string;
+            terminalId: string;
+            cols: number;
+            rows: number;
+        }) => Promise<void>;
+        terminalClose: (input: {
+            endpointId: string;
+            threadId: string;
+            terminalId: string;
+        }) => Promise<void>;
+    };
+}

package/dist/src/keybindings.d.ts

@@ -0,0 +1,71 @@
+import { Schema } from "effect";
+export declare const MAX_KEYBINDING_VALUE_LENGTH = 64;
+export declare const MAX_WHEN_EXPRESSION_DEPTH = 64;
+export declare const MAX_SCRIPT_ID_LENGTH = 24;
+export declare const MAX_KEYBINDINGS_COUNT = 256;
+export declare const SCRIPT_RUN_COMMAND_PATTERN: Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>;
+export declare const KeybindingCommand: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+export type KeybindingCommand = typeof KeybindingCommand.Type;
+export declare const KeybindingRule: Schema.Struct<{
+    readonly key: Schema.Trim;
+    readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+    readonly when: Schema.optional<Schema.Trim>;
+}>;
+export type KeybindingRule = typeof KeybindingRule.Type;
+export declare const KeybindingsConfig: Schema.$Array<Schema.Struct<{
+    readonly key: Schema.Trim;
+    readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+    readonly when: Schema.optional<Schema.Trim>;
+}>>;
+export type KeybindingsConfig = typeof KeybindingsConfig.Type;
+export declare const KeybindingShortcut: Schema.Struct<{
+    readonly key: Schema.Trim;
+    readonly metaKey: Schema.Boolean;
+    readonly ctrlKey: Schema.Boolean;
+    readonly shiftKey: Schema.Boolean;
+    readonly altKey: Schema.Boolean;
+    readonly modKey: Schema.Boolean;
+}>;
+export type KeybindingShortcut = typeof KeybindingShortcut.Type;
+export declare const KeybindingWhenNode: Schema.Schema<KeybindingWhenNode>;
+export type KeybindingWhenNode = {
+    type: "identifier";
+    name: string;
+} | {
+    type: "not";
+    node: KeybindingWhenNode;
+} | {
+    type: "and";
+    left: KeybindingWhenNode;
+    right: KeybindingWhenNode;
+} | {
+    type: "or";
+    left: KeybindingWhenNode;
+    right: KeybindingWhenNode;
+};
+export declare const ResolvedKeybindingRule: Schema.Struct<{
+    readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+    readonly shortcut: Schema.Struct<{
+        readonly key: Schema.Trim;
+        readonly metaKey: Schema.Boolean;
+        readonly ctrlKey: Schema.Boolean;
+        readonly shiftKey: Schema.Boolean;
+        readonly altKey: Schema.Boolean;
+        readonly modKey: Schema.Boolean;
+    }>;
+    readonly whenAst: Schema.optional<Schema.Schema<KeybindingWhenNode>>;
+}>;
+export type ResolvedKeybindingRule = typeof ResolvedKeybindingRule.Type;
+export declare const ResolvedKeybindingsConfig: Schema.$Array<Schema.Struct<{
+    readonly command: Schema.Union<readonly [Schema.Literals<readonly ["terminal.toggle", "terminal.split", "terminal.new", "terminal.close", "diff.toggle", "chat.new", "chat.newLocal", "editor.openFavorite"]>, Schema.TemplateLiteral<readonly [Schema.Literal<"script.">, Schema.String, Schema.Literal<".run">]>]>;
+    readonly shortcut: Schema.Struct<{
+        readonly key: Schema.Trim;
+        readonly metaKey: Schema.Boolean;
+        readonly ctrlKey: Schema.Boolean;
+        readonly shiftKey: Schema.Boolean;
+        readonly altKey: Schema.Boolean;
+        readonly modKey: Schema.Boolean;
+    }>;
+    readonly whenAst: Schema.optional<Schema.Schema<KeybindingWhenNode>>;
+}>>;
+export type ResolvedKeybindingsConfig = typeof ResolvedKeybindingsConfig.Type;

package/dist/src/model.d.ts

@@ -0,0 +1,77 @@
+import { Schema } from "effect";
+import { ProviderKind } from "./orchestration";
+export declare const CODEX_REASONING_EFFORT_OPTIONS: readonly ["xhigh", "high", "medium", "low"];
+export type CodexReasoningEffort = (typeof CODEX_REASONING_EFFORT_OPTIONS)[number];
+export declare const CodexModelOptions: Schema.Struct<{
+    readonly reasoningEffort: Schema.optional<Schema.Literals<readonly ["xhigh", "high", "medium", "low"]>>;
+    readonly fastMode: Schema.optional<Schema.Boolean>;
+}>;
+export type CodexModelOptions = typeof CodexModelOptions.Type;
+export declare const ClaudeModelOptions: Schema.Struct<{}>;
+export type ClaudeModelOptions = typeof ClaudeModelOptions.Type;
+export declare const ProviderModelOptions: Schema.Struct<{
+    readonly codex: Schema.optional<Schema.Struct<{
+        readonly reasoningEffort: Schema.optional<Schema.Literals<readonly ["xhigh", "high", "medium", "low"]>>;
+        readonly fastMode: Schema.optional<Schema.Boolean>;
+    }>>;
+    readonly claude: Schema.optional<Schema.Struct<{}>>;
+}>;
+export type ProviderModelOptions = typeof ProviderModelOptions.Type;
+export declare const MODEL_OPTIONS_BY_PROVIDER: {
+    readonly codex: readonly [{
+        readonly slug: "gpt-5.4";
+        readonly name: "GPT-5.4";
+    }, {
+        readonly slug: "gpt-5.3-codex";
+        readonly name: "GPT-5.3 Codex";
+    }, {
+        readonly slug: "gpt-5.3-codex-spark";
+        readonly name: "GPT-5.3 Codex Spark";
+    }, {
+        readonly slug: "gpt-5.2-codex";
+        readonly name: "GPT-5.2 Codex";
+    }, {
+        readonly slug: "gpt-5.2";
+        readonly name: "GPT-5.2";
+    }];
+    readonly claude: readonly [{
+        readonly slug: "claude-sonnet-4-6";
+        readonly name: "Claude Sonnet 4.6";
+    }, {
+        readonly slug: "claude-opus-4-1";
+        readonly name: "Claude Opus 4.1";
+    }, {
+        readonly slug: "claude-3-7-sonnet-latest";
+        readonly name: "Claude 3.7 Sonnet";
+    }];
+};
+export type ModelOptionsByProvider = typeof MODEL_OPTIONS_BY_PROVIDER;
+type BuiltInModelSlug = ModelOptionsByProvider[ProviderKind][number]["slug"];
+export type ModelSlug = BuiltInModelSlug | (string & {});
+export declare const DEFAULT_MODEL_BY_PROVIDER: {
+    readonly codex: "gpt-5.4";
+    readonly claude: "claude-sonnet-4-6";
+};
+export declare const MODEL_SLUG_ALIASES_BY_PROVIDER: {
+    readonly codex: {
+        readonly "5.4": "gpt-5.4";
+        readonly "5.3": "gpt-5.3-codex";
+        readonly "gpt-5.3": "gpt-5.3-codex";
+        readonly "5.3-spark": "gpt-5.3-codex-spark";
+        readonly "gpt-5.3-spark": "gpt-5.3-codex-spark";
+    };
+    readonly claude: {
+        readonly sonnet: "claude-sonnet-4-6";
+        readonly opus: "claude-opus-4-1";
+        readonly "3.7-sonnet": "claude-3-7-sonnet-latest";
+    };
+};
+export declare const REASONING_EFFORT_OPTIONS_BY_PROVIDER: {
+    readonly codex: readonly ["xhigh", "high", "medium", "low"];
+    readonly claude: readonly [];
+};
+export declare const DEFAULT_REASONING_EFFORT_BY_PROVIDER: {
+    readonly codex: "high";
+    readonly claude: null;
+};
+export {};