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

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

@@ -0,0 +1,8 @@
+export declare function isSubagent(header: {
+    origin?: string;
+    delegationDepth?: number;
+}): boolean;
+export declare function isEvidenceAgent(header: {
+    origin?: string;
+    agentPreset?: string;
+}): boolean;

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

@@ -0,0 +1,2 @@
+import type { z } from 'zod';
+export declare function validationMessage(error: z.ZodError): string;

package/lib/types/upload/consolidation.d.ts

@@ -0,0 +1,63 @@
+import type { Claim } from '../protocol/claim.js';
+import type { ClaimId } from '../protocol/ids.js';
+import type { z } from 'zod';
+import type { ConsolidationDeliverySchema } from '../store/uploads.js';
+export type ConsolidationDelivery = z.infer<typeof ConsolidationDeliverySchema>;
+export declare function relatedIds(groups: readonly ConsolidationDelivery[]): Set<ClaimId>;
+export declare function consolidationReady(claim: Claim, groups: readonly ConsolidationDelivery[], acknowledged: readonly Claim[], current: readonly Claim[]): boolean;
+export declare function pruneDeliveries(groups: readonly ConsolidationDelivery[], acknowledgements: readonly Claim[], pending: readonly Claim[]): {
+    consolidations: {
+        before: {
+            id: string & z.core.$brand<"ClaimId">;
+            name: string;
+            statement: string;
+            scope: string;
+            holder: string & z.core.$brand<"AgentId">;
+            confidence: "high" | "medium" | "low";
+            status: "active" | "stale" | "deprecated";
+            created_at: string;
+            source_claim_ids: ((string & z.core.$brand<"ClaimId">) | (string & z.core.$brand<"PolicyId">))[];
+            evidence_summary: string;
+            updated_at?: string | undefined;
+        };
+        retired: {
+            id: string & z.core.$brand<"ClaimId">;
+            name: string;
+            statement: string;
+            scope: string;
+            holder: string & z.core.$brand<"AgentId">;
+            confidence: "high" | "medium" | "low";
+            status: "active" | "stale" | "deprecated";
+            created_at: string;
+            source_claim_ids: ((string & z.core.$brand<"ClaimId">) | (string & z.core.$brand<"PolicyId">))[];
+            evidence_summary: string;
+            updated_at?: string | undefined;
+        };
+        carriers: {
+            id: string & z.core.$brand<"ClaimId">;
+            name: string;
+            statement: string;
+            scope: string;
+            holder: string & z.core.$brand<"AgentId">;
+            confidence: "high" | "medium" | "low";
+            status: "active" | "stale" | "deprecated";
+            created_at: string;
+            source_claim_ids: ((string & z.core.$brand<"ClaimId">) | (string & z.core.$brand<"PolicyId">))[];
+            evidence_summary: string;
+            updated_at?: string | undefined;
+        }[];
+    }[];
+    acknowledgements: {
+        id: string & z.core.$brand<"ClaimId">;
+        name: string;
+        statement: string;
+        scope: string;
+        holder: string & z.core.$brand<"AgentId">;
+        confidence: "high" | "medium" | "low";
+        status: "active" | "stale" | "deprecated";
+        created_at: string;
+        source_claim_ids: ((string & z.core.$brand<"ClaimId">) | (string & z.core.$brand<"PolicyId">))[];
+        evidence_summary: string;
+        updated_at?: string | undefined;
+    }[];
+};

package/lib/types/upload/deliver.d.ts

@@ -0,0 +1,15 @@
+import type { StoreContext } from '../store/context.js';
+import type { TeamFacade } from '../team/service.js';
+export interface DeliveryReport {
+    deliveredClaims: number;
+    deliveredDisputes: number;
+    pendingClaims: number;
+    pendingDisputes: number;
+    warnings: string[];
+}
+export declare class UploadDelivery {
+    readonly context: StoreContext;
+    readonly team: TeamFacade | null;
+    constructor(context: StoreContext, team: TeamFacade | null);
+    deliver(signal?: AbortSignal): Promise<DeliveryReport>;
+}

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

@@ -0,0 +1,2 @@
+export * from './deliver.js';
+export * from './scheduler.js';

package/lib/types/upload/scheduler.d.ts

@@ -0,0 +1,19 @@
+import type { AcnKnowledge } from '../knowledge/service.js';
+import { UploadDelivery } from './deliver.js';
+export declare class UploadScheduler {
+    readonly knowledge: AcnKnowledge;
+    private readonly intervalMs;
+    private pending;
+    private requested;
+    private closed;
+    private readonly abort;
+    private timer;
+    private unsubscribe;
+    readonly delivery: UploadDelivery;
+    constructor(knowledge: AcnKnowledge, intervalMs?: number);
+    start(): void;
+    kick(): void;
+    private run;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}

