@kitman-sh/sdk 0.9.0 → 0.10.53

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

@@ -33,6 +33,16 @@ export declare const WorkUnitLeaseInput: Schema.Struct<{
     readonly capacitySlot: Schema.String;
 }>;
 export declare const LoopCheckout: Schema.Union<readonly [Schema.Literal<"none">, Schema.Literal<"read">, Schema.Literal<"write">]>;
+/**
+ * Whose a Step's Secret is, which names its reference, the hosts that reference may be swapped for its value at, and
+ * which value it is, so replacing the Secret revokes it.
+ */
+export declare const SecretDestination: Schema.Struct<{
+    readonly scope: Schema.Union<readonly [Schema.Literal<"workspace">, Schema.Literal<"team">]>;
+    readonly hosts: Schema.$Array<Schema.String>;
+    readonly version: Schema.String;
+}>;
+export type SecretDestination = (typeof SecretDestination)['Type'];
 /** A program's agent Step: one StepAttempt, which any eligible Runner may run from the Step's base revision. */
 export declare const AgentStepWorkUnit: Schema.Struct<{
     readonly kind: Schema.Literal<"agent_step">;
@@ -51,6 +61,8 @@ export declare const AgentStepWorkUnit: Schema.Struct<{
         readonly leaseExpiresAt: Schema.String;
         readonly lastHeartbeatAt: Schema.String;
     }>;
+    /** When the Step's `timeout` runs out, across its attempts; absent when it declares none. */
+    readonly deadlineAt: Schema.optionalKey<Schema.String>;
     readonly brief: Schema.Struct<{
         readonly stepAttemptId: Schema.String;
         readonly harness: Schema.String;
@@ -63,11 +75,14 @@ export declare const AgentStepWorkUnit: Schema.Struct<{
             readonly contentMarkdown: Schema.String;
         }>>;
         readonly outputSchema: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-        readonly skills: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly kits: Schema.optionalKey<Schema.$Array<Schema.Struct<{
             readonly name: Schema.String;
-            readonly files: Schema.$Record<Schema.String, Schema.String>;
+            readonly version: Schema.String;
+            readonly setupDigest: Schema.String;
         }>>>;
         readonly toolless: Schema.optionalKey<Schema.Literal<true>>;
+        readonly tools: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["web", "subagents", "artifacts", "browser"]>>>;
+        readonly listedSkills: Schema.optionalKey<Schema.$Array<Schema.String>>;
     }>;
     readonly stepCredential: Schema.String;
     readonly checkout: Schema.Union<readonly [Schema.Literal<"none">, Schema.Literal<"read">, Schema.Literal<"write">]>;
@@ -91,12 +106,26 @@ export declare const AgentStepWorkUnit: Schema.Struct<{
     readonly network: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
         readonly hosts: Schema.$Array<Schema.String>;
     }>, Schema.Literal<"open">]>>;
+    /** Hosts the Run's Team and RepoBinding allow; the Runner adds them unless the Agent opens the network. */
+    readonly hosts: Schema.optionalKey<Schema.$Array<Schema.String>>;
     /** The SandboxBackend the Agent requires. */
     readonly sandbox: Schema.optionalKey<Schema.Literal<"docker">>;
     /** The values of the Secrets the Step names, for its sandbox's environment. */
     readonly secrets: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    /** For each of `secrets`, whose it is and where its reference may be swapped for its value. */
+    readonly secretDestinations: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+        readonly scope: Schema.Union<readonly [Schema.Literal<"workspace">, Schema.Literal<"team">]>;
+        readonly hosts: Schema.$Array<Schema.String>;
+        readonly version: Schema.String;
+    }>>>;
     /** Where the Run's first Step started; a boundary's change is the Run's whole change from there. */
     readonly runBaseRevision: Schema.optionalKey<Schema.String>;
