ushman-ledger 0.3.0

package/dist/coverage.d.ts

@@ -0,0 +1,8 @@
+export type CoverageReport = {
+    readonly coverageRatio: number;
+    readonly coveredFiles: string[];
+    readonly totalFiles: number;
+    readonly uncoveredFiles: string[];
+};
+export declare const computeCoverage: (workspaceRoot: string) => Promise<CoverageReport>;
+//# sourceMappingURL=coverage.d.ts.map

package/dist/coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../src/coverage.ts"],"names":[],"mappings":"AAgGA,MAAM,MAAM,cAAc,GAAG;IACzB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,cAAc,EAAE,MAAM,EAAE,CAAC;CACrC,CAAC;AAEF,eAAO,MAAM,eAAe,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,cAAc,CAgDnF,CAAC"}

package/dist/coverage.js

@@ -0,0 +1,128 @@
+import { readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { mapWithConcurrencyLimit } from "./async.js";
+import { CANDIDATE_EXCLUDE_GLOBS, CANDIDATE_FILE_GLOBS } from "./candidate-paths.js";
+import { readLabManifestMin } from "./lab-min.js";
+import { loadLedgerState } from "./recovery.js";
+const EXCLUDED_ROOTS = new Set(CANDIDATE_EXCLUDE_GLOBS.map((glob) => glob.replace(/\/\*\*$/u, '')));
+const CANDIDATE_DIRECTORIES = CANDIDATE_FILE_GLOBS.filter((glob) => glob.endsWith('/**/*')).map((glob) => glob.slice(0, -5));
+const CANDIDATE_FILES = CANDIDATE_FILE_GLOBS.filter((glob) => !glob.endsWith('/**/*'));
+const FILE_STAT_CONCURRENCY = 16;
+const toPosix = (value) => value.replaceAll(path.sep, '/');
+const isMissingPathError = (error) => {
+    const code = error.code;
+    return code === 'ENOENT' || code === 'ENOTDIR';
+};
+const shouldExclude = (relativePath) => {
+    const normalized = toPosix(relativePath);
+    for (const prefix of EXCLUDED_ROOTS) {
+        if (normalized === prefix || normalized.startsWith(`${prefix}/`)) {
+            return true;
+        }
+    }
+    return false;
+};
+const walkDirectory = async (root, current) => {
+    const dirPath = path.join(root, current);
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const relative = current ? path.join(current, entry.name) : entry.name;
+        if (shouldExclude(relative)) {
+            continue;
+        }
+        if (entry.isDirectory()) {
+            files.push(...(await walkDirectory(root, relative)));
+            continue;
+        }
+        files.push(toPosix(relative));
+    }
+    return files;
+};
+const collectCandidateFiles = async (workspaceRoot) => {
+    const files = new Set();
+    const directoryResults = await Promise.all(CANDIDATE_DIRECTORIES.map(async (relative) => {
+        try {
+            return await walkDirectory(workspaceRoot, relative);
+        }
+        catch (error) {
+            if (!isMissingPathError(error)) {
+                throw error;
+            }
+            return [];
+        }
+    }));
+    for (const directoryFiles of directoryResults) {
+        for (const filePath of directoryFiles) {
+            files.add(filePath);
+        }
+    }
+    for (const relative of CANDIDATE_FILES) {
+        try {
+            const fileStat = await stat(path.join(workspaceRoot, relative));
+            if (fileStat.isFile()) {
+                files.add(relative);
+            }
+        }
+        catch (error) {
+            if (!isMissingPathError(error)) {
+                throw error;
+            }
+        }
+    }
+    return [...files].sort((left, right) => left.localeCompare(right));
+};
+const getWorkspaceInitMs = async (workspaceRoot) => {
+    // Coverage intentionally ignores files that predate workspace initialization.
+    const labManifest = await readLabManifestMin(workspaceRoot);
+    if (labManifest.createdAt) {
+        const parsed = Date.parse(labManifest.createdAt);
+        if (!Number.isNaN(parsed)) {
+            return parsed;
+        }
+    }
+    const labManifestStat = await stat(path.join(workspaceRoot, '.lab', 'lab.json'));
+    return labManifestStat.birthtimeMs || labManifestStat.mtimeMs;
+};
+export const computeCoverage = async (workspaceRoot) => {
+    const [{ readIndex }, candidateFiles, workspaceInitMs] = await Promise.all([
+        loadLedgerState(workspaceRoot),
+        collectCandidateFiles(workspaceRoot),
+        getWorkspaceInitMs(workspaceRoot),
+    ]);
+    const coverageIndex = new Set(readIndex.coveredFiles.map((filePath) => toPosix(filePath)));
+    const candidateStats = await mapWithConcurrencyLimit(candidateFiles, FILE_STAT_CONCURRENCY, async (relativePath) => {
+        try {
+            return {
+                mtimeMs: (await stat(path.join(workspaceRoot, relativePath))).mtimeMs,
+                relativePath,
+            };
+        }
+        catch (error) {
+            if (isMissingPathError(error)) {
+                return null;
+            }
+            throw error;
+        }
+    });
+    const existingCandidateStats = candidateStats.filter((candidateStat) => candidateStat !== null);
+    const coveredFiles = [];
+    const uncoveredFiles = [];
+    for (const { mtimeMs, relativePath } of existingCandidateStats) {
+        if (mtimeMs <= workspaceInitMs) {
+            continue;
+        }
+        if (coverageIndex.has(relativePath)) {
+            coveredFiles.push(relativePath);
+            continue;
+        }
+        uncoveredFiles.push(relativePath);
+    }
+    const totalFiles = coveredFiles.length + uncoveredFiles.length;
+    return {
+        coverageRatio: totalFiles === 0 ? 1 : coveredFiles.length / totalFiles,
+        coveredFiles,
+        totalFiles,
+        uncoveredFiles,
+    };
+};

