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

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

@@ -0,0 +1,56 @@
+import { DreamSession } from './autonomous.js';
+import type { Claim } from '../protocol/claim.js';
+import type { ResolvedConfig } from '../config.js';
+import type { Route } from '../formation/transcript.js';
+import type { AcnKnowledge } from '../knowledge/service.js';
+import type { StructuredBackend } from '../llm/structured.js';
+import type { Job } from '../worker/types.js';
+import { EvidenceStore } from './evidence-store.js';
+export type EvidenceExplorer = (input: {
+    store: EvidenceStore;
+    claims: readonly Claim[];
+    route: Route;
+    config: ResolvedConfig['llm'];
+    signal: AbortSignal;
+}) => Promise<void>;
+export type AutonomousDreamRunner = (input: {
+    session: DreamSession;
+    route: Route;
+    config: ResolvedConfig['llm'];
+    system: string;
+    signal: AbortSignal;
+}) => Promise<void>;
+export interface DreamOptions {
+    workspace?: () => Promise<string>;
+    explore?: EvidenceExplorer;
+    run?: AutonomousDreamRunner;
+}
+export declare class AcnDream {
+    readonly knowledge: AcnKnowledge;
+    private readonly backend;
+    private readonly render;
+    private readonly beforeCall?;
+    private readonly options;
+    private readonly unregister;
+    private readonly timers;
+    private eligibilityRetry;
+    private pending;
+    private stopped;
+    private closed;
+    private active;
+    constructor(knowledge: AcnKnowledge, backend: StructuredBackend, render: (name: string, context: object) => string, beforeCall?: (() => Promise<void>) | undefined, options?: DreamOptions);
+    start(): Promise<void>;
+    private schedule;
+    trigger(): void;
+    flush(): Promise<void>;
+    check(): Promise<void>;
+    private eligible;
+    private workspace;
+    request(workspace?: string, sessionId?: string): Promise<Job>;
+    stop(): Promise<number>;
+    private boundary;
+    private call;
+    private run;
+    private compact;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,147 @@
+import { z } from 'zod';
+import type { StoreContext } from '../store/context.js';
+import type { ClaimId } from '../protocol/ids.js';
+import type { SemanticReview } from './schema.js';
+export declare const SyncValidationSchema: z.ZodObject<{
+    validation_id: z.ZodString;
+    input: z.ZodObject<{
+        before: 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>;
+        carriers: 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>>;
+        previous_dependency: z.ZodObject<{
+            before: 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>;
+            retired: 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>;
+            carriers: 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>>;
+        }, z.core.$strip>;
+        current_source: 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.$strict>;
+}, z.core.$strict>;
+export type SyncValidation = z.infer<typeof SyncValidationSchema>;
+export declare class DreamSync {
+    readonly context: StoreContext;
+    private readonly semanticReview;
+    constructor(context: StoreContext, semanticReview?: boolean);
+    resume(jobId: string, sourceId: ClaimId, signal: AbortSignal): Promise<boolean>;
+    prepare(sourceId: ClaimId, carrierIds: readonly ClaimId[], signal?: AbortSignal): Promise<SyncValidation>;
+    private prepareLocked;
+    apply(jobId: string, validation: SyncValidation, review: SemanticReview, signal: AbortSignal): Promise<void>;
+}

package/lib/types/dsh-adapter/configuration-remote.d.ts

@@ -0,0 +1 @@
+export declare const configurationRemote: import("@deepseek-ai/dsh-typert-protocol").TypertRemoteInfo<Readonly<Record<string, import("@deepseek-ai/dsh-typert-protocol").TypertRemoteMethod<object, unknown, "unary", never, unknown> | import("@deepseek-ai/dsh-typert-protocol").TypertRemoteMethod<object, unknown, "stream", unknown, unknown>>>>;

package/lib/types/dsh-adapter/configuration-service.d.ts

@@ -0,0 +1,28 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import type { ConfigurationSnapshot, ConfigurationResult, SaveConfiguration } from '../configuration.js';
+import type { InteractionRequest, InteractionResult } from '../interaction.js';
+import type { CredentialRequest, CredentialResult } from '../credentials.js';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        acnConfiguration: ConfigurationService;
+    }
+}
+export declare function configurationRevision(raw: Record<string, unknown>): string;
+export declare class ConfigurationService extends TypertRemoteService {
+    pending: number;
+    private mutationTail;
+    private readonly stagedCredentials;
+    private protectCredentials;
+    private serialize;
+    credential(request: CredentialRequest, signal?: AbortSignal): Promise<CredentialResult>;
+    private credentialOperation;
+    interact(request: InteractionRequest, signal?: AbortSignal): Promise<InteractionResult>;
+    constructor(ctx: Context);
+    private checkIdle;
+    private entry;
+    private models;
+    read(): Promise<ConfigurationSnapshot>;
+    save(request: SaveConfiguration): Promise<ConfigurationResult>;
+    private saveOperation;
+}