+    /** A write checkout's target branch, whose head the Runner merges in before the agent starts. */
+    readonly mergeTarget: Schema.optionalKey<Schema.String>;
+    /** What a Step that ran before is told when it carries on: its Question's answer and steers sent while it was away. */
+    readonly resumeNotes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    /** The last Transcript entry the attempt holds; a Step that ran before writes after it. */
+    readonly transcriptSequence: Schema.optionalKey<Schema.Int>;
     readonly storageOrigin: Schema.optionalKey<Schema.String>;
 }>;
 /** Encoded Exits by Activity `name/attempt` and by deferred name. */
@@ -139,7 +168,7 @@ export declare const OrchestrationWorkUnit: Schema.Struct<{
         readonly credential: Schema.String;
     }>;
 }>;
-/** What a Package's process reads on stdin; its Loop id and credential come in its environment instead. */
+/** What a Kit's process reads on stdin; its Loop id and credential come in its environment instead. */
 export declare const ProgramWorkUnit: Schema.Struct<{
     readonly kind: Schema.Literal<"orchestration">;
     readonly id: Schema.String;
@@ -169,12 +198,76 @@ export declare const ProgramWorkUnit: Schema.Struct<{
 }>;
 export type ProgramWorkUnit = (typeof ProgramWorkUnit)['Type'];
 /** An approved verification as Kitman holds it for a RepoBinding; never read from the branch. */
+/** What a verification is called, wherever one is named: approved, or suggested by an agent's Output. */
+export declare const CheckName: Schema.String;
 export declare const ApprovedCheck: Schema.Struct<{
     readonly name: Schema.String;
     readonly command: Schema.String;
     readonly workingDirectory: Schema.optionalKey<Schema.String>;
+    /** An agent suggested it for a repository with none approved; a Run sets it, never an approval. */
+    readonly suggested: Schema.optionalKey<Schema.Boolean>;
+}>;
+/** A check as a repository approves it and a verification runs it. */
+export declare const RepositoryCheck: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly command: Schema.String;
+    readonly workingDirectory: Schema.optionalKey<Schema.String>;
+    /** An agent suggested it for a repository with none approved; a Run sets it, never an approval. */
+    readonly suggested: Schema.optionalKey<Schema.Boolean>;
+    /**
+     * The repository's pipeline, for a forge that runs none: Shepherd runs it on a ChangeRequest's head and reports the
+     * result. A `verify` that names no checks leaves it out.
+     */
+    readonly pipeline: Schema.optionalKey<Schema.Boolean>;
+}>;
+/**
+ * How to benchmark a revision: `command` is one sample, run after `prepare` and `warmup` discarded samples. Each
+ * sample reports `wall_ms` and `cpu_ms`, and the numbers in a JSON object its last output line prints. One metric is
+ * primary; the others are guardrails. A `lowVariance` metric (instructions, allocations, queries) is what a noisy
+ * machine should be judged on instead.
+ */
+export declare const MeasurePlan: Schema.Struct<{
+    readonly command: Schema.String;
+    readonly prepare: Schema.optionalKey<Schema.String>;
+    readonly workingDirectory: Schema.optionalKey<Schema.String>;
+    readonly warmup: Schema.optionalKey<Schema.Int>;
+    readonly metrics: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly direction: Schema.Literals<readonly ["lower", "higher"]>;
+        readonly role: Schema.Literals<readonly ["primary", "guardrail"]>;
+        readonly lowVariance: Schema.optionalKey<Schema.Boolean>;
+    }>>;
+}>;
+/** A benchmark of the verification's revision against `base`, with `base` against itself first when `calibrate`. */
+export declare const MeasureSpec: Schema.Struct<{
+    readonly base: Schema.String;
+    readonly plan: Schema.Struct<{
+        readonly command: Schema.String;
+        readonly prepare: Schema.optionalKey<Schema.String>;
+        readonly workingDirectory: Schema.optionalKey<Schema.String>;
+        readonly warmup: Schema.optionalKey<Schema.Int>;
+        readonly metrics: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly direction: Schema.Literals<readonly ["lower", "higher"]>;
+            readonly role: Schema.Literals<readonly ["primary", "guardrail"]>;
+            readonly lowVariance: Schema.optionalKey<Schema.Boolean>;
+        }>>;
+    }>;
+    readonly samples: Schema.Int;
+    readonly calibrate: Schema.Boolean;
+}>;
+/** One sample's numbers by metric name. */
+export declare const MeasureSample: Schema.$Record<Schema.String, Schema.Finite>;
+/** The samples of a measurement, taken interleaved; `baseAgain` is the base measured against itself. */
+export declare const MeasureEvidence: Schema.Struct<{
+    readonly base: Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>;
+    readonly head: Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>;
+    readonly baseAgain: Schema.optionalKey<Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>>;
 }>;
