opencode-swarm 7.140.3 → 7.140.5

package/dist/knowledge/curation-policy.d.ts

@@ -26,7 +26,6 @@
  * the destructive callers (Layer 4 routing).
  */
 import { readFile } from 'node:fs/promises';
-import { readKnowledgeEvents } from '../hooks/knowledge-events.js';
 import { isLinked, readLinkPointer, resolveKnowledgeStoreDir, resolveLinkDir } from '../hooks/knowledge-link.js';
 import type { CurationAction, CurationEvidenceScope, CurationProposal, KnowledgeConfig } from '../hooks/knowledge-types.js';
 import { type CohortConfigFingerprintInput, cohortConfigFingerprint } from './config-fingerprint.js';
@@ -114,7 +113,6 @@ export declare function readCohortConfigFingerprint(directory: string): Promise<
  */
 export declare const _internals: {
     resolveWorktreeId: typeof resolveWorktreeId;
-    readKnowledgeEvents: typeof readKnowledgeEvents;
     cohortConfigFingerprint: typeof cohortConfigFingerprint;
     readCohortConfigFingerprint: typeof readCohortConfigFingerprint;
     readFile: typeof readFile;

package/dist/observability/catalog.d.ts

@@ -1,11 +1,13 @@
 /**
  * The event catalog (issue #2029).
  *
- * Exactly 40 entries, matching the `TelemetryEvent` union at
+ * Exactly 41 entries, matching the `TelemetryEvent` union at
  * `src/telemetry.ts:15-91`. Thirty-eight predate the #2029 contract; the 39th is
  * `agent_conflict_detected` (previously emitted through a force-cast past the
  * type system), and the 40th is `close_archive_result` (issue #2030 — the
- * structured close/archive result event). Both late additions are instances of
+ * structured close/archive result event). The 41st is the bounded diagnostic
+ * projection of authoritative knowledge-receipt transitions (issue #2031).
+ * These late additions are instances of
  * the defect class this contract exists to close: an event kind entering the
  * stream with no registration.
  *
@@ -60,7 +62,7 @@ export interface CatalogEntry {
     /**
      * Whether an event of this kind must carry `trace.parentSpanId`.
      *
-     * `false` for all 40 entries today, and that is a truthful statement about
+     * `false` for all 41 entries today, and that is a truthful statement about
      * the current system rather than a placeholder: no producer supplies a
      * parent span, so `createObservation` never sets one. Setting this to `true`
      * for a kind whose producer cannot supply a parent would make every

package/dist/observability/legacy.d.ts

@@ -53,9 +53,10 @@ export declare function adaptLegacyTelemetryPayload(kind: string, data: unknown,
  * Shallow, never throws, and NEVER synthesizes: an ID that is absent, empty, or
  * of the wrong type stays `undefined`. Only the mappings a producer actually
  * populates are implemented — `sessionId` to `hostSessionId`, `taskId`, `phase`
- * to `phaseId`, `laneId`, `batchId`. The remaining eight recognized IDs have no
- * current producer, and inventing an extraction for them would manufacture
- * exactly the joins issue #2029 item 2 forbids.
+ * to `phaseId`, `laneId`, `batchId`, plus the canonical receipt payload keys
+ * `knowledgeTraceId` and `knowledgeEntryId`. Unmapped IDs stay absent; inventing
+ * an extraction for them would manufacture exactly the joins issue #2029 item 2
+ * forbids.
  */
 export declare function extractWorkflowIds(data: unknown): WorkflowIds;
 /**

package/dist/plan/ledger.d.ts

@@ -78,6 +78,28 @@ declare function getLedgerPath(directory: string): string;
  * Get the path to plan.json
  */
 declare function getPlanJsonPath(directory: string): string;
+/**
+ * Durable atomic write: write `data` to `tempPath`, fsync the file descriptor so
+ * the bytes are flushed to stable storage, then atomically rename it over
+ * `targetPath`.
+ *
+ * WHY the fsync matters: a plain `writeFileSync` returns once the data is in the
+ * OS page cache, not on disk. A crash/power-loss between the write and the
+ * subsequent `rename` can publish a zero-length or partially-written temp file as
+ * the canonical ledger — silent truncation that later reads cannot distinguish
+ * from a legitimately short ledger. Forcing an fsync before the rename guarantees
+ * the temp file's bytes are durable before it becomes the canonical file.
+ *
+ * NOTE: the containing-directory fsync (which would also durably persist the
+ * rename's directory entry so the *rename itself* survives a crash) is
+ * intentionally OMITTED. The rename is atomic on POSIX, and the ledger's
+ * crash-consistency contract only requires that a published ledger never be
+ * partially-written; it tolerates losing the very last rename on power-loss (the
+ * prior canonical file is then still intact). Omitting the dir-fsync avoids the
+ * portability and cost concerns of opening the directory as a file descriptor.
+ */
+declare function writeFileFsyncedThenRename(tempPath: string, targetPath: string, data: string | Uint8Array): void;
+declare function fsyncRecoveryDirectory(directory: string): void;
 /**
  * Compute a SHA-256 hash of the plan state.
  * Uses deterministic JSON serialization for consistent hashing.
@@ -163,6 +185,13 @@ export declare function initLedger(directory: string, planId: string, initialPla
 export declare function appendLedgerEvent(directory: string, eventInput: LedgerEventInput, options?: {
     expectedSeq?: number;
     expectedHash?: string;
+    /**
+     * CAS against the durable ledger tail rather than plan.json. This is used
+     * only by stale-projection reconciliation, where plan.json intentionally
+     * differs from the ledger and a snapshot adopts that exact projection as
+     * the new authoritative state.
+     */
+    expectedLedgerHash?: string;
     planHashAfter?: string;
 }): Promise<LedgerEvent>;
 /**
@@ -244,7 +273,31 @@ export declare function takeSnapshotEvent(directory: string, plan: Plan, options
     source?: string;
     approvalMetadata?: Record<string, unknown>;
     payloadHashOverride?: string;
+    /** CAS binding for stale-projection recovery snapshots. */
+    expectedSeq?: number;
+    /** Previous durable hash used to preserve the ledger hash chain. */
+    expectedLedgerHash?: string;
 }): Promise<LedgerEvent>;
