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

package/lib/types/knowledge/service.d.ts

@@ -0,0 +1,52 @@
+import type { ResolvedConfig } from '../config.js';
+import type { AgentId, ClaimId, TraceId } from '../protocol/ids.js';
+import type { Claim } from '../protocol/claim.js';
+import type { StoreContext, StoreLogger } from '../store/context.js';
+import type { ClaimDetail, ClaimListPage, ClaimListQuery, ClaimUpdate, ClaimUpdateResult, KnowledgeVersion, TraceDetail, TraceListPage, TraceListQuery } from './types.js';
+import { FormationStore } from '../formation/checkpoint.js';
+import { TeamFacade } from '../team/service.js';
+import type { TeamStatus } from '../team/service.js';
+import type { CredentialResolver } from '../team/http.js';
+import { DurableWorker } from '../worker/worker.js';
+import { InboxEffectStore } from '../inbox/effects.js';
+import { DreamStore } from '../dream/checkpoint.js';
+export { nextClaimUpdateAt } from './timestamps.js';
+export declare class AcnKnowledge {
+    readonly config: ResolvedConfig;
+    readonly logger: StoreLogger;
+    readonly agentId: AgentId | null;
+    readonly mode: 'solo' | 'team';
+    readonly storeContext: StoreContext | null;
+    readonly team: TeamFacade | null;
+    readonly jobs: DurableWorker | null;
+    private cache;
+    private readonly listeners;
+    constructor(config: ResolvedConfig, logger: StoreLogger, credential?: CredentialResolver);
+    get active(): boolean;
+    get configured(): boolean;
+    teamStatus(): TeamStatus;
+    context(): StoreContext;
+    initialize(): Promise<void>;
+    snapshot(signal?: AbortSignal, lockTimeoutMs?: number): Promise<{
+        claims: Claim[];
+        version: KnowledgeVersion;
+    }>;
+    knowledgeVersion(signal?: AbortSignal, lockTimeoutMs?: number): Promise<KnowledgeVersion>;
+    listClaims(query?: ClaimListQuery, signal?: AbortSignal): Promise<ClaimListPage>;
+    readClaim(id: ClaimId, signal?: AbortSignal): Promise<ClaimDetail>;
+    private readOwnedClaim;
+    updateClaim(input: ClaimUpdate, signal?: AbortSignal): Promise<ClaimUpdateResult>;
+    listTraces(query?: TraceListQuery, signal?: AbortSignal): Promise<TraceListPage>;
+    readTrace(id: TraceId, options?: {
+        taskOffset?: number;
+        taskLimit?: number;
+    }, signal?: AbortSignal): Promise<TraceDetail>;
+    onClaimsChanged(listener: (version: KnowledgeVersion) => void): () => void;
+    applyFormation(...args: Parameters<FormationStore['commit']>): ReturnType<FormationStore['commit']>;
+    applyInboxEffect(...args: Parameters<InboxEffectStore['commit']>): ReturnType<InboxEffectStore['commit']>;
+    private consistentRead;
+    private notifyChanged;
+    dreamStore(): DreamStore;
+    dreamSnapshot(signal: AbortSignal): Promise<Claim[]>;
+    applyDreamGroup(...args: Parameters<DreamStore['commitGroup']>): ReturnType<DreamStore['commitGroup']>;
+}