-/** Runs approved checks at a revision with no agent, and at the default branch's head as the baseline. */
+/**
+ * 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.
+ */
 export declare const VerificationWorkUnit: Schema.Struct<{
     readonly kind: Schema.Literal<"verification">;
     readonly id: Schema.String;
@@ -204,11 +297,38 @@ export declare const VerificationWorkUnit: Schema.Struct<{
         readonly expectedCommitSha: Schema.optionalKey<Schema.String>;
     }>;
     readonly revision: Schema.String;
+    readonly baseline: Schema.optionalKey<Schema.String>;
     readonly checks: Schema.$Array<Schema.Struct<{
         readonly name: Schema.String;
         readonly command: Schema.String;
         readonly workingDirectory: Schema.optionalKey<Schema.String>;
+        /** An agent suggested it for a repository with none approved; a Run sets it, never an approval. */
+        readonly suggested: Schema.optionalKey<Schema.Boolean>;
+        /**
+         * The repository's pipeline, for a forge that runs none: Shepherd runs it on a ChangeRequest's head and reports the
+         * result. A `verify` that names no checks leaves it out.
+         */
+        readonly pipeline: Schema.optionalKey<Schema.Boolean>;
+    }>>;
+    readonly measure: Schema.optionalKey<Schema.Struct<{
+        readonly base: Schema.String;
+        readonly plan: Schema.Struct<{
+            readonly command: Schema.String;
+            readonly prepare: Schema.optionalKey<Schema.String>;
+            readonly workingDirectory: Schema.optionalKey<Schema.String>;
+            readonly warmup: Schema.optionalKey<Schema.Int>;
+            readonly metrics: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly direction: Schema.Literals<readonly ["lower", "higher"]>;
+                readonly role: Schema.Literals<readonly ["primary", "guardrail"]>;
+                readonly lowVariance: Schema.optionalKey<Schema.Boolean>;
+            }>>;
+        }>;
+        readonly samples: Schema.Int;
+        readonly calibrate: Schema.Boolean;
     }>>;
+    /** 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>;
 }>;
 export declare const WorkUnit: Schema.Union<readonly [Schema.Struct<{
@@ -261,6 +381,8 @@ export declare const WorkUnit: Schema.Union<readonly [Schema.Struct<{
         readonly leaseExpiresAt: Schema.String;
         readonly lastHeartbeatAt: Schema.String;
     }>;
+    /** When the Step's `timeout` runs out, across its attempts; absent when it declares none. */
+    readonly deadlineAt: Schema.optionalKey<Schema.String>;
     readonly brief: Schema.Struct<{
         readonly stepAttemptId: Schema.String;
         readonly harness: Schema.String;
@@ -273,11 +395,14 @@ export declare const WorkUnit: Schema.Union<readonly [Schema.Struct<{
             readonly contentMarkdown: Schema.String;
         }>>;
         readonly outputSchema: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-        readonly skills: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly kits: Schema.optionalKey<Schema.$Array<Schema.Struct<{
             readonly name: Schema.String;
-            readonly files: Schema.$Record<Schema.String, Schema.String>;
+            readonly version: Schema.String;
+            readonly setupDigest: Schema.String;
         }>>>;
         readonly toolless: Schema.optionalKey<Schema.Literal<true>>;
+        readonly tools: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["web", "subagents", "artifacts", "browser"]>>>;
+        readonly listedSkills: Schema.optionalKey<Schema.$Array<Schema.String>>;
     }>;
     readonly stepCredential: Schema.String;
     readonly checkout: Schema.Union<readonly [Schema.Literal<"none">, Schema.Literal<"read">, Schema.Literal<"write">]>;
@@ -301,12 +426,26 @@ export declare const WorkUnit: Schema.Union<readonly [Schema.Struct<{
     readonly network: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
         readonly hosts: Schema.$Array<Schema.String>;
     }>, Schema.Literal<"open">]>>;
+    /** Hosts the Run's Team and RepoBinding allow; the Runner adds them unless the Agent opens the network. */
+    readonly hosts: Schema.optionalKey<Schema.$Array<Schema.String>>;
     /** The SandboxBackend the Agent requires. */
     readonly sandbox: Schema.optionalKey<Schema.Literal<"docker">>;
     /** The values of the Secrets the Step names, for its sandbox's environment. */
     readonly secrets: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    /** For each of `secrets`, whose it is and where its reference may be swapped for its value. */
+    readonly secretDestinations: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+        readonly scope: Schema.Union<readonly [Schema.Literal<"workspace">, Schema.Literal<"team">]>;
+        readonly hosts: Schema.$Array<Schema.String>;
+        readonly version: Schema.String;
+    }>>>;
     /** Where the Run's first Step started; a boundary's change is the Run's whole change from there. */
     readonly runBaseRevision: Schema.optionalKey<Schema.String>;