package/lib/types/upstreams.d.ts

@@ -0,0 +1,5 @@
+import type { ResolvedConfig } from './config.js';
+export { upstreamsOf } from './config.js';
+export declare function resolveUpstream(config: ResolvedConfig, key: string, includeDisabled?: boolean): ResolvedConfig | undefined;
+export declare function defaultUpstream(config: ResolvedConfig): string;
+export declare function canonicalProjectPath(cwd: string): Promise<string>;

package/lib/types/worker/queue.d.ts

@@ -0,0 +1,17 @@
+import type { StoreContext } from '../store/context.js';
+import type { Job, JobKind } from './types.js';
+export declare function runnableJob(job: Job, kinds: Pick<ReadonlySet<JobKind>, 'has'>, now?: number): boolean;
+export declare class JobQueue {
+    readonly context: StoreContext;
+    constructor(context: StoreContext);
+    list(): Promise<Job[]>;
+    read(id: string): Promise<Job | null>;
+    private write;
+    private locked;
+    enqueue(kind: JobKind, payload: Job['payload'], sessionId?: string): Promise<Job>;
+    recoverRunning(): Promise<void>;
+    claim(kinds: ReadonlySet<JobKind>): Promise<Job | null>;
+    settle(job: Job, state: Job['state'], details?: Partial<Pick<Job, 'lastError' | 'lastErrorKind' | 'nextRunAt' | 'result' | 'attempts'>>): Promise<void>;
+    pauseDream(paused: boolean): Promise<Job[]>;
+    retry(id: string): Promise<Job>;
+}

package/lib/types/worker/types.d.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export declare const JobKindSchema: z.ZodEnum<{
+    inbox: "inbox";
+    dream: "dream";
+    finalize: "finalize";
+    recap: "recap";
+}>;
+export type JobKind = z.infer<typeof JobKindSchema>;
+export declare const JobSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        inbox: "inbox";
+        dream: "dream";
+        finalize: "finalize";
+        recap: "recap";
+    }>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    payload: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    state: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+    }>;
+    attempts: z.ZodNumber;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    ordinal: z.ZodOptional<z.ZodNumber>;
+    nextRunAt: z.ZodOptional<z.ZodNumber>;
+    lastError: z.ZodOptional<z.ZodString>;
+    lastErrorKind: z.ZodOptional<z.ZodString>;
+    result: z.ZodOptional<z.ZodJSONSchema>;
+}, z.core.$strict>;
+export type Job = z.infer<typeof JobSchema>;
+export declare const jobPriority: Record<JobKind, number>;
+export declare class JobError extends Error {
+    readonly kind: string;
+    readonly retryable: boolean;
+    readonly retryAfterMs?: number | undefined;
+    constructor(kind: string, message: string, retryable?: boolean, retryAfterMs?: number | undefined);
+}
+export declare class Preempted extends JobError {
+    constructor();
+}
+export declare class DreamStopped extends JobError {
+    constructor();
+}
+export declare class DreamYield extends JobError {
+    constructor();
+}

package/lib/types/worker/worker.d.ts

@@ -0,0 +1,39 @@
+import type { StoreContext } from '../store/context.js';
+import { JobQueue } from './queue.js';
+import { DreamStopped } from './types.js';
+import type { Job, JobKind } from './types.js';
+export interface JobControl {
+    signal: AbortSignal;
+    prepared(): void;
+    committed?(): void;
+}
+export type JobHandler = (job: Job, control: JobControl) => Promise<Job['result']>;
+export declare class DurableWorker {
+    readonly context: StoreContext;
+    private readonly options;
+    readonly queue: JobQueue;
+    private readonly handlers;
+    private lease;
+    private active;
+    private timer;
+    private ticking;
+    private closed;
+    private started;
+    private nextAcquire;
+    constructor(context: StoreContext, options?: {
+        pollMs?: number;
+        takeoverMs?: number;
+        retryBaseMs?: number;
+        staleMs?: number;
+    });
+    register(kind: JobKind, handler: JobHandler): () => void;
+    supports(kind: JobKind): boolean;
+    canRun(job: Job): boolean;
+    start(): Promise<void>;
+    wake(force?: boolean): void;
+    enqueue(kind: JobKind, payload: Job['payload'], sessionId?: string): Promise<Job>;
+    retry(id: string): Promise<Job>;
+    cancelDream(reason?: DreamStopped): void;
+    private tick;
+    close(): Promise<void>;
+}

