opencode-swarm 7.107.6 → 7.108.0

package/dist/commands/lanes.d.ts

@@ -0,0 +1,35 @@
+/**
+ * /swarm lanes command — lists active, awaiting-merge, and conflicted worktree lanes.
+ *
+ * FR-105: SC-114, SC-115, SC-116, SC-117
+ */
+import { type WorktreeMergeFailure } from '../hooks/delegation-gate/worktree-merge-status';
+/**
+ * Lane record shape for machine-parseable output (--json).
+ */
+export interface LaneRecord {
+    state: 'active' | 'awaiting-merge' | 'conflicted';
+    laneId: string;
+    branch: string;
+    worktreePath: string;
+    taskId: string;
+    planTaskId?: string;
+    parentSessionID: string;
+    mergeStrategy: 'merge' | 'rebase' | 'cherry-pick';
+    mergeOutcome?: WorktreeMergeFailure;
+    recoveryHint: string;
+}
+/**
+ * Handle the `/swarm lanes` command.
+ *
+ * Reads authoritative in-flight state from `standardWorktreeByCallID` and
+ * merge failure records from `worktree-merge-status.ts`. Produces two
+ * output formats controlled by the `--json` flag:
+ *
+ * - Human-readable (default): grouped by state with one-line summaries.
+ * - Machine-parseable (--json): stable-order array of `LaneRecord` objects.
+ *
+ * @param directory - Project root directory (used to init the durable status path)
+ * @param args      - Command arguments; `--json` selects machine-parseable output
+ */
+export declare function handleLanesCommand(directory: string, args: string[]): string;

package/dist/commands/registry.d.ts

@@ -190,6 +190,13 @@ export declare const COMMAND_REGISTRY: {
         readonly toolPolicy: "agent";
         readonly toolNoArgs: true;
     };
