opencode-swarm 7.184.6 → 7.184.7

package/dist/gate-evidence.d.ts

@@ -66,6 +66,25 @@ export interface TaskWorkflowMetadata {
      * `repair_idle` (which opens a new generation for genuinely new work).
      */
     supervisedRecovery?: boolean;
+    /**
+     * True when this task's current generation entered `pre_check_passed`
+     * through a settlement-backed Stage A recovery (issue #2828) — the
+     * deterministic `/swarm recover` settlement-wedge repair or the audited
+     * `recover_stage_a_task` architect tool — rather than the mechanical
+     * pre_check_batch recorder.
+     *
+     * Same durability contract as `supervisedRecovery`: the reducer consumes
+     * the event-scoped flag transiently, so without a persisted marker the
+     * evidence file becomes byte-identical to a mechanically-earned Stage A
+     * pass as soon as the next transition overwrites `lastTransitionId`.
+     * Preserved across subsequent transitions in the same generation, cleared
+     * by `repair_idle` and by `accepted_mutation`'s generation rotation (a new
+     * generation invalidates the recovery mode). One flag serves both entry
+     * modes because the durable predicate (COMMITTED accepted settlement +
+     * green post-settlement pre-check) is identical; provenance between them
+     * rides the `stage_a_repair` audit event's `via` field.
+     */
+    settlementRecovery?: boolean;
     /**
      * Exact proof that the generation-0 coder settlement declared no files and
      * observed no mutation. This is deliberately separate from retry history and
@@ -153,6 +172,15 @@ export type TaskWorkflowTransitionEvent = {
      * fail closed with TASK_WORKFLOW_CODER_MUTATION_REQUIRED from that state.
      */
     supervisedRecovery?: boolean;
+    /**
+     * Settlement-backed recovery only (issue #2828): the settlement-wedge
+     * repair paths (`/swarm recover`'s settlement scan and the
+     * recover_stage_a_task tool) set this to admit stage_a_passed from
+     * `idle`/`blocked` when a COMMITTED accepted coder settlement plus
+     * green post-settlement pre-check proof justify re-recording Stage A.
+     * Every other emitter leaves it unset and still fails closed.
+     */
+    settlementRecovery?: boolean;
     expectedGeneration: number;
     transitionId?: string;
 } | {
@@ -213,6 +241,17 @@ export interface TaskEvidenceTransaction {
     taskId: string;
     read(): TaskEvidence | null;
     transition(event: TaskWorkflowTransitionEvent): Promise<TaskEvidence>;
+    /**
+     * Same as `transition`, plus whether the reducer treated the event as a
+     * duplicate no-op (the durable evidence already recorded this exact
+     * transitionId + outcome, so nothing changed). Optional for backward
+     * compatibility with older transaction implementations; callers of the
+     * plain `transition` cannot distinguish a fresh write from a duplicate.
+     */
+    transitionWithStatus?(event: TaskWorkflowTransitionEvent): Promise<{
+        evidence: TaskEvidence;
+        duplicated: boolean;
+    }>;
 }
 export declare function parseTaskEvidence(raw: string, expectedTaskId: string): TaskEvidence;
 export declare const DEFAULT_REQUIRED_GATES: string[];
@@ -261,6 +300,18 @@ export declare function deriveRequiredGates(agentType: string, context?: GateDer
  */
 export declare function expandRequiredGates(existingGates: string[], newAgentType: string, context?: GateDerivationContext): string[];
 export declare function transitionTaskWorkflowEvidence(directory: string, taskId: string, event: TaskWorkflowTransitionEvent): Promise<TaskEvidence>;
+/**
+ * Same as `transitionTaskWorkflowEvidence`, plus whether the reducer treated
+ * the event as a duplicate no-op (the durable evidence already recorded this
+ * exact transitionId + outcome). Duplicate detection needs the locked pre-
+ * transition state, so it is only available from inside the transaction; a
+ * transaction implementation without `transitionWithStatus` reports
+ * `duplicated: false` (unknown, not proven-fresh).
+ */
+export declare function transitionTaskWorkflowEvidenceWithStatus(directory: string, taskId: string, event: TaskWorkflowTransitionEvent): Promise<{
+    evidence: TaskEvidence;
+    duplicated: boolean;
+}>;
 export declare function withTaskEvidenceTransaction<T>(directory: string, taskId: string, agent: string, callback: (transaction: TaskEvidenceTransaction) => Promise<T>): Promise<T>;
 /**
  * Re-publish a transition receipt after a caller has proven that its evidence