package/dist/doctor.d.ts

@@ -0,0 +1,9 @@
+import { type PreparedLedgerState } from './recovery.ts';
+export declare const runLedgerDoctor: (workspaceRoot: string, options?: {
+    readonly skipPrepare?: boolean;
+    readonly state?: PreparedLedgerState;
+}) => Promise<{
+    issues: string[];
+    ok: boolean;
+}>;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/doctor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../src/doctor.ts"],"names":[],"mappings":"AAMA,OAAO,EAAmB,KAAK,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAsL1E,eAAO,MAAM,eAAe,GACxB,eAAe,MAAM,EACrB,UAAS;IAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,mBAAmB,CAAA;CAAO;;;EAyCzF,CAAC"}

package/dist/doctor.js

@@ -0,0 +1,172 @@
+import { stat } from 'node:fs/promises';
+import { mapWithConcurrencyLimit } from "./async.js";
+import { resolveBlobPath } from "./blobs.js";
+import { sha256File } from "./json.js";
+import { getOrderedEntryLocations, readManifestEntryBatch } from "./list.js";
+import { isReadIndexCurrent, readReadIndex } from "./read-index.js";
+import { loadLedgerState } from "./recovery.js";
+import { readManifest } from "./storage/filesystem.js";
+const BLOB_HASH_CONCURRENCY = 16;
+const ENTRY_READ_BATCH_SIZE = 32;
+const checkPrevChain = (entry, previousByPhase, issues) => {
+    const expectedPrev = previousByPhase.get(entry.phase) ?? null;
+    if (entry.prevEntryId !== expectedPrev) {
+        issues.push(`Phase ${entry.phase} has broken prevEntryId chain at ${entry.id}: expected ${expectedPrev ?? 'null'}, found ${entry.prevEntryId ?? 'null'}.`);
+    }
+    previousByPhase.set(entry.phase, entry.id);
+};
+const checkBlobPresence = async (workspaceRoot, blobChecks) => {
+    const results = await mapWithConcurrencyLimit(blobChecks, BLOB_HASH_CONCURRENCY, async ({ blobHash, entryId }) => {
+        try {
+            const blobPath = resolveBlobPath(workspaceRoot, blobHash);
+            await stat(blobPath);
+            const actualHash = await sha256File(blobPath);
+            if (actualHash !== blobHash) {
+                return `Blob ${blobHash} for ${entryId} is corrupted (found ${actualHash}).`;
+            }
+            return null;
+        }
+        catch {
+            return `Missing blob ${blobHash} for ${entryId}.`;
+        }
+    });
+    return results.filter((issue) => issue !== null);
+};
+const checkManifestCounts = (manifest, entryCount) => {
+    const issues = [];
+    if (manifest.entryCount !== entryCount) {
+        issues.push(`Manifest entryCount ${manifest.entryCount} does not match disk entries ${entryCount}.`);
+    }
+    if (manifest.lastSequence !== entryCount) {
+        issues.push(`Manifest lastSequence ${manifest.lastSequence} does not match disk entries ${entryCount}.`);
+    }
+    return issues;
+};
+const finalizeManifestChecks = ({ entryCount, issues, latestByPhase, manifest, unseenManifestEntryIds, }) => {
+    issues.push(...checkManifestCounts(manifest, entryCount));
+    for (const entryId of unseenManifestEntryIds) {
+        issues.push(`Manifest entry location points to missing disk entry ${entryId}.`);
+    }
+    for (const [phase, latest] of latestByPhase.entries()) {
+        if (manifest.perPhaseLatest[phase] !== latest.entryId) {
+            issues.push(`Manifest perPhaseLatest mismatch for ${phase}: expected ${latest.entryId}, found ${manifest.perPhaseLatest[phase] ?? 'missing'}.`);
+        }
+    }
+};
+const checkManifestSequenceOrder = (entryLocations, issues) => {
+    for (let index = 0; index < entryLocations.length; index += 1) {
+        const [entryId, location] = entryLocations[index];
+        const expectedSequence = index + 1;
+        if (location.sequence !== expectedSequence) {
+            issues.push(`Manifest sequence mismatch for ${entryId}: expected ${expectedSequence}, found ${location.sequence}.`);
+        }
+    }
+};
+const buildReadFailure = (error) => ({
+    issues: [`Failed to read ledger state: ${error instanceof Error ? (error.message ?? error.name) : String(error)}.`],
+    ok: false,
+});
+const inspectDoctorEntry = ({ blobChecks, entry, issues, latestByPhase, manifest, previousByPhase, unseenManifestEntryIds, }) => {
+    unseenManifestEntryIds.delete(entry.id);
+    checkPrevChain(entry, previousByPhase, issues);
+    const manifestLocation = manifest.entryLocations[entry.id];
+    if (!manifestLocation) {
+        issues.push(`Manifest is missing entry location for ${entry.id}.`);
+        return;
+    }
+    if (manifestLocation.phase !== entry.phase) {
+        issues.push(`Manifest phase mismatch for ${entry.id}: expected ${entry.phase}, found ${manifestLocation.phase}.`);
+    }
+    const currentLatest = latestByPhase.get(entry.phase);
+    if (!currentLatest || manifestLocation.sequence > currentLatest.sequence) {
+        latestByPhase.set(entry.phase, { entryId: entry.id, sequence: manifestLocation.sequence });
+    }
+    if (entry.kind !== 'agent-patch' && entry.kind !== 'operator-patch') {
+        return;
+    }
+    for (const blobHash of new Set([entry.diff.blobSha256, ...(entry.links.blobs ?? [])])) {
+        blobChecks.push({ blobHash, entryId: entry.id });
+    }
+};
+const collectDoctorState = async (workspaceRoot, manifest, readIndex) => {
+    const issues = [];
+    const previousByPhase = new Map();
+    const latestByPhase = new Map();
+    const unseenManifestEntryIds = new Set(Object.keys(manifest.entryLocations));
+    const blobChecks = [];
+    let entryCount = 0;
+    const orderedEntries = getOrderedEntryLocations(manifest, readIndex, {});
+    checkManifestSequenceOrder(orderedEntries, issues);
+    for (let index = 0; index < orderedEntries.length; index += ENTRY_READ_BATCH_SIZE) {
+        const batch = orderedEntries.slice(index, index + ENTRY_READ_BATCH_SIZE);
+        const resolvedEntries = await readManifestEntryBatch({
+            allowMissing: true,
+            entryLocations: batch,
+            workspaceRoot,
+        });
+        for (const resolvedEntry of resolvedEntries) {
+            if (!resolvedEntry.entry) {
+                continue;
+            }
+            entryCount += 1;
+            inspectDoctorEntry({
+                blobChecks,
+                entry: resolvedEntry.entry,
+                issues,
+                latestByPhase,
+                manifest,
+                previousByPhase,
+                unseenManifestEntryIds,
+            });
+        }
+    }
+    return {
+        blobChecks,
+        entryCount,
+        issues,
+        latestByPhase,
+        unseenManifestEntryIds,
+    };
+};
+export const runLedgerDoctor = async (workspaceRoot, options = {}) => {
+    let preparedState;
+    try {
+        if (options.state) {
+            preparedState = options.state;
+        }
+        else if (!options.skipPrepare) {
+            preparedState = await loadLedgerState(workspaceRoot);
+        }
+        else {
+            const manifest = await readManifest(workspaceRoot);
+            const readIndex = await readReadIndex(workspaceRoot);
+            if (!readIndex || !isReadIndexCurrent(readIndex, manifest)) {
+                throw new Error('runLedgerDoctor skipPrepare requires a current read index snapshot.');
+            }
+            preparedState = { manifest, readIndex };
+        }
+    }
+    catch (error) {
+        return buildReadFailure(error);
+    }
+    let doctorState;
+    try {
+        doctorState = await collectDoctorState(workspaceRoot, preparedState.manifest, preparedState.readIndex);
+    }
+    catch (error) {
+        return buildReadFailure(error);
+    }
+    const { blobChecks, entryCount, issues, latestByPhase, unseenManifestEntryIds } = doctorState;
+    issues.push(...(await checkBlobPresence(workspaceRoot, blobChecks)));
+    finalizeManifestChecks({
+        entryCount,
+        issues,
+        latestByPhase,
+        manifest: preparedState.manifest,
+        unseenManifestEntryIds,
+    });
+    return {
+        issues,
+        ok: issues.length === 0,
+    };
+};

