opencode-swarm 7.161.1 → 7.162.1

package/dist/memory/curator-decision-helpers.d.ts

@@ -8,6 +8,7 @@ export declare function markProposalReviewed(proposal: MemoryProposal, decision:
     targetMemoryId?: string;
     oldMemoryId?: string;
     replacementMemoryId?: string;
+    relatedMemoryIds?: string[];
 }): MemoryProposal;
 export declare function curatorDecisionReason(decision: ResolvedCuratorMemoryDecision): string | undefined;
 export declare function buildCuratorDecisionEvent(change: AppliedMemoryChange, proposal: MemoryProposal): AppliedMemoryChange & {

package/dist/memory/index.d.ts

@@ -21,4 +21,4 @@ export { appendMemoryRunLog, sanitizeRunId } from './run-log';
 export { computeMemoryContentHash, createBundleId, createMemoryId, createProposalId, isExpired, MemoryAnchorSchema, normalizeMemoryAnchorFile, normalizeMemoryText, validateCuratorMemoryDecision, validateMemoryProposal, validateMemoryRecordRules, } from './schema';
 export { EVENT_CHAIN_GENESIS, MEMORY_EVENTS_CHAIN_HEAD_KEY, type MemoryAuditVerificationReport, type MemoryEventRow, memoryEventRowHash, SQLiteMemoryProvider, verifyMemoryEventChainRows, } from './sqlite-provider';
 export { isCohortRoot, isLocalRoot, resolveVettedMemoryRoot, rootStoragePath, type VettedMemoryRoot, wrapLocalRoot, } from './storage-root';
-export type { AppliedMemoryChange, CuratorMemoryDecision, MemoryAnchor, MemoryContext, MemoryKind, MemoryListFilter, MemoryOutcome, 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, MemoryRelation, MemoryScopeRef, MemoryScopeType, NewMemoryRecord, RecallBundle, RecallInjectionSkipReason, RecallMode, RecallRequest, RecallResultItem, ResolvedCuratorMemoryDecision, } from './types';

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

@@ -16,6 +16,7 @@ export declare class LocalJsonlMemoryProvider implements MemoryProvider, MemoryP
     private initialized;
     private memories;
     private proposals;
+    private lastInvalidProposalLoadSignature;
     constructor(rootDirectory: string, config?: Partial<MemoryConfig>, vettedCohortRoot?: string | null);
     /**
      * #1850 (critic GAP-5): explicit cohort-root path branch.
@@ -56,6 +57,7 @@ export declare class LocalJsonlMemoryProvider implements MemoryProvider, MemoryP
     private refreshMemoriesUnlocked;
     private appendMemoryUnlocked;
     private refreshProposalsUnlocked;
+    private reportInvalidProposalLoad;
     private readOutcomeEventsSync;
     private appendOutcomeEventUnlocked;
     private rewriteMemoryFamilyUnlocked;

package/dist/memory/proposal-load.d.ts

@@ -0,0 +1,15 @@
+import { MemoryValidationError } from './errors';
+import type { MemoryProposal } from './types';
+export interface ProposalLoadIssue {
+    proposalId: string;
+    reason: string;
+}
+export declare const INVALID_PROPOSAL_LOAD_SAMPLE_LIMIT = 5;
+export declare function parseLoadedProposal(value: unknown, rejectDurableSecrets: boolean): MemoryProposal;
+export declare function proposalLoadIssueFromValue(value: unknown, error: unknown): ProposalLoadIssue;
+export declare function proposalLoadIssueFromId(proposalId: string, error: unknown): ProposalLoadIssue;
+export declare function buildProposalLoadDiagnostics(issues: readonly ProposalLoadIssue[]): {
+    invalidCount: number;
+    samples: ProposalLoadIssue[];
+};
+export declare function asStoredProposalValidationError(proposalId: string, error: unknown): MemoryValidationError;

package/dist/memory/relation-constants.d.ts

@@ -0,0 +1,3 @@
+export declare const MAX_MERGE_PARTICIPANTS = 8;
+export declare const MAX_RELATIONS_PER_MEMORY = 32;
+export declare const RELATED_RECALL_FANOUT = 2;

package/dist/memory/relations.d.ts

@@ -0,0 +1,8 @@
+export { MAX_MERGE_PARTICIPANTS, MAX_RELATIONS_PER_MEMORY, RELATED_RECALL_FANOUT, } from './relation-constants';
+import type { MemoryProposal, MemoryRecord, MemoryRelation, RecallRequest, RecallResultItem } from './types';
+export declare function canonicalMemoryIds(ids: readonly string[]): string[];
+export declare function buildMemoryRelationIndex(proposals: Iterable<MemoryProposal>): Map<string, MemoryRelation[]>;
+export declare function projectMemoryRelations(records: readonly MemoryRecord[], proposals: Iterable<MemoryProposal>): MemoryRecord[];
+export declare function stripDerivedRelations(record: MemoryRecord): MemoryRecord;
+export declare function validateMergeParticipants(ids: readonly string[], records: Iterable<MemoryRecord>, proposals: Iterable<MemoryProposal>, now?: Date): string[];
+export declare function expandRelatedRecallItems(items: readonly RecallResultItem[], allRecords: readonly MemoryRecord[], request: RecallRequest): RecallResultItem[];

package/dist/memory/schema.d.ts

@@ -134,6 +134,10 @@ export declare const MemoryRecordSchema: z.ZodObject<{
     updatedAt: z.ZodString;
     lastAccessedAt: z.ZodOptional<z.ZodString>;
     expiresAt: z.ZodOptional<z.ZodString>;
+    relations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        memoryId: z.ZodString;
+        type: z.ZodLiteral<"merged_with">;
+    }, z.core.$strict>>>;
     qValue: z.ZodOptional<z.ZodNumber>;
     supersedes: z.ZodOptional<z.ZodArray<z.ZodString>>;
     supersededBy: z.ZodOptional<z.ZodString>;
@@ -228,6 +232,10 @@ export declare const MemoryProposalSchema: z.ZodObject<{
         updatedAt: z.ZodString;
         lastAccessedAt: z.ZodOptional<z.ZodString>;
         expiresAt: z.ZodOptional<z.ZodString>;
+        relations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            memoryId: z.ZodString;
+            type: z.ZodLiteral<"merged_with">;
+        }, z.core.$strict>>>;
         qValue: z.ZodOptional<z.ZodNumber>;
         supersedes: z.ZodOptional<z.ZodArray<z.ZodString>>;
         supersededBy: z.ZodOptional<z.ZodString>;

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

@@ -123,6 +123,7 @@ export declare class SQLiteMemoryProvider implements MemoryProvider, MemoryPropo
         items: RecallResultItem[];
         diagnostics: RecallScoringDiagnostics;
     }>;
+    private expandRelated;
     recordRecallUsage(event: MemoryRecallUsageEvent): Promise<void>;
     listRecallUsage(filter?: MemoryRecallUsageFilter): Promise<MemoryRecallUsageEvent[]>;
     appendRewardEvent(event: Omit<MemoryRewardEvent, 'id'>): Promise<void>;
@@ -231,6 +232,8 @@ export declare class SQLiteMemoryProvider implements MemoryProvider, MemoryPropo
     private parseMemoryRow;
     private loadMemories;
     private loadProposals;
+    private refreshProposalsFromStorage;
+    private projectRelationsFromStorage;
     private writeMemory;
     /** Raw row (WITH provenance columns) for a single memory item. */
     private readMemoryItemRowById;

package/dist/memory/types.d.ts

@@ -34,6 +34,10 @@ export interface MemoryOutcome {
     taskId?: string;
     correction?: string;
 }
+export interface MemoryRelation {
+    memoryId: string;
+    type: 'merged_with';
+}
 export interface MemoryRecord {
     id: string;
     scope: MemoryScopeRef;
@@ -47,6 +51,8 @@ export interface MemoryRecord {
     updatedAt: string;
     lastAccessedAt?: string;
     expiresAt?: string;
+    /** Provider-derived from applied curator proposals; never user-writable. */
+    relations?: MemoryRelation[];
     supersedes?: string[];
     supersededBy?: string;
     contentHash: string;
@@ -130,6 +136,11 @@ export type CuratorMemoryDecision = {
     oldMemoryId: string;
     replacement: NewMemoryRecord;
     reason: string;
+} | {
+    action: 'merge';
+    proposalId: string;
+    relatedMemoryIds: string[];
+    reason: string;
 } | {
     action: 'reject';
     proposalId: string;
@@ -155,6 +166,11 @@ export type ResolvedCuratorMemoryDecision = {
     oldMemoryId: string;
     replacement: MemoryRecord;
     reason: string;
+} | {
+    action: 'merge';
+    proposalId: string;
+    relatedMemoryIds: string[];
+    reason: string;
 } | {
     action: 'reject';
     proposalId: string;
@@ -174,6 +190,7 @@ export interface AppliedMemoryChange {
     targetMemoryId?: string;
     oldMemoryId?: string;
     replacementMemoryId?: string;
+    relatedMemoryIds?: string[];
     reason?: string;
 }
 export type RecallMode = 'manual' | 'injection' | 'curator' | 'evaluation';
@@ -202,6 +219,10 @@ export interface RecallResultItem {
     record: MemoryRecord;
     score: number;
     reason: string;
+    relation?: {
+        type: MemoryRelation['type'];
+        sourceMemoryId: string;
+    };
     signals: {
         textOverlap: number;
         tagOverlap: number;

package/dist/{hooks/pr-review-reentry-authorization.d.ts → pr-review/authorization.d.ts}

@@ -1,21 +1,29 @@
-import { z } from 'zod';
 /**
- * Correlated one-use reviewer re-entry authorization (issue #2383).
+ * PR-review authorization boundary (issues #2383, #2385).
+ *
+ * Correlated one-use reviewer re-entry authorization, moved behind the
+ * `src/pr-review/` boundary (issue #2385). This module replaces prompt-text
+ * inspection (`MODE: PR_REVIEW`) as the ONLY way a direct Task dispatch of
+ * `reviewer`/`test_engineer` may bypass the generic Stage-A task-workflow
+ * requirement. The PR workflow controller issues an authorization bound to
+ * the exact active session, workflow, run, base/head SHA, worktree revision
+ * digest, role, and gate generation; the Task delegation gate consumes it
+ * atomically, exactly once. Stale, cross-session, wrong-role, replayed,
+ * expired, or revision-drifted requests fail closed to the normal gating
+ * path.
  *
- * Replaces prompt-text inspection (`MODE: PR_REVIEW`) as the ONLY way a
- * direct Task dispatch of `reviewer`/`test_engineer` may bypass the generic
- * Stage-A task-workflow requirement. The PR workflow controller issues an
- * authorization bound to the exact active session, workflow, run, base/head
- * SHA, worktree revision digest, role, and gate generation; the Task
- * delegation gate consumes it atomically, exactly once. Stale, cross-session,
- * wrong-role, replayed, expired, or revision-drifted requests fail closed to
- * the normal gating path.
+ * Binding verification: the CURRENT gate binding (head/revision/generation)
+ * is supplied by the owning gate through a bound reader
+ * (`bindPrReviewReentryBindingReader`) — the boundary must not import the
+ * orchestration gate back. The gate binds its
+ * `readPrReviewReentryBindingContext` at module init.
  *
  * Persistence: `.swarm/pr-review/reentry-authorizations/<session-stem>.json`,
  * guarded by a `proper-lockfile` lock (the same dependency the candidate
  * sidecar store uses). Bounded: at most MAX_ACTIVE_AUTHORIZATIONS unconsumed
  * authorizations per session; expired/unconsumed records are pruned on write.
  */
+import { z } from 'zod';
 export type PrReviewReentryRole = 'reviewer' | 'test_engineer';
 export interface PrReviewReentryAuthorizationRecord {
     schemaVersion: 1;
@@ -32,6 +40,20 @@ export interface PrReviewReentryAuthorizationRecord {
     consumedAt?: string;
     consumedCallId?: string;
 }
+/**
+ * The CURRENT active-workflow binding an authorization must match at issue
+ * AND at consume time. Supplied by the owning gate (which reads state through
+ * the persistence boundary) via `bindPrReviewReentryBindingReader`.
+ */
+export interface PrReviewReentryBindingContext {
+    prHeadSha: string;
+    revisionDigest: string;
+    generation: number;
+    workflowInstanceId?: string;
+    runId?: string;
+}
+export type PrReviewReentryBindingReader = (directory: string, sessionID: string) => Promise<PrReviewReentryBindingContext | null>;
+export declare function bindPrReviewReentryBindingReader(reader: PrReviewReentryBindingReader): void;
 declare const AuthorizationFileSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     sessionId: z.ZodString;

package/dist/{hooks/pr-review-resilience-circuit.d.ts → pr-review/circuit.d.ts}

@@ -1,5 +1,6 @@
 /**
- * PR-review resilience circuit — typed, recoverable, versioned (issue #2382).
+ * PR-review resilience circuit — typed, recoverable, versioned (issues
+ * #2382, #2385).
  *
  * Pure state machine + typed-signal classification for the PR_REVIEW
  * resilience circuit. No I/O: the owning gate (`pr-workflow-gate.ts`) reads
@@ -17,9 +18,17 @@
  *   waterline) or back to OPEN (new interval). Legacy unversioned records
  *   migrate once to a nonblocking v2 CLOSED record with an evidence waterline;
  *   malformed records fail open.
+ *
+ * Issue #2385 additionally makes this module the ONLY authority that may
+ * construct or transition circuit records: policy snapshot resolution, the
+ * re-enable reset, and the rolled-back-probe transition live here (previously
+ * inline record constructions in the gate). The parallel-rule guardrail
+ * (`src/pr-review/guardrails.ts`) enforces that no circuit record is built
+ * outside `src/pr-review/`.
  */
 import { z } from 'zod';
 import type { BackgroundDelegationRecord } from '../background/pending-delegations.js';
+import { type PrReviewResilienceConfig } from '../config/schema.js';
 /** Bounded contributor ledger. Mirrors `MAX_WORKFLOW_BATCHES (128) × 6` base dimensions. */
 export declare const PR_REVIEW_CIRCUIT_CONTRIBUTOR_LIMIT = 768;
 export type PrReviewCircuitIgnoredReason = 'observer_deadline' | 'client_unavailable' | 'parser' | 'validation' | 'policy' | 'filesystem' | 'git' | 'cancellation' | 'stale_observation' | 'unknown';
@@ -67,6 +76,20 @@ export interface PrReviewCircuitLegacyRecord {
     }>;
     openedAt: string;
 }
+/**
+ * The persisted circuit union: a v2 record or a legacy unversioned record
+ * awaiting migration.
+ */
+export type PrReviewCircuitRecord = PrReviewCircuitLegacyRecord | PrReviewCircuitRecordV2;
+export interface PrReviewResiliencePolicyRecord {
+    enabled: boolean;
+    canaryProbeMs: number;
+    statusProbeTimeoutMs: number;
+    correlatedFailureThreshold: number;
+    maxRetryAttemptsAfterInitial: number;
+    /** Issue #2382. Optional: policies persisted before the field existed parse unchanged. */
+    circuitOpenDurationMs?: number;
+}
 export declare const PrReviewCircuitLegacyRecordSchema: z.ZodObject<{
     signature: z.ZodString;
     count: z.ZodNumber;
@@ -130,6 +153,12 @@ export declare const PrReviewCircuitRecordSchema: z.ZodUnion<readonly [z.ZodObje
         admittedAt: z.ZodString;
     }, z.core.$strict>>;
 }, z.core.$strict>]>;
+/**
+ * The terminal delegation statuses the circuit consults. The single shared
+ * definition (issue #2385): the gate's settlement paths and this module read
+ * the same vocabulary.
+ */
+export declare const CIRCUIT_TERMINAL_DELEGATION_STATUSES: ReadonlySet<string>;
 /**
  * Derive the typed circuit signal from a durable delegation record's LATEST
  * terminal state. Returns `null` for anything that is not a terminal failure
@@ -190,7 +219,7 @@ export interface PrReviewCircuitAdvanceInput {
     admission?: {
         batchId: string;
         laneId: string;
-    };
+    } | undefined;
     /** Latest-record signals for every dispatch lane of the current workflow. */
     laneSignals: readonly PrReviewCircuitSignal[];
     /**
@@ -202,7 +231,7 @@ export interface PrReviewCircuitAdvanceInput {
         terminalStatus: string;
         signal: PrReviewCircuitSignal | null;
         terminalAtMs: number;
-    };
+    } | undefined;
 }
 export type PrReviewCircuitAdvanceResult = {
     action: 'admit';
@@ -230,3 +259,31 @@ export type PrReviewCircuitAdvanceResult = {
  * gate passes an explicit waterlined record for migration / re-enable births).
  */
 export declare function advancePrReviewCircuit(current: PrReviewCircuitRecordV2 | null, input: PrReviewCircuitAdvanceInput): PrReviewCircuitAdvanceResult;
+/**
+ * Resolve the effective resilience policy record from optional config. Every
+ * default comes from `DEFAULT_PR_REVIEW_RESILIENCE_CONFIG` (single source);
+ * a hardcoded literal here would drift from the config schema (issue #2385
+ * recurrence class G-2).
+ */
+export declare function resolvePrReviewResiliencePolicy(policy?: PrReviewResilienceConfig): PrReviewResiliencePolicyRecord;
+/**
+ * Issue #2382 re-enable semantics (issue #2385: moved behind the machine).
+ * Re-enabling resilience after a live disable starts from a fresh v2 CLOSED
+ * generation with an evidence waterline at `nowMs` — pre-disable evidence can
+ * never resurrect. Generation strictly increases.
+ */
+export declare function resetPrReviewResilienceForReEnable(args: {
+    previousCircuit?: PrReviewCircuitRecord | null;
+    policy: PrReviewResiliencePolicyRecord;
+    nowMs: number;
+}): PrReviewCircuitRecordV2;
+/**
+ * Issue #2382 review (PRR-002) rolled-back-probe transition (issue #2385:
+ * moved behind the machine). A rolled-back HALF_OPEN probe can never produce
+ * a terminal record — the rollback's own precondition is that the batch has
+ * zero delegation records — so leaving the probe in place would wedge the
+ * circuit on probe_in_flight forever. End the probe lifecycle exactly the way
+ * an ignored outcome does: state stays OPEN with a restarted recovery
+ * cooldown, and no contributor, generation, or waterline changes.
+ */
+export declare function rollbackPrReviewCircuitProbe(circuit: PrReviewCircuitRecordV2, nowMs: number, openDurationMs: number): PrReviewCircuitRecordV2;