@canhta/dsh-autopilot 0.1.0-alpha.1

package/lib/client-types/notification/model.d.ts

@@ -0,0 +1,57 @@
+declare const notificationProviderIdBrand: unique symbol;
+declare const notificationDestinationIdBrand: unique symbol;
+export type NotificationProviderId = string & {
+    readonly [notificationProviderIdBrand]: true;
+};
+export type NotificationDestinationId = string & {
+    readonly [notificationDestinationIdBrand]: true;
+};
+export declare const notificationProviderId: (value: string) => NotificationProviderId;
+export declare const notificationDestinationId: (value: string) => NotificationDestinationId;
+export declare const NOTIFICATION_INTERFACE_VERSION: 1;
+export interface NotificationEvent {
+    readonly version: 1;
+    readonly eventId: string;
+    readonly runId: string;
+    readonly timestamp: string;
+    readonly type: 'started' | 'blocked' | 'paused' | 'failed' | 'completed';
+    readonly issueIdentity: string;
+    readonly displayKey: string;
+    readonly summary: string;
+    readonly actionNeeded?: string | undefined;
+    readonly runUrl: string;
+    readonly issueUrl: string;
+    readonly pullRequestUrl?: string | undefined;
+    readonly usage: {
+        readonly kind: 'provider' | 'estimate' | 'unknown';
+        readonly tokens?: number | undefined;
+    };
+}
+export interface NotificationReceipt {
+    readonly receiptId: string;
+    readonly receivedAt: string;
+}
+export interface NotificationProviderRequest {
+    readonly destinationId: NotificationDestinationId;
+    readonly event: NotificationEvent;
+    readonly signal: AbortSignal;
+}
+export interface NotificationProvider {
+    readonly id: NotificationProviderId;
+    readonly interfaceVersion: typeof NOTIFICATION_INTERFACE_VERSION;
+    readonly displayName: string;
+    readonly configurationNamespace: string;
+    reconcile(request: NotificationProviderRequest): Promise<NotificationReceipt | undefined>;
+    deliver(request: NotificationProviderRequest): Promise<NotificationReceipt>;
+}
+export interface NotificationSender {
+    reconcile(destinationId: NotificationDestinationId, event: NotificationEvent, signal?: AbortSignal): Promise<NotificationReceipt | undefined>;
+    deliver(destinationId: NotificationDestinationId, event: NotificationEvent, signal?: AbortSignal): Promise<NotificationReceipt>;
+}
+export type NotificationProviderErrorCode = 'authentication' | 'permission' | 'invalid-configuration' | 'permanent-rejection' | 'rate-limit' | 'timeout' | 'transient' | 'ambiguous-acknowledgement' | 'invalid-response' | 'provider-unavailable';
+export declare class NotificationProviderError extends Error {
+    readonly code: NotificationProviderErrorCode;
+    readonly retryAfterMs?: number | undefined;
+    constructor(code: NotificationProviderErrorCode, message: string, retryAfterMs?: number | undefined);
+}
+export {};

package/lib/client-types/notification/registry.d.ts

@@ -0,0 +1,16 @@
+import { type Context, Service } from '@deepseek-ai/cordis';
+import { type NotificationProvider, type NotificationProviderId, type NotificationSender } from './model.js';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        notifications: Notifications;
+    }
+}
+/** Registry for independently loaded notification transports; it stores no destinations, secrets, or delivery state. */
+export declare class Notifications extends Service {
+    private readonly providers;
+    constructor(ctx: Context);
+    register(provider: NotificationProvider): () => Promise<void>;
+    withProvider<T>(id: NotificationProviderId, operation: (sender: NotificationSender) => Promise<T>): Promise<T>;
+    private invoke;
+}
+export default Notifications;

package/lib/client-types/notification.d.ts

@@ -0,0 +1,2 @@
+export * from './notification/index.js';
+export { default } from './notification/index.js';

package/lib/client-types/providers/generation-registry.d.ts

