@kitman-sh/sdk 0.9.0 → 0.10.52

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

@@ -3,51 +3,198 @@ import { type ProgramRpcClient } from '../../../live/src/rpc/runner-client';
 import * as Effect from 'effect/Effect';
 import * as Option from 'effect/Option';
 import * as Schema from 'effect/Schema';
-import type { PackageConfig } from '../loop/config';
+import type { KitConfig } from '../loop/config';
 import { ManifestInvalid } from '../loop/define';
 import { type ProgramJournal } from './engine';
 /** Asks a bundle for its declarations and check results instead of running a program. */
 export declare const describeFlag = "--kitman-describe";
+/** Each Kit the bundle carries, the built Kit first, or the first refusal. */
 export declare const Described: Schema.Union<readonly [Schema.TaggedStruct<"Described", {
-    readonly loops: Schema.$Array<Schema.Struct<{
-        readonly id: Schema.String;
-        readonly title: Schema.String;
-        readonly input: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-        readonly output: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-        readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["feature", "bug", "refactor", "investigation", "docs", "migration"]>>;
-        readonly agents: Schema.$Record<Schema.String, Schema.String>;
-        readonly checkout: Schema.Literals<readonly ["none", "read", "write"]>;
-        readonly when: Schema.$Array<Schema.Struct<{
-            readonly event: Schema.String;
-            readonly filter: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
-            readonly input: Schema.$Record<Schema.String, Schema.String>;
-        }>>;
-        readonly offers: Schema.$Array<Schema.Struct<{
+    readonly kits: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly version: Schema.String;
+        readonly loops: Schema.$Array<Schema.Struct<{
             readonly id: Schema.String;
             readonly title: Schema.String;
-            readonly loop: Schema.String;
+            readonly version: Schema.optionalKey<Schema.String>;
+            readonly input: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly output: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["feature", "bug", "refactor", "investigation", "docs", "migration", "performance"]>>;
+            readonly agents: Schema.$Record<Schema.String, Schema.String>;
+            readonly checkout: Schema.Literals<readonly ["none", "read", "write"]>;
+            readonly when: Schema.$Array<Schema.Struct<{
+                readonly event: Schema.String;
+                readonly filter: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>, Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.Null]>>]>>>;
+                readonly input: Schema.$Record<Schema.String, Schema.String>;
+                readonly values: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>>;
+            readonly offers: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly title: Schema.String;
+                readonly loop: Schema.String;
+                readonly from: Schema.optionalKey<Schema.String>;
+            }>>;
+            readonly capabilities: Schema.$Array<Schema.Literals<readonly ["agent_work", "ask", "call", "verify", "change_request", "write_back", "post_comment", "create_tasks", "merge_change_request", "approve_change_request", "publish_release", "read_transcripts", "read_change_request", "measure", "claim", "propose", "read_project", "draft_update"]>>;
+            readonly secrets: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly network: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+                readonly hosts: Schema.$Array<Schema.String>;
+            }>, Schema.Literal<"open">]>>;
+            readonly schedule: Schema.optionalKey<Schema.Struct<{
+                readonly rule: Schema.Union<readonly [Schema.Struct<{
+                    readonly frequency: Schema.Literals<readonly ["daily", "weekly"]>;
+                    readonly hour: Schema.Int;
+                    readonly minute: Schema.Int;
+                    readonly second: Schema.optionalKey<Schema.Int>;
+                    readonly daysOfWeek: Schema.optionalKey<Schema.$Array<Schema.Int>>;
+                }>, Schema.Struct<{
+                    readonly cron: Schema.String;
+                }>]>;
+                readonly timezone: Schema.String;
+            }>>;
         }>>;
