ushman-ledger 1.1.0 → 1.2.0

package/dist/schema/entry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entry.d.ts","sourceRoot":"","sources":["../../src/schema/entry.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"entry.d.ts","sourceRoot":"","sources":["../../src/schema/entry.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAqB,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAE,KAAK,YAAY,EAAsB,MAAM,kBAAkB,CAAC;AAEzE,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AAEjC,eAAO,MAAM,gBAAgB,GAAI,OAAO,OAAO,KAAG,WAAyE,CAAC;AAE5H,eAAO,MAAM,iBAAiB,GAAI,OAAO,OAAO,KAAG,YACa,CAAC"}

package/dist/schema/entry.js

@@ -1,287 +1,10 @@
-import path from 'node:path';
 import * as v from 'valibot';
-import { NoteSubkindSchema } from "./note.js";
-export const LedgerSchemaVersion = 'ushman-ledger-entry/v1';
-export const LEDGER_PHASES = [
-    'capture',
-    'intake',
-    'seed',
-    'vendor-extract',
-    'cleanup',
-    'parity',
-    'characterize',
-    'equiv',
-    'analyze',
-    'recover',
-    'ship',
-    'migration',
-];
-export const LEDGER_KINDS = [
-    'tool-invocation',
-    'agent-patch',
-    'operator-patch',
-    'operator-decision',
-    'validator-result',
-    'runtime-event',
-    'note',
-    'correction',
-    'strip-decision-reverted',
-];
-export const OPERATOR_DECISION_ACTIONS = [
-    'bypass-doctor',
-    'skip-check',
-    'override-strip-decision',
-    'override-ship-state',
-    'manual-parity-assertion',
-    'ledger-hand-edit',
-    'escalation',
-];
-const STRIP_DECISION_INVALIDATED_STAGES = [
-    'intake',
-    'seed',
-    'vendor-extract',
-    'cleanup',
-    'parity',
-    'characterize',
-];
-const SHA256_HEX_PATTERN = /^[a-f0-9]{64}$/u;
-const WINDOWS_ABSOLUTE_PATH_PATTERN = /^[a-z]:[\\/]/iu;
-const normalizeWorkspaceRelativePath = (value) => value.replaceAll('\\', '/');
-const isNormalizedWorkspaceRelativePath = (value) => {
-    const normalized = normalizeWorkspaceRelativePath(value);
-    if (normalized.startsWith('/') || WINDOWS_ABSOLUTE_PATH_PATTERN.test(value)) {
-        return false;
-    }
-    if (normalized.startsWith('./') ||
-        normalized.endsWith('/') ||
-        normalized.includes('//') ||
-        normalized === '.' ||
-        normalized === '..') {
-        return false;
-    }
-    if (path.posix.normalize(normalized) !== normalized) {
-        return false;
-    }
-    return !normalized.split('/').includes('..');
-};
-const WorkspaceRelativePathSchema = v.pipe(v.string(), v.minLength(1), v.check(isNormalizedWorkspaceRelativePath, 'Expected a normalized workspace-relative path.'));
-const SHA256HexSchema = v.pipe(v.string(), v.regex(SHA256_HEX_PATTERN, 'Expected a lowercase SHA-256 hex digest.'));
-export const LedgerPhaseSchema = v.picklist(LEDGER_PHASES);
-export const OperatorDecisionActionSchema = v.picklist(OPERATOR_DECISION_ACTIONS);
-const StripDecisionInvalidatedStageSchema = v.picklist(STRIP_DECISION_INVALIDATED_STAGES);
-export const EmitterSchema = v.object({
-    tool: v.pipe(v.string(), v.minLength(1)),
-    user: v.optional(v.pipe(v.string(), v.minLength(1))),
-    version: v.pipe(v.string(), v.minLength(1)),
-});
-export const LedgerLinksSchema = v.objectWithRest({
-    affectedFiles: v.optional(v.array(WorkspaceRelativePathSchema)),
-    blobs: v.optional(v.array(v.string())),
-    briefId: v.optional(v.string()),
-    correctsLedgerId: v.optional(v.string()),
-    gitRef: v.optional(v.string()),
-    idempotencyKey: v.optional(v.string()),
-    stripDecisionId: v.optional(v.string()),
-    supersedesLedgerId: v.optional(v.string()),
-    validatorVerdictId: v.optional(v.string()),
-}, v.unknown());
-const ledgerEntryBaseEntries = {
-    details: v.optional(v.record(v.string(), v.unknown())),
-    emitter: EmitterSchema,
-    id: v.pipe(v.string(), v.minLength(1)),
-    links: v.optional(LedgerLinksSchema, {}),
-    phase: LedgerPhaseSchema,
-    prevEntryId: v.nullable(v.pipe(v.string(), v.minLength(1))),
-    schemaVersion: v.literal(LedgerSchemaVersion),
-    summary: v.pipe(v.string(), v.minLength(1)),
-    ts: v.pipe(v.string(), v.isoTimestamp()),
-};
-export const AgentPatchDiffSchema = v.object({
-    addedLines: v.pipe(v.number(), v.integer(), v.minValue(0)),
-    blobSha256: SHA256HexSchema,
-    bytes: v.pipe(v.number(), v.integer(), v.minValue(0)),
-    removedLines: v.pipe(v.number(), v.integer(), v.minValue(0)),
-});
-export const OperatorDecisionPayloadSchema = v.object({
-    action: OperatorDecisionActionSchema,
-    checkId: v.optional(v.pipe(v.string(), v.minLength(1))),
-    rationale: v.pipe(v.string(), v.trim(), v.minLength(1, 'payload.rationale must not be empty')),
-});
-export const StripDecisionRevertedPayloadSchema = v.object({
-    invalidatedStages: v.optional(v.array(StripDecisionInvalidatedStageSchema)),
-    rationale: v.pipe(v.string(), v.trim(), v.minLength(1)),
-    stripDecisionId: v.pipe(v.string(), v.minLength(1)),
-});
-export const ToolInvocationEntrySchema = v.object({
-    ...ledgerEntryBaseEntries,
-    args: v.optional(v.array(v.string())),
-    cwd: v.optional(v.string()),
-    exitCode: v.optional(v.pipe(v.number(), v.integer())),
-    kind: v.literal('tool-invocation'),
-});
-const patchEntryEntries = {
-    ...ledgerEntryBaseEntries,
-    diff: AgentPatchDiffSchema,
-    rationale: v.pipe(v.string(), v.minLength(1)),
-};
-export const AgentPatchEntrySchema = v.object({
-    ...patchEntryEntries,
-    agent: v.object({
-        name: v.pipe(v.string(), v.minLength(1)),
-        sessionId: v.optional(v.pipe(v.string(), v.minLength(1))),
-    }),
-    kind: v.literal('agent-patch'),
-});
-export const OperatorPatchEntrySchema = v.object({
-    ...patchEntryEntries,
-    kind: v.literal('operator-patch'),
-    operator: v.object({
-        name: v.pipe(v.string(), v.minLength(1)),
-    }),
-});
-export const OperatorDecisionEntrySchema = v.object({
-    ...ledgerEntryBaseEntries,
-    kind: v.literal('operator-decision'),
-    payload: OperatorDecisionPayloadSchema,
-});
-export const ValidatorResultEntrySchema = v.object({
-    ...ledgerEntryBaseEntries,
-    kind: v.literal('validator-result'),
-    metrics: v.optional(v.record(v.string(), v.unknown())),
-    resultPath: v.optional(v.string()),
-    validator: v.picklist(['parity', 'equiv', 'characterize', 'verify', 'doctor']),
-    verdict: v.picklist(['green', 'yellow', 'red']),
-});
-export const RuntimeEventEntrySchema = v.object({
-    ...ledgerEntryBaseEntries,
-    kind: v.literal('runtime-event'),
-    level: v.picklist(['info', 'warn', 'error']),
-    message: v.pipe(v.string(), v.minLength(1)),
-    source: v.pipe(v.string(), v.minLength(1)),
-    stripDecisionId: v.optional(v.string()),
-});
-export const NoteEntrySchema = v.object({
-    ...ledgerEntryBaseEntries,
-    body: v.string(),
-    kind: v.literal('note'),
-    subkind: NoteSubkindSchema,
-});
-export const CorrectionEntrySchema = v.pipe(v.object({
-    ...ledgerEntryBaseEntries,
-    kind: v.literal('correction'),
-    rationale: v.pipe(v.string(), v.minLength(1)),
-}), v.check((value) => Boolean(value.links?.correctsLedgerId), 'correction entries require links.correctsLedgerId'));
-export const StripDecisionRevertedEntrySchema = v.object({
-    ...ledgerEntryBaseEntries,
-    kind: v.literal('strip-decision-reverted'),
-    payload: StripDecisionRevertedPayloadSchema,
-});
-export const LedgerEntrySchema = v.variant('kind', [
-    ToolInvocationEntrySchema,
-    AgentPatchEntrySchema,
-    OperatorPatchEntrySchema,
-    OperatorDecisionEntrySchema,
-    ValidatorResultEntrySchema,
-    RuntimeEventEntrySchema,
-    NoteEntrySchema,
-    CorrectionEntrySchema,
-    StripDecisionRevertedEntrySchema,
-]);
-const recordEntryBaseEntries = {
-    details: v.optional(v.record(v.string(), v.unknown())),
-    emitter: EmitterSchema,
-    idempotencyKey: v.optional(v.pipe(v.string(), v.minLength(1))),
-    links: v.optional(LedgerLinksSchema),
-    phase: LedgerPhaseSchema,
-    summary: v.pipe(v.string(), v.minLength(1)),
-};
-export const ToolInvocationRecordSchema = v.object({
-    ...recordEntryBaseEntries,
-    args: v.optional(v.array(v.string())),
-    cwd: v.optional(v.string()),
-    exitCode: v.optional(v.pipe(v.number(), v.integer())),
-    kind: v.literal('tool-invocation'),
-});
-const patchRecordEntries = {
-    ...recordEntryBaseEntries,
-    diff: v.optional(AgentPatchDiffSchema),
-    diffPath: v.optional(v.pipe(v.string(), v.minLength(1))),
-    diffText: v.optional(v.pipe(v.string(), v.minLength(1))),
-    rationale: v.pipe(v.string(), v.minLength(1)),
-};
-const validatePatchRecord = (value) => {
-    const provided = [value.diff, value.diffPath, value.diffText].filter((entry) => Boolean(entry));
-    if (provided.length === 0) {
-        return false;
-    }
-    if (value.diffPath && value.diffText) {
-        return false;
-    }
-    return true;
-};
-const PATCH_RECORD_REFINEMENT_MESSAGE = 'patch records require exactly one source: diff, diffPath, or diffText (diffPath and diffText cannot be combined).';
-export const AgentPatchRecordSchema = v.pipe(v.object({
-    ...patchRecordEntries,
-    agent: v.object({
-        name: v.pipe(v.string(), v.minLength(1)),
-        sessionId: v.optional(v.pipe(v.string(), v.minLength(1))),
-    }),
-    kind: v.literal('agent-patch'),
-}), v.check(validatePatchRecord, PATCH_RECORD_REFINEMENT_MESSAGE));
-export const OperatorPatchRecordSchema = v.pipe(v.object({
-    ...patchRecordEntries,
-    kind: v.literal('operator-patch'),
-    operator: v.object({
-        name: v.pipe(v.string(), v.minLength(1)),
-    }),
-}), v.check(validatePatchRecord, PATCH_RECORD_REFINEMENT_MESSAGE));
-export const OperatorDecisionRecordSchema = v.object({
-    ...recordEntryBaseEntries,
-    kind: v.literal('operator-decision'),
-    payload: OperatorDecisionPayloadSchema,
-});
-export const ValidatorResultRecordSchema = v.object({
-    ...recordEntryBaseEntries,
-    kind: v.literal('validator-result'),
-    metrics: v.optional(v.record(v.string(), v.unknown())),
-    resultPath: v.optional(v.string()),
-    validator: v.picklist(['parity', 'equiv', 'characterize', 'verify', 'doctor']),
-    verdict: v.picklist(['green', 'yellow', 'red']),
-});
-export const RuntimeEventRecordSchema = v.object({
-    ...recordEntryBaseEntries,
-    kind: v.literal('runtime-event'),
-    level: v.picklist(['info', 'warn', 'error']),
-    message: v.pipe(v.string(), v.minLength(1)),
-    source: v.pipe(v.string(), v.minLength(1)),
-    stripDecisionId: v.optional(v.string()),
-});
-export const NoteRecordSchema = v.object({
-    ...recordEntryBaseEntries,
-    body: v.string(),
-    kind: v.literal('note'),
-    subkind: NoteSubkindSchema,
-});
-export const CorrectionRecordSchema = v.pipe(v.object({
-    ...recordEntryBaseEntries,
-    kind: v.literal('correction'),
-    rationale: v.pipe(v.string(), v.minLength(1)),
-}), v.check((value) => Boolean(value.links?.correctsLedgerId), 'correction records require links.correctsLedgerId'));
-export const StripDecisionRevertedRecordSchema = v.object({
-    ...recordEntryBaseEntries,
-    kind: v.literal('strip-decision-reverted'),
-    payload: StripDecisionRevertedPayloadSchema,
-});
-export const LedgerRecordSchema = v.variant('kind', [
-    ToolInvocationRecordSchema,
-    AgentPatchRecordSchema,
-    OperatorPatchRecordSchema,
-    OperatorDecisionRecordSchema,
-    ValidatorResultRecordSchema,
-    RuntimeEventRecordSchema,
-    NoteRecordSchema,
-    CorrectionRecordSchema,
-    StripDecisionRevertedRecordSchema,
-]);
-export const parseLedgerEntry = (input) => v.parse(LedgerEntrySchema, input);
-export const parseLedgerRecord = (input) => v.parse(LedgerRecordSchema, input);
+import { migrateLedgerEntryInput, migrateLedgerRecordInput } from "./entry-migrations.js";
+import { LedgerEntrySchema } from "./entry-read.js";
+import { LedgerRecordSchema } from "./entry-write.js";
+export * from "./entry-core.js";
+export * from "./entry-migrations.js";
+export * from "./entry-read.js";
+export * from "./entry-write.js";
+export const parseLedgerEntry = (input) => v.parse(LedgerEntrySchema, migrateLedgerEntryInput(input));
+export const parseLedgerRecord = (input) => v.parse(LedgerRecordSchema, migrateLedgerRecordInput(input));

