@kitman-sh/sdk 0.0.0-stage → 0.7.0

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

@@ -0,0 +1,255 @@
+import * as Schema from 'effect/Schema';
+export declare const ChangeRequestProvider: Schema.Literals<readonly ["github", "gitlab"]>;
+export declare const CodeHostCapability: Schema.Literals<readonly ["repository_read", "repository_write", "change_request_read", "change_request_write", "check_write", "webhook_manage"]>;
+/** The environment variables a code-host connection may name for its custom CA. */
+export declare const customCaReferencePattern: RegExp;
+export declare const CodeHostConnection: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly workspaceId: Schema.String;
+    readonly provider: Schema.Literals<readonly ["github", "gitlab"]>;
+    readonly host: Schema.String;
+    readonly authKind: Schema.Literals<readonly ["github_app", "gitlab_personal_access_token", "gitlab_group_token", "gitlab_project_token", "gitlab_oauth"]>;
+    readonly status: Schema.Literals<readonly ["connected", "degraded", "disconnected"]>;
+    readonly externalAccountId: Schema.optionalKey<Schema.String>;
+    readonly externalAccountLogin: Schema.optionalKey<Schema.String>;
+    readonly capabilities: Schema.$Array<Schema.Literals<readonly ["repository_read", "repository_write", "change_request_read", "change_request_write", "check_write", "webhook_manage"]>>;
+    readonly credentialConfigured: Schema.Boolean;
+    readonly webhookActive: Schema.Boolean;
+    readonly tls: Schema.Struct<{
+        readonly customCaRef: Schema.optionalKey<Schema.String>;
+    }>;
+    readonly supportEvidence: Schema.$Array<Schema.Struct<{
+        readonly capability: Schema.Literals<readonly ["repository_read", "repository_write", "change_request_read", "change_request_write", "check_write", "webhook_manage"]>;
+        readonly support: Schema.Literals<readonly ["certified", "detected", "unsupported"]>;
+        readonly observedAt: Schema.String;
+    }>>;
+    readonly expiresAt: Schema.optionalKey<Schema.String>;
+    readonly lastTestedAt: Schema.optionalKey<Schema.String>;
+    readonly healthMessage: Schema.optionalKey<Schema.String>;
+    readonly connectedAt: Schema.optionalKey<Schema.String>;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+}>;
+export declare const CodeHostConnectionList: Schema.Struct<{
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly workspaceId: Schema.String;
+        readonly provider: Schema.Literals<readonly ["github", "gitlab"]>;
+        readonly host: Schema.String;
+        readonly authKind: Schema.Literals<readonly ["github_app", "gitlab_personal_access_token", "gitlab_group_token", "gitlab_project_token", "gitlab_oauth"]>;
+        readonly status: Schema.Literals<readonly ["connected", "degraded", "disconnected"]>;
+        readonly externalAccountId: Schema.optionalKey<Schema.String>;
+        readonly externalAccountLogin: Schema.optionalKey<Schema.String>;
+        readonly capabilities: Schema.$Array<Schema.Literals<readonly ["repository_read", "repository_write", "change_request_read", "change_request_write", "check_write", "webhook_manage"]>>;
+        readonly credentialConfigured: Schema.Boolean;
+        readonly webhookActive: Schema.Boolean;
+        readonly tls: Schema.Struct<{
+            readonly customCaRef: Schema.optionalKey<Schema.String>;
+        }>;
+        readonly supportEvidence: Schema.$Array<Schema.Struct<{
+            readonly capability: Schema.Literals<readonly ["repository_read", "repository_write", "change_request_read", "change_request_write", "check_write", "webhook_manage"]>;
+            readonly support: Schema.Literals<readonly ["certified", "detected", "unsupported"]>;
+            readonly observedAt: Schema.String;
+        }>>;
+        readonly expiresAt: Schema.optionalKey<Schema.String>;
+        readonly lastTestedAt: Schema.optionalKey<Schema.String>;
+        readonly healthMessage: Schema.optionalKey<Schema.String>;
+        readonly connectedAt: Schema.optionalKey<Schema.String>;
+        readonly createdAt: Schema.String;
+        readonly updatedAt: Schema.String;
+    }>>;
+}>;
+export declare const CodeHostConnectionWrite: Schema.Struct<{
+    readonly provider: Schema.Literals<readonly ["github", "gitlab"]>;
+    readonly host: Schema.String;
+    readonly authKind: Schema.Literals<readonly ["github_app", "gitlab_personal_access_token", "gitlab_group_token", "gitlab_project_token"]>;
+    readonly externalAccountId: Schema.optionalKey<Schema.String>;
+    readonly externalAccountLogin: Schema.optionalKey<Schema.String>;
+    readonly appId: Schema.optionalKey<Schema.String>;
+    readonly installationId: Schema.optionalKey<Schema.String>;
+    readonly accessToken: Schema.optionalKey<Schema.String>;
+    readonly privateKey: Schema.optionalKey<Schema.String>;
+    readonly webhookSecret: Schema.optionalKey<Schema.String>;
+    readonly expiresAt: Schema.optionalKey<Schema.String>;
+    readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly webhookActive: Schema.optionalKey<Schema.Boolean>;
+    readonly tls: Schema.optionalKey<Schema.Struct<{
+        readonly customCaRef: Schema.optionalKey<Schema.String>;
+    }>>;
+}>;
+/** Where to send the person to install the deployment's GitHub App, carrying a signed `state`. */
+export declare const GithubConnectStart: Schema.Struct<{
+    readonly url: Schema.String;
+}>;
+/** What GitHub hands back to the App's setup URL after an installation. */
+export declare const GithubConnectComplete: Schema.Struct<{
+    readonly state: Schema.optionalKey<Schema.String>;
+    readonly code: Schema.optionalKey<Schema.String>;
+    readonly installationId: Schema.String;
+}>;
+export declare const GitlabConnectStart: Schema.Struct<{
+    readonly url: Schema.String;
+}>;
+/** What GitLab hands back to the OAuth redirect after the person authorizes Kitman. */
+export declare const GitlabConnectComplete: Schema.Struct<{
+    readonly state: Schema.String;
+    readonly code: Schema.String;
+}>;
+/** The scopes a GitLab token needs for everything Kitman does with it, webhooks included. */
+export declare const GitlabTokenScopes: readonly ['api'];
+/** The instance's new personal access token page, with Kitman's name and scopes filled in. */
+export declare function gitlabTokenPageUrl(host: string): string;
+export declare const CodeHostRepository: Schema.Struct<{
+    readonly providerRepositoryId: Schema.String;
+    readonly provider: Schema.Literals<readonly ["github", "gitlab"]>;
+    readonly host: Schema.String;
+    readonly owner: Schema.String;
+    readonly name: Schema.String;
+    readonly fullPath: Schema.String;
+    readonly repositoryUrl: Schema.String;
+    readonly defaultTargetBranch: Schema.String;
+}>;
+/** One page of the repositories a connection reaches, each saying whether the Workspace has bound it already. */
+export declare const CodeHostRepositoryList: Schema.Struct<{
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly providerRepositoryId: Schema.String;
+        readonly provider: Schema.Literals<readonly ["github", "gitlab"]>;
+        readonly host: Schema.String;
+        readonly owner: Schema.String;
+        readonly name: Schema.String;
+        readonly fullPath: Schema.String;
+        readonly repositoryUrl: Schema.String;
+        readonly defaultTargetBranch: Schema.String;
+        readonly bound: Schema.Boolean;
+    }>>;
+    readonly nextPage: Schema.optionalKey<Schema.Int>;
+}>;
+/** Repositories, by full path, to bind into one Project: an existing one, or a new one of this name. */
+export declare const CodeHostRepositoryBind: Schema.Struct<{
+    readonly repositories: Schema.$Array<Schema.String>;
+    readonly project: Schema.Union<readonly [Schema.Struct<{
+        readonly projectId: Schema.String;
+    }>, Schema.Struct<{
+        readonly name: Schema.String;
+    }>]>;
+}>;
+/** The Project the repositories joined, those bound now, and those the Workspace had bound already and kept as they were. */
+export declare const CodeHostRepositoryBindResult: Schema.Struct<{
+    readonly project: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly workspaceId: Schema.String;
+        readonly name: Schema.String;
+        readonly slug: Schema.String;
+        readonly description: Schema.optionalKey<Schema.String>;
+        readonly sourceType: Schema.Literal<"manual">;
+        readonly openTaskCount: Schema.Int;
+        readonly blockedTaskCount: Schema.Int;
+        readonly createdAt: Schema.String;
+        readonly updatedAt: Schema.String;
+        readonly defaultStatusMapping: Schema.$Record<Schema.String, Schema.String>;
+    }>;
+    readonly bound: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly workspaceId: Schema.String;
+        readonly projectId: Schema.String;
+        readonly provider: Schema.Union<readonly [Schema.Literal<"github">, Schema.Literal<"gitlab">, Schema.Literal<"generic_git">]>;
+        readonly host: Schema.String;
+        readonly owner: Schema.String;
+        readonly name: Schema.String;
+        readonly repositoryUrl: Schema.optionalKey<Schema.String>;
+        readonly pathPrefix: Schema.optionalKey<Schema.String>;
+        readonly defaultTargetBranch: Schema.String;
+        readonly expectedBranch: Schema.optionalKey<Schema.String>;
+        readonly expectedCommitSha: Schema.optionalKey<Schema.String>;
+        readonly credentialRefs: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"none">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"local_env">;
+            readonly envName: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"runner_secret">;
+            readonly runnerSecretName: Schema.String;
+            readonly providerType: Schema.Union<readonly [Schema.Literal<"env">, Schema.Literal<"file">, Schema.Literal<"exec">]>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"ssh_agent">;
+        }>]>>;
+        readonly status: Schema.Union<readonly [Schema.Literal<"active">, Schema.Literal<"disabled">]>;
+        readonly webhook: Schema.optionalKey<Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["active", "missing"]>;
+            readonly message: Schema.optionalKey<Schema.String>;
+        }>>;
+        readonly createdAt: Schema.String;
+        readonly updatedAt: Schema.String;
+    }>>;
+    readonly alreadyBound: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly workspaceId: Schema.String;
+        readonly projectId: Schema.String;
+        readonly provider: Schema.Union<readonly [Schema.Literal<"github">, Schema.Literal<"gitlab">, Schema.Literal<"generic_git">]>;
+        readonly host: Schema.String;
+        readonly owner: Schema.String;
+        readonly name: Schema.String;
+        readonly repositoryUrl: Schema.optionalKey<Schema.String>;
+        readonly pathPrefix: Schema.optionalKey<Schema.String>;
+        readonly defaultTargetBranch: Schema.String;
+        readonly expectedBranch: Schema.optionalKey<Schema.String>;
+        readonly expectedCommitSha: Schema.optionalKey<Schema.String>;
+        readonly credentialRefs: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"none">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"local_env">;
+            readonly envName: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"runner_secret">;
+            readonly runnerSecretName: Schema.String;
+            readonly providerType: Schema.Union<readonly [Schema.Literal<"env">, Schema.Literal<"file">, Schema.Literal<"exec">]>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"ssh_agent">;
+        }>]>>;
+        readonly status: Schema.Union<readonly [Schema.Literal<"active">, Schema.Literal<"disabled">]>;
+        readonly webhook: Schema.optionalKey<Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["active", "missing"]>;
+            readonly message: Schema.optionalKey<Schema.String>;
+        }>>;
+        readonly createdAt: Schema.String;
+        readonly updatedAt: Schema.String;
+    }>>;
+}>;
+export declare const ChangeRequestProviderIntegrationMetadata: Schema.Struct<{
+    readonly provider: Schema.Literals<readonly ["github", "gitlab"]>;
+    readonly host: Schema.String;
+    readonly authKind: Schema.Union<readonly [Schema.Literal<"github_app">, Schema.Literal<"gitlab_app">, Schema.Literal<"oauth_app">, Schema.Literal<"webhook_only">]>;
+    readonly externalAccountId: Schema.optionalKey<Schema.String>;
+    readonly externalAccountLogin: Schema.optionalKey<Schema.String>;
+    readonly appId: Schema.optionalKey<Schema.String>;
+    readonly appSlug: Schema.optionalKey<Schema.String>;
+    readonly installationId: Schema.optionalKey<Schema.String>;
+    readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly webhookActive: Schema.optionalKey<Schema.Boolean>;
+    readonly connectedAt: Schema.optionalKey<Schema.String>;
+}>;
+export declare const ProviderChangeRequestWebhookEvent: Schema.Union<readonly [Schema.Literal<"change_request_opened">, Schema.Literal<"change_request_updated">, Schema.Literal<"change_request_ready_for_review">, Schema.Literal<"change_request_checks_changed">, Schema.Literal<"change_request_merged">]>;
+export declare const ChangeRequestProviderWebhookReceipt: Schema.Struct<{
+    readonly provider: Schema.Literals<readonly ["github", "gitlab"]>;
+    readonly eventName: Schema.String;
+    readonly deliveryId: Schema.optionalKey<Schema.String>;
+    readonly normalizedEvent: Schema.optionalKey<Schema.Union<readonly [Schema.Literal<"change_request_opened">, Schema.Literal<"change_request_updated">, Schema.Literal<"change_request_ready_for_review">, Schema.Literal<"change_request_checks_changed">, Schema.Literal<"change_request_merged">]>>;
+    readonly changeRequestCount: Schema.Int;
+    readonly admittedLoopDispatchCount: Schema.Int;
+}>;
+export type ChangeRequestProvider = (typeof ChangeRequestProvider)['Type'];
+export type CodeHostCapability = (typeof CodeHostCapability)['Type'];
+export type CodeHostConnection = (typeof CodeHostConnection)['Type'];
+export type CodeHostConnectionList = (typeof CodeHostConnectionList)['Type'];
+export type CodeHostConnectionWrite = (typeof CodeHostConnectionWrite)['Type'];
+export type GitlabConnectStart = GithubConnectStart;
+export type GitlabConnectComplete = (typeof GitlabConnectComplete)['Type'];
+export type GithubConnectStart = (typeof GithubConnectStart)['Type'];
+export type GithubConnectComplete = (typeof GithubConnectComplete)['Type'];
+export type CodeHostRepository = (typeof CodeHostRepository)['Type'];
+export type CodeHostRepositoryList = (typeof CodeHostRepositoryList)['Type'];
+export type CodeHostRepositoryBind = (typeof CodeHostRepositoryBind)['Type'];
+export type CodeHostRepositoryBindResult = (typeof CodeHostRepositoryBindResult)['Type'];
+export type ChangeRequestProviderIntegrationMetadata = (typeof ChangeRequestProviderIntegrationMetadata)['Type'];
+export type ProviderChangeRequestWebhookEvent = (typeof ProviderChangeRequestWebhookEvent)['Type'];
+export type ChangeRequestProviderWebhookReceipt = (typeof ChangeRequestProviderWebhookReceipt)['Type'];

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

