@kitman-sh/sdk 0.10.57 → 0.10.59

package/dist/build/index.js

@@ -4,7 +4,7 @@ import {
   KitDigest,
   AgentDeclaration,
   KitDeclarations
-} from "../chunk-r33ndzyg.js";
+} from "../chunk-dnmb9dw9.js";
 import {
   digestSha256,
   digestSha512,
@@ -13,7 +13,7 @@ import {
   RunnerRpcProtocolVersion,
   describeFlag2,
   Described2
-} from "../chunk-9r9dqxwk.js";
+} from "../chunk-x37rn3aw.js";
 
 // packages/core/src/json.ts
 import * as Schema from "effect/Schema";

package/dist/{chunk-r33ndzyg.js → chunk-dnmb9dw9.js}

@@ -2071,7 +2071,7 @@ var StepOutputSubmissionResult = Schema12.Union([
   }),
   Schema12.Struct({ status: Schema12.Literal("failed"), message: Schema12.String })
 ]);
-var HarnessHoldReasons = ["out_of_quota", "failed_to_start"];
+var HarnessHoldReasons = ["out_of_quota", "rate_limited", "login_refused", "failed_to_start"];
 var SkippedChoiceReasons = ["not_on_runner", ...HarnessHoldReasons];
 var SkippedChoice = Schema12.Struct({
   harness: Schema12.optionalKey(Schema12.String),
@@ -2979,12 +2979,15 @@ var ask2 = (name, question) => takeStep2(name, "ask", "ask", Effect3.gen(functio
   const fallback = question.default === undefined ? recommendedDefault(recommended) : question.default ?? undefined;
   if (fallback !== undefined && options !== undefined && !options.includes(fallback))
     return yield* new QuestionRefused2({ step: name, answer: fallback, options });
+  if (question.auto !== undefined && options !== undefined && !options.includes(question.auto))
+    return yield* new QuestionRefused2({ step: name, answer: question.auto, options });
   yield* launch2(deferred, (host, token) => host.putQuestion({
     step: name,
     prompt: question.prompt,
     ...options === undefined ? undefined : { options },
     ...advice,
     ...fallback === undefined ? undefined : { default: fallback },
+    ...question.auto === undefined ? undefined : { auto: question.auto },
     ...question.timeout === undefined ? undefined : { timeoutMillis: Duration.toMillis(Duration.fromInputUnsafe(question.timeout)) },
     token
   }));
@@ -4138,7 +4141,7 @@ var scriptedHost = (script, engine, agentLaunches, childLaunches, waits) => {
       ...launch.mergeTarget === undefined ? undefined : { mergeTarget: launch.mergeTarget }
     })), resolve(agentDeferredNamed2(launch.deferredName), launch.token, scriptedExit(script.outputs?.[launch.step], (reason) => new StepFailed2({ step: launch.step, reason })))),
     putQuestion: (launch) => {
-      const answer = script.answers?.[launch.step] ?? launch.default;
+      const answer = script.answers?.[launch.step] ?? (script.fullAuto === true ? launch.auto : undefined) ?? launch.default;
       return resolve(answerDeferred2(launch.step), launch.token, answer === undefined ? Exit3.fail(new StepFailed2({ step: launch.step, reason: "no answer was scripted" })) : Exit3.succeed(answer));
     },
     admitChild: (launch) => Effect8.andThen(Effect8.sync(() => childLaunches.push({ step: launch.step, loop: launch.loop, input: launch.input })), resolve(childDeferred2(launch.step), launch.token, scriptedExit(script.children?.[launch.step], (reason) => new ChildFailed2({ step: launch.step, loop: launch.loop, reason })))),

package/dist/{chunk-9r9dqxwk.js → chunk-x37rn3aw.js}

@@ -33,7 +33,7 @@ import {
   executeLoop2,
   LoopCheckError2,
   checkLoop2
-} from "./chunk-r33ndzyg.js";
+} from "./chunk-dnmb9dw9.js";
 // packages/core/src/agent-environment.ts
 import * as Schema from "effect/Schema";
 var AgentEnvironmentPolicy = Schema.Union([Schema.Literal("recommended"), Schema.Literal("required")]);