package/lib/types/dsh-adapter/dream-agent.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { AutonomousDreamRunner } from '../dream/service.js';
+export declare function dreamToolGuard(name: string, args: unknown): string | undefined;
+export declare function autonomousDreamRunner(ctx: Context): AutonomousDreamRunner;

package/lib/types/dsh-adapter/dream-evidence.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { EvidenceExplorer } from '../dream/service.js';
+export declare function restrictedExplorer(ctx: Context, system: string): EvidenceExplorer;

package/lib/types/dsh-adapter/formation-archive.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { AcnFormation } from '../formation/service.js';
+export declare function connectArchives(ctx: Context, formation: Pick<AcnFormation, 'beginArchive' | 'cancelArchive' | 'archived' | 'reconcileArchives'>, owns?: (id: string) => Promise<boolean>): Promise<void>;

package/lib/types/dsh-adapter/formation-replay.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { ResolvedConfig } from '../config.js';
+import type { ProjectionReplay } from '../formation/capture.js';
+export declare function formationOwnership(ctx: Context, config: ResolvedConfig): (id: string) => Promise<boolean>;
+export declare function formationReplay(ctx: Context, config: ResolvedConfig): ProjectionReplay;

package/lib/types/dsh-adapter/formation.d.ts

@@ -0,0 +1,4 @@
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import type { Projection } from '../formation/transcript.js';
+export declare function projectEvent(event: SessionEvent): Projection;
+export declare function compactionEnd(event: unknown): number | undefined;

package/lib/types/dsh-adapter/interaction-service.d.ts

@@ -0,0 +1,13 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { InteractionRequest, InteractionResult, KnowledgeView } from '../interaction.js';
+import type { ActivityPage } from '../activities.js';
+import type { RuntimePool } from './runtime-pool.js';
+import type { CredentialResolver } from '../team/http.js';
+export declare function checkTeamConnection(ctx: Context, connection: Extract<InteractionRequest, {
+    action: 'check';
+}>['connection'], credential?: CredentialResolver, signal?: AbortSignal): Promise<InteractionResult>;
+export declare function readKnowledge(pool: RuntimePool, key: string, kind: 'claim' | 'dispute' | 'trace', query: string, offset: number, entities?: boolean, activityOptions?: ActivityPage, filters?: {
+    status?: string;
+    delivery?: string;
+}): Promise<KnowledgeView>;
+export declare function executeInteraction(ctx: Context, input: InteractionRequest, runtimePool?: RuntimePool, signal?: AbortSignal): Promise<InteractionResult>;

package/lib/types/dsh-adapter/knowledge-paths.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { AcnKnowledge } from '../knowledge/service.js';
+export declare function protectKnowledgePaths(ctx: Context, knowledge: AcnKnowledge): void;

package/lib/types/dsh-adapter/llm.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { StructuredBackend } from '../llm/structured.js';
+declare module '@deepseek-ai/dsh-llm' {
+    interface MessageSourceMap {
+        'acn-formation': {
+            kind: 'acn-formation';
+        };
+    }
+}
+export declare function structuredBackend(ctx: Context): StructuredBackend;

package/lib/types/dsh-adapter/project-upstream.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { SessionHeader } from '@deepseek-ai/dsh-session';
+import type { SessionSelection } from './session-binding.js';
+export declare function recentProjectSelection(ctx: Context, current: SessionHeader): Promise<SessionSelection | undefined>;

package/lib/types/dsh-adapter/runtime-pool.d.ts

