@kitman-sh/sdk 0.0.0-stage → 0.6.0

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

@@ -0,0 +1,182 @@
+import * as Schema from 'effect/Schema';
+export declare const ContextPackModes: readonly ['planning', 'implementation', 'debugging', 'review', 'handoff'];
+export declare const ContextPackIndexEntryKinds: readonly ['task', 'project', 'kit', 'memory', 'decision', 'session', 'session_update', 'proposal', 'task_dependency', 'repo_binding', 'agent_environment', 'loop_step'];
+export declare const ContextPackRetrievalRefKinds: readonly ['kit', 'memory', 'decision', 'session', 'session_update', 'proposal', 'task_dependency', 'repo_binding', 'agent_environment', 'loop_step'];
+export declare const DefaultContextPackMode = "implementation";
+export declare const ContextPackMode: Schema.Union<readonly [Schema.Literal<"planning">, Schema.Literal<"implementation">, Schema.Literal<"debugging">, Schema.Literal<"review">, Schema.Literal<"handoff">]>;
+export declare const ContextPackRetrievalRefKind: Schema.Literals<readonly ["kit", "memory", "decision", "session", "session_update", "proposal", "task_dependency", "repo_binding", "agent_environment", "loop_step"]>;
+export declare const ContextPackLaunchBrief: Schema.Struct<{
+    readonly mode: Schema.Union<readonly [Schema.Literal<"planning">, Schema.Literal<"implementation">, Schema.Literal<"debugging">, Schema.Literal<"review">, Schema.Literal<"handoff">]>;
+    readonly taskTitle: Schema.String;
+    readonly projectName: Schema.optionalKey<Schema.String>;
+    readonly summary: Schema.String;
+}>;
+export declare const ContextPackIndexEntry: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["task", "project", "kit", "memory", "decision", "session", "session_update", "proposal", "task_dependency", "repo_binding", "agent_environment", "loop_step"]>;
+    readonly id: Schema.String;
+    readonly title: Schema.String;
+    readonly reason: Schema.String;
+}>;
+export declare const ContextPackRetrievalRef: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["kit", "memory", "decision", "session", "session_update", "proposal", "task_dependency", "repo_binding", "agent_environment", "loop_step"]>;
+    readonly id: Schema.String;
+    readonly label: Schema.String;
+}>;
+export declare function normalizeContextPackVerificationCommands<InputType>(input: InputType): string[];
+export declare const ContextPackRelevanceSummary: Schema.Struct<{
+    readonly included: Schema.$Array<Schema.String>;
+    readonly omitted: Schema.$Array<Schema.String>;
+    readonly notes: Schema.$Array<Schema.String>;
+    readonly readiness: Schema.optionalKey<Schema.Struct<{
+        readonly scopeAvailable: Schema.Boolean;
+        readonly acceptanceCriteriaAvailable: Schema.Boolean;
+        readonly dependenciesSatisfied: Schema.Boolean;
+        readonly executionPlanAvailable: Schema.Boolean;
+        readonly repoBindingAvailable: Schema.Boolean;
+        readonly verificationCommands: Schema.$Array<Schema.String>;
+        readonly deliveryTargetAvailable: Schema.Boolean;
+    }>>;
+}>;
+export declare const ContextPackBudget: Schema.Struct<{
+    readonly maxMarkdownChars: Schema.Int;
+    readonly markdownChars: Schema.Int;
+    readonly indexedItemCount: Schema.Int;
+    readonly retrievalRefCount: Schema.Int;
+}>;
+export declare const ContextPack: Schema.Struct<{
+    readonly contextPackId: Schema.String;
+    readonly workspaceId: Schema.String;
+    readonly projectId: Schema.optionalKey<Schema.String>;
+    readonly taskId: Schema.String;
+    readonly mode: Schema.Union<readonly [Schema.Literal<"planning">, Schema.Literal<"implementation">, Schema.Literal<"debugging">, Schema.Literal<"review">, Schema.Literal<"handoff">]>;
+    readonly contentMarkdown: Schema.String;
+    readonly launchBrief: Schema.Struct<{
+        readonly mode: Schema.Union<readonly [Schema.Literal<"planning">, Schema.Literal<"implementation">, Schema.Literal<"debugging">, Schema.Literal<"review">, Schema.Literal<"handoff">]>;
+        readonly taskTitle: Schema.String;
+        readonly projectName: Schema.optionalKey<Schema.String>;
+        readonly summary: Schema.String;
+    }>;
+    readonly contextIndex: Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["task", "project", "kit", "memory", "decision", "session", "session_update", "proposal", "task_dependency", "repo_binding", "agent_environment", "loop_step"]>;
+        readonly id: Schema.String;
+        readonly title: Schema.String;
+        readonly reason: Schema.String;
+    }>>;
+    readonly retrievalRefs: Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["kit", "memory", "decision", "session", "session_update", "proposal", "task_dependency", "repo_binding", "agent_environment", "loop_step"]>;
+        readonly id: Schema.String;
+        readonly label: Schema.String;
+    }>>;
+    readonly relevanceSummary: Schema.Struct<{
+        readonly included: Schema.$Array<Schema.String>;
+        readonly omitted: Schema.$Array<Schema.String>;
+        readonly notes: Schema.$Array<Schema.String>;
+        readonly readiness: Schema.optionalKey<Schema.Struct<{
+            readonly scopeAvailable: Schema.Boolean;
+            readonly acceptanceCriteriaAvailable: Schema.Boolean;
+            readonly dependenciesSatisfied: Schema.Boolean;
+            readonly executionPlanAvailable: Schema.Boolean;
+            readonly repoBindingAvailable: Schema.Boolean;
+            readonly verificationCommands: Schema.$Array<Schema.String>;
+            readonly deliveryTargetAvailable: Schema.Boolean;
+        }>>;
+    }>;
+    readonly budget: Schema.Struct<{
+        readonly maxMarkdownChars: Schema.Int;
+        readonly markdownChars: Schema.Int;
+        readonly indexedItemCount: Schema.Int;
+        readonly retrievalRefCount: Schema.Int;
+    }>;
+    readonly includedKitIds: Schema.$Array<Schema.String>;
+    readonly includedMemoryIds: Schema.$Array<Schema.String>;
+    readonly includedDecisionIds: Schema.$Array<Schema.String>;
+    readonly includedProposalIds: Schema.$Array<Schema.String>;
+    readonly includedSessionIds: Schema.$Array<Schema.String>;
+    readonly createdByActorType: Schema.Union<readonly [Schema.Literal<"human">, Schema.Literal<"delegated_agent">, Schema.Literal<"agent">]>;
+    readonly createdByActorId: Schema.String;
+    readonly createdAt: Schema.String;
+}>;
+export declare const ContextPackGenerate: Schema.Struct<{
+    readonly mode: Schema.optionalKey<Schema.Union<readonly [Schema.Literal<"planning">, Schema.Literal<"implementation">, Schema.Literal<"debugging">, Schema.Literal<"review">, Schema.Literal<"handoff">]>>;
+}>;
+export declare const ContextPackLatestQuery: Schema.Struct<{
+    readonly mode: Schema.optionalKey<Schema.Union<readonly [Schema.Literal<"planning">, Schema.Literal<"implementation">, Schema.Literal<"debugging">, Schema.Literal<"review">, Schema.Literal<"handoff">]>>;
+}>;
+export declare const ContextPackResult: Schema.Struct<{
+    readonly contextPackId: Schema.String;
+    readonly mode: Schema.Union<readonly [Schema.Literal<"planning">, Schema.Literal<"implementation">, Schema.Literal<"debugging">, Schema.Literal<"review">, Schema.Literal<"handoff">]>;
+    readonly contentMarkdown: Schema.String;
+    readonly launchBrief: Schema.optionalKey<Schema.Struct<{
+        readonly mode: Schema.Union<readonly [Schema.Literal<"planning">, Schema.Literal<"implementation">, Schema.Literal<"debugging">, Schema.Literal<"review">, Schema.Literal<"handoff">]>;
+        readonly taskTitle: Schema.String;
+        readonly projectName: Schema.optionalKey<Schema.String>;
+        readonly summary: Schema.String;
+    }>>;
+    readonly contextIndex: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["task", "project", "kit", "memory", "decision", "session", "session_update", "proposal", "task_dependency", "repo_binding", "agent_environment", "loop_step"]>;
+        readonly id: Schema.String;
+        readonly title: Schema.String;
+        readonly reason: Schema.String;
+    }>>>;
+    readonly retrievalRefs: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["kit", "memory", "decision", "session", "session_update", "proposal", "task_dependency", "repo_binding", "agent_environment", "loop_step"]>;
+        readonly id: Schema.String;
+        readonly label: Schema.String;
+    }>>>;
+    readonly relevanceSummary: Schema.optionalKey<Schema.Struct<{
+        readonly included: Schema.$Array<Schema.String>;
+        readonly omitted: Schema.$Array<Schema.String>;
+        readonly notes: Schema.$Array<Schema.String>;
+        readonly readiness: Schema.optionalKey<Schema.Struct<{
+            readonly scopeAvailable: Schema.Boolean;
+            readonly acceptanceCriteriaAvailable: Schema.Boolean;
+            readonly dependenciesSatisfied: Schema.Boolean;
+            readonly executionPlanAvailable: Schema.Boolean;
+            readonly repoBindingAvailable: Schema.Boolean;
+            readonly verificationCommands: Schema.$Array<Schema.String>;
+            readonly deliveryTargetAvailable: Schema.Boolean;
+        }>>;
+    }>>;
+    readonly budget: Schema.optionalKey<Schema.Struct<{
+        readonly maxMarkdownChars: Schema.Int;
+        readonly markdownChars: Schema.Int;
+        readonly indexedItemCount: Schema.Int;
+        readonly retrievalRefCount: Schema.Int;
+    }>>;
+    readonly includedDecisionIds: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly includedProposalIds: Schema.optionalKey<Schema.$Array<Schema.String>>;
+}>;
+export declare const ContextPackRetrievalInput: Schema.Struct<{
+    readonly contextPackId: Schema.String;
+    readonly ref: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["kit", "memory", "decision", "session", "session_update", "proposal", "task_dependency", "repo_binding", "agent_environment", "loop_step"]>;
+        readonly id: Schema.String;
+        readonly label: Schema.String;
+    }>;
+}>;
+export declare const ContextPackRetrievedContext: Schema.Struct<{
+    readonly contextPackId: Schema.String;
+    readonly ref: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["kit", "memory", "decision", "session", "session_update", "proposal", "task_dependency", "repo_binding", "agent_environment", "loop_step"]>;
+        readonly id: Schema.String;
+        readonly label: Schema.String;
+    }>;
+    readonly contentMarkdown: Schema.String;
+    readonly safety: Schema.Struct<{
+        readonly rawContentIncluded: Schema.Boolean;
+        readonly notes: Schema.$Array<Schema.String>;
+    }>;
+}>;
+export type ContextPackMode = (typeof ContextPackMode)['Type'];
+export type ContextPackRetrievalRefKind = (typeof ContextPackRetrievalRefKind)['Type'];
+export type ContextPackLaunchBrief = (typeof ContextPackLaunchBrief)['Type'];
+export type ContextPackIndexEntry = (typeof ContextPackIndexEntry)['Type'];
+export type ContextPackRetrievalRef = (typeof ContextPackRetrievalRef)['Type'];
+export type ContextPackRelevanceSummary = (typeof ContextPackRelevanceSummary)['Type'];
+export type ContextPackBudget = (typeof ContextPackBudget)['Type'];
+export type ContextPack = (typeof ContextPack)['Type'];
+export type ContextPackGenerate = (typeof ContextPackGenerate)['Type'];
+export type ContextPackLatestQuery = (typeof ContextPackLatestQuery)['Type'];
+export type ContextPackResult = (typeof ContextPackResult)['Type'];
+export type ContextPackRetrievalInput = (typeof ContextPackRetrievalInput)['Type'];
+export type ContextPackRetrievedContext = (typeof ContextPackRetrievedContext)['Type'];

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

@@ -0,0 +1,11 @@
+type Encoding = 'hex' | 'base64' | 'base64url';
+type Data = string | Uint8Array;
+export declare function digestSha256(data: Data | readonly Data[], encoding: Encoding): string;
+export declare function hmacSha256Bytes(secret: Data, data: Data | readonly Data[]): Uint8Array;
+export declare function hmacSha256(secret: Data, data: Data | readonly Data[], encoding: Encoding): string;
+/** Constant-time equality; values of different lengths are unequal. */
+export declare function timingSafeEqualBytes(left: Uint8Array, right: Uint8Array): boolean;
+export declare function timingSafeEqualText(left: string, right: string): boolean;
+export declare function rsaSha256Signature(privateKey: string, data: string): string;
+export declare function randomBase64Url(byteLength: number): string;
+export {};

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;