@ftai/dsh-plugin-acn 0.0.0-stage → 0.1.0

package/lib/types/protocol/inbox.d.ts

@@ -0,0 +1,141 @@
+import { z } from 'zod';
+export declare const InboxMessageSchema: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "InboxId", "out">;
+    message_type: z.ZodLiteral<"policy_update">;
+    policy: z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "PolicyId", "out">;
+        message_type: z.ZodDefault<z.ZodEnum<{
+            policy_update: "policy_update";
+            claim_attribute_update: "claim_attribute_update";
+        }>>;
+        name: z.ZodString;
+        statement: z.ZodString;
+        scope: z.ZodString;
+        status: z.ZodEnum<{
+            active: "active";
+            deprecated: "deprecated";
+        }>;
+        created_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        updated_at: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+        target_agents: z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "AgentId", "out">>>>;
+    }, z.core.$strip>;
+    handled_at: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "InboxId", "out">;
+    message_type: z.ZodLiteral<"claim_attribute_update">;
+    policy: z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "PolicyId", "out">;
+        message_type: z.ZodDefault<z.ZodEnum<{
+            policy_update: "policy_update";
+            claim_attribute_update: "claim_attribute_update";
+        }>>;
+        name: z.ZodString;
+        statement: z.ZodString;
+        scope: z.ZodString;
+        status: z.ZodEnum<{
+            active: "active";
+            deprecated: "deprecated";
+        }>;
+        created_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        updated_at: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+        target_agents: z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "AgentId", "out">>>>;
+    }, z.core.$strip>;
+    arbitration_resolution: z.ZodPreprocess<z.ZodOptional<z.ZodPreprocess<z.ZodObject<{
+        context_snapshot_hash: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+        dispute_snapshot: z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodString, "DisputeId", "out">;
+            name: z.ZodString;
+            reporter_agent_id: z.ZodDefault<z.core.$ZodBranded<z.ZodString, "AgentId", "out">>;
+            claims: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">>;
+            summary: z.ZodString;
+            status: z.ZodEnum<{
+                open: "open";
+                resolved: "resolved";
+            }>;
+            created_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            resolved_at: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+        }, z.core.$strip>;
+        direct_claim_snapshots: z.ZodArray<z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+            name: z.ZodString;
+            statement: z.ZodString;
+            scope: z.ZodString;
+            holder: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+            confidence: z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>;
+            status: z.ZodEnum<{
+                active: "active";
+                stale: "stale";
+                deprecated: "deprecated";
+            }>;
+            created_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            updated_at: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+            source_claim_ids: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "ClaimId", "out">, z.core.$ZodBranded<z.ZodString, "PolicyId", "out">]>>>;
+            evidence_summary: z.ZodString;
+        }, z.core.$strip>>;
+        snapshot_source_resolution_id: z.ZodPreprocess<z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ResolutionId", "out">>>;
+        resolution_id: z.core.$ZodBranded<z.ZodString, "ResolutionId", "out">;
+        resolved_by: z.ZodEnum<{
+            human: "human";
+            automatic: "automatic";
+        }>;
+        resolved_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        resolution_type: z.ZodPreprocess<z.ZodOptional<z.ZodEnum<{
+            coexist: "coexist";
+            lifecycle_update: "lifecycle_update";
+            conflict_resolved: "conflict_resolved";
+            unresolved: "unresolved";
+        }>>>;
+        resolution_basis: z.ZodPreprocess<z.ZodOptional<z.ZodEnum<{
+            evidence: "evidence";
+            insufficient_evidence: "insufficient_evidence";
+            direct_analysis: "direct_analysis";
+            prior_resolution: "prior_resolution";
+            policy: "policy";
+        }>>>;
+        conclusion: z.ZodString;
+        claim_assessments: z.ZodPipe<z.ZodDefault<z.ZodArray<z.ZodObject<{
+            claim_id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+            recommended_status: z.ZodEnum<{
+                active: "active";
+                stale: "stale";
+                deprecated: "deprecated";
+            }>;
+            assessment: z.ZodString;
+            recommended_scope: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+            recommended_statement: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+            reason: z.ZodString;
+        }, z.core.$strip>>>, z.ZodTransform<{
+            claim_id: string & z.core.$brand<"ClaimId">;
+            recommended_status: "active" | "stale" | "deprecated";
+            assessment: string;
+            reason: string;
+            recommended_scope?: string | undefined;
+            recommended_statement?: string | undefined;
+        }[] | undefined, {
+            claim_id: string & z.core.$brand<"ClaimId">;
+            recommended_status: "active" | "stale" | "deprecated";
+            assessment: string;
+            reason: string;
+            recommended_scope?: string | undefined;
+            recommended_statement?: string | undefined;
+        }[]>>;
+        rejection_reason: z.ZodPreprocess<z.ZodOptional<z.ZodString>>;
+        dispute_id: z.core.$ZodBranded<z.ZodString, "DisputeId", "out">;
+    }, z.core.$loose>>>>;
+    handled_at: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+}, z.core.$strip>], "message_type">>;
+export type InboxMessage = z.infer<typeof InboxMessageSchema>;
+export declare const InboxAckRequestSchema: z.ZodObject<{
+    agent_id: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+    inbox_ids: z.ZodArray<z.core.$ZodBranded<z.ZodString, "InboxId", "out">>;
+}, z.core.$strip>;
+export declare const InboxPullRequestSchema: z.ZodObject<{
+    agent_id: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+}, z.core.$strip>;
+export type InboxAckRequest = z.infer<typeof InboxAckRequestSchema>;
+export type InboxPullRequest = z.infer<typeof InboxPullRequestSchema>;
+export declare const inboxEventAt: (message: InboxMessage) => string;

