@claude-flow/cli 3.56.10 → 3.57.0

package/dist/src/mcp-tools/neural-tools.js

@@ -908,9 +908,6 @@ export const neuralTools = [
                 if (!v.valid)
                     return { success: false, error: v.error };
             }
-            // Resolve provider so embeddingProvider in the result matches the old
-            // eager-init reporting.
-            await ensureEmbeddings();
             const store = loadNeuralStore();
             const method = input.method || 'quantize';
             const targetReduction = input.targetSize || 0.5;
@@ -919,38 +916,25 @@ export const neuralTools = [
                 return { success: false, error: 'No patterns to compress. Train patterns first with neural_train.' };
             }
             const beforeCount = patterns.length;
-            const beforeSize = patterns.reduce((s, p) => s + (p.embedding?.length || 0) * 4, 0); // Float32 = 4 bytes
             if (method === 'quantize') {
-                try {
-                    const { quantizeInt8, getQuantizationStats } = await import('../memory/memory-initializer.js');
-                    let totalCompressed = 0;
-                    for (const pattern of patterns) {
-                        if (pattern.embedding && pattern.embedding.length > 0) {
-                            const stats = getQuantizationStats(pattern.embedding);
-                            const quantized = quantizeInt8(pattern.embedding);
-                            // Store quantized metadata (keep original embedding for search)
-                            pattern._quantized = {
-                                scale: quantized.scale,
-                                zeroPoint: quantized.zeroPoint,
-                                compressionRatio: stats.compressionRatio,
-                            };
-                            totalCompressed++;
-                        }
-                    }
-                    saveNeuralStore(store);
-                    return {
-                        success: true, _real: true, method,
-                        embeddingProvider: embeddingServiceName,
-                        patternsCompressed: totalCompressed,
-                        compressionRatio: '3.92x (Int8)',
-                        beforeBytes: beforeSize,
-                        afterBytes: Math.round(beforeSize / 3.92),
-                    };
-                }
-                catch {
-                    return { success: false, error: 'Quantization requires memory-initializer. Run `memory init` first.' };
-                }
+                // Neural-store readers consume `embedding` as a full-precision number[]
+                // (search, prediction, deduplication, and optimization). The former
+                // implementation discarded the Int8 vector, persisted only metadata,
+                // and reported a calculated 3.92x reduction. Refuse until the store has
+                // a persisted representation with a reader-side decode contract.
+                const storedBytes = readFileSync(getNeuralPath()).byteLength;
+                return {
+                    success: false,
+                    error: 'Quantized embeddings are not persisted: neural-store readers require full-precision embedding arrays.',
+                    method,
+                    patternsCompressed: 0,
+                    beforeBytes: storedBytes,
+                    afterBytes: storedBytes,
+                    compressionRatio: '1.00x (unchanged JSON storage)',
+                };
             }