@@ -0,0 +1,20 @@
+export interface ProviderGeneration<P> {
+    readonly provider: P;
+    readonly controller: AbortController;
+    readonly active: Set<Promise<unknown>>;
+    accepting: boolean;
+}
+/** Shared lifecycle core for provider registries; protocol validation and error normalization stay with each seam. */
+export declare class GenerationRegistry<K, P> {
+    private readonly onAvailable?;
+    private readonly onUnavailable?;
+    private readonly generations;
+    constructor(onAvailable?: ((key: K) => void) | undefined, onUnavailable?: ((key: K) => void) | undefined);
+    has(key: K): boolean;
+    values(): IterableIterator<ProviderGeneration<P>>;
+    register(key: K, provider: P): () => Promise<void>;
+    require(key: K, unavailable: () => Error): ProviderGeneration<P>;
+    retain<T>(generation: ProviderGeneration<P>, operation: () => Promise<T>): Promise<T>;
+    assertCurrent(generation: ProviderGeneration<P>, unavailable: () => Error): void;
+    signal(generation: ProviderGeneration<P>, callerSignal?: AbortSignal): AbortSignal;
+}

package/lib/client-types/remote.d.ts

@@ -0,0 +1,65 @@
+import type { RemoteResult, TypertRemoteContribution } from '@deepseek-ai/dsh-typert-protocol';
+import { z } from 'zod';
+import { type CleanupPreviewView, type CommandReceipt, type CommandRequest, type OperationsQuery, type OperationsSnapshot, type ProviderTestResult, type RunDetailView, type WorktreeView } from './web/contract.js';
+export interface AutopilotRemoteNamespace {
+    operations: (query: OperationsQuery, signal?: AbortSignal) => Promise<RemoteResult<OperationsSnapshot>>;
+    run: (runId: string, signal?: AbortSignal) => Promise<RemoteResult<RunDetailView | null>>;
+    worktree: (runId: string, signal?: AbortSignal) => Promise<RemoteResult<WorktreeView | null>>;
+    previewCleanup: (runId: string, signal?: AbortSignal) => Promise<RemoteResult<CleanupPreviewView | null>>;
+    command: (request: CommandRequest, signal?: AbortSignal) => Promise<RemoteResult<CommandReceipt>>;
+    commandStatus: (requestId: string, signal?: AbortSignal) => Promise<RemoteResult<CommandReceipt | null>>;
+    testProvider: (providerId: string, signal?: AbortSignal) => Promise<RemoteResult<ProviderTestResult>>;
+}
+declare module '@deepseek-ai/dsh-typert-protocol' {
+    interface TypertRemoteMap {
+        'autopilot/operations': AutopilotRemoteNamespace['operations'];
+        'autopilot/run': AutopilotRemoteNamespace['run'];
+        'autopilot/worktree': AutopilotRemoteNamespace['worktree'];
+        'autopilot/previewCleanup': AutopilotRemoteNamespace['previewCleanup'];
+        'autopilot/command': AutopilotRemoteNamespace['command'];
+        'autopilot/commandStatus': AutopilotRemoteNamespace['commandStatus'];
+        'autopilot/testProvider': AutopilotRemoteNamespace['testProvider'];
+    }
+    interface TypertRemoteNamespaceMap {
+        autopilot: AutopilotRemoteNamespace;
+    }
+}
+export declare const TYPERT_REMOTE: TypertRemoteContribution;
+export declare const TYPERT: {
+    package: string;
+    face: string;
+    schemas: never[];
+    model: {
+        services: never[];
+        events: never[];
+        objects: never[];
+    };
+    invocations: {
+        id: string;
+        service: string;
+        namespace: string;
+        method: string;
+        invocation: {
+            kind: 'direct';
+        };
+        parameters: {
+            name: string;
+            wire: string;
+            source: 'json';
+            codec: {
+                mode: 'strict';
+                typeSymbol: string;
+                schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            };
+        }[];
+        cancellation: {
+            parameter: 'signal';
+        };
+        result: {
+            mode: 'strict';
+            typeSymbol: string;
+            schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        };
+    }[];
+};
+export default TYPERT_REMOTE;

package/lib/client-types/tracker/index.d.ts