package/lib/types/protocol/index.d.ts

@@ -0,0 +1,11 @@
+export * from './ids.js';
+export * from './time.js';
+export * from './claim.js';
+export * from './trace.js';
+export * from './dispute.js';
+export * from './policy.js';
+export * from './arbitration.js';
+export * from './inbox.js';
+export * from './router.js';
+export * from './auth.js';
+export * from './revision.js';

package/lib/types/protocol/policy.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export declare const PolicySchema: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "PolicyId", "out">;
+    message_type: z.ZodDefault<z.ZodEnum<{
+        policy_update: "policy_update";
+        claim_attribute_update: "claim_attribute_update";
+    }>>;
+    name: z.ZodString;
+    statement: z.ZodString;
+    scope: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        deprecated: "deprecated";
+    }>;
+    created_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    updated_at: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+    target_agents: z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "AgentId", "out">>>>;
+}, z.core.$strip>;
+export type Policy = z.infer<typeof PolicySchema>;
+export type PolicyMessageType = Policy['message_type'];
+export type PolicyStatus = Policy['status'];

package/lib/types/protocol/revision.d.ts

@@ -0,0 +1,2 @@
+export declare function canonicalJson(value: unknown): string;
+export declare function claimRevision(value: unknown): string;

package/lib/types/protocol/router.d.ts