+            // Resolve provider only for operations that actually use embeddings.
+            await ensureEmbeddings();
             if (method === 'prune') {
                 // Prune patterns with low usage count below threshold (targetReduction as min usage)
                 const threshold = targetReduction;
@@ -1136,24 +1120,10 @@ export const neuralTools = [
                 if (duplicatesRemoved > 0)
                     actions.push(`Removed ${duplicatesRemoved} near-duplicate patterns`);
             }
-            // memory / balanced: quantize large embeddings
+            // memory / balanced: report the unsupported persisted representation
+            // instead of attaching metadata for a discarded Int8 vector.
             if (target === 'memory' || target === 'balanced') {
-                try {
-                    const { quantizeInt8, getQuantizationStats } = await import('../memory/memory-initializer.js');
-                    for (const p of Object.values(store.patterns)) {
-                        if (p.embedding && p.embedding.length > 0 && !p._quantized) {
-                            const stats = getQuantizationStats(p.embedding);
-                            const q = quantizeInt8(p.embedding);
-                            p._quantized = { scale: q.scale, zeroPoint: q.zeroPoint, compressionRatio: stats.compressionRatio };
-                            patternsQuantized++;
-                        }
-                    }
-                    if (patternsQuantized > 0)
-                        actions.push(`Quantized ${patternsQuantized} pattern embeddings (Int8, ~3.92x)`);
-                }
-                catch {
-                    actions.push('Quantization skipped (memory-initializer not available)');
-                }
+                actions.push('Quantization skipped: neural-store readers require persisted full-precision embedding arrays.');
             }
             // accuracy / balanced: prune low-usage, zero-embedding patterns
             if (target === 'accuracy' || target === 'balanced') {

package/dist/src/mcp-tools/policy-tools.js

@@ -24,9 +24,11 @@ export const policyTools = [
         category: 'security',
         inputSchema: {
             type: 'object',
-            properties: {},
+            properties: {
+                full: { type: 'boolean', description: 'Also replay the archived receipts to verify the complete historical ledger, not just the retained hot tail (#3164)' },
+            },
         },
-        handler: async (_input, context) => {
+        handler: async (input, context) => {
             const root = typeof context?.projectRoot === 'string' ? context.projectRoot : process.cwd();
             const state = loadPolicyState(root);
             return {
@@ -39,7 +41,7 @@ export const policyTools = [
                     approvals: state.approvals.length,
                     receipts: state.receipts.length,
                 },
-                ledger: await verifyPolicyLedger(root),
+                ledger: await verifyPolicyLedger(root, { full: input.full === true }),
             };
         },
     },

package/dist/src/memory/intelligence.js

@@ -16,6 +16,7 @@ import { createRequire } from 'node:module';
 import { join } from 'node:path';
 import { resolveTrainingBackend } from '../ruvector/lora-adapter.js';
 import { getProjectCwd } from '../mcp-tools/types.js';
+import { withStatsFileLock } from './stats-file-lock.js';
 // ============================================================================
 // Persistence Configuration
 // ============================================================================
@@ -664,11 +665,9 @@ function bumpStat(key, n = 1) {
 }
 function readStatsFile() {
     try {
-        const path = getStatsPath();
-        if (!existsSync(path))
-            return null;
-        const data = JSON.parse(readFileSync(path, 'utf-8'));
-        return data && typeof data === 'object' ? data : null;
+        // Read-only callers keep their unavailable-on-error contract, while invalid
+        // disk values cannot poison local state and a later repaired-file flush.
+        return readStatsForWrite(getStatsPath());
     }
     catch {
         return null;
@@ -701,33 +700,79 @@ function maxTimestamp(a, b) {
         return a;
     return Math.max(a, b);
 }
-/**
- * Save stats to disk: merge this process's unsaved deltas into whatever is
- * currently on disk (read-merge-write, atomic rename), then adopt the merged
- * totals locally so this process also sees other writers' progress.
- */
+/** Missing files are first use; unreadable or invalid files must not be replaced. */
+function readStatsForWrite(path) {
+    let text;
+    try {
+        text = readFileSync(path, 'utf-8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        throw Object.assign(new Error('Invalid learning stats JSON'), { code: 'EINVALIDSTATS' });
+    }
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+        throw Object.assign(new Error('Invalid learning stats object'), { code: 'EINVALIDSTATS' });
+    }
+    for (const key of ['trajectoriesRecorded', 'patternsLearned', 'signalsProcessed']) {
+        const value = data[key];
+        // Older files may omit a counter, but present counters must be exact counts.
+        if (value === undefined)
+            continue;
+        if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {
+            throw Object.assign(new Error(`Invalid learning stats field: ${key}`), { code: 'EINVALIDSTATS' });
+        }
+    }
+    const timestamp = data.lastAdaptation;
+    if (timestamp != null && (typeof timestamp !== 'number' || !Number.isFinite(timestamp) || timestamp < 0)) {
+        throw Object.assign(new Error('Invalid learning stats timestamp'), { code: 'EINVALIDSTATS' });
+    }
+    return data;
+}
+/** Merge pending deltas under the cooperating-writer lock, then adopt committed totals. */
 function savePersistedStats() {
+    let statsPath;
     try {
-        ensureDataDir();
-        const path = getStatsPath();
-        const disk = readStatsFile();
-        const merged = disk
-            ? {
-                trajectoriesRecorded: (disk.trajectoriesRecorded ?? 0) + pendingDelta.trajectoriesRecorded,
-                patternsLearned: (disk.patternsLearned ?? 0) + pendingDelta.patternsLearned,
-                signalsProcessed: (disk.signalsProcessed ?? 0) + pendingDelta.signalsProcessed,
-                lastAdaptation: maxTimestamp(disk.lastAdaptation ?? null, globalStats.lastAdaptation),
+        statsPath = join(ensureDataDir(), 'stats.json');
+        withStatsFileLock(statsPath, (path) => {
+            const disk = readStatsForWrite(path);
+            const merged = disk
+                ? {
+                    trajectoriesRecorded: (disk.trajectoriesRecorded ?? 0) + pendingDelta.trajectoriesRecorded,
+                    patternsLearned: (disk.patternsLearned ?? 0) + pendingDelta.patternsLearned,
+                    signalsProcessed: (disk.signalsProcessed ?? 0) + pendingDelta.signalsProcessed,
+                    lastAdaptation: maxTimestamp(disk.lastAdaptation ?? null, globalStats.lastAdaptation),
+                }
+                : { ...globalStats };
+            for (const key of ['trajectoriesRecorded', 'patternsLearned', 'signalsProcessed']) {
+                if (!Number.isSafeInteger(merged[key]) || merged[key] < 0) {
+                    throw Object.assign(new Error('Learning stats counter overflow'), { code: 'EINVALIDSTATS' });
+                }
+            }
+            if (merged.lastAdaptation != null &&
+                (!Number.isFinite(merged.lastAdaptation) || merged.lastAdaptation < 0)) {
+                throw Object.assign(new Error('Invalid merged learning stats timestamp'), { code: 'EINVALIDSTATS' });
             }
-            : { ...globalStats };
-        const tmp = `${path}.${process.pid}.tmp`;
-        writeFileSync(tmp, JSON.stringify(merged, null, 2), 'utf-8');
-        renameSync(tmp, path);
-        globalStats = merged;
-        pendingDelta = { trajectoriesRecorded: 0, patternsLearned: 0, signalsProcessed: 0 };
-        persistedStatsLoaded = true;
+            const tmp = `${path}.${process.pid}.tmp`;
+            writeFileSync(tmp, JSON.stringify(merged, null, 2), 'utf-8');
+            renameSync(tmp, path);
+            // Commit local state before release: a failed release must not replay it.
+            globalStats = merged;
+            pendingDelta = { trajectoriesRecorded: 0, patternsLearned: 0, signalsProcessed: 0 };
+            persistedStatsLoaded = true;
+        });
     }
-    catch {
-        // Ignore save errors (deltas are retained for the next save)
+    catch (error) {
+        const { code = 'UNKNOWN', path = statsPath || 'neural stats directory' } = error;
+        // Do not print file contents, which may be malformed or user-controlled.
+        console.warn(`[intelligence] Could not persist learning stats at ${path} (${code}); pending increments retained`);
     }
 }
 /**
@@ -1015,13 +1060,15 @@ export async function recordTrajectory(steps, verdict) {
                 const avgQuality = verdict === 'success' ? 1.0 : verdict === 'partial' ? 0.5 : 0.0;
                 ruvllmCoord.recordTrajectory({
                     steps: enrichedSteps.map(s => ({
-                        state: s.content,
-                        action: s.type,
-                        reward: avgQuality,
-                        embedding: s.embedding || []
+                        type: ['query', 'route', 'generate', 'memory', 'feedback'].includes(s.type)
+                            ? s.type : 'generate',
+                        input: s.content,
+                        output: '',
+                        durationMs: 0,
+                        confidence: avgQuality
                     })),
                     totalReward: avgQuality,
-                    success: verdict === 'success'
+                    outcome: verdict
                 });
             }
             catch {

package/dist/src/memory/stats-file-lock.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Serialize cooperating local writers without stealing a paused writer's lock.
+ * Abnormal termination can leave an orphan: recovery requires confirming that
+ * no writer still owns the directory before removing it. Never age-reap it.
+ */
+export declare function withStatsFileLock<T>(file: string, write: (canonicalFile: string) => T): T;
+//# sourceMappingURL=stats-file-lock.d.ts.map

package/dist/src/memory/stats-file-lock.js

@@ -0,0 +1,53 @@
+import { mkdirSync, realpathSync, rmdirSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+/**
+ * Serialize cooperating local writers without stealing a paused writer's lock.
+ * Abnormal termination can leave an orphan: recovery requires confirming that
+ * no writer still owns the directory before removing it. Never age-reap it.
+ */
+export function withStatsFileLock(file, write) {
+    const canonicalFile = join(realpathSync(dirname(file)), basename(file));
+    const lock = `${canonicalFile}.lock`;
+    const deadline = performance.now() + 1000;
+    const sleeper = new Int32Array(new SharedArrayBuffer(4));
+    for (;;) {
+        try {
+            mkdirSync(lock, { mode: 0o700 });
+            break;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            const remaining = deadline - performance.now();
+            if (remaining <= 0) {
+                throw Object.assign(new Error('Learning stats lock is busy'), { code: 'ELOCKED', path: lock });
+            }
+            Atomics.wait(sleeper, 0, 0, Math.min(10, remaining));
+        }
+    }
+    const cleanup = () => {
+        // Only remove our empty directory. Never recursively remove foreign data.
+        rmdirSync(lock);
+    };
+    const onExit = () => {
+        try {
+            cleanup();
+        }
+        catch { /* abnormal exits may require deliberate recovery */ }
+    };
+    process.once('exit', onExit);
+    try {
+        return write(canonicalFile);
+    }
+    finally {
+        process.removeListener('exit', onExit);
+        try {
+            cleanup();
+        }
+        catch (error) {
+            const code = error.code || 'UNKNOWN';
+            console.warn(`[intelligence] Could not release learning stats lock at ${lock} (${code}); verify ownership before recovery`);
+        }
+    }
+}
+//# sourceMappingURL=stats-file-lock.js.map

package/dist/src/services/distill-oracle.d.ts

@@ -36,7 +36,7 @@
  */
 import { type VerifyTaskKind } from '../ruvector/output-verifier.js';
 import { FableHarness, type ReflectItem, type ReflectResult } from './fable-harness.js';
-export declare const MH_DARWIN_PIN = "0.10.2";
+export declare const MH_DARWIN_PIN = "0.12.0";
 export type ResolvedProvenance = 'oracle:test-exec' | 'judge:fable' | 'proxy:structural';
 /** SWE-bench-shaped / bench-suite-mapped test spec that Tier 1 can execute. */
 export interface TestSpec {

package/dist/src/services/distill-oracle.js

@@ -43,9 +43,9 @@ import { FableHarness, } from './fable-harness.js';
 // behavior mid-run (the #142 pin-drift failure mode). Pin it, and let
 // scripts/check-metaharness-pins.mjs watch this constant for drift. Kept in
 // lock-step with the optionalDependencies pin in package.json and the plugin
-// darwin cache (versioned by the plugin's own `~0.10.2` pin in _darwin.mjs;
+// darwin cache (versioned by the plugin's own `~0.12.0` pin in _darwin.mjs;
 // both are checked by scripts/check-metaharness-pins.mjs — #3366).
-export const MH_DARWIN_PIN = '0.10.2';
+export const MH_DARWIN_PIN = '0.12.0';
 // ── Public API ───────────────────────────────────────────────────────────
 /**
  * Label each trajectory with `resolved` + honest provenance, trying the tiers

package/dist/src/services/policy-anchor-log.d.ts

@@ -0,0 +1,13 @@
+export declare const ATOMIC_JSON_WRITER: unique symbol;
+export interface AtomicJsonSource {
+    [ATOMIC_JSON_WRITER](fd: number): void;
+}
+/** Supports property order/whitespace from ordinary JSON writers. Unknown
+ * root values remain bounded and syntax-checked; duplicate known keys fail. */
+export declare function anchorEntries(file: string): Generator<unknown>;
+/** Serialization callback runs inside the runtime's existing durable atomic
+ * writer. Failure removes the temporary file; no partial log is published. */
+export declare function appendedAnchorLog(file: string | undefined, next: unknown, validate: (value: unknown, sequence: number, previous: string | null) => value is {
+    hash: string;
+}): AtomicJsonSource;
+//# sourceMappingURL=policy-anchor-log.d.ts.map

package/dist/src/services/policy-anchor-log.js

@@ -0,0 +1,242 @@
+/** Streaming reader/writer for the existing version-1 anchor JSON object.
+ * Every entry is still parsed and authenticated by the caller. This bounds
+ * memory without weakening historical validation or changing the log format.
+ */
+import { closeSync, constants, fstatSync, openSync, readSync, writeSync } from 'node:fs';
+import { TextDecoder } from 'node:util';
+export const ATOMIC_JSON_WRITER = Symbol('policy-atomic-json-writer');
+const CHUNK_BYTES = 64 * 1024;
+const VALUE_LIMIT = 16 * 1024 * 1024;
+const STRING_STRUCTURE = /["\\]/g;
+const VALUE_STRUCTURE = /["\\{}\[\]]/g;
+class JsonReader {
+    fd;
+    buffer = Buffer.allocUnsafe(CHUNK_BYTES);
+    decoder = new TextDecoder('utf-8', { fatal: true });
+    text = '';
+    cursor = 0;
+    position = 0;
+    ended = false;
+    constructor(file) {
+        this.fd = openSync(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+        try {
+            if (!fstatSync(this.fd).isFile())
+                throw new Error('policy-anchor-log-corrupt');
+        }
+        catch (error) {
+            closeSync(this.fd);
+            throw error;
+        }
+    }
+    close() { closeSync(this.fd); }
+    peek() {
+        while (this.cursor >= this.text.length && !this.ended) {
+            const count = readSync(this.fd, this.buffer, 0, this.buffer.length, this.position);
+            this.position += count;
+            this.text = this.decoder.decode(this.buffer.subarray(0, count), { stream: count !== 0 });
+            this.cursor = 0;
+            if (!count)
+                this.ended = true;
+        }
+        return this.text[this.cursor] ?? '';
+    }
+    next() { const character = this.peek(); if (character)
+        this.cursor++; return character; }
+    whitespace() { while (/[ \t\r\n]/.test(this.peek()) && this.peek())
+        this.next(); }
+    expect(character) { this.whitespace(); if (this.next() !== character)
+        throw new Error('policy-anchor-log-corrupt'); }
+    value() {
+        this.whitespace();
+        const first = this.peek();
+        if (!first)
+            throw new Error('policy-anchor-log-corrupt');
+        const compound = first === '{' || first === '[';
+        const string = first === '"';
+        const parts = [];
+        let bytes = 0;
+        let depth = 0;
+        let quoted = false;
+        let escaped = false;
+        for (;;) {
+            if (!this.peek()) {
+                if (quoted || depth !== 0 || !parts.length)
+                    throw new Error('policy-anchor-log-corrupt');
+                break;
+            }
+            const start = this.cursor;
+            let end = start;
+            let complete = false;
+            // Scan the available segment directly. Avoid per-character method,
+            // regular-expression and string-concatenation overhead on mature logs.
+            for (; end < this.text.length; end++) {
+                if (!escaped && (quoted || compound)) {
+                    const markers = quoted ? STRING_STRUCTURE : VALUE_STRUCTURE;
+                    markers.lastIndex = end;
+                    const next = markers.exec(this.text);
+                    if (!next) {
+                        end = this.text.length;
+                        break;
+                    }
+                    end = next.index;
+                }
+                const code = this.text.charCodeAt(end);
+                if (!quoted && depth === 0 && (parts.length > 0 || end > start) && !compound && !string
+                    && (code === 32 || code === 9 || code === 10 || code === 13 || code === 44 || code === 125 || code === 93)) {
+                    complete = true;
+                    break;
+                }
+                if (quoted) {
+                    if (escaped)
+                        escaped = false;
+                    else if (code === 92)
+                        escaped = true;
+                    else if (code === 34) {
+                        quoted = false;
+                        if (string && depth === 0) {
+                            end++;
+                            complete = true;
+                            break;
+                        }
+                    }
+                }
+                else if (code === 34)
+                    quoted = true;
+                else if (code === 123 || code === 91)
+                    depth++;
+                else if (code === 125 || code === 93) {
+                    depth--;
+                    if (depth < 0)
+                        throw new Error('policy-anchor-log-corrupt');
+                    if (compound && depth === 0) {
+                        end++;
+                        complete = true;
+                        break;
+                    }
+                }
+            }
+            const segment = this.text.slice(start, end);
+            bytes += Buffer.byteLength(segment);
+            if (bytes > VALUE_LIMIT)
+                throw new Error('policy-anchor-log-record-too-large');
+            if (segment)
+                parts.push(segment);
+            this.cursor = end;
+            if (complete)
+                break;
+        }
+        // JSON.parse validates the complete bounded token's grammar, including
+        // bracket kinds, escapes, control characters and scalar spellings.
+        return JSON.parse(parts.join(''));
+    }
+}
+/** Supports property order/whitespace from ordinary JSON writers. Unknown
+ * root values remain bounded and syntax-checked; duplicate known keys fail. */
+export function* anchorEntries(file) {
+    const reader = new JsonReader(file);
+    let version;
+    let seenVersion = false;
+    let seenEntries = false;
+    try {
+        reader.expect('{');
+        reader.whitespace();
+        if (reader.peek() === '}')
+            throw new Error('policy-anchor-log-corrupt');
+        for (;;) {
+            const key = reader.value();
+            if (typeof key !== 'string')
+                throw new Error('policy-anchor-log-corrupt');
+            reader.expect(':');
+            if (key === 'entries') {
+                if (seenEntries)
+                    throw new Error('policy-anchor-log-corrupt');
+                seenEntries = true;
+                reader.expect('[');
+                reader.whitespace();
+                if (reader.peek() !== ']') {
+                    for (;;) {
+                        yield reader.value();
+                        reader.whitespace();
+                        if (reader.peek() === ']')
+                            break;
+                        reader.expect(',');
+                    }
+                }
+                reader.expect(']');
+            }
+            else {
+                const value = reader.value();
+                if (key === 'version') {
+                    if (seenVersion)
+                        throw new Error('policy-anchor-log-corrupt');
+                    seenVersion = true;
+                    version = value;
+                }
+            }
+            reader.whitespace();
+            if (reader.peek() === '}')
+                break;
+            reader.expect(',');
+        }
+        reader.expect('}');
+        reader.whitespace();
+        if (reader.peek() || !seenEntries || !seenVersion || version !== 1)
+            throw new Error('policy-anchor-log-corrupt');
+    }
+    finally {
+        reader.close();
+    }
+}
+function writeText(fd, text) {
+    const bytes = Buffer.from(text);
+    let count = 0;
+    while (count < bytes.length) {
+        const next = writeSync(fd, bytes, count, bytes.length - count);
+        if (!next)
+            throw new Error('policy-anchor-log-short-write');
+        count += next;
+    }
+}
+/** Serialization callback runs inside the runtime's existing durable atomic
+ * writer. Failure removes the temporary file; no partial log is published. */
+export function appendedAnchorLog(file, next, validate) {
+    return { [ATOMIC_JSON_WRITER](fd) {
+            let pending = '';
+            let pendingBytes = 0;
+            const flush = () => { if (pendingBytes)
+                writeText(fd, pending); pending = ''; pendingBytes = 0; };
+            const emit = (text) => {
+                const bytes = Buffer.byteLength(text);
+                if (pendingBytes + bytes > CHUNK_BYTES)
+                    flush();
+                if (bytes >= CHUNK_BYTES)
+                    writeText(fd, text);
+                else {
+                    pending += text;
+                    pendingBytes += bytes;
+                }
+            };
+            emit('{"version":1,"entries":[\n');
+            let count = 0;
+            let previous = null;
+            if (file) {
+                for (const entry of anchorEntries(file)) {
+                    if (!validate(entry, count, previous))
+                        throw new Error('policy-anchor-log-corrupt');
+                    if (count)
+                        emit(',\n');
+                    emit(JSON.stringify(entry));
+                    count++;
+                    previous = entry.hash;
+                }
+            }
+            if (!validate(next, count, previous))
+                throw new Error('policy-anchor-log-corrupt');
+            if (count)
+                emit(',\n');
+            emit(JSON.stringify(next));
+            emit('\n]}\n');
+            flush();
+        } };
+}
+//# sourceMappingURL=policy-anchor-log.js.map

package/dist/src/services/policy-archive-scan.d.ts

@@ -0,0 +1,7 @@
+export interface ReverseRecord {
+    bytes: Buffer;
+    offset: number;
+    terminated: boolean;
+}
+export declare function reverseArchiveRecords(fd: number, size: number, limit: number): Generator<ReverseRecord>;
+//# sourceMappingURL=policy-archive-scan.d.ts.map

package/dist/src/services/policy-archive-scan.js

@@ -0,0 +1,50 @@
+/** Fixed-chunk reverse archive scan used by the synchronous anchor gate.
+ * Memory follows the largest single line, never the entire archive/window.
+ */
+import { readSync } from 'node:fs';
+const CHUNK_BYTES = 64 * 1024;
+export function* reverseArchiveRecords(fd, size, limit) {
+    let position = size;
+    let parts = [];
+    let partBytes = 0;
+    let terminated = false;
+    while (position > 0) {
+        const count = Math.min(CHUNK_BYTES, position);
+        position -= count;
+        const chunk = Buffer.allocUnsafe(count);
+        let read = 0;
+        while (read < count) {
+            const next = readSync(fd, chunk, read, count - read, position + read);
+            if (!next)
+                throw new Error('policy-ledger-archive-changed');
+            read += next;
+        }
+        let end = chunk.length;
+        for (;;) {
+            const newline = chunk.lastIndexOf(10, end - 1);
+            if (newline < 0)
+                break;
+            const piece = chunk.subarray(newline + 1, end);
+            if (piece.length + partBytes > limit)
+                throw new Error(`policy-ledger-archive-record-too-large:${limit}`);
+            const bytes = parts.length ? Buffer.concat([piece, ...parts], piece.length + partBytes) : Buffer.from(piece);
+            yield { bytes, offset: position + newline + 1, terminated };
+            terminated = true;
+            parts = [];
+            partBytes = 0;
+            end = newline;
+            if (end === 0)
+                break;
+        }
+        if (end > 0) {
+            if (partBytes + end > limit)
+                throw new Error(`policy-ledger-archive-record-too-large:${limit}`);
+            const piece = Buffer.from(chunk.subarray(0, end));
+            parts.unshift(piece);
+            partBytes += piece.length;
+        }
+    }
+    if (partBytes > 0)
+        yield { bytes: Buffer.concat(parts, partBytes), offset: 0, terminated };
+}
+//# sourceMappingURL=policy-archive-scan.js.map