opencode-swarm 7.133.0 → 7.134.1

package/dist/cli/worktree-collision-ownership-c4bdnjtx.js

@@ -0,0 +1,221 @@
+// @bun
+import {
+  scanWorktreeProvisioningOwnersForRecovery
+} from "./index-b4z7s917.js";
+import {
+  scanWorktreeMergeFailuresForRecovery
+} from "./index-b8zgtz81.js";
+import {
+  scanDelegationFallbacksForRecovery,
+  scanDelegationsForRecovery
+} from "./index-y3v1404y.js";
+import"./index-2ghkk9ve.js";
+import"./index-fsrp8wp3.js";
+import"./index-5nybajn9.js";
+import"./index-7g4c7s5r.js";
+import"./index-q2rrv0cy.js";
+import"./index-bpmtbmy9.js";
+import"./index-z6xqpmqg.js";
+import"./index-zjygnfay.js";
+import {
+  bunSpawn
+} from "./index-qe3v54nb.js";
+import"./index-zgwm4ryv.js";
+import"./index-a76rekgs.js";
+
+// src/hooks/delegation-gate/worktree-collision-ownership.ts
+import * as path2 from "path";
+
+// src/hooks/delegation-gate/worktree-ownership-tag.ts
+import * as fs from "fs";
+import * as path from "path";
+var OWNERSHIP_TAG_SCAN_TIMEOUT_MS = 2000;
+var MAX_OWNERSHIP_TAGS = 512;
+function decodeTagPart(value) {
+  if (!value || !/^[A-Za-z0-9_-]+$/.test(value))
+    return null;
+  const decoded = Buffer.from(value, "base64url").toString("utf8");
+  return decoded && Buffer.from(decoded, "utf8").toString("base64url") === value ? decoded : null;
+}
+async function scanBackgroundWorktreeOwnershipTagsForRecovery(directory) {
+  try {
+    fs.statSync(path.join(directory, ".git"));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { status: "ok", owners: [] };
+    }
+    return {
+      status: "uncertain",
+      reason: `Git metadata could not be inspected: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  const proc = bunSpawn([
+    "git",
+    "-C",
+    directory,
+    "for-each-ref",
+    `--count=${MAX_OWNERSHIP_TAGS + 1}`,
+    "--format=%(refname:strip=2)%00%(objectname)",
+    "refs/tags/swarm-preserved-owner/"
+  ], {
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "ignore",
+    timeout: OWNERSHIP_TAG_SCAN_TIMEOUT_MS
+  });
+  try {
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      return {
+        status: "uncertain",
+        reason: `ownership tag scan exited ${exitCode}`
+      };
+    }
+    const lines = (await proc.stdout.text()).split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    if (lines.length > MAX_OWNERSHIP_TAGS) {
+      return {
+        status: "uncertain",
+        reason: `ownership tag scan exceeded the ${MAX_OWNERSHIP_TAGS}-tag safety bound`
+      };
+    }
+    const owners = [];
+    for (const line of lines) {
+      const [tag, ref, ...extra] = line.split("\x00");
+      const segments = tag?.split("/") ?? [];
+      const sessionId = decodeTagPart(segments[1] ?? "");
+      const laneId = decodeTagPart(segments[2] ?? "");
+      const callDigest = segments[3];
+      if (extra.length > 0 || segments.length !== 4 || segments[0] !== "swarm-preserved-owner" || !sessionId || !laneId || !callDigest || !/^[0-9a-f]{12}$/.test(callDigest) || !ref || !/^[0-9a-f]{40,64}$/i.test(ref)) {
+        return {
+          status: "uncertain",
+          reason: `malformed background ownership tag entry "${tag ?? ""}"`
+        };
+      }
+      owners.push({ sessionId, laneId, callDigest, ref });
+    }
+    return { status: "ok", owners };
+  } catch (error) {
+    return {
+      status: "uncertain",
+      reason: `ownership tag scan failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  } finally {
+    try {
+      proc.kill();
+    } catch {}
+  }
+}
+
+// src/hooks/delegation-gate/worktree-collision-ownership.ts
+function normalizedPath(value) {
+  const resolved = path2.normalize(path2.resolve(value));
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function descriptorCoordinateMatch(descriptor, identity) {
+  const branchMatches = descriptor.branchName === identity.branchName;
+  const pathMatches = normalizedPath(descriptor.worktreePath) === normalizedPath(identity.worktreePath);
+  if (!branchMatches && !pathMatches)
+    return "none";
+  if (!branchMatches || !pathMatches || descriptor.parentSessionId !== identity.parentSessionId || descriptor.taskId !== identity.taskId) {
+    return "uncertain";
+  }
+  return "exact";
+}
+function isProvenSettled(record) {
+  const settlement = record.coderSettlement;
+  return settlement?.state === "settled" && settlement.outcome?.kind === "standard-worktree" && (settlement.outcome.result === "merged" || settlement.outcome.result === "unchanged");
+}
+function classifyRecord(record, identity, ownerKind) {
+  if (!record.worktree)
+    return null;
+  const coordinates = descriptorCoordinateMatch(record.worktree, identity);
+  if (coordinates === "none")
+    return null;
+  if (coordinates === "uncertain") {
+    return {
+      status: "uncertain",
+      reason: `${ownerKind} background owner has conflicting identity for branch "${identity.branchName}"`
+    };
+  }
+  if (isProvenSettled(record))
+    return null;
+  const lifecycle = record.coderSettlement?.state === "preserved" ? "preserved" : "active";
+  return {
+    status: "protected",
+    ownerKind,
+    lifecycle,
+    reason: `${ownerKind} background owner ${record.correlationId} is ${record.status}` + (record.coderSettlement ? ` with coder settlement ${record.coderSettlement.state}` : " without a settled workspace outcome")
+  };
+}
+async function inspectStandardWorktreeCollisionOwnership(identity) {
+  const provisioning = scanWorktreeProvisioningOwnersForRecovery(identity.directory);
+  if (provisioning.status === "uncertain")
+    return provisioning;
+  for (const owner of provisioning.owners) {
+    const sameSession = owner.parentSessionId === identity.parentSessionId || owner.worktreeSessionId === identity.parentSessionId;
+    if (!sameSession)
+      continue;
+    if (owner.schemaVersion === 1 || owner.taskId === identity.taskId) {
+      return {
+        status: "protected",
+        ownerKind: "provisioning",
+        lifecycle: "active",
+        reason: owner.schemaVersion === 1 ? `legacy provisioning owner ${owner.callID} cannot disprove ownership of this same-session lane` : `provisioning owner ${owner.callID} is active for task ${identity.taskId}`
+      };
+    }
+  }
+  const fallback = await scanDelegationFallbacksForRecovery(identity.directory);
+  if (fallback.status === "uncertain")
+    return fallback;
+  for (const artifact of fallback.owners) {
+    const classified = classifyRecord(artifact.record, identity, "fallback");
+    if (classified)
+      return classified;
+  }
+  const primary = scanDelegationsForRecovery(identity.directory);
+  if (primary.status === "uncertain")
+    return primary;
+  for (const record of primary.owners) {
+    const classified = classifyRecord(record, identity, "primary");
+    if (classified)
+      return classified;
+  }
+  const tags = await scanBackgroundWorktreeOwnershipTagsForRecovery(identity.directory);
+  if (tags.status === "uncertain")
+    return tags;
+  for (const owner of tags.owners) {
+    if (owner.sessionId === identity.parentSessionId && owner.laneId === identity.taskId) {
+      return {
+        status: "protected",
+        ownerKind: "ownership-tag",
+        lifecycle: "preserved",
+        reason: `durable ownership tag ${owner.callDigest} preserves this same-session lane`
+      };
+    }
+  }
+  const mergeStatus = scanWorktreeMergeFailuresForRecovery(identity.directory);
+  if (mergeStatus.status === "uncertain")
+    return mergeStatus;
+  for (const [, failure] of mergeStatus.failures) {
+    const branchMatches = failure.branch === identity.branchName;
+    const pathMatches = typeof failure.worktreePath === "string" && normalizedPath(failure.worktreePath) === normalizedPath(identity.worktreePath);
+    if (!branchMatches && !pathMatches)
+      continue;
+    if (!branchMatches || !pathMatches) {
+      return {
+        status: "uncertain",
+        reason: `merge-status owner has conflicting identity for branch "${identity.branchName}"`
+      };
+    }
+    return {
+      status: "protected",
+      ownerKind: "merge-status",
+      lifecycle: "preserved",
+      reason: `merge-status records ${failure.outcome} at stage ${failure.stage}`
+    };
+  }
+  return { status: "unowned" };
+}
+export {
+  inspectStandardWorktreeCollisionOwnership
+};

package/dist/evaluation/contracts.d.ts

@@ -278,9 +278,9 @@ export declare const PromotionDecisionV1Schema: z.ZodObject<{
     runId: z.ZodString;
     decidedAt: z.ZodISODateTime;
     status: z.ZodEnum<{
-        reject: "reject";
         inconclusive: "inconclusive";
         accept: "accept";
+        reject: "reject";
     }>;
     reasons: z.ZodArray<z.ZodString>;
     baseline: z.ZodObject<{

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/guardrails/messages-transform.d.ts

@@ -39,6 +39,16 @@ type ChatMessageLike = {
  * never contained, making the guard permanently inert.
  */
 export declare const RUNAWAY_OUTPUT_ADVISORY_MARKER = "Model is generating analysis without taking action";
+/**
+ * Bound a set of advisory strings to a total byte budget, keeping the latest
+ * (dropping oldest from the front). Returns the kept entries and whether any
+ * were dropped. Never drops below a single entry (a single oversized advisory
+ * is kept verbatim rather than rendered empty).
+ */
+export declare function boundAdvisoryBytes(advisories: string[], maxBytes: number): {
+    kept: string[];
+    truncated: boolean;
+};
 export declare function getMostRecentAssistantText(messages: ChatMessageLike[]): string;
 export declare function isTransientProviderFailureText(text: string): boolean;
 export declare function getProviderFailureFingerprint(text: string): string;

package/dist/hooks/guardrails/stored-input-args.d.ts

@@ -5,6 +5,12 @@
  * input args by callID, used by guardrails for delegation detection
  * and exposed via safe accessor helpers.
  */
+/**
+ * Max stored callID->args entries before the oldest-inserted is evicted
+ * (invariant 8). Larger than the per-session cap because callIDs are per
+ * tool-call, not per-session.
+ */
+export declare const MAX_STORED_INPUT_ARGS = 2000;
 /**
  * Retrieves stored input args for a given callID.
  * Used by other hooks (e.g., delegation-gate) to access tool input args.

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 {};