dsh-run2skill 0.1.1-alpha → 0.2.0

package/lib/index.d.ts

@@ -475,6 +475,8 @@ declare const GlobalV1Schema: z.ZodObject<{
       resolutionContractDigest: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
       scope: z.ZodLiteral<"USER">;
+    }, z.core.$strict>, z.ZodObject<{
+      scope: z.ZodLiteral<"ALL">;
     }, z.core.$strict>], "scope">;
     hideBefore: z.ZodString;
     candidateDigest: z.ZodString;
@@ -487,6 +489,8 @@ declare const GlobalV1Schema: z.ZodObject<{
     }>;
     deletedWorkItems: z.ZodNumber;
     deletedLineages: z.ZodNumber;
+    targetWorkItems: z.ZodOptional<z.ZodNumber>;
+    targetLineages: z.ZodOptional<z.ZodNumber>;
     lastError: z.ZodOptional<z.ZodObject<{
       code: z.ZodString;
       occurredAt: z.ZodString;
@@ -494,6 +498,13 @@ declare const GlobalV1Schema: z.ZodObject<{
   }, z.core.$strict>>;
   completedPurgeFences: z.ZodOptional<z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
+    all: z.ZodOptional<z.ZodObject<{
+      schemaVersion: z.ZodLiteral<1>;
+      purgeId: z.ZodString;
+      completedAt: z.ZodString;
+      hideBefore: z.ZodString;
+      scope: z.ZodLiteral<"ALL">;
+    }, z.core.$strict>>;
     user: z.ZodOptional<z.ZodObject<{
       schemaVersion: z.ZodLiteral<1>;
       purgeId: z.ZodString;
@@ -510,11 +521,37 @@ declare const GlobalV1Schema: z.ZodObject<{
       scopeIdentityDigest: z.ZodString;
     }, z.core.$strict>>;
   }, z.core.$strict>>;
+  recentSkillActivity: z.ZodOptional<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    items: z.ZodArray<z.ZodObject<{
+      schemaVersion: z.ZodLiteral<1>;
+      activityId: z.ZodString;
+      workItemId: z.ZodString;
+      skillName: z.ZodString;
+      operation: z.ZodEnum<{
+        CREATED: "CREATED";
+        UPDATED: "UPDATED";
+      }>;
+      scope: z.ZodEnum<{
+        PROJECT: "PROJECT";
+        USER: "USER";
+      }>;
+      occurredAt: z.ZodString;
+    }, z.core.$strict>>;
+  }, z.core.$strict>>;
 }, z.core.$strict>;
 type CaptureWorkItemV1 = z.infer<typeof CaptureWorkItemV1Schema>;
 type GlobalV1 = z.infer<typeof GlobalV1Schema>;
 //#endregion
 //#region src/domain/learn/diagnostics.d.ts
+declare const LearningTerminalDetailV1Schema: z.ZodEnum<{
+  MODEL_STREAM_FAILURE: "MODEL_STREAM_FAILURE";
+  MODEL_FINISH_MISSING: "MODEL_FINISH_MISSING";
+  MODEL_USAGE_INVALID: "MODEL_USAGE_INVALID";
+  MODEL_ASSEMBLY_FAILED: "MODEL_ASSEMBLY_FAILED";
+  MODEL_UNEXPECTED_FINISH: "MODEL_UNEXPECTED_FINISH";
+}>;
+type LearningTerminalDetailV1 = z.infer<typeof LearningTerminalDetailV1Schema>;
 declare const LearningDiagnosticRecordV1Schema: z.ZodObject<{
   schemaVersion: z.ZodLiteral<1>;
   workItemId: z.ZodString;
@@ -627,6 +664,7 @@ interface DshLlmPort {
     readonly context?: {
       readonly contextWindow: number;
     };
+    readonly defaultMaxTokens?: number;
   }>;
   stream(options: DshGenerateOptions): AsyncIterable<DshStreamChunk>;
 }
@@ -647,6 +685,22 @@ interface AgentScopeProjection {
     }[] | undefined;
   };
 }
+type AgentScopeResolution<TAgent> = {
+  readonly status: 'AVAILABLE';
+  readonly agent: TAgent;
+  readonly cwd: string | undefined;
+  readonly lifecycleKey: string;
+} | {
+  readonly status: 'UNAVAILABLE';
+};
+declare class ExactAgentScopeRegistry<TAgent extends object> {
+  private readonly scopes;
+  register(agent: TAgent & AgentScopeProjection): () => void;
+  resolve(item: CaptureWorkItemV1): AgentScopeResolution<TAgent>;
+  resolveLifecycleKey(lifecycleKey: string): AgentScopeResolution<TAgent>;
+  resolveUniqueCwd(cwd: string): AgentScopeResolution<TAgent>;
+  clear(): void;
+}
 //#endregion
 //#region src/adapters/dsh-skills/skill-catalog.d.ts
 interface DshSkillRegistryPort<TView extends object> {
@@ -654,56 +708,6 @@ interface DshSkillRegistryPort<TView extends object> {
   get(name: string, view: TView): Promise<unknown>;
 }
 //#endregion
-//#region src/adapters/dsh-session/types.d.ts
-interface DshSessionHeader {
-  readonly version: number;
-  readonly id: string;
-  readonly createdAt: number;
-  readonly cwd?: string;
-  readonly parentSession?: string;
-  readonly origin?: 'subagent';
-  readonly delegationDepth?: number;
-}
-interface DshSessionEvent {
-  readonly type: string;
-  readonly seq: number;
-  readonly time: number;
-  readonly data: unknown;
-}
-interface SessionPersistenceSnapshot {
-  readonly header: DshSessionHeader;
-  readonly revision: string;
-}
-interface SessionPersistencePort {
-  listSnapshots(signal?: AbortSignal): Promise<readonly SessionPersistenceSnapshot[]>;
-  readFrom(sessionId: string, fromSeq: number, signal?: AbortSignal): Promise<{
-    readonly meta: DshSessionHeader;
-    readonly events: readonly DshSessionEvent[];
-  }>;
-}
-//#endregion
-//#region src/adapters/dsh-connection/observe-summary-rpc.d.ts
-type ObserveRpcError = {
-  readonly code: string;
-  readonly message: string;
-  readonly details: Record<string, unknown>;
-};
-type ObserveRpcResult<T> = {
-  readonly ok: true;
-  readonly value: T;
-} | {
-  readonly ok: false;
-  readonly error: ObserveRpcError;
-};
-type ObserveSummaryRpcHandler = (endpoint: string, payload: unknown, signal: AbortSignal) => Promise<ObserveRpcResult<unknown>>;
-interface ObserveSummaryHostConnection {
-  readonly rpc: {
-    handle(channel: string, handler: ObserveSummaryRpcHandler, options: {
-      readonly authority: 'loopback';
-    }): () => Promise<void>;
-  };
-}
-//#endregion
 //#region src/adapters/dsh-storage/domain.d.ts
 declare const run2skillDomainSpec: {
   readonly name: "run2skill_v1";
@@ -755,6 +759,8 @@ declare const run2skillDomainSpec: {
           resolutionContractDigest: import("zod").ZodString;
         }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
           scope: import("zod").ZodLiteral<"USER">;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+          scope: import("zod").ZodLiteral<"ALL">;
         }, import("zod/v4/core").$strict>], "scope">;
         hideBefore: import("zod").ZodString;
         candidateDigest: import("zod").ZodString;
@@ -767,6 +773,8 @@ declare const run2skillDomainSpec: {
         }>;
         deletedWorkItems: import("zod").ZodNumber;
         deletedLineages: import("zod").ZodNumber;
