opencode-swarm 7.133.0 → 7.134.0

package/dist/evaluation/public-api.d.ts

@@ -31,7 +31,7 @@ export declare const evaluationV1: ((options: EvaluateCandidateV1Options) => Pro
         decisionId: string;
         runId: string;
         decidedAt: string;
-        status: "reject" | "inconclusive" | "accept";
+        status: "inconclusive" | "accept" | "reject";
         reasons: string[];
         baseline: {
             baselineRunId: string;

package/dist/hooks/delegation-gate/worktree-collision-ownership.d.ts

@@ -0,0 +1,28 @@
+export interface StandardWorktreeCollisionIdentity {
+    directory: string;
+    parentSessionId: string;
+    taskId: string;
+    branchName: string;
+    worktreePath: string;
+}
+export type StandardWorktreeCollisionOwnership = {
+    status: 'unowned';
+} | {
+    status: 'protected';
+    ownerKind: 'primary' | 'fallback' | 'provisioning' | 'ownership-tag' | 'merge-status';
+    lifecycle: 'active' | 'preserved';
+    reason: string;
+} | {
+    status: 'uncertain';
+    reason: string;
+};
+/**
+ * Strict restart-time ownership classification for one exact same-session
+ * collision. Scanner order is part of the safety contract:
+ *
+ * provisioning -> fallback -> primary -> ownership tag -> merge status
+ *
+ * Fallback precedes primary because promotion publishes primary before removing
+ * fallback; this ordering cannot observe ownership absent from both stores.
+ */
+export declare function inspectStandardWorktreeCollisionOwnership(identity: StandardWorktreeCollisionIdentity): Promise<StandardWorktreeCollisionOwnership>;

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

@@ -9,9 +9,12 @@
  * The _internals seam allows test injection of worktree operations.
  */
 import type { PluginConfig, WorktreeIsolationConfig } from '../../config';
+import { tryAcquireLock } from '../../parallel/file-locks';
 import { bunSpawn } from '../../utils/bun-compat';
 import type { WorktreeHandle } from '../../worktree';
 import { attemptMergeBackFromDirty, cleanupOrphanedBranches, postMergeCleanup, provisionWorktree, removeWorktree, startupOrphanRecovery } from '../../worktree';
+import type { DirtyMergeOptions, MergeOperationProvenance } from '../../worktree/merge';
+import { recordWorktreeProvisioningOwner, removeWorktreeProvisioningOwner } from './worktree-provisioning-owner';
 /**
  * FR-201: Per-lane runtime profile injected into spawned child processes.
  *
@@ -62,6 +65,37 @@ export interface StandardWorktreeDispatch {
     /** Configured worktree-dir override, so cleanup trusts the same base. */
     worktree_dir?: string;
 }
+export interface StandardWorktreeSettlementOptions extends Pick<DirtyMergeOptions, 'operationId' | 'resume' | 'onBeforeMerge'> {
+    /**
+     * Awaited after Git reports success (including reconciled success) and before
+     * destructive worktree/branch cleanup. A rejection preserves the lane.
+     */
+    onMerged?: (result: StandardWorktreeMergedSettlement) => Promise<void>;
+}
+export interface StandardWorktreeMergedSettlement {
+    outcome: 'merged';
+    strategy: string;
+    autoCommitted: boolean;
+    cleaned: boolean;
+    reconciled: boolean;
+    provenance?: MergeOperationProvenance;
+}
+export interface StandardWorktreePartialSettlement {
+    outcome: 'partial';
+    stage: string;
+    message: string;
+    autoCommitted: boolean;
+    cleaned: boolean;
+    conflictFiles?: string[];
+    provenance?: MergeOperationProvenance;
+}
+export interface StandardWorktreeFailedSettlement {
+    outcome: 'failed';
+    stage: string;
+    message: string;
+    provenance?: MergeOperationProvenance;
+}
+export type StandardWorktreeSettlementResult = StandardWorktreeMergedSettlement | StandardWorktreePartialSettlement | StandardWorktreeFailedSettlement;
 export interface AwaitingMergeRecord {
     callID: string;
     parentSessionID: string;
@@ -130,6 +164,7 @@ export declare function preProvisionCollisionCheck(taskId: string, directory: st
     existingBranch?: string;
     ownerSessionId?: string;
     worktreePath?: string;
+    uncertainty?: string;
 }>;
 /**
  * FR-001b SC-005: Returns true when `branchName`'s embedded session ID matches
@@ -140,6 +175,13 @@ export declare function preProvisionCollisionCheck(taskId: string, directory: st
  * patterns.
  */
 export declare function isLaneOwnedByCurrentSession(branchName: string, expectedSessionId: string): boolean;
+declare function inspectStandardWorktreeCollisionOwnership(identity: {
+    directory: string;
+    parentSessionId: string;
+    taskId: string;
+    branchName: string;
+    worktreePath: string;
+}): Promise<import("./worktree-collision-ownership").StandardWorktreeCollisionOwnership>;
 export declare function precreateStandardWorktreeSession(args: {
     config: PluginConfig;
     directory: string;
@@ -155,6 +197,19 @@ export declare function precreateStandardWorktreeSession(args: {
         files: string[];
     };
 }): Promise<void>;
+/**
+ * Create a durable ownership tag without touching an in-flight background
+ * coder's index or working tree. This is used only when both correlation
+ * stores fail after launch: committing dirty files at that point could race
+ * the still-running child, while a tag plus the durable merge-status record
+ * makes restart cleanup fail closed.
+ */
+export declare function preserveBackgroundWorktreeOwnershipForCallId(callID: string): Promise<{
+    outcome: 'preserved' | 'preserve-failed' | 'not-found';
+    tag?: string;
+    ref?: string;
+    error?: string;
+}>;
 /**
  * FR-001c: Preserves dirty work in a worktree before cleanup on denial or cancellation.
  *
@@ -223,7 +278,7 @@ export declare function finishStandardWorktreeDispatch(directory: string, dispat
  * derived from dispatch.callID (for backward compatibility with test callers
  * that pass StandardWorktreeDispatch objects directly).
  */
-callID?: string): Promise<void>;
+callID?: string, settlement?: StandardWorktreeSettlementOptions): Promise<StandardWorktreeSettlementResult>;
 /**
  * FR-201: Read and parse a lane runtime profile from disk.
  *
@@ -264,6 +319,11 @@ export declare const _internals: {
     cleanupStandardWorktreeForCallId: typeof cleanupStandardWorktreeForCallId;
     /** FR-001c: preserves dirty worktree state before cleanup on denial/cancellation. */
     preserveDirtyWorktreeForCallId: typeof preserveDirtyWorktreeForCallId;
+    /** Background launch durability fallback: tag ownership without racing the child. */
+    preserveBackgroundWorktreeOwnershipForCallId: typeof preserveBackgroundWorktreeOwnershipForCallId;
+    tryAcquireWorktreeLifecycleLock: typeof tryAcquireLock;
+    recordWorktreeProvisioningOwner: typeof recordWorktreeProvisioningOwner;
+    removeWorktreeProvisioningOwner: typeof removeWorktreeProvisioningOwner;
     /** 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. */
@@ -271,6 +331,8 @@ export declare const _internals: {
     standardWorktreeByCallID: Map<string, StandardWorktreeDispatch>;
     /** FR-001b SC-004: pre-provision collision check. */
     preProvisionCollisionCheck: typeof preProvisionCollisionCheck;
+    /** Restart-safe durable owner classification for a colliding lane. */
+    inspectStandardWorktreeCollisionOwnership: typeof inspectStandardWorktreeCollisionOwnership;
     /** FR-001b SC-005: lane ownership validation. */
     isLaneOwnedByCurrentSession: typeof isLaneOwnedByCurrentSession;
     /** FR-001b: bunSpawn — exposed for test injection so collision check can be mocked. */

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

@@ -43,6 +43,13 @@ export interface WorktreeMergeFailure {
     /** Timestamp (Date.now()) when merge-back completed (success or failure). */
     completedAt?: number;
 }
+export type WorktreeMergeRecoveryScanResult = {
+    status: 'ok';
+    failures: Array<[string, WorktreeMergeFailure]>;
+} | {
+    status: 'uncertain';
+    reason: string;
+};
 declare function getDurableStatusPath(projectDir?: string): string;
 /**
  * Load the durable file into the in-memory map. The clear+repopulate is
@@ -52,6 +59,13 @@ declare function getDurableStatusPath(projectDir?: string): string;
  */
 declare function loadDurableStatus(statusPath: string): void;
 declare function saveDurableStatus(statusPath: string): void;
+/**
+ * Strict recovery-only read of durable merge ownership. The normal registry
+ * stays fail-open for plugin loadability, while destructive orphan cleanup
+ * receives an explicit uncertainty result for read, parse, schema, or cap
+ * failures.
+ */
+export declare function scanWorktreeMergeFailuresForRecovery(projectDir: string): WorktreeMergeRecoveryScanResult;
 /**
  * Initialize the durable status path for this project and load existing
  * status from disk. Called from `createDelegationGateHook` before any coder

package/dist/hooks/delegation-gate/worktree-ownership-tag.d.ts

@@ -0,0 +1,19 @@
+export interface BackgroundWorktreeOwnershipTag {
+    sessionId: string;
+    laneId: string;
+    callDigest: string;
+    ref: string;
+}
+export type BackgroundWorktreeOwnershipTagScan = {
+    status: 'ok';
+    owners: BackgroundWorktreeOwnershipTag[];
+} | {
+    status: 'uncertain';
+    reason: string;
+};
+/**
+ * Strict, bounded ownership-tag scan shared by init recovery and restart
+ * collision classification. Any malformed or unreadable entry is uncertainty:
+ * destructive cleanup must never infer absence from incomplete ownership data.
+ */
+export declare function scanBackgroundWorktreeOwnershipTagsForRecovery(directory: string): Promise<BackgroundWorktreeOwnershipTagScan>;

package/dist/hooks/delegation-gate/worktree-provisioning-owner.d.ts

@@ -0,0 +1,30 @@
+export declare const WORKTREE_LIFECYCLE_LOCK_FILE = ".swarm/locks/init-orphan-recovery.lock";
+export interface WorktreeProvisioningOwner {
+    schemaVersion: 1 | 2;
+    callID: string;
+    parentSessionId: string;
+    worktreeSessionId: string;
+    /** Added in v2 so restart collision checks can identify the exact lane. */
+    taskId?: string;
+    createdAt: number;
+}
+export type WorktreeProvisioningOwnerScan = {
+    status: 'ok';
+    owners: WorktreeProvisioningOwner[];
+} | {
+    status: 'uncertain';
+    reason: string;
+};
+/**
+ * Publish a provisional owner before a standard worktree can be created.
+ * Callers hold the shared orphan-recovery lifecycle lock during this atomic
+ * write, closing the gap between recovery's owner snapshot and provisioning.
+ */
+export declare function recordWorktreeProvisioningOwner(directory: string, input: Omit<WorktreeProvisioningOwner, 'schemaVersion' | 'createdAt'>): WorktreeProvisioningOwner;
+/** Remove a provisional owner only after durable ownership or cleanup exists. */
+export declare function removeWorktreeProvisioningOwner(directory: string, callID: string): boolean;
+/**
+ * Strict recovery scan. Anything except ENOENT is uncertainty because omitting
+ * one marker could allow destructive cleanup to race a live worktree.
+ */
+export declare function scanWorktreeProvisioningOwnersForRecovery(directory: string): WorktreeProvisioningOwnerScan;

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

@@ -4,6 +4,7 @@
  * Warns the architect when coder delegations are too large or batched.
  * Uses experimental.chat.messages.transform to provide non-blocking guidance.
  */
+import type { BackgroundDelegationRecord } from '../background/pending-delegations.js';
 import type { PluginConfig } from '../config';
 import { loadPlanJsonOnly } from '../plan/manager';
 import type { AgentSessionState } from '../state';
@@ -47,11 +48,12 @@ export declare function clearPendingCoderScope(): void;
  * `Task` with `background=true` (gated upstream by
  * `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true`) returns a "running" placeholder
  * immediately and completes later via synthetic parent injection. The delegation gate
- * treats a `Task` result as completion, so a background swarm delegation would advance
- * Stage B / record gate evidence before any review/test output exists. Until swarm can
- * correlate the deferred completion safely (a separate, spike-gated PR), background
- * swarm delegations are fail-closed-blocked. We do NOT silently coerce `background` to
- * false — the unsupported capability is surfaced explicitly.
+ * treats a foreground `Task` result as completion, so the running placeholder must be
+ * tracked without terminal side effects. When the opt-in is enabled, trusted deferred
+ * completion ingestion performs exact parent correlation, workspace settlement, and
+ * role-appropriate state/evidence updates. With the opt-in disabled (the default while
+ * upstream remains experimental), background swarm delegations are fail-closed-blocked.
+ * We do NOT silently coerce `background` to false.
  */
 export declare const SWARM_BACKGROUND_TASK_BLOCKED_MESSAGE: string;
 /**
@@ -324,12 +326,18 @@ export declare const _internals: {
     parsePerTaskVerdicts: typeof parsePerTaskVerdicts;
     buildParallelExecutionGuidance: typeof buildParallelExecutionGuidance;
     loadPlanJsonOnly: typeof loadPlanJsonOnly;
+    recordPendingDelegationForBackground: typeof import("../background/pending-delegations.js").recordPendingDelegation;
+    writeDelegationFallbackForBackground: typeof import("../background/pending-delegations.js").writeDelegationFallback;
+    reserveBackgroundCoderSlotForDispatch: typeof import("../background/pending-delegations.js").reserveBackgroundCoderSlot;
+    bindBackgroundCoderReservationForDispatch: typeof import("../background/pending-delegations.js").bindBackgroundCoderReservation;
+    releaseBackgroundCoderReservationForDispatch: typeof import("../background/pending-delegations.js").releaseBackgroundCoderReservation;
     resetStandardWorktreeIsolationState: typeof resetStandardWorktreeIsolationState;
     PLAN_CRITIC_TASK_SIGNALS: readonly ["critic-gate", "plan critic", "review plan", "review the plan", "plan.md", "approve the plan", "plan approval"];
     provisionWorktree: typeof _wtiInternals.provisionWorktree;
     removeWorktree: typeof _wtiInternals.removeWorktree;
     attemptMergeBackFromDirty: typeof _wtiInternals.attemptMergeBackFromDirty;
     postMergeCleanup: typeof _wtiInternals.postMergeCleanup;
+    preserveBackgroundWorktreeOwnershipForCallId: typeof _wtiInternals.preserveBackgroundWorktreeOwnershipForCallId;
 };
 /**
  * Creates the experimental.chat.messages.transform hook for delegation gating.
@@ -358,4 +366,5 @@ export declare function createDelegationGateHook(config: PluginConfig, directory
         childSessionID: string;
     }) => Promise<void>;
     sessionEnded: (sessionID: string, includeOwnedChildren?: boolean) => void;
+    backgroundCompletionClaimed: (record: BackgroundDelegationRecord) => void;
 };

package/dist/hooks/index.d.ts

@@ -4,7 +4,7 @@ export { createCompactionCustomizerHook } from './compaction-customizer';
 export { createContextBudgetHandler } from './context-budget';
 export { createContextCapsuleInjectHook } from './context-capsule-inject';
 export { createCuratorLLMDelegate } from './curator-llm-factory';
-export { createDelegationGateHook } from './delegation-gate';
+export { createDelegationGateHook, outputLooksLikeBackgroundRunning, } from './delegation-gate';
 export { createDelegationSanitizerHook } from './delegation-sanitizer';
 export { createDelegationTrackerHook } from './delegation-tracker';
 export { extractCurrentPhase, extractCurrentPhaseFromPlan, extractCurrentTask, extractCurrentTaskFromPlan, extractDecisions, extractIncompleteTasks, extractIncompleteTasksFromPlan, extractPatterns, } from './extractors';

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

@@ -15,8 +15,19 @@
  * reads the advisory file at session-start and pushes messages to pendingAdvisoryMessages.
  */
 import * as fs from 'node:fs';
+import { scanDelegationFallbacksForRecovery, scanDelegationsForRecovery } from '../background/pending-delegations.js';
 import { isLocked, listActiveLocks, tryAcquireLock } from '../parallel/file-locks';
 import { removeWorktree } from '../worktree/core';
+import { scanWorktreeMergeFailuresForRecovery } from './delegation-gate/worktree-merge-status';
+import { scanWorktreeProvisioningOwnersForRecovery } from './delegation-gate/worktree-provisioning-owner';
+type OwnershipTagSessionScan = {
+    status: 'ok';
+    sessionIds: string[];
+} | {
+    status: 'uncertain';
+    reason: string;
+};
+declare function listOwnershipTagSessionIds(directory: string): Promise<OwnershipTagSessionScan>;
 /**
  * Lock file path for the init orphan recovery advisory lock.
  * advisory-only — signals that another process may be actively using the repo.
@@ -33,6 +44,11 @@ export declare const _internals: {
     isLocked: typeof isLocked;
     listActiveLocks: typeof listActiveLocks;
     tryAcquireLock: typeof tryAcquireLock;
+    listOwnershipTagSessionIds: typeof listOwnershipTagSessionIds;
+    scanDelegationsForRecovery: typeof scanDelegationsForRecovery;
+    scanDelegationFallbacksForRecovery: typeof scanDelegationFallbacksForRecovery;
+    scanWorktreeMergeFailuresForRecovery: typeof scanWorktreeMergeFailuresForRecovery;
+    scanWorktreeProvisioningOwnersForRecovery: typeof scanWorktreeProvisioningOwnersForRecovery;
 };
 export interface InitOrphanRecoveryResult {
     attempted: boolean;
@@ -63,3 +79,4 @@ export interface InitOrphanRecoveryResult {
  * @returns Result object describing what was attempted and any warnings/diagnostics
  */
 export declare function runInitOrphanRecovery(directory: string): Promise<InitOrphanRecoveryResult>;
+export {};