@@ -0,0 +1,2 @@
+export * from './model.js';
+export { default, Tracker } from './registry.js';

package/lib/client-types/tracker/model.d.ts

@@ -0,0 +1,222 @@
+declare const trackerProviderIdBrand: unique symbol;
+declare const trackerBindingIdBrand: unique symbol;
+declare const trackerIssueIdBrand: unique symbol;
+declare const trackerCommentIdBrand: unique symbol;
+declare const readinessGenerationBrand: unique symbol;
+/** Validated stable identity of one tracker provider implementation. */
+export type TrackerProviderId = string & {
+    readonly [trackerProviderIdBrand]: true;
+};
+/** Validated identity of the configured project or workspace binding that supplied an issue. */
+export type TrackerBindingId = string & {
+    readonly [trackerBindingIdBrand]: true;
+};
+/** Validated provider-native issue identity, independent of its display key. */
+export type TrackerIssueId = string & {
+    readonly [trackerIssueIdBrand]: true;
+};
+/** Validated provider-native comment identity. */
+export type TrackerCommentId = string & {
+    readonly [trackerCommentIdBrand]: true;
+};
+/** Validated identity of the human readiness transition authorizing one run. */
+export type ReadinessGeneration = string & {
+    readonly [readinessGenerationBrand]: true;
+};
+/** Validate and brand a provider id; throws `TypeError` for an invalid external value and has no cancellation point. */
+export declare const trackerProviderId: (value: string) => TrackerProviderId;
+/** Validate and brand a binding id; throws `TypeError` for an invalid external value and has no cancellation point. */
+export declare const trackerBindingId: (value: string) => TrackerBindingId;
+/** Validate and brand an issue id; throws `TypeError` for an invalid external value and has no cancellation point. */
+export declare const trackerIssueId: (value: string) => TrackerIssueId;
+/** Validate and brand a comment id; throws `TypeError` for an invalid external value and has no cancellation point. */
+export declare const trackerCommentId: (value: string) => TrackerCommentId;
+/**
+ * Validate and brand a readiness-generation id; throws `TypeError` for an invalid external value and has no
+ * cancellation point.
+ */
+export declare const readinessGeneration: (value: string) => ReadinessGeneration;
+/** Exact provider contract version accepted by this build. */
+export declare const TRACKER_INTERFACE_VERSION: 2;
+/** Capabilities every provider generation must implement before registration succeeds. */
+export declare const trackerCapabilities: readonly ['candidates', 'comments', 'dependencies', 'readiness', 'ingress'];
+/** Capability name declared by a compatible provider generation. */
+export type TrackerCapability = (typeof trackerCapabilities)[number];
+export declare const trackerWriteCapabilities: readonly ['reports', 'projections'];
+export type TrackerWriteCapability = (typeof trackerWriteCapabilities)[number];
+/** Immutable comment data used to select and retain the Agent Brief. */
+export interface TrackerComment {
+    id: TrackerCommentId;
+    authorId: string;
+    body: string;
+    updatedAt: string;
+}
+/** Current completion observation for an issue that blocks a candidate. */
+export interface TrackerDependency {
+    issueId: TrackerIssueId;
+    displayKey: string;
+    state: 'completed' | 'not-completed' | 'unknown';
+}
+/** Human readiness evidence, or its explicit absence, at the time of the provider read. */
+export type TrackerReadiness = {
+    kind: 'absent';
+} | {
+    kind: 'transition';
+    generation: ReadinessGeneration;
+    actorId: string;
+    actorKind: 'human' | 'automation' | 'unknown';
+    occurredAt: string;
+};
+/** Complete, bounded issue projection consumed by admission policy. */
+export interface TrackerIssueSnapshot {
+    bindingId: TrackerBindingId;
+    issueId: TrackerIssueId;
+    displayKey: string;
+    summary: string;
+    priorityRank: number;
+    isReady: boolean;
+    labels: readonly string[];
+    comments: readonly TrackerComment[];
+    dependencies: readonly TrackerDependency[];
+    readiness: TrackerReadiness;
+}
+/** One validated provider page and its opaque continuation cursor. */
+export interface TrackerCandidatePage {
+    issues: readonly TrackerIssueSnapshot[];
+    nextCursor?: string;
+}
+/** Generation- and caller-cancellable input supplied to a provider candidate read. */
+export interface TrackerReadRequest {
+    /** Aborts when either the provider generation is withdrawn or the calling operation is cancelled. */
+    signal: AbortSignal;
+    cursor?: string;
+}
+/** One raw ingress header; repeated names remain separate entries. */
+export interface TrackerIngressHeader {
+    name: string;
+    value: string;
+}
+/** Detached, bounded HTTP input passed from the Host adapter to the selected provider. */
+export interface TrackerIngressRequest {
+    /** HTTP method received by the Host ingress adapter. */
+    method: string;
+    /** Raw headers with duplicates preserved so the provider can reject ambiguous authentication input. */
+    headers: readonly TrackerIngressHeader[];
+    /** Detached, bounded request bytes. */
+    body: Uint8Array;
+}
+/** Ingress input extended with the operation's combined cancellation signal. */
+export interface TrackerProviderIngressRequest extends TrackerIngressRequest {
+    /** Aborts when either the provider generation is withdrawn or the calling operation is cancelled. */
+    signal: AbortSignal;
+}
+/** Authentication result whose id is stable across retries and qualified by provider id. */
+export interface TrackerIngressDelivery {
+    /** Provider-qualified delivery id safe to retain in durable admission state. */
+    deliveryId: string;
+}
+export interface TrackerReportDelivery {
+    readonly kind: 'report';
+    readonly deliveryId: string;
+    readonly eventId: string;
+    readonly bindingId: TrackerBindingId;
+    readonly issueId: TrackerIssueId;
+    readonly displayKey: string;
+    readonly body: string;
+}
+export type TrackerProjectionState = 'queued' | 'implementing' | 'paused' | 'blocked' | 'failed' | 'completed';
+export interface TrackerProjectionDelivery {
+    readonly kind: 'projection';
+    readonly deliveryId: string;
+    readonly eventId: string;
+    readonly bindingId: TrackerBindingId;
+    readonly issueId: TrackerIssueId;
+    readonly displayKey: string;
+    readonly readinessGeneration: ReadinessGeneration;
+    readonly runRevision: number;
+    readonly desiredState: TrackerProjectionState;
+}
+export type TrackerOutboundDelivery = TrackerReportDelivery | TrackerProjectionDelivery;
+export interface TrackerOutboundReceipt {
+    readonly receiptId: string;
+    readonly receivedAt: string;
+}
+export type TrackerDeliveryObservation = {
+    readonly kind: 'missing';
+} | {
+    readonly kind: 'delivered';
+    readonly receipt: TrackerOutboundReceipt;
+} | {
+    readonly kind: 'conflict';
+    readonly reason: string;
+};
+export interface TrackerProviderWriteRequest {
+    readonly delivery: TrackerOutboundDelivery;
+    readonly signal: AbortSignal;
+}
+/** Non-replayed availability transition for one provider generation. */
+export interface TrackerProviderLifecycleEvent {
+    kind: 'available' | 'unavailable';
+    providerId: TrackerProviderId;
+}
+/** Bounded, secret-free metadata for one currently available tracker provider generation. */
+export interface TrackerProviderRegistration {
+    readonly id: TrackerProviderId;
+    readonly displayName: string;
+    readonly configurationNamespace: string;
+    readonly capabilities: readonly (TrackerCapability | TrackerWriteCapability)[];
+}
+/** Versioned read-only tracker adapter registered as one lifecycle-owned generation. */
+export interface TrackerProvider {
+    id: TrackerProviderId;
+    interfaceVersion: typeof TRACKER_INTERFACE_VERSION;
+    displayName: string;
+    configurationNamespace: string;
+    capabilities: readonly (TrackerCapability | TrackerWriteCapability)[];
+    /**
+     * Read one provider page without external writes. The cursor, when present, must come from the preceding page.
+     * Resolve with provider data or reject with `TrackerProviderError`; reject with the signal reason when cancelled.
+     */
+    readCandidates(request: TrackerReadRequest): Promise<TrackerCandidatePage>;
+    /**
+     * Authenticate a bounded raw ingress request without retaining a receipt or making external writes. Resolve with a
+     * provider-qualified, retry-stable delivery id; reject with `TrackerProviderError` for authentication or malformed
+     * input and reject with the signal reason when cancelled.
+     */
+    verifyIngress(request: TrackerProviderIngressRequest): Promise<TrackerIngressDelivery>;
+    /** Reconcile a stable outbound identity before any retry. Required when reports/projections are declared. */
+    reconcileDelivery?(request: TrackerProviderWriteRequest): Promise<TrackerDeliveryObservation>;
+    /** Apply one report or mutable projection. Required when reports/projections are declared. */
+    deliver?(request: TrackerProviderWriteRequest): Promise<TrackerOutboundReceipt>;
+}
+/** A generation-scoped, normalized provider view valid only during its `Tracker.withProvider` callback. */
+export interface TrackerReader {
+    /**
+     * Read and validate one candidate page. A supplied caller signal is combined with provider-withdrawal cancellation;
+     * caller cancellation rejects with its original reason, while withdrawal and provider failures are normalized as
+     * `TrackerProviderError`. This operation has no durable or external-write effect.
+     */
+    readCandidates(cursor?: string, signal?: AbortSignal): Promise<TrackerCandidatePage>;
+    /**
+     * Authenticate and validate detached ingress bytes. A supplied caller signal is combined with provider-withdrawal
+     * cancellation; caller cancellation rejects with its original reason, while withdrawal and provider failures are
+     * normalized as `TrackerProviderError`. Successful verification does not retain a receipt.
+     */
+    verifyIngress(request: TrackerIngressRequest, signal?: AbortSignal): Promise<TrackerIngressDelivery>;
+}
+export interface TrackerWriter {
+    reconcileDelivery(delivery: TrackerOutboundDelivery, signal?: AbortSignal): Promise<TrackerDeliveryObservation>;
+    deliver(delivery: TrackerOutboundDelivery, signal?: AbortSignal): Promise<TrackerOutboundReceipt>;
+}
+/** Stable failure classification safe for scheduling, diagnostics, and HTTP mapping. */
+export type TrackerProviderErrorCode = 'authentication' | 'permission' | 'invalid-configuration' | 'not-found' | 'conflict' | 'rate-limit' | 'timeout' | 'transient' | 'unsupported-capability' | 'ambiguous-acknowledgement' | 'invalid-response' | 'provider-unavailable';
+/** Normalized operational failure at the tracker-provider boundary. */
+export declare class TrackerProviderError extends Error {
+    readonly code: TrackerProviderErrorCode;
+    readonly retryAfterMs?: number | undefined;
+    /** Construct a provider-safe failure; retry delay is meaningful only for retryable codes and cannot be cancelled. */
+    constructor(code: TrackerProviderErrorCode, message: string, retryAfterMs?: number | undefined);
+}
+/** Map a provider failure code to stable operator-facing text without retaining provider-authored details. */
+export declare function publicTrackerFailureMessage(code: TrackerProviderErrorCode): string;
+export {};