@@ -879,6 +879,7 @@ class RunnerCapabilityRpcs extends RpcGroup.make(Rpc.make("PutQuestion", {
     informationOnly: Schema7.optional(Schema7.Boolean),
     verification: Schema7.optional(SuggestedVerification),
     default: Schema7.optional(Schema7.String),
+    auto: Schema7.optional(Schema7.String),
     timeoutMillis: Schema7.optional(Schema7.Finite),
     deferredName: Schema7.String
   },
@@ -1392,6 +1393,7 @@ var runnerHost = (capabilities) => ({
     ...launch.options === undefined ? undefined : { options: launch.options },
     ...launch.verification === undefined ? undefined : { verification: launch.verification },
     ...launch.default === undefined ? undefined : { default: launch.default },
+    ...launch.auto === undefined ? undefined : { auto: launch.auto },
     ...launch.timeoutMillis === undefined ? undefined : { timeoutMillis: launch.timeoutMillis }
   })).pipe(Effect2.asVoid),
   startVerification: (launch) => requested2(launch.step, capabilities.startVerification({
@@ -1613,6 +1615,7 @@ var rpcProgramPorts2 = (rpc, work) => {
       ...question.options === undefined ? undefined : { options: [...question.options] },
       ...question.verification === undefined ? undefined : { verification: question.verification },
       ...question.default === undefined ? undefined : { default: question.default },
+      ...question.auto === undefined ? undefined : { auto: question.auto },
       ...question.timeoutMillis === undefined ? undefined : { timeoutMillis: question.timeoutMillis }
     }),
     startVerification: (verification) => rpc.startVerification({

package/dist/loop/index.js

@@ -173,7 +173,7 @@ import {
   syncBase2,
   Continuing2,
   continuingBrief2
-} from "../chunk-r33ndzyg.js";
+} from "../chunk-dnmb9dw9.js";
 export {
   AlertTaskActivity2 as AlertTaskActivity,
   AlertTaskRequest2 as AlertTaskRequest,

package/dist/program/index.js

@@ -1,5 +1,5 @@
 // @bun
-import"../chunk-r33ndzyg.js";
+import"../chunk-dnmb9dw9.js";
 import {
   JournalWriteFailed2,
   refusedStep2,
@@ -17,7 +17,7 @@ import {
   networkGuard2,
   carriedKits2,
   runKit2
-} from "../chunk-9r9dqxwk.js";
+} from "../chunk-x37rn3aw.js";
 export {
   Described2 as Described,
   JournalWriteFailed2 as JournalWriteFailed,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitman-sh/sdk",
-  "version": "0.10.57",
+  "version": "0.10.59",
   "type": "module",
   "license": "UNLICENSED",
   "exports": {

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

@@ -1554,16 +1554,16 @@ export declare const StepOutputSubmissionResult: Schema.Union<readonly [Schema.S
     readonly message: Schema.String;
 }>]>;
 export type StepOutputSubmissionResult = (typeof StepOutputSubmissionResult)['Type'];
-/** Why a Runner holds a Harness: it reported the Harness out of quota, or it failed to start. */
-export declare const HarnessHoldReasons: readonly ['out_of_quota', 'failed_to_start'];
+/** Why a Runner holds a Harness: its provider would not serve it, or it failed to start. */
+export declare const HarnessHoldReasons: readonly ['out_of_quota', 'rate_limited', 'login_refused', 'failed_to_start'];
 export type HarnessHoldReason = (typeof HarnessHoldReasons)[number];
-export declare const SkippedChoiceReasons: readonly ["not_on_runner", "out_of_quota", "failed_to_start"];
+export declare const SkippedChoiceReasons: readonly ["not_on_runner", "out_of_quota", "rate_limited", "login_refused", "failed_to_start"];
 /** A choice the attempt passed over, and why; a choice that names no Harness needed the Runner's default. */
 export declare const SkippedChoice: Schema.Struct<{
     readonly harness: Schema.optionalKey<Schema.String>;
     readonly model: Schema.optionalKey<Schema.String>;
     readonly effort: Schema.optionalKey<Schema.Literals<readonly ["low", "medium", "high", "xhigh"]>>;
-    readonly reason: Schema.Literals<readonly ["not_on_runner", "out_of_quota", "failed_to_start"]>;
+    readonly reason: Schema.Literals<readonly ["not_on_runner", "out_of_quota", "rate_limited", "login_refused", "failed_to_start"]>;
     /** When the choice can be tried again. */
     readonly until: Schema.optionalKey<Schema.String>;
 }>;
@@ -1712,7 +1712,7 @@ export declare const StepAttempt: Schema.Struct<{
         readonly harness: Schema.optionalKey<Schema.String>;
         readonly model: Schema.optionalKey<Schema.String>;
         readonly effort: Schema.optionalKey<Schema.Literals<readonly ["low", "medium", "high", "xhigh"]>>;
-        readonly reason: Schema.Literals<readonly ["not_on_runner", "out_of_quota", "failed_to_start"]>;
+        readonly reason: Schema.Literals<readonly ["not_on_runner", "out_of_quota", "rate_limited", "login_refused", "failed_to_start"]>;
         /** When the choice can be tried again. */
         readonly until: Schema.optionalKey<Schema.String>;
     }>>>;
@@ -1877,7 +1877,7 @@ export declare const StepAttemptList: Schema.Struct<{
             readonly harness: Schema.optionalKey<Schema.String>;
             readonly model: Schema.optionalKey<Schema.String>;
             readonly effort: Schema.optionalKey<Schema.Literals<readonly ["low", "medium", "high", "xhigh"]>>;
-            readonly reason: Schema.Literals<readonly ["not_on_runner", "out_of_quota", "failed_to_start"]>;
+            readonly reason: Schema.Literals<readonly ["not_on_runner", "out_of_quota", "rate_limited", "login_refused", "failed_to_start"]>;
             /** When the choice can be tried again. */
             readonly until: Schema.optionalKey<Schema.String>;
         }>>>;

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

@@ -1071,7 +1071,7 @@ export declare const RunnerStepAttempt: Schema.Struct<{
             readonly harness: Schema.optionalKey<Schema.String>;
             readonly model: Schema.optionalKey<Schema.String>;
             readonly effort: Schema.optionalKey<Schema.Literals<readonly ["low", "medium", "high", "xhigh"]>>;
-            readonly reason: Schema.Literals<readonly ["not_on_runner", "out_of_quota", "failed_to_start"]>;
+            readonly reason: Schema.Literals<readonly ["not_on_runner", "out_of_quota", "rate_limited", "login_refused", "failed_to_start"]>;
             readonly until: Schema.optionalKey<Schema.String>;
         }>>>;
         readonly lease: Schema.optionalKey<Schema.Struct<{

package/types/packages/core/src/task-detail.d.ts

@@ -344,7 +344,7 @@ export declare const TaskDetailAggregate: Schema.Struct<{
             readonly harness: Schema.optionalKey<Schema.String>;
             readonly model: Schema.optionalKey<Schema.String>;
             readonly effort: Schema.optionalKey<Schema.Literals<readonly ["low", "medium", "high", "xhigh"]>>;
-            readonly reason: Schema.Literals<readonly ["not_on_runner", "out_of_quota", "failed_to_start"]>;
+            readonly reason: Schema.Literals<readonly ["not_on_runner", "out_of_quota", "rate_limited", "login_refused", "failed_to_start"]>;
             readonly until: Schema.optionalKey<Schema.String>;
         }>>>;
         readonly lease: Schema.optionalKey<Schema.Struct<{

package/types/packages/core/src/team-context.d.ts

@@ -1,9 +1,17 @@
 import * as Schema from 'effect/Schema';
+/**
+ * How the Team's changes ship. `gated`: a person decides each merge and release. `auto`: Kitman takes a Loop's
+ * full-auto answer at once, so a passing, non-blocking Review of the head carries a change through merge, tag and
+ * deploy with nobody asked.
+ */
+export declare const DeliveryMode: Schema.Literals<readonly ["gated", "auto"]>;
+export type DeliveryMode = (typeof DeliveryMode)['Type'];
 export declare const TeamDeliverySettings: Schema.Struct<{
     readonly defaultRepoBindingId: Schema.optionalKey<Schema.String>;
     readonly standardBranchTemplate: Schema.String;
     readonly epicBranchTemplate: Schema.String;
     readonly isolatedChildBranchTemplate: Schema.String;
+    readonly delivery: Schema.Literals<readonly ["gated", "auto"]>;
     readonly revision: Schema.Int;
 }>;
 export declare const TeamDeliverySettingsUpdate: Schema.Struct<{
@@ -11,6 +19,8 @@ export declare const TeamDeliverySettingsUpdate: Schema.Struct<{
     readonly standardBranchTemplate: Schema.optionalKey<Schema.String>;
     readonly epicBranchTemplate: Schema.optionalKey<Schema.String>;
     readonly isolatedChildBranchTemplate: Schema.optionalKey<Schema.String>;
+    /** Only a Workspace owner or admin, signed in as themselves, may change it. */
+    readonly delivery: Schema.optionalKey<Schema.Literals<readonly ["gated", "auto"]>>;
     readonly expectedRevision: Schema.Int;
 }>;
 /** A Team as agents and repository choices name it. */

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

@@ -848,7 +848,7 @@ export declare const CatchUp: Schema.Struct<{
 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"]>;
+    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. */
     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. */
@@ -949,7 +949,7 @@ export declare const WorkUnitOutcome: Schema.Struct<{
         readonly truncated: Schema.Boolean;
     }>>;
     readonly harnessHold: Schema.optionalKey<Schema.Struct<{
-        readonly reason: Schema.Literals<readonly ["out_of_quota", "failed_to_start"]>;
+        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. */
         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. */
@@ -1060,7 +1060,7 @@ export declare const WorkUnitCompletion: Schema.Struct<{
             readonly truncated: Schema.Boolean;
         }>>;
         readonly harnessHold: Schema.optionalKey<Schema.Struct<{
-            readonly reason: Schema.Literals<readonly ["out_of_quota", "failed_to_start"]>;
+            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. */
             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. */

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

@@ -495,7 +495,7 @@ export declare const makeRunnerRpcClient: (options: ConnectionOptions) => Effect
                 readonly truncated: boolean;
             };
             readonly harnessHold?: {
-                readonly reason: "failed_to_start" | "out_of_quota";
+                readonly reason: "failed_to_start" | "login_refused" | "out_of_quota" | "rate_limited";
                 readonly until?: string;
                 readonly scope?: "step";
             };
@@ -1139,6 +1139,7 @@ export declare const makeProgramRpcClient: (options: ConnectionOptions) => Effec
             readonly workingDirectory?: string | undefined;
         } | undefined;
         readonly default?: string | undefined;
+        readonly auto?: string | undefined;
         readonly timeoutMillis?: number | undefined;
         readonly deferredName: string;
     }, options?: {

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

@@ -123,65 +123,7 @@ export declare const ProgramOutcome: Schema.Union<readonly [Schema.Struct<{
     readonly status: Schema.Literal<"failed">;
     readonly failureSummary: Schema.String;
 }>]>;
-declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"Signals", Schema.Struct<{
-    runnerReplicaId: Schema.String;
-}>, import("effect/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.TaggedStruct<"WorkAvailable", {}>, Schema.TaggedStruct<"LeaseRevoked", {
-    readonly workUnitId: Schema.String;
-}>, Schema.TaggedStruct<"Settled", {
-    readonly workUnitId: Schema.String;
-}>, Schema.TaggedStruct<"Canceled", {
-    readonly workUnitId: Schema.String;
-}>, Schema.TaggedStruct<"RunSettled", {
-    readonly runId: Schema.String;
-}>, Schema.TaggedStruct<"Steer", {
-    readonly workUnitId: Schema.String;
-    readonly messageId: Schema.String;
-    readonly text: Schema.String;
-}>, Schema.TaggedStruct<"SessionUpdated", {
-    readonly workUnitId: Schema.String;
-}>, Schema.TaggedStruct<"UpdateAvailable", {
-    readonly version: Schema.String;
-}>]>, typeof RunnerRpcError>, Schema.Never, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreateCheckpointFile", Schema.Struct<{
-    lease: Schema.Struct<{
-        readonly workUnitId: Schema.String;
-        readonly leaseOwnerId: Schema.String;
-        readonly runnerReplicaId: Schema.String;
-        readonly leaseId: Schema.String;
-        readonly attempt: Schema.Int;
-        readonly fencingToken: Schema.String;
-        readonly capacitySlot: Schema.String;
-    }>;
-    byteSize: Schema.Int;
-    sha256: Schema.String;
-}>, Schema.Struct<{
-    readonly file: Schema.Struct<{
-        readonly id: Schema.String;
-        readonly runId: Schema.String;
-        readonly step: Schema.String;
-        readonly name: Schema.String;
-        readonly caption: Schema.optionalKey<Schema.String>;
-        readonly contentType: Schema.String;
-        readonly kind: Schema.Literals<readonly ["image", "video", "html", "text", "other"]>;
-        readonly byteSize: Schema.Int;
-        readonly sha256: Schema.String;
-        readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
-    }>;
-    readonly upload: Schema.optional<Schema.Union<readonly [Schema.Struct<{
-        readonly url: Schema.String;
-        readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-        readonly expiresAt: Schema.String;
-        readonly kind: Schema.Literal<"single">;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"multipart">;
-        readonly partSize: Schema.Int;
-        readonly parts: Schema.$Array<Schema.Struct<{
-            readonly url: Schema.String;
-            readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-            readonly expiresAt: Schema.String;
-            readonly partNumber: Schema.Int;
-        }>>;
-    }>]>>;
-}>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"AppendTranscript", Schema.Struct<{
+declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AppendTranscript", Schema.Struct<{
     workUnitId: Schema.String;
     entries: Schema.$Array<Schema.Struct<{
         readonly sequence: Schema.Int;
@@ -500,7 +442,7 @@ declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"Signals", Schem
             readonly truncated: Schema.Boolean;
         }>>;
         readonly harnessHold: Schema.optionalKey<Schema.Struct<{
-            readonly reason: Schema.Literals<readonly ["out_of_quota", "failed_to_start"]>;
+            readonly reason: Schema.Literals<readonly ["out_of_quota", "rate_limited", "login_refused", "failed_to_start"]>;
             readonly until: Schema.optionalKey<Schema.String>;
             readonly scope: Schema.optionalKey<Schema.Literal<"step">>;
         }>>;
@@ -535,7 +477,47 @@ declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"Signals", Schem
     readonly byteSize: Schema.Int;
     readonly sha256: Schema.String;
     readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
-}>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"ForgetCheckpoints", Schema.Struct<{
+}>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreateCheckpointFile", Schema.Struct<{
+    lease: Schema.Struct<{
+        readonly workUnitId: Schema.String;
+        readonly leaseOwnerId: Schema.String;
+        readonly runnerReplicaId: Schema.String;
+        readonly leaseId: Schema.String;
+        readonly attempt: Schema.Int;
+        readonly fencingToken: Schema.String;
+        readonly capacitySlot: Schema.String;
+    }>;
+    byteSize: Schema.Int;
+    sha256: Schema.String;
+}>, Schema.Struct<{
+    readonly file: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly runId: Schema.String;
+        readonly step: Schema.String;
+        readonly name: Schema.String;
+        readonly caption: Schema.optionalKey<Schema.String>;
+        readonly contentType: Schema.String;
+        readonly kind: Schema.Literals<readonly ["image", "video", "html", "text", "other"]>;
+        readonly byteSize: Schema.Int;
+        readonly sha256: Schema.String;
+        readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
+    }>;
+    readonly upload: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+        readonly url: Schema.String;
+        readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly expiresAt: Schema.String;
+        readonly kind: Schema.Literal<"single">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"multipart">;
+        readonly partSize: Schema.Int;
+        readonly parts: Schema.$Array<Schema.Struct<{
+            readonly url: Schema.String;
+            readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly expiresAt: Schema.String;
+            readonly partNumber: Schema.Int;
+        }>>;
+    }>]>>;
+}>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"ForgetCheckpoints", Schema.Struct<{
     stepAttemptIds: Schema.$Array<Schema.String>;
 }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"GitCredential", Schema.Struct<{
     repoBindingId: Schema.String;
@@ -652,7 +634,25 @@ declare const RunnerReplicaRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"Signals", Schem
     }>>;
 }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"SettledRuns", Schema.Struct<{
     runIds: Schema.$Array<Schema.String>;
-}>, Schema.$Array<Schema.String>, typeof RunnerRpcError, typeof RunnerAuthentication, never>>;
+}>, Schema.$Array<Schema.String>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Signals", Schema.Struct<{
+    runnerReplicaId: Schema.String;
+}>, import("effect/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.TaggedStruct<"WorkAvailable", {}>, Schema.TaggedStruct<"LeaseRevoked", {
+    readonly workUnitId: Schema.String;
+}>, Schema.TaggedStruct<"Settled", {
+    readonly workUnitId: Schema.String;
+}>, Schema.TaggedStruct<"Canceled", {
+    readonly workUnitId: Schema.String;
+}>, Schema.TaggedStruct<"RunSettled", {
+    readonly runId: Schema.String;
+}>, Schema.TaggedStruct<"Steer", {
+    readonly workUnitId: Schema.String;
+    readonly messageId: Schema.String;
+    readonly text: Schema.String;
+}>, Schema.TaggedStruct<"SessionUpdated", {
+    readonly workUnitId: Schema.String;
+}>, Schema.TaggedStruct<"UpdateAvailable", {
+    readonly version: Schema.String;
+}>]>, typeof RunnerRpcError>, Schema.Never, typeof RunnerAuthentication, never>>;
 /** The Runner process's procedures: Work Unit leases, signals, checkpoints and bundles. */
 export declare class RunnerReplicaRpcs extends RunnerReplicaRpcs_base {
 }