package/lib/types/knowledge/sessions.d.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import type { AcnKnowledge } from './service.js';
+import { ClaimIndexSchema } from './changes.js';
+export declare const KnowledgeSessionStateSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    catalog: z.ZodOptional<z.ZodObject<{
+        text: z.ZodString;
+        knowledgeVersion: z.ZodObject<{
+            claimsDigest: z.ZodString;
+        }, z.core.$strip>;
+        createdAt: z.ZodString;
+        baseline: z.ZodRecord<z.ZodString, z.ZodObject<{
+            name: z.ZodString;
+            scope: z.ZodString;
+            status: z.ZodEnum<{
+                active: "active";
+                stale: "stale";
+                deprecated: "deprecated";
+            }>;
+            revision: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    lastNotifiedVersion: z.ZodOptional<z.ZodObject<{
+        claimsDigest: z.ZodString;
+    }, z.core.$strip>>;
+    knownClaims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        scope: z.ZodString;
+        status: z.ZodEnum<{
+            active: "active";
+            stale: "stale";
+            deprecated: "deprecated";
+        }>;
+        revision: z.ZodString;
+    }, z.core.$strip>>>;
+    seenSourceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type KnowledgeSessionState = z.infer<typeof KnowledgeSessionStateSchema>;
+export interface ChangeAdmission {
+    text: string;
+    version: {
+        claimsDigest: string;
+    };
+    knownClaims: z.infer<typeof ClaimIndexSchema>;
+}
+export declare class KnowledgeSessions {
+    readonly knowledge: AcnKnowledge;
+    private readonly store;
+    private readonly states;
+    private readonly writes;
+    constructor(knowledge: AcnKnowledge);
+    freeze(id: string, source: 'startup' | 'clear' | 'resume' | 'compact', parentId?: string, fetchOverview?: boolean, signal?: AbortSignal): Promise<void>;
+    catalog(id: string): string;
+    prepare(id: string, signal?: AbortSignal): Promise<ChangeAdmission | null>;
+    admitted(id: string, notice: ChangeAdmission): void;
+    flush(id?: string): Promise<void>;
+    clear(id: string): void;
+    forget(id: string): Promise<void>;
+}

package/lib/types/knowledge/sources.d.ts

@@ -0,0 +1,2 @@
+import type { StoreContext } from '../store/context.js';
+export declare function knowledgeSources(context: StoreContext, entityIds: readonly string[]): Promise<Map<string, string[]>>;

package/lib/types/knowledge/timestamps.d.ts

@@ -0,0 +1 @@
+export declare function nextClaimUpdateAt(now: string, previous: string): string;

package/lib/types/knowledge/types.d.ts

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+import type { Claim, Confidence, ClaimStatus } from '../protocol/claim.js';
+import type { ClaimId, TraceId, AgentId, SourceId } from '../protocol/ids.js';
+export declare const DEFAULT_CLAIM_LIST_LIMIT = 20;
+export declare const MAX_CLAIM_PAGE_LIMIT = 100;
+export declare const DEFAULT_TRACE_TASK_PAGE_LIMIT = 4000;
+export declare const MAX_TRACE_TASK_PAGE_LIMIT = 16000;
+export declare const ClaimUpdateSchema: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+    expected_revision: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    statement: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+    evidence_summary: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        stale: "stale";
+        deprecated: "deprecated";
+    }>>;
+}, z.core.$strict>;
+export type ClaimUpdate = z.infer<typeof ClaimUpdateSchema>;
+export interface BoundedText {
+    text: string;
+    truncated: boolean;
+}
+export interface ClaimSummary {
+    id: ClaimId;
+    name: BoundedText;
+    scope: BoundedText;
+    confidence: Confidence;
+    status: ClaimStatus;
+    updated_at: string;
+}
+export interface Page<T> {
+    items: T[];
+    offset: number;
+    limit: number;
+    omitted: number;
+    next_offset: number | null;
+}
+export type ClaimListPage = Page<ClaimSummary>;
+export interface ClaimDetail {
+    claim: Claim;
+    revision: string;
+}
+export interface ClaimUpdateResult extends ClaimDetail {
+    sync_warning?: string;
+    sync_pending: boolean;
+}
+export interface TraceSummary {
+    id: TraceId;
+    name: string;
+    created_at: string;
+    input_claims: SourceId[];
+    output_claims: ClaimId[];
+}
+export type TraceListPage = Page<TraceSummary>;
+export interface TraceDetail extends TraceSummary {
+    agent: AgentId;
+    task: string;
+    task_offset: number;
+    task_limit: number;
+    task_omitted: number;
+    next_task_offset: number | null;
+}
+export interface ClaimListQuery {
+    query?: string;
+    includeDeprecated?: boolean;
+    offset?: number;
+    limit?: number;
+}
+export interface TraceListQuery {
+    claimId?: ClaimId;
+    offset?: number;
+    limit?: number;
+}
+export interface KnowledgeVersion {
+    claimsDigest: string;
+}

package/lib/types/llm/response.d.ts

@@ -0,0 +1 @@
+export declare function structuredResponseText(text: string): string;

package/lib/types/llm/structured.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import type { ResolvedConfig } from '../config.js';
+import type { StoreContext } from '../store/context.js';
+import { JobError } from '../worker/types.js';
+import type { Route } from '../formation/transcript.js';
+export interface StructuredResponse {
+    text: string;
+    usage?: object;
+}
+export type StructuredPhase = 'candidates' | 'draft' | 'review' | 'sync_review' | 'compaction';
+export type StructuredBackend = (route: Route, system: string, input: string, maxTokens: number, signal: AbortSignal) => Promise<StructuredResponse>;
+export declare function abortable<T>(promise: Promise<T>, signal: AbortSignal): Promise<T>;
+export declare function resolveRoute(config: ResolvedConfig['llm'], context: StoreContext, sessionRoute?: Route): Promise<Route>;
+export declare function transportError(error: unknown): JobError;
+export declare function structuredCall<T>(options: {
+    backend: StructuredBackend;
+    context: StoreContext;
+    config: ResolvedConfig['llm'];
+    route: Route;
+    jobId: string;
+    system: string;
+    input: string;
+    schema: z.ZodType;
+    parse(value: unknown): T;
+    signal: AbortSignal;
+    phase?: StructuredPhase;
+}): Promise<T>;