package/lib/client-types/tracker/registry.d.ts

@@ -0,0 +1,49 @@
+import { type Context, Service } from '@deepseek-ai/cordis';
+import { type TrackerCandidatePage, type TrackerProvider, type TrackerProviderId, type TrackerProviderLifecycleEvent, type TrackerProviderRegistration, type TrackerReader, type TrackerWriter } from './model.js';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        tracker: Tracker;
+    }
+}
+/** Provider registry and normalized read seam consumed by admission. */
+export declare class Tracker extends Service {
+    private readonly lifecycleObservers;
+    private readonly providers;
+    constructor(ctx: Context);
+    /**
+     * Register one complete provider generation and synchronously publish its availability. The provider must use the
+     * current interface version, declare every required capability, and have a unique id; violations throw without
+     * changing the registry. The returned idempotent disposer stops admission to the generation, aborts and drains its
+     * active operations, removes it, then publishes unavailability. Disposer cancellation is not supported.
+     */
+    register(provider: TrackerProvider): () => Promise<void>;
+    /**
+     * Observe future provider availability changes synchronously. Registration has no replay and no cancellation point;
+     * observer failures are logged and do not block other observers. The returned idempotent function unsubscribes.
+     */
+    watchProviders(observer: (event: TrackerProviderLifecycleEvent) => void): () => void;
+    /** Return stable, secret-free metadata for every currently accepting provider generation. */
+    providerRegistrations(): readonly TrackerProviderRegistration[];
+    /**
+     * Read one validated page through the currently registered provider generation. The optional cursor must have been
+     * returned by that provider. Provider failures and withdrawal reject with `TrackerProviderError`; caller cancellation
+     * rejects with its original reason. This operation has no durable or external-write effect.
+     */
+    readCandidates(id: TrackerProviderId, cursor?: string, signal?: AbortSignal): Promise<TrackerCandidatePage>;
+    /**
+     * Retain the selected provider generation while an operation uses its reader. The provider must be available when
+     * called. Provider withdrawal aborts its reads, waits for the callback to settle, and fences late results; consumer
+     * failures are preserved. Effects performed by the callback are caller-owned and must occur only after awaited reader
+     * operations succeed. `withProvider` itself has no independent caller-cancellation input.
+     */
+    withProvider<T>(id: TrackerProviderId, operation: (reader: TrackerReader) => Promise<T>): Promise<T>;
+    /** Retain one write-capable provider generation while a durable delivery owner reconciles and applies its intent. */
+    withWriter<T>(id: TrackerProviderId, operation: (writer: TrackerWriter) => Promise<T>): Promise<T>;
+    private readProviderCandidates;
+    private verifyProviderIngress;
+    private reconcileProviderDelivery;
+    private deliverProviderIntent;
+    private invokeWrite;
+    private notifyProviderLifecycle;
+}
+export default Tracker;

