@kitman-sh/sdk 0.0.0-stage → 0.7.0

package/types/packages/core/src/fix-flow.d.ts

@@ -0,0 +1,149 @@
+import * as Schema from 'effect/Schema';
+export declare const FixFlowFailureCategories: readonly ['harness_error', 'sandbox_error', 'verification_failed', 'review_failed', 'delivery_failed', 'missing_context', 'context_stale', 'rate_limited', 'canceled', 'missing_skill', 'stale_lease', 'missing_secret', 'materialization_failed', 'runner_unavailable', 'sandbox_unsupported', 'readiness_blocked', 'unknown'];
+export declare const FixFlowRecoveryActions: readonly ['retry', 'repair_readiness', 'refresh_context', 'sync_agent_environment', 'escalate_sandbox', 'pause', 'resume', 'cancel', 'takeover', 'rotate_secret_ref', 'rerun_verification', 'create_follow_up', 'drain_replica', 'discard_cache'];
+export declare const FixFlowRecoveryAction: Schema.Literals<readonly ["retry", "repair_readiness", "refresh_context", "sync_agent_environment", "escalate_sandbox", "pause", "resume", "cancel", "takeover", "rotate_secret_ref", "rerun_verification", "create_follow_up", "drain_replica", "discard_cache"]>;
+type FixFlowSafeMetadataValue = string | boolean | number | null | readonly FixFlowSafeMetadataValue[] | {
+    readonly [key: string]: FixFlowSafeMetadataValue;
+};
+declare const FixFlowSafeMetadataValue: Schema.Codec<FixFlowSafeMetadataValue>;
+export declare const FixFlowFailure: Schema.Struct<{
+    readonly outcome: Schema.Literals<readonly ["retry", "repair_task", "blocked", "terminal_failure"]>;
+    readonly category: Schema.Literals<readonly ["harness_error", "sandbox_error", "verification_failed", "review_failed", "delivery_failed", "missing_context", "context_stale", "rate_limited", "canceled", "missing_skill", "stale_lease", "missing_secret", "materialization_failed", "runner_unavailable", "sandbox_unsupported", "readiness_blocked", "unknown"]>;
+    readonly summary: Schema.String;
+    readonly retryAfterSeconds: Schema.optionalKey<Schema.Int>;
+    readonly repairTask: Schema.optionalKey<Schema.Struct<{
+        readonly title: Schema.String;
+        readonly reason: Schema.String;
+        readonly blocksCurrentTask: Schema.Boolean;
+        readonly suggestedStatus: Schema.optionalKey<Schema.Union<readonly [Schema.Literal<"ready">, Schema.Literal<"blocked">, Schema.Literal<"backlog">]>>;
+    }>>;
+    readonly evidenceRefs: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.String;
+        readonly id: Schema.optionalKey<Schema.String>;
+        readonly title: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<FixFlowSafeMetadataValue, FixFlowSafeMetadataValue, never, never>>>;
+}>;
+export declare const FixFlowRecoveryRequest: Schema.Struct<{
+    readonly action: Schema.optionalKey<Schema.Literals<readonly ["retry", "repair_readiness", "refresh_context", "sync_agent_environment", "escalate_sandbox", "pause", "resume", "cancel", "takeover", "rotate_secret_ref", "rerun_verification", "create_follow_up", "drain_replica", "discard_cache"]>>;
+    readonly stepKey: Schema.optionalKey<Schema.String>;
+    readonly expectedResourceVersion: Schema.optionalKey<Schema.Int>;
+}>;
+export declare const FixFlowRecoveryPlan: Schema.Struct<{
+    readonly contractVersion: Schema.Literal<"fix-flow.v1">;
+    readonly productName: Schema.Literal<"Fix Flow">;
+    readonly target: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["loop_step", "step_attempt", "run", "task", "runner_replica"]>;
+        readonly id: Schema.String;
+    }>;
+    readonly canonicalIds: Schema.Struct<{
+        readonly workUnitId: Schema.optionalKey<Schema.String>;
+        readonly stepAttemptId: Schema.optionalKey<Schema.String>;
+        readonly runId: Schema.optionalKey<Schema.String>;
+        readonly taskId: Schema.optionalKey<Schema.String>;
+        readonly runnerReplicaId: Schema.optionalKey<Schema.String>;
+        readonly stepKey: Schema.optionalKey<Schema.String>;
+    }>;
+    readonly failure: Schema.Struct<{
+        readonly outcome: Schema.Literals<readonly ["retry", "repair_task", "blocked", "terminal_failure"]>;
+        readonly category: Schema.Literals<readonly ["harness_error", "sandbox_error", "verification_failed", "review_failed", "delivery_failed", "missing_context", "context_stale", "rate_limited", "canceled", "missing_skill", "stale_lease", "missing_secret", "materialization_failed", "runner_unavailable", "sandbox_unsupported", "readiness_blocked", "unknown"]>;
+        readonly summary: Schema.String;
+        readonly retryAfterSeconds: Schema.optionalKey<Schema.Int>;
+        readonly repairTask: Schema.optionalKey<Schema.Struct<{
+            readonly title: Schema.String;
+            readonly reason: Schema.String;
+            readonly blocksCurrentTask: Schema.Boolean;
+            readonly suggestedStatus: Schema.optionalKey<Schema.Union<readonly [Schema.Literal<"ready">, Schema.Literal<"blocked">, Schema.Literal<"backlog">]>>;
+        }>>;
+        readonly evidenceRefs: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly kind: Schema.String;
+            readonly id: Schema.optionalKey<Schema.String>;
+            readonly title: Schema.optionalKey<Schema.String>;
+        }>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<FixFlowSafeMetadataValue, FixFlowSafeMetadataValue, never, never>>>;
+    }>;
+    readonly recommendedAction: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["retry", "repair_readiness", "refresh_context", "sync_agent_environment", "escalate_sandbox", "pause", "resume", "cancel", "takeover", "rotate_secret_ref", "rerun_verification", "create_follow_up", "drain_replica", "discard_cache"]>;
+        readonly label: Schema.String;
+        readonly reason: Schema.String;
+        readonly requiresApproval: Schema.Boolean;
+    }>;
+    readonly evidenceRefs: Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.String;
+        readonly id: Schema.optionalKey<Schema.String>;
+        readonly title: Schema.optionalKey<Schema.String>;
+    }>>;
+}>;
+export declare const FixFlowRecoveryResult: Schema.Struct<{
+    readonly contractVersion: Schema.Literal<"fix-flow.v1">;
+    readonly productName: Schema.Literal<"Fix Flow">;
+    readonly status: Schema.Union<readonly [Schema.Literal<"applied">, Schema.Literal<"queued">, Schema.Literal<"already_applied">]>;
+    readonly action: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["retry", "repair_readiness", "refresh_context", "sync_agent_environment", "escalate_sandbox", "pause", "resume", "cancel", "takeover", "rotate_secret_ref", "rerun_verification", "create_follow_up", "drain_replica", "discard_cache"]>;
+        readonly label: Schema.String;
+        readonly reason: Schema.String;
+        readonly requiresApproval: Schema.Boolean;
+    }>;
+    readonly summary: Schema.String;
+    readonly changedRefs: Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.String;
+        readonly id: Schema.optionalKey<Schema.String>;
+        readonly title: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly evidenceRefs: Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.String;
+        readonly id: Schema.optionalKey<Schema.String>;
+        readonly title: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly plan: Schema.optionalKey<Schema.Struct<{
+        readonly contractVersion: Schema.Literal<"fix-flow.v1">;
+        readonly productName: Schema.Literal<"Fix Flow">;
+        readonly target: Schema.Struct<{
+            readonly kind: Schema.Literals<readonly ["loop_step", "step_attempt", "run", "task", "runner_replica"]>;
+            readonly id: Schema.String;
+        }>;
+        readonly canonicalIds: Schema.Struct<{
+            readonly workUnitId: Schema.optionalKey<Schema.String>;
+            readonly stepAttemptId: Schema.optionalKey<Schema.String>;
+            readonly runId: Schema.optionalKey<Schema.String>;
+            readonly taskId: Schema.optionalKey<Schema.String>;
+            readonly runnerReplicaId: Schema.optionalKey<Schema.String>;
+            readonly stepKey: Schema.optionalKey<Schema.String>;
+        }>;
+        readonly failure: Schema.Struct<{
+            readonly outcome: Schema.Literals<readonly ["retry", "repair_task", "blocked", "terminal_failure"]>;
+            readonly category: Schema.Literals<readonly ["harness_error", "sandbox_error", "verification_failed", "review_failed", "delivery_failed", "missing_context", "context_stale", "rate_limited", "canceled", "missing_skill", "stale_lease", "missing_secret", "materialization_failed", "runner_unavailable", "sandbox_unsupported", "readiness_blocked", "unknown"]>;
+            readonly summary: Schema.String;
+            readonly retryAfterSeconds: Schema.optionalKey<Schema.Int>;
+            readonly repairTask: Schema.optionalKey<Schema.Struct<{
+                readonly title: Schema.String;
+                readonly reason: Schema.String;
+                readonly blocksCurrentTask: Schema.Boolean;
+                readonly suggestedStatus: Schema.optionalKey<Schema.Union<readonly [Schema.Literal<"ready">, Schema.Literal<"blocked">, Schema.Literal<"backlog">]>>;
+            }>>;
+            readonly evidenceRefs: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly kind: Schema.String;
+                readonly id: Schema.optionalKey<Schema.String>;
+                readonly title: Schema.optionalKey<Schema.String>;
+            }>>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<FixFlowSafeMetadataValue, FixFlowSafeMetadataValue, never, never>>>;
+        }>;
+        readonly recommendedAction: Schema.Struct<{
+            readonly kind: Schema.Literals<readonly ["retry", "repair_readiness", "refresh_context", "sync_agent_environment", "escalate_sandbox", "pause", "resume", "cancel", "takeover", "rotate_secret_ref", "rerun_verification", "create_follow_up", "drain_replica", "discard_cache"]>;
+            readonly label: Schema.String;
+            readonly reason: Schema.String;
+            readonly requiresApproval: Schema.Boolean;
+        }>;
+        readonly evidenceRefs: Schema.$Array<Schema.Struct<{
+            readonly kind: Schema.String;
+            readonly id: Schema.optionalKey<Schema.String>;
+            readonly title: Schema.optionalKey<Schema.String>;
+        }>>;
+    }>>;
+}>;
+export type FixFlowRecoveryAction = (typeof FixFlowRecoveryAction)['Type'];
+export type FixFlowFailure = (typeof FixFlowFailure)['Type'];
+export type FixFlowRecoveryPlan = (typeof FixFlowRecoveryPlan)['Type'];
+export type FixFlowRecoveryRequest = (typeof FixFlowRecoveryRequest)['Type'];
+export type FixFlowRecoveryResult = (typeof FixFlowRecoveryResult)['Type'];
+export {};

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