+    readonly lanes: {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "List active, awaiting-merge, and conflicted worktree lanes";
+        readonly category: "diagnostics";
+        readonly toolPolicy: "agent";
+        readonly toolNoArgs: true;
+    };
     readonly 'sync-plan': {
         readonly handler: (ctx: CommandContext) => Promise<string>;
         readonly description: "Ensure plan.json and plan.md are synced";

package/dist/config/schema.d.ts

@@ -1067,6 +1067,15 @@ export declare const WorktreeIsolationConfigSchema: z.ZodObject<{
         skip: "skip";
         copy: "copy";
     }>>;
+    serialization_release_after_dispatches: z.ZodDefault<z.ZodNumber>;
+    serialization_release_after_ms: z.ZodDefault<z.ZodNumber>;
+    runtime_isolation: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        port_base: z.ZodOptional<z.ZodNumber>;
+        port_stride: z.ZodDefault<z.ZodNumber>;
+        env_overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        cache_redirects: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type WorktreeIsolationConfig = z.infer<typeof WorktreeIsolationConfigSchema>;
 export declare const LeanTurboConfigSchema: z.ZodObject<{
@@ -1088,6 +1097,18 @@ export declare const LeanTurboConfigSchema: z.ZodObject<{
         "cherry-pick": "cherry-pick";
     }>>>;
     worktree_dir: z.ZodOptional<z.ZodString>;
+    deps_strategy: z.ZodOptional<z.ZodEnum<{
+        link: "link";
+        skip: "skip";
+        copy: "copy";
+    }>>;
+    runtime_isolation: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        port_base: z.ZodOptional<z.ZodNumber>;
+        port_stride: z.ZodDefault<z.ZodNumber>;
+        env_overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        cache_redirects: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type LeanTurboConfig = z.infer<typeof LeanTurboConfigSchema>;
 /**
@@ -1142,6 +1163,18 @@ export declare const StandardTurboConfigSchema: z.ZodObject<{
             "cherry-pick": "cherry-pick";
         }>>>;
         worktree_dir: z.ZodOptional<z.ZodString>;
+        deps_strategy: z.ZodOptional<z.ZodEnum<{
+            link: "link";
+            skip: "skip";
+            copy: "copy";
+        }>>;
+        runtime_isolation: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            port_base: z.ZodOptional<z.ZodNumber>;
+            port_stride: z.ZodDefault<z.ZodNumber>;
+            env_overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            cache_redirects: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     epic: z.ZodOptional<z.ZodObject<{
         cochange: z.ZodOptional<z.ZodObject<{
@@ -1184,6 +1217,18 @@ export declare const LeanTurboStrategyConfigSchema: z.ZodObject<{
             "cherry-pick": "cherry-pick";
         }>>>;
         worktree_dir: z.ZodOptional<z.ZodString>;
+        deps_strategy: z.ZodOptional<z.ZodEnum<{
+            link: "link";
+            skip: "skip";
+            copy: "copy";
+        }>>;
+        runtime_isolation: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            port_base: z.ZodOptional<z.ZodNumber>;
+            port_stride: z.ZodDefault<z.ZodNumber>;
+            env_overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            cache_redirects: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>;
     epic: z.ZodOptional<z.ZodObject<{
         cochange: z.ZodOptional<z.ZodObject<{
@@ -1226,6 +1271,18 @@ export declare const TurboConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             "cherry-pick": "cherry-pick";
         }>>>;
         worktree_dir: z.ZodOptional<z.ZodString>;
+        deps_strategy: z.ZodOptional<z.ZodEnum<{
+            link: "link";
+            skip: "skip";
+            copy: "copy";
+        }>>;
+        runtime_isolation: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            port_base: z.ZodOptional<z.ZodNumber>;
+            port_stride: z.ZodDefault<z.ZodNumber>;
+            env_overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            cache_redirects: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     epic: z.ZodOptional<z.ZodObject<{
         cochange: z.ZodOptional<z.ZodObject<{
@@ -1267,6 +1324,18 @@ export declare const TurboConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             "cherry-pick": "cherry-pick";
         }>>>;
         worktree_dir: z.ZodOptional<z.ZodString>;
+        deps_strategy: z.ZodOptional<z.ZodEnum<{
+            link: "link";
+            skip: "skip";
+            copy: "copy";
+        }>>;
+        runtime_isolation: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            port_base: z.ZodOptional<z.ZodNumber>;
+            port_stride: z.ZodDefault<z.ZodNumber>;
+            env_overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            cache_redirects: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>;
     epic: z.ZodOptional<z.ZodObject<{
         cochange: z.ZodOptional<z.ZodObject<{
@@ -2179,6 +2248,15 @@ export declare const PluginConfigSchema: z.ZodObject<{
             skip: "skip";
             copy: "copy";
         }>>;
+        serialization_release_after_dispatches: z.ZodDefault<z.ZodNumber>;
+        serialization_release_after_ms: z.ZodDefault<z.ZodNumber>;
+        runtime_isolation: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            port_base: z.ZodOptional<z.ZodNumber>;
+            port_stride: z.ZodDefault<z.ZodNumber>;
+            env_overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            cache_redirects: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     turbo: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         strategy: z.ZodLiteral<"standard">;
@@ -2201,6 +2279,18 @@ export declare const PluginConfigSchema: z.ZodObject<{
                 "cherry-pick": "cherry-pick";
             }>>>;
             worktree_dir: z.ZodOptional<z.ZodString>;
+            deps_strategy: z.ZodOptional<z.ZodEnum<{
+                link: "link";
+                skip: "skip";
+                copy: "copy";
+            }>>;
+            runtime_isolation: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                port_base: z.ZodOptional<z.ZodNumber>;
+                port_stride: z.ZodDefault<z.ZodNumber>;
+                env_overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                cache_redirects: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>;
         epic: z.ZodOptional<z.ZodObject<{
             cochange: z.ZodOptional<z.ZodObject<{
@@ -2242,6 +2332,18 @@ export declare const PluginConfigSchema: z.ZodObject<{
                 "cherry-pick": "cherry-pick";
             }>>>;
             worktree_dir: z.ZodOptional<z.ZodString>;
+            deps_strategy: z.ZodOptional<z.ZodEnum<{
+                link: "link";
+                skip: "skip";
+                copy: "copy";
+            }>>;
+            runtime_isolation: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                port_base: z.ZodOptional<z.ZodNumber>;
+                port_stride: z.ZodDefault<z.ZodNumber>;
+                env_overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                cache_redirects: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>;
         epic: z.ZodOptional<z.ZodObject<{
             cochange: z.ZodOptional<z.ZodObject<{

package/dist/git/branch.d.ts

@@ -1,3 +1,4 @@
+import * as child_process from 'node:child_process';
 export type GitRepositoryStatus = {
     isRepo: true;
 } | {
@@ -5,6 +6,23 @@ export type GitRepositoryStatus = {
     reason: 'not_git_repo' | 'git_unavailable' | 'git_error';
     message: string;
 };
+/**
+ * Seam that calls child_process.spawnSync dynamically.
+ * Uses getChildProcessSpawnSync() to resolve at call time, allowing
+ * tests to mock child_process.spawnSync before gitExec runs.
+ */
+declare const __spawnSyncSeam: {
+    spawnSync: (cmd: string, args: string[], options?: {
+        cwd?: string;
+        encoding?: BufferEncoding;
+        timeout?: number;
+        maxBuffer?: number;
+        windowsHide?: boolean;
+        stdio?: "pipe" | "ignore" | "inherit" | Array<"pipe" | "ignore" | "inherit">;
+        env?: Record<string, string | undefined>;
+        envOverrides?: Record<string, string | null>;
+    }) => child_process.SpawnSyncReturns<string | Buffer>;
+};
 /**
  * Execute git command safely.
  *
@@ -33,8 +51,17 @@ export type GitRepositoryStatus = {
  * with exponential backoff up to MAX_TRANSIENT_RETRIES before throwing.
  * Permanent errors — non-zero exit, missing git binary, non-transient
  * spawn errors — throw immediately with no retry.
+ *
+ * Lane env fallback (FR-201): when `laneEnv` is not provided but `laneIndex`
+ * is, reads the lane env file from disk synchronously.
+ */
+/**
+ * Synchronously read and parse a lane runtime profile from disk.
+ * Mirrors the logic of `readLaneEnvFileFromDisk` but uses sync fs.
+ * Returns an empty record when the file does not exist or cannot be read.
  */
-declare function gitExec(args: string[], cwd: string): string;
+export declare function readLaneEnvFileFromDiskSync(worktreePath: string, laneIndex: number): Record<string, string>;
+declare function gitExec(args: string[], cwd: string, laneEnv?: Record<string, string>, laneIndex?: number): string;
 export declare function getGitRepositoryStatus(cwd: string): GitRepositoryStatus;
 /**
  * Check if we're in a git repository
@@ -42,15 +69,20 @@ export declare function getGitRepositoryStatus(cwd: string): GitRepositoryStatus
 export declare function isGitRepo(cwd: string): boolean;
 /**
  * Get current branch name
+ * @param cwd - Working directory
+ * @param laneEnv - Optional lane env overrides for git spawn
+ * @param laneIndex - Optional lane index; if laneEnv not provided, reads env file from disk
  */
-export declare function getCurrentBranch(cwd: string): string;
+export declare function getCurrentBranch(cwd: string, laneEnv?: Record<string, string>, laneIndex?: number): string;
 /**
  * Create a new branch
  * @param cwd - Working directory
  * @param branchName - Name of the branch to create
  * @param remote - Remote name (default: 'origin')
+ * @param laneEnv - Optional lane env overrides for git spawn
+ * @param laneIndex - Optional lane index; if laneEnv not provided, reads env file from disk
  */
-export declare function createBranch(cwd: string, branchName: string, remote?: string): void;
+export declare function createBranch(cwd: string, branchName: string, remote?: string, laneEnv?: Record<string, string>, laneIndex?: number): void;
 /**
  * Get list of changed files compared to main/master
  * @param cwd - Working directory
@@ -72,20 +104,32 @@ export declare function stageFiles(cwd: string, files: string[]): void;
 /**
  * Stage all files in the working directory
  * @param cwd - Working directory
+ * @param laneEnv - Optional lane env overrides for git spawn
+ * @param laneIndex - Optional lane index; if laneEnv not provided, reads env file from disk
  */
-export declare function stageAll(cwd: string): void;
+export declare function stageAll(cwd: string, laneEnv?: Record<string, string>, laneIndex?: number): void;
 /**
  * Commit changes
+ * @param cwd - Working directory
+ * @param message - Commit message
+ * @param laneEnv - Optional lane env overrides for git spawn
+ * @param laneIndex - Optional lane index; if laneEnv not provided, reads env file from disk
  */
-export declare function commitChanges(cwd: string, message: string): void;
+export declare function commitChanges(cwd: string, message: string, laneEnv?: Record<string, string>, laneIndex?: number): void;
 /**
  * Get current commit SHA
+ * @param cwd - Working directory
+ * @param laneEnv - Optional lane env overrides for git spawn
+ * @param laneIndex - Optional lane index; if laneEnv not provided, reads env file from disk
  */
-export declare function getCurrentSha(cwd: string): string;
+export declare function getCurrentSha(cwd: string, laneEnv?: Record<string, string>, laneIndex?: number): string;
 /**
  * Check if there are uncommitted changes
+ * @param cwd - Working directory
+ * @param laneEnv - Optional lane env overrides for git spawn
+ * @param laneIndex - Optional lane index; if laneEnv not provided, reads env file from disk
  */
-export declare function hasUncommittedChanges(cwd: string): boolean;
+export declare function hasUncommittedChanges(cwd: string, laneEnv?: Record<string, string>, laneIndex?: number): boolean;
 export interface ResetToRemoteBranchResult {
     success: boolean;
     targetBranch: string;
@@ -155,5 +199,7 @@ export declare const _internals: {
     getGitRepositoryStatus: typeof getGitRepositoryStatus;
     resetToRemoteBranch: typeof resetToRemoteBranch;
     resetToMainAfterMerge: typeof resetToMainAfterMerge;
+    spawnSync: typeof __spawnSyncSeam.spawnSync;
+    readLaneEnvFileFromDiskSync: typeof readLaneEnvFileFromDiskSync;
 };
 export {};

package/dist/git/index.d.ts

@@ -4,6 +4,10 @@ export interface PRWorkflowOptions {
     title: string;
     body?: string;
     branch?: string;
+    /** Optional lane env overrides for git spawns. */
+    laneEnv?: Record<string, string>;
+    /** Optional lane index; used to read env file from disk if laneEnv not provided. */
+    laneIndex?: number;
 }
 export interface PRWorkflowResult {
     success: boolean;
@@ -18,5 +22,5 @@ export declare function runPRWorkflow(cwd: string, options: PRWorkflowOptions):
 /**
  * Generate evidence summary without creating PR
  */
-export declare function prepareEvidence(cwd: string): string;
+export declare function prepareEvidence(cwd: string): Promise<string>;
 export { isGhAvailable, isAuthenticated, isGitRepo, createBranch };

package/dist/git/pr.d.ts

@@ -1,4 +1,5 @@
 import * as child_process from 'node:child_process';
+import { readLaneEnvFileFromDiskSync } from './branch.js';
 export declare const GIT_TIMEOUT_MS = 30000;
 /**
  * Sanitize input string to prevent command injection
@@ -15,15 +16,41 @@ export declare function sanitizeInput(input: string): string;
  * - Bounded transient retry for ETIMEDOUT per AGENTS.md invariant 9
  */
 export declare function ghExec(args: string[], cwd: string): string;
+/**
+ * File-scoped indirection seam for spawnSync.
+ * Supports envOverrides so lane runtime profiles can inject env.
+ */
+declare const __spawnSyncSeam: {
+    spawnSync: (cmd: string, args: string[], options?: {
+        cwd?: string;
+        encoding?: BufferEncoding;
+        timeout?: number;
+        maxBuffer?: number;
+        windowsHide?: boolean;
+        stdio?: "pipe" | "ignore" | "inherit" | Array<"pipe" | "ignore" | "inherit">;
+        env?: Record<string, string | undefined>;
+        envOverrides?: Record<string, string | null>;
+    }) => child_process.SpawnSyncReturns<string | NonSharedBuffer>;
+};
 /**
  * Shared spawnSync wrapper with bounded ETIMEDOUT-only transient retry.
+ * Applies envOverrides to options.env before calling spawnSync.
  *
  * Mirrors the retry shape from ghExec (invariant 9):
  * - Up to MAX_TRANSIENT_RETRIES attempts with exponential backoff on ETIMEDOUT
  * - ENOENT and non-zero exit are thrown immediately (not retried)
  * - On success, returns the raw spawnSync result transparently
  */
-declare function spawnSyncWithTransientRetry(command: string, args: string[], options: child_process.SpawnSyncOptions): child_process.SpawnSyncReturns<string>;
+declare function spawnSyncWithTransientRetry(command: string, args: string[], options?: {
+    cwd?: string;
+    encoding?: BufferEncoding;
+    timeout?: number;
+    maxBuffer?: number;
+    windowsHide?: boolean;
+    stdio?: 'pipe' | 'ignore' | 'inherit' | Array<'pipe' | 'ignore' | 'inherit'>;
+    env?: Record<string, string | undefined>;
+    envOverrides?: Record<string, string | null>;
+}): child_process.SpawnSyncReturns<string>;
 /**
  * Execute gh CLI command asynchronously (non-blocking).
  * Used by background workers that must not block the event loop.
@@ -40,6 +67,8 @@ export declare const _internals: {
     ghExec: typeof ghExec;
     ghExecAsync: typeof ghExecAsync;
     spawnSyncWithTransientRetry: typeof spawnSyncWithTransientRetry;
+    spawnSync: typeof __spawnSyncSeam.spawnSync;
+    readLaneEnvFileFromDiskSync: typeof readLaneEnvFileFromDiskSync;
 };
 /**
  * Check if gh CLI is available
@@ -62,8 +91,12 @@ export declare function createPullRequest(cwd: string, title: string, body?: str
 }>;
 /**
  * Commit and push current changes
+ * @param cwd - Working directory
+ * @param message - Commit message
+ * @param laneEnv - Optional lane env overrides for git spawns
+ * @param laneIndex - Optional lane index; if laneEnv not provided, reads env file from disk
  */
-export declare function commitAndPush(cwd: string, message: string): void;
+export declare function commitAndPush(cwd: string, message: string, laneEnv?: Record<string, string>, laneIndex?: number): Promise<void>;
 export interface PRStatusResult {
     number: number;
     state: 'OPEN' | 'CLOSED' | 'MERGED';

package/dist/hooks/delegation-gate/worktree-isolation.d.ts

@@ -8,9 +8,46 @@
  * Extracted from delegation-gate.ts (FR-003) for modularity.
  * The _internals seam allows test injection of worktree operations.
  */
-import type { PluginConfig } from '../../config';
+import type { PluginConfig, WorktreeIsolationConfig } from '../../config';
 import type { WorktreeHandle } from '../../worktree';
 import { attemptMergeBackFromDirty, cleanupOrphanedBranches, postMergeCleanup, provisionWorktree, removeWorktree, startupOrphanRecovery } from '../../worktree';
+/**
+ * FR-201: Per-lane runtime profile injected into spawned child processes.
+ *
+ * Produced at lane provisioning time and written as `.swarm/lanes/{laneIndex}.env`
+ * (KEY=VAL format, one per line) so any child process spawned inside the lane
+ * can source it to get lane-specific PORT, TMPDIR, cache redirects, etc.
+ *
+ * The profile is computed from the resolved WorktreeIsolationConfig.runtime_isolation:
+ * - PORT = (port_base ?? 0) + laneIndex * port_stride
+ * - env_overrides merged verbatim
+ * - cache_redirects mapped to env vars
+ */
+export interface LaneRuntimeProfile {
+    /** 0-based lane index used for port and env derivation. */
+    laneIndex: number;
+    /** Absolute path to the provisioned worktree. */
+    worktreePath: string;
+    /** Env var overrides for this lane (includes PORT after derivation). */
+    envOverrides: Record<string, string>;
+}
+/**
+ * Parses a Lean Turbo laneId (e.g. "lane-3") and returns its 0-based index.
+ * Returns 0 for unparseable ids.
+ */
+export declare function parseLeanLaneIndex(laneId: string): number;
+/**
+ * FR-201 SC-122: Computes the per-lane runtime profile from the resolved runtime_isolation config.
+ *
+ * Derives:
+ * - PORT = (port_base ?? 0) + laneIndex * port_stride
+ * - Derives PORT from port_base + lane_index * port_stride (when port_base is set)
+ * - Merges env_overrides — explicit caller values win over derived PORT
+ * - Merges cache_redirects (base → lane-suffixed-path mapped to env vars; wins over env_overrides)
+ *
+ * Returns undefined when runtime_isolation is disabled (zero behavior change).
+ */
+export declare function computeLaneRuntimeProfile(runtime: WorktreeIsolationConfig['runtime_isolation'], laneIndex: number, worktreePath: string): LaneRuntimeProfile | undefined;
 export declare const MAX_TRACKED_STANDARD_WORKTREE_CALLS = 256;
 export interface StandardWorktreeDispatch {
     callID: string;
@@ -19,11 +56,54 @@ export interface StandardWorktreeDispatch {
     planTaskId?: string;
     handle: WorktreeHandle;
     mergeStrategy: 'merge' | 'rebase' | 'cherry-pick';
+    /** FR-201: 0-based lane index for runtime profile derivation. */
+    laneIndex: number;
+}
+export interface AwaitingMergeRecord {
+    callID: string;
+    parentSessionID: string;
+    taskId: string;
+    planTaskId?: string;
+    branch: string;
+    worktreePath: string;
+    mergeStrategy: 'merge' | 'rebase' | 'cherry-pick';
+    queuedAt: number;
 }
+/** Map keyed by callID. Lanes waiting for or in the middle of merge-back. */
+export declare const awaitingMergeByCallID: Map<string, AwaitingMergeRecord>;
 export declare const standardWorktreeByCallID: Map<string, StandardWorktreeDispatch>;
 export declare const standardWorktreeSerializationSessions: Set<string>;
+/**
+ * FR-104 SC-111/SC-112: Per-session state tracking for serialization release.
+ * Maps sessionID → serialization state for that session.
+ */
+interface SessionSerializationState {
+    sessionID: string;
+    /** Date.now() when the session was first added to standardWorktreeSerializationSessions */
+    serializedAt: number;
+    /**
+     * Count of successful dispatches (merge-back completed with 'merged') from this
+     * session since it entered serialized mode.
+     */
+    successfulDispatchesSince: number;
+}
 export declare function resetStandardWorktreeIsolationState(): void;
+/**
+ * FR-104 SC-111/SC-112: Check whether a serialized session has met its release conditions
+ * (either enough successful dispatches have completed, or the TTL has expired).
+ * If so, release it from serialized mode.
+ */
+export declare function checkStandardWorktreeSerializationRelease(sessionID: string, config: WorktreeIsolationConfig): void;
+/**
+ * FR-104 SC-113: Add a session to the serialization set.
+ * When the set is at capacity, evicts the oldest entry whose session has NO
+ * in-flight dispatch — never evict an actively-dispatching session.
+ * If ALL 256 entries are in-flight, refuses the new entry and logs a warning
+ * rather than silently breaking isolation.
+ */
+declare function rememberStandardWorktreeSerializationSession(sessionID: string): boolean;
 export declare function sanitizeWorktreeTaskId(raw: string): string;
+export declare function resolveWorktreeIsolationConfig(config: PluginConfig): WorktreeIsolationConfig;
 export declare function precreateStandardWorktreeSession(args: {
     config: PluginConfig;
     directory: string;
@@ -33,8 +113,31 @@ export declare function precreateStandardWorktreeSession(args: {
     planTaskId?: string;
     description?: string;
     outputArgs: Record<string, unknown>;
+    /** Scope to materialize into the lane for durability across restart (FR-102). */
+    scope?: {
+        taskId: string;
+        files: string[];
+    };
 }): Promise<void>;
-export declare function finishStandardWorktreeDispatch(directory: string, dispatch: StandardWorktreeDispatch): Promise<void>;
+export declare function finishStandardWorktreeDispatch(directory: string, dispatch: StandardWorktreeDispatch, config?: PluginConfig, 
+/**
+ * Optional callID for cleanup of awaitingMergeByCallID. When omitted,
+ * derived from dispatch.callID (for backward compatibility with test callers
+ * that pass StandardWorktreeDispatch objects directly).
+ */
+callID?: string): Promise<void>;
+/**
+ * FR-201: Read and parse a lane runtime profile from disk.
+ *
+ * Reads `<worktree>/.swarm/lanes/{laneIndex}.env` (KEY=VALUE format, one per line).
+ * - Skips blank lines and lines starting with `#` (comments).
+ * - Skips malformed lines (no `=` separator).
+ * - Validates each key with `isValidEnvKey`; rejects and skips invalid keys.
+ * - Returns an empty record when the file does not exist.
+ *
+ * Exposed via _internals for testability (no mock.module leakage).
+ */
+export declare function readLaneEnvFileFromDisk(worktreePath: string, laneIndex: number): Promise<Record<string, string>>;
 /**
  * _internals seam for test injection of worktree operations.
  * Tests set these entries on delegation-gate's _internals (which proxies
@@ -45,6 +148,19 @@ export declare const _internals: {
     removeWorktree: typeof removeWorktree;
     attemptMergeBackFromDirty: typeof attemptMergeBackFromDirty;
     postMergeCleanup: typeof postMergeCleanup;
+    /** FR-201: read lane runtime profile from disk for spawn injection. */
+    readLaneEnvFileFromDisk: typeof readLaneEnvFileFromDisk;
+    /** FR-104: exposes serializationStateBySessionID for test setup (SC-111/SC-112/SC-113). */
+    serializationStateBySessionID: Map<string, SessionSerializationState>;
+    /**
+     * FR-104 SC-113: exposes the FIFO eviction function for direct test invocation.
+     * Tests use this to exercise the cap-check logic without going through the
+     * full precreateStandardWorktreeSession path.
+     */
+    rememberStandardWorktreeSerializationSession: typeof rememberStandardWorktreeSerializationSession;
+    /** FR-105 SC-115: exposes awaitingMergeByCallID for test setup. */
+    awaitingMergeByCallID: Map<string, AwaitingMergeRecord>;
     startupOrphanRecovery: typeof startupOrphanRecovery;
     cleanupOrphanedBranches: typeof cleanupOrphanedBranches;
 };
+export {};

package/dist/hooks/delegation-gate/worktree-merge-status.d.ts

@@ -34,6 +34,14 @@ export interface WorktreeMergeFailure {
     stage: string;
     /** Human-readable detail surfaced in the Rule 2 skip warning. */
     message: string;
+    /** Worktree path where the lane is preserved after a failed/partial merge. */
+    worktreePath?: string;
+    /** Branch name of the lane. */
+    branch?: string;
+    /** Timestamp (Date.now()) when the lane entered merge-back. */
+    queuedAt?: number;
+    /** Timestamp (Date.now()) when merge-back completed (success or failure). */
+    completedAt?: number;
 }
 declare function getDurableStatusPath(projectDir?: string): string;
 /**
@@ -70,6 +78,15 @@ export declare function clearWorktreeMergeStatus(taskId: string | undefined): vo
  * On first read after plugin restart, loads from durable storage.
  */
 export declare function getWorktreeMergeFailure(taskId: string): WorktreeMergeFailure | undefined;
+/**
+ * Iterate all worktree merge failures. Used by /swarm lanes to surface
+ * conflicted lanes that are NOT in awaitingMergeByCallID (i.e., merge
+ * has completed with partial/failed outcome).
+ */
+export declare function getAllWorktreeMergeFailures(): IterableIterator<[
+    string,
+    WorktreeMergeFailure
+]>;
 /**
  * @internal test seam. Use `resetForTest()` in afterEach to isolate tests
  * that set durableStatusPath via `initDurableStatusPath`.

package/dist/hooks/init-orphan-recovery-advisory.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Init Orphan Recovery Advisory Hook (FR-103 SC-108)
+ *
+ * At plugin init, `cleanupOrphanedBranches` is called to reclaim orphaned worktrees
+ * and branches. Any warnings or errors (state-unreadable conditions) are written
+ * to `<directory>/.swarm/advisories/init-orphan-recovery.json`.
+ *
+ * This hook runs in the `messagesTransform` chain (before `guardrailsHooks.messagesTransform`)
+ * and surfaces those advisories to the architect on their NEXT TURN.
+ *
+ * Advisory file format:
+ * ```json
+ * {
+ *   "initTimestamp": "<ISO timestamp>",
+ *   "warnings": ["warning message 1", "warning message 2"],
+ *   "errors": [{ "branch": "swarm-lane/sess/lane", "error": "detail" }],
+ *   "reclaimed": { "removedBranches": [], "prunedWorktrees": true }
+ * }
+ * ```
+ *
+ * The file is deleted after consumption (best-effort) so repeated turns don't re-surface.
+ */
+export interface InitOrphanAdvisory {
+    initTimestamp: string;
+    warnings: string[];
+    errors: Array<{
+        branch: string;
+        error: string;
+    }>;
+    reclaimed: {
+        removedBranches: string[];
+        removedWorktrees: string[];
+        prunedWorktrees: boolean;
+    };
+}
+/**
+ * Creates a messagesTransform hook that surfaces init orphan recovery advisories
+ * on the architect's first turn after plugin init.
+ *
+ * @param directory - Project root directory (for .swarm/advisories path)
+ * @returns A hook object with a messagesTransform handler
+ */
+export declare function createInitOrphanRecoveryAdvisoryHook(directory: string): {
+    messagesTransform: (input: Record<string, never>, output: {
+        messages?: Array<{
+            info: {
+                role: string;
+                agent?: string;
+                sessionID?: string;
+            };
+            parts: Array<{
+                type?: string;
+                text?: string;
+                [key: string]: unknown;
+            }>;
+        }>;
+    }) => Promise<void>;
+};