create-principles-disciple 1.85.0 → 1.87.0

package/core/dist/storage-adapter.d.ts

@@ -1,59 +0,0 @@
-/**
- * StorageAdapter interface for the Evolution SDK.
- *
- * This interface decouples the evolution engine from specific persistence
- * implementations (file system, SQLite, remote API). All higher-level
- * modules that need to read or mutate the principle ledger should depend
- * on this interface rather than importing principle-tree-ledger directly.
- *
- * The interface uses HybridLedgerStore from types.ts as the
- * canonical store shape, but future adapters can map alternative backends
- * to this shape.
- */
-import type { HybridLedgerStore } from './types.js';
-/**
- * Abstract storage adapter for the principle ledger.
- *
- * Implementations must guarantee:
- * - Atomic writes (no partial/corrupted state on crash)
- * - Thread-safe concurrent access (locking or equivalent)
- * - Consistent read-after-write visibility
- *
- * The `mutateLedger` method is the preferred way to perform read-modify-write
- * cycles. It encapsulates locking so callers never need to manage it.
- */
-export interface StorageAdapter {
-    /**
-     * Load the current ledger state from persistence.
-     *
-     * If no persisted state exists (first run), returns an empty store.
-     */
-    loadLedger(): Promise<HybridLedgerStore>;
-    /**
-     * Persist the full ledger state.
-     *
-     * Must be atomic -- partial writes must never be visible to readers.
-     */
-    saveLedger(store: HybridLedgerStore): Promise<void>;
-    /**
-     * Perform a read-modify-write cycle with automatic locking.
-     *
-     * The `mutate` function receives the current store and may return a
-     * value synchronously or via Promise. The store is persisted after
-     * the mutate function resolves, regardless of its return value.
-     *
-     * If two concurrent `mutateLedger` calls overlap, one must wait for
-     * the other to complete (pessimistic locking) or retry on conflict
-     * (optimistic locking). The choice is left to the implementation.
-     *
-     * @example
-     * ```ts
-     * const count = await adapter.mutateLedger((store) => {
-     *   store.tree.principles['p-1'] = newPrinciple;
-     *   return Object.keys(store.tree.principles).length;
-     * });
-     * ```
-     */
-    mutateLedger<T>(mutate: (store: HybridLedgerStore) => T | Promise<T>): Promise<T>;
-}
-//# sourceMappingURL=storage-adapter.d.ts.map

package/core/dist/storage-adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"storage-adapter.d.ts","sourceRoot":"","sources":["../src/storage-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAMpD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,UAAU,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAEzC;;;;OAIG;IACH,UAAU,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEpD;;;;;;;;;;;;;;;;;;OAkBG;IACH,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CACnF"}

package/core/dist/storage-adapter.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=storage-adapter.js.map

package/core/dist/storage-adapter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"storage-adapter.js","sourceRoot":"","sources":["../src/storage-adapter.ts"],"names":[],"mappings":""}

package/core/dist/types/workspace-resolver.d.ts

@@ -1,25 +0,0 @@
-/**
- * WorkspaceResolver Interface
- *
- * Framework-agnostic contract for resolving the active workspace directory.
- * Concrete implementation is provided by the openclaw-plugin extension mechanism.
- *
- * D-01: Interface in @principles/core, implementation in openclaw-plugin
- */
-/**
- * Interface for resolving the active workspace directory.
- *
- * Concrete implementation lives in openclaw-plugin via extension/override pattern.
- * CLI commands depend on the interface only — no plugin internals.
- */
-export interface WorkspaceResolver {
-    /**
-     * Resolve the active workspace directory.
-     *
-     * @param workspaceDir - Optional override. If not provided, resolves using
-     *                       platform-specific defaults (env vars, config file, cwd).
-     * @returns The resolved workspace directory path.
-     */
-    resolve(workspaceDir?: string): string;
-}
-//# sourceMappingURL=workspace-resolver.d.ts.map