@@ -0,0 +1,114 @@
+import { z } from 'zod';
+export declare const AgentQuerySchema: z.ZodObject<{
+    scope: z.ZodString;
+    semantic_query: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare const CandidateClaimSchema: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+    name: z.ZodString;
+    statement: z.ZodString;
+    scope: z.ZodString;
+    holder: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+    confidence: z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+    status: z.ZodEnum<{
+        active: "active";
+        stale: "stale";
+        deprecated: "deprecated";
+    }>;
+    created_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    updated_at: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+    source_claim_ids: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "ClaimId", "out">, z.core.$ZodBranded<z.ZodString, "PolicyId", "out">]>>>;
+    evidence_summary: z.ZodString;
+    open_dispute_ids: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "DisputeId", "out">>>;
+    resolved_dispute_ids: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "DisputeId", "out">>>;
+}, z.core.$strip>;
+export declare const DisputeRefSchema: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "DisputeId", "out">;
+    name: z.ZodString;
+    claim_ids: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">>;
+    summary: z.ZodString;
+    status: z.ZodEnum<{
+        open: "open";
+        resolved: "resolved";
+    }>;
+}, z.core.$strip>;
+export declare const RouterQueryResultSchema: z.ZodObject<{
+    candidate_claims: z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+        name: z.ZodString;
+        statement: z.ZodString;
+        scope: z.ZodString;
+        holder: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+        confidence: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        status: z.ZodEnum<{
+            active: "active";
+            stale: "stale";
+            deprecated: "deprecated";
+        }>;
+        created_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        updated_at: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+        source_claim_ids: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "ClaimId", "out">, z.core.$ZodBranded<z.ZodString, "PolicyId", "out">]>>>;
+        evidence_summary: z.ZodString;
+        open_dispute_ids: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "DisputeId", "out">>>;
+        resolved_dispute_ids: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "DisputeId", "out">>>;
+    }, z.core.$strip>>;
+    disputes: z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "DisputeId", "out">;
+        name: z.ZodString;
+        claim_ids: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">>;
+        summary: z.ZodString;
+        status: z.ZodEnum<{
+            open: "open";
+            resolved: "resolved";
+        }>;
+    }, z.core.$strip>>;
+    retrieval_debug: z.ZodPreprocess<z.ZodOptional<z.ZodObject<{
+        mode: z.ZodString;
+        failed_paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        error_summaries: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        lexical_hits: z.ZodDefault<z.ZodNumber>;
+        vector_hits: z.ZodDefault<z.ZodNumber>;
+        rerank_fallback: z.ZodDefault<z.ZodBoolean>;
+        candidates: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            claim_id: z.ZodString;
+            hit_sources: z.ZodString;
+            lexical_score: z.ZodDefault<z.ZodNumber>;
+            vector_score: z.ZodDefault<z.ZodNumber>;
+            rank_before_rerank: z.ZodDefault<z.ZodNumber>;
+            rank_after_rerank: z.ZodDefault<z.ZodNumber>;
+            vector_status: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const ScopeOverviewItemSchema: z.ZodObject<{
+    scope: z.ZodString;
+    active_claims: z.ZodNumber;
+    stale_claims: z.ZodNumber;
+    open_disputes: z.ZodNumber;
+    resolved_disputes: z.ZodNumber;
+    latest_claim_created_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+}, z.core.$strict>;
+export declare const ScopesOverviewSnapshotSchema: z.ZodObject<{
+    scopes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        scope: z.ZodString;
+        active_claims: z.ZodNumber;
+        stale_claims: z.ZodNumber;
+        open_disputes: z.ZodNumber;
+        resolved_disputes: z.ZodNumber;
+        latest_claim_created_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type RouterQueryResult = z.infer<typeof RouterQueryResultSchema>;
+export type AgentQuery = z.infer<typeof AgentQuerySchema>;
+export type CandidateClaim = z.infer<typeof CandidateClaimSchema>;
+export type DisputeRef = z.infer<typeof DisputeRefSchema>;
+export type ScopeOverviewItem = z.infer<typeof ScopeOverviewItemSchema>;
+export type ScopesOverviewSnapshot = z.infer<typeof ScopesOverviewSnapshotSchema>;

package/lib/types/protocol/schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+export declare const TextSchema: z.ZodString;
+export declare const optional: <T extends z.ZodType>(schema: T) => z.ZodPreprocess<z.ZodOptional<T>>;
+export declare function withAliases<T extends z.ZodType>(schema: T, aliases: Readonly<Record<string, string>>): z.ZodPreprocess<T>;

package/lib/types/protocol/time.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export declare function normalizeTimestamp(input: string): string;
+export declare function timestampNanos(input: string): bigint;
+export declare function nowSeconds(): string;
+export declare const TimestampSchema: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;

package/lib/types/protocol/trace.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export declare const TraceSchema: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "TraceId", "out">;
+    name: z.ZodString;
+    task: z.ZodString;
+    agent: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+    input_claims: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "ClaimId", "out">, z.core.$ZodBranded<z.ZodString, "PolicyId", "out">]>>>;
+    output_claims: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">>>;
+    created_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+}, z.core.$strip>;
+export type Trace = z.infer<typeof TraceSchema>;

package/lib/types/store/atomic.d.ts

