opencode-swarm 7.142.0 → 7.143.0

package/dist/plan/ledger.d.ts

@@ -62,6 +62,16 @@ export type LedgerEventInput = Omit<LedgerEvent, 'seq' | 'timestamp' | 'plan_has
 export interface SnapshotEventPayload {
     plan: Plan;
     payload_hash: string;
+    plan_epoch?: string;
+    root_event_hash?: string;
+}
+export interface PlanEpochIdentity {
+    planId: string;
+    planIdentityHash: string;
+    planEpoch: string;
+    rootEventHash: string;
+    payloadHash: string;
+    source: 'root' | 'plan_epoch_adopted';
 }
 /**
  * Error thrown when a writer attempts to append to the ledger with stale state.
@@ -173,6 +183,23 @@ export declare function readLedgerEvents(directory: string): Promise<LedgerEvent
  * @param planId - Unique identifier for the plan
  */
 export declare function initLedger(directory: string, planId: string, initialPlanHash?: string, initialPlan?: Plan): Promise<void>;
+/**
+ * Read and validate the current plan epoch identity without creating,
+ * adopting, or appending any ledger state.
+ *
+ * Returns null when the ledger is absent or when a legacy ledger has not yet
+ * adopted an epoch. Invalid or conflicting epoch metadata still fails closed.
+ */
+export declare function readPlanEpochIdentity(directory: string, authoritativePlan: Plan): Promise<PlanEpochIdentity | null>;
+/**
+ * Return the persisted plan epoch for the authoritative ledger root, adopting
+ * one backward-readable snapshot when a legacy root predates the epoch field.
+ *
+ * The caller is expected to already hold the higher-level plan lock. This
+ * helper acquires only the ledger append lock so concurrent adopters serialize
+ * to one adoption snapshot.
+ */
+export declare function getOrAdoptPlanEpochUnderLock(directory: string, authoritativePlan: Plan): Promise<PlanEpochIdentity>;
 /**
  * Append a new event to the ledger.
  * Uses atomic write: write to temp file then rename.
@@ -390,7 +417,9 @@ export interface LedgerIntegrityResult {
  * @param directory - The working directory
  * @returns LedgerIntegrityResult with events, truncated flag, and bad suffix
  */
-export declare function readLedgerEventsWithIntegrity(directory: string): Promise<LedgerIntegrityResult>;
+export declare function readLedgerEventsWithIntegrity(directory: string, options?: {
+    failClosedOnReadError?: boolean;
+}): Promise<LedgerIntegrityResult>;
 /**
  * Result of a {@link quarantineLedgerSuffix} call.
  */
@@ -516,5 +545,6 @@ export declare const _internals: {
     getPlanJsonPath: typeof getPlanJsonPath;
     writeFileFsyncedThenRename: typeof writeFileFsyncedThenRename;
     fsyncRecoveryDirectory: typeof fsyncRecoveryDirectory;
+    randomUUID: () => `${string}-${string}-${string}-${string}-${string}`;
 };
 export {};

package/dist/plan/manager.d.ts

@@ -214,6 +214,7 @@ export declare function isTaskSettled(directory: string, taskId: string): Promis
 export declare function updateTaskStatus(directory: string, taskId: string, status: TaskStatus, options?: {
     force?: boolean;
     planLockAlreadyHeld?: boolean;
+    terminalReconciliation?: boolean;
 }): Promise<Plan>;
 /**
  * Generate deterministic markdown view from plan object.

package/dist/state.d.ts

@@ -64,7 +64,7 @@ export interface PrSubscriptionState {
  * Per-task workflow state for gate progression tracking.
  * Transitions must be forward-only: idle → coder_delegated → pre_check_passed → reviewer_run → tests_run → complete
  */
