opencode-swarm 7.170.2 → 7.171.0

package/dist/observability/catalog.d.ts

@@ -1,7 +1,7 @@
 /**
  * The event catalog (issue #2029).
  *
- * Exactly 61 entries, matching the `TelemetryEvent` union at
+ * Exactly 62 entries, matching the `TelemetryEvent` union at
  * `src/telemetry.ts:20-172`. Thirty-eight predate the #2029 contract; the 39th is
  * `agent_conflict_detected` (previously emitted through a force-cast past the
  * type system), the 40th is `close_archive_result` (issue #2030 — the
@@ -29,7 +29,7 @@
  * (issue #2046 item 9 — canonical council attempt / accepted-transition
  * observations joined to the lifecycle correlation system via the
  * server-derived `councilRoundId`). The 60th is
- * `context_source_attribution` and the 61st is `verdict_row_pipe_recovery`
+ * `context_source_attribution` and the 61st is `verdict_row_pipe_recovery` and the 62nd is `training_vault_health`
  * (issue #2482 — D3: honest savings attribution with the omit-when-unknown
  * rule, and the #2184 verdict-row pipe-recovery fidelity class in the event
  * lifecycle). These late
@@ -88,7 +88,7 @@ export interface CatalogEntry {
     /**
      * Whether an event of this kind must carry `trace.parentSpanId`.
      *
-     * `false` for all 61 entries today, and that is a truthful statement about
+     * `false` for all 62 entries today, and that is a truthful statement about
      * the current system rather than a placeholder: no producer supplies a
      * parent span, so `createObservation` never sets one. Setting this to `true`
      * for a kind whose producer cannot supply a parent would make every

package/dist/telemetry.d.ts

@@ -33,7 +33,7 @@ export type TelemetryEvent = 'session_started' | 'session_ended' | 'agent_activa
  * `prm_hard_stop` TRIGGER emitted by `src/prm/escalation.ts`. A trigger with
  * no matching delivery means the containment never reached the agent.
  */
- | 'prm_hard_stop_delivered' | 'agent_conflict_detected' | 'close_archive_result' | 'knowledge_receipt_transition' | 'knowledge_maintenance' | 'residue_health' | 'context_telemetry_health' | 'skill_usage_health' | 'core_events_health' | 'shell_audit_health' | 'trajectory_health' | 'learning_health_alarm' | 'pr_subscription_health' | 'council_attempt' | 'council_round_transition' | 'council_attempt_unscoped' | 'context_source_attribution' | 'verdict_row_pipe_recovery';
+ | 'prm_hard_stop_delivered' | 'agent_conflict_detected' | 'close_archive_result' | 'knowledge_receipt_transition' | 'knowledge_maintenance' | 'residue_health' | 'context_telemetry_health' | 'skill_usage_health' | 'core_events_health' | 'shell_audit_health' | 'trajectory_health' | 'learning_health_alarm' | 'pr_subscription_health' | 'council_attempt' | 'council_round_transition' | 'council_attempt_unscoped' | 'context_source_attribution' | 'verdict_row_pipe_recovery' | 'training_vault_health';
 /** Stable classification for how a reviewer-gate decision was established. */
 export type ReviewerGateEvidenceKind = 'genuine' | 'fallback' | 'data_quality' | 'block';
 /**
@@ -293,6 +293,18 @@ export declare const telemetry: {
      * contract's no-content-in-metrics rule. Enables PR 16 to alarm and PR 20 to
      * report without leaking workspace layout or capsule contents.
      */