+export interface TruncatedLedgerRecoveryResult {
+    archivePath: string;
+    archiveSha256: string;
+    recoveryRoot: LedgerEvent;
+}
+/**
+ * Recover an explicitly verified stale projection from a malformed ledger.
+ *
+ * A snapshot appended after an unparsable line is not durable recovery because
+ * integrity replay stops at that line after restart. This transaction first
+ * writes and fsyncs a byte-for-byte archive of the complete canonical ledger,
+ * then atomically replaces the canonical file with a new `plan_created` root
+ * that embeds the verified projection and links to the preserved archive.
+ * A crash therefore leaves either the old canonical ledger or the new complete
+ * root; it never creates a missing-ledger window or silently discards history.
+ */
+export declare function replaceTruncatedLedgerWithRecoveryRoot(directory: string, plan: Plan, expected: {
+    seq: number;
+    ledgerHash: string;
+}): Promise<TruncatedLedgerRecoveryResult>;
 /**
  * Options for replayFromLedger
  */
@@ -461,5 +514,7 @@ export declare const _internals: {
     loadLastPlanCriticApprovedSnapshot: typeof loadLastPlanCriticApprovedSnapshot;
     getLedgerPath: typeof getLedgerPath;
     getPlanJsonPath: typeof getPlanJsonPath;
+    writeFileFsyncedThenRename: typeof writeFileFsyncedThenRename;
+    fsyncRecoveryDirectory: typeof fsyncRecoveryDirectory;
 };
 export {};

package/dist/plan/manager.d.ts