@@ -0,0 +1,8 @@
+import type { StoreLogger } from './context.js';
+export declare function writeTextAtomic(path: string, content: string, logger: StoreLogger): Promise<void>;
+export declare function writeTextAtomicIfAbsent(path: string, content: string, logger: StoreLogger): Promise<boolean>;
+export declare function removeFile(path: string, logger: StoreLogger): Promise<void>;
+export declare function cleanupAtomicTemps(root: string, logger: StoreLogger, options?: {
+    olderThanMs?: number;
+    nowMs?: number;
+}): Promise<number>;

package/lib/types/store/claim-edits.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import type { StoreContext } from './context.js';
+export declare const PendingClaimEditSchema: z.ZodObject<{
+    expected_revision: z.ZodString;
+    target: z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+        name: z.ZodString;
+        statement: z.ZodString;
+        scope: z.ZodString;
+        holder: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+        confidence: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        status: z.ZodEnum<{
+            active: "active";
+            stale: "stale";
+            deprecated: "deprecated";
+        }>;
+        created_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        updated_at: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+        source_claim_ids: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "ClaimId", "out">, z.core.$ZodBranded<z.ZodString, "PolicyId", "out">]>>>;
+        evidence_summary: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare class ClaimEditStore {
+    readonly context: StoreContext;
+    constructor(context: StoreContext);
+    write(record: unknown): Promise<void>;
+    recover(): Promise<'none' | 'discarded' | 'queued'>;
+    recoverLocked(): Promise<'none' | 'discarded' | 'queued'>;
+}

package/lib/types/store/claims.d.ts

@@ -0,0 +1,7 @@
+import { type Claim } from '../protocol/claim.js';
+import type { StoreContext } from './context.js';
+import { EntityStore } from './entities.js';
+export declare class ClaimStore extends EntityStore<Claim> {
+    constructor(context: StoreContext);
+    write(value: unknown): Promise<Claim>;
+}

package/lib/types/store/context.d.ts

@@ -0,0 +1,13 @@
+import type { AgentId } from '../protocol/ids.js';
+import type { AgentPaths } from './paths.js';
+export interface StoreLogger {
+    warn(message: string): void;
+    debug(message: string): void;
+}
+export interface StoreContext {
+    paths: AgentPaths;
+    agentId: AgentId;
+    mode: 'solo' | 'team';
+    logger: StoreLogger;
+    lockTimeoutMs?: number;
+}

package/lib/types/store/delivery-status.d.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import type { StoreContext } from './context.js';
+export declare const DeliveryIssueSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        claim: "claim";
+        dispute: "dispute";
+    }>;
+    id: z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "ClaimId", "out">, z.core.$ZodBranded<z.ZodString, "DisputeId", "out">]>;
+    reason: z.ZodEnum<{
+        auth: "auth";
+        client: "client";
+        retryable: "retryable";
+        protocol: "protocol";
+        version: "version";
+        dependency: "dependency";
+        rejected: "rejected";
+    }>;
+    version: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodNumber>;
+    attempts: z.ZodDefault<z.ZodNumber>;
+    updatedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type DeliveryIssue = z.infer<typeof DeliveryIssueSchema>;
+export declare function deliveryTarget(endpoint: string): string;
+export declare class DeliveryStatusStore {
+    readonly context: StoreContext;
+    constructor(context: StoreContext);
+    read(): Promise<{
+        schemaVersion: 1;
+        issues: Record<string, {
+            kind: "claim" | "dispute";
+            id: (string & z.core.$brand<"ClaimId">) | (string & z.core.$brand<"DisputeId">);
+            reason: "auth" | "client" | "retryable" | "protocol" | "version" | "dependency" | "rejected";
+            attempts: number;
+            updatedAt: number;
+            version?: string | undefined;
+            status?: number | undefined;
+        }>;
+        delivered: Record<string, {
+            version: string;
+            target: string;
+        }>;
+    }>;
+    acknowledge(kind: DeliveryIssue['kind'], id: string, version: string, endpoint: string): Promise<void>;
+    record(input: Omit<DeliveryIssue, 'updatedAt' | 'attempts'>): Promise<void>;
+    clear(kind: DeliveryIssue['kind'], id: string): Promise<void>;
+}

