@kitman-sh/sdk 0.8.0 → 0.10.52

package/types/packages/core/src/{package-declarations.d.ts → kit-declarations.d.ts}

@@ -1,29 +1,33 @@
 import * as Schema from 'effect/Schema';
-import { KitKinds } from './kit';
 import type { JsonObject, JsonValue } from './runtime-type';
 import { ScheduleRule, type ScheduleMisfirePolicy, type ScheduleOverlapPolicy } from './schedule';
-export declare const LoopCapabilities: 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'];
+export declare const LoopCapabilities: 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'];
 declare const JsonObject: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
 /** What the control plane reads from a Loop without running it. */
 export declare const LoopManifest: Schema.Struct<{
     readonly id: Schema.String;
     readonly title: 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"]>>;
+    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>;
+        /** Loop Input fields every Run it starts gets, under the bound ones. */
+        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;
+        /** The Output field holding the offered Loop's Input; the offer shows only when the Output has it. */
+        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", "publish_release", "read_transcripts", "propose", "read_project", "draft_update"]>>;
+    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"]>>;
     /** The names of the Secrets the Loop reads. */
     readonly secrets: Schema.optionalKey<Schema.$Array<Schema.String>>;
     /** The hosts the program calls besides Kitman, or `open`. */
@@ -51,6 +55,7 @@ export declare const LoopDetail: Schema.Struct<{
     readonly resolved: Schema.optionalKey<Schema.Struct<{
         readonly id: Schema.String;
         readonly title: Schema.String;
+        readonly version: Schema.optionalKey<Schema.String>;
         readonly layer: Schema.Literals<readonly ["team", "workspace", "shipped"]>;
         readonly digest: Schema.String;
         readonly outcome: Schema.optionalKey<Schema.String>;
@@ -58,14 +63,17 @@ export declare const LoopDetail: Schema.Struct<{
             readonly id: Schema.String;
             readonly title: Schema.String;
             readonly loop: Schema.String;
+            readonly from: Schema.optionalKey<Schema.String>;
         }>>;
         readonly publishedAt: Schema.String;
-        readonly package: Schema.String;
+        readonly kit: Schema.String;
         readonly agents: Schema.$Record<Schema.String, Schema.String>;
         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>;
+            /** Loop Input fields every Run it starts gets, under the bound ones. */
+            readonly values: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
         }>>;
         /** The Schedule the Loop offers: whether this Workspace turned it on, and when it next runs. */
         readonly schedule: Schema.optionalKey<Schema.Struct<{
@@ -85,21 +93,27 @@ export declare const LoopDetail: Schema.Struct<{
     }>>;
 }>;
 export type LoopDetail = (typeof LoopDetail)['Type'];
-/** An Agent as a Package declares it, with its instructions already read from the repository. */
+/** An Agent as a Kit declares it, with its instructions already read from the repository. */
 export declare const AgentDeclaration: Schema.Struct<{
     readonly extends: Schema.optionalKey<Schema.String>;
     readonly instructions: Schema.optionalKey<Schema.String>;
     readonly harness: Schema.optionalKey<Schema.String>;
     readonly model: Schema.optionalKey<Schema.String>;
     readonly effort: Schema.optionalKey<Schema.Literals<readonly ["low", "medium", "high", "xhigh"]>>;
-    readonly kits: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly fallbacks: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly harness: Schema.String;
+        readonly model: Schema.optionalKey<Schema.String>;
+        readonly effort: Schema.optionalKey<Schema.Literals<readonly ["low", "medium", "high", "xhigh"]>>;
+    }>>>;
+    readonly tools: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["web", "subagents", "artifacts", "browser"]>>>;
+    readonly skills: 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 sandbox: Schema.optionalKey<Schema.Literal<"docker">>;
 }>;
 export type AgentDeclaration = typeof AgentDeclaration.Type;
-/** A recurring start of a Loop, as a Package declares it: by cron, or by a daily or weekly calendar rule. */
+/** A recurring start of a Loop, as a Kit declares it: by cron, or by a daily or weekly calendar rule. */
 export declare const ScheduleDeclaration: Schema.Union<readonly [Schema.Struct<{
     readonly name: Schema.String;
     readonly loop: Schema.String;
@@ -129,69 +143,41 @@ export declare const ScheduleDeclaration: Schema.Union<readonly [Schema.Struct<{
     }, unknown>;
 }>]>;
 export type ScheduleDeclaration = typeof ScheduleDeclaration.Type;
-/** A Kit the Package writes from its own files: context text, and each skill's files by path, `SKILL.md` among them. */
-export declare const AuthoredKitDeclaration: Schema.Struct<{
+/** A Kit a build carries: itself or one it builds on, its setup archive's digest, and the Loops and Agents it brings. */
+export declare const CarriedKit: Schema.Struct<{
     readonly name: Schema.String;
-    readonly kind: Schema.optionalKey<Schema.Literals<readonly ["technology", "brand", "domain", "process", "other"]>>;
-    readonly description: Schema.optionalKey<Schema.String>;
-    readonly context: Schema.String;
-    readonly skills: Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.String>>>;
+    readonly version: Schema.String;
+    readonly setup: Schema.String;
+    readonly loops: Schema.$Array<Schema.String>;
+    readonly agents: Schema.$Array<Schema.String>;
 }>;
-export type AuthoredKitDeclaration = typeof AuthoredKitDeclaration.Type;
-/** A Marketplace Kit the Workspace installs, by its source's slug or id. */
-export declare const KitInstallationDeclaration: Schema.Struct<{
-    readonly source: Schema.String;
-    readonly version: Schema.optionalKey<Schema.String>;
-}>;
-export type KitInstallationDeclaration = typeof KitInstallationDeclaration.Type;
-/** Where a Kit applies: as Workspace policy, and attached to Teams by slug. */
-export declare const KitAssignmentDeclaration: Schema.Struct<{
-    /** An authored Kit's key, or an installed Kit's source slug. */
-    readonly kit: Schema.String;
-    readonly workspace: Schema.optionalKey<Schema.Literals<readonly ["default", "mandatory"]>>;
-    readonly teams: Schema.optionalKey<Schema.$Array<Schema.String>>;
-}>;
-export type KitAssignmentDeclaration = typeof KitAssignmentDeclaration.Type;
-export declare const KitDeclaration: Schema.Union<readonly [Schema.Struct<{
-    readonly source: Schema.String;
-    readonly version: Schema.optionalKey<Schema.String>;
-}>, Schema.Struct<{
-    /** An authored Kit's key, or an installed Kit's source slug. */
-    readonly kit: Schema.String;
-    readonly workspace: Schema.optionalKey<Schema.Literals<readonly ["default", "mandatory"]>>;
-    readonly teams: Schema.optionalKey<Schema.$Array<Schema.String>>;
-}>, Schema.Struct<{
-    readonly name: Schema.String;
-    readonly kind: Schema.optionalKey<Schema.Literals<readonly ["technology", "brand", "domain", "process", "other"]>>;
-    readonly description: Schema.optionalKey<Schema.String>;
-    readonly context: Schema.String;
-    readonly skills: Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.String>>>;
-}>]>;
-export type KitDeclaration = typeof KitDeclaration.Type;
-export declare const isKitInstallation: (declaration: KitDeclaration) => declaration is KitInstallationDeclaration;
-export declare const isKitAssignment: (declaration: KitDeclaration) => declaration is KitAssignmentDeclaration;
-export declare const isAuthoredKit: (declaration: KitDeclaration) => declaration is AuthoredKitDeclaration;
-/** Everything a Package declares, as its build encodes it and Kitman decodes it. */
-export declare const PackageDeclarations: Schema.Struct<{
+export type CarriedKit = typeof CarriedKit.Type;
+/** Everything a Kit declares, as its build encodes it and Kitman decodes it. */
+export declare const KitDeclarations: Schema.Struct<{
     readonly loops: Schema.$Array<Schema.Struct<{
         readonly id: Schema.String;
         readonly title: 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"]>>;
+        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>;
+            /** Loop Input fields every Run it starts gets, under the bound ones. */
+            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;
+            /** The Output field holding the offered Loop's Input; the offer shows only when the Output has it. */
+            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", "publish_release", "read_transcripts", "propose", "read_project", "draft_update"]>>;
+        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"]>>;
         /** The names of the Secrets the Loop reads. */
         readonly secrets: Schema.optionalKey<Schema.$Array<Schema.String>>;
         /** The hosts the program calls besides Kitman, or `open`. */
@@ -218,7 +204,13 @@ export declare const PackageDeclarations: 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 kits: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly fallbacks: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly harness: Schema.String;
+            readonly model: Schema.optionalKey<Schema.String>;
+            readonly effort: Schema.optionalKey<Schema.Literals<readonly ["low", "medium", "high", "xhigh"]>>;
+        }>>>;
+        readonly tools: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["web", "subagents", "artifacts", "browser"]>>>;
+        readonly skills: Schema.optionalKey<Schema.$Array<Schema.String>>;
         readonly network: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
             readonly hosts: Schema.$Array<Schema.String>;
         }>, Schema.Literal<"open">]>>;
@@ -252,37 +244,30 @@ export declare const PackageDeclarations: Schema.Struct<{
             readonly cron: string;
         }, unknown>;
     }>]>>>;
-    readonly kits: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
-        readonly source: Schema.String;
-        readonly version: Schema.optionalKey<Schema.String>;
-    }>, Schema.Struct<{
-        /** An authored Kit's key, or an installed Kit's source slug. */
-        readonly kit: Schema.String;
-        readonly workspace: Schema.optionalKey<Schema.Literals<readonly ["default", "mandatory"]>>;
-        readonly teams: Schema.optionalKey<Schema.$Array<Schema.String>>;
-    }>, Schema.Struct<{
+    /** The built Kit first, then each Kit it builds on, once. */
+    readonly carried: Schema.optionalKey<Schema.$Array<Schema.Struct<{
         readonly name: Schema.String;
-        readonly kind: Schema.optionalKey<Schema.Literals<readonly ["technology", "brand", "domain", "process", "other"]>>;
-        readonly description: Schema.optionalKey<Schema.String>;
-        readonly context: Schema.String;
-        readonly skills: Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.String>>>;
-    }>]>>>;
+        readonly version: Schema.String;
+        readonly setup: Schema.String;
+        readonly loops: Schema.$Array<Schema.String>;
+        readonly agents: Schema.$Array<Schema.String>;
+    }>>>;
 }>;