-export type TaskWorkflowState = 'idle' | 'coder_delegated' | 'pre_check_passed' | 'reviewer_run' | 'tests_run' | 'rework_required' | 'complete' | 'blocked';
+export type TaskWorkflowState = 'idle' | 'coder_delegated' | 'pre_check_passed' | 'reviewer_run' | 'tests_run' | 'rework_required' | 'complete' | 'blocked' | 'closed';
 export interface TaskWorkflowCacheEntry {
     generation: number;
     retryCount: number;

package/dist/workflow/close-terminal.d.ts

@@ -0,0 +1,22 @@
+import type { Plan } from '../config/plan-schema.js';
+export interface CloseTerminalResult {
+    plan: Plan;
+    closedTaskIds: string[];
+    preservedCompletedTaskIds: string[];
+    closedPhaseIds: number[];
+    /**
+     * Tasks whose terminal state was settled as a QA-exempt forced completion — either
+     * recorded as such by this reconciliation, or already carrying `forcedCompletion`
+     * in durable evidence from an earlier one. Surfaced so `/swarm close` can report
+     * that these tasks did not pass the normal gates; without it a forced completion is
+     * indistinguishable from a genuinely reviewed and tested one.
+     */
+    forcedCompletionTaskIds: string[];
+}
+/** Reconcile `/swarm close` intent with exact-task workflow authority. */
+export declare function reconcileCloseTerminalState(directory: string, targetPlan: Plan, options: {
+    actor: string;
+    requestedClosedTaskIds: string[];
+    closedPhaseIds: number[];
+    originalStatuses?: Map<string, string>;
+}): Promise<CloseTerminalResult>;

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

@@ -1,32 +1,11 @@
 import type { BackgroundTaskChangeContext, BackgroundWorktreeDescriptor } from '../background/pending-delegations.js';
 import { type TaskEvidence } from '../gate-evidence.js';
 import type { MergeOperationProvenance } from '../worktree/merge.js';
-type CoderSettlementState = 'ABORTED' | 'COMMITTED' | 'DISPATCHED' | 'PREPARED';
-interface CoderSettlementWal {
-    version: 1;
-    state: CoderSettlementState;
-    taskId: string;
-    transitionId: string;
-    actor: string;
-    processId: number;
-    runtimeId: string;
-    expectedGeneration: number;
-    context: BackgroundTaskChangeContext;
-    worktree?: BackgroundWorktreeDescriptor;
-    observedFiles?: string[];
-    mergeProvenance?: MergeOperationProvenance;
-    accepted?: boolean;
-    testEngineerExempt?: boolean;
-    settlementFailed?: boolean;
-    cleanupComplete?: boolean;
-    recordedAt: string;
-}
 export interface CoderSettlementResult {
     evidence: TaskEvidence;
     accepted: boolean;
     alreadyApplied: boolean;
 }
-declare function parseWal(raw: string): CoderSettlementWal;
 export declare function beginCoderSettlement(options: {
     directory: string;
     taskId: string;
@@ -56,7 +35,5 @@ export declare function recoverCoderSettlement(directory: string, taskId: string
 export declare function releaseCoderDispatchOwnership(directory: string, taskId: string, transitionId: string): void;
 export declare function assertNoUnsettledCoderDispatch(directory: string, taskId: string): Promise<void>;
 export declare const _internals: {
-    parseWal: typeof parseWal;
     liveDispatches: Set<string>;
 };
-export {};

package/dist/workflow/task-repair.d.ts

@@ -10,6 +10,7 @@ export interface TaskRepairResult<TPlan> {
  * the task. This reads only the exact per-task WAL path; it never scans.
  */
 export declare function recoverPreparedTaskRepair(directory: string, taskId: string, actor: string): Promise<TaskRepairResult<NonNullable<Awaited<ReturnType<typeof loadPlanJsonOnly>>>> | null>;
+export declare function recoverPreparedTaskRepairUnderPlanLock(directory: string, taskId: string, actor: string, currentPlan: NonNullable<Awaited<ReturnType<typeof loadPlanJsonOnly>>>): Promise<TaskRepairResult<NonNullable<Awaited<ReturnType<typeof loadPlanJsonOnly>>>> | null>;
 /**
  * Execute or lazily finish one exact-task repair while the caller holds the
  * plan lock. Lock ordering is therefore always plan -> exact task evidence.

package/dist/workflow/task-terminal.d.ts

@@ -1,28 +1,12 @@
 import type { Plan } from '../config/plan-schema.js';
 import { type TaskEvidence, withTaskEvidenceTransaction } from '../gate-evidence.js';
-import type { TaskWorkflowState } from '../state.js';
-type TerminalPlanStatus = 'blocked' | 'completed';
-type TerminalWorkflowState = 'blocked' | 'complete';
-type TerminalWalState = 'ABORTED' | 'COMMITTED' | 'PREPARED';
-interface TaskTerminalWal {
-    version: 1;
-    state: TerminalWalState;
-    taskId: string;
-    transitionId: string;
-    actor: string;
-    oldPlanStatus: string;
-    newPlanStatus: TerminalPlanStatus;
-    oldWorkflowState: TaskWorkflowState;
-    newWorkflowState: TerminalWorkflowState;
-    generation: number;
-    qaExempt: boolean;
-    recordedAt: string;
-}
+import type { TaskTerminalWal, TerminalPlanStatus } from './workflow-wal-schema.js';
 export interface TaskTerminalResult<TPlan> {
     plan: TPlan;
     evidence: TaskEvidence;
     alreadyApplied: boolean;
     transitionId: string;
+    targetStatus: TerminalPlanStatus;
 }
 declare function applyTerminalEvidence(transaction: Parameters<Parameters<typeof withTaskEvidenceTransaction>[3]>[0], wal: TaskTerminalWal): Promise<TaskEvidence>;
 /** Narrow dependency-injection seam for crash-window failure tests. */
@@ -30,12 +14,16 @@ export declare const _internals: {
     applyTerminalEvidence: typeof applyTerminalEvidence;
 };
 /**
- * Lazily close the only recoverable terminal crash window: the plan was
- * persisted to completed/blocked after PREPARED, but exact-task evidence was
- * not. A PREPARED record whose plan and evidence are both still old is safely
- * aborted rather than executing an abandoned status request.
+ * Lazily close a recoverable terminal crash window: the WAL is PREPARED but the
+ * plan/evidence pair it describes has not settled. A v1 record whose plan and
+ * evidence are both still old is safely aborted rather than executing an
+ * abandoned completed/blocked request. A v2 (close) record is instead
+ * force-forwarded even from old plan and old evidence — its plan-epoch identity
+ * is re-verified first, and abandoning it would leave a task the caller already
+ * closed silently open.
  */
 export declare function recoverPreparedTaskTerminal(directory: string, taskId: string, actor: string): Promise<TaskTerminalResult<Plan> | null>;
+export declare function recoverPreparedTaskTerminalUnderPlanLock(directory: string, taskId: string, actor: string, currentPlan: Plan): Promise<TaskTerminalResult<Plan> | null>;
 /** Commit a terminal plan/evidence transition while the caller holds plan.json. */
 export declare function commitTaskTerminalUnderPlanLock<TPlan>(options: {
     directory: string;
@@ -45,8 +33,15 @@ export declare function commitTaskTerminalUnderPlanLock<TPlan>(options: {
     currentPlanStatus: string;
     targetStatus: TerminalPlanStatus;
     qaExempt: boolean;
+    resolveTerminal?: (evidence: TaskEvidence | null) => {
+        targetStatus: TerminalPlanStatus;
+        qaExempt: boolean;
+        preserveEvidence?: boolean;
+    };
+    planIdentityHash?: string;
+    planEpoch?: string;
     currentPlan: TPlan;
     validateEvidence?: (evidence: TaskEvidence | null) => Promise<void> | void;
-    updatePlan: () => Promise<TPlan>;
+    updatePlan: (targetStatus: TerminalPlanStatus) => Promise<TPlan>;
 }): Promise<TaskTerminalResult<TPlan>>;
 export {};

package/dist/workflow/workflow-wal-file.d.ts

@@ -0,0 +1,20 @@
+import * as fs from 'node:fs';
+import { type FileHandle } from 'node:fs/promises';
+import { type CoderSettlementWal, type TaskRepairWal, type TaskTerminalWal } from './workflow-wal-schema.js';
+type WorkflowWalKind = 'coder-settlement' | 'task-repair' | 'task-terminal';
+type WorkflowWalByKind = {
+    'coder-settlement': CoderSettlementWal;
+    'task-repair': TaskRepairWal;
+    'task-terminal': TaskTerminalWal;
+};
+type OpenFile = (filePath: string, flags: string) => Promise<FileHandle>;
+export declare const _internals: {
+    openFile: OpenFile;
+    openFileSync: typeof fs.openSync;
+    readFileSync: typeof fs.readSync;
+    closeFileSync: typeof fs.closeSync;
+};
+export declare function readWorkflowWalFile<K extends WorkflowWalKind>(kind: K, filePath: string, expectedTaskId: string): Promise<WorkflowWalByKind[K] | null>;
+export declare function readWorkflowWalFileSync<K extends WorkflowWalKind>(kind: K, filePath: string, expectedTaskId: string): WorkflowWalByKind[K] | null;
+export declare function writeWorkflowWalFile(kind: WorkflowWalKind, filePath: string, wal: CoderSettlementWal | TaskRepairWal | TaskTerminalWal): Promise<void>;
+export {};

package/dist/workflow/workflow-wal-schema.d.ts

@@ -0,0 +1,67 @@
+import type { BackgroundTaskChangeContext, BackgroundWorktreeDescriptor } from '../background/pending-delegations.js';
+import type { TaskWorkflowState } from '../state.js';
+import { type MergeOperationProvenance } from '../worktree/merge.js';
+export type CoderSettlementState = 'ABORTED' | 'COMMITTED' | 'DISPATCHED' | 'PREPARED';
+export interface CoderSettlementWal {
+    version: 1;
+    state: CoderSettlementState;
+    taskId: string;
+    transitionId: string;
+    actor: string;
+    processId: number;
+    runtimeId: string;
+    expectedGeneration: number;
+    context: BackgroundTaskChangeContext;
+    worktree?: BackgroundWorktreeDescriptor;
+    observedFiles?: string[];
+    mergeProvenance?: MergeOperationProvenance;
+    accepted?: boolean;
+    testEngineerExempt?: boolean;
+    settlementFailed?: boolean;
+    cleanupComplete?: boolean;
+    recordedAt: string;
+}
+export type RepairWalState = 'ABORTED' | 'COMMITTED' | 'PREPARED';
+export interface TaskRepairWal {
+    version: 1;
+    state: RepairWalState;
+    taskId: string;
+    transitionId: string;
+    reason: string;
+    actor: string;
+    oldPlanStatus: string;
+    newPlanStatus: 'in_progress';
+    oldWorkflowState: string;
+    newWorkflowState: 'idle';
+    oldGeneration: number;
+    generation: number;
+    recordedAt: string;
+}
+export type TerminalWalState = 'ABORTED' | 'COMMITTED' | 'PREPARED';
+export type TerminalPlanStatus = 'blocked' | 'closed' | 'completed';
+export type TerminalWorkflowState = 'blocked' | 'closed' | 'complete';
+export interface TaskTerminalWalV1 {
+    version: 1;
+    state: TerminalWalState;
+    taskId: string;
+    transitionId: string;
+    actor: string;
+    oldPlanStatus: string;
+    newPlanStatus: 'blocked' | 'completed';
+    oldWorkflowState: TaskWorkflowState;
+    newWorkflowState: 'blocked' | 'complete';
+    generation: number;
+    qaExempt: boolean;
+    recordedAt: string;
+}
+export interface TaskTerminalWalV2 extends Omit<TaskTerminalWalV1, 'version' | 'newPlanStatus' | 'newWorkflowState'> {
+    version: 2;
+    newPlanStatus: 'closed' | 'completed';
+    newWorkflowState: 'closed' | 'complete';
+    planIdentityHash: string;
+    planEpoch: string;
+}
+export type TaskTerminalWal = TaskTerminalWalV1 | TaskTerminalWalV2;
+export declare function parseCoderSettlementWal(raw: string, filePath: string, expectedTaskId?: string): CoderSettlementWal;
+export declare function parseTaskRepairWal(raw: string, filePath: string, expectedTaskId?: string): TaskRepairWal;
+export declare function parseTaskTerminalWal(raw: string, filePath: string, expectedTaskId?: string): TaskTerminalWal;

package/dist/worktree/merge.d.ts

@@ -99,6 +99,23 @@ export interface MergeOperationProvenance {
     branchName: string;
     strategy: MergeStrategy;
 }
+/**
+ * Git object ids as written by `git rev-parse HEAD`: sha1 (40) today, sha256 (64)
+ * under the sha256 object format. Abbreviated ids are deliberately rejected —
+ * nothing in this codebase persists them. Constraining the shape also makes a
+ * leading `-` structurally impossible for values later passed to git as
+ * revisions, which matters because neither sink below passes a separator that
+ * would protect one today: the `git log` call's `--` sits after the range and
+ * separates pathspecs rather than options, and the
+ * `git merge-base --is-ancestor` call passes the revision bare. (Both commands
+ * would accept `--`/`--end-of-options` before the operand, so sink-side
+ * hardening is also available; this pattern guards the value itself.)
+ *
+ * Owned here beside `MergeOperationProvenance` because this module defines the
+ * struct whose head fields reach git argv; `workflow-wal-schema.ts` re-imports
+ * it so the two validation surfaces for the same values cannot drift apart.
+ */
+export declare const GIT_OBJECT_ID_PATTERN: RegExp;
 export type MergeReconciliationResult = {
     landed: true;
     method: 'ancestry' | 'cherry-pick-trailer';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.142.0",
+	"version": "7.143.0",
 	"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",