@@ -1113,6 +1113,8 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
     }>>;
     /** Taken when the Run is unattended, or when nobody answers within `timeoutMillis`. */
     default: Schema.optional<Schema.String>;
+    /** Taken at once when the Run's Team delivers in full auto. */
+    auto: Schema.optional<Schema.String>;
     timeoutMillis: Schema.optional<Schema.Finite>;
     deferredName: Schema.String;
 }>, Schema.Struct<{
@@ -1340,51 +1342,7 @@ declare const RunnerCapabilityRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild",
 /** A program's domain calls. */
 export declare class RunnerCapabilityRpcs extends RunnerCapabilityRpcs_base {
 }
-declare const RunnerRunFileRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreateRunFile", Schema.Struct<{
-    lease: Schema.Struct<{
-        readonly workUnitId: Schema.String;
-        readonly leaseOwnerId: Schema.String;
-        readonly runnerReplicaId: Schema.String;
-        readonly leaseId: Schema.String;
-        readonly attempt: Schema.Int;
-        readonly fencingToken: Schema.String;
-        readonly capacitySlot: Schema.String;
-    }>;
-    step: Schema.String;
-    name: Schema.String;
-    caption: Schema.optional<Schema.String>;
-    contentType: Schema.String;
-    byteSize: Schema.Int;
-    sha256: Schema.String;
-}>, Schema.Struct<{
-    readonly file: Schema.Struct<{
-        readonly id: Schema.String;
-        readonly runId: Schema.String;
-        readonly step: Schema.String;
-        readonly name: Schema.String;
-        readonly caption: Schema.optionalKey<Schema.String>;
-        readonly contentType: Schema.String;
-        readonly kind: Schema.Literals<readonly ["image", "video", "html", "text", "other"]>;
-        readonly byteSize: Schema.Int;
-        readonly sha256: Schema.String;
-        readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
-    }>;
-    readonly upload: Schema.optional<Schema.Union<readonly [Schema.Struct<{
-        readonly url: Schema.String;
-        readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-        readonly expiresAt: Schema.String;
-        readonly kind: Schema.Literal<"single">;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"multipart">;
-        readonly partSize: Schema.Int;
-        readonly parts: Schema.$Array<Schema.Struct<{
-            readonly url: Schema.String;
-            readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-            readonly expiresAt: Schema.String;
-            readonly partNumber: Schema.Int;
-        }>>;
-    }>]>>;
-}>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"CompleteRunFile", Schema.Struct<{
+declare const RunnerRunFileRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CompleteRunFile", Schema.Struct<{
     lease: Schema.Struct<{
         readonly workUnitId: Schema.String;
         readonly leaseOwnerId: Schema.String;
@@ -1410,31 +1368,7 @@ declare const RunnerRunFileRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"CreateRunFile",
     readonly byteSize: Schema.Int;
     readonly sha256: Schema.String;
     readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
-}>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"RunFileParts", Schema.Struct<{
-    lease: Schema.Struct<{
-        readonly workUnitId: Schema.String;
-        readonly leaseOwnerId: Schema.String;
-        readonly runnerReplicaId: Schema.String;
-        readonly leaseId: Schema.String;
-        readonly attempt: Schema.Int;
-        readonly fencingToken: Schema.String;
-        readonly capacitySlot: Schema.String;
-    }>;
-    fileId: Schema.String;
-    partNumbers: Schema.$Array<Schema.Int>;
-}>, Schema.Struct<{
-    readonly parts: Schema.$Array<Schema.Struct<{
-        readonly url: Schema.String;
-        readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-        readonly expiresAt: Schema.String;
-        readonly partNumber: Schema.Int;
-    }>>;
-}>, typeof RunnerRpcError, typeof RunnerAuthentication, never>>;
-/** Run File uploads, under a program's orchestration lease or the Runner's verification lease. */
-export declare class RunnerRunFileRpcs extends RunnerRunFileRpcs_base {
-}
-/** What a program process may call; its bundle speaks the Runner RPC protocol version through these. */
-export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreateRunFile", Schema.Struct<{
+}>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreateRunFile", Schema.Struct<{
     lease: Schema.Struct<{
         readonly workUnitId: Schema.String;
         readonly leaseOwnerId: Schema.String;
@@ -1478,7 +1412,31 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreateRunFile", Sch
             readonly partNumber: Schema.Int;
         }>>;
     }>]>>;