-export type PackageDeclarations = typeof PackageDeclarations.Type;
+export type KitDeclarations = typeof KitDeclarations.Type;
 /** What a deploy does to one kind of record, by id. */
-export type PackageChanges = {
+export type KitChanges = {
     readonly created: readonly string[];
     readonly changed: readonly string[];
     readonly removed: readonly string[];
 };
-/** What a deploy does to records a Package owns, by key; `adopted` names the live record each key takes over. */
-export type PackageRecordChanges = PackageChanges & {
+/** What a deploy does to records a Kit owns, by key; `adopted` names the live record each key takes over. */
+export type KitRecordChanges = KitChanges & {
     readonly adopted: readonly {
         readonly key: string;
         readonly id: string;
     }[];
 };
-/** A Schedule as it is live, and as a Package last deployed it. */
+/** A Schedule as it is live, and as a Kit last deployed it. */
 export type ScheduleRecord = {
     readonly name?: string;
     readonly loop: string;
@@ -304,56 +289,6 @@ export type RecordChange<V> = {
     };
     readonly at: string;
 };
-/** An authored Kit as it is live, and as a Package last deployed it. */
-export type AuthoredKitRecord = {
-    readonly name: string;
-    readonly slug: string;
-    readonly kind: (typeof KitKinds)[number];
-    readonly description: string | null;
-    readonly context: string;
-    readonly skills: {
-        readonly [skill: string]: {
-            readonly [path: string]: string;
-        };
-    };
-};
-/** A Workspace's installation of a Kit source, pinned to a version or following the latest. */
-export type KitInstallationRecord = {
-    readonly source: string;
-    readonly version: string | null;
-};
-/** A Kit's Workspace policy mode and the Teams it is attached to. */
-export type KitAssignmentRecord = {
-    /** As declared: an authored Kit's key or an installed Kit's source slug. */
-    readonly kit: string;
-    readonly workspace: 'default' | 'mandatory' | null;
-    readonly teams: readonly string[];
-};
-/** A Kit source the Marketplace offers the Workspace, its versions newest first. */
-export type KitSourceOption = {
-    readonly id: string;
-    readonly slug: string;
-    /** Reviewed, approved, trusted and active, as installing requires. */
-    readonly installable: boolean;
-    readonly versions: readonly {
-        readonly id: string;
-        readonly version: string;
-        readonly installable: boolean;
-        /** The Kit that carries this version's content. */
-        readonly contentKitId?: string;
-    }[];
-};
-/** The live Kit records a deploy plan reads. */
-export type KitSnapshot = {
-    readonly authored: RecordSnapshot<AuthoredKitRecord>;
-    readonly installations: RecordSnapshot<KitInstallationRecord>;
-    /** Unowned entries are keyed by the id of the Kit they assign. */
-    readonly assignments: RecordSnapshot<KitAssignmentRecord>;
-    readonly sources: readonly KitSourceOption[];
-    /** The Workspace's live installations. */
-    readonly installed: readonly KitInstallationRecord[];
-    readonly policyEnabled: boolean;
-};
 export type RecordSnapshot<V> = {
     readonly owned: readonly OwnedRecord<V>[];
     readonly unowned: readonly {
@@ -361,82 +296,62 @@ export type RecordSnapshot<V> = {
         readonly value: V;
     }[];
 };
-/** A record a Package owns; `history` runs oldest first and ends with the live value. */
+/** A record a Kit owns; `history` runs oldest first and ends with the live value. */
 export type OwnedRecord<V> = {
     readonly key: string;
     readonly id: string;
     readonly deployed: V;
     readonly history: readonly RecordChange<V>[];
 };
-export type PackageRecordKind = 'schedule' | 'kit' | 'kit_installation' | 'kit_assignment';
+export type KitRecordKind = 'schedule';
 export type RecordDrift = {
-    readonly kind: PackageRecordKind;
+    readonly kind: KitRecordKind;
     readonly key: string;
     readonly field: string;
-    /** As the Package last deployed it. */
+    /** As the Kit last deployed it. */
     readonly declared: JsonValue;
     readonly live: JsonValue;
     readonly changedBy?: NonNullable<RecordChange<JsonObject>['by']>;
     readonly changedAt?: string;
 };
-export type PackagePlanConflict = {
+export type KitPlanConflict = {
     readonly kind: 'id_taken';
     readonly resource: 'loop' | 'agent';
     readonly id: string;
-    /** The other Package in the layer that declares it. */
-    readonly package: string;
+    /** The other Kit in the layer that declares it. */
+    readonly kit: string;
 } | {
     readonly kind: 'not_for_team';
     readonly declaration: string;
 } | {
     readonly kind: 'schedule_team';
     readonly key: string;
-    /** `missing` in a Workspace Package, `not_allowed` in a Team Package, `unknown` for no such Team. */
+    /** `missing` in a Workspace Kit, `not_allowed` in a Team Kit, `unknown` for no such Team. */
     readonly problem: 'missing' | 'not_allowed' | 'unknown';
 } | {
     readonly kind: 'loop_unresolved';
     readonly record: 'schedule';
     readonly key: string;
     readonly loop: string;
-} | {
-    readonly kind: 'kit_unresolved';
-    /** An Agent's id, or a Kit assignment's key. */
-    readonly record: 'agent' | 'kit_assignment';
-    readonly key: string;
-    readonly kit: string;
-} | {
-    readonly kind: 'kit_source';
-    readonly key: string;
-    readonly problem: 'unknown' | 'untrusted' | 'version_unknown';
-} | {
-    readonly kind: 'kit_policy_disabled';
-    readonly key: string;
-} | {
-    readonly kind: 'kit_team_unknown';
-    readonly key: string;
-    readonly team: string;
 };
-/** A Loop or Agent the deploy removes that a record outside the Package still names. */
-export type PackagePlanWarning = {
+/** A Loop or Agent the deploy removes that a record outside the Kit still names. */
+export type KitPlanWarning = {
     readonly kind: 'still_named';
     readonly resource: 'loop' | 'agent';
     readonly id: string;
     readonly record: string;
 };
 /** A plan with conflicts cannot deploy. */
-export type PackagePlan = {
-    readonly loops: PackageChanges;
-    readonly agents: PackageChanges;
-    readonly schedules: PackageRecordChanges;
-    readonly kits: PackageRecordChanges;
-    readonly kitInstallations: PackageRecordChanges;
-    readonly kitAssignments: PackageRecordChanges;
+export type KitPlan = {
+    readonly loops: KitChanges;
+    readonly agents: KitChanges;
+    readonly schedules: KitRecordChanges;
     readonly drift: readonly RecordDrift[];
-    readonly conflicts: readonly PackagePlanConflict[];
-    readonly warnings: readonly PackagePlanWarning[];
+    readonly conflicts: readonly KitPlanConflict[];
+    readonly warnings: readonly KitPlanWarning[];
 };
-/** A Package's layer, and where it puts its Schedules. */
-export type PackagePlanScope = {
+/** A Kit's layer, and where it puts its Schedules. */
+export type KitPlanScope = {
     readonly layer: 'team';
     readonly teamId: string;
 } | {
@@ -445,7 +360,7 @@ export type PackagePlanScope = {
     readonly teams: ReadonlyMap<string, string>;
 };
 /** The Team a declared Schedule runs in, or why it has none. */
-export declare const scheduleTeam: (declaration: ScheduleDeclaration, scope: PackagePlanScope) => {
+export declare const scheduleTeam: (declaration: ScheduleDeclaration, scope: KitPlanScope) => {
     readonly teamId: string;
 } | {
     readonly problem: 'missing' | 'not_allowed' | 'unknown';
@@ -454,26 +369,16 @@ export declare const scheduleTeam: (declaration: ScheduleDeclaration, scope: Pac
 export declare const scheduleRecord: (declaration: ScheduleDeclaration, teamId: string) => ScheduleRecord;
 /** The fields where a record's live value left what was deployed, each with the version that last changed it. */
 export declare const recordDrift: (kind: RecordDrift['kind'], owned: OwnedRecord<JsonObject>) => RecordDrift[];
-/** The live Kit an authored Kit declaration asks for; its key is its slug. */
-export declare const authoredKitRecord: (key: string, declaration: AuthoredKitDeclaration) => AuthoredKitRecord;
-/** The installation a declaration asks for, pinned to its version or the newest installable one. */
-export declare const kitInstallationRecord: (declaration: KitInstallationDeclaration, sources: readonly KitSourceOption[]) => KitInstallationRecord | {
-    readonly problem: 'unknown' | 'untrusted' | 'version_unknown';
-};
-/** The assignment a declaration asks for, with its Teams' ids, or the first Team slug that names none. */
-export declare const kitAssignmentRecord: (declaration: KitAssignmentDeclaration, teams: ReadonlyMap<string, string>) => KitAssignmentRecord | {
-    readonly unknownTeam: string;
-};
 /**
- * Compares a Package's current declarations with new ones. `others` are the other Packages in the same layer,
+ * Compares a Kit's current declarations with new ones. `others` are the other Kits in the same layer,
  * `elsewhere` what the layers beneath it declare, and `otherDeclarations` the kinds the new version declares besides
- * Loops, Agents and Schedules. `schedules` holds the Schedules the Package owns and, for adoption, those no Package owns;
- * `outside` the records outside the Package that name a Loop or Agent.
+ * Loops, Agents and Schedules. `schedules` holds the Schedules the Kit owns and, for adoption, those no Kit owns;
+ * `outside` the records outside the Kit that name a Loop or Agent.
  */
-export declare const planPackageDeploy: (input: {
-    readonly scope: PackagePlanScope;
-    readonly current?: PackageDeclarations;
-    readonly next: PackageDeclarations;
+export declare const planKitDeploy: (input: {
+    readonly scope: KitPlanScope;
+    readonly current?: KitDeclarations;
+    readonly next: KitDeclarations;
     readonly otherDeclarations?: readonly string[];
     readonly others: readonly {
         readonly name: string;
@@ -496,6 +401,5 @@ export declare const planPackageDeploy: (input: {
         readonly loop?: string;
         readonly agent?: string;
     }[];
-    readonly kits?: KitSnapshot;
-}) => PackagePlan;
+}) => KitPlan;
 export {};

package/types/packages/core/src/kit-install.d.ts

@@ -0,0 +1,130 @@
+import * as Schema from 'effect/Schema';
+/** A Kit installed from npm on the Workspace, a Team, or one person. */
+export declare const KitInstall: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly owner: Schema.Literals<readonly ["workspace", "team", "personal"]>;
+    readonly teamId: Schema.optionalKey<Schema.String>;
+    /** Absent for an install carried over from the old Kit model until a Run or a check first resolves it. */
+    readonly version: Schema.optionalKey<Schema.String>;
+    /** It follows npm `latest` without one. */
+    readonly pinnedVersion: Schema.optionalKey<Schema.String>;
+    readonly lastCheckedAt: Schema.optionalKey<Schema.String>;
+    /** Why its last check left it at `version`. */
+    readonly problem: Schema.optionalKey<Schema.String>;
+    /** The person its Loops' automatic starts act for; with nobody, they start only once someone Adds it again. */
+    readonly actsFor: Schema.optionalKey<Schema.String>;
+}>;
+export type KitInstall = typeof KitInstall.Type;
+export declare const KitInstallList: Schema.Struct<{
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly owner: Schema.Literals<readonly ["workspace", "team", "personal"]>;
+        readonly teamId: Schema.optionalKey<Schema.String>;
+        /** Absent for an install carried over from the old Kit model until a Run or a check first resolves it. */
+        readonly version: Schema.optionalKey<Schema.String>;
+        /** It follows npm `latest` without one. */
+        readonly pinnedVersion: Schema.optionalKey<Schema.String>;
+        readonly lastCheckedAt: Schema.optionalKey<Schema.String>;
+        /** Why its last check left it at `version`. */
+        readonly problem: Schema.optionalKey<Schema.String>;
+        /** The person its Loops' automatic starts act for; with nobody, they start only once someone Adds it again. */
+        readonly actsFor: Schema.optionalKey<Schema.String>;
+    }>>;
+}>;
+export type KitInstallList = typeof KitInstallList.Type;
+/** Installs on the Workspace, the Team `teamId` names, or, with `me`, the caller. */
+export declare const KitOwnerQuery: Schema.Struct<{
+    readonly teamId: Schema.optionalKey<Schema.String>;
+    readonly me: Schema.optionalKey<Schema.Literals<readonly ["true", "false"]>>;
+}>;
+export declare const KitAddRequest: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly teamId: Schema.optionalKey<Schema.String>;
+    readonly me: Schema.optionalKey<Schema.Boolean>;
+}>;
+export type KitAddRequest = typeof KitAddRequest.Type;
+export declare const KitPinRequest: Schema.Struct<{
+    readonly version: Schema.String;
+}>;
+/** The Kits a person's machines get, nearest first: their own, their Teams', the Workspace's, then Kitman's. */
+export declare const KitChain: Schema.Struct<{
+    readonly kits: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly version: Schema.String;
+        readonly setupDigest: Schema.String;
+    }>>;
+    /** Installs with no version to sync, and why. */
+    readonly skipped: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly problem: Schema.String;
+    }>>;
+}>;
+export type KitChain = typeof KitChain.Type;
+/** The Kits of an Owner chain, nearest first, each deployed or installed. */
+export declare const OwnerKits: Schema.Struct<{
+    readonly kits: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly version: Schema.String;
+        readonly source: Schema.Literals<readonly ["deployed", "installed"]>;
+    }>>;
+}>;
+export type OwnerKits = typeof OwnerKits.Type;
+export declare const OwnerKitsQuery: Schema.Struct<{
+    readonly teamId: Schema.optionalKey<Schema.String>;
+}>;
+/** A setup archive's JSON text, whose sha256 is its digest. */
+export declare const KitSetupDownload: Schema.Struct<{
+    readonly archive: Schema.String;
+}>;
+export type KitSetupDownload = typeof KitSetupDownload.Type;
+export declare const KitPreviewQuery: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly version: Schema.optionalKey<Schema.String>;
+}>;
+/** What a Kit brings, from its published build, before it is added. */
+export declare const KitPreview: 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 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 agents: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+    }>>;
+    readonly skills: Schema.$Array<Schema.Struct<{
+        readonly kit: Schema.String;
+        readonly name: Schema.String;
+    }>>;
+    readonly plugins: Schema.$Array<Schema.Struct<{
+        readonly kit: Schema.String;
+        readonly name: Schema.String;
+        readonly hooks: Schema.$Array<Schema.String>;
+    }>>;
+    readonly mcpServers: Schema.$Array<Schema.Struct<{
+        readonly kit: Schema.String;
+        readonly name: Schema.String;
+        /** A remote server's host; a stdio server runs `command` instead. */
+        readonly host: Schema.optionalKey<Schema.String>;
+        readonly command: Schema.optionalKey<Schema.String>;
+    }>>;
+    /** The Secrets its MCP config names by `{env:NAME}`. */
+    readonly secrets: Schema.$Array<Schema.String>;
+}>;
+export type KitPreview = typeof KitPreview.Type;
+/** A published Kit's preview; declarations or archives that don't decode contribute nothing. */
+export declare const kitPreview: (kit: {
+    readonly name: string;
+    readonly version: string;
+    readonly declarations: unknown;
+    readonly setupArchives: readonly {
+        readonly digest: string;
+        readonly archive: Uint8Array;
+    }[];
+}) => KitPreview;