@@ -146,6 +146,15 @@ export declare function savePlan(directory: string, plan: Plan, options?: {
     acknowledged_removals?: AcknowledgedRemovals;
     /** True only when the caller already owns the canonical plan.json lock. */
     planLockAlreadyHeld?: boolean;
+    /**
+     * Narrow recovery mode for a semantically unreadable ledger tail. The
+     * caller must bind the exact tail observed while validating an unchanged
+     * `_ledgerReplayStale` projection.
+     */
+    staleProjectionReconcile?: {
+        expectedSeq: number;
+        expectedLedgerHash: string;
+    };
 }): Promise<void>;
 /**
  * Rebuild plan from ledger events.

package/dist/plan/planning-profile.d.ts

@@ -0,0 +1,27 @@
+import type { ExecutionProfile, Plan } from '../config/plan-schema';
+import type { PluginConfig } from '../config/schema';
+export type PlanningProfile = NonNullable<NonNullable<ExecutionProfile['planning_profile']>>;
+export interface ResolvedPlanningProfile {
+    effective: PlanningProfile;
+    persisted: PlanningProfile | undefined;
+    source: 'incoming' | 'persisted' | 'repository_default' | 'legacy_locked_default';
+}
+export type PlanningProfileDirectiveContext = 'repository_default' | 'runtime';
+/**
+ * Render the authoritative planning ceremony for the architect prompt.
+ *
+ * Keep this policy next to the resolver so static agent construction and
+ * per-turn persisted-plan injection cannot drift into different meanings for
+ * the same resolved profile.
+ */
+export declare function renderPlanningProfileDirective(resolution: ResolvedPlanningProfile, context?: PlanningProfileDirectiveContext): string;
+interface ResolvePlanningProfileOptions {
+    directory: string;
+    incomingExecutionProfile?: Partial<ExecutionProfile>;
+    existingExecutionProfile?: Plan['execution_profile'];
+    resetStatuses?: boolean;
+    config?: Pick<PluginConfig, 'execution_mode'>;
+}
+export declare function resolvePlanningProfile({ directory, incomingExecutionProfile, existingExecutionProfile, resetStatuses, config, }: ResolvePlanningProfileOptions): ResolvedPlanningProfile;
+export declare function normalizeExecutionProfileForHash(profile: Plan['execution_profile']): Record<string, unknown> | undefined;
+export {};

package/dist/services/spec-drift-recovery.d.ts

