@kodax-ai/kodax 0.7.76 → 0.7.78

package/dist/types-chunks/{types.d-sRLugmjy.d.ts → types.d-BA-Jwpfs.d.ts}

@@ -1,4 +1,4 @@
-import { k as KodaXMessage, a1 as KodaXToolDefinition, F as KodaXReasoningMode, a9 as KodaXWireReasoningEffort, a3 as KodaXToolResultContentItem, Y as KodaXThinkingBlock, I as KodaXRedactedThinkingBlock } from './types.d-CSmF0t0n.js';
+import { k as KodaXMessage, a1 as KodaXToolDefinition, F as KodaXReasoningMode, a9 as KodaXWireReasoningEffort, a3 as KodaXToolResultContentItem, Y as KodaXThinkingBlock, I as KodaXRedactedThinkingBlock } from './types.d-DIpZJKUl.js';
 
 type AgentActorState = 'running' | 'idle' | 'closed';
 type AgentTurnState = 'accepted' | 'running' | 'completed' | 'failed' | 'interrupted';
@@ -195,16 +195,19 @@ interface AgentExecutionResult {
     readonly artifacts?: readonly string[];
     readonly artifactDetails?: readonly AgentArtifactDescriptor[];
     readonly structured?: AgentMetadataValue;
+    /** Runtime-observed completion facts merged into the durable Turn metadata. */
+    readonly turnMetadata?: Readonly<Record<string, AgentMetadataValue>>;
 }
 interface AgentMutationOptions {
     /** Optimistic Actor revision checked inside the serialized durable mutation. */
     readonly expectedRevision?: number;
+    /** Optimistic tree revision checked inside the serialized durable mutation. */
+    readonly expectedTreeRevision?: number;
 }
 interface AgentTurnExecutor {
     execute(input: AgentExecutionInput): Promise<AgentExecutionResult>;
 }
