opencode-swarm 7.192.1 → 7.192.2

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

@@ -138,6 +138,14 @@ export interface AwaitingMergeRecord {
 export declare const awaitingMergeByCallID: Map<string, AwaitingMergeRecord>;
 export declare const standardWorktreeByCallID: Map<string, StandardWorktreeDispatch>;
 export declare const standardWorktreeSerializationSessions: Set<string>;
+export declare const laneChildSessionAgents: Map<string, string>;
+export declare function recordLaneChildSession(sessionId: string, agent: string): void;
+/**
+ * Refuse a Task dispatch whose `task_id` resumes a lane child session the
+ * plugin created for a DIFFERENT agent. Resuming the same agent's session
+ * stays allowed; ids the plugin did not create are not judged here.
+ */
+export declare function assertTaskIdNotForeignLaneSession(args: Record<string, unknown> | undefined): void;
 /**
  * FR-104 SC-111/SC-112: Per-session state tracking for serialization release.
  * Maps sessionID → serialization state for that session.
@@ -167,6 +175,33 @@ interface CleanupStandardWorktreeResult {
     cleanedBranch: boolean;
     preservedRecoveryLane: boolean;
 }
+/**
+ * How long a lane dispatch waits for the worktree lifecycle lock.
+ *
+ * A holder can keep the lock across a recovery-lane session.create, bounded by
+ * `worktree.session_create_timeout_ms` (plus the settle grace), and the
+ * stale-lane cleanup after it. The wait therefore follows that budget plus a
+ * margin. Up to a 30s session.create budget (the default) it is capped so
+ * that the wait, this dispatch's own session.create, its settle grace and the
+ * provisioning work still fit in the host hook budget (10s at the default):
+ * a dispatch that overruns the hook is abandoned mid-provisioning, while a
+ * dispatch that stops here fails cleanly with STANDARD_WORKTREE_LIFECYCLE_BUSY.
+ * Above 30s there is no room left and the wait stays at its 10s floor, so the
+ * worst case exceeds the hook budget (61s at a 31s budget, 90s at 60s): a
+ * session.create budget that long is itself what overruns the hook.
+ */
+declare function resolveWorktreeLifecycleLockWaitMs(sessionCreateTimeoutMs: number): number;
+/**
+ * Acquire the worktree lifecycle lock, retrying within `waitMs`.
+ *
+ * The lock is held across the collision check (a git spawn) and the owner
+ * write, by every lane being provisioned and by init orphan recovery.
+ * `tryAcquireLock` alone gives up after about 310ms (5 retries, 10ms→500ms
+ * backoff, no jitter), so parallel coder dispatches that provision lanes at
+ * the same moment hard-stopped each other. Retry with jitter until the lock
+ * is free or the bounded wait is spent.
+ */
+declare function acquireWorktreeLifecycleLockWithin(directory: string, taskId: string, waitMs: number): ReturnType<typeof tryAcquireLock>;
 export declare function getStandardWorktreeDegradationReason(sessionID: string): {
     reason: string;
     at: number;
@@ -411,6 +446,11 @@ export declare const _internals: {
     /** Background launch durability fallback: tag ownership without racing the child. */
     preserveBackgroundWorktreeOwnershipForCallId: typeof preserveBackgroundWorktreeOwnershipForCallId;
     tryAcquireWorktreeLifecycleLock: typeof tryAcquireLock;
+    acquireWorktreeLifecycleLockWithin: typeof acquireWorktreeLifecycleLockWithin;
+    /** Bounded wait for the lifecycle lock, derived from the session-create budget. */
+    resolveWorktreeLifecycleLockWaitMs: typeof resolveWorktreeLifecycleLockWaitMs;
+    now: () => number;
+    sleep: (ms: number) => Promise<void>;
     recordWorktreeProvisioningOwner: typeof recordWorktreeProvisioningOwner;
     removeWorktreeProvisioningOwner: typeof removeWorktreeProvisioningOwner;
     lookupWorktreeRecoveryAuthoritiesByTask: typeof lookupWorktreeRecoveryAuthoritiesByTask;

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

@@ -51,6 +51,18 @@ export declare function getPendingCoderScope(directory: string, taskId: string):
  * circular import `state.ts ↔ delegation-gate.ts`. Called by `resetSwarmState`.
  */
 export declare function clearPendingCoderScope(): void;
+/**
+ * Whether Turbo may skip the Stage A re-delegation block for `taskId`.
+ *
+ * Tier 3 is defined by the files a task touches (security-sensitive paths,
+ * src/parallel/tier3-classifier.ts), the rule update_task_status already
+ * applies to Turbo's Stage B bypass. The gate used to guess it from the task
+ * id (`startsWith('3.')`): every phase-3 task was treated as Tier 3 and a
+ * security-sensitive task in any other phase was bypassed. Only a task whose
+ * planned `files_touched` are known and contain no Tier 3 path is bypassable;
+ * an unknown task, an empty file list or an unreadable plan is not.
+ */
+declare function turboMayBypassTask(directory: string, taskId: string): Promise<boolean>;
 /**
  * Issue #1151: OpenCode v1.16.2 background subagents.
  *
@@ -539,6 +551,7 @@ export declare const _internals: {
     buildParallelExecutionGuidance: typeof buildParallelExecutionGuidance;
     extractTaskFileDirectives: typeof extractTaskFileDirectives;
     loadPlanJsonOnly: typeof loadPlanJsonOnly;
+    turboMayBypassTask: typeof turboMayBypassTask;
     recordPendingDelegationForBackground: typeof import("../background/pending-delegations.js").recordPendingDelegationDetailed;
     writeDelegationFallbackForBackground: typeof import("../background/pending-delegations.js").writeDelegationFallback;
     reserveBackgroundCoderSlotForDispatch: typeof import("../background/pending-delegations.js").reserveBackgroundCoderSlot;

package/dist/hooks/extractors.d.ts

@@ -63,6 +63,8 @@ export declare function extractPatterns(contextContent: string, maxChars?: numbe
  * never suppress the summary — the honest active phase is reported instead.
  */
 export declare function extractCurrentPhaseFromPlan(plan: Plan): string | null;
+/** The sanitized `Phase N: name [STATUS]` label for one phase of the plan. */
+export declare function extractPhaseLabelFromPlan(plan: Plan, phaseId: number): string | null;
 /**
  * Parse the stable numeric phase id embedded in a stored phase label.
  *

package/dist/hooks/guardrails/index.d.ts

@@ -12,7 +12,9 @@ import { resolveEpicGateTaskAttribution } from '../../epic/gate-policy';
 import { assessSandboxEnforcement, getExecutor } from '../../sandbox/executor';
 import { dcCheckJunctionCreation } from './destructive-command';
 import { getMostRecentAssistantText, getProviderFailureFingerprint, isTransientProviderFailureText } from './messages-transform';
+import { resolveParallelGateTaskAttribution } from './parallel-gate-attribution';
 export declare const _internals: {
+    resolveParallelGateTaskAttribution: typeof resolveParallelGateTaskAttribution;
     extractSwarmIdFromAgentName: typeof extractSwarmIdFromAgentName;
     getSwarmAgents: typeof getSwarmAgents;
     getMostRecentAssistantText: typeof getMostRecentAssistantText;

package/dist/hooks/guardrails/parallel-gate-attribution.d.ts

@@ -0,0 +1,10 @@
+export type ParallelGateAttribution = {
+    kind: 'none';
+} | {
+    kind: 'task';
+    taskId: string;
+} | {
+    kind: 'unattributable';
+    message: string;
+};
+export declare function resolveParallelGateTaskAttribution(directory: string, sessionID: string, files: readonly string[] | null): Promise<ParallelGateAttribution>;