-        readonly capabilities: Schema.$Array<Schema.Literals<readonly ["agent_work", "ask", "call", "verify", "change_request", "write_back", "post_comment", "create_tasks", "merge_change_request", "publish_release", "read_transcripts", "propose", "read_project", "draft_update"]>>;
-        readonly secrets: Schema.optionalKey<Schema.$Array<Schema.String>>;
-        readonly network: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
-            readonly hosts: Schema.$Array<Schema.String>;
-        }>, Schema.Literal<"open">]>>;
-        readonly schedule: Schema.optionalKey<Schema.Struct<{
-            readonly rule: Schema.Union<readonly [Schema.Struct<{
-                readonly frequency: Schema.Literals<readonly ["daily", "weekly"]>;
-                readonly hour: Schema.Int;
-                readonly minute: Schema.Int;
-                readonly second: Schema.optionalKey<Schema.Int>;
-                readonly daysOfWeek: Schema.optionalKey<Schema.$Array<Schema.Int>>;
+        readonly agents: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly schedules: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly setup: Schema.optionalKey<Schema.Struct<{
+            readonly skills: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly policy: Schema.Union<readonly [Schema.Literal<"recommended">, Schema.Literal<"required">]>;
+                readonly source: Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"skills_sh">;
+                    readonly slug: Schema.String;
+                    readonly version: Schema.optionalKey<Schema.String>;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"kitman">;
+                    readonly skillId: Schema.optionalKey<Schema.String>;
+                    readonly name: Schema.optionalKey<Schema.String>;
+                    readonly contentMarkdown: Schema.optionalKey<Schema.String>;
+                    readonly files: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"git">;
+                    readonly url: Schema.String;
+                    readonly ref: Schema.optionalKey<Schema.String>;
+                    readonly path: Schema.optionalKey<Schema.String>;
+                    readonly sha256: Schema.optionalKey<Schema.String>;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"package">;
+                    readonly packageName: Schema.String;
+                    readonly version: Schema.String;
+                    readonly path: Schema.optionalKey<Schema.String>;
+                    readonly sha256: Schema.optionalKey<Schema.String>;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"url">;
+                    readonly url: Schema.String;
+                    readonly sha256: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"local_path">;
+                    readonly path: Schema.String;
+                }>]>;
+                readonly appliesTo: Schema.optionalKey<Schema.Struct<{
+                    readonly dependencies: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly files: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                }>>;
+            }>>>;
+            readonly plugins: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly policy: Schema.Union<readonly [Schema.Literal<"recommended">, Schema.Literal<"required">]>;
+                readonly sources: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"package">;
+                    readonly packageName: Schema.String;
+                    readonly version: Schema.optionalKey<Schema.String>;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"git">;
+                    readonly url: Schema.String;
+                    readonly ref: Schema.optionalKey<Schema.String>;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"url">;
+                    readonly url: Schema.String;
+                    readonly sha256: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"local_path">;
+                    readonly path: Schema.String;
+                }>]>>;
+            }>>>;
+            readonly mcpServers: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly policy: Schema.Union<readonly [Schema.Literal<"recommended">, Schema.Literal<"required">]>;
+                readonly transport: Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"stdio">;
+                    readonly command: Schema.String;
+                    readonly args: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly env: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"streamable_http">;
+                    readonly url: Schema.String;
+                    readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                }>]>;
+            }>>>;
+            readonly harnessSettings: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly harness: Schema.Union<readonly [Schema.Literal<"opencode">, Schema.Literal<"claude-code">, Schema.Literal<"codex">, Schema.Literal<"pi">]>;
+                readonly key: Schema.String;
+                readonly policy: Schema.Union<readonly [Schema.Literal<"recommended">, Schema.Literal<"required">]>;
+                readonly value: Schema.Unknown;
+            }>>>;
+            readonly providerAuthRefs: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly provider: Schema.String;
+                readonly policy: Schema.Union<readonly [Schema.Literal<"recommended">, Schema.Literal<"required">]>;
+                readonly kind: Schema.Literal<"existing_harness_login">;
+                readonly accountHint: Schema.optionalKey<Schema.String>;
+            }>, Schema.Struct<{
+                readonly provider: Schema.String;
+                readonly policy: Schema.Union<readonly [Schema.Literal<"recommended">, Schema.Literal<"required">]>;
+                readonly kind: Schema.Literal<"local_env">;
+                readonly envName: Schema.String;
             }>, Schema.Struct<{
-                readonly cron: Schema.String;
-            }>]>;
-            readonly timezone: Schema.String;
+                readonly provider: Schema.String;
+                readonly policy: Schema.Union<readonly [Schema.Literal<"recommended">, Schema.Literal<"required">]>;
+                readonly kind: Schema.Literal<"runner_secret">;
+                readonly runnerSecretName: Schema.String;
+            }>, Schema.Struct<{
+                readonly provider: Schema.String;
+                readonly policy: Schema.Union<readonly [Schema.Literal<"recommended">, Schema.Literal<"required">]>;
+                readonly kind: Schema.Literal<"managed_oauth">;
+                readonly grantId: Schema.optionalKey<Schema.String>;
+            }>]>>>;
+            readonly runnerSecretRefs: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly policy: Schema.Union<readonly [Schema.Literal<"recommended">, Schema.Literal<"required">]>;
+                readonly source: Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"env">;
+                    readonly envName: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"file">;
+                    readonly pathRef: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"exec">;
+                    readonly commandRef: Schema.String;
+                }>]>;
+                readonly capabilities: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            }>>>;
+            readonly permissions: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly key: Schema.String;
+                readonly policy: Schema.Union<readonly [Schema.Literal<"recommended">, Schema.Literal<"required">]>;
+                readonly value: Schema.Unknown;
+            }>>>;
+            readonly hooks: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly event: Schema.String;
+                readonly policy: Schema.Union<readonly [Schema.Literal<"recommended">, Schema.Literal<"required">]>;
+                readonly command: Schema.String;
+                readonly args: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly timeoutMs: Schema.optionalKey<Schema.Finite>;
+            }>>>;
+            readonly runtimeConstraints: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly key: Schema.String;
+                readonly policy: Schema.Union<readonly [Schema.Literal<"recommended">, Schema.Literal<"required">]>;
+                readonly value: Schema.Unknown;
+            }>>>;
+            readonly sandboxPolicyRequirements: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly key: Schema.String;
+                readonly policy: Schema.Union<readonly [Schema.Literal<"recommended">, Schema.Literal<"required">]>;
+                readonly value: Schema.Unknown;
+            }>>>;
+            readonly instructions: Schema.optionalKey<Schema.String>;
         }>>;
     }>>;
