opencode-swarm 7.200.11 → 7.200.13

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/package.json

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