opencode-swarm 7.31.0 → 7.32.1

package/dist/memory/gateway.d.ts

@@ -18,6 +18,7 @@ export interface ProposeMemoryInput {
 export interface RecallMemoryInput {
     query: string;
     task?: string;
+    scopes?: MemoryScopeRef[];
     kinds?: MemoryKind[];
     maxItems?: number;
     tokenBudget?: number;

package/dist/memory/index.d.ts

@@ -3,9 +3,13 @@ export { DEFAULT_MEMORY_CONFIG, resolveMemoryConfig } from './config';
 export { MemoryDisabledError, MemoryValidationError } from './errors';
 export type { MemoryGatewayOptions, ProposeMemoryInput, RecallMemoryInput, } from './gateway';
 export { createMemoryGateway, MemoryGateway } from './gateway';
+export { createMemoryLifecycleHooks, type MemoryLifecycleHookOptions, type MemoryLifecycleHooks, } from './injector';
 export { LocalJsonlMemoryProvider } from './local-jsonl-provider';
 export { buildRecallPromptBlock } from './prompt-block';
 export type { MemoryProposalStore, MemoryProvider } from './provider';
+export { buildMemoryRecallPlan, type MemoryRecallPlan, type MemoryRecallPlannerInput, } from './recall-planner';
 export { findSecrets, redactSecrets } from './redaction';
+export { MEMORY_RECALL_PROFILES, type MemoryRecallProfile, normalizeMemoryAgentRole, resolveMemoryRecallProfile, } from './role-profiles';
+export { appendMemoryRunLog, sanitizeRunId } from './run-log';
 export { computeMemoryContentHash, createBundleId, createMemoryId, createProposalId, isExpired, normalizeMemoryText, validateMemoryProposal, validateMemoryRecordRules, } from './schema';
 export type { MemoryContext, MemoryKind, MemoryListFilter, MemoryProposal, MemoryRecord, MemoryScopeRef, MemoryScopeType, RecallBundle, RecallRequest, RecallResultItem, } from './types';

package/dist/memory/injector.d.ts

@@ -0,0 +1,31 @@
+import type { MemoryConfig } from './config';
+import type { MemoryGateway, ProposeMemoryInput } from './gateway';
+import { appendMemoryRunLog } from './run-log';
+import type { MemoryKind } from './types';
+export interface MemoryLifecycleHookOptions {
+    directory: string;
+    config?: Partial<MemoryConfig>;
+    getActiveAgentName?: (sessionID: string | undefined) => string | undefined;
+    createGateway?: (context: {
+        directory: string;
+        sessionID?: string;
+        agentRole?: string;
+        agentId?: string;
+        runId?: string;
+    }, options: {
+        config?: Partial<MemoryConfig>;
+    }) => Pick<MemoryGateway, 'isEnabled' | 'deriveAllowedScopes' | 'recall' | 'propose'>;
+    appendRunLog?: typeof appendMemoryRunLog;
+}
+export interface MemoryLifecycleHooks {
+    messagesTransform(input: unknown, output: unknown): Promise<void>;
+    toolAfter(input: unknown, output: unknown): Promise<void>;
+}
+export declare function createMemoryLifecycleHooks(options: MemoryLifecycleHookOptions): MemoryLifecycleHooks;
+declare function messagesContainRecall(messages: unknown[]): boolean;
+declare function compactText(text: string): string;
+export type { ProposeMemoryInput, MemoryKind };
+export declare const _test_exports: {
+    compactText: typeof compactText;
+    messagesContainRecall: typeof messagesContainRecall;
+};

package/dist/memory/local-jsonl-provider.d.ts

@@ -1,5 +1,5 @@
 import { type MemoryConfig } from './config';
-import type { MemoryProposalStore, MemoryProvider } from './provider';
+import type { MemoryProposalStore, MemoryProvider, MemoryRecallUsageEvent } from './provider';
 import type { MemoryListFilter, MemoryProposal, MemoryRecord, RecallRequest, RecallResultItem } from './types';
 export declare class LocalJsonlMemoryProvider implements MemoryProvider, MemoryProposalStore {
     readonly name = "local-jsonl";
@@ -15,6 +15,7 @@ export declare class LocalJsonlMemoryProvider implements MemoryProvider, MemoryP
     get(id: string): Promise<MemoryRecord | null>;
     delete(id: string, reason?: string): Promise<void>;
     recall(request: RecallRequest): Promise<RecallResultItem[]>;
+    recordRecallUsage(event: MemoryRecallUsageEvent): Promise<void>;
     list(filter?: MemoryListFilter): Promise<MemoryRecord[]>;
     createProposal(proposal: MemoryProposal): Promise<MemoryProposal>;
     listProposals(filter?: {

package/dist/memory/prompt-block.d.ts

@@ -1,5 +1,5 @@
 import type { RecallBundle, RecallResultItem } from './types';
-export declare function buildRecallPromptBlock(items: RecallResultItem[], tokenBudget: number): {
+export declare function buildRecallPromptBlock(items: RecallResultItem[], tokenBudget: number, generatedAt?: string): {
     promptBlock: string;
     tokenEstimate: number;
     items: RecallResultItem[];

package/dist/memory/provider.d.ts

@@ -1,4 +1,16 @@
 import type { MemoryListFilter, MemoryProposal, MemoryRecord, RecallRequest, RecallResultItem } from './types';
+export interface MemoryRecallUsageEvent {
+    bundleId: string;
+    query: string;
+    scopes: RecallRequest['scopes'];
+    kinds?: RecallRequest['kinds'];
+    memoryIds: string[];
+    scores: number[];
+    tokenEstimate: number;
+    agentRole?: string;
+    runId?: string;
+    timestamp: string;
+}
 export interface MemoryProvider {
     readonly name: string;
     initialize?(): Promise<void>;
@@ -6,6 +18,7 @@ export interface MemoryProvider {
     get(id: string): Promise<MemoryRecord | null>;
     delete(id: string, reason?: string): Promise<void>;
     recall(request: RecallRequest): Promise<RecallResultItem[]>;
+    recordRecallUsage?(event: MemoryRecallUsageEvent): Promise<void>;
     list(filter: MemoryListFilter): Promise<MemoryRecord[]>;
 }
 export interface MemoryProposalStore {

package/dist/memory/recall-planner.d.ts

@@ -0,0 +1,26 @@
+import { type MemoryRecallProfile } from './role-profiles';
+import type { MemoryKind, MemoryScopeRef } from './types';
+export interface MemoryRecallPlannerInput {
+    userGoal: string;
+    runId: string;
+    agentRole: string;
+    agentId: string;
+    agentTask: string;
+    projectId?: string;
+    repoId?: string;
+    repoRoot?: string;
+    touchedFiles?: string[];
+    currentPlanSummary?: string;
+}
+export interface MemoryRecallPlan {
+    query: string;
+    scopes: MemoryScopeRef[];
+    kinds: MemoryKind[];
+    maxItems: number;
+    tokenBudget: number;
+}
+export interface BuildMemoryRecallPlanOptions {
+    scopes?: MemoryScopeRef[];
+    profile?: MemoryRecallProfile;
+}
+export declare function buildMemoryRecallPlan(input: MemoryRecallPlannerInput, options?: BuildMemoryRecallPlanOptions): MemoryRecallPlan;

package/dist/memory/role-profiles.d.ts

@@ -0,0 +1,41 @@
+import type { MemoryKind } from './types';
+export interface MemoryRecallProfile {
+    kinds: MemoryKind[];
+    maxItems: number;
+    tokenBudget: number;
+}
+export declare const MEMORY_RECALL_PROFILES: {
+    readonly architect: {
+        readonly kinds: ["project_fact", "architecture_decision", "repo_convention", "failure_pattern", "security_note"];
+        readonly maxItems: 10;
+        readonly tokenBudget: 1600;
+    };
+    readonly sme: {
+        readonly kinds: ["api_finding", "code_pattern", "repo_convention", "failure_pattern", "evidence"];
+        readonly maxItems: 8;
+        readonly tokenBudget: 1200;
+    };
+    readonly coder: {
+        readonly kinds: ["architecture_decision", "repo_convention", "code_pattern", "test_pattern", "failure_pattern"];
+        readonly maxItems: 8;
+        readonly tokenBudget: 1200;
+    };
+    readonly qa: {
+        readonly kinds: ["test_pattern", "failure_pattern", "repo_convention", "security_note"];
+        readonly maxItems: 8;
+        readonly tokenBudget: 1200;
+    };
+    readonly security: {
+        readonly kinds: ["security_note", "architecture_decision", "repo_convention", "evidence"];
+        readonly maxItems: 8;
+        readonly tokenBudget: 1200;
+    };
+    readonly curator: {
+        readonly kinds: ["project_fact", "architecture_decision", "repo_convention", "api_finding", "code_pattern", "test_pattern", "failure_pattern", "security_note", "evidence"];
+        readonly maxItems: 20;
+        readonly tokenBudget: 3000;
+    };
+};
+export type MemoryRecallProfileName = keyof typeof MEMORY_RECALL_PROFILES;
+export declare function resolveMemoryRecallProfile(agentRole: string | undefined): MemoryRecallProfile;
+export declare function normalizeMemoryAgentRole(agentRole: string | undefined): MemoryRecallProfileName;

package/dist/memory/run-log.d.ts

@@ -0,0 +1,17 @@
+export type MemoryRunLogEventName = 'recall_requested' | 'recall_returned' | 'prompt_injected' | 'proposal_created' | 'proposal_rejected_by_validation';
+export interface MemoryRunLogEvent {
+    event: MemoryRunLogEventName;
+    runId: string;
+    agentRole?: string;
+    agentId?: string;
+    bundleId?: string;
+    memoryIds?: string[];
+    scores?: number[];
+    tokenEstimate?: number;
+    proposalId?: string;
+    rejectionReason?: string;
+    timestamp?: string;
+    metadata?: Record<string, unknown>;
+}
+export declare function appendMemoryRunLog(directory: string, runId: string | undefined, event: MemoryRunLogEvent): Promise<void>;
+export declare function sanitizeRunId(runId: string | undefined): string;

package/dist/memory/schema.d.ts

@@ -41,8 +41,8 @@ export declare const MemoryKindSchema: z.ZodEnum<{
 }>;
 export declare const MemorySourceSchema: z.ZodObject<{
     type: z.ZodEnum<{
-        agent: "agent";
         file: "file";
+        agent: "agent";
         manual: "manual";
         test: "test";
         tool: "tool";
@@ -100,8 +100,8 @@ export declare const MemoryRecordSchema: z.ZodObject<{
     }>;
     source: z.ZodObject<{
         type: z.ZodEnum<{
-            agent: "agent";
             file: "file";
+            agent: "agent";
             manual: "manual";
             test: "test";
             tool: "tool";
@@ -178,8 +178,8 @@ export declare const MemoryProposalSchema: z.ZodObject<{
         }>;
         source: z.ZodObject<{
             type: z.ZodEnum<{
-                agent: "agent";
                 file: "file";
+                agent: "agent";
                 manual: "manual";
                 test: "test";
                 tool: "tool";

package/package.json

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