opencode-swarm 7.153.0 → 7.153.1

package/dist/hooks/delegation-gate/worktree-recovery-authority.d.ts

@@ -0,0 +1,201 @@
+export declare const WORKTREE_RECOVERY_MUTATOR_NAMES: readonly ["publish", "claim", "renew", "release", "finalize", "replay"];
+export type WorktreeRecoveryMutatorName = (typeof WORKTREE_RECOVERY_MUTATOR_NAMES)[number];
+export type WorktreeRecoveryStrategy = 'merge' | 'rebase' | 'cherry-pick';
+export type WorktreeRecoveryStatus = 'preserved' | 'claimed' | 'released' | 'finalized';
+export type WorktreeRecoveryJournalState = 'PREPARED' | 'COMMITTED' | 'CLAIM_RENEWED' | 'ABORTED' | 'RELEASED' | 'FINALIZED';
+export interface WorktreeRecoveryImmutableIdentityInput {
+    originalCallID: string;
+    parentSessionId: string;
+    taskId: string;
+    reservationId: string;
+    generation: number;
+    canonicalBranch: string;
+    canonicalPath: string;
+    laneBranch: string;
+    lanePath: string;
+    expectedPrimaryHead: string;
+    sourceBaseOid: string;
+    sourceHeadOid: string;
+    targetHeadOid: string;
+    strategy: WorktreeRecoveryStrategy;
+    declaredConflictFiles?: string[];
+}
+export interface WorktreeRecoveryImmutableIdentity extends WorktreeRecoveryImmutableIdentityInput {
+    createdAt: number;
+}
+export interface WorktreeRecoveryClaimState {
+    claimantCallID: string;
+    claimantSessionId: string;
+    childSessionId: string;
+    claimRevision: number;
+    attempt: number;
+    leaseExpiresAt: number;
+    claimTokenDigest: string;
+    claimedAt: number;
+}
+export interface WorktreeRecoveryAuthorityRecord {
+    schemaVersion: 2;
+    authorityDigest: string;
+    immutable: WorktreeRecoveryImmutableIdentity;
+    status: WorktreeRecoveryStatus;
+    claim?: WorktreeRecoveryClaimState;
+    claimCursor?: {
+        lastClaimRevision: number;
+        lastAttempt: number;
+    };
+    finalizedAt?: number;
+    settlement?: {
+        sourceCommitOrder: string[];
+        rewrittenCommitOrder: string[];
+    };
+}
+interface WorktreeRecoveryStore {
+    schemaVersion: 2;
+    authorities: WorktreeRecoveryAuthorityRecord[];
+    index: {
+        bySessionTask: Record<string, string[]>;
+    };
+}
+export interface WorktreeRecoveryClaimJournalEntry {
+    schemaVersion: 1;
+    authorityDigest: string;
+    state: WorktreeRecoveryJournalState;
+    claimantCallID: string;
+    claimantSessionId: string;
+    childSessionId?: string;
+    claimRevision: number;
+    attempt: number;
+    leaseExpiresAt: number;
+    claimTokenDigest: string;
+    preparedAt: number;
+    credentialInstalledAt?: number;
+    committedAt?: number;
+    abortedAt?: number;
+    reason?: string;
+}
+interface WorktreeRecoveryClaimJournal {
+    schemaVersion: 1;
+    entries: WorktreeRecoveryClaimJournalEntry[];
+}
+interface WorktreeRecoveryCredential {
+    schemaVersion: 1;
+    authorityDigest: string;
+    claimantCallID: string;
+    claimantSessionId: string;
+    childSessionId: string;
+    claimRevision: number;
+    rawToken: string;
+    leaseExpiresAt: number;
+    createdAt: number;
+}
+type ScanStatus = 'ok' | 'unsupported-legacy' | 'uncertain';
+export type WorktreeRecoveryScanResult = {
+    status: 'ok';
+    authorities: WorktreeRecoveryAuthorityRecord[];
+} | {
+    status: 'unsupported-legacy';
+    reason: string;
+} | {
+    status: 'uncertain';
+    reason: string;
+};
+export type WorktreeRecoveryLookupResult = {
+    status: 'ok';
+    authorities: WorktreeRecoveryAuthorityRecord[];
+} | {
+    status: Exclude<ScanStatus, 'ok'>;
+    reason: string;
+};
+type BaseMutationFailureCode = 'not_found' | 'busy' | 'stale_claim' | 'retry_cap_exceeded' | 'revalidation_required' | 'revalidation_failed' | 'unsupported_legacy' | 'uncertain_store' | 'finalized';
+type BaseMutationFailure = {
+    ok: false;
+    code: BaseMutationFailureCode;
+    reason: string;
+};
+export type PublishWorktreeRecoveryAuthorityResult = {
+    ok: true;
+    authority: WorktreeRecoveryAuthorityRecord;
+} | BaseMutationFailure;
+export type ClaimWorktreeRecoveryAuthorityResult = {
+    ok: true;
+    authority: WorktreeRecoveryAuthorityRecord;
+    rawToken: string;
+    credentialPath: string;
+} | BaseMutationFailure;
+export type MutateWorktreeRecoveryClaimResult = {
+    ok: true;
+    authority: WorktreeRecoveryAuthorityRecord;
+} | BaseMutationFailure;
+export interface ClaimWorktreeRecoveryAuthorityRequest {
+    authorityDigest: string;
+    claimantCallID: string;
+    claimantSessionId: string;
+    now?: number;
+    leaseMs: number;
+    maxAttempts?: number;
+    createChildSession: () => string | Promise<string>;
+    revalidateExpiredClaim?: (args: {
+        authority: WorktreeRecoveryAuthorityRecord;
+        previousClaim: WorktreeRecoveryClaimState;
+    }) => {
+        ok: true;
+    } | {
+        ok: false;
+        reason: string;
+    } | Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        reason: string;
+    }>;
+}
+interface ExactClaimMutationRequest {
+    authorityDigest: string;
+    claimantCallID: string;
+    claimRevision: number;
+    rawToken: string;
+    now?: number;
+}
+export interface FinalizeWorktreeRecoveryAuthorityRequest extends ExactClaimMutationRequest {
+    settlement?: {
+        sourceCommitOrder: string[];
+        rewrittenCommitOrder: string[];
+    };
+}
+export interface ReplayPreparedClaimOptions {
+    onAbortPreparedClaim?: (entry: WorktreeRecoveryClaimJournalEntry) => void;
+}
+export interface ReplayPreparedClaimOutcome {
+    authorityDigest: string;
+    outcome: 'aborted_prepared_claim' | 'removed_uncommitted_credential' | 'committed_claim_stable' | 'released_orphaned_committed_claim' | 'repaired_terminal_claim' | 'uncertain_committed_without_authority' | 'noop';
+}
+declare function storePath(directory: string): string;
+declare function journalPath(directory: string): string;
+declare function credentialPath(directory: string, authorityDigest: string): string;
+declare function acquireAuthorityLock(directory: string): (() => void) | undefined;
+export declare function publishWorktreeRecoveryAuthority(directory: string, input: WorktreeRecoveryImmutableIdentityInput): PublishWorktreeRecoveryAuthorityResult;
+export declare function scanWorktreeRecoveryAuthoritiesForRecovery(directory: string): WorktreeRecoveryScanResult;
+export declare function lookupWorktreeRecoveryAuthoritiesByTask(directory: string, query: {
+    parentSessionId: string;
+    taskId: string;
+}): WorktreeRecoveryLookupResult;
+export declare function claimWorktreeRecoveryAuthority(directory: string, request: ClaimWorktreeRecoveryAuthorityRequest): Promise<ClaimWorktreeRecoveryAuthorityResult>;
+export declare function renewWorktreeRecoveryClaim(directory: string, request: ExactClaimMutationRequest & {
+    leaseMs: number;
+}): MutateWorktreeRecoveryClaimResult;
+export declare function releaseWorktreeRecoveryClaim(directory: string, request: ExactClaimMutationRequest): MutateWorktreeRecoveryClaimResult;
+export declare function finalizeWorktreeRecoveryAuthority(directory: string, request: FinalizeWorktreeRecoveryAuthorityRequest): MutateWorktreeRecoveryClaimResult;
+export declare function replayWorktreeRecoveryClaimJournal(directory: string, options?: ReplayPreparedClaimOptions): ReplayPreparedClaimOutcome[];
+export declare const _internals: {
+    generateRawToken: () => string;
+    writeRecoveryStore: (targetPath: string, store: WorktreeRecoveryStore, _phase: "publish" | "claim-commit" | "claim-renew" | "claim-release" | "claim-finalize") => void;
+    writeClaimJournal: (targetPath: string, journal: WorktreeRecoveryClaimJournal) => void;
+    writeCredentialFile: (targetPath: string, credential: WorktreeRecoveryCredential) => void;
+    getRecoveryStorePath: typeof storePath;
+    getClaimJournalPath: typeof journalPath;
+    getCredentialPath: typeof credentialPath;
+    acquireAuthorityLock: typeof acquireAuthorityLock;
+    readClaimJournal(directory: string): WorktreeRecoveryClaimJournal;
+    resetForTest(): void;
+};
+export {};

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

