opencode-swarm 7.170.2 → 7.171.1

package/dist/training/vault.d.ts

@@ -0,0 +1,177 @@
+import { z } from 'zod';
+import { type TrainingConsent } from './consent';
+import { type DiskFloorCheck } from './disk';
+export declare const TRAINING_VAULT_SCHEMA_VERSION = 1;
+/** Re-exported alias recorded on every vault record (see `./redact.ts`). */
+export declare const REDACTION_VERSION = 1;
+export declare const TrainingVaultKindSchema: z.ZodEnum<{
+    user_message: "user_message";
+    assistant_message: "assistant_message";
+    tool_call: "tool_call";
+    tool_result: "tool_result";
+}>;
+export type TrainingVaultKind = z.infer<typeof TrainingVaultKindSchema>;
+export declare const TrainingVaultRecordSchema: z.ZodObject<{
+    record_id: z.ZodString;
+    schema_version: z.ZodLiteral<1>;
+    kind: z.ZodEnum<{
+        user_message: "user_message";
+        assistant_message: "assistant_message";
+        tool_call: "tool_call";
+        tool_result: "tool_result";
+    }>;
+    role: z.ZodString;
+    content: z.ZodString;
+    content_digest: z.ZodString;
+    lineage: z.ZodObject<{
+        session_id: z.ZodString;
+        task_id: z.ZodOptional<z.ZodString>;
+        trace_id: z.ZodOptional<z.ZodString>;
+        project_ref: z.ZodString;
+        captured_at: z.ZodString;
+    }, z.core.$strict>;
+    labels: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+        provenance: z.ZodString;
+        confidence: z.ZodNumber;
+    }, z.core.$strict>>;
+    provenance: z.ZodObject<{
+        plugin_version: z.ZodString;
+        source: z.ZodEnum<{
+            tool: "tool";
+            chat: "chat";
+        }>;
+    }, z.core.$strict>;
+    redaction: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        applied: z.ZodBoolean;
+        redactions: z.ZodNumber;
+    }, z.core.$strict>;
+    consent: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodNumber;
+    }, z.core.$strict>;
+    retention: z.ZodObject<{
+        expires_at: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type TrainingVaultRecord = z.infer<typeof TrainingVaultRecordSchema>;
+export declare const TrainingWithdrawalTombstoneSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    tombstone_id: z.ZodString;
+    withdrawn_at: z.ZodString;
+    purged_records: z.ZodNumber;
+    purged_record_ids_digest: z.ZodString;
+    revoked_export_ids: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type TrainingWithdrawalTombstone = z.infer<typeof TrainingWithdrawalTombstoneSchema>;
+export type TrainingStopReason = 'quota_bytes' | 'quota_records' | 'disk_floor' | 'consent_missing';
+export interface AppendResult {
+    appended: boolean;
+    stopReason?: TrainingStopReason;
+}
+export interface QuarantinedItem {
+    line: number;
+    reason: 'malformed_json' | 'schema_invalid';
+}
+export interface VaultRead {
+    records: TrainingVaultRecord[];
+    quarantined: QuarantinedItem[];
+}
+export interface VaultStatus {
+    recordCount: number;
+    vaultBytes: number;
+    consentState: 'granted' | 'withdrawn' | 'absent';
+    lastStopReason?: string;
+    tombstoneCount: number;
+    quarantinedCount: number;
+}
+export interface PurgeResult {
+    purgedRecords: number;
+    tombstone: TrainingWithdrawalTombstone;
+    revokedExports: string[];
+}
+export interface LabelInput {
+    name: string;
+    value: string;
+    provenance: string;
+    confidence: number;
+}
+export interface BuildRecordInput {
+    directory: string;
+    kind: TrainingVaultKind;
+    role: string;
+    content: string;
+    sessionId: string;
+    taskId?: string;
+    traceId?: string;
+    pluginVersion: string;
+    source: 'chat' | 'tool';
+    consent: TrainingConsent;
+    labels?: LabelInput[];
+    now?: Date;
+}
+/**
+ * Build a vault record per the frozen contract: content is bounded FIRST
+ * (4096 chars) then redacted (redaction placeholders can outgrow the spans
+ * they replace; bounding after redaction would collapse distinct inputs onto
+ * one identity); `content_digest` hashes the final stored content;
+ * `record_id` binds projectRef + session + kind + role + digest so repeat
+ * observations of the same surface dedup to one record id; retention is the
+ * earlier of captured_at + retentionDays and the consent's own expiry.
+ */
+export declare function buildTrainingVaultRecord(input: BuildRecordInput): TrainingVaultRecord;
+export declare const _internals: {
+    statfsCheck: (directory: string) => DiskFloorCheck;
+    appendFile: (target: string, data: string) => void | Promise<void>;
+    readFile: (target: string) => string;
+    now: () => Date;
+};
+/**
+ * The ONLY vault write path. Gates, in order: active consent for THIS root
+ * (fail-closed, no file creation on refusal), disk floor, byte cap, record
+ * cap. A write is only accepted when it is synchronously confirmed durable
+ * (the vault file grew) — an async/unconfirmed seam result or a write error
+ * fails closed as `disk_floor`. Unexpired records are never evicted.
+ */
+export declare function appendTrainingVaultRecord(directory: string, record: TrainingVaultRecord): AppendResult;
+/**
+ * Read the vault. Corrupt items are quarantined with a typed reason, journaled
+ * to `<root>/vault/quarantine.jsonl` (deduped in-process by line content), and
+ * excluded from `records`. Never throws on corrupt content.
+ */
+export declare function readTrainingVault(directory: string): VaultRead;
+/** Current valid + quarantined counts without journaling (status surfaces). */
+export declare function getTrainingVaultStatus(directory: string): VaultStatus;
+/**
+ * Physically purge records past their retention expiry (honored retention —
+ * distinct from quota stops, which never delete). Tombstones are untouched.
+ */
+export declare function sweepTrainingVaultExpiry(directory: string, options?: {
+    now?: Date;
+}): {
+    purged: number;
+};
+/**
+ * Physically delete ALL vault content, append a durable withdrawal tombstone,
+ * and revoke every export still under plugin control with a `REVOKED.json`
+ * revocation manifest. Tombstones from prior withdrawals are never touched.
+ *
+ * The export listing happens BEFORE any destruction: if the exports dir is
+ * unreadable (not merely absent), the purge refuses rather than truncating
+ * records and then silently writing a tombstone that under-reports the
+ * revocation set.
+ */
+export declare function purgeTrainingVaultContent(directory: string, options?: {
+    now?: Date;
+}): PurgeResult;
+/** All durable withdrawal tombstones (corrupt lines skipped). */
+export declare function listTrainingTombstones(directory: string): TrainingWithdrawalTombstone[];
+export interface TrainingExportRevocation {
+    exportId: string;
+    revokedAt: string;
+    tombstoneId: string;
+}
+/** Revocation manifests for exports still under plugin control. */
+export declare function readTrainingExportRevocations(directory: string): TrainingExportRevocation[];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.170.2",
+	"version": "7.171.1",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -113,6 +113,7 @@
 		"repro:704": "node scripts/repro-704.mjs",
 		"repro:1144": "bun scripts/repro-1144.mjs",
 		"repro:1873": "bun build scripts/repro-1873-entry.ts --outdir dist-build-test/repro-1873 --target node --format esm && node scripts/repro-1873.mjs",
+		"repro:2487": "bun build scripts/repro-2487-parity-entry.ts --outdir dist-build-test/repro-2487 --target node --format esm && node scripts/repro-2487-parity.mjs",
 		"check:events": "bun run scripts/check-event-contract.ts",
 		"check:retention": "bun run scripts/check-retention-registry.ts",
 		"check:core-events": "bun run scripts/check-core-events-usage.ts",