opencode-swarm 7.110.2 → 7.112.0

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

@@ -9,6 +9,7 @@
  * The _internals seam allows test injection of worktree operations.
  */
 import type { PluginConfig, WorktreeIsolationConfig } from '../../config';
+import { bunSpawn } from '../../utils/bun-compat';
 import type { WorktreeHandle } from '../../worktree';
 import { attemptMergeBackFromDirty, cleanupOrphanedBranches, postMergeCleanup, provisionWorktree, removeWorktree, startupOrphanRecovery } from '../../worktree';
 /**
@@ -107,6 +108,38 @@ declare function rememberStandardWorktreeSerializationSession(sessionID: string)
 export declare function sanitizeWorktreeTaskId(raw: string): string;
 import { resolveWorktreeIsolationConfig } from '../../config/worktree-isolation-config';
 export { resolveWorktreeIsolationConfig };
+/**
+ * FR-001b SC-004: Runs `git worktree list --porcelain` and checks whether
+ * ANY registered worktree has a lane branch for the given taskId (regardless
+ * of which session owns it).
+ *
+ * The detection pattern matches both current `swarm/lane/<sessionId>/<taskId>`
+ * and legacy `swarm-lane/<sessionId>/<taskId>` branch formats.
+ *
+ * Returns collision info if any lane for this taskId is found registered in
+ * an active worktree. Does NOT check whether the worktree path is valid on
+ * disk — only whether the branch is checked out somewhere.
+ *
+ * @param taskId       - Task ID to detect collisions for.
+ * @param directory    - Project root (git working tree).
+ * @param sessionId    - Current session ID (used only to populate ownerSessionId
+ *                       in the collision result; NOT used for collision detection).
+ */
+export declare function preProvisionCollisionCheck(taskId: string, directory: string, _sessionId: string): Promise<{
+    collision: boolean;
+    existingBranch?: string;
+    ownerSessionId?: string;
+    worktreePath?: string;
+}>;
+/**
+ * FR-001b SC-005: Returns true when `branchName`'s embedded session ID matches
+ * `expectedSessionId`.
+ *
+ * Uses `extractSessionId` (merge.ts) to parse the branch name. Supports both
+ * legacy `swarm-lane/<sessionId>/<id>` and current `swarm/lane/<sessionId>/<id>`
+ * patterns.
+ */
+export declare function isLaneOwnedByCurrentSession(branchName: string, expectedSessionId: string): boolean;
 export declare function precreateStandardWorktreeSession(args: {
     config: PluginConfig;
     directory: string;
@@ -122,6 +155,68 @@ export declare function precreateStandardWorktreeSession(args: {
         files: string[];
     };
 }): Promise<void>;
+/**
+ * FR-001c: Preserves dirty work in a worktree before cleanup on denial or cancellation.
+ *
+ * Detects dirty state, auto-commits with a descriptive message, tags the commit,
+ * and returns the commit hash so the work is recoverable from the reflog.
+ *
+ * @returns Three distinct outcomes:
+ *   - `{ outcome: 'clean', preserved: false }` — worktree was clean; nothing to preserve.
+ *   - `{ outcome: 'preserved', preserved: true, ref: <hash> }` — dirty AND commit succeeded.
+ *   - `{ outcome: 'preserve-failed', preserved: false, error: <msg> }` — dirty AND commit/tag failed.
+ */
+export declare function preserveDirtyWorktreeForCallId(callID: string, reason: 'denied' | 'cancelled', _directory: string, _worktree_dir?: string): Promise<{
+    outcome: 'clean' | 'preserved' | 'preserve-failed';
+    preserved: false | true;
+    ref?: string;
+    error?: string;
+}>;
+/**
+ * FR-001b SC-004: Preserves dirty worktree state at a known worktree path.
+ *
+ * This is the path-based counterpart of `preserveDirtyWorktreeForCallId` for the
+ * pre-provision collision fallback path where the callID is no longer tracked in
+ * any map (dispatch was GC'd). It runs the same git status → add → commit → tag
+ * sequence on a direct worktreePath.
+ *
+ * @param worktreePath - Absolute path to the worktree directory.
+ * @param branchName - Branch name (used only for advisory messages).
+ * @param reason - Preservation reason: 'denied' (pre-provision collision) or 'cancelled'.
+ * @param directory - Project root for git commands.
+ * @param worktree_dir - Optional worktree-dir override.
+ * @returns Preservation result matching preserveDirtyWorktreeForCallId's shape.
+ */
+export declare function preserveDirtyWorktreeAtPath(worktreePath: string, branchName: string, reason: 'denied' | 'cancelled', _directory: string, _worktree_dir?: string): Promise<{
+    outcome: 'clean' | 'preserved' | 'preserve-failed';
+    preserved: false | true;
+    ref?: string;
+    error?: string;
+}>;
+/**
+ * FR-001a: Unconditionally cleans up a standard worktree dispatch's resources.
+ *
+ * Called at the end of every dispatch outcome (success, denial, cancellation)
+ * to ensure no worktree or branch is left behind.
+ *
+ * @param callID - The callID of the dispatch to clean up.
+ * @param reason - The outcome reason: 'success', 'denied', or 'cancelled'.
+ * @param directory - The project root (required for git worktree/branch commands).
+ * @param worktree_dir - Configured worktree-dir override.
+ */
+export declare function cleanupStandardWorktreeForCallId(callID: string, reason: 'success' | 'denied' | 'cancelled', directory: string, worktree_dir?: string): Promise<void>;
+/**
+ * FR-001a: Abort an in-flight standard worktree dispatch.
+ *
+ * Called when a dispatch needs to be cancelled before merge-back completes.
+ * Handles the case where the worktree was never provisioned (no entry in
+ * standardWorktreeByCallID) by returning early with a no-op diagnostic.
+ *
+ * @param callID - The callID of the dispatch to abort.
+ * @param reason - The abort reason: 'denied' or 'cancelled'.
+ * @param directory - The project root (required for git worktree/branch commands).
+ */
+export declare function abortStandardWorktreeDispatch(callID: string, reason: 'denied' | 'cancelled', directory: string): Promise<void>;
 export declare function finishStandardWorktreeDispatch(directory: string, dispatch: StandardWorktreeDispatch, config?: PluginConfig, 
 /**
  * Optional callID for cleanup of awaitingMergeByCallID. When omitted,
@@ -165,4 +260,19 @@ export declare const _internals: {
     awaitingMergeByCallID: Map<string, AwaitingMergeRecord>;
     startupOrphanRecovery: typeof startupOrphanRecovery;
     cleanupOrphanedBranches: typeof cleanupOrphanedBranches;
+    /** FR-001a: cleanup entry point for finishStandardWorktreeDispatch. */
+    cleanupStandardWorktreeForCallId: typeof cleanupStandardWorktreeForCallId;
+    /** FR-001c: preserves dirty worktree state before cleanup on denial/cancellation. */
+    preserveDirtyWorktreeForCallId: typeof preserveDirtyWorktreeForCallId;
+    /** FR-001b SC-004: path-based dirty worktree preservation for stale-lane fallback. */
+    preserveDirtyWorktreeAtPath: typeof preserveDirtyWorktreeAtPath;
+    /** FR-001a: abort entry point for in-flight dispatches. */
+    abortStandardWorktreeDispatch: typeof abortStandardWorktreeDispatch;
+    standardWorktreeByCallID: Map<string, StandardWorktreeDispatch>;
+    /** FR-001b SC-004: pre-provision collision check. */
+    preProvisionCollisionCheck: typeof preProvisionCollisionCheck;
+    /** FR-001b SC-005: lane ownership validation. */
+    isLaneOwnedByCurrentSession: typeof isLaneOwnedByCurrentSession;
+    /** FR-001b: bunSpawn — exposed for test injection so collision check can be mocked. */
+    bunSpawn: typeof bunSpawn;
 };

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

@@ -83,6 +83,22 @@ interface MessageWithParts {
     parts: MessagePart[];
 }
 declare function resolveDelegatedPlanTaskId(args: Record<string, unknown>, knownPlanTaskIds?: ReadonlySet<string>): string | null;
+/**
+ * Parses structured per-task verdict lines from agent dispatch output.
+ *
+ * Recognized formats:
+ *   [REVIEWED] | task-2.1 | APPROVED | ...
+ *   [TESTED] | task-2.1 | PASS | ...
+ *   [REVIEWED] | 2.1 | APPROVED | ...   (bare task ID without prefix)
+ *
+ * Returns a Map from task ID to verdict string (e.g. "APPROVED", "REJECTED", "PASS", "FAIL").
+ * Only task IDs matching strict task ID format (N.M or N.M.P) are included.
+ * Lines that don't match the pattern are silently ignored.
+ *
+ * @param outputText - Raw text output from the agent dispatch
+ * @returns Map of taskId -> verdict string
+ */
+export declare function parsePerTaskVerdicts(outputText: string): Map<string, string>;
 declare function buildParallelExecutionGuidance(directory: string | undefined, sessionID: string, session: AgentSessionState): Promise<string | null>;
 /**
  * Resolves the correct task ID for evidence recording by chaining:
@@ -107,6 +123,7 @@ declare function resolveEvidenceTaskId(args: Record<string, unknown> | undefined
 export declare const _internals: {
     resolveEvidenceTaskId: typeof resolveEvidenceTaskId;
     resolveDelegatedPlanTaskId: typeof resolveDelegatedPlanTaskId;
+    parsePerTaskVerdicts: typeof parsePerTaskVerdicts;
     buildParallelExecutionGuidance: typeof buildParallelExecutionGuidance;
     loadPlanJsonOnly: typeof loadPlanJsonOnly;
     resetStandardWorktreeIsolationState: typeof resetStandardWorktreeIsolationState;

package/dist/hooks/full-auto-intercept.d.ts

@@ -53,7 +53,7 @@ export declare function injectVerdictIntoMessages(messages: MessageWithParts[],
  * This function encapsulates the critic invocation and event writing flow.
  * The critic response is awaited before writing the event to events.jsonl.
  */
-export declare function dispatchCriticAndWriteEvent(directory: string, architectOutput: string, criticContext: string, criticModel: string, escalationType: 'phase_completion' | 'question', interactionCount: number, deadlockCount: number, oversightAgentName: string, sessionID?: string): Promise<CriticDispatchResult>;
+export declare function dispatchCriticAndWriteEvent(directory: string, architectOutput: string, criticContext: string, criticModel: string, escalationType: 'phase_completion' | 'question', interactionCount: number, deadlockCount: number, oversightAgentName: string, sessionID?: string, maxDispatchRetries?: number, maxConsecutiveDispatchFailures?: number): Promise<CriticDispatchResult>;
 /**
  * Creates the full-auto intercept hook factory.
  *