@@ -0,0 +1,260 @@
+import * as Schema from 'effect/Schema';
+export declare const RunIntentConstraint: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly text: Schema.String;
+    readonly kind: Schema.Union<readonly [Schema.Literal<"rule">, Schema.Literal<"semantic">]>;
+    readonly severity: Schema.Union<readonly [Schema.Literal<"block">, Schema.Literal<"warn">]>;
+    readonly source: Schema.Union<readonly [Schema.Literal<"launch">, Schema.Literal<"repository">, Schema.Literal<"plan">, Schema.Literal<"parent">, Schema.Literal<"human">]>;
+    readonly rule: Schema.optionalKey<Schema.Struct<{
+        readonly kind: Schema.Literal<"protected_paths">;
+        readonly globs: Schema.$Array<Schema.String>;
+    }>>;
+}>;
+export type RunIntentConstraint = (typeof RunIntentConstraint)['Type'];
+/** One version of a Run's Intent, with what changed and who changed it. */
+export declare const RunIntentVersion: Schema.Struct<{
+    readonly version: Schema.Int;
+    readonly goal: Schema.String;
+    readonly doneWhen: Schema.$Array<Schema.String>;
+    readonly constraints: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly text: Schema.String;
+        readonly kind: Schema.Union<readonly [Schema.Literal<"rule">, Schema.Literal<"semantic">]>;
+        readonly severity: Schema.Union<readonly [Schema.Literal<"block">, Schema.Literal<"warn">]>;
+        readonly source: Schema.Union<readonly [Schema.Literal<"launch">, Schema.Literal<"repository">, Schema.Literal<"plan">, Schema.Literal<"parent">, Schema.Literal<"human">]>;
+        readonly rule: Schema.optionalKey<Schema.Struct<{
+            readonly kind: Schema.Literal<"protected_paths">;
+            readonly globs: Schema.$Array<Schema.String>;
+        }>>;
+    }>>;
+    readonly corrections: Schema.Boolean;
+    readonly removedConstraintIds: Schema.$Array<Schema.String>;
+    readonly change: Schema.String;
+    readonly author: Schema.Struct<{
+        readonly actorType: Schema.String;
+        readonly actorId: Schema.String;
+    }>;
+    readonly createdAt: Schema.String;
+}>;
+export type RunIntentVersion = (typeof RunIntentVersion)['Type'];
+/** What a Run is held to: its current Intent and every version, oldest first. */
+export declare const RunIntent: Schema.Struct<{
+    readonly runId: Schema.String;
+    readonly current: Schema.optionalKey<Schema.Struct<{
+        readonly version: Schema.Int;
+        readonly goal: Schema.String;
+        readonly doneWhen: Schema.$Array<Schema.String>;
+        readonly constraints: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly text: Schema.String;
+            readonly kind: Schema.Union<readonly [Schema.Literal<"rule">, Schema.Literal<"semantic">]>;
+            readonly severity: Schema.Union<readonly [Schema.Literal<"block">, Schema.Literal<"warn">]>;
+            readonly source: Schema.Union<readonly [Schema.Literal<"launch">, Schema.Literal<"repository">, Schema.Literal<"plan">, Schema.Literal<"parent">, Schema.Literal<"human">]>;
+            readonly rule: Schema.optionalKey<Schema.Struct<{
+                readonly kind: Schema.Literal<"protected_paths">;
+                readonly globs: Schema.$Array<Schema.String>;
+            }>>;
+        }>>;
+        readonly corrections: Schema.Boolean;
+        readonly removedConstraintIds: Schema.$Array<Schema.String>;
+        readonly change: Schema.String;
+        readonly author: Schema.Struct<{
+            readonly actorType: Schema.String;
+            readonly actorId: Schema.String;
+        }>;
+        readonly createdAt: Schema.String;
+    }>>;
+    readonly versions: Schema.$Array<Schema.Struct<{
+        readonly version: Schema.Int;
+        readonly goal: Schema.String;
+        readonly doneWhen: Schema.$Array<Schema.String>;
+        readonly constraints: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly text: Schema.String;
+            readonly kind: Schema.Union<readonly [Schema.Literal<"rule">, Schema.Literal<"semantic">]>;
+            readonly severity: Schema.Union<readonly [Schema.Literal<"block">, Schema.Literal<"warn">]>;
+            readonly source: Schema.Union<readonly [Schema.Literal<"launch">, Schema.Literal<"repository">, Schema.Literal<"plan">, Schema.Literal<"parent">, Schema.Literal<"human">]>;
+            readonly rule: Schema.optionalKey<Schema.Struct<{
+                readonly kind: Schema.Literal<"protected_paths">;
+                readonly globs: Schema.$Array<Schema.String>;
+            }>>;
+        }>>;
+        readonly corrections: Schema.Boolean;
+        readonly removedConstraintIds: Schema.$Array<Schema.String>;
+        readonly change: Schema.String;
+        readonly author: Schema.Struct<{
+            readonly actorType: Schema.String;
+            readonly actorId: Schema.String;
+        }>;
+        readonly createdAt: Schema.String;
+    }>>;
+}>;
+export type RunIntent = (typeof RunIntent)['Type'];
+export declare const RunIntentAmend: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"set_goal">;
+    readonly goal: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"add_constraint">;
+    /** `rule:protected_paths:<glob>[,<glob>…]` spells a rule; any other text is semantic. */
+    readonly constraint: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"remove_constraint">;
+    readonly id: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"set_corrections">;
+    readonly on: Schema.Boolean;
+}>]>;
+export type RunIntentAmend = (typeof RunIntentAmend)['Type'];
+/** A constraint every Run on a repository starts with, as a person spelled it. */
+export declare const StandingConstraint: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly repoBindingId: Schema.String;
+    readonly text: Schema.String;
+    readonly addedByUserId: Schema.String;
+    readonly createdAt: Schema.String;
+}>;
+export type StandingConstraint = (typeof StandingConstraint)['Type'];
+export declare const StandingConstraintList: Schema.Struct<{
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly repoBindingId: Schema.String;
+        readonly text: Schema.String;
+        readonly addedByUserId: Schema.String;
+        readonly createdAt: Schema.String;
+    }>>;
+}>;
+export type StandingConstraintList = (typeof StandingConstraintList)['Type'];
+export declare const StandingConstraintAdd: Schema.Struct<{
+    /** `rule:protected_paths:<glob>[,<glob>…]` spells a rule; any other text is semantic. */
+    readonly text: Schema.String;
+}>;
+export type StandingConstraintAdd = (typeof StandingConstraintAdd)['Type'];
+export declare const DriftResolution: Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["open", "correction_sent", "escalated", "verified", "dismissed"]>;
+    readonly intentVersion: Schema.Int;
+    readonly at: Schema.String;
+    readonly reason: Schema.optionalKey<Schema.String>;
+    readonly actor: Schema.optionalKey<Schema.Struct<{
+        readonly actorType: Schema.String;
+        readonly actorId: Schema.String;
+    }>>;
+}>;
+/** What a check found against one of the Run's constraints, and its resolutions, oldest first. */
+export declare const DriftReport: Schema.Struct<{
+    readonly constraintId: Schema.String;
+    readonly constraintText: Schema.String;
+    readonly kind: Schema.Union<readonly [Schema.Literal<"rule">, Schema.Literal<"semantic">]>;
+    readonly severity: Schema.Union<readonly [Schema.Literal<"block">, Schema.Literal<"warn">]>;
+    readonly intentVersion: Schema.Int;
+    readonly citedPaths: Schema.$Array<Schema.String>;
+    readonly truncated: Schema.Boolean;
+    readonly status: Schema.Literals<readonly ["open", "correction_sent", "escalated", "verified", "dismissed"]>;
+    readonly history: Schema.$Array<Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["open", "correction_sent", "escalated", "verified", "dismissed"]>;
+        readonly intentVersion: Schema.Int;
+        readonly at: Schema.String;
+        readonly reason: Schema.optionalKey<Schema.String>;
+        readonly actor: Schema.optionalKey<Schema.Struct<{
+            readonly actorType: Schema.String;
+            readonly actorId: Schema.String;
+        }>>;
+    }>>;
+}>;
+export type DriftReport = (typeof DriftReport)['Type'];
+/** An accepted agent Step's boundary: what evidence it had, and why its rules went unchecked if they did. */
+export declare const RunBoundary: Schema.Struct<{
+    readonly stepAttemptId: Schema.String;
+    readonly stepKey: Schema.String;
+    readonly intentVersion: Schema.optionalKey<Schema.Int>;
+    readonly evidence: Schema.optionalKey<Schema.Struct<{
+        readonly kind: Schema.Union<readonly [Schema.Literal<"change">, Schema.Literal<"output">]>;
+        readonly changedPaths: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly truncated: Schema.Boolean;
+    }>>;
+    readonly uncheckedReason: Schema.optionalKey<Schema.String>;
+    readonly createdAt: Schema.String;
+}>;
+export type RunBoundary = (typeof RunBoundary)['Type'];
+/** A `judge` StepAttempt's verdicts on the Run's semantic constraints, and at the finish its goal and doneWhen. */
+export declare const RunJudgement: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly final: Schema.Boolean;
+    readonly status: Schema.Literals<readonly ["queued", "running", "judged", "skipped"]>;
+    readonly stepAttemptId: Schema.optionalKey<Schema.String>;
+    readonly intentVersion: Schema.optionalKey<Schema.Int>;
+    readonly constraints: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly constraintId: Schema.String;
+        readonly verdict: Schema.Literals<readonly ["holds", "breached", "unverified"]>;
+        readonly citations: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly line: Schema.optionalKey<Schema.Int>;
+        }>>;
+    }>>>;
+    readonly goal: Schema.optionalKey<Schema.Literals<readonly ["met", "not_met", "unverified"]>>;
+    readonly doneWhen: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["met", "not_met", "unverified"]>>>;
+    readonly skipReason: Schema.optionalKey<Schema.String>;
+    readonly createdAt: Schema.String;
+    readonly settledAt: Schema.optionalKey<Schema.String>;
+}>;
+export type RunJudgement = (typeof RunJudgement)['Type'];
+export declare const RunDrift: Schema.Struct<{
+    readonly runId: Schema.String;
+    readonly reports: Schema.$Array<Schema.Struct<{
+        readonly constraintId: Schema.String;
+        readonly constraintText: Schema.String;
+        readonly kind: Schema.Union<readonly [Schema.Literal<"rule">, Schema.Literal<"semantic">]>;
+        readonly severity: Schema.Union<readonly [Schema.Literal<"block">, Schema.Literal<"warn">]>;
+        readonly intentVersion: Schema.Int;
+        readonly citedPaths: Schema.$Array<Schema.String>;
+        readonly truncated: Schema.Boolean;
+        readonly status: Schema.Literals<readonly ["open", "correction_sent", "escalated", "verified", "dismissed"]>;
+        readonly history: Schema.$Array<Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["open", "correction_sent", "escalated", "verified", "dismissed"]>;
+            readonly intentVersion: Schema.Int;
+            readonly at: Schema.String;
+            readonly reason: Schema.optionalKey<Schema.String>;
+            readonly actor: Schema.optionalKey<Schema.Struct<{
+                readonly actorType: Schema.String;
+                readonly actorId: Schema.String;
+            }>>;
+        }>>;
+    }>>;
+    readonly boundaries: Schema.$Array<Schema.Struct<{
+        readonly stepAttemptId: Schema.String;
+        readonly stepKey: Schema.String;
+        readonly intentVersion: Schema.optionalKey<Schema.Int>;
+        readonly evidence: Schema.optionalKey<Schema.Struct<{
+            readonly kind: Schema.Union<readonly [Schema.Literal<"change">, Schema.Literal<"output">]>;
+            readonly changedPaths: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly truncated: Schema.Boolean;
+        }>>;
+        readonly uncheckedReason: Schema.optionalKey<Schema.String>;
+        readonly createdAt: Schema.String;
+    }>>;
+    /** Oldest first. */
+    readonly judgements: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly final: Schema.Boolean;
+        readonly status: Schema.Literals<readonly ["queued", "running", "judged", "skipped"]>;
+        readonly stepAttemptId: Schema.optionalKey<Schema.String>;
+        readonly intentVersion: Schema.optionalKey<Schema.Int>;
+        readonly constraints: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly constraintId: Schema.String;
+            readonly verdict: Schema.Literals<readonly ["holds", "breached", "unverified"]>;
+            readonly citations: Schema.$Array<Schema.Struct<{
+                readonly path: Schema.String;
+                readonly line: Schema.optionalKey<Schema.Int>;
+            }>>;
+        }>>>;
+        readonly goal: Schema.optionalKey<Schema.Literals<readonly ["met", "not_met", "unverified"]>>;
+        readonly doneWhen: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["met", "not_met", "unverified"]>>>;
+        readonly skipReason: Schema.optionalKey<Schema.String>;
+        readonly createdAt: Schema.String;
+        readonly settledAt: Schema.optionalKey<Schema.String>;
+    }>>;
+}>;
+export type RunDrift = (typeof RunDrift)['Type'];
+export declare const RunDriftDismiss: Schema.Struct<{
+    readonly reason: Schema.String;
+}>;
+export type RunDriftDismiss = (typeof RunDriftDismiss)['Type'];

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