package/dist/handle.d.ts

@@ -0,0 +1,28 @@
+import { computeCoverage } from './coverage.ts';
+import { runLedgerDoctor } from './doctor.ts';
+import { type LedgerFilter } from './list.ts';
+import { appendNote, type NoteBody } from './note.ts';
+import type { LedgerEntry, LedgerPhase } from './schema/entry.ts';
+export type LedgerHandle = {
+    readonly archive: (outPath: string) => Promise<{
+        integrityHash: string;
+    }>;
+    readonly computeCoverage: () => Promise<Awaited<ReturnType<typeof computeCoverage>>>;
+    readonly doctor: () => Promise<Awaited<ReturnType<typeof runLedgerDoctor>>>;
+    readonly list: (filter?: LedgerFilter) => AsyncIterable<LedgerEntry>;
+    readonly note: (subkind: Parameters<typeof appendNote>[1], body: NoteBody) => Promise<{
+        id: string;
+    }>;
+    readonly record: (entry: unknown) => Promise<{
+        id: string;
+    }>;
+    readonly render: (options: {
+        fresh?: boolean;
+        out?: string;
+        phase?: LedgerPhase;
+        to: 'analytics-summary' | 'dependency-graph' | 'jsonl' | 'retro' | 'timeline-html';
+    }) => Promise<string>;
+    readonly show: (entryId: string) => Promise<LedgerEntry | null>;
+};
+export declare const openLedger: (workspaceRoot: string) => Promise<LedgerHandle>;
+//# sourceMappingURL=handle.d.ts.map

