opencode-swarm 7.144.1 → 7.144.2

package/dist/memory/config.d.ts

@@ -19,6 +19,12 @@ export interface MemoryConfig {
             tokenBudget: number;
         };
     };
+    reflection: {
+        /** Generate/inject deterministic outcome lessons automatically. */
+        enabled: boolean;
+        /** Exponential decay half-life for signed outcomes. */
+        halfLifeDays: number;
+    };
     learning: MemoryLearningConfig;
     writes: {
         mode: 'propose';

package/dist/memory/consolidation.d.ts

@@ -28,6 +28,8 @@ export interface ConsolidationDeps {
     logEvent: (event: MemoryRunLogEvent) => Promise<void>;
     readLog: () => Promise<ConsolidationLogRecord[]>;
     appendLog: (record: ConsolidationLogRecord) => Promise<void>;
+    /** Worktree-local structural staleness. Optional for legacy/test callers. */
+    readDeadAnchorMemoryIds?: () => ReadonlySet<string>;
     signal?: AbortSignal;
 }
 export interface ConsolidationInput {

package/dist/memory/gateway.d.ts

@@ -1,12 +1,20 @@
 import { type MemoryConfig } from './config';
 import type { MemoryProposalStore, MemoryProvider, MemoryRecallUsageEvent, MemoryRecallUsageFilter } from './provider';
 import { type VettedMemoryRoot } from './storage-root';
-import type { AppliedMemoryChange, CuratorMemoryDecision, MemoryContext, MemoryKind, MemoryListFilter, MemoryProposal, MemoryRecord, MemoryScopeRef, MemorySource, RecallBundle, RecallMode } from './types';
+import type { AppliedMemoryChange, CuratorMemoryDecision, MemoryAnchor, MemoryContext, MemoryKind, MemoryListFilter, MemoryOutcome, MemoryProposal, MemoryRecord, MemoryScopeRef, MemorySource, RecallBundle, RecallMode } from './types';
 export interface MemoryGatewayOptions {
     config?: Partial<MemoryConfig>;
     provider?: MemoryProvider & Partial<MemoryProposalStore>;
     now?: () => Date;
 }
+export interface RecordMemoryOutcomeInput {
+    memoryId?: string;
+    question?: string;
+    outcome: MemoryOutcome['outcome'];
+    anchors?: MemoryAnchor[];
+    correction?: string;
+    eventId?: string;
+}
 export interface ProposeMemoryInput {
     operation: MemoryProposal['operation'];
     kind?: MemoryKind;
@@ -59,6 +67,7 @@ export declare class MemoryGateway {
     }): Promise<MemoryProposal[]>;
     listRecallUsage(filter?: MemoryRecallUsageFilter): Promise<MemoryRecallUsageEvent[]>;
     upsertCurated(record: MemoryRecord): Promise<MemoryRecord>;
+    recordOutcome(input: RecordMemoryOutcomeInput): Promise<MemoryRecord>;
     applyCuratorDecision(decision: CuratorMemoryDecision): Promise<AppliedMemoryChange>;
     createRecord(input: {
         kind: MemoryKind;
@@ -70,6 +79,8 @@ export declare class MemoryGateway {
         stability?: MemoryRecord['stability'];
         tags?: string[];
         metadata?: Record<string, unknown>;
+        anchors?: MemoryAnchor[];
+        outcomes?: MemoryOutcome[];
     }): MemoryRecord;
     private resolveCuratorDecision;
     private createRecordFromNew;

package/dist/memory/index.d.ts

@@ -2,20 +2,22 @@ export type { MemoryConfig } from './config';
 export { DEFAULT_MEMORY_CONFIG, resolveMemoryConfig } from './config';
 export { MemoryDisabledError, MemoryValidationError } from './errors';
 export { evaluateMemoryRecallFixtures, loadRecallEvaluationFixtures, type RecallEvaluationMetrics, type RecallEvaluationMode, type RecallEvaluationOptions, type RecallEvaluationProviderName, type RecallEvaluationReport, type RecallEvaluationRun, } from './evaluation';
-export type { MemoryGatewayOptions, ProposeMemoryInput, RecallMemoryInput, } from './gateway';
+export type { MemoryGatewayOptions, ProposeMemoryInput, RecallMemoryInput, RecordMemoryOutcomeInput, } from './gateway';
 export { createConfiguredMemoryProvider, createConfiguredMemoryProviderForRoot, createMemoryGateway, MemoryGateway, } from './gateway';
 export { createMemoryLifecycleHooks, type MemoryLifecycleHookOptions, type MemoryLifecycleHooks, } from './injector';
-export { backupLegacyJsonl, getLegacyJsonlFileStatus, type JsonlBackupResult, type JsonlImportPayload, type JsonlInvalidRow, type JsonlMigrationReport, LEGACY_JSONL_MIGRATION_NAME, LEGACY_JSONL_MIGRATION_VERSION, readLegacyJsonl, readMigrationReport, resolveMemoryStorageDir, resolveSqliteDatabasePath, writeJsonlExport, writeMigrationReport, } from './jsonl-migration';
+export { backupLegacyJsonl, getLegacyJsonlFileStatus, getLegacyOutcomeJsonlSignature, type JsonlBackupResult, type JsonlImportPayload, type JsonlInvalidRow, type JsonlMigrationReport, LEGACY_JSONL_MIGRATION_NAME, LEGACY_JSONL_MIGRATION_VERSION, LEGACY_JSONL_OUTCOME_META_KEY, readLegacyJsonl, readMigrationReport, resolveMemoryStorageDir, resolveSqliteDatabasePath, writeJsonlExport, writeMigrationReport, } from './jsonl-migration';
 export { LocalJsonlMemoryProvider } from './local-jsonl-provider';
 export { buildMemoryMaintenanceReport, type MemoryMaintenanceReport, type MemoryMaintenanceReportOptions, type MemoryRecallUsageByMemory, type MemoryRecallUsageByRole, type MemorySupersededChain, shouldCompactMemory, } from './maintenance';
 export { invalidateMemoryStoreDirCache, isMemoryLinked, MEMORY_LINK_POINTER_FILENAME, type MemoryLinkPointer, readMemoryLinkPointer, removeMemoryLinkPointer, resolveMemoryStoreDir, writeMemoryLinkPointer, } from './memory-link';
+export type { MemoryOutcomeEvent } from './outcome-events';
 export { buildRecallPromptBlock } from './prompt-block';
 export type { MemoryCompactOptions, MemoryCompactResult, MemoryProposalStore, MemoryProvider, MemoryRecallUsageEvent, MemoryRecallUsageFilter, } from './provider';
 export { buildMemoryRecallPlan, type MemoryRecallPlan, type MemoryRecallPlannerInput, } from './recall-planner';
 export { buildMemoryCohortFingerprintInput, computeMemoryCohortFingerprint, computeRedactionPolicyVersion, FINGERPRINT_ALGORITHM_VERSION, findSecrets, redactSecrets, } from './redaction';
+export { readDeadAnchorMemoryIds, readReflectionDigest, recordOutcomeWithReflection, regenerateMemoryReflection, } from './reflection-service';
 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';
+export { computeMemoryContentHash, createBundleId, createMemoryId, createProposalId, isExpired, MemoryAnchorSchema, normalizeMemoryAnchorFile, normalizeMemoryText, validateCuratorMemoryDecision, validateMemoryProposal, validateMemoryRecordRules, } from './schema';
 export { SQLiteMemoryProvider } from './sqlite-provider';
 export { isCohortRoot, isLocalRoot, resolveVettedMemoryRoot, rootStoragePath, type VettedMemoryRoot, wrapLocalRoot, } from './storage-root';
-export type { AppliedMemoryChange, CuratorMemoryDecision, MemoryContext, MemoryKind, MemoryListFilter, MemoryPatch, MemoryProposal, MemoryRecord, MemoryScopeRef, MemoryScopeType, NewMemoryRecord, RecallBundle, RecallInjectionSkipReason, RecallMode, RecallRequest, RecallResultItem, ResolvedCuratorMemoryDecision, } from './types';
+export type { AppliedMemoryChange, CuratorMemoryDecision, MemoryAnchor, MemoryContext, MemoryKind, MemoryListFilter, MemoryOutcome, MemoryPatch, MemoryProposal, MemoryRecord, MemoryScopeRef, MemoryScopeType, NewMemoryRecord, RecallBundle, RecallInjectionSkipReason, RecallMode, RecallRequest, RecallResultItem, ResolvedCuratorMemoryDecision, } from './types';

package/dist/memory/jsonl-migration.d.ts

@@ -1,15 +1,32 @@
 import { type MemoryConfig } from './config';
+import { type MemoryOutcomeEvent } from './outcome-events';
 import type { MemoryProposal, MemoryRecord } from './types';
 export declare const LEGACY_JSONL_MIGRATION_VERSION = 2;
 export declare const LEGACY_JSONL_MIGRATION_NAME = "legacy_jsonl_import_complete";
+/**
+ * Separate additive marker for outcome events. Existing databases may already
+ * carry the immutable v2 schema_migrations row, so outcome import cannot reuse
+ * that row or invent a future migration version (the migration runner is
+ * MAX(version)-based).
+ */
+export declare const LEGACY_JSONL_OUTCOME_META_KEY = "legacy_jsonl_outcomes_import_complete";
 export interface JsonlInvalidRow {
-    file: 'memories.jsonl' | 'proposals.jsonl';
+    file: 'memories.jsonl' | 'proposals.jsonl' | 'outcome-events.jsonl';
     line: number;
     error: string;
 }
 export interface JsonlImportPayload {
     memories: MemoryRecord[];
+    memoryRows: Array<{
+        line: number;
+        record: MemoryRecord;
+    }>;
     proposals: MemoryProposal[];
+    outcomeEvents: MemoryOutcomeEvent[];
+    outcomeEventRows: Array<{
+        line: number;
+        event: MemoryOutcomeEvent;
+    }>;
     invalidRows: JsonlInvalidRow[];
     totalRows: number;
 }
@@ -25,6 +42,7 @@ export interface JsonlMigrationReport {
     reason?: string;
     importedMemories: number;
     importedProposals: number;
+    importedOutcomes: number;
     invalidRows: JsonlInvalidRow[];
     backups: JsonlBackupResult[];
 }
@@ -32,16 +50,23 @@ export declare function resolveMemoryStorageDir(rootDirectory: string, config?:
 export declare function resolveSqliteDatabasePath(rootDirectory: string, config?: Partial<MemoryConfig>): string;
 export declare function readLegacyJsonl(rootDirectory: string, config?: Partial<MemoryConfig>): Promise<JsonlImportPayload>;
 export declare function backupLegacyJsonl(rootDirectory: string, config?: Partial<MemoryConfig>): Promise<JsonlBackupResult[]>;
-export declare function writeJsonlExport(rootDirectory: string, config: Partial<MemoryConfig>, memories: MemoryRecord[], proposals: MemoryProposal[]): Promise<{
+export declare function writeJsonlExport(rootDirectory: string, config: Partial<MemoryConfig>, memories: MemoryRecord[], proposals: MemoryProposal[], outcomeEvents?: MemoryOutcomeEvent[]): Promise<{
     directory: string;
     memoriesPath: string;
     proposalsPath: string;
+    outcomesPath: string;
 }>;
 export declare function writeMigrationReport(rootDirectory: string, report: JsonlMigrationReport, config?: Partial<MemoryConfig>): Promise<string>;
 export declare function readMigrationReport(rootDirectory: string, config?: Partial<MemoryConfig>): Promise<JsonlMigrationReport | null>;
 export declare function getLegacyJsonlFileStatus(rootDirectory: string, config?: Partial<MemoryConfig>): Promise<Array<{
-    file: 'memories.jsonl' | 'proposals.jsonl';
+    file: 'memories.jsonl' | 'proposals.jsonl' | 'outcome-events.jsonl';
     path: string;
     exists: boolean;
     sizeBytes: number;
 }>>;
+/**
+ * Cheap change token for the append-only outcome stream. Unlike the legacy v2
+ * one-shot marker, this advances when a user switches back to JSONL, records
+ * more outcomes, and later reopens SQLite.
+ */
+export declare function getLegacyOutcomeJsonlSignature(rootDirectory: string, config?: Partial<MemoryConfig>): Promise<string>;

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

@@ -1,7 +1,8 @@
 import { type MemoryConfig } from './config';
+import { type MemoryOutcomeEvent } from './outcome-events';
 import type { MemoryCompactOptions, MemoryCompactResult, MemoryProposalStore, MemoryProvider, MemoryRecallUsageEvent, MemoryRecallUsageFilter, MemoryRewardEvent, MemoryRewardEventFilter } from './provider';
 import type { RecallScoringDiagnostics } from './scoring';
-import type { AppliedMemoryChange, MemoryListFilter, MemoryProposal, MemoryRecord, RecallRequest, RecallResultItem, ResolvedCuratorMemoryDecision } from './types';
+import type { AppliedMemoryChange, MemoryAnchor, MemoryListFilter, MemoryOutcome, MemoryProposal, MemoryRecord, RecallRequest, RecallResultItem, ResolvedCuratorMemoryDecision } from './types';
 export declare class LocalJsonlMemoryProvider implements MemoryProvider, MemoryProposalStore {
     readonly name = "local-jsonl";
     private readonly rootDirectory;
@@ -25,6 +26,11 @@ export declare class LocalJsonlMemoryProvider implements MemoryProvider, MemoryP
     initialize(): Promise<void>;
     upsert(record: MemoryRecord): Promise<MemoryRecord>;
     get(id: string): Promise<MemoryRecord | null>;
+    appendOutcome(memoryId: string, event: {
+        id: string;
+        outcome: MemoryOutcome;
+    }, anchors?: MemoryAnchor[]): Promise<MemoryRecord>;
+    listOutcomeEvents(): Promise<MemoryOutcomeEvent[]>;
     delete(id: string, reason?: string): Promise<void>;
     recall(request: RecallRequest): Promise<RecallResultItem[]>;
     recallWithDiagnostics(request: RecallRequest): Promise<{
@@ -42,9 +48,18 @@ export declare class LocalJsonlMemoryProvider implements MemoryProvider, MemoryP
         limit?: number;
     }): Promise<MemoryProposal[]>;
     applyCuratorDecision(decision: ResolvedCuratorMemoryDecision): Promise<AppliedMemoryChange>;
+    private applyCuratorDecisionUnlocked;
     compact(): Promise<void>;
     compactMaintenance(options?: MemoryCompactOptions): Promise<MemoryCompactResult>;
     private audit;
+    private withOutcomeStoreLock;
+    private refreshMemoriesUnlocked;
+    private appendMemoryUnlocked;
+    private refreshProposalsUnlocked;
+    private readOutcomeEventsSync;
+    private appendOutcomeEventUnlocked;
+    private rewriteMemoryFamilyUnlocked;
+    private validateMaterializedRecordUnlocked;
     /**
      * #1850 (critic CONCERN-1): bump the cohort generation marker so sibling
      * worktrees observe this write on their next revalidation. Called at the

package/dist/memory/maintenance.d.ts

@@ -41,6 +41,9 @@ export interface MemoryMaintenanceReport {
     supersededMemories: MemoryRecord[];
     supersededChains: MemorySupersededChain[];
     lowUtilityMemories: MemoryRecord[];
+    /** Structurally stale memories whose anchors are all dead in the latest
+     * worktree-local reflection digest. Reporting never deletes them. */
+    deadAnchorMemories: MemoryRecord[];
     /**
      * Memories suppressed for low LEARNED utility (q-value < suppression
      * threshold). Distinct from `lowUtilityMemories`, which is the orthogonal
@@ -71,6 +74,8 @@ export interface MemoryMaintenanceReportOptions {
     importanceThreshold?: number;
     /** Learned-utility (q-value) thresholds for the low-Q / promotion surfaces. Defaults to DEFAULT_QLEARNING_CONFIG. */
     qLearning?: QLearningConfig;
+    /** Worktree-local stale ids read from `.swarm/reflections/lessons.json`. */
+    deadAnchorMemoryIds?: ReadonlySet<string>;
 }
 type ObservableProvider = MemoryProvider & Partial<MemoryProposalStore> & {
     listRecallUsage?: MemoryProvider['listRecallUsage'];

package/dist/memory/memory-family-migration.d.ts

@@ -25,6 +25,7 @@
  * No writes happen here on the plugin-init path (invariant 1). Called only
  * from the `/swarm memory link` / `/swarm memory unlink` command handlers.
  */
+import { type MemoryOutcomeEvent } from './outcome-events.js';
 import type { VettedMemoryRoot } from './storage-root.js';
 export interface MemoryFamilyMigrationCounts {
     readonly perMember: ReadonlyArray<{
@@ -39,6 +40,16 @@ declare function appendUnionById<T>(destination: T[], source: T[]): {
     added: number;
     skipped: number;
 };
+/**
+ * Outcome event ids are retry identities, not generic append-only row ids.
+ * Apply the provider's shared semantic collision rules while retaining the
+ * destination's first committed representation (including its timestamp).
+ */
+declare function appendUnionOutcomeEvents(destination: unknown[], source: unknown[]): {
+    merged: MemoryOutcomeEvent[];
+    added: number;
+    skipped: number;
+};
 /** Serialize a merged JSONL member. */
 declare function serializeJsonl(values: unknown[]): string;
 /** Validate a serialized JSONL member: every line must parse and carry an id. */
@@ -85,6 +96,7 @@ declare function countRowsSafe(dbPath: string): Promise<number>;
 export declare function migrateMemoryFamily(destRoot: VettedMemoryRoot, sourceRoot: VettedMemoryRoot): Promise<MemoryFamilyMigrationCounts>;
 export declare const _internals: {
     appendUnionById: typeof appendUnionById;
+    appendUnionOutcomeEvents: typeof appendUnionOutcomeEvents;
     serializeJsonl: typeof serializeJsonl;
     validateSerializedJsonl: typeof validateSerializedJsonl;
     stageSqliteDb: typeof stageSqliteDb;

package/dist/memory/outcome-events.d.ts

@@ -0,0 +1,24 @@
+import type { MemoryAnchor, MemoryOutcome, MemoryRecord } from './types';
+export interface MemoryOutcomeEvent {
+    id: string;
+    memoryId: string;
+    generation: string;
+    outcome: MemoryOutcome;
+    anchors: MemoryAnchor[];
+}
+export declare function newOutcomeGeneration(): string;
+export declare function ensureOutcomeGeneration(record: MemoryRecord): MemoryRecord;
+export declare function outcomeGeneration(record: MemoryRecord): string;
+export declare function stripMaterializedOutcomes(record: MemoryRecord): MemoryRecord;
+export declare function materializeOutcomeRecord(base: MemoryRecord, events: readonly MemoryOutcomeEvent[]): MemoryRecord;
+export declare function importMaterializedOutcomeEvents(record: MemoryRecord, existing: readonly MemoryOutcomeEvent[]): MemoryOutcomeEvent[];
+export declare function validateOutcomeEvent(value: unknown): MemoryOutcomeEvent;
+/**
+ * Apply record-sensitive policy before an outcome event reaches either
+ * provider's canonical store. Shape validation alone cannot determine whether
+ * correction text belongs to a durable record.
+ */
+export declare function validateOutcomeEventForMemory(value: unknown, memory: MemoryRecord, rejectDurableSecrets: boolean): MemoryOutcomeEvent;
+export declare function assertEventIdentityCompatible(existing: MemoryOutcomeEvent | undefined, next: MemoryOutcomeEvent): void;
+export declare function canonicalOutcomePayload(outcome: MemoryOutcome, anchors: readonly MemoryAnchor[]): string;
+export declare function dedupeAnchors(anchors: readonly MemoryAnchor[]): MemoryAnchor[];

package/dist/memory/provider.d.ts

@@ -1,5 +1,6 @@
+import type { MemoryOutcomeEvent } from './outcome-events';
 import type { RecallScoringDiagnostics } from './scoring';
-import type { AppliedMemoryChange, MemoryListFilter, MemoryProposal, MemoryRecord, RecallRequest, RecallResultItem, ResolvedCuratorMemoryDecision } from './types';
+import type { AppliedMemoryChange, MemoryAnchor, MemoryListFilter, MemoryOutcome, MemoryProposal, MemoryRecord, RecallRequest, RecallResultItem, ResolvedCuratorMemoryDecision } from './types';
 export interface MemoryRecallResult {
     items: RecallResultItem[];
     diagnostics?: RecallScoringDiagnostics;
@@ -73,6 +74,11 @@ export interface MemoryProvider {
     initialize?(): Promise<void>;
     close?(): Promise<void> | void;
     upsert(record: MemoryRecord): Promise<MemoryRecord>;
+    appendOutcome?(memoryId: string, event: {
+        id: string;
+        outcome: MemoryOutcome;
+    }, anchors?: MemoryAnchor[]): Promise<MemoryRecord>;
+    listOutcomeEvents?(): Promise<MemoryOutcomeEvent[]>;
     get(id: string): Promise<MemoryRecord | null>;
     delete(id: string, reason?: string): Promise<void>;
     recall(request: RecallRequest): Promise<RecallResultItem[]>;

package/dist/memory/reflection-injection.d.ts

@@ -0,0 +1 @@
+export declare function buildReflectionInjection(directory: string, estimateTokens: (text: string) => number): string | null;

package/dist/memory/reflection-service.d.ts

@@ -0,0 +1,68 @@
+import { type MemoryConfig } from './config';
+import { type MemoryGateway, type RecordMemoryOutcomeInput } from './gateway';
+import { type ReflectionDigest } from './reflection';
+import type { MemoryOutcome, MemoryRecord } from './types';
+interface OutcomeWriteThroughBase {
+    record: MemoryRecord;
+    eventId: string;
+    outcomeRecorded: true;
+    reflectionEnabled: boolean;
+    reflectionAttempted: boolean;
+}
+export type OutcomeWriteThroughResult = (OutcomeWriteThroughBase & {
+    reflectionEnabled: false;
+    reflectionAttempted: false;
+    reflectionUpdated: false;
+}) | (OutcomeWriteThroughBase & {
+    reflectionEnabled: true;
+    reflectionAttempted: true;
+    reflectionUpdated: true;
+    digest: ReflectionDigest;
+}) | (OutcomeWriteThroughBase & {
+    reflectionEnabled: true;
+    reflectionAttempted: true;
+    reflectionUpdated: false;
+    error: string;
+});
+export declare function recordOutcomeWithReflection(directory: string, config: Partial<MemoryConfig>, gateway: MemoryGateway, input: RecordMemoryOutcomeInput): Promise<OutcomeWriteThroughResult>;
+export declare function regenerateMemoryReflection(directory: string, config: Partial<MemoryConfig>): Promise<ReflectionDigest>;
+export declare function readReflectionDigest(directory: string): ReflectionDigest | null;
+export declare function readDeadAnchorMemoryIds(directory: string): ReadonlySet<string>;
+/**
+ * Providers have historically returned bounded results in different orders.
+ * Re-sort centrally with an id tie-break, and reserve one slot for a
+ * just-committed target that is older than the normal window.
+ */
+declare function selectReflectionEntries(storedEntries: readonly MemoryRecord[], writeThroughRecord?: MemoryRecord, asOf?: Date, allowInactiveWriteThrough?: boolean): MemoryRecord[];
+declare function prepareWriteThroughEntry(writeThrough: {
+    record: MemoryRecord;
+    eventId: string;
+    outcome: MemoryOutcome['outcome'];
+}, asOf: Date): {
+    record: MemoryRecord;
+    allowInactive: boolean;
+} | undefined;
+declare function isReflectionEligible(record: MemoryRecord, asOf: Date): boolean;
+declare function sanitizeReflectionRecord(record: MemoryRecord): MemoryRecord;
+export declare const _test_exports: {
+    selectReflectionEntries: typeof selectReflectionEntries;
+    isReflectionEligible: typeof isReflectionEligible;
+    prepareWriteThroughEntry: typeof prepareWriteThroughEntry;
+    sanitizeReflectionRecord: typeof sanitizeReflectionRecord;
+};
+export declare const _internals: {
+    withReflectionLock: typeof withReflectionLock;
+    serializeDigestArtifacts: typeof serializeDigestArtifacts;
+    boundDigest: typeof boundDigest;
+};
+declare function withReflectionLock<T>(directory: string, fn: () => Promise<T>): Promise<T>;
+interface ReflectionArtifactPair {
+    markdown: string;
+    json: string;
+}
+declare function serializeDigestArtifacts(digest: ReflectionDigest): ReflectionArtifactPair;
+declare function boundDigest(digest: ReflectionDigest): {
+    digest: ReflectionDigest;
+    artifacts: ReflectionArtifactPair;
+};
+export {};

package/dist/memory/reflection.d.ts

@@ -0,0 +1,41 @@
+import type { MemoryAnchor, MemoryOutcome, MemoryRecord } from './types';
+export interface ReflectionAnchorStatus {
+    alive: boolean;
+    packageBoundary?: string;
+}
+export interface ReflectionDigestItem {
+    memoryId: string;
+    text: string;
+    anchor?: MemoryAnchor;
+    group?: string;
+    score: number;
+    positiveOutcomes: number;
+    negativeOutcomes: number;
+    latestAt: string;
+    resolution?: MemoryOutcome['outcome'];
+}
+export interface ReflectionCorrection {
+    memoryId: string;
+    correction: string;
+    at: string;
+    anchor?: MemoryAnchor;
+    group?: string;
+}
+export interface ReflectionDigest {
+    preferred: ReflectionDigestItem[];
+    tentative: ReflectionDigestItem[];
+    contested: ReflectionDigestItem[];
+    deadEnds: ReflectionDigestItem[];
+    corrections: ReflectionCorrection[];
+    deadAnchorMemoryIds: string[];
+    generatedFrom: {
+        entries: number;
+        asOf: string;
+    };
+}
+export interface BuildReflectionOptions {
+    halfLifeDays?: number;
+    resolveAnchor?: (anchor: MemoryAnchor) => ReflectionAnchorStatus;
+}
+export declare function buildReflectionDigest(entries: readonly MemoryRecord[], now: Date, opts?: BuildReflectionOptions): ReflectionDigest;
+export declare function renderReflectionMarkdown(digest: ReflectionDigest): string;

package/dist/memory/schema.d.ts

@@ -1,5 +1,9 @@
 import { z } from 'zod';
-import type { CuratorMemoryDecision, MemoryKind, MemoryPatch, MemoryProposal, MemoryRecord, MemoryScopeRef, NewMemoryRecord } from './types';
+import type { CuratorMemoryDecision, MemoryAnchor, MemoryKind, MemoryOutcome, MemoryPatch, MemoryProposal, MemoryRecord, MemoryScopeRef, NewMemoryRecord } from './types';
+export declare const MAX_MEMORY_TEXT_LENGTH = 2000;
+export declare const MAX_MEMORY_ANCHORS = 20;
+export declare const MEMORY_OUTCOME_QUESTION_PREFIX = "Outcome evidence for question: ";
+export declare const MAX_OUTCOME_QUESTION_LENGTH: number;
 export declare const MemoryScopeTypeSchema: z.ZodEnum<{
     agent: "agent";
     project: "project";
@@ -60,6 +64,10 @@ export declare const MemorySourceSchema: z.ZodObject<{
     commitSha: z.ZodOptional<z.ZodString>;
     createdBy: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
+export declare const MemoryAnchorSchema: z.ZodType<MemoryAnchor>;
+/** Normalize a repository-relative memory anchor to a portable identity. */
+export declare function normalizeMemoryAnchorFile(value: string): string;
+export declare const MemoryOutcomeSchema: z.ZodType<MemoryOutcome>;
 export declare const MemoryRecordSchema: z.ZodObject<{
     id: z.ZodString;
     scope: z.ZodObject<{
@@ -130,6 +138,8 @@ export declare const MemoryRecordSchema: z.ZodObject<{
     supersededBy: z.ZodOptional<z.ZodString>;
     contentHash: z.ZodString;
     metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    anchors: z.ZodOptional<z.ZodArray<z.ZodType<MemoryAnchor, unknown, z.core.$ZodTypeInternals<MemoryAnchor, unknown>>>>;
+    outcomes: z.ZodOptional<z.ZodArray<z.ZodType<MemoryOutcome, unknown, z.core.$ZodTypeInternals<MemoryOutcome, unknown>>>>;
     cohortId: z.ZodOptional<z.ZodString>;
     producerSessionId: z.ZodOptional<z.ZodString>;
     producerAgentRole: z.ZodOptional<z.ZodString>;
@@ -218,6 +228,8 @@ export declare const MemoryProposalSchema: z.ZodObject<{
         supersededBy: z.ZodOptional<z.ZodString>;
         contentHash: z.ZodString;
         metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        anchors: z.ZodOptional<z.ZodArray<z.ZodType<MemoryAnchor, unknown, z.core.$ZodTypeInternals<MemoryAnchor, unknown>>>>;
+        outcomes: z.ZodOptional<z.ZodArray<z.ZodType<MemoryOutcome, unknown, z.core.$ZodTypeInternals<MemoryOutcome, unknown>>>>;
         cohortId: z.ZodOptional<z.ZodString>;
         producerSessionId: z.ZodOptional<z.ZodString>;
         producerAgentRole: z.ZodOptional<z.ZodString>;

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

@@ -1,8 +1,9 @@
 import { type MemoryConfig } from './config';
 import { type JsonlMigrationReport } from './jsonl-migration';
+import { type MemoryOutcomeEvent } from './outcome-events';
 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';
+import type { AppliedMemoryChange, MemoryAnchor, MemoryListFilter, MemoryOutcome, MemoryProposal, MemoryRecord, RecallRequest, RecallResultItem, ResolvedCuratorMemoryDecision } from './types';
 interface Migration {
     version: number;
     name: string;
@@ -12,6 +13,7 @@ export declare const MIGRATIONS: Migration[];
 export interface SQLiteJsonlImportResult {
     importedMemories: number;
     importedProposals: number;
+    importedOutcomes: number;
     invalidRows: JsonlMigrationReport['invalidRows'];
     totalRows: number;
 }
@@ -63,6 +65,11 @@ export declare class SQLiteMemoryProvider implements MemoryProvider, MemoryPropo
     private doInitialize;
     upsert(record: MemoryRecord): Promise<MemoryRecord>;
     get(id: string): Promise<MemoryRecord | null>;
+    appendOutcome(memoryId: string, event: {
+        id: string;
+        outcome: MemoryOutcome;
+    }, anchors?: MemoryAnchor[]): Promise<MemoryRecord>;
+    listOutcomeEvents(): Promise<MemoryOutcomeEvent[]>;
     withTransaction<T>(fn: (tx: MemoryTransaction) => Promise<T> | T): Promise<T>;
     delete(id: string, reason?: string): Promise<void>;
     recall(request: RecallRequest): Promise<RecallResultItem[]>;
@@ -114,8 +121,10 @@ export declare class SQLiteMemoryProvider implements MemoryProvider, MemoryPropo
         directory: string;
         memoriesPath: string;
         proposalsPath: string;
+        outcomesPath: string;
         memories: number;
         proposals: number;
+        outcomes: number;
     }>;
     compactMaintenance(options?: MemoryCompactOptions): Promise<MemoryCompactResult>;
     hasMigration(name: string): boolean;
@@ -136,6 +145,10 @@ export declare class SQLiteMemoryProvider implements MemoryProvider, MemoryPropo
     private loadMemories;
     private loadProposals;
     private writeMemory;
+    private readMemoryById;
+    private readOutcomeEvents;
+    private readOutcomeEventsForMemoryIds;
+    private insertOutcomeEvent;
     /**
      * #1850: write a monotonic generation marker so siblings re-open their
      * in-memory mirror. Fire-and-forget; failures are non-fatal (peers simply
@@ -166,6 +179,10 @@ export declare class SQLiteMemoryProvider implements MemoryProvider, MemoryPropo
     private validateDecisionMemory;
     private migrateLegacyJsonlIfNeeded;
     private importLegacyJsonlRows;
+    private importLegacyMaterializedOutcomeRow;
+    private importLegacyOutcomeRows;
+    private importLegacyOutcomeEventRows;
+    private hasOutcomeEvent;
     private event;
     private insertEvent;
     private requireDb;

package/dist/memory/types.d.ts

@@ -22,6 +22,18 @@ export interface MemorySource {
     commitSha?: string;
     createdBy?: string;
 }
+/** Repository-relative structural location associated with a memory result. */
+export interface MemoryAnchor {
+    file: string;
+    symbol?: string;
+}
+/** A task-observed result for a recalled memory or graph answer. */
+export interface MemoryOutcome {
+    outcome: 'useful' | 'dead_end' | 'corrected';
+    at: string;
+    taskId?: string;
+    correction?: string;
+}
 export interface MemoryRecord {
     id: string;
     scope: MemoryScopeRef;
@@ -39,6 +51,10 @@ export interface MemoryRecord {
     supersededBy?: string;
     contentHash: string;
     metadata: Record<string, unknown>;
+    /** Optional code-structure anchors; additive for pre-#1989 stores. */
+    anchors?: MemoryAnchor[];
+    /** Append-only materialized outcome view; provider events remain canonical. */
+    outcomes?: MemoryOutcome[];
     /** Canonical cohort id the record belongs to. Matches `scope.cohortId`
      * when `scope.type === 'cohort'`. */
     cohortId?: string;
@@ -85,8 +101,10 @@ export interface NewMemoryRecord {
     source?: MemorySource;
     expiresAt?: string;
     metadata?: Record<string, unknown>;
+    anchors?: MemoryAnchor[];
+    outcomes?: MemoryOutcome[];
 }
-export type MemoryPatch = Partial<Pick<NewMemoryRecord, 'scope' | 'kind' | 'text' | 'tags' | 'confidence' | 'stability' | 'source' | 'expiresAt' | 'metadata'>>;
+export type MemoryPatch = Partial<Pick<NewMemoryRecord, 'scope' | 'kind' | 'text' | 'tags' | 'confidence' | 'stability' | 'source' | 'expiresAt' | 'metadata' | 'anchors' | 'outcomes'>>;
 export type CuratorMemoryDecision = {
     action: 'add';
     proposalId: string;