package/core/dist/types/workspace-resolver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"workspace-resolver.d.ts","sourceRoot":"","sources":["../../src/types/workspace-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;;;OAMG;IACH,OAAO,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CACxC"}

package/core/dist/types/workspace-resolver.js

@@ -1,10 +0,0 @@
-/**
- * WorkspaceResolver Interface
- *
- * Framework-agnostic contract for resolving the active workspace directory.
- * Concrete implementation is provided by the openclaw-plugin extension mechanism.
- *
- * D-01: Interface in @principles/core, implementation in openclaw-plugin
- */
-export {};
-//# sourceMappingURL=workspace-resolver.js.map

package/core/dist/types/workspace-resolver.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"workspace-resolver.js","sourceRoot":"","sources":["../../src/types/workspace-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/core/dist/types.d.ts

@@ -1,56 +0,0 @@
-/**
- * Duplicated type shapes for principles-core.
- *
- * These types are minimal shapes duplicated from openclaw-plugin to avoid
- * cross-package imports. principles-core must NOT depend on openclaw-plugin.
- *
- * MAINTENANCE CONTRACT: When updating these types, also update the corresponding
- * source types in openclaw-plugin and vice-versa. These are the same shapes --
- * drift between them will cause subtle storage/pipeline bugs.
- *
- * Source locations:
- * - InjectablePrinciple  -> openclaw-plugin/src/core/principle-injection.ts
- * - HybridLedgerStore     -> openclaw-plugin/src/core/principle-tree-ledger.ts
- */
-/**
- * Minimal InjectablePrinciple shape for principle injection.
- * Must stay in sync with openclaw-plugin/src/core/principle-injection.ts.
- */
-export interface InjectablePrinciple {
-    id: string;
-    text: string;
-    /** Priority level. Defaults to 'P1' if not set by the source. */
-    priority?: 'P0' | 'P1' | 'P2';
-    createdAt: string;
-}
-/**
- * Minimal HybridLedgerStore shape for storage adapter interface.
- * Must stay in sync with openclaw-plugin/src/core/principle-tree-ledger.ts.
- *
- * Note: tree.* fields use `unknown` to avoid importing the actual node types.
- * This is an intentional trade-off -- StorageAdapter implementations must
- * be careful to validate the shape of objects they store/retrieve.
- */
-export interface HybridLedgerStore {
-    trainingStore: Record<string, {
-        principleId: string;
-        evaluability: 'deterministic' | 'weak_heuristic' | 'manual_only';
-        applicableOpportunityCount: number;
-        observedViolationCount: number;
-        complianceRate: number;
-        violationTrend: number;
-        generatedSampleCount: number;
-        approvedSampleCount: number;
-        includedTrainRunIds: string[];
-        deployedCheckpointIds: string[];
-        internalizationStatus: 'prompt_only' | 'needs_training' | 'in_training' | 'deployed_pending_eval' | 'internalized' | 'regressed';
-    }>;
-    tree: {
-        principles: Record<string, unknown>;
-        rules: Record<string, unknown>;
-        implementations: Record<string, unknown>;
-        metrics: Record<string, unknown>;
-        lastUpdated: string;
-    };
-}
-//# sourceMappingURL=types.d.ts.map

package/core/dist/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,iEAAiE;IACjE,QAAQ,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAiB;IAChC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE;QAC5B,WAAW,EAAE,MAAM,CAAC;QACpB,YAAY,EAAE,eAAe,GAAG,gBAAgB,GAAG,aAAa,CAAC;QACjE,0BAA0B,EAAE,MAAM,CAAC;QACnC,sBAAsB,EAAE,MAAM,CAAC;QAC/B,cAAc,EAAE,MAAM,CAAC;QACvB,cAAc,EAAE,MAAM,CAAC;QACvB,oBAAoB,EAAE,MAAM,CAAC;QAC7B,mBAAmB,EAAE,MAAM,CAAC;QAC5B,mBAAmB,EAAE,MAAM,EAAE,CAAC;QAC9B,qBAAqB,EAAE,MAAM,EAAE,CAAC;QAChC,qBAAqB,EAAE,aAAa,GAAG,gBAAgB,GAAG,aAAa,GAAG,uBAAuB,GAAG,cAAc,GAAG,WAAW,CAAC;KAClI,CAAC,CAAC;IACH,IAAI,EAAE;QACJ,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACpC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC/B,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACzC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACjC,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;CACH"}

package/core/dist/types.js

@@ -1,16 +0,0 @@
-/**
- * Duplicated type shapes for principles-core.
- *
- * These types are minimal shapes duplicated from openclaw-plugin to avoid
- * cross-package imports. principles-core must NOT depend on openclaw-plugin.
- *
- * MAINTENANCE CONTRACT: When updating these types, also update the corresponding
- * source types in openclaw-plugin and vice-versa. These are the same shapes --
- * drift between them will cause subtle storage/pipeline bugs.
- *
- * Source locations:
- * - InjectablePrinciple  -> openclaw-plugin/src/core/principle-injection.ts
- * - HybridLedgerStore     -> openclaw-plugin/src/core/principle-tree-ledger.ts
- */
-export {};
-//# sourceMappingURL=types.js.map

package/core/dist/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}