package/lib/types/store/disputes.d.ts

@@ -0,0 +1,6 @@
+import { type Dispute } from '../protocol/dispute.js';
+import type { StoreContext } from './context.js';
+import { EntityStore } from './entities.js';
+export declare class DisputeStore extends EntityStore<Dispute> {
+    constructor(context: StoreContext);
+}

package/lib/types/store/entities.d.ts

@@ -0,0 +1,16 @@
+import type { z } from 'zod';
+import type { StoreContext } from './context.js';
+export declare class EntityStore<T extends {
+    id: string;
+}> {
+    readonly context: StoreContext;
+    readonly directory: string;
+    readonly schema: z.ZodType<T>;
+    private readonly idSchema;
+    constructor(context: StoreContext, directory: string, schema: z.ZodType<T>, idSchema: z.ZodType<string>);
+    path(id: string): string;
+    read(id: string): Promise<T>;
+    write(value: unknown): Promise<T>;
+    list(): Promise<T[]>;
+    create(makeId: () => string, makeValue: (id: string) => T): Promise<T>;
+}

package/lib/types/store/errors.d.ts

@@ -0,0 +1,8 @@
+export declare class StoreError extends Error {
+    readonly kind: 'io' | 'decode' | 'encode' | 'conflict' | 'ownership' | 'lock_timeout' | 'lock_order' | 'lock_compromised';
+    constructor(kind: 'io' | 'decode' | 'encode' | 'conflict' | 'ownership' | 'lock_timeout' | 'lock_order' | 'lock_compromised', message: string, options?: ErrorOptions);
+}
+export declare class LockTimeoutError extends StoreError {
+    constructor(path: string);
+}
+export declare function hasCode(error: unknown, code: string): boolean;

package/lib/types/store/inbox.d.ts

@@ -0,0 +1,27 @@
+import { type InboxMessage } from '../protocol/inbox.js';
+import type { StoreContext } from './context.js';
+export interface ClaimedInboxMessage {
+    message: InboxMessage;
+    leaseId: string;
+}
+export declare class InboxStore {
+    readonly context: StoreContext;
+    readonly processingStaleAfterSecs: number;
+    constructor(context: StoreContext, processingStaleAfterSecs?: number);
+    private locked;
+    private names;
+    private leasePath;
+    private exists;
+    acceptPulled(value: unknown): Promise<void>;
+    private pending;
+    listPending(): Promise<InboxMessage[]>;
+    hasUnfinished(): Promise<boolean>;
+    private recoverUnlocked;
+    recoverStale(nowMs?: number): Promise<number>;
+    recoverOrphans(): Promise<number>;
+    claimPending(limit?: number): Promise<ClaimedInboxMessage[]>;
+    validateSnapshotLocked(message: InboxMessage): Promise<string[]>;
+    completeSnapshotLocked(message: InboxMessage): Promise<void>;
+    complete(claimed: ClaimedInboxMessage): Promise<void>;
+    release(claimed: ClaimedInboxMessage): Promise<void>;
+}

package/lib/types/store/index.d.ts

@@ -0,0 +1,16 @@
+export * from './errors.js';
+export * from './paths.js';
+export * from './context.js';
+export * from './atomic.js';
+export * from './yaml.js';
+export * from './lock.js';
+export * from './entities.js';
+export * from './claims.js';
+export * from './traces.js';
+export * from './disputes.js';
+export * from './inbox.js';
+export * from './uploads.js';
+export * from './reported-sets.js';
+export * from './claim-edits.js';
+export * from './session-state.js';
+export * from './jobs.js';

package/lib/types/store/jobs.d.ts

@@ -0,0 +1,5 @@
+import type { StoreContext } from './context.js';
+import { VersionedFileStore } from './session-state.js';
+export declare class JobStore extends VersionedFileStore {
+    constructor(context: StoreContext);
+}

package/lib/types/store/lock.d.ts

