@kitman-sh/sdk 0.7.2 → 0.7.4

package/types/packages/core/src/data-lifecycle.d.ts

@@ -0,0 +1,195 @@
+import * as Schema from 'effect/Schema';
+declare const DataLifecycleSubjectKinds: readonly ['workspace', 'project', 'task', 'runner', 'runner_replica'];
+export type DataLifecycleSubjectKind = (typeof DataLifecycleSubjectKinds)[number];
+export declare const DataLifecycleStates: readonly ['active', 'requested', 'draining', 'export_evaluated', 'erased', 'tombstoned', 'blocked_by_hold', 'residue_unknown', 'rejected', 'canceled'];
+export type DataLifecycleState = (typeof DataLifecycleStates)[number];
+declare const DataLifecycleDispositions: readonly ['retain', 'erase', 'tombstone'];
+export type DataLifecycleDisposition = (typeof DataLifecycleDispositions)[number];
+declare const DataLifecycleHoldStatuses: readonly ['active', 'released', 'superseded'];
+export type DataLifecycleHoldStatus = (typeof DataLifecycleHoldStatuses)[number];
+declare const DataLifecycleCaseHoldStatuses: readonly ['none', 'active', 'released'];
+export type DataLifecycleCaseHoldStatus = (typeof DataLifecycleCaseHoldStatuses)[number];
+declare const DataLifecycleResidueDispositions: readonly ['deleted', 'quarantined', 'retained_until', 'unknown'];
+export type DataLifecycleResidueDisposition = (typeof DataLifecycleResidueDispositions)[number];
+export declare const DataLifecycleSubjectKind: Schema.Union<readonly [Schema.Literal<"workspace">, Schema.Literal<"project">, Schema.Literal<"task">, Schema.Literal<"runner">, Schema.Literal<"runner_replica">]>;
+export declare const DataLifecycleState: Schema.Union<readonly [Schema.Literal<"active">, Schema.Literal<"requested">, Schema.Literal<"draining">, Schema.Literal<"export_evaluated">, Schema.Literal<"erased">, Schema.Literal<"tombstoned">, Schema.Literal<"blocked_by_hold">, Schema.Literal<"residue_unknown">, Schema.Literal<"rejected">, Schema.Literal<"canceled">]>;
+export declare const DataLifecycleDisposition: Schema.Union<readonly [Schema.Literal<"retain">, Schema.Literal<"erase">, Schema.Literal<"tombstone">]>;
+export declare const DataLifecycleHoldStatus: Schema.Union<readonly [Schema.Literal<"active">, Schema.Literal<"released">, Schema.Literal<"superseded">]>;
+export declare const DataLifecycleCaseHoldStatus: Schema.Union<readonly [Schema.Literal<"none">, Schema.Literal<"active">, Schema.Literal<"released">]>;
+export declare const DataLifecycleResidueDisposition: Schema.Union<readonly [Schema.Literal<"deleted">, Schema.Literal<"quarantined">, Schema.Literal<"retained_until">, Schema.Literal<"unknown">]>;
+export declare const DataLifecycleCase: Schema.Struct<{
+    readonly contractVersion: Schema.Literal<"data-lifecycle.v1">;
+    readonly id: Schema.String;
+    readonly subjectKind: Schema.Union<readonly [Schema.Literal<"workspace">, Schema.Literal<"project">, Schema.Literal<"task">, Schema.Literal<"runner">, Schema.Literal<"runner_replica">]>;
+    readonly subjectId: Schema.String;
+    readonly workspaceId: Schema.String;
+    readonly projectId: Schema.optionalKey<Schema.String>;
+    readonly requestedDisposition: Schema.Union<readonly [Schema.Literal<"retain">, Schema.Literal<"erase">, Schema.Literal<"tombstone">]>;
+    readonly policyDigest: Schema.String;
+    readonly state: Schema.Union<readonly [Schema.Literal<"active">, Schema.Literal<"requested">, Schema.Literal<"draining">, Schema.Literal<"export_evaluated">, Schema.Literal<"erased">, Schema.Literal<"tombstoned">, Schema.Literal<"blocked_by_hold">, Schema.Literal<"residue_unknown">, Schema.Literal<"rejected">, Schema.Literal<"canceled">]>;
+    readonly holdStatus: Schema.Union<readonly [Schema.Literal<"none">, Schema.Literal<"active">, Schema.Literal<"released">]>;
+    readonly resourceVersion: Schema.Int;
+    readonly containmentVersion: Schema.Int;
+    readonly exportManifestId: Schema.optionalKey<Schema.String>;
+    readonly erasureId: Schema.optionalKey<Schema.String>;
+    readonly tombstoneId: Schema.optionalKey<Schema.String>;
+    readonly residueUnknown: Schema.Boolean;
+    readonly owner: Schema.Struct<{
+        readonly actorType: Schema.Union<readonly [Schema.Literal<"human">, Schema.Literal<"delegated_agent">, Schema.Literal<"agent">]>;
+        readonly actorId: Schema.String;
+        readonly delegatedByUserId: Schema.optionalKey<Schema.String>;
+    }>;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+}>;
+export type DataLifecycleCase = (typeof DataLifecycleCase)['Type'];
+export declare const DataLifecycleRequest: Schema.Struct<{
+    readonly subjectKind: Schema.Union<readonly [Schema.Literal<"workspace">, Schema.Literal<"project">, Schema.Literal<"task">, Schema.Literal<"runner">, Schema.Literal<"runner_replica">]>;
+    readonly subjectId: Schema.String;
+    readonly workspaceId: Schema.String;
+    readonly projectId: Schema.optionalKey<Schema.String>;
+    readonly requestedDisposition: Schema.Union<readonly [Schema.Literal<"retain">, Schema.Literal<"erase">, Schema.Literal<"tombstone">]>;
+    readonly policyDigest: Schema.String;
+    readonly reasonClass: Schema.String;
+    readonly expectedResourceVersion: Schema.optionalKey<Schema.Int>;
+}>;
+export type DataLifecycleRequest = (typeof DataLifecycleRequest)['Type'];
+export declare const DataLifecycleHoldRequest: Schema.Struct<{
+    readonly scopeKind: Schema.Union<readonly [Schema.Literal<"workspace">, Schema.Literal<"project">, Schema.Literal<"task">, Schema.Literal<"runner">, Schema.Literal<"runner_replica">]>;
+    readonly scopeRef: Schema.String;
+    readonly categories: Schema.$Array<Schema.String>;
+    readonly authorityRef: Schema.String;
+    readonly reasonClass: Schema.String;
+    readonly reviewAt: Schema.String;
+    readonly policyDigest: Schema.String;
+}>;
+export type DataLifecycleHoldRequest = (typeof DataLifecycleHoldRequest)['Type'];
+export declare const DataLifecycleHold: Schema.Struct<{
+    readonly contractVersion: Schema.Literal<"data-lifecycle.v1">;
+    readonly id: Schema.String;
+    readonly caseId: Schema.String;
+    readonly scopeKind: Schema.Union<readonly [Schema.Literal<"workspace">, Schema.Literal<"project">, Schema.Literal<"task">, Schema.Literal<"runner">, Schema.Literal<"runner_replica">]>;
+    readonly scopeRef: Schema.String;
+    readonly categories: Schema.$Array<Schema.String>;
+    readonly authorityRef: Schema.String;
+    readonly reasonClass: Schema.String;
+    readonly openedAt: Schema.String;
+    readonly reviewAt: Schema.String;
+    readonly releasedAt: Schema.optionalKey<Schema.String>;
+    readonly policyDigest: Schema.String;
+    readonly actor: Schema.Struct<{
+        readonly actorType: Schema.Union<readonly [Schema.Literal<"human">, Schema.Literal<"delegated_agent">, Schema.Literal<"agent">]>;
+        readonly actorId: Schema.String;
+        readonly delegatedByUserId: Schema.optionalKey<Schema.String>;
+    }>;
+    readonly status: Schema.Union<readonly [Schema.Literal<"active">, Schema.Literal<"released">, Schema.Literal<"superseded">]>;
+}>;
+export type DataLifecycleHold = (typeof DataLifecycleHold)['Type'];
+export declare const DataLifecycleExportManifest: Schema.Struct<{
+    readonly contractVersion: Schema.Literal<"data-lifecycle.v1">;
+    readonly id: Schema.String;
+    readonly caseId: Schema.String;
+    readonly subjectKind: Schema.Union<readonly [Schema.Literal<"workspace">, Schema.Literal<"project">, Schema.Literal<"task">, Schema.Literal<"runner">, Schema.Literal<"runner_replica">]>;
+    readonly subjectId: Schema.String;
+    readonly workspaceId: Schema.String;
+    readonly policyDigest: Schema.String;
+    readonly memberDigests: Schema.$Array<Schema.String>;
+    readonly omissions: Schema.$Array<Schema.Struct<{
+        readonly category: Schema.String;
+        readonly reason: Schema.Union<readonly [Schema.Literal<"authorization">, Schema.Literal<"redaction">, Schema.Literal<"retention">, Schema.Literal<"legal_hold">, Schema.Literal<"raw_local">, Schema.Literal<"provider_owned">]>;
+    }>>;
+    readonly manifestDigest: Schema.String;
+    readonly createdAt: Schema.String;
+    readonly actor: Schema.Struct<{
+        readonly actorType: Schema.Union<readonly [Schema.Literal<"human">, Schema.Literal<"delegated_agent">, Schema.Literal<"agent">]>;
+        readonly actorId: Schema.String;
+        readonly delegatedByUserId: Schema.optionalKey<Schema.String>;
+    }>;
+}>;
+export type DataLifecycleExportManifest = (typeof DataLifecycleExportManifest)['Type'];
+export declare const DataLifecycleExportRequest: Schema.Struct<{
+    readonly memberDigests: Schema.$Array<Schema.String>;
+    readonly omissions: Schema.$Array<Schema.Struct<{
+        readonly category: Schema.String;
+        readonly reason: Schema.Union<readonly [Schema.Literal<"authorization">, Schema.Literal<"redaction">, Schema.Literal<"retention">, Schema.Literal<"legal_hold">, Schema.Literal<"raw_local">, Schema.Literal<"provider_owned">]>;
+    }>>;
+}>;
+export type DataLifecycleExportRequest = (typeof DataLifecycleExportRequest)['Type'];
+export declare const DataLifecycleErasure: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly caseId: Schema.String;
+    readonly status: Schema.Union<readonly [Schema.Literal<"requested">, Schema.Literal<"blocked_by_hold">, Schema.Literal<"approved">, Schema.Literal<"completed">, Schema.Literal<"provider_owned_nonclaim">]>;
+    readonly reasonClass: Schema.String;
+    readonly policyDigest: Schema.String;
+    readonly holdSummary: Schema.String;
+    readonly finalRedactionEpoch: Schema.Int;
+    readonly tombstoneId: Schema.optionalKey<Schema.String>;
+    readonly providerOwnedNonclaim: Schema.Boolean;
+    readonly actor: Schema.optionalKey<Schema.Struct<{
+        readonly actorType: Schema.Union<readonly [Schema.Literal<"human">, Schema.Literal<"delegated_agent">, Schema.Literal<"agent">]>;
+        readonly actorId: Schema.String;
+        readonly delegatedByUserId: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+}>;
+export type DataLifecycleErasure = (typeof DataLifecycleErasure)['Type'];
+export declare const DataLifecycleResidueResource: Schema.Struct<{
+    readonly resourceKind: Schema.String;
+    readonly resourceRef: Schema.String;
+    readonly disposition: Schema.Union<readonly [Schema.Literal<"deleted">, Schema.Literal<"quarantined">, Schema.Literal<"retained_until">, Schema.Literal<"unknown">]>;
+    readonly retainedUntil: Schema.optionalKey<Schema.String>;
+    readonly ownerRef: Schema.optionalKey<Schema.String>;
+    readonly policyDigest: Schema.String;
+    readonly nextCheckAt: Schema.optionalKey<Schema.String>;
+    readonly receiptDigest: Schema.optionalKey<Schema.String>;
+}>;
+export type DataLifecycleResidueResource = (typeof DataLifecycleResidueResource)['Type'];
+export declare const DataLifecycleResidueRequest: Schema.Struct<{
+    readonly resources: Schema.$Array<Schema.Struct<{
+        readonly resourceKind: Schema.String;
+        readonly resourceRef: Schema.String;
+        readonly disposition: Schema.Union<readonly [Schema.Literal<"deleted">, Schema.Literal<"quarantined">, Schema.Literal<"retained_until">, Schema.Literal<"unknown">]>;
+        readonly retainedUntil: Schema.optionalKey<Schema.String>;
+        readonly ownerRef: Schema.optionalKey<Schema.String>;
+        readonly policyDigest: Schema.String;
+        readonly nextCheckAt: Schema.optionalKey<Schema.String>;
+        readonly receiptDigest: Schema.optionalKey<Schema.String>;
+    }>>;
+}>;
+export type DataLifecycleResidueRequest = (typeof DataLifecycleResidueRequest)['Type'];
+export declare const DataLifecycleTombstone: Schema.Struct<{
+    readonly contractVersion: Schema.Literal<"data-lifecycle.v1">;
+    readonly id: Schema.String;
+    readonly caseId: Schema.String;
+    readonly subjectKind: Schema.Union<readonly [Schema.Literal<"workspace">, Schema.Literal<"project">, Schema.Literal<"task">, Schema.Literal<"runner">, Schema.Literal<"runner_replica">]>;
+    readonly subjectId: Schema.String;
+    readonly workspaceId: Schema.String;
+    readonly projectId: Schema.optionalKey<Schema.String>;
+    readonly taskId: Schema.optionalKey<Schema.String>;
+    readonly priorSafeDigest: Schema.optionalKey<Schema.String>;
+    readonly finalRedactionEpoch: Schema.Int;
+    readonly disposition: Schema.Union<readonly [Schema.Literal<"retain">, Schema.Literal<"erase">, Schema.Literal<"tombstone">]>;
+    readonly erasureReasonClass: Schema.String;
+    readonly retentionPolicyDigest: Schema.String;
+    readonly holdSummary: Schema.String;
+    readonly residueDisposition: Schema.optionalKey<Schema.Union<readonly [Schema.Literal<"deleted">, Schema.Literal<"quarantined">, Schema.Literal<"retained_until">, Schema.Literal<"unknown">]>>;
+    readonly createdAt: Schema.String;
+    readonly eventRef: Schema.String;
+}>;
+export type DataLifecycleTombstone = (typeof DataLifecycleTombstone)['Type'];
+export declare function isDataLifecycleTransitionAllowed(from: DataLifecycleState, to: DataLifecycleState): boolean;
+export declare function assertDataLifecycleTransition(from: DataLifecycleState, to: DataLifecycleState): void;
+export declare function isDataLifecycleSecurityContained(state: DataLifecycleState): boolean;
+export declare function lifecycleRequestDigest(input: {
+    readonly subjectKind: DataLifecycleSubjectKind;
+    readonly subjectId: string;
+    readonly workspaceId: string;
+    readonly projectId?: string;
+    readonly requestedDisposition: DataLifecycleDisposition;
+    readonly policyDigest: string;
+    readonly reasonClass: string;
+}): string;
+export declare function assertSafeDataLifecycleText(value: string, path?: string): void;
+export declare function assertSafeDataLifecycleMetadata<ValueType>(value: ValueType, path?: string): void;
+export {};

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