@@ -0,0 +1,59 @@
+import * as Schema from 'effect/Schema';
+export declare const FollowTarget: Schema.Struct<{
+    readonly kind: Schema.Literal<"task">;
+    readonly taskId: Schema.String;
+}>;
+export declare const FollowEventPreset: Schema.Literals<readonly ["attention", "all"]>;
+export declare const FollowCreate: Schema.Struct<{
+    readonly target: Schema.Struct<{
+        readonly kind: Schema.Literal<"task">;
+        readonly taskId: Schema.String;
+    }>;
+    readonly preset: Schema.optionalKey<Schema.Literals<readonly ["attention", "all"]>>;
+}>;
+export declare const Follow: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly workspaceId: Schema.String;
+    readonly target: Schema.Struct<{
+        readonly kind: Schema.Literal<"task">;
+        readonly taskId: Schema.String;
+    }>;
+    readonly preset: Schema.Literals<readonly ["attention", "all"]>;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+}>;
+export declare const FollowListQuery: Schema.Struct<{
+    readonly limit: Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.FiniteFromString]>>;
+    readonly cursor: Schema.optionalKey<Schema.String>;
+}>;
+export declare const FollowList: Schema.Struct<{
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly workspaceId: Schema.String;
+        readonly target: Schema.Struct<{
+            readonly kind: Schema.Literal<"task">;
+            readonly taskId: Schema.String;
+        }>;
+        readonly preset: Schema.Literals<readonly ["attention", "all"]>;
+        readonly createdAt: Schema.String;
+        readonly updatedAt: Schema.String;
+    }>>;
+    readonly pageInfo: Schema.Union<readonly [Schema.Struct<{
+        readonly limit: Schema.Int;
+        readonly hasNextPage: Schema.Literal<false>;
+    }>, Schema.Struct<{
+        readonly limit: Schema.Int;
+        readonly hasNextPage: Schema.Literal<true>;
+        readonly nextCursor: Schema.String;
+    }>]>;
+}>;
+export declare const FollowDelete: Schema.Struct<{
+    readonly deleted: Schema.Literal<true>;
+}>;
+export type FollowTarget = (typeof FollowTarget)['Type'];
+export type FollowEventPreset = (typeof FollowEventPreset)['Type'];
+export type FollowCreate = (typeof FollowCreate)['Type'];
+export type Follow = (typeof Follow)['Type'];
+export type FollowListQuery = (typeof FollowListQuery)['Type'];
+export type FollowList = (typeof FollowList)['Type'];
+export type FollowDelete = (typeof FollowDelete)['Type'];