@@ -0,0 +1,11 @@
+export interface LockOptions {
+    timeoutMs?: number | undefined;
+    staleMs?: number | undefined;
+    signal?: AbortSignal | undefined;
+}
+export declare function acquireFileLease(path: string, options?: LockOptions): Promise<{
+    check(): void;
+    release(): Promise<void>;
+}>;
+export declare function withFileLock<T>(path: string, action: () => Promise<T>, options?: LockOptions): Promise<T>;
+export declare function withFileLocks<T>(paths: readonly string[], action: () => Promise<T>, options?: LockOptions): Promise<T>;

package/lib/types/store/path-names.d.ts

@@ -0,0 +1,2 @@
+export declare function invalidStorageName(name: string, platform?: NodeJS.Platform): boolean;
+export declare function assertStorageName(name: string): void;

package/lib/types/store/paths.d.ts

@@ -0,0 +1,45 @@
+export declare function expandHomePath(home: string): string;
+export declare function agentHomePath(home: string, agentId: string): string;
+export declare function safeKey(value: string): string;
+export declare class AgentPaths {
+    readonly root: string;
+    constructor(agentHome: string);
+    get claims(): string;
+    get traces(): string;
+    get disputes(): string;
+    get inbox(): string;
+    get uploads(): string;
+    get pendingUploads(): string;
+    get pendingUploadsLock(): string;
+    get rejectedDisputes(): string;
+    get deliveryStatus(): string;
+    get deliveryLock(): string;
+    get knowledgeLock(): string;
+    get claimEditPending(): string;
+    get reportedSets(): string;
+    get jobs(): string;
+    get workerLock(): string;
+    get jobQueueLock(): string;
+    get sessions(): string;
+    get lastRoute(): string;
+    get dreamWorkspace(): string;
+    get llmCalls(): string;
+    get dreamRoot(): string;
+    get dreamState(): string;
+    get dreamPending(): string;
+    dreamJob(id: string): string;
+    dreamFinal(id: string): string;
+    dreamExecution(id: string, validation: string): string;
+    transcript(id: string): string;
+    transcriptPending(id: string): string;
+    claim(id: string): string;
+    trace(id: string): string;
+    dispute(id: string): string;
+    pendingInbox(id: string): string;
+    doneInbox(id: string): string;
+    inboxEffect(id: string): string;
+    session(id: string): string;
+    sessionState(id: string): string;
+    finalizeCheckpoint(id: string): string;
+    job(id: string): string;
+}

package/lib/types/store/presentation.d.ts

@@ -0,0 +1,13 @@
+import type { StoreContext } from './context.js';
+export declare class PresentationStore {
+    private readonly context;
+    private readonly path;
+    constructor(context: StoreContext);
+    read(): Promise<{
+        schemaVersion: 1;
+        baselineAt: number;
+        seen: Record<string, number>;
+    } | null>;
+    initialize(): Promise<void>;
+    acknowledge(id: string, version: number): Promise<void>;
+}

package/lib/types/store/regular-file.d.ts

@@ -0,0 +1,2 @@
+import fs from 'node:fs/promises';
+export declare function openSingleFile(path: string, invalid: () => Error): Promise<fs.FileHandle>;

package/lib/types/store/rejected-disputes.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { type Dispute } from '../protocol/dispute.js';
+import type { StoreContext } from './context.js';
+declare const RejectionsSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    dispute_id: z.core.$ZodBranded<z.ZodString, "DisputeId", "out">;
+    status: z.ZodLiteral<409>;
+    attempts: z.ZodDefault<z.ZodNumber>;
+    rejected_at: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+}, z.core.$strip>>;
+export declare const disputeVersion: (dispute: Dispute) => string;
+export declare class RejectedDisputeStore {
+    readonly context: StoreContext;
+    constructor(context: StoreContext);
+    read(includeHistory?: boolean): Promise<z.infer<typeof RejectionsSchema>>;
+    contains(dispute: Dispute): Promise<boolean>;
+    record(dispute: Dispute, attempts?: number): Promise<void>;
+}
+export {};

package/lib/types/store/rename.d.ts

@@ -0,0 +1 @@
+export declare function renameFile(source: string, destination: string): Promise<void>;