package/pd-cli/dist/principle-tree-ledger-adapter.d.ts

@@ -1,12 +0,0 @@
-/**
- * Re-exports the canonical PrincipleTreeLedgerAdapter from @principles/core/runtime-v2.
- *
- * This adapter uses @principles/core's addPrincipleToLedger/loadLedger, which write to
- * <stateDir>/principle_training_state.json (HybridLedgerStore format), matching the ledger
- * format used by the OpenClaw plugin's pain-signal-bridge.
- *
- * audit/repair commands use this adapter — it ensures consistency between
- * what intake writes and what audit/repair read back.
- */
-export { PrincipleTreeLedgerAdapter, } from '@principles/core/runtime-v2';
-//# sourceMappingURL=principle-tree-ledger-adapter.d.ts.map

package/pd-cli/dist/principle-tree-ledger-adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"principle-tree-ledger-adapter.d.ts","sourceRoot":"","sources":["../src/principle-tree-ledger-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EACL,0BAA0B,GAC3B,MAAM,6BAA6B,CAAC"}

package/pd-cli/dist/principle-tree-ledger-adapter.js

@@ -1,12 +0,0 @@
-/**
- * Re-exports the canonical PrincipleTreeLedgerAdapter from @principles/core/runtime-v2.
- *
- * This adapter uses @principles/core's addPrincipleToLedger/loadLedger, which write to
- * <stateDir>/principle_training_state.json (HybridLedgerStore format), matching the ledger
- * format used by the OpenClaw plugin's pain-signal-bridge.
- *
- * audit/repair commands use this adapter — it ensures consistency between
- * what intake writes and what audit/repair read back.
- */
-export { PrincipleTreeLedgerAdapter, } from '@principles/core/runtime-v2';
-//# sourceMappingURL=principle-tree-ledger-adapter.js.map

package/pd-cli/dist/principle-tree-ledger-adapter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"principle-tree-ledger-adapter.js","sourceRoot":"","sources":["../src/principle-tree-ledger-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EACL,0BAA0B,GAC3B,MAAM,6BAA6B,CAAC"}

package/plugin/dist/core/evolution-hook.d.ts

