opencode-swarm 7.103.2 → 7.104.0

package/dist/lang/symbol-visibility.d.ts

@@ -32,6 +32,8 @@ export interface SymbolVisibilityContext {
     explicitExported: boolean;
     commonJsExport?: CommonJsExportInfo;
     pythonAllNames?: Set<string> | null;
+    /** For Python methods: true if the enclosing class is exported (in __all__ or public naming convention) */
+    pythonParentClassExported?: boolean;
 }
 export declare function collectCommonJsExports(source: string): Map<string, CommonJsExportInfo>;
 export declare function collectPythonAllNames(source: string): Set<string> | null;

package/dist/memory/config.d.ts

@@ -19,6 +19,7 @@ export interface MemoryConfig {
             tokenBudget: number;
         };
     };
+    learning: MemoryLearningConfig;
     writes: {
         mode: 'propose';
     };
@@ -84,9 +85,28 @@ export interface ConsolidationConfig {
      */
     decayHalfLifeDays: Record<MemoryKind, number>;
 }
+export interface MemoryLearningConfig {
+    learningRate: number;
+    propagationFactor: number;
+    qValueBoostWeight: number;
+    suppressionThreshold: number;
+    promotionThreshold: number;
+    propagationTokenOverlapThreshold: number;
+    /**
+     * Minimum cosine similarity (embedding space) for a candidate memory to
+     * qualify for soft propagation via the embedding path, independent of the
+     * token-overlap path. Only evaluated when `embeddings.enabled` is true and
+     * the configured embedding provider is available; otherwise propagation
+     * falls back to token-overlap only (issue #1467 acceptance criteria).
+     */
+    propagationEmbeddingCosineThreshold: number;
+    propagationFanout: number;
+    propagationLookbackDays: number;
+}
 export declare const DEFAULT_DECAY_HALF_LIFE_DAYS: Record<MemoryKind, number>;
 export declare const DEFAULT_IMPORTANCE_CONFIG: ImportanceConfig;
 export declare const DEFAULT_CONSOLIDATION_CONFIG: ConsolidationConfig;