@@ -0,0 +1,48 @@
+import * as Schema from 'effect/Schema';
+export declare const DecisionStatuses: readonly ['active', 'superseded', 'deprecated'];
+export declare const DecisionChangeOperations: readonly ['create', 'update', 'supersede', 'deprecate'];
+export declare const DecisionStatus: Schema.Literals<readonly ["active", "superseded", "deprecated"]>;
+export declare const DecisionScopeType: Schema.Literals<readonly ["workspace", "project", "task", "kit"]>;
+export declare const DecisionContent: Schema.Struct<{
+    readonly title: Schema.String;
+    readonly decision: Schema.String;
+    readonly rationale: Schema.String;
+    readonly alternatives: Schema.$Array<Schema.String>;
+    readonly consequences: Schema.$Array<Schema.String>;
+}>;
+export declare const Decision: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly workspaceId: Schema.String;
+    readonly scopeType: Schema.Literals<readonly ["workspace", "project", "task", "kit"]>;
+    readonly scopeId: Schema.String;
+    readonly title: Schema.String;
+    readonly status: Schema.Literals<readonly ["active", "superseded", "deprecated"]>;
+    readonly decision: Schema.String;
+    readonly rationale: Schema.String;
+    readonly alternatives: Schema.$Array<Schema.String>;
+    readonly consequences: Schema.$Array<Schema.String>;
+    readonly sourceProposalId: Schema.optionalKey<Schema.String>;
+    readonly sourceTaskId: Schema.optionalKey<Schema.String>;
+    readonly supersedesDecisionId: Schema.optionalKey<Schema.String>;
+    readonly approvedByActorType: Schema.Union<readonly [Schema.Literal<"human">, Schema.Literal<"delegated_agent">, Schema.Literal<"agent">]>;
+    readonly approvedByActorId: Schema.String;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+}>;
+export declare const DecisionChange: Schema.Struct<{
+    readonly operation: Schema.Literals<readonly ["create", "update", "supersede", "deprecate"]>;
+    readonly decisionId: Schema.optionalKey<Schema.String>;
+    readonly expectedStatus: Schema.optionalKey<Schema.Literals<readonly ["active", "superseded", "deprecated"]>>;
+    readonly decision: Schema.optionalKey<Schema.Struct<{
+        readonly title: Schema.String;
+        readonly decision: Schema.String;
+        readonly rationale: Schema.String;
+        readonly alternatives: Schema.$Array<Schema.String>;
+        readonly consequences: Schema.$Array<Schema.String>;
+    }>>;
+}>;
+export type DecisionStatus = (typeof DecisionStatus)['Type'];
+export type DecisionScopeType = (typeof DecisionScopeType)['Type'];
+export type DecisionContent = (typeof DecisionContent)['Type'];
+export type Decision = (typeof Decision)['Type'];
+export type DecisionChange = (typeof DecisionChange)['Type'];

