@unbrained/pm-cli 2026.7.19 → 2026.7.20

package/dist/cli-bundle/chunks/{chunk-ODEIDKGW.js → chunk-3LPFHE3P.js}

@@ -1,19 +1,19 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="b111adf0-7ac6-5083-9fb7-c9a093abf43b")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="4c96022d-a7de-55fa-835e-c7cf3a43e0b8")}catch(e){}}();
 import {
   runUpdate
-} from "./chunk-MRXAHR4B.js";
+} from "./chunk-RZJLNXFG.js";
 import {
   buildCapabilityContractMetadata,
   buildRegistrationCollisionRemediation,
   collectUnknownCapabilityGuidance,
   readManagedExtensionState,
   runInit
-} from "./chunk-MI3346YW.js";
+} from "./chunk-QANSTTC7.js";
 import {
   collectStaleVectorizationIds,
   runNext
-} from "./chunk-CZA2DXCV.js";
+} from "./chunk-YQQNAKW3.js";
 import {
   buildVectorizationEmbeddingIdentity,
   hasVectorizationEmbeddingIdentityChanged,
@@ -23,10 +23,10 @@ import {
   resolveProviderConfigSource,
   resolveSettingsWithSemanticRuntimeDefaults,
   resolveVectorStores
-} from "./chunk-UE7LK3RE.js";
+} from "./chunk-THAOZG4U.js";
 import {
   scanHistoryDrift
-} from "./chunk-XXWDEQ6O.js";
+} from "./chunk-ZV2NTVMJ.js";
 import {
   ACTIVITY_COMMANDER_STRING_OPTION_CONTRACTS,
   ACTIVITY_FLAG_CONTRACTS,
@@ -83,6 +83,7 @@ import {
   LEARNINGS_FLAG_CONTRACTS,
   LIST_COMMANDER_STRING_OPTION_CONTRACTS,
   LIST_FILTER_FLAG_CONTRACTS,
+  MERGE_FLAG_CONTRACTS,
   NEXT_FLAG_CONTRACTS,
   NOTES_FLAG_CONTRACTS,
   PACKAGE_FLAG_CONTRACTS,
@@ -118,10 +119,13 @@ import {
   UPGRADE_FLAG_CONTRACTS,
   VALIDATE_FLAG_CONTRACTS,
   compactFlagAliasContracts
-} from "./chunk-JPWUZOMR.js";
+} from "./chunk-UZDQXNUB.js";
+import {
+  auditMergeAttributeFence
+} from "./chunk-CFHAODHQ.js";
 import {
   wrapOwnershipConflict
-} from "./chunk-Y2VSGFT4.js";
+} from "./chunk-HB3P4M52.js";
 import {
   LINKED_TEST_PM_CONTEXT_MODE_VALUES,
   LINKED_TEST_PROTECTED_ENV_KEYS,
@@ -138,38 +142,38 @@ import {
   parseLinkedTestRegexList,
   parseLinkedTestStringList,
   runCreate
-} from "./chunk-BDC4TW4B.js";
+} from "./chunk-OV7MSW3I.js";
 import {
   collectDanglingDependencyReferences
-} from "./chunk-77XFQRTD.js";
+} from "./chunk-GSJSM5BJ.js";
 import {
   runDocs
-} from "./chunk-LT5UWU7H.js";
+} from "./chunk-ZOJ3LR7O.js";
 import {
   runFiles
-} from "./chunk-YGEA4CLH.js";
+} from "./chunk-3MCTMJXI.js";
 import {
   isRemoteLinkedArtifactReference
-} from "./chunk-VSQE43NO.js";
+} from "./chunk-GV2262OF.js";
 import {
   createStdinTokenResolver,
   parseCsvKv,
   parseOptionalNumber
-} from "./chunk-SVAWG7EE.js";
+} from "./chunk-J4FBIFU6.js";
 import {
   computeContentFieldUtilization
-} from "./chunk-YG56M3NE.js";
+} from "./chunk-7DOJC3HS.js";
 import {
   computeMetadataCoverage,
   groupItemsByDimension,
   lifecycleClassifierFromStatusRegistry
-} from "./chunk-XKVHL3MB.js";
+} from "./chunk-QWRVBJ4D.js";
 import {
   parseLimit
-} from "./chunk-FIUTBFC6.js";
+} from "./chunk-K4CI6Y45.js";
 import {
   readHistoryEntries
-} from "./chunk-M4B4RK4J.js";
+} from "./chunk-2BO4CA46.js";
 import {
   resolveAuthor
 } from "./chunk-CUFW7ITY.js";