package/types/packages/core/src/github-delivery-fixtures.d.ts

@@ -0,0 +1,28 @@
+/** Non-secret certification fixtures. Hosted GitHub and GHES remain independent rows. */
+export declare const GitHubDeliveryCertificationFixtures: readonly [{
+    readonly rowId: 'DELIVERY-GITHUB-COM-EPIC-INTEGRATION-V1';
+    readonly hostClass: 'github_com';
+    readonly host: 'github.com';
+    readonly repositoryId: 'fixture-github-com-repository';
+    readonly owner: 'kitman-fixtures';
+    readonly repositoryName: 'epic-delivery';
+    readonly adapterVersion: 'github.v1';
+    readonly apiVersion: '2022-11-28';
+    readonly accountScopeDigest: string;
+    readonly apiBaseUrl: 'https://api.github.com';
+    readonly protectionProfile: 'protected-default-human-merge';
+    readonly authMode: 'runner_secret_ref';
+}, {
+    readonly rowId: 'DELIVERY-GHES-EPIC-INTEGRATION-V1';
+    readonly hostClass: 'github_enterprise_server';
+    readonly host: 'github.example.test';
+    readonly repositoryId: 'fixture-ghes-repository';
+    readonly owner: 'kitman-fixtures';
+    readonly repositoryName: 'epic-delivery';
+    readonly adapterVersion: 'github.v1';
+    readonly apiVersion: '2022-11-28';
+    readonly accountScopeDigest: string;
+    readonly apiBaseUrl: 'https://github.example.test/api/v3';
+    readonly protectionProfile: 'protected-default-human-merge';
+    readonly authMode: 'runner_secret_ref';
+}];

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