package/dist/handle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle.d.ts","sourceRoot":"","sources":["../src/handle.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,EAA8B,KAAK,YAAY,EAAe,MAAM,WAAW,CAAC;AACvF,OAAO,EAAE,UAAU,EAAE,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC;AAQtD,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAwDlE,MAAM,MAAM,YAAY,GAAG;IACvB,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC1E,QAAQ,CAAC,eAAe,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC,CAAC;IACrF,QAAQ,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC,CAAC;IAC5E,QAAQ,CAAC,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,YAAY,KAAK,aAAa,CAAC,WAAW,CAAC,CAAC;IACrE,QAAQ,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACtG,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7D,QAAQ,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE;QACvB,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,KAAK,CAAC,EAAE,WAAW,CAAC;QACpB,EAAE,EAAE,mBAAmB,GAAG,kBAAkB,GAAG,OAAO,GAAG,OAAO,GAAG,eAAe,CAAC;KACtF,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;CACnE,CAAC;AAEF,eAAO,MAAM,UAAU,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,YAAY,CAsC5E,CAAC"}

package/dist/handle.js

@@ -0,0 +1,90 @@
+import { archiveLedger } from "./archive.js";
+import { computeCoverage } from "./coverage.js";
+import { runLedgerDoctor } from "./doctor.js";
+import { readLabManifestMin } from "./lab-min.js";
+import { iterateEntriesFromManifest, listEntries } from "./list.js";
+import { appendNote } from "./note.js";
+import { appendRecord, readEntryById } from "./record.js";
+import { loadLedgerState, prepareLedgerState } from "./recovery.js";
+import { renderAnalyticsSummary } from "./render/analytics-summary.js";
+import { renderDependencyGraph } from "./render/dependency-graph.js";
+import { renderJsonl } from "./render/jsonl.js";
+import { renderRetroMarkdown } from "./render/retro.js";
+import { renderTimelineHtml } from "./render/timeline-html.js";
+import { resolveLedgerPaths, writeAtomicTextFile } from "./storage/filesystem.js";
+const renderEntries = async ({ filter, target, useCache, workspaceRoot, }) => {
+    const { manifest, readIndex } = await loadLedgerState(workspaceRoot);
+    switch (target) {
+        case 'analytics-summary':
+            return renderAnalyticsSummary({
+                cachePath: resolveLedgerPaths(workspaceRoot).analyticsSummaryFile,
+                entries: iterateEntriesFromManifest(workspaceRoot, manifest, readIndex, filter),
+                filter,
+                manifest,
+                readIndex,
+                useCache,
+            });
+        case 'dependency-graph':
+            return renderDependencyGraph(iterateEntriesFromManifest(workspaceRoot, manifest, readIndex, filter));
+        case 'jsonl':
+            return renderJsonl(iterateEntriesFromManifest(workspaceRoot, manifest, readIndex, filter));
+        case 'timeline-html':
+            return renderTimelineHtml(iterateEntriesFromManifest(workspaceRoot, manifest, readIndex, filter));
+        case 'retro':
+            return renderRetroMarkdown({
+                entries: iterateEntriesFromManifest(workspaceRoot, manifest, readIndex, filter),
+                manifest,
+            });
+    }
+};
+const resolveRenderOutputPath = (workspaceRoot, target) => {
+    const paths = resolveLedgerPaths(workspaceRoot);
+    switch (target) {
+        case 'analytics-summary':
+            return paths.analyticsSummaryFile;
+        case 'retro':
+            return paths.renderFile;
+        case 'timeline-html':
+            return paths.renderTimelineFile;
+        default:
+            return null;
+    }
+};
+export const openLedger = async (workspaceRoot) => {
+    await readLabManifestMin(workspaceRoot);
+    await prepareLedgerState(workspaceRoot);
+    return {
+        archive: async (outPath) => archiveLedger(workspaceRoot, outPath),
+        computeCoverage: async () => computeCoverage(workspaceRoot),
+        doctor: async () => runLedgerDoctor(workspaceRoot),
+        list: (filter = {}) => listEntries(workspaceRoot, filter),
+        note: async (subkind, body) => {
+            const result = await appendNote(workspaceRoot, subkind, body);
+            return { id: result.id };
+        },
+        record: async (entry) => {
+            const result = await appendRecord(workspaceRoot, entry);
+            return { id: result.id };
+        },
+        render: async (options) => {
+            const content = await renderEntries({
+                filter: { phase: options.phase },
+                target: options.to,
+                useCache: options.to === 'analytics-summary' ? options.fresh !== true : false,
+                workspaceRoot,
+            });
+            const outputPath = options.out ?? resolveRenderOutputPath(workspaceRoot, options.to);
+            if (outputPath) {
+                await writeAtomicTextFile(outputPath, `${content}${content.endsWith('\n') ? '' : '\n'}`);
+            }
+            return content;
+        },
+        show: async (entryId) => {
+            const { manifest } = await loadLedgerState(workspaceRoot);
+            if (!manifest.entryLocations[entryId]) {
+                return null;
+            }
+            return readEntryById(workspaceRoot, manifest, entryId);
+        },
+    };
+};

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { buildAgentPatchRecord, buildCorrectionRecord, buildDescopeBriefRecord, buildMergeReturnRecord, buildMergeReturnRejectedRecord, buildOperatorDecisionRecord, buildOperatorPatchRecord, buildRevertRecord, buildReworkTestRetiredRecord, buildRollbackRecord, buildStageTransitionRecord, buildStripDecisionRevertedRecord, buildValidatorResultRecord, } from './builders.ts';
+export { runLedgerCli } from './cli.ts';
+export { type CoverageReport, computeCoverage } from './coverage.ts';
+export { type LedgerHandle, openLedger } from './handle.ts';
+export type { LedgerFilter } from './list.ts';
+export { derivePatchPayloadFromDiffText, parseStructuredPatch } from './patch-metadata.ts';
+export { type AnalyticsSummary, AnalyticsSummarySchema } from './render/analytics-summary.ts';
+export { type AgentPatchDiff, AgentPatchDiffSchema, AgentPatchEntrySchema, AgentPatchRecordSchema, CorrectionEntrySchema, type CorrectionPayload, CorrectionPayloadSchema, CorrectionRecordSchema, DescopeBriefEntrySchema, type DescopeBriefPayload, DescopeBriefPayloadSchema, DescopeBriefRecordSchema, EmitterSchema, type LedgerEntry, LedgerEntrySchema, type LedgerKind, LedgerLinksSchema, type LedgerPhase, LedgerPhaseSchema, type LedgerRecord, LedgerRecordSchema, MergeReturnEntrySchema, type MergeReturnPayload, MergeReturnPayloadSchema, MergeReturnRecordSchema, MergeReturnRejectedEntrySchema, MergeReturnRejectedPayloadSchema, MergeReturnRejectedRecordSchema, NoteEntrySchema, type OperatorDecisionAction, OperatorDecisionActionSchema, OperatorDecisionEntrySchema, OperatorDecisionPayloadSchema, OperatorDecisionRecordSchema, OperatorPatchEntrySchema, OperatorPatchRecordSchema, type PatchHunk, PatchHunkSchema, type PatchPayload, PatchPayloadSchema, PatchPayloadWriteSchema, parseLedgerEntry, parseLedgerRecord, RevertEntrySchema, RevertPayloadSchema, RevertRecordSchema, ReworkTestRetiredEntrySchema, type ReworkTestRetiredPayload, ReworkTestRetiredPayloadSchema, ReworkTestRetiredRecordSchema, RollbackEntrySchema, type RollbackPayload, RollbackPayloadSchema, RollbackRecordSchema, RuntimeEventEntrySchema, StageTransitionEntrySchema, type StageTransitionPayload, StageTransitionPayloadSchema, StageTransitionRecordSchema, StripDecisionRevertedEntrySchema, type StripDecisionRevertedPayload, StripDecisionRevertedPayloadSchema, StripDecisionRevertedRecordSchema, ToolInvocationEntrySchema, ToolInvocationRecordSchema, ValidatorResultEntrySchema, ValidatorResultPayloadSchema, ValidatorResultRecordSchema, } from './schema/entry.ts';
+export { type NoteSubkind, NoteSubkindSchema } from './schema/note.ts';
+export { resolveLedgerPaths } from './storage/filesystem.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,sBAAsB,EACtB,8BAA8B,EAC9B,2BAA2B,EAC3B,wBAAwB,EACxB,iBAAiB,EACjB,4BAA4B,EAC5B,mBAAmB,EACnB,0BAA0B,EAC1B,gCAAgC,EAChC,0BAA0B,GAC7B,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,KAAK,cAAc,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EAAE,KAAK,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC5D,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,8BAA8B,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3F,OAAO,EAAE,KAAK,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAC9F,OAAO,EACH,KAAK,cAAc,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,sBAAsB,EACtB,qBAAqB,EACrB,KAAK,iBAAiB,EACtB,uBAAuB,EACvB,sBAAsB,EACtB,uBAAuB,EACvB,KAAK,mBAAmB,EACxB,yBAAyB,EACzB,wBAAwB,EACxB,aAAa,EACb,KAAK,WAAW,EAChB,iBAAiB,EACjB,KAAK,UAAU,EACf,iBAAiB,EACjB,KAAK,WAAW,EAChB,iBAAiB,EACjB,KAAK,YAAY,EACjB,kBAAkB,EAClB,sBAAsB,EACtB,KAAK,kBAAkB,EACvB,wBAAwB,EACxB,uBAAuB,EACvB,8BAA8B,EAC9B,gCAAgC,EAChC,+BAA+B,EAC/B,eAAe,EACf,KAAK,sBAAsB,EAC3B,4BAA4B,EAC5B,2BAA2B,EAC3B,6BAA6B,EAC7B,4BAA4B,EAC5B,wBAAwB,EACxB,yBAAyB,EACzB,KAAK,SAAS,EACd,eAAe,EACf,KAAK,YAAY,EACjB,kBAAkB,EAClB,uBAAuB,EACvB,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,4BAA4B,EAC5B,KAAK,wBAAwB,EAC7B,8BAA8B,EAC9B,6BAA6B,EAC7B,mBAAmB,EACnB,KAAK,eAAe,EACpB,qBAAqB,EACrB,oBAAoB,EACpB,uBAAuB,EACvB,0BAA0B,EAC1B,KAAK,sBAAsB,EAC3B,4BAA4B,EAC5B,2BAA2B,EAC3B,gCAAgC,EAChC,KAAK,4BAA4B,EACjC,kCAAkC,EAClC,iCAAiC,EACjC,yBAAyB,EACzB,0BAA0B,EAC1B,0BAA0B,EAC1B,4BAA4B,EAC5B,2BAA2B,GAC9B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,WAAW,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/index.js

