opencode-swarm 7.200.13 → 7.200.14

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

@@ -63,14 +63,67 @@ export interface MemoryFamilyMigrationCounts {
         filename: string;
         merged: number;
         skipped: number;
+        /** Same-id rows replaced by a strictly newer version (#3520 PRR-002 truthfulness). */
+        superseded: number;
     }>;
+    /**
+     * #2958 tombstone / recency audit, one entry per member that had anything
+     * to report (members whose three fields are all empty are omitted). Every
+     * emitted entry carries all three fields.
+     */
+    readonly audit: ReadonlyArray<MemoryFamilyMemberAudit>;
 }
-/** Id-keyed union of two append-only JSONL arrays (idempotent on retry). */
-declare function appendUnionById<T>(destination: T[], source: T[]): {
+/** Per-member divergence audit (#2958). */
+export interface MemoryFamilyMemberAudit {
+    readonly filename: string;
+    /** Destination-deleted ids a newer live source row resurrected. */
+    readonly resurrectedIds: readonly string[];
+    /**
+     * Collisions resolved by recency OTHER THAN resurrections: source-newer
+     * wins (live or tombstone) plus destination-tombstone suppressions.
+     * Destination-newer keep-rows are not supersessions (nothing moved), and
+     * resurrections are reported solely via {@link resurrectedIds} so no
+     * event renders twice.
+     */
+    readonly supersededCount: number;
+    /** Collisions with no usable recency signal (destination kept, reported). */
+    readonly unresolvedCollisions: readonly string[];
+}
+/** Options for {@link appendUnionById}. */
+export interface AppendUnionByIdOptions {
+    /**
+     * Member filename — selects the member's recency rules
+     * ({@link MEMBER_RECENCY_KEYS}). Defaults to the memories shape.
+     */
+    memberFilename?: string;
+}
+/** Result of {@link appendUnionById} (#2958 recency-aware union). */
+export interface AppendUnionByIdResult<T> {
     merged: T[];
     added: number;
     skipped: number;
-};
+    /** Source rows that superseded an older destination row for a shared id. */
+    superseded: number;
+    /** Shared ids with no usable recency signal (destination kept, reported). */
+    unresolvedCollisions: readonly string[];
+    /** Destination tombstones resurrected by a newer live source row. */
+    resurrectedIds: readonly string[];
+}
+/**
+ * Id-keyed union of two append-only JSONL arrays — recency-aware (#2958).
+ *
+ * For a shared id the union compares the source row against the EFFECTIVE last
+ * destination row (load is last-row-wins; the map is updated as rows append,
+ * so a multi-row source history resolves against the merge's own state). A
+ * strictly newer source row is APPENDED (files stay append-only — never
+ * rewritten in place); destination-newer or equal keeps today's skip; a
+ * byte-equal retry is benign dedup; a collision with no usable recency signal
+ * keeps the destination row AND is reported in `unresolvedCollisions`.
+ * Proposals use reviewed-outranks-unreviewed ordering (a curator review is a
+ * lifecycle advancement); tombstoned destination memories resurrected by a
+ * newer live source row are reported in `resurrectedIds`.
+ */
+declare function appendUnionById<T>(destination: T[], source: T[], options?: AppendUnionByIdOptions): AppendUnionByIdResult<T>;
 /**
  * Outcome event ids are retry identities, not generic append-only row ids.
  * Apply the provider's shared semantic collision rules while retaining the
@@ -110,6 +163,7 @@ declare function stageSqliteDb(sourceStoragePath: string, destDir: string): {
 declare function mergeStagedSqlite(destStoragePath: string, stagedPath: string): Promise<{
     merged: number;
     skipped: number;
+    audit: MemoryFamilyMemberAudit;
 }>;
 /** Best-effort row count via a direct DB open (does not enter the pool). */
 declare function countRowsSafe(dbPath: string): Promise<number>;

package/dist/utils/ephemeral-session-teardown.d.ts

@@ -128,12 +128,30 @@ export type EphemeralTeardownVerification = {
     reason: string;
 };
 /**
- * Bounded existence check via `session.get`. `get` throwing (session-gone
- * errors surface as rejections on the SDK surface) or returning an empty body
- * both mean the session is gone (mirrors the reason-forwarding resolver
- * precedent in `src/hooks/pr-workflow-session-resolver.ts`).
+ * Existence verdict for the post-delete verify (`session.get`).
+ *
+ * - `'gone'` — confirmed-gone signal only: an empty body (`data` undefined or
+ *   null with no transport-class error envelope), or — for hosts configured
+ *   `throwOnError: true` — a rejection that is neither the verify deadline
+ *   error (compared by identity) nor transport-class.
+ * - `'unreadable'` — the verify timed out (the locally constructed deadline
+ *   error, distinguished by identity) or the call failed with a transport-class
+ *   error (whatwg fetch `TypeError`, connection-reset family). Never a death
+ *   claim: under the installed SDK's `throwOnError` default-off, session-gone
+ *   surfaces through the body check, so nearly every rejection/envelope-error
+ *   reaching these paths is an unproven-death signal (issue #2964).
+ * - `'alive'` — non-empty body, or `get` unavailable (cannot disprove).
+ */
+type SessionExistence = 'alive' | 'gone' | 'unreadable';
+/**
+ * Whether an error looks like a transient transport failure rather than a
+ * host-level answer: a whatwg fetch network `TypeError`, a Node/Deno
+ * connection error code, or an SDK abort. Used both for rejections of
+ * `session.get` and for transport errors normalized into `{data: null, error}`
+ * envelopes by the v2 session shim (`src/host/v2/session-client.ts`).
  */
-declare function sessionExists(session: EphemeralSessionLifecycle, sessionId: string, verifyTimeoutMs: number): Promise<boolean>;
+declare function isTransientTransportError(err: unknown): boolean;
+declare function sessionExists(session: EphemeralSessionLifecycle, sessionId: string, verifyTimeoutMs: number): Promise<SessionExistence>;
 /**
  * Verified teardown (issue #2599): bounded abort → bounded delete → bounded
  * existence check, retrying the delete a bounded number of times when the
@@ -146,6 +164,7 @@ export declare const _internals: {
     boundedAbort: typeof boundedAbortEphemeralSession;
     boundedDelete: typeof boundedDeleteEphemeralSession;
     sessionExists: typeof sessionExists;
+    isTransientTransportError: typeof isTransientTransportError;
     log: typeof log;
 };
 export {};

package/package.json

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