@@ -0,0 +1,78 @@
+import type { JsonValue } from './runtime-type';
+import type { DeliveryAttempt, DeliveryPolicy, DeliveryPolicyOperation } from './delivery-policy';
+export declare const GitHubProviderOperations: readonly ['create_branch', 'update_branch', 'create_pull_request', 'update_pull_request', 'read_checks', 'request_review', 'record_review', 'update_description', 'reply_review_thread', 'set_draft_state', 'publish_check_run', 'set_pull_request_state', 'enqueue_pull_request', 'delete_merged_branch', 'merge_pull_request', 'reconcile', 'conflict'];
+type GitHubProviderOperation = (typeof GitHubProviderOperations)[number];
+type GitHubHostClass = 'github_com' | 'github_enterprise_server';
+type GitHubObservationClassification = 'found_same' | 'not_found' | 'found_conflict';
+export declare function assertGitHubProviderOperation(deliveryOperation: DeliveryPolicyOperation, providerOperation: GitHubProviderOperation): void;
+export declare function githubProviderOperationForDeliveryOperation(deliveryOperation: DeliveryPolicyOperation): GitHubProviderOperation;
+export interface DeclaredGitHubRepository {
+    readonly rowId: string;
+    readonly hostClass: GitHubHostClass;
+    readonly host: string;
+    readonly repositoryId: string;
+    readonly owner: string;
+    readonly repositoryName: string;
+    readonly adapterVersion: string;
+    readonly apiVersion: string;
+    readonly accountScopeDigest: string;
+    readonly apiBaseUrl: string;
+}
+export interface GitHubDeliveryExpectation {
+    readonly operation: GitHubProviderOperation;
+    readonly deliveryOperation: DeliveryPolicyOperation;
+    readonly repositoryId: string;
+    readonly host: string;
+    readonly sourceBranch?: string;
+    readonly targetBranch?: string;
+    readonly sourceSha?: string;
+    readonly targetSha?: string;
+    readonly pullRequestNumber?: string;
+    readonly title?: string;
+    readonly effectMarker: string;
+}
+export interface GitHubProviderObservation {
+    readonly operation: GitHubProviderOperation;
+    readonly repositoryId: string;
+    readonly host: string;
+    readonly providerObjectId?: string;
+    readonly pullRequestNumber?: string;
+    readonly sourceBranch?: string;
+    readonly targetBranch?: string;
+    readonly sourceSha?: string;
+    readonly targetSha?: string;
+    readonly effectMarker?: string;
+    readonly resultingSha?: string;
+}
+type GitHubIdentityPin = 'sourceBranch' | 'targetBranch' | 'sourceSha' | 'targetSha' | 'pullRequestNumber';
+export declare function githubIdentityPinsForOperation(operation: GitHubProviderOperation): readonly GitHubIdentityPin[];
+export declare function normalizeGitHubDeliveryExpectation(expectation: GitHubDeliveryExpectation, attempt: Pick<DeliveryAttempt, 'source' | 'target'>): GitHubDeliveryExpectation;
+declare const GitHubDeliveryError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "GitHubDeliveryError";
+} & Readonly<A>;
+export declare class GitHubDeliveryError extends GitHubDeliveryError_base<{
+    readonly code: string;
+    readonly message: string;
+}> {
+    constructor(code: string, message: string);
+}
+export declare function isDeclaredGitHubHost(input: Pick<DeclaredGitHubRepository, 'hostClass' | 'host'>): boolean;
+export declare function assertDeclaredGitHubRepository(repository: DeclaredGitHubRepository): void;
+export declare function assertSafeGitHubRef(ref: string): void;
+export declare function githubRepositoryPath(repository: Pick<DeclaredGitHubRepository, 'owner' | 'repositoryName'>): string;
+export declare function assertGitHubDeliveryTarget(input: {
+    readonly policy: DeliveryPolicy;
+    readonly operation: DeliveryPolicyOperation;
+    readonly targetBranch: string;
+}): void;
+export declare function githubRequestMarker(input: {
+    readonly effectKey: string;
+    readonly policyDigest: string;
+}): string;
+export declare function classifyGitHubProviderObservation(expected: GitHubDeliveryExpectation, observed: GitHubProviderObservation | null): GitHubObservationClassification;
+export declare function assertExactGitHubSha(expected: string, observed: string, kind: 'source' | 'target'): void;
+export type GitHubProviderEvidence = {
+    readonly [key: string]: JsonValue;
+};
+export declare function safeGitHubProviderEvidence<Evidence extends GitHubProviderEvidence>(input: Evidence): Evidence;
+export {};