+        targetWorkItems: import("zod").ZodOptional<import("zod").ZodNumber>;
+        targetLineages: import("zod").ZodOptional<import("zod").ZodNumber>;
         lastError: import("zod").ZodOptional<import("zod").ZodObject<{
           code: import("zod").ZodString;
           occurredAt: import("zod").ZodString;
@@ -774,6 +782,13 @@ declare const run2skillDomainSpec: {
       }, import("zod/v4/core").$strict>>;
       completedPurgeFences: import("zod").ZodOptional<import("zod").ZodObject<{
         schemaVersion: import("zod").ZodLiteral<1>;
+        all: import("zod").ZodOptional<import("zod").ZodObject<{
+          schemaVersion: import("zod").ZodLiteral<1>;
+          purgeId: import("zod").ZodString;
+          completedAt: import("zod").ZodString;
+          hideBefore: import("zod").ZodString;
+          scope: import("zod").ZodLiteral<"ALL">;
+        }, import("zod/v4/core").$strict>>;
         user: import("zod").ZodOptional<import("zod").ZodObject<{
           schemaVersion: import("zod").ZodLiteral<1>;
           purgeId: import("zod").ZodString;
@@ -790,6 +805,24 @@ declare const run2skillDomainSpec: {
           scopeIdentityDigest: import("zod").ZodString;
         }, import("zod/v4/core").$strict>>;
       }, import("zod/v4/core").$strict>>;
+      recentSkillActivity: import("zod").ZodOptional<import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodLiteral<1>;
+        items: import("zod").ZodArray<import("zod").ZodObject<{
+          schemaVersion: import("zod").ZodLiteral<1>;
+          activityId: import("zod").ZodString;
+          workItemId: import("zod").ZodString;
+          skillName: import("zod").ZodString;
+          operation: import("zod").ZodEnum<{
+            CREATED: "CREATED";
+            UPDATED: "UPDATED";
+          }>;
+          scope: import("zod").ZodEnum<{
+            PROJECT: "PROJECT";
+            USER: "USER";
+          }>;
+          occurredAt: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>>;
+      }, import("zod/v4/core").$strict>>;
     }, import("zod/v4/core").$strict>;
     readonly initial: {
       schemaVersion: 1;
@@ -837,6 +870,8 @@ declare const run2skillDomainSpec: {
           resolutionContractDigest: string;
         } | {
           scope: "USER";
+        } | {
+          scope: "ALL";
         };
         hideBefore: string;
         candidateDigest: string;
@@ -844,6 +879,8 @@ declare const run2skillDomainSpec: {
         phase: "HIDING" | "DELETING_LINEAGES" | "DELETING_WORK_ITEMS" | "VERIFYING";
         deletedWorkItems: number;
         deletedLineages: number;
+        targetWorkItems?: number | undefined;
+        targetLineages?: number | undefined;
         lastError?: {
           code: string;
           occurredAt: string;
@@ -859,6 +896,13 @@ declare const run2skillDomainSpec: {
           scope: "PROJECT";
           scopeIdentityDigest: string;
         }>;
+        all?: {
+          schemaVersion: 1;
+          purgeId: string;
+          completedAt: string;
+          hideBefore: string;
+          scope: "ALL";
+        } | undefined;
         user?: {
           schemaVersion: 1;
           purgeId: string;
@@ -867,6 +911,18 @@ declare const run2skillDomainSpec: {
           scope: "USER";
         } | undefined;
       } | undefined;
+      recentSkillActivity?: {
+        schemaVersion: 1;
+        items: {
+          schemaVersion: 1;
+          activityId: string;
+          workItemId: string;
+          skillName: string;
+          operation: "CREATED" | "UPDATED";
+          scope: "PROJECT" | "USER";
+          occurredAt: string;
+        }[];
+      } | undefined;
     };
   };
   readonly tables: {
@@ -1334,145 +1390,3371 @@ declare const run2skillDomainSpec: {
   };
 };
 //#endregion
-//#region src/adapters/dsh-storage/learning-diagnostic-domain.d.ts
-declare const learningDiagnosticDomainSpec: {
-  readonly name: "run2skill_learning_diagnostics_v1";
-  readonly version: 1;
-  readonly tables: {
-    readonly terminal_details: {
-      readonly valueSchema: import("zod").ZodObject<{
-        schemaVersion: import("zod").ZodLiteral<1>;
-        workItemId: import("zod").ZodString;
-        workItemRevision: import("zod").ZodNumber;
-        attempt: import("zod").ZodNumber;
-        requestOrdinal: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<1>, import("zod").ZodLiteral<2>]>;
-        callKind: import("zod").ZodEnum<{
-          PRIMARY: "PRIMARY";
-          FORMAT_REPAIR: "FORMAT_REPAIR";
-        }>;
-        callOutcome: import("zod").ZodEnum<{
-          SUCCEEDED: "SUCCEEDED";
-          FAILED: "FAILED";
-          ABORTED: "ABORTED";
-          TIMED_OUT: "TIMED_OUT";
-        }>;
-        failureCode: import("zod").ZodEnum<{
-          SESSION_LOG_UNAVAILABLE: "SESSION_LOG_UNAVAILABLE";
-          AGENT_SCOPE_UNAVAILABLE: "AGENT_SCOPE_UNAVAILABLE";
-          MODEL_ROUTE_UNAVAILABLE: "MODEL_ROUTE_UNAVAILABLE";
-          MODEL_INFO_UNAVAILABLE: "MODEL_INFO_UNAVAILABLE";
-          CATALOG_INCOMPLETE: "CATALOG_INCOMPLETE";
-          CANDIDATE_UNAVAILABLE: "CANDIDATE_UNAVAILABLE";
-          ENVELOPE_UNBUILDABLE: "ENVELOPE_UNBUILDABLE";
-          MODEL_TIMEOUT: "MODEL_TIMEOUT";
-          MODEL_ABORTED: "MODEL_ABORTED";
-          MODEL_TERMINAL_FAILURE: "MODEL_TERMINAL_FAILURE";
-          MODEL_OUTPUT_LIMIT_EXCEEDED: "MODEL_OUTPUT_LIMIT_EXCEEDED";
-          INVALID_STRUCTURED_OUTPUT: "INVALID_STRUCTURED_OUTPUT";
-          LEARNING_GUARD_REJECTED: "LEARNING_GUARD_REJECTED";
-          STORE_WRITE_FAILED: "STORE_WRITE_FAILED";
-        }>;
-        failureOccurredAt: import("zod").ZodString;
-        detail: import("zod").ZodEnum<{
-          MODEL_STREAM_FAILURE: "MODEL_STREAM_FAILURE";
-          MODEL_FINISH_MISSING: "MODEL_FINISH_MISSING";
-          MODEL_USAGE_INVALID: "MODEL_USAGE_INVALID";
-          MODEL_ASSEMBLY_FAILED: "MODEL_ASSEMBLY_FAILED";
-          MODEL_UNEXPECTED_FINISH: "MODEL_UNEXPECTED_FINISH";
-        }>;
-      }, import("zod/v4/core").$strict>;
-    };
-    readonly health_checks: {
-      readonly valueSchema: import("zod").ZodObject<{
-        schemaVersion: import("zod").ZodLiteral<1>;
-        generation: import("zod").ZodNumber;
-      }, import("zod/v4/core").$strict>;
-    };
-  };
-};
-interface LearningDiagnosticDomain {
-  readonly name: 'run2skill_learning_diagnostics_v1';
-  table(name: 'terminal_details'): Run2skillTable<string, LearningDiagnosticRecordV1>;
-  table(name: 'health_checks'): Run2skillTable<string, LearningDiagnosticHealthV1>;
-  close(): Promise<void>;
-}
-//#endregion
-//#region src/domain/publication/schemas.d.ts
-declare const PublicationJournalStageV1Schema: z.ZodEnum<{
-  APPROVAL_COMMITTED: "APPROVAL_COMMITTED";
-  FACTS_REVALIDATED: "FACTS_REVALIDATED";
-  ROOT_PREPARED: "ROOT_PREPARED";
-  TARGET_INSTALLED: "TARGET_INSTALLED";
-  DISK_VERIFIED: "DISK_VERIFIED";
-  READBACK_CONFIRMED: "READBACK_CONFIRMED";
-  LINEAGE_PENDING: "LINEAGE_PENDING";
-  LINEAGE_COMMITTED: "LINEAGE_COMMITTED";
-  OUTCOME_COMMITTED: "OUTCOME_COMMITTED";
-}>;
-type PublicationJournalStageV1 = z.infer<typeof PublicationJournalStageV1Schema>;
-declare const LineageV1Schema: z.ZodObject<{
+//#region src/domain/v2/schemas.d.ts
+declare const TurnObservationV2Schema: z.ZodObject<{
   schemaVersion: z.ZodLiteral<1>;
-  scope: z.ZodEnum<{
-    PROJECT: "PROJECT";
-    USER: "USER";
-  }>;
-  provider: z.ZodString;
-  source: z.ZodEnum<{
-    "project-dsh": "project-dsh";
-    "user-dsh": "user-dsh";
+  revision: z.ZodNumber;
+  observationId: z.ZodString;
+  sessionLifecycleKey: z.ZodString;
+  turn: z.ZodNumber;
+  turnEndSeq: z.ZodNumber;
+  turnInstanceDigest: z.ZodString;
+  observedAt: z.ZodString;
+  outcomeKind: z.ZodString;
+  assistantOutcomeSummary: z.ZodString;
+  toolOutcomeSummary: z.ZodArray<z.ZodObject<{
+    toolName: z.ZodString;
+    outcome: z.ZodString;
+    contentDigest: z.ZodString;
+  }, z.core.$strict>>;
+  routeObservation: z.ZodObject<{
+    provider: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    complete: z.ZodBoolean;
+  }, z.core.$strict>;
+  completeness: z.ZodEnum<{
+    COMPLETE: "COMPLETE";
+    INCOMPLETE: "INCOMPLETE";
   }>;
-  skillName: z.ZodString;
-  canonicalTargetPath: z.ZodString;
-  targetIdentityDigest: z.ZodString;
-  currentRevision: z.ZodNumber;
-  revisions: z.ZodArray<z.ZodObject<{
-    revision: z.ZodNumber;
-    origin: z.ZodEnum<{
-      ADOPTED_BASE: "ADOPTED_BASE";
-      MANUAL_BASE: "MANUAL_BASE";
-      RUN2SKILL: "RUN2SKILL";
+  explicitSaveRequested: z.ZodBoolean;
+  scopeBinding: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"PROJECT">;
+    workspaceId: z.ZodString;
+    scopeIdentityDigest: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"USER">;
+    scopeIdentityDigest: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"UNRESOLVED">;
+    reason: z.ZodEnum<{
+      NO_CWD: "NO_CWD";
+      UNREGISTERED: "UNREGISTERED";
+      UNAVAILABLE: "UNAVAILABLE";
     }>;
-    proposalId: z.ZodOptional<z.ZodString>;
-    exactSkillBytes: z.ZodString;
-    skillBytesDigest: z.ZodString;
-    committedAt: z.ZodString;
+  }, z.core.$strict>], "status">;
+  directUserEvidence: z.ZodArray<z.ZodObject<{
+    source: z.ZodLiteral<"USER_DIRECT">;
+    messageSeq: z.ZodNumber;
+    excerpt: z.ZodString;
+    excerptDigest: z.ZodString;
+    redactionKinds: z.ZodArray<z.ZodEnum<{
+      PRIVATE_KEY: "PRIVATE_KEY";
+      AUTHORIZATION: "AUTHORIZATION";
+      BEARER_TOKEN: "BEARER_TOKEN";
+      API_KEY: "API_KEY";
+      SECRET_ASSIGNMENT: "SECRET_ASSIGNMENT";
+      URL_CREDENTIAL: "URL_CREDENTIAL";
+    }>>;
+    truncated: z.ZodBoolean;
+  }, z.core.$strict>>;
+  evidenceDigest: z.ZodString;
+  contentDigest: z.ZodString;
+  sessionRecovery: z.ZodOptional<z.ZodObject<{
+    headerRevision: z.ZodString;
+    observedLogPrefixDigest: z.ZodString;
   }, z.core.$strict>>;
-  lineageId: z.ZodString;
 }, z.core.$strict>;
-type LineageV1 = z.infer<typeof LineageV1Schema>;
-//#endregion
-//#region src/adapters/dsh-storage/types.d.ts
-interface Run2skillTable<K extends string, V> {
-  get(key: K): V | undefined;
-  entries(): IterableIterator<[K, V]>;
-  keys(): IterableIterator<K>;
-  readonly size: number;
-  put(key: K, value: V): Promise<void>;
-  delete(key: K): Promise<boolean>;
-  update(key: K, transform: (current: V) => V): Promise<V>;
-}
-interface Run2skillDomain {
-  readonly name: 'run2skill_v1';
-  readonly global: {
-    get(): GlobalV1;
-    set(value: GlobalV1): Promise<void>;
-  };
-  table(name: 'work_items'): Run2skillTable<string, CaptureWorkItemV1>;
-  table(name: 'lineages'): Run2skillTable<string, LineageV1>;
-  close(): Promise<void>;
-}
-interface Run2skillStorageContext {
-  readonly storageDomain: {
-    open(spec: typeof run2skillDomainSpec | typeof learningDiagnosticDomainSpec): Promise<Run2skillDomain | LearningDiagnosticDomain>;
-  };
-}
-//#endregion
-//#region src/domain/purge/schemas.d.ts
-declare const PurgeJournalV1Schema: z.ZodObject<{
+declare const SessionBatchV2Schema: z.ZodObject<{
   schemaVersion: z.ZodLiteral<1>;
-  purgeId: z.ZodString;
-  scopeBinding: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    scope: z.ZodLiteral<"PROJECT">;
+  revision: z.ZodNumber;
+  batchId: z.ZodString;
+  sessionLifecycleKey: z.ZodString;
+  firstTurnEndSeq: z.ZodNumber;
+  lastTurnEndSeq: z.ZodNumber;
+  detectorPolicyVersion: z.ZodString;
+  triggerReasons: z.ZodArray<z.ZodEnum<{
+    EXPLICIT: "EXPLICIT";
+    THRESHOLD: "THRESHOLD";
+    IDLE: "IDLE";
+  }>>;
+  observationManifest: z.ZodArray<z.ZodObject<{
+    observationId: z.ZodString;
+    turnEndSeq: z.ZodNumber;
+    evidenceDigest: z.ZodString;
+    completeness: z.ZodEnum<{
+      COMPLETE: "COMPLETE";
+      INCOMPLETE: "INCOMPLETE";
+    }>;
+  }, z.core.$strict>>;
+  observationManifestDigest: z.ZodString;
+  batchManifestBaseline: z.ZodObject<{
+    observedAt: z.ZodString;
+    rootManifestDigest: z.ZodString;
+    runtimeCatalogDigest: z.ZodString;
+    complete: z.ZodBoolean;
+    ownershipCandidates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      candidateId: z.ZodString;
+      name: z.ZodString;
+      provider: z.ZodString;
+      source: z.ZodString;
+      scope: z.ZodEnum<{
+        PROJECT: "PROJECT";
+        USER: "USER";
+      }>;
+      writable: z.ZodBoolean;
+      targetPathDigest: z.ZodOptional<z.ZodString>;
+      bodyDigest: z.ZodString;
+    }, z.core.$strict>>>;
+  }, z.core.$strict>;
+  manifestEndObservation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    state: z.ZodLiteral<"PENDING">;
+  }, z.core.$strict>, z.ZodObject<{
+    state: z.ZodLiteral<"OBSERVED">;
+    observedAt: z.ZodString;
+    rootManifestDigest: z.ZodString;
+    runtimeCatalogDigest: z.ZodString;
+    complete: z.ZodBoolean;
+  }, z.core.$strict>], "state">;
+  routeSnapshot: z.ZodObject<{
+    provider: z.ZodString;
+    model: z.ZodString;
+    policyVersion: z.ZodString;
+    maxInputBytes: z.ZodNumber;
+    maxOutputBytes: z.ZodNumber;
+    failureCode: z.ZodOptional<z.ZodLiteral<"ROUTE_UNAVAILABLE">>;
+  }, z.core.$strict>;
+  detector: z.ZodObject<{
+    result: z.ZodEnum<{
+      NEEDS_ATTENTION: "NEEDS_ATTENTION";
+      READY: "READY";
+      NOT_RUN: "NOT_RUN";
+      NONE: "NONE";
+      DEFER: "DEFER";
+    }>;
+    failureCode: z.ZodOptional<z.ZodString>;
+    calls: z.ZodArray<z.ZodObject<{
+      stage: z.ZodLiteral<"DETECTION">;
+      callId: z.ZodString;
+      ordinal: z.ZodNumber;
+      inputDigest: z.ZodString;
+      provider: z.ZodString;
+      model: z.ZodString;
+      policyVersion: z.ZodString;
+      outcome: z.ZodEnum<{
+        SUCCEEDED: "SUCCEEDED";
+        FAILED: "FAILED";
+        ABORTED: "ABORTED";
+        TIMED_OUT: "TIMED_OUT";
+        RESERVED: "RESERVED";
+        OUTCOME_UNKNOWN: "OUTCOME_UNKNOWN";
+      }>;
+      outputDigest: z.ZodOptional<z.ZodString>;
+      failureCode: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    carryDigest: z.ZodOptional<z.ZodString>;
+    carry: z.ZodArray<z.ZodObject<{
+      summary: z.ZodString;
+      behaviorSignatureDraft: z.ZodString;
+      evidenceDigests: z.ZodArray<z.ZodString>;
+      remainingBatches: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    }, z.core.$strict>>;
+    intentIds: z.ZodArray<z.ZodString>;
+  }, z.core.$strict>;
+  state: z.ZodEnum<{
+    NEEDS_ATTENTION: "NEEDS_ATTENTION";
+    FROZEN: "FROZEN";
+    DETECTION_CLAIMED: "DETECTION_CLAIMED";
+    COMMITTED_NONE: "COMMITTED_NONE";
+    COMMITTED_DEFER: "COMMITTED_DEFER";
+    COMMITTED_READY: "COMMITTED_READY";
+  }>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strict>;
+declare const ExperienceIntentV2Schema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  revision: z.ZodNumber;
+  intentId: z.ZodString;
+  batchId: z.ZodString;
+  ordinal: z.ZodNumber;
+  sessionLifecycleKey: z.ZodString;
+  detectorPolicyVersion: z.ZodString;
+  persistenceScope: z.ZodEnum<{
+    PROJECT: "PROJECT";
+    USER: "USER";
+  }>;
+  explicitSave: z.ZodBoolean;
+  experienceType: z.ZodEnum<{
+    CORRECTION: "CORRECTION";
+    CONSTRAINT: "CONSTRAINT";
+    WORKFLOW: "WORKFLOW";
+  }>;
+  applicabilitySummary: z.ZodString;
+  keySteps: z.ZodArray<z.ZodString>;
+  prohibitions: z.ZodArray<z.ZodString>;
+  behaviorSignature: z.ZodString;
+  evidenceRefs: z.ZodArray<z.ZodObject<{
+    observationId: z.ZodString;
+    sessionLifecycleKey: z.ZodString;
+    turnEndSeq: z.ZodNumber;
+    evidenceDigest: z.ZodString;
+  }, z.core.$strict>>;
+  evidenceDigests: z.ZodArray<z.ZodString>;
+  completeness: z.ZodObject<{
+    status: z.ZodEnum<{
+      COMPLETE: "COMPLETE";
+      INCOMPLETE: "INCOMPLETE";
+    }>;
+    blockers: z.ZodArray<z.ZodString>;
+  }, z.core.$strict>;
+  quiescence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    state: z.ZodLiteral<"WAITING">;
+    batchLastTurnEndSeq: z.ZodNumber;
+    requiredIdleMs: z.ZodNumber;
+  }, z.core.$strict>, z.ZodObject<{
+    state: z.ZodLiteral<"SATISFIED">;
+    batchLastTurnEndSeq: z.ZodNumber;
+    requiredIdleMs: z.ZodNumber;
+    observedThroughTurnEndSeq: z.ZodNumber;
+    detectedThroughTurnEndSeq: z.ZodNumber;
+    activityRevision: z.ZodString;
+    satisfiedAt: z.ZodString;
+    fenceDigest: z.ZodString;
+  }, z.core.$strict>], "state">;
+  ownership: z.ZodObject<{
+    state: z.ZodEnum<{
+      NOT_STARTED: "NOT_STARTED";
+      ARBITRATING: "ARBITRATING";
+      RESOLVED_BY_AGENT: "RESOLVED_BY_AGENT";
+      NEEDS_CONFIRMATION: "NEEDS_CONFIRMATION";
+      RUN2SKILL_OWNED: "RUN2SKILL_OWNED";
+    }>;
+    claimId: z.ZodOptional<z.ZodString>;
+    claimedIntentRevision: z.ZodOptional<z.ZodNumber>;
+    claimedAt: z.ZodOptional<z.ZodString>;
+    inputDigest: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      status: z.ZodLiteral<"UNAVAILABLE">;
+      reasonCode: z.ZodEnum<{
+        INTENT_INCOMPLETE: "INTENT_INCOMPLETE";
+        BASELINE_INCOMPLETE: "BASELINE_INCOMPLETE";
+        CLAIM_INPUT_UNAVAILABLE: "CLAIM_INPUT_UNAVAILABLE";
+        BASELINE_TIME_INVALID: "BASELINE_TIME_INVALID";
+        OBSERVATION_FAILED: "OBSERVATION_FAILED";
+        OBSERVATION_INVALID: "OBSERVATION_INVALID";
+        OBSERVATION_OUTCOME_UNKNOWN: "OBSERVATION_OUTCOME_UNKNOWN";
+      }>;
+    }, z.core.$strict>, z.ZodObject<{
+      status: z.ZodLiteral<"OBSERVED">;
+      inputDigest: z.ZodString;
+      observedAfterTurnEndSeq: z.ZodNumber;
+      observedAt: z.ZodString;
+      endManifest: z.ZodObject<{
+        rootManifestDigest: z.ZodString;
+        runtimeCatalogDigest: z.ZodString;
+        complete: z.ZodBoolean;
+      }, z.core.$strict>;
+      catalogComplete: z.ZodBoolean;
+      toolEvidenceComplete: z.ZodBoolean;
+      agentActivity: z.ZodEnum<{
+        NONE: "NONE";
+        WRITE_SUCCEEDED: "WRITE_SUCCEEDED";
+        WRITE_FAILED: "WRITE_FAILED";
+        BODY_GENERATED: "BODY_GENERATED";
+        AMBIGUOUS: "AMBIGUOUS";
+      }>;
+      changedCandidates: z.ZodArray<z.ZodObject<{
+        candidateId: z.ZodString;
+        provider: z.ZodString;
+        source: z.ZodString;
+        scope: z.ZodEnum<{
+          PROJECT: "PROJECT";
+          USER: "USER";
+        }>;
+        writable: z.ZodBoolean;
+        exactReadbackComplete: z.ZodBoolean;
+        bodyDigest: z.ZodOptional<z.ZodString>;
+        writeAttribution: z.ZodEnum<{
+          UNKNOWN: "UNKNOWN";
+          AGENT_WRITE_SUCCEEDED: "AGENT_WRITE_SUCCEEDED";
+          NOT_AGENT: "NOT_AGENT";
+        }>;
+        intentBinding: z.ZodEnum<{
+          UNKNOWN: "UNKNOWN";
+          MATCH: "MATCH";
+          NO_MATCH: "NO_MATCH";
+        }>;
+      }, z.core.$strict>>;
+    }, z.core.$strict>], "status">>;
+    evidenceDigest: z.ZodOptional<z.ZodString>;
+    receiptDigest: z.ZodOptional<z.ZodString>;
+    reasonCode: z.ZodOptional<z.ZodString>;
+    resolvedCandidateId: z.ZodOptional<z.ZodString>;
+    resolvedCandidateBodyDigest: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>;
+  recall: z.ZodObject<{
+    state: z.ZodEnum<{
+      COMPLETE: "COMPLETE";
+      INCOMPLETE: "INCOMPLETE";
+      NOT_STARTED: "NOT_STARTED";
+      SCANNING: "SCANNING";
+    }>;
+    runtimeCatalogDigest: z.ZodOptional<z.ZodString>;
+    pendingCatalogDigest: z.ZodOptional<z.ZodString>;
+    complete: z.ZodBoolean;
+    summaryScanComplete: z.ZodBoolean;
+    catalogEpoch: z.ZodOptional<z.ZodNumber>;
+    catalogMutationReceiptDigest: z.ZodOptional<z.ZodString>;
+    scanBasisRevision: z.ZodOptional<z.ZodNumber>;
+    scanRouteProvider: z.ZodOptional<z.ZodString>;
+    scanRouteModel: z.ZodOptional<z.ZodString>;
+    scanPolicyVersion: z.ZodOptional<z.ZodString>;
+    scanBindingDigest: z.ZodOptional<z.ZodString>;
+    scanPlanDigest: z.ZodOptional<z.ZodString>;
+    scanPageCount: z.ZodOptional<z.ZodNumber>;
+    scanSummaryCount: z.ZodOptional<z.ZodNumber>;
+    scanPages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      ordinal: z.ZodNumber;
+      itemCount: z.ZodNumber;
+      inputDigest: z.ZodString;
+      membershipDigest: z.ZodString;
+    }, z.core.$strict>>>;
+    summaryClassifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      candidateId: z.ZodString;
+      summaryDigest: z.ZodString;
+      classification: z.ZodEnum<{
+        RELEVANT: "RELEVANT";
+        POSSIBLE: "POSSIBLE";
+        UNRELATED: "UNRELATED";
+      }>;
+      pageOrdinal: z.ZodNumber;
+      callId: z.ZodString;
+      inputDigest: z.ZodString;
+      outputDigest: z.ZodString;
+    }, z.core.$strict>>>;
+    incompleteReason: z.ZodOptional<z.ZodString>;
+    selfExclusion: z.ZodOptional<z.ZodObject<{
+      intentId: z.ZodString;
+      priorGenerationRevision: z.ZodNumber;
+      barrierReceiptDigest: z.ZodString;
+      selfExclusionDigest: z.ZodString;
+    }, z.core.$strict>>;
+    candidates: z.ZodArray<z.ZodObject<{
+      candidateId: z.ZodString;
+      summary: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        whenToUse: z.ZodOptional<z.ZodString>;
+        provider: z.ZodString;
+        source: z.ZodString;
+        scope: z.ZodEnum<{
+          PROJECT: "PROJECT";
+          USER: "USER";
+        }>;
+        writable: z.ZodBoolean;
+      }, z.core.$strict>;
+      classification: z.ZodEnum<{
+        RELEVANT: "RELEVANT";
+        POSSIBLE: "POSSIBLE";
+        UNRELATED: "UNRELATED";
+      }>;
+      capability: z.ZodEnum<{
+        UNAVAILABLE: "UNAVAILABLE";
+        AVAILABLE: "AVAILABLE";
+        READABLE_NOT_MERGEABLE: "READABLE_NOT_MERGEABLE";
+      }>;
+      bodyDigest: z.ZodOptional<z.ZodString>;
+      unavailableReason: z.ZodOptional<z.ZodEnum<{
+        CATALOG_INCOMPLETE: "CATALOG_INCOMPLETE";
+        CANDIDATE_DISAPPEARED: "CANDIDATE_DISAPPEARED";
+        IDENTITY_CHANGED: "IDENTITY_CHANGED";
+        READ_FAILED: "READ_FAILED";
+        FILTERED_UNSAFE: "FILTERED_UNSAFE";
+        INPUT_BUDGET_EXCEEDED: "INPUT_BUDGET_EXCEEDED";
+        READ_TIMEOUT: "READ_TIMEOUT";
+        SNAPSHOT_TIMEOUT: "SNAPSHOT_TIMEOUT";
+      }>>;
+    }, z.core.$strict>>;
+  }, z.core.$strict>;
+  coverage: z.ZodObject<{
+    state: z.ZodEnum<{
+      ANALYZING: "ANALYZING";
+      NEEDS_ATTENTION: "NEEDS_ATTENTION";
+      CREATE: "CREATE";
+      MERGE: "MERGE";
+      NOT_STARTED: "NOT_STARTED";
+      COVERED: "COVERED";
+    }>;
+    retryUsed: z.ZodBoolean;
+    inputDigest: z.ZodOptional<z.ZodString>;
+    targetDigest: z.ZodOptional<z.ZodString>;
+    targetCandidateId: z.ZodOptional<z.ZodString>;
+    basisRevision: z.ZodOptional<z.ZodNumber>;
+    routeProvider: z.ZodOptional<z.ZodString>;
+    routeModel: z.ZodOptional<z.ZodString>;
+    routeMaxInputBytes: z.ZodOptional<z.ZodNumber>;
+    routeMaxOutputBytes: z.ZodOptional<z.ZodNumber>;
+    reserveBytes: z.ZodOptional<z.ZodNumber>;
+    mergeOutputReserveBytes: z.ZodOptional<z.ZodNumber>;
+    policyVersion: z.ZodOptional<z.ZodString>;
+    bindingDigest: z.ZodOptional<z.ZodString>;
+    planDigest: z.ZodOptional<z.ZodString>;
+    pages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      ordinal: z.ZodNumber;
+      itemCount: z.ZodNumber;
+      inputDigest: z.ZodString;
+      membershipDigest: z.ZodString;
+    }, z.core.$strict>>>;
+    candidateBindings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      ordinal: z.ZodNumber;
+      candidateId: z.ZodString;
+      bodyDigest: z.ZodString;
+      bodyBytes: z.ZodNumber;
+      pageOrdinal: z.ZodNumber;
+    }, z.core.$strict>>>;
+    decisions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      candidateId: z.ZodString;
+      decision: z.ZodEnum<{
+        AMBIGUOUS: "AMBIGUOUS";
+        UNRELATED: "UNRELATED";
+        COVERED: "COVERED";
+        PARTIAL: "PARTIAL";
+      }>;
+      reason: z.ZodString;
+      pageOrdinal: z.ZodNumber;
+      callId: z.ZodString;
+      inputDigest: z.ZodString;
+      outputDigest: z.ZodString;
+    }, z.core.$strict>>>;
+    reasonCode: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>;
+  generation: z.ZodObject<{
+    state: z.ZodEnum<{
+      NEEDS_ATTENTION: "NEEDS_ATTENTION";
+      NOT_STARTED: "NOT_STARTED";
+      RESULT_COMMITTED: "RESULT_COMMITTED";
+      PROPOSAL_COMMIT_AUTHORIZED: "PROPOSAL_COMMIT_AUTHORIZED";
+      GENERATION_AUTHORIZED: "GENERATION_AUTHORIZED";
+      GENERATION_LEASED: "GENERATION_LEASED";
+      GENERATION_CALL_RESERVED: "GENERATION_CALL_RESERVED";
+      GENERATION_CALL_TERMINAL: "GENERATION_CALL_TERMINAL";
+      PROPOSAL_BODY_COMMITTED: "PROPOSAL_BODY_COMMITTED";
+      PROPOSAL_READY: "PROPOSAL_READY";
+    }>;
+    action: z.ZodOptional<z.ZodEnum<{
+      CREATE: "CREATE";
+      MERGE: "MERGE";
+    }>>;
+    inputDigest: z.ZodOptional<z.ZodString>;
+    resultDigest: z.ZodOptional<z.ZodString>;
+    leaseId: z.ZodOptional<z.ZodString>;
+    generationRevision: z.ZodOptional<z.ZodNumber>;
+    catalogEpoch: z.ZodOptional<z.ZodNumber>;
+    externalPendingDigest: z.ZodOptional<z.ZodString>;
+    selfExclusionDigest: z.ZodOptional<z.ZodString>;
+    sealedResult: z.ZodOptional<z.ZodObject<{
+      resultId: z.ZodString;
+      leaseId: z.ZodString;
+      intentId: z.ZodString;
+      generationRevision: z.ZodNumber;
+      callId: z.ZodString;
+      action: z.ZodEnum<{
+        CREATE: "CREATE";
+        MERGE: "MERGE";
+      }>;
+      body: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        whenToUse: z.ZodString;
+        exactSkillBytes: z.ZodString;
+        skillBytesDigest: z.ZodString;
+      }, z.core.$strict>;
+      targetDigest: z.ZodString;
+      baseSkillBytesDigest: z.ZodOptional<z.ZodString>;
+      inputDigest: z.ZodString;
+      runtimeCatalogDigest: z.ZodString;
+      pendingCatalogDigest: z.ZodString;
+      externalPendingDigest: z.ZodString;
+      inputCatalogEpoch: z.ZodNumber;
+      outcomeCatalogEpoch: z.ZodNumber;
+      sealedAt: z.ZodString;
+      mutationReceiptDigest: z.ZodString;
+      receiptDigest: z.ZodString;
+    }, z.core.$strict>>;
+    proposalId: z.ZodOptional<z.ZodString>;
+    reasonCode: z.ZodOptional<z.ZodEnum<{
+      GENERATION_KNOWN_FAILED: "GENERATION_KNOWN_FAILED";
+      GENERATION_RESULT_LOST: "GENERATION_RESULT_LOST";
+      GENERATION_OUTCOME_UNKNOWN: "GENERATION_OUTCOME_UNKNOWN";
+      STALE_RESULT: "STALE_RESULT";
+    }>>;
+    revalidationAuthorization: z.ZodOptional<z.ZodObject<{
+      runtimeCatalogDigest: z.ZodString;
+      pendingCatalogDigest: z.ZodString;
+      externalPendingDigest: z.ZodString;
+      catalogEpoch: z.ZodNumber;
+      catalogMutationReceiptDigest: z.ZodString;
+      sealedResultReceiptDigest: z.ZodString;
+      selfExclusionDigest: z.ZodOptional<z.ZodString>;
+      authorizedAt: z.ZodString;
+    }, z.core.$strict>>;
+    userRetryUsed: z.ZodBoolean;
+    staleRefreshUsed: z.ZodBoolean;
+    receipts: z.ZodArray<z.ZodObject<{
+      kind: z.ZodEnum<{
+        CALL_RESERVED: "CALL_RESERVED";
+        LEASE_ACQUIRED: "LEASE_ACQUIRED";
+        CALL_TERMINAL: "CALL_TERMINAL";
+        RESULT_SEALED: "RESULT_SEALED";
+        BARRIER_COMMITTED: "BARRIER_COMMITTED";
+        PROPOSAL_AUTHORIZED: "PROPOSAL_AUTHORIZED";
+        BODY_COMMITTED: "BODY_COMMITTED";
+        INDEX_COMMITTED: "INDEX_COMMITTED";
+      }>;
+      digest: z.ZodString;
+      leaseId: z.ZodString;
+      intentId: z.ZodString;
+      generationRevision: z.ZodNumber;
+      callId: z.ZodOptional<z.ZodString>;
+      catalogEpoch: z.ZodOptional<z.ZodNumber>;
+      recordedAt: z.ZodString;
+    }, z.core.$strict>>;
+  }, z.core.$strict>;
+  duplicateBarrier: z.ZodOptional<z.ZodObject<{
+    barrierId: z.ZodString;
+    leaseId: z.ZodString;
+    intentId: z.ZodString;
+    generationRevision: z.ZodNumber;
+    kind: z.ZodEnum<{
+      KNOWN_FAILED: "KNOWN_FAILED";
+      OUTCOME_UNKNOWN: "OUTCOME_UNKNOWN";
+      STALE_RESULT: "STALE_RESULT";
+      RESULT_LOST: "RESULT_LOST";
+    }>;
+    behaviorSignature: z.ZodString;
+    inputDigest: z.ZodString;
+    callId: z.ZodOptional<z.ZodString>;
+    priorGenerationRevision: z.ZodOptional<z.ZodNumber>;
+    inputCatalogEpoch: z.ZodNumber;
+    outcomeCatalogEpoch: z.ZodNumber;
+    mutationReceiptDigest: z.ZodString;
+    recordedAt: z.ZodString;
+    receiptDigest: z.ZodString;
+  }, z.core.$strict>>;
+  stageCalls: z.ZodArray<z.ZodObject<{
+    stage: z.ZodEnum<{
+      CATALOG_SCAN: "CATALOG_SCAN";
+      COVERAGE: "COVERAGE";
+      GENERATION: "GENERATION";
+    }>;
+    intentRevision: z.ZodNumber;
+    callId: z.ZodString;
+    ordinal: z.ZodNumber;
+    itemCount: z.ZodOptional<z.ZodNumber>;
+    inputDigest: z.ZodString;
+    provider: z.ZodString;
+    model: z.ZodString;
+    policyVersion: z.ZodString;
+    outcome: z.ZodEnum<{
+      SUCCEEDED: "SUCCEEDED";
+      FAILED: "FAILED";
+      ABORTED: "ABORTED";
+      TIMED_OUT: "TIMED_OUT";
+      RESERVED: "RESERVED";
+      OUTCOME_UNKNOWN: "OUTCOME_UNKNOWN";
+    }>;
+    outputDigest: z.ZodOptional<z.ZodString>;
+    failureCode: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  reasonReceipts: z.ZodArray<z.ZodObject<{
+    revision: z.ZodNumber;
+    reasonCode: z.ZodString;
+    recordedAt: z.ZodString;
+  }, z.core.$strict>>;
+  lineageId: z.ZodOptional<z.ZodString>;
+  status: z.ZodEnum<{
+    NEEDS_ATTENTION: "NEEDS_ATTENTION";
+    DISCARDED: "DISCARDED";
+    READY: "READY";
+    RESOLVED_BY_AGENT: "RESOLVED_BY_AGENT";
+    NEEDS_CONFIRMATION: "NEEDS_CONFIRMATION";
+    RUN2SKILL_OWNED: "RUN2SKILL_OWNED";
+    COVERED: "COVERED";
+    PROPOSAL_READY: "PROPOSAL_READY";
+    DETECTOR_STAGED: "DETECTOR_STAGED";
+    WAITING_FOR_QUIESCENCE: "WAITING_FOR_QUIESCENCE";
+    OWNERSHIP_ARBITRATING: "OWNERSHIP_ARBITRATING";
+    RECALLING: "RECALLING";
+    COVERAGE_READY: "COVERAGE_READY";
+    COVERAGE_ANALYZING: "COVERAGE_ANALYZING";
+    COVERED_NEEDS_CONFIRMATION: "COVERED_NEEDS_CONFIRMATION";
+    COVERAGE_RETRY_AUTHORIZED: "COVERAGE_RETRY_AUTHORIZED";
+    CREATE_AUTHORIZED: "CREATE_AUTHORIZED";
+    MERGE_AUTHORIZED: "MERGE_AUTHORIZED";
+    GENERATING: "GENERATING";
+  }>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strict>;
+declare const LegacyItemV2Schema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  legacyItemId: z.ZodString;
+  sourceWorkItemId: z.ZodString;
+  sourceDigest: z.ZodString;
+  disposition: z.ZodEnum<{
+    AUDIT_ONLY_NO_SIGNAL: "AUDIT_ONLY_NO_SIGNAL";
+    LEGACY_NEEDS_ATTENTION: "LEGACY_NEEDS_ATTENTION";
+    LEGACY_CALL_OUTCOME_UNKNOWN: "LEGACY_CALL_OUTCOME_UNKNOWN";
+    ACTIVE_LEGACY_PROPOSAL: "ACTIVE_LEGACY_PROPOSAL";
+    ACTIVE_LEGACY_PUBLICATION: "ACTIVE_LEGACY_PUBLICATION";
+    AUDIT_ONLY_DISCARDED: "AUDIT_ONLY_DISCARDED";
+    AUDIT_ONLY_PUBLISHED: "AUDIT_ONLY_PUBLISHED";
+  }>;
+  importedAt: z.ZodString;
+  sourceWorkItem: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    revision: z.ZodNumber;
+    workItemId: z.ZodString;
+    signalKey: z.ZodObject<{
+      rootSessionId: z.ZodString;
+      sessionCreatedAt: z.ZodNumber;
+      sessionCwdDigest: z.ZodString;
+      turn: z.ZodNumber;
+      turnEndSeq: z.ZodNumber;
+      turnInstanceDigest: z.ZodString;
+      triggerPolicyVersion: z.ZodLiteral<"cheap-trigger-v1">;
+    }, z.core.$strict>;
+    captureReason: z.ZodEnum<{
+      CHEAP_TRIGGER: "CHEAP_TRIGGER";
+      SCAN_INCOMPLETE: "SCAN_INCOMPLETE";
+    }>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    turnOutcomeKind: z.ZodString;
+    rootIdentity: z.ZodObject<{
+      status: z.ZodLiteral<"ROOT">;
+      parentSessionId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    workspaceBinding: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      status: z.ZodLiteral<"BOUND">;
+      workspaceId: z.ZodString;
+      canonicalPath: z.ZodString;
+      observedAt: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+      status: z.ZodEnum<{
+        NO_CWD: "NO_CWD";
+        UNREGISTERED: "UNREGISTERED";
+        UNAVAILABLE: "UNAVAILABLE";
+      }>;
+      observedAt: z.ZodString;
+    }, z.core.$strict>], "status">;
+    scanStatus: z.ZodEnum<{
+      COMPLETE: "COMPLETE";
+      INCOMPLETE: "INCOMPLETE";
+    }>;
+    triggerHits: z.ZodArray<z.ZodObject<{
+      kind: z.ZodEnum<{
+        EXPLICIT_SAVE: "EXPLICIT_SAVE";
+        CORRECTION: "CORRECTION";
+        CONSTRAINT: "CONSTRAINT";
+        WORKFLOW: "WORKFLOW";
+      }>;
+      messageSeq: z.ZodNumber;
+      ruleId: z.ZodString;
+      confidence: z.ZodLiteral<"HIGH">;
+    }, z.core.$strict>>;
+    evidenceRefs: z.ZodArray<z.ZodObject<{
+      source: z.ZodLiteral<"USER_DIRECT">;
+      messageSeq: z.ZodNumber;
+      excerpt: z.ZodString;
+      excerptDigest: z.ZodString;
+      redactionKinds: z.ZodArray<z.ZodEnum<{
+        PRIVATE_KEY: "PRIVATE_KEY";
+        AUTHORIZATION: "AUTHORIZATION";
+        BEARER_TOKEN: "BEARER_TOKEN";
+        API_KEY: "API_KEY";
+        SECRET_ASSIGNMENT: "SECRET_ASSIGNMENT";
+        URL_CREDENTIAL: "URL_CREDENTIAL";
+      }>>;
+      truncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+    captureBlockers: z.ZodArray<z.ZodEnum<{
+      TURN_BOUNDARY_INCOMPLETE: "TURN_BOUNDARY_INCOMPLETE";
+      TEXT_LIMIT_EXCEEDED: "TEXT_LIMIT_EXCEEDED";
+      REDACTION_UNAVAILABLE: "REDACTION_UNAVAILABLE";
+    }>>;
+    processingState: z.ZodEnum<{
+      CAPTURED: "CAPTURED";
+      ANALYZING: "ANALYZING";
+      LEARNED: "LEARNED";
+      READY_FOR_REVIEW: "READY_FOR_REVIEW";
+      PUBLISHING: "PUBLISHING";
+      TERMINAL: "TERMINAL";
+      NEEDS_ATTENTION: "NEEDS_ATTENTION";
+      RESOLVED_NO_SIGNAL: "RESOLVED_NO_SIGNAL";
+    }>;
+    learning: z.ZodOptional<z.ZodObject<{
+      policyVersion: z.ZodLiteral<"learning-v1">;
+      attempt: z.ZodNumber;
+      requestBudgetUsed: z.ZodNumber;
+      claimedAt: z.ZodOptional<z.ZodString>;
+      nextEligibleAt: z.ZodOptional<z.ZodString>;
+      modelRoute: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+      }, z.core.$strict>>;
+      calls: z.ZodArray<z.ZodObject<{
+        requestOrdinal: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+        kind: z.ZodEnum<{
+          PRIMARY: "PRIMARY";
+          FORMAT_REPAIR: "FORMAT_REPAIR";
+        }>;
+        inputTokens: z.ZodOptional<z.ZodNumber>;
+        outputTokens: z.ZodOptional<z.ZodNumber>;
+        outcome: z.ZodEnum<{
+          SUCCEEDED: "SUCCEEDED";
+          FAILED: "FAILED";
+          ABORTED: "ABORTED";
+          TIMED_OUT: "TIMED_OUT";
+        }>;
+      }, z.core.$strict>>;
+      failure: z.ZodOptional<z.ZodObject<{
+        code: z.ZodEnum<{
+          SESSION_LOG_UNAVAILABLE: "SESSION_LOG_UNAVAILABLE";
+          AGENT_SCOPE_UNAVAILABLE: "AGENT_SCOPE_UNAVAILABLE";
+          MODEL_ROUTE_UNAVAILABLE: "MODEL_ROUTE_UNAVAILABLE";
+          MODEL_INFO_UNAVAILABLE: "MODEL_INFO_UNAVAILABLE";
+          CATALOG_INCOMPLETE: "CATALOG_INCOMPLETE";
+          CANDIDATE_UNAVAILABLE: "CANDIDATE_UNAVAILABLE";
+          ENVELOPE_UNBUILDABLE: "ENVELOPE_UNBUILDABLE";
+          MODEL_TIMEOUT: "MODEL_TIMEOUT";
+          MODEL_ABORTED: "MODEL_ABORTED";
+          MODEL_TERMINAL_FAILURE: "MODEL_TERMINAL_FAILURE";
+          MODEL_OUTPUT_LIMIT_EXCEEDED: "MODEL_OUTPUT_LIMIT_EXCEEDED";
+          INVALID_STRUCTURED_OUTPUT: "INVALID_STRUCTURED_OUTPUT";
+          LEARNING_GUARD_REJECTED: "LEARNING_GUARD_REJECTED";
+          STORE_WRITE_FAILED: "STORE_WRITE_FAILED";
+        }>;
+        retryable: z.ZodBoolean;
+        occurredAt: z.ZodString;
+      }, z.core.$strict>>;
+      experiences: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        experienceId: z.ZodString;
+        type: z.ZodEnum<{
+          CORRECTION: "CORRECTION";
+          CONSTRAINT: "CONSTRAINT";
+          WORKFLOW: "WORKFLOW";
+        }>;
+        lesson: z.ZodString;
+        persistenceScope: z.ZodEnum<{
+          PROJECT: "PROJECT";
+          USER: "USER";
+        }>;
+        evidenceStrength: z.ZodLiteral<"HIGH">;
+        supportingEvidence: z.ZodArray<z.ZodObject<{
+          messageSeq: z.ZodNumber;
+          excerptDigest: z.ZodString;
+        }, z.core.$strict>>;
+        contextSummary: z.ZodOptional<z.ZodString>;
+      }, z.core.$strict>>>;
+      proposal: z.ZodOptional<z.ZodObject<{
+        learningProposalId: z.ZodString;
+        policyVersion: z.ZodLiteral<"learning-v1">;
+        name: z.ZodString;
+        description: z.ZodString;
+        whenToUse: z.ZodString;
+        content: z.ZodString;
+        invocation: z.ZodObject<{
+          modelInvocable: z.ZodLiteral<true>;
+          userInvocable: z.ZodLiteral<false>;
+        }, z.core.$strict>;
+        persistenceScope: z.ZodEnum<{
+          PROJECT: "PROJECT";
+          USER: "USER";
+        }>;
+        supportingExperienceIds: z.ZodArray<z.ZodString>;
+        curation: z.ZodObject<{
+          decision: z.ZodEnum<{
+            CREATE: "CREATE";
+            MERGE: "MERGE";
+            DISCARD: "DISCARD";
+          }>;
+          candidateKey: z.ZodOptional<z.ZodString>;
+          rationale: z.ZodString;
+        }, z.core.$strict>;
+        catalogObservationDigest: z.ZodString;
+        shortlistDigests: z.ZodArray<z.ZodString>;
+      }, z.core.$strict>>;
+      publicationOutcome: z.ZodOptional<z.ZodLiteral<"NEEDS_ATTENTION">>;
+    }, z.core.$strict>>;
+    review: z.ZodOptional<z.ZodObject<{
+      policyVersion: z.ZodLiteral<"review-v1">;
+      proposal: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        revision: z.ZodNumber;
+        createdAt: z.ZodString;
+        sourceLearningProposalId: z.ZodString;
+        kind: z.ZodEnum<{
+          CREATE: "CREATE";
+          MERGE: "MERGE";
+          DISCARD: "DISCARD";
+        }>;
+        name: z.ZodString;
+        description: z.ZodString;
+        whenToUse: z.ZodString;
+        invocation: z.ZodObject<{
+          modelInvocable: z.ZodLiteral<true>;
+          userInvocable: z.ZodLiteral<false>;
+        }, z.core.$strict>;
+        exactSkillBytes: z.ZodString;
+        skillBytesDigest: z.ZodString;
+        rendererVersion: z.ZodString;
+        persistenceScope: z.ZodEnum<{
+          PROJECT: "PROJECT";
+          USER: "USER";
+        }>;
+        workspaceBinding: z.ZodOptional<z.ZodObject<{
+          workspaceId: z.ZodString;
+          canonicalPath: z.ZodString;
+          observedAt: z.ZodString;
+        }, z.core.$strict>>;
+        dshHomeBinding: z.ZodOptional<z.ZodObject<{
+          resolutionKind: z.ZodEnum<{
+            CONFIGURATION: "CONFIGURATION";
+            ENVIRONMENT: "ENVIRONMENT";
+            DEFAULT: "DEFAULT";
+          }>;
+          canonicalPath: z.ZodString;
+          identityDigest: z.ZodString;
+          observedAt: z.ZodString;
+        }, z.core.$strict>>;
+        supportingExperienceIds: z.ZodArray<z.ZodString>;
+        catalogObservationDigest: z.ZodString;
+        curationRationale: z.ZodString;
+        actionBinding: z.ZodDiscriminatedUnion<[z.ZodObject<{
+          kind: z.ZodLiteral<"CREATE">;
+          rootBinding: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            scope: z.ZodEnum<{
+              PROJECT: "PROJECT";
+              USER: "USER";
+            }>;
+            expectedProvider: z.ZodLiteral<"filesystem">;
+            expectedSource: z.ZodEnum<{
+              "project-dsh": "project-dsh";
+              "user-dsh": "user-dsh";
+            }>;
+            resolverVersion: z.ZodLiteral<"stock-root-resolver-v2">;
+            rootContractVersion: z.ZodLiteral<"stock-dsh-web-default-roots-v1">;
+            resolutionContractDigest: z.ZodString;
+            declaredRootPath: z.ZodString;
+            state: z.ZodLiteral<"EXISTING">;
+            canonicalRootPath: z.ZodString;
+            rootIdentityDigest: z.ZodString;
+          }, z.core.$strict>, z.ZodObject<{
+            scope: z.ZodEnum<{
+              PROJECT: "PROJECT";
+              USER: "USER";
+            }>;
+            expectedProvider: z.ZodLiteral<"filesystem">;
+            expectedSource: z.ZodEnum<{
+              "project-dsh": "project-dsh";
+              "user-dsh": "user-dsh";
+            }>;
+            resolverVersion: z.ZodLiteral<"stock-root-resolver-v2">;
+            rootContractVersion: z.ZodLiteral<"stock-dsh-web-default-roots-v1">;
+            resolutionContractDigest: z.ZodString;
+            declaredRootPath: z.ZodString;
+            state: z.ZodLiteral<"ABSENT">;
+            canonicalExistingAncestorPath: z.ZodString;
+            ancestorIdentityDigest: z.ZodString;
+            missingSegments: z.ZodArray<z.ZodString>;
+          }, z.core.$strict>], "state">;
+          targetBinding: z.ZodObject<{
+            skillName: z.ZodString;
+            bundlePath: z.ZodString;
+            skillFilePath: z.ZodString;
+          }, z.core.$strict>;
+          expectedAbsence: z.ZodObject<{
+            catalogObservationDigest: z.ZodString;
+            observedAt: z.ZodString;
+            flatSkillFilePath: z.ZodString;
+            bundlePathAbsent: z.ZodLiteral<true>;
+            skillFilePathAbsent: z.ZodLiteral<true>;
+            flatSkillFilePathAbsent: z.ZodLiteral<true>;
+          }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+          kind: z.ZodLiteral<"MERGE">;
+          rootBinding: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            scope: z.ZodEnum<{
+              PROJECT: "PROJECT";
+              USER: "USER";
+            }>;
+            expectedProvider: z.ZodLiteral<"filesystem">;
+            expectedSource: z.ZodEnum<{
+              "project-dsh": "project-dsh";
+              "user-dsh": "user-dsh";
+            }>;
+            resolverVersion: z.ZodLiteral<"stock-root-resolver-v2">;
+            rootContractVersion: z.ZodLiteral<"stock-dsh-web-default-roots-v1">;
+            resolutionContractDigest: z.ZodString;
+            declaredRootPath: z.ZodString;
+            state: z.ZodLiteral<"EXISTING">;
+            canonicalRootPath: z.ZodString;
+            rootIdentityDigest: z.ZodString;
+          }, z.core.$strict>, z.ZodObject<{
+            scope: z.ZodEnum<{
+              PROJECT: "PROJECT";
+              USER: "USER";
+            }>;
+            expectedProvider: z.ZodLiteral<"filesystem">;
+            expectedSource: z.ZodEnum<{
+              "project-dsh": "project-dsh";
+              "user-dsh": "user-dsh";
+            }>;
+            resolverVersion: z.ZodLiteral<"stock-root-resolver-v2">;
+            rootContractVersion: z.ZodLiteral<"stock-dsh-web-default-roots-v1">;
+            resolutionContractDigest: z.ZodString;
+            declaredRootPath: z.ZodString;
+            state: z.ZodLiteral<"ABSENT">;
+            canonicalExistingAncestorPath: z.ZodString;
+            ancestorIdentityDigest: z.ZodString;
+            missingSegments: z.ZodArray<z.ZodString>;
+          }, z.core.$strict>], "state">;
+          targetBinding: z.ZodObject<{
+            skillName: z.ZodString;
+            bundlePath: z.ZodString;
+            skillFilePath: z.ZodString;
+          }, z.core.$strict>;
+          baseBinding: z.ZodObject<{
+            candidateKey: z.ZodString;
+            provider: z.ZodString;
+            source: z.ZodString;
+            path: z.ZodString;
+            exactBytes: z.ZodString;
+            bytesDigest: z.ZodString;
+            catalogObservationDigest: z.ZodString;
+            observedAt: z.ZodString;
+          }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+          kind: z.ZodLiteral<"DISCARD">;
+          coveringCandidateBinding: z.ZodObject<{
+            candidateKey: z.ZodString;
+            provider: z.ZodString;
+            source: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodString;
+            whenToUse: z.ZodOptional<z.ZodString>;
+            content: z.ZodString;
+            contentDigest: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            catalogObservationDigest: z.ZodString;
+            observedAt: z.ZodString;
+          }, z.core.$strict>;
+        }, z.core.$strict>], "kind">;
+        proposalId: z.ZodString;
+        digest: z.ZodString;
+      }, z.core.$strict>;
+      reviewDecision: z.ZodEnum<{
+        PENDING: "PENDING";
+        APPROVED: "APPROVED";
+        REJECTED: "REJECTED";
+      }>;
+      publicationOutcome: z.ZodEnum<{
+        NEEDS_ATTENTION: "NEEDS_ATTENTION";
+        PENDING_REVIEW: "PENDING_REVIEW";
+        DISCARDED: "DISCARDED";
+        NEEDS_REFRESH: "NEEDS_REFRESH";
+        PUBLISHED: "PUBLISHED";
+        PUBLISH_FAILED: "PUBLISH_FAILED";
+      }>;
+      coverageRetryCount: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>;
+      decidedAt: z.ZodOptional<z.ZodString>;
+      decisionReason: z.ZodOptional<z.ZodEnum<{
+        USER_REJECTED: "USER_REJECTED";
+        COVERAGE_CONFIRMED: "COVERAGE_CONFIRMED";
+      }>>;
+      failure: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        retryable: z.ZodBoolean;
+        occurredAt: z.ZodString;
+      }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    publication: z.ZodOptional<z.ZodObject<{
+      schemaVersion: z.ZodLiteral<1>;
+      policyVersion: z.ZodLiteral<"publication-v1">;
+      attemptCount: z.ZodNumber;
+      activeAttemptId: z.ZodString;
+      targetIdentityDigest: z.ZodString;
+      journal: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        ordinal: z.ZodNumber;
+        attempt: z.ZodNumber;
+        attemptId: z.ZodString;
+        stage: z.ZodEnum<{
+          APPROVAL_COMMITTED: "APPROVAL_COMMITTED";
+          FACTS_REVALIDATED: "FACTS_REVALIDATED";
+          ROOT_PREPARED: "ROOT_PREPARED";
+          TARGET_INSTALLED: "TARGET_INSTALLED";
+          DISK_VERIFIED: "DISK_VERIFIED";
+          READBACK_CONFIRMED: "READBACK_CONFIRMED";
+          LINEAGE_PENDING: "LINEAGE_PENDING";
+          LINEAGE_COMMITTED: "LINEAGE_COMMITTED";
+          OUTCOME_COMMITTED: "OUTCOME_COMMITTED";
+        }>;
+        targetIdentityDigest: z.ZodString;
+        expectedHash: z.ZodOptional<z.ZodString>;
+        observedHash: z.ZodOptional<z.ZodString>;
+        occurredAt: z.ZodString;
+        previousDigest: z.ZodNullable<z.ZodString>;
+        digest: z.ZodString;
+      }, z.core.$strict>>;
+      pendingLineage: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        scope: z.ZodEnum<{
+          PROJECT: "PROJECT";
+          USER: "USER";
+        }>;
+        provider: z.ZodString;
+        source: z.ZodEnum<{
+          "project-dsh": "project-dsh";
+          "user-dsh": "user-dsh";
+        }>;
+        skillName: z.ZodString;
+        canonicalTargetPath: z.ZodString;
+        targetIdentityDigest: z.ZodString;
+        currentRevision: z.ZodNumber;
+        revisions: z.ZodArray<z.ZodObject<{
+          revision: z.ZodNumber;
+          origin: z.ZodEnum<{
+            ADOPTED_BASE: "ADOPTED_BASE";
+            MANUAL_BASE: "MANUAL_BASE";
+            RUN2SKILL: "RUN2SKILL";
+          }>;
+          proposalId: z.ZodOptional<z.ZodString>;
+          exactSkillBytes: z.ZodString;
+          skillBytesDigest: z.ZodString;
+          committedAt: z.ZodString;
+        }, z.core.$strict>>;
+        lineageId: z.ZodString;
+      }, z.core.$strict>>;
+    }, z.core.$strict>>;
+  }, z.core.$strict>;
+}, z.core.$strict>;
+declare const ProposalLineageV2Schema: z.ZodUnion<readonly [z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  revision: z.ZodNumber;
+  lineageId: z.ZodString;
+  persistenceScope: z.ZodEnum<{
+    PROJECT: "PROJECT";
+    USER: "USER";
+  }>;
+  origin: z.ZodLiteral<"LEGACY_V1">;
+  state: z.ZodLiteral<"PUBLISHED">;
+  sourceDigest: z.ZodString;
+  importedAt: z.ZodString;
+  updatedAt: z.ZodString;
+  legacySnapshot: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    scope: z.ZodEnum<{
+      PROJECT: "PROJECT";
+      USER: "USER";
+    }>;
+    provider: z.ZodString;
+    source: z.ZodEnum<{
+      "project-dsh": "project-dsh";
+      "user-dsh": "user-dsh";
+    }>;
+    skillName: z.ZodString;
+    canonicalTargetPath: z.ZodString;
+    targetIdentityDigest: z.ZodString;
+    currentRevision: z.ZodNumber;
+    revisions: z.ZodArray<z.ZodObject<{
+      revision: z.ZodNumber;
+      origin: z.ZodEnum<{
+        ADOPTED_BASE: "ADOPTED_BASE";
+        MANUAL_BASE: "MANUAL_BASE";
+        RUN2SKILL: "RUN2SKILL";
+      }>;
+      proposalId: z.ZodOptional<z.ZodString>;
+      exactSkillBytes: z.ZodString;
+      skillBytesDigest: z.ZodString;
+      committedAt: z.ZodString;
+    }, z.core.$strict>>;
+    lineageId: z.ZodString;
+  }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  revision: z.ZodNumber;
+  lineageId: z.ZodString;
+  persistenceScope: z.ZodEnum<{
+    PROJECT: "PROJECT";
+    USER: "USER";
+  }>;
+  origin: z.ZodLiteral<"RUN2SKILL_V2">;
+  state: z.ZodEnum<{
+    TERMINAL: "TERMINAL";
+    PUBLISHED: "PUBLISHED";
+    RESERVED: "RESERVED";
+    ACTIVE_PROPOSAL: "ACTIVE_PROPOSAL";
+  }>;
+  behaviorSignature: z.ZodString;
+  ownerIntentId: z.ZodString;
+  ownerIntentRevision: z.ZodNumber;
+  currentProposalRevision: z.ZodNumber;
+  proposalRevisions: z.ZodArray<z.ZodObject<{
+    revision: z.ZodNumber;
+    proposalId: z.ZodString;
+    ownerIntentId: z.ZodString;
+    ownerIntentRevision: z.ZodNumber;
+    action: z.ZodEnum<{
+      CREATE: "CREATE";
+      MERGE: "MERGE";
+    }>;
+    body: z.ZodObject<{
+      name: z.ZodString;
+      description: z.ZodString;
+      whenToUse: z.ZodString;
+      exactSkillBytes: z.ZodString;
+      skillBytesDigest: z.ZodString;
+    }, z.core.$strict>;
+    runtimeCatalogDigest: z.ZodString;
+    pendingCatalogDigest: z.ZodString;
+    generationResultReceiptDigest: z.ZodString;
+    catalogMutationReceiptDigest: z.ZodString;
+    catalogEpoch: z.ZodNumber;
+    targetIdentityDigest: z.ZodOptional<z.ZodString>;
+    baseSkillBytesDigest: z.ZodOptional<z.ZodString>;
+    projectScopeBinding: z.ZodOptional<z.ZodObject<{
+      workspaceId: z.ZodString;
+      scopeIdentityDigest: z.ZodString;
+    }, z.core.$strict>>;
+    state: z.ZodEnum<{
+      TERMINAL: "TERMINAL";
+      PUBLISHED: "PUBLISHED";
+      ACTIVE_PROPOSAL: "ACTIVE_PROPOSAL";
+    }>;
+    reviewDecision: z.ZodOptional<z.ZodEnum<{
+      APPROVED: "APPROVED";
+      REJECTED: "REJECTED";
+    }>>;
+    reviewedAt: z.ZodOptional<z.ZodString>;
+    reviewReceiptDigest: z.ZodOptional<z.ZodString>;
+    reviewCatalog: z.ZodOptional<z.ZodObject<{
+      status: z.ZodLiteral<"CURRENT">;
+      runtimeCatalogDigest: z.ZodString;
+      pendingCatalogDigest: z.ZodString;
+      catalogEpoch: z.ZodNumber;
+      catalogMutationReceiptDigest: z.ZodString;
+    }, z.core.$strict>>;
+    reviewFailureCode: z.ZodOptional<z.ZodEnum<{
+      CATALOG_CHANGED: "CATALOG_CHANGED";
+      CATALOG_UNAVAILABLE: "CATALOG_UNAVAILABLE";
+    }>>;
+    reviewAttemptedAt: z.ZodOptional<z.ZodString>;
+    publicationFailureCode: z.ZodOptional<z.ZodEnum<{
+      CATALOG_CHANGED: "CATALOG_CHANGED";
+      PUBLICATION_CONFLICT: "PUBLICATION_CONFLICT";
+      CATALOG_UNAVAILABLE: "CATALOG_UNAVAILABLE";
+      PUBLICATION_UNAVAILABLE: "PUBLICATION_UNAVAILABLE";
+    }>>;
+    publicationAttemptedAt: z.ZodOptional<z.ZodString>;
+    publicationExternalReceiptDigest: z.ZodOptional<z.ZodString>;
+    publishedAt: z.ZodOptional<z.ZodString>;
+    publicationReceiptDigest: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+  }, z.core.$strict>>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strict>]>;
+declare const GlobalV2Schema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  migration: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    source: z.ZodObject<{
+      domainName: z.ZodLiteral<"run2skill_v1">;
+      domainVersion: z.ZodLiteral<2>;
+      globalSchemaVersion: z.ZodLiteral<1>;
+    }, z.core.$strict>;
+    phase: z.ZodLiteral<"NOT_STARTED">;
+  }, z.core.$strict>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    source: z.ZodObject<{
+      domainName: z.ZodLiteral<"run2skill_v1">;
+      domainVersion: z.ZodLiteral<2>;
+      globalSchemaVersion: z.ZodLiteral<1>;
+    }, z.core.$strict>;
+    sourceFingerprint: z.ZodString;
+    counts: z.ZodObject<{
+      workItems: z.ZodNumber;
+      lineages: z.ZodNumber;
+      activeLegacyProposals: z.ZodNumber;
+    }, z.core.$strict>;
+    startedAt: z.ZodString;
+    updatedAt: z.ZodString;
+    phase: z.ZodLiteral<"COPYING">;
+  }, z.core.$strict>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    source: z.ZodObject<{
+      domainName: z.ZodLiteral<"run2skill_v1">;
+      domainVersion: z.ZodLiteral<2>;
+      globalSchemaVersion: z.ZodLiteral<1>;
+    }, z.core.$strict>;
+    sourceFingerprint: z.ZodString;
+    counts: z.ZodObject<{
+      workItems: z.ZodNumber;
+      lineages: z.ZodNumber;
+      activeLegacyProposals: z.ZodNumber;
+    }, z.core.$strict>;
+    startedAt: z.ZodString;
+    updatedAt: z.ZodString;
+    phase: z.ZodLiteral<"VALIDATING">;
+  }, z.core.$strict>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    source: z.ZodObject<{
+      domainName: z.ZodLiteral<"run2skill_v1">;
+      domainVersion: z.ZodLiteral<2>;
+      globalSchemaVersion: z.ZodLiteral<1>;
+    }, z.core.$strict>;
+    committedAt: z.ZodString;
+    activationFenceDigest: z.ZodString;
+    sourceFingerprint: z.ZodString;
+    counts: z.ZodObject<{
+      workItems: z.ZodNumber;
+      lineages: z.ZodNumber;
+      activeLegacyProposals: z.ZodNumber;
+    }, z.core.$strict>;
+    startedAt: z.ZodString;
+    updatedAt: z.ZodString;
+    phase: z.ZodLiteral<"COMMITTED">;
+  }, z.core.$strict>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    source: z.ZodObject<{
+      domainName: z.ZodLiteral<"run2skill_v1">;
+      domainVersion: z.ZodLiteral<2>;
+      globalSchemaVersion: z.ZodLiteral<1>;
+    }, z.core.$strict>;
+    failureCode: z.ZodString;
+    sourceFingerprint: z.ZodString;
+    counts: z.ZodObject<{
+      workItems: z.ZodNumber;
+      lineages: z.ZodNumber;
+      activeLegacyProposals: z.ZodNumber;
+    }, z.core.$strict>;
+    startedAt: z.ZodString;
+    updatedAt: z.ZodString;
+    phase: z.ZodLiteral<"FAILED">;
+  }, z.core.$strict>], "phase">;
+  sessions: z.ZodRecord<z.ZodString, z.ZodObject<{
+    observedThroughTurnEndSeq: z.ZodNumber;
+    detectedThroughTurnEndSeq: z.ZodNumber;
+    headerRevision: z.ZodOptional<z.ZodString>;
+    observedLogPrefixDigest: z.ZodOptional<z.ZodString>;
+    activeBatchId: z.ZodOptional<z.ZodString>;
+    lastActivityAt: z.ZodOptional<z.ZodString>;
+    batchManifestBaseline: z.ZodOptional<z.ZodObject<{
+      observedAt: z.ZodString;
+      rootManifestDigest: z.ZodString;
+      runtimeCatalogDigest: z.ZodString;
+      complete: z.ZodBoolean;
+      ownershipCandidates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        candidateId: z.ZodString;
+        name: z.ZodString;
+        provider: z.ZodString;
+        source: z.ZodString;
+        scope: z.ZodEnum<{
+          PROJECT: "PROJECT";
+          USER: "USER";
+        }>;
+        writable: z.ZodBoolean;
+        targetPathDigest: z.ZodOptional<z.ZodString>;
+        bodyDigest: z.ZodString;
+      }, z.core.$strict>>>;
+      afterTurnEndSeq: z.ZodNumber;
+    }, z.core.$strict>>;
+    openExperienceCarry: z.ZodArray<z.ZodObject<{
+      summary: z.ZodString;
+      behaviorSignatureDraft: z.ZodString;
+      evidenceDigests: z.ZodArray<z.ZodString>;
+      remainingBatches: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    }, z.core.$strict>>;
+    updatedAt: z.ZodString;
+  }, z.core.$strict>>;
+  behaviorSignatureIndex: z.ZodRecord<z.ZodString, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    persistenceScope: z.ZodEnum<{
+      PROJECT: "PROJECT";
+      USER: "USER";
+    }>;
+    behaviorSignature: z.ZodString;
+    ownerIntentId: z.ZodString;
+    ownerRevision: z.ZodNumber;
+    state: z.ZodEnum<{
+      RESERVED: "RESERVED";
+      ACTIVE: "ACTIVE";
+    }>;
+    updatedAt: z.ZodString;
+  }, z.core.$strict>>;
+  proposalGenerationLease: z.ZodOptional<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    leaseId: z.ZodString;
+    ownerIntentId: z.ZodString;
+    ownerRevision: z.ZodNumber;
+    generationRevision: z.ZodNumber;
+    action: z.ZodEnum<{
+      CREATE: "CREATE";
+      MERGE: "MERGE";
+    }>;
+    inputDigest: z.ZodString;
+    externalPendingDigest: z.ZodString;
+    catalogEpoch: z.ZodNumber;
+    acquiredAt: z.ZodString;
+    callId: z.ZodOptional<z.ZodString>;
+    callOutcomeReceiptDigest: z.ZodOptional<z.ZodString>;
+    sealedResultReceiptDigest: z.ZodOptional<z.ZodString>;
+    barrierReceiptDigest: z.ZodOptional<z.ZodString>;
+    proposalAuthorizationReceiptDigest: z.ZodOptional<z.ZodString>;
+    completionReceiptDigest: z.ZodOptional<z.ZodString>;
+    state: z.ZodEnum<{
+      NOT_CALLED: "NOT_CALLED";
+      CALL_RESERVED: "CALL_RESERVED";
+      KNOWN_FAILED: "KNOWN_FAILED";
+      SUCCEEDED_RESULT_MISSING: "SUCCEEDED_RESULT_MISSING";
+      RESULT_COMMITTED: "RESULT_COMMITTED";
+      PROPOSAL_COMMIT_AUTHORIZED: "PROPOSAL_COMMIT_AUTHORIZED";
+      OUTCOME_UNKNOWN: "OUTCOME_UNKNOWN";
+      BODY_COMMITTED_INDEX_PENDING: "BODY_COMMITTED_INDEX_PENDING";
+      ACTIVE_COMPLETE: "ACTIVE_COMPLETE";
+    }>;
+  }, z.core.$strict>>;
+  proposalCatalogEpoch: z.ZodNumber;
+  proposalCatalogLastMutation: z.ZodDefault<z.ZodObject<{
+    epoch: z.ZodNumber;
+    kind: z.ZodEnum<{
+      GENESIS: "GENESIS";
+      PROPOSAL: "PROPOSAL";
+      GENERATION_RESULT: "GENERATION_RESULT";
+      BARRIER: "BARRIER";
+      LEGACY: "LEGACY";
+      REVIEW: "REVIEW";
+      PUBLICATION: "PUBLICATION";
+      PURGE: "PURGE";
+      USER_ACTION: "USER_ACTION";
+    }>;
+    ownerId: z.ZodString;
+    mutationId: z.ZodString;
+    digest: z.ZodString;
+  }, z.core.$strict>>;
+  proposalCatalogMutationJournal: z.ZodOptional<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    mutationId: z.ZodString;
+    ownerId: z.ZodString;
+    kind: z.ZodEnum<{
+      PROPOSAL: "PROPOSAL";
+      GENERATION_RESULT: "GENERATION_RESULT";
+      BARRIER: "BARRIER";
+      LEGACY: "LEGACY";
+      REVIEW: "REVIEW";
+      PUBLICATION: "PUBLICATION";
+      PURGE: "PURGE";
+      USER_ACTION: "USER_ACTION";
+    }>;
+    phase: z.ZodEnum<{
+      NEEDS_REFRESH: "NEEDS_REFRESH";
+      PREPARED: "PREPARED";
+      EXECUTING: "EXECUTING";
+    }>;
+    preparedAt: z.ZodString;
+    executionStartedAt: z.ZodOptional<z.ZodString>;
+    failureCode: z.ZodOptional<z.ZodEnum<{
+      CATALOG_CHANGED: "CATALOG_CHANGED";
+      PUBLICATION_CONFLICT: "PUBLICATION_CONFLICT";
+    }>>;
+    failedAt: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  purgeJournal: z.ZodOptional<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    purgeId: z.ZodString;
+    scopeBinding: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      scope: z.ZodLiteral<"ALL">;
+    }, z.core.$strict>, z.ZodObject<{
+      scope: z.ZodLiteral<"USER">;
+      scopeIdentityDigest: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+      scope: z.ZodLiteral<"PROJECT">;
+      workspaceId: z.ZodString;
+      scopeIdentityDigest: z.ZodString;
+    }, z.core.$strict>], "scope">;
+    hideBefore: z.ZodString;
+    phase: z.ZodEnum<{
+      VALIDATING: "VALIDATING";
+      PREPARED: "PREPARED";
+      QUIESCED: "QUIESCED";
+      DELETING: "DELETING";
+    }>;
+    updatedAt: z.ZodString;
+  }, z.core.$strict>>;
+  legacyCompletedPurgeFences: z.ZodOptional<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    all: z.ZodOptional<z.ZodObject<{
+      schemaVersion: z.ZodLiteral<1>;
+      purgeId: z.ZodString;
+      completedAt: z.ZodString;
+      hideBefore: z.ZodString;
+      scope: z.ZodLiteral<"ALL">;
+    }, z.core.$strict>>;
+    user: z.ZodOptional<z.ZodObject<{
+      schemaVersion: z.ZodLiteral<1>;
+      purgeId: z.ZodString;
+      completedAt: z.ZodString;
+      hideBefore: z.ZodString;
+      scope: z.ZodLiteral<"USER">;
+    }, z.core.$strict>>;
+    projects: z.ZodRecord<z.ZodString, z.ZodObject<{
+      schemaVersion: z.ZodLiteral<1>;
+      purgeId: z.ZodString;
+      completedAt: z.ZodString;
+      hideBefore: z.ZodString;
+      scope: z.ZodLiteral<"PROJECT">;
+      scopeIdentityDigest: z.ZodString;
+    }, z.core.$strict>>;
+  }, z.core.$strict>>;
+  activation: z.ZodOptional<z.ZodObject<{
+    committedAt: z.ZodString;
+    sourceFingerprint: z.ZodString;
+    observerStartWatermarks: z.ZodRecord<z.ZodString, z.ZodObject<{
+      nextSeq: z.ZodNumber;
+      observedTailSeq: z.ZodNumber;
+      headerRevision: z.ZodOptional<z.ZodString>;
+      headerDigest: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    observerStartWatermarkDigest: z.ZodString;
+    legacyPendingCatalogDigest: z.ZodString;
+    legacyPendingCandidateCount: z.ZodNumber;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+type TurnObservationV2 = z.infer<typeof TurnObservationV2Schema>;
+type SessionBatchV2 = z.infer<typeof SessionBatchV2Schema>;
+type ExperienceIntentV2 = z.infer<typeof ExperienceIntentV2Schema>;
+type LegacyItemV2 = z.infer<typeof LegacyItemV2Schema>;
+type ProposalLineageV2 = z.infer<typeof ProposalLineageV2Schema>;
+type GlobalV2 = z.infer<typeof GlobalV2Schema>;
+//#endregion
+//#region src/adapters/dsh-storage/v2-types.d.ts
+interface Run2skillV2Domain {
+  readonly name: 'run2skill_v2';
+  readonly global: {
+    get(): GlobalV2;
+    set(value: GlobalV2): Promise<void>;
+  };
+  table(name: 'turn_observations'): Run2skillTable<string, TurnObservationV2>;
+  table(name: 'session_batches'): Run2skillTable<string, SessionBatchV2>;
+  table(name: 'experience_intents'): Run2skillTable<string, ExperienceIntentV2>;
+  table(name: 'proposal_lineages'): Run2skillTable<string, ProposalLineageV2>;
+  table(name: 'legacy_items'): Run2skillTable<string, LegacyItemV2>;
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/adapters/dsh-storage/v2-domain.d.ts
+declare const run2skillV2DomainSpec: {
+  readonly name: "run2skill_v2";
+  readonly version: 1;
+  readonly global: {
+    readonly schema: import("zod").ZodObject<{
+      schemaVersion: import("zod").ZodLiteral<1>;
+      migration: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodLiteral<1>;
+        source: import("zod").ZodObject<{
+          domainName: import("zod").ZodLiteral<"run2skill_v1">;
+          domainVersion: import("zod").ZodLiteral<2>;
+          globalSchemaVersion: import("zod").ZodLiteral<1>;
+        }, import("zod/v4/core").$strict>;
+        phase: import("zod").ZodLiteral<"NOT_STARTED">;
+      }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodLiteral<1>;
+        source: import("zod").ZodObject<{
+          domainName: import("zod").ZodLiteral<"run2skill_v1">;
+          domainVersion: import("zod").ZodLiteral<2>;
+          globalSchemaVersion: import("zod").ZodLiteral<1>;
+        }, import("zod/v4/core").$strict>;
+        sourceFingerprint: import("zod").ZodString;
+        counts: import("zod").ZodObject<{
+          workItems: import("zod").ZodNumber;
+          lineages: import("zod").ZodNumber;
+          activeLegacyProposals: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strict>;
+        startedAt: import("zod").ZodString;
+        updatedAt: import("zod").ZodString;
+        phase: import("zod").ZodLiteral<"COPYING">;
+      }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodLiteral<1>;
+        source: import("zod").ZodObject<{
+          domainName: import("zod").ZodLiteral<"run2skill_v1">;
+          domainVersion: import("zod").ZodLiteral<2>;
+          globalSchemaVersion: import("zod").ZodLiteral<1>;
+        }, import("zod/v4/core").$strict>;
+        sourceFingerprint: import("zod").ZodString;
+        counts: import("zod").ZodObject<{
+          workItems: import("zod").ZodNumber;
+          lineages: import("zod").ZodNumber;
+          activeLegacyProposals: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strict>;
+        startedAt: import("zod").ZodString;
+        updatedAt: import("zod").ZodString;
+        phase: import("zod").ZodLiteral<"VALIDATING">;
+      }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodLiteral<1>;
+        source: import("zod").ZodObject<{
+          domainName: import("zod").ZodLiteral<"run2skill_v1">;
+          domainVersion: import("zod").ZodLiteral<2>;
+          globalSchemaVersion: import("zod").ZodLiteral<1>;
+        }, import("zod/v4/core").$strict>;
+        committedAt: import("zod").ZodString;
+        activationFenceDigest: import("zod").ZodString;
+        sourceFingerprint: import("zod").ZodString;
+        counts: import("zod").ZodObject<{
+          workItems: import("zod").ZodNumber;
+          lineages: import("zod").ZodNumber;
+          activeLegacyProposals: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strict>;
+        startedAt: import("zod").ZodString;
+        updatedAt: import("zod").ZodString;
+        phase: import("zod").ZodLiteral<"COMMITTED">;
+      }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodLiteral<1>;
+        source: import("zod").ZodObject<{
+          domainName: import("zod").ZodLiteral<"run2skill_v1">;
+          domainVersion: import("zod").ZodLiteral<2>;
+          globalSchemaVersion: import("zod").ZodLiteral<1>;
+        }, import("zod/v4/core").$strict>;
+        failureCode: import("zod").ZodString;
+        sourceFingerprint: import("zod").ZodString;
+        counts: import("zod").ZodObject<{
+          workItems: import("zod").ZodNumber;
+          lineages: import("zod").ZodNumber;
+          activeLegacyProposals: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strict>;
+        startedAt: import("zod").ZodString;
+        updatedAt: import("zod").ZodString;
+        phase: import("zod").ZodLiteral<"FAILED">;
+      }, import("zod/v4/core").$strict>], "phase">;
+      sessions: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        observedThroughTurnEndSeq: import("zod").ZodNumber;
+        detectedThroughTurnEndSeq: import("zod").ZodNumber;
+        headerRevision: import("zod").ZodOptional<import("zod").ZodString>;
+        observedLogPrefixDigest: import("zod").ZodOptional<import("zod").ZodString>;
+        activeBatchId: import("zod").ZodOptional<import("zod").ZodString>;
+        lastActivityAt: import("zod").ZodOptional<import("zod").ZodString>;
+        batchManifestBaseline: import("zod").ZodOptional<import("zod").ZodObject<{
+          observedAt: import("zod").ZodString;
+          rootManifestDigest: import("zod").ZodString;
+          runtimeCatalogDigest: import("zod").ZodString;
+          complete: import("zod").ZodBoolean;
+          ownershipCandidates: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            candidateId: import("zod").ZodString;
+            name: import("zod").ZodString;
+            provider: import("zod").ZodString;
+            source: import("zod").ZodString;
+            scope: import("zod").ZodEnum<{
+              PROJECT: "PROJECT";
+              USER: "USER";
+            }>;
+            writable: import("zod").ZodBoolean;
+            targetPathDigest: import("zod").ZodOptional<import("zod").ZodString>;
+            bodyDigest: import("zod").ZodString;
+          }, import("zod/v4/core").$strict>>>;
+          afterTurnEndSeq: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strict>>;
+        openExperienceCarry: import("zod").ZodArray<import("zod").ZodObject<{
+          summary: import("zod").ZodString;
+          behaviorSignatureDraft: import("zod").ZodString;
+          evidenceDigests: import("zod").ZodArray<import("zod").ZodString>;
+          remainingBatches: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<0>, import("zod").ZodLiteral<1>, import("zod").ZodLiteral<2>]>;
+        }, import("zod/v4/core").$strict>>;
+        updatedAt: import("zod").ZodString;
+      }, import("zod/v4/core").$strict>>;
+      behaviorSignatureIndex: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodLiteral<1>;
+        persistenceScope: import("zod").ZodEnum<{
+          PROJECT: "PROJECT";
+          USER: "USER";
+        }>;
+        behaviorSignature: import("zod").ZodString;
+        ownerIntentId: import("zod").ZodString;
+        ownerRevision: import("zod").ZodNumber;
+        state: import("zod").ZodEnum<{
+          RESERVED: "RESERVED";
+          ACTIVE: "ACTIVE";
+        }>;
+        updatedAt: import("zod").ZodString;
+      }, import("zod/v4/core").$strict>>;
+      proposalGenerationLease: import("zod").ZodOptional<import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodLiteral<1>;
+        leaseId: import("zod").ZodString;
+        ownerIntentId: import("zod").ZodString;
+        ownerRevision: import("zod").ZodNumber;
+        generationRevision: import("zod").ZodNumber;
+        action: import("zod").ZodEnum<{
+          CREATE: "CREATE";
+          MERGE: "MERGE";
+        }>;
+        inputDigest: import("zod").ZodString;
+        externalPendingDigest: import("zod").ZodString;
+        catalogEpoch: import("zod").ZodNumber;
+        acquiredAt: import("zod").ZodString;
+        callId: import("zod").ZodOptional<import("zod").ZodString>;
+        callOutcomeReceiptDigest: import("zod").ZodOptional<import("zod").ZodString>;
+        sealedResultReceiptDigest: import("zod").ZodOptional<import("zod").ZodString>;
+        barrierReceiptDigest: import("zod").ZodOptional<import("zod").ZodString>;
+        proposalAuthorizationReceiptDigest: import("zod").ZodOptional<import("zod").ZodString>;
+        completionReceiptDigest: import("zod").ZodOptional<import("zod").ZodString>;
+        state: import("zod").ZodEnum<{
+          NOT_CALLED: "NOT_CALLED";
+          CALL_RESERVED: "CALL_RESERVED";
+          KNOWN_FAILED: "KNOWN_FAILED";
+          SUCCEEDED_RESULT_MISSING: "SUCCEEDED_RESULT_MISSING";
+          RESULT_COMMITTED: "RESULT_COMMITTED";
+          PROPOSAL_COMMIT_AUTHORIZED: "PROPOSAL_COMMIT_AUTHORIZED";
+          OUTCOME_UNKNOWN: "OUTCOME_UNKNOWN";
+          BODY_COMMITTED_INDEX_PENDING: "BODY_COMMITTED_INDEX_PENDING";
+          ACTIVE_COMPLETE: "ACTIVE_COMPLETE";
+        }>;
+      }, import("zod/v4/core").$strict>>;
+      proposalCatalogEpoch: import("zod").ZodNumber;
+      proposalCatalogLastMutation: import("zod").ZodDefault<import("zod").ZodObject<{
+        epoch: import("zod").ZodNumber;
+        kind: import("zod").ZodEnum<{
+          GENESIS: "GENESIS";
+          PROPOSAL: "PROPOSAL";
+          GENERATION_RESULT: "GENERATION_RESULT";
+          BARRIER: "BARRIER";
+          LEGACY: "LEGACY";
+          REVIEW: "REVIEW";
+          PUBLICATION: "PUBLICATION";
+          PURGE: "PURGE";
+          USER_ACTION: "USER_ACTION";
+        }>;
+        ownerId: import("zod").ZodString;
+        mutationId: import("zod").ZodString;
+        digest: import("zod").ZodString;
+      }, import("zod/v4/core").$strict>>;
+      proposalCatalogMutationJournal: import("zod").ZodOptional<import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodLiteral<1>;
+        mutationId: import("zod").ZodString;
+        ownerId: import("zod").ZodString;
+        kind: import("zod").ZodEnum<{
+          PROPOSAL: "PROPOSAL";
+          GENERATION_RESULT: "GENERATION_RESULT";
+          BARRIER: "BARRIER";
+          LEGACY: "LEGACY";
+          REVIEW: "REVIEW";
+          PUBLICATION: "PUBLICATION";
+          PURGE: "PURGE";
+          USER_ACTION: "USER_ACTION";
+        }>;
+        phase: import("zod").ZodEnum<{
+          NEEDS_REFRESH: "NEEDS_REFRESH";
+          PREPARED: "PREPARED";
+          EXECUTING: "EXECUTING";
+        }>;
+        preparedAt: import("zod").ZodString;
+        executionStartedAt: import("zod").ZodOptional<import("zod").ZodString>;
+        failureCode: import("zod").ZodOptional<import("zod").ZodEnum<{
+          CATALOG_CHANGED: "CATALOG_CHANGED";
+          PUBLICATION_CONFLICT: "PUBLICATION_CONFLICT";
+        }>>;
+        failedAt: import("zod").ZodOptional<import("zod").ZodString>;
+      }, import("zod/v4/core").$strict>>;
+      purgeJournal: import("zod").ZodOptional<import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodLiteral<1>;
+        purgeId: import("zod").ZodString;
+        scopeBinding: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+          scope: import("zod").ZodLiteral<"ALL">;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+          scope: import("zod").ZodLiteral<"USER">;
+          scopeIdentityDigest: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+          scope: import("zod").ZodLiteral<"PROJECT">;
+          workspaceId: import("zod").ZodString;
+          scopeIdentityDigest: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>], "scope">;
+        hideBefore: import("zod").ZodString;
+        phase: import("zod").ZodEnum<{
+          VALIDATING: "VALIDATING";
+          PREPARED: "PREPARED";
+          QUIESCED: "QUIESCED";
+          DELETING: "DELETING";
+        }>;
+        updatedAt: import("zod").ZodString;
+      }, import("zod/v4/core").$strict>>;
+      legacyCompletedPurgeFences: import("zod").ZodOptional<import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodLiteral<1>;
+        all: import("zod").ZodOptional<import("zod").ZodObject<{
+          schemaVersion: import("zod").ZodLiteral<1>;
+          purgeId: import("zod").ZodString;
+          completedAt: import("zod").ZodString;
+          hideBefore: import("zod").ZodString;
+          scope: import("zod").ZodLiteral<"ALL">;
+        }, import("zod/v4/core").$strict>>;
+        user: import("zod").ZodOptional<import("zod").ZodObject<{
+          schemaVersion: import("zod").ZodLiteral<1>;
+          purgeId: import("zod").ZodString;
+          completedAt: import("zod").ZodString;
+          hideBefore: import("zod").ZodString;
+          scope: import("zod").ZodLiteral<"USER">;
+        }, import("zod/v4/core").$strict>>;
+        projects: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+          schemaVersion: import("zod").ZodLiteral<1>;
+          purgeId: import("zod").ZodString;
+          completedAt: import("zod").ZodString;
+          hideBefore: import("zod").ZodString;
+          scope: import("zod").ZodLiteral<"PROJECT">;
+          scopeIdentityDigest: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>>;
+      }, import("zod/v4/core").$strict>>;
+      activation: import("zod").ZodOptional<import("zod").ZodObject<{
+        committedAt: import("zod").ZodString;
+        sourceFingerprint: import("zod").ZodString;
+        observerStartWatermarks: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+          nextSeq: import("zod").ZodNumber;
+          observedTailSeq: import("zod").ZodNumber;
+          headerRevision: import("zod").ZodOptional<import("zod").ZodString>;
+          headerDigest: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>>;
+        observerStartWatermarkDigest: import("zod").ZodString;
+        legacyPendingCatalogDigest: import("zod").ZodString;
+        legacyPendingCandidateCount: import("zod").ZodNumber;
+      }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>;
+    readonly initial: {
+      schemaVersion: 1;
+      migration: {
+        schemaVersion: 1;
+        source: {
+          domainName: "run2skill_v1";
+          domainVersion: 2;
+          globalSchemaVersion: 1;
+        };
+        phase: "NOT_STARTED";
+      } | {
+        schemaVersion: 1;
+        source: {
+          domainName: "run2skill_v1";
+          domainVersion: 2;
+          globalSchemaVersion: 1;
+        };
+        sourceFingerprint: string;
+        counts: {
+          workItems: number;
+          lineages: number;
+          activeLegacyProposals: number;
+        };
+        startedAt: string;
+        updatedAt: string;
+        phase: "COPYING";
+      } | {
+        schemaVersion: 1;
+        source: {
+          domainName: "run2skill_v1";
+          domainVersion: 2;
+          globalSchemaVersion: 1;
+        };
+        sourceFingerprint: string;
+        counts: {
+          workItems: number;
+          lineages: number;
+          activeLegacyProposals: number;
+        };
+        startedAt: string;
+        updatedAt: string;
+        phase: "VALIDATING";
+      } | {
+        schemaVersion: 1;
+        source: {
+          domainName: "run2skill_v1";
+          domainVersion: 2;
+          globalSchemaVersion: 1;
+        };
+        committedAt: string;
+        activationFenceDigest: string;
+        sourceFingerprint: string;
+        counts: {
+          workItems: number;
+          lineages: number;
+          activeLegacyProposals: number;
+        };
+        startedAt: string;
+        updatedAt: string;
+        phase: "COMMITTED";
+      } | {
+        schemaVersion: 1;
+        source: {
+          domainName: "run2skill_v1";
+          domainVersion: 2;
+          globalSchemaVersion: 1;
+        };
+        failureCode: string;
+        sourceFingerprint: string;
+        counts: {
+          workItems: number;
+          lineages: number;
+          activeLegacyProposals: number;
+        };
+        startedAt: string;
+        updatedAt: string;
+        phase: "FAILED";
+      };
+      sessions: Record<string, {
+        observedThroughTurnEndSeq: number;
+        detectedThroughTurnEndSeq: number;
+        openExperienceCarry: {
+          summary: string;
+          behaviorSignatureDraft: string;
+          evidenceDigests: string[];
+          remainingBatches: 0 | 1 | 2;
+        }[];
+        updatedAt: string;
+        headerRevision?: string | undefined;
+        observedLogPrefixDigest?: string | undefined;
+        activeBatchId?: string | undefined;
+        lastActivityAt?: string | undefined;
+        batchManifestBaseline?: {
+          observedAt: string;
+          rootManifestDigest: string;
+          runtimeCatalogDigest: string;
+          complete: boolean;
+          afterTurnEndSeq: number;
+          ownershipCandidates?: {
+            candidateId: string;
+            name: string;
+            provider: string;
+            source: string;
+            scope: "PROJECT" | "USER";
+            writable: boolean;
+            bodyDigest: string;
+            targetPathDigest?: string | undefined;
+          }[] | undefined;
+        } | undefined;
+      }>;
+      behaviorSignatureIndex: Record<string, {
+        schemaVersion: 1;
+        persistenceScope: "PROJECT" | "USER";
+        behaviorSignature: string;
+        ownerIntentId: string;
+        ownerRevision: number;
+        state: "RESERVED" | "ACTIVE";
+        updatedAt: string;
+      }>;
+      proposalCatalogEpoch: number;
+      proposalCatalogLastMutation: {
+        epoch: number;
+        kind: "GENESIS" | "PROPOSAL" | "GENERATION_RESULT" | "BARRIER" | "LEGACY" | "REVIEW" | "PUBLICATION" | "PURGE" | "USER_ACTION";
+        ownerId: string;
+        mutationId: string;
+        digest: string;
+      };
+      proposalGenerationLease?: {
+        schemaVersion: 1;
+        leaseId: string;
+        ownerIntentId: string;
+        ownerRevision: number;
+        generationRevision: number;
+        action: "CREATE" | "MERGE";
+        inputDigest: string;
+        externalPendingDigest: string;
+        catalogEpoch: number;
+        acquiredAt: string;
+        state: "NOT_CALLED" | "CALL_RESERVED" | "KNOWN_FAILED" | "SUCCEEDED_RESULT_MISSING" | "RESULT_COMMITTED" | "PROPOSAL_COMMIT_AUTHORIZED" | "OUTCOME_UNKNOWN" | "BODY_COMMITTED_INDEX_PENDING" | "ACTIVE_COMPLETE";
+        callId?: string | undefined;
+        callOutcomeReceiptDigest?: string | undefined;
+        sealedResultReceiptDigest?: string | undefined;
+        barrierReceiptDigest?: string | undefined;
+        proposalAuthorizationReceiptDigest?: string | undefined;
+        completionReceiptDigest?: string | undefined;
+      } | undefined;
+      proposalCatalogMutationJournal?: {
+        schemaVersion: 1;
+        mutationId: string;
+        ownerId: string;
+        kind: "PROPOSAL" | "GENERATION_RESULT" | "BARRIER" | "LEGACY" | "REVIEW" | "PUBLICATION" | "PURGE" | "USER_ACTION";
+        phase: "NEEDS_REFRESH" | "PREPARED" | "EXECUTING";
+        preparedAt: string;
+        executionStartedAt?: string | undefined;
+        failureCode?: "CATALOG_CHANGED" | "PUBLICATION_CONFLICT" | undefined;
+        failedAt?: string | undefined;
+      } | undefined;
+      purgeJournal?: {
+        schemaVersion: 1;
+        purgeId: string;
+        scopeBinding: {
+          scope: "ALL";
+        } | {
+          scope: "USER";
+          scopeIdentityDigest: string;
+        } | {
+          scope: "PROJECT";
+          workspaceId: string;
+          scopeIdentityDigest: string;
+        };
+        hideBefore: string;
+        phase: "VALIDATING" | "PREPARED" | "QUIESCED" | "DELETING";
+        updatedAt: string;
+      } | undefined;
+      legacyCompletedPurgeFences?: {
+        schemaVersion: 1;
+        projects: Record<string, {
+          schemaVersion: 1;
+          purgeId: string;
+          completedAt: string;
+          hideBefore: string;
+          scope: "PROJECT";
+          scopeIdentityDigest: string;
+        }>;
+        all?: {
+          schemaVersion: 1;
+          purgeId: string;
+          completedAt: string;
+          hideBefore: string;
+          scope: "ALL";
+        } | undefined;
+        user?: {
+          schemaVersion: 1;
+          purgeId: string;
+          completedAt: string;
+          hideBefore: string;
+          scope: "USER";
+        } | undefined;
+      } | undefined;
+      activation?: {
+        committedAt: string;
+        sourceFingerprint: string;
+        observerStartWatermarks: Record<string, {
+          nextSeq: number;
+          observedTailSeq: number;
+          headerRevision?: string | undefined;
+          headerDigest?: string | undefined;
+        }>;
+        observerStartWatermarkDigest: string;
+        legacyPendingCatalogDigest: string;
+        legacyPendingCandidateCount: number;
+      } | undefined;
+    };
+  };
+  readonly tables: {
+    readonly turn_observations: {
+      readonly valueSchema: import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodLiteral<1>;
+        revision: import("zod").ZodNumber;
+        observationId: import("zod").ZodString;
+        sessionLifecycleKey: import("zod").ZodString;
+        turn: import("zod").ZodNumber;
+        turnEndSeq: import("zod").ZodNumber;
+        turnInstanceDigest: import("zod").ZodString;
+        observedAt: import("zod").ZodString;
+        outcomeKind: import("zod").ZodString;
+        assistantOutcomeSummary: import("zod").ZodString;
+        toolOutcomeSummary: import("zod").ZodArray<import("zod").ZodObject<{
+          toolName: import("zod").ZodString;
+          outcome: import("zod").ZodString;
+          contentDigest: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>>;
+        routeObservation: import("zod").ZodObject<{
+          provider: import("zod").ZodOptional<import("zod").ZodString>;
+          model: import("zod").ZodOptional<import("zod").ZodString>;
+          complete: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strict>;
+        completeness: import("zod").ZodEnum<{
+          COMPLETE: "COMPLETE";
+          INCOMPLETE: "INCOMPLETE";
+        }>;
+        explicitSaveRequested: import("zod").ZodBoolean;
+        scopeBinding: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+          status: import("zod").ZodLiteral<"PROJECT">;
+          workspaceId: import("zod").ZodString;
+          scopeIdentityDigest: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+          status: import("zod").ZodLiteral<"USER">;
+          scopeIdentityDigest: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+          status: import("zod").ZodLiteral<"UNRESOLVED">;
+          reason: import("zod").ZodEnum<{
+            NO_CWD: "NO_CWD";
+            UNREGISTERED: "UNREGISTERED";
+            UNAVAILABLE: "UNAVAILABLE";
+          }>;
+        }, import("zod/v4/core").$strict>], "status">;
+        directUserEvidence: import("zod").ZodArray<import("zod").ZodObject<{
+          source: import("zod").ZodLiteral<"USER_DIRECT">;
+          messageSeq: import("zod").ZodNumber;
+          excerpt: import("zod").ZodString;
+          excerptDigest: import("zod").ZodString;
+          redactionKinds: import("zod").ZodArray<import("zod").ZodEnum<{
+            PRIVATE_KEY: "PRIVATE_KEY";
+            AUTHORIZATION: "AUTHORIZATION";
+            BEARER_TOKEN: "BEARER_TOKEN";
+            API_KEY: "API_KEY";
+            SECRET_ASSIGNMENT: "SECRET_ASSIGNMENT";
+            URL_CREDENTIAL: "URL_CREDENTIAL";
+          }>>;
+          truncated: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strict>>;
+        evidenceDigest: import("zod").ZodString;
+        contentDigest: import("zod").ZodString;
+        sessionRecovery: import("zod").ZodOptional<import("zod").ZodObject<{
+          headerRevision: import("zod").ZodString;
+          observedLogPrefixDigest: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>>;
+      }, import("zod/v4/core").$strict>;
+    };
+    readonly session_batches: {
+      readonly valueSchema: import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodLiteral<1>;
+        revision: import("zod").ZodNumber;
+        batchId: import("zod").ZodString;
+        sessionLifecycleKey: import("zod").ZodString;
+        firstTurnEndSeq: import("zod").ZodNumber;
+        lastTurnEndSeq: import("zod").ZodNumber;
+        detectorPolicyVersion: import("zod").ZodString;
+        triggerReasons: import("zod").ZodArray<import("zod").ZodEnum<{
+          EXPLICIT: "EXPLICIT";
+          THRESHOLD: "THRESHOLD";
+          IDLE: "IDLE";
+        }>>;
+        observationManifest: import("zod").ZodArray<import("zod").ZodObject<{
+          observationId: import("zod").ZodString;
+          turnEndSeq: import("zod").ZodNumber;
+          evidenceDigest: import("zod").ZodString;
+          completeness: import("zod").ZodEnum<{
+            COMPLETE: "COMPLETE";
+            INCOMPLETE: "INCOMPLETE";
+          }>;
+        }, import("zod/v4/core").$strict>>;
+        observationManifestDigest: import("zod").ZodString;
+        batchManifestBaseline: import("zod").ZodObject<{
+          observedAt: import("zod").ZodString;
+          rootManifestDigest: import("zod").ZodString;
+          runtimeCatalogDigest: import("zod").ZodString;
+          complete: import("zod").ZodBoolean;
+          ownershipCandidates: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            candidateId: import("zod").ZodString;
+            name: import("zod").ZodString;
+            provider: import("zod").ZodString;
+            source: import("zod").ZodString;
+            scope: import("zod").ZodEnum<{
+              PROJECT: "PROJECT";
+              USER: "USER";
+            }>;
+            writable: import("zod").ZodBoolean;
+            targetPathDigest: import("zod").ZodOptional<import("zod").ZodString>;
+            bodyDigest: import("zod").ZodString;
+          }, import("zod/v4/core").$strict>>>;
+        }, import("zod/v4/core").$strict>;
+        manifestEndObservation: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+          state: import("zod").ZodLiteral<"PENDING">;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+          state: import("zod").ZodLiteral<"OBSERVED">;
+          observedAt: import("zod").ZodString;
+          rootManifestDigest: import("zod").ZodString;
+          runtimeCatalogDigest: import("zod").ZodString;
+          complete: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strict>], "state">;
+        routeSnapshot: import("zod").ZodObject<{
+          provider: import("zod").ZodString;
+          model: import("zod").ZodString;
+          policyVersion: import("zod").ZodString;
+          maxInputBytes: import("zod").ZodNumber;
+          maxOutputBytes: import("zod").ZodNumber;
+          failureCode: import("zod").ZodOptional<import("zod").ZodLiteral<"ROUTE_UNAVAILABLE">>;
+        }, import("zod/v4/core").$strict>;
+        detector: import("zod").ZodObject<{
+          result: import("zod").ZodEnum<{
+            NEEDS_ATTENTION: "NEEDS_ATTENTION";
+            READY: "READY";
+            NOT_RUN: "NOT_RUN";
+            NONE: "NONE";
+            DEFER: "DEFER";
+          }>;
+          failureCode: import("zod").ZodOptional<import("zod").ZodString>;
+          calls: import("zod").ZodArray<import("zod").ZodObject<{
+            stage: import("zod").ZodLiteral<"DETECTION">;
+            callId: import("zod").ZodString;
+            ordinal: import("zod").ZodNumber;
+            inputDigest: import("zod").ZodString;
+            provider: import("zod").ZodString;
+            model: import("zod").ZodString;
+            policyVersion: import("zod").ZodString;
+            outcome: import("zod").ZodEnum<{
+              SUCCEEDED: "SUCCEEDED";
+              FAILED: "FAILED";
+              ABORTED: "ABORTED";
+              TIMED_OUT: "TIMED_OUT";
+              RESERVED: "RESERVED";
+              OUTCOME_UNKNOWN: "OUTCOME_UNKNOWN";
+            }>;
+            outputDigest: import("zod").ZodOptional<import("zod").ZodString>;
+            failureCode: import("zod").ZodOptional<import("zod").ZodString>;
+          }, import("zod/v4/core").$strict>>;
+          carryDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          carry: import("zod").ZodArray<import("zod").ZodObject<{
+            summary: import("zod").ZodString;
+            behaviorSignatureDraft: import("zod").ZodString;
+            evidenceDigests: import("zod").ZodArray<import("zod").ZodString>;
+            remainingBatches: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<0>, import("zod").ZodLiteral<1>, import("zod").ZodLiteral<2>]>;
+          }, import("zod/v4/core").$strict>>;
+          intentIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>;
+        state: import("zod").ZodEnum<{
+          NEEDS_ATTENTION: "NEEDS_ATTENTION";
+          FROZEN: "FROZEN";
+          DETECTION_CLAIMED: "DETECTION_CLAIMED";
+          COMMITTED_NONE: "COMMITTED_NONE";
+          COMMITTED_DEFER: "COMMITTED_DEFER";
+          COMMITTED_READY: "COMMITTED_READY";
+        }>;
+        createdAt: import("zod").ZodString;
+        updatedAt: import("zod").ZodString;
+      }, import("zod/v4/core").$strict>;
+    };
+    readonly experience_intents: {
+      readonly valueSchema: import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodLiteral<1>;
+        revision: import("zod").ZodNumber;
+        intentId: import("zod").ZodString;
+        batchId: import("zod").ZodString;
+        ordinal: import("zod").ZodNumber;
+        sessionLifecycleKey: import("zod").ZodString;
+        detectorPolicyVersion: import("zod").ZodString;
+        persistenceScope: import("zod").ZodEnum<{
+          PROJECT: "PROJECT";
+          USER: "USER";
+        }>;
+        explicitSave: import("zod").ZodBoolean;
+        experienceType: import("zod").ZodEnum<{
+          CORRECTION: "CORRECTION";
+          CONSTRAINT: "CONSTRAINT";
+          WORKFLOW: "WORKFLOW";
+        }>;
+        applicabilitySummary: import("zod").ZodString;
+        keySteps: import("zod").ZodArray<import("zod").ZodString>;
+        prohibitions: import("zod").ZodArray<import("zod").ZodString>;
+        behaviorSignature: import("zod").ZodString;
+        evidenceRefs: import("zod").ZodArray<import("zod").ZodObject<{
+          observationId: import("zod").ZodString;
+          sessionLifecycleKey: import("zod").ZodString;
+          turnEndSeq: import("zod").ZodNumber;
+          evidenceDigest: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>>;
+        evidenceDigests: import("zod").ZodArray<import("zod").ZodString>;
+        completeness: import("zod").ZodObject<{
+          status: import("zod").ZodEnum<{
+            COMPLETE: "COMPLETE";
+            INCOMPLETE: "INCOMPLETE";
+          }>;
+          blockers: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>;
+        quiescence: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+          state: import("zod").ZodLiteral<"WAITING">;
+          batchLastTurnEndSeq: import("zod").ZodNumber;
+          requiredIdleMs: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+          state: import("zod").ZodLiteral<"SATISFIED">;
+          batchLastTurnEndSeq: import("zod").ZodNumber;
+          requiredIdleMs: import("zod").ZodNumber;
+          observedThroughTurnEndSeq: import("zod").ZodNumber;
+          detectedThroughTurnEndSeq: import("zod").ZodNumber;
+          activityRevision: import("zod").ZodString;
+          satisfiedAt: import("zod").ZodString;
+          fenceDigest: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>], "state">;
+        ownership: import("zod").ZodObject<{
+          state: import("zod").ZodEnum<{
+            NOT_STARTED: "NOT_STARTED";
+            ARBITRATING: "ARBITRATING";
+            RESOLVED_BY_AGENT: "RESOLVED_BY_AGENT";
+            NEEDS_CONFIRMATION: "NEEDS_CONFIRMATION";
+            RUN2SKILL_OWNED: "RUN2SKILL_OWNED";
+          }>;
+          claimId: import("zod").ZodOptional<import("zod").ZodString>;
+          claimedIntentRevision: import("zod").ZodOptional<import("zod").ZodNumber>;
+          claimedAt: import("zod").ZodOptional<import("zod").ZodString>;
+          inputDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          evidence: import("zod").ZodOptional<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            status: import("zod").ZodLiteral<"UNAVAILABLE">;
+            reasonCode: import("zod").ZodEnum<{
+              INTENT_INCOMPLETE: "INTENT_INCOMPLETE";
+              BASELINE_INCOMPLETE: "BASELINE_INCOMPLETE";
+              CLAIM_INPUT_UNAVAILABLE: "CLAIM_INPUT_UNAVAILABLE";
+              BASELINE_TIME_INVALID: "BASELINE_TIME_INVALID";
+              OBSERVATION_FAILED: "OBSERVATION_FAILED";
+              OBSERVATION_INVALID: "OBSERVATION_INVALID";
+              OBSERVATION_OUTCOME_UNKNOWN: "OBSERVATION_OUTCOME_UNKNOWN";
+            }>;
+          }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            status: import("zod").ZodLiteral<"OBSERVED">;
+            inputDigest: import("zod").ZodString;
+            observedAfterTurnEndSeq: import("zod").ZodNumber;
+            observedAt: import("zod").ZodString;
+            endManifest: import("zod").ZodObject<{
+              rootManifestDigest: import("zod").ZodString;
+              runtimeCatalogDigest: import("zod").ZodString;
+              complete: import("zod").ZodBoolean;
+            }, import("zod/v4/core").$strict>;
+            catalogComplete: import("zod").ZodBoolean;
+            toolEvidenceComplete: import("zod").ZodBoolean;
+            agentActivity: import("zod").ZodEnum<{
+              NONE: "NONE";
+              WRITE_SUCCEEDED: "WRITE_SUCCEEDED";
+              WRITE_FAILED: "WRITE_FAILED";
+              BODY_GENERATED: "BODY_GENERATED";
+              AMBIGUOUS: "AMBIGUOUS";
+            }>;
+            changedCandidates: import("zod").ZodArray<import("zod").ZodObject<{
+              candidateId: import("zod").ZodString;
+              provider: import("zod").ZodString;
+              source: import("zod").ZodString;
+              scope: import("zod").ZodEnum<{
+                PROJECT: "PROJECT";
+                USER: "USER";
+              }>;
+              writable: import("zod").ZodBoolean;
+              exactReadbackComplete: import("zod").ZodBoolean;
+              bodyDigest: import("zod").ZodOptional<import("zod").ZodString>;
+              writeAttribution: import("zod").ZodEnum<{
+                UNKNOWN: "UNKNOWN";
+                AGENT_WRITE_SUCCEEDED: "AGENT_WRITE_SUCCEEDED";
+                NOT_AGENT: "NOT_AGENT";
+              }>;
+              intentBinding: import("zod").ZodEnum<{
+                UNKNOWN: "UNKNOWN";
+                MATCH: "MATCH";
+                NO_MATCH: "NO_MATCH";
+              }>;
+            }, import("zod/v4/core").$strict>>;
+          }, import("zod/v4/core").$strict>], "status">>;
+          evidenceDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          receiptDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          reasonCode: import("zod").ZodOptional<import("zod").ZodString>;
+          resolvedCandidateId: import("zod").ZodOptional<import("zod").ZodString>;
+          resolvedCandidateBodyDigest: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>;
+        recall: import("zod").ZodObject<{
+          state: import("zod").ZodEnum<{
+            COMPLETE: "COMPLETE";
+            INCOMPLETE: "INCOMPLETE";
+            NOT_STARTED: "NOT_STARTED";
+            SCANNING: "SCANNING";
+          }>;
+          runtimeCatalogDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          pendingCatalogDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          complete: import("zod").ZodBoolean;
+          summaryScanComplete: import("zod").ZodBoolean;
+          catalogEpoch: import("zod").ZodOptional<import("zod").ZodNumber>;
+          catalogMutationReceiptDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          scanBasisRevision: import("zod").ZodOptional<import("zod").ZodNumber>;
+          scanRouteProvider: import("zod").ZodOptional<import("zod").ZodString>;
+          scanRouteModel: import("zod").ZodOptional<import("zod").ZodString>;
+          scanPolicyVersion: import("zod").ZodOptional<import("zod").ZodString>;
+          scanBindingDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          scanPlanDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          scanPageCount: import("zod").ZodOptional<import("zod").ZodNumber>;
+          scanSummaryCount: import("zod").ZodOptional<import("zod").ZodNumber>;
+          scanPages: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            ordinal: import("zod").ZodNumber;
+            itemCount: import("zod").ZodNumber;
+            inputDigest: import("zod").ZodString;
+            membershipDigest: import("zod").ZodString;
+          }, import("zod/v4/core").$strict>>>;
+          summaryClassifications: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            candidateId: import("zod").ZodString;
+            summaryDigest: import("zod").ZodString;
+            classification: import("zod").ZodEnum<{
+              RELEVANT: "RELEVANT";
+              POSSIBLE: "POSSIBLE";
+              UNRELATED: "UNRELATED";
+            }>;
+            pageOrdinal: import("zod").ZodNumber;
+            callId: import("zod").ZodString;
+            inputDigest: import("zod").ZodString;
+            outputDigest: import("zod").ZodString;
+          }, import("zod/v4/core").$strict>>>;
+          incompleteReason: import("zod").ZodOptional<import("zod").ZodString>;
+          selfExclusion: import("zod").ZodOptional<import("zod").ZodObject<{
+            intentId: import("zod").ZodString;
+            priorGenerationRevision: import("zod").ZodNumber;
+            barrierReceiptDigest: import("zod").ZodString;
+            selfExclusionDigest: import("zod").ZodString;
+          }, import("zod/v4/core").$strict>>;
+          candidates: import("zod").ZodArray<import("zod").ZodObject<{
+            candidateId: import("zod").ZodString;
+            summary: import("zod").ZodObject<{
+              name: import("zod").ZodString;
+              description: import("zod").ZodString;
+              whenToUse: import("zod").ZodOptional<import("zod").ZodString>;
+              provider: import("zod").ZodString;
+              source: import("zod").ZodString;
+              scope: import("zod").ZodEnum<{
+                PROJECT: "PROJECT";
+                USER: "USER";
+              }>;
+              writable: import("zod").ZodBoolean;
+            }, import("zod/v4/core").$strict>;
+            classification: import("zod").ZodEnum<{
+              RELEVANT: "RELEVANT";
+              POSSIBLE: "POSSIBLE";
+              UNRELATED: "UNRELATED";
+            }>;
+            capability: import("zod").ZodEnum<{
+              UNAVAILABLE: "UNAVAILABLE";
+              AVAILABLE: "AVAILABLE";
+              READABLE_NOT_MERGEABLE: "READABLE_NOT_MERGEABLE";
+            }>;
+            bodyDigest: import("zod").ZodOptional<import("zod").ZodString>;
+            unavailableReason: import("zod").ZodOptional<import("zod").ZodEnum<{
+              CATALOG_INCOMPLETE: "CATALOG_INCOMPLETE";
+              CANDIDATE_DISAPPEARED: "CANDIDATE_DISAPPEARED";
+              IDENTITY_CHANGED: "IDENTITY_CHANGED";
+              READ_FAILED: "READ_FAILED";
+              FILTERED_UNSAFE: "FILTERED_UNSAFE";
+              INPUT_BUDGET_EXCEEDED: "INPUT_BUDGET_EXCEEDED";
+              READ_TIMEOUT: "READ_TIMEOUT";
+              SNAPSHOT_TIMEOUT: "SNAPSHOT_TIMEOUT";
+            }>>;
+          }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>;
+        coverage: import("zod").ZodObject<{
+          state: import("zod").ZodEnum<{
+            ANALYZING: "ANALYZING";
+            NEEDS_ATTENTION: "NEEDS_ATTENTION";
+            CREATE: "CREATE";
+            MERGE: "MERGE";
+            NOT_STARTED: "NOT_STARTED";
+            COVERED: "COVERED";
+          }>;
+          retryUsed: import("zod").ZodBoolean;
+          inputDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          targetDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          targetCandidateId: import("zod").ZodOptional<import("zod").ZodString>;
+          basisRevision: import("zod").ZodOptional<import("zod").ZodNumber>;
+          routeProvider: import("zod").ZodOptional<import("zod").ZodString>;
+          routeModel: import("zod").ZodOptional<import("zod").ZodString>;
+          routeMaxInputBytes: import("zod").ZodOptional<import("zod").ZodNumber>;
+          routeMaxOutputBytes: import("zod").ZodOptional<import("zod").ZodNumber>;
+          reserveBytes: import("zod").ZodOptional<import("zod").ZodNumber>;
+          mergeOutputReserveBytes: import("zod").ZodOptional<import("zod").ZodNumber>;
+          policyVersion: import("zod").ZodOptional<import("zod").ZodString>;
+          bindingDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          planDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          pages: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            ordinal: import("zod").ZodNumber;
+            itemCount: import("zod").ZodNumber;
+            inputDigest: import("zod").ZodString;
+            membershipDigest: import("zod").ZodString;
+          }, import("zod/v4/core").$strict>>>;
+          candidateBindings: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            ordinal: import("zod").ZodNumber;
+            candidateId: import("zod").ZodString;
+            bodyDigest: import("zod").ZodString;
+            bodyBytes: import("zod").ZodNumber;
+            pageOrdinal: import("zod").ZodNumber;
+          }, import("zod/v4/core").$strict>>>;
+          decisions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            candidateId: import("zod").ZodString;
+            decision: import("zod").ZodEnum<{
+              AMBIGUOUS: "AMBIGUOUS";
+              UNRELATED: "UNRELATED";
+              COVERED: "COVERED";
+              PARTIAL: "PARTIAL";
+            }>;
+            reason: import("zod").ZodString;
+            pageOrdinal: import("zod").ZodNumber;
+            callId: import("zod").ZodString;
+            inputDigest: import("zod").ZodString;
+            outputDigest: import("zod").ZodString;
+          }, import("zod/v4/core").$strict>>>;
+          reasonCode: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>;
+        generation: import("zod").ZodObject<{
+          state: import("zod").ZodEnum<{
+            NEEDS_ATTENTION: "NEEDS_ATTENTION";
+            NOT_STARTED: "NOT_STARTED";
+            RESULT_COMMITTED: "RESULT_COMMITTED";
+            PROPOSAL_COMMIT_AUTHORIZED: "PROPOSAL_COMMIT_AUTHORIZED";
+            GENERATION_AUTHORIZED: "GENERATION_AUTHORIZED";
+            GENERATION_LEASED: "GENERATION_LEASED";
+            GENERATION_CALL_RESERVED: "GENERATION_CALL_RESERVED";
+            GENERATION_CALL_TERMINAL: "GENERATION_CALL_TERMINAL";
+            PROPOSAL_BODY_COMMITTED: "PROPOSAL_BODY_COMMITTED";
+            PROPOSAL_READY: "PROPOSAL_READY";
+          }>;
+          action: import("zod").ZodOptional<import("zod").ZodEnum<{
+            CREATE: "CREATE";
+            MERGE: "MERGE";
+          }>>;
+          inputDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          resultDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          leaseId: import("zod").ZodOptional<import("zod").ZodString>;
+          generationRevision: import("zod").ZodOptional<import("zod").ZodNumber>;
+          catalogEpoch: import("zod").ZodOptional<import("zod").ZodNumber>;
+          externalPendingDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          selfExclusionDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          sealedResult: import("zod").ZodOptional<import("zod").ZodObject<{
+            resultId: import("zod").ZodString;
+            leaseId: import("zod").ZodString;
+            intentId: import("zod").ZodString;
+            generationRevision: import("zod").ZodNumber;
+            callId: import("zod").ZodString;
+            action: import("zod").ZodEnum<{
+              CREATE: "CREATE";
+              MERGE: "MERGE";
+            }>;
+            body: import("zod").ZodObject<{
+              name: import("zod").ZodString;
+              description: import("zod").ZodString;
+              whenToUse: import("zod").ZodString;
+              exactSkillBytes: import("zod").ZodString;
+              skillBytesDigest: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            targetDigest: import("zod").ZodString;
+            baseSkillBytesDigest: import("zod").ZodOptional<import("zod").ZodString>;
+            inputDigest: import("zod").ZodString;
+            runtimeCatalogDigest: import("zod").ZodString;
+            pendingCatalogDigest: import("zod").ZodString;
+            externalPendingDigest: import("zod").ZodString;
+            inputCatalogEpoch: import("zod").ZodNumber;
+            outcomeCatalogEpoch: import("zod").ZodNumber;
+            sealedAt: import("zod").ZodString;
+            mutationReceiptDigest: import("zod").ZodString;
+            receiptDigest: import("zod").ZodString;
+          }, import("zod/v4/core").$strict>>;
+          proposalId: import("zod").ZodOptional<import("zod").ZodString>;
+          reasonCode: import("zod").ZodOptional<import("zod").ZodEnum<{
+            GENERATION_KNOWN_FAILED: "GENERATION_KNOWN_FAILED";
+            GENERATION_RESULT_LOST: "GENERATION_RESULT_LOST";
+            GENERATION_OUTCOME_UNKNOWN: "GENERATION_OUTCOME_UNKNOWN";
+            STALE_RESULT: "STALE_RESULT";
+          }>>;
+          revalidationAuthorization: import("zod").ZodOptional<import("zod").ZodObject<{
+            runtimeCatalogDigest: import("zod").ZodString;
+            pendingCatalogDigest: import("zod").ZodString;
+            externalPendingDigest: import("zod").ZodString;
+            catalogEpoch: import("zod").ZodNumber;
+            catalogMutationReceiptDigest: import("zod").ZodString;
+            sealedResultReceiptDigest: import("zod").ZodString;
+            selfExclusionDigest: import("zod").ZodOptional<import("zod").ZodString>;
+            authorizedAt: import("zod").ZodString;
+          }, import("zod/v4/core").$strict>>;
+          userRetryUsed: import("zod").ZodBoolean;
+          staleRefreshUsed: import("zod").ZodBoolean;
+          receipts: import("zod").ZodArray<import("zod").ZodObject<{
+            kind: import("zod").ZodEnum<{
+              CALL_RESERVED: "CALL_RESERVED";
+              LEASE_ACQUIRED: "LEASE_ACQUIRED";
+              CALL_TERMINAL: "CALL_TERMINAL";
+              RESULT_SEALED: "RESULT_SEALED";
+              BARRIER_COMMITTED: "BARRIER_COMMITTED";
+              PROPOSAL_AUTHORIZED: "PROPOSAL_AUTHORIZED";
+              BODY_COMMITTED: "BODY_COMMITTED";
+              INDEX_COMMITTED: "INDEX_COMMITTED";
+            }>;
+            digest: import("zod").ZodString;
+            leaseId: import("zod").ZodString;
+            intentId: import("zod").ZodString;
+            generationRevision: import("zod").ZodNumber;
+            callId: import("zod").ZodOptional<import("zod").ZodString>;
+            catalogEpoch: import("zod").ZodOptional<import("zod").ZodNumber>;
+            recordedAt: import("zod").ZodString;
+          }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>;
+        duplicateBarrier: import("zod").ZodOptional<import("zod").ZodObject<{
+          barrierId: import("zod").ZodString;
+          leaseId: import("zod").ZodString;
+          intentId: import("zod").ZodString;
+          generationRevision: import("zod").ZodNumber;
+          kind: import("zod").ZodEnum<{
+            KNOWN_FAILED: "KNOWN_FAILED";
+            OUTCOME_UNKNOWN: "OUTCOME_UNKNOWN";
+            STALE_RESULT: "STALE_RESULT";
+            RESULT_LOST: "RESULT_LOST";
+          }>;
+          behaviorSignature: import("zod").ZodString;
+          inputDigest: import("zod").ZodString;
+          callId: import("zod").ZodOptional<import("zod").ZodString>;
+          priorGenerationRevision: import("zod").ZodOptional<import("zod").ZodNumber>;
+          inputCatalogEpoch: import("zod").ZodNumber;
+          outcomeCatalogEpoch: import("zod").ZodNumber;
+          mutationReceiptDigest: import("zod").ZodString;
+          recordedAt: import("zod").ZodString;
+          receiptDigest: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>>;
+        stageCalls: import("zod").ZodArray<import("zod").ZodObject<{
+          stage: import("zod").ZodEnum<{
+            CATALOG_SCAN: "CATALOG_SCAN";
+            COVERAGE: "COVERAGE";
+            GENERATION: "GENERATION";
+          }>;
+          intentRevision: import("zod").ZodNumber;
+          callId: import("zod").ZodString;
+          ordinal: import("zod").ZodNumber;
+          itemCount: import("zod").ZodOptional<import("zod").ZodNumber>;
+          inputDigest: import("zod").ZodString;
+          provider: import("zod").ZodString;
+          model: import("zod").ZodString;
+          policyVersion: import("zod").ZodString;
+          outcome: import("zod").ZodEnum<{
+            SUCCEEDED: "SUCCEEDED";
+            FAILED: "FAILED";
+            ABORTED: "ABORTED";
+            TIMED_OUT: "TIMED_OUT";
+            RESERVED: "RESERVED";
+            OUTCOME_UNKNOWN: "OUTCOME_UNKNOWN";
+          }>;
+          outputDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          failureCode: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>>;
+        reasonReceipts: import("zod").ZodArray<import("zod").ZodObject<{
+          revision: import("zod").ZodNumber;
+          reasonCode: import("zod").ZodString;
+          recordedAt: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>>;
+        lineageId: import("zod").ZodOptional<import("zod").ZodString>;
+        status: import("zod").ZodEnum<{
+          NEEDS_ATTENTION: "NEEDS_ATTENTION";
+          DISCARDED: "DISCARDED";
+          READY: "READY";
+          RESOLVED_BY_AGENT: "RESOLVED_BY_AGENT";
+          NEEDS_CONFIRMATION: "NEEDS_CONFIRMATION";
+          RUN2SKILL_OWNED: "RUN2SKILL_OWNED";
+          COVERED: "COVERED";
+          PROPOSAL_READY: "PROPOSAL_READY";
+          DETECTOR_STAGED: "DETECTOR_STAGED";
+          WAITING_FOR_QUIESCENCE: "WAITING_FOR_QUIESCENCE";
+          OWNERSHIP_ARBITRATING: "OWNERSHIP_ARBITRATING";
+          RECALLING: "RECALLING";
+          COVERAGE_READY: "COVERAGE_READY";
+          COVERAGE_ANALYZING: "COVERAGE_ANALYZING";
+          COVERED_NEEDS_CONFIRMATION: "COVERED_NEEDS_CONFIRMATION";
+          COVERAGE_RETRY_AUTHORIZED: "COVERAGE_RETRY_AUTHORIZED";
+          CREATE_AUTHORIZED: "CREATE_AUTHORIZED";
+          MERGE_AUTHORIZED: "MERGE_AUTHORIZED";
+          GENERATING: "GENERATING";
+        }>;
+        createdAt: import("zod").ZodString;
+        updatedAt: import("zod").ZodString;
+      }, import("zod/v4/core").$strict>;
+    };
+    readonly proposal_lineages: {
+      readonly valueSchema: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodLiteral<1>;
+        revision: import("zod").ZodNumber;
+        lineageId: import("zod").ZodString;
+        persistenceScope: import("zod").ZodEnum<{
+          PROJECT: "PROJECT";
+          USER: "USER";
+        }>;
+        origin: import("zod").ZodLiteral<"LEGACY_V1">;
+        state: import("zod").ZodLiteral<"PUBLISHED">;
+        sourceDigest: import("zod").ZodString;
+        importedAt: import("zod").ZodString;
+        updatedAt: import("zod").ZodString;
+        legacySnapshot: import("zod").ZodObject<{
+          schemaVersion: import("zod").ZodLiteral<1>;
+          scope: import("zod").ZodEnum<{
+            PROJECT: "PROJECT";
+            USER: "USER";
+          }>;
+          provider: import("zod").ZodString;
+          source: import("zod").ZodEnum<{
+            "project-dsh": "project-dsh";
+            "user-dsh": "user-dsh";
+          }>;
+          skillName: import("zod").ZodString;
+          canonicalTargetPath: import("zod").ZodString;
+          targetIdentityDigest: import("zod").ZodString;
+          currentRevision: import("zod").ZodNumber;
+          revisions: import("zod").ZodArray<import("zod").ZodObject<{
+            revision: import("zod").ZodNumber;
+            origin: import("zod").ZodEnum<{
+              ADOPTED_BASE: "ADOPTED_BASE";
+              MANUAL_BASE: "MANUAL_BASE";
+              RUN2SKILL: "RUN2SKILL";
+            }>;
+            proposalId: import("zod").ZodOptional<import("zod").ZodString>;
+            exactSkillBytes: import("zod").ZodString;
+            skillBytesDigest: import("zod").ZodString;
+            committedAt: import("zod").ZodString;
+          }, import("zod/v4/core").$strict>>;
+          lineageId: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>;
+      }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodLiteral<1>;
+        revision: import("zod").ZodNumber;
+        lineageId: import("zod").ZodString;
+        persistenceScope: import("zod").ZodEnum<{
+          PROJECT: "PROJECT";
+          USER: "USER";
+        }>;
+        origin: import("zod").ZodLiteral<"RUN2SKILL_V2">;
+        state: import("zod").ZodEnum<{
+          TERMINAL: "TERMINAL";
+          PUBLISHED: "PUBLISHED";
+          RESERVED: "RESERVED";
+          ACTIVE_PROPOSAL: "ACTIVE_PROPOSAL";
+        }>;
+        behaviorSignature: import("zod").ZodString;
+        ownerIntentId: import("zod").ZodString;
+        ownerIntentRevision: import("zod").ZodNumber;
+        currentProposalRevision: import("zod").ZodNumber;
+        proposalRevisions: import("zod").ZodArray<import("zod").ZodObject<{
+          revision: import("zod").ZodNumber;
+          proposalId: import("zod").ZodString;
+          ownerIntentId: import("zod").ZodString;
+          ownerIntentRevision: import("zod").ZodNumber;
+          action: import("zod").ZodEnum<{
+            CREATE: "CREATE";
+            MERGE: "MERGE";
+          }>;
+          body: import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            description: import("zod").ZodString;
+            whenToUse: import("zod").ZodString;
+            exactSkillBytes: import("zod").ZodString;
+            skillBytesDigest: import("zod").ZodString;
+          }, import("zod/v4/core").$strict>;
+          runtimeCatalogDigest: import("zod").ZodString;
+          pendingCatalogDigest: import("zod").ZodString;
+          generationResultReceiptDigest: import("zod").ZodString;
+          catalogMutationReceiptDigest: import("zod").ZodString;
+          catalogEpoch: import("zod").ZodNumber;
+          targetIdentityDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          baseSkillBytesDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          projectScopeBinding: import("zod").ZodOptional<import("zod").ZodObject<{
+            workspaceId: import("zod").ZodString;
+            scopeIdentityDigest: import("zod").ZodString;
+          }, import("zod/v4/core").$strict>>;
+          state: import("zod").ZodEnum<{
+            TERMINAL: "TERMINAL";
+            PUBLISHED: "PUBLISHED";
+            ACTIVE_PROPOSAL: "ACTIVE_PROPOSAL";
+          }>;
+          reviewDecision: import("zod").ZodOptional<import("zod").ZodEnum<{
+            APPROVED: "APPROVED";
+            REJECTED: "REJECTED";
+          }>>;
+          reviewedAt: import("zod").ZodOptional<import("zod").ZodString>;
+          reviewReceiptDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          reviewCatalog: import("zod").ZodOptional<import("zod").ZodObject<{
+            status: import("zod").ZodLiteral<"CURRENT">;
+            runtimeCatalogDigest: import("zod").ZodString;
+            pendingCatalogDigest: import("zod").ZodString;
+            catalogEpoch: import("zod").ZodNumber;
+            catalogMutationReceiptDigest: import("zod").ZodString;
+          }, import("zod/v4/core").$strict>>;
+          reviewFailureCode: import("zod").ZodOptional<import("zod").ZodEnum<{
+            CATALOG_CHANGED: "CATALOG_CHANGED";
+            CATALOG_UNAVAILABLE: "CATALOG_UNAVAILABLE";
+          }>>;
+          reviewAttemptedAt: import("zod").ZodOptional<import("zod").ZodString>;
+          publicationFailureCode: import("zod").ZodOptional<import("zod").ZodEnum<{
+            CATALOG_CHANGED: "CATALOG_CHANGED";
+            PUBLICATION_CONFLICT: "PUBLICATION_CONFLICT";
+            CATALOG_UNAVAILABLE: "CATALOG_UNAVAILABLE";
+            PUBLICATION_UNAVAILABLE: "PUBLICATION_UNAVAILABLE";
+          }>>;
+          publicationAttemptedAt: import("zod").ZodOptional<import("zod").ZodString>;
+          publicationExternalReceiptDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          publishedAt: import("zod").ZodOptional<import("zod").ZodString>;
+          publicationReceiptDigest: import("zod").ZodOptional<import("zod").ZodString>;
+          createdAt: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>>;
+        createdAt: import("zod").ZodString;
+        updatedAt: import("zod").ZodString;
+      }, import("zod/v4/core").$strict>]>;
+    };
+    readonly legacy_items: {
+      readonly valueSchema: import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodLiteral<1>;
+        legacyItemId: import("zod").ZodString;
+        sourceWorkItemId: import("zod").ZodString;
+        sourceDigest: import("zod").ZodString;
+        disposition: import("zod").ZodEnum<{
+          AUDIT_ONLY_NO_SIGNAL: "AUDIT_ONLY_NO_SIGNAL";
+          LEGACY_NEEDS_ATTENTION: "LEGACY_NEEDS_ATTENTION";
+          LEGACY_CALL_OUTCOME_UNKNOWN: "LEGACY_CALL_OUTCOME_UNKNOWN";
+          ACTIVE_LEGACY_PROPOSAL: "ACTIVE_LEGACY_PROPOSAL";
+          ACTIVE_LEGACY_PUBLICATION: "ACTIVE_LEGACY_PUBLICATION";
+          AUDIT_ONLY_DISCARDED: "AUDIT_ONLY_DISCARDED";
+          AUDIT_ONLY_PUBLISHED: "AUDIT_ONLY_PUBLISHED";
+        }>;
+        importedAt: import("zod").ZodString;
+        sourceWorkItem: import("zod").ZodObject<{
+          schemaVersion: import("zod").ZodLiteral<1>;
+          revision: import("zod").ZodNumber;
+          workItemId: import("zod").ZodString;
+          signalKey: import("zod").ZodObject<{
+            rootSessionId: import("zod").ZodString;
+            sessionCreatedAt: import("zod").ZodNumber;
+            sessionCwdDigest: import("zod").ZodString;
+            turn: import("zod").ZodNumber;
+            turnEndSeq: import("zod").ZodNumber;
+            turnInstanceDigest: import("zod").ZodString;
+            triggerPolicyVersion: import("zod").ZodLiteral<"cheap-trigger-v1">;
+          }, import("zod/v4/core").$strict>;
+          captureReason: import("zod").ZodEnum<{
+            CHEAP_TRIGGER: "CHEAP_TRIGGER";
+            SCAN_INCOMPLETE: "SCAN_INCOMPLETE";
+          }>;
+          createdAt: import("zod").ZodString;
+          updatedAt: import("zod").ZodString;
+          turnOutcomeKind: import("zod").ZodString;
+          rootIdentity: import("zod").ZodObject<{
+            status: import("zod").ZodLiteral<"ROOT">;
+            parentSessionId: import("zod").ZodOptional<import("zod").ZodString>;
+          }, import("zod/v4/core").$strict>;
+          workspaceBinding: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            status: import("zod").ZodLiteral<"BOUND">;
+            workspaceId: import("zod").ZodString;
+            canonicalPath: import("zod").ZodString;
+            observedAt: import("zod").ZodString;
+          }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            status: import("zod").ZodEnum<{
+              NO_CWD: "NO_CWD";
+              UNREGISTERED: "UNREGISTERED";
+              UNAVAILABLE: "UNAVAILABLE";
+            }>;
+            observedAt: import("zod").ZodString;
+          }, import("zod/v4/core").$strict>], "status">;
+          scanStatus: import("zod").ZodEnum<{
+            COMPLETE: "COMPLETE";
+            INCOMPLETE: "INCOMPLETE";
+          }>;
+          triggerHits: import("zod").ZodArray<import("zod").ZodObject<{
+            kind: import("zod").ZodEnum<{
+              EXPLICIT_SAVE: "EXPLICIT_SAVE";
+              CORRECTION: "CORRECTION";
+              CONSTRAINT: "CONSTRAINT";
+              WORKFLOW: "WORKFLOW";
+            }>;
+            messageSeq: import("zod").ZodNumber;
+            ruleId: import("zod").ZodString;
+            confidence: import("zod").ZodLiteral<"HIGH">;
+          }, import("zod/v4/core").$strict>>;
+          evidenceRefs: import("zod").ZodArray<import("zod").ZodObject<{
+            source: import("zod").ZodLiteral<"USER_DIRECT">;
+            messageSeq: import("zod").ZodNumber;
+            excerpt: import("zod").ZodString;
+            excerptDigest: import("zod").ZodString;
+            redactionKinds: import("zod").ZodArray<import("zod").ZodEnum<{
+              PRIVATE_KEY: "PRIVATE_KEY";
+              AUTHORIZATION: "AUTHORIZATION";
+              BEARER_TOKEN: "BEARER_TOKEN";
+              API_KEY: "API_KEY";
+              SECRET_ASSIGNMENT: "SECRET_ASSIGNMENT";
+              URL_CREDENTIAL: "URL_CREDENTIAL";
+            }>>;
+            truncated: import("zod").ZodBoolean;
+          }, import("zod/v4/core").$strict>>;
+          captureBlockers: import("zod").ZodArray<import("zod").ZodEnum<{
+            TURN_BOUNDARY_INCOMPLETE: "TURN_BOUNDARY_INCOMPLETE";
+            TEXT_LIMIT_EXCEEDED: "TEXT_LIMIT_EXCEEDED";
+            REDACTION_UNAVAILABLE: "REDACTION_UNAVAILABLE";
+          }>>;
+          processingState: import("zod").ZodEnum<{
+            CAPTURED: "CAPTURED";
+            ANALYZING: "ANALYZING";
+            LEARNED: "LEARNED";
+            READY_FOR_REVIEW: "READY_FOR_REVIEW";
+            PUBLISHING: "PUBLISHING";
+            TERMINAL: "TERMINAL";
+            NEEDS_ATTENTION: "NEEDS_ATTENTION";
+            RESOLVED_NO_SIGNAL: "RESOLVED_NO_SIGNAL";
+          }>;
+          learning: import("zod").ZodOptional<import("zod").ZodObject<{
+            policyVersion: import("zod").ZodLiteral<"learning-v1">;
+            attempt: import("zod").ZodNumber;
+            requestBudgetUsed: import("zod").ZodNumber;
+            claimedAt: import("zod").ZodOptional<import("zod").ZodString>;
+            nextEligibleAt: import("zod").ZodOptional<import("zod").ZodString>;
+            modelRoute: import("zod").ZodOptional<import("zod").ZodObject<{
+              provider: import("zod").ZodString;
+              model: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+            calls: import("zod").ZodArray<import("zod").ZodObject<{
+              requestOrdinal: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<1>, import("zod").ZodLiteral<2>]>;
+              kind: import("zod").ZodEnum<{
+                PRIMARY: "PRIMARY";
+                FORMAT_REPAIR: "FORMAT_REPAIR";
+              }>;
+              inputTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
+              outputTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
+              outcome: import("zod").ZodEnum<{
+                SUCCEEDED: "SUCCEEDED";
+                FAILED: "FAILED";
+                ABORTED: "ABORTED";
+                TIMED_OUT: "TIMED_OUT";
+              }>;
+            }, import("zod/v4/core").$strict>>;
+            failure: import("zod").ZodOptional<import("zod").ZodObject<{
+              code: import("zod").ZodEnum<{
+                SESSION_LOG_UNAVAILABLE: "SESSION_LOG_UNAVAILABLE";
+                AGENT_SCOPE_UNAVAILABLE: "AGENT_SCOPE_UNAVAILABLE";
+                MODEL_ROUTE_UNAVAILABLE: "MODEL_ROUTE_UNAVAILABLE";
+                MODEL_INFO_UNAVAILABLE: "MODEL_INFO_UNAVAILABLE";
+                CATALOG_INCOMPLETE: "CATALOG_INCOMPLETE";
+                CANDIDATE_UNAVAILABLE: "CANDIDATE_UNAVAILABLE";
+                ENVELOPE_UNBUILDABLE: "ENVELOPE_UNBUILDABLE";
+                MODEL_TIMEOUT: "MODEL_TIMEOUT";
+                MODEL_ABORTED: "MODEL_ABORTED";
+                MODEL_TERMINAL_FAILURE: "MODEL_TERMINAL_FAILURE";
+                MODEL_OUTPUT_LIMIT_EXCEEDED: "MODEL_OUTPUT_LIMIT_EXCEEDED";
+                INVALID_STRUCTURED_OUTPUT: "INVALID_STRUCTURED_OUTPUT";
+                LEARNING_GUARD_REJECTED: "LEARNING_GUARD_REJECTED";
+                STORE_WRITE_FAILED: "STORE_WRITE_FAILED";
+              }>;
+              retryable: import("zod").ZodBoolean;
+              occurredAt: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+            experiences: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+              experienceId: import("zod").ZodString;
+              type: import("zod").ZodEnum<{
+                CORRECTION: "CORRECTION";
+                CONSTRAINT: "CONSTRAINT";
+                WORKFLOW: "WORKFLOW";
+              }>;
+              lesson: import("zod").ZodString;
+              persistenceScope: import("zod").ZodEnum<{
+                PROJECT: "PROJECT";
+                USER: "USER";
+              }>;
+              evidenceStrength: import("zod").ZodLiteral<"HIGH">;
+              supportingEvidence: import("zod").ZodArray<import("zod").ZodObject<{
+                messageSeq: import("zod").ZodNumber;
+                excerptDigest: import("zod").ZodString;
+              }, import("zod/v4/core").$strict>>;
+              contextSummary: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>>>;
+            proposal: import("zod").ZodOptional<import("zod").ZodObject<{
+              learningProposalId: import("zod").ZodString;
+              policyVersion: import("zod").ZodLiteral<"learning-v1">;
+              name: import("zod").ZodString;
+              description: import("zod").ZodString;
+              whenToUse: import("zod").ZodString;
+              content: import("zod").ZodString;
+              invocation: import("zod").ZodObject<{
+                modelInvocable: import("zod").ZodLiteral<true>;
+                userInvocable: import("zod").ZodLiteral<false>;
+              }, import("zod/v4/core").$strict>;
+              persistenceScope: import("zod").ZodEnum<{
+                PROJECT: "PROJECT";
+                USER: "USER";
+              }>;
+              supportingExperienceIds: import("zod").ZodArray<import("zod").ZodString>;
+              curation: import("zod").ZodObject<{
+                decision: import("zod").ZodEnum<{
+                  CREATE: "CREATE";
+                  MERGE: "MERGE";
+                  DISCARD: "DISCARD";
+                }>;
+                candidateKey: import("zod").ZodOptional<import("zod").ZodString>;
+                rationale: import("zod").ZodString;
+              }, import("zod/v4/core").$strict>;
+              catalogObservationDigest: import("zod").ZodString;
+              shortlistDigests: import("zod").ZodArray<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>>;
+            publicationOutcome: import("zod").ZodOptional<import("zod").ZodLiteral<"NEEDS_ATTENTION">>;
+          }, import("zod/v4/core").$strict>>;
+          review: import("zod").ZodOptional<import("zod").ZodObject<{
+            policyVersion: import("zod").ZodLiteral<"review-v1">;
+            proposal: import("zod").ZodObject<{
+              schemaVersion: import("zod").ZodLiteral<1>;
+              revision: import("zod").ZodNumber;
+              createdAt: import("zod").ZodString;
+              sourceLearningProposalId: import("zod").ZodString;
+              kind: import("zod").ZodEnum<{
+                CREATE: "CREATE";
+                MERGE: "MERGE";
+                DISCARD: "DISCARD";
+              }>;
+              name: import("zod").ZodString;
+              description: import("zod").ZodString;
+              whenToUse: import("zod").ZodString;
+              invocation: import("zod").ZodObject<{
+                modelInvocable: import("zod").ZodLiteral<true>;
+                userInvocable: import("zod").ZodLiteral<false>;
+              }, import("zod/v4/core").$strict>;
+              exactSkillBytes: import("zod").ZodString;
+              skillBytesDigest: import("zod").ZodString;
+              rendererVersion: import("zod").ZodString;
+              persistenceScope: import("zod").ZodEnum<{
+                PROJECT: "PROJECT";
+                USER: "USER";
+              }>;
+              workspaceBinding: import("zod").ZodOptional<import("zod").ZodObject<{
+                workspaceId: import("zod").ZodString;
+                canonicalPath: import("zod").ZodString;
+                observedAt: import("zod").ZodString;
+              }, import("zod/v4/core").$strict>>;
+              dshHomeBinding: import("zod").ZodOptional<import("zod").ZodObject<{
+                resolutionKind: import("zod").ZodEnum<{
+                  CONFIGURATION: "CONFIGURATION";
+                  ENVIRONMENT: "ENVIRONMENT";
+                  DEFAULT: "DEFAULT";
+                }>;
+                canonicalPath: import("zod").ZodString;
+                identityDigest: import("zod").ZodString;
+                observedAt: import("zod").ZodString;
+              }, import("zod/v4/core").$strict>>;
+              supportingExperienceIds: import("zod").ZodArray<import("zod").ZodString>;
+              catalogObservationDigest: import("zod").ZodString;
+              curationRationale: import("zod").ZodString;
+              actionBinding: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"CREATE">;
+                rootBinding: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                  scope: import("zod").ZodEnum<{
+                    PROJECT: "PROJECT";
+                    USER: "USER";
+                  }>;
+                  expectedProvider: import("zod").ZodLiteral<"filesystem">;
+                  expectedSource: import("zod").ZodEnum<{
+                    "project-dsh": "project-dsh";
+                    "user-dsh": "user-dsh";
+                  }>;
+                  resolverVersion: import("zod").ZodLiteral<"stock-root-resolver-v2">;
+                  rootContractVersion: import("zod").ZodLiteral<"stock-dsh-web-default-roots-v1">;
+                  resolutionContractDigest: import("zod").ZodString;
+                  declaredRootPath: import("zod").ZodString;
+                  state: import("zod").ZodLiteral<"EXISTING">;
+                  canonicalRootPath: import("zod").ZodString;
+                  rootIdentityDigest: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                  scope: import("zod").ZodEnum<{
+                    PROJECT: "PROJECT";
+                    USER: "USER";
+                  }>;
+                  expectedProvider: import("zod").ZodLiteral<"filesystem">;
+                  expectedSource: import("zod").ZodEnum<{
+                    "project-dsh": "project-dsh";
+                    "user-dsh": "user-dsh";
+                  }>;
+                  resolverVersion: import("zod").ZodLiteral<"stock-root-resolver-v2">;
+                  rootContractVersion: import("zod").ZodLiteral<"stock-dsh-web-default-roots-v1">;
+                  resolutionContractDigest: import("zod").ZodString;
+                  declaredRootPath: import("zod").ZodString;
+                  state: import("zod").ZodLiteral<"ABSENT">;
+                  canonicalExistingAncestorPath: import("zod").ZodString;
+                  ancestorIdentityDigest: import("zod").ZodString;
+                  missingSegments: import("zod").ZodArray<import("zod").ZodString>;
+                }, import("zod/v4/core").$strict>], "state">;
+                targetBinding: import("zod").ZodObject<{
+                  skillName: import("zod").ZodString;
+                  bundlePath: import("zod").ZodString;
+                  skillFilePath: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+                expectedAbsence: import("zod").ZodObject<{
+                  catalogObservationDigest: import("zod").ZodString;
+                  observedAt: import("zod").ZodString;
+                  flatSkillFilePath: import("zod").ZodString;
+                  bundlePathAbsent: import("zod").ZodLiteral<true>;
+                  skillFilePathAbsent: import("zod").ZodLiteral<true>;
+                  flatSkillFilePathAbsent: import("zod").ZodLiteral<true>;
+                }, import("zod/v4/core").$strict>;
+              }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"MERGE">;
+                rootBinding: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                  scope: import("zod").ZodEnum<{
+                    PROJECT: "PROJECT";
+                    USER: "USER";
+                  }>;
+                  expectedProvider: import("zod").ZodLiteral<"filesystem">;
+                  expectedSource: import("zod").ZodEnum<{
+                    "project-dsh": "project-dsh";
+                    "user-dsh": "user-dsh";
+                  }>;
+                  resolverVersion: import("zod").ZodLiteral<"stock-root-resolver-v2">;
+                  rootContractVersion: import("zod").ZodLiteral<"stock-dsh-web-default-roots-v1">;
+                  resolutionContractDigest: import("zod").ZodString;
+                  declaredRootPath: import("zod").ZodString;
+                  state: import("zod").ZodLiteral<"EXISTING">;
+                  canonicalRootPath: import("zod").ZodString;
+                  rootIdentityDigest: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                  scope: import("zod").ZodEnum<{
+                    PROJECT: "PROJECT";
+                    USER: "USER";
+                  }>;
+                  expectedProvider: import("zod").ZodLiteral<"filesystem">;
+                  expectedSource: import("zod").ZodEnum<{
+                    "project-dsh": "project-dsh";
+                    "user-dsh": "user-dsh";
+                  }>;
+                  resolverVersion: import("zod").ZodLiteral<"stock-root-resolver-v2">;
+                  rootContractVersion: import("zod").ZodLiteral<"stock-dsh-web-default-roots-v1">;
+                  resolutionContractDigest: import("zod").ZodString;
+                  declaredRootPath: import("zod").ZodString;
+                  state: import("zod").ZodLiteral<"ABSENT">;
+                  canonicalExistingAncestorPath: import("zod").ZodString;
+                  ancestorIdentityDigest: import("zod").ZodString;
+                  missingSegments: import("zod").ZodArray<import("zod").ZodString>;
+                }, import("zod/v4/core").$strict>], "state">;
+                targetBinding: import("zod").ZodObject<{
+                  skillName: import("zod").ZodString;
+                  bundlePath: import("zod").ZodString;
+                  skillFilePath: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+                baseBinding: import("zod").ZodObject<{
+                  candidateKey: import("zod").ZodString;
+                  provider: import("zod").ZodString;
+                  source: import("zod").ZodString;
+                  path: import("zod").ZodString;
+                  exactBytes: import("zod").ZodString;
+                  bytesDigest: import("zod").ZodString;
+                  catalogObservationDigest: import("zod").ZodString;
+                  observedAt: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+              }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"DISCARD">;
+                coveringCandidateBinding: import("zod").ZodObject<{
+                  candidateKey: import("zod").ZodString;
+                  provider: import("zod").ZodString;
+                  source: import("zod").ZodString;
+                  name: import("zod").ZodString;
+                  description: import("zod").ZodString;
+                  whenToUse: import("zod").ZodOptional<import("zod").ZodString>;
+                  content: import("zod").ZodString;
+                  contentDigest: import("zod").ZodString;
+                  path: import("zod").ZodOptional<import("zod").ZodString>;
+                  catalogObservationDigest: import("zod").ZodString;
+                  observedAt: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+              }, import("zod/v4/core").$strict>], "kind">;
+              proposalId: import("zod").ZodString;
+              digest: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            reviewDecision: import("zod").ZodEnum<{
+              PENDING: "PENDING";
+              APPROVED: "APPROVED";
+              REJECTED: "REJECTED";
+            }>;
+            publicationOutcome: import("zod").ZodEnum<{
+              NEEDS_ATTENTION: "NEEDS_ATTENTION";
+              PENDING_REVIEW: "PENDING_REVIEW";
+              DISCARDED: "DISCARDED";
+              NEEDS_REFRESH: "NEEDS_REFRESH";
+              PUBLISHED: "PUBLISHED";
+              PUBLISH_FAILED: "PUBLISH_FAILED";
+            }>;
+            coverageRetryCount: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<0>, import("zod").ZodLiteral<1>]>;
+            decidedAt: import("zod").ZodOptional<import("zod").ZodString>;
+            decisionReason: import("zod").ZodOptional<import("zod").ZodEnum<{
+              USER_REJECTED: "USER_REJECTED";
+              COVERAGE_CONFIRMED: "COVERAGE_CONFIRMED";
+            }>>;
+            failure: import("zod").ZodOptional<import("zod").ZodObject<{
+              code: import("zod").ZodString;
+              retryable: import("zod").ZodBoolean;
+              occurredAt: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+          }, import("zod/v4/core").$strict>>;
+          publication: import("zod").ZodOptional<import("zod").ZodObject<{
+            schemaVersion: import("zod").ZodLiteral<1>;
+            policyVersion: import("zod").ZodLiteral<"publication-v1">;
+            attemptCount: import("zod").ZodNumber;
+            activeAttemptId: import("zod").ZodString;
+            targetIdentityDigest: import("zod").ZodString;
+            journal: import("zod").ZodArray<import("zod").ZodObject<{
+              schemaVersion: import("zod").ZodLiteral<1>;
+              ordinal: import("zod").ZodNumber;
+              attempt: import("zod").ZodNumber;
+              attemptId: import("zod").ZodString;
+              stage: import("zod").ZodEnum<{
+                APPROVAL_COMMITTED: "APPROVAL_COMMITTED";
+                FACTS_REVALIDATED: "FACTS_REVALIDATED";
+                ROOT_PREPARED: "ROOT_PREPARED";
+                TARGET_INSTALLED: "TARGET_INSTALLED";
+                DISK_VERIFIED: "DISK_VERIFIED";
+                READBACK_CONFIRMED: "READBACK_CONFIRMED";
+                LINEAGE_PENDING: "LINEAGE_PENDING";
+                LINEAGE_COMMITTED: "LINEAGE_COMMITTED";
+                OUTCOME_COMMITTED: "OUTCOME_COMMITTED";
+              }>;
+              targetIdentityDigest: import("zod").ZodString;
+              expectedHash: import("zod").ZodOptional<import("zod").ZodString>;
+              observedHash: import("zod").ZodOptional<import("zod").ZodString>;
+              occurredAt: import("zod").ZodString;
+              previousDigest: import("zod").ZodNullable<import("zod").ZodString>;
+              digest: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+            pendingLineage: import("zod").ZodOptional<import("zod").ZodObject<{
+              schemaVersion: import("zod").ZodLiteral<1>;
+              scope: import("zod").ZodEnum<{
+                PROJECT: "PROJECT";
+                USER: "USER";
+              }>;
+              provider: import("zod").ZodString;
+              source: import("zod").ZodEnum<{
+                "project-dsh": "project-dsh";
+                "user-dsh": "user-dsh";
+              }>;
+              skillName: import("zod").ZodString;
+              canonicalTargetPath: import("zod").ZodString;
+              targetIdentityDigest: import("zod").ZodString;
+              currentRevision: import("zod").ZodNumber;
+              revisions: import("zod").ZodArray<import("zod").ZodObject<{
+                revision: import("zod").ZodNumber;
+                origin: import("zod").ZodEnum<{
+                  ADOPTED_BASE: "ADOPTED_BASE";
+                  MANUAL_BASE: "MANUAL_BASE";
+                  RUN2SKILL: "RUN2SKILL";
+                }>;
+                proposalId: import("zod").ZodOptional<import("zod").ZodString>;
+                exactSkillBytes: import("zod").ZodString;
+                skillBytesDigest: import("zod").ZodString;
+                committedAt: import("zod").ZodString;
+              }, import("zod/v4/core").$strict>>;
+              lineageId: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>;
+          }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>;
+      }, import("zod/v4/core").$strict>;
+    };
+  };
+};
+//#endregion
+//#region src/domain/publication/schemas.d.ts
+declare const PublicationJournalStageV1Schema: z.ZodEnum<{
+  APPROVAL_COMMITTED: "APPROVAL_COMMITTED";
+  FACTS_REVALIDATED: "FACTS_REVALIDATED";
+  ROOT_PREPARED: "ROOT_PREPARED";
+  TARGET_INSTALLED: "TARGET_INSTALLED";
+  DISK_VERIFIED: "DISK_VERIFIED";
+  READBACK_CONFIRMED: "READBACK_CONFIRMED";
+  LINEAGE_PENDING: "LINEAGE_PENDING";
+  LINEAGE_COMMITTED: "LINEAGE_COMMITTED";
+  OUTCOME_COMMITTED: "OUTCOME_COMMITTED";
+}>;
+type PublicationJournalStageV1 = z.infer<typeof PublicationJournalStageV1Schema>;
+declare const LineageV1Schema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  scope: z.ZodEnum<{
+    PROJECT: "PROJECT";
+    USER: "USER";
+  }>;
+  provider: z.ZodString;
+  source: z.ZodEnum<{
+    "project-dsh": "project-dsh";
+    "user-dsh": "user-dsh";
+  }>;
+  skillName: z.ZodString;
+  canonicalTargetPath: z.ZodString;
+  targetIdentityDigest: z.ZodString;
+  currentRevision: z.ZodNumber;
+  revisions: z.ZodArray<z.ZodObject<{
+    revision: z.ZodNumber;
+    origin: z.ZodEnum<{
+      ADOPTED_BASE: "ADOPTED_BASE";
+      MANUAL_BASE: "MANUAL_BASE";
+      RUN2SKILL: "RUN2SKILL";
+    }>;
+    proposalId: z.ZodOptional<z.ZodString>;
+    exactSkillBytes: z.ZodString;
+    skillBytesDigest: z.ZodString;
+    committedAt: z.ZodString;
+  }, z.core.$strict>>;
+  lineageId: z.ZodString;
+}, z.core.$strict>;
+type LineageV1 = z.infer<typeof LineageV1Schema>;
+//#endregion
+//#region src/adapters/dsh-storage/types.d.ts
+interface Run2skillTable<K extends string, V> {
+  get(key: K): V | undefined;
+  entries(): IterableIterator<[K, V]>;
+  keys(): IterableIterator<K>;
+  readonly size: number;
+  put(key: K, value: V): Promise<void>;
+  delete(key: K): Promise<boolean>;
+  update(key: K, transform: (current: V) => V): Promise<V>;
+}
+interface Run2skillDomain {
+  readonly name: 'run2skill_v1';
+  readonly global: {
+    get(): GlobalV1;
+    set(value: GlobalV1): Promise<void>;
+  };
+  table(name: 'work_items'): Run2skillTable<string, CaptureWorkItemV1>;
+  table(name: 'lineages'): Run2skillTable<string, LineageV1>;
+  close(): Promise<void>;
+}
+interface Run2skillStorageContext {
+  readonly storageDomain: {
+    open(spec: typeof run2skillDomainSpec | typeof learningDiagnosticDomainSpec | typeof run2skillV2DomainSpec): Promise<Run2skillDomain | LearningDiagnosticDomain | Run2skillV2Domain>;
+  };
+}
+//#endregion
+//#region src/adapters/dsh-storage/learning-diagnostic-domain.d.ts
+declare const learningDiagnosticDomainSpec: {
+  readonly name: "run2skill_learning_diagnostics_v1";
+  readonly version: 1;
+  readonly tables: {
+    readonly terminal_details: {
+      readonly valueSchema: import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodLiteral<1>;
+        workItemId: import("zod").ZodString;
+        workItemRevision: import("zod").ZodNumber;
+        attempt: import("zod").ZodNumber;
+        requestOrdinal: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<1>, import("zod").ZodLiteral<2>]>;
+        callKind: import("zod").ZodEnum<{
+          PRIMARY: "PRIMARY";
+          FORMAT_REPAIR: "FORMAT_REPAIR";
+        }>;
+        callOutcome: import("zod").ZodEnum<{
+          SUCCEEDED: "SUCCEEDED";
+          FAILED: "FAILED";
+          ABORTED: "ABORTED";
+          TIMED_OUT: "TIMED_OUT";
+        }>;
+        failureCode: import("zod").ZodEnum<{
+          SESSION_LOG_UNAVAILABLE: "SESSION_LOG_UNAVAILABLE";
+          AGENT_SCOPE_UNAVAILABLE: "AGENT_SCOPE_UNAVAILABLE";
+          MODEL_ROUTE_UNAVAILABLE: "MODEL_ROUTE_UNAVAILABLE";
+          MODEL_INFO_UNAVAILABLE: "MODEL_INFO_UNAVAILABLE";
+          CATALOG_INCOMPLETE: "CATALOG_INCOMPLETE";
+          CANDIDATE_UNAVAILABLE: "CANDIDATE_UNAVAILABLE";
+          ENVELOPE_UNBUILDABLE: "ENVELOPE_UNBUILDABLE";
+          MODEL_TIMEOUT: "MODEL_TIMEOUT";
+          MODEL_ABORTED: "MODEL_ABORTED";
+          MODEL_TERMINAL_FAILURE: "MODEL_TERMINAL_FAILURE";
+          MODEL_OUTPUT_LIMIT_EXCEEDED: "MODEL_OUTPUT_LIMIT_EXCEEDED";
+          INVALID_STRUCTURED_OUTPUT: "INVALID_STRUCTURED_OUTPUT";
+          LEARNING_GUARD_REJECTED: "LEARNING_GUARD_REJECTED";
+          STORE_WRITE_FAILED: "STORE_WRITE_FAILED";
+        }>;
+        failureOccurredAt: import("zod").ZodString;
+        detail: import("zod").ZodEnum<{
+          MODEL_STREAM_FAILURE: "MODEL_STREAM_FAILURE";
+          MODEL_FINISH_MISSING: "MODEL_FINISH_MISSING";
+          MODEL_USAGE_INVALID: "MODEL_USAGE_INVALID";
+          MODEL_ASSEMBLY_FAILED: "MODEL_ASSEMBLY_FAILED";
+          MODEL_UNEXPECTED_FINISH: "MODEL_UNEXPECTED_FINISH";
+        }>;
+      }, import("zod/v4/core").$strict>;
+    };
+    readonly health_checks: {
+      readonly valueSchema: import("zod").ZodObject<{
+        schemaVersion: import("zod").ZodLiteral<1>;
+        generation: import("zod").ZodNumber;
+      }, import("zod/v4/core").$strict>;
+    };
+  };
+};
+interface LearningDiagnosticDomain {
+  readonly name: 'run2skill_learning_diagnostics_v1';
+  table(name: 'terminal_details'): Run2skillTable<string, LearningDiagnosticRecordV1>;
+  table(name: 'health_checks'): Run2skillTable<string, LearningDiagnosticHealthV1>;
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/adapters/dsh-storage/learning-diagnostic-store.d.ts
+declare class LearningDiagnosticStore {
+  #private;
+  private readonly main;
+  constructor(main: Run2skillDomain, sidecar: LearningDiagnosticDomain, runMutation?: <T>(operation: () => Promise<T>) => Promise<T>);
+  attach(item: CaptureWorkItemV1, requestOrdinal: 1 | 2, detail: LearningTerminalDetailV1): Promise<{
+    readonly changed: boolean;
+  }>;
+  detailFor(item: CaptureWorkItemV1): LearningTerminalDetailV1 | undefined;
+  deleteWorkItem(workItemId: string): Promise<void>;
+  deleteWorkItemWithinMutation(workItemId: string): Promise<void>;
+  deleteAllWithinMutation(): Promise<void>;
+  cleanupOrphans(): Promise<{
+    readonly deleted: number;
+  }>;
+  verifyReady(): Promise<void>;
+}
+//#endregion
+//#region src/adapters/dsh-session/types.d.ts
+interface DshSessionHeader {
+  readonly version: number;
+  readonly id: string;
+  readonly createdAt: number;
+  readonly cwd?: string;
+  readonly parentSession?: string;
+  readonly origin?: 'subagent';
+  readonly delegationDepth?: number;
+}
+interface DshSessionEvent {
+  readonly type: string;
+  readonly seq: number;
+  readonly time: number;
+  readonly data: unknown;
+  readonly ignorable?: true;
+}
+interface DirectUserCoordinate {
+  readonly messageSeq: number;
+  readonly messageId: string;
+}
+interface TurnIngressCandidate {
+  readonly header: DshSessionHeader;
+  readonly turn: number;
+  readonly turnStartSeq?: number;
+  readonly turnEndSeq: number;
+  readonly directUserMessages: readonly DirectUserCoordinate[];
+}
+interface SessionPersistenceSnapshot {
+  readonly header: DshSessionHeader;
+  readonly revision: string;
+}
+interface SessionPersistencePort {
+  listSnapshots(signal?: AbortSignal): Promise<readonly SessionPersistenceSnapshot[]>;
+  readFrom(sessionId: string, fromSeq: number, signal?: AbortSignal): Promise<{
+    readonly meta: DshSessionHeader;
+    readonly events: readonly DshSessionEvent[];
+  }>;
+}
+//#endregion
+//#region src/adapters/dsh-connection/observe-summary-rpc.d.ts
+type ObserveRpcError = {
+  readonly code: string;
+  readonly message: string;
+  readonly details: Record<string, unknown>;
+};
+type ObserveRpcResult<T> = {
+  readonly ok: true;
+  readonly value: T;
+} | {
+  readonly ok: false;
+  readonly error: ObserveRpcError;
+};
+type ObserveSummaryRpcHandler = (endpoint: string, payload: unknown, signal: AbortSignal) => Promise<ObserveRpcResult<unknown>>;
+interface ObserveSummaryHostConnection {
+  readonly rpc: {
+    handle(channel: string, handler: ObserveSummaryRpcHandler, options: {
+      readonly authority: 'loopback';
+    }): () => Promise<void>;
+  };
+}
+//#endregion
+//#region src/application/automatic-learning-policy.d.ts
+interface AutomaticLearningSnapshot {
+  readonly automaticLearning: boolean;
+}
+interface AutomaticLearningPolicyPort {
+  snapshot(): AutomaticLearningSnapshot;
+}
+//#endregion
+//#region src/domain/purge/schemas.d.ts
+declare const PurgeScopeBindingV1Schema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  scope: z.ZodLiteral<"PROJECT">;
+  workspaceId: z.ZodString;
+  canonicalWorkspacePath: z.ZodString;
+  workspaceObservedAt: z.ZodString;
+  canonicalRootPath: z.ZodString;
+  rootContractVersion: z.ZodLiteral<"stock-dsh-web-default-roots-v1">;
+  resolverVersion: z.ZodLiteral<"stock-root-resolver-v2">;
+  resolutionContractDigest: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  scope: z.ZodLiteral<"USER">;
+}, z.core.$strict>, z.ZodObject<{
+  scope: z.ZodLiteral<"ALL">;
+}, z.core.$strict>], "scope">;
+declare const PurgePhaseV1Schema: z.ZodEnum<{
+  HIDING: "HIDING";
+  DELETING_LINEAGES: "DELETING_LINEAGES";
+  DELETING_WORK_ITEMS: "DELETING_WORK_ITEMS";
+  VERIFYING: "VERIFYING";
+}>;
+declare const PurgeJournalV1Schema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  purgeId: z.ZodString;
+  scopeBinding: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    scope: z.ZodLiteral<"PROJECT">;
     workspaceId: z.ZodString;
     canonicalWorkspacePath: z.ZodString;
     workspaceObservedAt: z.ZodString;
