opencode-swarm 7.135.0 → 7.135.2

package/dist/tools/write-pr-review-trigger-eval.d.ts

@@ -1,79 +1,51 @@
 import { z } from 'zod';
 import { resolveExactMergeBase, resolvePrWorkflowRevisionDigest } from '../background/workspace-snapshot.js';
 import { createSwarmTool } from './create-tool';
+export { PR_REVIEW_TRIGGER_DEFINITIONS } from '../background/pr-review-trigger-contract.js';
 export declare const _internals: {
     resolvePrWorkflowRevisionDigest: typeof resolvePrWorkflowRevisionDigest;
     resolveMergeBase: typeof resolveExactMergeBase;
 };
-/** Canonical trigger IDs and display values shared with the PR-review protocol. */
-export declare const PR_REVIEW_TRIGGER_DEFINITIONS: readonly [{
-    readonly id: "auth-identity-secrets";
-    readonly scope: "universal";
-    readonly trigger_row: "authentication, authorization, identity, sessions, permissions, secrets, cryptography";
-    readonly micro_lane: "Identity and secret boundaries";
-}, {
-    readonly id: "untrusted-input-boundaries";
-    readonly scope: "universal";
-    readonly trigger_row: "parsing, serialization, queries, templates/rendering, file or network input/output";
-    readonly micro_lane: "Untrusted input and sink analysis";
-}, {
-    readonly id: "subprocess-platform";
-    readonly scope: "universal";
-    readonly trigger_row: "subprocesses, shell commands, filesystem operations, OS/runtime-specific code";
-    readonly micro_lane: "Subprocess and platform safety";
-}, {
-    readonly id: "concurrency-state";
-    readonly scope: "universal";
-    readonly trigger_row: "queues, caches, retries, transactions, locks, state machines, async coordination";
-    readonly micro_lane: "Concurrency and state transitions";
-}, {
-    readonly id: "dependencies-build-release";
-    readonly scope: "universal";
-    readonly trigger_row: "dependency manifests, lockfiles, installers, build scripts, CI, packaging, deployment";
-    readonly micro_lane: "Dependency and delivery integrity";
-}, {
-    readonly id: "api-schema-migrations";
-    readonly scope: "universal";
-    readonly trigger_row: "public API, wire/schema/config/storage formats, migrations, feature flags";
-    readonly micro_lane: "Compatibility and migration safety";
-}, {
-    readonly id: "test-infrastructure";
-    readonly scope: "universal";
-    readonly trigger_row: "tests, mocks, fixtures, harnesses, coverage, CI matrices";
-    readonly micro_lane: "Test validity and isolation";
-}, {
-    readonly id: "ui-accessibility-i18n";
-    readonly scope: "universal";
-    readonly trigger_row: "user interfaces, interaction flows, rendering, accessibility, localization";
-    readonly micro_lane: "UI and human-interface quality";
-}, {
-    readonly id: "privacy-observability";
-    readonly scope: "universal";
-    readonly trigger_row: "telemetry, logs, analytics, traces, retention, diagnostics";
-    readonly micro_lane: "Privacy and observability safety";
-}, {
-    readonly id: "generated-provenance";
-    readonly scope: "universal";
-    readonly trigger_row: "generated, vendored, binary, model-produced, codegen or checked-in build artifacts";
-    readonly micro_lane: "Generated artifact provenance";
-}, {
-    readonly id: "unclassified-risk";
-    readonly scope: "universal";
-    readonly trigger_row: "any changed artifact or behavior not confidently classified by the rows above";
-    readonly micro_lane: "Unclassified high-risk fallback";
-}];
 declare const WritePrReviewTriggerEvalArgsSchema: z.ZodObject<{
     run_id: z.ZodString;
     pr_head_sha: z.ZodString;
     base_sha: z.ZodOptional<z.ZodString>;
     base_ref: z.ZodOptional<z.ZodString>;
-    rows: z.ZodArray<z.ZodObject<{
-        trigger_id: z.ZodString;
+    rows: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        trigger_id: z.ZodEnum<{
+            "auth-identity-secrets": "auth-identity-secrets";
+            "untrusted-input-boundaries": "untrusted-input-boundaries";
+            "subprocess-platform": "subprocess-platform";
+            "concurrency-state": "concurrency-state";
+            "dependencies-build-release": "dependencies-build-release";
+            "api-schema-migrations": "api-schema-migrations";
+            "test-infrastructure": "test-infrastructure";
+            "ui-accessibility-i18n": "ui-accessibility-i18n";
+            "privacy-observability": "privacy-observability";
+            "generated-provenance": "generated-provenance";
+            "unclassified-risk": "unclassified-risk";
+        }>;
         result: z.ZodLiteral<"MATCHED">;
         evidence: z.ZodString;
-        source_batch_id: z.ZodOptional<z.ZodString>;
-        source_lane_id: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
+        source_batch_id: z.ZodString;
+        source_lane_id: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        trigger_id: z.ZodEnum<{
+            "auth-identity-secrets": "auth-identity-secrets";
+            "untrusted-input-boundaries": "untrusted-input-boundaries";
+            "subprocess-platform": "subprocess-platform";
+            "concurrency-state": "concurrency-state";
+            "dependencies-build-release": "dependencies-build-release";
+            "api-schema-migrations": "api-schema-migrations";
+            "test-infrastructure": "test-infrastructure";
+            "ui-accessibility-i18n": "ui-accessibility-i18n";
+            "privacy-observability": "privacy-observability";
+            "generated-provenance": "generated-provenance";
+            "unclassified-risk": "unclassified-risk";
+        }>;
+        result: z.ZodLiteral<"NOT_TRIGGERED">;
+        evidence: z.ZodString;
+    }, z.core.$strict>], "result">>;
 }, z.core.$strict>;
 export type WritePrReviewTriggerEvalArgs = z.infer<typeof WritePrReviewTriggerEvalArgsSchema>;
 /** Validate and atomically persist the complete PR-review trigger evaluation. */
