opencode-swarm 7.200.12 → 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/turbo/lean/planner.d.ts

@@ -95,11 +95,14 @@ export interface LeanTurboLanePlan {
  *        redesign). When supplied, a cross-batch dependency (a `depends:`
  *        upstream not present in this planning call's task set — typically
  *        completed in a prior phase) is treated as satisfied **only** if
- *        the predicate returns `true`. Production callers build this from
- *        `buildIsUpstreamCommitted(directory)` so the check resolves to
- *        "is there a `swarm(task <id>)` commit in HEAD". When undefined
- *        the planner falls back to its legacy behavior (cross-batch deps
- *        are implicitly satisfied) for backward compatibility.
+ *        the predicate returns `true`. Production lean callers supply it via
+ *        `resolveLeanRule3Predicate(directory, taskIds)`
+ *        (`src/turbo/lean/upstream-committed.ts`) ONLY while an Epic is open
+ *        for the project — `swarm(task <id>):` landing commits exist only
+ *        under Epic Mode, so wiring it unconditionally would wrongly degrade
+ *        every healthy pure-lean cross-phase dependent. When undefined (no
+ *        open Epic) the planner falls back to its legacy behavior (cross-batch
+ *        deps are implicitly satisfied) for backward compatibility.
  * @returns Complete lane plan with lanes, degraded tasks, and counters
  */
 export declare function planLeanTurboLanes(directory: string, phaseNumber: number, plan: {

package/dist/turbo/lean/runner.d.ts

@@ -29,6 +29,7 @@ import { attemptMergeBackFromDirty, getMergeStrategy, mergeLaneBranch, postMerge
 import { planLeanTurboLanes } from './planner';
 import type { LeanTurboDegradedTask, LeanTurboLane } from './state';
 import { loadLeanTurboRunState, saveLeanTurboRunState } from './state';
+import { resolveLeanRule3Predicate } from './upstream-committed';
 import { assertCleanWorkingTree, provisionWorktree, removeLaneProfileFromDiskReal, removeWorktree } from './worktree';
 /**
  * Shape of the OpencodeClient session API used by the runner.
@@ -216,6 +217,8 @@ export declare class LeanTurboRunner {
     static _internals: {
         loadPlanJsonOnly: typeof loadPlanJsonOnly;
         planLeanTurboLanes: typeof planLeanTurboLanes;
+        /** Issue #2962: epic-gated Rule-3 upstream-commit predicate for lane planning. */
+        resolveLeanRule3Predicate: typeof resolveLeanRule3Predicate;
         acquireLaneLocks: typeof acquireLaneLocks;
         releaseLaneLocks: typeof releaseLaneLocks;
         loadLeanTurboRunState: typeof loadLeanTurboRunState;

package/dist/turbo/lean/upstream-committed.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Lean Turbo Rule-3 upstream-commit predicate (issue #2962).
+ *
+ * `planLeanTurboLanes` reserves an optional `isUpstreamCommitted` predicate
+ * (greenfield-smart Rule 3): when supplied, a cross-batch `depends:` upstream
+ * (a dep not present in this planning call's task set — typically completed in
+ * a prior phase) counts as satisfied only when the predicate proves the
+ * upstream's work landed in git. Before this module existed, neither
+ * production caller supplied it, so `makeDependencySatisfactionChecker`
+ * (`partition-common.ts`) treated every cross-batch dep as implicitly
+ * satisfied — a dependent task was dispatched in a parallel lane against work
+ * that never reached HEAD.
+ *
+ * The predicate is EPIC-GATED: `swarm(task <id>):` landing commits exist only
+ * under Epic Mode (`src/epic/plan-key.ts` → `task-landing.ts`/`residue-commit.ts`;
+ * `src/plan/manager.ts` performs no git writes). In pure Lean Turbo no such
+ * commits ever exist, so this helper returns `undefined` (the planner's
+ * byte-identical legacy branch) unless an Epic is open for the project.
+ *
+ * Evidence reuses the CURRENT Epic marker machinery — never a re-implemented
+ * subject scanner: coder landings are `git merge --no-ff` MERGE commits (the
+ * log read is merge-inclusive), task ids repeat across plans (the
+ * `Swarm-Plan:` trailer filters by planKey), and ids are scrubbed in subjects
+ * (`scrubTaskIdForGitSubject` mapping handled inside `findTaskCommits`).
+ *
+ * Failure taxonomy:
+ * - Unreadable Epic state           → Epic reads as OFF (same direction as
+ *   `isEpicOpenForProject`): `undefined` + operator-visible warn.
+ * - Epic closed between the reads   → `undefined`, no warn (not an error).
+ * - Unborn HEAD (positively
+ *   classified)                     → defined predicate, EMPTY committed set
+ *                                     (nothing has landed yet).
+ * - Genuine git failure (log read
+ *   fails with HEAD resolvable, or
+ *   the probe itself fails)         → disclosed permissive fallback
+ *                                     (`() => true`): legacy degradation,
+ *                                     NOT continued Rule-3 enforcement — wave
+ *                                     ordering never covers cross-batch deps.
+ *
+ * This module is the Lean-owned side of a documented Lean→Epic seam (see
+ * `src/epic/README.md`, upstream consumers): `src/epic/lifecycle.ts` and
+ * `src/epic/markers.ts` import nothing from `src/turbo/lean/`, so the edge is
+ * acyclic, and Epic-off costs exactly the sentinel `existsSync` inside
+ * `isEpicOpenForProject` (Epic rule zero).
+ */
+import { getOpenEpic, isEpicOpenForProject } from '../../epic/lifecycle.js';
+import { epicCommitRange, findTaskCommits } from '../../epic/markers.js';
+import * as logger from '../../utils/logger.js';
+/** Three-way HEAD probe outcome. */
+export type HeadCommitState = 'exists' | 'unborn' | 'unknown';
+/**
+ * Bounded HEAD classification. `'exists'` when `git rev-parse --verify HEAD`
+ * resolves (exit 0). `'unborn'` ONLY when positively classified: rev-parse
+ * fails AND `git symbolic-ref -q HEAD` still resolves the branch (we are on a
+ * branch that simply has no commits yet — the structural unborn shape; stderr
+ * text varies by git version, so the ref probe is the classifier). Every other
+ * outcome — spawn error, timeout, other exit, detached/corrupt HEAD — yields
+ * `'unknown'` so a probe failure can never masquerade as "nothing committed".
+ */
+declare function headCommitExistsReal(directory: string): HeadCommitState;
+/**
+ * Warn once per (resolved directory, failure class). The class key keeps the
+ * two semantically distinct degradations from suppressing each other (#2962
+ * review PRR-006): an unreadable-Epic warning must not silence a later
+ * git-log-failure warning for the same project, and vice versa. The key is
+ * the canonical lexical root so path-spelling variants dedup to one entry.
+ */
+declare function warnOnceReal(directory: string, failureClass: 'epic-unreadable' | 'rule3-git-failure', message: string): void;
+/**
+ * Resolve the Rule-3 predicate for a Lean Turbo planning call.
+ *
+ * @param directory - Project root directory.
+ * @param taskIds - The plan's full task-id set (all phases) — the candidate
+ *        cross-batch upstreams the marker read scans for. One bounded git
+ *        call per planning pass; never on the plugin-init path.
+ * @returns `undefined` when no Epic is open for the project (pure-lean
+ *        legacy semantics, byte-identical placement), otherwise a predicate
+ *        answering "does this task id have a `swarm(task <id>):` landing in
+ *        the open Epic's commit range for the current plan?".
+ */
+export declare function resolveLeanRule3Predicate(directory: string, taskIds: readonly string[]): ((taskId: string) => boolean) | undefined;
+/** DI seam (AGENTS.md invariant 7). Restore in `afterEach`. */
+export declare const _internals: {
+    isEpicOpenForProject: typeof isEpicOpenForProject;
+    getOpenEpic: typeof getOpenEpic;
+    epicCommitRange: typeof epicCommitRange;
+    findTaskCommits: typeof findTaskCommits;
+    headCommitExists: typeof headCommitExistsReal;
+    warnOnce: typeof warnOnceReal;
+    criticalWarn: typeof logger.criticalWarn;
+    /** Test-reset surface for the module-level dedup registry (lifecycle.ts precedent). */
+    warnedDirectories: Set<string>;
+};
+export {};

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.12",
+	"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",