@@ -0,0 +1,110 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { SessionHeader, SessionEvent } from '@deepseek-ai/dsh-session';
+import { z } from 'zod';
+import type { ResolvedConfig } from '../config.js';
+import { AcnKnowledge } from '../knowledge/service.js';
+import { KnowledgeSessions } from '../knowledge/sessions.js';
+import { AcnFormation } from '../formation/service.js';
+import { AcnInbox } from '../inbox/service.js';
+import { AcnDream } from '../dream/service.js';
+import { UploadScheduler } from '../upload/scheduler.js';
+import type { SessionView } from '../interaction.js';
+export interface Runtime {
+    knowledge: AcnKnowledge;
+    formation: AcnFormation;
+    inbox: AcnInbox;
+    dream: AcnDream;
+    catalog: KnowledgeSessions;
+    uploads: UploadScheduler;
+    components: Set<RuntimeComponent>;
+    setComponent(component: RuntimeComponent, enabled: boolean): Promise<void>;
+    close(): Promise<void>;
+}
+export type RuntimeComponent = 'prompt' | 'formation' | 'inbox' | 'dream';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        acnRuntime: RuntimePool;
+    }
+}
+export declare class RuntimePool {
+    private readonly owner;
+    readonly base: AcnKnowledge;
+    private readonly runtimes;
+    private readonly ready;
+    private readonly workers;
+    private readonly preferredWorkers;
+    private readonly retiredWorkers;
+    private starting;
+    private readonly instructions;
+    private render;
+    private readonly syncs;
+    private readonly syncTasks;
+    private readonly baselines;
+    private readonly baselineRenderers;
+    private readonly admissions;
+    private readonly resumed;
+    private readonly attached;
+    private readonly unboundTools;
+    private readonly components;
+    private pending;
+    private closed;
+    get preparing(): boolean;
+    private host;
+    get ctx(): Context;
+    constructor(owner: Context, base: AcnKnowledge);
+    component(name: RuntimeComponent): () => Promise<void>;
+    supportsJob(key: string, kind: import('../worker/types.js').JobKind): boolean;
+    private enabled;
+    choices(): {
+        key: string;
+        name: string;
+        agentId: string & z.core.$brand<"AgentId">;
+        enabled: boolean;
+        mode: "team" | "solo";
+    }[];
+    config(key: string, includeDisabled?: boolean): ResolvedConfig | undefined;
+    private forSession;
+    private runtimeId;
+    private prefer;
+    private readyFor;
+    backgroundSelection(config: ResolvedConfig): {
+        schemaVersion: 1;
+        key: string;
+        identity: string;
+        prepared: boolean;
+    } | undefined;
+    private selected;
+    private defaultFor;
+    sessionView(header: SessionHeader, events?: readonly SessionEvent[]): Promise<SessionView>;
+    key(header: SessionHeader): string;
+    isBase(key: string): boolean;
+    allowed(header: SessionHeader): boolean;
+    unbound(header: SessionHeader, events?: readonly SessionEvent[]): boolean;
+    chatAllowed(header: SessionHeader): boolean;
+    knowledge(header: SessionHeader): Promise<AcnKnowledge>;
+    service(header: SessionHeader): Promise<{
+        knowledge: AcnKnowledge;
+        formation: AcnFormation | undefined;
+        inbox: AcnInbox | undefined;
+        dream: AcnDream | undefined;
+    }>;
+    activate(key: string): Promise<AcnKnowledge>;
+    dreamService(key: string): Promise<AcnDream | undefined>;
+    registerBaseline(refresh: (id: string, fetchOverview?: boolean) => Promise<void>, render: (header: SessionHeader) => Record<string, string>): () => void;
+    private hasUser;
+    private selectionLocked;
+    view(header: SessionHeader, events?: readonly SessionEvent[]): SessionView;
+    select(header: SessionHeader, key: string): Promise<SessionView>;
+    cancel(header: SessionHeader): Promise<void>;
+    sync(header: SessionHeader): Promise<void>;
+    private synchronize;
+    private ensure;
+    private create;
+    private freezeInstructions;
+    private bind;
+    private attach;
+    private prepareSession;
+    private install;
+    private schedule;
+    close(): Promise<void>;
+}

