@attentionform/astra-mcp-server 0.4.1 → 0.5.0

package/dist/index.js

@@ -45,7 +45,7 @@ __export(index_exports, {
   takeDirFlag: () => takeDirFlag
 });
 module.exports = __toCommonJS(index_exports);
-var path21 = __toESM(require("path"));
+var path24 = __toESM(require("path"));
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_types2 = require("@modelcontextprotocol/sdk/types.js");
@@ -2003,8 +2003,8 @@ function sortChildrenBySchema(element, order) {
 }
 function generateValidParaId(seed, counter = 0) {
   if (seed !== void 0 && seed !== null && seed !== "") {
-    const hash = import_crypto2.default.createHash("sha256").update(`${seed}:${counter}`).digest();
-    const raw = hash.readUInt32BE(0) & 2147483647;
+    const hash2 = import_crypto2.default.createHash("sha256").update(`${seed}:${counter}`).digest();
+    const raw = hash2.readUInt32BE(0) & 2147483647;
     const val2 = raw === 0 ? 1 : raw;
     return val2.toString(16).toUpperCase().padStart(8, "0");
   }
@@ -2905,8 +2905,8 @@ function parserRandomUnit() {
   if (injectedParserRandom) return injectedParserRandom();
   if (resolveReproducibleMode(void 0)) {
     parserDeterministicSeq += 1;
-    const hash = (parserDeterministicSeq * 2654435761 >>> 0) / 4294967296;
-    return hash === 0 ? 0.5 : hash;
+    const hash2 = (parserDeterministicSeq * 2654435761 >>> 0) / 4294967296;
+    return hash2 === 0 ? 0.5 : hash2;
   }
   return Math.random();
 }
@@ -4530,9 +4530,9 @@ function ommlToMathmlDisplay(xml) {
 // ../engine/src/ooxml/validator-backend.ts
 var nativeBackend = {
   name: "native",
-  async validateFile(path22, opts) {
+  async validateFile(path25, opts) {
     const native = await import("@attentionform/ooxml-validator");
-    return native.validateFile(path22, opts ? { officeVersion: opts.officeVersion } : void 0);
+    return native.validateFile(path25, opts ? { officeVersion: opts.officeVersion } : void 0);
   },
   async validateBuffer(buf, opts) {
     const native = await import("@attentionform/ooxml-validator");
@@ -5494,10 +5494,10 @@ function mergeCorePropertiesXml(existingXml, patch, fallback) {
   return { xml: serializer2.serializeToString(doc), touched };
 }
 function ensureContentTypeOverride(adapter) {
-  const path22 = "[Content_Types].xml";
+  const path25 = "[Content_Types].xml";
   let raw = null;
   try {
-    raw = adapter.readTextOrNull(path22);
+    raw = adapter.readTextOrNull(path25);
   } catch {
     return;
   }
@@ -5514,13 +5514,13 @@ function ensureContentTypeOverride(adapter) {
   created.setAttribute("PartName", "/docProps/core.xml");
   created.setAttribute("ContentType", CORE_PROPERTIES_CONTENT_TYPE);
   root.appendChild(created);
-  adapter.writeText(path22, new import_xmldom7.XMLSerializer().serializeToString(doc));
+  adapter.writeText(path25, new import_xmldom7.XMLSerializer().serializeToString(doc));
 }
 function ensurePackageRel(adapter) {
-  const path22 = "_rels/.rels";
+  const path25 = "_rels/.rels";
   let raw = null;
   try {
-    raw = adapter.readTextOrNull(path22);
+    raw = adapter.readTextOrNull(path25);
   } catch {
     return;
   }
@@ -5553,7 +5553,7 @@ function ensurePackageRel(adapter) {
   created.setAttribute("Type", CORE_PROPERTIES_REL_TYPE);
   created.setAttribute("Target", CORE_PROPERTIES_PART);
   root.appendChild(created);
-  adapter.writeText(path22, new import_xmldom7.XMLSerializer().serializeToString(doc));
+  adapter.writeText(path25, new import_xmldom7.XMLSerializer().serializeToString(doc));
 }
 function writeCorePropertiesPart(adapter, xml) {
   adapter.writeText(CORE_PROPERTIES_PART, xml);
@@ -6082,6 +6082,9 @@ var RSIDS_EMPTY_RE = /<w:rsids>\s*<\/w:rsids>/g;
 var RSIDS_SELF_CLOSING_RE = /<w:rsids\s*\/>/g;
 var AUTHOR_ATTR_RE = /\s+(w|w15):author="[^"]*"/g;
 var INITIALS_ATTR_RE = /\s+w:initials="[^"]*"/g;
+var PRESENCE_INFO_TAG_RE = /<w15:presenceInfo\b(?:[^>"']|"[^"]*"|'[^']*')*>/g;
+var PRESENCE_PROVIDER_NONE_RE = /\sw15:providerId=(["'])None\1/;
+var PRESENCE_USERID_RE = /(\sw15:userId=)(?:"[^"]*"|'[^']*')/;
 var EMAIL_RE = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g;
 var PHONE_RE = /(\+\d[\d\s\-().]{6,}\d|\(\d{3}\)\s*\d{3}[\s\-.]\d{4}|\b\d{3}[\s\-.]\d{3}[\s\-.]\d{4}\b)/g;
 var CLAUSE_ACRONYM_RE = /\b(dfars|far|cfr|nist)\b/gi;
@@ -6853,6 +6856,15 @@ function sanitizeDocumentXml(xml, opts, partName = "word XML part", hooks) {
       o.replacementAuthor.split(/[\s._-]+/).filter(Boolean).map((s) => s[0]).join("").slice(0, 4).toUpperCase() || "A"
     );
     out = out.replace(INITIALS_ATTR_RE, ` w:initials="${initials}"`);
+    if (partName === "word/people.xml") {
+      out = out.replace(PRESENCE_INFO_TAG_RE, (tag) => {
+        if (!PRESENCE_PROVIDER_NONE_RE.test(tag)) return tag;
+        return tag.replace(PRESENCE_USERID_RE, (_m, open) => {
+          purgedAuthors += 1;
+          return `${open}"${replacement === "" ? "Anonymous" : replacement}"`;
+        });
+      });
+    }
   }
   let acceptedRevisions = 0;
   let unresolvedRevisions = [];
@@ -7404,20 +7416,20 @@ function sanitizeEmbeddedWorkbookBytes(buf, outerName) {
 }
 var XML_PART_RE = /^(word\/document\.xml|word\/styles\.xml|word\/stylesWithEffects\.xml|word\/numbering\.xml|word\/comments\.xml|word\/commentsExtended\.xml|word\/footnotes\.xml|word\/endnotes\.xml|word\/settings\.xml|word\/header.*\.xml|word\/footer.*\.xml|word\/people\.xml|word\/customXml\/.*\.xml|word\/charts\/.*\.xml|word\/embeddings\/.*\.xml)$/i;
 function bufferZipAdapter(files, touched) {
-  const write = (path22, content) => {
-    files.set(path22, content);
-    touched?.add(path22);
+  const write = (path25, content) => {
+    files.set(path25, content);
+    touched?.add(path25);
   };
   return {
-    hasFile: (path22) => files.has(path22),
-    readText: (path22) => {
-      const data = files.get(path22);
-      if (!data) throw new Error(`E_VALIDATION: Part ${path22} was not found.`);
+    hasFile: (path25) => files.has(path25),
+    readText: (path25) => {
+      const data = files.get(path25);
+      if (!data) throw new Error(`E_VALIDATION: Part ${path25} was not found.`);
       return data.toString("utf8");
     },
-    readTextOrNull: (path22) => files.get(path22)?.toString("utf8") ?? null,
-    writeText: (path22, content) => write(path22, Buffer.from(content, "utf8")),
-    writeBuffer: (path22, content) => write(path22, Buffer.from(content))
+    readTextOrNull: (path25) => files.get(path25)?.toString("utf8") ?? null,
+    writeText: (path25, content) => write(path25, Buffer.from(content, "utf8")),
+    writeBuffer: (path25, content) => write(path25, Buffer.from(content))
   };
 }
 function deleteRemovedComments(files, ids, touched) {
@@ -10402,7 +10414,7 @@ var DocxParser = class _DocxParser {
    * Captures a full package snapshot: a clone of every zip entry buffer.
    * Used by OperationEngine for transactional rollback of failed batches.
    */
-  capturePackageSnapshot() {
+  capturePackageSnapshot(options) {
     this.purgeRogueZipEntries();
     const snapshot3 = /* @__PURE__ */ new Map();
     for (const entry of this.zip.getEntries()) {
@@ -10413,7 +10425,7 @@ var DocxParser = class _DocxParser {
       snapshot3.set(entry.entryName, Buffer.from(entry.getData()));
     }
     try {
-      snapshot3.set("word/document.xml", Buffer.from(this.readDocumentXml(), "utf8"));
+      snapshot3.set("word/document.xml", Buffer.from(options?.documentXml ?? this.readDocumentXml(), "utf8"));
     } catch {
     }
     return snapshot3;
@@ -10480,9 +10492,10 @@ var DocxParser = class _DocxParser {
   /**
    * Restores the package to a previously captured snapshot: every entry is
    * restored (entries added after the snapshot are removed), then documentDom
-   * and stylesDom are reloaded and stable IDs re-assigned.
+   * and stylesDom are reloaded and stable IDs re-assigned. The restored package is exactly the snapshot;
+   * only a restore that mixes a pre-0.4.2 commit with live parts passes `registerCoreProperties`.
    */
-  restorePackageSnapshot(snapshot3) {
+  restorePackageSnapshot(snapshot3, options) {
     for (const entry of [...this.zip.getEntries()]) {
       if (!snapshot3.has(entry.entryName)) {
         this.zip.deleteFile(entry);
@@ -10501,8 +10514,15 @@ var DocxParser = class _DocxParser {
         continue;
       }
       const buffer = Buffer.from(data);
-      if (this.zip.getEntry(entryName)) {
-        this.zip.updateFile(entryName, buffer);
+      const liveEntry = this.zip.getEntry(entryName);
+      if (liveEntry) {
+        let unchanged = false;
+        try {
+          unchanged = !liveEntry.isDirectory && liveEntry.header.size === buffer.length && readPartData(liveEntry, entryName).equals(buffer);
+        } catch {
+          unchanged = false;
+        }
+        if (!unchanged) this.zip.updateFile(entryName, buffer);
       } else {
         this.zip.addFile(entryName, buffer);
       }
@@ -10527,7 +10547,7 @@ var DocxParser = class _DocxParser {
     } else {
       this.stylesDom = null;
     }
-    registerExistingCorePropertiesPart(this.getZipAdapter());
+    if (options?.registerCoreProperties) registerExistingCorePropertiesPart(this.getZipAdapter());
     this.invalidateMediaCache();
     this.assignStableIds();
     this._bumpNodePagesRevision();
@@ -11048,20 +11068,20 @@ var DocxParser = class _DocxParser {
   }
   getZipAdapter() {
     return {
-      hasFile: (path22) => !!this.zip.getEntry(this.sanitizePath(path22)),
-      readText: (path22) => {
-        const cleanPath = this.sanitizePath(path22);
+      hasFile: (path25) => !!this.zip.getEntry(this.sanitizePath(path25)),
+      readText: (path25) => {
+        const cleanPath = this.sanitizePath(path25);
         const entry = this.zip.getEntry(cleanPath);
         if (!entry) throw new Error(`File not found: ${cleanPath}`);
         return entry.getData().toString("utf8");
       },
-      readTextOrNull: (path22) => {
-        const cleanPath = this.sanitizePath(path22);
+      readTextOrNull: (path25) => {
+        const cleanPath = this.sanitizePath(path25);
         const entry = this.zip.getEntry(cleanPath);
         return entry ? entry.getData().toString("utf8") : null;
       },
-      writeText: (path22, content) => {
-        const cleanPath = this.sanitizePath(path22);
+      writeText: (path25, content) => {
+        const cleanPath = this.sanitizePath(path25);
         assertNoXxe(content, cleanPath);
         assertNoXxeAdjacent(content, cleanPath);
         if (this.zip.getEntry(cleanPath)) {
@@ -11070,8 +11090,8 @@ var DocxParser = class _DocxParser {
           this.zip.addFile(cleanPath, Buffer.from(content, "utf8"));
         }
       },
-      writeBuffer: (path22, content) => {
-        const cleanPath = this.sanitizePath(path22);
+      writeBuffer: (path25, content) => {
+        const cleanPath = this.sanitizePath(path25);
         assertNoXxe(content.toString("utf8"), cleanPath);
         assertNoXxeAdjacent(content.toString("utf8"), cleanPath);
         if (this.zip.getEntry(cleanPath)) {
@@ -12895,12 +12915,12 @@ ${validation.errors.join("\n")}`, "repair the part XML or re-save the document i
     if (!comments || /<w:comment[\s>]/.test(comments.getData().toString("utf8"))) return;
     const parts = ["comments", "commentsExtended", "commentsIds", "commentsExtensible"].map((n) => `${n}.xml`);
     for (const part of parts) if (this.zip.getEntry(`word/${part}`)) this.zip.deleteFile(`word/${part}`);
-    const edit = (path22, tag, attr, drop) => {
-      const entry = this.zip.getEntry(path22);
+    const edit = (path25, tag, attr, drop) => {
+      const entry = this.zip.getEntry(path25);
       if (!entry) return;
       const dom = this.parser.parseFromString(entry.getData().toString("utf8"), "text/xml");
       for (const el of Array.from(dom.getElementsByTagName(tag))) if (drop(el.getAttribute(attr) ?? "")) el.parentNode?.removeChild(el);
-      this.zip.updateFile(path22, Buffer.from(this.serializer.serializeToString(dom), "utf8"));
+      this.zip.updateFile(path25, Buffer.from(this.serializer.serializeToString(dom), "utf8"));
     };
     edit("word/_rels/document.xml.rels", "Relationship", "Target", (value) => parts.includes(value.replace(/^\/?(word\/)?/, "")));
     edit("[Content_Types].xml", "Override", "PartName", (value) => parts.map((p) => `/word/${p}`).includes(value));
@@ -13638,12 +13658,11 @@ ${validation.errors.join("\n")}`, "repair the part XML or re-save the document i
   }
 };
 
-// ../engine/src/git.ts
-var import_fs4 = __toESM(require("fs"));
-var import_promises2 = __toESM(require("fs/promises"));
-var import_path3 = __toESM(require("path"));
-var import_crypto4 = __toESM(require("crypto"));
-var import_isomorphic_git = __toESM(require("isomorphic-git"));
+// ../engine/src/original.ts
+var import_node_fs = __toESM(require("node:fs"));
+var import_promises2 = __toESM(require("node:fs/promises"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_crypto = require("node:crypto");
 
 // ../engine/src/sandbox/paths.ts
 var import_fs3 = __toESM(require("fs"));
@@ -13785,7 +13804,408 @@ function writeFileNoFollowSync(target, data, encoding = "utf8") {
   assertWriteTargetNoSymlink(import_path2.default.resolve(target));
 }
 
+// ../engine/src/original.ts
+var SNAPSHOT_NAME = "original.snapshot";
+var SNAPSHOT_MAGIC = Buffer.from("ASTRA-ORIGINAL\n");
+var MAX_SNAPSHOT_HEADER = 4096;
+function originalSha256(bytes) {
+  return (0, import_node_crypto.createHash)("sha256").update(bytes).digest("hex");
+}
+function coded(message, code = "E_IO") {
+  return Object.assign(new Error(message), { code });
+}
+function errno(e) {
+  return typeof e === "object" && e !== null && "code" in e ? String(e.code) : "";
+}
+function originalDir(docPath) {
+  return import_node_path.default.join(getRepoDir(docPath), ".git", "astra-original");
+}
+async function readSafe(file, maxBytes = resolveHistoryMaxSidecarBytes()) {
+  assertWriteTargetNoSymlink(file);
+  const h = await import_promises2.default.open(file, import_node_fs.default.constants.O_RDONLY | import_node_fs.default.constants.O_NOFOLLOW);
+  try {
+    const stat3 = await h.stat();
+    if (!stat3.isFile() || stat3.size > maxBytes) throw coded("Original recovery refused: expected a regular file within the size limit.");
+    return await h.readFile();
+  } finally {
+    await h.close();
+  }
+}
+async function exists(file) {
+  try {
+    await import_promises2.default.lstat(file);
+    return true;
+  } catch (e) {
+    if (errno(e) === "ENOENT") return false;
+    throw e;
+  }
+}
+async function syncDirectory(dir) {
+  if (process.platform === "win32") return false;
+  let h;
+  let synced = false;
+  try {
+    h = await import_promises2.default.open(dir, import_node_fs.default.constants.O_RDONLY);
+    await h.sync();
+    synced = true;
+  } catch {
+  }
+  try {
+    await h?.close();
+  } catch {
+    synced = false;
+  }
+  return synced;
+}
+async function cleanupTemp(file) {
+  try {
+    await import_promises2.default.unlink(file);
+  } catch (e) {
+    if (errno(e) !== "ENOENT") throw Object.assign(coded(`Temporary file cleanup failed: ${file}. ${e instanceof Error ? e.message : String(e)}`), { tempPath: file });
+  }
+}
+async function preparedTempParts(target, parts, mode = 384) {
+  assertWriteTargetNoSymlink(target);
+  const dir = import_node_path.default.dirname(target);
+  await import_promises2.default.mkdir(dir, { recursive: true, mode: 448 });
+  assertWriteTargetNoSymlink(target);
+  const tmp = import_node_path.default.join(dir, `.${import_node_path.default.basename(target).slice(0, 60)}.astra-tmp-${(0, import_node_crypto.randomUUID)()}`);
+  const h = await import_promises2.default.open(tmp, import_node_fs.default.constants.O_WRONLY | import_node_fs.default.constants.O_CREAT | import_node_fs.default.constants.O_EXCL | import_node_fs.default.constants.O_NOFOLLOW, mode);
+  let writeError;
+  try {
+    for (const part of parts) {
+      let offset = 0;
+      while (offset < part.length) {
+        const { bytesWritten } = await h.write(part, offset, part.length - offset, null);
+        if (bytesWritten === 0) throw coded("Original recovery refused: temporary file write made no progress.");
+        offset += bytesWritten;
+      }
+    }
+    await h.sync();
+  } catch (error) {
+    writeError = error;
+  }
+  let closeError;
+  try {
+    await h.close();
+  } catch (error) {
+    closeError = error;
+  }
+  if (writeError || closeError) {
+    const primary = writeError ?? closeError;
+    let message = primary instanceof Error ? primary.message : String(primary);
+    if (writeError && closeError) message += `; temporary file close also failed: ${closeError instanceof Error ? closeError.message : String(closeError)}`;
+    let cleanupFailed = false;
+    try {
+      await cleanupTemp(tmp);
+    } catch (cleanup) {
+      cleanupFailed = true;
+      message += `; ${cleanup instanceof Error ? cleanup.message : String(cleanup)}`;
+    }
+    throw Object.assign(coded(message, errno(primary) || "E_IO"), { ...cleanupFailed ? { tempPath: tmp } : {}, cause: primary });
+  }
+  try {
+    const expectedBytes = parts.reduce((total, part) => total + part.length, 0);
+    const expectedHash = (0, import_node_crypto.createHash)("sha256");
+    for (const part of parts) expectedHash.update(part);
+    const check = await import_promises2.default.open(tmp, import_node_fs.default.constants.O_RDONLY | import_node_fs.default.constants.O_NOFOLLOW);
+    try {
+      const stat3 = await check.stat();
+      if (!stat3.isFile() || stat3.size !== expectedBytes) throw coded("Original recovery refused: temporary file integrity check failed.");
+      const actualHash = (0, import_node_crypto.createHash)("sha256");
+      const chunk = Buffer.allocUnsafe(64 * 1024);
+      let position2 = 0;
+      while (position2 < expectedBytes) {
+        const { bytesRead } = await check.read(chunk, 0, Math.min(chunk.length, expectedBytes - position2), position2);
+        if (bytesRead === 0) throw coded("Original recovery refused: temporary file integrity check failed.");
+        actualHash.update(chunk.subarray(0, bytesRead));
+        position2 += bytesRead;
+      }
+      if (actualHash.digest("hex") !== expectedHash.digest("hex")) throw coded("Original recovery refused: temporary file integrity check failed.");
+    } finally {
+      await check.close();
+    }
+  } catch (e) {
+    try {
+      await cleanupTemp(tmp);
+    } catch (cleanup) {
+      throw coded(`${e instanceof Error ? e.message : String(e)}; ${cleanup instanceof Error ? cleanup.message : String(cleanup)}`);
+    }
+    throw e;
+  }
+  return tmp;
+}
+async function preparedTemp(target, data, mode = 384) {
+  return preparedTempParts(target, [data], mode);
+}
+async function writePartsExclusive(target, parts, mode = 384) {
+  const tmp = await preparedTempParts(target, parts, mode);
+  let failure;
+  try {
+    assertWriteTargetNoSymlink(target);
+    try {
+      await import_promises2.default.link(tmp, target);
+    } catch (e) {
+      if (errno(e) === "EEXIST") throw coded(`Destination exists: ${target}`, "E_CONFLICT");
+      if (["ENOTSUP", "EOPNOTSUPP", "EPERM", "EXDEV", "ENOSYS"].includes(errno(e))) {
+        throw coded("This location does not support safe exclusive publication; export to another directory.");
+      }
+      throw e;
+    }
+    await syncDirectory(import_node_path.default.dirname(target));
+  } catch (error) {
+    failure = error;
+  }
+  try {
+    await cleanupTemp(tmp);
+  } catch (cleanup) {
+    const detail = cleanup instanceof Error ? cleanup.message : String(cleanup);
+    if (failure) {
+      throw Object.assign(coded(`${failure instanceof Error ? failure.message : String(failure)}; ${detail}`, errno(failure) || "E_IO"), { tempPath: tmp });
+    }
+    throw Object.assign(coded(`Destination was published at ${target}, but ${detail}`), { tempPath: tmp, published: true });
+  }
+  if (failure) throw failure;
+}
+async function writeFileExclusive(target, data, mode = 384) {
+  return writePartsExclusive(target, [data], mode);
+}
+async function createVerifiedBackup(target, bytes) {
+  let ownsTarget = false;
+  try {
+    await writeFileExclusive(target, bytes);
+    ownsTarget = true;
+    assertWriteTargetNoSymlink(target);
+    const written = await import_promises2.default.readFile(target);
+    if (written.length !== bytes.length || originalSha256(written) !== originalSha256(bytes)) {
+      throw coded(`Restore backup verification failed: ${target}`, "E_IO");
+    }
+  } catch (error) {
+    if (error?.published === true) ownsTarget = true;
+    if (ownsTarget) {
+      try {
+        await import_promises2.default.unlink(target);
+      } catch (cleanupError) {
+        if (errno(cleanupError) !== "ENOENT") {
+          throw Object.assign(coded(`${error instanceof Error ? error.message : String(error)}; invalid backup could not be removed: ${target} (${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)})`, "E_IO"), { backupPath: target });
+        }
+      }
+    }
+    throw error;
+  }
+}
+function newRestoreBackupPath(target) {
+  return import_node_path.default.join(import_node_path.default.dirname(target), `.astra-restore-backup-${(0, import_node_crypto.randomUUID)()}`);
+}
+async function replaceFileAtomic(target, data, newFileMode = 384) {
+  let tmp;
+  let replaced = false;
+  let renameStarted = false;
+  try {
+    assertWriteTargetNoSymlink(target);
+    let mode = newFileMode;
+    try {
+      const st = await import_promises2.default.lstat(target);
+      if (!st.isFile()) throw coded("Atomic replace requires a regular target file.");
+      mode = st.mode & 511;
+      if ((mode & 146) === 0) throw coded("Atomic replace refused: target is read-only.");
+      await import_promises2.default.access(target, import_node_fs.default.constants.W_OK);
+    } catch (e) {
+      if (errno(e) !== "ENOENT") throw e;
+    }
+    tmp = await preparedTemp(target, data, mode);
+    assertWriteTargetNoSymlink(target);
+    renameStarted = true;
+    for (let attempt = 0; ; attempt++) {
+      try {
+        await import_promises2.default.rename(tmp, target);
+        replaced = true;
+        break;
+      } catch (e) {
+        if (process.platform !== "win32" || !["EBUSY", "EPERM", "EACCES"].includes(errno(e)) || attempt >= 3) throw e;
+        await new Promise((resolve10) => setTimeout(resolve10, 25 * (attempt + 1)));
+      }
+    }
+    const durable = await syncDirectory(import_node_path.default.dirname(target));
+    await cleanupTemp(tmp);
+    tmp = void 0;
+    return { outcome: "replaced", ...!durable ? { durabilityUnconfirmed: true } : {} };
+  } catch (e) {
+    let message = e instanceof Error ? e.message : String(e);
+    let outcome = replaced ? "replaced" : renameStarted ? "uncertain" : "not-replaced";
+    if (!replaced && renameStarted && tmp) {
+      try {
+        const tempStat = await import_promises2.default.lstat(tmp);
+        if (tempStat.isFile() && !tempStat.isSymbolicLink()) outcome = "not-replaced";
+      } catch (tempError) {
+        if (errno(tempError) === "ENOENT") {
+          try {
+            assertWriteTargetNoSymlink(target);
+            const targetStat = await import_promises2.default.lstat(target);
+            if (targetStat.isFile() && targetStat.size === data.length && (await import_promises2.default.readFile(target)).equals(data)) {
+              replaced = true;
+              outcome = "replaced";
+            }
+          } catch {
+          }
+        }
+      }
+    }
+    if (tmp) {
+      try {
+        await cleanupTemp(tmp);
+      } catch (cleanup) {
+        message += `; ${cleanup instanceof Error ? cleanup.message : String(cleanup)}`;
+      }
+    }
+    throw Object.assign(coded(message, errno(e) || "E_IO"), {
+      outcome
+    });
+  }
+}
+function encodeSnapshot(bytes, sourceName) {
+  const meta = { magic: "ASTRA-ORIGINAL", version: 1, sha256: originalSha256(bytes), bytes: bytes.length, capturedAt: (/* @__PURE__ */ new Date()).toISOString(), sourceName };
+  const json = Buffer.from(JSON.stringify(meta));
+  if (json.length > MAX_SNAPSHOT_HEADER) throw coded("Original snapshot metadata exceeds its format limit.", "E_LIMIT");
+  const prefix = Buffer.alloc(SNAPSHOT_MAGIC.length + 4);
+  SNAPSHOT_MAGIC.copy(prefix);
+  prefix.writeUInt32BE(json.length, SNAPSHOT_MAGIC.length);
+  return [prefix, json, bytes];
+}
+function decodeSnapshot(all) {
+  const offset = SNAPSHOT_MAGIC.length;
+  if (all.length < offset + 4 || !all.subarray(0, offset).equals(SNAPSHOT_MAGIC)) throw coded("Original snapshot has an invalid format header.", "E_VALIDATION");
+  const headerBytes = all.readUInt32BE(offset);
+  if (headerBytes < 2 || headerBytes > MAX_SNAPSHOT_HEADER || all.length < offset + 4 + headerBytes) throw coded("Original snapshot has an invalid metadata length.", "E_VALIDATION");
+  let meta;
+  try {
+    meta = JSON.parse(all.subarray(offset + 4, offset + 4 + headerBytes).toString("utf8"));
+  } catch {
+    throw coded("Original snapshot metadata is not valid JSON.", "E_VALIDATION");
+  }
+  const bytes = all.subarray(offset + 4 + headerBytes);
+  if (meta.magic !== "ASTRA-ORIGINAL" || meta.version !== 1 || !/^[a-f0-9]{64}$/.test(meta.sha256) || !Number.isSafeInteger(meta.bytes) || meta.bytes < 1 || meta.bytes !== bytes.length || typeof meta.capturedAt !== "string" || typeof meta.sourceName !== "string") {
+    throw coded("Original snapshot metadata is invalid.", "E_VALIDATION");
+  }
+  if (originalSha256(bytes) !== meta.sha256) throw coded("Original snapshot integrity verification failed.", "E_VALIDATION");
+  return { meta, bytes };
+}
+async function verifiedSnapshot(docPath) {
+  const file = import_node_path.default.join(originalDir(docPath), SNAPSHOT_NAME);
+  const raw = await readSafe(file);
+  return decodeSnapshot(raw);
+}
+async function getOriginalInfo(docPath) {
+  if (!import_node_path.default.isAbsolute(docPath)) return { available: false, reason: "not-applicable" };
+  const dir = originalDir(docPath);
+  try {
+    if (!await exists(dir)) return { available: false, reason: "predates-feature" };
+    const snapshot3 = import_node_path.default.join(dir, SNAPSHOT_NAME);
+    assertWriteTargetNoSymlink(snapshot3);
+    if (await exists(snapshot3)) {
+      const { meta } = await verifiedSnapshot(docPath);
+      return { available: true, sha256: meta.sha256, bytes: meta.bytes, capturedAt: meta.capturedAt };
+    }
+    try {
+      const status = JSON.parse((await readSafe(import_node_path.default.join(dir, "status.json"), 16 * 1024)).toString("utf8"));
+      if (["capture-failed", "too-large", "not-applicable"].includes(status.reason)) return { available: false, reason: status.reason, ...typeof status.detail === "string" ? { detail: status.detail.slice(0, 1024) } : {} };
+    } catch {
+    }
+    return { available: false, reason: "incomplete" };
+  } catch (e) {
+    return { available: false, reason: "corrupt", detail: e instanceof Error ? e.message : String(e) };
+  }
+}
+async function captureOriginal(docPath, bytes) {
+  const dir = originalDir(docPath);
+  let result;
+  try {
+    assertWriteTargetNoSymlink(import_node_path.default.join(dir, SNAPSHOT_NAME));
+    await import_promises2.default.mkdir(dir, { recursive: true, mode: 448 });
+    assertWriteTargetNoSymlink(import_node_path.default.join(dir, SNAPSHOT_NAME));
+    if (await exists(import_node_path.default.join(dir, SNAPSHOT_NAME))) {
+      const info = await getOriginalInfo(docPath);
+      if (info.available && bytes && originalSha256(bytes) !== info.sha256) return { available: false, reason: "capture-failed", detail: "An original is already recorded for this history." };
+      return info;
+    }
+    if (!bytes) result = { available: false, reason: "not-applicable" };
+    else if (!Buffer.isBuffer(bytes) || bytes.length === 0) result = { available: false, reason: "capture-failed", detail: "Original input is empty." };
+    else if (await getSidecarBytes(getRepoDir(docPath)) + bytes.length + 4096 + SNAPSHOT_MAGIC.length > resolveHistoryMaxSidecarBytes()) result = { available: false, reason: "too-large" };
+    else {
+      const digest = originalSha256(bytes);
+      const snapshot3 = import_node_path.default.join(dir, SNAPSHOT_NAME);
+      try {
+        await writePartsExclusive(snapshot3, encodeSnapshot(bytes, import_node_path.default.basename(docPath)));
+      } catch (e) {
+        if (e?.published === true) {
+          const published = await getOriginalInfo(docPath);
+          if (published.available && published.sha256 === digest) return published;
+          throw e;
+        }
+        if (errno(e) !== "E_CONFLICT") throw e;
+        const winner = await verifiedSnapshot(docPath);
+        if (!winner.bytes.equals(bytes)) return { available: false, reason: "capture-failed", detail: "An original is already recorded for this history." };
+      }
+      const info = await getOriginalInfo(docPath);
+      if (info.available && info.sha256 !== digest) return { available: false, reason: "capture-failed", detail: "An original is already recorded for this history." };
+      return info;
+    }
+  } catch (e) {
+    result = { available: false, reason: "capture-failed", detail: e instanceof Error ? e.message : String(e) };
+  }
+  try {
+    await writeFileExclusive(import_node_path.default.join(dir, "status.json"), Buffer.from(JSON.stringify(result)));
+  } catch {
+  }
+  return result;
+}
+async function readOriginal(docPath) {
+  const info = await getOriginalInfo(docPath);
+  if (!info.available) {
+    throw Object.assign(coded(`Original unavailable: ${info.reason}${info.detail ? ` (${info.detail})` : ""}`, "E_STATE"), {
+      remedy: "The retained original cannot be trusted, so no substitute is returned. Keep the working file and any separate backup, and check the history status for the reason."
+    });
+  }
+  return (await verifiedSnapshot(docPath)).bytes;
+}
+async function exportOriginal(docPath, outPath, opts) {
+  const bytes = await readOriginal(docPath);
+  const source = await import_promises2.default.realpath(docPath).catch((e) => {
+    if (errno(e) === "ENOENT") return import_node_path.default.resolve(docPath);
+    throw e;
+  });
+  const parent = import_node_path.default.dirname(import_node_path.default.resolve(outPath));
+  const destination = import_node_path.default.join(await import_promises2.default.realpath(parent).catch((e) => {
+    if (errno(e) === "ENOENT") return parent;
+    throw e;
+  }), import_node_path.default.basename(outPath));
+  const samePath = (a, b) => process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
+  let sameFile = samePath(source, destination);
+  try {
+    const [a, b] = await Promise.all([import_promises2.default.stat(source), import_promises2.default.stat(destination)]);
+    sameFile ||= a.ino !== 0 && b.ino !== 0 && a.dev === b.dev && a.ino === b.ino;
+  } catch (e) {
+    if (errno(e) !== "ENOENT") throw e;
+  }
+  if (sameFile) throw coded("Use restore_original_document to replace the working file.", "E_CONFLICT");
+  const repo = await import_promises2.default.realpath(getRepoDir(docPath));
+  const normalizedDest = process.platform === "win32" ? destination.toLowerCase() : destination;
+  const normalizedRepo = process.platform === "win32" ? repo.toLowerCase() : repo;
+  if (normalizedDest === normalizedRepo || normalizedDest.startsWith(`${normalizedRepo}${import_node_path.default.sep}`)) {
+    throw coded("Original export cannot write inside the document history store.", "E_CONFLICT");
+  }
+  if (opts?.overwrite) await replaceFileAtomic(outPath, bytes, 438);
+  else await writeFileExclusive(outPath, bytes, 438);
+  return getOriginalInfo(docPath);
+}
+
 // ../engine/src/git.ts
+var import_fs4 = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
+var import_promises3 = __toESM(require("fs/promises"));
+var import_path3 = __toESM(require("path"));
+var import_crypto4 = __toESM(require("crypto"));
+var import_isomorphic_git = __toESM(require("isomorphic-git"));
 var HISTORY_DIR_ENV = "ASTRA_HISTORY_DIR";
 function historyRoot() {
   const raw = process.env[HISTORY_DIR_ENV];
@@ -13818,7 +14238,55 @@ function getRepoDir(docPath) {
   if (root !== null) return import_path3.default.join(root, historyKey(import_path3.default.dirname(docPath)), import_path3.default.basename(docPath));
   return import_path3.default.join(import_path3.default.dirname(docPath), ".astra", import_path3.default.basename(docPath));
 }
+var SNAPSHOT_FORMAT_MARKER = ".astra-snapshot-format";
+var SNAPSHOT_FORMAT_VERSION = "2";
+function isCompleteSnapshotMarker(content) {
+  if (content === void 0) return false;
+  return Buffer.from(content).toString("utf8").trim() === SNAPSHOT_FORMAT_VERSION;
+}
+var ESCAPED_DIR = "__astra_escaped__";
+var ESCAPED_NAME_MAX = 255;
+function needsHistoryEscape(entryName) {
+  const name2 = entryName.replace(/\\/g, "/");
+  if (name2 === SNAPSHOT_FORMAT_MARKER || name2 === "document.xml") return true;
+  if (name2 === ESCAPED_DIR || name2.startsWith(`${ESCAPED_DIR}/`)) return true;
+  return name2.split("/").some((segment) => segment.toLowerCase().startsWith(".git"));
+}
+function isUnrecordableName(entryName) {
+  const name2 = entryName.replace(/\\/g, "/");
+  if (name2 === "" || name2.endsWith("/") || name2.startsWith("/") || /^[a-zA-Z]:/.test(name2)) return true;
+  return name2.split("/").some((segment) => segment === "" || segment === "." || segment === "..");
+}
 function isTrackedPackageFile(entryName) {
+  const name2 = entryName.replace(/\\/g, "/");
+  if (name2 === "word/document.xml") return false;
+  return !isUnrecordableName(name2);
+}
+function historyPathFor(entryName) {
+  const name2 = entryName.replace(/\\/g, "/");
+  if (!needsHistoryEscape(name2)) return name2;
+  const encoded = Buffer.from(name2, "utf8").toString("base64url");
+  if (encoded.length > ESCAPED_NAME_MAX) {
+    throw Object.assign(
+      new Error(`E_VALIDATION: the package entry name is too long to record in history (${name2.length} characters).`),
+      {
+        code: "E_VALIDATION",
+        remedy: "Rename or remove that package part (for example with sanitize_document), then save again."
+      }
+    );
+  }
+  return `${ESCAPED_DIR}/${encoded}`;
+}
+function entryNameFor(repoPath) {
+  const rel = repoPath.replace(/\\/g, "/");
+  if (!rel.startsWith(`${ESCAPED_DIR}/`)) return rel;
+  return Buffer.from(rel.slice(ESCAPED_DIR.length + 1), "base64url").toString("utf8");
+}
+function isRepoPartPath(repoPath) {
+  const rel = repoPath.replace(/\\/g, "/");
+  return rel !== "document.xml" && rel !== SNAPSHOT_FORMAT_MARKER && rel !== "" && !rel.startsWith(".git/");
+}
+function isLegacyTrackedPackageFile(entryName) {
   const name2 = entryName.replace(/\\/g, "/");
   if (name2 === "word/document.xml") return false;
   if (name2 === "word/styles.xml") return true;
@@ -13842,22 +14310,109 @@ function toRepoRelative(entryName) {
 }
 async function writeAndAdd(repoDir, relPath, content) {
   const safeRel = toRepoRelative(relPath);
-  if (safeRel.includes("..") || import_path3.default.isAbsolute(safeRel) || /^[a-zA-Z]:/.test(safeRel)) {
+  if (isTraversalName(safeRel)) {
     throw new Error(`Security Violation: refusing to track package path '${relPath}'`);
   }
   const fullPath = import_path3.default.join(repoDir, safeRel);
   const dirName = import_path3.default.dirname(fullPath);
   assertWriteTargetNoSymlink(fullPath);
-  await import_promises2.default.mkdir(dirName, { recursive: true, mode: 448 });
+  await import_promises3.default.mkdir(dirName, { recursive: true, mode: 448 });
   await secureDirChain0700(repoDir, dirName);
   assertWriteTargetNoSymlink(fullPath);
   await writeFileNoFollow(fullPath, content);
   await import_isomorphic_git.default.add({ fs: import_fs4.default, dir: repoDir, filepath: safeRel });
 }
+function isTraversalName(entryName) {
+  const name2 = toRepoRelative(entryName);
+  return name2.split("/").includes("..") || import_path3.default.isAbsolute(name2) || /^[a-zA-Z]:/.test(name2);
+}
+async function writeSnapshotParts(repoDir, extraFiles) {
+  const written = /* @__PURE__ */ new Set();
+  if (!extraFiles) return written;
+  for (const [name2, content] of Object.entries(extraFiles)) {
+    if (isTraversalName(name2)) {
+      await writeAndAdd(repoDir, name2, content);
+      continue;
+    }
+    if (!isTrackedPackageFile(name2)) continue;
+    const repoPath = historyPathFor(name2);
+    await writeAndAdd(repoDir, repoPath, content);
+    written.add(repoPath);
+  }
+  return written;
+}
+async function indexedPartPaths(repoDir) {
+  const tracked = await import_isomorphic_git.default.listFiles({ fs: import_fs4.default, dir: repoDir });
+  return new Set(tracked.map((t) => toRepoRelative(t)).filter(isRepoPartPath));
+}
+async function clearUncommittedPackageParts(repoDir) {
+  const repoRoot = import_path3.default.resolve(repoDir);
+  for (const rel of await indexedPartPaths(repoDir)) {
+    if (isTraversalName(rel)) {
+      throw Object.assign(new Error(`History repair refused an unsafe indexed path: ${rel}`), { code: "E_SANDBOX" });
+    }
+    const fullPath = import_path3.default.resolve(repoRoot, rel);
+    const relative3 = import_path3.default.relative(repoRoot, fullPath);
+    if (relative3 === "" || relative3 === ".." || relative3.startsWith(`..${import_path3.default.sep}`) || import_path3.default.isAbsolute(relative3)) {
+      throw Object.assign(new Error(`History repair refused an indexed path outside its repository: ${rel}`), { code: "E_SANDBOX" });
+    }
+    assertWriteTargetNoSymlink(fullPath);
+    try {
+      await import_promises3.default.unlink(fullPath);
+    } catch (error) {
+      if (error?.code !== "ENOENT") throw error;
+    }
+    await import_isomorphic_git.default.remove({ fs: import_fs4.default, dir: repoDir, filepath: rel });
+  }
+}
+async function isUnbornHistory(repoDir) {
+  let head;
+  try {
+    head = await import_promises3.default.readFile(import_path3.default.join(repoDir, ".git", "HEAD"), "utf8");
+  } catch {
+    return false;
+  }
+  if (!/^ref:\s*refs\/heads\/[^\s]+\s*$/.test(head)) return false;
+  const [branches, tags] = await Promise.all([
+    import_isomorphic_git.default.listBranches({ fs: import_fs4.default, dir: repoDir }),
+    import_isomorphic_git.default.listTags({ fs: import_fs4.default, dir: repoDir })
+  ]);
+  return branches.length === 0 && tags.length === 0;
+}
+async function snapshotIsProvenComplete(repoDir, extraFiles, written) {
+  if (!extraFiles) return false;
+  try {
+    const indexed = await indexedPartPaths(repoDir);
+    if (indexed.size !== written.size) return false;
+    for (const p of written) if (!indexed.has(p)) return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function applySnapshotMarker(repoDir, complete) {
+  if (complete) {
+    await writeAndAdd(repoDir, SNAPSHOT_FORMAT_MARKER, `${SNAPSHOT_FORMAT_VERSION}
+`);
+    return;
+  }
+  try {
+    await import_promises3.default.unlink(import_path3.default.join(repoDir, SNAPSHOT_FORMAT_MARKER));
+  } catch {
+  }
+  try {
+    await import_isomorphic_git.default.remove({ fs: import_fs4.default, dir: repoDir, filepath: SNAPSHOT_FORMAT_MARKER });
+  } catch {
+  }
+  const stillIndexed = (await import_isomorphic_git.default.listFiles({ fs: import_fs4.default, dir: repoDir })).some((t) => toRepoRelative(t) === SNAPSHOT_FORMAT_MARKER);
+  if (stillIndexed) {
+    throw new Error("History commit refused: could not clear the snapshot marker of an earlier commit.");
+  }
+}
 async function chmod0700BestEffort(dir) {
   if (process.platform === "win32") return;
   try {
-    await import_promises2.default.chmod(dir, 448);
+    await import_promises3.default.chmod(dir, 448);
   } catch {
   }
 }
@@ -13890,7 +14445,7 @@ async function migrateExistingTree0700(repoDir) {
       await chmod0700BestEffort(dir);
       let entries = [];
       try {
-        entries = await import_promises2.default.readdir(dir, { withFileTypes: true });
+        entries = await import_promises3.default.readdir(dir, { withFileTypes: true });
       } catch {
         continue;
       }
@@ -13940,7 +14495,7 @@ async function getSidecarBytes(repoDir) {
     const dir = stack.pop();
     let entries = [];
     try {
-      entries = await import_promises2.default.readdir(dir, { withFileTypes: true });
+      entries = await import_promises3.default.readdir(dir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -13953,7 +14508,7 @@ async function getSidecarBytes(repoDir) {
           continue;
         }
         if (typeof entry?.isFile === "function" && !entry.isFile()) continue;
-        const st = await import_promises2.default.stat(full);
+        const st = await import_promises3.default.stat(full);
         if (st.isDirectory()) stack.push(full);
         else if (st.isFile()) total += st.size;
       } catch {
@@ -13971,6 +14526,116 @@ async function getHistoryCommitCount(repoDir) {
     return 0;
   }
 }
+var GIT_INITIALIZATION_LOCK = ".astra-init.lock";
+function gitInitializationLockPath(repoDir) {
+  return import_path3.default.join(repoDir, GIT_INITIALIZATION_LOCK);
+}
+function gitInitializationIncompleteError(repoDir) {
+  return Object.assign(new Error(`History initialization is incomplete at ${repoDir}.`), {
+    code: "E_STATE",
+    remedy: "Stop other ASTra processes using this document, inspect the history directory, then run `astra history <file> --init` to record a baseline."
+  });
+}
+async function gitInitializationLockExists(repoDir) {
+  const file = gitInitializationLockPath(repoDir);
+  try {
+    const st = await import_promises3.default.lstat(file);
+    if (!st.isFile() || st.isSymbolicLink()) throw Object.assign(new Error(`Unsafe history initialization lock: ${file}`), { code: "E_SANDBOX" });
+    return true;
+  } catch (error) {
+    if (error?.code === "ENOENT") return false;
+    throw error;
+  }
+}
+async function describeInitializationLock(file) {
+  let record = {};
+  try {
+    const st = await import_promises3.default.lstat(file);
+    if (st.isFile() && !st.isSymbolicLink() && st.size <= 4096) record = JSON.parse(await import_promises3.default.readFile(file, "utf8"));
+  } catch {
+  }
+  const pid = typeof record.pid === "number" && Number.isInteger(record.pid) && record.pid > 0 ? record.pid : void 0;
+  const hostname = typeof record.hostname === "string" ? record.hostname.slice(0, 255) : void 0;
+  const started = typeof record.startedAt === "string" ? ` since ${record.startedAt.slice(0, 40)}` : "";
+  if (pid === void 0) return `the lock does not record its owner${started}; cannot tell whether an initializer is still running`;
+  if (hostname === void 0) return `owner pid ${pid}, host not recorded${started}; cannot tell whether it is still running`;
+  if (hostname !== import_os.default.hostname()) return `owner pid ${pid} on host ${hostname}${started}; this host is ${import_os.default.hostname()}, cannot tell whether it is still running`;
+  try {
+    process.kill(pid, 0);
+    return `owner pid ${pid} on this host${started}; that process is running`;
+  } catch (error) {
+    if (error?.code === "EPERM") return `owner pid ${pid} on this host${started}; that process is running`;
+    if (error?.code === "ESRCH") return `owner pid ${pid} on this host${started}; that process was not found (this alone does not prove the lock is stale)`;
+    return `owner pid ${pid} on this host${started}; cannot tell whether it is still running`;
+  }
+}
+async function gitInitializationConflictError(file) {
+  return Object.assign(new Error(`Another or interrupted ASTra history initialization is marked at ${file} (${await describeInitializationLock(file)}).`), {
+    code: "E_CONFLICT",
+    remedy: `Do not delete the lock while any ASTra process (an agent, a pipeline or a CLI run) may be using this document. Once you have made sure none is, delete ${file}; if the history then has no commits, run \`astra history <file> --init\`. ASTra never removes the lock itself.`
+  });
+}
+async function countCommitsStrict(repoDir) {
+  await assertUsableSidecarGit(repoDir);
+  try {
+    return (await import_isomorphic_git.default.log({ fs: import_fs4.default, dir: repoDir })).length;
+  } catch (error) {
+    if (await isUnbornHistory(repoDir)) return 0;
+    throw error;
+  }
+}
+async function assertGitHistoryReady(repoDir) {
+  await assertNoGitInitializationInProgress(repoDir);
+  if (await countCommitsStrict(repoDir) === 0) throw gitInitializationIncompleteError(repoDir);
+}
+async function assertNoGitInitializationInProgress(repoDir) {
+  if (await gitInitializationLockExists(repoDir)) throw await gitInitializationConflictError(gitInitializationLockPath(repoDir));
+}
+async function assertHistoryReadyForWrite(docPath) {
+  const repoDir = getRepoDir(docPath);
+  await assertNoGitInitializationInProgress(repoDir);
+  if (import_fs4.default.existsSync(import_path3.default.join(repoDir, ".git"))) await assertGitHistoryReady(repoDir);
+}
+async function withGitInitializationLock(repoDir, run) {
+  const file = gitInitializationLockPath(repoDir);
+  assertWriteTargetNoSymlink(file);
+  const token = import_crypto4.default.randomUUID();
+  let handle;
+  try {
+    handle = await import_promises3.default.open(file, import_fs4.default.constants.O_WRONLY | import_fs4.default.constants.O_CREAT | import_fs4.default.constants.O_EXCL | import_fs4.default.constants.O_NOFOLLOW, 384);
+  } catch (error) {
+    if (error?.code === "EEXIST") throw await gitInitializationConflictError(file);
+    throw error;
+  }
+  let primaryError;
+  let result;
+  try {
+    await handle.writeFile(JSON.stringify({ version: 2, pid: process.pid, hostname: import_os.default.hostname(), token, startedAt: (/* @__PURE__ */ new Date()).toISOString() }));
+    await handle.sync();
+    result = await run();
+  } catch (error) {
+    primaryError = error;
+  }
+  await handle.close().catch(() => void 0);
+  let cleanupError;
+  try {
+    const current = JSON.parse(await import_promises3.default.readFile(file, "utf8"));
+    if (current.token !== token) throw Object.assign(new Error(`History initialization lock ownership changed; left in place: ${file}`), { code: "E_CONFLICT" });
+    await import_promises3.default.unlink(file);
+  } catch (error) {
+    cleanupError = error;
+  }
+  if (cleanupError && cleanupError?.code !== "ENOENT") {
+    if (primaryError) {
+      const cause = primaryError instanceof Error ? primaryError.message : String(primaryError);
+      throw Object.assign(new Error(`${cause}; initialization lock cleanup failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`), { code: "E_IO", lockPath: file });
+    }
+    throw Object.assign(new Error(`History initialization lock cleanup failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`), { code: "E_IO", lockPath: file });
+  }
+  if (cleanupError && !primaryError) throw Object.assign(new Error(`History initialization finished, but its lock file disappeared while it ran: ${file}. Another process or a cleaner may have removed it, so exclusivity is not guaranteed for this run. Inspect the history with \`astra history <file>\` before relying on it.`), { code: "E_CONFLICT" });
+  if (primaryError) throw primaryError;
+  return result;
+}
 var SIDECAR_TOMBSTONE_FILENAME = ".astra-tombstones.json";
 var sidecarRegenWarnings = /* @__PURE__ */ new Map();
 function resolveDocIdentity(target) {
@@ -14090,7 +14755,7 @@ async function checkSidecarTombstone(target, repoDir) {
   const key = import_path3.default.resolve(repoDir);
   let hasGit = false;
   try {
-    hasGit = (await import_promises2.default.stat(import_path3.default.join(repoDir, ".git"))).isDirectory();
+    hasGit = (await import_promises3.default.stat(import_path3.default.join(repoDir, ".git"))).isDirectory();
   } catch {
     hasGit = false;
   }
@@ -14184,14 +14849,14 @@ async function assertUsableSidecarGit(repoDir) {
   const gitPath = import_path3.default.join(repoDir, ".git");
   let entry;
   try {
-    entry = await import_promises2.default.lstat(gitPath);
+    entry = await import_promises3.default.lstat(gitPath);
   } catch {
     return;
   }
   let usable = false;
   if (entry.isSymbolicLink()) {
     try {
-      usable = (await import_promises2.default.stat(gitPath)).isDirectory();
+      usable = (await import_promises3.default.stat(gitPath)).isDirectory();
     } catch {
       usable = false;
     }
@@ -14209,7 +14874,7 @@ async function assertUsableSidecarGit(repoDir) {
 async function ensureAstraGitRepo(target) {
   const repoDir = isRepoDirTarget(target) ? target : getRepoDir(target);
   await assertUsableSidecarGit(repoDir);
-  await import_promises2.default.mkdir(repoDir, { recursive: true, mode: 448 });
+  await import_promises3.default.mkdir(repoDir, { recursive: true, mode: 448 });
   if (process.platform !== "win32") {
     await chmod0700BestEffort(repoDir);
     const parent = import_path3.default.dirname(repoDir);
@@ -14225,20 +14890,44 @@ async function ensureAstraGitRepo(target) {
   }
   return repoDir;
 }
-async function initAstraRepo(docPath, initialXml, extraFiles) {
+async function initAstraRepo(docPath, initialXml, extraFiles, originalBytes) {
   const repoDir = await ensureAstraGitRepo(docPath);
-  await import_isomorphic_git.default.init({ fs: import_fs4.default, dir: repoDir });
-  await writeAndAdd(repoDir, "document.xml", initialXml);
-  if (extraFiles) {
-    for (const [name2, content] of Object.entries(extraFiles)) {
-      await writeAndAdd(repoDir, name2, content);
+  await withGitInitializationLock(repoDir, async () => {
+    await import_isomorphic_git.default.init({ fs: import_fs4.default, dir: repoDir });
+    let commits;
+    try {
+      commits = await import_isomorphic_git.default.log({ fs: import_fs4.default, dir: repoDir });
+    } catch (error) {
+      if (!await isUnbornHistory(repoDir)) throw error;
+      commits = [];
+    }
+    if (commits.length > 0) {
+      throw Object.assign(new Error(`History is already initialized at ${repoDir}.`), { code: "E_CONFLICT" });
+    }
+    await clearUncommittedPackageParts(repoDir);
+    if (originalBytes) {
+      const existing = await getOriginalInfo(import_path3.default.resolve(docPath));
+      if (existing.available && existing.sha256 !== originalSha256(originalBytes)) {
+        const snapshotPath = import_path3.default.join(repoDir, ".git", "astra-original", "original.snapshot");
+        throw Object.assign(new Error(
+          `History initialization refused: an interrupted earlier initialization left a retained original (sha256 ${existing.sha256}) that differs from this file (sha256 ${originalSha256(originalBytes)}), and no history was recorded.`
+        ), {
+          code: "E_CONFLICT",
+          reason: "original-mismatch",
+          remedy: `Nothing was changed. The retained original may be the only copy of the earlier document: keep ${snapshotPath} (copy or rename it, do not delete it; \`astra history <file> --export-original <out>\` can still write its bytes to a new file), then run \`astra history <file> --init\` again once it is out of the way.`
+        });
+      }
     }
-  }
-  await import_isomorphic_git.default.commit({
-    fs: import_fs4.default,
-    dir: repoDir,
-    author: { name: "ASTra", email: "astra@attentionform.com" },
-    message: "Initial state"
+    await captureOriginal(import_path3.default.resolve(docPath), originalBytes);
+    await writeAndAdd(repoDir, "document.xml", initialXml);
+    const writtenParts = await writeSnapshotParts(repoDir, extraFiles);
+    await applySnapshotMarker(repoDir, await snapshotIsProvenComplete(repoDir, extraFiles, writtenParts));
+    await import_isomorphic_git.default.commit({
+      fs: import_fs4.default,
+      dir: repoDir,
+      author: { name: "ASTra", email: "astra@attentionform.com" },
+      message: "Initial state"
+    });
   });
   try {
     await checkSidecarTombstone(docPath, repoDir);
@@ -14250,6 +14939,7 @@ async function commitChange(docPath, xmlContent, message, extraFiles, deletedFil
   const maxCommits = resolveHistoryMaxCommits(limits?.maxCommits);
   const maxSidecarBytes = resolveHistoryMaxSidecarBytes(limits?.maxSidecarBytes);
   const repoDir = await ensureAstraGitRepo(docPath);
+  await assertGitHistoryReady(repoDir);
   const existingCommits = await getHistoryCommitCount(repoDir);
   if (existingCommits + 1 > maxCommits) {
     throw Object.assign(
@@ -14289,41 +14979,35 @@ async function commitChange(docPath, xmlContent, message, extraFiles, deletedFil
   } catch (err) {
     if (err?.code === HISTORY_QUOTA_CODE) throw err;
   }
-  await writeAndAdd(repoDir, "document.xml", xmlContent);
   if (extraFiles) {
-    for (const [name2, content] of Object.entries(extraFiles)) {
-      await writeAndAdd(repoDir, name2, content);
-    }
+    for (const name2 of Object.keys(extraFiles)) if (!isTraversalName(name2) && isTrackedPackageFile(name2)) historyPathFor(name2);
   }
+  await writeAndAdd(repoDir, "document.xml", xmlContent);
+  const writtenParts = await writeSnapshotParts(repoDir, extraFiles);
   try {
     const toDelete = /* @__PURE__ */ new Set();
     if (deletedFiles) {
       for (const name2 of deletedFiles) {
-        const rel = toRepoRelative(name2);
-        if (rel === "document.xml") continue;
-        toDelete.add(rel);
+        if (!isTrackedPackageFile(name2) || isTraversalName(name2)) continue;
+        toDelete.add(historyPathFor(name2));
       }
     }
     if (extraFiles) {
-      const newTracked = new Set(
-        Object.keys(extraFiles).map((k) => toRepoRelative(k))
-      );
+      const newTracked = writtenParts;
       try {
         const tracked = await import_isomorphic_git.default.listFiles({ fs: import_fs4.default, dir: repoDir });
         for (const t of tracked) {
           const rel = toRepoRelative(t);
-          if (rel === "document.xml") continue;
-          if (isTrackedPackageFile(rel) && !newTracked.has(rel)) {
+          if (isRepoPartPath(rel) && !newTracked.has(rel)) {
             toDelete.add(rel);
           }
         }
       } catch {
       }
       try {
-        const onDisk = await collectRepoFiles(repoDir);
-        for (const rel of onDisk.keys()) {
-          if (rel === "document.xml") continue;
-          if (isTrackedPackageFile(rel) && !newTracked.has(rel)) {
+        const onDisk = await listRepoPaths(repoDir);
+        for (const rel of onDisk) {
+          if (isRepoPartPath(rel) && !newTracked.has(rel)) {
             toDelete.add(rel);
           }
         }
@@ -14331,10 +15015,10 @@ async function commitChange(docPath, xmlContent, message, extraFiles, deletedFil
       }
     }
     for (const rel of toDelete) {
-      if (rel.includes("..") || import_path3.default.isAbsolute(rel) || /^[a-zA-Z]:/.test(rel)) continue;
+      if (isTraversalName(rel)) continue;
       const fullPath = import_path3.default.join(repoDir, rel);
       try {
-        await import_promises2.default.unlink(fullPath);
+        await import_promises3.default.unlink(fullPath);
       } catch {
       }
       try {
@@ -14344,6 +15028,7 @@ async function commitChange(docPath, xmlContent, message, extraFiles, deletedFil
     }
   } catch {
   }
+  await applySnapshotMarker(repoDir, await snapshotIsProvenComplete(repoDir, extraFiles, writtenParts));
   const sha = await import_isomorphic_git.default.commit({
     fs: import_fs4.default,
     dir: repoDir,
@@ -14356,8 +15041,27 @@ async function commitChange(docPath, xmlContent, message, extraFiles, deletedFil
   }
   return sha;
 }
+async function getHistoryInitializationState(docPath) {
+  const repoDir = getRepoDir(docPath);
+  try {
+    if (await gitInitializationLockExists(repoDir)) {
+      return { state: "in-progress", detail: "Another ASTra process holds the history initialization lock (or it was interrupted)." };
+    }
+    if (!import_fs4.default.existsSync(import_path3.default.join(repoDir, ".git"))) return { state: "absent" };
+    await assertUsableSidecarGit(repoDir);
+    const commits = await import_isomorphic_git.default.log({ fs: import_fs4.default, dir: repoDir });
+    if (commits.length === 0) return { state: "incomplete", detail: "History initialization is incomplete: no commit was recorded." };
+    const root = commits[commits.length - 1];
+    const initial = await checkoutCommit(docPath, root.oid);
+    if (!initial.complete) return { state: "incomplete", detail: "The first history commit is not a complete package snapshot." };
+    return { state: "complete" };
+  } catch (error) {
+    return { state: "incomplete", detail: error instanceof Error ? error.message : String(error) };
+  }
+}
 async function getHistory(docPath) {
   const repoDir = getRepoDir(docPath);
+  await assertNoGitInitializationInProgress(repoDir);
   await assertUsableSidecarGit(repoDir);
   let commits;
   try {
@@ -14395,32 +15099,29 @@ async function getHistory(docPath) {
   });
   return entries;
 }
-async function collectRepoFiles(repoDir) {
-  const out = /* @__PURE__ */ new Map();
+async function listRepoPaths(repoDir) {
+  const out = [];
   async function walk(dir, relBase) {
     let entries = [];
     try {
-      entries = await import_promises2.default.readdir(dir, { withFileTypes: true });
+      entries = await import_promises3.default.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (entry.name === ".git") continue;
-      const full = import_path3.default.join(dir, entry.name);
       const rel = relBase ? `${relBase}/${entry.name}` : entry.name;
-      if (entry.isDirectory()) {
-        await walk(full, rel);
-      } else if (entry.isFile()) {
-        try {
-          out.set(rel, await import_promises2.default.readFile(full));
-        } catch {
-        }
-      }
+      if (entry.isDirectory()) await walk(import_path3.default.join(dir, entry.name), rel);
+      else if (entry.isFile()) out.push(rel);
     }
   }
   await walk(repoDir, "");
   return out;
 }
+function trackedPredicateFor(target) {
+  return target.complete ? isTrackedPackageFile : isLegacyTrackedPackageFile;
+}
+var INCOMPLETE_SNAPSHOT_WARNING = "This commit was recorded by an older ASTra version and predates complete snapshots: parts it never recorded (for example comment metadata, document properties, custom XML) keep their current content in the file, so the restore is not exact: those parts can be left without the content-type or relationship entries they had before. Restores to versions saved from now on are exact.";
 async function checkoutCommit(docPath, commitOid) {
   if (typeof commitOid !== "string" || commitOid.length === 0) {
     throw new Error(`Cannot checkout: commit ${commitOid} not found in history.`);
@@ -14484,8 +15185,18 @@ async function checkoutCommit(docPath, commitOid) {
     );
   }
   const xml = Buffer.from(docBlob.blob).toString("utf8");
+  let complete = false;
+  const markerOid = blobs.get(SNAPSHOT_FORMAT_MARKER);
+  if (markerOid) {
+    try {
+      const marker = await import_isomorphic_git.default.readBlob({ fs: import_fs4.default, dir: repoDir, oid: markerOid });
+      complete = isCompleteSnapshotMarker(marker.blob);
+    } catch {
+      complete = false;
+    }
+  }
   const trackedEntries = [...blobs.entries()].filter(
-    ([rel]) => rel !== "document.xml" && isTrackedPackageFile(rel)
+    ([rel]) => isRepoPartPath(rel) && (complete || isLegacyTrackedPackageFile(entryNameFor(rel)))
   );
   const extraBlobs = await Promise.all(
     trackedEntries.map(async ([rel, blobOid]) => {
@@ -14498,11 +15209,11 @@ async function checkoutCommit(docPath, commitOid) {
           `Checkout failed: cannot read blob '${rel}' (${blobOid}) at commit ${commitOid}: ${cause}`
         );
       }
-      return [rel, Buffer.from(blobResult.blob)];
+      return [entryNameFor(rel), Buffer.from(blobResult.blob)];
     })
   );
   const extra = new Map(extraBlobs);
-  return { xml, extra };
+  return { xml, extra, complete };
 }
 async function commitStateIfDiffersFromHead(docPath, xmlContent, message, extraFiles = {}, author) {
   try {
@@ -35075,7 +35786,7 @@ var ToonGenerator = class _ToonGenerator {
 // ../engine/src/tmp.ts
 var import_crypto5 = __toESM(require("crypto"));
 var import_fs7 = __toESM(require("fs"));
-var import_os = __toESM(require("os"));
+var import_os2 = __toESM(require("os"));
 var import_path6 = __toESM(require("path"));
 var ASTRA_TMPDIR_ENV = "ASTRA_TMPDIR";
 var TMP_SYMLINK_REMEDY = "Point $ASTRA_TMPDIR at a real directory (not a symlink), or unset it and retry.";
@@ -35131,7 +35842,7 @@ function resolveAstraTmpBase() {
     try {
       import_fs7.default.mkdirSync(dir, { recursive: true });
     } catch {
-      return import_os.default.tmpdir();
+      return import_os2.default.tmpdir();
     }
     refuseSymlinkBase(dir);
     refuseForeignOwner(dir);
@@ -35141,7 +35852,7 @@ function resolveAstraTmpBase() {
     }
     return dir;
   }
-  const fallback = import_os.default.tmpdir();
+  const fallback = import_os2.default.tmpdir();
   const injected = [process.env.TMPDIR, process.env.TEMP, process.env.TMP].filter((v) => typeof v === "string" && v.trim() !== "").map((v) => import_path6.default.resolve(v.trim()));
   if (injected.includes(import_path6.default.resolve(fallback))) {
     const dir = import_path6.default.resolve(fallback);
@@ -35181,12 +35892,12 @@ function logForensics(p, reason) {
   try {
     const rawName = import_path6.default.basename(p);
     const name2 = rawName !== "" ? rawName : "artifact";
-    let hash = "unknown";
+    let hash2 = "unknown";
     try {
-      hash = import_crypto5.default.createHash("sha256").update(p).digest("hex").slice(0, 16);
+      hash2 = import_crypto5.default.createHash("sha256").update(p).digest("hex").slice(0, 16);
     } catch {
     }
-    process.stderr.write(`[ASTra] tmp artifact kept for forensics: name="${name2}" sha256="${hash}" (${reason}). Base honors $ASTRA_TMPDIR; remove manually after inspection.
+    process.stderr.write(`[ASTra] tmp artifact kept for forensics: name="${name2}" sha256="${hash2}" (${reason}). Base honors $ASTRA_TMPDIR; remove manually after inspection.
 `);
   } catch {
   }
@@ -35250,12 +35961,12 @@ function logForensicPrune(target, reason) {
   try {
     const rawName = import_path6.default.basename(target);
     const name2 = rawName !== "" ? rawName : "artifact";
-    let hash = "unknown";
+    let hash2 = "unknown";
     try {
-      hash = import_crypto5.default.createHash("sha256").update(target).digest("hex").slice(0, 16);
+      hash2 = import_crypto5.default.createHash("sha256").update(target).digest("hex").slice(0, 16);
     } catch {
     }
-    process.stderr.write(`[ASTra] tmp forensics prune: name="${name2}" sha256="${hash}" (${reason}).
+    process.stderr.write(`[ASTra] tmp forensics prune: name="${name2}" sha256="${hash2}" (${reason}).
 `);
   } catch {
   }
@@ -37491,9 +38202,9 @@ function escapeHtml(str) {
 
 // ../engine/src/export/pdf.ts
 var import_child_process = require("child_process");
-var fs8 = __toESM(require("fs"));
-var fsp3 = __toESM(require("fs/promises"));
-var path7 = __toESM(require("path"));
+var fs9 = __toESM(require("fs"));
+var fsp4 = __toESM(require("fs/promises"));
+var path8 = __toESM(require("path"));
 var import_url = require("url");
 
 // ../engine/src/export/preflight.ts
@@ -37952,7 +38663,7 @@ var MAX_CONVERT_ATTEMPTS = 3;
 async function removeStagedDir(dir) {
   for (let attempt = 1; attempt <= 2; attempt++) {
     try {
-      await fsp3.rm(dir, { recursive: true, force: true });
+      await fsp4.rm(dir, { recursive: true, force: true });
       return;
     } catch {
       if (attempt < 2) {
@@ -37964,10 +38675,10 @@ async function removeStagedDir(dir) {
 }
 async function convertWithFilter(docxBuffer, outPdfPath, filterSpec, options, binary, stagedForensics) {
   const tmpDir = secureMkdtemp("astra-pdf-");
-  const tmpDocxPath = path7.join(tmpDir, `doc_${Date.now()}.docx`);
+  const tmpDocxPath = path8.join(tmpDir, `doc_${Date.now()}.docx`);
   let succeeded = false;
   try {
-    await fsp3.writeFile(tmpDocxPath, docxBuffer);
+    await fsp4.writeFile(tmpDocxPath, docxBuffer);
     secureFile(tmpDocxPath);
     let converted = false;
     let lastError = null;
@@ -37976,7 +38687,7 @@ async function convertWithFilter(docxBuffer, outPdfPath, filterSpec, options, bi
         await new Promise((resolve10, reject) => {
           const child = (0, import_child_process.spawn)(
             binary,
-            [`-env:UserInstallation=${(0, import_url.pathToFileURL)(path7.join(tmpDir, "lo_profile")).href}`, "--headless", "--convert-to", filterSpec, tmpDocxPath, "--outdir", tmpDir],
+            [`-env:UserInstallation=${(0, import_url.pathToFileURL)(path8.join(tmpDir, "lo_profile")).href}`, "--headless", "--convert-to", filterSpec, tmpDocxPath, "--outdir", tmpDir],
             { stdio: ["ignore", "pipe", "pipe"] }
           );
           let stderr = "";
@@ -38012,23 +38723,23 @@ async function convertWithFilter(docxBuffer, outPdfPath, filterSpec, options, bi
     if (!converted && lastError) {
       throw lastError;
     }
-    const expectedPdfName = path7.basename(tmpDocxPath).replace(/\.docx$/i, ".pdf");
-    const generatedPdfPath = path7.join(tmpDir, expectedPdfName);
-    if (!fs8.existsSync(generatedPdfPath)) {
+    const expectedPdfName = path8.basename(tmpDocxPath).replace(/\.docx$/i, ".pdf");
+    const generatedPdfPath = path8.join(tmpDir, expectedPdfName);
+    if (!fs9.existsSync(generatedPdfPath)) {
       throw new Error(`PDF conversion failed: output file ${generatedPdfPath} was not created`);
     }
-    const targetDir = path7.dirname(path7.resolve(outPdfPath));
-    assertWriteTargetNoSymlink(path7.resolve(outPdfPath));
-    await fsp3.mkdir(targetDir, { recursive: true });
-    assertWriteTargetNoSymlink(path7.resolve(outPdfPath));
-    await writeFileNoFollow(path7.resolve(outPdfPath), await fsp3.readFile(generatedPdfPath));
-    fs8.chmodSync(path7.resolve(outPdfPath), 420);
+    const targetDir = path8.dirname(path8.resolve(outPdfPath));
+    assertWriteTargetNoSymlink(path8.resolve(outPdfPath));
+    await fsp4.mkdir(targetDir, { recursive: true });
+    assertWriteTargetNoSymlink(path8.resolve(outPdfPath));
+    await writeFileNoFollow(path8.resolve(outPdfPath), await fsp4.readFile(generatedPdfPath));
+    fs9.chmodSync(path8.resolve(outPdfPath), 420);
     succeeded = true;
-    return path7.resolve(outPdfPath);
+    return path8.resolve(outPdfPath);
   } finally {
     if (succeeded) {
       try {
-        await fsp3.rm(tmpDir, { recursive: true, force: true });
+        await fsp4.rm(tmpDir, { recursive: true, force: true });
       } catch {
         keepForForensics(tmpDir, "could not remove tmp dir after success");
       }
@@ -38041,8 +38752,8 @@ async function convertWithFilter(docxBuffer, outPdfPath, filterSpec, options, bi
 }
 
 // ../engine/src/visual/backend.ts
-var fs9 = __toESM(require("fs"));
-var path8 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
+var path9 = __toESM(require("path"));
 var VISUAL_DEPENDENCY_REMEDY = "PDF render backend missing. Install LibreOffice and poppler-utils (pdftoppm): sudo apt install libreoffice poppler-utils, or brew install libreoffice poppler. Alternatively inspect the XML/DOM without images (telemetry-only mode).";
 function createDependencyError(missing) {
   const which = missing.length > 0 ? missing.join(", ") : "soffice, pdftoppm";
@@ -38057,9 +38768,9 @@ function findOnPath(name2, pathEnv) {
     const trimmed = name2.trim();
     if (trimmed.includes("/") || trimmed.includes("\\")) {
       try {
-        const abs = path8.resolve(trimmed);
-        fs9.accessSync(abs, fs9.constants.X_OK);
-        const stat3 = fs9.statSync(abs);
+        const abs = path9.resolve(trimmed);
+        fs10.accessSync(abs, fs10.constants.X_OK);
+        const stat3 = fs10.statSync(abs);
         if (stat3.isFile()) return abs;
         return null;
       } catch {
@@ -38068,12 +38779,12 @@ function findOnPath(name2, pathEnv) {
     }
     const pathValue = pathEnv !== void 0 ? pathEnv : process.env.PATH ?? "";
     if (!pathValue) return null;
-    const dirs = pathValue.split(path8.delimiter).filter((d) => d.length > 0);
+    const dirs = pathValue.split(path9.delimiter).filter((d) => d.length > 0);
     for (const dir of dirs) {
       try {
-        const candidate = path8.join(dir, trimmed);
-        fs9.accessSync(candidate, fs9.constants.X_OK);
-        const stat3 = fs9.statSync(candidate);
+        const candidate = path9.join(dir, trimmed);
+        fs10.accessSync(candidate, fs10.constants.X_OK);
+        const stat3 = fs10.statSync(candidate);
         if (stat3.isFile()) return candidate;
       } catch {
         continue;
@@ -38118,8 +38829,8 @@ function assertPdfBackend(override) {
 }
 
 // ../engine/src/visual/renderer.ts
-var fs10 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
 var import_url2 = require("url");
 var import_child_process2 = require("child_process");
 var import_util = require("util");
@@ -38130,13 +38841,13 @@ var VISUAL_DEFAULT_MAX_PAGES = 4;
 var VISUAL_MIN_DPI = 72;
 var VISUAL_MAX_DPI = 300;
 function getVisualArtifactsBaseDir() {
-  const dir = path9.join(resolveAstraTmpBase(), "ASTra", "visual");
+  const dir = path10.join(resolveAstraTmpBase(), "ASTra", "visual");
   try {
-    fs10.mkdirSync(dir, { recursive: true, mode: 448 });
+    fs11.mkdirSync(dir, { recursive: true, mode: 448 });
   } catch {
   }
   try {
-    secureDir(path9.join(resolveAstraTmpBase(), "ASTra"));
+    secureDir(path10.join(resolveAstraTmpBase(), "ASTra"));
   } catch {
   }
   secureDir(dir);
@@ -38146,9 +38857,9 @@ function getVisualArtifactsDir(subDir) {
   const base = getVisualArtifactsBaseDir();
   if (!subDir || subDir.trim() === "") return base;
   const safe = subDir.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").slice(0, 64) || "run";
-  const dir = path9.join(base, safe);
+  const dir = path10.join(base, safe);
   try {
-    fs10.mkdirSync(dir, { recursive: true, mode: 448 });
+    fs11.mkdirSync(dir, { recursive: true, mode: 448 });
   } catch {
   }
   secureDir(dir);
@@ -38182,7 +38893,7 @@ function parsePageNumber(fileName) {
 function listRenderedPages(workDir, prefixBase) {
   let entries = [];
   try {
-    entries = fs10.readdirSync(workDir);
+    entries = fs11.readdirSync(workDir);
   } catch {
     return [];
   }
@@ -38191,7 +38902,7 @@ function listRenderedPages(workDir, prefixBase) {
     if (!name2.startsWith(prefixBase)) continue;
     const page = parsePageNumber(name2);
     if (page === null) continue;
-    out.push({ page, file: path9.join(workDir, name2) });
+    out.push({ page, file: path10.join(workDir, name2) });
   }
   out.sort((a, b) => a.page - b.page);
   return out;
@@ -38205,7 +38916,7 @@ function sandboxError(message, remedy) {
 function canonicalVisualBaseDir() {
   const base = getVisualArtifactsBaseDir();
   try {
-    return fs10.realpathSync(base);
+    return fs11.realpathSync(base);
   } catch {
     return base;
   }
@@ -38229,7 +38940,7 @@ function resolveJailedVisualOutDir(rawOutDir) {
   if (trimmed.includes("\n") || trimmed.includes("\r")) {
     throw sandboxError("E_SANDBOX: visual outDir contains a forbidden line break.", "Remove line breaks from the path and retry.");
   }
-  const resolved = path9.resolve(trimmed);
+  const resolved = path10.resolve(trimmed);
   const canonical = canonicalizeForAsset(resolved);
   const canonicalBase = canonicalVisualBaseDir();
   assertVisualInsideBase(canonical, trimmed, canonicalBase);
@@ -38261,7 +38972,7 @@ async function renderDocxToImages(docxBuffer, opts = {}) {
     outDir = getVisualArtifactsDir(runId);
   }
   try {
-    fs10.mkdirSync(outDir, { recursive: true });
+    fs11.mkdirSync(outDir, { recursive: true });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     throw validationError(`E_VALIDATION: cannot create artifacts dir "${outDir}": ${msg}`, "Pass a writable outDir and retry.");
@@ -38272,16 +38983,16 @@ async function renderDocxToImages(docxBuffer, opts = {}) {
     outDir = live;
   }
   const workDir = secureMkdtemp("astra-visual-");
-  const inputDocx = path9.join(workDir, "input.docx");
+  const inputDocx = path10.join(workDir, "input.docx");
   let succeeded = false;
   try {
-    fs10.writeFileSync(inputDocx, docxBuffer);
+    fs11.writeFileSync(inputDocx, docxBuffer);
     secureFile(inputDocx);
     let lastErr;
     let converted = false;
     for (let attempt = 1; attempt <= 3; attempt++) {
       try {
-        await execFileAsync(sofficePath, [`-env:UserInstallation=${(0, import_url2.pathToFileURL)(path9.join(workDir, "lo_profile")).href}`, "--headless", "--convert-to", "pdf", "--outdir", workDir, inputDocx], {
+        await execFileAsync(sofficePath, [`-env:UserInstallation=${(0, import_url2.pathToFileURL)(path10.join(workDir, "lo_profile")).href}`, "--headless", "--convert-to", "pdf", "--outdir", workDir, inputDocx], {
           timeout: timeoutMs
         });
         converted = true;
@@ -38299,17 +39010,17 @@ async function renderDocxToImages(docxBuffer, opts = {}) {
     }
     let pdfPath = null;
     try {
-      const names = fs10.readdirSync(workDir).filter((n) => n.toLowerCase().endsWith(".pdf"));
+      const names = fs11.readdirSync(workDir).filter((n) => n.toLowerCase().endsWith(".pdf"));
       names.sort((a, b) => a === "input.pdf" ? -1 : b === "input.pdf" ? 1 : a.localeCompare(b));
-      if (names.length > 0) pdfPath = path9.join(workDir, names[0]);
+      if (names.length > 0) pdfPath = path10.join(workDir, names[0]);
     } catch {
       pdfPath = null;
     }
-    if (!pdfPath || !fs10.existsSync(pdfPath)) {
+    if (!pdfPath || !fs11.existsSync(pdfPath)) {
       throw validationError("E_VALIDATION: libreoffice produced no PDF output.", "Verify the .docx opens in Word/LibreOffice and retry.");
     }
     const prefixBase = "page";
-    const prefix = path9.join(workDir, prefixBase);
+    const prefix = path10.join(workDir, prefixBase);
     const ppmArgs = format === "png" ? ["-png", "-r", String(dpi), pdfPath, prefix] : ["-jpeg", "-jpegopt", `quality=${jpegQuality}`, "-r", String(dpi), pdfPath, prefix];
     try {
       await execFileAsync(pdftoppmPath, ppmArgs, { timeout: Math.min(timeoutMs, 6e4) });
@@ -38328,15 +39039,15 @@ async function renderDocxToImages(docxBuffer, opts = {}) {
     const ext = format === "png" ? "png" : "jpg";
     for (const entry of selected) {
       const destName = `page-${entry.page}.${ext}`;
-      const dest = path9.join(outDir, destName);
-      if (!isPathInsideDir(path9.resolve(dest), path9.resolve(outDir))) {
+      const dest = path10.join(outDir, destName);
+      if (!isPathInsideDir(path10.resolve(dest), path10.resolve(outDir))) {
         throw sandboxError(
           `E_SANDBOX: visual artifact destination escapes outDir: "${dest}".`,
           "Pass an outDir inside the visual artifacts dir (use getVisualArtifactsDir(subDir) for a run-scoped dir) and retry."
         );
       }
       try {
-        fs10.copyFileSync(entry.file, dest);
+        fs11.copyFileSync(entry.file, dest);
         secureFile(dest);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -38345,7 +39056,7 @@ async function renderDocxToImages(docxBuffer, opts = {}) {
       const canonicalDest = canonicalizeForAsset(dest);
       if (!isPathInsideDir(canonicalDest, canonicalizeForAsset(outDir))) {
         try {
-          fs10.unlinkSync(dest);
+          fs11.unlinkSync(dest);
         } catch {
         }
         throw sandboxError(
@@ -38355,7 +39066,7 @@ async function renderDocxToImages(docxBuffer, opts = {}) {
       }
       let bytes = 0;
       try {
-        bytes = fs10.statSync(dest).size;
+        bytes = fs11.statSync(dest).size;
       } catch {
         bytes = 0;
       }
@@ -40671,9 +41382,39 @@ function summarizeStyleGuide(guide) {
   return out;
 }
 
+// ../engine/src/restore-original.ts
+var import_node_fs2 = __toESM(require("node:fs"));
+var import_promises4 = __toESM(require("node:fs/promises"));
+var import_node_path2 = __toESM(require("node:path"));
+var import_isomorphic_git2 = __toESM(require("isomorphic-git"));
+async function captureHistoryState(docPath) {
+  const target = import_node_path2.default.resolve(docPath);
+  const [head, index] = await Promise.all([
+    getHistory(target).then((entries) => entries[0]?.oid, () => void 0),
+    import_isomorphic_git2.default.statusMatrix({ fs: import_node_fs2.default, dir: getRepoDir(target) }).then((matrix) => JSON.stringify(matrix), () => void 0)
+  ]);
+  return { head, index };
+}
+async function historyChangedSince(docPath, before) {
+  const after = await captureHistoryState(docPath);
+  if (before.head === void 0 || after.head === void 0 || before.index === void 0 || after.index === void 0) return true;
+  return after.head !== before.head || after.index !== before.index;
+}
+async function rollbackReplacedFile(docPath, previous, failure) {
+  const outcome = failure.error?.outcome;
+  if (!failure.replaced && outcome !== "replaced" && outcome !== "uncertain") return { recovered: true };
+  try {
+    await replaceFileAtomic(docPath, previous);
+    if (originalSha256(await import_promises4.default.readFile(docPath)) === originalSha256(previous)) return { recovered: true };
+    return { recovered: false, failure: "the file does not match the previous bytes after rollback" };
+  } catch (error) {
+    return { recovered: false, failure: error instanceof Error ? error.message : String(error) };
+  }
+}
+
 // src/lib/mcp/baseline-gate.ts
 var crypto13 = __toESM(require("crypto"));
-var fsp4 = __toESM(require("fs/promises"));
+var fsp6 = __toESM(require("fs/promises"));
 
 // src/lib/mcp/errors.ts
 function mcpError(code, message, remedy) {
@@ -40753,8 +41494,8 @@ function invalidInput(message) {
 }
 
 // src/lib/mcp/diff.ts
-var fs12 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
 var DISCARDED_NODE_IDS_MAX = 20;
 var AUDIT_NODE_IDS_MAX = 100;
 var AUDIT_FILES_MAX = 100;
@@ -41121,7 +41862,7 @@ function pathDirname(p) {
 }
 function sidecarRepoExists(docPath) {
   try {
-    return fs12.existsSync(path11.join(getRepoDir(docPath), ".git"));
+    return fs14.existsSync(path13.join(getRepoDir(docPath), ".git"));
   } catch {
     return false;
   }
@@ -41160,7 +41901,7 @@ async function resolveBaseline(handle) {
   if (handle.validationBaseline !== void 0) return handle.validationBaseline;
   if (!handle.openSha256) return null;
   try {
-    const bytes = await fsp4.readFile(handle.filePath);
+    const bytes = await fsp6.readFile(handle.filePath);
     if (sha256Hex(bytes) !== handle.openSha256) return null;
     const baseline = buildBaseline(await validateForBaseline(bytes));
     handle.validationBaseline = baseline;
@@ -41244,7 +41985,7 @@ function withToleratedNote(message, preExisting) {
 async function validateAtOpen(handle, timeoutMs) {
   let bytes;
   try {
-    bytes = await fsp4.readFile(handle.filePath);
+    bytes = await fsp6.readFile(handle.filePath);
   } catch (err) {
     return { status: "skipped", note: `the file could not be read for validation: ${err instanceof Error ? err.message : String(err)}` };
   }
@@ -41288,10 +42029,10 @@ async function validateAtOpen(handle, timeoutMs) {
 }
 
 // src/lib/session-store.ts
-var fs13 = __toESM(require("fs"));
-var fsp5 = __toESM(require("fs/promises"));
-var os2 = __toESM(require("os"));
-var path12 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
+var fsp7 = __toESM(require("fs/promises"));
+var os3 = __toESM(require("os"));
+var path14 = __toESM(require("path"));
 var import_crypto6 = require("crypto");
 var MCP_SESSION_MAX_DOCS = 10;
 var MCP_SESSION_MAX_BYTES = 200 * 1024 * 1024;
@@ -41489,19 +42230,19 @@ function getMcpAllowedRoots() {
   if (named.length > 0) return [...new Set(named)];
   const roots = [];
   try {
-    roots.push(path12.resolve(process.cwd(), "documents"));
+    roots.push(path14.resolve(process.cwd(), "documents"));
   } catch {
   }
   try {
-    roots.push(path12.resolve(os2.tmpdir()));
+    roots.push(path14.resolve(os3.tmpdir()));
   } catch {
   }
   try {
-    roots.push(path12.resolve(process.cwd(), "documents", "Drafts"));
+    roots.push(path14.resolve(process.cwd(), "documents", "Drafts"));
   } catch {
   }
   try {
-    roots.push(path12.resolve(os2.tmpdir(), "ASTra"));
+    roots.push(path14.resolve(os3.tmpdir(), "ASTra"));
   } catch {
   }
   return [...new Set(roots)];
@@ -41518,12 +42259,12 @@ function getExistingExtraRoots() {
   const raw = (process.env.ASTRA_EXTRA_DOC_ROOTS || "").trim();
   if (!raw) return [];
   const out = [];
-  for (const part of raw.split(path12.delimiter)) {
+  for (const part of raw.split(path14.delimiter)) {
     const p = part.trim();
     if (!p) continue;
     try {
-      const resolved = path12.resolve(p);
-      const stat3 = fs13.statSync(resolved);
+      const resolved = path14.resolve(p);
+      const stat3 = fs15.statSync(resolved);
       if (!stat3.isDirectory()) continue;
       out.push(resolved);
     } catch {
@@ -41535,7 +42276,7 @@ function findMcpContainingRoot(canonical) {
   for (const root of getMcpAllowedRoots()) {
     let canonicalRoot = root;
     try {
-      canonicalRoot = fs13.realpathSync(root);
+      canonicalRoot = fs15.realpathSync(root);
     } catch {
     }
     if (isPathInsideDir(canonical, canonicalRoot) || isPathInsideDir(canonical, root)) {
@@ -41545,8 +42286,8 @@ function findMcpContainingRoot(canonical) {
   return void 0;
 }
 function assertNoDotSegments(canonical, root) {
-  const rel = path12.relative(root, canonical);
-  const segs = rel.split(path12.sep).filter((s) => s && s !== "." && s !== "..");
+  const rel = path14.relative(root, canonical);
+  const segs = rel.split(path14.sep).filter((s) => s && s !== "." && s !== "..");
   for (const seg of segs) {
     if (seg.startsWith(".")) {
       throw Object.assign(new Error(`Document path traverses a hidden directory "${seg}"`), {
@@ -41555,7 +42296,7 @@ function assertNoDotSegments(canonical, root) {
       });
     }
   }
-  const base = path12.basename(canonical);
+  const base = path14.basename(canonical);
   if (base.startsWith(".")) {
     throw Object.assign(new Error("Document path must not use a hidden (dot-prefixed) file name"), {
       code: "E_SANDBOX",
@@ -41596,8 +42337,8 @@ function validateDocPath(rawPath) {
       remedy: `Use a path ${describeAllowedFolders()}.`
     });
   }
-  const resolved = path12.resolve(trimmed);
-  const resolvedSegments = resolved.split(path12.sep);
+  const resolved = path14.resolve(trimmed);
+  const resolvedSegments = resolved.split(path14.sep);
   if (resolvedSegments.includes("..")) {
     throw Object.assign(new Error("Document path resolves outside its directory"), {
       code: "E_SANDBOX",
@@ -41616,7 +42357,7 @@ function validateDocPath(rawPath) {
     );
   }
   assertNoDotSegments(canonical, containingRoot);
-  const ext = path12.extname(trimmed).toLowerCase();
+  const ext = path14.extname(trimmed).toLowerCase();
   if (ext !== ".docx") {
     throw Object.assign(new Error(`Document path must use a .docx extension (got "${ext || "(none)"}")`), {
       code: "E_VALIDATION",
@@ -41638,9 +42379,9 @@ function validateOpenBufferLabel(rawLabel) {
       remedy: "Pass a plain memory label such as memory.docx."
     });
   }
-  if (path12.isAbsolute(trimmed)) return validateDocPath(trimmed);
+  if (path14.isAbsolute(trimmed)) return validateDocPath(trimmed);
   if (trimmed.includes("\n") || trimmed.includes("\r")) return fallback;
-  const base = path12.basename(trimmed.replace(/\\/g, "/"));
+  const base = path14.basename(trimmed.replace(/\\/g, "/"));
   if (!base || base === "." || base === "..") return fallback;
   const clean = base.slice(0, 128);
   return clean.toLowerCase().endsWith(".docx") ? clean : fallback;
@@ -41654,29 +42395,141 @@ function collectTrackedExtrasForGit(parser2) {
     }
     return extras;
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(`[collectTrackedExtrasForGit] snapshot failed: ${msg}`);
-    return {};
+    throw snapshotCollectionError(err);
   }
 }
-async function ensureGitRepo(docPath, xml, extras) {
+function snapshotCollectionError(cause) {
+  const detail = cause instanceof Error ? cause.message : String(cause);
+  return Object.assign(new Error(`The document's package parts could not be collected for history (${detail}). Nothing was recorded.`), {
+    code: "E_STATE",
+    remedy: "Nothing was recorded in history. Retry; if it keeps failing, the document package may be damaged."
+  });
+}
+async function ensureGitRepo(docPath, xml, extras, originalBytes) {
+  return (await ensureGitRepoWith(docPath, () => ({ xml, extras }), originalBytes)).existed;
+}
+async function ensureGitRepoWith(docPath, baseline, originalBytes, options) {
   const repoDir = getRepoDir(docPath);
   let hasGit = false;
   try {
-    hasGit = fs13.existsSync(path12.join(repoDir, ".git"));
+    hasGit = fs15.existsSync(path14.join(repoDir, ".git"));
   } catch {
     hasGit = false;
   }
-  if (hasGit) return true;
-  await initAstraRepo(docPath, xml, extras);
-  return false;
+  if (hasGit) {
+    if (!options?.alreadyReady) await assertGitHistoryReady(repoDir);
+    return { existed: true };
+  }
+  try {
+    const initial = baseline();
+    await initAstraRepo(docPath, initial.xml, initial.extras, originalBytes);
+    return { existed: false, baseline: initial };
+  } catch (error) {
+    if (fs15.existsSync(path14.join(repoDir, ".git"))) {
+      await assertGitHistoryReady(repoDir);
+      return { existed: true };
+    }
+    throw error;
+  }
 }
-async function initGitForHandleBestEffort(handle) {
+function collectBaselineForGit(parser2) {
+  const xml = parser2.readDocumentXml();
   try {
-    if (!path12.isAbsolute(handle.filePath)) return;
-    const xml = handle.parser.readDocumentXml();
-    await ensureGitRepo(handle.filePath, xml, collectTrackedExtrasForGit(handle.parser));
-  } catch {
+    const snapshot3 = parser2.capturePackageSnapshot({ documentXml: xml });
+    const extras = {};
+    for (const [name2, buf] of snapshot3) if (isTrackedPackageFile(name2)) extras[name2] = buf;
+    return { xml, extras };
+  } catch (err) {
+    throw snapshotCollectionError(err);
+  }
+}
+var sha256Of = (bytes) => (0, import_crypto6.createHash)("sha256").update(bytes).digest("hex");
+async function resolveSessionOriginal(handle) {
+  const fallback = handle.originalInfo ?? { available: false, reason: "not-applicable" };
+  const pin = handle.originalPin;
+  if (!pin || !path14.isAbsolute(handle.filePath)) return fallback;
+  const current = await getOriginalInfo(handle.filePath);
+  if (pin.kind === "retained") {
+    if (!current.available) return current;
+    if (current.sha256 !== pin.sha256) {
+      return { available: false, reason: "capture-failed", detail: "The retained original no longer matches the one this session opened." };
+    }
+    return current;
+  }
+  if (current.available && current.sha256 !== pin.sha256) {
+    return { available: false, reason: "capture-failed", detail: "Another opener recorded a different original for this history." };
+  }
+  const initialization = await getHistoryInitializationState(handle.filePath);
+  if (initialization.state !== "complete") {
+    return { available: false, reason: "initializing", detail: initialization.detail ?? "History initialization has not completed. Check get_document_history again later." };
+  }
+  if (!current.available) return current;
+  handle.originalInfo = current;
+  handle.originalPin = { kind: "retained", sha256: current.sha256 };
+  handle.originalWarning = void 0;
+  return current;
+}
+var INITIALIZING_WARNING = "History initialization was not complete when this document opened (another ASTra process may be creating it). Editing is available. Exact-original recovery becomes available if that initialization finishes for this same file; check get_document_history.";
+async function initGitForHandleBestEffort(handle, originalBytes) {
+  try {
+    if (!path14.isAbsolute(handle.filePath)) return;
+    const repoDir = getRepoDir(handle.filePath);
+    let completeBeforeRead = false;
+    if (fs15.existsSync(path14.join(repoDir, ".git"))) {
+      try {
+        await assertGitHistoryReady(repoDir);
+        completeBeforeRead = true;
+      } catch {
+      }
+    }
+    const availabilityAtOpen = await getOriginalInfo(handle.filePath);
+    const ensured = await ensureGitRepoWith(handle.filePath, () => collectBaselineForGit(handle.parser), originalBytes, { alreadyReady: completeBeforeRead });
+    if (ensured.existed) {
+      const preExisting = completeBeforeRead && availabilityAtOpen.available;
+      const now = preExisting ? availabilityAtOpen : await getOriginalInfo(handle.filePath);
+      handle.originalInfo = now;
+      if (now.available) {
+        if (preExisting || originalBytes && sha256Of(originalBytes) === now.sha256) {
+          handle.originalPin = { kind: "retained", sha256: now.sha256 };
+        } else {
+          handle.originalInfo = { available: false, reason: "capture-failed", detail: "Another opener recorded a different original for this history." };
+        }
+      } else if (originalBytes && now.reason === "incomplete") {
+        handle.originalInfo = { available: false, reason: "initializing", detail: "The history was still being initialized when this session opened." };
+        handle.originalPin = { kind: "input", sha256: sha256Of(originalBytes) };
+        handle.originalWarning = INITIALIZING_WARNING;
+      }
+    } else {
+      handle.originalInfo = await getOriginalInfo(handle.filePath);
+      const recorded = ensured.baseline;
+      const history = await getHistory(handle.filePath);
+      const head = history[0] ? await checkoutCommit(handle.filePath, history[0].oid) : void 0;
+      const names = Object.keys(recorded.extras).sort();
+      const headNames = head ? [...head.extra.keys()].sort() : [];
+      const initialStateMatches = !!head?.complete && recorded.xml === head.xml && JSON.stringify(names) === JSON.stringify(headNames) && names.every((name2) => recorded.extras[name2].equals(head.extra.get(name2)));
+      if (!initialStateMatches && handle.originalInfo.available) {
+        handle.originalInfo = { available: false, reason: "capture-failed", detail: "Concurrent history initialization produced a different initial document state. Close and reopen after inspecting history." };
+      }
+      if (originalBytes && handle.originalInfo.available && handle.originalInfo.sha256 !== sha256Of(originalBytes)) {
+        handle.originalInfo = { available: false, reason: "capture-failed", detail: "Another opener recorded a different original for this history." };
+      }
+      if (handle.originalInfo.available) handle.originalPin = { kind: "retained", sha256: handle.originalInfo.sha256 };
+    }
+    if (!handle.originalInfo.available && !["predates-feature", "not-applicable"].includes(handle.originalInfo.reason)) {
+      handle.originalWarning = handle.originalInfo.reason === "initializing" ? INITIALIZING_WARNING : `Exact-original recovery is unavailable: ${handle.originalInfo.reason}. Keep a separate copy of the input file.`;
+    }
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    const mismatch = error?.reason === "original-mismatch";
+    const initialization = originalBytes && !mismatch && path14.isAbsolute(handle.filePath) ? await getHistoryInitializationState(handle.filePath) : void 0;
+    if (initialization && originalBytes && initialization.state !== "absent") {
+      handle.originalInfo = { available: false, reason: "initializing", detail: initialization.detail ?? detail };
+      handle.originalPin = { kind: "input", sha256: sha256Of(originalBytes) };
+      handle.originalWarning = INITIALIZING_WARNING;
+    } else {
+      handle.originalInfo = mismatch ? { available: false, reason: "capture-failed", detail } : { available: false, reason: "incomplete", detail };
+      handle.originalWarning = `History initialization or original-file capture did not complete. Editing is available, but exact-original recovery is not. ${detail} Keep a separate copy of the input file.`;
+    }
   }
 }
 var McpSessionStore = class {
@@ -41926,12 +42779,12 @@ var McpSessionStore = class {
    * Macro/active content refuses by default (E_VALIDATION naming the parts);
    * pass {allowMacros:true} to preserve or {stripMacros:true} to strip.
    */
-  async openDocument(filePath, sessionId, macroOpts) {
+  async openDocument(filePath, sessionId, macroOpts, captureInput = true) {
     const cleanPath = validateDocPath(filePath);
     const expiredEvicted = this.evictExpired();
     let buf;
     try {
-      buf = await fsp5.readFile(cleanPath);
+      buf = await fsp7.readFile(cleanPath);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       throw Object.assign(new Error(`open_document: cannot read "${cleanPath}": ${msg}`), {
@@ -41966,10 +42819,12 @@ var McpSessionStore = class {
       lastAccess: Date.now(),
       mutex: new SessionMutex(),
       redoStack: this.createRedoStack(),
-      pendingAudit: { ops: 0, nodeIds: [] }
+      pendingAudit: { ops: 0, nodeIds: [] },
+      lastWrittenSha256: (0, import_crypto6.createHash)("sha256").update(buf).digest("hex"),
+      macroPolicy: macroOpts
     };
     this.sessions.set(id, handle);
-    await initGitForHandleBestEffort(handle);
+    await initGitForHandleBestEffort(handle, captureInput ? buf : void 0);
     this.lastOpenEvicted = [...expiredEvicted, ...this.evictToFit(id)];
     const live = this.sessions.get(id);
     if (!live) {
@@ -42036,10 +42891,13 @@ var McpSessionStore = class {
       lastAccess: Date.now(),
       mutex: new SessionMutex(),
       redoStack: this.createRedoStack(),
-      pendingAudit: { ops: 0, nodeIds: [] }
+      pendingAudit: { ops: 0, nodeIds: [] },
+      lastWrittenSha256: (0, import_crypto6.createHash)("sha256").update(buf).digest("hex"),
+      macroPolicy: macroOpts
     };
     this.sessions.set(id, handle);
-    await initGitForHandleBestEffort(handle);
+    await initGitForHandleBestEffort(handle, buf);
+    if (!path14.isAbsolute(handle.filePath)) handle.originalInfo = { available: false, reason: "not-applicable" };
     this.lastOpenEvicted = [...expiredEvicted, ...this.evictToFit(id)];
     const live = this.sessions.get(id);
     if (!live) {
@@ -42214,6 +43072,8 @@ var LEAN6_TOOL_NAMES = [
 ];
 var GIT_HISTORY_TOOL_NAMES = [
   "get_document_history",
+  "export_original_document",
+  "restore_original_document",
   "preview_revert",
   "revert_document",
   "redo_document"
@@ -42261,8 +43121,10 @@ var LEAN6_DESCRIPTIONS = {
   )
 };
 var GIT_HISTORY_DESCRIPTIONS = {
+  export_original_document: "Export the exact original DOCX captured when this history was created. Requires sessionId and outPath; overwrite defaults to false. Verifies the retained SHA-256 and never serializes the original. Does not change the live session. Refuses overwriting the active document: use restore_original_document instead. Old histories and memory-only sessions may have no original. The original can contain content removed by later sanitization; history retains it until the history store is deleted.",
+  restore_original_document: "Replace the working file with the exact captured original, verified by SHA-256, and record a new history commit. Requires sessionId. Unsaved edits refuse unless discard:true explicitly discards them. Refuses an externally changed file or history that does not match the saved state. Close other programs editing this file before restoring; an external write racing the final replacement cannot be excluded. Reloads the session under its opening policy. Normal revert/redo restore document state, not necessarily the original ZIP bytes. The next normal save may normalize the file again. Use export_original_document for recovery to a different path.",
   get_document_history: withSharedDocs(
-    'List the saved git history for a session (newest first, read-only: never mutates, never flips dirty). Paginate with limit (1-100, default 20) and offset (default 0). Returns {ok:true,sessionId,documentPath,currentCommit,totalCommits,history:[{oid,message,author,timestamp,timestampMs,opCount,affectedNodeIds,resultingHeadOid}]} (timestampMs = ms-precision epoch millis; commit-time clock for tracked commits, git seconds for older ones; opCount is always present (0 for pre-tracking commits and heals-only saves: it folds operations, not normalizer rewrites); affectedNodeIds is always present ([] when untracked); resultingHeadOid always equals oid (append-only; refs never move). Example {"sessionId":"sess_abc","limit":10} -> history slice. Use the oids with revert_document (or preview_revert first) to restore an earlier saved state. '
+    'List the saved git history and original-file availability for a session (newest first, read-only: never mutates, never flips dirty). Paginate with limit (1-100, default 20) and offset (default 0). Returns {ok:true,sessionId,documentPath,currentCommit,totalCommits,history:[{oid,message,author,timestamp,timestampMs,opCount,affectedNodeIds,resultingHeadOid}]} (timestampMs = ms-precision epoch millis; commit-time clock for tracked commits, git seconds for older ones; opCount is always present (0 for pre-tracking commits and heals-only saves: it folds operations, not normalizer rewrites); affectedNodeIds is always present ([] when untracked); resultingHeadOid always equals oid (append-only; refs never move). Example {"sessionId":"sess_abc","limit":10} -> history slice. Use the oids with revert_document (or preview_revert first) to restore an earlier saved state. '
   ),
   preview_revert: withSharedDocs(
     `Read-only WOULD-restore preview for revert_document (never mutates: no revision bump, no disk write, no redo-stack change). Target one commit: {steps:N} walks back N saved commits from the head (1 = the previous saved commit, must be < totalCommits) OR {commitOid:"<40-hex>"} jumps to that commit (mutually exclusive). Returns {ok:true,sessionId,targetOid,targetMessage,targetAuthor,stepsBack,affectedFiles,changedValues,changedValuesTruncated,changedValuesPositional,dirty,dirtyHandling,currentHeadOid,totalCommits} where affectedFiles lists package paths that differ from the target (word/document.xml plus tracked extras). The preview also carries advisory changedValues [{nodeId,before,after}] (live current text -> target restore text, bounded: at most ${CHANGED_VALUES_MAX} entries, each side at most ${CHANGED_VALUE_TEXT_MAX} chars, truncated flag honest; changedValuesPositional:true means either side held orphan ids (no shared id across the boundary, common under duplicate native ids) so before/after pairing is positional, not identity; empty + changedValuesReason when the target range is not computable). Example {"sessionId":"sess_abc","steps":1} -> preview summary. Preview first when a revert would discard unsaved edits.`
@@ -42451,6 +43313,15 @@ var ImportDocumentSchema = import_zod4.z.object({
   // Read $...$ as inline math (off by default: prices and shell text can look like math).
   dollarMath: import_zod4.z.boolean().optional()
 }).strict();
+var ExportOriginalDocumentSchema = import_zod4.z.object({
+  sessionId: import_zod4.z.string().min(1).max(128),
+  outPath: import_zod4.z.string().min(1).max(1024),
+  overwrite: import_zod4.z.boolean().optional()
+}).strict();
+var RestoreOriginalDocumentSchema = import_zod4.z.object({
+  sessionId: import_zod4.z.string().min(1).max(128),
+  discard: import_zod4.z.boolean().optional()
+}).strict();
 
 // src/lib/mcp/handlers/open-inspect.ts
 function extractStylePalette2(parser2) {
@@ -42544,7 +43415,7 @@ async function handleOpenDocument(store, input) {
     const evicted = store.drainLastOpenEvicted();
     const pendingNormalizations = readPendingNormalizations(handle);
     const validation = await validateAtOpen(handle, parsed.data.validationTimeoutMs ?? openValidationTimeoutMs());
-    return { ok: true, sessionId: handle.sessionId, revision: handle.revision, summary, evicted, pendingNormalizations, validation };
+    return { ok: true, sessionId: handle.sessionId, revision: handle.revision, summary, evicted, pendingNormalizations, validation, original: handle.originalInfo, ...handle.originalWarning ? { originalWarning: handle.originalWarning } : {} };
   } catch (err) {
     return mcpErrorFrom(err, "E_IO", "Check the .docx path is readable and retry open_document.");
   }
@@ -42769,11 +43640,11 @@ async function handleInspectDocument(store, input) {
 }
 
 // src/lib/mcp/handlers/search-batch.ts
-var path14 = __toESM(require("path"));
+var path16 = __toESM(require("path"));
 
 // src/tools/compose-document.ts
-var fs14 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
+var fs16 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
 var import_zod5 = require("zod");
 var COMPOSE_MARKDOWN_MAX = 5e5;
 var COMPOSE_VALIDATION_ERRORS_MAX = 3;
@@ -42788,8 +43659,8 @@ function resolveMcpStyleGuide(ref, jail) {
   let anchor;
   if (jail?.allowedDir !== void 0) {
     anchor = jail.allowedDir;
-  } else if (jail?.sessionFilePath !== void 0 && path13.isAbsolute(jail.sessionFilePath)) {
-    anchor = canonicalizeForAsset(path13.resolve(path13.dirname(jail.sessionFilePath)));
+  } else if (jail?.sessionFilePath !== void 0 && path15.isAbsolute(jail.sessionFilePath)) {
+    anchor = canonicalizeForAsset(path15.resolve(path15.dirname(jail.sessionFilePath)));
   }
   if (anchor === void 0 && !hasGuideScheme(trimmed) && isFileGuideRef(trimmed)) {
     throw guideSandboxError(
@@ -42888,22 +43759,22 @@ function assertPathAllowed(allowedDir, roots) {
       remedy: `Use a folder ${describeAllowedFolders()}.`
     });
   }
-  const resolved = path13.resolve(trimmed);
+  const resolved = path15.resolve(trimmed);
   const canonical = canonicalizeForAsset(resolved);
   const inside = roots.some((root) => {
     let canonicalRoot = root;
     try {
-      canonicalRoot = fs14.realpathSync(root);
+      canonicalRoot = fs16.realpathSync(root);
     } catch {
     }
-    const normC = path13.normalize(canonical);
-    const normR = path13.normalize(canonicalRoot);
+    const normC = path15.normalize(canonical);
+    const normR = path15.normalize(canonicalRoot);
     if (process.platform === "win32") {
       const lc = normC.toLowerCase();
       const lr = normR.toLowerCase();
-      return lc === lr || lc.startsWith(lr + path13.sep.toLowerCase());
+      return lc === lr || lc.startsWith(lr + path15.sep.toLowerCase());
     }
-    return normC === normR || normC.startsWith(normR + path13.sep);
+    return normC === normR || normC.startsWith(normR + path15.sep);
   });
   if (!inside) {
     throw Object.assign(
@@ -43281,8 +44152,8 @@ async function handleExecuteBatch(store, input) {
         const explicit = parsed.data.allowedDir;
         if (explicit !== void 0) {
           batchAllowedDir = assertPathAllowed(explicit, getMcpAllowedRoots());
-        } else if (path14.isAbsolute(handle.filePath)) {
-          batchAllowedDir = canonicalizeForAsset(path14.resolve(path14.dirname(handle.filePath)));
+        } else if (path16.isAbsolute(handle.filePath)) {
+          batchAllowedDir = canonicalizeForAsset(path16.resolve(path16.dirname(handle.filePath)));
         } else {
           throw Object.assign(
             new Error(
@@ -43431,8 +44302,9 @@ async function handleExecuteBatch(store, input) {
 }
 
 // src/lib/mcp/handlers/save-close.ts
-var fsp6 = __toESM(require("fs/promises"));
-var path15 = __toESM(require("path"));
+var import_crypto7 = require("crypto");
+var fsp8 = __toESM(require("fs/promises"));
+var path17 = __toESM(require("path"));
 async function executeSaveDocument(store, input) {
   const parsed = SaveDocumentSchema.safeParse(input);
   if (!parsed.success) {
@@ -43478,18 +44350,18 @@ async function executeSaveDocument(store, input) {
         ),
         {
           code: "E_VALIDATION",
-          remedy: `name the output "${path15.basename(target)}" with a .docm extension, or add stripMacros: true to remove the macro parts`
+          remedy: `name the output "${path17.basename(target)}" with a .docm extension, or add stripMacros: true to remove the macro parts`
         }
       );
     }
     if (isStripped && macroParts.length === 0 && /\.(docm|dotm)$/i.test(target)) {
       throw Object.assign(
         new Error(
-          `E_VALIDATION: save_document: stripMacros removes the macro parts, so the result is a plain document and cannot be written to "${path15.basename(target)}", a macro-enabled name`
+          `E_VALIDATION: save_document: stripMacros removes the macro parts, so the result is a plain document and cannot be written to "${path17.basename(target)}", a macro-enabled name`
         ),
         {
           code: "E_VALIDATION",
-          remedy: `write the result to a .docx with outPath: "${path15.basename(target).replace(/\.docm$/i, ".docx")}", or use allowMacros: true to keep the macro parts in the .docm`
+          remedy: `write the result to a .docx with outPath: "${path17.basename(target).replace(/\.docm$/i, ".docx")}", or use allowMacros: true to keep the macro parts in the .docm`
         }
       );
     }
@@ -43530,19 +44402,22 @@ async function executeSaveDocument(store, input) {
     const saveGateNormalized = readParserNormalizations(handle.parser);
     const buf = handle.parser.rezip();
     const saveNormalized = mergeNormalized(saveGateNormalized, readParserNormalizations(handle.parser));
+    const savedXml = handle.parser.readDocumentXml();
+    const extras = collectTrackedExtrasForGit(handle.parser);
     const prevRevision = handle.revision;
     const prevSavedRevision = handle.savedRevision;
     const prevByteSize = handle.byteSize;
     const prevFilePath = handle.filePath;
     let prevBytes = null;
     try {
-      prevBytes = await fsp6.readFile(target);
+      prevBytes = await fsp8.readFile(target);
     } catch {
       prevBytes = null;
     }
+    await assertHistoryReadyForWrite(target);
     try {
       assertWriteTargetNoSymlink(target);
-      await fsp6.mkdir(pathDirname(target), { recursive: true });
+      await fsp8.mkdir(pathDirname(target), { recursive: true });
       assertWriteTargetNoSymlink(target);
       await writeFileNoFollow(target, buf);
     } catch (err) {
@@ -43553,7 +44428,7 @@ async function executeSaveDocument(store, input) {
         if (prevBytes !== null) {
           await writeFileNoFollow(target, prevBytes);
         } else {
-          await fsp6.unlink(target);
+          await fsp8.unlink(target);
         }
       } catch (restoreErr) {
         diskOk = false;
@@ -43565,8 +44440,6 @@ async function executeSaveDocument(store, input) {
         remedy
       });
     }
-    const savedXml = handle.parser.readDocumentXml();
-    const extras = collectTrackedExtrasForGit(handle.parser);
     const opsSinceSave = handle.revision - handle.savedRevision;
     const fallbackMessage = opsSinceSave <= 0 ? `save_document: rev ${handle.revision} (initial baseline)` : `save_document: rev ${handle.revision} (${opsSinceSave} ops since last save)`;
     const baseMessage = sanitizeCommitMessage(parsed.data.message, fallbackMessage);
@@ -43574,7 +44447,7 @@ async function executeSaveDocument(store, input) {
     const authorName = sanitizeCommitAuthor(parsed.data.author);
     let commitOid;
     try {
-      await ensureGitRepo(target, savedXml, extras);
+      await ensureGitRepo(target, savedXml, extras, prevBytes ?? void 0);
       commitOid = await commitChange(target, savedXml, commitMessage, extras, void 0, authorName);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -43583,7 +44456,7 @@ async function executeSaveDocument(store, input) {
         if (prevBytes !== null) {
           await writeFileNoFollow(target, prevBytes);
         } else {
-          await fsp6.unlink(target);
+          await fsp8.unlink(target);
         }
       } catch (restoreErr) {
         diskOk = false;
@@ -43604,6 +44477,15 @@ async function executeSaveDocument(store, input) {
     }
     try {
       handle.filePath = target;
+      if (prevFilePath !== target || !handle.originalInfo) {
+        handle.originalInfo = await getOriginalInfo(target);
+        handle.originalPin = handle.originalInfo.available ? { kind: "retained", sha256: handle.originalInfo.sha256 } : void 0;
+      }
+      if (prevFilePath !== target) handle.originalWarning = void 0;
+      if (!handle.originalInfo.available && !["predates-feature", "not-applicable"].includes(handle.originalInfo.reason)) {
+        handle.originalWarning = `Exact-original recovery is unavailable: ${handle.originalInfo.reason}. Keep a separate copy of the input file.`;
+      }
+      handle.lastWrittenSha256 = (0, import_crypto7.createHash)("sha256").update(buf).digest("hex");
       handle.byteSize = buf.length;
       const auditNodeIds = [...handle.pendingAudit.nodeIds];
       const auditOps = handle.pendingAudit.ops;
@@ -43641,6 +44523,7 @@ async function executeSaveDocument(store, input) {
       ok: true,
       sessionId: handle.sessionId,
       path: target,
+      ...handle.originalWarning ? { originalWarning: handle.originalWarning } : {},
       revision: handle.revision,
       commitOid,
       commitMessage,
@@ -43710,8 +44593,151 @@ async function handleCloseDocument(store, input) {
   }
 }
 
+// src/lib/mcp/handlers/original.ts
+var fsp9 = __toESM(require("fs/promises"));
+var path18 = __toESM(require("path"));
+var import_crypto8 = require("crypto");
+var hash = (buf) => (0, import_crypto8.createHash)("sha256").update(buf).digest("hex");
+function refuse2(code, message, remedy = "Inspect the file and its history before retrying. Export the original to a new path for recovery without changing this document.") {
+  throw Object.assign(new Error(message), { code, remedy });
+}
+async function requireAvailableOriginal(handle) {
+  const info = await resolveSessionOriginal(handle);
+  if (info.available) return;
+  const detail = info.detail ?? "Close and reopen after checking history.";
+  const remedy = info.reason === "initializing" ? "History initialization for this document has not finished. Call get_document_history again later; the original becomes available once it completes for this same file." : "The retained original cannot be trusted, so no substitute is returned. Keep the working file and any separate backup, and call get_document_history to see the reason.";
+  refuse2("E_CONFLICT", `Exact-original recovery is unavailable to this session (${info.reason}). ${detail}`, remedy);
+}
+async function handleExportOriginalDocument(store, input) {
+  const parsed = ExportOriginalDocumentSchema.safeParse(input);
+  if (!parsed.success) return invalidInput(`export_original_document: ${parsed.error.message}`);
+  try {
+    return await store.withSession(parsed.data.sessionId, async (handle) => {
+      if (!path18.isAbsolute(handle.filePath)) refuse2("E_VALIDATION", "This memory session has no retained original.");
+      await requireAvailableOriginal(handle);
+      const outPath = validateSaveTarget(parsed.data.outPath);
+      if (outPath === handle.filePath) refuse2("E_CONFLICT", "Use restore_original_document to replace the active document.");
+      const original = await exportOriginal(handle.filePath, outPath, { overwrite: parsed.data.overwrite === true });
+      return { ok: true, sessionId: handle.sessionId, path: outPath, original };
+    });
+  } catch (err) {
+    return mcpErrorFrom(err, "E_IO", "Choose a writable output path inside the allowed directory.");
+  }
+}
+async function confirmHistoryCurrent(handle, bytes) {
+  const history = await getHistory(handle.filePath);
+  if (!history[0]) refuse2("E_CONFLICT", "Cannot confirm history is current: there is no recorded head.");
+  const head = await checkoutCommit(handle.filePath, history[0].oid);
+  if (!head.complete) refuse2("E_CONFLICT", "Cannot confirm history is current: the head is not a complete package snapshot. Save the document first.");
+  const parser2 = new DocxParser(bytes, handle.macroPolicy);
+  await parser2.getAST();
+  const snapshot3 = parser2.capturePackageSnapshot();
+  if (parser2.readDocumentXml() !== head.xml) refuse2("E_CONFLICT", "History differs from the current file. Save or revert before restoring the original.");
+  const names = [...snapshot3.keys()].filter(isTrackedPackageFile).sort();
+  const recorded = [...head.extra.keys()].sort();
+  if (JSON.stringify(names) !== JSON.stringify(recorded) || names.some((name2) => !snapshot3.get(name2).equals(head.extra.get(name2)))) {
+    refuse2("E_CONFLICT", "History is behind the file or the file was modified outside ASTra. Save or revert before restoring the original.");
+  }
+  return { oid: history[0].oid, parser: parser2 };
+}
+async function handleRestoreOriginalDocument(store, input) {
+  const parsed = RestoreOriginalDocumentSchema.safeParse(input);
+  if (!parsed.success) return invalidInput(`restore_original_document: ${parsed.error.message}`);
+  try {
+    return await store.withSession(parsed.data.sessionId, async (handle) => {
+      if (!path18.isAbsolute(handle.filePath)) refuse2("E_VALIDATION", "This memory session has no retained original.");
+      await requireAvailableOriginal(handle);
+      if (handle.revision !== handle.savedRevision && !parsed.data.discard) refuse2("E_CONFLICT", "The session has unsaved edits. Save first, or explicitly pass discard:true.");
+      const source = validateSaveTarget(handle.filePath);
+      await assertHistoryReadyForWrite(source);
+      const original = await getOriginalInfo(source);
+      if (!original.available) refuse2("E_NOT_FOUND", `The original is unavailable: ${original.reason}.`);
+      const bytes = await readOriginal(source);
+      const previous = await fsp9.readFile(source);
+      if (!handle.lastWrittenSha256 || hash(previous) !== handle.lastWrittenSha256) refuse2("E_CONFLICT", "The file changed outside ASTra. Reopen it before restoring.");
+      const checked = await confirmHistoryCurrent(handle, previous);
+      const parser2 = new DocxParser(bytes, handle.macroPolicy);
+      const ast = await parser2.getAST();
+      const engine = new OperationEngine(ast, parser2);
+      if (handle.styleGuide) engine.setStyleGuide(handle.styleGuide);
+      const validation = await validateForBaseline(bytes);
+      const backup = newRestoreBackupPath(source);
+      await createVerifiedBackup(backup, previous);
+      const historyBefore = await captureHistoryState(source);
+      const oldRedo = Array.from(handle.redoStack);
+      const previousSession = {
+        parser: handle.parser,
+        ast: handle.ast,
+        engine: handle.engine,
+        toon: handle.toon,
+        revision: handle.revision,
+        savedRevision: handle.savedRevision,
+        byteSize: handle.byteSize,
+        lastWrittenSha256: handle.lastWrittenSha256,
+        validationBaseline: handle.validationBaseline,
+        pendingAudit: { ops: handle.pendingAudit.ops, nodeIds: [...handle.pendingAudit.nodeIds] }
+      };
+      let replaced = false;
+      let commitAttempted = false;
+      let commitOid;
+      let durabilityUnconfirmed = false;
+      try {
+        handle.redoStack.length = 0;
+        try {
+          handle.redoStack.push((parsed.data.discard ? checked.parser : handle.parser).capturePackageSnapshot());
+        } catch (quota) {
+          if (quota?.code !== "E_QUOTA") throw quota;
+        }
+        if (hash(await fsp9.readFile(source)) !== hash(previous)) refuse2("E_CONFLICT", "The file changed while restore was being prepared.");
+        const write = await replaceFileAtomic(source, bytes);
+        replaced = true;
+        durabilityUnconfirmed = write.durabilityUnconfirmed === true;
+        commitAttempted = true;
+        commitOid = await commitChange(source, parser2.readDocumentXml(), `Restore original file (sha256 ${hash(bytes)})`, collectTrackedExtrasForGit(parser2));
+        handle.parser = parser2;
+        handle.ast = ast;
+        handle.engine = engine;
+        handle.toon = new ToonGenerator();
+        handle.byteSize = bytes.length;
+        store.bumpRevision(handle);
+        store.markSaved(handle);
+        handle.lastWrittenSha256 = hash(bytes);
+        adoptBaseline(handle, validation);
+      } catch (err) {
+        Object.assign(handle, previousSession);
+        handle.redoStack.length = 0;
+        Array.prototype.push.apply(handle.redoStack, oldRedo);
+        const { recovered: diskRecovered, failure: rollbackFailure } = await rollbackReplacedFile(source, previous, { replaced, error: err });
+        const rollbackError = rollbackFailure ?? "";
+        const historyChanged = commitAttempted && await historyChangedSince(source, historyBefore);
+        if (diskRecovered) await fsp9.unlink(backup).catch(() => void 0);
+        const detail = `${String(err instanceof Error ? err.message : err)}${historyChanged ? " History may have changed despite the failed commit; inspect history before continuing." : ""}${diskRecovered ? "" : ` Rollback failed (${rollbackError}); recovery bytes are retained at ${backup}.`}`;
+        throw Object.assign(new Error(detail), {
+          code: err?.code ?? "E_IO",
+          remedy: diskRecovered ? "Inspect the file and history before retrying." : `Recover from ${backup} before editing further.`
+        });
+      }
+      const cleanupFailed = await fsp9.unlink(backup).then(() => false, () => true);
+      return {
+        ok: true,
+        sessionId: handle.sessionId,
+        path: source,
+        revision: handle.revision,
+        dirty: false,
+        commitOid,
+        original,
+        ...durabilityUnconfirmed ? { durabilityUnconfirmed: true } : {},
+        ...cleanupFailed ? { warning: `Restore succeeded but the temporary recovery backup could not be removed: ${backup}` } : {}
+      };
+    });
+  } catch (err) {
+    return mcpErrorFrom(err, "E_IO", "Inspect the document and history; export the original to a new path if in-place restore is unavailable.");
+  }
+}
+
 // src/lib/mcp/handlers/history.ts
-var fsp7 = __toESM(require("fs/promises"));
+var import_crypto9 = require("crypto");
+var fsp10 = __toESM(require("fs/promises"));
 async function handleGetDocumentHistory(store, input) {
   const parsed = GetDocumentHistorySchema.safeParse(input);
   if (!parsed.success) {
@@ -43738,7 +44764,21 @@ async function handleGetDocumentHistory(store, input) {
           currentCommit: null,
           totalCommits: 0,
           history: [],
-          warning: emptyWarning
+          warning: emptyWarning,
+          original: await resolveSessionOriginal(handle)
+        };
+      }
+      const original = await resolveSessionOriginal(handle);
+      if (!original.available && original.reason === "initializing") {
+        return {
+          ok: true,
+          sessionId,
+          documentPath: filePath,
+          currentCommit: null,
+          totalCommits: 0,
+          history: [],
+          warning: original.detail ?? "History initialization has not completed.",
+          original
         };
       }
       const full = await getHistory(filePath);
@@ -43772,7 +44812,10 @@ async function handleGetDocumentHistory(store, input) {
         currentCommit: full.length > 0 ? full[0].oid : null,
         totalCommits: full.length,
         history: slice,
-        warning
+        warning,
+        // Recovery status was re-verified above against what this session pinned at open, so a corrupted or
+        // replaced original is not reported as available and another history's original is never adopted.
+        original
       };
     });
   } catch (err) {
@@ -43874,7 +44917,7 @@ async function handleRevertDocument(store, input) {
       const prevByteSize = handle.byteSize;
       let prevFileBytes = null;
       try {
-        prevFileBytes = await fsp7.readFile(handle.filePath);
+        prevFileBytes = await fsp10.readFile(handle.filePath);
       } catch {
         prevFileBytes = null;
       }
@@ -43897,6 +44940,7 @@ async function handleRevertDocument(store, input) {
           truncated: false
         };
       }
+      await assertHistoryReadyForWrite(handle.filePath);
       let target;
       try {
         target = await checkoutCommit(handle.filePath, targetOid);
@@ -43908,15 +44952,16 @@ async function handleRevertDocument(store, input) {
         });
       }
       const merged = new Map(preRevertSnap);
+      const isTrackedForTarget = trackedPredicateFor(target);
       for (const key of [...merged.keys()]) {
-        if (key !== "word/document.xml" && isTrackedPackageFile(key)) merged.delete(key);
+        if (key !== "word/document.xml" && isTrackedForTarget(key)) merged.delete(key);
       }
       for (const [k, v] of target.extra) merged.set(k, v);
       merged.set("word/document.xml", Buffer.from(target.xml, "utf8"));
       let writeAttempted = false;
       let commitPhase = false;
       try {
-        handle.parser.restorePackageSnapshot(merged);
+        handle.parser.restorePackageSnapshot(merged, { registerCoreProperties: !target.complete });
         await refreshHandleAstInPlace(handle);
         const buf = handle.parser.rezip();
         const candidate = await validateForBaseline(buf);
@@ -43925,7 +44970,7 @@ async function handleRevertDocument(store, input) {
         }
         assertWriteTargetNoSymlink(handle.filePath);
         writeAttempted = true;
-        await fsp7.mkdir(pathDirname(handle.filePath), { recursive: true });
+        await fsp10.mkdir(pathDirname(handle.filePath), { recursive: true });
         assertWriteTargetNoSymlink(handle.filePath);
         await writeFileNoFollow(handle.filePath, buf);
         handle.byteSize = buf.length;
@@ -43954,6 +44999,7 @@ async function handleRevertDocument(store, input) {
           affectedNodeIds: diffIdTexts(liveBefore.texts, liveAfter.order, liveAfter.texts)
         });
         store.markSaved(handle);
+        handle.lastWrittenSha256 = (0, import_crypto9.createHash)("sha256").update(buf).digest("hex");
         adoptBaseline(handle, candidate);
         return {
           ok: true,
@@ -43964,7 +45010,9 @@ async function handleRevertDocument(store, input) {
           dirty: false,
           discardedUnsaved,
           commitOid,
-          commitMessage
+          commitMessage,
+          snapshotComplete: target.complete,
+          ...target.complete ? {} : { restoreWarning: INCOMPLETE_SNAPSHOT_WARNING }
         };
       } catch (stageErr) {
         const preserved = getEngineErrorCode(stageErr);
@@ -43987,7 +45035,7 @@ async function handleRevertDocument(store, input) {
             if (prevFileBytes !== null) {
               await writeFileNoFollow(handle.filePath, prevFileBytes);
             } else {
-              await fsp7.unlink(handle.filePath);
+              await fsp10.unlink(handle.filePath);
             }
           } catch (restoreErr) {
             diskOk = false;
@@ -44044,6 +45092,7 @@ async function handleRedoDocument(store, input) {
       const redoReasonProvided = "reason" in rawRedo && parsed.data.reason !== void 0;
       const redoReasonText = redoReasonProvided ? sanitizeCommitMessage(parsed.data.reason, "") : "";
       const authorName = sanitizeCommitAuthor(parsed.data.author);
+      await assertHistoryReadyForWrite(handle.filePath);
       const redoBefore = collectAstIdTexts(handle.ast);
       const prevRevision = handle.revision;
       const prevSavedRevision = handle.savedRevision;
@@ -44051,7 +45100,7 @@ async function handleRedoDocument(store, input) {
       const preRedoSnap = handle.parser.capturePackageSnapshot();
       let prevFileBytes = null;
       try {
-        prevFileBytes = await fsp7.readFile(handle.filePath);
+        prevFileBytes = await fsp10.readFile(handle.filePath);
       } catch {
         prevFileBytes = null;
       }
@@ -44071,7 +45120,7 @@ async function handleRedoDocument(store, input) {
         didPop = true;
         assertWriteTargetNoSymlink(handle.filePath);
         writeAttempted = true;
-        await fsp7.mkdir(pathDirname(handle.filePath), { recursive: true });
+        await fsp10.mkdir(pathDirname(handle.filePath), { recursive: true });
         assertWriteTargetNoSymlink(handle.filePath);
         await writeFileNoFollow(handle.filePath, buf);
         handle.byteSize = buf.length;
@@ -44104,6 +45153,7 @@ async function handleRedoDocument(store, input) {
           affectedNodeIds: diffIdTexts(redoBefore.texts, redoAfter.order, redoAfter.texts)
         });
         store.markSaved(handle);
+        handle.lastWrittenSha256 = (0, import_crypto9.createHash)("sha256").update(buf).digest("hex");
         adoptBaseline(handle, candidate);
         return {
           ok: true,
@@ -44138,7 +45188,7 @@ async function handleRedoDocument(store, input) {
             if (prevFileBytes !== null) {
               await writeFileNoFollow(handle.filePath, prevFileBytes);
             } else {
-              await fsp7.unlink(handle.filePath);
+              await fsp10.unlink(handle.filePath);
             }
           } catch (restoreErr) {
             diskOk = false;
@@ -44266,7 +45316,8 @@ async function handlePreviewRevert(store, input) {
         const targetXmlBytes = Buffer.from(target.xml, "utf8");
         if (!liveXml || Buffer.compare(liveXml, targetXmlBytes) !== 0) affectedFiles.push("word/document.xml");
         const names = /* @__PURE__ */ new Set();
-        for (const k of liveSnap.keys()) if (k !== "word/document.xml" && isTrackedPackageFile(k)) names.add(k);
+        const isTrackedForTarget = trackedPredicateFor(target);
+        for (const k of liveSnap.keys()) if (k !== "word/document.xml" && isTrackedForTarget(k)) names.add(k);
         for (const k of target.extra.keys()) names.add(k);
         for (const name2 of [...names].sort()) {
           if (affectedFiles.length >= AUDIT_FILES_MAX) break;
@@ -44314,6 +45365,8 @@ async function handlePreviewRevert(store, input) {
         changedValuesTruncated,
         changedValuesPositional,
         ...changedValuesReason ? { changedValuesReason } : {},
+        snapshotComplete: target.complete,
+        ...target.complete ? {} : { restoreWarning: INCOMPLETE_SNAPSHOT_WARNING },
         dirty,
         dirtyHandling: dirty ? `Session holds ${unsavedOps} revision(s) of unsaved edits: a bare real revert would fail closed with E_CONFLICT; a real revert with discardUnsaved:true WOULD discard them (echoed back bounded). Net-zero edits still count as dirty (revisions pending, not a content diff). This preview discarded nothing.` : "Session is clean: a real revert would discard nothing.",
         currentHeadOid: full[0].oid,
@@ -44329,6 +45382,8 @@ async function handlePreviewRevert(store, input) {
   }
 }
 var GIT_HISTORY_HANDLERS = {
+  export_original_document: handleExportOriginalDocument,
+  restore_original_document: handleRestoreOriginalDocument,
   get_document_history: handleGetDocumentHistory,
   preview_revert: handlePreviewRevert,
   revert_document: handleRevertDocument,
@@ -44376,9 +45431,9 @@ function adoptForkNumbering(fork, ast) {
 }
 
 // src/tools/export.ts
-var fs15 = __toESM(require("fs"));
-var fsp8 = __toESM(require("fs/promises"));
-var path16 = __toESM(require("path"));
+var fs17 = __toESM(require("fs"));
+var fsp11 = __toESM(require("fs/promises"));
+var path19 = __toESM(require("path"));
 var ExportDocumentSchema = import_zod6.z.object({
   sessionId: import_zod6.z.string().describe("Active document session ID returned by open_document"),
   format: import_zod6.z.enum(["html", "markdown", "md", "pdf"]).describe('Target export format: "html", "markdown", "md", or "pdf"'),
@@ -44434,18 +45489,18 @@ function validateExportTarget(rawPath, expectedFormat) {
       remedy: "Use a path inside the workspace documents directory."
     });
   }
-  const resolved = path16.resolve(trimmed);
+  const resolved = path19.resolve(trimmed);
   const canonical = canonicalizeForAsset(resolved);
   const allowedRoots = getMcpAllowedRoots();
   const isInside2 = allowedRoots.some((root) => {
     let canonicalRoot = root;
     try {
-      canonicalRoot = fs15.realpathSync(root);
+      canonicalRoot = fs17.realpathSync(root);
     } catch {
     }
-    const normC = path16.normalize(canonical);
-    const normR = path16.normalize(canonicalRoot);
-    return normC === normR || normC.startsWith(normR + path16.sep);
+    const normC = path19.normalize(canonical);
+    const normR = path19.normalize(canonicalRoot);
+    return normC === normR || normC.startsWith(normR + path19.sep);
   });
   if (!isInside2) {
     throw Object.assign(
@@ -44456,7 +45511,7 @@ function validateExportTarget(rawPath, expectedFormat) {
       }
     );
   }
-  const ext = path16.extname(trimmed).toLowerCase();
+  const ext = path19.extname(trimmed).toLowerCase();
   const validExts = {
     html: [".html", ".htm"],
     markdown: [".md", ".markdown"],
@@ -44500,18 +45555,18 @@ function validateAssetTarget(rawPath) {
       remedy: "Use a path inside the workspace documents directory."
     });
   }
-  const resolved = path16.resolve(trimmed);
+  const resolved = path19.resolve(trimmed);
   const canonical = canonicalizeForAsset(resolved);
   const allowedRoots = getMcpAllowedRoots();
   const isInside2 = allowedRoots.some((root) => {
     let canonicalRoot = root;
     try {
-      canonicalRoot = fs15.realpathSync(root);
+      canonicalRoot = fs17.realpathSync(root);
     } catch {
     }
-    const normC = path16.normalize(canonical);
-    const normR = path16.normalize(canonicalRoot);
-    return normC === normR || normC.startsWith(normR + path16.sep);
+    const normC = path19.normalize(canonical);
+    const normR = path19.normalize(canonicalRoot);
+    return normC === normR || normC.startsWith(normR + path19.sep);
   });
   if (!isInside2) {
     throw Object.assign(
@@ -44619,7 +45674,7 @@ async function handleExportDocument(store, rawArgs) {
         remedy: "Install LibreOffice on the host system: sudo apt install libreoffice (Linux) or brew install --cask libreoffice (macOS)."
       };
     }
-    const defaultPdf = targetPath || path16.join(path16.dirname(session.filePath), `${path16.basename(session.filePath, path16.extname(session.filePath))}.pdf`);
+    const defaultPdf = targetPath || path19.join(path19.dirname(session.filePath), `${path19.basename(session.filePath, path19.extname(session.filePath))}.pdf`);
     try {
       validatedPdfPath = validateExportTarget(defaultPdf, "pdf");
     } catch (err) {
@@ -44658,7 +45713,7 @@ async function handleExportDocument(store, rawArgs) {
         }
         throw original;
       }
-      const stat3 = await fsp8.stat(validatedPdfPath);
+      const stat3 = await fsp11.stat(validatedPdfPath);
       return {
         ok: true,
         format: "pdf",
@@ -44672,22 +45727,22 @@ async function handleExportDocument(store, rawArgs) {
     }
     const ast = session.ast;
     if (format === "html") {
-      const title = htmlDocumentTitle(ast, path16.basename(session.filePath, path16.extname(session.filePath)));
+      const title = htmlDocumentTitle(ast, path19.basename(session.filePath, path19.extname(session.filePath)));
       const html = convertAstToHtml(ast, title, void 0, session.parser);
       if (targetPath) {
         assertWriteTargetNoSymlink(targetPath);
-        await fsp8.mkdir(path16.dirname(targetPath), { recursive: true });
+        await fsp11.mkdir(path19.dirname(targetPath), { recursive: true });
         assertWriteTargetNoSymlink(targetPath);
         await writeFileNoFollow(targetPath, html, "utf-8");
-        const stat3 = await fsp8.stat(targetPath);
+        const stat3 = await fsp11.stat(targetPath);
         return { ok: true, format: "html", path: targetPath, bytes: stat3.size, dirty, revision };
       }
       return { ok: true, format: "html", content: html, bytes: Buffer.byteLength(html, "utf-8"), dirty, revision };
     } else {
       const effectiveImageMode = parsed.data.imageMode ?? (targetPath ? "file" : "embed");
-      const docBase = path16.basename(
+      const docBase = path19.basename(
         targetPath || session.filePath || "document.docx",
-        path16.extname(targetPath || session.filePath || "document.docx")
+        path19.extname(targetPath || session.filePath || "document.docx")
       ) || "document";
       const safeDocBase = docBase.replace(/[^A-Za-z0-9._-]+/g, "_").replace(/^\.+/, "").slice(0, 120) || "document";
       const defaultAssetPrefix = `${safeDocBase}_assets`;
@@ -44695,39 +45750,39 @@ async function handleExportDocument(store, rawArgs) {
       if (effectiveImageMode === "file") {
         const initialAssets = collectMarkdownImageAssets(ast, effectiveAssetPrefix);
         if (!targetPath) throw new Error("Markdown file image mode requires an output path.");
-        const destDir = path16.dirname(targetPath);
+        const destDir = path19.dirname(targetPath);
         let generation;
         let staging;
         let published = false;
         try {
           assertWriteTargetNoSymlink(targetPath);
-          await fsp8.mkdir(destDir, { recursive: true });
+          await fsp11.mkdir(destDir, { recursive: true });
           assertWriteTargetNoSymlink(targetPath);
           let outputPrefix = effectiveAssetPrefix;
           if (initialAssets.length > 0) {
-            const prefixDir = validateAssetTarget(path16.resolve(destDir, effectiveAssetPrefix));
+            const prefixDir = validateAssetTarget(path19.resolve(destDir, effectiveAssetPrefix));
             assertWriteTargetNoSymlink(prefixDir);
-            await fsp8.mkdir(prefixDir, { recursive: true });
+            await fsp11.mkdir(prefixDir, { recursive: true });
             assertWriteTargetNoSymlink(prefixDir);
-            generation = await fsp8.mkdtemp(path16.join(prefixDir, "export-"));
+            generation = await fsp11.mkdtemp(path19.join(prefixDir, "export-"));
             assertWriteTargetNoSymlink(generation);
-            outputPrefix = path16.relative(destDir, generation).split(path16.sep).join("/");
+            outputPrefix = path19.relative(destDir, generation).split(path19.sep).join("/");
           }
           const md = convertAstToMarkdown(ast, session.parser, { imageMode: "file", assetPrefix: outputPrefix });
           const imageAssets = collectMarkdownImageAssets(ast, outputPrefix);
           const writtenAssets = [];
           for (const asset of imageAssets) {
-            const assetPath = validateAssetTarget(path16.resolve(destDir, asset.name));
+            const assetPath = validateAssetTarget(path19.resolve(destDir, asset.name));
             assertWriteTargetNoSymlink(assetPath);
             await writeFileNoFollow(assetPath, asset.data);
             writtenAssets.push(assetPath);
           }
-          staging = await fsp8.mkdtemp(path16.join(destDir, ".astra-export-"));
-          const stagedFile = path16.join(staging, "document.md");
+          staging = await fsp11.mkdtemp(path19.join(destDir, ".astra-export-"));
+          const stagedFile = path19.join(staging, "document.md");
           assertWriteTargetNoSymlink(stagedFile);
           await writeFileNoFollow(stagedFile, md, "utf-8");
           assertWriteTargetNoSymlink(targetPath);
-          await fsp8.rename(stagedFile, targetPath);
+          await fsp11.rename(stagedFile, targetPath);
           published = true;
           return {
             ok: true,
@@ -44742,17 +45797,17 @@ async function handleExportDocument(store, rawArgs) {
             assetCount: writtenAssets.length
           };
         } finally {
-          if (staging) await fsp8.rm(staging, { recursive: true, force: true }).catch(() => void 0);
-          if (!published && generation) await fsp8.rm(generation, { recursive: true, force: true }).catch(() => void 0);
+          if (staging) await fsp11.rm(staging, { recursive: true, force: true }).catch(() => void 0);
+          if (!published && generation) await fsp11.rm(generation, { recursive: true, force: true }).catch(() => void 0);
         }
       } else {
         const md = convertAstToMarkdown(ast, session.parser, { imageMode: "embed" });
         if (targetPath) {
           assertWriteTargetNoSymlink(targetPath);
-          await fsp8.mkdir(path16.dirname(targetPath), { recursive: true });
+          await fsp11.mkdir(path19.dirname(targetPath), { recursive: true });
           assertWriteTargetNoSymlink(targetPath);
           await writeFileNoFollow(targetPath, md, "utf-8");
-          const stat3 = await fsp8.stat(targetPath);
+          const stat3 = await fsp11.stat(targetPath);
           return {
             ok: true,
             format: "markdown",
@@ -44790,8 +45845,8 @@ async function handleExportDocument(store, rawArgs) {
 }
 
 // src/tools/visual.ts
-var fs16 = __toESM(require("fs"));
-var path17 = __toESM(require("path"));
+var fs18 = __toESM(require("fs"));
+var path20 = __toESM(require("path"));
 var import_zod7 = require("zod");
 function visualError(code, message, remedy) {
   return { ok: false, code, message, remedy };
@@ -44939,14 +45994,14 @@ function serializeSessionCopy2(parser2, ast) {
   return fork.rezip();
 }
 function placeImages(images, dir, docPath) {
-  fs16.mkdirSync(dir, { recursive: true });
-  const base = path17.basename(docPath || "document", path17.extname(docPath || "")).replace(/[^a-zA-Z0-9._-]+/g, "-") || "document";
+  fs18.mkdirSync(dir, { recursive: true });
+  const base = path20.basename(docPath || "document", path20.extname(docPath || "")).replace(/[^a-zA-Z0-9._-]+/g, "-") || "document";
   return images.map((img) => {
-    const ext = path17.extname(img.path) || (img.format === "jpeg" ? ".jpg" : ".png");
-    const dest = path17.join(dir, `${base}-page-${img.page}${ext}`);
-    writeFileNoFollowSync(dest, fs16.readFileSync(img.path));
+    const ext = path20.extname(img.path) || (img.format === "jpeg" ? ".jpg" : ".png");
+    const dest = path20.join(dir, `${base}-page-${img.page}${ext}`);
+    writeFileNoFollowSync(dest, fs18.readFileSync(img.path));
     try {
-      fs16.rmSync(img.path, { force: true });
+      fs18.rmSync(img.path, { force: true });
     } catch {
     }
     return { ...img, path: dest };
@@ -45073,8 +46128,8 @@ async function handleVisualInspect(store, input) {
 
 // src/tools/new-document.ts
 var import_zod8 = require("zod");
-var fsp9 = __toESM(require("fs/promises"));
-var path18 = __toESM(require("path"));
+var fsp12 = __toESM(require("fs/promises"));
+var path21 = __toESM(require("path"));
 var NEW_DOCUMENT_TEMPLATES = ["report", "memo", "blank"];
 var NewDocumentSchema = import_zod8.z.object({
   outPath: import_zod8.z.string().min(1).max(1024),
@@ -45150,10 +46205,10 @@ async function handleNewDocument(store, rawArgs) {
   }
   if (!force) {
     try {
-      await fsp9.access(target);
+      await fsp12.access(target);
       return newDocError(
         "E_CONFLICT",
-        `new_document: destination "${path18.basename(target)}" already exists (refusing to overwrite without force)`,
+        `new_document: destination "${path21.basename(target)}" already exists (refusing to overwrite without force)`,
         'Retry with {"force":true} to overwrite, or choose a different outPath.'
       );
     } catch {
@@ -45204,7 +46259,7 @@ async function handleNewDocument(store, rawArgs) {
   }
   try {
     assertWriteTargetNoSymlink(target);
-    await fsp9.mkdir(path18.dirname(target), { recursive: true });
+    await fsp12.mkdir(path21.dirname(target), { recursive: true });
     assertWriteTargetNoSymlink(target);
     await writeFileNoFollow(target, buf);
   } catch (err) {
@@ -45216,12 +46271,12 @@ async function handleNewDocument(store, rawArgs) {
     );
   }
   try {
-    const handle = await store.openDocument(target, parsed.data.sessionId);
+    const handle = await store.openDocument(target, parsed.data.sessionId, void 0, false);
     handle.parser.adoptBuiltinSeedFrom(parser2);
     if (parsed.data.author !== void 0) handle.ast.settings.defaultAuthor = parsed.data.author;
     let bytes = buf.length;
     try {
-      bytes = (await fsp9.stat(target)).size;
+      bytes = (await fsp12.stat(target)).size;
     } catch {
     }
     if (guideRef !== void 0 && resolvedGuide !== void 0) {
@@ -45251,8 +46306,8 @@ async function handleNewDocument(store, rawArgs) {
 }
 
 // src/lib/mcp/handlers/parity.ts
-var fs17 = __toESM(require("fs"));
-var path19 = __toESM(require("path"));
+var fs19 = __toESM(require("fs"));
+var path22 = __toESM(require("path"));
 var IMPORT_FILE_MAX_BYTES = COMPOSE_MARKDOWN_MAX;
 async function refreshSessionAst(handle) {
   await refreshAstInPlace(handle.ast, handle.parser);
@@ -45507,17 +46562,17 @@ function readImportMarkdownFile(rawPath, roots = getMcpAllowedRoots()) {
   if (segments.includes("..")) {
     throw toError("E_SANDBOX", 'import path contains forbidden ".." traversal', "Use a path inside the workspace documents directory.");
   }
-  const resolved = path19.resolve(trimmed);
+  const resolved = path22.resolve(trimmed);
   const canonical = canonicalizeForAsset(resolved);
   const inside = roots.some((root) => {
     let canonicalRoot = root;
     try {
-      canonicalRoot = fs17.realpathSync(root);
+      canonicalRoot = fs19.realpathSync(root);
     } catch {
     }
-    const normC = path19.normalize(canonical);
-    const normR = path19.normalize(canonicalRoot);
-    return normC === normR || normC.startsWith(normR + path19.sep);
+    const normC = path22.normalize(canonical);
+    const normR = path22.normalize(canonicalRoot);
+    return normC === normR || normC.startsWith(normR + path22.sep);
   });
   if (!inside) {
     throw toError(
@@ -45526,12 +46581,12 @@ function readImportMarkdownFile(rawPath, roots = getMcpAllowedRoots()) {
       "Place the Markdown file inside one of the allowed directories, or name its folder with --allowed-dir or ASTRA_EXTRA_DOC_ROOTS."
     );
   }
-  const base = path19.basename(canonical);
-  const nofollow = fs17.constants.O_NOFOLLOW;
-  const flags = typeof nofollow === "number" && nofollow !== 0 ? fs17.constants.O_RDONLY | nofollow : "r";
+  const base = path22.basename(canonical);
+  const nofollow = fs19.constants.O_NOFOLLOW;
+  const flags = typeof nofollow === "number" && nofollow !== 0 ? fs19.constants.O_RDONLY | nofollow : "r";
   let fd;
   try {
-    fd = fs17.openSync(canonical, flags);
+    fd = fs19.openSync(canonical, flags);
   } catch (err) {
     const code = err?.code;
     if (code === "ENOENT") {
@@ -45543,7 +46598,7 @@ function readImportMarkdownFile(rawPath, roots = getMcpAllowedRoots()) {
     throw toError("E_IO", `import file cannot be read (${base})`, "Check the file exists and is readable, then retry.");
   }
   try {
-    const st = fs17.fstatSync(fd);
+    const st = fs19.fstatSync(fd);
     if (!st.isFile()) {
       throw toError("E_IO", `import reference is not a file (${base})`, "Point the import at a regular Markdown file.");
     }
@@ -45557,7 +46612,7 @@ function readImportMarkdownFile(rawPath, roots = getMcpAllowedRoots()) {
         "Split the Markdown source into smaller files and import each in its own call."
       );
     }
-    const buf = fs17.readFileSync(fd);
+    const buf = fs19.readFileSync(fd);
     if (buf.length > IMPORT_FILE_MAX_BYTES) {
       throw toError(
         "E_LIMIT",
@@ -45567,18 +46622,18 @@ function readImportMarkdownFile(rawPath, roots = getMcpAllowedRoots()) {
     }
     let post = canonical;
     try {
-      post = fs17.realpathSync(canonical);
+      post = fs19.realpathSync(canonical);
     } catch {
     }
     const stillInside = roots.some((root) => {
       let canonicalRoot = root;
       try {
-        canonicalRoot = fs17.realpathSync(root);
+        canonicalRoot = fs19.realpathSync(root);
       } catch {
       }
-      const normC = path19.normalize(post);
-      const normR = path19.normalize(canonicalRoot);
-      return normC === normR || normC.startsWith(normR + path19.sep);
+      const normC = path22.normalize(post);
+      const normR = path22.normalize(canonicalRoot);
+      return normC === normR || normC.startsWith(normR + path22.sep);
     });
     if (!stillInside) {
       throw toError("E_SANDBOX", "import path points outside the allowed directory", `Keep Markdown files ${describeAllowedFolders()}.`);
@@ -45586,7 +46641,7 @@ function readImportMarkdownFile(rawPath, roots = getMcpAllowedRoots()) {
     return buf.toString("utf8");
   } finally {
     try {
-      if (fd !== void 0) fs17.closeSync(fd);
+      if (fd !== void 0) fs19.closeSync(fd);
     } catch {
     }
   }
@@ -45602,12 +46657,12 @@ async function handleImportDocument(store, input) {
       remedy: 'Retry with {"sessionId":"<id from open_document>","path":"<allowed-dir>/file.md"} (optional allowedDir for image refs, optional template report|memo|blank, optional styleGuide).'
     };
   }
-  const srcExt = path19.extname(parsed.data.path).toLowerCase();
+  const srcExt = path22.extname(parsed.data.path).toLowerCase();
   if (srcExt === ".html" || srcExt === ".htm") {
     return {
       ok: false,
       code: "E_VALIDATION",
-      message: `HTML import is not supported directly ("${path19.basename(parsed.data.path)}")`,
+      message: `HTML import is not supported directly ("${path22.basename(parsed.data.path)}")`,
       remedy: "ASTra imports Markdown (.md). Convert the HTML file to Markdown or supply a .md document"
     };
   }
@@ -45615,7 +46670,7 @@ async function handleImportDocument(store, input) {
     return {
       ok: false,
       code: "E_VALIDATION",
-      message: `import_document cannot ingest .docx files ("${path19.basename(parsed.data.path)}"): open .docx files directly with open_document instead`,
+      message: `import_document cannot ingest .docx files ("${path22.basename(parsed.data.path)}"): open .docx files directly with open_document instead`,
       remedy: "Call open_document with the .docx path to work with it, or convert it to Markdown first and import the .md file."
     };
   }
@@ -45651,15 +46706,15 @@ async function handleImportDocument(store, input) {
 }
 
 // src/lib/mcp/schema-dump.ts
-var fs18 = __toESM(require("fs"));
-var path20 = __toESM(require("path"));
+var fs20 = __toESM(require("fs"));
+var path23 = __toESM(require("path"));
 var import_zod9 = require("zod");
 
 // package.json
 var package_default = {
   name: "@attentionform/astra-mcp-server",
   mcpName: "com.attentionform/astra-mcp-server",
-  version: "0.4.1",
+  version: "0.5.0",
   description: "Official Model Context Protocol (MCP) server for ASTra document IDE",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -45700,8 +46755,8 @@ var package_default = {
     "adm-zip-gate": "node ../../scripts/check-adm-zip-imports.mjs"
   },
   dependencies: {
-    "@attentionform/astra-engine": "^0.4.1",
-    "@attentionform/ooxml-validator": "^0.4.1",
+    "@attentionform/astra-engine": "^0.5.0",
+    "@attentionform/ooxml-validator": "^0.5.0",
     "@modelcontextprotocol/sdk": "^1.32.2",
     "@xmldom/xmldom": "0.8.15",
     "adm-zip": "0.6.1",
@@ -45746,6 +46801,8 @@ function getToolDefinitions() {
     { name: "compose_document", description: COMPOSE_DOCUMENT_DESCRIPTION, schema: ComposeDocumentSchema },
     { name: "export_document", description: EXPORT_DOCUMENT_DESCRIPTION, schema: ExportDocumentSchema },
     { name: "visual_inspect", description: VISUAL_INSPECT_DESCRIPTION, schema: VisualInspectSchema },
+    { name: "export_original_document", description: GIT_HISTORY_DESCRIPTIONS.export_original_document, schema: ExportOriginalDocumentSchema },
+    { name: "restore_original_document", description: GIT_HISTORY_DESCRIPTIONS.restore_original_document, schema: RestoreOriginalDocumentSchema },
     { name: "get_document_history", description: GIT_HISTORY_DESCRIPTIONS.get_document_history, schema: GetDocumentHistorySchema },
     { name: "preview_revert", description: GIT_HISTORY_DESCRIPTIONS.preview_revert, schema: PreviewRevertSchema },
     { name: "revert_document", description: GIT_HISTORY_DESCRIPTIONS.revert_document, schema: RevertDocumentSchema },
@@ -45766,8 +46823,8 @@ function compactToolSchema(schema) {
   return raw;
 }
 function generateSchemasToDir(targetDir, version = getServerVersion()) {
-  if (!fs18.existsSync(targetDir)) {
-    fs18.mkdirSync(targetDir, { recursive: true });
+  if (!fs20.existsSync(targetDir)) {
+    fs20.mkdirSync(targetDir, { recursive: true });
   }
   const stamp2 = buildStamp(version);
   const written = [];
@@ -45779,8 +46836,8 @@ function generateSchemasToDir(targetDir, version = getServerVersion()) {
       parameters: raw,
       [SCHEMA_STAMP_KEY]: stamp2
     };
-    const filePath = path20.join(targetDir, `${tool.name}.json`);
-    fs18.writeFileSync(filePath, JSON.stringify(payload, null, 2) + "\n", "utf8");
+    const filePath = path23.join(targetDir, `${tool.name}.json`);
+    fs20.writeFileSync(filePath, JSON.stringify(payload, null, 2) + "\n", "utf8");
     written.push(filePath);
   }
   return { written, count: written.length };
@@ -45790,11 +46847,11 @@ function checkSchemasInDir(dir, expectedVersion2 = getServerVersion()) {
   const mismatches = [];
   let checked = 0;
   for (const tool of getToolDefinitions()) {
-    const file = path20.join(dir, `${tool.name}.json`);
+    const file = path23.join(dir, `${tool.name}.json`);
     checked += 1;
     let stamped = "<missing>";
     try {
-      const raw = JSON.parse(fs18.readFileSync(file, "utf8"));
+      const raw = JSON.parse(fs20.readFileSync(file, "utf8"));
       const value = raw[SCHEMA_STAMP_KEY];
       stamped = typeof value === "string" ? value : "<unstamped>";
     } catch {
@@ -45807,7 +46864,7 @@ function checkSchemasInDir(dir, expectedVersion2 = getServerVersion()) {
   return { ok: mismatches.length === 0, mismatches, checked };
 }
 function formatMismatchWarning(mismatches) {
-  const lines = mismatches.map((m) => `  ${path20.basename(m.file)}: stamped ${m.stamped}, installed ${m.expected}`);
+  const lines = mismatches.map((m) => `  ${path23.basename(m.file)}: stamped ${m.stamped}, installed ${m.expected}`);
   return "Schema cache is stale: regenerated wire schemas differ from the installed server. Refresh file-based client copies with `astra-mcp-server --dump-schemas <dir>` and restart memory-cached clients.\n" + lines.join("\n");
 }
 
@@ -45874,20 +46931,20 @@ function buildUsageText() {
 var CLI_USAGE_ERROR = 2;
 function initAllowedDirs(argv = process.argv) {
   const currentRoots = new Set(
-    (process.env.ASTRA_EXTRA_DOC_ROOTS || "").split(path21.delimiter).map((p) => p.trim()).filter(Boolean)
+    (process.env.ASTRA_EXTRA_DOC_ROOTS || "").split(path24.delimiter).map((p) => p.trim()).filter(Boolean)
   );
   for (let i = 0; i < argv.length; i++) {
     if (argv[i] === "--") break;
     if (argv[i] === "--allowed-dir" && argv[i + 1] && !argv[i + 1].startsWith("-")) {
-      currentRoots.add(path21.resolve(argv[i + 1]));
+      currentRoots.add(path24.resolve(argv[i + 1]));
       i++;
     } else if (argv[i].startsWith("--allowed-dir=")) {
       const value = argv[i].slice("--allowed-dir=".length).trim();
-      if (value && !value.startsWith("-")) currentRoots.add(path21.resolve(value));
+      if (value && !value.startsWith("-")) currentRoots.add(path24.resolve(value));
     }
   }
   if (currentRoots.size > 0) {
-    process.env.ASTRA_EXTRA_DOC_ROOTS = Array.from(currentRoots).join(path21.delimiter);
+    process.env.ASTRA_EXTRA_DOC_ROOTS = Array.from(currentRoots).join(path24.delimiter);
   }
 }
 function takeDirFlag(argv, flag) {
@@ -45953,6 +47010,16 @@ function createAstraMcpServer(store = createMcpSessionStore()) {
     },
     async (args) => toTextResult(await handleVisualInspect(store, args))
   );
+  server.registerTool(
+    "export_original_document",
+    { description: GIT_HISTORY_DESCRIPTIONS.export_original_document, inputSchema: ExportOriginalDocumentSchema },
+    async (args) => toTextResult(await GIT_HISTORY_HANDLERS.export_original_document(store, args))
+  );
+  server.registerTool(
+    "restore_original_document",
+    { description: GIT_HISTORY_DESCRIPTIONS.restore_original_document, inputSchema: RestoreOriginalDocumentSchema },
+    async (args) => toTextResult(await GIT_HISTORY_HANDLERS.restore_original_document(store, args))
+  );
   server.registerTool(
     "get_document_history",
     { description: GIT_HISTORY_DESCRIPTIONS.get_document_history, inputSchema: GetDocumentHistorySchema },
@@ -46080,7 +47147,7 @@ async function main(argv = process.argv) {
   if (openTimeout !== void 0) setOpenValidationTimeoutMs(Number(openTimeout));
   const dumpDir = takeDirFlag(argv, "--dump-schemas");
   if (dumpDir !== void 0) {
-    const resolved = path21.resolve(dumpDir);
+    const resolved = path24.resolve(dumpDir);
     const result = generateSchemasToDir(resolved, SERVER_VERSION);
     process.stdout.write(`[${SERVER_NAME} v${SERVER_VERSION}] wrote ${result.count} schemas to ${resolved}
 `);
@@ -46088,7 +47155,7 @@ async function main(argv = process.argv) {
   }
   const checkDir = takeDirFlag(argv, "--check-schemas");
   if (checkDir !== void 0) {
-    const resolved = path21.resolve(checkDir);
+    const resolved = path24.resolve(checkDir);
     const verdict = checkSchemasInDir(resolved, SERVER_VERSION);
     if (verdict.ok) {
       process.stdout.write(`[${SERVER_NAME} v${SERVER_VERSION}] schemas fresh (${verdict.checked} tools)