@kitman-sh/sdk 0.10.82 → 0.10.84

package/types/packages/core/src/transcript.d.ts

@@ -0,0 +1,250 @@
+import * as Schema from 'effect/Schema';
+import type { JsonValue } from './runtime-type';
+/** One normalized moment of an agent session (ADR-0007): never terminal bytes or a Harness's own files. */
+export declare const AgentEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"message">;
+    readonly role: Schema.Literals<readonly ["assistant", "user"]>;
+    readonly text: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"tool_call">;
+    readonly callId: Schema.String;
+    readonly name: Schema.String;
+    readonly arguments: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"tool_result">;
+    readonly callId: Schema.String;
+    readonly output: Schema.String;
+    readonly isError: Schema.optionalKey<Schema.Boolean>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"file">;
+    readonly path: Schema.String;
+    readonly change: Schema.Literals<readonly ["read", "changed"]>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"question">;
+    readonly text: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"answer">;
+    readonly callId: Schema.optionalKey<Schema.String>;
+    readonly questionId: Schema.optionalKey<Schema.String>;
+    readonly text: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"steer">;
+    readonly messageId: Schema.String;
+    readonly text: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"secret_refused">;
+    readonly reference: Schema.optionalKey<Schema.String>;
+    readonly host: Schema.String;
+    readonly reason: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"lifecycle">;
+    readonly state: Schema.Literals<readonly ["started", "resumed", "parked", "finished", "failed", "canceled"]>;
+}>]>;
+export type AgentEvent = (typeof AgentEvent)['Type'];
+/** What replaces the words of an erased person's steers and answers. */
+export declare const removedText = "removed";
+/** An AgentEvent as the Runner numbers it, from 1, for its StepAttempt. */
+export declare const TranscriptAppendEntry: Schema.Struct<{
+    readonly sequence: Schema.Int;
+    readonly event: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"message">;
+        readonly role: Schema.Literals<readonly ["assistant", "user"]>;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"tool_call">;
+        readonly callId: Schema.String;
+        readonly name: Schema.String;
+        readonly arguments: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"tool_result">;
+        readonly callId: Schema.String;
+        readonly output: Schema.String;
+        readonly isError: Schema.optionalKey<Schema.Boolean>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"file">;
+        readonly path: Schema.String;
+        readonly change: Schema.Literals<readonly ["read", "changed"]>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"question">;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"answer">;
+        readonly callId: Schema.optionalKey<Schema.String>;
+        readonly questionId: Schema.optionalKey<Schema.String>;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"steer">;
+        readonly messageId: Schema.String;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"secret_refused">;
+        readonly reference: Schema.optionalKey<Schema.String>;
+        readonly host: Schema.String;
+        readonly reason: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"lifecycle">;
+        readonly state: Schema.Literals<readonly ["started", "resumed", "parked", "finished", "failed", "canceled"]>;
+    }>]>;
+}>;
+export type TranscriptAppendEntry = (typeof TranscriptAppendEntry)['Type'];
+export declare const TranscriptEntry: Schema.Struct<{
+    readonly stepAttemptId: Schema.String;
+    readonly sequence: Schema.Int;
+    readonly event: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"message">;
+        readonly role: Schema.Literals<readonly ["assistant", "user"]>;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"tool_call">;
+        readonly callId: Schema.String;
+        readonly name: Schema.String;
+        readonly arguments: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"tool_result">;
+        readonly callId: Schema.String;
+        readonly output: Schema.String;
+        readonly isError: Schema.optionalKey<Schema.Boolean>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"file">;
+        readonly path: Schema.String;
+        readonly change: Schema.Literals<readonly ["read", "changed"]>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"question">;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"answer">;
+        readonly callId: Schema.optionalKey<Schema.String>;
+        readonly questionId: Schema.optionalKey<Schema.String>;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"steer">;
+        readonly messageId: Schema.String;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"secret_refused">;
+        readonly reference: Schema.optionalKey<Schema.String>;
+        readonly host: Schema.String;
+        readonly reason: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"lifecycle">;
+        readonly state: Schema.Literals<readonly ["started", "resumed", "parked", "finished", "failed", "canceled"]>;
+    }>]>;
+    readonly createdAt: Schema.String;
+}>;
+export type TranscriptEntry = (typeof TranscriptEntry)['Type'];
+/** A `before` past every sequence number, which reads the newest page. */
+export declare const transcriptEnd = 2147483647;
+/**
+ * A page of one StepAttempt's Transcript, oldest first; `next` is the `after` that reads the following page, and
+ * `previous` the `before` that reads the page before it.
+ */
+export declare const TranscriptPage: Schema.Struct<{
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly stepAttemptId: Schema.String;
+        readonly sequence: Schema.Int;
+        readonly event: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"message">;
+            readonly role: Schema.Literals<readonly ["assistant", "user"]>;
+            readonly text: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"tool_call">;
+            readonly callId: Schema.String;
+            readonly name: Schema.String;
+            readonly arguments: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"tool_result">;
+            readonly callId: Schema.String;
+            readonly output: Schema.String;
+            readonly isError: Schema.optionalKey<Schema.Boolean>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"file">;
+            readonly path: Schema.String;
+            readonly change: Schema.Literals<readonly ["read", "changed"]>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"question">;
+            readonly text: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"answer">;
+            readonly callId: Schema.optionalKey<Schema.String>;
+            readonly questionId: Schema.optionalKey<Schema.String>;
+            readonly text: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"steer">;
+            readonly messageId: Schema.String;
+            readonly text: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"secret_refused">;
+            readonly reference: Schema.optionalKey<Schema.String>;
+            readonly host: Schema.String;
+            readonly reason: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"lifecycle">;
+            readonly state: Schema.Literals<readonly ["started", "resumed", "parked", "finished", "failed", "canceled"]>;
+        }>]>;
+        readonly createdAt: Schema.String;
+    }>>;
+    readonly next: Schema.optionalKey<Schema.Int>;
+    readonly previous: Schema.optionalKey<Schema.Int>;
+}>;
+export type TranscriptPage = (typeof TranscriptPage)['Type'];
+/** How many days a Workspace keeps Transcripts; `null` keeps each as long as its Run. */
+export declare const TranscriptRetention: Schema.Struct<{
+    readonly days: Schema.NullOr<Schema.Int>;
+}>;
+export type TranscriptRetention = (typeof TranscriptRetention)['Type'];
+export declare const MaxTranscriptSearchLimit = 50;
+export declare const TranscriptSearchQuery: Schema.Struct<{
+    readonly q: Schema.String;
+    readonly limit: Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.FiniteFromString]>>;
+}>;
+/** A Transcript that matches, opened at its first matching entry. */
+export declare const TranscriptSearchHit: Schema.Struct<{
+    readonly runId: Schema.String;
+    readonly loop: Schema.String;
+    readonly task: Schema.optionalKey<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly key: Schema.String;
+        readonly title: Schema.String;
+    }>>;
+    readonly stepAttemptId: Schema.String;
+    /** The Run graph node the Run page opens the Step by. */
+    readonly node: Schema.optionalKey<Schema.String>;
+    readonly step: Schema.String;
+    readonly attempt: Schema.Int;
+    readonly agent: Schema.optionalKey<Schema.String>;
+    readonly ranAt: Schema.String;
+    readonly sequence: Schema.Int;
+    readonly matches: Schema.Int;
+    readonly excerpt: Schema.String;
+}>;
+export type TranscriptSearchHit = (typeof TranscriptSearchHit)['Type'];
+/** Newest Transcripts first; `total` counts every matching Transcript the person may read. */
+export declare const TranscriptSearchResult: Schema.Struct<{
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly loop: Schema.String;
+        readonly task: Schema.optionalKey<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly key: Schema.String;
+            readonly title: Schema.String;
+        }>>;
+        readonly stepAttemptId: Schema.String;
+        /** The Run graph node the Run page opens the Step by. */
+        readonly node: Schema.optionalKey<Schema.String>;
+        readonly step: Schema.String;
+        readonly attempt: Schema.Int;
+        readonly agent: Schema.optionalKey<Schema.String>;
+        readonly ranAt: Schema.String;
+        readonly sequence: Schema.Int;
+        readonly matches: Schema.Int;
+        readonly excerpt: Schema.String;
+    }>>;
+    readonly total: Schema.Int;
+}>;
+export type TranscriptSearchResult = (typeof TranscriptSearchResult)['Type'];
+/** Up to `width` characters of `text` around the first case-insensitive match of `query`, on one line. */
+export declare const transcriptExcerpt: (text: string, query: string, width?: number) => string;
+/** A redaction keeps the JSON's shape. */
+export type Redact = <T extends JsonValue>(json: T) => T;
+/** Replaces every exact occurrence of `values` in the strings of JSON, longest first so none is left in part. */
+export declare const redactSecretValues: (values: readonly (readonly [name: string, value: string])[]) => Redact;