package/lib/types/dsh-adapter/session-binding.d.ts

@@ -0,0 +1,43 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { SessionHeader, SessionEvent } from '@deepseek-ai/dsh-session';
+import { z } from 'zod';
+import { type ResolvedConfig } from '../config.js';
+declare const BindingSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    identity: z.ZodString;
+}, z.core.$strict>;
+declare const EligibilitySchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+}, z.core.$strict>;
+export declare const SelectionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    key: z.ZodString;
+    identity: z.ZodString;
+    prepared: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type SessionSelection = z.infer<typeof SelectionSchema>;
+declare module '@deepseek-ai/dsh-session' {
+    interface PluginRecordMap {
+        'plugin:acn/session-binding': z.infer<typeof BindingSchema>;
+        'plugin:acn/team-selection': SessionSelection;
+        'plugin:acn/session-eligibility': z.infer<typeof EligibilitySchema>;
+    }
+}
+export declare const identityOf: (config: ResolvedConfig) => string;
+export declare const configurationActivation: (header: SessionHeader) => number;
+export declare function runningConfiguration(header: SessionHeader): ResolvedConfig | undefined;
+export declare function rememberConfiguration(header: SessionHeader, config: ResolvedConfig): void;
+export declare function forgetConfiguration(header: SessionHeader): void;
+export declare function observeSelection(header: SessionHeader, event: SessionEvent): void;
+export declare function restoreSessionBinding(header: SessionHeader, events: readonly SessionEvent[]): void;
+export declare function sessionSelection(ctx: Context, header: SessionHeader): SessionSelection | undefined;
+export declare function sessionHasWork(events: readonly SessionEvent[]): boolean;
+export declare function sessionEligible(ctx: Context, header: SessionHeader, events?: readonly SessionEvent[] | undefined): boolean;
+export declare function markSessionEligible(ctx: Context, header: SessionHeader): void;
+export declare function sessionUnbound(ctx: Context, header: SessionHeader, events?: readonly SessionEvent[]): boolean;
+export declare function bindSession(ctx: Context, config: ResolvedConfig, header: SessionHeader): void;
+export declare const sessionChanged = "ACN \u4F1A\u8BDD\u8EAB\u4EFD\u4E0E\u5F53\u524D\u914D\u7F6E\u4E0D\u4E00\u81F4\uFF0C\u6216\u7F3A\u5C11\u53EF\u9A8C\u8BC1\u7684\u5386\u53F2\u8EAB\u4EFD\u8BB0\u5F55\uFF0C\u8BF7\u65B0\u5EFA\u4F1A\u8BDD\u3002\u65E7\u4F1A\u8BDD\u4E0D\u80FD\u8BBF\u95EE\u5F53\u524D\u8EAB\u4EFD\u7684\u77E5\u8BC6\u3002";
+export declare const configurationBusy = "ACN \u914D\u7F6E\u6B63\u5728\u5E94\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002";
+export declare const unboundSession = "\u672C\u4F1A\u8BDD\u672A\u542F\u7528 ACN\uFF0C\u804A\u5929\u4ECD\u53EF\u7EE7\u7EED\u3002\u53EA\u6709\u5B89\u88C5\u63D2\u4EF6\u540E\u65B0\u5EFA\u4E14\u5C1A\u672A\u53D1\u9001\u6D88\u606F\u7684\u4F1A\u8BDD\u53EF\u9009\u62E9\u5DE5\u4F5C\u914D\u7F6E\uFF1B\u5982\u9700\u4F7F\u7528 ACN\uFF0C\u8BF7\u65B0\u5EFA\u4F1A\u8BDD\u3002";
+export declare function sessionAllowed(ctx: Context, config: ResolvedConfig, header: SessionHeader): boolean;
+export {};

package/lib/types/dsh-adapter/source-sessions.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { SourceSession } from '../interaction.js';
+export declare function sourceSession(ctx: Context, id: string, signal?: AbortSignal): Promise<SourceSession>;

package/lib/types/dsh-adapter/team-credentials.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { CredentialRef } from '@deepseek-ai/dsh-credentials/types';
+import type { CredentialResolver } from '../team/http.js';
+export declare function credentialReference(reference: string): CredentialRef;
+export declare function teamCredentials(ctx: Context): CredentialResolver;