package/types/packages/core/src/delivery-operation.d.ts

@@ -0,0 +1,125 @@
+import * as Schema from 'effect/Schema';
+import type { DeliveryPolicyOperation } from './delivery-policy';
+import type { LoopCapabilityKind } from './loop';
+export declare const DeliveryOperationRequest: Schema.Union<readonly [Schema.Struct<{
+    readonly deliveryAttemptId: Schema.String;
+    readonly idempotencyKey: Schema.String;
+    readonly operation: Schema.Literal<"create_branch">;
+}>, Schema.Struct<{
+    readonly deliveryAttemptId: Schema.String;
+    readonly idempotencyKey: Schema.String;
+    readonly operation: Schema.Literal<"push_commit">;
+}>, Schema.Struct<{
+    readonly deliveryAttemptId: Schema.String;
+    readonly idempotencyKey: Schema.String;
+    readonly operation: Schema.Literal<"create_change_request">;
+    readonly title: Schema.String;
+    readonly managedContent: Schema.optionalKey<Schema.String>;
+    readonly draft: Schema.optionalKey<Schema.Boolean>;
+}>, Schema.Struct<{
+    readonly deliveryAttemptId: Schema.String;
+    readonly idempotencyKey: Schema.String;
+    readonly operation: Schema.Literal<"update_target">;
+}>, Schema.Struct<{
+    readonly deliveryAttemptId: Schema.String;
+    readonly idempotencyKey: Schema.String;
+    readonly operation: Schema.Literal<"request_review">;
+    readonly reviewers: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly teamReviewers: Schema.optionalKey<Schema.$Array<Schema.String>>;
+}>, Schema.Struct<{
+    readonly deliveryAttemptId: Schema.String;
+    readonly idempotencyKey: Schema.String;
+    readonly operation: Schema.Literal<"record_review">;
+}>, Schema.Struct<{
+    readonly deliveryAttemptId: Schema.String;
+    readonly idempotencyKey: Schema.String;
+    readonly operation: Schema.Literal<"update_description">;
+    readonly expectedBodyDigest: Schema.String;
+    readonly managedContent: Schema.String;
+}>, Schema.Struct<{
+    readonly deliveryAttemptId: Schema.String;
+    readonly idempotencyKey: Schema.String;
+    readonly operation: Schema.Literal<"reply_review_thread">;
+    readonly commentId: Schema.String;
+    readonly body: Schema.String;
+}>, Schema.Struct<{
+    readonly deliveryAttemptId: Schema.String;
+    readonly idempotencyKey: Schema.String;
+    readonly operation: Schema.Literal<"set_draft_state">;
+    readonly draft: Schema.Boolean;
+}>, Schema.Struct<{
+    readonly deliveryAttemptId: Schema.String;
+    readonly idempotencyKey: Schema.String;
+    readonly operation: Schema.Literal<"publish_check">;
+    readonly name: Schema.String;
+    readonly status: Schema.Literals<readonly ["queued", "in_progress", "completed"]>;
+    readonly conclusion: Schema.optionalKey<Schema.Literals<readonly ["success", "failure", "neutral", "cancelled", "skipped", "timed_out", "action_required"]>>;
+    readonly title: Schema.String;
+    readonly summary: Schema.String;
+}>, Schema.Struct<{
+    readonly deliveryAttemptId: Schema.String;
+    readonly idempotencyKey: Schema.String;
+    readonly operation: Schema.Literal<"set_change_request_state">;
+    readonly state: Schema.Literals<readonly ["open", "closed"]>;
+}>, Schema.Struct<{
+    readonly deliveryAttemptId: Schema.String;
+    readonly idempotencyKey: Schema.String;
+    readonly operation: Schema.Literal<"enqueue_merge_queue">;
+}>, Schema.Struct<{
+    readonly deliveryAttemptId: Schema.String;
+    readonly idempotencyKey: Schema.String;
+    readonly operation: Schema.Literal<"delete_merged_branch">;
+}>, Schema.Struct<{
+    readonly deliveryAttemptId: Schema.String;
+    readonly idempotencyKey: Schema.String;
+    readonly operation: Schema.Literal<"merge_intermediate">;
+}>, Schema.Struct<{
+    readonly deliveryAttemptId: Schema.String;
+    readonly idempotencyKey: Schema.String;
+    readonly operation: Schema.Literal<"create_final_change_request">;
+    readonly title: Schema.String;
+}>, Schema.Struct<{
+    readonly deliveryAttemptId: Schema.String;
+    readonly idempotencyKey: Schema.String;
+    readonly operation: Schema.Literal<"merge_final">;
+}>]>;
+export declare const DeliveryOperationResult: Schema.Struct<{
+    readonly deliveryAttemptId: Schema.String;
+    readonly operation: Schema.Literals<readonly ["create_branch", "push_commit", "create_change_request", "update_target", "request_review", "record_review", "update_description", "reply_review_thread", "set_draft_state", "publish_check", "set_change_request_state", "enqueue_merge_queue", "delete_merged_branch", "merge_intermediate", "create_final_change_request", "merge_final", "reconcile", "revert"]>;
+    readonly changeRequestId: Schema.optionalKey<Schema.String>;
+    readonly expectedBodyDigest: Schema.optionalKey<Schema.String>;
+    readonly draft: Schema.optionalKey<Schema.Boolean>;
+    readonly changeRequestState: Schema.optionalKey<Schema.Literals<readonly ["open", "closed", "merged"]>>;
+    readonly externalEffectId: Schema.String;
+    readonly disposition: Schema.Literals<readonly ["applied", "unknown", "reconciled_absent", "reconciled_applied", "conflict", "manual"]>;
+    readonly state: Schema.Literals<readonly ["prepared", "executing", "confirmed_applied", "confirmed_absent", "unknown", "reconciling", "manual"]>;
+    readonly reasonCode: Schema.optionalKey<Schema.String>;
+    readonly observedAt: Schema.String;
+}>;
+export declare const DeliveryOperationAvailability: Schema.Struct<{
+    readonly deliveryAttemptId: Schema.String;
+    readonly operation: Schema.Literals<readonly ["create_branch", "push_commit", "create_change_request", "update_target", "request_review", "record_review", "update_description", "reply_review_thread", "set_draft_state", "publish_check", "set_change_request_state", "enqueue_merge_queue", "delete_merged_branch", "merge_intermediate", "create_final_change_request", "merge_final", "reconcile", "revert"]>;
+    readonly available: Schema.Boolean;
+    readonly reasons: Schema.$Array<Schema.String>;
+    readonly changeRequestId: Schema.optionalKey<Schema.String>;
+    readonly expectedBodyDigest: Schema.optionalKey<Schema.String>;
+    readonly draft: Schema.optionalKey<Schema.Boolean>;
+    readonly changeRequestState: Schema.optionalKey<Schema.Literals<readonly ["draft", "open", "closed", "merged"]>>;
+}>;
+export declare const TaskDeliveryOperations: Schema.Struct<{
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly deliveryAttemptId: Schema.String;
+        readonly operation: Schema.Literals<readonly ["create_branch", "push_commit", "create_change_request", "update_target", "request_review", "record_review", "update_description", "reply_review_thread", "set_draft_state", "publish_check", "set_change_request_state", "enqueue_merge_queue", "delete_merged_branch", "merge_intermediate", "create_final_change_request", "merge_final", "reconcile", "revert"]>;
+        readonly available: Schema.Boolean;
+        readonly reasons: Schema.$Array<Schema.String>;
+        readonly changeRequestId: Schema.optionalKey<Schema.String>;
+        readonly expectedBodyDigest: Schema.optionalKey<Schema.String>;
+        readonly draft: Schema.optionalKey<Schema.Boolean>;
+        readonly changeRequestState: Schema.optionalKey<Schema.Literals<readonly ["draft", "open", "closed", "merged"]>>;
+    }>>;
+}>;
+export type DeliveryOperationRequest = (typeof DeliveryOperationRequest)['Type'];
+export type DeliveryOperationResult = (typeof DeliveryOperationResult)['Type'];
+export type DeliveryOperationAvailability = (typeof DeliveryOperationAvailability)['Type'];
+export type TaskDeliveryOperations = (typeof TaskDeliveryOperations)['Type'];
+export declare function deliveryOperationLoopCapability(operation: DeliveryPolicyOperation): LoopCapabilityKind;