package/types/packages/core/src/trust-panel.d.ts

@@ -0,0 +1,27 @@
+import { type ChangeRequest } from './change-request';
+import type { RunShow } from './loop';
+export type TrustStatus = 'failed' | 'partial' | 'unproved' | 'verified' | 'claims';
+/** One kind of evidence a person reads before merging, with where it came from. */
+export type TrustRow = {
+    readonly kind: 'checks' | 'criteria' | 'review' | 'forge' | 'claims';
+    readonly status: TrustStatus;
+    readonly label: string;
+    readonly word: string;
+    readonly detail: string;
+    readonly source: string;
+};
+export type TrustPanel = {
+    /** Failed when any evidence fails, partial while any is open or unproved; claims never count. */
+    readonly state: 'verified' | 'partial' | 'failed';
+    /** What the Run's Output left unsettled, unmet acceptance criteria first. */
+    readonly gaps: readonly string[];
+    /** Failing, then open, then unproved evidence, before the verified and the claims. */
+    readonly rows: readonly TrustRow[];
+};
+export type TrustPanelInput = {
+    readonly shown: Pick<RunShow, 'run' | 'steps' | 'evidence' | 'findings'>;
+    readonly acceptanceCriteria: readonly string[];
+    readonly changeRequest?: Pick<ChangeRequest, 'provider' | 'providerMetadata'> | undefined;
+};
+/** The rows of "Why you can trust this": each kind of evidence the Run has, set apart from what its agents claim. */
+export declare const trustPanel: (input: TrustPanelInput) => TrustPanel;

