@kodax-ai/kodax 0.7.77 → 0.7.79

package/dist/types-chunks/{types.d-RdWRfUEs.d.ts → controller.d-RGV7Pjv9.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-DIpZJKUl.js';
+import { k as KodaXMessage, a2 as KodaXToolDefinition, G as KodaXReasoningMode, aa as KodaXWireReasoningEffort, a4 as KodaXToolResultContentItem, Z as KodaXThinkingBlock, J as KodaXRedactedThinkingBlock } from './types.d-CgrXrFrq.js';
 
 type AgentActorState = 'running' | 'idle' | 'closed';
 type AgentTurnState = 'accepted' | 'running' | 'completed' | 'failed' | 'interrupted';
@@ -124,6 +124,8 @@ interface AgentTreeSnapshot {
     readonly activeNonRootTurns: number;
     readonly maxConcurrentThreads: number;
     readonly revision: number;
+    /** Turn-admission state revision; absent only on older/custom clients. */
+    readonly admissionRevision?: number;
 }
 interface AgentTurnSummary {
     readonly turnId: string;
@@ -203,13 +205,16 @@ interface AgentMutationOptions {
     readonly expectedRevision?: number;
     /** Optimistic tree revision checked inside the serialized durable mutation. */
     readonly expectedTreeRevision?: number;
+    /** Optimistic turn-admission revision, excluding progress and mailbox writes. */
+    readonly expectedAdmissionRevision?: number;
 }
 interface AgentTurnExecutor {
     execute(input: AgentExecutionInput): Promise<AgentExecutionResult>;
 }
-interface AgentActorSnapshot {
-    readonly schemaVersion: 1;
+interface AgentActorSnapshotContents {
     readonly revision: number;
+    /** Added after schema v2; legacy snapshots derive it from revision on load. */
+    readonly admissionRevision?: number;
     readonly maxConcurrentThreads: number;
     readonly actors: readonly AgentActor[];
     readonly turns: readonly AgentTurn[];
@@ -220,13 +225,35 @@ 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;
+    /** Stable in-process identity shared by clients bound to the same Actor tree. */
+    readonly admissionScope?: object;
     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>;
@@ -346,26 +373,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 {
@@ -375,9 +423,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';
@@ -617,6 +669,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>;
@@ -1927,6 +1987,172 @@ declare function buildAssistantMessageFromLlmResult(result: RunnerLlmResult): Ag
  */
 declare function buildToolResultMessage(calls: readonly RunnerToolCall[], results: readonly RunnerToolResult[]): AgentMessage;
 
+/**
+ * Guardrail Runtime — FEATURE_085 (v0.7.26).
+ *
+ * Three-tier runtime for Agent guardrails:
+ *
+ *   - `InputGuardrail`: runs once before the first LLM turn, inspects the
+ *     full input transcript, may allow / rewrite / block / escalate.
+ *   - `OutputGuardrail`: runs once before returning, inspects the final
+ *     assistant message, may allow / rewrite / block / escalate.
+ *   - `ToolGuardrail`: runs before and/or after each tool invocation,
+ *     inspects the call / result, may allow / rewrite / block / escalate.
+ *
+ * The four verdict actions:
+ *
+ *   - `allow`: continue with the current value.
+ *   - `rewrite`: replace the current value with `payload`.
+ *   - `block`: throw `GuardrailBlockedError` (for input/output) or surface
+ *     an error tool_result (for tool-before); the LLM / caller sees a
+ *     rejection and must adapt.
+ *   - `escalate`: throw `GuardrailEscalateError`; the SDK consumer catches
+ *     and decides whether to prompt the user, retry under different
+ *     constraints, etc.
+ *
+ * Every guardrail invocation emits a `GuardrailSpan` under the agent's
+ * span when tracing is active.
+ *
+ * @experimental API shape may adjust during v0.7.x rollout.
+ */
+
+/**
+ * Runtime-authenticated intent metadata for permission guardrails.
+ *
+ * This is deliberately separate from the model-visible transcript: a child
+ * briefing is context generated by the Runtime, not a new user authorization.
+ */
+interface GuardrailPermissionIntent {
+    readonly rootUserIntent?: string;
+    readonly delegatedObjective?: string;
+    readonly bindingConstraints?: readonly string[];
+    readonly scopeHint?: string;
+    readonly readOnly?: boolean;
+}
+/**
+ * Shared execution context passed to every guardrail.
+ *
+ * `messages` is the live conversation transcript at the moment this
+ * guardrail fires. For tool-side guardrails this is the transcript at
+ * call-site time — it does NOT yet include the assistant turn that
+ * emitted the current tool_use, since that turn is appended only after
+ * the full tool batch settles. Optional so existing guardrails that
+ * don't read context still type-check; populated by the Runner for all
+ * production hook points.
+ *
+ * Added in FEATURE_092 (v0.7.33) so the auto-mode classifier guardrail
+ * can extract intent context (user prompt + prior tool_use / tool_result
+ * blocks) without reaching into Runner internals.
+ */
+interface GuardrailContext {
+    readonly agent: Agent;
+    readonly abortSignal?: AbortSignal;
+    readonly messages?: readonly AgentMessage[];
+    readonly permissionIntent?: GuardrailPermissionIntent;
+}
+/**
+ * Outcome of a single guardrail check. `payload` shape depends on the hook
+ * point — see the specific guardrail interface for the expected type.
+ */
+type GuardrailVerdict = {
+    readonly action: 'allow';
+} | {
+    readonly action: 'rewrite';
+    readonly payload: unknown;
+    readonly reason?: string;
+} | {
+    readonly action: 'block';
+    readonly reason: string;
+} | {
+    readonly action: 'escalate';
+    readonly reason: string;
+};
+/**
+ * Input-side guardrail. Expected `rewrite` payload shape:
+ * `readonly AgentMessage[]` — the replacement transcript.
+ */
+interface InputGuardrail extends Guardrail {
+    readonly kind: 'input';
+    check(input: readonly AgentMessage[], ctx: GuardrailContext): Promise<GuardrailVerdict>;
+}
+/**
+ * Output-side guardrail. Expected `rewrite` payload shape:
+ * `AgentMessage` — the replacement final assistant message.
+ */
+interface OutputGuardrail extends Guardrail {
+    readonly kind: 'output';
+    check(output: AgentMessage, ctx: GuardrailContext): Promise<GuardrailVerdict>;
+}
+/**
+ * Tool-side guardrail. `beforeTool` rewrite payload shape: `RunnerToolCall`
+ * (replacement call). `afterTool` rewrite payload shape: `RunnerToolResult`
+ * (replacement result). Either hook is optional.
+ */
+interface ToolGuardrail extends Guardrail {
+    readonly kind: 'tool';
+    beforeTool?(call: RunnerToolCall, ctx: GuardrailContext): Promise<GuardrailVerdict>;
+    afterTool?(call: RunnerToolCall, result: RunnerToolResult, ctx: GuardrailContext): Promise<GuardrailVerdict>;
+}
+/**
+ * Thrown when any guardrail returns `{ action: 'block' }`. The Runner
+ * propagates this up to the caller — the run is aborted at that point.
+ */
+declare class GuardrailBlockedError extends Error {
+    readonly guardrailName: string;
+    readonly hookPoint: 'input' | 'output' | 'tool';
+    constructor(guardrailName: string, hookPoint: 'input' | 'output' | 'tool', reason: string);
+}
+/**
+ * Thrown when any guardrail returns `{ action: 'escalate' }`. Callers can
+ * catch and prompt the user or apply a stricter policy before retrying.
+ */
+declare class GuardrailEscalateError extends Error {
+    readonly guardrailName: string;
+    readonly hookPoint: 'input' | 'output' | 'tool';
+    constructor(guardrailName: string, hookPoint: 'input' | 'output' | 'tool', reason: string);
+}
+/** Filter a guardrail list by hook-point. */
+declare function collectGuardrails(guardrails: readonly Guardrail[] | undefined): {
+    input: readonly InputGuardrail[];
+    output: readonly OutputGuardrail[];
+    tool: readonly ToolGuardrail[];
+};
+/**
+ * Run all input guardrails in declaration order. Returns the (possibly
+ * rewritten) transcript. Throws on block / escalate.
+ */
+declare function runInputGuardrails(transcript: readonly AgentMessage[], guardrails: readonly InputGuardrail[], ctx: GuardrailContext, agentSpan: Span | null): Promise<readonly AgentMessage[]>;
+/**
+ * Run all output guardrails in declaration order. Returns the (possibly
+ * rewritten) final assistant message. Throws on block / escalate.
+ */
+declare function runOutputGuardrails(output: AgentMessage, guardrails: readonly OutputGuardrail[], ctx: GuardrailContext, agentSpan: Span | null): Promise<AgentMessage>;
+/**
+ * Outcome of the before-tool guardrail stage.
+ *   - `{ kind: 'allow', call }`: continue to executeRunnerToolCall with `call`
+ *   - `{ kind: 'block', result }`: skip execution; return `result` as the
+ *     tool_result to the LLM (so it sees the rejection and can adapt)
+ */
+type ToolBeforeOutcome = {
+    readonly kind: 'allow';
+    readonly call: RunnerToolCall;
+} | {
+    readonly kind: 'block';
+    readonly call: RunnerToolCall;
+    readonly result: RunnerToolResult;
+};
+/**
+ * Run before-tool guardrails in declaration order. Rewrite replaces the
+ * tool call. Block surfaces an error tool_result to the LLM instead of
+ * throwing — the LLM sees the rejection and adapts. Escalate still throws.
+ */
+declare function runToolBeforeGuardrails(call: RunnerToolCall, guardrails: readonly ToolGuardrail[], ctx: GuardrailContext, agentSpan: Span | null): Promise<ToolBeforeOutcome>;
+/**
+ * Run after-tool guardrails in declaration order. Rewrite replaces the
+ * result content. Block replaces with an error result. Escalate throws.
+ */
+declare function runToolAfterGuardrails(call: RunnerToolCall, result: RunnerToolResult, guardrails: readonly ToolGuardrail[], ctx: GuardrailContext, agentSpan: Span | null): Promise<RunnerToolResult>;
+
 /**
  * Layer A Primitive: Runner
  *
@@ -2003,6 +2229,8 @@ interface RunOptions {
      * this union. See `@kodax-ai/agent/primitives/guardrail.ts` for shape.
      */
     readonly guardrails?: readonly Guardrail[];
+    /** Trusted authority context kept separate from the conversation transcript. */
+    readonly permissionIntent?: GuardrailPermissionIntent;
     /**
      * Per-run override for the tool-loop iteration cap. When omitted, the
      * loop uses `MAX_TOOL_LOOP_ITERATIONS` (20) — a safe ceiling for
@@ -2794,6 +3022,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;
@@ -2892,6 +3122,7 @@ interface MemoryApproval {
     readonly expectedFingerprints: Readonly<Record<string, string>>;
     readonly policyId?: string;
     readonly policyReason?: string;
+    readonly revalidateAuthority?: () => Promise<void>;
 }
 interface MemoryApplyResult {
     readonly proposalId: string;
@@ -3068,7 +3299,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>;
@@ -3095,6 +3334,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
  */
@@ -4007,7 +4635,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>;
@@ -4095,7 +4723,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[]>;
@@ -4140,5 +4768,154 @@ 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 };
+interface AgentControllerOptions {
+    readonly maxConcurrentThreadsPerSession?: number;
+    readonly rootCapabilities?: AgentCapabilities;
+    readonly executor?: AgentTurnExecutor;
+    readonly executorFor?: (kind: AgentExecutionKind) => AgentTurnExecutor;
+    readonly budget?: AgentBudgetPort;
+    readonly store?: AgentActorStore;
+    /** Unique Runtime/controller claim for one durable Session Actor tree. */
+    readonly owner?: AgentActorOwner;
+    /** Conservative liveness probe for a persisted foreign owner. Omitted means alive. */
+    readonly isOwnerAlive?: (owner: AgentActorOwner) => boolean | Promise<boolean>;
+    readonly now?: () => string;
+    readonly warn?: (message: string) => void;
+    readonly onBackgroundError?: (error: unknown) => void;
+    readonly onHealthChanged?: (health: AgentControllerHealth) => void;
+    /** Post-durability event sink. Callback failures never roll back committed actor state. */
+    readonly onEventCommitted?: (event: AgentEvent) => void | Promise<void>;
+    /** Post-durability mailbox sink. Callback failures never roll back committed actor state. */
+    readonly onMessageCommitted?: (message: AgentMailboxMessage) => void | Promise<void>;
+}
+interface AgentControllerHealth {
+    readonly state: 'healthy' | 'recovering' | 'unknown';
+    readonly code?: 'actor_settlement_not_persisted';
+    readonly turnId?: string;
+    readonly message?: string;
+}
+declare class AgentActorController {
+    private readonly options;
+    private readonly actors;
+    private readonly turns;
+    private readonly mailboxes;
+    private readonly acknowledgedCompletionTurnIds;
+    private readonly pendingRootCompletionTurnIds;
+    private readonly eventsLog;
+    private readonly abortControllers;
+    private readonly waiters;
+    private readonly pendingSettlements;
+    private readonly settlementRecoveryMessages;
+    private readonly scheduler;
+    private readonly budget;
+    private readonly now;
+    private readonly admissionScope;
+    private mutationTail;
+    private revision;
+    private admissionRevision;
+    private snapshotSchemaVersion;
+    private durableOwner?;
+    private initialized;
+    private ownershipLost;
+    private ownershipReleased;
+    private closing;
+    private settlementGeneration;
+    private settlementValidityGeneration;
+    private shutdownFailure?;
+    private indeterminateFailure?;
+    private shutdownPromise?;
+    private committedSnapshot;
+    private health;
+    constructor(options?: AgentControllerOptions);
+    healthSnapshot(): AgentControllerHealth;
+    initialize(): Promise<void>;
+    ownsDurableFence(): boolean;
+    bind(callerPath: string): AgentActorClient;
+    /** Trusted host API: register a zero-slot Workflow protocol owner in this tree. */
+    createProtocolOwner(callerPath: string, ownerId: string): Promise<AgentActorClient>;
+    /** Trusted host API: settle a zero-slot Workflow protocol owner. */
+    settleProtocolOwner(ownerPath: string, state: 'completed' | 'failed' | 'interrupted', result: AgentExecutionResult & {
+        readonly error?: string;
+    }): Promise<void>;
+    /** Trusted host API: cancellation signal for a zero-slot Workflow protocol owner. */
+    protocolOwnerSignal(ownerPath: string): AbortSignal;
+    spawn(callerPath: string, input: AgentSpawnInput, options?: AgentMutationOptions): Promise<AgentTurnRef>;
+    send(callerPath: string, targetPath: string, content: string, classification?: AgentDataClassification, forwardedMessageId?: string): Promise<AgentMailboxMessage>;
+    acknowledgeCompletions(callerPath: string, turnIds: readonly string[]): Promise<number>;
+    followup(callerPath: string, targetPath: string, objective: string, metadata?: Readonly<Record<string, AgentMetadataValue>>, options?: AgentMutationOptions): Promise<AgentFollowupResult>;
+    interrupt(callerPath: string, targetPath: string, reason?: string, scope?: AgentInterruptScope): Promise<void>;
+    close(callerPath: string, targetPath: string, reason?: string): Promise<void>;
+    /**
+     * Final local teardown after the host has durably removed the backing store.
+     * No mutation is allowed here because there is no longer a snapshot to save.
+     */
+    disposeAfterStoreRemoval(reason?: string): void;
+    /** Interrupts every local execution while retaining the durable owner fence. */
+    quiesce(reason?: string): Promise<void>;
+    /** Stops in-flight work for process shutdown while preserving reusable Actor identities. */
+    shutdown(reason?: string): Promise<void>;
+    private performShutdown;
+    list(callerPath: string): AgentTreeSnapshot;
+    get(callerPath: string, targetPath: string): AgentDetail;
+    output(callerPath: string, targetPath: string, turnId?: string): AgentOutput;
+    eventSnapshot(callerPath: string, afterSequence?: number): readonly AgentEvent[];
+    private isAcknowledgedDirectChildTerminal;
+    wait(callerPath: string, afterSequence?: number, timeoutMs?: number, signal?: AbortSignal): Promise<AgentEvent | undefined>;
+    private prepareSpawn;
+    private prepareExistingTurn;
+    private admitTurn;
+    private commitStart;
+    private launch;
+    private trackSettlement;
+    private flushPendingSettlements;
+    private completeExecution;
+    private failExecution;
+    private commitExecutionSettlement;
+    private setHealth;
+    private publishSettlementHealth;
+    private finishTurn;
+    private appendCompletion;
+    private drainMailbox;
+    private unreadMailbox;
+    private recordProgress;
+    private resolveForwarding;
+    private appendMessage;
+    private appendEvent;
+    private requireControl;
+    private assertMessagePermission;
+    private isVisible;
+    private visibleActors;
+    private latestTurnSummary;
+    private descendantsInclusive;
+    private createActor;
+    private createTurn;
+    private requireActor;
+    private requireTurn;
+    private requireCommittedActor;
+    private requireCommittedTurn;
+    private requireCommittedControl;
+    private installRoot;
+    private mutate;
+    private snapshot;
+    private restore;
+    private republishUnacknowledgedRootCompletions;
+    private recoverUnmatchedTurns;
+    private claimOwnership;
+    private releaseOwnershipAfterInitializationFailure;
+    private assertWritableOwner;
+    private fenceUnknownSettlement;
+    private stopLocalWork;
+    private fenceAfterSnapshotConflict;
+    private isInterruptionDurable;
+    private notify;
+    private publishCommittedEvent;
+    private publishCommittedMessage;
+    private reportBackgroundError;
+    private reportBackgroundCallbackFailure;
+    private assertExpectedTreeRevision;
+    private assertExpectedAdmissionRevision;
+}
+declare function createAgentActorController(options?: AgentControllerOptions): Promise<AgentActorController>;
+
+export { ASK_USER_BACK_SIGNAL as A, ASK_USER_CUSTOM_INPUT_SIGNAL as a, DEFAULT_SYSTEM_CAP as b2, GuardrailBlockedError as bm, GuardrailEscalateError as bo, InvariantSession as bz, MAX_TOOL_LOOP_ITERATIONS as c$, LearningCapabilityError as cK, LearnedAreaStore as cn, Runner as dY, Tracer as eC, WorkflowEventRecorder as eQ, SpanImpl as ei, exactInvokedSkillSnapshotForSession as f$, admitAndRecordLearnedSkillInvocation as fA, admitLearnedSkillBinding as fB, asSingleSelection as fC, assertLearnedCapabilityTransition as fD, attachRunnerRecoveryTranscript as fE, buildAssistantMessageFromLlmResult as fF, buildSystemPrompt as fG, buildToolResultMessage as fH, canTransitionLearnedCapability as fI, collectGuardrails as fJ, commitLearnedSkillRevision as fK, completeLearnedSkillOutcome as fL, completeLearnedSkillSessionOutcomes as fM, createAgent as fN, createAgentActorController as fO, createHandoff as fP, createInMemorySession as fQ, createInvariantSessionForAgent as fR, createLearnedCapabilityScope as fS, createLearnedSkillRecord as fT, createStateWriter as fU, createTrace as fV, createWorkflowProcessTracker as fW, defaultTracer as fX, detectInstructionsInjection as fY, discoverInstances as fZ, eventFromCapability as f_, _resetAdmittedAgentBindings as fy, _resetPresetDispatchers as fz, executeRunnerToolCall as g0, extractAssistantTextFromMessage as g1, getActiveUserInteraction as g2, getAdmittedAgentBindings as g3, hashMemoryIdentityComponent as g4, invokeLearnedSkillCanary as g5, isAskUserCustomInputAnswer as g6, isFinalWorkflowProcessStatus as g7, isLearnedCapabilityRecordV2 as g8, isRunnableTool as g9, slugifyLearnedCapabilityName as gA, stageLearnedSkillRevision as gB, validateDeclarativeSkillSpec as gC, isRunnerLlmResult as ga, isUnifiedLearningReviewModelInput as gb, learningEventIdFor as gc, learningEventKindForLifecycle as gd, listLearnedSkillUsageReceipts as ge, matchesMemoryApplicability as gf, memoryApplicabilityFingerprint as gg, normalizeHostMetadata as gh, normalizeUnifiedLearningReview as gi, quarantineLearnedSkillRevision as gj, readRunnerRecoveryTranscript as gk, reconcileLearnedSkillBindingOutcomes as gl, recordLearnedSkillOffered as gm, registerPresetDispatcher as gn, releaseLearnedSkillBinding as go, renderDeclarativeSkill as gp, resolveLearnedAreaPaths as gq, resolveProjectLearnedAreaRoot as gr, runAdmissionAudit as gs, runInputGuardrails as gt, runOutputGuardrails as gu, runToolAfterGuardrails as gv, runToolBeforeGuardrails as gw, sanitizeUnifiedLearningReviewInput as gx, setActiveUserInteraction as gy, setAdmittedAgentBindings as gz, AgentActorController as i };
+export type { AgentExecutorPlaneBinding as $, AgentCapabilityRequirements as B, AgentContinuationInput as C, AgentControllerHealth as D, AgentControllerOptions as E, AgentCredentialBroker as F, AgentDataClassification as G, AgentDetail as H, AgentDispatchContext as I, AgentDispatchPolicy as J, AgentDispatchPolicyDecision as K, AgentDispatchPolicyInput as L, AgentDispatchabilitySnapshot as M, AgentDispatchabilityStatus as N, AgentEffectDeclaration as O, AgentEvent as P, AgentEventKind as Q, AgentExecutionInput as R, AgentExecutionKind as S, AgentExecutionResult as T, AgentExecutor as U, AgentExecutorEvent as V, AgentExecutorFactory as W, AgentExecutorFactoryContext as X, AgentExecutorPlane as Y, AgentExecutorPlaneBackgroundErrorContext as Z, AgentExecutorPlaneBackgroundErrorHandler as _, CreateAgentExecutorPlaneOptions as a$, AgentExecutorPlaneStore as a0, AgentExecutorPreflightResult as a1, AgentExecutorProtocol as a2, AgentExecutorTaskReference as a3, AgentExecutorTaskSnapshot as a4, AgentFollowupResult as a5, AgentForkTurns as a6, AgentInterruptScope as a7, AgentJsonObject as a8, AgentJsonValue as a9, AgentTaskService as aA, AgentTaskSnapshot as aB, AgentTaskStartInput as aC, AgentTaskState as aD, AgentTaskUsage as aE, AgentTool as aF, AgentTreeSnapshot as aG, AgentTurn as aH, AgentTurnExecutor as aI, AgentTurnRef as aJ, AgentTurnState as aK, AgentTurnSummary as aL, AskUserAnswer as aM, AskUserCustomInputAnswer as aN, AskUserMultiOptions as aO, AskUserQuestionItem as aP, AskUserQuestionOptions as aQ, AskUserSelectionAnswer as aR, CapabilitySupport as aS, CommitLearnedSkillRevisionInput as aT, CompactionAnchor as aU, CompactionConfig as aV, CompactionDetails as aW, CompactionReport as aX, CompactionResult as aY, CompactionSpanData as aZ, CompactionUpdate as a_, AgentLimitReached as aa, AgentListEntry as ab, AgentMailboxMessage as ac, AgentManifest as ad, AgentMessage as ae, AgentMetadataValue as af, AgentMiddlewareDeclaration as ag, AgentMutationOptions as ah, AgentOutput as ai, AgentPreflightInput as aj, AgentPreflightResult as ak, AgentProgressItem as al, AgentProgressKind as am, AgentProgressUpdate as an, AgentReasoningProfile as ao, AgentRegistrationEnabledMutationOptions as ap, AgentRegistrationMutationOptions as aq, AgentRegistrationService as ar, AgentSpanData as as, AgentSpawnInput as at, AgentTaskCancellation as au, AgentTaskCorrelation as av, AgentTaskEvent as aw, AgentTaskFilter as ax, AgentTaskProgress as ay, AgentTaskRegistrationSnapshot as az, AdmissionAuditOptions as b, KodaXSessionGoalEntry as b$, CreateLearnedSkillRecordInput as b0, CurrentTodoSummary as b1, DeclarativeSkillSpec as b3, Deliverable as b4, DiscoveredInstance as b5, DiscoveryOptions as b6, DispatchableAgentDescriptor as b7, DispatchableAgentListing as b8, DispatchableAgentOrigin as b9, KodaXCompactMemoryProgress as bA, KodaXCompactMemorySeed as bB, KodaXExtensionSessionRecord as bC, KodaXExtensionSessionState as bD, KodaXExtensionStore as bE, KodaXExtensionStoreEntry as bF, KodaXFileInputArtifact as bG, KodaXGoalEventType as bH, KodaXGoalState as bI, KodaXGoalStatus as bJ, KodaXImageInputArtifact as bK, KodaXImageMediaType as bL, KodaXInputArtifact as bM, KodaXInputArtifactSource as bN, KodaXJsonValue as bO, KodaXMemoryInfluenceRef as bP, KodaXMemoryIntent as bQ, KodaXMemoryOutcomeDigest as bR, KodaXMemoryOutcomeEvidence as bS, KodaXSessionArchiveMarkerEntry as bT, KodaXSessionArtifactLedgerEntry as bU, KodaXSessionBranchSummaryEntry as bV, KodaXSessionClientNoticeEntry as bW, KodaXSessionCompactionEntry as bX, KodaXSessionData as bY, KodaXSessionEntry as bZ, KodaXSessionEntryBase as b_, DispatchableAgentQuery as ba, EvidenceSpanData as bb, ExactInvokedSkillSnapshot as bc, ExternalAgentEffectDeclaration as bd, ExternalAgentHealth as be, ExternalAgentProtocol as bf, ExternalAgentRegistration as bg, ExternalAgentRegistrationSummary as bh, FanoutSpanData as bi, FileOperations as bj, GenerationSpanData as bk, Guardrail as bl, GuardrailContext as bn, GuardrailPermissionIntent as bp, GuardrailSpanData as bq, GuardrailVerdict as br, Handoff as bs, HandoffSpanData as bt, InMemorySessionOptions as bu, InputGuardrail as bv, InstanceDiscoveryFs as bw, InvariantId as bx, InvariantResult as by, AdmissionCtx as c, KodaXSessionLabelEntry as c0, KodaXSessionLineage as c1, KodaXSessionMemoryOutcomeDigestEntry as c2, KodaXSessionMemoryReviewReceiptEntry as c3, KodaXSessionMessageEntry as c4, KodaXSessionMeta as c5, KodaXSessionNavigationOptions as c6, KodaXSessionRewindMarkerEntry as c7, KodaXSessionRuntimeInfo as c8, KodaXSessionScope as c9, LearnedSkillBindingAdmission as cA, LearnedSkillCanaryOutcome as cB, LearnedSkillDecisionDisposition as cC, LearnedSkillInvocationAdmission as cD, LearnedSkillInvokedReceipt as cE, LearnedSkillOfferedReceipt as cF, LearnedSkillOutcomeReceipt as cG, LearnedSkillUsageReceipt as cH, LearningAction as cI, LearningActionDriver as cJ, LearningCapabilityErrorCode as cL, LearningClientEventState as cM, LearningClientRecord as cN, LearningEvent as cO, LearningEventKind as cP, LearningExplicitUserAuthority as cQ, LearningNotificationState as cR, LearningPage as cS, LearningQuery as cT, LearningReviewEvidencePacket as cU, LearningReviewQualification as cV, LearningReviewVerifierFact as cW, LearningSubscribeOptions as cX, LearningSurfaceSnapshot as cY, LocalAgentTaskInput as cZ, LocalAgentTaskUpdate as c_, KodaXSessionStorage as ca, KodaXSessionTreeNode as cb, KodaXSessionUiHistoryItem as cc, KodaXSessionUiHistoryItemType as cd, KodaXSessionUiTextHistoryItem as ce, KodaXSessionUiTextHistoryItemType as cf, KodaXSessionUiToolCall as cg, KodaXSessionUiToolCallStatus as ch, KodaXSessionUiToolGroupHistoryItem as ci, KodaXSessionWorkspaceKind as cj, KodaXVideoInputArtifact as ck, KodaXVideoMediaType as cl, LearnedAreaPaths as cm, LearnedCapabilityArtifact as co, LearnedCapabilityCanary as cp, LearnedCapabilityCanaryBinding as cq, LearnedCapabilityCanaryInvocation as cr, LearnedCapabilityCarrier as cs, LearnedCapabilityLifecycle as ct, LearnedCapabilityProvenance as cu, LearnedCapabilityRecord as cv, LearnedCapabilityRecordV1 as cw, LearnedCapabilityRecordV2 as cx, LearnedCapabilityScope as cy, LearnedCapabilitySource as cz, AdmissionVerdict as d, RunnerLlmReturn as d$, ManifestPatch as d0, MemoryActionProposal as d1, MemoryApplicability as d2, MemoryApplyPreview as d3, MemoryApplyResult as d4, MemoryApproval as d5, MemoryAuthority as d6, MemoryAutoCuratorInput as d7, MemoryAutoCuratorResult as d8, MemoryBodySnapshot as d9, MemoryReviewPersistenceDecision as dA, MemoryReviewPersistenceKind as dB, MemoryReviewPlan as dC, MemoryReviewRunner as dD, MemoryReviewTrigger as dE, MemoryScope as dF, MemorySourceAdapter as dG, MemoryVisibility as dH, MessageEntry as dI, NormalizedLearnedSkillDecision as dJ, ObserveCtx as dK, OutputGuardrail as dL, PersistedSessionState as dM, PresetDispatcher as dN, PresetTracingContext as dO, QualityInvariant as dP, ReadonlyMutationTracker as dQ, ReadonlyRecorder as dR, ReasoningDepth as dS, RecentlyModifiedFile as dT, RunEvent as dU, RunOptions as dV, RunResult as dW, RunnableTool as dX, RunnerEvent as dZ, RunnerLlmResult as d_, MemoryClaimKind as da, MemoryContextIdentity as db, MemoryController as dc, MemoryCuratorInput as dd, MemoryDecisionTraceReceipt as de, MemoryEpisodeReviewResult as df, MemoryEvent as dg, MemoryGovernanceFinding as dh, MemoryGovernanceFindingKind as di, MemoryGovernanceReport as dj, MemoryItemRef as dk, MemoryLifecycle as dl, MemoryLifecycleOperationResult as dm, MemoryPack as dn, MemoryPackHint as dp, MemoryPackInput as dq, MemoryPackTraceMetadata as dr, MemoryProposalAction as ds, MemoryRefFilter as dt, MemoryRefKind as du, MemoryRejectResult as dv, MemoryReviewCandidateRef as dw, MemoryReviewDraftAction as dx, MemoryReviewInput as dy, MemoryReviewModelInput as dz, AdmittedHandle as e, WorkflowOutcomeStatus as e$, RunnerRecoveryTranscriptCarrier as e0, RunnerToolCall as e1, RunnerToolContext as e2, RunnerToolObserver as e3, RunnerToolResult as e4, RunnerToolResultBatch as e5, RunnerToolResultBatchTransform as e6, Session as e7, SessionDispatchResult as e8, SessionEntry as e9, Trace as eA, TraceOptions as eB, TracerOptions as eD, UnifiedLearningReviewModelInput as eE, UnifiedLearningReviewResult as eF, UnifiedLearningReviewRunner as eG, UserInteraction as eH, WorkflowAgentBackend as eI, WorkflowApi as eJ, WorkflowApproval as eK, WorkflowApprovalSummary as eL, WorkflowArtifactRef as eM, WorkflowBudget as eN, WorkflowEvent as eO, WorkflowEventCorrelation as eP, WorkflowEventType as eR, WorkflowIsolation as eS, WorkflowLimits as eT, WorkflowLogEvent as eU, WorkflowMeta as eV, WorkflowModelHint as eW, WorkflowModule as eX, WorkflowOutcome as eY, WorkflowOutcomeError as eZ, WorkflowOutcomeResult as e_, SessionErrorMetadata as ea, SessionExtension as eb, SessionForkOptions as ec, SessionMeta as ed, SessionStateSnapshot as ee, Span as ef, SpanData as eg, SpanError as eh, SpanImplOptions as ej, StagedLearnedSkillArtifact as ek, StartTraceOptions as el, StateWriter as em, StateWriterFs as en, StateWriterOptions as eo, StopHookContext as ep, StopHookFn as eq, StopHookResult as er, StopHookSpanData as es, SystemCap as et, TerminalCtx as eu, ToolBeforeOutcome as ev, ToolCallSpanData as ew, ToolCapability as ex, ToolGuardrail as ey, ToolPermission as ez, Agent as f, WorkflowOutcomeUsage as f0, WorkflowParallelOptions as f1, WorkflowProcessArtifact as f2, WorkflowProcessCounts as f3, WorkflowProcessEvent as f4, WorkflowProcessItem as f5, WorkflowProcessItemKind as f6, WorkflowProcessItemOrigin as f7, WorkflowProcessItemStatus as f8, WorkflowProcessProgress as f9, WorkflowProcessSnapshot as fa, WorkflowProcessSource as fb, WorkflowProcessStatus as fc, WorkflowProcessSummaryStatus as fd, WorkflowProcessTokenUsage as fe, WorkflowProcessTracker as ff, WorkflowProcessTrackerOptions as fg, WorkflowRun as fh, WorkflowRunState as fi, WorkflowRunStatus as fj, WorkflowSpawnAgentInput as fk, WorkflowSynthesis as fl, WorkflowSynthesizeInput as fm, WorkflowTaskHandle as fn, WorkflowTaskResult as fo, WorkflowTaskSnapshot as fp, WorkflowTaskStatus as fq, WorkflowTaskSummaryEventUpdate as fr, WorkflowTaskSummaryKind as fs, WorkflowTaskSummaryUpdate as ft, WorkflowTaskUsage as fu, WorkflowTaskVerification as fv, WorkflowTaskVerificationResult as fw, WorkflowWaitOptions as fx, AgentActor as g, AgentActorClient as h, AgentActorOwner as j, AgentActorSnapshot as k, AgentActorSnapshotV1 as l, AgentActorSnapshotV2 as m, AgentActorState as n, AgentActorStore as o, AgentArtifactDescriptor as p, AgentArtifactPolicy as q, AgentArtifactPolicyDecision as r, AgentArtifactPolicyInput as s, AgentArtifactReference as t, AgentBudgetAdmission as u, AgentBudgetAdmissionInput as v, AgentBudgetExhausted as w, AgentBudgetPort as x, AgentCapabilities as y, AgentCapabilityDeclaration as z };