package/lib/types-C2ST2Zdg.js

@@ -0,0 +1,17 @@
+import { a as TextSchema, l as ClaimIdSchema, n as ClaimStatusSchema, r as ConfidenceSchema } from "./claim-DOAGe8ZK.js";
+import { z } from "zod";
+//#region src/knowledge/types.ts
+const DEFAULT_TRACE_TASK_PAGE_LIMIT = 4e3;
+const MAX_TRACE_TASK_PAGE_LIMIT = 16e3;
+const ClaimUpdateSchema = z.strictObject({
+	id: ClaimIdSchema,
+	expected_revision: z.string(),
+	name: TextSchema.optional(),
+	statement: TextSchema.optional(),
+	scope: TextSchema.optional(),
+	evidence_summary: TextSchema.optional(),
+	confidence: ConfidenceSchema.optional(),
+	status: ClaimStatusSchema.optional()
+});
+//#endregion
+export { DEFAULT_TRACE_TASK_PAGE_LIMIT as n, MAX_TRACE_TASK_PAGE_LIMIT as r, ClaimUpdateSchema as t };

package/lib/upload.js

@@ -0,0 +1,3 @@
+import { t as UploadDelivery } from "./deliver-C-dmhkfm.js";
+import { t as UploadScheduler } from "./scheduler-BfJSY1eq.js";
+export { UploadDelivery, UploadScheduler };

package/lib/uploads-BCA2p92b.js