package/types/packages/core/src/work-unit.d.ts

@@ -264,9 +264,17 @@ export declare const MeasureEvidence: Schema.Struct<{
     readonly head: Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>;
     readonly baseAgain: Schema.optionalKey<Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>>;
 }>;
+/** Revisions to resolve to the commits they name now, running no checks. */
+export declare const ResolveSpec: Schema.Struct<{
+    readonly revisions: Schema.$Array<Schema.String>;
+}>;
+/** The commit each of a resolve's revisions names, in its order. */
+export declare const ResolvedRevisions: Schema.Struct<{
+    readonly commits: Schema.$Array<Schema.String>;
+}>;
 /**
  * Runs approved checks at a revision with no agent, and at `baseline`, the default branch's head when left out; or,
- * with `measure`, benchmarks the revision against a base.
+ * with `measure`, benchmarks the revision against a base; or, with `resolve`, resolves revisions to commits.
  */
 export declare const VerificationWorkUnit: Schema.Struct<{
     readonly kind: Schema.Literal<"verification">;
@@ -327,6 +335,9 @@ export declare const VerificationWorkUnit: Schema.Struct<{
         readonly samples: Schema.Int;
         readonly calibrate: Schema.Boolean;
     }>>;
+    readonly resolve: Schema.optionalKey<Schema.Struct<{
+        readonly revisions: Schema.$Array<Schema.String>;
+    }>>;
     /** Hosts the Run's Team and RepoBinding allow, which the check's sandbox adds. */
     readonly hosts: Schema.optionalKey<Schema.$Array<Schema.String>>;
     readonly storageOrigin: Schema.optionalKey<Schema.String>;
@@ -506,6 +517,9 @@ export declare const WorkUnit: Schema.Union<readonly [Schema.Struct<{
         readonly samples: Schema.Int;
         readonly calibrate: Schema.Boolean;
     }>>;
+    readonly resolve: Schema.optionalKey<Schema.Struct<{
+        readonly revisions: Schema.$Array<Schema.String>;
+    }>>;
     /** Hosts the Run's Team and RepoBinding allow, which the check's sandbox adds. */
     readonly hosts: Schema.optionalKey<Schema.$Array<Schema.String>>;
     readonly storageOrigin: Schema.optionalKey<Schema.String>;
@@ -686,6 +700,9 @@ export declare const WorkUnitClaimResult: Schema.Struct<{
             readonly samples: Schema.Int;
             readonly calibrate: Schema.Boolean;
         }>>;
+        readonly resolve: Schema.optionalKey<Schema.Struct<{
+            readonly revisions: Schema.$Array<Schema.String>;
+        }>>;
         /** Hosts the Run's Team and RepoBinding allow, which the check's sandbox adds. */
         readonly hosts: Schema.optionalKey<Schema.$Array<Schema.String>>;
         readonly storageOrigin: Schema.optionalKey<Schema.String>;
@@ -846,6 +863,9 @@ export declare const VerificationEvidence: Schema.Struct<{
         readonly head: Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>;
         readonly baseAgain: Schema.optionalKey<Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>>;
     }>>;
+    readonly resolved: Schema.optionalKey<Schema.Struct<{
+        readonly commits: Schema.$Array<Schema.String>;
+    }>>;
 }>;
 /** A write checkout's change since the Run began, bounded and redacted by the Runner; Kitman bounds it again. */
 export declare const BoundaryChange: Schema.Struct<{
@@ -974,6 +994,9 @@ export declare const WorkUnitOutcome: Schema.Struct<{
             readonly head: Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>;
             readonly baseAgain: Schema.optionalKey<Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>>;
         }>>;
+        readonly resolved: Schema.optionalKey<Schema.Struct<{
+            readonly commits: Schema.$Array<Schema.String>;
+        }>>;
     }>>;
     readonly boundary: Schema.optionalKey<Schema.Struct<{
         readonly kind: Schema.Literal<"change">;
@@ -1002,6 +1025,8 @@ export declare const WorkUnitOutcome: Schema.Struct<{
         /** A list was longer than `catchUpPathLimit` and was cut. */
         readonly truncated: Schema.Boolean;
     }>>;
+    /** The target's commit a base sync merged in, or tried to: what a review of the branch diffs against. */
+    readonly syncedTarget: Schema.optionalKey<Schema.String>;
     readonly harnessHold: Schema.optionalKey<Schema.Struct<{
         readonly reason: Schema.Literals<readonly ["out_of_quota", "rate_limited", "login_refused", "failed_to_start"]>;
         /** When the Harness can run again, as it reported; Kitman holds it for a while when this is missing or implausible. */
@@ -1103,6 +1128,9 @@ export declare const WorkUnitCompletion: Schema.Struct<{
                 readonly head: Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>;
                 readonly baseAgain: Schema.optionalKey<Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>>;
             }>>;
+            readonly resolved: Schema.optionalKey<Schema.Struct<{
+                readonly commits: Schema.$Array<Schema.String>;
+            }>>;
         }>>;
         readonly boundary: Schema.optionalKey<Schema.Struct<{
             readonly kind: Schema.Literal<"change">;
@@ -1131,6 +1159,8 @@ export declare const WorkUnitCompletion: Schema.Struct<{
             /** A list was longer than `catchUpPathLimit` and was cut. */
             readonly truncated: Schema.Boolean;
         }>>;
+        /** The target's commit a base sync merged in, or tried to: what a review of the branch diffs against. */
+        readonly syncedTarget: Schema.optionalKey<Schema.String>;
         readonly harnessHold: Schema.optionalKey<Schema.Struct<{
             readonly reason: Schema.Literals<readonly ["out_of_quota", "rate_limited", "login_refused", "failed_to_start"]>;
             /** When the Harness can run again, as it reported; Kitman holds it for a while when this is missing or implausible. */
@@ -1158,6 +1188,8 @@ export type VerificationEvidence = (typeof VerificationEvidence)['Type'];
 export type MeasurePlan = (typeof MeasurePlan)['Type'];
 export type MeasureSpec = (typeof MeasureSpec)['Type'];
 export type MeasureEvidence = (typeof MeasureEvidence)['Type'];
+export type ResolveSpec = (typeof ResolveSpec)['Type'];
+export type ResolvedRevisions = (typeof ResolvedRevisions)['Type'];
 export type LoopCheckout = (typeof LoopCheckout)['Type'];
 export type RunJournal = (typeof RunJournal)['Type'];
 export type WorkUnitClaimResult = (typeof WorkUnitClaimResult)['Type'];

package/types/packages/core/src/workspace.d.ts

@@ -0,0 +1,167 @@
+import * as Schema from 'effect/Schema';
+export declare const WorkspaceNotificationPreferences: Schema.Struct<{
+    readonly decisionsRequiringAttention: Schema.Boolean;
+    readonly workReadyForReview: Schema.Boolean;
+}>;
+export declare const Workspace: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly slug: Schema.String;
+    readonly plan: Schema.Union<readonly [Schema.Literal<"free">, Schema.Literal<"solo_pro">, Schema.Literal<"team_starter">]>;
+    readonly notificationPreferences: Schema.optionalKey<Schema.Struct<{
+        readonly decisionsRequiringAttention: Schema.Boolean;
+        readonly workReadyForReview: Schema.Boolean;
+    }>>;
+    readonly createdByUserId: Schema.optionalKey<Schema.String>;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+}>;
+export declare const WorkspaceCreate: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly slug: Schema.optionalKey<Schema.String>;
+}>;
+export declare const WorkspaceUpdate: Schema.Struct<{
+    readonly name: Schema.optionalKey<Schema.String>;
+    readonly slug: Schema.optionalKey<Schema.String>;
+    readonly notificationPreferences: Schema.optionalKey<Schema.Struct<{
+        readonly decisionsRequiringAttention: Schema.Boolean;
+        readonly workReadyForReview: Schema.Boolean;
+    }>>;
+}>;
+export declare const WorkspaceList: Schema.Struct<{
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly slug: Schema.String;
+        readonly plan: Schema.Union<readonly [Schema.Literal<"free">, Schema.Literal<"solo_pro">, Schema.Literal<"team_starter">]>;
+        readonly notificationPreferences: Schema.optionalKey<Schema.Struct<{
+            readonly decisionsRequiringAttention: Schema.Boolean;
+            readonly workReadyForReview: Schema.Boolean;
+        }>>;
+        readonly createdByUserId: Schema.optionalKey<Schema.String>;
+        readonly createdAt: Schema.String;
+        readonly updatedAt: Schema.String;
+    }>>;
+}>;
+/** What a Workspace has set up, each part read from the rows that exist; onboarding stores only when it was seen. */
+export declare const WorkspaceSetup: Schema.Struct<{
+    readonly forgeConnected: Schema.Boolean;
+    /** The first repository bound in the Workspace; a first Research Run reads it. */
+    readonly firstRepoBinding: Schema.NullOr<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly owner: Schema.String;
+        readonly name: Schema.String;
+    }>>;
+    readonly verificationsApproved: Schema.Boolean;
+    /** The caller's own Runner heartbeating now, the Harnesses it offers, and what each other Harness lacks. */
+    readonly machine: Schema.Struct<{
+        readonly ready: Schema.Boolean;
+        readonly harnesses: Schema.$Array<Schema.String>;
+        readonly missing: Schema.$Array<Schema.String>;
+    }>;
+    /** Someone besides the caller is a member; a pending invitation is not one. */
+    readonly secondMember: Schema.Boolean;
+    /** The caller requested a Run on a Task. */
+    readonly taskRun: Schema.Boolean;
+    readonly onboardingSeenAt: Schema.NullOr<Schema.String>;
+    /** The forges this deployment connects in one click. */
+    readonly oneClickConnect: Schema.Struct<{
+        readonly github: Schema.Boolean;
+        readonly gitlab: Schema.Boolean;
+    }>;
+}>;
+/** A minted Pairing Code and the one command that pairs a machine with it. */
+export declare const PairingCode: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly code: Schema.String;
+    readonly expiresAt: Schema.String;
+    readonly command: Schema.String;
+}>;
+/** Whether the machine has redeemed a Pairing Code yet. */
+export declare const PairingStatus: Schema.Union<readonly [Schema.Struct<{
+    readonly state: Schema.Literals<readonly ["waiting", "expired"]>;
+}>, Schema.Struct<{
+    readonly state: Schema.Literal<"redeemed">;
+    readonly redeemedAt: Schema.String;
+}>]>;
+/** The Runner a Pairing Code pairs instead of signing its person in: a new shared Runner, or an existing one re-keyed. */
+export declare const PairingTarget: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"shared">;
+    readonly name: Schema.String;
+    readonly labels: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly ownership: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"workspace">;
+        readonly teamAccess: Schema.Union<readonly [Schema.Literal<"all">, Schema.Literal<"selected">]>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"team">;
+        readonly teamId: Schema.String;
+    }>]>>;
+    readonly teamId: Schema.optionalKey<Schema.String>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"runner">;
+    readonly runnerId: Schema.String;
+}>]>;
+export declare const PairingMint: Schema.Struct<{
+    readonly target: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"shared">;
+        readonly name: Schema.String;
+        readonly labels: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly ownership: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"workspace">;
+            readonly teamAccess: Schema.Union<readonly [Schema.Literal<"all">, Schema.Literal<"selected">]>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"team">;
+            readonly teamId: Schema.String;
+        }>]>>;
+        readonly teamId: Schema.optionalKey<Schema.String>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"runner">;
+        readonly runnerId: Schema.String;
+    }>]>>;
+}>;
+/** A code with a target needs the machine's new public key. */
+export declare const PairingRedeem: Schema.Struct<{
+    readonly code: Schema.String;
+    readonly publicKey: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Boolean, Schema.$Array<Schema.String>]>>>;
+}>;
+/** The credentials `kitman login` stores, for the person and Workspace the code was minted for. */
+export declare const PairingCredentials: Schema.Struct<{
+    readonly accessToken: Schema.String;
+    readonly refreshToken: Schema.optional<Schema.String>;
+    readonly expiresIn: Schema.optional<Schema.Finite>;
+    readonly workspaceId: Schema.String;
+    readonly userId: Schema.String;
+}>;
+/** The Runner a code with a target paired, and the identity the redeemed public key now holds. */
+export declare const PairedRunner: Schema.Struct<{
+    readonly runnerId: Schema.String;
+    readonly workspaceId: Schema.String;
+    readonly agentIdentityId: Schema.String;
+    readonly credentialHostId: Schema.String;
+}>;
+export declare const PairingRedemption: Schema.Union<readonly [Schema.Struct<{
+    readonly accessToken: Schema.String;
+    readonly refreshToken: Schema.optional<Schema.String>;
+    readonly expiresIn: Schema.optional<Schema.Finite>;
+    readonly workspaceId: Schema.String;
+    readonly userId: Schema.String;
+}>, Schema.Struct<{
+    readonly runnerId: Schema.String;
+    readonly workspaceId: Schema.String;
+    readonly agentIdentityId: Schema.String;
+    readonly credentialHostId: Schema.String;
+}>]>;
+export type Workspace = (typeof Workspace)['Type'];
+export type PairingCode = (typeof PairingCode)['Type'];
+export type PairingRedeem = (typeof PairingRedeem)['Type'];
+export type PairingStatus = (typeof PairingStatus)['Type'];
+export type PairingCredentials = (typeof PairingCredentials)['Type'];
+export type PairingTarget = (typeof PairingTarget)['Type'];
+export type PairingMint = (typeof PairingMint)['Type'];
+export type PairedRunner = (typeof PairedRunner)['Type'];
+export type PairingRedemption = (typeof PairingRedemption)['Type'];
+export type WorkspaceSetup = (typeof WorkspaceSetup)['Type'];
+export type WorkspaceNotificationPreferences = (typeof WorkspaceNotificationPreferences)['Type'];
+export type WorkspaceCreate = (typeof WorkspaceCreate)['Type'];
+export type WorkspaceUpdate = (typeof WorkspaceUpdate)['Type'];
+export type WorkspaceList = (typeof WorkspaceList)['Type'];