+export declare const DEFAULT_MEMORY_LEARNING_CONFIG: MemoryLearningConfig;
 export declare const DEFAULT_EMBEDDINGS_CONFIG: {
     enabled: boolean;
     model: string;

package/dist/memory/gateway.d.ts

@@ -24,6 +24,7 @@ export interface RecallMemoryInput {
     maxItems?: number;
     tokenBudget?: number;
     minScore?: number;
+    includeLowQ?: boolean;
     requireQuerySignal?: boolean;
     includeExpired?: boolean;
 }

package/dist/memory/index.d.ts

@@ -9,9 +9,10 @@ export { backupLegacyJsonl, getLegacyJsonlFileStatus, type JsonlBackupResult, ty
 export { LocalJsonlMemoryProvider } from './local-jsonl-provider';
 export { buildMemoryMaintenanceReport, type MemoryMaintenanceReport, type MemoryMaintenanceReportOptions, type MemoryRecallUsageByMemory, type MemoryRecallUsageByRole, type MemorySupersededChain, shouldCompactMemory, } from './maintenance';
 export { buildRecallPromptBlock } from './prompt-block';
-export type { MemoryCompactOptions, MemoryCompactResult, MemoryProposalStore, MemoryProvider, MemoryRecallUsageEvent, MemoryRecallUsageFilter, } from './provider';
+export type { MemoryCompactOptions, MemoryCompactResult, MemoryProposalStore, MemoryProvider, MemoryRecallRewardInput, MemoryRecallRewardResult, MemoryRecallUsageEvent, MemoryRecallUsageFilter, MemoryTaskOutcome, MemoryValueLogEntry, MemoryValueLogFilter, } from './provider';
 export { buildMemoryRecallPlan, type MemoryRecallPlan, type MemoryRecallPlannerInput, } from './recall-planner';
 export { findSecrets, redactSecrets } from './redaction';
+export { applyRecallRewardForCouncil, councilVerdictToMemoryOutcome, resolveRewardRunIds, } from './reward';
 export { MEMORY_RECALL_PROFILES, type MemoryRecallProfile, normalizeMemoryAgentRole, resolveMemoryRecallProfile, } from './role-profiles';
 export { appendMemoryRunLog, sanitizeRunId } from './run-log';
 export { computeMemoryContentHash, createBundleId, createMemoryId, createProposalId, isExpired, normalizeMemoryText, validateCuratorMemoryDecision, validateMemoryProposal, validateMemoryRecordRules, } from './schema';

package/dist/memory/maintenance.d.ts

@@ -1,4 +1,4 @@
-import type { MemoryProposalStore, MemoryProvider } from './provider';
+import type { MemoryProposalStore, MemoryProvider, MemoryValueLogEntry } from './provider';
 import { type ImportanceWeights } from './scoring';
 import type { MemoryProposal, MemoryRecord } from './types';
 /**
@@ -40,6 +40,8 @@ export interface MemoryMaintenanceReport {
     supersededMemories: MemoryRecord[];
     supersededChains: MemorySupersededChain[];
     lowUtilityMemories: MemoryRecord[];
+    lowQValueMemories: MemoryValueLogEntry[];
+    promotionCandidates: MemoryValueLogEntry[];
     neverRecalledMemories: MemoryRecord[];
     mostRecalledMemories: MemoryRecallUsageByMemory[];
     recallByAgentRole: MemoryRecallUsageByRole[];
@@ -59,6 +61,7 @@ export interface MemoryMaintenanceReportOptions {
 }
 type ObservableProvider = MemoryProvider & Partial<MemoryProposalStore> & {
     listRecallUsage?: MemoryProvider['listRecallUsage'];
+    listMemoryValueLog?: MemoryProvider['listMemoryValueLog'];
 };
 export declare function buildMemoryMaintenanceReport(provider: ObservableProvider, options?: MemoryMaintenanceReportOptions): Promise<MemoryMaintenanceReport>;
 export declare function shouldCompactMemory(memory: MemoryRecord, now?: Date): 'deleted' | 'superseded' | 'expired_scratch' | null;

package/dist/memory/provider-pool.d.ts

@@ -46,5 +46,28 @@ export declare function releaseProvider(provider: MemoryProvider & Partial<Memor
 /**
  * Evict and close every cached provider. Intended for test teardown only —
  * production code should rely on LRU eviction.
+ *
+ * DANGER for production code paths: this force-closes EVERY pooled entry
+ * process-wide, bypassing the refCount contract that `releaseProvider()` /
+ * `evictLru()` honor — including entries for OTHER directories with active
+ * callers (this plugin's module-level pool is shared by every in-process
+ * memory operation, per AGENTS.md invariant 8). A production command that
+ * needs to force-close its OWN throwaway provider (e.g. before deleting a
+ * temp directory) must use `evictAndClose(directory)` instead, which is
+ * scoped to a single pool key and leaves every other entry untouched.
  */
 export declare function clearPool(): void;
+/**
+ * Force-close and evict the SINGLE pool entry for `directory` (matched via
+ * the same canonical key as `getOrCreateProvider`), regardless of refCount.
+ * Every other pooled entry is left completely untouched — safe to call from
+ * a scoped, single-directory teardown (e.g. a throwaway eval temp root about
+ * to be deleted) without disrupting other in-process callers sharing the
+ * pool. No-op if no entry exists for that directory.
+ *
+ * Bypassing refCount here is intentional and safe ONLY when the caller
+ * already knows the directory is being torn down and will never be accessed
+ * again (e.g. immediately followed by `fs.rm` on the same path) — it is not
+ * a general-purpose substitute for `releaseProvider()`.
+ */
+export declare function evictAndClose(directory: string): void;

package/dist/memory/provider.d.ts

@@ -14,11 +14,62 @@ export interface MemoryRecallUsageEvent {
     tokenEstimate: number;
     agentRole?: string;
     runId?: string;
+    qValue?: number;
+    lastReward?: number;
+    taskOutcome?: MemoryTaskOutcome;
     timestamp: string;
 }
 export interface MemoryRecallUsageFilter {
     limit?: number;
 }
+export type MemoryTaskOutcome = 'approved' | 'rejected' | 'concerns' | 'unknown';
+export interface MemoryRecallRewardInput {
+    /**
+     * Candidate session/run identifiers whose recall-usage bundle(s) should
+     * receive this reward. Every id is matched independently (exact match
+     * only, no unscoped time-window fallback); all matched bundles are
+     * rewarded together. Callers should include every session id known to
+     * have actually recalled memory for this task (e.g. dispatched council
+     * member sessions), not just the submitting session, so sub-agent
+     * recalls are not silently skipped.
+     */
+    runIds: string[];
+    outcome: MemoryTaskOutcome;
+    verdictPayload: unknown;
+    timestamp?: string;
+}
+export interface MemoryRecallRewardResult {
+    success: boolean;
+    /** First matched bundle id, for back-compat display. See `bundleIds` for the full set. */
+    bundleId?: string;
+    /** Every recall-usage bundle (across all matched runIds) that received this reward. */
+    bundleIds?: string[];
+    outcome: MemoryTaskOutcome;
+    memoryIds: string[];
+    updatedMemoryIds: string[];
+    propagatedMemoryIds: string[];
+    reward: number;
+    qValue?: number;
+    reason?: string;
+}
+export interface MemoryValueLogEntry {
+    memoryId: string;
+    kind: MemoryRecord['kind'];
+    scopeKey: string;
+    textPreview: string;
+    qValue: number;
+    lastReward?: number;
+    taskOutcome?: MemoryTaskOutcome;
+    recallCount: number;
+    lastRecalledAt?: string;
+    promotionCandidate: boolean;
+    suppressionCandidate: boolean;
+}
+export interface MemoryValueLogFilter {
+    limit?: number;
+    includePromotionCandidatesOnly?: boolean;
+    includeSuppressionCandidatesOnly?: boolean;
+}
 export interface MemoryCompactOptions {
     dryRun?: boolean;
     now?: string;
@@ -41,6 +92,8 @@ export interface MemoryProvider {
     recallWithDiagnostics?(request: RecallRequest): Promise<MemoryRecallResult>;
     recordRecallUsage?(event: MemoryRecallUsageEvent): Promise<void>;
     listRecallUsage?(filter?: MemoryRecallUsageFilter): Promise<MemoryRecallUsageEvent[]>;
+    applyRecallReward?(input: MemoryRecallRewardInput): Promise<MemoryRecallRewardResult>;
+    listMemoryValueLog?(filter?: MemoryValueLogFilter): Promise<MemoryValueLogEntry[]>;
     compactMaintenance?(options?: MemoryCompactOptions): Promise<MemoryCompactResult>;
     list(filter: MemoryListFilter): Promise<MemoryRecord[]>;
 }

package/dist/memory/reward.d.ts

@@ -0,0 +1,39 @@
+import type { CouncilVerdict } from '../council/types';
+import { type MemoryConfig } from './config';
+import type { MemoryRecallRewardInput, MemoryRecallRewardResult, MemoryTaskOutcome } from './provider';
+export declare function councilVerdictToMemoryOutcome(verdict: CouncilVerdict): MemoryTaskOutcome;
+/**
+ * Resolve the set of session/run ids whose recall-usage bundles should
+ * receive a council-verdict reward, deduplicated and order-preserving.
+ *
+ * `trustedSessionIds` are host/runtime-derived (e.g. `ctx.sessionID`) and are
+ * always included when present — they cannot be spoofed by tool-call
+ * arguments. `untrustedSessionIds` are caller-supplied strings (e.g. a
+ * `provenanceSessionId` arg or a per-verdict `sessionId` reported by the
+ * architect) and are included ONLY when `isKnownSession` returns true — an
+ * arbitrary, made-up string is silently dropped rather than trusted as a
+ * reward-targeting key.
+ *
+ * Important scope limitation: `isKnownSession` (backed by `getAgentSession`)
+ * proves only that the id belongs to SOME currently-tracked session
+ * process-wide — it does NOT prove that session actually participated in
+ * THIS council review. There is no swarmId/taskId cross-check available on
+ * `AgentSessionState` today, so a hallucinated or copied session id that
+ * happens to match a real, unrelated, concurrently-running session's id
+ * would still be accepted here. The blast radius is bounded to Q-value
+ * corruption of that other session's recalled memories (not privilege
+ * escalation or data exfiltration), but this is a real residual gap, not a
+ * complete fix — closing it fully requires a session→task ownership
+ * registry that does not exist in this codebase yet.
+ *
+ * A bare swarm identifier is never a valid session id substitute and must
+ * never be passed into either list.
+ */
+export declare function resolveRewardRunIds(input: {
+    trustedSessionIds: Array<string | undefined>;
+    untrustedSessionIds: Array<string | undefined>;
+    isKnownSession: (sessionId: string) => boolean;
+}): string[];
+export declare function applyRecallRewardForCouncil(directory: string, configInput: Partial<MemoryConfig> | undefined, input: Omit<MemoryRecallRewardInput, 'outcome'> & {
+    verdict: CouncilVerdict;
+}): Promise<MemoryRecallRewardResult>;

package/dist/memory/schema.d.ts

@@ -120,6 +120,7 @@ export declare const MemoryRecordSchema: z.ZodObject<{
     updatedAt: z.ZodString;
     lastAccessedAt: z.ZodOptional<z.ZodString>;
     expiresAt: z.ZodOptional<z.ZodString>;
+    qValue: z.ZodOptional<z.ZodNumber>;
     supersedes: z.ZodOptional<z.ZodArray<z.ZodString>>;
     supersededBy: z.ZodOptional<z.ZodString>;
     contentHash: z.ZodString;
@@ -198,6 +199,7 @@ export declare const MemoryProposalSchema: z.ZodObject<{
         updatedAt: z.ZodString;
         lastAccessedAt: z.ZodOptional<z.ZodString>;
         expiresAt: z.ZodOptional<z.ZodString>;
+        qValue: z.ZodOptional<z.ZodNumber>;
         supersedes: z.ZodOptional<z.ZodArray<z.ZodString>>;
         supersededBy: z.ZodOptional<z.ZodString>;
         contentHash: z.ZodString;

package/dist/memory/scoring.d.ts

@@ -26,6 +26,7 @@ export declare const SCORING_WEIGHTS: {
     readonly roleBoost: 0.05;
     readonly confidence: 0.08;
 };
+export declare const DEFAULT_MEMORY_Q_VALUE = 0.5;
 export declare function tokenize(text: string): Set<string>;
 /**
  * True Jaccard similarity |A∩B| / |A∪B| over two token sets. Distinct from the
@@ -74,6 +75,7 @@ export declare function importanceScore(input: {
 export declare function sameScope(a: MemoryScopeRef, b: MemoryScopeRef): boolean;
 export declare function scopeAllowed(recordScope: MemoryScopeRef, allowedScopes: MemoryScopeRef[]): boolean;
 export declare function scoreMemoryRecord(record: MemoryRecord, request: RecallRequest): RecallResultItem | null;
+export declare function memoryQValue(record: MemoryRecord): number;
 export declare function scoreMemoryRecords(records: MemoryRecord[], request: RecallRequest): RecallResultItem[];
 export declare function scoreMemoryRecordsWithDiagnostics(records: MemoryRecord[], request: RecallRequest): {
     items: RecallResultItem[];

package/dist/memory/sqlite-provider.d.ts

@@ -1,6 +1,7 @@
 import { type MemoryConfig } from './config';
+import type { EmbeddingProvider } from './embeddings/types';
 import { type JsonlMigrationReport } from './jsonl-migration';
-import type { MemoryCompactOptions, MemoryCompactResult, MemoryProposalStore, MemoryProvider, MemoryRecallUsageEvent, MemoryRecallUsageFilter } from './provider';
+import type { MemoryCompactOptions, MemoryCompactResult, MemoryProposalStore, MemoryProvider, MemoryRecallRewardInput, MemoryRecallRewardResult, MemoryRecallUsageEvent, MemoryRecallUsageFilter, MemoryValueLogEntry, MemoryValueLogFilter } from './provider';
 import type { RecallScoringDiagnostics } from './scoring';
 import type { AppliedMemoryChange, MemoryListFilter, MemoryProposal, MemoryRecord, RecallRequest, RecallResultItem, ResolvedCuratorMemoryDecision } from './types';
 interface Migration {
@@ -32,6 +33,21 @@ export declare class SQLiteMemoryProvider implements MemoryProvider, MemoryPropo
     private lastAutomaticJsonlMigration;
     private recallCountSinceLastCompaction;
     private isCompacting;
+    /**
+     * _internals DI seam for testing. Exposes key methods so tests can inject
+     * failures without touching the module-level mock surface.
+     */
+    readonly _internals: {
+        writeMemory: (record: MemoryRecord) => void;
+        /**
+         * Test-only seam: inject a fake embedding provider so propagation's
+         * cosine-similarity path can be exercised without the real
+         * `@xenova/transformers` model dependency. Must be called AFTER
+         * `initialize()` (which may otherwise construct/overwrite the real
+         * provider when `embeddings.enabled` is true).
+         */
+        setEmbeddingProvider: (provider: EmbeddingProvider | null) => void;
+    };
     constructor(rootDirectory: string, config?: Partial<MemoryConfig>);
     private databasePath;
     initialize(): Promise<void>;
@@ -46,6 +62,8 @@ export declare class SQLiteMemoryProvider implements MemoryProvider, MemoryPropo
     }>;
     recordRecallUsage(event: MemoryRecallUsageEvent): Promise<void>;
     listRecallUsage(filter?: MemoryRecallUsageFilter): Promise<MemoryRecallUsageEvent[]>;
+    applyRecallReward(input: MemoryRecallRewardInput): Promise<MemoryRecallRewardResult>;
+    listMemoryValueLog(filter?: MemoryValueLogFilter): Promise<MemoryValueLogEntry[]>;
     list(filter?: MemoryListFilter): Promise<MemoryRecord[]>;
     createProposal(proposal: MemoryProposal): Promise<MemoryProposal>;
     listProposals(filter?: {
@@ -73,6 +91,40 @@ export declare class SQLiteMemoryProvider implements MemoryProvider, MemoryPropo
         proposals: number;
     }>;
     compactMaintenance(options?: MemoryCompactOptions): Promise<MemoryCompactResult>;
+    /**
+     * Find, across the given candidate session/run ids, the most recent
+     * recall-usage bundle for EACH distinct matching id (exact match only —
+     * no unscoped time-window fallback, which would risk rewarding an
+     * unrelated task/session's recall bundle). Every distinct matched runId
+     * contributes its own latest bundle, so a council review informed by
+     * several sessions (e.g. dispatched council-member sub-agents) rewards
+     * all of their recalls, not just one.
+     */
+    private matchingRecallUsageRows;
+    private updateMemoryQValue;
+    /**
+     * Select soft-propagation targets among recently-recalled, same-scope
+     * memories via two independent qualifying paths (issue #1467 O-004):
+     * lexical token-overlap (Jaccard, gated additionally on same `kind`), OR
+     * embedding cosine similarity when `embeddings.enabled` and a provider is
+     * available (not gated on `kind` — semantic similarity can legitimately
+     * cross kinds). A candidate qualifies if EITHER path clears its
+     * threshold; the higher of the two scores is used for fanout-cap
+     * ranking. When embeddings are disabled (the default), this reduces to
+     * the original token-overlap-only behavior with no extra cost.
+     */
+    private findPropagationTargets;
+    /**
+     * Embed `text` (cache-first, same pattern as the recall-time query
+     * embedding lookup) for use in propagation's cosine-similarity path.
+     * Returns null on any embedding failure or when no provider is
+     * configured — callers must treat that as "no cosine signal available"
+     * and fall back to the token-overlap path rather than throwing, since
+     * this is a best-effort enhancement to an already-approximate feature.
+     */
+    private getCachedEmbeddingForPropagation;
+    private recentlyRecalledMemoryIds;
+    private listRecallUsageSync;
     hasMigration(name: string): boolean;
     markMigration(version: number, name: string): void;
     private selectRecallCandidates;

package/dist/memory/types.d.ts

@@ -31,6 +31,7 @@ export interface MemoryRecord {
     updatedAt: string;
     lastAccessedAt?: string;
     expiresAt?: string;
+    qValue?: number;
     supersedes?: string[];
     supersededBy?: string;
     contentHash: string;
@@ -142,6 +143,9 @@ export interface RecallRequest {
     maxItems: number;
     tokenBudget: number;
     minScore?: number;
+    qValueBoostWeight?: number;
+    suppressionThreshold?: number;
+    includeLowQ?: boolean;
     requireQuerySignal?: boolean;
     includeExpired?: boolean;
     includePendingProposals?: boolean;
@@ -155,6 +159,7 @@ export interface RecallResultItem {
         tagOverlap: number;
         fileOverlap?: number;
         symbolOverlap?: number;
+        qValue?: number;
         kindMatch: boolean;
         scopeMatch: boolean;
     };

package/dist/state.d.ts

@@ -334,9 +334,9 @@ export declare const swarmState: {
         phase?: string;
         generatedAt: number;
     }>;
-    /** v2: dedup set for ack records. Key = `${sessionId}|${id}|${result}|${dayKey}`.
+    /** v2: dedup set for ack records. Key = `${sessionId}|${id}|${result}`.
      *  Prevents the chat.messages.transform path AND a knowledge_ack tool call
-     *  from double-counting the same ack within a session-day. FIFO-capped —
+     *  from double-counting the same ack within a session. FIFO-capped —
      *  see addKnowledgeAckDedup. */
     knowledgeAckDedup: Set<string>;
     /**

package/dist/tools/convene-council.d.ts

@@ -49,7 +49,9 @@ export declare const ArgsSchema: z.ZodObject<{
         criteriaAssessed: z.ZodArray<z.ZodString>;
         criteriaUnmet: z.ZodArray<z.ZodString>;
         durationMs: z.ZodNumber;
+        sessionId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     working_directory: z.ZodOptional<z.ZodString>;
+    provenanceSessionId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const submit_council_verdicts: ReturnType<typeof tool>;

package/dist/tools/repo-graph/builder.d.ts

@@ -11,7 +11,7 @@
  * used by both the builder and the incremental updater.
  */
 import { extractFileSymbols } from '../../lang/symbol-graph';
-import { extractPythonSymbols, extractTSSymbols } from '../symbols';
+import { extractGoSymbols, extractPythonSymbols, extractRustSymbols, extractTSSymbols } from '../symbols';
 import { extractFileOntology } from './ontology';
 import { safeRealpathSync } from './safe-realpath';
 import type { BuildWorkspaceGraphOptions, GraphEdge, GraphNode, RepoGraph, RepoGraphDiagnostics, SymbolEdge } from './types';
@@ -25,6 +25,8 @@ export declare const _internals: {
     safeRealpathSync: typeof safeRealpathSync;
     extractTSSymbols: typeof extractTSSymbols;
     extractPythonSymbols: typeof extractPythonSymbols;
+    extractRustSymbols: typeof extractRustSymbols;
+    extractGoSymbols: typeof extractGoSymbols;
     parseFileImports: typeof parseFileImports;
     extractFileOntology: typeof extractFileOntology;
     stripComments: typeof stripComments;
@@ -108,7 +110,7 @@ interface ParsedImport {
  * character (REGEX_ALLOWED_AFTER).
  */
 declare function stripComments(content: string): string;
-declare function parseFileImports(rawContent: string): ParsedImport[];
+declare function parseFileImports(rawContent: string, sourceFile?: string, workspaceRoot?: string): ParsedImport[];
 /**
  * Conservatively determine which imported bindings are actually referenced in
  * the importing file's body.

package/dist/tools/submit-phase-council-verdicts.d.ts

@@ -35,6 +35,7 @@ export declare const ArgsSchema: z.ZodObject<{
         criteriaAssessed: z.ZodArray<z.ZodString>;
         criteriaUnmet: z.ZodArray<z.ZodString>;
         durationMs: z.ZodNumber;
+        sessionId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     working_directory: z.ZodOptional<z.ZodString>;
     provenanceAgentName: z.ZodOptional<z.ZodString>;

package/dist/tools/symbols.d.ts

@@ -17,5 +17,7 @@ export declare function extractTSSymbols(filePath: string, cwd: string): SymbolI
  * Extract symbols from a Python file.
  */
 export declare function extractPythonSymbols(filePath: string, cwd: string): SymbolInfo[];
+export declare function extractRustSymbols(filePath: string, cwd: string): SymbolInfo[];
+export declare function extractGoSymbols(filePath: string, cwd: string): SymbolInfo[];
 export declare const symbols: ToolDefinition;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.103.2",
+	"version": "7.104.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",