@kodax-ai/kodax 0.7.96 → 0.7.97-alpha.2

package/dist/types-chunks/{types.d-CSv0_cZC.d.ts → review-inbox.d-BeaLRNHx.d.ts}

@@ -1,4 +1,4 @@
-import { k as KodaXMessage } from './types.d-BrQMB-hy.js';
+import { k as KodaXMessage } from './types.d-BjOq57-z.js';
 
 type AgentActorState = 'running' | 'idle' | 'closed';
 type AgentTurnState = 'accepted' | 'running' | 'completed' | 'failed' | 'interrupted';
@@ -574,17 +574,38 @@ type KodaXSessionScope = 'user' | 'managed-task-worker';
 type KodaXSessionUiTextHistoryItemType = 'user' | 'assistant' | 'system' | 'thinking' | 'error' | 'event' | 'info' | 'hint' | 'sidecar';
 type KodaXSessionUiHistoryItemType = KodaXSessionUiTextHistoryItemType | 'tool_group';
 interface KodaXSessionUiTextHistoryItem {
+    /** Host checkpoint provenance; never inferred from display IDs or text. */
+    sourceRunId?: string;
+    sourceTurnId?: string;
+    /** Uncommitted generated output; canonical messages take ownership on save. */
+    outputId?: string;
+    textRevision?: number;
+    /** Source input boundary for retained output without a canonical message. */
+    afterInputId?: string;
+    /** Stable display identity, retained when a live item becomes history. */
+    id?: string;
     type: KodaXSessionUiTextHistoryItemType;
+    /** Accepted client input identity; joins this display item to its canonical user message. */
+    inputId?: string;
     text: string;
     /** Original UI event time in epoch milliseconds. Absent on older sessions. */
     timestamp?: number;
     /** Display-only item that is authoritative even without a canonical message anchor. */
     presentationOnly?: true;
+    /** Verifier facts; absent on legacy items whose icon encoded a single value. */
+    sidecarVerdict?: 'revise' | 'blocked';
+    sidecarDelivery?: 'synthetic-user-message' | 'budget-exhausted' | 'terminal-block';
     icon?: string;
     compactText?: string;
 }
 type KodaXSessionUiToolCallStatus = 'success' | 'error' | 'cancelled' | 'awaiting_approval';
 interface KodaXSessionUiToolCall {
+    /** Generated assistant invocation owning this call; call IDs can repeat. */
+    assistantOutputId?: string;
+    /** Execution crossed the tool boundary; a missing result still has an unknown outcome. */
+    executionBegan?: true;
+    /** A tool result was saved, including an empty result. */
+    resultRecorded?: true;
     id: string;
     name: string;
     status: KodaXSessionUiToolCallStatus;
@@ -598,6 +619,10 @@ interface KodaXSessionUiToolCall {
     endTime?: number;
 }
 interface KodaXSessionUiToolGroupHistoryItem {
+    sourceRunId?: string;
+    sourceTurnId?: string;
+    afterInputId?: string;
+    id?: string;
     type: 'tool_group';
     /** Original UI event time in epoch milliseconds. Absent on older sessions. */
     timestamp?: number;
@@ -606,6 +631,8 @@ interface KodaXSessionUiToolGroupHistoryItem {
 type KodaXSessionUiHistoryItem = KodaXSessionUiTextHistoryItem | KodaXSessionUiToolGroupHistoryItem;
 type KodaXSessionWorkspaceKind = 'detected' | 'managed';
 interface KodaXSessionRuntimeInfo {
+    /** Host-owned task lifetime; delete this Session after its task settles. */
+    temporary?: boolean;
     canonicalRepoRoot?: string;
     workspaceRoot?: string;
     executionCwd?: string;
@@ -1107,5 +1134,226 @@ type MemoryEvent = {
     readonly actionCount: number;
 };
 
-export { hashMemoryIdentityComponent as bg, isMemoryManagementController as bh, matchesMemoryApplicability as bi, memoryApplicabilityFingerprint as bj };
-export type { KodaXGoalStatus as $, AgentActor as A, AgentInterruptScope as B, AgentIterationProgress as C, AgentLimitReached as D, AgentListEntry as E, AgentMailboxMessage as F, AgentMetadataValue as G, AgentMutationOptions as H, AgentOutput as I, AgentProgressItem as J, AgentProgressKind as K, AgentProgressUpdate as L, AgentSpawnInput as M, AgentTreeSnapshot as N, AgentTurn as O, AgentTurnExecutor as P, AgentTurnRef as Q, AgentTurnState as R, AgentTurnSummary as S, KodaXCompactMemoryProgress as T, KodaXCompactMemorySeed as U, KodaXExtensionSessionRecord as V, KodaXExtensionSessionState as W, KodaXExtensionStore as X, KodaXExtensionStoreEntry as Y, KodaXGoalEventType as Z, KodaXGoalState as _, AgentActorClient as a, MemoryRefKind as a$, KodaXHandledMemoryOperation as a0, KodaXJsonValue as a1, KodaXMemoryInfluenceRef as a2, KodaXMemoryIntent as a3, KodaXMemoryOutcomeDigest as a4, KodaXMemoryOutcomeEvidence as a5, KodaXSessionArchiveMarkerEntry as a6, KodaXSessionArtifactLedgerEntry as a7, KodaXSessionBranchSummaryEntry as a8, KodaXSessionClientNoticeEntry as a9, MemoryApplicability as aA, MemoryApplyPreview as aB, MemoryApplyResult as aC, MemoryApproval as aD, MemoryAuthority as aE, MemoryAutoCuratorInput as aF, MemoryAutoCuratorResult as aG, MemoryBodySnapshot as aH, MemoryClaimKind as aI, MemoryContextIdentity as aJ, MemoryController as aK, MemoryCuratorInput as aL, MemoryEpisodeReviewResult as aM, MemoryEvent as aN, MemoryGovernanceFinding as aO, MemoryGovernanceFindingKind as aP, MemoryGovernanceReport as aQ, MemoryItemRef as aR, MemoryLifecycle as aS, MemoryLifecycleOperationResult as aT, MemoryManagementController as aU, MemoryPack as aV, MemoryPackHint as aW, MemoryPackInput as aX, MemoryPackTraceMetadata as aY, MemoryProposalAction as aZ, MemoryRefFilter as a_, KodaXSessionCompactionEntry as aa, KodaXSessionData as ab, KodaXSessionEntry as ac, KodaXSessionEntryBase as ad, KodaXSessionGoalEntry as ae, KodaXSessionLabelEntry as af, KodaXSessionLineage as ag, KodaXSessionMemoryOutcomeDigestEntry as ah, KodaXSessionMemoryReviewReceiptEntry as ai, KodaXSessionMessageEntry as aj, KodaXSessionMeta as ak, KodaXSessionNavigationOptions as al, KodaXSessionRewindMarkerEntry as am, KodaXSessionRuntimeInfo as an, KodaXSessionScope as ao, KodaXSessionStorage as ap, KodaXSessionTreeNode as aq, KodaXSessionUiHistoryItem as ar, KodaXSessionUiHistoryItemType as as, KodaXSessionUiTextHistoryItem as at, KodaXSessionUiTextHistoryItemType as au, KodaXSessionUiToolCall as av, KodaXSessionUiToolCallStatus as aw, KodaXSessionUiToolGroupHistoryItem as ax, KodaXSessionWorkspaceKind as ay, MemoryActionProposal as az, AgentActorOwner as b, MemoryRejectResult as b0, MemoryRememberInput as b1, MemoryRememberResult as b2, MemoryReviewCandidateRef as b3, MemoryReviewDraftAction as b4, MemoryReviewInput as b5, MemoryReviewModelInput as b6, MemoryReviewPersistenceDecision as b7, MemoryReviewPersistenceKind as b8, MemoryReviewPlan as b9, MemoryReviewRunner as ba, MemoryReviewTrigger as bb, MemoryScope as bc, MemorySourceAdapter as bd, MemoryVisibility as be, SessionErrorMetadata as bf, AgentActorSaveAttempt as c, AgentActorSaveDiagnostics as d, AgentActorSavePhase as e, AgentActorSaveTiming as f, AgentActorSnapshot as g, AgentActorSnapshotV1 as h, AgentActorSnapshotV2 as i, AgentActorState as j, AgentActorStore as k, AgentArtifactDescriptor as l, AgentBudgetAdmission as m, AgentBudgetAdmissionInput as n, AgentBudgetExhausted as o, AgentBudgetPort as p, AgentCapabilities as q, AgentDataClassification as r, AgentDetail as s, AgentEvent as t, AgentEventKind as u, AgentExecutionInput as v, AgentExecutionKind as w, AgentExecutionResult as x, AgentFollowupResult as y, AgentForkTurns as z };
+interface PendingEpisodeReviewV1 {
+    readonly version: 1;
+    readonly reviewKey: string;
+    readonly digest: KodaXMemoryOutcomeDigest;
+    readonly ownerSessionRef: string;
+    readonly ownerAgentHash: string;
+    readonly ownerProjectHash?: string;
+    readonly createdAt: string;
+}
+interface PendingEpisodeReviewV2 {
+    readonly version: 2;
+    readonly jobId: string;
+    readonly reviewKey: string;
+    readonly digest: KodaXMemoryOutcomeDigest;
+    readonly ownerSessionRef: string;
+    readonly ownerAgentHash: string;
+    readonly ownerProjectHash?: string;
+    readonly branchId: string;
+    readonly branchEpoch: number;
+    readonly authorityCeiling: 'memory_and_project_skill';
+    readonly createdAt: string;
+}
+type PendingEpisodeReview = PendingEpisodeReviewV1 | PendingEpisodeReviewV2;
+interface PendingEpisodeReviewFilter {
+    readonly configHome?: string;
+    readonly tenantId: string;
+    readonly agentId?: string;
+    /** Omit for every project; pass null for ownerless reviews only. */
+    readonly projectId?: string | null;
+}
+type EpisodeReviewJobStatus = 'pending' | 'processing' | 'decided' | 'completed' | 'attention';
+interface EpisodeReviewJobState {
+    readonly schemaVersion: 1;
+    readonly jobId: string;
+    readonly status: EpisodeReviewJobStatus;
+    readonly claimEpoch: number;
+    readonly claimToken?: string;
+    readonly leaseDeadline?: string;
+    readonly providerAttempts: number;
+    readonly applyAttempts: number;
+    readonly applyAttemptsByCarrier: {
+        readonly memory: number;
+        readonly skill: number;
+    };
+    readonly completionAttempts: number;
+    readonly nextAttemptAt?: string;
+    readonly nextApplyAttemptAt?: string;
+    readonly nextCompletionAttemptAt?: string;
+    readonly lastError?: string;
+    readonly updatedAt: string;
+}
+interface PendingEpisodeReviewSummary {
+    readonly version: 1 | 2;
+    readonly jobId?: string;
+    readonly reviewKey: string;
+    readonly ownerSessionRef: string;
+    readonly createdAt: string;
+    readonly status: EpisodeReviewJobStatus | 'unknown';
+    readonly providerAttempts?: number;
+    readonly applyAttempts?: number;
+    readonly completionAttempts?: number;
+    readonly nextAttemptAt?: string;
+    readonly nextApplyAttemptAt?: string;
+    readonly nextCompletionAttemptAt?: string;
+    readonly lastError?: string;
+}
+interface EpisodeReviewClaim {
+    readonly jobId: string;
+    readonly reviewKey: string;
+    readonly ownerSessionRef: string;
+    readonly branchId: string;
+    readonly branchEpoch: number;
+    readonly epoch: number;
+    readonly token: string;
+    readonly leaseDeadline: string;
+}
+interface EpisodeReviewInputSpec {
+    readonly evidence: unknown;
+    readonly promptRevision: string;
+    readonly schemaRevision: string;
+    readonly policyRevision: string;
+    readonly providerRevision: string;
+}
+interface EpisodeReviewInputCheckpoint extends EpisodeReviewInputSpec {
+    readonly version: 1;
+    readonly jobId: string;
+    readonly evidenceBytes: string;
+    readonly evidenceHash: string;
+    readonly createdAt: string;
+}
+interface EpisodeReviewDecisionInput {
+    readonly inputHash: string;
+    readonly memoryProposalIds: readonly string[];
+    readonly requiredCarriers?: readonly ('memory' | 'skill')[];
+    readonly memoryPlan?: unknown;
+    readonly capabilityDecision?: unknown;
+}
+interface EpisodeReviewDecision extends EpisodeReviewDecisionInput {
+    readonly version: 1;
+    readonly jobId: string;
+    readonly decisionId: string;
+    readonly committedAt: string;
+}
+interface EpisodeReviewActionInput {
+    readonly actionId: string;
+    readonly decisionId: string;
+    readonly carrier: 'memory' | 'skill';
+    readonly resultRefs: readonly string[];
+}
+interface EpisodeReviewActionReceipt extends EpisodeReviewActionInput {
+    readonly version: 1;
+    readonly jobId: string;
+    readonly committedAt: string;
+}
+type EpisodeReviewFailureKind = 'provider_timeout' | 'provider_error' | 'malformed_response' | 'shutdown' | 'budget_unavailable' | 'provider_unavailable';
+declare class EpisodeReviewFailure extends Error {
+    readonly kind: EpisodeReviewFailureKind;
+    constructor(kind: EpisodeReviewFailureKind, message: string);
+}
+interface EpisodeReviewJobSnapshot {
+    readonly envelope: PendingEpisodeReviewV2;
+    readonly state: EpisodeReviewJobState;
+    readonly input?: EpisodeReviewInputCheckpoint;
+    readonly decision?: EpisodeReviewDecision;
+    readonly actions: readonly EpisodeReviewActionReceipt[];
+}
+interface EpisodeReviewReceipt {
+    readonly version: 1;
+    readonly jobId?: string;
+    readonly reviewKey: string;
+    readonly ownerAgentHash?: string;
+    readonly ownerProjectHash?: string;
+    readonly proposalIds: readonly string[];
+    readonly completedAt: string;
+}
+type EpisodeReviewDrainEligibility = 'eligible' | 'discard' | 'defer';
+interface EpisodeReviewDrainOptions {
+    readonly maxEntries?: number;
+    /** Process this just-persisted job before bounded backlog work. */
+    readonly preferredJobId?: string;
+    /** Skip unrelated backlog when searching across alternate project identities. */
+    readonly onlyPreferred?: boolean;
+    /** Epoch-ms deadline: stop claiming new jobs once passed and release an
+     * in-flight claim instead of committing a decision. */
+    readonly deadlineAtMs?: number;
+    /** Cancel new work and await the active reviewer before releasing its claim.
+     * Owned reviewers must honor their signal and settle; neither cancellation nor
+     * the provider timeout detaches a still-running owned reviewer. */
+    readonly abortSignal?: AbortSignal;
+    readonly revalidate: (entry: PendingEpisodeReview) => Promise<EpisodeReviewDrainEligibility>;
+    readonly review: (entry: PendingEpisodeReview, signal?: AbortSignal) => Promise<readonly string[]>;
+    readonly prepareV2Input?: (entry: PendingEpisodeReviewV2) => Promise<EpisodeReviewInputSpec>;
+    readonly decideV2?: (entry: PendingEpisodeReviewV2, input: EpisodeReviewInputCheckpoint, signal: AbortSignal) => Promise<EpisodeReviewDecisionInput>;
+    readonly listV2Actions?: (entry: PendingEpisodeReviewV2, decision: EpisodeReviewDecision) => readonly ('memory' | 'skill')[];
+    readonly applyV2Action?: (entry: PendingEpisodeReviewV2, decision: EpisodeReviewDecision, carrier: 'memory' | 'skill', claim: EpisodeReviewClaim, commitWithAuthority: (effect: (revalidateAuthority: () => Promise<void>) => Promise<readonly string[]>) => Promise<readonly string[]>) => Promise<readonly string[]>;
+    readonly onV2Completed?: (entry: PendingEpisodeReviewV2, decision: EpisodeReviewDecision, proposalIds: readonly string[]) => Promise<void>;
+}
+interface EpisodeReviewDrainResult {
+    readonly reviewed: number;
+    readonly discarded: number;
+    readonly deferred: number;
+    readonly failed: number;
+    readonly failures: readonly {
+        readonly reviewKey: string;
+        readonly error: string;
+    }[];
+}
+declare class EpisodeReviewBranchChangedError extends Error {
+    constructor();
+}
+declare function captureEpisodeReviewBranchEpoch(identity: MemoryContextIdentity): Promise<number>;
+declare function persistPendingEpisodeReview(identity: MemoryContextIdentity, digest: KodaXMemoryOutcomeDigest, options?: {
+    readonly expectedBranchEpoch?: number;
+    readonly persistOwner?: (entry: PendingEpisodeReviewV2) => Promise<void>;
+}): Promise<{
+    readonly path: string;
+    readonly entry: PendingEpisodeReviewV2;
+}>;
+declare function claimEpisodeReview(identity: MemoryContextIdentity, reviewKeyOrJobId: string, options?: {
+    readonly now?: Date;
+    readonly leaseMs?: number;
+}): Promise<EpisodeReviewClaim | undefined>;
+declare function freezeEpisodeReviewInput(identity: MemoryContextIdentity, claim: EpisodeReviewClaim, spec: EpisodeReviewInputSpec, now?: Date): Promise<EpisodeReviewInputCheckpoint>;
+declare function commitEpisodeReviewDecision(identity: MemoryContextIdentity, claim: EpisodeReviewClaim, input: EpisodeReviewDecisionInput, now?: Date): Promise<EpisodeReviewDecision>;
+declare function commitEpisodeReviewAction(identity: MemoryContextIdentity, claim: EpisodeReviewClaim, input: EpisodeReviewActionInput, now?: Date): Promise<EpisodeReviewActionReceipt>;
+declare function withEpisodeReviewClaimAuthority<T>(identity: MemoryContextIdentity, claim: EpisodeReviewClaim, operation: (revalidateAuthority: () => Promise<void>) => Promise<T>): Promise<T>;
+declare function failEpisodeReviewAttempt(identity: MemoryContextIdentity, claim: EpisodeReviewClaim, failure: {
+    readonly kind: EpisodeReviewFailureKind;
+    readonly message: string;
+}, now?: Date): Promise<EpisodeReviewJobState>;
+declare function failEpisodeReviewApply(identity: MemoryContextIdentity, claim: EpisodeReviewClaim, failure: {
+    readonly carrier: 'memory' | 'skill';
+    readonly message: string;
+}, now?: Date): Promise<EpisodeReviewJobState>;
+declare function deferEpisodeReview(identity: MemoryContextIdentity, claim: EpisodeReviewClaim, reason: string, now?: Date): Promise<EpisodeReviewJobState>;
+declare function completeFencedEpisodeReview(identity: MemoryContextIdentity, claim: EpisodeReviewClaim, proposalIds: readonly string[], now?: Date): Promise<{
+    readonly acknowledged: boolean;
+    readonly receiptPath: string;
+}>;
+declare function discardFencedEpisodeReview(identity: MemoryContextIdentity, claim: EpisodeReviewClaim, reason: string, now?: Date): Promise<void>;
+declare function inspectEpisodeReviewJob(identity: MemoryContextIdentity, reviewKeyOrJobId: string): Promise<EpisodeReviewJobSnapshot | undefined>;
+declare function listPendingEpisodeReviews(filter: PendingEpisodeReviewFilter): Promise<readonly PendingEpisodeReview[]>;
+declare function listPendingEpisodeReviewSummaries(filter: PendingEpisodeReviewFilter): Promise<readonly PendingEpisodeReviewSummary[]>;
+declare function completeEpisodeReview(identity: MemoryContextIdentity, reviewKey: string, proposalIds: readonly string[]): Promise<{
+    readonly acknowledged: boolean;
+    readonly receiptPath: string;
+}>;
+/**
+ * Establishes the lock order used by both review completion and Session branch
+ * mutation: the Session root registry first, every sorted tenant branch fence
+ * next, then the caller-owned Session transaction. The supplied fence operation
+ * runs without reacquiring those locks, so a mutation can fence its prospective
+ * lineage and persist that exact lineage atomically with respect to review
+ * effects, new tenant registration and completion delivery.
+ */
+declare function withPendingEpisodeReviewSessionFence<T>(input: {
+    readonly configHome?: string;
+    readonly sessionId: string;
+}, operation: (fence: (activeReviewIds: readonly string[]) => Promise<number>) => Promise<T>): Promise<T>;
+declare function drainPendingEpisodeReviews(identity: MemoryContextIdentity, options: EpisodeReviewDrainOptions): Promise<EpisodeReviewDrainResult>;
+
+export { EpisodeReviewBranchChangedError as V, EpisodeReviewFailure as a0, captureEpisodeReviewBranchEpoch as bC, claimEpisodeReview as bD, commitEpisodeReviewAction as bE, commitEpisodeReviewDecision as bF, completeEpisodeReview as bG, completeFencedEpisodeReview as bH, deferEpisodeReview as bI, discardFencedEpisodeReview as bJ, drainPendingEpisodeReviews as bK, failEpisodeReviewApply as bL, failEpisodeReviewAttempt as bM, freezeEpisodeReviewInput as bN, hashMemoryIdentityComponent as bO, inspectEpisodeReviewJob as bP, isMemoryManagementController as bQ, listPendingEpisodeReviewSummaries as bR, listPendingEpisodeReviews as bS, matchesMemoryApplicability as bT, memoryApplicabilityFingerprint as bU, persistPendingEpisodeReview as bV, withEpisodeReviewClaimAuthority as bW, withPendingEpisodeReviewSessionFence as bX };
+export type { EpisodeReviewDrainResult as $, AgentActor as A, AgentInterruptScope as B, AgentIterationProgress as C, AgentLimitReached as D, AgentListEntry as E, AgentMailboxMessage as F, AgentMetadataValue as G, AgentMutationOptions as H, AgentOutput as I, AgentProgressItem as J, AgentProgressKind as K, AgentProgressUpdate as L, AgentSpawnInput as M, AgentTreeSnapshot as N, AgentTurn as O, AgentTurnExecutor as P, AgentTurnRef as Q, AgentTurnState as R, AgentTurnSummary as S, EpisodeReviewActionInput as T, EpisodeReviewActionReceipt as U, EpisodeReviewClaim as W, EpisodeReviewDecision as X, EpisodeReviewDecisionInput as Y, EpisodeReviewDrainEligibility as Z, EpisodeReviewDrainOptions as _, AgentActorClient as a, MemoryController as a$, EpisodeReviewFailureKind as a1, EpisodeReviewInputCheckpoint as a2, EpisodeReviewInputSpec as a3, EpisodeReviewJobSnapshot as a4, EpisodeReviewJobState as a5, EpisodeReviewJobStatus as a6, EpisodeReviewReceipt as a7, KodaXCompactMemoryProgress as a8, KodaXCompactMemorySeed as a9, KodaXSessionMessageEntry as aA, KodaXSessionMeta as aB, KodaXSessionNavigationOptions as aC, KodaXSessionRewindMarkerEntry as aD, KodaXSessionRuntimeInfo as aE, KodaXSessionScope as aF, KodaXSessionStorage as aG, KodaXSessionTreeNode as aH, KodaXSessionUiHistoryItem as aI, KodaXSessionUiHistoryItemType as aJ, KodaXSessionUiTextHistoryItem as aK, KodaXSessionUiTextHistoryItemType as aL, KodaXSessionUiToolCall as aM, KodaXSessionUiToolCallStatus as aN, KodaXSessionUiToolGroupHistoryItem as aO, KodaXSessionWorkspaceKind as aP, MemoryActionProposal as aQ, MemoryApplicability as aR, MemoryApplyPreview as aS, MemoryApplyResult as aT, MemoryApproval as aU, MemoryAuthority as aV, MemoryAutoCuratorInput as aW, MemoryAutoCuratorResult as aX, MemoryBodySnapshot as aY, MemoryClaimKind as aZ, MemoryContextIdentity as a_, KodaXExtensionSessionRecord as aa, KodaXExtensionSessionState as ab, KodaXExtensionStore as ac, KodaXExtensionStoreEntry as ad, KodaXGoalEventType as ae, KodaXGoalState as af, KodaXGoalStatus as ag, KodaXHandledMemoryOperation as ah, KodaXJsonValue as ai, KodaXMemoryInfluenceRef as aj, KodaXMemoryIntent as ak, KodaXMemoryOutcomeDigest as al, KodaXMemoryOutcomeEvidence as am, KodaXSessionArchiveMarkerEntry as an, KodaXSessionArtifactLedgerEntry as ao, KodaXSessionBranchSummaryEntry as ap, KodaXSessionClientNoticeEntry as aq, KodaXSessionCompactionEntry as ar, KodaXSessionData as as, KodaXSessionEntry as at, KodaXSessionEntryBase as au, KodaXSessionGoalEntry as av, KodaXSessionLabelEntry as aw, KodaXSessionLineage as ax, KodaXSessionMemoryOutcomeDigestEntry as ay, KodaXSessionMemoryReviewReceiptEntry as az, AgentActorOwner as b, MemoryCuratorInput as b0, MemoryEpisodeReviewResult as b1, MemoryEvent as b2, MemoryGovernanceFinding as b3, MemoryGovernanceFindingKind as b4, MemoryGovernanceReport as b5, MemoryItemRef as b6, MemoryLifecycle as b7, MemoryLifecycleOperationResult as b8, MemoryManagementController as b9, PendingEpisodeReviewV2 as bA, SessionErrorMetadata as bB, MemoryPack as ba, MemoryPackHint as bb, MemoryPackInput as bc, MemoryPackTraceMetadata as bd, MemoryProposalAction as be, MemoryRefFilter as bf, MemoryRefKind as bg, MemoryRejectResult as bh, MemoryRememberInput as bi, MemoryRememberResult as bj, MemoryReviewCandidateRef as bk, MemoryReviewDraftAction as bl, MemoryReviewInput as bm, MemoryReviewModelInput as bn, MemoryReviewPersistenceDecision as bo, MemoryReviewPersistenceKind as bp, MemoryReviewPlan as bq, MemoryReviewRunner as br, MemoryReviewTrigger as bs, MemoryScope as bt, MemorySourceAdapter as bu, MemoryVisibility as bv, PendingEpisodeReview as bw, PendingEpisodeReviewFilter as bx, PendingEpisodeReviewSummary as by, PendingEpisodeReviewV1 as bz, AgentActorSaveAttempt as c, AgentActorSaveDiagnostics as d, AgentActorSavePhase as e, AgentActorSaveTiming as f, AgentActorSnapshot as g, AgentActorSnapshotV1 as h, AgentActorSnapshotV2 as i, AgentActorState as j, AgentActorStore as k, AgentArtifactDescriptor as l, AgentBudgetAdmission as m, AgentBudgetAdmissionInput as n, AgentBudgetExhausted as o, AgentBudgetPort as p, AgentCapabilities as q, AgentDataClassification as r, AgentDetail as s, AgentEvent as t, AgentEventKind as u, AgentExecutionInput as v, AgentExecutionKind as w, AgentExecutionResult as x, AgentFollowupResult as y, AgentForkTurns as z };

package/dist/types-chunks/{shell-command-sets.d-oejwpP_7.d.ts → review-packet.d-D4bbTbq3.d.ts}

@@ -1,4 +1,4 @@
-import { bK as RunScopedToolDefinition, a as BashPrefixExtractor } from './bash-prefix-extractor.d-DWFIMg0v.js';
+import { bL as RunScopedToolDefinition, a as BashPrefixExtractor } from './bash-prefix-extractor.d-DvswAXKS.js';
 
 /**
  * Permission Utilities
@@ -294,5 +294,48 @@ declare const MODIFICATION_TOOLS: Set<string>;
 declare const BASH_WRITE_COMMANDS: Set<string>;
 declare const BASH_SAFE_READ_COMMANDS: Set<string>;
 
-export { BASH_SAFE_READ_COMMANDS as B, FILE_MODIFICATION_TOOLS as F, MODIFICATION_TOOLS as M, BASH_WRITE_COMMANDS as a, collectDeterministicBashWriteTargets as b, collectBashWriteTargets as c, getBashOutsideProjectWriteRisk as d, extractPathsFromCommand as e, findGitSubcommandIndex as f, generateSavePattern as g, getDirectShellBypassBlockReason as h, getPlanModeAllowedWritablePaths as i, getPlanModeBlockReason as j, gitSignatureInspectionMayExecute as k, inferPermissionMode as l, isAlwaysConfirmPath as m, isBashReadCommand as n, isBashReadCommandAutoAllowed as o, isBashWriteCommand as p, isCommandOnProtectedPath as q, isHelpCommand as r, isPathInsideProject as s, isPlanModeAllowedPath as t, isShellReadOnlyArgv as u, isToolCallAllowed as v, parseAllowedToolPattern as w, parseGitGrepShortOption as x, tokenizeRawCommandStages as y };
-export type { GitGrepShortOption as G, PermissionMode as P, RawCommandWord as R };
+interface ReviewPacketBudget {
+    readonly maxBytes: number;
+    readonly maxLines: number;
+    readonly maxLineChars: number;
+}
+interface ReviewPacketChunk {
+    readonly path: string;
+    readonly contentHash: string;
+}
+interface ReviewPacketMetadata {
+    readonly packetPath: string;
+    readonly contentHash: string;
+    readonly rangeId: string;
+    readonly partitionKey: string;
+    readonly label: string;
+    readonly baseRef?: string;
+    readonly headRef?: string;
+    readonly scopePaths: readonly string[];
+    readonly riskFlags: readonly 'routing-high'[];
+    readonly budget: ReviewPacketBudget;
+    readonly evidenceChunks: readonly ReviewPacketChunk[];
+    readonly requirementsPresent: boolean;
+    readonly testEvidencePresent: boolean;
+}
+interface ReviewPacketInput {
+    readonly cwd: string;
+    readonly sessionId: string;
+    readonly label: string;
+    /** Exact captured diff bytes. The builder never rereads Git. */
+    readonly diff: string;
+    readonly scope?: 'staged' | 'unstaged' | 'all' | 'compare' | 'commit';
+    readonly baseRef?: string;
+    readonly headRef?: string;
+    readonly customPrompt?: string;
+    readonly requirements?: readonly string[];
+    readonly testEvidence?: readonly string[];
+    /** Must come from KodaXTaskRoutingDecision; no local semantic inference occurs. */
+    readonly routingRisk?: 'low' | 'medium' | 'high';
+    /** Test seam only; production snapshots the existing Read-tool caps. */
+    readonly budget?: ReviewPacketBudget;
+}
+declare function writeReviewPackets(input: ReviewPacketInput): Promise<readonly ReviewPacketMetadata[]>;
+
+export { parseAllowedToolPattern as A, BASH_SAFE_READ_COMMANDS as B, parseGitGrepShortOption as C, tokenizeRawCommandStages as D, writeReviewPackets as E, FILE_MODIFICATION_TOOLS as F, MODIFICATION_TOOLS as M, BASH_WRITE_COMMANDS as a, collectBashWriteTargets as f, collectDeterministicBashWriteTargets as g, extractPathsFromCommand as h, findGitSubcommandIndex as i, generateSavePattern as j, getBashOutsideProjectWriteRisk as k, getDirectShellBypassBlockReason as l, getPlanModeAllowedWritablePaths as m, getPlanModeBlockReason as n, gitSignatureInspectionMayExecute as o, inferPermissionMode as p, isAlwaysConfirmPath as q, isBashReadCommand as r, isBashReadCommandAutoAllowed as s, isBashWriteCommand as t, isCommandOnProtectedPath as u, isHelpCommand as v, isPathInsideProject as w, isPlanModeAllowedPath as x, isShellReadOnlyArgv as y, isToolCallAllowed as z };
+export type { GitGrepShortOption as G, PermissionMode as P, RawCommandWord as R, ReviewPacketBudget as b, ReviewPacketChunk as c, ReviewPacketInput as d, ReviewPacketMetadata as e };