package/types/packages/live/src/rpc/runner-client.d.ts

@@ -193,6 +193,9 @@ export declare const makeRunnerRpcClient: (options: ConnectionOptions) => Effect
                 readonly samples: number;
                 readonly calibrate: boolean;
             };
+            readonly resolve?: {
+                readonly revisions: readonly string[];
+            };
             readonly hosts?: readonly string[];
             readonly storageOrigin?: string;
         };
@@ -362,6 +365,9 @@ export declare const makeRunnerRpcClient: (options: ConnectionOptions) => Effect
                 readonly samples: number;
                 readonly calibrate: boolean;
             };
+            readonly resolve?: {
+                readonly revisions: readonly string[];
+            };
             readonly hosts?: readonly string[];
             readonly storageOrigin?: string;
         };
@@ -489,6 +495,9 @@ export declare const makeRunnerRpcClient: (options: ConnectionOptions) => Effect
                         readonly [x: string]: number;
                     }[];
                 };
+                readonly resolved?: {
+                    readonly commits: readonly string[];
+                };
             };
             readonly boundary?: {
                 readonly kind: "change";
@@ -510,6 +519,7 @@ export declare const makeRunnerRpcClient: (options: ConnectionOptions) => Effect
                 readonly changed: readonly string[];
                 readonly truncated: boolean;
             };