@@ -1,54 +0,0 @@
-/**
- * EvolutionHook interface for the Evolution SDK.
- *
- * Provides a callback-based interface for observing evolution lifecycle
- * events: pain detection, principle creation, and principle promotion.
- *
- * Per D-03, this interface contains only the 3 core event methods.
- * Per D-04, consumers implement the interface directly (no EventEmitter).
- * Hooks not needed can use the provided noOpEvolutionHook and override
- * individual methods.
- */
-import type { PainSignal } from './pain-signal.js';
-/** Event payload for principle creation lifecycle events. */
-export interface PrincipleCreatedEvent {
-    /** Unique principle identifier */
-    id: string;
-    /** Principle text ("When X, then Y.") */
-    text: string;
-    /** What triggered this principle's creation */
-    trigger: string;
-}
-/** Event payload for principle promotion lifecycle events. */
-export interface PrinciplePromotedEvent {
-    /** Unique principle identifier */
-    id: string;
-    /** Previous status tier */
-    from: string;
-    /** New status tier */
-    to: string;
-}
-/**
- * Callback interface for observing evolution lifecycle events.
- *
- * Implement all 3 methods, or spread noOpEvolutionHook and override
- * only the methods you need:
- *
- * @example
- * ```ts
- * const myHook: EvolutionHook = {
- *   ...noOpEvolutionHook,
- *   onPainDetected(signal) { console.log(signal); },
- * };
- * ```
- */
-export interface EvolutionHook {
-    /** Called when a pain signal is detected and recorded. */
-    onPainDetected(signal: PainSignal): void;
-    /** Called when a new principle candidate is created. */
-    onPrincipleCreated(event: PrincipleCreatedEvent): void;
-    /** Called when a principle is promoted to a higher tier. */
-    onPrinciplePromoted(event: PrinciplePromotedEvent): void;
-}
-/** No-op implementation -- consumers can spread and override individual methods. */
-export declare const noOpEvolutionHook: EvolutionHook;

package/plugin/dist/core/evolution-hook.js

@@ -1,9 +0,0 @@
-// ---------------------------------------------------------------------------
-// No-op Helper
-// ---------------------------------------------------------------------------
-/** No-op implementation -- consumers can spread and override individual methods. */
-export const noOpEvolutionHook = {
-    onPainDetected(_signal) { },
-    onPrincipleCreated(_event) { },
-    onPrinciplePromoted(_event) { },
-};

package/plugin/dist/core/file-storage-adapter.d.ts

@@ -1,43 +0,0 @@
-import type { StorageAdapter } from './storage-adapter.js';
-import type { HybridLedgerStore } from './principle-tree-ledger.js';
-/**
- * File-system backed storage adapter for the principle ledger.
- *
- * Delegates read/write operations to principle-tree-ledger while providing
- * the async StorageAdapter interface. The mutateLedger method uses
- * withLockAsync with exponential backoff retry for robust concurrent access.
- */
-export declare class FileStorageAdapter implements StorageAdapter {
-    private readonly stateDir;
-    private readonly workspaceDir;
-    constructor(stateDir: string, workspaceDir?: string);
-    /** Resolve the ledger file path for this state directory. */
-    private get filePath();
-    /**
-     * Load the current ledger state from the file system.
-     *
-     * Returns an empty store if no persisted state exists (first run).
-     * Uses the synchronous loadLedger from principle-tree-ledger which
-     * handles missing/corrupted files gracefully.
-     */
-    loadLedger(): Promise<HybridLedgerStore>;
-    /**
-     * Persist the full ledger state atomically.
-     *
-     * Delegates to principle-tree-ledger's saveLedgerAsync which uses
-     * withLockAsync internally. Logs failures via SystemLogger.
-     */
-    saveLedger(store: HybridLedgerStore): Promise<void>;
-    /**
-     * Perform a read-modify-write cycle with automatic locking and retry.
-     *
-     * Uses withLockAsync to acquire a file lock, reads the current store,
-     * applies the mutate function, then writes the modified store atomically.
-     * On lock acquisition failure, retries up to MUTATE_RETRY_COUNT (5) times
-     * with exponential backoff + jitter to reduce contention.
-     *
-     * Write failures are logged to SystemLogger and re-thrown so callers
-     * can decide how to handle persistence errors.
-     */
-    mutateLedger<T>(mutate: (store: HybridLedgerStore) => T | Promise<T>): Promise<T>;
-}