package/lib/client-types/tracker/validation.d.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+export declare const candidatePageSchema: z.ZodObject<{
+    issues: z.ZodArray<z.ZodObject<{
+        bindingId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./model.js").TrackerBindingId, string>>;
+        issueId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./model.js").TrackerIssueId, string>>;
+        displayKey: z.ZodString;
+        summary: z.ZodString;
+        priorityRank: z.ZodNumber;
+        isReady: z.ZodBoolean;
+        labels: z.ZodArray<z.ZodString>;
+        comments: z.ZodArray<z.ZodObject<{
+            id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./model.js").TrackerCommentId, string>>;
+            authorId: z.ZodString;
+            body: z.ZodString;
+            updatedAt: z.ZodISODateTime;
+        }, z.core.$strip>>;
+        dependencies: z.ZodArray<z.ZodObject<{
+            issueId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./model.js").TrackerIssueId, string>>;
+            displayKey: z.ZodString;
+            state: z.ZodEnum<{
+                completed: "completed";
+                "not-completed": "not-completed";
+                unknown: "unknown";
+            }>;
+        }, z.core.$strip>>;
+        readiness: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"absent">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"transition">;
+            generation: z.ZodPipe<z.ZodString, z.ZodTransform<import("./model.js").ReadinessGeneration, string>>;
+            actorId: z.ZodString;
+            actorKind: z.ZodEnum<{
+                automation: "automation";
+                human: "human";
+                unknown: "unknown";
+            }>;
+            occurredAt: z.ZodISODateTime;
+        }, z.core.$strip>], "kind">;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ingressDeliverySchema: z.ZodObject<{
+    deliveryId: z.ZodString;
+}, z.core.$strip>;
+export declare const outboundReceiptSchema: z.ZodObject<{
+    receiptId: z.ZodString;
+    receivedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export declare const deliveryObservationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"missing">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"delivered">;
+    receipt: z.ZodObject<{
+        receiptId: z.ZodString;
+        receivedAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"conflict">;
+    reason: z.ZodString;
+}, z.core.$strip>], "kind">;

package/lib/client-types/tracker.d.ts

@@ -0,0 +1,2 @@
+export * from './tracker/index.js';
+export { default } from './tracker/index.js';