@@ -21,7 +21,8 @@ import { isLocked, listActiveLocks, tryAcquireLock } from '../parallel/file-lock
 import { removeWorktree } from '../worktree/core';
 import { scanRegisteredWorktreeLiveness } from '../worktree/merge';
 import { scanWorktreeMergeFailuresForRecovery } from './delegation-gate/worktree-merge-status';
-import { removeWorktreeProvisioningOwner, scanWorktreeProvisioningOwnersForRecovery } from './delegation-gate/worktree-provisioning-owner';
+import { removeWorktreeProvisioningOwner, scanWorktreeProvisioningLifecycleJournalForRecovery, scanWorktreeProvisioningOwnersForRecovery } from './delegation-gate/worktree-provisioning-owner';
+import { replayWorktreeRecoveryClaimJournal, scanWorktreeRecoveryAuthoritiesForRecovery } from './delegation-gate/worktree-recovery-authority';
 type OwnershipTagSessionScan = {
     status: 'ok';
     sessionIds: string[];
@@ -51,7 +52,10 @@ export declare const _internals: {
     recordDelegationRecoveryObservation: typeof recordDelegationRecoveryObservation;
     scanDelegationFallbacksForRecovery: typeof scanDelegationFallbacksForRecovery;
     scanWorktreeMergeFailuresForRecovery: typeof scanWorktreeMergeFailuresForRecovery;
+    scanWorktreeRecoveryAuthoritiesForRecovery: typeof scanWorktreeRecoveryAuthoritiesForRecovery;
+    replayWorktreeRecoveryClaimJournal: typeof replayWorktreeRecoveryClaimJournal;
     scanWorktreeProvisioningOwnersForRecovery: typeof scanWorktreeProvisioningOwnersForRecovery;
+    scanWorktreeProvisioningLifecycleJournalForRecovery: typeof scanWorktreeProvisioningLifecycleJournalForRecovery;
     scanRegisteredWorktreeLiveness: typeof scanRegisteredWorktreeLiveness;
     removeWorktreeProvisioningOwner: typeof removeWorktreeProvisioningOwner;
 };

package/dist/hooks/trajectory-logger.d.ts

@@ -9,6 +9,13 @@
  */
 export interface TrajectoryConfig {
     enabled: boolean;
+    /**
+     * Line budget for BOTH the session store's in-memory cache trim AND its
+     * on-disk compaction (issue #2041): over budget, the newest
+     * floor(max_lines/2) entries are retained on disk and in cache, and the
+     * derived byte ceiling is sovereign. The task-evidence copy below uses the
+     * same value for its own write-side truncation.
+     */
     max_lines: number;
 }
 export interface TrajectoryEntry {
@@ -64,8 +71,8 @@ declare function extractTarget(tool: string, args?: Record<string, unknown>): st
 /**
  * Creates the trajectory logger hook pair.
  *
- * @param config - TrajectoryConfig { enabled: boolean (default true), max_lines: number (default 500) }
- * @param _directory - Reserved for future use (evidence path derived from session taskId)
+ * @param config - TrajectoryConfig { enabled: boolean (default true), max_lines: number (default 500) — bounds the session store's cache AND disk compaction plus the task-evidence truncation }
+ * @param _directory - Workspace root (session store + evidence paths derive from it)
  * @returns Object with toolAfter handler
  */
 export declare function createTrajectoryLoggerHook(config: Partial<TrajectoryConfig>, _directory: string): {
@@ -90,8 +97,9 @@ export declare function createTrajectoryLoggerHook(config: Partial<TrajectoryCon
  * the record of it.
  *
  * Contract:
- *   - The step is minted with the SHARED `nextTrajectoryStep(sessionId)`. Any
- *     private counter would desynchronise the `prmTrajectoryStep` window and
+ *   - The step is minted with the SHARED `nextTrajectoryStep(sessionId, directory)`
+ *     (seeded from the persisted high-water mark — see ensureSessionStepSeeded).
+ *     Any private counter would desynchronise the `prmTrajectoryStep` window and
  *     silently break PRM's step-range filtering.
  *   - `session.delegationActive` gates recording at all (the architect session
  *     is deliberately out of scope); the task-evidence copy additionally
@@ -117,13 +125,18 @@ export declare function recordDeniedToolCall(sessionID: string, input: {
 export declare function clearDeniedCallMarkers(): void;
 /**
  * Resets the step counter for a session. Called when a new session starts
- * or when trajectory tracking should restart from step 1.
+ * or when trajectory tracking should restart from step 1. The restart-seed
+ * gate is invalidated so the next mint re-seeds from the persisted
+ * high-water mark (issue #2041 monotonicity).
  *
  * @param sessionId - Session identifier
+ * @param directory - Workspace root owning the session's trajectory store
  */
-export declare function resetTrajectoryStep(sessionId: string): void;
+export declare function resetTrajectoryStep(sessionId: string, directory?: string): void;
 /**
  * Clears trajectory step counters for one session, or all sessions when omitted.
+ * The restart-seed gate is invalidated alongside so a cleared session re-seeds
+ * from disk on its next mint (issue #2041 monotonicity).
  *
  * @param sessionId - Optional session identifier
  */
@@ -140,6 +153,7 @@ export declare function recordToolCallStart(sessionId: string, callID: string, s
 /**
  * Tier-0 pure-function test seam (writing-tests skill). These helpers take no
  * external dependencies, so testing them directly needs no mocks at all.
+ * The seed-gate accessors cover the restart-seeding state machine (issue #2041).
  */
 export declare const _test_exports: {
     readonly deriveAction: typeof deriveAction;
@@ -147,5 +161,7 @@ export declare const _test_exports: {
     readonly MAX_DENIED_CALL_MARKERS: 500;
     readonly DENIED_CALL_TTL_MS: number;
     readonly deniedCallMarkerCount: () => number;
+    readonly stepSeedGateSize: () => number;
+    readonly clearStepSeedGate: () => void;
 };
 export {};

package/dist/hooks/trajectory-step-state.d.ts

@@ -1,11 +1,52 @@
 /**
  * Module-level trajectory step counters shared by runtime reset code and the
  * trajectory logger without creating a state <-> hook import cycle.
+ *
+ * Keys are canonical-root + session id (issue #2041 Required 6): the counters
+ * are process-global module state, so a host that loads one plugin module
+ * instance for several project roots must not let two roots' sessions with
+ * the same host session id share a counter — nor let two aliases of one root
+ * diverge. The shared `src/utils/canonical-root.ts` helper owns the keying so
+ * the trajectory store, these counters, and the logger's restart-seed gate
+ * cannot drift. `directory` is required on the minting/seed path; the clear
+ * paths may omit it and suffix-scan every root, because the reset entry
+ * points legitimately lack a directory.
+ */
+/** Current step-counter generation (changes on every clear/reset). */
+export declare function trajectoryStepGeneration(): number;
+/**
+ * Mints the next sequential step for a session. Restart continuity is the
+ * logger's job (`ensureSessionStepSeeded` in trajectory-logger.ts seeds the
+ * counter from the bounded store before the first mint), not this counter's.
+ */
+export declare function nextTrajectoryStep(sessionId: string, directory: string): number;
+/**
+ * Raises a session's counter to `step` when it is higher than the current
+ * value. Used by the restart-seed path so a resumed session continues minting
+ * monotonically after the on-disk high-water mark instead of restarting at 1
+ * (which would duplicate step numbers against the persisted trajectory).
+ * A lower value never lowers the counter (issue #2041 monotonicity).
+ */
+export declare function seedTrajectoryStepCounter(sessionId: string, directory: string, step: number): void;
+/**
+ * Resets the step counter for a session to zero (module-level semantics —
+ * "restart at step one"). The production reset entry points go through
+ * trajectory-logger.ts, which also invalidates the per-process restart-seed
+ * gate so the next mint re-seeds from disk and steps stay monotonic against
+ * the persisted trajectory.
+ */
+export declare function resetTrajectoryStepCounter(sessionId: string, directory: string): void;
+/**
+ * Clears trajectory step counters for one session (every canonical root — the
+ * reset entry points legitimately lack a directory), or all sessions when
+ * omitted.
  */
-export declare function nextTrajectoryStep(sessionId: string): number;
-export declare function resetTrajectoryStepCounter(sessionId: string): void;
 export declare function clearTrajectoryStepCounters(sessionId?: string): void;
 export declare const _test_exports: {
     MAX_TRACKED_STEP_SESSIONS: number;
     getTrackedStepSessionCount: () => number;
+    /** Whether a counter exists for this session+root in this process. */
+    hasTrajectoryStepCounter: (sessionId: string, directory: string) => boolean;
+    /** Current generation (test seam: gate-invalidation assertions). */
+    getStepCounterGeneration: () => number;
 };