package/types/packages/core/src/gitlab-delivery-fixtures.d.ts

@@ -0,0 +1,26 @@
+/** Non-secret certification fixtures. They intentionally describe two independent rows. */
+export declare const GitLabDeliveryCertificationFixtures: readonly [{
+    readonly rowId: 'DELIVERY-GITLAB-COM-EPIC-INTEGRATION-V1';
+    readonly hostClass: 'gitlab_com';
+    readonly host: 'gitlab.com';
+    readonly projectId: 'fixture-gitlab-com-project';
+    readonly owner: 'kitman-fixtures';
+    readonly repositoryName: 'epic-delivery';
+    readonly adapterVersion: 'gitlab.v1';
+    readonly accountScopeDigest: string;
+    readonly apiBaseUrl: 'https://gitlab.com/api/v4';
+    readonly protectionProfile: 'protected-default-human-merge';
+    readonly authMode: 'runner_secret_ref';
+}, {
+    readonly rowId: 'DELIVERY-GITLAB-SELF-MANAGED-EPIC-INTEGRATION-V1';
+    readonly hostClass: 'gitlab_self_managed';
+    readonly host: 'gitlab.example.test';
+    readonly projectId: 'fixture-gitlab-self-managed-project';
+    readonly owner: 'kitman-fixtures';
+    readonly repositoryName: 'epic-delivery';
+    readonly adapterVersion: 'gitlab.v1';
+    readonly accountScopeDigest: string;
+    readonly apiBaseUrl: 'https://gitlab.example.test/api/v4';
+    readonly protectionProfile: 'protected-default-human-merge';
+    readonly authMode: 'runner_secret_ref';
+}];

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