+    /** A write checkout's target branch, whose head the Runner merges in before the agent starts. */
+    readonly mergeTarget: Schema.optionalKey<Schema.String>;
+    /** What a Step that ran before is told when it carries on: its Question's answer and steers sent while it was away. */
+    readonly resumeNotes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    /** The last Transcript entry the attempt holds; a Step that ran before writes after it. */
+    readonly transcriptSequence: Schema.optionalKey<Schema.Int>;
     readonly storageOrigin: Schema.optionalKey<Schema.String>;
 }>, Schema.Struct<{
     readonly kind: Schema.Literal<"verification">;
@@ -337,11 +476,38 @@ export declare const WorkUnit: Schema.Union<readonly [Schema.Struct<{
         readonly expectedCommitSha: Schema.optionalKey<Schema.String>;
     }>;
     readonly revision: Schema.String;
+    readonly baseline: Schema.optionalKey<Schema.String>;
     readonly checks: Schema.$Array<Schema.Struct<{
         readonly name: Schema.String;
         readonly command: Schema.String;
         readonly workingDirectory: Schema.optionalKey<Schema.String>;
+        /** An agent suggested it for a repository with none approved; a Run sets it, never an approval. */
+        readonly suggested: Schema.optionalKey<Schema.Boolean>;
+        /**
+         * The repository's pipeline, for a forge that runs none: Shepherd runs it on a ChangeRequest's head and reports the
+         * result. A `verify` that names no checks leaves it out.
+         */
+        readonly pipeline: Schema.optionalKey<Schema.Boolean>;
     }>>;
+    readonly measure: Schema.optionalKey<Schema.Struct<{
+        readonly base: Schema.String;
+        readonly plan: Schema.Struct<{
+            readonly command: Schema.String;
+            readonly prepare: Schema.optionalKey<Schema.String>;
+            readonly workingDirectory: Schema.optionalKey<Schema.String>;
+            readonly warmup: Schema.optionalKey<Schema.Int>;
+            readonly metrics: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly direction: Schema.Literals<readonly ["lower", "higher"]>;
+                readonly role: Schema.Literals<readonly ["primary", "guardrail"]>;
+                readonly lowVariance: Schema.optionalKey<Schema.Boolean>;
+            }>>;
+        }>;
+        readonly samples: Schema.Int;
+        readonly calibrate: Schema.Boolean;
+    }>>;
+    /** 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>;
 }>]>;
 export declare const WorkUnitClaimResult: Schema.Struct<{
@@ -395,6 +561,8 @@ export declare const WorkUnitClaimResult: Schema.Struct<{
             readonly leaseExpiresAt: Schema.String;
             readonly lastHeartbeatAt: Schema.String;
         }>;
+        /** When the Step's `timeout` runs out, across its attempts; absent when it declares none. */
+        readonly deadlineAt: Schema.optionalKey<Schema.String>;
         readonly brief: Schema.Struct<{
             readonly stepAttemptId: Schema.String;
             readonly harness: Schema.String;
@@ -407,11 +575,14 @@ export declare const WorkUnitClaimResult: Schema.Struct<{
                 readonly contentMarkdown: Schema.String;
             }>>;
             readonly outputSchema: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-            readonly skills: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly kits: Schema.optionalKey<Schema.$Array<Schema.Struct<{
                 readonly name: Schema.String;
-                readonly files: Schema.$Record<Schema.String, Schema.String>;
+                readonly version: Schema.String;
+                readonly setupDigest: Schema.String;
             }>>>;
             readonly toolless: Schema.optionalKey<Schema.Literal<true>>;
+            readonly tools: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["web", "subagents", "artifacts", "browser"]>>>;
+            readonly listedSkills: Schema.optionalKey<Schema.$Array<Schema.String>>;
         }>;
         readonly stepCredential: Schema.String;
         readonly checkout: Schema.Union<readonly [Schema.Literal<"none">, Schema.Literal<"read">, Schema.Literal<"write">]>;
@@ -435,12 +606,26 @@ export declare const WorkUnitClaimResult: Schema.Struct<{
         readonly network: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
             readonly hosts: Schema.$Array<Schema.String>;
         }>, Schema.Literal<"open">]>>;