@@ -0,0 +1,84 @@
+import { validateSwarmPath } from '../hooks/utils.js';
+import { tryAcquireLock } from '../parallel/file-locks.js';
+import { takeSnapshotEvent } from '../plan/ledger.js';
+import { loadPlanJsonOnly, savePlan } from '../plan/manager.js';
+import { readEffectiveSpecSync } from '../sdd/effective-spec.js';
+import type { SpecDriftAcknowledgedEvent, SpecDriftRepairedEvent } from '../types/events.js';
+import { bunWrite } from '../utils/bun-compat.js';
+import { assertProjectRoot } from '../utils/project-boundary.js';
+import { invalidateCachedArtifact } from '../utils/swarm-artifact-cache.js';
+type RecoveryMode = 'acknowledge' | 'repair';
+type RecoveryActor = 'cli' | 'spec_write' | 'unknown' | 'user';
+type RecoveryState = 'COMMITTED' | 'PREPARED';
+interface SpecStalenessMarker {
+    planTitle: string;
+    phase: number;
+    specHash_plan: string | null;
+    specHash_current: string | null;
+    reason: string;
+    timestamp: string;
+}
+interface SpecDriftRecoveryWal {
+    version: 2;
+    mode: RecoveryMode;
+    state: RecoveryState;
+    transitionId: string;
+    markerHash: string;
+    planTitle: string;
+    phase: number;
+    previousHash: string | null;
+    newHash: string | null;
+    specContent: string | null;
+    actor: RecoveryActor;
+    recordedAt: string;
+}
+export interface SpecDriftRecoveryResult {
+    status: 'applied' | 'cleanup_pending' | 'corrupt_marker' | 'failed' | 'no_marker' | 'retry_later';
+    mode: RecoveryMode;
+    message: string;
+    phase?: number;
+    planTitle?: string;
+    previousHash?: string | null;
+    newHash?: string | null;
+    transitionId?: string;
+}
+export declare const _internals: {
+    appendEvent: typeof appendEvent;
+    assertProjectRoot: typeof assertProjectRoot;
+    bunWrite: typeof bunWrite;
+    invalidateCachedArtifact: typeof invalidateCachedArtifact;
+    loadPlanJsonOnly: typeof loadPlanJsonOnly;
+    now: typeof now;
+    parseMarker: typeof parseMarker;
+    parseWal: typeof parseWal;
+    readEffectiveSpecSync: typeof readEffectiveSpecSync;
+    readFileText: typeof readFileText;
+    savePlan: typeof savePlan;
+    tryAcquireLock: typeof tryAcquireLock;
+    takeSnapshotEvent: typeof takeSnapshotEvent;
+    unlinkIfExists: typeof unlinkIfExists;
+    validateSwarmPath: typeof validateSwarmPath;
+    verifyEventPresence: typeof verifyEventPresence;
+    ensureSnapshotEvent: typeof ensureSnapshotEvent;
+    verifySnapshot: typeof verifySnapshot;
+    writeWal: typeof writeWal;
+};
+declare function now(): string;
+declare function parseMarker(raw: string): SpecStalenessMarker | null;
+declare function parseWal(raw: string): SpecDriftRecoveryWal | null;
+declare function readFileText(filePath: string): Promise<string | null>;
+declare function unlinkIfExists(filePath: string): Promise<boolean>;
+declare function writeWal(walPath: string, wal: SpecDriftRecoveryWal): Promise<void>;
+declare function verifySnapshot(snapshotPath: string, currentSpec: {
+    content: string;
+} | null): Promise<void>;
+declare function ensureSnapshotEvent(directory: string, plan: NonNullable<Awaited<ReturnType<typeof loadPlanJsonOnly>>>, transitionId: string): Promise<void>;
+declare function appendEvent(eventsPath: string, event: SpecDriftAcknowledgedEvent | SpecDriftRepairedEvent): Promise<void>;
+declare function verifyEventPresence(eventsPath: string, eventType: 'spec_drift_acknowledged' | 'spec_drift_repaired', transitionId: string): Promise<boolean>;
+export declare function reconcileSpecDrift(directory: string, options: {
+    mode: RecoveryMode;
+    actor: RecoveryActor;
+    /** Caller already holds the spec.md lock across the canonical spec write. */
+    specLockAlreadyHeld?: boolean;
+}): Promise<SpecDriftRecoveryResult>;
+export {};

package/dist/session/snapshot-writer.d.ts

@@ -2,6 +2,7 @@
  * Session snapshot writer for OpenCode Swarm plugin.
  * Serializes swarmState to .swarm/session/state.json using atomic write (temp-file + rename).
  */