@@ -0,0 +1,210 @@
+import { S as timestampNanos, i as effectiveUpdatedAt, l as ClaimIdSchema, t as ClaimSchema, u as DisputeIdSchema, x as nowSeconds, y as TimestampSchema } from "./claim-DOAGe8ZK.js";
+import { n as claimRevision } from "./revision-DeoL_IUN.js";
+import { C as StoreError, c as readYamlOr, d as removeFile, l as writeYamlAtomic, n as withFileLock } from "./lock-DbmlKOoX.js";
+import { l as sameClaim } from "./alignment-CwH0nBf-.js";
+import { t as DisputeSchema } from "./dispute-CtrInHzf.js";
+import { z } from "zod";
+import { createHash } from "node:crypto";
+//#region src/upload/consolidation.ts
+function relatedIds(groups) {
+	return new Set(groups.flatMap((group) => [group.retired.id, ...group.carriers.map((claim) => claim.id)]));
+}
+function carrierReady(claim, groups, acknowledged, current, visiting) {
+	if (claim.status !== "deprecated" && current.some((value) => sameClaim(value, claim)) && acknowledged.some((value) => sameClaim(value, claim))) return true;
+	if (visiting.has(claim.id)) return false;
+	visiting.add(claim.id);
+	const result = groups.some((group) => sameClaim(group.before, claim) && current.some((value) => sameClaim(value, group.retired)) && group.carriers.length > 0 && group.carriers.every((carrier) => carrierReady(carrier, groups, acknowledged, current, visiting)));
+	visiting.delete(claim.id);
+	return result;
+}
+function consolidationReady(claim, groups, acknowledged, current) {
+	return groups.filter((group) => sameClaim(group.retired, claim)).every((group) => group.carriers.length > 0 && group.carriers.every((carrier) => carrierReady(carrier, groups, acknowledged, current, /* @__PURE__ */ new Set())));
+}
+function pruneDeliveries(groups, acknowledgements, pending) {
+	const keep = new Set(groups.filter((group) => pending.some((claim) => sameClaim(claim, group.retired))));
+	let size = -1;
+	while (size !== keep.size) {
+		size = keep.size;
+		for (const group of keep) for (const carrier of group.carriers) for (const next of groups) if (sameClaim(next.before, carrier)) keep.add(next);
+	}
+	const retained = groups.filter((group) => keep.has(group));
+	const related = relatedIds(retained);
+	return {
+		consolidations: retained,
+		acknowledgements: acknowledgements.filter((claim) => related.has(claim.id))
+	};
+}
+//#endregion
+//#region src/store/rejected-disputes.ts
+const RejectionsSchema = z.record(z.string().regex(/^[0-9a-f]{64}$/), z.object({
+	dispute_id: DisputeIdSchema,
+	status: z.literal(409),
+	attempts: z.number().int().positive().default(1),
+	rejected_at: TimestampSchema
+}));
+const disputeVersion = (dispute) => createHash("sha256").update(JSON.stringify(DisputeSchema.parse(dispute))).digest("hex");
+var RejectedDisputeStore = class {
+	context;
+	constructor(context) {
+		this.context = context;
+	}
+	async read(includeHistory = false) {
+		if (this.context.mode === "solo" && !includeHistory) return {};
+		return readYamlOr(this.context.paths.rejectedDisputes, RejectionsSchema, () => ({}));
+	}
+	async contains(dispute) {
+		return Object.hasOwn(await this.read(), disputeVersion(dispute));
+	}
+	async record(dispute, attempts = 1) {
+		if (this.context.mode === "solo") return;
+		await withFileLock(`${this.context.paths.rejectedDisputes}.lock`, async () => {
+			const records = await this.read();
+			const key = disputeVersion(dispute);
+			if (Object.hasOwn(records, key)) return;
+			records[key] = {
+				dispute_id: dispute.id,
+				status: 409,
+				attempts,
+				rejected_at: nowSeconds()
+			};
+			await writeYamlAtomic(this.context.paths.rejectedDisputes, records, RejectionsSchema, this.context.logger);
+		}, { timeoutMs: this.context.lockTimeoutMs });
+	}
+};
+//#endregion
+//#region src/store/uploads.ts
+const ConsolidationDeliverySchema = z.object({
+	before: ClaimSchema,
+	retired: ClaimSchema,
+	carriers: z.array(ClaimSchema)
+});
+const PendingUploadsSchema = z.object({
+	consolidations: z.array(ConsolidationDeliverySchema).default([]).transform((items) => items.length === 0 ? void 0 : items),
+	acknowledgements: z.array(ClaimSchema).default([]).transform((items) => items.length === 0 ? void 0 : items),
+	claims: z.array(ClaimSchema).default([]),
+	durable_claim_ids: z.array(ClaimIdSchema).default([]).transform((items) => items.length === 0 ? void 0 : [...new Set(items)].sort()),
+	disputes: z.array(DisputeSchema).default([])
+});
+var UploadStore = class {
+	context;
+	constructor(context) {
+		this.context = context;
+	}
+	async read() {
+		if (this.context.mode === "solo") return PendingUploadsSchema.parse({});
+		return readYamlOr(this.context.paths.pendingUploads, PendingUploadsSchema, () => PendingUploadsSchema.parse({}));
+	}
+	async save(value) {
+		if (this.context.mode === "solo") return;
+		await this.modify(() => PendingUploadsSchema.parse(value));
+	}
+	async persist(value) {
+		if (value.claims.length === 0 && value.disputes.length === 0 && !value.consolidations?.length && !value.acknowledgements?.length) await removeFile(this.context.paths.pendingUploads, this.context.logger);
+		else await writeYamlAtomic(this.context.paths.pendingUploads, value, PendingUploadsSchema, this.context.logger);
+	}
+	async modify(update) {
+		if (this.context.mode === "solo") return;
+		await withFileLock(this.context.paths.pendingUploadsLock, async () => {
+			await this.persist(PendingUploadsSchema.parse(await update(await this.read())));
+		}, { timeoutMs: this.context.lockTimeoutMs });
+	}
+	async enqueue(claims, disputes, durable = false, dependencies = []) {
+		if (this.context.mode === "solo") return;
+		await this.modify(async (pending) => {
+			const rejected = await new RejectedDisputeStore(this.context).read();
+			const byClaim = new Map(pending.claims.map((claim) => [claim.id, claim]));
+			let consolidations = pending.consolidations ?? [];
+			for (const value of claims) {
+				const claim = ClaimSchema.parse(value);
+				const existing = byClaim.get(claim.id);
+				if (existing !== void 0 && timestampNanos(effectiveUpdatedAt(claim)) < timestampNanos(effectiveUpdatedAt(existing))) continue;
+				consolidations = claim.status === "deprecated" ? consolidations.map((group) => group.retired.id === claim.id ? {
+					...group,
+					retired: claim
+				} : group) : consolidations.filter((group) => group.retired.id !== claim.id);
+				byClaim.set(claim.id, claim);
+			}
+			const byDispute = new Map(pending.disputes.map((dispute) => [dispute.id, dispute]));
+			for (const value of disputes) {
+				const dispute = DisputeSchema.parse(value);
+				if (Object.hasOwn(rejected, disputeVersion(dispute))) continue;
+				const existing = byDispute.get(dispute.id);
+				if (existing === void 0 || timestampNanos(dispute.created_at) >= timestampNanos(existing.created_at)) byDispute.set(dispute.id, dispute);
+			}
+			const durableIds = new Set(pending.durable_claim_ids ?? []);
+			if (durable) for (const claim of claims) durableIds.add(claim.id);
+			for (const dependency of dependencies) if (byClaim.get(dependency.retired.id) !== void 0 && sameClaim(byClaim.get(dependency.retired.id) ?? dependency.before, dependency.retired)) {
+				consolidations = consolidations.filter((group) => group.retired.id !== dependency.retired.id);
+				consolidations.push(ConsolidationDeliverySchema.parse(dependency));
+			}
+			return PendingUploadsSchema.parse({
+				...pending,
+				consolidations,
+				claims: [...byClaim.values()].sort((a, b) => a.id.localeCompare(b.id)),
+				durable_claim_ids: [...durableIds].filter((id) => byClaim.has(id)).sort(),
+				disputes: [...byDispute.values()].sort((a, b) => a.id.localeCompare(b.id))
+			});
+		});
+	}
+	async removeDeliveredClaims(delivered) {
+		if (this.context.mode === "solo") return;
+		const revisions = new Map(delivered.map((claim) => [claim.id, claimRevision(claim)]));
+		await this.modify((pending) => {
+			const claims = pending.claims.filter((claim) => revisions.get(claim.id) !== claimRevision(claim));
+			const ids = new Set(claims.map((claim) => claim.id));
+			const acknowledgements = [...pending.acknowledgements ?? []];
+			for (const claim of delivered) {
+				const index = acknowledgements.findIndex((value) => value.id === claim.id);
+				if (index >= 0) acknowledgements.splice(index, 1);
+				acknowledgements.push(claim);
+			}
+			return PendingUploadsSchema.parse({
+				...pending,
+				...pruneDeliveries(pending.consolidations ?? [], acknowledgements, claims),
+				claims,
+				durable_claim_ids: pending.durable_claim_ids?.filter((id) => ids.has(id))
+			});
+		});
+	}
+	async rebind(previous, revised) {
+		if (this.context.mode === "solo") throw new StoreError("conflict", "Team delivery is disabled.");
+		await this.modify((pending) => {
+			const exact = (group, value) => sameClaim(group.before, value.before) && sameClaim(group.retired, value.retired) && group.carriers.length === value.carriers.length && group.carriers.every((claim, index) => value.carriers[index] !== void 0 && sameClaim(claim, value.carriers[index]));
+			if (pending.consolidations?.some((group) => exact(group, revised))) return pending;
+			if (!pending.consolidations?.some((group) => exact(group, previous)) || !pending.claims.some((claim) => sameClaim(claim, previous.retired))) throw new StoreError("conflict", "Consolidation dependency changed; review current versions.");
+			const claims = pending.claims.filter((claim) => !revised.carriers.some((carrier) => carrier.id === claim.id));
+			claims.push(...revised.carriers);
+			return PendingUploadsSchema.parse({
+				...pending,
+				claims,
+				durable_claim_ids: [.../* @__PURE__ */ new Set([...pending.durable_claim_ids ?? [], ...revised.carriers.map((claim) => claim.id)])],
+				consolidations: [...pending.consolidations.filter((group) => group.retired.id !== revised.retired.id), revised]
+			});
+		});
+	}
+	async removeDeliveredDisputes(delivered) {
+		if (this.context.mode === "solo") return;
+		const encoded = new Set(delivered.map((dispute) => JSON.stringify(DisputeSchema.parse(dispute))));
+		await this.modify((pending) => PendingUploadsSchema.parse({
+			...pending,
+			disputes: pending.disputes.filter((dispute) => !encoded.has(JSON.stringify(dispute)))
+		}));
+	}
+	async withdrawPolicy(policyId) {
+		if (this.context.mode === "solo") return;
+		await this.modify((pending) => {
+			const obsolete = (pending.consolidations ?? []).filter((group) => group.before.source_claim_ids.includes(policyId) || group.retired.source_claim_ids.includes(policyId));
+			const obsoleteIds = new Set(obsolete.map((group) => group.retired.id));
+			const carriers = new Set(obsolete.flatMap((group) => group.carriers.map((claim) => claim.id)));
+			const retained = (pending.consolidations ?? []).filter((group) => !obsoleteIds.has(group.retired.id));
+			const stillNeeded = new Set(retained.flatMap((group) => group.carriers.map((claim) => claim.id)));
+			return PendingUploadsSchema.parse({
+				...pending,
+				consolidations: retained,
+				claims: pending.claims.filter((claim) => !carriers.has(claim.id) || stillNeeded.has(claim.id) || pending.durable_claim_ids?.includes(claim.id) || claim.source_claim_ids.some((source) => source === policyId))
+			});
+		});
+	}
+};
+//#endregion
+export { disputeVersion as a, RejectedDisputeStore as i, PendingUploadsSchema as n, consolidationReady as o, UploadStore as r, relatedIds as s, ConsolidationDeliverySchema as t };