@unbrained/pm-cli 2026.9.2 → 2026.9.4

package/dist/core/history/history.d.ts

@@ -1,11 +1,47 @@
 import { type AuthorSource } from "../shared/author.js";
-import type { HistoryEntry, ItemDocument } from "../../types/index.js";
+import type { HistoryEntry, HistoryPatchOp, ItemDocument } from "../../types/index.js";
 /** Hash epoch for the current canonical item surface written into immutable history. */
 export declare const CURRENT_HISTORY_ITEM_HASH_VERSION: 3;
 /** Hash epochs understood by this runtime. */
 export declare const SUPPORTED_HISTORY_ITEM_HASH_VERSIONS: readonly [1, 2, 3];
+/** Record-integrity epoch written beside new immutable history events. */
+export declare const CURRENT_HISTORY_RECORD_HASH_VERSION: 1;
+/** Record-integrity epochs understood by this runtime. */
+export declare const SUPPORTED_HISTORY_RECORD_HASH_VERSIONS: readonly [1];
 /** Restricts item hash versions accepted by history replay. */
 export type HistoryItemHashVersion = (typeof SUPPORTED_HISTORY_ITEM_HASH_VERSIONS)[number];
+/** Restricts immutable-record hash versions accepted by history replay. */
+export type HistoryRecordHashVersion = (typeof SUPPORTED_HISTORY_RECORD_HASH_VERSIONS)[number];
+/** Canonicalize and hash every immutable record field except the hash value itself. */
+export declare function hashHistoryRecord(entry: Omit<HistoryEntry, "record_hash">): string;
+/** Hash one patch representation without retaining its potentially sensitive values. */
+export declare function hashHistoryPatch(patch: readonly HistoryPatchOp[]): string;
+/** Hash an ordered history prefix for compact checkpoint provenance. */
+export declare function hashHistoryStream(entries: readonly HistoryEntry[]): string;
+/** Attach the current immutable-record integrity envelope to one history event. */
+export declare function sealHistoryRecord(entry: HistoryEntry): HistoryEntry;
+/** Verify record-level attribution coverage while accepting explicit legacy item-state-only entries. */
+export declare function verifyHistoryRecordHash(entry: HistoryEntry): {
+    ok: true;
+    coverage: "record_and_item_state" | "item_state_only";
+} | {
+    ok: false;
+    error: "incomplete_record_hash_envelope" | "record_hash_mismatch" | "unsupported_record_hash_version";
+};
+/** Reseal a maintenance rewrite and retain the anchors and patch digest it replaced. */
+export declare function resealHistoryRewrite(original: HistoryEntry, rewritten: HistoryEntry, options?: Readonly<{
+    retainOriginalPatch?: boolean;
+    retainPriorRecord?: boolean;
+    retainPriorRecordHash?: boolean;
+}>): HistoryEntry;
+/** Verify that retained rewrite evidence reconstructs every available prior record envelope. */
+export declare function verifyHistoryRewriteEvidence(entry: HistoryEntry): {
+    ok: true;
+    coverage: "complete" | "digest_only" | "legacy_anchor_only" | "none";
+} | {
+    ok: false;
+    error: "rewrite_evidence_invalid" | "rewrite_evidence_patch_hash_mismatch" | "rewrite_evidence_record_hash_mismatch";
+};
 declare function decodeJsonPointer(path: string): string[];
 declare function isDefinedPointerPath(document: unknown, path: string): boolean;
 /** Implements hash document for the public runtime surface of this module. */

package/dist/core/history/history.js

@@ -4,18 +4,20 @@
  * Implements append-only history and replay behavior for History.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="60d6ec0e-a8ed-5a5d-b5bd-d29da8532a79")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="bf6a9831-134c-5dc2-a3e2-74dca00cf22c")}catch(e){}}();
 import jsonPatch from "fast-json-patch";
-import { ITEM_METADATA_KEY_ORDER } from "../shared/constants.js";
+import { EXIT_CODE, ITEM_METADATA_KEY_ORDER } from "../shared/constants.js";
 import { runActiveServiceOverride } from "../extensions/index.js";
 import { appendLineAtomic } from "../fs/fs-utils.js";
 import { canonicalDocument } from "../item/item-format.js";
 import { toItemRecord } from "../item/item-record.js";
 import { orderObject, sha256Hex, stableStringify, } from "../shared/serialization.js";