@@ -0,0 +1,76 @@
+import type { JsonValue } from './runtime-type';
+import type { DeliveryAttempt, DeliveryPolicy, DeliveryPolicyOperation } from './delivery-policy';
+export declare const GitLabProviderOperations: readonly ['create_branch', 'update_branch', 'create_merge_request', 'update_merge_request', 'read_checks', 'request_review', 'record_review', 'update_description', 'reply_discussion', 'set_draft_state', 'publish_commit_status', 'set_merge_request_state', 'enqueue_merge_train', 'delete_merged_branch', 'merge_merge_request', 'revert_merge_request', 'reconcile', 'conflict'];
+type GitLabProviderOperation = (typeof GitLabProviderOperations)[number];
+type GitLabHostClass = 'gitlab_com' | 'gitlab_self_managed';
+type GitLabObservationClassification = 'found_same' | 'not_found' | 'found_conflict';
+export declare function assertGitLabProviderOperation(deliveryOperation: DeliveryPolicyOperation, providerOperation: GitLabProviderOperation): void;
+export declare function gitlabProviderOperationForDeliveryOperation(deliveryOperation: DeliveryPolicyOperation): GitLabProviderOperation;
+export interface DeclaredGitLabProject {
+    readonly rowId: string;
+    readonly hostClass: GitLabHostClass;
+    readonly host: string;
+    readonly projectId: string;
+    readonly owner: string;
+    readonly repositoryName: string;
+    readonly adapterVersion: string;
+    readonly accountScopeDigest: string;
+    readonly apiBaseUrl: string;
+}
+export interface GitLabDeliveryExpectation {
+    readonly operation: GitLabProviderOperation;
+    readonly deliveryOperation: DeliveryPolicyOperation;
+    readonly projectId: string;
+    readonly host: string;
+    readonly sourceBranch?: string;
+    readonly targetBranch?: string;
+    readonly sourceSha?: string;
+    readonly targetSha?: string;
+    readonly mergeRequestIid?: string;
+    readonly title?: string;
+    readonly effectMarker: string;
+}
+export interface GitLabProviderObservation {
+    readonly operation: GitLabProviderOperation;
+    readonly projectId: string;
+    readonly host: string;
+    readonly providerObjectId?: string;
+    readonly mergeRequestIid?: string;
+    readonly sourceBranch?: string;
+    readonly targetBranch?: string;
+    readonly sourceSha?: string;
+    readonly targetSha?: string;
+    readonly effectMarker?: string;
+    readonly resultingSha?: string;
+}
+type GitLabIdentityPin = 'sourceBranch' | 'targetBranch' | 'sourceSha' | 'targetSha' | 'mergeRequestIid';
+export declare function gitLabIdentityPinsForOperation(operation: GitLabProviderOperation): readonly GitLabIdentityPin[];
+export declare function normalizeGitLabDeliveryExpectation(expectation: GitLabDeliveryExpectation, attempt: Pick<DeliveryAttempt, 'source' | 'target'>): GitLabDeliveryExpectation;
+declare const GitLabDeliveryError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "GitLabDeliveryError";
+} & Readonly<A>;
+export declare class GitLabDeliveryError extends GitLabDeliveryError_base<{
+    readonly code: string;
+    readonly message: string;
+}> {
+    constructor(code: string, message: string);
+}
+export declare function isDeclaredGitLabHost(input: Pick<DeclaredGitLabProject, 'hostClass' | 'host'>): boolean;
+export declare function assertDeclaredGitLabProject(project: DeclaredGitLabProject): void;
+export declare function assertSafeGitLabRef(ref: string): void;
+export declare function assertGitLabDeliveryTarget(input: {
+    readonly policy: DeliveryPolicy;
+    readonly operation: DeliveryPolicyOperation;
+    readonly targetBranch: string;
+}): void;
+export declare function gitLabRequestMarker(input: {
+    readonly effectKey: string;
+    readonly policyDigest: string;
+}): string;
+export declare function classifyGitLabProviderObservation(expected: GitLabDeliveryExpectation, observed: GitLabProviderObservation | null): GitLabObservationClassification;
+export declare function assertExactGitLabSha(expected: string, observed: string, kind: 'source' | 'target'): void;
+export type GitLabProviderEvidence = {
+    readonly [key: string]: JsonValue;
+};
+export declare function safeGitLabProviderEvidence<Evidence extends GitLabProviderEvidence>(input: Evidence): Evidence;
+export {};

