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

package/lib/types/dream/evidence-store.d.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import type { ResolvedConfig } from '../config.js';
+import type { StoreContext } from '../store/context.js';
+import type { Claim } from '../protocol/claim.js';
+import { type Receipts } from './evidence.js';
+export declare const ReadArgs: z.ZodObject<{
+    path: z.ZodString;
+    claim_ids: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">>;
+    start: z.ZodDefault<z.ZodNumber>;
+    count: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const GlobArgs: z.ZodObject<{
+    query: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>;
+export declare const GrepArgs: z.ZodObject<{
+    query: z.ZodString;
+}, z.core.$strict>;
+export declare const ClaimArgs: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"list">;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"read">;
+    id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+}, z.core.$strict>], "action">;
+export declare const EvidenceTools: {
+    read: z.ZodObject<{
+        path: z.ZodString;
+        claim_ids: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">>;
+        start: z.ZodDefault<z.ZodNumber>;
+        count: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+    glob: z.ZodObject<{
+        query: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>;
+    grep: z.ZodObject<{
+        query: z.ZodString;
+    }, z.core.$strict>;
+    claim: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"list">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"read">;
+        id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+    }, z.core.$strict>], "action">;
+};
+export type EvidenceTool = keyof typeof EvidenceTools;
+export declare const EvidenceManifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    job_id: z.ZodString;
+    group_id: z.ZodString;
+    workspace_root: z.ZodString;
+    claim_versions: z.ZodRecord<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">, z.ZodString>;
+    receipts: z.ZodRecord<z.ZodString, z.ZodObject<{
+        tool: z.ZodLiteral<"file_read">;
+        input: z.ZodObject<{
+            path: z.ZodString;
+            claim_ids: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">>>;
+            show_linenos: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$loose>;
+        output: z.ZodObject<{
+            content: z.ZodString;
+            page: z.ZodOptional<z.ZodObject<{
+                returned_start: z.ZodNumber;
+                returned_end: z.ZodNumber;
+            }, z.core.$loose>>;
+            file_version: z.ZodObject<{
+                path: z.ZodString;
+                revision: z.ZodObject<{
+                    sha256: z.ZodString;
+                    byte_len: z.ZodNumber;
+                }, z.core.$strict>;
+            }, z.core.$strip>;
+        }, z.core.$loose>;
+    }, z.core.$loose>>;
+    calls: z.ZodNumber;
+    model_steps: z.ZodNumber;
+    bytes_read: z.ZodNumber;
+    files_examined: z.ZodNumber;
+    limits: z.ZodObject<{
+        calls: z.ZodNumber;
+        steps: z.ZodNumber;
+        bytes: z.ZodNumber;
+        chars: z.ZodNumber;
+        files: z.ZodNumber;
+    }, z.core.$strict>;
+    completed: z.ZodBoolean;
+}, z.core.$strict>;
+export type EvidenceManifest = z.infer<typeof EvidenceManifestSchema>;
+export declare const privateDataHome: (context: StoreContext) => string;
+export declare class EvidenceStore {
+    readonly context: StoreContext;
+    readonly jobId: string;
+    readonly groupId: string;
+    readonly path: string;
+    constructor(context: StoreContext, jobId: string, groupId: string);
+    read(): Promise<EvidenceManifest | null>;
+    private save;
+    initialize(workspace: string, claims: readonly Claim[], config: ResolvedConfig['dream'], signal?: AbortSignal): Promise<EvidenceManifest>;
+    admitStep(signal: AbortSignal): Promise<void>;
+    reopen(signal: AbortSignal): Promise<void>;
+    complete(signal: AbortSignal): Promise<void>;
+    current(manifest: EvidenceManifest): Promise<boolean>;
+    authorize(receipts: Receipts, workspace: string | undefined, before: readonly Claim[]): Promise<boolean>;
+    execute(name: EvidenceTool, args: unknown, claims: readonly Claim[], signal: AbortSignal): Promise<z.infer<ReturnType<typeof z.json>>>;
+}

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

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import type { ClaimId } from '../protocol/ids.js';
+export declare const ReceiptSchema: z.ZodObject<{
+    tool: z.ZodLiteral<"file_read">;
+    input: z.ZodObject<{
+        path: z.ZodString;
+        claim_ids: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">>>;
+        show_linenos: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>;
+    output: z.ZodObject<{
+        content: z.ZodString;
+        page: z.ZodOptional<z.ZodObject<{
+            returned_start: z.ZodNumber;
+            returned_end: z.ZodNumber;
+        }, z.core.$loose>>;
+        file_version: z.ZodObject<{
+            path: z.ZodString;
+            revision: z.ZodObject<{
+                sha256: z.ZodString;
+                byte_len: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strip>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export type Receipt = z.infer<typeof ReceiptSchema>;
+export type Receipts = Record<string, z.infer<ReturnType<typeof z.json>>>;
+export declare function independentReceipt(receipts: Receipts, id: string): Receipt | null;
+export declare function directEvidence(receipts: Receipts, ids: readonly string[], claimId: ClaimId): string[];
+export declare function evidenceBody(receipt: Receipt): string;
+export declare function requireEvidenceIds(ids: readonly string[], available: readonly string[], message: string): void;

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

@@ -0,0 +1,10 @@
+export * from './schema.js';
+export * from './plan.js';
+export * from './review.js';
+export * from './candidates.js';
+export * from './checkpoint.js';
+export * from './service.js';
+export * from './sync.js';
+export * from './evidence.js';
+export * from './evidence-files.js';
+export * from './evidence-store.js';

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

@@ -0,0 +1,18 @@
+import type { Claim } from '../protocol/claim.js';
+import type { AgentId, ClaimId } from '../protocol/ids.js';
+import type { Candidate, DraftGroup, Group, PreparedGroup, Validation } from './schema.js';
+import { type Receipts } from './evidence.js';
+export declare const contentHash: (claim: Claim) => string;
+export declare function valueHash(value: unknown): string;
+export declare function sameIds(a: readonly string[], b: readonly string[]): boolean;
+export declare function validateCandidates(candidates: readonly Candidate[], readable: readonly Claim[], owner: AgentId, evidenceEnabled?: boolean): void;
+export declare function expandDraft(draft: DraftGroup, readable: readonly Claim[]): Group;
+export declare function reaches(id: ClaimId, target: ClaimId, graph: readonly Claim[], visited?: Set<string & import("zod").$brand<"ClaimId">>): boolean;
+export declare function validateConsolidationSources(input: Claim, after: readonly Claim[], destinations: readonly ClaimId[]): void;
+export interface EvidenceContext {
+    enabled: boolean;
+    receipts: Receipts;
+    semanticReview?: boolean;
+}
+export declare function prepareGroup(group: Group, readable: readonly Claim[], owner: AgentId, now?: string, evidence?: EvidenceContext): PreparedGroup;
+export declare function reviewInput(groupId: string, group: Group, readable: readonly Claim[], receipts?: Receipts): Validation;

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

@@ -0,0 +1,6 @@
+import type { Claim } from '../protocol/claim.js';
+import type { Validation } from './schema.js';
+type EvidenceSummary = Pick<Claim, 'id' | 'evidence_summary'>;
+export declare function validateEvidenceSummaryPreservation(input: EvidenceSummary, outputs: readonly EvidenceSummary[]): void;
+export declare function validateEvidencePreservation(input: Pick<Validation['input'], 'kind' | 'before' | 'after' | 'coverage'>): void;
+export {};

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

@@ -0,0 +1,10 @@
+import { type Validation, type SelfReview, type SemanticReview } from './schema.js';
+export interface CoverageGap {
+    side: string;
+    claim_id: string;
+    field: string;
+    missing_fragments: string[];
+}
+export declare function coverageGaps(validation: Validation, review: SelfReview): CoverageGap[];
+export declare function validateSelfReview(validation: Validation, review: SelfReview): void;
+export declare function validateSemanticReview(validation: Validation, review: SemanticReview): void;