@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/{tier → domains/ant}/ant_lane.js

@@ -12,13 +12,14 @@
  *
  * @since v1.6.0
  */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { v4 as uuid } from "uuid";
-import { getFeatureGate, SWARM_FEATURES } from "./feature_gate.js";
-import { CheckpointScanner } from "./checkpoint.js";
-const STATE_FILE = "ant_lane_state.v1.json";
-const SIGNALS_FILE = "checkpoint_signals.v1.jsonl";
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { v4 as uuid } from 'uuid';
+import { writeFileAtomic } from '../../kernel/atomic_writer.js';
+import { getFeatureGate, SWARM_FEATURES } from '../../tier/feature_gate.js';
+import { CheckpointScanner } from './checkpoint.js';
+const STATE_FILE = 'ant_lane_state.v1.json';
+const SIGNALS_FILE = 'checkpoint_signals.v1.jsonl';
 // ============================================================================
 // Ant Lane Class
 // ============================================================================
@@ -56,12 +57,13 @@ export class AntLane {
     /**
      * Add a task to the queue
      */
-    addTask(type, targetPaths) {
+    addTask(type, targetPaths, payload) {
         const task = {
             id: uuid(),
             type,
             target_paths: targetPaths,
-            status: "queued",
+            status: 'queued',
+            ...(payload !== undefined && { payload }),
             created_at: new Date().toISOString(),
         };
         this.state.tasks.push(task);
@@ -77,20 +79,20 @@ export class AntLane {
         // Check feature gate
         const gate = getFeatureGate();
         if (!gate.isAllowed(SWARM_FEATURES.ANT_MODE)) {
-            throw new Error("Ant Lane requires swarm feature access");
+            throw new Error('Ant Lane requires swarm feature access');
         }
         // Check if paused
         if (this.state.paused) {
             return null;
         }
         // Find next queued task
-        const task = this.state.tasks.find((t) => t.status === "queued");
+        const task = this.state.tasks.find(t => t.status === 'queued');
         if (!task) {
             return null;
         }
         // Update state
         this.state.current_task_id = task.id;
-        task.status = "scanning";
+        task.status = 'scanning';
         task.started_at = new Date().toISOString();
         this.saveState();
         // Run checkpoint scan
@@ -106,26 +108,26 @@ export class AntLane {
         // Record checkpoint signal
         this.recordCheckpoint(checkpoint);
         // Apply verdict
-        if (checkpoint.verdict === "pass") {
-            task.status = "ready";
+        if (checkpoint.verdict === 'pass') {
+            task.status = 'ready';
             task.decision = {
                 checkpoint_id: checkpoint.checkpoint_id,
                 task_id: task.id,
-                decision: "proceed",
-                decided_by: "auto_rule",
+                decision: 'proceed',
+                decided_by: 'auto_rule',
                 decided_at: new Date().toISOString(),
-                reason: "Checkpoint passed",
+                reason: 'Checkpoint passed',
             };
         }
-        else if (checkpoint.verdict === "block") {
-            task.status = "blocked";
+        else if (checkpoint.verdict === 'block') {
+            task.status = 'blocked';
             this.state.stats.blocked++;
             this.state.stats.queued--;
             this.pause(`Task ${task.id} blocked: ${checkpoint.recommendation.reason}`);
         }
         else {
             // warn - pause for review
-            task.status = "scanning"; // Keep in scanning until decision
+            task.status = 'scanning'; // Keep in scanning until decision
             this.pause(`Task ${task.id} needs review: ${checkpoint.recommendation.reason}`);
         }
         this.saveState();
@@ -135,25 +137,25 @@ export class AntLane {
      * Submit a decision for a task checkpoint
      */
     submitDecision(taskId, decision) {
-        const task = this.state.tasks.find((t) => t.id === taskId);
+        const task = this.state.tasks.find(t => t.id === taskId);
         if (!task) {
             throw new Error(`Task ${taskId} not found`);
         }
         task.decision = decision;
-        if (decision.decision === "proceed") {
-            task.status = "ready";
+        if (decision.decision === 'proceed') {
+            task.status = 'ready';
         }
-        else if (decision.decision === "abort") {
-            task.status = "blocked";
+        else if (decision.decision === 'abort') {
+            task.status = 'blocked';
             this.state.stats.blocked++;
             this.state.stats.queued--;
         }
-        else if (decision.decision === "modify") {
+        else if (decision.decision === 'modify') {
             // Apply modifications and re-queue
             if (decision.modifications?.remove_targets) {
-                task.target_paths = task.target_paths.filter((p) => !decision.modifications.remove_targets.includes(p));
+                task.target_paths = task.target_paths.filter(p => !decision.modifications.remove_targets.includes(p));
             }
-            task.status = "queued";
+            task.status = 'queued';
             task.checkpoint = undefined;
         }
         // Resume if was paused for this task
@@ -166,11 +168,11 @@ export class AntLane {
      * Mark a task as completed
      */
     completeTask(taskId) {
-        const task = this.state.tasks.find((t) => t.id === taskId);
-        if (!task || task.status !== "ready") {
+        const task = this.state.tasks.find(t => t.id === taskId);
+        if (!task || task.status !== 'ready') {
             throw new Error(`Task ${taskId} not ready for completion`);
         }
-        task.status = "completed";
+        task.status = 'completed';
         task.completed_at = new Date().toISOString();
         this.state.stats.completed++;
         this.state.stats.queued--;
@@ -181,7 +183,7 @@ export class AntLane {
      * Get a task by ID
      */
     getTask(taskId) {
-        return this.state.tasks.find((t) => t.id === taskId);
+        return this.state.tasks.find(t => t.id === taskId);
     }
     /**
      * Get all tasks
@@ -234,14 +236,14 @@ export class AntLane {
      */
     getFacts() {
         return {
-            "ant.active": !this.state.paused && this.state.stats.queued > 0,
-            "ant.campaign_id": this.state.campaign_id,
-            "ant.queue_length": this.state.stats.queued,
-            "ant.current_task_id": this.state.current_task_id,
-            "ant.checkpoint.verdict": this.getCurrentCheckpointVerdict(),
-            "ant.checkpoint.blocked_count": this.state.stats.blocked,
-            "ant.paused": this.state.paused,
-            "ant.paused_reason": this.state.paused_reason ?? null,
+            'ant.active': !this.state.paused && this.state.stats.queued > 0,
+            'ant.campaign_id': this.state.campaign_id,
+            'ant.queue_length': this.state.stats.queued,
+            'ant.current_task_id': this.state.current_task_id,
+            'ant.checkpoint.verdict': this.getCurrentCheckpointVerdict(),
+            'ant.checkpoint.blocked_count': this.state.stats.blocked,
+            'ant.paused': this.state.paused,
+            'ant.paused_reason': this.state.paused_reason ?? null,
         };
     }
     // ========================================
@@ -250,13 +252,13 @@ export class AntLane {
     estimateImpact(task) {
         const count = task.target_paths.length;
         if (count > 10)
-            return "high";
+            return 'high';
         if (count > 3)
-            return "medium";
-        return "low";
+            return 'medium';
+        return 'low';
     }
     getCurrentCheckpointVerdict() {
-        const current = this.state.tasks.find((t) => t.id === this.state.current_task_id);
+        const current = this.state.tasks.find(t => t.id === this.state.current_task_id);
         return current?.checkpoint?.verdict ?? null;
     }
     createInitialState(campaignId) {
@@ -269,10 +271,10 @@ export class AntLane {
         };
     }
     loadState() {
-        const statePath = path.join(this.workspace, ".vibe", "cache", "bitnet", STATE_FILE);
+        const statePath = path.join(this.workspace, '.vibe', 'cache', 'bitnet', STATE_FILE);
         if (fs.existsSync(statePath)) {
             try {
-                return JSON.parse(fs.readFileSync(statePath, "utf-8"));
+                return JSON.parse(fs.readFileSync(statePath, 'utf-8'));
             }
             catch {
                 return null;
@@ -281,20 +283,20 @@ export class AntLane {
         return null;
     }
     saveState() {
-        const cacheDir = path.join(this.workspace, ".vibe", "cache", "bitnet");
+        const cacheDir = path.join(this.workspace, '.vibe', 'cache', 'bitnet');
         if (!fs.existsSync(cacheDir)) {
             fs.mkdirSync(cacheDir, { recursive: true });
         }
         const statePath = path.join(cacheDir, STATE_FILE);
-        fs.writeFileSync(statePath, JSON.stringify(this.state, null, 2));
+        writeFileAtomic(statePath, JSON.stringify(this.state, null, 2));
     }
     recordCheckpoint(checkpoint) {
-        const cacheDir = path.join(this.workspace, ".vibe", "cache", "bitnet");
+        const cacheDir = path.join(this.workspace, '.vibe', 'cache', 'bitnet');
         if (!fs.existsSync(cacheDir)) {
             fs.mkdirSync(cacheDir, { recursive: true });
         }
         const signalsPath = path.join(cacheDir, SIGNALS_FILE);
-        fs.appendFileSync(signalsPath, JSON.stringify(checkpoint) + "\n");
+        fs.appendFileSync(signalsPath, JSON.stringify(checkpoint) + '\n');
     }
 }
 // ============================================================================

package/build/domains/ant/ant_lane_remediation.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Ant Lane Remediation Dispatcher
+ *
+ * Bridges AntLane (FIFO task queue) with AntRemediator (code surgery).
+ * Provides convenience functions to:
+ *   - Add REMEDIATION tasks with typed payloads
+ *   - Execute ready REMEDIATION tasks via AntRemediator
+ *
+ * @since v1.8.0
+ */
+import type { AntLane } from './ant_lane.js';
+import type { AntLaneTask } from './checkpoint_types.js';
+import { type RemediationPayload, type SurgeryResult } from './ant_remediator.js';
+import type { BlockStore } from '../../kernel/blocks/store.js';
+import type { ChainManager } from '../../kernel/blocks/chain.js';
+import type { PatchHunk } from '../../kernel/smart_patcher.js';
+export declare const REMEDIATION_TASK_TYPE: "REMEDIATION";
+export declare const PATCH_REMEDIATION_TASK_TYPE: "PATCH_REMEDIATION";
+/**
+ * Add a REMEDIATION task to the AntLane queue.
+ *
+ * Wraps `lane.addTask()` with typed payload and correct target_paths.
+ */
+export declare function addRemediationTask(lane: AntLane, payload: RemediationPayload): AntLaneTask;
+/**
+ * Execute a ready REMEDIATION task via AntRemediator.
+ *
+ * Validates task state, dispatches to AntRemediator, and updates
+ * the lane based on the surgery result:
+ *   - COMPLETED → lane.completeTask()
+ *   - BLOCKED/FAILED → lane.pause()
+ *
+ * @throws if task not found, not ready, not REMEDIATION, or missing payload
+ */
+export declare function executeRemediationTask(lane: AntLane, store: BlockStore, chainManager: ChainManager, taskId: string): Promise<SurgeryResult>;
+export interface PatchRemediationPayload {
+    filePath: string;
+    hunks: PatchHunk[];
+    reason: string;
+}
+/**
+ * Add a PATCH_REMEDIATION task to the AntLane queue.
+ */
+export declare function addPatchRemediationTask(lane: AntLane, payload: PatchRemediationPayload): AntLaneTask;
+/**
+ * Execute a ready PATCH_REMEDIATION task via Smart Patcher + AntRemediator.
+ *
+ * Flow: read file → applyPatch() → contentToBlocks() → performSurgery()
+ */
+export declare function executePatchRemediationTask(lane: AntLane, store: BlockStore, chainManager: ChainManager, taskId: string, workspaceRoot: string): Promise<SurgeryResult>;

package/build/domains/ant/ant_lane_remediation.js

@@ -0,0 +1,157 @@
+/**
+ * Ant Lane Remediation Dispatcher
+ *
+ * Bridges AntLane (FIFO task queue) with AntRemediator (code surgery).
+ * Provides convenience functions to:
+ *   - Add REMEDIATION tasks with typed payloads
+ *   - Execute ready REMEDIATION tasks via AntRemediator
+ *
+ * @since v1.8.0
+ */
+import { createAntRemediator, } from './ant_remediator.js';
+import { computeChainDelta, recordRemediation } from './remediation_log.js';
+import { buildPatchPayload } from './payload_builder.js';
+// ============================================================================
+// Constants
+// ============================================================================
+export const REMEDIATION_TASK_TYPE = 'REMEDIATION';
+export const PATCH_REMEDIATION_TASK_TYPE = 'PATCH_REMEDIATION';
+// ============================================================================
+// Public API
+// ============================================================================
+/**
+ * Add a REMEDIATION task to the AntLane queue.
+ *
+ * Wraps `lane.addTask()` with typed payload and correct target_paths.
+ */
+export function addRemediationTask(lane, payload) {
+    return lane.addTask(REMEDIATION_TASK_TYPE, [payload.filePath], payload);
+}
+/**
+ * Execute a ready REMEDIATION task via AntRemediator.
+ *
+ * Validates task state, dispatches to AntRemediator, and updates
+ * the lane based on the surgery result:
+ *   - COMPLETED → lane.completeTask()
+ *   - BLOCKED/FAILED → lane.pause()
+ *
+ * @throws if task not found, not ready, not REMEDIATION, or missing payload
+ */
+export async function executeRemediationTask(lane, store, chainManager, taskId) {
+    const task = lane.getTask(taskId);
+    if (!task) {
+        throw new Error(`Task not found: ${taskId}`);
+    }
+    if (task.status !== 'ready') {
+        throw new Error(`Task not ready: ${task.status}`);
+    }
+    if (task.type !== REMEDIATION_TASK_TYPE) {
+        throw new Error(`Not a REMEDIATION task: ${task.type}`);
+    }
+    if (!task.payload) {
+        throw new Error('Missing remediation payload');
+    }
+    const payload = task.payload;
+    // Capture old chain blocks BEFORE surgery (surgery deletes old chain)
+    const preOldRootHash = store.getRootHashBySourcePath(payload.filePath);
+    const preOldBlocks = preOldRootHash ? (store.getChainBlocks(preOldRootHash) ?? []) : [];
+    const remediator = createAntRemediator(store, chainManager);
+    const result = await remediator.execute(payload);
+    if (result.status === 'COMPLETED') {
+        lane.completeTask(taskId);
+        // Record remediation history (best-effort)
+        try {
+            const newBlocks = store.getChainBlocks(result.newRootHash) ?? [];
+            const delta = computeChainDelta(preOldBlocks, newBlocks);
+            await recordRemediation(store.workspaceRoot, {
+                remediation_id: `rem_${taskId}`,
+                timestamp: new Date().toISOString(),
+                task_id: taskId,
+                filePath: payload.filePath,
+                reason: payload.reason,
+                status: 'COMPLETED',
+                oldRootHash: result.oldRootHash,
+                newRootHash: result.newRootHash,
+                snapshotId: result.snapshotId,
+                delta,
+                usedDelta: result.usedDelta,
+            });
+        }
+        catch {
+            // Best-effort: don't fail the task for logging errors
+        }
+    }
+    else {
+        lane.pause(`Remediation ${result.status}: ${result.error ?? 'unknown'}`);
+    }
+    return result;
+}
+/**
+ * Add a PATCH_REMEDIATION task to the AntLane queue.
+ */
+export function addPatchRemediationTask(lane, payload) {
+    return lane.addTask(PATCH_REMEDIATION_TASK_TYPE, [payload.filePath], payload);
+}
+/**
+ * Execute a ready PATCH_REMEDIATION task via Smart Patcher + AntRemediator.
+ *
+ * Flow: read file → applyPatch() → contentToBlocks() → performSurgery()
+ */
+export async function executePatchRemediationTask(lane, store, chainManager, taskId, workspaceRoot) {
+    const task = lane.getTask(taskId);
+    if (!task) {
+        throw new Error(`Task not found: ${taskId}`);
+    }
+    if (task.status !== 'ready') {
+        throw new Error(`Task not ready: ${task.status}`);
+    }
+    if (task.type !== PATCH_REMEDIATION_TASK_TYPE) {
+        throw new Error(`Not a PATCH_REMEDIATION task: ${task.type}`);
+    }
+    if (!task.payload) {
+        throw new Error('Missing patch remediation payload');
+    }
+    const patchPayload = task.payload;
+    // Build remediation payload via Smart Patcher
+    const buildResult = await buildPatchPayload(store, patchPayload.filePath, workspaceRoot, patchPayload.hunks, patchPayload.reason);
+    if (!buildResult.success || !buildResult.payload) {
+        lane.pause(`Patch build failed: ${buildResult.error ?? 'unknown'}`);
+        return {
+            status: 'FAILED',
+            error: `PATCH_BUILD_FAILED: ${buildResult.error}`,
+        };
+    }
+    // Capture old chain blocks BEFORE surgery
+    const preOldRootHash = store.getRootHashBySourcePath(patchPayload.filePath);
+    const preOldBlocks = preOldRootHash ? (store.getChainBlocks(preOldRootHash) ?? []) : [];
+    const remediator = createAntRemediator(store, chainManager);
+    const result = await remediator.execute(buildResult.payload);
+    if (result.status === 'COMPLETED') {
+        lane.completeTask(taskId);
+        // Record remediation history (best-effort)
+        try {
+            const newBlocks = store.getChainBlocks(result.newRootHash) ?? [];
+            const delta = computeChainDelta(preOldBlocks, newBlocks);
+            await recordRemediation(store.workspaceRoot, {
+                remediation_id: `rem_${taskId}`,
+                timestamp: new Date().toISOString(),
+                task_id: taskId,
+                filePath: patchPayload.filePath,
+                reason: patchPayload.reason,
+                status: 'COMPLETED',
+                oldRootHash: result.oldRootHash,
+                newRootHash: result.newRootHash,
+                snapshotId: result.snapshotId,
+                delta,
+                usedDelta: result.usedDelta,
+            });
+        }
+        catch {
+            // Best-effort
+        }
+    }
+    else {
+        lane.pause(`Patch remediation ${result.status}: ${result.error ?? 'unknown'}`);
+    }
+    return result;
+}

package/build/domains/ant/ant_remediator.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Ant Remediator — Safe code surgery with FeatureGate
+ *
+ * Performs atomic code modifications through the BlockStore chain system:
+ *   1. Stale check — target block still in current chain?
+ *   2. Snapshot — backup current chain before mutation
+ *   3. Mutation — delete old chain, create new with patched blocks
+ *   4. Rollback — restore snapshot on failure
+ *
+ * @since v1.8.0
+ */
+import type { BlockInput } from '../../kernel/blocks/types.js';
+import type { BlockStore } from '../../kernel/blocks/store.js';
+import type { ChainManager } from '../../kernel/blocks/chain.js';
+export interface RemediationPayload {
+    filePath: string;
+    patch: BlockInput[];
+    targetBlockId: string;
+    reason: string;
+}
+export interface SurgeryResult {
+    status: 'COMPLETED' | 'BLOCKED' | 'FAILED';
+    error?: string;
+    oldRootHash?: string;
+    newRootHash?: string;
+    snapshotId?: string;
+    /** Whether delta (surgical) update was used instead of full recreate */
+    usedDelta?: boolean;
+}
+/**
+ * Performs a safe code surgery using existing building blocks.
+ *
+ * Can be called directly (bypasses FeatureGate) for testing or
+ * internal use. For production entry, use AntRemediator.execute().
+ */
+export declare function performSurgery(store: BlockStore, chainManager: ChainManager, payload: RemediationPayload): Promise<SurgeryResult>;
+/**
+ * Production entry point for code surgery with FeatureGate enforcement.
+ *
+ * Requires PRO tier (POST_ANALYSIS_FEATURES.AUTO_FIX).
+ */
+export declare class AntRemediator {
+    private store;
+    private chainManager;
+    constructor(store: BlockStore, chainManager: ChainManager);
+    execute(payload: RemediationPayload): Promise<SurgeryResult>;
+}
+export declare function createAntRemediator(store: BlockStore, chainManager: ChainManager): AntRemediator;

package/build/domains/ant/ant_remediator.js

@@ -0,0 +1,129 @@
+/**
+ * Ant Remediator — Safe code surgery with FeatureGate
+ *
+ * Performs atomic code modifications through the BlockStore chain system:
+ *   1. Stale check — target block still in current chain?
+ *   2. Snapshot — backup current chain before mutation
+ *   3. Mutation — delete old chain, create new with patched blocks
+ *   4. Rollback — restore snapshot on failure
+ *
+ * @since v1.8.0
+ */
+import { buildChangedBlocks } from '../../kernel/blocks/chain.js';
+import { createSnapshot, restoreSnapshot } from '../../kernel/blocks/snapshot.js';
+import { getFeatureGate, POST_ANALYSIS_FEATURES } from '../../tier/feature_gate.js';
+// ============================================================================
+// Core Surgery Function
+// ============================================================================
+/**
+ * Performs a safe code surgery using existing building blocks.
+ *
+ * Can be called directly (bypasses FeatureGate) for testing or
+ * internal use. For production entry, use AntRemediator.execute().
+ */
+export async function performSurgery(store, chainManager, payload) {
+    const { filePath, patch, targetBlockId, reason } = payload;
+    // Step 1: Stale check
+    const currentRootHash = store.getRootHashBySourcePath(filePath);
+    if (!currentRootHash) {
+        return { status: 'BLOCKED', error: 'NO_CHAIN_FOUND' };
+    }
+    const currentChain = store.getChain(currentRootHash);
+    if (!currentChain) {
+        return { status: 'BLOCKED', error: 'CHAIN_NOT_FOUND' };
+    }
+    const hasTarget = currentChain.blocks.some(b => b.block_id === targetBlockId);
+    if (!hasTarget) {
+        return { status: 'BLOCKED', error: 'TARGET_BLOCK_STALE' };
+    }
+    // Step 2: Snapshot before mutation
+    let snapshotId;
+    try {
+        const snapshot = await createSnapshot(store, {
+            name: `pre-surgery-${Date.now()}`,
+            description: reason,
+            chainRootHashes: [currentRootHash],
+        });
+        snapshotId = snapshot.snapshot_id;
+    }
+    catch (e) {
+        return { status: 'FAILED', error: `SNAPSHOT_FAILED: ${e}` };
+    }
+    // Step 3: Mutation — try delta-first, fallback to full recreate
+    try {
+        let newRootHash;
+        let usedDelta = false;
+        // Try delta path: check if surgical block replacement is possible
+        const oldBlocks = chainManager.getChainBlocks(currentRootHash);
+        const changedBlocks = oldBlocks ? buildChangedBlocks(oldBlocks, patch) : null;
+        if (changedBlocks !== null && changedBlocks.length > 0) {
+            // Delta path: surgical block replacement (preserves root_hash)
+            const deltaResult = chainManager.updateChainDelta({
+                rootHash: currentRootHash,
+                changedBlocks,
+            });
+            newRootHash = deltaResult.chain.root_hash;
+            usedDelta = true;
+        }
+        else if (changedBlocks !== null && changedBlocks.length === 0) {
+            // No-op: all blocks identical
+            newRootHash = currentRootHash;
+            usedDelta = true;
+        }
+        else {
+            // Full recreate (structural change or first block changed)
+            store.deleteChain(currentRootHash);
+            const result = chainManager.createChain({
+                sourcePath: filePath,
+                blocks: patch,
+            });
+            newRootHash = result.chain.root_hash;
+        }
+        return {
+            status: 'COMPLETED',
+            oldRootHash: currentRootHash,
+            newRootHash,
+            snapshotId,
+            usedDelta,
+        };
+    }
+    catch (e) {
+        // Step 4: Rollback on failure
+        try {
+            await restoreSnapshot(store, {
+                snapshotId: snapshotId,
+                overwrite: true,
+            });
+        }
+        catch {
+            // rollback also failed — critical error
+        }
+        return { status: 'FAILED', error: `SURGERY_FAILED: ${e}` };
+    }
+}
+// ============================================================================
+// AntRemediator Class
+// ============================================================================
+/**
+ * Production entry point for code surgery with FeatureGate enforcement.
+ *
+ * Requires PRO tier (POST_ANALYSIS_FEATURES.AUTO_FIX).
+ */
+export class AntRemediator {
+    store;
+    chainManager;
+    constructor(store, chainManager) {
+        this.store = store;
+        this.chainManager = chainManager;
+    }
+    async execute(payload) {
+        const gate = getFeatureGate();
+        if (!gate.isAllowed(POST_ANALYSIS_FEATURES.AUTO_FIX)) {
+            return { status: 'BLOCKED', error: 'FEATURE_GATE_PRO_REQUIRED' };
+        }
+        return performSurgery(this.store, this.chainManager, payload);
+    }
+}
+export function createAntRemediator(store, chainManager) {
+    return new AntRemediator(store, chainManager);
+}

package/build/{tier → domains/ant}/checkpoint.d.ts

@@ -14,7 +14,7 @@
  *
  * @since v1.6.0
  */
-import type { CheckpointInput, CheckpointOutput } from "./checkpoint_types.js";
+import type { CheckpointInput, CheckpointOutput } from './checkpoint_types.js';
 /**
  * Scanner for checkpoint validation.
  *