+    /**
+     * Training vault health (issue #2486). Emitted on capture-stop transitions
+     * (quota/disk/consent), quarantine aggregates, and withdrawals for the
+     * consented training-content vault. Bounded payload: the pseudonymous
+     * project ref, a reason enum, and a count — no vault content, no raw
+     * paths, matching the observability contract's no-content rule.
+     */
+    trainingVaultHealth(data: {
+        project_ref: string;
+        reason: "quota_bytes" | "quota_records" | "disk_floor" | "consent_missing" | "withdrawal_executed";
+        count: number;
+    }): void;
     contextTelemetryHealth(data: {
         trigger: "compaction" | "close";
         accepted_count: number;

package/dist/tools/repo-map.d.ts

@@ -87,6 +87,11 @@ export declare const _internals: {
             oldest_age_ms: number;
             grammar_counts: Record<string, number>;
         }): void;
+        trainingVaultHealth(data: {
+            project_ref: string;
+            reason: "quota_bytes" | "quota_records" | "disk_floor" | "consent_missing" | "withdrawal_executed";
+            count: number;
+        }): void;
         contextTelemetryHealth(data: {
             trigger: "compaction" | "close";
             accepted_count: number;

package/dist/training/capture.d.ts

@@ -0,0 +1,37 @@
+import { type TrainingConsent } from './consent';
+import { appendTrainingVaultRecord, buildTrainingVaultRecord } from './vault';
+interface MessageLike {
+    info?: {
+        role?: string;
+        id?: string;
+        sessionID?: string;
+    };
+    parts?: Array<{
+        type?: string;
+        text?: string;
+    }>;
+}
+interface ToolExecutionLike {
+    tool: string;
+    sessionID?: string;
+    input?: unknown;
+    output?: unknown;
+    error?: unknown;
+}
+export interface TrainingCaptureObserver {
+    observeMessages(output: {
+        messages?: MessageLike[];
+    }): Promise<void>;
+    observeToolExecution(event: ToolExecutionLike): Promise<void>;
+}
+export declare const _internals: {
+    appendRecord: typeof appendTrainingVaultRecord;
+    readConsent: (directory: string) => TrainingConsent | null;
+    buildRecord: typeof buildTrainingVaultRecord;
+};
+/**
+ * Create the observer. Pure construction — no filesystem access until the
+ * first observation (which itself only reads when a message actually arrives).
+ */
+export declare function createTrainingCaptureObserver(directory: string): TrainingCaptureObserver;
+export {};

package/dist/training/consent.d.ts

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+export declare const TRAINING_CONSENT_SCHEMA_VERSION = 1;
+/** Version of the consent TERMS presented to the human (bump when terms change). */
+export declare const TRAINING_CONSENT_CURRENT_VERSION = 1;
+/** Hard per-project vault maxima (source contract #2050 §6). Lower is allowed; higher is not. */
+export declare const TRAINING_QUOTA_CEILINGS: {
+    readonly maxBytes: 1073741824;
+    readonly maxRecords: 250000;
+    readonly retentionDays: 30;
+};
+/** Hard per-project export maxima. */
+export declare const TRAINING_EXPORT_QUOTA_CEILINGS: {
+    readonly maxBytes: 1073741824;
+    readonly maxExports: 20;
+    readonly retentionDays: 30;
+};
+export declare const TrainingProjectBindingSchema: z.ZodObject<{
+    rootDigest: z.ZodString;
+    projectRef: z.ZodString;
+}, z.core.$strict>;
+export declare const TrainingConsentSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    consent_id: z.ZodString;
+    state: z.ZodEnum<{
+        granted: "granted";
+        withdrawn: "withdrawn";
+    }>;
+    consent_version: z.ZodLiteral<1>;
+    granted_at: z.ZodString;
+    withdrawn_at: z.ZodOptional<z.ZodString>;
+    expires_at: z.ZodString;
+    purpose: z.ZodString;
+    content_classes: z.ZodArray<z.ZodString>;
+    quotas: z.ZodObject<{
+        maxBytes: z.ZodNumber;
+        maxRecords: z.ZodNumber;
+        retentionDays: z.ZodNumber;
+    }, z.core.$strip>;
+    redaction_version: z.ZodLiteral<1>;
+    project_binding: z.ZodObject<{
+        rootDigest: z.ZodString;
+        projectRef: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type TrainingConsent = z.infer<typeof TrainingConsentSchema>;
+export interface GrantTrainingConsentInput {
+    quotas?: Partial<{
+        maxBytes: number;
+        maxRecords: number;
+        retentionDays: number;
+    }>;
+    expiresAt?: string;
+    now?: Date;
+}
+/**
+ * The project identity a consent is bound to. `rootDigest` pins the canonical
+ * absolute root (clone/copy produces a different digest); `projectRef` reuses
+ * the observability lineage pseudonym so vault records correlate with the
+ * metadata-only event stream without carrying raw paths.
+ */
+export declare function computeProjectBinding(directory: string): {
+    rootDigest: string;
+    projectRef: string;
+};
+/**
+ * Write a new granted consent record (atomically). A prior record — granted or
+ * withdrawn — is replaced; each grant carries a fresh consent_id so vault
+ * records remain attributable to the exact grant they were captured under.
+ */
+export declare function grantTrainingConsent(directory: string, input?: GrantTrainingConsentInput): TrainingConsent;
+/**
+ * Mark the consent withdrawn. Capture stops immediately (every observation
+ * re-reads the active consent); physical content deletion is the withdraw
+ * command's confirmed step, not this write.
+ */
+export declare function revokeTrainingConsent(directory: string, options?: {
+    now?: Date;
+}): void;
+/**
+ * The capture-gating consent read. Fail-closed: missing file, malformed JSON,
+ * schema mismatch, `state !== 'granted'`, expiry, or a project binding issued
+ * for a different canonical root all return null.
+ */
+export declare function readActiveTrainingConsent(directory: string, options?: {
+    now?: Date;
+}): TrainingConsent | null;
+/**
+ * Read a granted, project-bound consent WITHOUT the wall-clock expiry check.
+ * The capture observer uses `readActiveTrainingConsent` (expiry-aware); the
+ * vault's append gate instead validates that the consent was active AT THE
+ * RECORD'S captured_at, so a record legitimately captured before expiry still
+ * lands while any capture attempted under an expired grant is refused.
+ */
+export declare function readGrantedTrainingConsent(directory: string): TrainingConsent | null;
+/** Read the raw consent state for status reporting (never throws). */
+export declare function readTrainingConsentState(directory: string): 'granted' | 'withdrawn' | 'absent';

package/dist/training/disk.d.ts

@@ -0,0 +1,16 @@
+/** Hard free-space floor: max(2 GiB, 10% of the volume size). */
+export declare const TRAINING_DISK_FLOOR_BYTES = 2147483648;
+export interface DiskFloorCheck {
+    ok: boolean;
+    freeBytes?: number;
+    floorBytes: number;
+    reason?: 'disk_floor';
+}
+/**
+ * Check the free-space floor for the volume holding the training tree.
+ * The reported `floorBytes` is the guaranteed constant floor; the ok/not-ok
+ * decision uses the stricter of that floor and 10% of the volume size.
+ * Never throws: an unprobeable volume reports ok with the byte caps as the
+ * remaining bound (see module doc).
+ */
+export declare function checkTrainingDiskFloor(directory: string): DiskFloorCheck;

package/dist/training/exporter.d.ts

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+import { listTrainingTombstones, type TrainingVaultRecord } from './vault';
+export declare const TRAINING_EXPORT_SCHEMA_VERSION = 1;
+export declare const TrainingExportFiltersSchema: z.ZodObject<{
+    kinds: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        user_message: "user_message";
+        assistant_message: "assistant_message";
+        tool_call: "tool_call";
+        tool_result: "tool_result";
+    }>>>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    taskId: z.ZodOptional<z.ZodString>;
+    since: z.ZodOptional<z.ZodString>;
+    validationRatio: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type TrainingExportFilters = z.infer<typeof TrainingExportFiltersSchema>;
+export interface ExportPreview {
+    exportId: string;
+    recordCount: number;
+    estimatedBytes: number;
+    destination: string;
+    split: {
+        train: number;
+        validation: number;
+    };
+    quarantinedExcluded: number;
+    expiredExcluded: number;
+    requiresConfirm: true;
+}
+export interface ExportExecution {
+    written: boolean;
+    exportId?: string;
+    destination?: string;
+    reason?: 'token_mismatch' | 'token_expired' | 'scope_changed' | 'empty' | 'export_quota' | 'export_revoked';
+}
+export type ExportFiles = Record<'records.jsonl' | 'train.jsonl' | 'validation.jsonl' | 'manifest.json', string>;
+export interface ExportBundle {
+    exportId: string;
+    files: ExportFiles;
+}
+interface PendingOpRecord {
+    schema_version: 1;
+    kind: 'export' | 'withdraw' | 'consent';
+    scope_digest: string;
+    confirm_token: string;
+    created_at: number;
+}
+/**
+ * Build the deterministic export bundle. The export id hashes the schema
+ * versions, the canonical filters, and each included record's id + consent id
+ * (so an identical re-export of identical content under the same consent is
+ * idempotent, while a fresh consent cycle yields a fresh id).
+ */
+export declare function buildTrainingExportBundle(records: TrainingVaultRecord[], filters?: TrainingExportFilters, options?: {
+    quarantinedExcluded?: number;
+    expiredExcluded?: number;
+}): ExportBundle;
+/** Side-effect-free export preview: no files written, no token issued. */
+export declare function previewTrainingExport(directory: string, filters?: TrainingExportFilters): ExportPreview;
+export declare function consumeTrainingPendingOp(directory: string): void;
+/** Arm the single pending-op slot and return the 24-hex confirmation token. */
+export declare function issueTrainingConfirmToken(directory: string, scope: {
+    kind: 'export' | 'withdraw' | 'consent';
+    digest: string;
+}): string;
+type TokenCheck = {
+    ok: true;
+    record: PendingOpRecord;
+} | {
+    ok: false;
+    reason: 'token_mismatch' | 'token_expired';
+};
+export declare function checkTrainingConfirmToken(directory: string, kind: 'export' | 'withdraw' | 'consent', token: string): TokenCheck;
+declare function countExportDirs(directory: string): number;
+export declare const _internals: {
+    countExportDirs: typeof countExportDirs;
+    listTombstones: typeof listTrainingTombstones;
+};
+/**
+ * Execute the confirmed export: consumes the token (single use), re-derives
+ * the CURRENT scope digest from the vault + filters, writes the bundle
+ * atomically under `<root>/exports/<exportId>/`. Identical re-exports are
+ * idempotent (same destination, same bytes).
+ */
+export declare function executeTrainingExport(directory: string, filters: TrainingExportFilters | undefined, options: {
+    confirmToken: string;
+}): ExportExecution;
+export {};

package/dist/training/paths.d.ts

@@ -0,0 +1,20 @@
+/** Root directory name of the governed training tree, relative to `.swarm/`. */
+export declare const TRAINING_ROOT_NAME = ".swarm/training/v1";
+/** Resolved absolute root of the training tree for a project directory. */
+export declare function trainingRootDir(directory: string): string;
+/** `<root>/vault/records.jsonl` — the append-only vault record store. */
+export declare function trainingVaultRecordsPath(directory: string): string;
+/** `<root>/vault/quarantine.jsonl` — journal of quarantined corrupt lines. */
+export declare function trainingQuarantinePath(directory: string): string;
+/** `<root>/consent.json` — the durable, separately-consented grant record. */
+export declare function trainingConsentPath(directory: string): string;
+/** `<root>/tombstones.jsonl` — append-only withdrawal tombstones (never pruned). */
+export declare function trainingTombstonesPath(directory: string): string;
+/** `<root>/health.json` — bounded capture-health state (stop reasons, counters). */
+export declare function trainingHealthPath(directory: string): string;
+/** `<root>/exports` — contained dataset export bundles (`<exports>/<exportId>/`). */
+export declare function trainingExportsDir(directory: string): string;
+/** `<root>/pending-op.json` — single-slot confirmation token store. */
+export declare function trainingPendingOpPath(directory: string): string;
+/** Directory portion of a resolved training path (for mkdir before writes). */
+export declare function parentDirOf(filePath: string): string;

package/dist/training/redact.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Issue #2486: capture-time defense-in-depth redaction for training content.
+ *
+ * Mirrors the URL / credential-pattern classes of
+ * `sanitizeFailureEvidenceDisplay` (`src/failures/invocation-failure.ts`)
+ * WITHOUT that function's 512-byte display bounding — vault records keep the
+ * contracted 4096-char content budget. This is defense-in-depth, not a
+ * security boundary (same honest framing as #2369): the human consenting to
+ * capture is trusting the redactor class, and the recorded
+ * `redaction.version` pins which revision produced each stored record.
+ */
+/** Bumped when the pattern set changes; recorded on every vault record.
+ * v1's pattern set was extended pre-release (quoted-JSON credential shapes,
+ * scheme-prefixed tokens) before any v1 record shipped, so the first released
+ * revision covers the full set and no migration surface exists. */
+export declare const TRAINING_REDACTION_VERSION = 1;
+export interface RedactionResult {
+    content: string;
+    applied: boolean;
+    redactions: number;
+}
+/**
+ * Redact URL and credential patterns from already-bounded capture content
+ * (callers bound FIRST — a placeholder can be longer than the span it
+ * replaces, and truncating after redaction would collapse distinct inputs
+ * onto one identity). Pure; never throws (on internal failure the content is
+ * withheld rather than stored raw).
+ */
+export declare function redactTrainingContent(content: string): RedactionResult;

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.0",
 	"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",