opencode-swarm 7.152.1 → 7.153.1

package/dist/security/protected-path-policy.d.ts

@@ -0,0 +1,9 @@
+export interface ProtectedPathPolicyOptions {
+    includeDefaults?: boolean;
+    additional?: readonly string[];
+}
+export declare const DEFAULT_PROTECTED_PATH_PREFIXES: readonly [".github/workflows", ".github/CODEOWNERS", "src/sandbox", "src/hooks/guardrails", "src/security", "src/evaluation", "docs/releases", "tests/fixtures/evaluation"];
+export declare function normalizeProtectedPath(value: string): string;
+/** Central lexical policy; canonical containment remains caller-owned. */
+export declare function isPolicyProtectedPath(filePath: string, options?: ProtectedPathPolicyOptions): boolean;
+export declare function protectedRoots(projectRoot: string, additional?: readonly string[]): string[];

package/dist/security/write-authority.d.ts

@@ -0,0 +1,46 @@
+export type WriteAuthorityOrigin = 'autonomous' | 'optimizer_proposed' | 'critic_approved' | 'human_approved';
+export type WriteApprovalAction = 'skill_improve';
+export interface WriteApprovalRequest {
+    targetSessionId: string;
+    action: WriteApprovalAction;
+    candidateId: string;
+    candidateContentHash: string;
+    allowedPathDigest?: string;
+    generation?: number;
+}
+export interface WriteApprovalFactV1 extends WriteApprovalRequest {
+    v: 1;
+    id: string;
+    issuingSessionId: string;
+    issuedByCommand: 'approve-write';
+    issuedAt: string;
+    expiresAt: string;
+}
+export interface WriteAuthorityContext {
+    origin: WriteAuthorityOrigin;
+    fact?: WriteApprovalFactV1;
+}
+export declare function computeWriteApprovalHash(input: Record<string, unknown>): string;
+export declare function getCurrentWriteAuthority(): WriteAuthorityContext;
+export declare function withWriteAuthority<T>(context: WriteAuthorityContext, fn: () => Promise<T>): Promise<T>;
+export declare function buildHumanApprovedWriteAuthority(fact: WriteApprovalFactV1): WriteAuthorityContext;
+export declare function currentWriteAuthoritySatisfies(request: WriteApprovalRequest): boolean;
+export declare function formatApproveWriteCommand(request: WriteApprovalRequest): string;
+export declare function findWriteApprovalFact(args: {
+    directory: string;
+    request: WriteApprovalRequest;
+    now?: Date;
+}): Promise<WriteApprovalFactV1 | null>;
+export declare function issueWriteApprovalFact(args: {
+    directory: string;
+    request: WriteApprovalRequest;
+    issuingSessionId: string;
+    now?: Date;
+    ttlMs?: number;
+}): Promise<WriteApprovalFactV1>;
+export declare function consumeWriteApprovalFact(args: {
+    directory: string;
+    request: WriteApprovalRequest;
+    consumerSessionId: string;
+    now?: Date;
+}): Promise<WriteApprovalFactV1 | null>;

package/dist/services/diagnose-service.d.ts

@@ -1,6 +1,6 @@
 import { getExecutor } from '../sandbox/executor.js';
 export declare const _internals: {
-    detectSandboxCapability: () => Promise<import("../sandbox/capability-probe.js").SandboxCapability>;
+    detectSandboxCapability: () => Promise<import("../sandbox/capability-probe.js").SandboxCapabilityV1>;
     getSandboxExecutor: typeof getExecutor;
 };
 /**

package/dist/services/skill-generator.d.ts

@@ -100,6 +100,7 @@ export interface GenerateRequest {
     evaluate?: boolean;
     minConfidence?: number;
     minConfirmations?: number;
+    preview?: boolean;
 }
 export interface GenerateResult {
     written: Array<{
@@ -110,6 +111,7 @@ export interface GenerateResult {
         missingSourceKnowledgeIds?: string[];
         preserved: boolean;
         evaluation?: SkillEvaluationResult;
+        content?: string;
     }>;
     skipped: Array<{
         slug: string;

package/dist/services/skill-improver.d.ts

@@ -19,6 +19,7 @@
 import type { EnrichmentQuotaOptions } from '../hooks/knowledge-curator.js';
 import type { KnowledgeEntryBase } from '../hooks/knowledge-types.js';
 import { type SkillImproverLLMDelegate } from '../hooks/skill-improver-llm-factory.js';
+import { type WriteApprovalRequest } from '../security/write-authority.js';
 import { type AutoApplyResult, regenerateSkill } from './skill-generator.js';
 import { type QuotaWindow } from './skill-improver-quota.js';
 export interface SkillImproverConfigInput {
@@ -56,10 +57,20 @@ export interface SkillImproveRequest {
     evaluateDrafts?: boolean;
     /** Consolidation callers stage proposals only and must never auto-apply. */
     allowAutoApply?: boolean;