-}>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"AdmitChild", Schema.Struct<{
+}>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"RunFileParts", Schema.Struct<{
+    lease: Schema.Struct<{
+        readonly workUnitId: Schema.String;
+        readonly leaseOwnerId: Schema.String;
+        readonly runnerReplicaId: Schema.String;
+        readonly leaseId: Schema.String;
+        readonly attempt: Schema.Int;
+        readonly fencingToken: Schema.String;
+        readonly capacitySlot: Schema.String;
+    }>;
+    fileId: Schema.String;
+    partNumbers: Schema.$Array<Schema.Int>;
+}>, Schema.Struct<{
+    readonly parts: Schema.$Array<Schema.Struct<{
+        readonly url: Schema.String;
+        readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly expiresAt: Schema.String;
+        readonly partNumber: Schema.Int;
+    }>>;
+}>, typeof RunnerRpcError, typeof RunnerAuthentication, never>>;
+/** Run File uploads, under a program's orchestration lease or the Runner's verification lease. */
+export declare class RunnerRunFileRpcs extends RunnerRunFileRpcs_base {
+}
+/** What a program process may call; its bundle speaks the Runner RPC protocol version through these. */
+export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.Struct<{
     lease: Schema.Struct<{
         readonly workUnitId: Schema.String;
         readonly leaseOwnerId: Schema.String;
@@ -1643,7 +1601,51 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreateRunFile", Sch
 }>, Schema.$Array<Schema.Struct<{
     readonly key: Schema.String;
     readonly taskId: Schema.String;
-}>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"DeferredDone", Schema.Struct<{
+}>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreateRunFile", Schema.Struct<{
+    lease: Schema.Struct<{
+        readonly workUnitId: Schema.String;
+        readonly leaseOwnerId: Schema.String;
+        readonly runnerReplicaId: Schema.String;
+        readonly leaseId: Schema.String;
+        readonly attempt: Schema.Int;
+        readonly fencingToken: Schema.String;
+        readonly capacitySlot: Schema.String;
+    }>;
+    step: Schema.String;
+    name: Schema.String;
+    caption: Schema.optional<Schema.String>;
+    contentType: Schema.String;
+    byteSize: Schema.Int;
+    sha256: Schema.String;
+}>, Schema.Struct<{
+    readonly file: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly runId: Schema.String;
+        readonly step: Schema.String;
+        readonly name: Schema.String;
+        readonly caption: Schema.optionalKey<Schema.String>;
+        readonly contentType: Schema.String;
+        readonly kind: Schema.Literals<readonly ["image", "video", "html", "text", "other"]>;
+        readonly byteSize: Schema.Int;
+        readonly sha256: Schema.String;
+        readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
+    }>;
+    readonly upload: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+        readonly url: Schema.String;
+        readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly expiresAt: Schema.String;
+        readonly kind: Schema.Literal<"single">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"multipart">;
+        readonly partSize: Schema.Int;
+        readonly parts: Schema.$Array<Schema.Struct<{
+            readonly url: Schema.String;
+            readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly expiresAt: Schema.String;
+            readonly partNumber: Schema.Int;
+        }>>;
+    }>]>>;
+}>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"DeferredDone", Schema.Struct<{
     lease: Schema.Struct<{
         readonly workUnitId: Schema.String;
         readonly leaseOwnerId: Schema.String;
@@ -1921,6 +1923,8 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreateRunFile", Sch
     }>>;
     /** Taken when the Run is unattended, or when nobody answers within `timeoutMillis`. */
     default: Schema.optional<Schema.String>;
+    /** Taken at once when the Run's Team delivers in full auto. */
+    auto: Schema.optional<Schema.String>;
     timeoutMillis: Schema.optional<Schema.Finite>;
     deferredName: Schema.String;
 }>, Schema.Struct<{
@@ -2201,109 +2205,7 @@ export declare const ProgramRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"CreateRunFile", Sch
     }>;
 }>, Schema.Void, typeof RunnerRpcError, typeof RunnerAuthentication, never>>;
 /** Every group, served on the one Runner RPC endpoint; a request names its procedure by tag alone. */