package/types/packages/core/src/delivery-policy.d.ts

@@ -0,0 +1,174 @@
+import type { ActorType } from './common';
+import type { RepoBindingProvider } from './repo-binding';
+declare const DeliveryPolicyTopologies: readonly ['epic_integration', 'direct_to_default'];
+export type DeliveryPolicyTopology = (typeof DeliveryPolicyTopologies)[number];
+export declare const DeliveryPolicyOperations: readonly ['create_branch', 'push_commit', 'create_change_request', 'update_target', 'request_review', 'record_review', 'update_description', 'reply_review_thread', 'set_draft_state', 'publish_check', 'set_change_request_state', 'enqueue_merge_queue', 'delete_merged_branch', 'merge_intermediate', 'create_final_change_request', 'merge_final', 'reconcile', 'revert'];
+export type DeliveryPolicyOperation = (typeof DeliveryPolicyOperations)[number];
+export declare const DeliveryAttemptStatuses: readonly ['prepared', 'running', 'succeeded', 'failed', 'blocked', 'canceled', 'unknown_reconciliation_required', 'superseded'];
+export type DeliveryAttemptStatus = (typeof DeliveryAttemptStatuses)[number];
+export declare const DeliveryReconciliationStates: readonly ['not_required', 'pending', 'reconciling', 'resolved', 'manual'];
+export type DeliveryReconciliationState = (typeof DeliveryReconciliationStates)[number];
+declare const DeliveryFinalReviewAuthorities: readonly ['human_required', 'qualified_independent_agent'];
+type DeliveryFinalReviewAuthority = (typeof DeliveryFinalReviewAuthorities)[number];
+type DeliveryDigest = string;
+type CommitSha = string;
+export interface DeliveryRepositoryIdentity {
+    readonly provider: RepoBindingProvider;
+    readonly host: string;
+    readonly providerRepositoryId: string;
+    readonly owner: string;
+    readonly repositoryName: string;
+}
+export interface DeliveryBranchPin {
+    readonly ref: string;
+    readonly sha: CommitSha;
+}
+export interface DeliveryIntegrationBranchPolicy {
+    readonly generatedRefTemplate: string;
+    readonly ref?: string;
+    readonly creationBase: DeliveryBranchPin;
+    readonly deletionForbiddenUntilEpicClosure: boolean;
+}
+interface DeliveryVerificationPolicy {
+    readonly commandProfileDigest: DeliveryDigest;
+    readonly requiredChecks: readonly string[];
+    readonly freshnessSeconds: number;
+    readonly bindSourceSha: boolean;
+    readonly bindTargetSha: boolean;
+    readonly missingCheck: 'block' | 'manual';
+    readonly staleCheck: 'block' | 'manual';
+}
+interface DeliveryReviewPolicy {
+    readonly requiredApprovals: number;
+    readonly reviewerQualification: string;
+    readonly excludeAuthorLineage: boolean;
+    readonly unresolvedThreads: 'block' | 'allow';
+}
+interface DeliveryFinalReviewPolicy extends DeliveryReviewPolicy {
+    readonly authority: DeliveryFinalReviewAuthority;
+    readonly qualification?: string;
+}
+interface DeliveryDirectDefaultRisk {
+    readonly explicitlyOptedIn: boolean;
+    readonly reason?: string;
+    readonly approverClass?: 'human_owner' | 'human_admin' | 'qualified_independent_agent';
+    readonly extraVerificationDigest?: DeliveryDigest;
+}
+export interface DeliveryPolicy {
+    readonly id: string;
+    readonly version: number;
+    readonly digest: DeliveryDigest;
+    readonly workspaceId: string;
+    readonly projectId?: string;
+    readonly repoBindingId: string;
+    readonly epicTaskId: string;
+    readonly childTaskId?: string;
+    readonly providerHostClass: 'gitlab_com' | 'gitlab_self_managed' | 'github_com' | 'github_enterprise_server';
+    readonly repositoryIdentity: DeliveryRepositoryIdentity;
+    readonly topology: DeliveryPolicyTopology;
+    readonly integrationBranch?: DeliveryIntegrationBranchPolicy;
+    readonly defaultBranch: DeliveryBranchPin;
+    readonly taskBranchNamespace: string;
+    readonly allowStackedBranches: boolean;
+    readonly operations: readonly DeliveryPolicyOperation[];
+    readonly verification: DeliveryVerificationPolicy;
+    readonly intermediateReview: DeliveryReviewPolicy;
+    readonly finalReview: DeliveryFinalReviewPolicy;
+    readonly directDefaultRisk: DeliveryDirectDefaultRisk;
+    readonly conflicts: Readonly<Record<string, 'block' | 'manual' | 'new_attempt'>>;
+    readonly maxActiveWriteAttempts: number;
+    readonly singleWriterIntegrationBranch: boolean;
+    readonly allowedDeliveryAgentIdentityId?: string;
+    readonly accountScopeReference: string;
+    readonly evidenceRetentionClass: string;
+    readonly createdByActorType: ActorType;
+    readonly createdByActorId: string;
+    readonly createdAt: string;
+}
+export interface DeliveryPolicyDraft extends Omit<DeliveryPolicy, 'digest'> {
+    readonly digest?: DeliveryDigest;
+}
+export interface DeliveryAttempt {
+    readonly id: string;
+    readonly workspaceId: string;
+    readonly projectId: string;
+    readonly taskId: string;
+    readonly deliveryId: string;
+    readonly workUnitId: string;
+    readonly attemptNumber: number;
+    readonly policyId: string;
+    readonly policyDigest: DeliveryDigest;
+    readonly snapshotDigest: DeliveryDigest;
+    readonly operation: DeliveryPolicyOperation;
+    readonly repositoryIdentity: DeliveryRepositoryIdentity;
+    readonly source: DeliveryBranchPin;
+    readonly target: DeliveryBranchPin;
+    readonly integrationBranch?: DeliveryBranchPin;
+    readonly verificationSnapshotDigest: DeliveryDigest;
+    readonly reviewPolicyDigest: DeliveryDigest;
+    readonly effectKeys: readonly string[];
+    readonly authorActorType: ActorType;
+    readonly authorActorId: string;
+    readonly authorAgentIdentityId?: string;
+    /** Immutable actor/AgentIdentity/Loop lineage used to exclude alternate author credentials. */
+    readonly authorLineage?: readonly string[];
+    readonly status: DeliveryAttemptStatus;
+    readonly reconciliationState: DeliveryReconciliationState;
+    readonly failureCode?: string;
+    readonly createdAt: string;
+}
+export interface DeliveryChangeRequest {
+    readonly id: string;
+    readonly deliveryAttemptId: string;
+    readonly workspaceId: string;
+    readonly projectId?: string;
+    readonly taskId: string;
+    readonly repoBindingId: string;
+    readonly provider: RepoBindingProvider;
+    readonly host: string;
+    readonly owner: string;
+    readonly repositoryName: string;
+    readonly providerRepositoryId: string;
+    readonly externalId: string;
+    readonly url: string;
+    readonly title: string;
+    readonly source: DeliveryBranchPin;
+    readonly target: DeliveryBranchPin;
+    readonly status: 'draft' | 'open' | 'closed' | 'merged';
+    readonly headSha: CommitSha;
+    readonly baseSha: CommitSha;
+    readonly verificationSnapshotDigest: DeliveryDigest;
+    readonly reviewSnapshotDigest: DeliveryDigest;
+    readonly reconciliationState: DeliveryReconciliationState;
+    readonly providerObjectDigest: DeliveryDigest;
+    readonly createdByActorType: ActorType;
+    readonly createdByActorId: string;
+    readonly createdAt: string;
+}
+export interface DeliveryReviewEvidence {
+    readonly reviewerActorType: string;
+    readonly reviewerActorId: string;
+    readonly reviewerAgentIdentityId?: string;
+    readonly sourceSha: CommitSha;
+    readonly targetSha: CommitSha;
+    readonly inspectedExactRevision: boolean;
+    readonly qualified: boolean;
+    readonly authorLineage: readonly string[];
+    readonly outcome: 'approved' | 'changes_requested' | 'commented';
+}
+export interface DeliveryGateEvidence {
+    readonly checksPassed: boolean;
+    readonly checksCurrent: boolean;
+    readonly noBlockingThreads: boolean;
+    readonly mergeable: boolean;
+    readonly targetSha: CommitSha;
+    readonly sourceSha: CommitSha;
+    readonly reviews: readonly DeliveryReviewEvidence[];
+}
+export declare function createDeliveryPolicy(draft: DeliveryPolicyDraft): DeliveryPolicy;
+export declare function assertDeliveryPolicy(policy: DeliveryPolicyDraft | DeliveryPolicy): void;
+export declare function assertTargetSha(attempt: DeliveryAttempt, observedTargetSha: CommitSha): void;
+export declare function assertIndependentReview(attempt: Pick<DeliveryAttempt, 'authorActorId' | 'authorAgentIdentityId' | 'authorActorType' | 'source' | 'target'>, review: DeliveryReviewEvidence): void;
+export declare function assertIntermediateMergeGate(policy: DeliveryPolicy, attempt: DeliveryAttempt, evidence: DeliveryGateEvidence): void;
+export declare function assertFinalMergeGate(policy: DeliveryPolicy, attempt: DeliveryAttempt, evidence: DeliveryGateEvidence): void;
+export {};

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