package/lib/types/local-name.d.ts

@@ -0,0 +1 @@
+export declare function portableLocalName(value: string): boolean;

package/lib/types/plugins/client.d.ts

@@ -0,0 +1,9 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { ConfigurationText } from '../client/locales.js';
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        'acn.configuration': ConfigurationText;
+    }
+}
+export declare const inject: string[];
+export declare function apply(ctx: Context): Promise<void>;

package/lib/types/plugins/commands.d.ts

@@ -0,0 +1,11 @@
+import type { Context } from '@deepseek-ai/cordis';
+export { importCommand } from '../commands/import.js';
+export declare const name = "acn-commands";
+export declare const inject: string[];
+export declare function apply(ctx: Context): void;
+declare const _default: {
+    name: string;
+    inject: string[];
+    apply: typeof apply;
+};
+export default _default;

package/lib/types/plugins/configuration.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from '@deepseek-ai/cordis';
+export declare const name = "acn-configuration";
+export declare function apply(ctx: Context): void;
+declare const _default: {
+    name: string;
+    apply: typeof apply;
+};
+export default _default;

package/lib/types/plugins/dream.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { AcnDream } from '../dream/service.js';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        acnDream: AcnDream;
+    }
+}
+export declare const name = "acn-dream";
+export declare const inject: string[];
+export declare function apply(ctx: Context): Promise<void>;
+declare const _default: {
+    name: string;
+    inject: string[];
+    apply: typeof apply;
+};
+export default _default;

package/lib/types/plugins/formation.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { AcnFormation } from '../formation/service.js';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        acnFormation: AcnFormation;
+    }
+}
+export declare const name = "acn-formation";
+export declare const inject: string[];
+export declare function apply(ctx: Context): Promise<void>;
+declare const _default: {
+    name: string;
+    inject: string[];
+    apply: typeof apply;
+};
+export default _default;

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

@@ -0,0 +1,16 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { AcnInbox } from '../inbox/service.js';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        acnInbox: AcnInbox;
+    }
+}
+export declare const name = "acn-inbox";
+export declare const inject: string[];
+export declare function apply(ctx: Context): Promise<void>;
+declare const _default: {
+    name: string;
+    inject: string[];
+    apply: typeof apply;
+};
+export default _default;

package/lib/types/plugins/knowledge.d.ts

@@ -0,0 +1,19 @@
+import type { Context } from '@deepseek-ai/cordis';
+import Schema from '@deepseek-ai/schemastery';
+import { AcnKnowledge } from '../knowledge/service.js';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        acnKnowledge: AcnKnowledge;
+    }
+}
+export declare const name = "acn-knowledge";
+export declare const inject: string[];
+export declare const Config: Schema;
+export declare function apply(ctx: Context, input?: unknown): Promise<void>;
+declare const _default: {
+    name: string;
+    Config: Schema;
+    inject: string[];
+    apply: typeof apply;
+};
+export default _default;

package/lib/types/plugins/prompt.d.ts

@@ -0,0 +1,17 @@
+import type { Context } from '@deepseek-ai/cordis';
+declare module '@deepseek-ai/dsh-llm' {
+    interface MessageSourceMap {
+        'acn-claim-changes': {
+            kind: 'acn-claim-changes';
+        };
+    }
+}
+export declare const name = "acn-prompt";
+export declare const inject: string[];
+export declare function apply(ctx: Context): Promise<void>;
+declare const _default: {
+    name: string;
+    inject: string[];
+    apply: typeof apply;
+};
+export default _default;

package/lib/types/plugins/tools.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from '@deepseek-ai/cordis';
+export declare const name = "acn-tools";
+export declare const inject: string[];
+export declare function apply(ctx: Context): void;
+declare const _default: {
+    name: string;
+    inject: string[];
+    apply: typeof apply;
+};
+export default _default;

package/lib/types/prompt/render.d.ts

@@ -0,0 +1,2 @@
+export declare function promptRenderer(sources: Readonly<Record<string, string>>): (name: string, context: object) => string;
+export declare function loadPromptRenderer(): Promise<(name: string, context: object) => string>;

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