package/dist/schema/note.d.ts

@@ -1,4 +1,4 @@
 import * as v from 'valibot';
-export declare const NoteSubkindSchema: v.PicklistSchema<["regression", "automation", "retro", "operator", "tooling-gap"], undefined>;
+export declare const NoteSubkindSchema: v.PicklistSchema<["regression", "automation", "retro", "operator", "tooling-gap", "cleanup-wave", "verified-flow", "open-issue", "decomposition-wave", "semantic-cleanup-summary"], undefined>;
 export type NoteSubkind = v.InferOutput<typeof NoteSubkindSchema>;
 //# sourceMappingURL=note.d.ts.map

package/dist/schema/note.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"note.d.ts","sourceRoot":"","sources":["../../src/schema/note.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAE7B,eAAO,MAAM,iBAAiB,+FAA+E,CAAC;AAE9G,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC"}
+{"version":3,"file":"note.d.ts","sourceRoot":"","sources":["../../src/schema/note.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAE7B,eAAO,MAAM,iBAAiB,gMAW5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/schema/note.js

@@ -1,2 +1,13 @@
 import * as v from 'valibot';
-export const NoteSubkindSchema = v.picklist(['regression', 'automation', 'retro', 'operator', 'tooling-gap']);
+export const NoteSubkindSchema = v.picklist([
+    'regression',
+    'automation',
+    'retro',
+    'operator',
+    'tooling-gap',
+    'cleanup-wave',
+    'verified-flow',
+    'open-issue',
+    'decomposition-wave',
+    'semantic-cleanup-summary',
+]);

package/dist/storage/filesystem.d.ts

@@ -16,7 +16,9 @@ export type LedgerPaths = {
     readonly phaseDir: (phase: LedgerPhase) => string;
     readonly readIndexFile: string;
     readonly renderFile: string;
+    readonly renderMigrationLogFile: string;
     readonly renderTimelineFile: string;
+    readonly renderWorkspaceNarrativeFile: string;
     readonly root: string;
     readonly workspaceRoot: string;
 };

package/dist/storage/filesystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filesystem.d.ts","sourceRoot":"","sources":["../../src/storage/filesystem.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,aAAa,EAAE,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACrE,OAAO,EAAE,KAAK,cAAc,EAAwB,MAAM,uBAAuB,CAAC;AAElF,OAAO,EAAE,aAAa,EAAE,CAAC;AACzB,eAAO,MAAM,oBAAoB,6BAA8B,CAAC;AAChE,eAAO,MAAM,oBAAoB,QAAS,CAAC;AAC3C,KAAK,mBAAmB,GAAG;IACvB,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/C,CAAC;AAaF,MAAM,MAAM,WAAW,GAAG;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,MAAM,CAAC;IAClD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,MAAM,CAAC;IAClD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,eAAe,MAAM,KAAG,WAgB1D,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,WAAW,CAYxF,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,UAAU,MAAM,EAAE,MAAM,mBAAmB,GAAG,IAAI,SAOxF,CAAC;AAoBF,eAAO,MAAM,mBAAmB,GAAU,UAAU,MAAM,EAAE,MAAM,MAAM,kBAiBvE,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAU,UAAU,MAAM,EAAE,OAAO,OAAO,kBAEzE,CAAC;AAoCF,eAAO,MAAM,YAAY,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,cAAc,CAmBhF,CAAC;AAEF,eAAO,MAAM,YAAY,GAAU,eAAe,MAAM,EAAE,UAAU,cAAc,kBASjF,CAAC;AAoFF,eAAO,MAAM,qBAAqB,GAAU,eAAe,MAAM,kBAIhE,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAU,eAAe,MAAM,EAAE,OAAO,WAAW,KAAG,OAAO,CAAC,MAAM,EAAE,CAOzG,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,eAAe,MAAM,EAAE,OAAO,WAAW,EAAE,UAAU,MAAM,oBAGnG,CAAC;AAEF,eAAO,MAAM,cAAc,GAAU,eAAe,MAAM,EAAE,OAAO,WAAW,EAAE,UAAU,MAAM,EAAE,OAAO,OAAO,oBAK/G,CAAC"}
+{"version":3,"file":"filesystem.d.ts","sourceRoot":"","sources":["../../src/storage/filesystem.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,aAAa,EAAE,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACrE,OAAO,EAAE,KAAK,cAAc,EAAwB,MAAM,uBAAuB,CAAC;AAElF,OAAO,EAAE,aAAa,EAAE,CAAC;AACzB,eAAO,MAAM,oBAAoB,6BAA8B,CAAC;AAChE,eAAO,MAAM,oBAAoB,QAAS,CAAC;AAC3C,KAAK,mBAAmB,GAAG;IACvB,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/C,CAAC;AAaF,MAAM,MAAM,WAAW,GAAG;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,MAAM,CAAC;IAClD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,MAAM,CAAC;IAClD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;IACxC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,4BAA4B,EAAE,MAAM,CAAC;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,eAAe,MAAM,KAAG,WAkB1D,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,WAAW,CAYxF,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,UAAU,MAAM,EAAE,MAAM,mBAAmB,GAAG,IAAI,SAOxF,CAAC;AAoBF,eAAO,MAAM,mBAAmB,GAAU,UAAU,MAAM,EAAE,MAAM,MAAM,kBAiBvE,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAU,UAAU,MAAM,EAAE,OAAO,OAAO,kBAEzE,CAAC;AAoCF,eAAO,MAAM,YAAY,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,cAAc,CAmBhF,CAAC;AAEF,eAAO,MAAM,YAAY,GAAU,eAAe,MAAM,EAAE,UAAU,cAAc,kBASjF,CAAC;AAoFF,eAAO,MAAM,qBAAqB,GAAU,eAAe,MAAM,kBAIhE,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAU,eAAe,MAAM,EAAE,OAAO,WAAW,KAAG,OAAO,CAAC,MAAM,EAAE,CAOzG,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,eAAe,MAAM,EAAE,OAAO,WAAW,EAAE,UAAU,MAAM,oBAGnG,CAAC;AAEF,eAAO,MAAM,cAAc,GAAU,eAAe,MAAM,EAAE,OAAO,WAAW,EAAE,UAAU,MAAM,EAAE,OAAO,OAAO,oBAK/G,CAAC"}

package/dist/storage/filesystem.js

@@ -29,7 +29,9 @@ export const resolveLedgerPaths = (workspaceRoot) => {
         phaseDir: (phase) => path.join(root, phase),
         readIndexFile: path.join(root, 'read-index.json'),
         renderFile: path.join(root, 'render.md'),
+        renderMigrationLogFile: path.join(root, 'render.migration-log.md'),
         renderTimelineFile: path.join(root, 'render.timeline.html'),
+        renderWorkspaceNarrativeFile: path.join(root, 'render.workspace-narrative.md'),
         root,
         workspaceRoot,
     };

package/dist/storage/lock-reclaimer.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lock-reclaimer.d.ts.map

package/dist/storage/lock-reclaimer.d.ts.map

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

package/dist/storage/lock-reclaimer.js

@@ -0,0 +1,45 @@
+import { mkdir, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { acquireLock } from "./lock.js";
+const [, , lockPath, signalDir] = process.argv;
+if (!lockPath || !signalDir) {
+    throw new Error('Expected lock path and signal directory.');
+}
+const waitForFile = async (filePath) => {
+    while (true) {
+        try {
+            await stat(filePath);
+            return;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, 5));
+    }
+};
+const observedPath = path.join(signalDir, 'observed');
+const continuePath = path.join(signalDir, 'continue');
+const acquiredPath = path.join(signalDir, 'acquired');
+const timedOutPath = path.join(signalDir, 'timed-out');
+await mkdir(signalDir, { recursive: true });
+try {
+    const lock = await acquireLock(lockPath, {
+        retryDelayMs: 10,
+        staleMs: 1_000,
+        testHooks: {
+            afterStaleObservation: async () => {
+                await writeFile(observedPath, '1', 'utf8');
+                await waitForFile(continuePath);
+            },
+        },
+        timeoutMs: 100,
+    });
+    await writeFile(acquiredPath, '1', 'utf8');
+    await lock.release();
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    await writeFile(timedOutPath, message, 'utf8');
+}

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const LEDGER_LIBRARY_VERSION = "1.0.0";
+export declare const LEDGER_LIBRARY_VERSION = "1.1.0";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -1 +1 @@
-export const LEDGER_LIBRARY_VERSION = '1.0.0';
+export const LEDGER_LIBRARY_VERSION = '1.1.0';

package/package.json

@@ -18,7 +18,7 @@
     "devDependencies": {
         "@biomejs/biome": "^2.4.15",
         "@types/bun": "^1.3.14",
-        "@types/node": "^25.8.0",
+        "@types/node": "^25.9.1",
         "typescript": "^6.0.3"
     },
     "engines": {
@@ -68,5 +68,5 @@
     },
     "type": "module",
     "types": "dist/index.d.ts",
-    "version": "1.1.0"
+    "version": "1.2.0"
 }