-    readonly agents: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-    readonly schedules: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-    readonly kits: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
 }>, Schema.TaggedStruct<"Refused", {
     readonly error: Schema.Union<readonly [typeof ManifestInvalid, Schema.Union<readonly [typeof import("../loop").CheckFailed, typeof import("../loop").StepNamedTwice, typeof import("../loop").ReplayDiverged]>]>;
 }>]>;
@@ -77,6 +224,21 @@ export declare const networkGuard: (input: {
     fetch: Fetch;
     journal: <Journal extends Pick<ProgramJournal, 'suspend' | 'finish'>>(journal: Journal) => Journal;
 };
-/** The entry of every Package bundle. */
-export declare const runPackage: (config: PackageConfig) => void;
+/** A Kit's package name and version, as its build reads them from `package.json`. */
+export type KitIdentity = {
+    readonly name: string;
+    readonly version: string;
+};
+type CarriedKit = {
+    readonly identity: KitIdentity;
+    readonly config: KitConfig;
+};
+/**
+ * The Kit and each Kit it extends, in priority order: the Kit, then each `extends` entry and what it extends, in turn.
+ * A Kit met twice keeps its first place and its highest version. `packages` names each Kit module the build found; a
+ * Kit in `extends` that none names is refused.
+ */
+export declare const carriedKits: (config: KitConfig, identity: KitIdentity, packages: readonly (readonly [KitConfig, KitIdentity])[]) => readonly CarriedKit[];
+/** The entry of every Kit bundle, given the Kit's identity and that of each Kit package it depends on. */
+export declare const runKit: (config: KitConfig, identity: KitIdentity, packages: readonly (readonly [KitConfig, KitIdentity])[]) => void;
 export {};

package/types/packages/core/src/engineering-resources.d.ts

@@ -1,24 +0,0 @@
-import type { KitCreate } from './kit';
-declare const marketplace: {
-    readonly source: 'kitman-engineering-loop';
-    readonly publisher: 'Kitman Platform';
-    readonly visibility: 'public';
-    readonly trusted: true;
-    readonly reviewStatus: 'approved';
-    readonly installable: true;
-    readonly rollout: {
-        readonly channel: 'default';
-        readonly installDefault: true;
-        readonly preservesExistingInstallations: true;
-    };
-};
-type ShippedKit = Omit<KitCreate, 'metadata' | 'kind' | 'slug'> & {
-    readonly slug: string;
-    readonly kind: 'process' | 'technology';
-    readonly metadata: {
-        readonly marketplace: typeof marketplace;
-    };
-};
-/** The Kits every Workspace gets by default: the owner's Claude Code setup, for every Harness, at the latest versions. */
-export declare const ShippedKitCatalog: readonly ShippedKit[];
-export {};

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

@@ -1,369 +0,0 @@
-import * as Schema from 'effect/Schema';
-/** A Package's name, from its `package.json`. */
-export declare const PackageName: Schema.String;
-export declare const PackageDigest: Schema.String;
-export declare const PackageLayer: Schema.Union<readonly [Schema.Literal<"team">, Schema.Literal<"workspace">, Schema.Literal<"shipped">]>;
-export type PackageLayer = (typeof PackageLayer)['Type'];
-export declare const PackageProvenance: Schema.Struct<{
-    readonly repository: Schema.optionalKey<Schema.String>;
-    readonly commit: Schema.optionalKey<Schema.String>;
-    readonly clean: Schema.Boolean;
-}>;
-export type PackageProvenance = (typeof PackageProvenance)['Type'];
-/** A built bundle, base64-encoded. */
-export declare const PackageBundleUpload: Schema.Struct<{
-    readonly bundle: Schema.String;
-}>;
-export type PackageBundleUpload = (typeof PackageBundleUpload)['Type'];
-/** A Package already built and its bundle uploaded, to plan. */
-export declare const PackagePlanRequest: Schema.Struct<{
-    name: Schema.String;
-    /** The Team layer; without it, the Workspace's. */
-    teamId: Schema.optionalKey<Schema.String>;
-    digest: Schema.String;
-    /** As the build read them out: `loops`, `agents`, and any other kind the Package declares. */
-    declarations: Schema.$Record<Schema.String, Schema.Unknown>;
-    protocolVersion: Schema.Int;
-    provenance: Schema.Struct<{
-        readonly repository: Schema.optionalKey<Schema.String>;
-        readonly commit: Schema.optionalKey<Schema.String>;
-        readonly clean: Schema.Boolean;
-    }>;
-}>;
-export type PackagePlanRequest = (typeof PackagePlanRequest)['Type'];
-/** Deploys against the version the plan was made from; `null` when the Package has none yet. */
-export declare const PackageDeployRequest: Schema.Struct<{
-    readonly name: Schema.String;
-    readonly teamId: Schema.optionalKey<Schema.String>;
-    readonly digest: Schema.String;
-    readonly declarations: Schema.$Record<Schema.String, Schema.Unknown>;
-    readonly protocolVersion: Schema.Int;
-    readonly provenance: Schema.Struct<{
-        readonly repository: Schema.optionalKey<Schema.String>;
-        readonly commit: Schema.optionalKey<Schema.String>;
-        readonly clean: Schema.Boolean;
-    }>;
-    readonly expectedVersion: Schema.Union<readonly [Schema.Int, Schema.Null]>;
-}>;
-export type PackageDeployRequest = (typeof PackageDeployRequest)['Type'];
-/** A build of the author's working tree, to run with `kitman dev` and resolve for no one. */
-export declare const PackageDevRequest: Schema.Struct<{
-    digest: Schema.String;
-    /** As the build read them out: `loops`, `agents`, and any other kind the Package declares. */
-    declarations: Schema.$Record<Schema.String, Schema.Unknown>;
-    protocolVersion: Schema.Int;
-    provenance: Schema.Struct<{
-        readonly repository: Schema.optionalKey<Schema.String>;
-        readonly commit: Schema.optionalKey<Schema.String>;
-        readonly clean: Schema.Boolean;
-    }>;
-}>;
-export type PackageDevRequest = (typeof PackageDevRequest)['Type'];
-export declare const PackageDevVersion: Schema.Struct<{
-    readonly id: Schema.String;
-    readonly digest: Schema.String;
-    readonly loops: Schema.$Array<Schema.String>;
-}>;
-export type PackageDevVersion = (typeof PackageDevVersion)['Type'];
-/** A field of a Package-owned record edited since the deploy, which the next deploy resets. */
-export declare const PackageDrift: Schema.Struct<{
-    readonly kind: Schema.Union<readonly [Schema.Literal<"schedule">, Schema.Literal<"kit">, Schema.Literal<"kit_installation">, Schema.Literal<"kit_assignment">]>;
-    readonly key: Schema.String;
-    readonly field: Schema.String;
-    /** As the Package last deployed it. */
-    readonly declared: Schema.Unknown;
-    readonly live: Schema.Unknown;
-    readonly changedBy: Schema.optionalKey<Schema.Struct<{
-        readonly actorType: Schema.String;
-        readonly actorId: Schema.String;
-    }>>;
-    readonly changedAt: Schema.optionalKey<Schema.String>;
-}>;
-export type PackageDrift = (typeof PackageDrift)['Type'];
-export declare const PackagePlanResult: Schema.Struct<{
-    readonly name: Schema.String;
-    readonly layer: Schema.Union<readonly [Schema.Literal<"team">, Schema.Literal<"workspace">, Schema.Literal<"shipped">]>;
-    readonly currentVersion: Schema.Union<readonly [Schema.Int, Schema.Null]>;
-    /** The commit the current version was built from; a deploy must descend from it. */
-    readonly currentCommit: Schema.optionalKey<Schema.String>;
-    readonly loops: Schema.Struct<{
-        readonly created: Schema.$Array<Schema.String>;
-        readonly changed: Schema.$Array<Schema.String>;
-        readonly removed: Schema.$Array<Schema.String>;
-    }>;
-    readonly agents: Schema.Struct<{
-        readonly created: Schema.$Array<Schema.String>;
-        readonly changed: Schema.$Array<Schema.String>;
-        readonly removed: Schema.$Array<Schema.String>;
-    }>;
-    readonly schedules: Schema.Struct<{
-        readonly created: Schema.$Array<Schema.String>;
-        readonly changed: Schema.$Array<Schema.String>;
-        readonly removed: Schema.$Array<Schema.String>;
-        /** Unowned records of the same name a first deploy takes over, by key. */
-        readonly adopted: Schema.$Array<Schema.Struct<{
-            readonly key: Schema.String;
-            readonly id: Schema.String;
-        }>>;
-    }>;
-    readonly kits: Schema.Struct<{
-        readonly created: Schema.$Array<Schema.String>;
-        readonly changed: Schema.$Array<Schema.String>;
-        readonly removed: Schema.$Array<Schema.String>;
-        /** Unowned records of the same name a first deploy takes over, by key. */
-        readonly adopted: Schema.$Array<Schema.Struct<{
-            readonly key: Schema.String;
-            readonly id: Schema.String;
-        }>>;
-    }>;
-    readonly kitInstallations: Schema.Struct<{
-        readonly created: Schema.$Array<Schema.String>;
-        readonly changed: Schema.$Array<Schema.String>;
-        readonly removed: Schema.$Array<Schema.String>;
-        /** Unowned records of the same name a first deploy takes over, by key. */
-        readonly adopted: Schema.$Array<Schema.Struct<{
-            readonly key: Schema.String;
-            readonly id: Schema.String;
-        }>>;
-    }>;
-    readonly kitAssignments: Schema.Struct<{
-        readonly created: Schema.$Array<Schema.String>;
-        readonly changed: Schema.$Array<Schema.String>;
-        readonly removed: Schema.$Array<Schema.String>;
-        /** Unowned records of the same name a first deploy takes over, by key. */
-        readonly adopted: Schema.$Array<Schema.Struct<{
-            readonly key: Schema.String;
-            readonly id: Schema.String;
-        }>>;
-    }>;
-    readonly drift: Schema.$Array<Schema.Struct<{
-        readonly kind: Schema.Union<readonly [Schema.Literal<"schedule">, Schema.Literal<"kit">, Schema.Literal<"kit_installation">, Schema.Literal<"kit_assignment">]>;
-        readonly key: Schema.String;
-        readonly field: Schema.String;
-        /** As the Package last deployed it. */
-        readonly declared: Schema.Unknown;
-        readonly live: Schema.Unknown;
-        readonly changedBy: Schema.optionalKey<Schema.Struct<{
-            readonly actorType: Schema.String;
-            readonly actorId: Schema.String;
-        }>>;
-        readonly changedAt: Schema.optionalKey<Schema.String>;
-    }>>;
-    readonly conflicts: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-        readonly kind: Schema.Literal<"id_taken">;
-        readonly resource: Schema.Union<readonly [Schema.Literal<"loop">, Schema.Literal<"agent">]>;
-        readonly id: Schema.String;
-        readonly package: Schema.String;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"not_for_team">;
-        readonly declaration: Schema.String;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"schedule_team">;
-        readonly key: Schema.String;
-        readonly problem: Schema.Union<readonly [Schema.Literal<"missing">, Schema.Literal<"not_allowed">, Schema.Literal<"unknown">]>;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"loop_unresolved">;
-        readonly record: Schema.Literal<"schedule">;
-        readonly key: Schema.String;
-        readonly loop: Schema.String;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"kit_unresolved">;
-        readonly record: Schema.Union<readonly [Schema.Literal<"agent">, Schema.Literal<"kit_assignment">]>;
-        readonly key: Schema.String;
-        readonly kit: Schema.String;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"kit_source">;
-        readonly key: Schema.String;
-        readonly problem: Schema.Union<readonly [Schema.Literal<"unknown">, Schema.Literal<"untrusted">, Schema.Literal<"version_unknown">]>;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"kit_policy_disabled">;
-        readonly key: Schema.String;
-    }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"kit_team_unknown">;
-        readonly key: Schema.String;
-        readonly team: Schema.String;
-    }>]>>;
-    /** Loops and Agents the deploy removes that records outside the Package still name. */
-    readonly warnings: Schema.$Array<Schema.Struct<{
-        readonly kind: Schema.Literal<"still_named">;
-        readonly resource: Schema.Union<readonly [Schema.Literal<"loop">, Schema.Literal<"agent">]>;
-        readonly id: Schema.String;
-        readonly record: Schema.String;
-    }>>;
-    /** Declared Secrets with no value in the Package's layer; a Run that reads one is refused. */
-    readonly secretsWithoutValue: Schema.$Array<Schema.String>;
-}>;
-export type PackagePlanResult = (typeof PackagePlanResult)['Type'];
-export declare const PackageVersionSummary: Schema.Struct<{
-    readonly number: Schema.Int;
-    readonly digest: Schema.String;
-    readonly protocolVersion: Schema.Int;
-    readonly provenance: Schema.Struct<{
-        readonly repository: Schema.optionalKey<Schema.String>;
-        readonly commit: Schema.optionalKey<Schema.String>;
-        readonly clean: Schema.Boolean;
-    }>;
-    readonly deployedByActorType: Schema.Union<readonly [Schema.Literal<"human">, Schema.Literal<"delegated_agent">, Schema.Literal<"agent">]>;
-    readonly deployedByActorId: Schema.String;
-    /** The Deploy Binding a pipeline deployed it through; a person deployed it when absent. */
-    readonly deployBindingId: Schema.optionalKey<Schema.String>;
-    readonly deployedAt: Schema.String;
-    readonly status: Schema.Union<readonly [Schema.Literal<"current">, Schema.Literal<"superseded">, Schema.Literal<"dev">, Schema.Literal<"removed">]>;
-}>;
-export type PackageVersionSummary = (typeof PackageVersionSummary)['Type'];
-export declare const PackageSummary: Schema.Struct<{
-    name: Schema.String;
-    layer: Schema.Union<readonly [Schema.Literal<"team">, Schema.Literal<"workspace">, Schema.Literal<"shipped">]>;
-    teamId: Schema.optionalKey<Schema.String>;
-    current: Schema.optionalKey<Schema.Struct<{
-        readonly number: Schema.Int;
-        readonly digest: Schema.String;
-        readonly protocolVersion: Schema.Int;
-        readonly provenance: Schema.Struct<{
-            readonly repository: Schema.optionalKey<Schema.String>;
-            readonly commit: Schema.optionalKey<Schema.String>;
-            readonly clean: Schema.Boolean;
-        }>;
-        readonly deployedByActorType: Schema.Union<readonly [Schema.Literal<"human">, Schema.Literal<"delegated_agent">, Schema.Literal<"agent">]>;
-        readonly deployedByActorId: Schema.String;
-        /** The Deploy Binding a pipeline deployed it through; a person deployed it when absent. */
-        readonly deployBindingId: Schema.optionalKey<Schema.String>;
-        readonly deployedAt: Schema.String;
-        readonly status: Schema.Union<readonly [Schema.Literal<"current">, Schema.Literal<"superseded">, Schema.Literal<"dev">, Schema.Literal<"removed">]>;
-    }>>;
-    loops: Schema.$Array<Schema.String>;
-    agents: Schema.$Array<Schema.String>;
-}>;
-export type PackageSummary = (typeof PackageSummary)['Type'];
-export declare const PackageList: Schema.Struct<{
-    readonly items: Schema.$Array<Schema.Struct<{
-        name: Schema.String;
-        layer: Schema.Union<readonly [Schema.Literal<"team">, Schema.Literal<"workspace">, Schema.Literal<"shipped">]>;
-        teamId: Schema.optionalKey<Schema.String>;
-        current: Schema.optionalKey<Schema.Struct<{
-            readonly number: Schema.Int;
-            readonly digest: Schema.String;
-            readonly protocolVersion: Schema.Int;
-            readonly provenance: Schema.Struct<{
-                readonly repository: Schema.optionalKey<Schema.String>;
-                readonly commit: Schema.optionalKey<Schema.String>;
-                readonly clean: Schema.Boolean;
-            }>;
-            readonly deployedByActorType: Schema.Union<readonly [Schema.Literal<"human">, Schema.Literal<"delegated_agent">, Schema.Literal<"agent">]>;
-            readonly deployedByActorId: Schema.String;
-            /** The Deploy Binding a pipeline deployed it through; a person deployed it when absent. */
-            readonly deployBindingId: Schema.optionalKey<Schema.String>;
-            readonly deployedAt: Schema.String;
-            readonly status: Schema.Union<readonly [Schema.Literal<"current">, Schema.Literal<"superseded">, Schema.Literal<"dev">, Schema.Literal<"removed">]>;
-        }>>;
-        loops: Schema.$Array<Schema.String>;
-        agents: Schema.$Array<Schema.String>;
-    }>>;
-}>;
-export type PackageList = (typeof PackageList)['Type'];
-/** A Package with every version, newest first. */
-export declare const PackageDetail: Schema.Struct<{
-    readonly name: Schema.String;
-    readonly layer: Schema.Union<readonly [Schema.Literal<"team">, Schema.Literal<"workspace">, Schema.Literal<"shipped">]>;
-    readonly teamId: Schema.optionalKey<Schema.String>;
-    readonly current: Schema.optionalKey<Schema.Struct<{
-        readonly number: Schema.Int;
-        readonly digest: Schema.String;
-        readonly protocolVersion: Schema.Int;
-        readonly provenance: Schema.Struct<{
-            readonly repository: Schema.optionalKey<Schema.String>;
-            readonly commit: Schema.optionalKey<Schema.String>;
-            readonly clean: Schema.Boolean;
-        }>;
-        readonly deployedByActorType: Schema.Union<readonly [Schema.Literal<"human">, Schema.Literal<"delegated_agent">, Schema.Literal<"agent">]>;
-        readonly deployedByActorId: Schema.String;
-        /** The Deploy Binding a pipeline deployed it through; a person deployed it when absent. */
-        readonly deployBindingId: Schema.optionalKey<Schema.String>;
-        readonly deployedAt: Schema.String;
-        readonly status: Schema.Union<readonly [Schema.Literal<"current">, Schema.Literal<"superseded">, Schema.Literal<"dev">, Schema.Literal<"removed">]>;
-    }>>;
-    readonly loops: Schema.$Array<Schema.String>;
-    readonly agents: Schema.$Array<Schema.String>;
-    readonly versions: Schema.$Array<Schema.Struct<{
-        readonly number: Schema.Int;
-        readonly digest: Schema.String;
-        readonly protocolVersion: Schema.Int;
-        readonly provenance: Schema.Struct<{
-            readonly repository: Schema.optionalKey<Schema.String>;
-            readonly commit: Schema.optionalKey<Schema.String>;
-            readonly clean: Schema.Boolean;
-        }>;
-        readonly deployedByActorType: Schema.Union<readonly [Schema.Literal<"human">, Schema.Literal<"delegated_agent">, Schema.Literal<"agent">]>;
-        readonly deployedByActorId: Schema.String;
-        /** The Deploy Binding a pipeline deployed it through; a person deployed it when absent. */
-        readonly deployBindingId: Schema.optionalKey<Schema.String>;
-        readonly deployedAt: Schema.String;
-        readonly status: Schema.Union<readonly [Schema.Literal<"current">, Schema.Literal<"superseded">, Schema.Literal<"dev">, Schema.Literal<"removed">]>;
-    }>>;
-    /** The Schedules the Package owns, by declared key. */
-    readonly schedules: Schema.$Array<Schema.Struct<{
-        readonly key: Schema.String;
-        readonly id: Schema.String;
-        readonly name: Schema.optionalKey<Schema.String>;
-    }>>;
-    /** The Kits, installations and assignments the Package owns, by declared key; an assignment's id is its Kit's. */
-    readonly kits: Schema.$Array<Schema.Struct<{
-        readonly kind: Schema.Union<readonly [Schema.Literal<"kit">, Schema.Literal<"kit_installation">, Schema.Literal<"kit_assignment">]>;
-        readonly key: Schema.String;
-        readonly id: Schema.String;
-    }>>;
-    readonly drift: Schema.$Array<Schema.Struct<{
-        readonly kind: Schema.Union<readonly [Schema.Literal<"schedule">, Schema.Literal<"kit">, Schema.Literal<"kit_installation">, Schema.Literal<"kit_assignment">]>;
-        readonly key: Schema.String;
-        readonly field: Schema.String;
-        /** As the Package last deployed it. */
-        readonly declared: Schema.Unknown;
-        readonly live: Schema.Unknown;
-        readonly changedBy: Schema.optionalKey<Schema.Struct<{
-            readonly actorType: Schema.String;
-            readonly actorId: Schema.String;
-        }>>;
-        readonly changedAt: Schema.optionalKey<Schema.String>;
-    }>>;
-}>;
-export type PackageDetail = (typeof PackageDetail)['Type'];
-export declare const PackageScopeQuery: Schema.Struct<{
-    readonly teamId: Schema.optionalKey<Schema.String>;
-}>;
-/** A Workspace owner's or admin's trust in one repository branch to deploy one Package to one layer from CI. */
-export declare const DeployBinding: Schema.Struct<{
-    readonly id: Schema.String;
-    readonly repoBindingId: Schema.String;
-    /** The RepoBinding's repository, as `owner/name`. */
-    readonly repository: Schema.String;
-    readonly branch: Schema.String;
-    readonly packageName: Schema.String;
-    readonly layer: Schema.Union<readonly [Schema.Literal<"team">, Schema.Literal<"workspace">, Schema.Literal<"shipped">]>;
-    readonly teamId: Schema.optionalKey<Schema.String>;
-    readonly createdByUserId: Schema.String;
-    readonly createdAt: Schema.String;
-}>;
-export type DeployBinding = (typeof DeployBinding)['Type'];
-/** Binds a RepoBinding's branch to a Package in a Team's layer, or the Workspace's without `teamId`. */
-export declare const DeployBindingCreate: Schema.Struct<{
-    readonly repoBindingId: Schema.String;
-    readonly branch: Schema.String;
-    readonly packageName: Schema.String;
-    readonly teamId: Schema.optionalKey<Schema.String>;
-}>;
-export type DeployBindingCreate = (typeof DeployBindingCreate)['Type'];
-export declare const DeployBindingList: Schema.Struct<{
-    readonly items: Schema.$Array<Schema.Struct<{
-        readonly id: Schema.String;
-        readonly repoBindingId: Schema.String;
-        /** The RepoBinding's repository, as `owner/name`. */
-        readonly repository: Schema.String;
-        readonly branch: Schema.String;
-        readonly packageName: Schema.String;
-        readonly layer: Schema.Union<readonly [Schema.Literal<"team">, Schema.Literal<"workspace">, Schema.Literal<"shipped">]>;
-        readonly teamId: Schema.optionalKey<Schema.String>;
-        readonly createdByUserId: Schema.String;
-        readonly createdAt: Schema.String;
-    }>>;
-}>;
-export type DeployBindingList = (typeof DeployBindingList)['Type'];