package/types/packages/core/src/global-search.d.ts

@@ -0,0 +1,42 @@
+import * as Schema from 'effect/Schema';
+declare const GlobalSearchKinds: readonly ['task', 'loop', 'runner'];
+export type GlobalSearchKind = (typeof GlobalSearchKinds)[number];
+export declare const GlobalSearchQuery: Schema.Struct<{
+    readonly query: Schema.optionalKey<Schema.String>;
+    readonly limit: Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.FiniteFromString]>>;
+    readonly cursor: Schema.optionalKey<Schema.String>;
+}>;
+export type GlobalSearchQuery = (typeof GlobalSearchQuery)['Type'];
+export declare const GlobalSearchItem: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.Literals<readonly ["task", "loop", "runner"]>;
+    readonly title: Schema.String;
+    readonly subtitle: Schema.String;
+    readonly to: Schema.Union<readonly [Schema.String, Schema.String, Schema.String]>;
+}>;
+export type GlobalSearchItem = (typeof GlobalSearchItem)['Type'];
+export declare const GlobalSearchPage: Schema.Struct<{
+    readonly scope: Schema.Struct<{
+        readonly workspaceId: Schema.String;
+        readonly projectId: Schema.String;
+    }>;
+    readonly query: Schema.String;
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["task", "loop", "runner"]>;
+        readonly title: Schema.String;
+        readonly subtitle: Schema.String;
+        readonly to: Schema.Union<readonly [Schema.String, Schema.String, Schema.String]>;
+    }>>;
+    readonly pageInfo: Schema.Union<readonly [Schema.Struct<{
+        readonly limit: Schema.Int;
+        readonly hasNextPage: Schema.Literal<false>;
+    }>, Schema.Struct<{
+        readonly limit: Schema.Int;
+        readonly hasNextPage: Schema.Literal<true>;
+        readonly nextCursor: Schema.String;
+    }>]>;
+    readonly completeness: Schema.Union<readonly [Schema.Literal<"complete">, Schema.Literal<"partial">]>;
+}>;
+export type GlobalSearchPage = (typeof GlobalSearchPage)['Type'];
+export {};

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

@@ -0,0 +1 @@
+export declare function createId(): string;

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

@@ -0,0 +1,74 @@
+export * from './common';
+export * from './connection';
+export * from './provider-safe-text';
+export * from './me';
+export * from './workspace';
+export * from './project';
+export * from './scope-directory';
+export * from './agent-environment';
+export * from './extension';
+export * from './sync-kit';
+export * from './agent-sandbox-policy';
+export * from './agent-launch-snapshot';
+export * from './kit';
+export * from './kit-taxonomy';
+export * from './memory';
+export * from './proposal';
+export * from './decision';
+export * from './session';
+export * from './context-pack';
+export * from './context-feedback';
+export * from './fix-flow';
+export * from './task';
+export * from './task-key';
+export * from './agent-capabilities';
+export * from './personal-development-profile';
+export * from './repo-binding';
+export * from './runner';
+export * from './runner-routing';
+export * from './runner-eligibility';
+export * from './runner-trust';
+export * from './platform-release';
+export * from './work-unit';
+export * from './external-effect';
+export * from './global-search';
+export * from './change-delivery';
+export * from './change-request';
+export * from './change-request-review';
+export * from './engineering-resources';
+export * from './delivery-policy';
+export * from './delivery-operation';
+export * from './epic-delivery';
+export * from './gitlab-delivery';
+export * from './gitlab-delivery-fixtures';
+export * from './github-delivery';
+export * from './github-delivery-fixtures';
+export * from './integration';
+export * from './enterprise-code-host';
+export * from './loop';
+export * from './run-launch';
+export * from './my-teams';
+export * from './notification';
+export * from './intent';
+export * from './loop-version';
+export * from './id';
+export * from './live';
+export * from './run';
+export * from './step-brief';
+export * from './program-credential';
+export * from './trigger-dispatch';
+export * from './schedule';
+export * from './task-detail';
+export * from './task-execution-record';
+export * from './a2a';
+export * from './audit';
+export * from './redaction';
+export * from './observability';
+export * from './following';
+export * from './approval-queue';
+export * from './data-lifecycle';
+export * from './run-journal';
+export * from './loop-layers';
+export * from './package-declarations';
+export * from './secret';
+export * from './package';