opencode-swarm 7.105.0 → 7.106.0

package/dist/memory/schema.d.ts

@@ -3,19 +3,19 @@ import type { CuratorMemoryDecision, MemoryKind, MemoryPatch, MemoryProposal, Me
 export declare const MemoryScopeTypeSchema: z.ZodEnum<{
     agent: "agent";
     project: "project";
-    workspace: "workspace";
-    run: "run";
     global_user: "global_user";
+    workspace: "workspace";
     repository: "repository";
+    run: "run";
 }>;
 export declare const MemoryScopeRefSchema: z.ZodObject<{
     type: z.ZodEnum<{
         agent: "agent";
         project: "project";
-        workspace: "workspace";
-        run: "run";
         global_user: "global_user";
+        workspace: "workspace";
         repository: "repository";
+        run: "run";
     }>;
     userId: z.ZodOptional<z.ZodString>;
     workspaceId: z.ZodOptional<z.ZodString>;
@@ -63,10 +63,10 @@ export declare const MemoryRecordSchema: z.ZodObject<{
         type: z.ZodEnum<{
             agent: "agent";
             project: "project";
-            workspace: "workspace";
-            run: "run";
             global_user: "global_user";
+            workspace: "workspace";
             repository: "repository";
+            run: "run";
         }>;
         userId: z.ZodOptional<z.ZodString>;
         workspaceId: z.ZodOptional<z.ZodString>;
@@ -142,10 +142,10 @@ export declare const MemoryProposalSchema: z.ZodObject<{
             type: z.ZodEnum<{
                 agent: "agent";
                 project: "project";
-                workspace: "workspace";
-                run: "run";
                 global_user: "global_user";
+                workspace: "workspace";
                 repository: "repository";
+                run: "run";
             }>;
             userId: z.ZodOptional<z.ZodString>;
             workspaceId: z.ZodOptional<z.ZodString>;
@@ -218,8 +218,8 @@ export declare const MemoryProposalSchema: z.ZodObject<{
         pending: "pending";
         rejected: "rejected";
         approved: "approved";
-        applied: "applied";
         superseded: "superseded";
+        applied: "applied";
     }>;
     reviewer: z.ZodOptional<z.ZodEnum<{
         user: "user";

package/dist/memory/scoring.d.ts

@@ -1,3 +1,4 @@
+import type { QLearningConfig } from './config';
 import type { MemoryRecord, MemoryScopeRef, RecallRequest, RecallResultItem } from './types';
 export interface RecallScoringDiagnostics {
     candidateCount: number;
@@ -6,6 +7,14 @@ export interface RecallScoringDiagnostics {
     returnedCount: number;
     noSignalCount: number;
     belowThresholdCount: number;
+    /** Count of records skipped via the A.6 low-q suppression filter (FR-006/SC-007). */
+    suppressedLowQCount: number;
+    /**
+     * 0 or 1 — whether the C.1 active-exploration layer resurfaced a
+     * suppressed candidate this recall (FR-014/SC-016). At most one per
+     * recall by design; see `scoreMemoryRecordsWithDiagnostics`.
+     */
+    exploredCount: number;
     fusionActive?: boolean;
 }
 /**
@@ -14,6 +23,14 @@ export interface RecallScoringDiagnostics {
  * are calibrated against these weights.
  *
  * Pinned by tests/unit/memory/scoring.test.ts to detect drift.
+ *
+ * A.5 note: the learned-utility (q-value) term is intentionally NOT part of
+ * this static table. Its weight is `qLearning.qValueBoostWeight` (config,
+ * default 0.10) so it stays user-tunable, and its contribution is CENTERED
+ * on the neutral q-value (see `NEUTRAL_Q_VALUE`) rather than a flat add — a
+ * neutral-q record contributes 0, so the max score impact is
+ * `±0.10 * 0.5 = ±0.05`, not a flat `+0.10`. It only affects ranking order,
+ * never the `minScore` inclusion cutoff (FR-005 / SC-006).
  */
 export declare const SCORING_WEIGHTS: {
     readonly textOverlap: 0.38;
@@ -26,7 +43,6 @@ 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,10 +90,49 @@ export declare function importanceScore(input: {
 }, weights: ImportanceWeights): number;
 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): {
+export declare function scoreMemoryRecord(record: MemoryRecord, request: RecallRequest, qLearningConfig?: QLearningConfig): RecallResultItem | null;
+export declare function scoreMemoryRecords(records: MemoryRecord[], request: RecallRequest, qLearningConfig?: QLearningConfig): RecallResultItem[];
+export interface ScoreMemoryRecordsOptions {
+    /**
+     * RNG seam for the C.1 active-exploration draw (FR-014/SC-016). Defaults
+     * to `Math.random`. Tests inject a deterministic function — `() => 0`
+     * forces exploration (for any `explorationRate > 0`), `() => 0.99` forces
+     * none (for the default `explorationRate` of 0.05) — so exploration is
+     * unit-testable without depending on real randomness.
+     */
+    random?: () => number;
+}
+export declare function scoreMemoryRecordsWithDiagnostics(records: MemoryRecord[], request: RecallRequest, qLearningConfig?: QLearningConfig, options?: ScoreMemoryRecordsOptions): {
     items: RecallResultItem[];
     diagnostics: RecallScoringDiagnostics;
 };
+/**
+ * Applies the recall `maxItems` cap ADDITIVELY with respect to the C.1
+ * active-exploration item (FR-014/SC-016 reviewer fix). Normal (non-explored)
+ * items are capped at `maxItems` in their existing order; the single
+ * `explored: true` item (if present in `items`) is then appended AFTER the
+ * cap, beyond `maxItems`.
+ *
+ * This guarantees bounded exploration can never evict a legitimate ranked
+ * hit: a recall can return at most `maxItems` normal hits plus (at most) one
+ * explored item — never fewer normal hits because an explored candidate
+ * displaced one within the cap. Every provider recall-slicing site
+ * (`sqlite-provider.ts`, `local-jsonl-provider.ts`) must use this helper
+ * instead of a plain `.slice(0, maxItems)` so exploration stays additive
+ * everywhere `maxItems` is enforced.
+ *
+ * SCOPE OF THE GUARANTEE (reviewer note, known limitation G-3): additivity is
+ * strict at THIS slice. On the opt-in embeddings/RRF fusion path the explored
+ * item participates in `fuseRankings` as an ordinary lexical candidate BEFORE
+ * this slice (`sqlite-provider.ts`), and because exploration deliberately picks
+ * the highest-baseScore suppressed record, it can out-rank a normal hit by one
+ * lexical position; after `minMaxNormalise` a normal item sitting exactly on
+ * the fusion `minScore` boundary can then fall below the Stage-5 re-gate
+ * BECAUSE the explored item was present. That is a marginal RRF reshuffle
+ * upstream of the slice, not an eviction at the slice. Making additivity strict
+ * through fusion too would require excluding `explored` items from
+ * `fuseRankings` and re-injecting them only here — deferred with G-1/G-2 to the
+ * injection-path/fusion enhancement (fixing it alone is moot while G-2 gates
+ * the dominant injection path).
+ */
+export declare function sliceRecallItemsWithExploration(items: RecallResultItem[], maxItems: number): RecallResultItem[];

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

@@ -1,7 +1,6 @@
 import { type MemoryConfig } from './config';
-import type { EmbeddingProvider } from './embeddings/types';
 import { type JsonlMigrationReport } from './jsonl-migration';
-import type { MemoryCompactOptions, MemoryCompactResult, MemoryProposalStore, MemoryProvider, MemoryRecallRewardInput, MemoryRecallRewardResult, MemoryRecallUsageEvent, MemoryRecallUsageFilter, MemoryValueLogEntry, MemoryValueLogFilter } from './provider';
+import type { MemoryCompactOptions, MemoryCompactResult, MemoryProposalStore, MemoryProvider, MemoryRecallUsageEvent, MemoryRecallUsageFilter, MemoryRewardEvent, MemoryRewardEventFilter, MemoryTransaction } from './provider';
 import type { RecallScoringDiagnostics } from './scoring';
 import type { AppliedMemoryChange, MemoryListFilter, MemoryProposal, MemoryRecord, RecallRequest, RecallResultItem, ResolvedCuratorMemoryDecision } from './types';
 interface Migration {
@@ -33,27 +32,13 @@ 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>;
     private doInitialize;
     upsert(record: MemoryRecord): Promise<MemoryRecord>;
     get(id: string): Promise<MemoryRecord | null>;
+    withTransaction<T>(fn: (tx: MemoryTransaction) => Promise<T> | T): Promise<T>;
     delete(id: string, reason?: string): Promise<void>;
     recall(request: RecallRequest): Promise<RecallResultItem[]>;
     recallWithDiagnostics(request: RecallRequest): Promise<{
@@ -62,8 +47,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[]>;
+    appendRewardEvent(event: Omit<MemoryRewardEvent, 'id'>): Promise<void>;
+    listRewardEvents(filter?: MemoryRewardEventFilter): Promise<MemoryRewardEvent[]>;
     list(filter?: MemoryListFilter): Promise<MemoryRecord[]>;
     createProposal(proposal: MemoryProposal): Promise<MemoryProposal>;
     listProposals(filter?: {
@@ -91,40 +76,6 @@ 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;
@@ -132,6 +83,7 @@ export declare class SQLiteMemoryProvider implements MemoryProvider, MemoryPropo
     private selectDenseCandidates;
     private runMigrations;
     private backfillScopeKeys;
+    private backfillRecallRunIds;
     private initializeFtsIndex;
     private initializeVecExtension;
     private recreateFtsIndex;

package/dist/memory/types.d.ts

@@ -31,7 +31,6 @@ export interface MemoryRecord {
     updatedAt: string;
     lastAccessedAt?: string;
     expiresAt?: string;
-    qValue?: number;
     supersedes?: string[];
     supersededBy?: string;
     contentHash: string;
@@ -143,12 +142,15 @@ export interface RecallRequest {
     maxItems: number;
     tokenBudget: number;
     minScore?: number;
-    qValueBoostWeight?: number;
-    suppressionThreshold?: number;
-    includeLowQ?: boolean;
     requireQuerySignal?: boolean;
     includeExpired?: boolean;
     includePendingProposals?: boolean;
+    /**
+     * Opt in to include memories suppressed for low learned utility (q-value
+     * below `qLearning.suppressionThreshold`). Default recall omits them;
+     * suppression never deletes or tombstones the underlying record.
+     */
+    includeLowQ?: boolean;
 }
 export interface RecallResultItem {
     record: MemoryRecord;
@@ -159,10 +161,17 @@ export interface RecallResultItem {
         tagOverlap: number;
         fileOverlap?: number;
         symbolOverlap?: number;
-        qValue?: number;
         kindMatch: boolean;
         scopeMatch: boolean;
     };
+    /**
+     * C.1 (FR-014/SC-016): true when this item was an otherwise-suppressed
+     * low-q memory (qValue < `qLearning.suppressionThreshold`) resurfaced by
+     * the bounded active-exploration layer in
+     * `scoreMemoryRecordsWithDiagnostics`, rather than a normal recall hit.
+     * Absent/undefined for every normal (non-explored) item.
+     */
+    explored?: boolean;
 }
 export interface RecallBundle {
     id: string;
@@ -185,6 +194,17 @@ export interface MemoryContext {
     agentRole?: string;
     agentId?: string;
     runId?: string;
+    /**
+     * Task/phase unit-of-work identity (e.g. plan task id "1.1"). ADDITIVE join
+     * key recorded alongside `runId` on recall-usage rows so reward attribution
+     * (B.2) and the finalize sweep (B.6) can join memories to the unit of work
+     * they were recalled for — independent of session id. NULL/undefined when a
+     * trustworthy id cannot be resolved at recording time; the system then
+     * degrades to today's session-scoped (`runId`) behavior. Never defaulted to
+     * sessionID — that would repopulate the exact session-scoped value this
+     * escapes.
+     */
+    unitId?: string;
 }
 export interface MemoryListFilter {
     scopes?: MemoryScopeRef[];

package/dist/state.d.ts

@@ -137,6 +137,13 @@ export interface AgentSessionState {
          * quorumSize: 1 — conservative; forces a fresh council run.
          */
         quorumSize: number;
+        /**
+         * A.4 dedup guard: set true once the positive council reward
+         * (EMA step on session-recalled memories) has fired for this task.
+         * Ensures the reward is applied at most once per task even if the
+         * APPROVE→complete path is re-entered.
+         */
+        rewarded?: boolean;
     }>;
     /**
      * Per-(task,round) required council members for the next submission attempt.
@@ -334,9 +341,9 @@ export declare const swarmState: {
         phase?: string;
         generatedAt: number;
     }>;
-    /** v2: dedup set for ack records. Key = `${sessionId}|${id}|${result}`.
+    /** v2: dedup set for ack records. Key = `${sessionId}|${id}|${result}|${dayKey}`.
      *  Prevents the chat.messages.transform path AND a knowledge_ack tool call
-     *  from double-counting the same ack within a session. FIFO-capped —
+     *  from double-counting the same ack within a session-day. FIFO-capped —
      *  see addKnowledgeAckDedup. */
     knowledgeAckDedup: Set<string>;
     /**

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

@@ -49,9 +49,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>;
-    provenanceSessionId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const submit_council_verdicts: ReturnType<typeof tool>;

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

@@ -35,7 +35,6 @@ 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/swarm-memory-recall.d.ts

@@ -1,8 +1,10 @@
 import { loadPluginConfigWithMeta } from '../config';
 import { createMemoryGateway } from '../memory';
+import { getAgentSession } from '../state';
 import { createSwarmTool } from './create-tool';
 export declare const swarm_memory_recall: ReturnType<typeof createSwarmTool>;
 export declare const _internals: {
     loadPluginConfigWithMeta: typeof loadPluginConfigWithMeta;
     createMemoryGateway: typeof createMemoryGateway;
+    getAgentSession: typeof getAgentSession;
 };

package/dist/tools/write-final-council-evidence.d.ts

@@ -5,7 +5,7 @@
  * five-member CouncilMemberVerdict objects used by phase council, synthesized
  * at completed-project scope.
  */
-import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+import type { ToolContext, ToolDefinition } from '@opencode-ai/plugin/tool';
 import { z } from 'zod';
 import type { CouncilMemberVerdict } from '../council/types';
 export declare const ArgsSchema: z.ZodObject<{
@@ -60,7 +60,7 @@ export interface WriteFinalCouncilEvidenceArgs {
  * Execute the write_final_council_evidence tool.
  * Validates input, synthesizes project-scoped council evidence, and writes it.
  */
-export declare function executeWriteFinalCouncilEvidence(args: unknown, directory: string): Promise<string>;
+export declare function executeWriteFinalCouncilEvidence(args: unknown, directory: string, ctx?: ToolContext): Promise<string>;
 /**
  * Tool definition for write_final_council_evidence.
  */

package/package.json

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

package/dist/memory/reward.d.ts

@@ -1,39 +0,0 @@
-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>;