+        /** Hosts the Run's Team and RepoBinding allow; the Runner adds them unless the Agent opens the network. */
+        readonly hosts: Schema.optionalKey<Schema.$Array<Schema.String>>;
         /** The SandboxBackend the Agent requires. */
         readonly sandbox: Schema.optionalKey<Schema.Literal<"docker">>;
         /** The values of the Secrets the Step names, for its sandbox's environment. */
         readonly secrets: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        /** For each of `secrets`, whose it is and where its reference may be swapped for its value. */
+        readonly secretDestinations: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+            readonly scope: Schema.Union<readonly [Schema.Literal<"workspace">, Schema.Literal<"team">]>;
+            readonly hosts: Schema.$Array<Schema.String>;
+            readonly version: Schema.String;
+        }>>>;
         /** Where the Run's first Step started; a boundary's change is the Run's whole change from there. */
         readonly runBaseRevision: Schema.optionalKey<Schema.String>;
+        /** A write checkout's target branch, whose head the Runner merges in before the agent starts. */
+        readonly mergeTarget: Schema.optionalKey<Schema.String>;
+        /** What a Step that ran before is told when it carries on: its Question's answer and steers sent while it was away. */
+        readonly resumeNotes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        /** The last Transcript entry the attempt holds; a Step that ran before writes after it. */
+        readonly transcriptSequence: Schema.optionalKey<Schema.Int>;
         readonly storageOrigin: Schema.optionalKey<Schema.String>;
     }>, Schema.Struct<{
         readonly kind: Schema.Literal<"verification">;
@@ -471,11 +656,38 @@ export declare const WorkUnitClaimResult: Schema.Struct<{
             readonly expectedCommitSha: Schema.optionalKey<Schema.String>;
         }>;
         readonly revision: Schema.String;
+        readonly baseline: Schema.optionalKey<Schema.String>;
         readonly checks: Schema.$Array<Schema.Struct<{
             readonly name: Schema.String;
             readonly command: Schema.String;
             readonly workingDirectory: Schema.optionalKey<Schema.String>;
+            /** An agent suggested it for a repository with none approved; a Run sets it, never an approval. */
+            readonly suggested: Schema.optionalKey<Schema.Boolean>;
+            /**
+             * The repository's pipeline, for a forge that runs none: Shepherd runs it on a ChangeRequest's head and reports the
+             * result. A `verify` that names no checks leaves it out.
+             */
+            readonly pipeline: Schema.optionalKey<Schema.Boolean>;
+        }>>;
+        readonly measure: Schema.optionalKey<Schema.Struct<{
+            readonly base: Schema.String;
+            readonly plan: Schema.Struct<{
+                readonly command: Schema.String;
+                readonly prepare: Schema.optionalKey<Schema.String>;
+                readonly workingDirectory: Schema.optionalKey<Schema.String>;
+                readonly warmup: Schema.optionalKey<Schema.Int>;
+                readonly metrics: Schema.$Array<Schema.Struct<{
+                    readonly name: Schema.String;
+                    readonly direction: Schema.Literals<readonly ["lower", "higher"]>;
+                    readonly role: Schema.Literals<readonly ["primary", "guardrail"]>;
+                    readonly lowVariance: Schema.optionalKey<Schema.Boolean>;
+                }>>;
+            }>;
+            readonly samples: Schema.Int;
+            readonly calibrate: Schema.Boolean;
         }>>;
+        /** 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>;
     }>]>>;
 }>;
@@ -500,12 +712,23 @@ export declare const WorkUnitHeartbeatInput: Schema.Struct<{
         readonly capacitySlot: Schema.String;
     }>;
     readonly leaseDurationSeconds: Schema.optionalKey<Schema.Int>;
+    /** The Secrets an agent Step holds references to, and their versions, for Kitman to say which are revoked. */
+    readonly secrets: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly version: Schema.String;
+    }>>>;
 }>;
 /** `settled` means the control plane already recorded this Work Unit's outcome; the Runner stops and reports nothing. */
 export declare const WorkUnitHeartbeatResult: Schema.Struct<{
     readonly settled: Schema.Boolean;
     /** An agent Step's Output was accepted; the Runner pushes its work and completes the Step. */
     readonly outputSubmitted: Schema.optionalKey<Schema.Boolean>;
+    /** The Output answers `merged`: the Runner commits the merge it opened for a merge Step, and otherwise aborts it. */
+    readonly outputMerged: Schema.optionalKey<Schema.Boolean>;
+    /** An agent Step's agent waits on a Question: the Runner parks the Step rather than hold its slot. */
+    readonly questionOpen: Schema.optionalKey<Schema.Boolean>;
+    /** Those of the heartbeat's `secrets` deleted or replaced since they were delivered: their references stop working. */
+    readonly revokedSecrets: Schema.optionalKey<Schema.$Array<Schema.String>>;
 }>;
 /** Releases an uncompleted WorkUnit after verifying the complete lease tuple. */
 export declare const WorkUnitReleaseInput: Schema.Struct<{
@@ -518,6 +741,10 @@ export declare const WorkUnitReleaseInput: Schema.Struct<{
         readonly fencingToken: Schema.String;
         readonly capacitySlot: Schema.String;
     }>;
+    /** The Runner gives it back because it could not run it: a program crashed, or an executor failed. */
+    readonly crashed: Schema.optionalKey<Schema.Struct<{
+        readonly reason: Schema.String;
+    }>>;
 }>;
 /** One check's run at a tree: what an EvidenceRef records. */
 export declare const CheckEvidence: Schema.Struct<{
@@ -578,6 +805,11 @@ export declare const VerificationEvidence: Schema.Struct<{
             readonly fileIds: Schema.optionalKey<Schema.$Array<Schema.String>>;
         }>>;
     }>>;