-import { nowIso } from "../shared/time.js";
+import { isMillisecondPrecisionRfc3339DateTime, nowIso, } from "../shared/time.js";
 import { diagnoseAgentIdentity, resolveHistoryAgentIdentity, resolveHistoryAuthorSource, } from "../shared/author.js";
-import { removeHistoryEventIndexForHistoryPath, updateHistoryEventIndexAfterAppend, } from "./event-index.js";
+import { appendHistoryEntryWithEventIndex, removeHistoryEventIndexForHistoryPath, } from "./event-index.js";
+import { classifyHistoryEvent } from "./event-classification.js";
 import { invalidateHistoryDriftCacheForPath } from "./drift-cache.js";
+import { PmCliError } from "../shared/errors.js";
 const EMPTY_LEGACY_HASH_DOCUMENT = {
     front_matter: {},
     body: "",
@@ -24,6 +26,242 @@ const EMPTY_LEGACY_HASH_DOCUMENT = {
 export const CURRENT_HISTORY_ITEM_HASH_VERSION = 3;
 /** Hash epochs understood by this runtime. */
 export const SUPPORTED_HISTORY_ITEM_HASH_VERSIONS = [1, 2, 3];
+/** Record-integrity epoch written beside new immutable history events. */
+export const CURRENT_HISTORY_RECORD_HASH_VERSION = 1;
+/** Record-integrity epochs understood by this runtime. */
+export const SUPPORTED_HISTORY_RECORD_HASH_VERSIONS = [1];
+/** Canonicalize and hash every immutable record field except the hash value itself. */
+export function hashHistoryRecord(entry) {
+    return sha256Hex(stableStringify(entry));
+}
+/** Hash one patch representation without retaining its potentially sensitive values. */
+export function hashHistoryPatch(patch) {
+    return sha256Hex(stableStringify(patch));
+}
+/** Hash an ordered history prefix for compact checkpoint provenance. */
+export function hashHistoryStream(entries) {
+    return sha256Hex(stableStringify(entries));
+}
+/** Attach the current immutable-record integrity envelope to one history event. */
+export function sealHistoryRecord(entry) {
+    const sealed = {
+        ...entry,
+        record_hash_version: CURRENT_HISTORY_RECORD_HASH_VERSION,
+    };
+    const { record_hash: _recordHash, ...canonical } = sealed;
+    return { ...sealed, record_hash: hashHistoryRecord(canonical) };
+}
+/** Verify record-level attribution coverage while accepting explicit legacy item-state-only entries. */
+export function verifyHistoryRecordHash(entry) {
+    if (entry.record_hash_version === undefined &&
+        entry.record_hash === undefined) {
+        return { ok: true, coverage: "item_state_only" };
+    }
+    if (entry.record_hash_version === undefined ||
+        entry.record_hash === undefined) {
+        return { ok: false, error: "incomplete_record_hash_envelope" };
+    }
+    if (!SUPPORTED_HISTORY_RECORD_HASH_VERSIONS.includes(entry.record_hash_version)) {
+        return { ok: false, error: "unsupported_record_hash_version" };
+    }
+    const { record_hash: _recordHash, ...canonical } = entry;
+    return hashHistoryRecord(canonical) === entry.record_hash
+        ? { ok: true, coverage: "record_and_item_state" }
+        : { ok: false, error: "record_hash_mismatch" };
+}
+/** Build the retained coordinate and optional exact-record rewrite evidence. */
+function createHistoryRewriteEvidence(original, options) {
+    const evidence = {
+        before_hash: original.before_hash,
+        after_hash: original.after_hash,
+        patch_hash: hashHistoryPatch(original.patch),
+    };
+    if (original.item_hash_version !== undefined) {
+        evidence.item_hash_version = original.item_hash_version;
+    }
+    if (options.retainOriginalPatch) {
+        evidence.patch = structuredClone(original.patch);
+    }
+    if (options.retainPriorRecordHash !== false &&
+        original.record_hash_version !== undefined &&
+        original.record_hash !== undefined) {
+        evidence.record_hash_version = original.record_hash_version;
+        evidence.record_hash = original.record_hash;
+        evidence.record = structuredClone(original);
+    }
+    return evidence;
+}
+/** Reseal a maintenance rewrite and retain the anchors and patch digest it replaced. */
+export function resealHistoryRewrite(original, rewritten, options = {}) {
+    const originalRecordVerification = verifyHistoryRecordHash(original);
+    if (!originalRecordVerification.ok) {
+        throw new TypeError(originalRecordVerification.error);
+    }
+    const originalPatchHash = hashHistoryPatch(original.patch);
+    const retainsRewriteEvidence = options.retainPriorRecord === true ||
+        original.before_hash !== rewritten.before_hash ||
+        original.after_hash !== rewritten.after_hash ||
+        original.item_hash_version !== rewritten.item_hash_version ||
+        originalPatchHash !== hashHistoryPatch(rewritten.patch);
+    const sealed = sealHistoryRecord({
+        ...rewritten,
+        ...(retainsRewriteEvidence
+            ? {
+                reanchor_evidence: [
+                    ...(rewritten.reanchor_evidence ?? []),
+                    createHistoryRewriteEvidence(original, options),
+                ],
+            }
+            : {}),
+    });
+    const evidenceVerification = verifyHistoryRewriteEvidence(sealed);
+    if (!evidenceVerification.ok) {
+        throw new TypeError(evidenceVerification.error);
+    }
+    return sealed;
+}
+/** Return whether runtime data is a dense list of structurally valid patch operations. */
+function isHistoryPatch(value) {
+    if (!Array.isArray(value) || Object.keys(value).length !== value.length) {
+        return false;
+    }
+    return value.every((operation) => {
+        if (!isRecord(operation) || typeof operation.path !== "string") {
+            return false;
+        }
+        if (operation.op === "move" || operation.op === "copy") {
+            return typeof operation.from === "string";
+        }
+        if (["add", "replace", "test"].includes(operation.op)) {
+            return Object.hasOwn(operation, "value");
+        }
+        return operation.op === "remove";
+    });
+}
+/** Return whether a retained record has the minimum immutable event shape. */
+function isRetainedHistoryRecordShape(value) {
+    return (isRecord(value) &&
+        typeof value.ts === "string" &&
+        typeof value.author === "string" &&
+        typeof value.op === "string" &&
+        typeof value.before_hash === "string" &&
+        typeof value.after_hash === "string" &&
+        isHistoryPatch(value.patch));
+}
+/** Return whether optional retained record-hash fields form a complete pair. */
+function hasCompleteRetainedRecordHashEnvelope(evidence) {
+    const hasVersion = evidence.record_hash_version !== undefined;
+    const hasHash = evidence.record_hash !== undefined;
+    return hasVersion === hasHash;
+}
+/** Return whether runtime evidence has the bounded shape needed for verification. */
+function isHistoryReanchorEvidence(evidence) {
+    if (!isRecord(evidence) ||
+        !hasCompleteRetainedRecordHashEnvelope(evidence) ||
+        typeof evidence.before_hash !== "string" ||
+        typeof evidence.after_hash !== "string" ||
+        typeof evidence.patch_hash !== "string" ||
+        !/^[a-f0-9]{64}$/u.test(evidence.patch_hash) ||
+        (evidence.patch !== undefined && !isHistoryPatch(evidence.patch)) ||
+        (evidence.record_hash_version !== undefined &&
+            typeof evidence.record_hash_version !== "number") ||
+        (evidence.record_hash !== undefined &&
+            (typeof evidence.record_hash !== "string" ||
+                !/^[a-f0-9]{64}$/u.test(evidence.record_hash)))) {
+        return false;
+    }
+    return (evidence.record === undefined ||
+        isRetainedHistoryRecordShape(evidence.record));
+}
+/** Return whether a retained exact record agrees with its summary coordinates. */
+function matchesRetainedHistoryRecord(evidence) {
+    const record = evidence.record;
+    return (record !== undefined &&
+        record.before_hash === evidence.before_hash &&
+        record.after_hash === evidence.after_hash &&
+        record.item_hash_version === evidence.item_hash_version &&
+        record.record_hash_version === evidence.record_hash_version &&
+        record.record_hash === evidence.record_hash &&
+        hashHistoryPatch(record.patch) === evidence.patch_hash);
+}
+/** Reconstruct one prior record represented by retained rewrite evidence. */
+function reconstructPriorHistoryRecord(current, evidence, priorEvidence) {
+    if (evidence.patch &&
+        hashHistoryPatch(evidence.patch) !== evidence.patch_hash) {
+        return { kind: "patch_hash_mismatch" };
+    }
+    if (evidence.record) {
+        if (!matchesRetainedHistoryRecord(evidence)) {
+            return { kind: "record_hash_mismatch" };
+        }
+        return { kind: "record", entry: evidence.record };
+    }
+    const priorPatch = evidence.patch ?? current.patch;
+    if (hashHistoryPatch(priorPatch) !== evidence.patch_hash) {
+        return { kind: "digest_only" };
+    }
+    const priorRecord = {
+        ...current,
+        before_hash: evidence.before_hash,
+        after_hash: evidence.after_hash,
+        patch: priorPatch,
+        ...(evidence.item_hash_version === undefined
+            ? {}
+            : { item_hash_version: evidence.item_hash_version }),
+        ...(evidence.record_hash_version === undefined
+            ? {}
+            : { record_hash_version: evidence.record_hash_version }),
+        ...(evidence.record_hash === undefined
+            ? {}
+            : { record_hash: evidence.record_hash }),
+        ...(priorEvidence.length === 0 ? {} : { reanchor_evidence: priorEvidence }),
+    };
+    if (priorEvidence.length === 0)
+        delete priorRecord.reanchor_evidence;
+    if (evidence.item_hash_version === undefined) {
+        delete priorRecord.item_hash_version;
+    }
+    return evidence.record_hash_version === undefined ||
+        evidence.record_hash === undefined
+        ? { kind: "legacy", entry: priorRecord }
+        : { kind: "record", entry: priorRecord };
+}
+/** Verify that retained rewrite evidence reconstructs every available prior record envelope. */
+export function verifyHistoryRewriteEvidence(entry) {
+    const evidenceEntries = entry.reanchor_evidence;
+    if (evidenceEntries === undefined)
+        return { ok: true, coverage: "none" };
+    if (!Array.isArray(evidenceEntries)) {
+        return { ok: false, error: "rewrite_evidence_invalid" };
+    }
+    if (evidenceEntries.length === 0)
+        return { ok: true, coverage: "none" };
+    let reconstructed = entry;
+    for (let index = evidenceEntries.length - 1; index >= 0; index -= 1) {
+        const evidence = evidenceEntries[index];
+        if (!(index in evidenceEntries) || !isHistoryReanchorEvidence(evidence)) {
+            return { ok: false, error: "rewrite_evidence_invalid" };
+        }
+        const prior = reconstructPriorHistoryRecord(reconstructed, evidence, evidenceEntries.slice(0, index));
+        if (prior.kind === "patch_hash_mismatch") {
+            return { ok: false, error: "rewrite_evidence_patch_hash_mismatch" };
+        }
+        if (prior.kind === "record_hash_mismatch") {
+            return { ok: false, error: "rewrite_evidence_record_hash_mismatch" };
+        }
+        if (prior.kind === "digest_only") {
+            return { ok: true, coverage: "digest_only" };
+        }
+        if (prior.kind === "legacy") {
+            return { ok: true, coverage: "legacy_anchor_only" };
+        }
+        if (!verifyHistoryRecordHash(prior.entry).ok) {
+            return { ok: false, error: "rewrite_evidence_record_hash_mismatch" };
+        }
+        reconstructed = prior.entry;
+    }
+    return { ok: true, coverage: "complete" };
+}
 function compareOptionalStrings(left, right) {
     return (left ?? "").localeCompare(right ?? "");
 }
@@ -42,7 +280,8 @@ function compareLegacyLinkedTests(left, right) {
         compareOptionalStrings(left.command, right.command),
         compareOptionalNumbers(left.timeout_seconds, right.timeout_seconds),
         compareOptionalStrings(left.pm_context_mode, right.pm_context_mode),
-        Number(Boolean(left.shared_host_safe)) - Number(Boolean(right.shared_host_safe)),
+        Number(Boolean(left.shared_host_safe)) -
+            Number(Boolean(right.shared_host_safe)),
         compareJsonValues(left.env_clear, right.env_clear, []),
         compareJsonValues(left.env_set, right.env_set, {}),
         compareJsonValues(left.assert_stdout_contains, right.assert_stdout_contains, []),
@@ -75,31 +314,17 @@ function isDefinedPointerPath(document, path) {
     }
     let cursor = document;
     for (const segment of segments) {
-        if (Array.isArray(cursor)) {
-            if (segment === "-" || !/^(0|[1-9]\d*)$/.test(segment)) {
-                return false;
-            }
-            const index = Number(segment);
-            if (!Number.isInteger(index) || index < 0 || index >= cursor.length) {
-                return false;
-            }
-            const next = cursor[index];
-            if (next === undefined) {
-                return false;
-            }
-            cursor = next;
-            continue;
-        }
-        if (typeof cursor !== "object" || cursor === null) {
-            return false;
-        }
-        if (!Object.prototype.hasOwnProperty.call(cursor, segment)) {
-            return false;
-        }
-        const next = cursor[segment];
-        if (next === undefined) {
+        const arrayIndex = /^(0|[1-9]\d*)$/.test(segment) ? Number(segment) : -1;
+        const next = Array.isArray(cursor)
+            ? arrayIndex >= 0 && arrayIndex < cursor.length
+                ? cursor[arrayIndex]
+                : undefined
+            : isRecord(cursor) &&
+                Object.prototype.hasOwnProperty.call(cursor, segment)
+                ? cursor[segment]
+                : undefined;
+        if (next === undefined)
             return false;
-        }
         cursor = next;
     }
     return true;
@@ -222,13 +447,14 @@ export function createHistoryEntry(params) {
     const provenanceOutcomes = agentIdentity.harness
         ? Object.fromEntries(Object.entries(diagnoseAgentIdentity().provenance_outcomes).filter(([, outcome]) => outcome.resolver !== undefined && outcome.status !== "resolved"))
         : undefined;
-    const context = provenanceOutcomes === undefined || Object.keys(provenanceOutcomes).length === 0
+    const context = provenanceOutcomes === undefined ||
+        Object.keys(provenanceOutcomes).length === 0
         ? params.context
         : {
             ...params.context,
             agent_provenance_outcomes: provenanceOutcomes,
         };
-    return {
+    const entry = {
         ts: params.nowIso,
         author: params.author,
         author_source: params.authorSource ?? resolveHistoryAuthorSource(params.author),
@@ -243,9 +469,7 @@ export function createHistoryEntry(params) {
         ...(agentIdentity.provenance
             ? { agent_provenance: agentIdentity.provenance }
             : {}),
-        ...(agentIdentity.episode
-            ? { agent_episode: agentIdentity.episode }
-            : {}),
+        ...(agentIdentity.episode ? { agent_episode: agentIdentity.episode } : {}),
         op: params.op,
         patch,
         before_hash: sha256Hex(stableStringify(beforeHashCanonical)),
@@ -254,17 +478,37 @@ export function createHistoryEntry(params) {
         message: params.message === undefined ? undefined : params.message,
         ...(context === undefined ? {} : { context }),
     };
+    return sealHistoryRecord({
+        ...entry,
+        event_class: classifyHistoryEvent(entry),
+    });
 }
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function invalidHistoryTimestamp(message) {
+    return new PmCliError(message, EXIT_CODE.GENERIC_FAILURE, {
+        code: "history_timestamp_invalid",
+    });
+}
 function fallbackHistoryTimestamp(entry) {
     const ts = entry.ts.trim();
-    return ts.length > 0 ? ts : nowIso();
+    if (ts.length === 0)
+        return nowIso();
+    if (!isMillisecondPrecisionRfc3339DateTime(ts)) {
+        throw invalidHistoryTimestamp("History timestamp must be a valid RFC 3339 date-time with millisecond precision");
+    }
+    if (ts !== entry.ts) {
+        throw invalidHistoryTimestamp("History timestamp must not contain surrounding whitespace");
+    }
+    return entry.ts;
 }
 function withHistoryTimestamp(value, fallbackTs) {
     const ts = value.ts;
     if (typeof ts === "string" && ts.trim().length > 0) {
+        if (!isMillisecondPrecisionRfc3339DateTime(ts)) {
+            throw invalidHistoryTimestamp("History timestamp must be a valid RFC 3339 date-time with millisecond precision");
+        }
         return value;
     }
     return { ...value, ts: fallbackTs };
@@ -272,14 +516,16 @@ function withHistoryTimestamp(value, fallbackTs) {
 function serializeHistoryLine(value, fallbackEntry) {
     const fallbackTs = fallbackHistoryTimestamp(fallbackEntry);
     if (typeof value === "string") {
+        let parsed;
         try {
-            const parsed = JSON.parse(value);
-            if (isRecord(parsed)) {
-                return JSON.stringify(withHistoryTimestamp(parsed, fallbackTs));
-            }
+            parsed = JSON.parse(value);
         }
         catch {
             // Non-JSON extension lines are preserved for compatibility.
+            return value;
+        }
+        if (isRecord(parsed)) {
+            return JSON.stringify(withHistoryTimestamp(parsed, fallbackTs));
         }
         return value;
     }
@@ -288,45 +534,48 @@ function serializeHistoryLine(value, fallbackEntry) {
     }
     return JSON.stringify(value);
 }
+/** Apply one extension-provided append decision and report whether it consumed the write. */
+async function applyHistoryAppendOverride(historyPath, entry, result) {
+    if (result === false)
+        return true;
+    if (typeof result === "string") {
+        await appendLineAtomic(historyPath, serializeHistoryLine(result, entry));
+        await invalidateHistoryDriftCacheForPath(historyPath);
+        await removeHistoryEventIndexForHistoryPath(historyPath);
+        return true;
+    }
+    if (typeof result !== "object" || result === null)
+        return false;
+    const record = result;
+    if (record.skip === true)
+        return true;
+    const nextHistoryPath = typeof record.history_path === "string" ? record.history_path : historyPath;
+    await appendLineAtomic(nextHistoryPath, serializeHistoryLine(typeof record.line === "string" ? record.line : (record.entry ?? entry), entry));
+    await invalidateHistoryDriftCacheForPath(nextHistoryPath);
+    await removeHistoryEventIndexForHistoryPath(nextHistoryPath);
+    return true;
+}
 /** Implements append history entry for the public runtime surface of this module. */
 export async function appendHistoryEntry(historyPath, entry) {
     const override = await runActiveServiceOverride("history_append", {
         history_path: historyPath,
         entry,
     });
-    if (override.handled) {
-        if (override.result === false) {
-            return;
-        }
-        if (typeof override.result === "string") {
-            await appendLineAtomic(historyPath, serializeHistoryLine(override.result, entry));
-            await invalidateHistoryDriftCacheForPath(historyPath);
-            await removeHistoryEventIndexForHistoryPath(historyPath);
-            return;
-        }
-        if (typeof override.result === "object" && override.result !== null) {
-            const record = override.result;
-            if (record.skip === true) {
-                return;
-            }
-            const nextHistoryPath = typeof record.history_path === "string"
-                ? record.history_path
-                : historyPath;
-            if (typeof record.line === "string") {
-                await appendLineAtomic(nextHistoryPath, serializeHistoryLine(record.line, entry));
-                await invalidateHistoryDriftCacheForPath(nextHistoryPath);
-                await removeHistoryEventIndexForHistoryPath(nextHistoryPath);
-                return;
-            }
-            await appendLineAtomic(nextHistoryPath, serializeHistoryLine(record.entry ?? entry, entry));
-            await invalidateHistoryDriftCacheForPath(nextHistoryPath);
-            await removeHistoryEventIndexForHistoryPath(nextHistoryPath);
-            return;
-        }
+    if (override.handled &&
+        (await applyHistoryAppendOverride(historyPath, entry, override.result))) {
+        return;
     }
-    await appendLineAtomic(historyPath, serializeHistoryLine(entry, entry));
+    const timestampedEntry = entry.ts.trim().length > 0
+        ? entry
+        : { ...entry, ts: fallbackHistoryTimestamp(entry) };
+    const normalizedEntry = sealHistoryRecord({
+        ...timestampedEntry,
+        event_class: classifyHistoryEvent(timestampedEntry),
+    });
+    await appendHistoryEntryWithEventIndex(historyPath, normalizedEntry, async () => {
+        await appendLineAtomic(historyPath, serializeHistoryLine(normalizedEntry, normalizedEntry));
+    });
     await invalidateHistoryDriftCacheForPath(historyPath);
-    await updateHistoryEventIndexAfterAppend(historyPath, entry);
 }
 /** Public contract for test only, shared by SDK and presentation-layer consumers. */
 export const _testOnly = {
@@ -334,4 +583,4 @@ export const _testOnly = {
     isDefinedPointerPath,
 };
 //# sourceMappingURL=history.js.map
-//# debugId=60d6ec0e-a8ed-5a5d-b5bd-d29da8532a79
+//# debugId=bf6a9831-134c-5dc2-a3e2-74dca00cf22c