@@ -1482,6 +4764,8 @@ declare const PurgeJournalV1Schema: z.ZodObject<{
     resolutionContractDigest: z.ZodString;
   }, z.core.$strict>, z.ZodObject<{
     scope: z.ZodLiteral<"USER">;
+  }, z.core.$strict>, z.ZodObject<{
+    scope: z.ZodLiteral<"ALL">;
   }, z.core.$strict>], "scope">;
   hideBefore: z.ZodString;
   candidateDigest: z.ZodString;
@@ -1494,23 +4778,61 @@ declare const PurgeJournalV1Schema: z.ZodObject<{
   }>;
   deletedWorkItems: z.ZodNumber;
   deletedLineages: z.ZodNumber;
+  targetWorkItems: z.ZodOptional<z.ZodNumber>;
+  targetLineages: z.ZodOptional<z.ZodNumber>;
   lastError: z.ZodOptional<z.ZodObject<{
     code: z.ZodString;
     occurredAt: z.ZodString;
   }, z.core.$strict>>;
 }, z.core.$strict>;
+type PurgeScopeBindingV1 = z.infer<typeof PurgeScopeBindingV1Schema>;
+type PurgePhaseV1 = z.infer<typeof PurgePhaseV1Schema>;
 type PurgeJournalV1 = z.infer<typeof PurgeJournalV1Schema>;
 //#endregion