+import { TASK_WORKFLOW_SCHEMA_MARKER } from '../gate-evidence.js';
 import type { AgentSessionState, DelegationEntry, ToolAggregate } from '../state';
 import { swarmState } from '../state';
 /**
@@ -114,8 +115,9 @@ export interface SerializedInvocationWindow {
  * Snapshot data structure written to disk
  */
 export interface SnapshotData {
-    version: 1 | 2;
+    version: 1 | 2 | 3;
     writtenAt: number;
+    workflowSchema?: typeof TASK_WORKFLOW_SCHEMA_MARKER;
     toolAggregates: Record<string, ToolAggregate>;
     activeAgent: Record<string, string>;
     delegationChains: Record<string, DelegationEntry[]>;

package/dist/state.d.ts

@@ -10,6 +10,7 @@ import type { OpencodeClient } from '@opencode-ai/sdk';
 import type { CouncilAgent } from './council/types';
 import { type QaGates } from './db/qa-gate-profile.js';
 import { type EnvironmentProfile } from './environment/profile.js';
+import { type TaskWorkflowMetadata } from './gate-evidence';
 import type { EscalationTracker } from './prm/escalation.js';
 import type { PatternMatch } from './prm/types.js';
 import { AgentRunContext } from './state/agent-run-context.js';
@@ -63,7 +64,14 @@ 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' | 'complete';
+export type TaskWorkflowState = 'idle' | 'coder_delegated' | 'pre_check_passed' | 'reviewer_run' | 'tests_run' | 'rework_required' | 'complete' | 'blocked';
+export interface TaskWorkflowCacheEntry {
+    generation: number;
+    retryCount: number;
+    lastOutcome: TaskWorkflowMetadata['lastOutcome'];
+    lastTransitionId: string | null;
+    updatedAt: string;
+}
 /**
  * Upper bound for per-session task file-attribution entries.
  *
@@ -187,6 +195,8 @@ export interface AgentSessionState {
     qaSkipTaskIds: string[];
     /** Per-task workflow state — taskId → current state */
     taskWorkflowStates: Map<string, TaskWorkflowState>;
+    /** Exact-task workflow cache keyed by taskId. Durable evidence remains authoritative. */
+    taskWorkflowCache?: Map<string, TaskWorkflowCacheEntry>;
     /**
      * PR 2 Stage B barrier: per-task set of completed Stage B agents.
      * Order-independent — either 'reviewer' or 'test_engineer' may complete first.
@@ -213,6 +223,8 @@ export interface AgentSessionState {
          */
         rewarded?: boolean;
     }>;
+    /** Generation captured when the first member of a task council is dispatched. */
+    taskCouncilWorkflowGeneration?: Map<string, number>;
     /**
      * Per-(task,round) required council members for the next submission attempt.
      * Key format: `${taskId}:${roundNumber}`.
@@ -1026,6 +1038,7 @@ export declare function resetModifiedFilesForTask(session: AgentSessionState, ta
  * Epic sessions retain it until `epic_record_divergence` consumes the entry.
  */
 export declare function completeModifiedFilesForTask(session: AgentSessionState, taskId: string): void;
+export declare function updateTaskWorkflowCache(session: AgentSessionState, taskId: string, overrides: Partial<TaskWorkflowCacheEntry>): void;
 /**
  * Advance a task's workflow state. Validates forward-only transitions.
  * Throws 'INVALID_TASK_STATE_TRANSITION: [taskId] [current] → [requested]' on illegal transition.
@@ -1061,23 +1074,12 @@ export declare function canAdvanceTaskState(session: AgentSessionState, taskId:
     requireAllMembers?: boolean;
 }): boolean;
 /**
- * Advance the per-task workflow state machine AND persist the corresponding
- * plan.json status at meaningful workflow boundaries.
- *
- * The two-layer model splits in-memory workflow state (Layer 1, fast, used by
- * gates) from the durable plan (Layer 2, projected to plan.md). Without this
- * bridge, council APPROVE → 'complete' updates Layer 1 only and plan.md goes
- * stale. This helper closes the gap by mapping:
- *   - 'coder_delegated' → plan.json status 'in_progress'
- *   - 'complete'        → plan.json status 'completed'
- * Other transitions are in-memory only (the task is already in_progress on disk
- * once coder_delegated has fired).
- *
- * Persistence errors are logged and swallowed so a transient disk failure does
- * not break the in-memory state machine — matches the existing defensive
- * pattern around advanceTaskState call sites.
+ * Legacy compatibility wrapper for diagnostic-only intermediate projections.
+ * Durable coder/terminal boundaries must use the exact-task evidence reducer
+ * and the plan→evidence transaction/WAL; this wrapper intentionally refuses
+ * those states so no caller can recreate the former split-brain writer.
  */