+    readonly measurement: Schema.optionalKey<Schema.Struct<{
+        readonly base: Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>;
+        readonly head: Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>;
+        readonly baseAgain: Schema.optionalKey<Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>>;
+    }>>;
 }>;
 /** 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<{
@@ -593,6 +825,41 @@ export declare const BoundaryChange: Schema.Struct<{
     readonly truncated: Schema.Boolean;
 }>;
 export type BoundaryChange = (typeof BoundaryChange)['Type'];
+/** The most paths a catch-up report lists in each of its lists. */
+export declare const catchUpPathLimit = 200;
+/**
+ * What a base sync's merge did to the branch's own change, as the Runner found it in git: the branch's own diff is
+ * `git diff <merge-base with the target>..<head>`, compared file by file without line numbers.
+ */
+export declare const CatchUp: Schema.Struct<{
+    /** The branch's head before the merge. */
+    readonly from: Schema.String;
+    /** The head the Step pushed. */
+    readonly head: Schema.String;
+    /** The files the merge conflicted on, settled by the agent. */
+    readonly conflicted: Schema.$Array<Schema.String>;
+    /** The files changed besides the merge, while it was open or after it, such as migrations `db:rebase` regenerated. */
+    readonly rewritten: Schema.$Array<Schema.String>;
+    /** The files whose own diff at `head` differs from theirs at `from`. */
+    readonly changed: Schema.$Array<Schema.String>;
+    /** A list was longer than `catchUpPathLimit` and was cut. */
+    readonly truncated: Schema.Boolean;
+}>;
+export type CatchUp = (typeof CatchUp)['Type'];
+/** An agent Step's Harness cannot run on this Runner: Kitman holds it and starts the Step again on the next choice. */
+export declare const HarnessHold: Schema.Struct<{
+    readonly reason: Schema.Literals<readonly ["out_of_quota", "failed_to_start"]>;
+    /** When the Harness can run again, as it reported; Kitman holds it for a while when this is missing or implausible. */
+    readonly until: Schema.optionalKey<Schema.String>;
+    /** The cause is this Step's own, such as a missing login Secret: only this Step passes the choice over, on any Runner. */
+    readonly scope: Schema.optionalKey<Schema.Literal<"step">>;
+}>;
+export type HarnessHold = (typeof HarnessHold)['Type'];
+/** The Harness lost its login while it ran, such as to a revoked token: Kitman starts the Step again, signed in afresh. */
+export declare const StepRestart: Schema.Struct<{
+    readonly reason: Schema.Literal<"login_revoked">;
+}>;
+export type StepRestart = (typeof StepRestart)['Type'];
 export declare const WorkUnitOutcome: Schema.Struct<{
     readonly status: Schema.Union<readonly [Schema.Literal<"completed">, Schema.Literal<"failed">, Schema.Literal<"blocked">, Schema.Literal<"canceled">]>;
     readonly result: Schema.optionalKey<Schema.Struct<{
@@ -648,6 +915,11 @@ export declare const WorkUnitOutcome: Schema.Struct<{
                 readonly fileIds: Schema.optionalKey<Schema.$Array<Schema.String>>;
             }>>;
         }>>;
+        readonly measurement: Schema.optionalKey<Schema.Struct<{
+            readonly base: Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>;
+            readonly head: Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>;
+            readonly baseAgain: Schema.optionalKey<Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>>;
+        }>>;
     }>>;
     readonly boundary: Schema.optionalKey<Schema.Struct<{
         readonly kind: Schema.Literal<"change">;
@@ -661,6 +933,31 @@ export declare const WorkUnitOutcome: Schema.Struct<{
         }>>;
         readonly truncated: Schema.Boolean;
     }>>;