+//#region src/domain/purge/scope.d.ts
+type PurgeClassification = 'DELETE' | 'KEEP_NEW' | 'KEEP_SCOPE' | 'KEEP_UNPROVEN';
+//#endregion
 //#region src/adapters/dsh-storage/purge-visibility.d.ts
 declare class PurgeVisibility {
   private readonly domain;
   constructor(domain: Run2skillDomain);
+  revision(): `visibility_${string}`;
   active(): PurgeJournalV1 | undefined;
   workItemWasPurged(item: CaptureWorkItemV1): boolean;
   workItemVisible(item: CaptureWorkItemV1): boolean;
   lineageVisible(lineage: LineageV1): boolean;
 }
 //#endregion
+//#region src/application/capture/runtime-notices.d.ts
+interface RuntimeNoticeInput {
+  readonly healthCode: string;
+  readonly sessionId: string;
+  readonly turnEndSeq?: number;
+  readonly signalClass?: 'EXPLICIT_SAVE' | 'OTHER_HIGH';
+}
+type RuntimeNoticeKind = 'HEALTH' | 'UNSAVED_SIGNAL';
+interface RuntimeNotice extends RuntimeNoticeInput {
+  readonly kind: RuntimeNoticeKind;
+  readonly count: number;
+  readonly firstObservedAt: number;
+  readonly lastObservedAt: number;
+  readonly requiresAttention: boolean;
+}
+declare class RuntimeNotices {
+  #private;
+  constructor(options?: {
+    now?: () => number;
+    limit?: number;
+    aggregationWindowMs?: number;
+  });
+  record(input: RuntimeNoticeInput): void;
+  recordUnsaved(input: RuntimeNoticeInput): void;
+  unsavedCompletenessKnown(): boolean;
+  clearSignal(sessionId: string, turnEndSeq: number): void;
+  markUnsavedAttention(sessionId: string, turnEndSeq: number): void;
+  list(): readonly RuntimeNotice[];
+}
+//#endregion
 //#region src/adapters/dsh-workspace/binding.d.ts
 interface DshWorkspaceProjection {
   readonly id: string;
@@ -1522,70 +4844,73 @@ interface DshWorkspaceRegistryPort {
   get?(id: string): DshWorkspaceProjection | undefined;
 }
 //#endregion
-//#region src/application/learn/learning-worker.d.ts
-type LearningAgent = object & AgentScopeProjection;
-interface LearningSkillView<TAgent extends LearningAgent> {
-  readonly cwd?: string;
-  readonly scope: TAgent;
-  readonly signal: AbortSignal;
-}
-//#endregion
-//#region src/adapters/dsh-skills/stock-root-contract.d.ts
-interface StockSkillRuntimeConfiguration {
-  readonly profile: string;
-  readonly presetId?: string | undefined;
-  readonly providerName: string;
-  readonly includeDefaultRoots: boolean;
-  readonly customSkillDirs: readonly string[];
-  readonly configuredDshHome?: string | undefined;
-}
-interface StockFiberProjection {
-  readonly parent: {
-    readonly fiber: StockFiberProjection;
-  };
-  readonly config: unknown;
-}
-interface StockPluginRuntimeProjection {
-  readonly name?: string | undefined;
-  readonly fibers: Iterable<StockFiberProjection>;
-}
-interface StockPresetMountProjection {
-  readonly presetId: string;
-  readonly fiber: StockFiberProjection;
-}
-interface StockPresetMountPort {
-  standingMountFor(agentContext: object): StockPresetMountProjection | undefined | Promise<StockPresetMountProjection | undefined>;
+//#region src/application/capture/bounded-gap-scanner.d.ts
+interface GapScanMetrics {
+  readonly processedSessions: number;
+  readonly processedEvents: number;
+  readonly maxReadFromLatencyMs: number;
+  readonly peakHeapBytes: number;
 }
-interface StockComposedAgentProjection {
-  readonly ctx: {
-    readonly registry: {
-      values(): Iterable<StockPluginRuntimeProjection>;
-    };
+type GapScanResult = GapScanMetrics & ({
+  readonly status: 'COMPLETE';
+} | {
+  readonly status: 'MORE';
+  readonly cursor: {
+    readonly lifecycleKey: string;
+    readonly nextSeq: number;
   };
+} | {
+  readonly status: 'UNAVAILABLE';
+  readonly healthCode: string;
+});
+//#endregion
+//#region src/application/capture/recovery-lifecycle.d.ts
+interface RecoveryScannerPort {
+  ensureActivated(signal?: AbortSignal): Promise<GapScanResult>;
+  scanBatch(signal?: AbortSignal): Promise<GapScanResult>;
 }
-interface StockAgentPresetObservationPort {
-  composedPreset(agentContext: object): string | undefined;
-  resolve(id: string): Promise<{
-    readonly id: string;
-    readonly trust: 'system' | 'user';
-  }>;
-  read(id: string): Promise<string>;
+interface RecoveryRuntime<Candidate = TurnIngressCandidate> {
+  readonly scanner: RecoveryScannerPort;
+  processCandidate(candidate: Candidate): Promise<void>;
+  close(): Promise<void>;
+}
+interface RecoveryRuntimeFactory<Candidate = TurnIngressCandidate> {
+  open(): Promise<RecoveryRuntime<Candidate>>;
 }
-declare function resolvePinnedStockPresetConfiguration(presets: StockAgentPresetObservationPort, agent: {
-  readonly ctx: object;
-}, expectedDigests?: Readonly<Record<'standard' | 'code', string>>): Promise<StockSkillRuntimeConfiguration | undefined>;
-/** Reads the exact stock filesystem fiber mounted for one Agent's joined generation. */
-declare function resolveStockSkillRuntimeConfiguration(mounts: StockPresetMountPort, agent: StockComposedAgentProjection): Promise<StockSkillRuntimeConfiguration | undefined>;
 //#endregion
-//#region src/adapters/dsh-settings/automatic-learning.d.ts
-interface DshSettingsScope<T> {
-  get(): T;
-  watch(callback: (next: T, previous: T) => void | Promise<void>): () => void;
+//#region src/application/learn/learning-scheduler.d.ts
+interface LearningSchedulerStore {
+  recoverInterrupted(): Promise<readonly CaptureWorkItemV1[]>;
+  resumeAvailableAgentScopes(available: (item: CaptureWorkItemV1) => boolean): Promise<readonly CaptureWorkItemV1[]>;
+  listEligible(now: string): readonly CaptureWorkItemV1[];
+  nextEligibleAt(now: string): string | undefined;
 }
-interface DshSettingsPort {
-  register<T>(namespace: string, schema: z$1<T>, options: {
-    readonly applies: 'live';
-  }): DshSettingsScope<T>;
+interface LearningWorkerPort {
+  canResolveScope(item: CaptureWorkItemV1): boolean;
+  run(item: CaptureWorkItemV1, signal: AbortSignal, settings: AutomaticLearningSnapshot): Promise<void>;
+}
+interface LearningSchedulerOptions {
+  readonly store: LearningSchedulerStore;
+  readonly worker: LearningWorkerPort;
+  readonly policy: AutomaticLearningPolicyPort;
+  readonly notices: RuntimeNotices;
+  readonly now?: () => number;
+}
+declare class LearningScheduler {
+  #private;
+  constructor(options: LearningSchedulerOptions);
+  start(): Promise<void>;
+  wake(): void;
+  abortMatching(predicate: (item: CaptureWorkItemV1) => boolean): void;
+  dispose(): Promise<void>;
+}
+//#endregion
+//#region src/application/learn/learning-worker.d.ts
+type LearningAgent = object & AgentScopeProjection;
+interface LearningSkillView<TAgent extends LearningAgent> {
+  readonly cwd?: string;
+  readonly scope: TAgent;
+  readonly signal: AbortSignal;
 }
 //#endregion
 //#region src/domain/review/schemas.d.ts
@@ -1799,71 +5124,6 @@ declare const ProposalRefV1Schema: z.ZodObject<{
 }, z.core.$strict>;
 type ProposalRefV1 = z.infer<typeof ProposalRefV1Schema>;
 //#endregion
-//#region src/adapters/dsh-publication/filesystem-cas.d.mts
-interface PublicationResult {
-  readonly status: 'written' | 'conflict' | 'finalized';
-  readonly code?: string;
-  readonly txid: string;
-  readonly target?: string;
-  readonly backup?: string | null;
-}
-interface PublicationHooks {
-  readonly beforeInstall?: (record: Readonly<Record<string, unknown>>) => Promise<void>;
-  readonly beforeBackupMove?: (record: Readonly<Record<string, unknown>>) => Promise<void>;
-  readonly beforeBackupRename?: (record: Readonly<Record<string, unknown>>) => Promise<void>;
-  readonly afterInstall?: (record: Readonly<Record<string, unknown>>) => Promise<void>;
-}
-interface RootPreparation {
-  readonly root: string;
-  readonly createdSegments: readonly string[];
-  readonly rootIdentityDigest: string;
-}
-declare class PublicationConflict extends Error {
-  readonly code: string;
-  constructor(code: string, message: string);
-}
-declare function preparePublicationRoot(input: {
-  readonly binding: RootBindingV2;
-  readonly verifyIdentity: (canonicalPath: string, identityDigest: string) => Promise<boolean>;
-  readonly verifyParity: (binding: RootBindingV2, canonicalRoot: string) => Promise<boolean>;
-  readonly crashAt?: string;
-}): Promise<RootPreparation>;
-declare function createBundle(input: {
-  readonly root: string;
-  readonly name: string;
-  readonly txid: string;
-  readonly nextBytes: string | Uint8Array;
-  readonly rootPreparation?: RootPreparation;
-  readonly crashAt?: string;
-  readonly hooks?: PublicationHooks;
-}): Promise<PublicationResult>;
-declare function mergeBundle(input: {
-  readonly root: string;
-  readonly name: string;
-  readonly txid: string;
-  readonly expectedHash: string;
-  readonly nextBytes: string | Uint8Array;
-  readonly rootPreparation?: RootPreparation;
-  readonly crashAt?: string;
-  readonly hooks?: PublicationHooks;
-}): Promise<PublicationResult>;
-declare function recoverTransaction(input: {
-  readonly root: string;
-  readonly txid: string;
-}): Promise<PublicationResult>;
-declare function finalizeTransaction(input: {
-  readonly root: string;
-  readonly txid: string;
-  readonly confirmedExactReadback: true;
-}): Promise<PublicationResult>;
-//#endregion
-//#region src/adapters/dsh-publication/target-single-flight.d.ts
-declare class PublicationTargetSingleFlight {
-  #private;
-  run<T>(canonicalTargetPath: string, task: () => Promise<T>): Promise<T>;
-  get activeTargetCount(): number;
-}
-//#endregion
 //#region src/adapters/dsh-storage/publication-saga-store.d.ts
 type FailureOutcome = 'NEEDS_ATTENTION' | 'NEEDS_REFRESH' | 'PUBLISH_FAILED';
 declare class PublicationSagaStore {
@@ -2002,11 +5262,308 @@ declare class PublicationScheduler {
   dispose(): Promise<void>;
 }
 //#endregion
+//#region src/application/review/v2-proposal-review.d.ts
+interface V2ProposalRef {
+  readonly proposalId: string;
+  readonly revision: number;
+  readonly digest: string;
+}
+type V2ProposalReviewRevalidation = {
+  readonly status: 'CURRENT';
+  readonly runtimeCatalogDigest: string;
+  readonly pendingCatalogDigest: string;
+  readonly catalogEpoch: number;
+  readonly catalogMutationReceiptDigest: string;
+} | {
+  readonly status: 'STALE' | 'UNAVAILABLE';
+};
+//#endregion
+//#region src/application/publication/v2-proposal-publication.d.ts
+type NativeProposalLineageV2 = Extract<ProposalLineageV2, {
+  readonly origin: 'RUN2SKILL_V2';
+}>;
+type NativeProposalRevisionV2 = NativeProposalLineageV2['proposalRevisions'][number];
+interface V2ProposalPublicationRequest {
+  readonly lineageId: string;
+  readonly expectedLineageRevision: number;
+  readonly proposalRef: V2ProposalRef;
+}
+type V2ProposalPublicationOutcome = {
+  readonly status: 'PUBLISHED';
+  readonly externalReceiptDigest: string;
+} | {
+  readonly status: 'STALE' | 'UNAVAILABLE' | 'CONFLICT';
+};
+type V2ProposalPublicationRecoveryOutcome = V2ProposalPublicationOutcome | {
+  readonly status: 'ABSENT';
+};
+interface V2ProposalPublicationInput {
+  readonly lineage: NativeProposalLineageV2;
+  readonly proposal: NativeProposalRevisionV2;
+  readonly proposalRef: V2ProposalRef;
+  readonly intent: ExperienceIntentV2;
+  readonly batch: SessionBatchV2;
+}
+interface V2ProposalPublicationOptions {
+  revalidate(input: V2ProposalPublicationInput): Promise<V2ProposalReviewRevalidation>;
+  /** Recover an existing attempt only. ABSENT must guarantee that no external transaction exists. */
+  recover?(input: V2ProposalPublicationInput & {
+    readonly attemptId: string;
+  }): Promise<unknown>;
+  publish(input: V2ProposalPublicationInput & {
+    readonly attemptId: string;
+  }): Promise<unknown>;
+  readonly now?: () => string;
+}
+interface V2ProposalPublicationResult {
+  readonly changed: boolean;
+  readonly state: 'PUBLISHED' | 'NEEDS_ATTENTION';
+  readonly lineage: NativeProposalLineageV2;
+}
+declare class V2ProposalPublicationError extends Error {
+  readonly code: 'PUBLICATION_LINEAGE_NOT_FOUND' | 'PUBLICATION_REVISION_CONFLICT' | 'STALE_PROPOSAL_REF' | 'INVALID_PUBLICATION_STATE' | 'PUBLICATION_INPUT_UNAVAILABLE' | 'PUBLICATION_BUSY' | 'PUBLICATION_RECOVERY_CONFLICT';
+  constructor(code: 'PUBLICATION_LINEAGE_NOT_FOUND' | 'PUBLICATION_REVISION_CONFLICT' | 'STALE_PROPOSAL_REF' | 'INVALID_PUBLICATION_STATE' | 'PUBLICATION_INPUT_UNAVAILABLE' | 'PUBLICATION_BUSY' | 'PUBLICATION_RECOVERY_CONFLICT');
+}
+/**
+ * Publishes one approved native v2 Proposal behind a durable Catalog mutation
+ * fence. The filesystem port must use attemptId as an idempotency key and
+ * return success only after exact readback.
+ */
+declare class V2ProposalPublicationCoordinator {
+  #private;
+  private readonly domain;
+  private readonly options;
+  constructor(domain: Run2skillV2Domain, options: V2ProposalPublicationOptions);
+  publish(request: V2ProposalPublicationRequest): Promise<V2ProposalPublicationResult>;
+  recover(): Promise<'IDLE' | 'RECOVERED'>;
+}
+//#endregion
+//#region src/adapters/dsh-skills/stock-root-contract.d.ts
+interface StockSkillRuntimeConfiguration {
+  readonly profile: string;
+  readonly presetId?: string | undefined;
+  readonly providerName: string;
+  readonly includeDefaultRoots: boolean;
+  readonly customSkillDirs: readonly string[];
+  readonly configuredDshHome?: string | undefined;
+  readonly configuredAgentsHome?: string | undefined;
+  readonly configuredBundledSkillDir?: string | undefined;
+  readonly usesContextFileSystem?: true | undefined;
+}
+interface StockFiberProjection {
+  readonly parent: {
+    readonly fiber: StockFiberProjection;
+  };
+  readonly config: unknown;
+}
+interface StockPluginRuntimeProjection {
+  readonly name?: string | undefined;
+  readonly fibers: Iterable<StockFiberProjection>;
+}
+interface StockPresetMountProjection {
+  readonly presetId: string;
+  readonly fiber: StockFiberProjection;
+}
+interface StockPresetMountPort {
+  standingMountFor(agentContext: object): StockPresetMountProjection | undefined | Promise<StockPresetMountProjection | undefined>;
+}
+interface StockComposedAgentProjection {
+  readonly ctx: {
+    readonly registry: {
+      values(): Iterable<StockPluginRuntimeProjection>;
+    };
+    readonly get?: (name: string) => unknown;
+  };
+}
+interface StockAgentPresetObservationPort {
+  composedPreset(agentContext: object): string | undefined;
+  resolve(id: string): Promise<{
+    readonly id: string;
+    readonly trust: 'system' | 'user';
+  }>;
+  read(id: string): Promise<string>;
+}
+declare function resolvePinnedStockPresetConfiguration(presets: StockAgentPresetObservationPort, agent: {
+  readonly ctx: object;
+}, expectedDigests?: Readonly<Record<'standard' | 'code', string>>): Promise<StockSkillRuntimeConfiguration | undefined>;
+/** Reads the exact stock filesystem fiber mounted for one Agent's joined generation. */
+declare function resolveStockSkillRuntimeConfiguration(mounts: StockPresetMountPort, agent: StockComposedAgentProjection): Promise<StockSkillRuntimeConfiguration | undefined>;
+//#endregion
+//#region src/adapters/dsh-settings/automatic-learning.d.ts
+interface DshSettingsScope<T> {
+  get(): T;
+  watch(callback: (next: T, previous: T) => void | Promise<void>): () => void;
+}
+interface DshSettingsPort {
+  register<T>(namespace: string, schema: z$1<T>, options: {
+    readonly applies: 'live';
+  }): DshSettingsScope<T>;
+}
+interface AutomaticLearningSettingsPolicy extends AutomaticLearningPolicyPort {
+  watch(callback: (next: AutomaticLearningSnapshot, previous: AutomaticLearningSnapshot) => void | Promise<void>): () => void;
+}
+//#endregion
+//#region src/application/purge/purge-service.d.ts
+interface PurgePreviewV1 {
+  readonly apiVersion: 1;
+  readonly previewId: string;
+  readonly digest: string;
+  readonly expiresAt: string;
+  readonly scopeBinding: PurgeScopeBindingV1;
+  readonly hideBefore: string;
+  readonly workItemCount: number;
+  readonly lineageCount: number;
+  readonly derivedRecordCount: number;
+  readonly blockedOrUnprovenCount: number;
+  readonly willDelete: readonly {
+    readonly kind: 'WORK_ITEMS' | 'LINEAGES';
+    readonly count: number;
+  }[];
+  readonly willKeep: readonly {
+    readonly reason: Exclude<PurgeClassification, 'DELETE'>;
+    readonly count: number;
+  }[];
+  readonly busyPublicationCount: number;
+}
+type PurgeReceiptV1 = {
+  readonly apiVersion: 1;
+  readonly purgeId: string;
+  readonly state: 'COMPLETED' | 'IN_PROGRESS';
+  readonly phase?: PurgePhaseV1;
+  readonly deletedWorkItems: number;
+  readonly deletedLineages: number;
+};
+type PurgeStatusV1 = {
+  readonly apiVersion: 1;
+  readonly state: 'IDLE';
+} | ({
+  readonly apiVersion: 1;
+  readonly state: 'IN_PROGRESS';
+} & Omit<PurgeJournalV1, 'schemaVersion' | 'scopeBinding' | 'candidateDigest'>);
+type PurgeConfirmationScope = {
+  readonly scope: 'ALL';
+} | {
+  readonly scope: 'USER';
+} | {
+  readonly scope: 'PROJECT';
+  readonly workspaceId: string;
+};
+interface PurgeScopeResolver {
+  resolve(scope: 'PROJECT' | 'USER', workspaceId?: string): Promise<PurgeScopeBindingV1>;
+}
+interface PurgeServiceOptions {
+  readonly now?: () => number;
+  readonly previewTtlMs?: number;
+  readonly onHidden?: (journal: PurgeJournalV1) => void | Promise<void>;
+  readonly onPhasePersisted?: (phase: PurgePhaseV1) => void | Promise<void>;
+  readonly beforeDeleteWorkItem?: (workItemId: string) => void | Promise<void>;
+  readonly beforeDeleteAll?: () => void | Promise<void>;
+  readonly assertDeletionReady?: () => void | Promise<void>;
+  readonly v2Domain?: Run2skillV2Domain;
+}
+declare class PurgeService {
+  #private;
+  private readonly domain;
+  private readonly scopeResolver;
+  constructor(domain: Run2skillDomain, scopeResolver: PurgeScopeResolver, options?: PurgeServiceOptions);
+  preview(scope: 'ALL' | 'PROJECT' | 'USER', workspaceId?: string): Promise<PurgePreviewV1>;
+  confirm(previewId: string, digest: string, confirmationScope?: PurgeConfirmationScope): Promise<PurgeReceiptV1>;
+  status(): PurgeStatusV1;
+  recover(): Promise<PurgeReceiptV1 | undefined>;
+  retry(purgeId: string): Promise<PurgeReceiptV1>;
+}
+//#endregion
+//#region src/application/migration/legacy-source-cutover-gate.d.ts
+/**
+ * Serializes every legacy mutation with the v1 -> v2 cutover and permanently
+ * rejects v1 writes after a successful migration commit.
+ */
+declare class LegacySourceCutoverGate {
+  #private;
+  get state(): 'ACCEPTING' | 'CUTTING_OVER' | 'SEALED';
+  runLegacyMutation<T>(operation: () => T | Promise<T>): Promise<T>;
+  sealAndRun<T>(operation: () => T | Promise<T>, durableCommitObserved?: () => boolean): Promise<T>;
+}
+//#endregion
+//#region src/application/host-mutation-gate.d.ts
+declare class HostMutationGate extends LegacySourceCutoverGate {
+  run<T>(operation: () => Promise<T>): Promise<T>;
+}
+//#endregion
+//#region src/adapters/dsh-publication/filesystem-cas.d.mts
+interface PublicationResult {
+  readonly status: 'written' | 'conflict' | 'finalized';
+  readonly code?: string;
+  readonly txid: string;
+  readonly target?: string;
+  readonly backup?: string | null;
+}
+interface PublicationHooks {
+  readonly beforeInstall?: (record: Readonly<Record<string, unknown>>) => Promise<void>;
+  readonly beforeBackupMove?: (record: Readonly<Record<string, unknown>>) => Promise<void>;
+  readonly beforeBackupRename?: (record: Readonly<Record<string, unknown>>) => Promise<void>;
+  readonly afterInstall?: (record: Readonly<Record<string, unknown>>) => Promise<void>;
+  readonly afterBackupRemoval?: (record: Readonly<Record<string, unknown>>) => Promise<void>;
+}
+interface RootPreparation {
+  readonly root: string;
+  readonly createdSegments: readonly string[];
+  readonly rootIdentityDigest: string;
+}
+declare class PublicationConflict extends Error {
+  readonly code: string;
+  constructor(code: string, message: string);
+}
+declare function preparePublicationRoot(input: {
+  readonly binding: RootBindingV2;
+  readonly verifyIdentity: (canonicalPath: string, identityDigest: string) => Promise<boolean>;
+  readonly verifyParity: (binding: RootBindingV2, canonicalRoot: string, rootIdentityDigest: string) => Promise<boolean>;
+  readonly crashAt?: string;
+}): Promise<RootPreparation>;
+declare function createBundle(input: {
+  readonly root: string;
+  readonly name: string;
+  readonly txid: string;
+  readonly nextBytes: string | Uint8Array;
+  readonly rootPreparation?: RootPreparation;
+  readonly crashAt?: string;
+  readonly hooks?: PublicationHooks;
+}): Promise<PublicationResult>;
+declare function mergeBundle(input: {
+  readonly root: string;
+  readonly name: string;
+  readonly txid: string;
+  readonly expectedHash: string;
+  readonly nextBytes: string | Uint8Array;
+  readonly rootPreparation?: RootPreparation;
+  readonly crashAt?: string;
+  readonly hooks?: PublicationHooks;
+}): Promise<PublicationResult>;
+declare function recoverTransaction(input: {
+  readonly root: string;
+  readonly txid: string;
+}): Promise<PublicationResult>;
+declare function finalizeTransaction(input: {
+  readonly root: string;
+  readonly txid: string;
+  readonly confirmedExactReadback: true;
+  readonly crashAt?: string;
+  readonly hooks?: PublicationHooks;
+}): Promise<PublicationResult>;
+//#endregion
+//#region src/adapters/dsh-publication/target-single-flight.d.ts
+declare class PublicationTargetSingleFlight {
+  #private;
+  run<T>(canonicalTargetPath: string, task: () => Promise<T>): Promise<T>;
+  get activeTargetCount(): number;
+}
+//#endregion
 //#region src/host/index.d.ts
 declare const name = "run2skill";
-declare const inject: readonly ["sessions", "sessionPersistence", "storageDomain", "workspaceRegistry", "connection", "llm", "skills", "settings", "agentPresets"];
+declare const inject: readonly ["agents", "sessions", "sessionPersistence", "storageDomain", "workspaceRegistry", "connection", "llm", "skills", "settings", "agentPresets"];
 type Run2skillAgent = object & AgentScopeProjection & Parameters<typeof resolveStockSkillRuntimeConfiguration>[1];
 interface Run2skillHostContext extends Run2skillStorageContext {
+  readonly agents: unknown;
   readonly sessions: unknown;
   readonly sessionPersistence: SessionPersistencePort;
   readonly workspaceRegistry: DshWorkspaceRegistryPort;
@@ -2017,6 +5574,28 @@ interface Run2skillHostContext extends Run2skillStorageContext {
   readonly agentPresets: Parameters<typeof resolvePinnedStockPresetConfiguration>[0];
   on(event: string, listener: (...args: never[]) => unknown): void;
 }
+declare class Run2skillRuntimeFactory implements RecoveryRuntimeFactory {
+  #private;
+  private readonly context;
+  private readonly notices;
+  private readonly scopes;
+  private readonly automaticLearning;
+  private readonly mutationGate;
+  currentDomain: Run2skillDomain | undefined;
+  currentScheduler: LearningScheduler | undefined;
+  currentPublicationScheduler: PublicationScheduler | undefined;
+  currentPurgeService: PurgeService | undefined;
+  currentDiagnosticStore: LearningDiagnosticStore | undefined;
+  constructor(context: Run2skillHostContext, notices: RuntimeNotices, scopes: ExactAgentScopeRegistry<Run2skillAgent>, automaticLearning: AutomaticLearningSettingsPolicy, mutationGate: HostMutationGate);
+  wakeLearning(): void;
+  wakePublication(): void;
+  wakeCuration(): void;
+  captureRootConfiguration(agent: Run2skillAgent): Promise<void>;
+  releaseRootConfiguration(agent: Run2skillAgent): void;
+  currentCurationWake: (() => void) | undefined;
+  resolvePurgeScope(scope: 'PROJECT' | 'USER', workspaceId?: string): Promise<PurgeScopeBindingV1>;
+  open(): Promise<RecoveryRuntime>;
+}
 declare function apply(context: Run2skillHostContext): Promise<() => Promise<void>>;
 //#endregion
-export { ApprovalPublicationSaga, ApprovalPublicationSagaOptions, ApprovedProposalRevalidator, PublicationConflict, PublicationFileSystemPort, PublicationFileSystemResult, PublicationReadbackPort, PublicationReadbackResult, PublicationRevalidationPort, PublicationRevalidationResult, PublicationRootPreparation, PublicationScheduler, PublicationSchedulerOptions, PublicationSingleFlightPort, PublicationTargetSingleFlight, PublicationWorkerPort, Run2skillHostContext, apply, createBundle, finalizeTransaction, inject, mergeBundle, name, preparePublicationRoot, recoverTransaction };
+export { ApprovalPublicationSaga, ApprovalPublicationSagaOptions, ApprovedProposalRevalidator, PublicationConflict, PublicationFileSystemPort, PublicationFileSystemResult, PublicationReadbackPort, PublicationReadbackResult, PublicationRevalidationPort, PublicationRevalidationResult, PublicationRootPreparation, PublicationScheduler, PublicationSchedulerOptions, PublicationSingleFlightPort, PublicationTargetSingleFlight, PublicationWorkerPort, Run2skillHostContext, Run2skillRuntimeFactory, V2ProposalPublicationCoordinator, V2ProposalPublicationError, V2ProposalPublicationInput, V2ProposalPublicationOptions, V2ProposalPublicationOutcome, V2ProposalPublicationRecoveryOutcome, V2ProposalPublicationRequest, V2ProposalPublicationResult, apply, createBundle, finalizeTransaction, inject, mergeBundle, name, preparePublicationRoot, recoverTransaction };