@@ -0,0 +1,24 @@
+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/enterprise-code-host.d.ts

@@ -0,0 +1,18 @@
+import { type CodeHostCapability } from './integration';
+type EnterpriseCodeHostSetup = {
+    readonly provider: 'github' | 'gitlab';
+    readonly host: string;
+    readonly tls?: {
+        readonly customCaRef?: string;
+    };
+    readonly capabilities: readonly CodeHostCapability[];
+};
+type EnterpriseSupportEvidence = {
+    readonly provider: 'github' | 'gitlab';
+    readonly host: string;
+    readonly capability: CodeHostCapability;
+    readonly support: 'certified' | 'detected' | 'unsupported';
+    readonly evidenceDigest: string;
+};
+export declare function certifyEnterpriseCodeHostSetup(setup: EnterpriseCodeHostSetup): readonly EnterpriseSupportEvidence[];
+export {};

package/types/packages/core/src/epic-delivery.d.ts

@@ -0,0 +1,38 @@
+import { type DeliveryPolicy } from './delivery-policy';
+declare const EpicDeliveryFactKinds: readonly ['integration_branch_observed', 'task_branch_observed', 'task_change_request_opened', 'task_intermediate_merged', 'shared_branch_contribution_accepted', 'shared_branch_contribution_lost', 'task_failed', 'task_reverted', 'effect_unknown', 'target_moved', 'review_invalidated', 'final_change_request_opened', 'final_change_request_closed', 'final_merge_reconciled'];
+export type EpicDeliveryFactKind = (typeof EpicDeliveryFactKinds)[number];
+/** The immutable WorkUnit lease tuple required by every delivery mutation. */
+export interface DeliveryWorkUnitFence {
+    readonly leaseOwnerId: string;
+    readonly runnerReplicaId: string;
+    readonly leaseId: string;
+    readonly attempt: number;
+    readonly fencingToken: string;
+    readonly capacitySlot: string;
+    readonly leaseExpiresAt: string;
+}
+export interface EpicDeliveryWriterLease {
+    readonly key: string;
+    readonly workspaceId: string;
+    readonly projectId: string;
+    readonly epicTaskId: string;
+    readonly repoBindingId: string;
+    readonly provider: DeliveryPolicy['repositoryIdentity']['provider'];
+    readonly host: string;
+    readonly providerRepositoryId: string;
+    readonly policyDigest: string;
+    readonly integrationBranchRef: string;
+    readonly integrationBranchSha: string;
+    readonly ownerId: string;
+    readonly workUnitId: string;
+    readonly fence: DeliveryWorkUnitFence;
+    readonly resourceVersion: number;
+    readonly status: 'held' | 'released';
+    readonly expiresAt: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+export type { DeliveryAttempt, DeliveryPolicy } from './delivery-policy';
+export type SafeDeliveryEvidence = {
+    readonly [key: string]: string | number | boolean | null;
+};