+    /** What a base sync that merged did to the branch's own change. */
+    readonly catchUp: Schema.optionalKey<Schema.Struct<{
+        /** The branch's head before the merge. */
+        readonly from: Schema.String;
+        /** The head the Step pushed. */
+        readonly head: Schema.String;
+        /** The files the merge conflicted on, settled by the agent. */
+        readonly conflicted: Schema.$Array<Schema.String>;
+        /** The files changed besides the merge, while it was open or after it, such as migrations `db:rebase` regenerated. */
+        readonly rewritten: Schema.$Array<Schema.String>;
+        /** The files whose own diff at `head` differs from theirs at `from`. */
+        readonly changed: Schema.$Array<Schema.String>;
+        /** A list was longer than `catchUpPathLimit` and was cut. */
+        readonly truncated: Schema.Boolean;
+    }>>;
+    readonly harnessHold: Schema.optionalKey<Schema.Struct<{
+        readonly reason: Schema.Literals<readonly ["out_of_quota", "failed_to_start"]>;
+        /** When the Harness can run again, as it reported; Kitman holds it for a while when this is missing or implausible. */
+        readonly until: Schema.optionalKey<Schema.String>;
+        /** The cause is this Step's own, such as a missing login Secret: only this Step passes the choice over, on any Runner. */
+        readonly scope: Schema.optionalKey<Schema.Literal<"step">>;
+    }>>;
+    readonly restart: Schema.optionalKey<Schema.Struct<{
+        readonly reason: Schema.Literal<"login_revoked">;
+    }>>;
     readonly failureSummary: Schema.optionalKey<Schema.String>;
 }>;
 export declare const WorkUnitCompletion: Schema.Struct<{
@@ -729,6 +1026,11 @@ export declare const WorkUnitCompletion: Schema.Struct<{
                     readonly fileIds: Schema.optionalKey<Schema.$Array<Schema.String>>;
                 }>>;
             }>>;