package/plugin/dist/core/file-storage-adapter.js

@@ -1,158 +0,0 @@
-/**
- * FileStorageAdapter — file-backed implementation of StorageAdapter.
- *
- * Wraps principle-tree-ledger functions with the async StorageAdapter
- * contract. Uses withLockAsync for thread-safe mutateLedger with
- * retry with exponential backoff for lock acquisition (5 retries).
- * Write failures are logged via SystemLogger and re-thrown.
- *
- * Guarantees:
- * - Atomic writes via atomicWriteFileSync (temp + rename)
- * - Thread-safe concurrent access via file locks
- * - Consistent read-after-write visibility
- * - Write failures logged to SystemLogger and re-thrown
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { TREE_NAMESPACE } from './principle-tree-ledger.js';
-import { loadLedger as loadLedgerFromFile, saveLedgerAsync, } from './principle-tree-ledger.js';
-import { withLockAsync, LockAcquisitionError } from '../utils/file-lock.js';
-import { atomicWriteFileSync } from '../utils/io.js';
-import { SystemLogger } from './system-logger.js';
-// ---------------------------------------------------------------------------
-// Configuration
-// ---------------------------------------------------------------------------
-/** Maximum retries for lock acquisition in mutateLedger. */
-const MUTATE_RETRY_COUNT = 5;
-/** Base delay in ms for exponential backoff between retries. */
-const MUTATE_BACKOFF_BASE_MS = 50;
-/** Maximum backoff delay in ms. */
-const MUTATE_BACKOFF_MAX_MS = 500;
-const PRINCIPLE_TRAINING_FILE = 'principle_training_state.json';
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-/**
- * Serialize the hybrid ledger store to JSON.
- * Mirrors the unexported serializeLedger from principle-tree-ledger.ts.
- */
-function serializeStore(store) {
-    return JSON.stringify({
-        ...store.trainingStore,
-        [TREE_NAMESPACE]: {
-            ...store.tree,
-            lastUpdated: new Date().toISOString(),
-        },
-    }, null, 2);
-}
-/** Ensure the parent directory exists before writing. */
-function ensureParentDir(filePath) {
-    const dir = path.dirname(filePath);
-    if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-    }
-}
-// ---------------------------------------------------------------------------
-// FileStorageAdapter
-// ---------------------------------------------------------------------------
-/**
- * File-system backed storage adapter for the principle ledger.
- *
- * Delegates read/write operations to principle-tree-ledger while providing
- * the async StorageAdapter interface. The mutateLedger method uses
- * withLockAsync with exponential backoff retry for robust concurrent access.
- */
-export class FileStorageAdapter {
-    stateDir;
-    workspaceDir;
-    constructor(stateDir, workspaceDir) {
-        this.stateDir = stateDir;
-        this.workspaceDir = workspaceDir;
-    }
-    /** Resolve the ledger file path for this state directory. */
-    get filePath() {
-        return path.join(this.stateDir, PRINCIPLE_TRAINING_FILE);
-    }
-    /**
-     * Load the current ledger state from the file system.
-     *
-     * Returns an empty store if no persisted state exists (first run).
-     * Uses the synchronous loadLedger from principle-tree-ledger which
-     * handles missing/corrupted files gracefully.
-     */
-    async loadLedger() {
-        return loadLedgerFromFile(this.stateDir);
-    }
-    /**
-     * Persist the full ledger state atomically.
-     *
-     * Delegates to principle-tree-ledger's saveLedgerAsync which uses
-     * withLockAsync internally. Logs failures via SystemLogger.
-     */
-    async saveLedger(store) {
-        try {
-            await saveLedgerAsync(this.stateDir, store);
-        }
-        catch (err) {
-            SystemLogger.log(this.workspaceDir, 'STORAGE_WRITE_FAILED', `FileStorageAdapter.saveLedger failed: ${String(err)}`);
-            throw err;
-        }
-    }
-    /**
-     * Perform a read-modify-write cycle with automatic locking and retry.
-     *
-     * Uses withLockAsync to acquire a file lock, reads the current store,
-     * applies the mutate function, then writes the modified store atomically.
-     * On lock acquisition failure, retries up to MUTATE_RETRY_COUNT (5) times
-     * with exponential backoff + jitter to reduce contention.
-     *
-     * Write failures are logged to SystemLogger and re-thrown so callers
-     * can decide how to handle persistence errors.
-     */
-    async mutateLedger(mutate) {
-        let lastError;
-        for (let attempt = 0; attempt < MUTATE_RETRY_COUNT; attempt++) {
-            try {
-                const lockOptions = {
-                    maxRetries: 3,
-                    baseRetryDelayMs: 10,
-                    maxRetryDelayMs: 200,
-                    lockStaleMs: 10_000,
-                };
-                const ledgerPath = this.filePath;
-                return await withLockAsync(ledgerPath, async () => {
-                    const store = loadLedgerFromFile(this.stateDir);
-                    const result = await mutate(store);
-                    // Write directly — we already hold the lock, so we must NOT
-                    // call saveLedger/saveLedgerAsync (they try to acquire the same lock).
-                    try {
-                        ensureParentDir(ledgerPath);
-                        atomicWriteFileSync(ledgerPath, serializeStore(store));
-                    }
-                    catch (writeErr) {
-                        SystemLogger.log(this.workspaceDir, 'STORAGE_WRITE_FAILED', `FileStorageAdapter.mutateLedger write failed: ${String(writeErr)}`);
-                        throw writeErr;
-                    }
-                    return result;
-                }, lockOptions);
-            }
-            catch (err) {
-                lastError = err;
-                // Only retry on lock acquisition errors
-                if (err instanceof LockAcquisitionError && attempt < MUTATE_RETRY_COUNT - 1) {
-                    const delay = Math.min(MUTATE_BACKOFF_BASE_MS * Math.pow(2, attempt), MUTATE_BACKOFF_MAX_MS);
-                    // Add jitter (0-20%) to avoid thundering herd
-                    const jitter = delay * 0.2 * Math.random();
-                    const totalDelay = Math.floor(delay + jitter);
-                    await new Promise((resolve) => setTimeout(resolve, totalDelay));
-                    continue;
-                }
-                // Non-retryable error or exhausted retries
-                SystemLogger.log(this.workspaceDir, 'STORAGE_MUTATE_FAILED', `FileStorageAdapter.mutateLedger failed after ${attempt + 1} attempts: ${String(err)}`);
-                throw err;
-            }
-        }
-        // Should not reach here, but satisfy the type checker
-        throw lastError ?? new Error('FileStorageAdapter.mutateLedger: unexpected state');
-    }
-}

package/plugin/dist/core/merge-gate-audit.d.ts

@@ -1,21 +0,0 @@
-export type MergeGateAuditStatus = 'pass' | 'block' | 'defer';
-export interface MergeGateAuditCheck {
-    id: string;
-    status: MergeGateAuditStatus;
-    summary: string;
-    details?: Record<string, unknown>;
-}
-export interface MergeGateAuditReport {
-    overallStatus: MergeGateAuditStatus;
-    generatedAt: string;
-    workspaceDir: string;
-    stateDir: string;
-    checks: MergeGateAuditCheck[];
-    counts: {
-        pass: number;
-        block: number;
-        defer: number;
-    };
-}
-export declare function runMergeGateAudit(workspaceDir: string, stateDir: string): MergeGateAuditReport;
-export declare function formatMergeGateAuditReport(report: MergeGateAuditReport): string;