@@ -0,0 +1,9 @@
+export { buildAgentPatchRecord, buildCorrectionRecord, buildDescopeBriefRecord, buildMergeReturnRecord, buildMergeReturnRejectedRecord, buildOperatorDecisionRecord, buildOperatorPatchRecord, buildRevertRecord, buildReworkTestRetiredRecord, buildRollbackRecord, buildStageTransitionRecord, buildStripDecisionRevertedRecord, buildValidatorResultRecord, } from "./builders.js";
+export { runLedgerCli } from "./cli.js";
+export { computeCoverage } from "./coverage.js";
+export { openLedger } from "./handle.js";
+export { derivePatchPayloadFromDiffText, parseStructuredPatch } from "./patch-metadata.js";
+export { AnalyticsSummarySchema } from "./render/analytics-summary.js";
+export { AgentPatchDiffSchema, AgentPatchEntrySchema, AgentPatchRecordSchema, CorrectionEntrySchema, CorrectionPayloadSchema, CorrectionRecordSchema, DescopeBriefEntrySchema, DescopeBriefPayloadSchema, DescopeBriefRecordSchema, EmitterSchema, LedgerEntrySchema, LedgerLinksSchema, LedgerPhaseSchema, LedgerRecordSchema, MergeReturnEntrySchema, MergeReturnPayloadSchema, MergeReturnRecordSchema, MergeReturnRejectedEntrySchema, MergeReturnRejectedPayloadSchema, MergeReturnRejectedRecordSchema, NoteEntrySchema, OperatorDecisionActionSchema, OperatorDecisionEntrySchema, OperatorDecisionPayloadSchema, OperatorDecisionRecordSchema, OperatorPatchEntrySchema, OperatorPatchRecordSchema, PatchHunkSchema, PatchPayloadSchema, PatchPayloadWriteSchema, parseLedgerEntry, parseLedgerRecord, RevertEntrySchema, RevertPayloadSchema, RevertRecordSchema, ReworkTestRetiredEntrySchema, ReworkTestRetiredPayloadSchema, ReworkTestRetiredRecordSchema, RollbackEntrySchema, RollbackPayloadSchema, RollbackRecordSchema, RuntimeEventEntrySchema, StageTransitionEntrySchema, StageTransitionPayloadSchema, StageTransitionRecordSchema, StripDecisionRevertedEntrySchema, StripDecisionRevertedPayloadSchema, StripDecisionRevertedRecordSchema, ToolInvocationEntrySchema, ToolInvocationRecordSchema, ValidatorResultEntrySchema, ValidatorResultPayloadSchema, ValidatorResultRecordSchema, } from "./schema/entry.js";
+export { NoteSubkindSchema } from "./schema/note.js";
+export { resolveLedgerPaths } from "./storage/filesystem.js";