-export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"Signals", Schema.Struct<{
-    runnerReplicaId: Schema.String;
-}>, import("effect/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.TaggedStruct<"WorkAvailable", {}>, Schema.TaggedStruct<"LeaseRevoked", {
-    readonly workUnitId: Schema.String;
-}>, Schema.TaggedStruct<"Settled", {
-    readonly workUnitId: Schema.String;
-}>, Schema.TaggedStruct<"Canceled", {
-    readonly workUnitId: Schema.String;
-}>, Schema.TaggedStruct<"RunSettled", {
-    readonly runId: Schema.String;
-}>, Schema.TaggedStruct<"Steer", {
-    readonly workUnitId: Schema.String;
-    readonly messageId: Schema.String;
-    readonly text: Schema.String;
-}>, Schema.TaggedStruct<"SessionUpdated", {
-    readonly workUnitId: Schema.String;
-}>, Schema.TaggedStruct<"UpdateAvailable", {
-    readonly version: Schema.String;
-}>]>, typeof RunnerRpcError>, Schema.Never, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreateCheckpointFile", Schema.Struct<{
-    lease: Schema.Struct<{
-        readonly workUnitId: Schema.String;
-        readonly leaseOwnerId: Schema.String;
-        readonly runnerReplicaId: Schema.String;
-        readonly leaseId: Schema.String;
-        readonly attempt: Schema.Int;
-        readonly fencingToken: Schema.String;
-        readonly capacitySlot: Schema.String;
-    }>;
-    byteSize: Schema.Int;
-    sha256: Schema.String;
-}>, Schema.Struct<{
-    readonly file: Schema.Struct<{
-        readonly id: Schema.String;
-        readonly runId: Schema.String;
-        readonly step: Schema.String;
-        readonly name: Schema.String;
-        readonly caption: Schema.optionalKey<Schema.String>;
-        readonly contentType: Schema.String;
-        readonly kind: Schema.Literals<readonly ["image", "video", "html", "text", "other"]>;
-        readonly byteSize: Schema.Int;
-        readonly sha256: Schema.String;
-        readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
-    }>;
-    readonly upload: Schema.optional<Schema.Union<readonly [Schema.Struct<{
-        readonly url: Schema.String;
-        readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-        readonly expiresAt: Schema.String;
-        readonly kind: Schema.Literal<"single">;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"multipart">;
-        readonly partSize: Schema.Int;
-        readonly parts: Schema.$Array<Schema.Struct<{
-            readonly url: Schema.String;
-            readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-            readonly expiresAt: Schema.String;
-            readonly partNumber: Schema.Int;
-        }>>;
-    }>]>>;
-}>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreateRunFile", Schema.Struct<{
-    lease: Schema.Struct<{
-        readonly workUnitId: Schema.String;
-        readonly leaseOwnerId: Schema.String;
-        readonly runnerReplicaId: Schema.String;
-        readonly leaseId: Schema.String;
-        readonly attempt: Schema.Int;
-        readonly fencingToken: Schema.String;
-        readonly capacitySlot: Schema.String;
-    }>;
-    step: Schema.String;
-    name: Schema.String;
-    caption: Schema.optional<Schema.String>;
-    contentType: Schema.String;
-    byteSize: Schema.Int;
-    sha256: Schema.String;
-}>, Schema.Struct<{
-    readonly file: Schema.Struct<{
-        readonly id: Schema.String;
-        readonly runId: Schema.String;
-        readonly step: Schema.String;
-        readonly name: Schema.String;
-        readonly caption: Schema.optionalKey<Schema.String>;
-        readonly contentType: Schema.String;
-        readonly kind: Schema.Literals<readonly ["image", "video", "html", "text", "other"]>;
-        readonly byteSize: Schema.Int;
-        readonly sha256: Schema.String;
-        readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
-    }>;
-    readonly upload: Schema.optional<Schema.Union<readonly [Schema.Struct<{
-        readonly url: Schema.String;
-        readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-        readonly expiresAt: Schema.String;
-        readonly kind: Schema.Literal<"single">;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"multipart">;
-        readonly partSize: Schema.Int;
-        readonly parts: Schema.$Array<Schema.Struct<{
-            readonly url: Schema.String;
-            readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-            readonly expiresAt: Schema.String;
-            readonly partNumber: Schema.Int;
-        }>>;
-    }>]>>;
-}>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"AdmitChild", Schema.Struct<{
+export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"AdmitChild", Schema.Struct<{
     lease: Schema.Struct<{
         readonly workUnitId: Schema.String;
         readonly leaseOwnerId: Schema.String;
@@ -2739,7 +2641,7 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"Signals", Schema.Str
             readonly truncated: Schema.Boolean;
         }>>;
         readonly harnessHold: Schema.optionalKey<Schema.Struct<{
-            readonly reason: Schema.Literals<readonly ["out_of_quota", "failed_to_start"]>;
+            readonly reason: Schema.Literals<readonly ["out_of_quota", "rate_limited", "login_refused", "failed_to_start"]>;
             readonly until: Schema.optionalKey<Schema.String>;
             readonly scope: Schema.optionalKey<Schema.Literal<"step">>;
         }>>;
@@ -2800,7 +2702,47 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"Signals", Schema.Str
     readonly byteSize: Schema.Int;
     readonly sha256: Schema.String;
     readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
-}>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreatePlanTasks", Schema.Struct<{
+}>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreateCheckpointFile", Schema.Struct<{
+    lease: Schema.Struct<{
+        readonly workUnitId: Schema.String;
+        readonly leaseOwnerId: Schema.String;
+        readonly runnerReplicaId: Schema.String;
+        readonly leaseId: Schema.String;
+        readonly attempt: Schema.Int;
+        readonly fencingToken: Schema.String;
+        readonly capacitySlot: Schema.String;
+    }>;
+    byteSize: Schema.Int;
+    sha256: Schema.String;
+}>, Schema.Struct<{
+    readonly file: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly runId: Schema.String;
+        readonly step: Schema.String;
+        readonly name: Schema.String;
+        readonly caption: Schema.optionalKey<Schema.String>;
+        readonly contentType: Schema.String;
+        readonly kind: Schema.Literals<readonly ["image", "video", "html", "text", "other"]>;
+        readonly byteSize: Schema.Int;
+        readonly sha256: Schema.String;
+        readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
+    }>;
+    readonly upload: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+        readonly url: Schema.String;
+        readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly expiresAt: Schema.String;
+        readonly kind: Schema.Literal<"single">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"multipart">;
+        readonly partSize: Schema.Int;
+        readonly parts: Schema.$Array<Schema.Struct<{
+            readonly url: Schema.String;
+            readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly expiresAt: Schema.String;
+            readonly partNumber: Schema.Int;
+        }>>;
+    }>]>>;
+}>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreatePlanTasks", Schema.Struct<{
     lease: Schema.Struct<{
         readonly workUnitId: Schema.String;
         readonly leaseOwnerId: Schema.String;
@@ -2822,7 +2764,51 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"Signals", Schema.Str
 }>, Schema.$Array<Schema.Struct<{
     readonly key: Schema.String;
     readonly taskId: Schema.String;
-}>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"DeferredDone", Schema.Struct<{
+}>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"CreateRunFile", Schema.Struct<{
+    lease: Schema.Struct<{
+        readonly workUnitId: Schema.String;
+        readonly leaseOwnerId: Schema.String;
+        readonly runnerReplicaId: Schema.String;
+        readonly leaseId: Schema.String;
+        readonly attempt: Schema.Int;
+        readonly fencingToken: Schema.String;
+        readonly capacitySlot: Schema.String;
+    }>;
+    step: Schema.String;
+    name: Schema.String;
+    caption: Schema.optional<Schema.String>;
+    contentType: Schema.String;
+    byteSize: Schema.Int;
+    sha256: Schema.String;
+}>, Schema.Struct<{
+    readonly file: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly runId: Schema.String;
+        readonly step: Schema.String;
+        readonly name: Schema.String;
+        readonly caption: Schema.optionalKey<Schema.String>;
+        readonly contentType: Schema.String;
+        readonly kind: Schema.Literals<readonly ["image", "video", "html", "text", "other"]>;
+        readonly byteSize: Schema.Int;
+        readonly sha256: Schema.String;
+        readonly status: Schema.Literals<readonly ["uploading", "available", "rejected", "refused", "removing", "removed", "expired"]>;
+    }>;
+    readonly upload: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+        readonly url: Schema.String;
+        readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly expiresAt: Schema.String;
+        readonly kind: Schema.Literal<"single">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"multipart">;
+        readonly partSize: Schema.Int;
+        readonly parts: Schema.$Array<Schema.Struct<{
+            readonly url: Schema.String;
+            readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly expiresAt: Schema.String;
+            readonly partNumber: Schema.Int;
+        }>>;
+    }>]>>;
+}>, Schema.Union<readonly [typeof RunnerRpcError, typeof RunFileRefused]>, typeof RunnerAuthentication, never> | Rpc.Rpc<"DeferredDone", Schema.Struct<{
     lease: Schema.Struct<{
         readonly workUnitId: Schema.String;
         readonly leaseOwnerId: Schema.String;
@@ -3143,6 +3129,8 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"Signals", Schema.Str
     }>>;
     /** Taken when the Run is unattended, or when nobody answers within `timeoutMillis`. */
     default: Schema.optional<Schema.String>;
+    /** Taken at once when the Run's Team delivers in full auto. */
+    auto: Schema.optional<Schema.String>;
     timeoutMillis: Schema.optional<Schema.Finite>;
     deferredName: Schema.String;
 }>, Schema.Struct<{
@@ -3401,7 +3389,25 @@ export declare const RunnerRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"Signals", Schema.Str
     }>>;
 }>>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"SettledRuns", Schema.Struct<{
     runIds: Schema.$Array<Schema.String>;
-}>, Schema.$Array<Schema.String>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartAgentStep", Schema.Struct<{
+}>, Schema.$Array<Schema.String>, typeof RunnerRpcError, typeof RunnerAuthentication, never> | Rpc.Rpc<"Signals", Schema.Struct<{
+    runnerReplicaId: Schema.String;
+}>, import("effect/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.TaggedStruct<"WorkAvailable", {}>, Schema.TaggedStruct<"LeaseRevoked", {
+    readonly workUnitId: Schema.String;
+}>, Schema.TaggedStruct<"Settled", {
+    readonly workUnitId: Schema.String;
+}>, Schema.TaggedStruct<"Canceled", {
+    readonly workUnitId: Schema.String;
+}>, Schema.TaggedStruct<"RunSettled", {
+    readonly runId: Schema.String;
+}>, Schema.TaggedStruct<"Steer", {
+    readonly workUnitId: Schema.String;
+    readonly messageId: Schema.String;
+    readonly text: Schema.String;
+}>, Schema.TaggedStruct<"SessionUpdated", {
+    readonly workUnitId: Schema.String;
+}>, Schema.TaggedStruct<"UpdateAvailable", {
+    readonly version: Schema.String;
+}>]>, typeof RunnerRpcError>, Schema.Never, typeof RunnerAuthentication, never> | Rpc.Rpc<"StartAgentStep", Schema.Struct<{
     lease: Schema.Struct<{
         readonly workUnitId: Schema.String;
         readonly leaseOwnerId: Schema.String;

package/types/packages/sdk/src/loop/steps.d.ts

@@ -132,6 +132,8 @@ export type QuestionLaunch = Launch & QuestionAdvice & {
     readonly options?: readonly string[];
     /** Taken when the Run is unattended, or when nobody answers within `timeoutMillis`. */
     readonly default?: string;
+    /** Taken at once, with nobody asked, when the Run's Team delivers in full auto. */
+    readonly auto?: string;
     readonly timeoutMillis?: number;
     /** Approving the Question approves this verification. */
     readonly verification?: SuggestedVerification;
@@ -252,6 +254,11 @@ export declare const agentWorkOnce: <Out>(name: string, options: Parameters<type
 type Fallback<Value extends string> = {
     readonly default?: Value | null;
     readonly timeout?: Duration.Input;
+    /**
+     * The answer Kitman takes at once, asking nobody, when the Run's Team delivers in full auto. Only for a decision a
+     * full-auto Team has handed to the Loop, such as merging a change its Review passed.
+     */
+    readonly auto?: Value;
 };
 /** The answer the Loop would pick and why, in one or two sentences. */
 type Recommended<Value extends string> = {

package/types/packages/sdk/src/loop/test-loop.d.ts

@@ -52,6 +52,8 @@ export type TestLoopScript = {
     readonly answers?: {
         readonly [step: string]: string;
     };
+    /** Runs as a full-auto Team's Run: an unscripted Question with a full-auto answer takes it. */
+    readonly fullAuto?: boolean;
     readonly children?: {
         readonly [step: string]: Scripted;
     };

package/types/packages/sdk/src/program/engine.d.ts

@@ -42,6 +42,7 @@ export type ProgramCapabilities = {
         readonly options?: readonly string[];
         readonly verification?: SuggestedVerification;
         readonly default?: string;
+        readonly auto?: string;
         readonly timeoutMillis?: number;
         readonly deferredName: string;
     }) => Effect.Effect<{