@@ -0,0 +1,10 @@
+import * as Schema from 'effect/Schema';
+export declare const decodeJsonString: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<Schema.Json, Schema.SchemaError, never>;
+export declare const decodeJsonStringOption: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Option").Option<Schema.Json>;
+export declare const encodeJsonStringSync: (input: Schema.Json, options?: import("effect/SchemaAST").ParseOptions) => string;
+/** Two-space indented JSON text, for files people read. */
+export declare const encodePrettyJsonString: (input: Schema.Json, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<string, Schema.SchemaError, never>;
+/** Decodes JSON text, throwing on invalid input; for code that runs outside an Effect. */
+export declare const decodeJsonStringSync: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Schema.Json;
+/** JSON text for a value of any shape (diagnostics and assertions); `JSON.stringify` semantics. */
+export declare const encodeUnknownJsonStringSync: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string;

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

@@ -0,0 +1,21 @@
+import type { KitCreate } from './kit';
+type SimplifiedKitDefinition = KitCreate & {
+    readonly slug: string;
+    readonly marketplace: {
+        readonly visibility: 'public';
+        readonly trusted: true;
+        readonly reviewStatus: 'approved';
+        readonly installable: true;
+    };
+};
+export declare const ComplianceKitSections: {
+    readonly 'privacy-ai-governance': readonly ['ai-inventory', 'aia-generation', 'pia-generation', 'use-case-triage', 'dsar-response', 'policy-monitor', 'policy-diff', 'policy-redraft', 'policy-drafting', 'policy-starter', 'reg-feed-watcher', 'reg-gap-analysis', 'gaps', 'comments', 'launch-review', 'feature-risk-assessment'];
+    readonly 'commercial-legal': readonly ['nda-review', 'saas-msa-review', 'vendor-agreement-review', 'vendor-ai-review', 'dpa-review', 'material-contract-schedule', 'diligence-issue-extraction', 'closing-checklist', 'renewal-tracker', 'stakeholder-summary', 'amendment-history'];
+    readonly 'legal-operations': readonly ['matter-intake', 'matter-briefing', 'matter-update', 'matter-close', 'matter-workspace', 'chronology', 'deadlines', 'client-letter', 'client-intake', 'review', 'memo', 'legal-writing', 'research-start', 'status', 'pdf'];
+    readonly 'litigation-investigations': readonly ['demand-intake', 'demand-draft', 'demand-received', 'cease-desist', 'subpoena-triage', 'deposition-prep', 'privilege-log-review', 'legal-hold', 'claim-chart', 'brief-section-drafter', 'investigation-open', 'investigation-add', 'investigation-query', 'investigation-memo', 'investigation-summary'];
+    readonly 'legal-education': readonly ['bar-prep-questions', 'case-brief', 'cold-call-prep', 'exam-forecast', 'flashcards', 'irac-practice', 'outline-builder', 'session', 'socratic-drill', 'study-plan', 'ramp', 'semester-handoff', 'supervisor-review-queue', 'build-guide'];
+    readonly 'claims-review': readonly ['marketing-claims-review'];
+};
+export declare const SimplifiedKitTaxonomy: readonly [SimplifiedKitDefinition, SimplifiedKitDefinition, SimplifiedKitDefinition, SimplifiedKitDefinition, SimplifiedKitDefinition, SimplifiedKitDefinition];
+export declare const SimplifiedKitSlugs: string[];
+export {};