@@ -199,7 +203,7 @@ import {
   stableValueEquals,
   toItemRecord,
   writeSettings
-} from "./chunk-QFG4MB7P.js";
+} from "./chunk-POG76WWZ.js";
 import {
   DEFAULT_VALIDATE_CLOSURE_LIKE_METADATA_FIELD_PATTERNS,
   DEFAULT_VALIDATE_STALE_BLOCKER_REASON_PATTERNS,
@@ -246,7 +250,7 @@ import {
   statusIsTerminal,
   toNonEmptyStringOrUndefined,
   writeFileAtomic
-} from "./chunk-D35WYXWC.js";
+} from "./chunk-HYW67VJ5.js";
 
 // dist/core/telemetry/observability.js
 var SETUP_ROOT_COMMANDS = /* @__PURE__ */ new Set([
@@ -2952,6 +2956,7 @@ var CORE_COMMAND_FLAG_CONTRACT_ENTRIES = [
   ["history-compact", HISTORY_COMPACT_FLAG_CONTRACTS],
   ["history-redact", HISTORY_REDACT_FLAG_CONTRACTS],
   ["history-repair", HISTORY_REPAIR_FLAG_CONTRACTS],
+  ["merge", MERGE_FLAG_CONTRACTS],
   ["schema", SCHEMA_FLAG_CONTRACTS],
   ["profile", PROFILE_FLAG_CONTRACTS],
   ["plan", PLAN_FLAG_CONTRACTS],
@@ -4256,17 +4261,144 @@ function runRemind(title, options, global) {
   return runCreate(createOptions, global);
 }
 
-// dist/sdk/governance/gc.js
-import fs3 from "node:fs/promises";
-import path4 from "node:path";
-
-// dist/core/checkpoint/checkpoint-gc.js
+// dist/sdk/workspace-transaction-gc.js
 import fs from "node:fs/promises";
 import path2 from "node:path";
-var MILLISECONDS_PER_DAY2 = 864e5;
+var MILLISECONDS_PER_DAY2 = 24 * 60 * 60 * 1e3;
+var TERMINAL_JOURNAL_STATUSES = /* @__PURE__ */ new Set(["committed", "compensated"]);
 function isErrno(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
+function readJournalStatusAndTimestamp(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { status: null, updatedAt: null };
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return { status: null, updatedAt: null };
+  }
+  const record = parsed;
+  return {
+    status: typeof record.status === "string" ? record.status : null,
+    updatedAt: typeof record.updatedAt === "string" ? record.updatedAt : null
+  };
+}
+function classifyWorkspaceTransactionJournal(file, status, updatedAt, nowMs2, retentionMs) {
+  const updatedAtMs = updatedAt === null ? Number.NaN : Date.parse(updatedAt);
+  if (status === null || !Number.isFinite(updatedAtMs)) {
+    return {
+      entry: {
+        file,
+        status,
+        age_seconds: null,
+        stale: false,
+        reason: "unparseable"
+      },
+      remove: false
+    };
+  }
+  const ageMs = nowMs2 - updatedAtMs;
+  if (!TERMINAL_JOURNAL_STATUSES.has(status)) {
+    return {
+      entry: {
+        file,
+        status,
+        age_seconds: Math.floor(ageMs / 1e3),
+        stale: false,
+        reason: "active"
+      },
+      remove: false
+    };
+  }
+  if (!(ageMs > retentionMs)) {
+    return {
+      entry: {
+        file,
+        status,
+        age_seconds: Math.floor(ageMs / 1e3),
+        stale: false,
+        reason: "fresh"
+      },
+      remove: false
+    };
+  }
+  return {
+    entry: {
+      file,
+      status,
+      age_seconds: Math.floor(ageMs / 1e3),
+      stale: true
+    },
+    remove: true
+  };
+}
+async function processWorkspaceTransactionJournal(absolutePath, relativePath, fileName, options) {
+  const warnings = options.hooks?.onRead ? await options.hooks.onRead(absolutePath) : [];
+  const journal = readJournalStatusAndTimestamp(await fs.readFile(absolutePath, "utf8"));
+  const decision = classifyWorkspaceTransactionJournal(relativePath, journal.status, journal.updatedAt, options.nowMs, options.retentionMs);
+  if (decision.entry.reason === "unparseable") {
+    warnings.push(`transaction_journal_unparseable:${fileName}`);
+  }
+  if (decision.remove && !options.dryRun) {
+    await fs.rm(absolutePath, { force: true });
+    if (options.hooks?.onWrite) {
+      warnings.push(...await options.hooks.onWrite(absolutePath));
+    }
+  }
+  return { decision, warnings };
+}
+async function runWorkspaceTransactionGc(pmRoot, options) {
+  const { dryRun, hooks } = options;
+  const nowMs2 = options.now ?? Date.now();
+  const retentionMs = Math.max(0, options.retentionDays) * MILLISECONDS_PER_DAY2;
+  const journalsDir = path2.join(pmRoot, "transactions", "sdk");
+  const result = {
+    scanned: 0,
+    removed: [],
+    retained: [],
+    warnings: [],
+    entries: []
+  };
+  let files;
+  try {
+    files = (await fs.readdir(journalsDir)).filter((file) => file.endsWith(".json")).sort((left, right) => left.localeCompare(right));
+  } catch (error) {
+    if (isErrno(error, "ENOENT")) {
+      return result;
+    }
+    throw error;
+  }
+  for (const file of files) {
+    const absPath = path2.join(journalsDir, file);
+    const relPath = `transactions/sdk/${file}`;
+    const fileResult = await processWorkspaceTransactionJournal(absPath, relPath, file, { dryRun, hooks, nowMs: nowMs2, retentionMs });
+    result.warnings.push(...fileResult.warnings);
+    result.scanned += 1;
+    const { decision } = fileResult;
+    if (!decision.remove) {
+      result.retained.push(relPath);
+      result.entries.push(decision.entry);
+      continue;
+    }
+    result.removed.push(relPath);
+    result.entries.push(decision.entry);
+  }
+  return result;
+}
+
+// dist/sdk/governance/gc.js
+import fs4 from "node:fs/promises";
+import path5 from "node:path";
+
+// dist/core/checkpoint/checkpoint-gc.js
+import fs2 from "node:fs/promises";
+import path3 from "node:path";
+var MILLISECONDS_PER_DAY3 = 864e5;
+function isErrno2(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
 function readCheckpointCreatedAt(raw) {
   let parsed;
   try {
@@ -4283,9 +4415,9 @@ function readCheckpointCreatedAt(raw) {
 async function collectCheckpointFiles(checkpointsDir, warnings) {
   let dirEntries;
   try {
-    dirEntries = await fs.readdir(checkpointsDir, { withFileTypes: true });
+    dirEntries = await fs2.readdir(checkpointsDir, { withFileTypes: true });
   } catch (error) {
-    if (isErrno(error, "ENOENT")) {
+    if (isErrno2(error, "ENOENT")) {
       return [];
     }
     throw error;
@@ -4293,12 +4425,12 @@ async function collectCheckpointFiles(checkpointsDir, warnings) {
   const files = [];
   for (const entry of dirEntries) {
     if (entry.isDirectory()) {
-      const subdir = path2.join(checkpointsDir, entry.name);
+      const subdir = path3.join(checkpointsDir, entry.name);
       let nested;
       try {
-        nested = await fs.readdir(subdir);
+        nested = await fs2.readdir(subdir);
       } catch (error) {
-        if (!isErrno(error, "ENOENT")) {
+        if (!isErrno2(error, "ENOENT")) {
           warnings.push(`checkpoint_subdir_unreadable:${entry.name}`);
         }
         continue;
@@ -4317,8 +4449,8 @@ async function collectCheckpointFiles(checkpointsDir, warnings) {
 async function runCheckpointGc(pmRoot, options) {
   const { dryRun, hooks } = options;
   const nowMs2 = options.now ?? Date.now();
-  const retentionMs = Math.max(0, options.retentionDays) * MILLISECONDS_PER_DAY2;
-  const checkpointsDir = path2.join(pmRoot, "checkpoints");
+  const retentionMs = Math.max(0, options.retentionDays) * MILLISECONDS_PER_DAY3;
+  const checkpointsDir = path3.join(pmRoot, "checkpoints");
   const result = {
     scanned: 0,
     removed: [],
@@ -4328,7 +4460,7 @@ async function runCheckpointGc(pmRoot, options) {
   };
   const files = await collectCheckpointFiles(checkpointsDir, result.warnings);
   for (const relName of files) {
-    const absPath = path2.join(checkpointsDir, relName);
+    const absPath = path3.join(checkpointsDir, relName);
     const relPath = `checkpoints/${relName}`;
     result.scanned += 1;
     if (hooks?.onRead) {
@@ -4336,9 +4468,9 @@ async function runCheckpointGc(pmRoot, options) {
     }
     let raw;
     try {
-      raw = await fs.readFile(absPath, "utf8");
+      raw = await fs2.readFile(absPath, "utf8");
     } catch (readError) {
-      if (isErrno(readError, "ENOENT")) {
+      if (isErrno2(readError, "ENOENT")) {
         result.scanned -= 1;
         continue;
       }
@@ -4382,9 +4514,9 @@ async function runCheckpointGc(pmRoot, options) {
     }
     if (!dryRun) {
       try {
-        await fs.unlink(absPath);
+        await fs2.unlink(absPath);
       } catch (unlinkError) {
-        if (!isErrno(unlinkError, "ENOENT")) {
+        if (!isErrno2(unlinkError, "ENOENT")) {
           result.warnings.push(`checkpoint_remove_failed:${relName}`);
           result.retained.push(relPath);
           result.entries.push(entry);
@@ -4402,8 +4534,8 @@ async function runCheckpointGc(pmRoot, options) {
 }
 
 // dist/core/lock/lock-gc.js
-import fs2 from "node:fs/promises";
-import path3 from "node:path";
+import fs3 from "node:fs/promises";
+import path4 from "node:path";
 function parseLock(raw) {
   let parsed;
   try {
@@ -4421,7 +4553,7 @@ function parseLock(raw) {
   }
   return { id, owner, created_at, ttl_seconds };
 }
-function isErrno2(error, code) {
+function isErrno3(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
 function classifyLockContent(file, raw, nowMs2) {
@@ -4476,7 +4608,7 @@ function classifyLockContent(file, raw, nowMs2) {
 }
 async function scanLockHealth(pmRoot, now) {
   const nowMs2 = now ?? Date.now();
-  const locksDir = path3.join(pmRoot, "locks");
+  const locksDir = path4.join(pmRoot, "locks");
   const scan = {
     scanned: 0,
     active_lock_count: 0,
@@ -4486,10 +4618,10 @@ async function scanLockHealth(pmRoot, now) {
   };
   let dirEntries;
   try {
-    const rawDir = await fs2.readdir(locksDir);
+    const rawDir = await fs3.readdir(locksDir);
     dirEntries = rawDir.filter((f) => f.endsWith(".lock")).sort();
   } catch (error) {
-    if (isErrno2(error, "ENOENT")) {
+    if (isErrno3(error, "ENOENT")) {
       return scan;
     }
     throw error;
@@ -4497,9 +4629,9 @@ async function scanLockHealth(pmRoot, now) {
   for (const file of dirEntries) {
     let raw;
     try {
-      raw = await fs2.readFile(path3.join(locksDir, file), "utf8");
+      raw = await fs3.readFile(path4.join(locksDir, file), "utf8");
     } catch (readError) {
-      if (isErrno2(readError, "ENOENT")) {
+      if (isErrno3(readError, "ENOENT")) {
         continue;
       }
       scan.scanned += 1;
@@ -4521,7 +4653,7 @@ async function scanLockHealth(pmRoot, now) {
 async function runLockGc(pmRoot, options) {
   const { dryRun, hooks } = options;
   const nowMs2 = options.now ?? Date.now();
-  const locksDir = path3.join(pmRoot, "locks");
+  const locksDir = path4.join(pmRoot, "locks");
   const result = {
     scanned: 0,
     removed: [],
@@ -4531,17 +4663,17 @@ async function runLockGc(pmRoot, options) {
   };
   let dirEntries;
   try {
-    const raw = await fs2.readdir(locksDir);
+    const raw = await fs3.readdir(locksDir);
     dirEntries = raw.filter((f) => f.endsWith(".lock")).sort();
   } catch (error) {
-    if (isErrno2(error, "ENOENT")) {
+    if (isErrno3(error, "ENOENT")) {
       return result;
     }
     throw error;
   }
   for (const file of dirEntries) {
     result.scanned += 1;
-    const absPath = path3.join(locksDir, file);
+    const absPath = path4.join(locksDir, file);
     const relPath = `locks/${file}`;
     if (hooks?.onRead) {
       const hookWarnings = await hooks.onRead(absPath);
@@ -4549,9 +4681,9 @@ async function runLockGc(pmRoot, options) {
     }
     let raw;
     try {
-      raw = await fs2.readFile(absPath, "utf8");
+      raw = await fs3.readFile(absPath, "utf8");
     } catch (readError) {
-      if (isErrno2(readError, "ENOENT")) {
+      if (isErrno3(readError, "ENOENT")) {
         result.scanned -= 1;
         continue;
       }
@@ -4589,9 +4721,9 @@ async function runLockGc(pmRoot, options) {
     }
     if (!dryRun) {
       try {
-        await fs2.unlink(absPath);
+        await fs3.unlink(absPath);
       } catch (unlinkError) {
-        if (!isErrno2(unlinkError, "ENOENT")) {
+        if (!isErrno3(unlinkError, "ENOENT")) {
           result.warnings.push(`lock_remove_failed:${file}`);
           result.retained.push(relPath);
           result.entries.push(classified.entry);
@@ -4615,7 +4747,8 @@ var GC_SCOPE_VALUES = [
   "embeddings",
   "runtime",
   "locks",
-  "checkpoints"
+  "checkpoints",
+  "transactions"
 ];
 var GC_TARGETS = [
   {
@@ -4664,18 +4797,18 @@ var GC_TARGETS = [
     kind: "file"
   }
 ];
-function isErrno3(error, code) {
+function isErrno4(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
 async function removeCacheFile(pmRoot, target, dryRun) {
   const relativePath = target.relativePath;
-  const absolutePath = path4.join(pmRoot, relativePath);
+  const absolutePath = path5.join(pmRoot, relativePath);
   const warnings = await runActiveOnReadHooks({
     path: absolutePath,
     scope: "project"
   });
   try {
-    const stats = await fs3.stat(absolutePath);
+    const stats = await fs4.stat(absolutePath);
     if (target.kind === "file" && !stats.isFile()) {
       return {
         removed: false,
@@ -4695,9 +4828,9 @@ async function removeCacheFile(pmRoot, target, dryRun) {
       };
     }
     if (target.kind === "file") {
-      await fs3.unlink(absolutePath);
+      await fs4.unlink(absolutePath);
     } else {
-      await fs3.rm(absolutePath, { recursive: true, force: true });
+      await fs4.rm(absolutePath, { recursive: true, force: true });
     }
     const writeWarnings = await runActiveOnWriteHooks({
       path: absolutePath,
@@ -4709,7 +4842,7 @@ async function removeCacheFile(pmRoot, target, dryRun) {
       warnings: [...warnings, ...writeWarnings]
     };
   } catch (error) {
-    if (isErrno3(error, "ENOENT")) {
+    if (isErrno4(error, "ENOENT")) {
       return {
         removed: false,
         warnings
@@ -4751,6 +4884,9 @@ function buildGcGuidance(params) {
   if (!params.dryRun && params.removed.some((entry) => entry.startsWith("checkpoints/"))) {
     guidance.push('Aged rollback checkpoints were removed; their "pm update-many"/"pm close-many --rollback" windows are no longer recoverable.');
   }
+  if (!params.dryRun && params.removed.some((entry) => entry.startsWith("transactions/"))) {
+    guidance.push("Aged terminal workspace-transaction journals were removed; replaying those transactionIds re-executes their idempotent steps instead of short-circuiting.");
+  }
   return guidance;
 }
 async function runGc(global, options = {}) {
@@ -4796,6 +4932,31 @@ async function runGc(global, options = {}) {
       retained: lockResult.retained.length
     };
   }
+  let transactionsSummary;
+  if (scopes.includes("transactions")) {
+    const retentionDays = settings.checkpoints.retention_days;
+    const transactionResult = await runWorkspaceTransactionGc(pmRoot, {
+      dryRun,
+      retentionDays,
+      hooks: {
+        onRead: (journalPath) => runActiveOnReadHooks({ path: journalPath, scope: "project" }),
+        onWrite: (journalPath) => runActiveOnWriteHooks({
+          path: journalPath,
+          scope: "project",
+          op: "gc:transaction_journal_remove"
+        })
+      }
+    });
+    removed.push(...transactionResult.removed);
+    retained.push(...transactionResult.retained);
+    warnings.push(...transactionResult.warnings);
+    transactionsSummary = {
+      scanned: transactionResult.scanned,
+      removed: transactionResult.removed.length,
+      retained: transactionResult.retained.length,
+      retention_days: retentionDays
+    };
+  }
   let checkpointsSummary;
   if (scopes.includes("checkpoints")) {
     const retentionDays = settings.checkpoints.retention_days;
@@ -4839,14 +5000,15 @@ async function runGc(global, options = {}) {
     warnings,
     ...locksSummary ? { locks: locksSummary } : {},
     ...checkpointsSummary ? { checkpoints: checkpointsSummary } : {},
+    ...transactionsSummary ? { transactions: transactionsSummary } : {},
     guidance,
     generated_at: nowIso()
   };
 }
 
 // dist/sdk/author-attribution.js
-import fs4 from "node:fs/promises";
-import path5 from "node:path";
+import fs5 from "node:fs/promises";
+import path6 from "node:path";
 var HISTORY_AUTHOR_ATTRIBUTION_BASELINE = "2026-07-15T06:22:12.276Z";
 var HISTORY_AUTHOR_ATTRIBUTION_BASELINE_MS = Date.parse(HISTORY_AUTHOR_ATTRIBUTION_BASELINE);
 var HISTORY_AUTHOR_EVENT_CLASSIFICATIONS = [
@@ -4895,10 +5057,10 @@ var inspectHistoryAuthorStream = (itemId, raw, sampleLimit = 20) => {
   };
 };
 var scanHistoryAuthorAttribution = async (pmRoot, sampleLimit = 20) => {
-  const historyDirectory = path5.join(pmRoot, "history");
+  const historyDirectory = path6.join(pmRoot, "history");
   let fileNames;
   try {
-    fileNames = (await fs4.readdir(historyDirectory)).filter((fileName) => fileName.endsWith(".jsonl")).sort((left, right) => left.localeCompare(right));
+    fileNames = (await fs5.readdir(historyDirectory)).filter((fileName) => fileName.endsWith(".jsonl")).sort((left, right) => left.localeCompare(right));
   } catch {
     fileNames = [];
   }
@@ -4912,7 +5074,7 @@ var scanHistoryAuthorAttribution = async (pmRoot, sampleLimit = 20) => {
   for (const fileName of fileNames) {
     let raw;
     try {
-      raw = await fs4.readFile(path5.join(historyDirectory, fileName), "utf8");
+      raw = await fs5.readFile(path6.join(historyDirectory, fileName), "utf8");
     } catch {
       continue;
     }
@@ -4940,8 +5102,8 @@ var scanHistoryAuthorAttribution = async (pmRoot, sampleLimit = 20) => {
 };
 
 // dist/sdk/governance/health.js
-import fs5 from "node:fs/promises";
-import path6 from "node:path";
+import fs6 from "node:fs/promises";
+import path7 from "node:path";
 
 // dist/core/diagnostics/remediation.js
 var REMEDIATION_REGISTRY = Object.freeze([
@@ -5050,6 +5212,42 @@ var REMEDIATION_REGISTRY = Object.freeze([
     command: "pm history-repair <id>",
     summary: "A history stream contains Git conflict markers; resolve the markers, then re-anchor the chain."
   },
+  // --- pm validate: storage_integrity (post-merge corruption detection) ---
+  {
+    code: "validate_storage_unreadable_items",
+    command: "pm validate --check-storage-integrity --verbose-diagnostics",
+    summary: "An on-disk item file cannot be parsed (for example a botched merge resolution with stale TOON count headers); repair or restore the file at the reported path \u2014 list commands silently skip it while pm get hard-errors."
+  },
+  {
+    code: "validate_storage_duplicate_item_ids",
+    command: "pm validate --check-storage-integrity --verbose-diagnostics",
+    summary: "One item id is claimed by multiple item documents \u2014 usually two branches minting the same id for different items before merging (GH-600). Keep one document, recreate the other item under a fresh id (pm copy, then delete the colliding file), and consider raising ids.token_length for concurrent multi-agent work."
+  },
+  {
+    code: "validate_storage_history_conflict_markers",
+    command: "pm merge driver history <base> <ours> <theirs>",
+    summary: "A history stream contains unresolved Git conflict markers; re-merge it with the pm history merge driver (or resolve the markers by hand), then run pm history-repair for the item."
+  },
+  {
+    code: "validate_storage_unparseable_history",
+    command: "pm history-repair <id>",
+    summary: "A history stream's newest line is not valid JSONL; repair or restore the stream before further mutations."
+  },
+  {
+    code: "validate_storage_resurrected_items",
+    command: "pm delete <id>",
+    summary: "A live item's newest history operation is a delete: a delete/modify merge silently resurrected it. Decide the winner \u2014 re-delete the item, or keep it and append a mutation documenting the revival."
+  },
+  {
+    code: "validate_storage_unparseable_config",
+    command: "pm merge driver json <base> <ours> <theirs>",
+    summary: "settings.json or a schema file cannot be parsed, so pm silently falls back to defaults; re-merge it with the pm JSON merge driver or fix the file by hand, then rerun pm validate."
+  },
+  {
+    code: "validate_merge_fence_drift",
+    command: "pm merge install",
+    summary: "The committed .gitattributes merge fence no longer matches the active schema's type folders or tracker JSONL stores; rerun pm merge install (and commit .gitattributes) so every tracker artifact keeps its field-aware merge driver."
+  },
   // --- pm health (integrity) + pm validate (format_version): item format version ---
   {
     code: "integrity_item_outdated_format_version",
@@ -5316,8 +5514,8 @@ function buildRemediationCommands(warnings) {
 var PM_TELEMETRY_SOURCE_CONTEXT_SET2 = new Set(PM_TELEMETRY_SOURCE_CONTEXT_VALUES);
 var STALE_VECTORIZATION_SUMMARY_LIMIT = 25;
 var BRIEF_HEALTH_DETAIL_LIMIT = 8;
-var TELEMETRY_QUEUE_RELATIVE_PATH2 = path6.join("runtime", "telemetry", "events.jsonl");
-var TELEMETRY_STATE_RELATIVE_PATH2 = path6.join("runtime", "telemetry", "state.json");
+var TELEMETRY_QUEUE_RELATIVE_PATH2 = path7.join("runtime", "telemetry", "events.jsonl");
+var TELEMETRY_STATE_RELATIVE_PATH2 = path7.join("runtime", "telemetry", "state.json");
 var TELEMETRY_ENDPOINT_PROBE_TIMEOUT_MS = 2500;
 var TELEMETRY_QUEUE_HIGH_WATER_MARK = 500;
 var TELEMETRY_QUEUE_HIGH_RETRY_THRESHOLD = TELEMETRY_MAX_QUEUE_ENTRY_ATTEMPTS - 3;
@@ -5349,29 +5547,29 @@ function isExpectedUnmanagedExtension(name, directory) {
 }
 async function isDirectory(targetPath) {
   try {
-    const stats = await fs5.stat(targetPath);
+    const stats = await fs6.stat(targetPath);
     return stats.isDirectory();
   } catch {
     return false;
   }
 }
 async function countHistoryStreams(pmRoot, compactPolicy) {
-  const historyDir = path6.join(pmRoot, "history");
+  const historyDir = path7.join(pmRoot, "history");
   if (!await isDirectory(historyDir)) {
     return { count: 0, warnings: [], over_threshold: [], max_entries: null };
   }
-  const historyFiles = (await fs5.readdir(historyDir)).filter((entry) => entry.endsWith(".jsonl")).sort((left, right) => left.localeCompare(right));
+  const historyFiles = (await fs6.readdir(historyDir)).filter((entry) => entry.endsWith(".jsonl")).sort((left, right) => left.localeCompare(right));
   const policyActive = compactPolicy.enabled;
   const maxEntries = policyActive ? compactPolicy.max_entries : null;
   const warnings = [];
   const overThreshold = [];
   for (const fileName of historyFiles) {
-    const streamPath = path6.join(historyDir, fileName);
+    const streamPath = path7.join(historyDir, fileName);
     warnings.push(...await runActiveOnReadHooks({ path: streamPath, scope: "project" }));
     if (!policyActive) {
       continue;
     }
-    const raw = await fs5.readFile(streamPath, "utf8");
+    const raw = await fs6.readFile(streamPath, "utf8");
     let entries = 0;
     for (const line of raw.split(/\r?\n/)) {
       if (line.trim().length > 0) {
@@ -5393,16 +5591,16 @@ async function countHistoryStreams(pmRoot, compactPolicy) {
   };
 }
 function normalizeRelativePath(pmRoot, targetPath) {
-  return path6.relative(pmRoot, targetPath).replaceAll("\\", "/");
+  return path7.relative(pmRoot, targetPath).replaceAll("\\", "/");
 }
 async function listItemDocumentPaths(pmRoot, typeToFolder) {
   const folders = [...new Set(Object.values(typeToFolder))].sort((left, right) => left.localeCompare(right));
   const itemPaths = [];
   for (const folder of folders) {
-    const directoryPath = path6.join(pmRoot, folder);
+    const directoryPath = path7.join(pmRoot, folder);
     let entries = [];
     try {
-      entries = await fs5.readdir(directoryPath);
+      entries = await fs6.readdir(directoryPath);
     } catch (error) {
       if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
         continue;
@@ -5413,7 +5611,7 @@ async function listItemDocumentPaths(pmRoot, typeToFolder) {
       if (!ITEM_FILE_EXTENSIONS.some((extension) => entry.toLowerCase().endsWith(extension))) {
         continue;
       }
-      itemPaths.push(path6.join(directoryPath, entry));
+      itemPaths.push(path7.join(directoryPath, entry));
     }
   }
   itemPaths.sort((left, right) => normalizeRelativePath(pmRoot, left).localeCompare(normalizeRelativePath(pmRoot, right)));
@@ -5433,7 +5631,7 @@ async function buildIntegrityCheck(pmRoot, typeToFolder, schema) {
     const relativePath = normalizeRelativePath(pmRoot, itemPath);
     let raw = "";
     try {
-      raw = await fs5.readFile(itemPath, "utf8");
+      raw = await fs6.readFile(itemPath, "utf8");
     } catch {
       itemUnreadable.push(relativePath);
       continue;
@@ -5462,13 +5660,13 @@ async function buildIntegrityCheck(pmRoot, typeToFolder, schema) {
     }
   }
   const formatVersionScan = scanItemFormatVersions(formatVersionEntries);
-  const historyDir = path6.join(pmRoot, "history");
+  const historyDir = path7.join(pmRoot, "history");
   const historyUnreadable = [];
   const historyConflictMarkers = [];
   const historyInvalidJson = [];
   let historyFiles = [];
   try {
-    historyFiles = (await fs5.readdir(historyDir)).filter((entry) => entry.endsWith(".jsonl")).sort((left, right) => left.localeCompare(right));
+    historyFiles = (await fs6.readdir(historyDir)).filter((entry) => entry.endsWith(".jsonl")).sort((left, right) => left.localeCompare(right));
   } catch (error) {
     if (shouldReportHistoryDirectoryUnreadable(error)) {
       historyUnreadable.push("history");
@@ -5476,10 +5674,10 @@ async function buildIntegrityCheck(pmRoot, typeToFolder, schema) {
   }
   for (const fileName of historyFiles) {
     const itemId = fileName.slice(0, -".jsonl".length);
-    const historyPath = path6.join(historyDir, fileName);
+    const historyPath = path7.join(historyDir, fileName);
     let raw = "";
     try {
-      raw = await fs5.readFile(historyPath, "utf8");
+      raw = await fs6.readFile(historyPath, "utf8");
     } catch {
       historyUnreadable.push(itemId);
       continue;
@@ -6273,8 +6471,8 @@ async function probeTelemetryEndpointHealth(endpoint) {
 }
 async function buildTelemetryCheck(settings, options) {
   const globalPmRoot = resolveGlobalPmRoot(process.cwd());
-  const queuePath2 = path6.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH2);
-  const statePath = path6.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH2);
+  const queuePath2 = path7.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH2);
+  const statePath = path7.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH2);
   const queueRaw = await readFileIfExists(queuePath2);
   const queueExists = queueRaw !== null;
   const queueSizeBytes = queueRaw ? Buffer.byteLength(queueRaw, "utf8") : 0;
@@ -6605,7 +6803,7 @@ async function scanHealthDirectories(pmRoot, typeRegistry, strictDirectories) {
   const missingOptionalDirs = [];
   const hookWarnings = [];
   for (const relativeDir of [...requiredDirs, ...optionalDirs]) {
-    const directoryPath = path6.join(pmRoot, relativeDir);
+    const directoryPath = path7.join(pmRoot, relativeDir);
     hookWarnings.push(...await runActiveOnReadHooks({
       path: directoryPath,
       scope: "project"
@@ -6904,8 +7102,8 @@ var _testOnlyHealthCommand = {
 };
 
 // dist/sdk/stats.js
-import fs6 from "node:fs/promises";
-import path7 from "node:path";
+import fs7 from "node:fs/promises";
+import path8 from "node:path";
 
 // dist/core/history/history-storage-stats.js
 function shouldReplaceExtreme(candidate, current, candidateTieBreaker, currentTieBreaker, direction, tieDirection = "min") {
@@ -7012,7 +7210,7 @@ function countNonEmptyLines(raw) {
   return raw.split(/\r?\n/u).filter((line) => line.trim().length > 0).length;
 }
 async function readHistoryStreamContents(pmRoot) {
-  const historyDir = path7.join(pmRoot, "history");
+  const historyDir = path8.join(pmRoot, "history");
   if (!await pathExists(historyDir)) {
     return [];
   }
@@ -7020,10 +7218,10 @@ async function readHistoryStreamContents(pmRoot) {
     path: historyDir,
     scope: "project"
   });
-  const historyFiles = (await fs6.readdir(historyDir)).filter((entry) => entry.endsWith(".jsonl")).sort((a, b) => a.localeCompare(b));
+  const historyFiles = (await fs7.readdir(historyDir)).filter((entry) => entry.endsWith(".jsonl")).sort((a, b) => a.localeCompare(b));
   const streams = [];
   for (const file of historyFiles) {
-    const historyPath = path7.join(historyDir, file);
+    const historyPath = path8.join(historyDir, file);
     const raw = await readFileIfExists(historyPath);
     if (raw === null) {
       continue;
@@ -7096,11 +7294,11 @@ async function runStats(global, options = {}) {
 }
 
 // dist/sdk/telemetry.js
-import fs7 from "node:fs/promises";
-import path8 from "node:path";
-var TELEMETRY_QUEUE_RELATIVE_PATH3 = path8.join("runtime", "telemetry", "events.jsonl");
-var TELEMETRY_STATE_RELATIVE_PATH3 = path8.join("runtime", "telemetry", "state.json");
-var TELEMETRY_RUNTIME_RELATIVE_PATH = path8.join("runtime", "telemetry");
+import fs8 from "node:fs/promises";
+import path9 from "node:path";
+var TELEMETRY_QUEUE_RELATIVE_PATH3 = path9.join("runtime", "telemetry", "events.jsonl");
+var TELEMETRY_STATE_RELATIVE_PATH3 = path9.join("runtime", "telemetry", "state.json");
+var TELEMETRY_RUNTIME_RELATIVE_PATH = path9.join("runtime", "telemetry");
 var DEFAULT_STATS_LIMIT = 20;
 var TELEMETRY_SUBCOMMANDS = [
   "status",
@@ -7317,8 +7515,8 @@ var readTelemetryRuntimeState = async (statePath) => {
 var nullableTelemetryStateValue = (value) => value ?? null;
 var buildTelemetryStatusSummary = async (globalPmRoot) => {
   const settings = await readSettings(globalPmRoot);
-  const queuePath2 = path8.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH3);
-  const statePath = path8.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH3);
+  const queuePath2 = path9.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH3);
+  const statePath = path9.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH3);
   const queueRaw = await readFileIfExists(queuePath2);
   const queue = parseTelemetryQueue2(queueRaw);
   const runtimeState = await readTelemetryRuntimeState(statePath);
@@ -7396,9 +7594,9 @@ var runTelemetryClear = async (_options, context) => {
   if (settingsChanged) {
     await writeSettings(context.globalPmRoot, settings, "telemetry:clear");
   }
-  const telemetryRuntimePath = path8.join(context.globalPmRoot, TELEMETRY_RUNTIME_RELATIVE_PATH);
+  const telemetryRuntimePath = path9.join(context.globalPmRoot, TELEMETRY_RUNTIME_RELATIVE_PATH);
   const existed = await pathExists(telemetryRuntimePath);
-  await fs7.rm(telemetryRuntimePath, { recursive: true, force: true });
+  await fs8.rm(telemetryRuntimePath, { recursive: true, force: true });
   return {
     action: "telemetry",
     subcommand: "clear",
@@ -7422,8 +7620,8 @@ var runTelemetry = async (options, _global) => {
   const globalPmRoot = resolveGlobalPmRoot(process.cwd());
   return TELEMETRY_COMMAND_HANDLERS[subcommand](options, {
     globalPmRoot,
-    queuePath: path8.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH3),
-    statePath: path8.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH3)
+    queuePath: path9.join(globalPmRoot, TELEMETRY_QUEUE_RELATIVE_PATH3),
+    statePath: path9.join(globalPmRoot, TELEMETRY_STATE_RELATIVE_PATH3)
   });
 };
 
@@ -7887,7 +8085,7 @@ function firstPositionalToken(tokens, flagsWithValue = /* @__PURE__ */ new Set()
 import { spawn as spawn2 } from "node:child_process";
 import { cp, mkdir as mkdir2, mkdtemp, readdir as readdir2, rm as rm2 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import path9 from "node:path";
+import path10 from "node:path";
 
 // dist/core/test/item-test-run-tracking.js
 var DEFAULT_TRACKED_TEST_RUN_HISTORY_LIMIT = 20;
@@ -8875,7 +9073,7 @@ async function copyIntoSandboxIfPresent(sourcePath, targetPath, recursive = fals
   if (!await pathExists(sourcePath)) {
     return;
   }
-  await mkdir2(path9.dirname(targetPath), { recursive: true });
+  await mkdir2(path10.dirname(targetPath), { recursive: true });
   try {
     if (recursive) {
       await cp(sourcePath, targetPath, { recursive: true, force: true });
@@ -8891,9 +9089,9 @@ async function copyIntoSandboxIfPresent(sourcePath, targetPath, recursive = fals
 }
 async function seedLinkedTestSandbox(sandboxPmPath, sandboxGlobalPath, sourceRoots) {
   await copyIntoSandboxIfPresent(getSettingsPath(sourceRoots.projectPmRoot), getSettingsPath(sandboxPmPath));
-  await copyIntoSandboxIfPresent(path9.join(sourceRoots.projectPmRoot, "extensions"), path9.join(sandboxPmPath, "extensions"), true);
+  await copyIntoSandboxIfPresent(path10.join(sourceRoots.projectPmRoot, "extensions"), path10.join(sandboxPmPath, "extensions"), true);
   await copyIntoSandboxIfPresent(getSettingsPath(sourceRoots.globalPmRoot), getSettingsPath(sandboxGlobalPath));
-  await copyIntoSandboxIfPresent(path9.join(sourceRoots.globalPmRoot, "extensions"), path9.join(sandboxGlobalPath, "extensions"), true);
+  await copyIntoSandboxIfPresent(path10.join(sourceRoots.globalPmRoot, "extensions"), path10.join(sandboxGlobalPath, "extensions"), true);
 }
 async function seedLinkedTestTrackerData(sourceRoot, sandboxRoot) {
   if (!await pathExists(sourceRoot)) {
@@ -8904,8 +9102,8 @@ async function seedLinkedTestTrackerData(sourceRoot, sandboxRoot) {
     if (LINKED_TEST_TRACKER_DIRS_TO_SKIP.has(entry.name)) {
       continue;
     }
-    const sourcePath = path9.join(sourceRoot, entry.name);
-    const targetPath = path9.join(sandboxRoot, entry.name);
+    const sourcePath = path10.join(sourceRoot, entry.name);
+    const targetPath = path10.join(sandboxRoot, entry.name);
     if (entry.isDirectory()) {
       await copyIntoSandboxIfPresent(sourcePath, targetPath, true);
       continue;
@@ -8925,7 +9123,7 @@ async function countLinkedTestItemFiles(pmRoot) {
     if (!entry.isDirectory() || LINKED_TEST_ITEM_COUNT_DIRS_TO_SKIP.has(entry.name)) {
       continue;
     }
-    const folderPath = path9.join(pmRoot, entry.name);
+    const folderPath = path10.join(pmRoot, entry.name);
     let files;
     try {
       files = await readdir2(folderPath, { withFileTypes: true });
@@ -9120,10 +9318,10 @@ ${stderr}`;
 function createLinkedTestSandboxLayout(sandboxRoot) {
   return {
     root: sandboxRoot,
-    schemaProjectPmPath: path9.join(sandboxRoot, "schema", "project", ".agents", "pm"),
-    schemaGlobalPmPath: path9.join(sandboxRoot, "schema", "global"),
-    trackerProjectPmPath: path9.join(sandboxRoot, "tracker", "project", ".agents", "pm"),
-    trackerGlobalPmPath: path9.join(sandboxRoot, "tracker", "global")
+    schemaProjectPmPath: path10.join(sandboxRoot, "schema", "project", ".agents", "pm"),
+    schemaGlobalPmPath: path10.join(sandboxRoot, "schema", "global"),
+    trackerProjectPmPath: path10.join(sandboxRoot, "tracker", "project", ".agents", "pm"),
+    trackerGlobalPmPath: path10.join(sandboxRoot, "tracker", "global")
   };
 }
 async function initializeLinkedTestSandboxes(layout) {
@@ -9323,7 +9521,7 @@ async function runSingleLinkedTest(params) {
 }
 async function runLinkedTests(tests, defaultTimeoutSeconds, options) {
   const results = [];
-  const sandboxRoot = await mkdtemp(path9.join(tmpdir(), "pm-linked-test-"));
+  const sandboxRoot = await mkdtemp(path10.join(tmpdir(), "pm-linked-test-"));
   const layout = createLinkedTestSandboxLayout(sandboxRoot);
   const runLevelPmContextMode = parsePmContextMode(options?.pmContext);
   const progressMode = options?.progress === true ? "always" : "auto";
@@ -10037,10 +10235,10 @@ var runTestAll = async (options, global) => {
 import os2 from "node:os";
 
 // dist/core/test/background-runs.js
-import fs8 from "node:fs/promises";
+import fs9 from "node:fs/promises";
 import { spawn as spawn3 } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
-import path10 from "node:path";
+import path11 from "node:path";
 var BACKGROUND_RUN_ACTIVE_STATUSES = /* @__PURE__ */ new Set([
   "queued",
   "running"
@@ -10078,7 +10276,7 @@ function buildBackgroundTestRunFingerprint(kind, commandArgs, pmRoot) {
   const payload = {
     kind,
     command: normalizeCommandArgs(commandArgs),
-    pm_root: path10.resolve(pmRoot)
+    pm_root: path11.resolve(pmRoot)
   };
   return createHash("sha256").update(JSON.stringify(payload)).digest("hex");
 }
@@ -10133,8 +10331,8 @@ async function listBackgroundRunRecordPaths(pmRoot) {
   if (!await pathExists(recordsRoot)) {
     return [];
   }
-  const entries = await fs8.readdir(recordsRoot, { withFileTypes: true });
-  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => path10.join(recordsRoot, entry.name)).sort((left, right) => right.localeCompare(left));
+  const entries = await fs9.readdir(recordsRoot, { withFileTypes: true });
+  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => path11.join(recordsRoot, entry.name)).sort((left, right) => right.localeCompare(left));
 }
 function parseLinuxRssStatus(raw) {
   const match = raw.match(/^VmRSS:\s+(\d+)\s+kB$/m);
@@ -10148,7 +10346,7 @@ async function readLinuxRssBytes(pid) {
     return void 0;
   }
   try {
-    const raw = await fs8.readFile(`/proc/${pid}/status`, "utf8");
+    const raw = await fs9.readFile(`/proc/${pid}/status`, "utf8");
     return parseLinuxRssStatus(raw);
   } catch {
     return void 0;
@@ -10176,7 +10374,7 @@ async function readLinuxCpuSeconds(pid) {
     return {};
   }
   try {
-    const raw = await fs8.readFile(`/proc/${pid}/stat`, "utf8");
+    const raw = await fs9.readFile(`/proc/${pid}/stat`, "utf8");
     return parseLinuxCpuStat(raw);
   } catch {
     return {};
@@ -10312,18 +10510,18 @@ function tailLines(value, limit) {
 async function resolveBackgroundCliEntry(cwd) {
   const configured = process.env.PM_BACKGROUND_CLI_ENTRY?.trim();
   if (configured && configured.length > 0) {
-    const resolvedConfigured = path10.resolve(cwd, configured);
+    const resolvedConfigured = path11.resolve(cwd, configured);
     if (await pathExists(resolvedConfigured)) {
       return resolvedConfigured;
     }
   }
-  const distEntry = path10.resolve(cwd, "dist", "cli.js");
+  const distEntry = path11.resolve(cwd, "dist", "cli.js");
   if (await pathExists(distEntry)) {
     return distEntry;
   }
   const argvEntry = process.argv[1]?.trim();
   if (argvEntry && argvEntry.length > 0) {
-    const resolvedArgvEntry = path10.resolve(cwd, argvEntry);
+    const resolvedArgvEntry = path11.resolve(cwd, argvEntry);
     if (await pathExists(resolvedArgvEntry)) {
       return resolvedArgvEntry;
     }
@@ -10380,8 +10578,8 @@ async function startBackgroundTestRun(options) {
   const stdoutPath = getTestRunStdoutPath(options.pmRoot, runId);
   const stderrPath = getTestRunStderrPath(options.pmRoot, runId);
   const resultPath = getTestRunResultPath(options.pmRoot, runId);
-  await fs8.writeFile(stdoutPath, "", "utf8");
-  await fs8.writeFile(stderrPath, "", "utf8");
+  await fs9.writeFile(stdoutPath, "", "utf8");
+  await fs9.writeFile(stderrPath, "", "utf8");
   const record = {
     id: runId,
     kind: options.kind,
@@ -10460,7 +10658,7 @@ async function spawnBackgroundTestRunWorker(options) {
 }
 async function appendFileOrdered(queue, filePath, text) {
   await queue;
-  await fs8.appendFile(filePath, text, "utf8");
+  await fs9.appendFile(filePath, text, "utf8");
 }
 function resolvePositiveEnvInteger(name, fallback) {
   const parsed = Number.parseInt(process.env[name] ?? "", 10);
@@ -11040,10 +11238,10 @@ async function runTestRunsWorker(runId, global) {
 }
 
 // dist/sdk/governance/validate.js
-import fs9 from "node:fs/promises";
+import fs11 from "node:fs/promises";
 import { realpathSync } from "node:fs";
 import { execFile } from "node:child_process";
-import path11 from "node:path";
+import path13 from "node:path";
 import { promisify } from "node:util";
 
 // dist/core/validate/fix-planning.js
@@ -11349,8 +11547,8 @@ function buildMissingLinkedPathRows(rows, lookup) {
       });
     }
   }
-  return [...buckets.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([path12, bucket]) => ({
-    path: path12,
+  return [...buckets.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([path14, bucket]) => ({
+    path: path14,
     classification: bucket.classification,
     items: [...bucket.owners.values()].map((owner) => {
       const metadata = lookup(owner.item_id);
@@ -11380,6 +11578,199 @@ function summarizeMissingLinkedPathRows(rows) {
   return lines;
 }
 
+// dist/sdk/governance/storage-integrity.js
+import fs10 from "node:fs/promises";
+import path12 from "node:path";
+async function listItemFilesOnDisk(pmRoot, typeToFolder) {
+  const folders = [...new Set(Object.values(typeToFolder))];
+  const found = [];
+  await Promise.all(folders.map(async (folder) => {
+    let entries;
+    try {
+      entries = await fs10.readdir(path12.join(pmRoot, folder));
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      for (const extension of ITEM_FILE_EXTENSIONS) {
+        if (entry.toLowerCase().endsWith(extension)) {
+          found.push({
+            relativePath: `${folder}/${entry}`,
+            id: entry.slice(0, -extension.length)
+          });
+          break;
+        }
+      }
+    }
+  }));
+  return found.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+}
+function scanHistoryStreamContent(accumulator, raw) {
+  const { id, relativePath, liveItemIds, out } = accumulator;
+  out.scanned += 1;
+  const conflictMarker = findFirstMergeConflictMarker(raw);
+  if (conflictMarker) {
+    out.conflictMarkers.push({
+      id,
+      path: relativePath,
+      line: conflictMarker.line,
+      detail: `unresolved merge conflict marker ${conflictMarker.marker}`
+    });
+    return;
+  }
+  let latestEntry = null;
+  const lines = raw.split(/\r?\n/).map((line, index) => ({ content: line.trim(), number: index + 1 })).filter((line) => line.content.length > 0);
+  for (const line of lines) {
+    try {
+      const parsed = JSON.parse(line.content);
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new TypeError("history entry must be an object");
+      }
+      latestEntry = parsed;
+    } catch {
+      out.unparseable.push({
+        id,
+        path: relativePath,
+        line: line.number,
+        detail: "history line is not a valid JSON object"
+      });
+      return;
+    }
+  }
+  if (latestEntry === null) {
+    return;
+  }
+  if (latestEntry.op === "delete" && liveItemIds.has(id)) {
+    out.resurrected.push({
+      id,
+      deleted_at: typeof latestEntry.ts === "string" ? latestEntry.ts : "",
+      deleted_by: typeof latestEntry.author === "string" ? latestEntry.author : ""
+    });
+  }
+  if (latestEntry.op === "history_repair" && Array.isArray(latestEntry.patch) && latestEntry.patch.length > 0) {
+    out.repairReconciliations += 1;
+  }
+}
+async function scanHistoryStreams(pmRoot, liveItemIds) {
+  const out = {
+    conflictMarkers: [],
+    unparseable: [],
+    resurrected: [],
+    repairReconciliations: 0,
+    scanned: 0
+  };
+  let entries;
+  try {
+    entries = await fs10.readdir(path12.join(pmRoot, "history"));
+  } catch {
+    return out;
+  }
+  for (const entry of entries.sort((left, right) => left.localeCompare(right))) {
+    if (!entry.endsWith(".jsonl")) {
+      continue;
+    }
+    const raw = await fs10.readFile(path12.join(pmRoot, "history", entry), "utf8");
+    scanHistoryStreamContent({
+      id: entry.slice(0, -".jsonl".length),
+      relativePath: `history/${entry}`,
+      liveItemIds,
+      out
+    }, raw);
+  }
+  return out;
+}
+function describeUnparseableJson(raw) {
+  const conflictMarker = findFirstMergeConflictMarker(raw);
+  if (conflictMarker) {
+    return `unresolved merge conflict marker ${conflictMarker.marker} at line ${conflictMarker.line}`;
+  }
+  try {
+    JSON.parse(raw);
+    return null;
+  } catch (error) {
+    return `invalid JSON (${String(error)})`;
+  }
+}
+async function scanConfigFiles(pmRoot) {
+  const unparseable = [];
+  let scanned = 0;
+  const settingsRaw = await readFileIfExists(getSettingsPath(pmRoot));
+  if (settingsRaw !== null) {
+    scanned += 1;
+    const detail = describeUnparseableJson(settingsRaw);
+    if (detail !== null) {
+      unparseable.push({ path: "settings.json", detail });
+    }
+  }
+  let schemaEntries;
+  try {
+    schemaEntries = await fs10.readdir(path12.join(pmRoot, "schema"));
+  } catch {
+    return { scanned, unparseable };
+  }
+  for (const entry of schemaEntries.sort((left, right) => left.localeCompare(right))) {
+    if (!entry.endsWith(".json")) {
+      continue;
+    }
+    const raw = await fs10.readFile(path12.join(pmRoot, "schema", entry), "utf8");
+    scanned += 1;
+    const detail = describeUnparseableJson(raw);
+    if (detail !== null) {
+      unparseable.push({ path: `schema/${entry}`, detail });
+    }
+  }
+  return { scanned, unparseable };
+}
+async function scanStorageIntegrity(pmRoot, parsedItemIds, typeToFolder, itemParseOptions = {}) {
+  const itemFiles = await listItemFilesOnDisk(pmRoot, typeToFolder);
+  const idsOnDisk = new Set(itemFiles.map((file) => file.id));
+  const pathsById = /* @__PURE__ */ new Map();
+  for (const file of itemFiles) {
+    const paths = pathsById.get(file.id);
+    if (paths === void 0) {
+      pathsById.set(file.id, [file.relativePath]);
+    } else {
+      paths.push(file.relativePath);
+    }
+  }
+  const duplicateItemIds = [...pathsById.entries()].filter(([, paths]) => paths.length > 1).map(([id, paths]) => ({
+    id,
+    paths: [...paths].sort((left, right) => left.localeCompare(right))
+  })).sort((left, right) => left.id.localeCompare(right.id));
+  const unreadableItemFiles = (await Promise.all(itemFiles.map(async (file) => {
+    if (!parsedItemIds.has(file.id)) {
+      return { path: file.relativePath, id: file.id };
+    }
+    try {
+      const absolutePath = path12.join(pmRoot, file.relativePath);
+      parseItemDocument(await fs10.readFile(absolutePath, "utf8"), {
+        format: absolutePath.toLowerCase().endsWith(".md") ? "json_markdown" : "toon",
+        schema: itemParseOptions.schema,
+        extensionFieldNames: itemParseOptions.extensionFieldNames
+      });
+      return null;
+    } catch {
+      return { path: file.relativePath, id: file.id };
+    }
+  }))).filter((row) => row !== null);
+  const historyScan = await scanHistoryStreams(pmRoot, idsOnDisk);
+  const configScan = await scanConfigFiles(pmRoot);
+  return {
+    item_files_on_disk: itemFiles.length,
+    item_ids_on_disk: idsOnDisk.size,
+    parsed_items: parsedItemIds.size,
+    unreadable_item_files: unreadableItemFiles,
+    duplicate_item_ids: duplicateItemIds,
+    history_streams_scanned: historyScan.scanned,
+    history_conflict_marker_streams: historyScan.conflictMarkers,
+    history_unparseable_streams: historyScan.unparseable,
+    resurrected_items: historyScan.resurrected,
+    history_repair_reconciliations: historyScan.repairReconciliations,
+    config_files_scanned: configScan.scanned,
+    unparseable_config_files: configScan.unparseable
+  };
+}
+
 // dist/sdk/governance/validate.js
 var FILE_SCAN_DIRECTORIES = ["src", "tests", "docs"];
 var FILE_SCAN_ROOT_FILES = [
@@ -11687,16 +12078,16 @@ function resolveFileScanMode(scanMode) {
   throw new PmCliError(`Unknown --scan-mode value "${scanMode}". Supported values: ${VALIDATE_FILE_SCAN_MODES.join(", ")}.`, EXIT_CODE.USAGE);
 }
 function resolveWorkspaceRoot(pmRoot) {
-  const resolvedPmRoot = path11.resolve(pmRoot);
+  const resolvedPmRoot = path13.resolve(pmRoot);
   const normalizedPmRoot = resolvedPmRoot.replaceAll("\\", "/");
   if (normalizedPmRoot.endsWith("/.agents/pm")) {
-    return path11.dirname(path11.dirname(resolvedPmRoot));
+    return path13.dirname(path13.dirname(resolvedPmRoot));
   }
-  const resolvedCwd = path11.resolve(process.cwd());
+  const resolvedCwd = path13.resolve(process.cwd());
   const canonicalPmRoot = realpathForWorkspaceRoot(resolvedPmRoot);
   const canonicalCwd = realpathForWorkspaceRoot(resolvedCwd);
-  const relativeFromPmRoot = path11.relative(canonicalPmRoot, canonicalCwd);
-  const cwdInsidePmRoot = relativeFromPmRoot.length === 0 || !relativeFromPmRoot.startsWith("..") && !path11.isAbsolute(relativeFromPmRoot);
+  const relativeFromPmRoot = path13.relative(canonicalPmRoot, canonicalCwd);
+  const cwdInsidePmRoot = relativeFromPmRoot.length === 0 || !relativeFromPmRoot.startsWith("..") && !path13.isAbsolute(relativeFromPmRoot);
   if (cwdInsidePmRoot) {
     return resolvedPmRoot;
   }
@@ -11706,14 +12097,14 @@ function realpathForWorkspaceRoot(inputPath) {
   try {
     return realpathSync.native(inputPath);
   } catch {
-    return path11.resolve(inputPath);
+    return path13.resolve(inputPath);
   }
 }
 async function listFilesRecursive(basePath, relativePath, output) {
-  const targetDirectory = relativePath.length > 0 ? path11.join(basePath, relativePath) : basePath;
+  const targetDirectory = relativePath.length > 0 ? path13.join(basePath, relativePath) : basePath;
   let entries;
   try {
-    entries = await fs9.readdir(targetDirectory, { withFileTypes: true });
+    entries = await fs11.readdir(targetDirectory, { withFileTypes: true });
   } catch (error) {
     if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
       return;
@@ -11724,7 +12115,7 @@ async function listFilesRecursive(basePath, relativePath, output) {
     if (entry.name.startsWith(".")) {
       continue;
     }
-    const childRelative = relativePath.length > 0 ? path11.join(relativePath, entry.name) : entry.name;
+    const childRelative = relativePath.length > 0 ? path13.join(relativePath, entry.name) : entry.name;
     if (entry.isDirectory()) {
       if (DIRECTORY_IGNORE_SET.has(entry.name)) {
         continue;
@@ -11744,9 +12135,9 @@ async function collectDefaultProjectFileCandidates(workspaceRoot) {
     await listFilesRecursive(workspaceRoot, directory, discovered);
   }
   for (const candidate of FILE_SCAN_ROOT_FILES) {
-    const absolute = path11.join(workspaceRoot, candidate);
+    const absolute = path13.join(workspaceRoot, candidate);
     try {
-      const stats = await fs9.stat(absolute);
+      const stats = await fs11.stat(absolute);
       if (stats.isFile()) {
         discovered.push(normalizeRelativePath2(candidate));
       }
@@ -11776,7 +12167,7 @@ function resolvePmInternalCandidatePrefixes(pmRoot, workspaceRoot) {
   if (configuredDefault.length > 0) {
     prefixes.add(configuredDefault);
   }
-  const relativePmRoot = normalizeRelativeDirectoryPath(path11.relative(workspaceRoot, pmRoot));
+  const relativePmRoot = normalizeRelativeDirectoryPath(path13.relative(workspaceRoot, pmRoot));
   if (relativePmRoot.length > 0 && !relativePmRoot.startsWith("..")) {
     prefixes.add(relativePmRoot);
   }
@@ -11895,6 +12286,9 @@ function resolveRequestedChecks(options) {
   if (options.checkCommandReferences) {
     requested.add("command_references");
   }
+  if (options.checkStorageIntegrity) {
+    requested.add("storage_integrity");
+  }
   if (requested.size === 0) {
     if (options.autoFix) {
       requested.add("metadata");
@@ -11912,6 +12306,7 @@ function resolveRequestedChecks(options) {
       requested.add("command_references");
       requested.add("history_drift");
       requested.add("format_version");
+      requested.add("storage_integrity");
     }
     return requested;
   }
@@ -12256,30 +12651,30 @@ function resolveLifecycleDependencyCycleSamplePath(component, graph) {
     return [start, start];
   }
   const componentSet = new Set(component);
-  const path12 = [start];
+  const path14 = [start];
   const visited = /* @__PURE__ */ new Set([start]);
   const search = (current) => {
     const neighbors = (graph.get(current) ?? []).filter((candidate) => componentSet.has(candidate));
     for (const next of neighbors) {
-      if (next === start && path12.length > 1) {
-        path12.push(start);
+      if (next === start && path14.length > 1) {
+        path14.push(start);
         return true;
       }
       if (visited.has(next)) {
         continue;
       }
       visited.add(next);
-      path12.push(next);
+      path14.push(next);
       if (search(next)) {
         return true;
       }
-      path12.pop();
+      path14.pop();
       visited.delete(next);
     }
     return false;
   };
   if (search(start)) {
-    return [...path12];
+    return [...path14];
   }
   return [...component, start];
 }
@@ -12537,12 +12932,12 @@ function linkedArtifactPathExceedsFilesystemLimits(artifactPath) {
   return normalized.length > LINKED_ARTIFACT_MAX_PATH_LENGTH || normalized.split(/[\\/]/).some((segment) => segment.length > LINKED_ARTIFACT_MAX_SEGMENT_LENGTH);
 }
 async function linkedArtifactIsMissing(workspaceRoot, artifactPath) {
-  const absolutePath = path11.isAbsolute(artifactPath) ? artifactPath : path11.resolve(workspaceRoot, artifactPath);
+  const absolutePath = path13.isAbsolute(artifactPath) ? artifactPath : path13.resolve(workspaceRoot, artifactPath);
   if (linkedArtifactPathExceedsFilesystemLimits(absolutePath)) {
     return false;
   }
   try {
-    const stats = await fs9.stat(absolutePath);
+    const stats = await fs11.stat(absolutePath);
     return !stats.isFile() && !stats.isDirectory();
   } catch (error) {
     const code = typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
@@ -13036,6 +13431,49 @@ var _testOnlyValidateCommand = {
   summarizeDuplicateIssueCodes,
   toMeaningfulString
 };
+async function buildStorageIntegrityCheck(pmRoot, items, typeToFolder, settings) {
+  const scan = await scanStorageIntegrity(pmRoot, new Set(items.map((item) => item.id)), typeToFolder, {
+    schema: settings.schema,
+    extensionFieldNames: collectRegisteredItemFieldNames(getActiveExtensionRegistrations())
+  });
+  const warnings = [];
+  if (scan.unreadable_item_files.length > 0) {
+    warnings.push(`validate_storage_unreadable_items:${scan.unreadable_item_files.length}`);
+  }
+  if (scan.duplicate_item_ids.length > 0) {
+    warnings.push(`validate_storage_duplicate_item_ids:${scan.duplicate_item_ids.length}`);
+  }
+  if (scan.history_conflict_marker_streams.length > 0) {
+    warnings.push(`validate_storage_history_conflict_markers:${scan.history_conflict_marker_streams.length}`);
+  }
+  if (scan.history_unparseable_streams.length > 0) {
+    warnings.push(`validate_storage_unparseable_history:${scan.history_unparseable_streams.length}`);
+  }
+  if (scan.resurrected_items.length > 0) {
+    warnings.push(`validate_storage_resurrected_items:${scan.resurrected_items.length}`);
+  }
+  if (scan.unparseable_config_files.length > 0) {
+    warnings.push(`validate_storage_unparseable_config:${scan.unparseable_config_files.length}`);
+  }
+  const errorCount = warnings.length;
+  const fenceAudit = await auditMergeAttributeFence(pmRoot, [
+    ...new Set(Object.values(typeToFolder))
+  ]);
+  if (fenceAudit.status === "drift") {
+    warnings.push(`validate_merge_fence_drift:${fenceAudit.missing_patterns.length + fenceAudit.stale_patterns.length}`);
+  }
+  return {
+    check: {
+      name: "storage_integrity",
+      // Corruption findings fail the check; fence drift alone is a warning —
+      // the workspace data is intact, but future merges of uncovered paths
+      // would fall back to git's default text driver.
+      status: errorCount > 0 ? "error" : warnings.length > 0 ? "warn" : "ok",
+      details: { ...scan, merge_fence: fenceAudit }
+    },
+    warnings
+  };
+}
 function recordValidateCheck(state, built, fixHintsEnabled) {
   if (fixHintsEnabled) {
     attachValidateFixHints(built.check, built.warnings);
@@ -13086,6 +13524,9 @@ async function executeRequestedValidateChecks(params) {
   if (params.requestedChecks.has("format_version")) {
     recordValidateCheck(state, buildFormatVersionCheck(params.items, fullDiagnostics), fixHintsEnabled);
   }
+  if (params.requestedChecks.has("storage_integrity")) {
+    recordValidateCheck(state, await buildStorageIntegrityCheck(params.pmRoot, params.items, resolveItemTypeRegistry(params.settings, getActiveExtensionRegistrations()).type_to_folder, params.settings), fixHintsEnabled);
+  }
   return state;
 }
 function planValidateFixes(options, state, settings) {
@@ -13223,6 +13664,7 @@ export {
   runMeet,
   runEvent,
   runRemind,
+  runWorkspaceTransactionGc,
   runGc,
   inspectHistoryAuthorStream,
   scanHistoryAuthorAttribution,
@@ -13251,6 +13693,6 @@ export {
   runValidate2,
   resolveStartTaskInProgressStatus
 };
-//# sourceMappingURL=chunk-ODEIDKGW.js.map
+//# sourceMappingURL=chunk-3LPFHE3P.js.map
 
-//# debugId=b111adf0-7ac6-5083-9fb7-c9a093abf43b
+//# debugId=4c96022d-a7de-55fa-835e-c7cf3a43e0b8