@@ -81,4 +53,3 @@ export declare function executeWritePrReviewTriggerEval(args: unknown, directory
     sessionID?: string;
 }): Promise<string>;
 export declare const write_pr_review_trigger_eval: ReturnType<typeof createSwarmTool>;
-export {};

package/dist/turbo/lean/lane-scope.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Lean Turbo lane write authority (issue #2002 — Lean Turbo half).
+ *
+ * ## The defect this closes
+ *
+ * A Lean Turbo lane creates a coder session rooted at the lane worktree and
+ * dispatches it with `tools: { write: true, edit: true, patch: true }`
+ * (`src/turbo/lean/runner.ts`), but nothing ever published a v2 scope binding
+ * for that session and nothing ever materialized the authoritative plan into
+ * the lane. `resolveAuthorizedScopeBinding` starts from
+ * `readCurrentPlan(directory)` (`src/scope/scope-persistence.ts`), so with no
+ * `.swarm/plan.json` in the lane it returned null before it even looked at a
+ * binding — and every lane coder write failed `SCOPE_NOT_DECLARED` regardless
+ * of which directory the gate resolved.
+ *
+ * This module publishes that authority using the same primitives as the
+ * standard worktree path (`src/hooks/delegation-gate.ts`, the
+ * `savePlan` → `deriveChildScopeBinding` → register + `writeScopeBindingToDisk`
+ * sequence), so every identity condition in
+ * `getAuthorizedScopeBindingByPlanIdentity` is satisfied without weakening or
+ * bypassing any of them.
+ *
+ * ## Authority boundary
+ *
+ * A lane binding authorizes exactly the intersection of
+ *   1. `lane.files` — the file set the lane already holds exclusive locks on
+ *      (`acquireLaneLocks(directory, laneId, lane.files, agent, lane.taskIds[0], …)`
+ *      in `src/turbo/lean/runner.ts`), and
+ *   2. the authoritative plan's `files_touched` for the lane's own tasks.
+ *
+ * It therefore grants nothing the lane's pre-existing file locks did not
+ * already reserve for this dispatch, and nothing the plan does not attribute to
+ * this lane's tasks. It is rooted at the lane worktree, owned by the lane's
+ * child session id, and correlated to a single synthetic dispatch id — so it
+ * can never authorize a write in another lane or in the project root.
+ *
+ * ## Known gap (deliberate, not a bypass)
+ *
+ * A lane may carry several task ids (`src/turbo/lean/planner.ts` assigns every
+ * non-conflicting ready task to the first non-conflicting lane). The scope
+ * gates resolve a binding by a single `session.currentTaskId`, so a lane gets
+ * ONE binding labelled with the lane's representative task id
+ * (`lane.taskIds[0]`, the same representative the lock layer already uses) and
+ * carrying the lane's whole plan-backed authority. This mirrors the lock
+ * record 1:1; it does not widen the lane past what the lock already reserved.
+ *
+ * ## Fail-closed contract
+ *
+ * When a lane has no representative task id in strict `N.M[.P]` form, no
+ * plan-backed files, or an unusable child identity, this module publishes
+ * NOTHING and returns null. The lane coder then hits the ordinary
+ * `SCOPE_NOT_DECLARED` block — byte-identical to pre-fix behaviour. There is no
+ * path here that grants a lane coder write authority without a validated,
+ * plan-correlated, lane-rooted binding.
+ */
+import type { Plan } from '../../config/plan-schema';
+import { type ScopeBinding } from '../../scope/scope-binding';
+/**
+ * Namespace for the synthetic dispatch-call id that correlates a lane's child
+ * binding to its parent Lean Turbo run. Lean Turbo dispatches through the
+ * OpenCode session API rather than the Task tool, so there is no upstream
+ * `callID`. The prefix keeps these ids disjoint from real Task call ids so a
+ * lane binding can never be claimed by a Task-dispatch lookup.
+ */
+export declare const LEAN_TURBO_LANE_DISPATCH_PREFIX = "lean-turbo-lane";
+/** Minimal lane shape this module needs. Matches `LeanTurboLane`. */
+export interface LeanTurboLaneScopeLane {
+    laneId: string;
+    taskIds: readonly string[];
+    files: readonly string[];
+}
+export interface PublishLeanTurboLaneScopeInput {
+    /** Project root the Lean Turbo run was started in. */
+    primaryDirectory: string;
+    /** Root the lane's coder session actually executes in. */
+    laneRoot: string;
+    /**
+     * True only when `laneRoot` is `provisionWorktree`'s own output. Never
+     * derive this from a path comparison and never from an agent-supplied
+     * value: it gates both the lane plan materialization and the workspace-root
+     * recording, which are the two writes that must follow provisioning
+     * authority only.
+     */
+    isolated: boolean;
+    /** Authoritative plan for this run (already loaded from the project root). */
+    plan: Plan;
+    lane: LeanTurboLaneScopeLane;
+    /** Session running the Lean Turbo phase (the architect). */
+    parentSessionId: string;
+    /** Session id returned by `session.create` for this lane. */
+    childSessionId: string;
+}
+/**
+ * Resolve the file set a lane may be authorized for: lane-locked files that the
+ * authoritative plan also attributes to one of the lane's own tasks.
+ *
+ * Returns null when the plan attributes no usable file to this lane's tasks or
+ * when no locked lane file falls inside that plan authority — both are
+ * fail-closed outcomes, never a widening fallback.
+ */
+export declare function resolveLeanTurboLaneAuthorityFiles(plan: Plan, lane: LeanTurboLaneScopeLane): string[] | null;
+/**
+ * Publish one Lean Turbo lane's write authority.
+ *
+ * Ordering is deliberate:
+ *   1. validate identity and resolve plan-backed authority (cheap, no writes) —
+ *      a failure here publishes nothing at all;
+ *   2. materialize the authoritative plan into the lane (isolated lanes only,
+ *      so concurrent lanes never re-write the project's own plan ledger);
+ *   3. derive the active child binding, register it, and persist it under the
+ *      lane root;
+ *   4. bind the child session to the lane root so the write gates resolve
+ *      against the lane instead of the plugin-root `ctx.directory`.
+ *
+ * @returns the published child binding, or null when the lane cannot be
+ *   authorized (fail closed — the caller must NOT grant any substitute).
+ * @throws only on unexpected I/O failure (e.g. `savePlan` rejecting). The
+ *   caller treats a throw as a hard dispatch failure.
+ */
+export declare function publishLeanTurboLaneScopeBinding(input: PublishLeanTurboLaneScopeInput): Promise<ScopeBinding | null>;

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

@@ -16,13 +16,15 @@
  * - If dispatch fails, locks for that lane are released and lane is marked 'failed'
  */
 import type { OpencodeClient } from '@opencode-ai/sdk';
+import type { Plan } from '../../config/plan-schema';
 import type { LeanTurboConfig } from '../../config/schema';
 import { loadFullAutoRunState } from '../../full-auto/state';
 import { acquireLaneLocks, releaseLaneLocks } from '../../parallel/file-locks';
 import { loadPlanJsonOnly } from '../../plan/manager';
-import { ensureAgentSession, hasActiveFullAuto } from '../../state';
+import { hasActiveFullAuto } from '../../state';
 import { type ModelOverride } from '../../utils/model-dispatch-fallback';
 import { writeLaneEvidence, writePhaseEvidence } from './evidence';
+import { publishLeanTurboLaneScopeBinding } from './lane-scope';
 import { attemptMergeBackFromDirty, getMergeStrategy, mergeLaneBranch, postMergeCleanup, startupOrphanRecovery } from './merge-back';
 import { planLeanTurboLanes } from './planner';
 import type { LeanTurboDegradedTask, LeanTurboLane } from './state';
@@ -167,6 +169,32 @@ export interface LeanTurboPhaseResult {
     /** Lanes whose coder completed but merge-back to primary branch failed */
     mergeBackFailures?: MergeBackFailureInfo[];
 }
+/**
+ * Orchestrates Lean Turbo lane execution.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * const runner = new LeanTurboRunner({
+ *   directory: projectRoot,
+ *   sessionID: 'sess-abc123',
+ *   opencodeClient: swarmState.opencodeClient,
+ *   generatedAgentNames: swarmState.generatedAgentNames,
+ * });
+ *
+ * const result = await runner.runPhase(1);
+ * // ... monitor lanes ...
+ * await runner.cleanup();
+ * ```
+ */
+/**
+ * Error code returned when a lane's write authority could not be published
+ * (issue #2002). Deliberately free of any token matched by
+ * `TRANSIENT_MODEL_ERROR_PATTERN` / `QUOTA_ERROR_PATTERN`, and classified
+ * `permanent` explicitly in `_processLane` so a broken authority handshake can
+ * never be mistaken for a provider blip and retried across fallback models.
+ */
+export declare const LANE_SCOPE_DENIED_CODE = "LEAN_TURBO_LANE_SCOPE_DENIED";
 export declare class LeanTurboRunner {
     /**
      * Test-only dependency-injection seam.
@@ -195,8 +223,11 @@ export declare class LeanTurboRunner {
         startupOrphanRecovery: typeof startupOrphanRecovery;
         getMergeStrategy: typeof getMergeStrategy;
         assertCleanWorkingTree: typeof assertCleanWorkingTree;
-        /** DI seam for ensureAgentSession — allows tests to intercept advisory queue writes. */
-        ensureAgentSession: typeof ensureAgentSession;
+        /**
+         * Issue #2002: publishes a lane's plan-correlated, lane-rooted write
+         * authority before the lane's coder prompt is sent.
+         */
+        publishLeanTurboLaneScopeBinding: typeof publishLeanTurboLaneScopeBinding;
     };
     /**
      * Test-only dependency-injection seam for session operations.
@@ -269,12 +300,43 @@ export declare class LeanTurboRunner {
      *
      * @param lane - Lane to dispatch
      * @param agentName - Agent name to dispatch to
+     * @param worktreeDirectory - Provisioned lane worktree, when isolation is on
+     * @param model - Per-call model override for a fallback attempt (#1896)
+     * @param plan - Authoritative plan for this run. Required to publish the
+     *   lane's write authority (issue #2002). When omitted, no binding is
+     *   minted AND the lane's `write`/`edit`/`patch` tools are force-disabled
+     *   (see `_doDispatch`) — an unscoped lane can never be dispatched
+     *   writable, regardless of caller. Only `_processLane` supplies a plan in
+     *   production (always, per `runPhase`'s own `NO_PLAN` guard); direct
+     *   callers that omit it get a read-only lane rather than a silent
+     *   unscoped-but-writable one.
      */
-    dispatchLane(lane: LeanTurboLane, agentName: string, worktreeDirectory?: string, model?: ModelOverride): Promise<LaneDispatchResult>;
+    dispatchLane(lane: LeanTurboLane, agentName: string, worktreeDirectory?: string, model?: ModelOverride, plan?: Plan): Promise<LaneDispatchResult>;
     /**
      * Internal dispatch implementation (separated for timeout wrapping).
      */
     private _doDispatch;
+    /**
+     * Publish the lane's write authority for a freshly created lane session
+     * (issue #2002 — Lean Turbo half).
+     *
+     * Two distinct fail-closed outcomes, deliberately kept apart:
+     *
+     * - **No authorizable lane** (`publishLeanTurboLaneScopeBinding` returns
+     *   null: representative task id not in strict `N.M[.P]` form, no
+     *   plan-backed files, unusable child identity). Nothing is published and
+     *   the lane still runs — the coder is blocked by the ordinary
+     *   `SCOPE_NOT_DECLARED` gate exactly as it was before this fix. An
+     *   architect advisory makes the unscoped lane visible instead of silent.
+     * - **Publication failed unexpectedly** (I/O error, plan materialization
+     *   rejected). That is not a pre-existing state, so the lane session is
+     *   torn down and the dispatch fails permanently rather than running a
+     *   coder whose authority is in an unknown state.
+     *
+     * @returns a failing `LaneDispatchResult` to abort the dispatch, or null to
+     *   continue.
+     */
+    private _publishLaneScope;
     /**
      * Get current status of all lanes tracked by this runner.
      *

package/package.json

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

package/dist/cli/guardrail-explain-zmbxwh3s.js

@@ -1,57 +0,0 @@
-// @bun
-import {
-  handleGuardrailExplain
-} from "./index-6kmmdtdp.js";
-import"./index-crw4n55v.js";
-import"./index-13xxjfhn.js";
-import"./index-grxkbbc5.js";
-import"./index-ctvnb76s.js";
-import"./index-ens0gt38.js";
-import"./index-4905hd2m.js";
-import"./index-134d35c1.js";
-import"./index-a4972t0f.js";
-import"./index-86wdrskb.js";
-import"./index-vf6e8ame.js";
-import"./index-vxv732ex.js";
-import"./index-c8s9a3zh.js";
-import"./index-9ss2m4rs.js";
-import"./index-b7p0mp2q.js";
-import"./index-z085b4ka.js";
-import"./index-997d6p42.js";
-import"./index-g0raqavt.js";
-import"./index-rtry5xyf.js";
-import"./index-nrvs08pr.js";
-import"./index-x88w0cp5.js";
-import"./index-ae75rja9.js";
-import"./index-yhba8swx.js";
-import"./index-xg9repnx.js";
-import"./index-e8w62fgs.js";
-import"./index-k5jrywpr.js";
-import"./index-n832052r.js";
-import"./index-337r9pkr.js";
-import"./index-bk5tah7q.js";
-import"./index-8fwhhayc.js";
-import"./index-q1exe2b3.js";
-import"./index-ny93srnd.js";
-import"./index-wxyxf0bd.js";
-import"./index-1kz6da87.js";
-import"./index-b4z7s917.js";
-import"./index-b8zgtz81.js";
-import"./index-44zgqvqh.js";
-import"./index-4rhhvd1a.js";
-import"./index-7an2qn0s.js";
-import"./index-2ghkk9ve.js";
-import"./index-fsrp8wp3.js";
-import"./index-09b9zncg.js";
-import"./index-7g4c7s5r.js";
-import"./index-7a2hm51h.js";
-import"./index-bpmtbmy9.js";
-import"./index-z6xqpmqg.js";
-import"./index-zjygnfay.js";
-import"./index-qe3v54nb.js";
-import"./index-zgwm4ryv.js";
-import"./index-3nasn371.js";
-import"./index-a76rekgs.js";
-export {
-  handleGuardrailExplain
-};