+            readonly syncedTarget?: string;
             readonly harnessHold?: {
                 readonly reason: "failed_to_start" | "login_refused" | "out_of_quota" | "rate_limited";
                 readonly until?: string;
@@ -1254,6 +1264,9 @@ export declare const makeProgramRpcClient: (options: ConnectionOptions) => Effec
             readonly samples: number;
             readonly calibrate: boolean;
         };
+        readonly resolve?: {
+            readonly revisions: readonly string[];
+        };
     }, options?: {
         readonly headers?: import("effect/http/Headers").Input | undefined;
         readonly context?: import("effect/Context").Context<never> | undefined;
@@ -1731,6 +1744,7 @@ export declare const makeProgramRpcClient: (options: ConnectionOptions) => Effec
         readonly runnerChecks?: readonly string[];
         readonly approved?: string;
         readonly repository?: string;
+        readonly targetBranch?: string;
         readonly conflicts?: boolean;
         readonly needsRebase?: boolean;
         readonly target?: {
@@ -1757,6 +1771,7 @@ export declare const makeProgramRpcClient: (options: ConnectionOptions) => Effec
         readonly runnerChecks?: readonly string[];
         readonly approved?: string;
         readonly repository?: string;
+        readonly targetBranch?: string;
         readonly conflicts?: boolean;
         readonly needsRebase?: boolean;
         readonly target?: {