package/lib/types/dsh-adapter/tool-schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+declare const JsonObject: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+export declare function toolParameters(schema: z.ZodType): z.infer<typeof JsonObject>;
+export {};

package/lib/types/dsh-adapter/tools.d.ts

@@ -0,0 +1,5 @@
+import type { ToolDefinition } from '@deepseek-ai/dsh-tools';
+import type { AcnKnowledge } from '../knowledge/service.js';
+import type { SessionHeader } from '@deepseek-ai/dsh-session';
+export declare function claimTool(knowledge: AcnKnowledge, resolve?: (header: SessionHeader) => Promise<AcnKnowledge>): ToolDefinition;
+export declare function consultRouterTool(knowledge: AcnKnowledge, resolve?: (header: SessionHeader) => Promise<AcnKnowledge>): ToolDefinition;

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

@@ -0,0 +1,19 @@
+import { JobError } from '../worker/types.js';
+import type { TranscriptStore, Projection } from './transcript.js';
+export type ProjectionReplay = (id: string) => Promise<readonly Projection[]>;
+export type FormationStage = 'projection' | 'replay' | 'route' | 'scan' | 'enqueue';
+export declare function formationFault(error: unknown): string;
+export declare function retryFormation<T>(action: () => Promise<T>): Promise<T>;
+export declare function projectionError(error: unknown, stage: 'projection' | 'replay', seq?: number): JobError;
+export declare class FormationCapture {
+    private readonly transcript;
+    private readonly replay?;
+    private readonly buffers;
+    private readonly blocked;
+    private readonly restored;
+    constructor(transcript: TranscriptStore, replay?: ProjectionReplay | undefined);
+    add(id: string, projection: Projection): void;
+    drain(id: string, retry?: boolean): Promise<void>;
+    prepare(id: string): Promise<void>;
+    ids(): string[];
+}

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

@@ -0,0 +1,136 @@
+import { z } from 'zod';
+import type { StoreContext } from '../store/context.js';
+import type { Claim } from '../protocol/claim.js';
+import type { JobControl } from '../worker/worker.js';
+import type { PreparedFormation } from './prepare.js';
+import { TranscriptStore } from './transcript.js';
+export declare const CheckpointSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    sessionId: z.ZodString;
+    jobId: z.ZodString;
+    kind: z.ZodEnum<{
+        finalize: "finalize";
+        recap: "recap";
+    }>;
+    fromSeq: z.ZodNumber;
+    untilSeq: z.ZodNumber;
+    status: z.ZodEnum<{
+        prepared: "prepared";
+        applied: "applied";
+    }>;
+    analysisClaims: z.ZodNullable<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>>>;
+    preparedClaims: 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>>;
+    appliedClaims: 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>>;
+    teamAuthorized: z.ZodOptional<z.ZodBoolean>;
+    disputes: z.ZodArray<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>>;
+    trace: z.ZodNullable<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>>;
+    warnings: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type FormationCheckpoint = z.infer<typeof CheckpointSchema>;
+export declare class FormationStore {
+    readonly context: StoreContext;
+    readonly transcript: TranscriptStore;
+    constructor(context: StoreContext);
+    read(sessionId: string): Promise<FormationCheckpoint | null>;
+    private write;
+    recover(): Promise<void>;
+    recoverLocked(): Promise<void>;
+    commit(input: {
+        sessionId: string;
+        jobId: string;
+        kind: 'recap' | 'finalize';
+        fromSeq: number;
+        untilSeq: number;
+        analysisClaims: Claim[];
+        prepared: PreparedFormation;
+        task: string;
+    }, control: JobControl): Promise<{
+        applied: boolean;
+        warnings: string[];
+        claimCount: number;
+        disputeCount: number;
+        traceCount: number;
+        entityIds?: string[];
+    }>;
+    private applyLocked;
+}

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

@@ -0,0 +1,10 @@
+export * from './schema.js';
+export * from './prepare.js';
+export * from './transcript.js';
+export * from './checkpoint.js';
+export * from './service.js';
+export * from '../worker/types.js';
+export * from '../worker/queue.js';
+export * from '../worker/worker.js';
+export * from '../llm/structured.js';
+export * from '../knowledge/alignment.js';