-interface AgentActorSnapshot {
-    readonly schemaVersion: 1;
+interface AgentActorSnapshotContents {
     readonly revision: number;
     readonly maxConcurrentThreads: number;
     readonly actors: readonly AgentActor[];
@@ -216,14 +219,34 @@ interface AgentActorSnapshot {
     readonly pendingRootCompletionTurnIds?: readonly string[];
     readonly events: readonly AgentEvent[];
 }
+/** Runtime process/controller identity that exclusively owns one durable Actor tree. */
+interface AgentActorOwner {
+    readonly ownerId: string;
+    readonly runtimeId: string;
+    readonly pid: number;
+    readonly startedAt: string;
+    /** Opaque host identity for proving that this exact Runtime, not only its PID, remains alive. */
+    readonly livenessId?: string;
+    /** Loopback challenge endpoint paired with livenessId. */
+    readonly livenessPort?: number;
+}
+interface AgentActorSnapshotV1 extends AgentActorSnapshotContents {
+    readonly schemaVersion: 1;
+}
+interface AgentActorSnapshotV2 extends AgentActorSnapshotContents {
+    readonly schemaVersion: 2;
+    readonly owner?: AgentActorOwner;
+}
+type AgentActorSnapshot = AgentActorSnapshotV1 | AgentActorSnapshotV2;
 interface AgentActorStore {
     load(): Promise<AgentActorSnapshot | undefined>;
+    /** CAS save. Implementations must throw actor_snapshot_conflict on a revision mismatch. */
     save(snapshot: AgentActorSnapshot, expectedRevision: number): Promise<void>;
 }
 /** Runtime-bound actor control surface. The caller path is minted by Runtime. */
 interface AgentActorClient {
     readonly callerPath: string;
-    spawn(input: AgentSpawnInput): Promise<AgentTurnRef>;
+    spawn(input: AgentSpawnInput, options?: AgentMutationOptions): Promise<AgentTurnRef>;
     send(targetPath: string, content: string, classification?: AgentDataClassification, forwardedMessageId?: string): Promise<AgentMailboxMessage>;
     followup(targetPath: string, objective: string, metadata?: Readonly<Record<string, AgentMetadataValue>>, options?: AgentMutationOptions): Promise<AgentFollowupResult>;
     interrupt(targetPath: string, reason?: string, scope?: AgentInterruptScope): Promise<void>;
@@ -342,26 +365,47 @@ interface KodaXSessionClientNoticeEntry extends KodaXSessionEntryBase {
 interface KodaXMemoryOutcomeDigest {
     readonly id: string;
     readonly reviewKey: string;
+    /** Stable root-episode identity; absent on pre-F263 digests. */
+    readonly episodeId?: string;
     readonly sessionId: string;
     readonly branchId: string;
     readonly sequence: number;
     readonly objective: string;
     readonly actionSignature?: string;
     readonly approach: string;
-    readonly outcome: 'succeeded' | 'failed';
+    /**
+     * `cancelled` is reserved for a host-bound explicit Memory intent. Ordinary
+     * cancelled episodes do not produce an outcome digest.
+     */
+    readonly outcome: 'succeeded' | 'failed' | 'cancelled';
     readonly summary: string;
     readonly preconditions?: string;
     readonly lesson?: string;
     readonly evidenceRefs: readonly string[];
     readonly evidence?: readonly KodaXMemoryOutcomeEvidence[];
+    /**
+     * Explicit durable intent captured from the Action LLM and bound by the
+     * host to an exact quote in the current user turn. It is evidence for the
+     * governed reviewer, never proof that Memory was queued or applied.
+     */
+    readonly memoryIntent?: KodaXMemoryIntent;
     readonly memoryInfluence?: readonly KodaXMemoryInfluenceRef[];
     readonly visibility: 'prompt_safe' | 'private' | 'sensitive';
     readonly createdAt: string;
 }
+interface KodaXMemoryIntent {
+    readonly operation: 'remember' | 'correct';
+    readonly evidenceRef: string;
+    /** Sanitized model-derived claim proposed for governed review. */
+    readonly candidateStatement: string;
+    /** Sanitized representation of the exact current-user quote verified by the host. */
+    readonly userQuote: string;
+}
 interface KodaXMemoryOutcomeEvidence {
     readonly ref: string;
     readonly grade: 'authoritative' | 'verified' | 'corroborated' | 'observed' | 'inferred';
     readonly source: 'user' | 'host' | 'tool' | 'environment' | 'agent';
+    readonly verdict?: 'passed' | 'failed' | 'inconclusive';
     readonly observedAt: string;
 }
 interface KodaXMemoryInfluenceRef {
@@ -371,9 +415,13 @@ interface KodaXMemoryInfluenceRef {
 interface KodaXSessionMemoryOutcomeDigestEntry extends KodaXSessionEntryBase {
     readonly type: 'memory_outcome_digest';
     readonly digest: KodaXMemoryOutcomeDigest;
+    /** Durable F263 review job identity. Absent on pre-F263 lineage records. */
+    readonly jobId?: string;
 }
 interface KodaXSessionMemoryReviewReceiptEntry extends KodaXSessionEntryBase {
     readonly type: 'memory_review_receipt';
+    /** Distinguishes repeated review keys across branch epochs. */
+    readonly jobId?: string;
     readonly reviewKey: string;
     readonly proposalIds: readonly string[];
     readonly status: 'completed' | 'no_action';
@@ -613,6 +661,14 @@ interface KodaXExtensionStore {
 interface KodaXSessionStorage {
     save(id: string, data: KodaXSessionData): Promise<void>;
     load(id: string): Promise<KodaXSessionData | null>;
+    /**
+     * Atomically mutates context-silent lineage state against the latest
+     * persisted session. Hosts that own session persistence may expose this
+     * without allowing the runner to write a stale full snapshot. Returns
+     * true when the session existed and the callback was evaluated, including
+     * an idempotent no-op; false only when the session was not found.
+     */
+    mutateLineage?(id: string, mutation: (lineage: KodaXSessionLineage) => KodaXSessionLineage): Promise<boolean>;
     getLineage?(id: string): Promise<KodaXSessionLineage | null>;
     /** Exact lineage merged from the active session file and island sidecars. */
     loadFullLineage?(id: string): Promise<KodaXSessionLineage | null>;
@@ -974,10 +1030,16 @@ interface MemoryDecisionTraceReceipt {
     readonly decisionRevision: string;
     readonly policyVersion: string;
     readonly candidateSetFingerprint: string;
+    readonly candidateIds: readonly string[];
+    readonly selectedCandidateIds: readonly string[];
+    readonly injectedEvidenceRefs: readonly string[];
+    readonly triggers?: readonly ('tool_failure' | 'verification_failure' | 'context_compacted')[];
     readonly candidateRefs: readonly string[];
     readonly selectedRefs: readonly string[];
     readonly injectedRefs: readonly string[];
-    readonly selectionModes: readonly ('task_hint' | 'exact' | 'semantic_prefetch' | 'deliberate_query')[];
+    readonly selectionModes: readonly ('task_hint' | 'exact'
+    /** @deprecated Retained for source compatibility; F275 no longer emits this mode. */
+     | 'semantic_prefetch' | 'semantic_intervention' | 'deliberate_query')[];
     readonly actionSignature?: string;
     readonly throughSequence: number;
 }
@@ -1791,6 +1853,13 @@ interface RunnerLlmResult {
     readonly text: string;
     readonly toolCalls?: readonly RunnerToolCall[];
     readonly stopReason?: string;
+    /**
+     * Provider-visible input messages synthesized by the LLM adapter for this
+     * exact generation (for example a runtime reminder). Runner commits them
+     * immediately before the generated assistant message so the authoritative
+     * transcript remains a faithful prefix of the next provider request.
+     */
+    readonly injectedInputMessages?: readonly AgentMessage[];
     /**
      * v0.7.26 parity: extended-thinking blocks from the provider stream.
      * Must be preserved on the assistant message so (a) session resume can
@@ -2123,6 +2192,32 @@ interface RunOptions {
         /** Executed tool names from the iteration that reached this boundary. */
         readonly lastTurnToolNames: readonly string[];
     }) => Promise<readonly AgentMessage[]>;
+    /**
+     * Active-run input continuation owned by an embedder that accepts input
+     * against a specific in-flight run.
+     *
+     * Unlike `beforeNextTurn`, this hook is consulted at a terminal candidate:
+     * a no-tool model response or a terminal tool signal. Runner synchronously
+     * closes admission as soon as it recognizes the candidate, then drains input
+     * that was already accepted. A non-empty drain is committed to the
+     * transcript, admission reopens, and the same run continues.
+     * Lifecycle continuations may reserve only a small fixed number of turns
+     * beyond the configured iteration cap; the final absolute turn keeps
+     * admission closed.
+     *
+     * REPL hosts should omit this option so their existing round boundary keeps
+     * ownership of queued follow-ups.
+     */
+    readonly terminalContinuation?: {
+        readonly closeInputWindow: () => void;
+        readonly reopenInputWindow: () => void;
+        readonly drain: (ctx: {
+            readonly agent: Agent;
+            readonly transcript: readonly AgentMessage[];
+            readonly iteration: number;
+            readonly lastTurnToolNames: readonly string[];
+        }) => Promise<readonly AgentMessage[]>;
+    };
     /**
      * FEATURE_166 (v0.7.41 follow-up) — agent-switch hook.
      *
@@ -2751,6 +2846,8 @@ interface DiscoveryOptions {
 declare function discoverInstances(options?: DiscoveryOptions): DiscoveredInstance[];
 
 interface MemoryContextIdentity {
+    /** Explicit owner home for durable runtime state; never persisted in review envelopes. */
+    readonly configHome?: string;
     readonly tenantId: string;
     readonly workspaceId?: string;
     readonly userId?: string;
@@ -2849,6 +2946,7 @@ interface MemoryApproval {
     readonly expectedFingerprints: Readonly<Record<string, string>>;
     readonly policyId?: string;
     readonly policyReason?: string;
+    readonly revalidateAuthority?: () => Promise<void>;
 }
 interface MemoryApplyResult {
     readonly proposalId: string;
@@ -2921,7 +3019,7 @@ interface MemoryPackInput {
     readonly includeSensitive?: boolean;
     readonly includeSnippets?: boolean;
     readonly ignoreMemory?: boolean;
-    readonly purpose?: 'automatic' | 'deliberate_query';
+    readonly purpose?: 'automatic' | 'deliberate_query' | 'intervention';
 }
 interface MemoryPackHint {
     readonly ref: MemoryItemRef;
@@ -3025,7 +3123,15 @@ interface MemoryController {
     maybeRunAutoCurator(input?: MemoryAutoCuratorInput): Promise<MemoryAutoCuratorResult>;
     buildMemoryPack(input: MemoryPackInput): Promise<MemoryPack>;
     reviewMemoryFeedback(input: MemoryReviewInput): Promise<MemoryReviewPlan>;
+    prepareEpisodeReview?(digest: KodaXMemoryOutcomeDigest): Promise<MemoryReviewModelInput>;
+    applyReviewedEpisode?(plan: MemoryReviewPlan, digest: KodaXMemoryOutcomeDigest, signal?: AbortSignal, revalidateAuthority?: () => Promise<void>): Promise<MemoryEpisodeReviewResult>;
     persistReviewPlan(plan: MemoryReviewPlan): Promise<readonly string[]>;
+    /**
+     * Resolves which episode-review proposals were actually auto-applied by the
+     * governed host policy. Used to keep durable receipts complete while user
+     * notices remain truthful.
+     */
+    listHostAppliedEpisodeProposalIds?(proposalIds: readonly string[]): Promise<readonly string[]>;
     reviewEpisode(digest: KodaXMemoryOutcomeDigest, signal?: AbortSignal): Promise<MemoryEpisodeReviewResult>;
     archiveRef(id: string): Promise<MemoryLifecycleOperationResult>;
     forgetRef(id: string): Promise<MemoryLifecycleOperationResult>;
@@ -3052,6 +3158,395 @@ type MemoryEvent = {
     readonly actionCount: number;
 };
 
+type LearnedCapabilityCarrier = 'skill' | 'extension' | 'workflow_handoff';
+type LearnedCapabilityLifecycle = 'opportunity' | 'drafting' | 'ready' | 'testing' | 'active_learned' | 'promoted_user' | 'quarantined' | 'archived' | 'rejected';
+type LearningEventKind = 'opportunity' | 'drafting' | 'ready' | 'testing' | 'activated' | 'promoted' | 'attention' | 'archived' | 'rejected';
+type LearningAction = 'review' | 'trust' | 'reject' | 'disable' | 'rollback' | 'archive' | 'restore' | 'promote';
+interface LearnedCapabilitySource {
+    readonly kind: 'learning_controller' | 'f224_proposal' | 'skill_learning_loop' | 'legacy_manual';
+    readonly proposalId?: string;
+}
+interface LearnedCapabilityRecordBase {
+    readonly capabilityId: string;
+    readonly displayName: string;
+    readonly slug: string;
+    readonly carrier: LearnedCapabilityCarrier;
+    readonly lifecycle: LearnedCapabilityLifecycle;
+    readonly revision: number;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly source: LearnedCapabilitySource;
+    /** The control action that produced this revision, when it is not implied by lifecycle. */
+    readonly lastAction?: LearningAction;
+    readonly artifactPath?: string;
+    readonly previousGoodRevision?: number;
+    readonly previousLifecycle?: LearnedCapabilityLifecycle;
+    readonly diagnostics?: readonly string[];
+}
+interface LearnedCapabilityRecordV1 extends LearnedCapabilityRecordBase {
+    readonly schemaVersion: 1;
+}
+interface LearnedCapabilityScope {
+    readonly configHomeHash: string;
+    readonly tenantHash: string;
+    readonly projectHash: string;
+}
+interface LearnedCapabilityArtifact {
+    readonly kind: 'skill_markdown';
+    readonly relativePath: string;
+    readonly fingerprint: string;
+    readonly contentRevision: number;
+}
+interface LearnedCapabilityProvenance {
+    readonly jobId: string;
+    readonly inputHash: string;
+    readonly decisionId: string;
+    readonly actionId: string;
+}
+interface LearnedCapabilityCanaryBinding {
+    readonly bindingId: string;
+    readonly ownerSessionRef: string;
+    readonly expiresAt: string;
+}
+interface LearnedCapabilityCanaryInvocation {
+    readonly invocationId: string;
+    readonly bindingId: string;
+    /** Durable usage-ledger identity for recovery after the binding expires. */
+    readonly usageSessionHash?: string;
+    readonly artifactRevision?: number;
+    readonly artifactFingerprint?: string;
+    readonly status: 'pending' | 'verified_success' | 'credible_negative' | 'inconclusive';
+    readonly evidenceRefs: readonly string[];
+    readonly invokedAt: string;
+    readonly completedAt?: string;
+}
+interface LearnedCapabilityCanary {
+    readonly maxInvocations: 3;
+    readonly invocationCount: number;
+    readonly verifiedSuccesses: number;
+    readonly credibleNegatives: number;
+    readonly binding?: LearnedCapabilityCanaryBinding;
+    readonly invocations: readonly LearnedCapabilityCanaryInvocation[];
+}
+interface LearnedCapabilityRecordV2 extends LearnedCapabilityRecordBase {
+    readonly schemaVersion: 2;
+    readonly carrier: 'skill';
+    readonly scope: LearnedCapabilityScope;
+    readonly artifact: LearnedCapabilityArtifact;
+    readonly previousGoodArtifact?: LearnedCapabilityArtifact;
+    readonly provenance: LearnedCapabilityProvenance;
+    readonly canary: LearnedCapabilityCanary;
+}
+type LearnedCapabilityRecord = LearnedCapabilityRecordV1 | LearnedCapabilityRecordV2;
+interface LearningEvent {
+    readonly schemaVersion: 1;
+    readonly sequence: number;
+    readonly eventId: string;
+    readonly capabilityId: string;
+    readonly capabilityRevision: number;
+    readonly kind: LearningEventKind;
+    readonly lifecycle: LearnedCapabilityLifecycle;
+    readonly displayName: string;
+    readonly slug: string;
+    readonly carrier: LearnedCapabilityCarrier;
+    readonly createdAt: string;
+}
+type LearningNotificationState = 'unread' | 'seen' | 'acknowledged' | 'snoozed';
+interface LearningClientEventState {
+    readonly state: LearningNotificationState;
+    readonly capabilityRevision: number;
+    readonly updatedAt: string;
+    readonly snoozedUntil?: string;
+}
+interface LearningClientRecord {
+    readonly schemaVersion: 1;
+    readonly clientIdentity: string;
+    readonly events: Readonly<Record<string, LearningClientEventState>>;
+}
+interface LearningSurfaceSnapshot {
+    readonly ready: number;
+    readonly newlyActive: number;
+    readonly attention: number;
+    readonly active: number;
+    readonly revision: number;
+}
+interface LearningQuery {
+    readonly search?: string;
+    readonly carrier?: LearnedCapabilityCarrier;
+    readonly lifecycle?: LearnedCapabilityLifecycle;
+    readonly limit?: number;
+    readonly cursor?: string;
+}
+interface LearningPage {
+    readonly items: readonly LearnedCapabilityRecord[];
+    readonly nextCursor?: string;
+    readonly revision: number;
+}
+interface LearningSubscribeOptions {
+    readonly afterRevision?: number;
+}
+interface LearningExplicitUserAuthority {
+    readonly authority: 'explicit_user';
+    readonly expectedRevision: number;
+    readonly expectedFingerprint?: string;
+}
+interface LearningActionDriver {
+    readonly carrier: LearnedCapabilityCarrier;
+    readonly actions: readonly LearningAction[];
+    execute(action: LearningAction, capability: LearnedCapabilityRecord): Promise<LearnedCapabilityRecord>;
+}
+type LearningCapabilityErrorCode = 'ambiguous_name' | 'action_failed' | 'capability_not_found' | 'invalid_record' | 'invalid_transition' | 'store_integrity_error' | 'unsupported_action';
+declare class LearningCapabilityError extends Error {
+    readonly code: LearningCapabilityErrorCode;
+    constructor(code: LearningCapabilityErrorCode, message: string);
+}
+declare function canTransitionLearnedCapability(from: LearnedCapabilityLifecycle, to: LearnedCapabilityLifecycle): boolean;
+declare function assertLearnedCapabilityTransition(from: LearnedCapabilityLifecycle, to: LearnedCapabilityLifecycle): void;
+declare function slugifyLearnedCapabilityName(displayName: string): string;
+declare function learningEventKindForLifecycle(lifecycle: LearnedCapabilityLifecycle): LearningEventKind;
+declare function learningEventIdFor(record: LearnedCapabilityRecord): string;
+
+interface LearnedAreaPaths {
+    readonly root: string;
+    readonly skills: string;
+    readonly extensions: string;
+    readonly capabilities: string;
+    readonly events: string;
+    readonly clients: string;
+}
+declare function resolveLearnedAreaPaths(rootDir: string): LearnedAreaPaths;
+declare class LearnedAreaStore {
+    #private;
+    readonly paths: LearnedAreaPaths;
+    constructor(rootDir: string);
+    initialize(): Promise<void>;
+    readCapability(capabilityId: string): Promise<LearnedCapabilityRecord | undefined>;
+    listCapabilities(): Promise<readonly LearnedCapabilityRecord[]>;
+    writeCapability(record: LearnedCapabilityRecord): Promise<void>;
+    writeEvent(event: LearningEvent): Promise<void>;
+    listEvents(): Promise<readonly LearningEvent[]>;
+    readClient(identity: string): Promise<LearningClientRecord>;
+    writeClient(record: LearningClientRecord): Promise<void>;
+    withOwnerMutation<T>(operation: () => Promise<T>): Promise<T>;
+    withClientMutation<T>(identity: string, operation: () => Promise<T>): Promise<T>;
+    ensureCurrentEvent(record: LearnedCapabilityRecord): Promise<LearningEvent>;
+}
+declare function eventFromCapability(record: LearnedCapabilityRecord, sequence: number): LearningEvent;
+
+interface DeclarativeSkillSpec {
+    readonly name: string;
+    readonly description: string;
+    readonly purpose: string;
+    readonly triggers: readonly string[];
+    readonly steps: readonly string[];
+    readonly verification: readonly string[];
+    readonly pitfalls: readonly string[];
+}
+interface StagedLearnedSkillArtifact extends LearnedCapabilityArtifact {
+    readonly absolutePath: string;
+}
+interface CreateLearnedSkillRecordInput {
+    readonly capabilityId: string;
+    readonly displayName: string;
+    readonly scope: LearnedCapabilityScope;
+    readonly artifact: LearnedCapabilityArtifact;
+    readonly provenance: LearnedCapabilityProvenance;
+    readonly now?: string;
+    readonly previous?: LearnedCapabilityRecordV2;
+}
+interface LearnedSkillBindingAdmission {
+    readonly bindingId: string;
+    readonly ownerSessionRef: string;
+    readonly expiresAt: string;
+}
+interface LearnedSkillInvocationAdmission {
+    readonly invocationId: string;
+    readonly invocationCount: number;
+    readonly maxInvocations: 3;
+}
+interface CommitLearnedSkillRevisionInput {
+    readonly scope: LearnedCapabilityScope;
+    readonly spec: DeclarativeSkillSpec;
+    readonly disposition: 'ready' | 'project_canary';
+    readonly operation: 'create' | 'patch';
+    readonly provenance: LearnedCapabilityProvenance;
+    readonly targetCapabilityId?: string;
+    readonly expectedRevision?: number;
+    readonly expectedFingerprint?: string;
+    readonly protectedSkillNames?: readonly string[];
+    readonly now?: string;
+    readonly authority?: {
+        readonly commit: (operation: (revalidateAuthority: () => Promise<void>) => Promise<LearnedCapabilityRecordV2>) => Promise<LearnedCapabilityRecordV2>;
+    };
+}
+type LearnedSkillCanaryOutcome = 'verified_success' | 'credible_negative' | 'inconclusive';
+declare function resolveProjectLearnedAreaRoot(configHome: string, scope: {
+    readonly tenantId: string;
+    readonly projectId: string;
+}): string;
+declare function createLearnedCapabilityScope(configHome: string, scope: {
+    readonly tenantId: string;
+    readonly projectId: string;
+}): LearnedCapabilityScope;
+declare function validateDeclarativeSkillSpec(spec: DeclarativeSkillSpec): void;
+declare function renderDeclarativeSkill(spec: DeclarativeSkillSpec): string;
+declare function stageLearnedSkillRevision(rootDir: string, capabilityId: string, spec: DeclarativeSkillSpec): Promise<StagedLearnedSkillArtifact>;
+declare function createLearnedSkillRecord(input: CreateLearnedSkillRecordInput): LearnedCapabilityRecordV2;
+declare function commitLearnedSkillRevision(store: LearnedAreaStore, input: CommitLearnedSkillRevisionInput): Promise<LearnedCapabilityRecordV2>;
+declare function admitLearnedSkillBinding(store: LearnedAreaStore, capabilityId: string, input: {
+    readonly bindingId: string;
+    readonly ownerSessionRef: string;
+    readonly now?: Date;
+    readonly ttlMs?: number;
+}): Promise<LearnedSkillBindingAdmission | undefined>;
+declare function releaseLearnedSkillBinding(store: LearnedAreaStore, capabilityId: string, bindingId: string, now?: string): Promise<boolean>;
+declare function invokeLearnedSkillCanary(store: LearnedAreaStore, capabilityId: string, input: {
+    readonly bindingId: string;
+    readonly invocationId?: string;
+    readonly usageSessionHash?: string;
+    readonly artifactRevision?: number;
+    readonly artifactFingerprint?: string;
+    readonly now?: Date;
+}): Promise<LearnedSkillInvocationAdmission>;
+declare function completeLearnedSkillOutcome(store: LearnedAreaStore, capabilityId: string, input: {
+    readonly invocationId: string;
+    readonly outcome: LearnedSkillCanaryOutcome;
+    readonly evidenceRefs: readonly string[];
+    readonly now?: string;
+}): Promise<LearnedCapabilityRecordV2>;
+declare function quarantineLearnedSkillRevision(store: LearnedAreaStore, capabilityId: string, input: {
+    readonly expectedRevision: number;
+    readonly expectedFingerprint: string;
+    readonly reason: string;
+    readonly now?: string;
+    readonly revalidateAuthority?: () => Promise<void>;
+}): Promise<LearnedCapabilityRecordV2>;
+declare function isLearnedCapabilityRecordV2(record: LearnedCapabilityRecord): record is LearnedCapabilityRecordV2;
+
+interface LearnedSkillOfferedReceipt {
+    readonly version: 1;
+    readonly kind: 'offered';
+    readonly receiptId: string;
+    readonly sessionHash: string;
+    readonly bindingId: string;
+    readonly capabilityId: string;
+    readonly revision: number;
+    readonly fingerprint: string;
+    readonly createdAt: string;
+}
+interface LearnedSkillInvokedReceipt {
+    readonly version: 1;
+    readonly kind: 'invoked';
+    readonly receiptId: string;
+    readonly sessionHash: string;
+    readonly bindingId: string;
+    readonly invocationId: string;
+    readonly capabilityId: string;
+    readonly revision: number;
+    readonly fingerprint: string;
+    readonly createdAt: string;
+}
+interface LearnedSkillOutcomeReceipt {
+    readonly version: 1;
+    readonly kind: 'outcome';
+    readonly receiptId: string;
+    readonly sessionHash: string;
+    readonly invocationId: string;
+    readonly capabilityId: string;
+    readonly outcome: LearnedSkillCanaryOutcome;
+    readonly evidenceRefs: readonly string[];
+    readonly createdAt: string;
+}
+type LearnedSkillUsageReceipt = LearnedSkillOfferedReceipt | LearnedSkillInvokedReceipt | LearnedSkillOutcomeReceipt;
+interface ExactInvokedSkillSnapshot {
+    readonly capabilityId: string;
+    readonly name: string;
+    readonly fingerprint: string;
+    readonly revision: number;
+    readonly invocationId: string;
+    readonly content: string;
+}
+declare function recordLearnedSkillOffered(store: LearnedAreaStore, input: {
+    readonly sessionId: string;
+    readonly bindingId: string;
+    readonly capabilityId: string;
+    readonly revision: number;
+    readonly fingerprint: string;
+    readonly now?: string;
+}): Promise<LearnedSkillOfferedReceipt>;
+declare function admitAndRecordLearnedSkillInvocation(store: LearnedAreaStore, input: {
+    readonly sessionId: string;
+    readonly bindingId: string;
+    readonly ownerSessionRef: string;
+    readonly capabilityId: string;
+    readonly expectedRevision: number;
+    readonly expectedFingerprint: string;
+    readonly invocationId?: string;
+    readonly now?: Date;
+}): Promise<LearnedSkillInvokedReceipt>;
+declare function completeLearnedSkillSessionOutcomes(store: LearnedAreaStore, input: {
+    readonly sessionId: string;
+    /** Restricts completion to invocations from one root-run binding. */
+    readonly bindingId?: string;
+    readonly outcome: LearnedSkillCanaryOutcome;
+    readonly evidenceRefs: readonly string[];
+    readonly now?: string;
+}): Promise<readonly LearnedSkillOutcomeReceipt[]>;
+/** Repairs current-binding and stale-canary outcome delivery fail closed. */
+declare function reconcileLearnedSkillBindingOutcomes(store: LearnedAreaStore, input: {
+    readonly sessionId: string;
+    readonly bindingId: string;
+    readonly now?: string;
+}): Promise<readonly LearnedSkillOutcomeReceipt[]>;
+declare function listLearnedSkillUsageReceipts(store: LearnedAreaStore, sessionId: string): Promise<readonly LearnedSkillUsageReceipt[]>;
+declare function exactInvokedSkillSnapshotForSession(store: LearnedAreaStore, sessionId: string, options?: {
+    readonly bindingId?: string;
+}): Promise<ExactInvokedSkillSnapshot | null>;
+
+interface LearningReviewVerifierFact {
+    readonly ref: string;
+    readonly verdict: 'passed' | 'failed' | 'inconclusive';
+}
+
+interface LearningReviewQualification {
+    readonly reusableMethodEvidence: boolean;
+    readonly explicitSkillPreservation: boolean;
+    readonly independentEpisodeCount: number;
+    readonly verifiedOutcome: boolean;
+    readonly exactSkillInvoked: boolean;
+}
+interface LearningReviewEvidencePacket {
+    readonly outcomeDigest: KodaXMemoryOutcomeDigest;
+    readonly exactInvokedSkill: ExactInvokedSkillSnapshot | null;
+    readonly verifierFacts: readonly LearningReviewVerifierFact[];
+    readonly priorDigests: readonly KodaXMemoryOutcomeDigest[];
+    readonly qualification: LearningReviewQualification;
+}
+interface UnifiedLearningReviewModelInput {
+    readonly cacheDomain: 'learning-review';
+    readonly memory: MemoryReviewModelInput;
+    readonly evidence: LearningReviewEvidencePacket;
+}
+type LearnedSkillDecisionDisposition = 'discard' | 'ready' | 'project_canary';
+interface NormalizedLearnedSkillDecision {
+    readonly disposition: LearnedSkillDecisionDisposition;
+    readonly reasonCodes: readonly string[];
+    readonly operation?: 'create' | 'patch';
+    readonly spec?: DeclarativeSkillSpec;
+    readonly targetCapabilityId?: string;
+    readonly expectedFingerprint?: string;
+    readonly expectedRevision?: number;
+    readonly quarantineExactInvokedRevision?: true;
+}
+interface UnifiedLearningReviewResult {
+    readonly memoryPlan: MemoryReviewPlan;
+    readonly capabilityDecision?: NormalizedLearnedSkillDecision;
+}
+type UnifiedLearningReviewRunner = (input: UnifiedLearningReviewModelInput, signal?: AbortSignal) => Promise<unknown>;
+declare function sanitizeUnifiedLearningReviewInput(input: UnifiedLearningReviewModelInput): UnifiedLearningReviewModelInput;
+declare function isUnifiedLearningReviewModelInput(value: unknown): value is UnifiedLearningReviewModelInput;
+declare function normalizeUnifiedLearningReview(input: UnifiedLearningReviewModelInput, raw: unknown): UnifiedLearningReviewResult;
+
 /**
  * ../../index.js Compaction Types
  */
@@ -3964,7 +4459,7 @@ interface AgentExecutorPreflightResult {
 }
 interface AgentExecutor {
     preflight?(input: AgentTaskStartInput): Promise<AgentExecutorPreflightResult>;
-    start(input: AgentTaskStartInput): Promise<AgentExecutorTaskReference>;
+    start(input: AgentTaskStartInput, signal?: AbortSignal): Promise<AgentExecutorTaskReference>;
     events(reference: AgentExecutorTaskReference): AsyncIterable<AgentExecutorEvent>;
     get(reference: AgentExecutorTaskReference): Promise<AgentExecutorTaskSnapshot>;
     sendInput(reference: AgentExecutorTaskReference, input: AgentContinuationInput): Promise<void>;
@@ -4052,7 +4547,7 @@ interface AgentRegistrationService {
     remove(agentId: string, options?: AgentRegistrationMutationOptions): Promise<boolean>;
 }
 interface AgentTaskService {
-    start(input: AgentTaskStartInput): Promise<AgentTaskSnapshot>;
+    start(input: AgentTaskStartInput, signal?: AbortSignal): Promise<AgentTaskSnapshot>;
     list(filter?: AgentTaskFilter): Promise<readonly AgentTaskSnapshot[]>;
     get(taskId: string): Promise<AgentTaskSnapshot>;
     events(taskId: string, cursor?: number): Promise<readonly AgentTaskEvent[]>;
@@ -4097,5 +4592,5 @@ interface CreateAgentExecutorPlaneOptions {
     readonly closeTimeoutMs?: number;
 }
 
-export { ASK_USER_BACK_SIGNAL as A, ASK_USER_CUSTOM_INPUT_SIGNAL as a, DEFAULT_SYSTEM_CAP as aW, InvariantSession as bj, MAX_TOOL_LOOP_ITERATIONS as c7, Runner as d1, Tracer as dF, WorkflowEventRecorder as dQ, SpanImpl as dn, readRunnerRecoveryTranscript as e$, asSingleSelection as eA, attachRunnerRecoveryTranscript as eB, buildAssistantMessageFromLlmResult as eC, buildSystemPrompt as eD, buildToolResultMessage as eE, createAgent as eF, createHandoff as eG, createInMemorySession as eH, createInvariantSessionForAgent as eI, createStateWriter as eJ, createTrace as eK, createWorkflowProcessTracker as eL, defaultTracer as eM, detectInstructionsInjection as eN, discoverInstances as eO, executeRunnerToolCall as eP, extractAssistantTextFromMessage as eQ, getActiveUserInteraction as eR, getAdmittedAgentBindings as eS, hashMemoryIdentityComponent as eT, isAskUserCustomInputAnswer as eU, isFinalWorkflowProcessStatus as eV, isRunnableTool as eW, isRunnerLlmResult as eX, matchesMemoryApplicability as eY, memoryApplicabilityFingerprint as eZ, normalizeHostMetadata as e_, _resetAdmittedAgentBindings as ey, _resetPresetDispatchers as ez, registerPresetDispatcher as f0, runAdmissionAudit as f1, setActiveUserInteraction as f2, setAdmittedAgentBindings as f3 };
-export type { AgentFollowupResult as $, AgentDetail as B, AgentDispatchContext as C, AgentDispatchPolicy as D, AgentDispatchPolicyDecision as E, AgentDispatchPolicyInput as F, AgentDispatchabilitySnapshot as G, AgentDispatchabilityStatus as H, AgentEffectDeclaration as I, AgentEvent as J, AgentEventKind as K, AgentExecutionInput as L, AgentExecutionKind as M, AgentExecutionResult as N, AgentExecutor as O, AgentExecutorEvent as P, AgentExecutorFactory as Q, AgentExecutorFactoryContext as R, AgentExecutorPlane as S, AgentExecutorPlaneBackgroundErrorContext as T, AgentExecutorPlaneBackgroundErrorHandler as U, AgentExecutorPlaneBinding as V, AgentExecutorPlaneStore as W, AgentExecutorPreflightResult as X, AgentExecutorProtocol as Y, AgentExecutorTaskReference as Z, AgentExecutorTaskSnapshot as _, DispatchableAgentListing as a$, AgentForkTurns as a0, AgentInterruptScope as a1, AgentJsonObject as a2, AgentJsonValue as a3, AgentLimitReached as a4, AgentListEntry as a5, AgentMailboxMessage as a6, AgentManifest as a7, AgentMessage as a8, AgentMetadataValue as a9, AgentTreeSnapshot as aA, AgentTurn as aB, AgentTurnExecutor as aC, AgentTurnRef as aD, AgentTurnState as aE, AgentTurnSummary as aF, AskUserAnswer as aG, AskUserCustomInputAnswer as aH, AskUserMultiOptions as aI, AskUserQuestionItem as aJ, AskUserQuestionOptions as aK, AskUserSelectionAnswer as aL, CapabilitySupport as aM, CompactionAnchor as aN, CompactionConfig as aO, CompactionDetails as aP, CompactionReport as aQ, CompactionResult as aR, CompactionSpanData as aS, CompactionUpdate as aT, CreateAgentExecutorPlaneOptions as aU, CurrentTodoSummary as aV, Deliverable as aX, DiscoveredInstance as aY, DiscoveryOptions as aZ, DispatchableAgentDescriptor as a_, AgentMiddlewareDeclaration as aa, AgentMutationOptions as ab, AgentOutput as ac, AgentPreflightInput as ad, AgentPreflightResult as ae, AgentProgressItem as af, AgentProgressKind as ag, AgentProgressUpdate as ah, AgentReasoningProfile as ai, AgentRegistrationEnabledMutationOptions as aj, AgentRegistrationMutationOptions as ak, AgentRegistrationService as al, AgentSpanData as am, AgentSpawnInput as an, AgentTaskCancellation as ao, AgentTaskCorrelation as ap, AgentTaskEvent as aq, AgentTaskFilter as ar, AgentTaskProgress as as, AgentTaskRegistrationSnapshot as at, AgentTaskService as au, AgentTaskSnapshot as av, AgentTaskStartInput as aw, AgentTaskState as ax, AgentTaskUsage as ay, AgentTool as az, AdmissionAuditOptions as b, KodaXSessionUiToolCall as b$, DispatchableAgentOrigin as b0, DispatchableAgentQuery as b1, EvidenceSpanData as b2, ExternalAgentEffectDeclaration as b3, ExternalAgentHealth as b4, ExternalAgentProtocol as b5, ExternalAgentRegistration as b6, ExternalAgentRegistrationSummary as b7, FanoutSpanData as b8, FileOperations as b9, KodaXMemoryOutcomeDigest as bA, KodaXMemoryOutcomeEvidence as bB, KodaXSessionArchiveMarkerEntry as bC, KodaXSessionArtifactLedgerEntry as bD, KodaXSessionBranchSummaryEntry as bE, KodaXSessionClientNoticeEntry as bF, KodaXSessionCompactionEntry as bG, KodaXSessionData as bH, KodaXSessionEntry as bI, KodaXSessionEntryBase as bJ, KodaXSessionGoalEntry as bK, KodaXSessionLabelEntry as bL, KodaXSessionLineage as bM, KodaXSessionMemoryOutcomeDigestEntry as bN, KodaXSessionMemoryReviewReceiptEntry as bO, KodaXSessionMessageEntry as bP, KodaXSessionMeta as bQ, KodaXSessionNavigationOptions as bR, KodaXSessionRewindMarkerEntry as bS, KodaXSessionRuntimeInfo as bT, KodaXSessionScope as bU, KodaXSessionStorage as bV, KodaXSessionTreeNode as bW, KodaXSessionUiHistoryItem as bX, KodaXSessionUiHistoryItemType as bY, KodaXSessionUiTextHistoryItem as bZ, KodaXSessionUiTextHistoryItemType as b_, GenerationSpanData as ba, Guardrail as bb, GuardrailSpanData as bc, Handoff as bd, HandoffSpanData as be, InMemorySessionOptions as bf, InstanceDiscoveryFs as bg, InvariantId as bh, InvariantResult as bi, KodaXCompactMemoryProgress as bk, KodaXCompactMemorySeed as bl, KodaXExtensionSessionRecord as bm, KodaXExtensionSessionState as bn, KodaXExtensionStore as bo, KodaXExtensionStoreEntry as bp, KodaXFileInputArtifact as bq, KodaXGoalEventType as br, KodaXGoalState as bs, KodaXGoalStatus as bt, KodaXImageInputArtifact as bu, KodaXImageMediaType as bv, KodaXInputArtifact as bw, KodaXInputArtifactSource as bx, KodaXJsonValue as by, KodaXMemoryInfluenceRef as bz, AdmissionCtx as c, RunResult as c$, KodaXSessionUiToolCallStatus as c0, KodaXSessionUiToolGroupHistoryItem as c1, KodaXSessionWorkspaceKind as c2, KodaXVideoInputArtifact as c3, KodaXVideoMediaType as c4, LocalAgentTaskInput as c5, LocalAgentTaskUpdate as c6, ManifestPatch as c8, MemoryActionProposal as c9, MemoryRefFilter as cA, MemoryRefKind as cB, MemoryRejectResult as cC, MemoryReviewCandidateRef as cD, MemoryReviewDraftAction as cE, MemoryReviewInput as cF, MemoryReviewModelInput as cG, MemoryReviewPersistenceDecision as cH, MemoryReviewPersistenceKind as cI, MemoryReviewPlan as cJ, MemoryReviewRunner as cK, MemoryReviewTrigger as cL, MemoryScope as cM, MemorySourceAdapter as cN, MemoryVisibility as cO, MessageEntry as cP, ObserveCtx as cQ, PersistedSessionState as cR, PresetDispatcher as cS, PresetTracingContext as cT, QualityInvariant as cU, ReadonlyMutationTracker as cV, ReadonlyRecorder as cW, ReasoningDepth as cX, RecentlyModifiedFile as cY, RunEvent as cZ, RunOptions as c_, MemoryApplicability as ca, MemoryApplyPreview as cb, MemoryApplyResult as cc, MemoryApproval as cd, MemoryAuthority as ce, MemoryAutoCuratorInput as cf, MemoryAutoCuratorResult as cg, MemoryBodySnapshot as ch, MemoryClaimKind as ci, MemoryContextIdentity as cj, MemoryController as ck, MemoryCuratorInput as cl, MemoryDecisionTraceReceipt as cm, MemoryEpisodeReviewResult as cn, MemoryEvent as co, MemoryGovernanceFinding as cp, MemoryGovernanceFindingKind as cq, MemoryGovernanceReport as cr, MemoryItemRef as cs, MemoryLifecycle as ct, MemoryLifecycleOperationResult as cu, MemoryPack as cv, MemoryPackHint as cw, MemoryPackInput as cx, MemoryPackTraceMetadata as cy, MemoryProposalAction as cz, AdmissionVerdict as d, WorkflowOutcomeStatus as d$, RunnableTool as d0, RunnerEvent as d2, RunnerLlmResult as d3, RunnerLlmReturn as d4, RunnerRecoveryTranscriptCarrier as d5, RunnerToolCall as d6, RunnerToolContext as d7, RunnerToolObserver as d8, RunnerToolResult as d9, ToolCallSpanData as dA, ToolCapability as dB, ToolPermission as dC, Trace as dD, TraceOptions as dE, TracerOptions as dG, UserInteraction as dH, WorkflowAgentBackend as dI, WorkflowApi as dJ, WorkflowApproval as dK, WorkflowApprovalSummary as dL, WorkflowArtifactRef as dM, WorkflowBudget as dN, WorkflowEvent as dO, WorkflowEventCorrelation as dP, WorkflowEventType as dR, WorkflowIsolation as dS, WorkflowLimits as dT, WorkflowLogEvent as dU, WorkflowMeta as dV, WorkflowModelHint as dW, WorkflowModule as dX, WorkflowOutcome as dY, WorkflowOutcomeError as dZ, WorkflowOutcomeResult as d_, RunnerToolResultBatch as da, RunnerToolResultBatchTransform as db, Session as dc, SessionDispatchResult as dd, SessionEntry as de, SessionErrorMetadata as df, SessionExtension as dg, SessionForkOptions as dh, SessionMeta as di, SessionStateSnapshot as dj, Span as dk, SpanData as dl, SpanError as dm, SpanImplOptions as dp, StartTraceOptions as dq, StateWriter as dr, StateWriterFs as ds, StateWriterOptions as dt, StopHookContext as du, StopHookFn as dv, StopHookResult as dw, StopHookSpanData as dx, SystemCap as dy, TerminalCtx as dz, AdmittedHandle as e, WorkflowOutcomeUsage as e0, WorkflowParallelOptions as e1, WorkflowProcessArtifact as e2, WorkflowProcessCounts as e3, WorkflowProcessEvent as e4, WorkflowProcessItem as e5, WorkflowProcessItemKind as e6, WorkflowProcessItemOrigin as e7, WorkflowProcessItemStatus as e8, WorkflowProcessProgress as e9, WorkflowProcessSnapshot as ea, WorkflowProcessSource as eb, WorkflowProcessStatus as ec, WorkflowProcessSummaryStatus as ed, WorkflowProcessTokenUsage as ee, WorkflowProcessTracker as ef, WorkflowProcessTrackerOptions as eg, WorkflowRun as eh, WorkflowRunState as ei, WorkflowRunStatus as ej, WorkflowSpawnAgentInput as ek, WorkflowSynthesis as el, WorkflowSynthesizeInput as em, WorkflowTaskHandle as en, WorkflowTaskResult as eo, WorkflowTaskSnapshot as ep, WorkflowTaskStatus as eq, WorkflowTaskSummaryEventUpdate as er, WorkflowTaskSummaryKind as es, WorkflowTaskSummaryUpdate as et, WorkflowTaskUsage as eu, WorkflowTaskVerification as ev, WorkflowTaskVerificationResult as ew, WorkflowWaitOptions as ex, Agent as f, AgentActor as g, AgentActorClient as h, AgentActorSnapshot as i, AgentActorState as j, AgentActorStore as k, AgentArtifactDescriptor as l, AgentArtifactPolicy as m, AgentArtifactPolicyDecision as n, AgentArtifactPolicyInput as o, AgentArtifactReference as p, AgentBudgetAdmission as q, AgentBudgetAdmissionInput as r, AgentBudgetExhausted as s, AgentBudgetPort as t, AgentCapabilities as u, AgentCapabilityDeclaration as v, AgentCapabilityRequirements as w, AgentContinuationInput as x, AgentCredentialBroker as y, AgentDataClassification as z };
+export { ASK_USER_BACK_SIGNAL as A, ASK_USER_CUSTOM_INPUT_SIGNAL as a, DEFAULT_SYSTEM_CAP as a$, InvariantSession as bq, LearningCapabilityError as cB, MAX_TOOL_LOOP_ITERATIONS as cS, LearnedAreaStore as ce, Runner as dO, SpanImpl as e8, WorkflowEventRecorder as eE, Tracer as eq, learningEventKindForLifecycle as f$, createAgent as fA, createHandoff as fB, createInMemorySession as fC, createInvariantSessionForAgent as fD, createLearnedCapabilityScope as fE, createLearnedSkillRecord as fF, createStateWriter as fG, createTrace as fH, createWorkflowProcessTracker as fI, defaultTracer as fJ, detectInstructionsInjection as fK, discoverInstances as fL, eventFromCapability as fM, exactInvokedSkillSnapshotForSession as fN, executeRunnerToolCall as fO, extractAssistantTextFromMessage as fP, getActiveUserInteraction as fQ, getAdmittedAgentBindings as fR, hashMemoryIdentityComponent as fS, invokeLearnedSkillCanary as fT, isAskUserCustomInputAnswer as fU, isFinalWorkflowProcessStatus as fV, isLearnedCapabilityRecordV2 as fW, isRunnableTool as fX, isRunnerLlmResult as fY, isUnifiedLearningReviewModelInput as fZ, learningEventIdFor as f_, _resetAdmittedAgentBindings as fm, _resetPresetDispatchers as fn, admitAndRecordLearnedSkillInvocation as fo, admitLearnedSkillBinding as fp, asSingleSelection as fq, assertLearnedCapabilityTransition as fr, attachRunnerRecoveryTranscript as fs, buildAssistantMessageFromLlmResult as ft, buildSystemPrompt as fu, buildToolResultMessage as fv, canTransitionLearnedCapability as fw, commitLearnedSkillRevision as fx, completeLearnedSkillOutcome as fy, completeLearnedSkillSessionOutcomes as fz, listLearnedSkillUsageReceipts as g0, matchesMemoryApplicability as g1, memoryApplicabilityFingerprint as g2, normalizeHostMetadata as g3, normalizeUnifiedLearningReview as g4, quarantineLearnedSkillRevision as g5, readRunnerRecoveryTranscript as g6, reconcileLearnedSkillBindingOutcomes as g7, recordLearnedSkillOffered as g8, registerPresetDispatcher as g9, releaseLearnedSkillBinding as ga, renderDeclarativeSkill as gb, resolveLearnedAreaPaths as gc, resolveProjectLearnedAreaRoot as gd, runAdmissionAudit as ge, sanitizeUnifiedLearningReviewInput as gf, setActiveUserInteraction as gg, setAdmittedAgentBindings as gh, slugifyLearnedCapabilityName as gi, stageLearnedSkillRevision as gj, validateDeclarativeSkillSpec as gk };
+export type { AgentExecutorProtocol as $, AgentContinuationInput as B, AgentCredentialBroker as C, AgentDataClassification as D, AgentDetail as E, AgentDispatchContext as F, AgentDispatchPolicy as G, AgentDispatchPolicyDecision as H, AgentDispatchPolicyInput as I, AgentDispatchabilitySnapshot as J, AgentDispatchabilityStatus as K, AgentEffectDeclaration as L, AgentEvent as M, AgentEventKind as N, AgentExecutionInput as O, AgentExecutionKind as P, AgentExecutionResult as Q, AgentExecutor as R, AgentExecutorEvent as S, AgentExecutorFactory as T, AgentExecutorFactoryContext as U, AgentExecutorPlane as V, AgentExecutorPlaneBackgroundErrorContext as W, AgentExecutorPlaneBackgroundErrorHandler as X, AgentExecutorPlaneBinding as Y, AgentExecutorPlaneStore as Z, AgentExecutorPreflightResult as _, AgentExecutorTaskReference as a0, AgentExecutorTaskSnapshot as a1, AgentFollowupResult as a2, AgentForkTurns as a3, AgentInterruptScope as a4, AgentJsonObject as a5, AgentJsonValue as a6, AgentLimitReached as a7, AgentListEntry as a8, AgentMailboxMessage as a9, AgentTaskState as aA, AgentTaskUsage as aB, AgentTool as aC, AgentTreeSnapshot as aD, AgentTurn as aE, AgentTurnExecutor as aF, AgentTurnRef as aG, AgentTurnState as aH, AgentTurnSummary as aI, AskUserAnswer as aJ, AskUserCustomInputAnswer as aK, AskUserMultiOptions as aL, AskUserQuestionItem as aM, AskUserQuestionOptions as aN, AskUserSelectionAnswer as aO, CapabilitySupport as aP, CommitLearnedSkillRevisionInput as aQ, CompactionAnchor as aR, CompactionConfig as aS, CompactionDetails as aT, CompactionReport as aU, CompactionResult as aV, CompactionSpanData as aW, CompactionUpdate as aX, CreateAgentExecutorPlaneOptions as aY, CreateLearnedSkillRecordInput as aZ, CurrentTodoSummary as a_, AgentManifest as aa, AgentMessage as ab, AgentMetadataValue as ac, AgentMiddlewareDeclaration as ad, AgentMutationOptions as ae, AgentOutput as af, AgentPreflightInput as ag, AgentPreflightResult as ah, AgentProgressItem as ai, AgentProgressKind as aj, AgentProgressUpdate as ak, AgentReasoningProfile as al, AgentRegistrationEnabledMutationOptions as am, AgentRegistrationMutationOptions as an, AgentRegistrationService as ao, AgentSpanData as ap, AgentSpawnInput as aq, AgentTaskCancellation as ar, AgentTaskCorrelation as as, AgentTaskEvent as at, AgentTaskFilter as au, AgentTaskProgress as av, AgentTaskRegistrationSnapshot as aw, AgentTaskService as ax, AgentTaskSnapshot as ay, AgentTaskStartInput as az, AdmissionAuditOptions as b, KodaXSessionRuntimeInfo as b$, DeclarativeSkillSpec as b0, Deliverable as b1, DiscoveredInstance as b2, DiscoveryOptions as b3, DispatchableAgentDescriptor as b4, DispatchableAgentListing as b5, DispatchableAgentOrigin as b6, DispatchableAgentQuery as b7, EvidenceSpanData as b8, ExactInvokedSkillSnapshot as b9, KodaXGoalStatus as bA, KodaXImageInputArtifact as bB, KodaXImageMediaType as bC, KodaXInputArtifact as bD, KodaXInputArtifactSource as bE, KodaXJsonValue as bF, KodaXMemoryInfluenceRef as bG, KodaXMemoryIntent as bH, KodaXMemoryOutcomeDigest as bI, KodaXMemoryOutcomeEvidence as bJ, KodaXSessionArchiveMarkerEntry as bK, KodaXSessionArtifactLedgerEntry as bL, KodaXSessionBranchSummaryEntry as bM, KodaXSessionClientNoticeEntry as bN, KodaXSessionCompactionEntry as bO, KodaXSessionData as bP, KodaXSessionEntry as bQ, KodaXSessionEntryBase as bR, KodaXSessionGoalEntry as bS, KodaXSessionLabelEntry as bT, KodaXSessionLineage as bU, KodaXSessionMemoryOutcomeDigestEntry as bV, KodaXSessionMemoryReviewReceiptEntry as bW, KodaXSessionMessageEntry as bX, KodaXSessionMeta as bY, KodaXSessionNavigationOptions as bZ, KodaXSessionRewindMarkerEntry as b_, ExternalAgentEffectDeclaration as ba, ExternalAgentHealth as bb, ExternalAgentProtocol as bc, ExternalAgentRegistration as bd, ExternalAgentRegistrationSummary as be, FanoutSpanData as bf, FileOperations as bg, GenerationSpanData as bh, Guardrail as bi, GuardrailSpanData as bj, Handoff as bk, HandoffSpanData as bl, InMemorySessionOptions as bm, InstanceDiscoveryFs as bn, InvariantId as bo, InvariantResult as bp, KodaXCompactMemoryProgress as br, KodaXCompactMemorySeed as bs, KodaXExtensionSessionRecord as bt, KodaXExtensionSessionState as bu, KodaXExtensionStore as bv, KodaXExtensionStoreEntry as bw, KodaXFileInputArtifact as bx, KodaXGoalEventType as by, KodaXGoalState as bz, AdmissionCtx as c, MemoryAutoCuratorResult as c$, KodaXSessionScope as c0, KodaXSessionStorage as c1, KodaXSessionTreeNode as c2, KodaXSessionUiHistoryItem as c3, KodaXSessionUiHistoryItemType as c4, KodaXSessionUiTextHistoryItem as c5, KodaXSessionUiTextHistoryItemType as c6, KodaXSessionUiToolCall as c7, KodaXSessionUiToolCallStatus as c8, KodaXSessionUiToolGroupHistoryItem as c9, LearningActionDriver as cA, LearningCapabilityErrorCode as cC, LearningClientEventState as cD, LearningClientRecord as cE, LearningEvent as cF, LearningEventKind as cG, LearningExplicitUserAuthority as cH, LearningNotificationState as cI, LearningPage as cJ, LearningQuery as cK, LearningReviewEvidencePacket as cL, LearningReviewQualification as cM, LearningReviewVerifierFact as cN, LearningSubscribeOptions as cO, LearningSurfaceSnapshot as cP, LocalAgentTaskInput as cQ, LocalAgentTaskUpdate as cR, ManifestPatch as cT, MemoryActionProposal as cU, MemoryApplicability as cV, MemoryApplyPreview as cW, MemoryApplyResult as cX, MemoryApproval as cY, MemoryAuthority as cZ, MemoryAutoCuratorInput as c_, KodaXSessionWorkspaceKind as ca, KodaXVideoInputArtifact as cb, KodaXVideoMediaType as cc, LearnedAreaPaths as cd, LearnedCapabilityArtifact as cf, LearnedCapabilityCanary as cg, LearnedCapabilityCanaryBinding as ch, LearnedCapabilityCanaryInvocation as ci, LearnedCapabilityCarrier as cj, LearnedCapabilityLifecycle as ck, LearnedCapabilityProvenance as cl, LearnedCapabilityRecord as cm, LearnedCapabilityRecordV1 as cn, LearnedCapabilityRecordV2 as co, LearnedCapabilityScope as cp, LearnedCapabilitySource as cq, LearnedSkillBindingAdmission as cr, LearnedSkillCanaryOutcome as cs, LearnedSkillDecisionDisposition as ct, LearnedSkillInvocationAdmission as cu, LearnedSkillInvokedReceipt as cv, LearnedSkillOfferedReceipt as cw, LearnedSkillOutcomeReceipt as cx, LearnedSkillUsageReceipt as cy, LearningAction as cz, AdmissionVerdict as d, SessionEntry as d$, MemoryBodySnapshot as d0, MemoryClaimKind as d1, MemoryContextIdentity as d2, MemoryController as d3, MemoryCuratorInput as d4, MemoryDecisionTraceReceipt as d5, MemoryEpisodeReviewResult as d6, MemoryEvent as d7, MemoryGovernanceFinding as d8, MemoryGovernanceFindingKind as d9, NormalizedLearnedSkillDecision as dA, ObserveCtx as dB, PersistedSessionState as dC, PresetDispatcher as dD, PresetTracingContext as dE, QualityInvariant as dF, ReadonlyMutationTracker as dG, ReadonlyRecorder as dH, ReasoningDepth as dI, RecentlyModifiedFile as dJ, RunEvent as dK, RunOptions as dL, RunResult as dM, RunnableTool as dN, RunnerEvent as dP, RunnerLlmResult as dQ, RunnerLlmReturn as dR, RunnerRecoveryTranscriptCarrier as dS, RunnerToolCall as dT, RunnerToolContext as dU, RunnerToolObserver as dV, RunnerToolResult as dW, RunnerToolResultBatch as dX, RunnerToolResultBatchTransform as dY, Session as dZ, SessionDispatchResult as d_, MemoryGovernanceReport as da, MemoryItemRef as db, MemoryLifecycle as dc, MemoryLifecycleOperationResult as dd, MemoryPack as de, MemoryPackHint as df, MemoryPackInput as dg, MemoryPackTraceMetadata as dh, MemoryProposalAction as di, MemoryRefFilter as dj, MemoryRefKind as dk, MemoryRejectResult as dl, MemoryReviewCandidateRef as dm, MemoryReviewDraftAction as dn, MemoryReviewInput as dp, MemoryReviewModelInput as dq, MemoryReviewPersistenceDecision as dr, MemoryReviewPersistenceKind as ds, MemoryReviewPlan as dt, MemoryReviewRunner as du, MemoryReviewTrigger as dv, MemoryScope as dw, MemorySourceAdapter as dx, MemoryVisibility as dy, MessageEntry as dz, AdmittedHandle as e, WorkflowProcessSource as e$, SessionErrorMetadata as e0, SessionExtension as e1, SessionForkOptions as e2, SessionMeta as e3, SessionStateSnapshot as e4, Span as e5, SpanData as e6, SpanError as e7, SpanImplOptions as e9, WorkflowArtifactRef as eA, WorkflowBudget as eB, WorkflowEvent as eC, WorkflowEventCorrelation as eD, WorkflowEventType as eF, WorkflowIsolation as eG, WorkflowLimits as eH, WorkflowLogEvent as eI, WorkflowMeta as eJ, WorkflowModelHint as eK, WorkflowModule as eL, WorkflowOutcome as eM, WorkflowOutcomeError as eN, WorkflowOutcomeResult as eO, WorkflowOutcomeStatus as eP, WorkflowOutcomeUsage as eQ, WorkflowParallelOptions as eR, WorkflowProcessArtifact as eS, WorkflowProcessCounts as eT, WorkflowProcessEvent as eU, WorkflowProcessItem as eV, WorkflowProcessItemKind as eW, WorkflowProcessItemOrigin as eX, WorkflowProcessItemStatus as eY, WorkflowProcessProgress as eZ, WorkflowProcessSnapshot as e_, StagedLearnedSkillArtifact as ea, StartTraceOptions as eb, StateWriter as ec, StateWriterFs as ed, StateWriterOptions as ee, StopHookContext as ef, StopHookFn as eg, StopHookResult as eh, StopHookSpanData as ei, SystemCap as ej, TerminalCtx as ek, ToolCallSpanData as el, ToolCapability as em, ToolPermission as en, Trace as eo, TraceOptions as ep, TracerOptions as er, UnifiedLearningReviewModelInput as es, UnifiedLearningReviewResult as et, UnifiedLearningReviewRunner as eu, UserInteraction as ev, WorkflowAgentBackend as ew, WorkflowApi as ex, WorkflowApproval as ey, WorkflowApprovalSummary as ez, Agent as f, WorkflowProcessStatus as f0, WorkflowProcessSummaryStatus as f1, WorkflowProcessTokenUsage as f2, WorkflowProcessTracker as f3, WorkflowProcessTrackerOptions as f4, WorkflowRun as f5, WorkflowRunState as f6, WorkflowRunStatus as f7, WorkflowSpawnAgentInput as f8, WorkflowSynthesis as f9, WorkflowSynthesizeInput as fa, WorkflowTaskHandle as fb, WorkflowTaskResult as fc, WorkflowTaskSnapshot as fd, WorkflowTaskStatus as fe, WorkflowTaskSummaryEventUpdate as ff, WorkflowTaskSummaryKind as fg, WorkflowTaskSummaryUpdate as fh, WorkflowTaskUsage as fi, WorkflowTaskVerification as fj, WorkflowTaskVerificationResult as fk, WorkflowWaitOptions as fl, AgentActor as g, AgentActorClient as h, AgentActorOwner as i, AgentActorSnapshot as j, AgentActorSnapshotV1 as k, AgentActorSnapshotV2 as l, AgentActorState as m, AgentActorStore as n, AgentArtifactDescriptor as o, AgentArtifactPolicy as p, AgentArtifactPolicyDecision as q, AgentArtifactPolicyInput as r, AgentArtifactReference as s, AgentBudgetAdmission as t, AgentBudgetAdmissionInput as u, AgentBudgetExhausted as v, AgentBudgetPort as w, AgentCapabilities as x, AgentCapabilityDeclaration as y, AgentCapabilityRequirements as z };