@@ -0,0 +1,154 @@
+import { z } from 'zod';
+export declare const ClaimAssessmentSchema: 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>;
+export declare const DisputeResolutionSchema: z.ZodPreprocess<z.ZodObject<{
+    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>>;
+}, z.core.$strip>>;
+export declare const ArbitrationResolutionContextSchema: 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>>;
+export type ArbitrationResolutionContext = z.infer<typeof ArbitrationResolutionContextSchema>;
+export type ClaimAssessment = z.infer<typeof ClaimAssessmentSchema>;
+export type DisputeResolution = z.infer<typeof DisputeResolutionSchema>;
+export type ResolutionType = NonNullable<DisputeResolution['resolution_type']>;
+export type ResolutionBasis = NonNullable<DisputeResolution['resolution_basis']>;
+export type ResolvedBy = DisputeResolution['resolved_by'];

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

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+export declare const AuthEnvelopeSchema: z.ZodObject<{
+    agent_id: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+    acn_key: z.ZodString;
+}, z.core.$strict>;
+export declare const authRequestSchema: <T extends z.ZodType>(data: T) => z.ZodObject<{
+    auth: z.ZodObject<{
+        agent_id: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+        acn_key: z.ZodString;
+    }, z.core.$strict>;
+    data: T;
+}, z.core.$strict>;
+export declare const HealthRequestSchema: z.ZodObject<{
+    auth: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        agent_id: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+        acn_key: z.ZodString;
+    }, z.core.$strict>>>;
+    data: z.ZodDefault<z.ZodObject<{}, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const HealthResponseSchema: z.ZodObject<{
+    status: z.ZodString;
+    team_auth_enabled: z.ZodBoolean;
+    auth_passed: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type AuthEnvelope = z.infer<typeof AuthEnvelopeSchema>;
+export interface AuthRequest<T> {
+    auth: AuthEnvelope;
+    data: T;
+}
+export type HealthRequest = z.infer<typeof HealthRequestSchema>;
+export type HealthResponse = z.infer<typeof HealthResponseSchema>;

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

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+export declare const ConfidenceSchema: z.ZodEnum<{
+    high: "high";
+    medium: "medium";
+    low: "low";
+}>;
+export declare const ClaimStatusSchema: z.ZodEnum<{
+    active: "active";
+    stale: "stale";
+    deprecated: "deprecated";
+}>;
+export declare const ClaimSchema: 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>;
+export type Claim = z.infer<typeof ClaimSchema>;
+export type Confidence = z.infer<typeof ConfidenceSchema>;
+export type ClaimStatus = z.infer<typeof ClaimStatusSchema>;
+export declare const effectiveUpdatedAt: (claim: Claim) => string;

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

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const DisputeSchema: 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>;
+export type Dispute = z.infer<typeof DisputeSchema>;
+export type DisputeStatus = Dispute['status'];
+export declare function validateAgentReport(value: unknown): Dispute;

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

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export declare const AgentIdSchema: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+export declare const ClaimIdSchema: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+export declare const TraceIdSchema: z.core.$ZodBranded<z.ZodString, "TraceId", "out">;
+export declare const DisputeIdSchema: z.core.$ZodBranded<z.ZodString, "DisputeId", "out">;
+export declare const PolicyIdSchema: z.core.$ZodBranded<z.ZodString, "PolicyId", "out">;
+export declare const InboxIdSchema: z.core.$ZodBranded<z.ZodString, "InboxId", "out">;
+export declare const ResolutionIdSchema: z.core.$ZodBranded<z.ZodString, "ResolutionId", "out">;
+export declare const SourceIdSchema: z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "ClaimId", "out">, z.core.$ZodBranded<z.ZodString, "PolicyId", "out">]>;
+export type AgentId = z.infer<typeof AgentIdSchema>;
+export type ClaimId = z.infer<typeof ClaimIdSchema>;
+export type TraceId = z.infer<typeof TraceIdSchema>;
+export type DisputeId = z.infer<typeof DisputeIdSchema>;
+export type InboxId = z.infer<typeof InboxIdSchema>;
+export type PolicyId = z.infer<typeof PolicyIdSchema>;
+export type ResolutionId = z.infer<typeof ResolutionIdSchema>;
+export type SourceId = z.infer<typeof SourceIdSchema>;
+export declare function deriveClaimId(createdAt: string, name: string, scope: string, salt?: string): ClaimId;
+export declare function deriveTraceId(createdAt: string, name: string, inputs: readonly string[], outputs: readonly string[], salt?: string): TraceId;
+export declare function deriveDisputeId(createdAt: string, name: string, claims: readonly string[], summary: string, salt?: string): DisputeId;