+            readonly measurement: Schema.optionalKey<Schema.Struct<{
+                readonly base: Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>;
+                readonly head: Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>;
+                readonly baseAgain: Schema.optionalKey<Schema.$Array<Schema.$Record<Schema.String, Schema.Finite>>>;
+            }>>;
         }>>;
         readonly boundary: Schema.optionalKey<Schema.Struct<{
             readonly kind: Schema.Literal<"change">;
@@ -742,6 +1044,31 @@ export declare const WorkUnitCompletion: Schema.Struct<{
             }>>;
             readonly truncated: Schema.Boolean;
         }>>;
+        /** What a base sync that merged did to the branch's own change. */
+        readonly catchUp: Schema.optionalKey<Schema.Struct<{
+            /** The branch's head before the merge. */
+            readonly from: Schema.String;
+            /** The head the Step pushed. */
+            readonly head: Schema.String;
+            /** The files the merge conflicted on, settled by the agent. */
+            readonly conflicted: Schema.$Array<Schema.String>;
+            /** The files changed besides the merge, while it was open or after it, such as migrations `db:rebase` regenerated. */
+            readonly rewritten: Schema.$Array<Schema.String>;
+            /** The files whose own diff at `head` differs from theirs at `from`. */
+            readonly changed: Schema.$Array<Schema.String>;
+            /** A list was longer than `catchUpPathLimit` and was cut. */
+            readonly truncated: Schema.Boolean;
+        }>>;
+        readonly harnessHold: Schema.optionalKey<Schema.Struct<{
+            readonly reason: Schema.Literals<readonly ["out_of_quota", "failed_to_start"]>;
+            /** When the Harness can run again, as it reported; Kitman holds it for a while when this is missing or implausible. */
+            readonly until: Schema.optionalKey<Schema.String>;
+            /** The cause is this Step's own, such as a missing login Secret: only this Step passes the choice over, on any Runner. */
+            readonly scope: Schema.optionalKey<Schema.Literal<"step">>;
+        }>>;
+        readonly restart: Schema.optionalKey<Schema.Struct<{
+            readonly reason: Schema.Literal<"login_revoked">;
+        }>>;
         readonly failureSummary: Schema.optionalKey<Schema.String>;
     }>;
 }>;
@@ -751,10 +1078,14 @@ export type WorkUnit = (typeof WorkUnit)['Type'];
 export type OrchestrationWorkUnit = (typeof OrchestrationWorkUnit)['Type'];
 export type AgentStepWorkUnit = (typeof AgentStepWorkUnit)['Type'];
 export type ApprovedCheck = (typeof ApprovedCheck)['Type'];
+export type RepositoryCheck = (typeof RepositoryCheck)['Type'];
 export type VerificationWorkUnit = (typeof VerificationWorkUnit)['Type'];
 export type CheckEvidence = (typeof CheckEvidence)['Type'];
 export type TreeEvidence = (typeof TreeEvidence)['Type'];
 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 LoopCheckout = (typeof LoopCheckout)['Type'];
 export type RunJournal = (typeof RunJournal)['Type'];
 export type WorkUnitClaimResult = (typeof WorkUnitClaimResult)['Type'];