package/dist/json.d.ts

@@ -0,0 +1,4 @@
+export declare const stableStringify: (value: unknown, pretty?: boolean) => string;
+export declare const sha256Hex: (value: Uint8Array | string) => string;
+export declare const sha256File: (filePath: string) => Promise<string>;
+//# sourceMappingURL=json.d.ts.map

package/dist/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe,GAAI,OAAO,OAAO,EAAE,gBAAc,KAAG,MAMhE,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,OAAO,UAAU,GAAG,MAAM,KAAG,MAA0D,CAAC;AAElH,eAAO,MAAM,UAAU,GAAU,UAAU,MAAM,KAAG,OAAO,CAAC,MAAM,CAajE,CAAC"}

package/dist/json.js

@@ -0,0 +1,25 @@
+import { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import stringify from 'safe-stable-stringify';
+export const stableStringify = (value, pretty = false) => {
+    const text = stringify(value, undefined, pretty ? 2 : undefined);
+    if (text === undefined) {
+        throw new Error('Failed to serialize value.');
+    }
+    return text;
+};
+export const sha256Hex = (value) => createHash('sha256').update(value).digest('hex');
+export const sha256File = async (filePath) => {
+    const hash = createHash('sha256');
+    await new Promise((resolve, reject) => {
+        const stream = createReadStream(filePath);
+        stream.on('data', (chunk) => {
+            hash.update(chunk);
+        });
+        stream.on('end', () => {
+            resolve();
+        });
+        stream.on('error', reject);
+    });
+    return hash.digest('hex');
+};

package/dist/lab-min.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const LabManifestMin: z.ZodObject<{
+    createdAt: z.ZodOptional<z.ZodString>;
+    schemaVersion: z.ZodLiteral<"ushman-lab/v4.0">;
+    workspaceId: z.ZodString;
+}, z.core.$loose>;
+export type LabManifestMin = z.infer<typeof LabManifestMin>;
+export declare const readLabManifestMin: (workspaceRoot: string) => Promise<LabManifestMin>;
+//# sourceMappingURL=lab-min.d.ts.map

package/dist/lab-min.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lab-min.d.ts","sourceRoot":"","sources":["../src/lab-min.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc;;;;iBAMT,CAAC;AAEnB,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,eAAO,MAAM,kBAAkB,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,cAAc,CAWtF,CAAC"}

package/dist/lab-min.js

@@ -0,0 +1,23 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { z } from 'zod';
+export const LabManifestMin = z
+    .object({
+    createdAt: z.string().optional(),
+    schemaVersion: z.literal('ushman-lab/v4.0'),
+    workspaceId: z.string().uuid(),
+})
+    .passthrough();
+export const readLabManifestMin = async (workspaceRoot) => {
+    const filePath = path.join(workspaceRoot, '.lab', 'lab.json');
+    try {
+        const text = await readFile(filePath, 'utf8');
+        return LabManifestMin.parse(JSON.parse(text));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(`Workspace is not initialized: missing ${filePath}.`);
+        }
+        throw error;
+    }
+};