-export declare function advanceTaskStateAndPersist(session: AgentSessionState, taskId: string, newState: TaskWorkflowState, directory: string, options?: {
+export declare function advanceTaskStateAndPersist(session: AgentSessionState, taskId: string, newState: TaskWorkflowState, _directory: string, options?: {
     telemetrySessionId?: string;
     emitTelemetry?: boolean;
 }, councilConfig?: {

package/dist/summaries/schema.d.ts

@@ -22,8 +22,8 @@ export declare const MAX_LIST_ITEMS = 5;
 /** Verdict vocabulary — mirrors the phase-council gate (APPROVE | CONCERNS | REJECT). */
 export declare const SupervisorVerdictSchema: z.ZodEnum<{
     APPROVE: "APPROVE";
-    REJECT: "REJECT";
     CONCERNS: "CONCERNS";
+    REJECT: "REJECT";
 }>;
 export type SupervisorVerdict = z.infer<typeof SupervisorVerdictSchema>;
 /** Count whitespace-delimited words in a string. */
@@ -130,8 +130,8 @@ export declare const ArchitectureSupervisorReportSchema: z.ZodObject<{
     phase: z.ZodNumber;
     verdict: z.ZodEnum<{
         APPROVE: "APPROVE";
-        REJECT: "REJECT";
         CONCERNS: "CONCERNS";
+        REJECT: "REJECT";
     }>;
     findings: z.ZodDefault<z.ZodArray<z.ZodObject<{
         severity: z.ZodEnum<{

package/dist/telemetry.d.ts

@@ -26,7 +26,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';
+ | 'prm_hard_stop_delivered' | 'agent_conflict_detected' | 'close_archive_result' | 'knowledge_receipt_transition';
 /** Stable classification for how a reviewer-gate decision was established. */
 export type ReviewerGateEvidenceKind = 'genuine' | 'fallback' | 'data_quality' | 'block';
 /**

package/dist/tools/convene-council.d.ts

@@ -8,23 +8,23 @@ export declare const ArgsSchema: z.ZodObject<{
     verdicts: z.ZodArray<z.ZodObject<{
         agent: z.ZodEnum<{
             reviewer: "reviewer";
-            test_engineer: "test_engineer";
+            critic: "critic";
             explorer: "explorer";
+            test_engineer: "test_engineer";
             sme: "sme";
-            critic: "critic";
         }>;
         verdict: z.ZodEnum<{
             APPROVE: "APPROVE";
-            REJECT: "REJECT";
             CONCERNS: "CONCERNS";
+            REJECT: "REJECT";
         }>;
         confidence: z.ZodNumber;
         findings: z.ZodArray<z.ZodObject<{
             severity: z.ZodEnum<{
-                LOW: "LOW";
-                MEDIUM: "MEDIUM";
-                HIGH: "HIGH";
                 CRITICAL: "CRITICAL";
+                HIGH: "HIGH";
+                MEDIUM: "MEDIUM";
+                LOW: "LOW";
             }>;
             category: z.ZodString;
             location: z.ZodString;

package/dist/tools/index.d.ts

@@ -106,8 +106,11 @@ export { lean_turbo_status } from './lean-turbo-status';
 export { lint_spec } from './lint-spec';
 export { mutation_test } from './mutation-test';
 export { executePreparePrWorkflowCheckout, prepare_pr_workflow_checkout, } from './prepare-pr-workflow-checkout';
+export { executeRebindPrFeedbackHead, rebind_pr_feedback_head, } from './rebind-pr-feedback-head';
+export { executeRecordImplementationReview, record_implementation_review, } from './record-implementation-review';
 export { executeRecordIssuePublication, record_issue_publication, } from './record-issue-publication';
 export { executeRecordIssueReproduction, record_issue_reproduction, } from './record-issue-reproduction';
+export { executeRecordRecurrenceSweep, record_recurrence_sweep, } from './record-recurrence-sweep';
 export { executeRunPrFeedbackStageA, run_pr_feedback_stage_a, } from './run-pr-feedback-stage-a';
 export { symbols } from './symbols';
 export { type SyntaxCheckFileResult, type SyntaxCheckInput, type SyntaxCheckResult, syntax_check, syntaxCheck, } from './syntax-check';

package/dist/tools/manifest.d.ts

@@ -46,8 +46,11 @@ export declare const TOOL_MANIFEST: {
     abort_pr_workflow: () => ToolDefinition;
     approve_plan_critic: () => ToolDefinition;
     prepare_pr_workflow_checkout: () => ToolDefinition;
+    record_implementation_review: () => ToolDefinition;
     record_issue_publication: () => ToolDefinition;
     record_issue_reproduction: () => ToolDefinition;
+    record_recurrence_sweep: () => ToolDefinition;
+    rebind_pr_feedback_head: () => ToolDefinition;
     run_pr_feedback_stage_a: () => ToolDefinition;
     submit_council_verdicts: () => ToolDefinition;
     submit_phase_council_verdicts: () => ToolDefinition;

package/dist/tools/phase-complete.d.ts

@@ -3,6 +3,15 @@
  * Core implementation - gathers data, enforces policy, writes event, resets state.
  */
 import type { ToolDefinition } from '@opencode-ai/plugin/tool';
+/** Narrow seam for receipt/plan ordering tests. */
+export declare const phaseCompleteReceiptInternals: {
+    recordPhaseCloseIntent: (directory: string, phase: string, sessionId?: string, taskId?: string) => Promise<import("../hooks/knowledge-receipt-ledger.js").ReceiptLedgerResult<{
+        event_id: string;
+    }>>;
+    commitPhaseClosed: (directory: string, phase: string, sessionId?: string, taskId?: string) => Promise<import("../hooks/knowledge-receipt-ledger.js").ReceiptLedgerResult<{
+        event_id: string;
+    }>>;
+};
 import type { ReviewModelDispatcher } from '../review/contracts.js';
 import type { ReviewAgentModelRegistry } from '../review/runtime.js';
 /**

package/dist/tools/rebind-pr-feedback-head.d.ts

@@ -0,0 +1,17 @@
+/**
+ * rebind_pr_feedback_head — controlled base-sync/rebind transition for a
+ * PR_FEEDBACK workflow (issue #2131 criterion C2).
+ *
+ * After a merge/rebase used to resolve base drift or conflicts, the local
+ * history is no longer a direct child of the immutable intake head, so the
+ * ordinary exactly-one-reviewed-commit publication path can never be satisfied.
+ * This tool moves the intake head to the new verified remote PR head and
+ * invalidates every ancestry-bound receipt (Stage A, verification batches,
+ * ordered gates), forcing the full mechanical ladder to re-run on the new
+ * ancestry. Refuses while publication is armed or while lanes are in flight.
+ */
+import { createSwarmTool } from './create-tool';
+export declare function executeRebindPrFeedbackHead(args: unknown, directory: string, context?: {
+    sessionID?: string;
+}): Promise<string>;
+export declare const rebind_pr_feedback_head: ReturnType<typeof createSwarmTool>;

package/dist/tools/record-implementation-review.d.ts

@@ -0,0 +1,19 @@
+/**
+ * record_implementation_review — persist an issue-bound independent
+ * implementation-review receipt for the issue-trace workflow (issue #2131
+ * residual criterion B).
+ *
+ * Records that FRESH-context reviewer and critic passes (separate contexts
+ * from the implementer) both delivered APPROVE verdicts over the
+ * implementation diff. This is an agent self-attestation of the review
+ * discipline — it records the verdicts, the reviewed diff range, and the
+ * calling session, but does not itself authenticate that the review contexts
+ * were genuinely fresh; under PR-review/feedback modes the mechanically
+ * authenticated reviewer gates remain the PR-workflow machinery. The trace
+ * engine will not hand off to commit-pr until this receipt exists.
+ */
+import { createSwarmTool } from './create-tool';
+export declare function executeRecordImplementationReview(args: unknown, directory: string, context?: {
+    sessionID?: string;
+}): Promise<string>;
+export declare const record_implementation_review: ReturnType<typeof createSwarmTool>;

package/dist/tools/record-recurrence-sweep.d.ts

@@ -0,0 +1,17 @@
+/**
+ * record_recurrence_sweep — persist an issue-bound recurrence-sweep receipt for
+ * the issue-trace workflow (issue #2131 residual criterion B).
+ *
+ * Modeled on issue-tracer Phase 4.2: for a real defect class the sweep must
+ * record the pattern statement, explicit search predicates, a typed
+ * disposition for every hit, and a guardrail with proof it catches the
+ * original defect. The "no defect class" fast path (a change that corrects no
+ * incorrect behavior) requires a one-line justification. The trace engine will
+ * not hand off to commit-pr until this receipt (or a real defect-class sweep)
+ * exists; the reader validates the same shape.
+ */
+import { createSwarmTool } from './create-tool';
+export declare function executeRecordRecurrenceSweep(args: unknown, directory: string, context?: {
+    sessionID?: string;
+}): Promise<string>;
+export declare const record_recurrence_sweep: ReturnType<typeof createSwarmTool>;

package/dist/tools/run-pr-feedback-stage-a.d.ts

@@ -35,6 +35,14 @@ declare const StageACheckSchema: z.ZodObject<{
         feedback_item_id: z.ZodString;
         target: z.ZodString;
         expected_behavior: z.ZodString;
+        proof_kind: z.ZodEnum<{
+            conflict: "conflict";
+            metadata: "metadata";
+            defect: "defect";
+            "source-proof": "source-proof";
+            ci: "ci";
+            "user-decision": "user-decision";
+        }>;
     }, z.core.$strict>>>;
     working_directory: z.ZodOptional<z.ZodString>;
     obligation_id: z.ZodOptional<z.ZodString>;

package/dist/tools/save-plan.d.ts

@@ -82,6 +82,12 @@ export interface SavePlanArgs {
      * Omit to leave the current profile unchanged.
      */
     execution_profile?: Partial<ExecutionProfile>;
+    /**
+     * Narrow recovery mode for stale plan.json projections whose ledger replay
+     * previously failed. When true, save_plan will only accept an unchanged
+     * semantic re-save that reconverges plan.json with the authoritative ledger.
+     */
+    reconcile_ledger_projection?: boolean;
 }
 /**
  * Result from executing save_plan
@@ -115,6 +121,8 @@ interface RequirementCoverageResult {
     missing: RequirementCoverageEntry[];
     blocking_missing: RequirementCoverageEntry[];
 }
+export declare function isLedgerProjectionReconcileRequest(args: Pick<SavePlanArgs, 'reconcile_ledger_projection'>): boolean;
+export declare function isPureLedgerProjectionReconcileRequest(args: SavePlanArgs): boolean;
 /**
  * Detect template placeholder content (e.g., [task], [Project], [description], [N]).
  * These patterns indicate the LLM reproduced template examples literally rather than

package/dist/tools/submit-phase-council-verdicts.d.ts

@@ -8,23 +8,23 @@ export declare const ArgsSchema: z.ZodObject<{
     verdicts: z.ZodArray<z.ZodObject<{
         agent: z.ZodEnum<{
             reviewer: "reviewer";
-            test_engineer: "test_engineer";
+            critic: "critic";
             explorer: "explorer";
+            test_engineer: "test_engineer";
             sme: "sme";
-            critic: "critic";
         }>;
         verdict: z.ZodEnum<{
             APPROVE: "APPROVE";
-            REJECT: "REJECT";
             CONCERNS: "CONCERNS";
+            REJECT: "REJECT";
         }>;
         confidence: z.ZodNumber;
         findings: z.ZodArray<z.ZodObject<{
             severity: z.ZodEnum<{
-                LOW: "LOW";
-                MEDIUM: "MEDIUM";
-                HIGH: "HIGH";
                 CRITICAL: "CRITICAL";
+                HIGH: "HIGH";
+                MEDIUM: "MEDIUM";
+                LOW: "LOW";
             }>;
             category: z.ZodString;
             location: z.ZodString;