+    /** Exact approval-phase proposal body returned by a prior challenge. */
+    approvedCandidateContent?: string;
 }
 export interface SkillImproveResult {
     ran: boolean;
     reason?: string;
+    approvalRequired?: {
+        request?: WriteApprovalRequest;
+        command?: string;
+        candidateContent?: string;
+        candidateContentChars?: number;
+        candidateContentTokenEstimate?: number;
+        allowedPaths?: string[];
+    };
     proposalPath?: string;
     source?: 'llm' | 'deterministic_fallback';
     quota: {
@@ -100,6 +111,59 @@ export interface SkillImproveResult {
     /** #1234 Part 3D: critic-gated auto-apply of proposals in full-auto mode. */
     autoApply?: AutoApplyResult;
 }
+export declare const SKILL_IMPROVER_APPROVAL_CANDIDATE_ID = "skill_improve_request";
+export declare const MAX_APPROVED_CANDIDATE_CONTENT_CHARS = 64000;
+interface SkillImproverDraftWrite {
+    slug: string;
+    path: string;
+    content: string;
+    sourceKnowledgeIds: string[];
+    missingSourceKnowledgeIds?: string[];
+}
+interface SkillImproverDraftSourceStampTarget {
+    knowledgePath: string;
+    ids: string[];
+    slug: string;
+    draftGeneratedSkillPath: string;
+    updatedAt: string;
+}
+export declare function buildSkillImproverApprovalRequest(input: {
+    sessionId?: string;
+    candidateContent: string;
+    allowedPaths: string[];
+    candidateId?: string;
+    generation?: number;
+}): WriteApprovalRequest | null;
+export interface PreparedSkillImproverApprovalCandidate {
+    directory: string;
+    sessionId: string;
+    now: Date;
+    source: 'llm' | 'deterministic_fallback';
+    model?: string;
+    proposalPath: string;
+    proposalContent: string;
+    allowedPaths: string[];
+    candidateContent: string;
+    draftWrites: SkillImproverDraftWrite[];
+    draftSourceStamps: SkillImproverDraftSourceStampTarget[];
+    request: WriteApprovalRequest;
+    quota: {
+        date: string;
+        calls_used: number;
+        max_calls: number;
+    };
+    quotaWindow: QuotaWindow;
+    maxCalls: number;
+    maxCallsPerDay: number;
+    released: boolean;
+}
+type SkillImproverApprovalPreparation = {
+    kind: 'result';
+    result: SkillImproveResult;
+} | {
+    kind: 'prepared';
+    prepared: PreparedSkillImproverApprovalCandidate;
+};
 interface InventorySnapshot {
     knowledge: {
         swarm: number;
@@ -152,6 +216,10 @@ export interface StaleSkillReconciliationResult {
 export declare function reconcileStaleActiveSkills(directory: string, options?: {
     dryRun?: boolean;
 }): Promise<StaleSkillReconciliationResult>;
+export declare function prepareSkillImproverApprovalCandidate(req: SkillImproveRequest): Promise<SkillImproverApprovalPreparation>;
+export declare function prepareApprovedSkillImproverCandidateWrite(req: SkillImproveRequest): Promise<SkillImproverApprovalPreparation>;
+export declare function releasePreparedSkillImproverApprovalCandidate(prepared: PreparedSkillImproverApprovalCandidate): Promise<SkillImproveResult['quota']>;
+export declare function writeApprovedSkillImproverCandidate(prepared: PreparedSkillImproverApprovalCandidate): Promise<SkillImproveResult>;
 export declare function runSkillImprover(req: SkillImproveRequest): Promise<SkillImproveResult>;
 export declare const _internals: {
     runSkillImprover: typeof runSkillImprover;
@@ -159,6 +227,7 @@ export declare const _internals: {
     buildLLMProposalFrame: typeof buildLLMProposalFrame;
     buildSystemPrompt: typeof buildSystemPrompt;
     buildUserPrompt: typeof buildUserPrompt;
+    buildSkillImproverApprovalRequest: typeof buildSkillImproverApprovalRequest;
     gatherInventory: typeof gatherInventory;
     reconcileStaleActiveSkills: typeof reconcileStaleActiveSkills;
     regenerateSkill: typeof regenerateSkill;

package/dist/telemetry.d.ts

@@ -32,7 +32,7 @@ export type TelemetryEvent = 'session_started' | 'session_ended' | 'agent_activa
  * `prm_hard_stop` TRIGGER emitted by `src/prm/escalation.ts`. A trigger with
  * no matching delivery means the containment never reached the agent.
  */
- | 'prm_hard_stop_delivered' | 'agent_conflict_detected' | 'close_archive_result' | 'knowledge_receipt_transition' | 'knowledge_maintenance' | 'residue_health' | 'context_telemetry_health' | 'skill_usage_health' | 'core_events_health' | 'shell_audit_health';
+ | 'prm_hard_stop_delivered' | 'agent_conflict_detected' | 'close_archive_result' | 'knowledge_receipt_transition' | 'knowledge_maintenance' | 'residue_health' | 'context_telemetry_health' | 'skill_usage_health' | 'core_events_health' | 'shell_audit_health' | 'trajectory_health';
 /** Stable classification for how a reviewer-gate decision was established. */
 export type ReviewerGateEvidenceKind = 'genuine' | 'fallback' | 'data_quality' | 'block';
 /**
@@ -335,6 +335,26 @@ export declare const telemetry: {
         bytes: number;
         limit_bytes: number;
     }): void;
+    /**
+     * PRM session-trajectory store health (issue #2041): emitted on
+     * compaction, cleanup sweeps, and (cooldown-bounded) lock-skipped appends
+     * for the bounded `.swarm/trajectories/` store. Counts ONLY — no session
+     * identifiers, no filesystem paths, no trajectory content — matching the
+     * observability contract's no-content-in-metrics rule.
+     * `dropped_count` discloses entries folded by compaction (line budget or
+     * the sovereign byte ceiling) and files removed by cleanup; `skipped_lock_count`
+     * discloses appends skipped because the per-file cross-process lock stayed
+     * busy (best-effort store: telemetry loss is preferred over corruption).
+     */
+    trajectoryHealth(data: {
+        trigger: "compaction" | "cleanup" | "append_skip";
+        retained_count: number;
+        dropped_count: number;
+        corrupt_count: number;
+        skipped_lock_count: number;
+        bytes: number;
+        limit_bytes: number;
+    }): void;
     /**
      * Issue #2063 C2 — the PRM hard-stop DENIAL was actually delivered to the
      * agent (thrown by the guardrails `toolBefore` consumer). `prm_hard_stop`

package/dist/tools/dispatch-lanes.d.ts

@@ -203,8 +203,30 @@ export interface CollectLaneResultsResult {
      * or any lane's state.
      */
     pending_liveness?: PrWorkflowPendingLaneLiveness[];
+    /**
+     * Issue #2381: identities of every lane that had NOT settled when this
+     * collection returned. Present whenever any lane is unsettled, INDEPENDENT of
+     * `include_pending` — a caller must never have to opt in to learn that work is
+     * still outstanding, and a wait budget expiring is not evidence the work died.
+     *
+     * Purely additive: `lane_results` filtering and every aggregate counter are
+     * unchanged, so existing consumers are unaffected.
+     */
+    pending_lanes?: CollectPendingLaneIdentity[];
     errors?: string[];
 }
+/**
+ * Issue #2381: minimal, stable identity of an unsettled lane. `output_ref` is
+ * carried when the record already has one (for example an `ingesting` lane whose
+ * artifact was written before settlement) so a caller can still recover partial
+ * output via `retrieve_lane_output` without a second collection.
+ */
+export interface CollectPendingLaneIdentity {
+    batch_id: string;
+    lane_id: string;
+    status: string;
+    output_ref?: string;
+}
 export interface SessionOps {
     create(args: {
         body?: {
@@ -341,6 +363,8 @@ export declare const _test_exports: {
     nextCollectPollInterval: typeof nextCollectPollInterval;
     promptHash: typeof promptHash;
     reserveCollectionLaneCallBudgets: typeof reserveCollectionLaneCallBudgets;
+    assembleCollectionDiagnostics: typeof assembleCollectionDiagnostics;
+    addLaneDiagnostic: typeof addLaneDiagnostic;
     isRetryableSessionCreateFailure: typeof isRetryableSessionCreateFailure;
     DispatchLanesArgsSchema: z.ZodObject<{
         lanes: z.ZodArray<z.ZodObject<{
@@ -451,6 +475,29 @@ export declare function executeDispatchLanes(args: unknown, directory: string, c
 export declare function executeDispatchLanesAsync(args: unknown, directory: string, context?: DispatchLanesExecutionContext): Promise<DispatchLanesAsyncResult>;
 export declare function executeCollectLaneResults(args: unknown, directory: string, context?: Pick<DispatchLanesExecutionContext, 'sessionID'>): Promise<CollectLaneResultsResult>;
 declare function isRetryableSessionCreateFailure(error: unknown): boolean;
+/**
+ * Issue #2381 (PR review follow-up): lane-keyed collection diagnostics.
+ *
+ * These were message-keyed `Set<string>`s, which forced clearing to match on the
+ * quoted lane label inside the message. Because entries embed host-derived error
+ * text, one lane's error could literally contain another lane's quoted id and
+ * clear it — a missing diagnostic, never a wrong lane state, but a real residue.
+ * Keying by lane removes the class outright: clearing is an exact `delete`, and
+ * no message content can ever influence another lane's entries.
+ */
+type LaneDiagnostics = Map<string, Set<string>>;
+/**
+ * Assemble `result.errors` from the three diagnostic channels.
+ *
+ * Extracted as a pure function so the starvation invariant is testable without
+ * having to drive the poll loop into a real timeout flood: each channel is
+ * bounded INDEPENDENTLY, so no channel can crowd out another no matter how one
+ * of them behaves. The lane-keyed channels lead because they carry the per-lane
+ * cause an operator acts on; `hostTimeouts` is the coarser "a host call ran out
+ * of budget" signal and takes its own slice.
+ */
+declare function assembleCollectionDiagnostics(hostTimeouts: ReadonlySet<string>, settleFailureLogs: LaneDiagnostics, collectionResourceFailures: LaneDiagnostics): string[];
+declare function addLaneDiagnostic(diagnostics: LaneDiagnostics, laneLabel: string, message: string): void;
 declare function consumePrReviewReceiptAppendFailureLog(loggedFailures: Set<string>, parentSessionId: string, correlationId: string): boolean;
 /**
  * Issue #2349: a terminal error read off the last assistant message of a lane

package/dist/tools/repo-graph/query.d.ts

@@ -1,5 +1,5 @@
 import type { FreshnessProbe } from './freshness';
-import type { BlastRadiusResult, CallerReference, ContextPackResult, DeadExportsResult, FileOntology, FileReference, GraphHealthResult, GraphNode, LocalizationBlock, PackageBoundarySummary, RepoGraph, SymbolReference } from './types';
+import type { BlastRadiusResult, CallerReference, ContextPackResult, ContextPackSourceMode, DeadExportsResult, FileOntology, FileReference, GraphHealthResult, GraphNode, LocalizationBlock, PackageBoundarySummary, RepoGraph, SymbolReference } from './types';
 export declare function getGraphNode(graph: RepoGraph, input: string): GraphNode | undefined;
 export declare function resetQueryCache(): void;
 /**
@@ -49,6 +49,7 @@ export declare function getContextPack(graph: RepoGraph, file: string, symbol: s
     maxDepth?: number;
     maxTokens?: number;
     includeSource?: boolean;
+    sourceMode?: ContextPackSourceMode;
     directory?: string;
 }): ContextPackResult;
 export declare function getPackageBoundaries(graph: RepoGraph, topN?: number): PackageBoundarySummary[];

package/dist/tools/repo-graph/types.d.ts

@@ -286,6 +286,64 @@ export interface ContextPackSpan {
     text?: string;
     note?: string;
 }
+/**
+ * Source-text extraction mode for source-bearing context packs (issue #1533).
+ * `include_source` remains the sole gate; `source_mode` only refines what is
+ * extracted once source was requested.
+ *
+ * - `mixed` (default): body text for near spans (span mode 'full'), signature
+ *   text for periphery spans (span mode 'signature').
+ * - `body`: body text for every span with an export range.
+ * - `signature`: signature text for every span with an export range.
+ */
+export type ContextPackSourceMode = 'signature' | 'body' | 'mixed';
+/**
+ * A bounded source snippet with provenance (issue #1533). Emitted one per
+ * returned span that actually had text extracted; internal-symbol fallback
+ * spans produce no snippet.
+ *
+ * `mode` describes the returned text, independent of the owning span's
+ * traversal mode: 'full' = whole range text; 'signature' = signature-only
+ * extraction; 'summary' = body text line-capped at 80 lines.
+ *
+ * `hash` is the sha256 hex of the returned `text` — a content fingerprint.
+ * It is stable for a given source mode and file content; summary-mode hashes
+ * are cap-dependent by design because the text itself is truncated.
+ *
+ * `confidence` is a deterministic resolution-quality score in [0, 1]:
+ * 1.0 = the exact requested target symbol, 0.8 = a resolved neighbor with
+ * extracted text. Spans whose read failed or which lack an export range
+ * produce no snippet at all (their state surfaces via span.note, coverage,
+ * and warnings). It is NOT language grammar quality; issue #1532 (KG-11
+ * SymbolEdge v2) will replace this derivation with real edge confidence.
+ */
+export interface ContextPackSnippet {
+    file: string;
+    symbol: string;
+    startLine: number;
+    endLine: number;
+    mode: 'full' | 'signature' | 'summary';
+    text: string;
+    hash: string;
+    confidence: number;
+}
+/**
+ * Coverage accounting for a context pack (issue #1533).
+ *
+ * `unresolvedEdges` and `lowConfidenceEdges` count distinct destination
+ * SYMBOLS (keyed `file\0symbol`, collected at BFS first discovery), not edge
+ * instances — duplicate edges toward the same unresolved symbol count once.
+ * `lowConfidenceEdges` uses exactly the same predicate as the internal-symbol
+ * span fallback (destination file present, no own-property export range for
+ * the symbol), so coverage and spans can never disagree.
+ */
+export interface ContextPackCoverage {
+    reachedSymbols: number;
+    returnedSymbols: number;
+    omittedByBudget: number;
+    unresolvedEdges: number;
+    lowConfidenceEdges: number;
+}
 /**
  * Result of a context-pack query: the set of spans needed to understand
  * how a target symbol is used across the workspace.
@@ -308,6 +366,12 @@ export interface ContextPackResult {
     note?: string;
     /** Whether source text was embedded in spans (only present when include_source was requested). */
     sourceIncluded?: boolean;
+    /** Source snippets with provenance; only present when include_source was requested. */
+    snippets?: ContextPackSnippet[];
+    /** Reach/omission and edge-resolution accounting; present on every result. */
+    coverage?: ContextPackCoverage;
+    /** Bounded, deduplicated non-fatal warnings (budget omissions, read failures, containment). */
+    warnings?: string[];
 }
 export interface AskHit {
     file: string;

package/dist/tools/repo-graph.d.ts

@@ -26,6 +26,6 @@ export { extractFileOntology } from './repo-graph/ontology';
 export type { DeadExportsOptions } from './repo-graph/query';
 export { buildOntologyPreflightPacket, getBlastRadius, getCallers, getContextPack, getDeadExports, getDependencies, getFileOntology, getGraphHealth, getGraphNode, getImporters, getKeyFiles, getLocalizationContext, getPackageBoundaries, getSymbolConsumers, isGraphFresh, resetQueryCache, } from './repo-graph/query';
 export { getGraphPath, loadGraph, loadGraphSync, loadOrCreateGraph, saveGraph, saveIfDirty, } from './repo-graph/storage';
-export type { AskHit, AskOptions, AskResult, BlastRadiusResult, BuildWorkspaceGraphOptions, CallerReference, ContextPackResult, ContextPackSpan, ConventionFact, DataOperationFact, DeadExportCandidate, DeadExportsResult, FileOntology, FileReference, FileRole, FreshnessProbeState, GraphEdge, GraphExtractionFailure, GraphExtractorInputWitness, GraphHealthResult, GraphNode, GraphUnresolvedImport, LocalizationBlock, OntologyFinding, PackageBoundarySummary, RepoGraph, RepoGraphDiagnostics, RouteFact, RouteMethod, SecurityFact, SymbolEdge, SymbolEdgeEvidence, SymbolEdgeKind, SymbolEdgeResolution, SymbolIdentityKind, SymbolReference, } from './repo-graph/types';
+export type { AskHit, AskOptions, AskResult, BlastRadiusResult, BuildWorkspaceGraphOptions, CallerReference, ContextPackCoverage, ContextPackResult, ContextPackSnippet, ContextPackSourceMode, ContextPackSpan, ConventionFact, DataOperationFact, DeadExportCandidate, DeadExportsResult, FileOntology, FileReference, FileRole, FreshnessProbeState, GraphEdge, GraphExtractionFailure, GraphExtractorInputWitness, GraphHealthResult, GraphNode, GraphUnresolvedImport, LocalizationBlock, OntologyFinding, PackageBoundarySummary, RepoGraph, RepoGraphDiagnostics, RouteFact, RouteMethod, SecurityFact, SymbolEdge, SymbolEdgeEvidence, SymbolEdgeKind, SymbolEdgeResolution, SymbolIdentityKind, SymbolReference, } from './repo-graph/types';
 export { createEmptyGraph, GRAPH_SCHEMA_VERSION, inferPackageBoundary, isSchemaVersionAtLeast, normalizeGraphPath, REPO_GRAPH_FILENAME, updateGraphMetadata, } from './repo-graph/types';
 export { validateGraphEdge, validateGraphNode, validateWorkspace, } from './repo-graph/validation';

package/dist/tools/skill-improve.d.ts

@@ -9,8 +9,15 @@
  * Closes issue #629: lets users wire an expensive OpenRouter model and cap
  * its usage to e.g. 10 calls/day.
  */
+import { findWriteApprovalFact, formatApproveWriteCommand } from '../security/write-authority.js';
 import { createSwarmTool } from './create-tool.js';
+declare const writeAuthorityDependencies: {
+    findWriteApprovalFact: typeof findWriteApprovalFact;
+    formatApproveWriteCommand: typeof formatApproveWriteCommand;
+};
 export declare const skill_improve: ReturnType<typeof createSwarmTool>;
 export declare const _internals: {
     skill_improve: typeof skill_improve;
+    writeAuthorityDependencies: typeof writeAuthorityDependencies;
 };
+export {};

package/dist/utils/atomic-write.d.ts

@@ -131,6 +131,8 @@ export declare const MAX_ATOMIC_WRITE_BYTES: number;
 export interface AtomicWriteOptions {
     /** Skip the pre-rename fsync (tests / truly ephemeral data). */
     readonly skipFsync?: boolean;
+    /** File mode for the per-write temporary file before rename. */
+    readonly mode?: number;
     /**
      * Override the bounded-write cap (default MAX_ATOMIC_WRITE_BYTES). Exposed
      * so the bound itself is testable without allocating 256 MiB.

package/dist/utils/canonical-root.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Canonical project-root keying for session-scoped module state (issue #2041).
+ *
+ * The trajectory cache (src/prm/trajectory-store.ts), the step counters
+ * (src/hooks/trajectory-step-state.ts), and the logger's restart-seed gate
+ * (src/hooks/trajectory-logger.ts) are all process-global maps that a
+ * multi-root host can share through one plugin module instance. They must key
+ * by canonical root + session id, and they must agree on what "canonical"
+ * means: realpath resolves junction/symlink aliases (linked worktrees on
+ * Windows are junctions), `path.resolve` is the fallback for a root that does
+ * not exist yet, and Windows roots are case-folded because the filesystem is.
+ * A symlinked `.swarm` directory itself is already rejected by
+ * `validateSwarmPath`, so the aliasing this resolves lives strictly ABOVE
+ * `.swarm`. One shared implementation so the three maps cannot drift.
+ */
+/**
+ * Separator between canonical root and session id in composite keys.
+ * `String.fromCharCode(0)` rather than an escape literal so the source stays
+ * clean text (a literal NUL byte in source makes tooling treat the file as
+ * binary); NUL cannot appear in a path on any supported platform.
+ */
+export declare const SESSION_KEY_SEPARATOR: string;
+export declare function canonicalRootKey(directory: string): string;
+/** Composite map key: canonical root + NUL + session id. */
+export declare function compositeSessionKey(directory: string, sessionId: string): string;
+/**
+ * Suffix every root's key for a session ends with. Suffix-scan clear paths
+ * that legitimately lack a directory (the `/swarm reset` entry points) match
+ * all roots with this.
+ */
+export declare function sessionKeySuffix(sessionId: string): string;

package/dist/workflow/coder-settlement.d.ts

@@ -1,5 +1,6 @@
 import type { BackgroundTaskChangeContext, BackgroundWorktreeDescriptor } from '../background/pending-delegations.js';
 import { type TaskEvidence } from '../gate-evidence.js';
+import { removeWorktreeProvisioningOwner } from '../hooks/delegation-gate/worktree-provisioning-owner.js';
 import type { MergeOperationProvenance } from '../worktree/merge.js';
 import type { CoderSettlementWal } from './workflow-wal-schema.js';
 export interface CoderSettlementResult {
@@ -161,6 +162,7 @@ export declare function recoverStaleCoderSettlements(directory: string, options?
 }>;
 export declare const _internals: {
     liveDispatches: Set<string>;
+    removeWorktreeProvisioningOwner: typeof removeWorktreeProvisioningOwner;
     /**
      * Test seam for the lane-branch existence probe. Production reads it here,
      * so the #2236 fail-closed invariants — never mark a WAL terminal while the

package/dist/worktree/index.d.ts

@@ -1,5 +1,5 @@
 export type { AutoCommitSkip, AutoCommitSuccess, CleanCheckFailure, CleanCheckSuccess, CleanFailure, CleanSuccess, ProvisionFailure, ProvisionSuccess, RemoveFailure, RemoveSuccess, } from './core';
 export { _internals as coreInternals, assertCleanWorkingTree, autoCommitDirty, checkPathBudget, cleanUntrackedFiles, isCleanWorktree, isPathUnderSwarmWorktreeBase, makeWorktreeBranchName, provisionWorktree, removeWorktree, resolveWorktreeBaseDir, shortenWorktreePath, } from './core';
-export type { CleanupFailure, CleanupSuccess, ConflictHandlingError, ConflictInfo, DirtyMergeFailure, DirtyMergePartial, DirtyMergeSuccess, MergeConflict, MergeFailure, MergeSuccess, OrphanCleanupResult, StartupRecoveryResult, } from './merge';
-export { _internals as mergeInternals, attemptMergeBackFromDirty, cleanupOrphanedBranches, getMergeStrategy, handleMergeConflict, mergeLaneBranch, postMergeCleanup, pruneStaleWorktreeMetadata, scanRegisteredWorktreeLiveness, startupOrphanRecovery, } from './merge';
+export type { CleanupFailure, CleanupSuccess, ConflictHandlingError, ConflictInfo, DirtyMergeFailure, DirtyMergePartial, DirtyMergeSuccess, ImmutableMergeRecoveryCoordinates, ImmutableMergeRecoveryResult, MergeConflict, MergeFailure, MergeSuccess, OrphanCleanupResult, StartupRecoveryResult, } from './merge';
+export { _internals as mergeInternals, attemptMergeBackFromDirty, cleanupOrphanedBranches, getMergeStrategy, handleMergeConflict, mergeLaneBranch, postMergeCleanup, pruneStaleWorktreeMetadata, recoverMergeBackFromImmutableCoordinates, scanRegisteredWorktreeLiveness, startupOrphanRecovery, } from './merge';
 export * from './types';

package/dist/worktree/merge.d.ts

@@ -30,6 +30,8 @@ export declare const _internals: {
     cleanupOrphanedBranches: typeof cleanupOrphanedBranches;
     /** Test seam for startupOrphanRecovery — allows tests to intercept the recovery call. */
     startupOrphanRecovery: typeof startupOrphanRecovery;
+    /** Test seam for the dirty merge overlap preflight. */
+    captureMergeOverlapSnapshot: typeof captureMergeOverlapSnapshot;
     /** FR-001b: exposes extractSessionId for lane ownership validation. */
     extractSessionId: typeof extractSessionId;
     /**
@@ -156,6 +158,26 @@ export type MergeReconciliationResult = {
     landed: false;
     error?: string;
 };
+/**
+ * Immutable preserved-lane coordinates captured by the #2105 recovery
+ * authority. This path deliberately consumes exact object ids rather than a
+ * mutable branch ref, so a redispatch can recover the preserved lane even if
+ * the lane branch later advances, rewinds, or is renamed.
+ */
+export interface ImmutableMergeRecoveryCoordinates {
+    sourceBaseOid: string;
+    sourceHeadOid: string;
+    targetHeadOid: string;
+    strategy: MergeStrategy;
+}
+export type ImmutableMergeRecoveryResult = (MergeSuccess & {
+    sourceCommitOrder?: string[];
+    rewrittenCommitOrder?: string[];
+}) | (MergeConflict & {
+    sourceCommitOrder?: string[];
+}) | (MergeFailure & {
+    sourceCommitOrder?: string[];
+});
 export interface DirtyMergeOptions {
     /** Stable identifier allocated before the merge-back begins. */
     operationId?: string;
@@ -167,6 +189,20 @@ export interface DirtyMergeOptions {
      */
     onBeforeMerge?: (provenance: MergeOperationProvenance) => Promise<void>;
 }
+interface MergeOverlapSnapshot {
+    targetHead: string;
+    laneHead: string;
+    mergeBase: string;
+    indexDigest: string;
+    statusDigest: string;
+    incomingDigest: string;
+    overlapPaths: string[];
+}
+declare function captureMergeOverlapSnapshot(primaryDir: string, branchName: string): Promise<{
+    snapshot: MergeOverlapSnapshot;
+} | {
+    error: string;
+}>;
 export interface OrphanCleanupResult {
     removed: string[];
     skipped: string[];
@@ -219,6 +255,17 @@ export declare function getMergeStrategy(config: {
  * @returns Discriminated union: success, conflict, or failure.
  */
 export declare function mergeLaneBranch(primaryDir: string, branchName: string, strategy: MergeStrategy): Promise<MergeSuccess | MergeConflict | MergeFailure>;
+/**
+ * Re-applies a preserved lane using exact immutable object ids captured by the
+ * #2105 recovery authority.
+ *
+ * This is the strategy-specific recovery primitive that `worktree-isolation`
+ * can call when a same-task redispatch claims a preserved lane. It refuses to
+ * operate on mutable branch refs, verifies that the captured lane ancestry is
+ * coherent, and fails closed if the current primary checkout no longer
+ * descends from the captured target head.
+ */
+export declare function recoverMergeBackFromImmutableCoordinates(primaryDir: string, coordinates: ImmutableMergeRecoveryCoordinates): Promise<ImmutableMergeRecoveryResult>;
 /**
  * Detect whether a previously-started merge-back already landed on the target.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.152.1",
+	"version": "7.153.1",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -111,6 +111,7 @@
 		"check:retention": "bun run scripts/check-retention-registry.ts",
 		"check:core-events": "bun run scripts/check-core-events-usage.ts",
 		"check:shell-audit": "bun run scripts/check-shell-audit-usage.ts",
+		"check:trajectory-store": "bun run scripts/check-trajectory-store-usage.ts",
 		"check:test-file-cap": "bun run scripts/check-test-file-cap.ts",
 		"check:pending-fragment": "bun run scripts/check-pending-fragment.ts",
 		"check:gate-portability": "bun run scripts/check-gate-portability.ts",

package/dist/cli/curator-llm-factory-462rysph.js

@@ -1,65 +0,0 @@
-// @bun
-import {
-  createCuratorLLMDelegate
-} from "./index-sg2sx2q7.js";
-import"./index-44xdtqz8.js";
-import"./index-k3d919yf.js";
-import"./index-x6803sxh.js";
-import"./index-26vyr198.js";
-import"./index-73pmnsjg.js";
-import"./index-134d35c1.js";
-import"./index-nj6rmyeh.js";
-import"./index-y8552snf.js";
-import"./index-nd8tkb3g.js";
-import"./index-02ajc6d1.js";
-import"./index-70ha9e09.js";
-import"./index-c8s9a3zh.js";
-import"./index-9ss2m4rs.js";
-import"./index-vnn7qq8c.js";
-import"./index-0q2mjxp2.js";
-import"./index-2e1294d1.js";
-import"./index-rq6aetkv.js";
-import"./index-pvrap7xg.js";
-import"./index-rtry5xyf.js";
-import"./index-zsrtt42s.js";
-import"./index-z4bg1hv8.js";
-import"./index-fxvgaeq4.js";
-import"./index-z9fyd0d6.js";
-import"./index-qqrdmaxq.js";
-import"./index-q77e475x.js";
-import"./index-xyfdmrv7.js";
-import"./index-6zkm4p7p.js";
-import"./index-556ja8an.js";
-import"./index-b43rt5ph.js";
-import"./index-q7sjgr1y.js";
-import"./index-3g0xk6tk.js";
-import"./index-85gkedsf.js";
-import"./index-0tfgn5x0.js";
-import"./index-dn6yt0xg.js";
-import"./index-ryecg2st.js";
-import"./index-gprxjmm7.js";
-import"./index-n832052r.js";
-import"./index-4cgee5vh.js";
-import"./index-z6xqpmqg.js";
-import"./index-r3mvsbtq.js";
-import"./index-3djxegsc.js";
-import"./index-n0vc5b5t.js";
-import"./index-cpg98bh1.js";
-import"./index-9e6fdz2h.js";
-import"./index-4rhhvd1a.js";
-import"./index-zjygnfay.js";
-import"./index-ae75rja9.js";
-import"./index-79g6edht.js";
-import"./index-mken64yj.js";
-import"./index-bk5tah7q.js";
-import"./index-7fh82sm1.js";
-import"./index-txbd25bc.js";
-import"./index-aw492hpn.js";
-import"./index-7g4c7s5r.js";
-import"./index-bpmtbmy9.js";
-import"./index-ed5ykebp.js";
-import"./index-zgwm4ryv.js";
-import"./index-a76rekgs.js";
-export {
-  createCuratorLLMDelegate
-};