agent-trajectories 0.5.7 → 0.5.9

package/dist/cli/index.js

@@ -404,17 +404,23 @@ function abandonTrajectory(trajectory, reason) {
 }
 
 // src/storage/file.ts
-import { randomUUID } from "crypto";
 import { existsSync } from "fs";
 import {
   mkdir,
   readFile,
   readdir,
   rename,
-  unlink,
+  rm,
   writeFile
 } from "fs/promises";
-import { join } from "path";
+import {
+  basename,
+  dirname,
+  isAbsolute,
+  join,
+  relative,
+  resolve
+} from "path";
 
 // src/export/markdown.ts
 function exportToMarkdown(trajectory) {
@@ -577,6 +583,10 @@ function extractDecisions(trajectory) {
 }
 
 // src/storage/file.ts
+var TRAJECTORY_FILE = "trajectory.json";
+var SUMMARY_FILE = "summary.md";
+var COMPACTION_FILE = "compaction.json";
+var LEGACY_COMPACTION_SUFFIX = ".compaction.json";
 function expandPath(path2) {
   if (path2.startsWith("~")) {
     return join(process.env.HOME ?? "", path2.slice(1));
@@ -594,22 +604,26 @@ function getSearchPaths() {
   }
   return [join(process.cwd(), ".trajectories")];
 }
-var indexLocks = /* @__PURE__ */ new Map();
-function withIndexLock(path2, task) {
-  const prev = indexLocks.get(path2) ?? Promise.resolve();
-  const next = prev.then(task, task);
-  indexLocks.set(
-    path2,
-    next.catch(() => void 0)
-  );
-  return next;
+function describeReadFailure(reason, error) {
+  if (reason === "schema_violation" && error && typeof error === "object" && "issues" in error) {
+    const issues = error.issues ?? [];
+    if (issues.length > 0) {
+      const first = issues[0];
+      const where = first.path.length > 0 ? first.path.join(".") : "root";
+      const extra = issues.length > 1 ? ` (+${issues.length - 1} more)` : "";
+      return `${where}: ${first.message}${extra}`;
+    }
+    return "schema validation failed";
+  }
+  if (error instanceof Error) return error.message;
+  return String(error);
 }
 var FileStorage = class {
   baseDir;
   trajectoriesDir;
   activeDir;
   completedDir;
-  indexPath;
+  lastReconcileSummary;
   constructor(baseDir) {
     this.baseDir = baseDir ?? process.cwd();
     const dataDir = process.env.TRAJECTORIES_DATA_DIR;
@@ -620,7 +634,6 @@ var FileStorage = class {
     }
     this.activeDir = join(this.trajectoriesDir, "active");
     this.completedDir = join(this.trajectoriesDir, "completed");
-    this.indexPath = join(this.trajectoriesDir, "index.json");
   }
   /**
    * Initialize storage directories
@@ -629,28 +642,22 @@ var FileStorage = class {
     await mkdir(this.trajectoriesDir, { recursive: true });
     await mkdir(this.activeDir, { recursive: true });
     await mkdir(this.completedDir, { recursive: true });
-    if (!existsSync(this.indexPath)) {
-      await withIndexLock(this.indexPath, async () => {
-        if (!existsSync(this.indexPath)) {
-          await this.saveIndex(this.emptyIndex());
-        }
-      });
-    }
+    await this.migrateLegacyIndexCompactionMarkers();
+    await rm(join(this.trajectoriesDir, "index.json"), { force: true });
     await this.reconcileIndex();
   }
   /**
-   * Scan active/ and completed/ recursively and add any trajectory files
-   * missing from the index. Existing entries are preserved — reconcile
-   * only adds, never removes.
+   * Scan active/ and completed/ recursively and report trajectory files
+   * that can be loaded plus files that should be surfaced by doctor.
    *
    * Handles three on-disk layouts in completed/:
    *   - flat:      completed/{id}.json         (legacy workforce data)
-   *   - monthly:   completed/YYYY-MM/{id}.json (current save() writes)
+   *   - monthly:   completed/YYYY-MM/{id}.json (legacy monthly layout)
+   *   - directory: completed/YYYY-MM/{id}/trajectory.json (current layout)
    *   - nested:    completed/.../{id}.json     (defensive — any depth)
    *
-   * Returns a ReconcileSummary so tests and CLI wrappers can observe
-   * outcomes without parsing logs. Only writes the index if anything was
-   * added.
+   * The method name is kept for callers such as `trail doctor`, but no
+   * shared index file is written.
    */
   async reconcileIndex() {
     const summary = {
@@ -659,55 +666,32 @@ var FileStorage = class {
       alreadyIndexed: 0,
       skippedMalformedJson: 0,
       skippedSchemaViolation: 0,
-      skippedIoError: 0
+      skippedIoError: 0,
+      failures: []
     };
-    await withIndexLock(this.indexPath, async () => {
-      const index = await this.loadIndex();
-      const before = Object.keys(index.trajectories).length;
-      const discovered = [];
-      try {
-        const activeFiles = await readdir(this.activeDir);
-        for (const file of activeFiles) {
-          if (!file.endsWith(".json")) continue;
-          discovered.push(join(this.activeDir, file));
-        }
-      } catch (error) {
-        if (error.code !== "ENOENT") throw error;
-      }
-      await this.walkJsonFilesInto(this.completedDir, discovered);
-      for (const filePath of discovered) {
-        summary.scanned += 1;
-        const result = await this.readTrajectoryFile(filePath);
-        if (!result.ok) {
-          if (result.reason === "malformed_json") {
-            summary.skippedMalformedJson += 1;
-          } else if (result.reason === "schema_violation") {
-            summary.skippedSchemaViolation += 1;
-          } else {
-            summary.skippedIoError += 1;
-          }
-          continue;
-        }
-        const trajectory = result.trajectory;
-        if (index.trajectories[trajectory.id]) {
-          summary.alreadyIndexed += 1;
-          continue;
+    const discovered = await this.listTrajectoryFiles();
+    for (const filePath of discovered) {
+      summary.scanned += 1;
+      const result = await this.readTrajectoryFile(filePath);
+      if (!result.ok) {
+        if (result.reason === "malformed_json") {
+          summary.skippedMalformedJson += 1;
+        } else if (result.reason === "schema_violation") {
+          summary.skippedSchemaViolation += 1;
+        } else {
+          summary.skippedIoError += 1;
         }
-        index.trajectories[trajectory.id] = {
-          title: trajectory.task.title,
-          status: trajectory.status,
-          startedAt: trajectory.startedAt,
-          completedAt: trajectory.completedAt,
-          path: filePath
-        };
-        summary.added += 1;
-      }
-      if (Object.keys(index.trajectories).length !== before) {
-        await this.saveIndex(index);
+        summary.failures.push({
+          path: result.path,
+          reason: result.reason,
+          message: describeReadFailure(result.reason, result.error)
+        });
+        continue;
       }
-    });
+      summary.added += 1;
+    }
     const hadSkips = summary.skippedMalformedJson + summary.skippedSchemaViolation + summary.skippedIoError > 0;
-    if (summary.added > 0 || hadSkips) {
+    if (hadSkips) {
       const parts = [`reconciled ${summary.added}/${summary.scanned}`];
       if (summary.skippedMalformedJson > 0) {
         parts.push(`malformed: ${summary.skippedMalformedJson}`);
@@ -720,10 +704,76 @@ var FileStorage = class {
       }
       console.warn(`[trajectories] ${parts.join(", ")}`);
     }
+    this.lastReconcileSummary = summary;
     return summary;
   }
   /**
-   * Recursively collect all .json file paths under `dir` into `out`.
+   * Returns the most recent reconcile summary, if any. Lets the CLI
+   * inspect the failures collected during `initialize()` without having
+   * to re-walk the directory tree (and re-emit the warn line).
+   */
+  getLastReconcileSummary() {
+    return this.lastReconcileSummary;
+  }
+  /**
+   * Move trajectory files that fail to load into `.trajectories/invalid/`
+   * so reconcile no longer scans them. Only quarantines parse and schema
+   * failures — transient io_error failures are left in place because the
+   * file may load fine on the next attempt.
+   *
+   * Returns the list of files that were moved (with their original paths
+   * and the destination directory) so the caller can report what changed.
+   */
+  async quarantineInvalid() {
+    const summary = await this.reconcileIndex();
+    const targetDir = join(this.trajectoriesDir, "invalid");
+    const candidates = summary.failures.filter((f) => f.reason !== "io_error");
+    if (candidates.length === 0) {
+      return { moved: [], targetDir };
+    }
+    await mkdir(targetDir, { recursive: true });
+    const moved = [];
+    for (const failure of candidates) {
+      const dest = await this.resolveQuarantineDest(failure.path, targetDir);
+      try {
+        await mkdir(dirname(dest), { recursive: true });
+        await rename(failure.path, dest);
+        moved.push(failure);
+      } catch (error) {
+        console.warn(
+          `[trajectories] failed to quarantine ${failure.path}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    return { moved, targetDir };
+  }
+  /**
+   * Pick a destination path under `targetDir` for a quarantined file.
+   *
+   * Preserves the file's relative location under the trajectories root
+   * (e.g. `completed/2026-04/foo.json` → `invalid/completed/2026-04/foo.json`)
+   * so two invalid files that share a basename across `active/` and
+   * `completed/` don't collapse onto each other and silently overwrite.
+   *
+   * Falls back to a numeric-suffix scheme for paths that live outside
+   * the trajectories directory or that, after relative resolution, would
+   * still collide with something already quarantined.
+   */
+  async resolveQuarantineDest(sourcePath, targetDir) {
+    const rel = relative(this.trajectoriesDir, sourcePath);
+    const safeRel = rel && !rel.startsWith("..") && !isAbsolute(rel) ? rel : basename(sourcePath);
+    let dest = join(targetDir, safeRel);
+    if (!existsSync(dest)) return dest;
+    const ext = safeRel.endsWith(".json") ? ".json" : "";
+    const stem = ext ? safeRel.slice(0, -ext.length) : safeRel;
+    for (let i = 1; i < 1e3; i += 1) {
+      dest = join(targetDir, `${stem}.${i}${ext}`);
+      if (!existsSync(dest)) return dest;
+    }
+    return dest;
+  }
+  /**
+   * Recursively collect trajectory JSON file paths under `dir` into `out`.
    * Silently treats a missing directory as empty.
    */
   async walkJsonFilesInto(dir, out) {
@@ -738,7 +788,7 @@ var FileStorage = class {
       const entryPath = join(dir, entry.name);
       if (entry.isDirectory()) {
         await this.walkJsonFilesInto(entryPath, out);
-      } else if (entry.isFile() && entry.name.endsWith(".json")) {
+      } else if (entry.isFile() && isTrajectoryJsonFile(entry.name)) {
         out.push(entryPath);
       }
     }
@@ -762,56 +812,43 @@ var FileStorage = class {
     }
     const trajectory = validation.data;
     const isCompleted = trajectory.status === "completed" || trajectory.status === "abandoned";
-    let filePath;
+    const existingPaths = await this.findTrajectoryFilePaths(trajectory.id);
+    let trajectoryDir;
     if (isCompleted) {
       const date = new Date(trajectory.completedAt ?? trajectory.startedAt);
       const monthDir = join(
         this.completedDir,
         `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}`
       );
-      await mkdir(monthDir, { recursive: true });
-      filePath = join(monthDir, `${trajectory.id}.json`);
-      const activePath = join(this.activeDir, `${trajectory.id}.json`);
-      if (existsSync(activePath)) {
-        await unlink(activePath);
-      }
-      const mdPath = join(monthDir, `${trajectory.id}.md`);
-      const markdown = exportToMarkdown(trajectory);
-      await writeFile(mdPath, markdown, "utf-8");
+      trajectoryDir = join(monthDir, trajectory.id);
     } else {
-      filePath = join(this.activeDir, `${trajectory.id}.json`);
+      trajectoryDir = join(this.activeDir, trajectory.id);
+    }
+    const filePath = join(trajectoryDir, TRAJECTORY_FILE);
+    await this.removeTrajectoryFiles(existingPaths, filePath);
+    await mkdir(trajectoryDir, { recursive: true });
+    if (isCompleted) {
+      const markdown = exportToMarkdown(trajectory);
+      await writeFile(join(trajectoryDir, SUMMARY_FILE), markdown, "utf-8");
     }
     await writeFile(filePath, JSON.stringify(trajectory, null, 2), "utf-8");
-    await this.updateIndex(trajectory, filePath);
   }
   /**
    * Get a trajectory by ID
    */
   async get(id) {
-    const activePath = join(this.activeDir, `${id}.json`);
-    if (existsSync(activePath)) {
-      return this.readTrajectoryOrNull(activePath);
-    }
-    const index = await this.loadIndex();
-    const entry = index.trajectories[id];
-    if (entry?.path && existsSync(entry.path)) {
-      return this.readTrajectoryOrNull(entry.path);
-    }
-    try {
-      const flatPath = join(this.completedDir, `${id}.json`);
-      if (existsSync(flatPath)) {
-        return this.readTrajectoryOrNull(flatPath);
-      }
-      const months = await readdir(this.completedDir);
-      for (const month of months) {
-        const filePath = join(this.completedDir, month, `${id}.json`);
-        if (existsSync(filePath)) {
-          return this.readTrajectoryOrNull(filePath);
-        }
+    for (const filePath of this.getActiveCandidatePaths(id)) {
+      if (!existsSync(filePath)) continue;
+      const trajectory = await this.readTrajectoryOrNull(filePath);
+      if (trajectory?.id === id) {
+        return trajectory;
       }
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        console.error("Error searching completed trajectories:", error);
+    }
+    const paths = await this.findTrajectoryFilePaths(id);
+    for (const filePath of paths) {
+      const trajectory = await this.readTrajectoryOrNull(filePath);
+      if (trajectory?.id === id) {
+        return trajectory;
       }
     }
     return null;
@@ -820,107 +857,61 @@ var FileStorage = class {
    * Get the currently active trajectory
    */
   async getActive() {
-    try {
-      const files = await readdir(this.activeDir);
-      const jsonFiles = files.filter((f) => f.endsWith(".json"));
-      if (jsonFiles.length === 0) {
-        return null;
-      }
-      let mostRecent = null;
-      let mostRecentTime = 0;
-      for (const file of jsonFiles) {
-        const trajectory = await this.readTrajectoryOrNull(
-          join(this.activeDir, file)
-        );
-        if (trajectory) {
-          const startTime = new Date(trajectory.startedAt).getTime();
-          if (startTime > mostRecentTime) {
-            mostRecentTime = startTime;
-            mostRecent = trajectory;
-          }
-        }
-      }
-      return mostRecent;
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return null;
-      }
-      console.error("Error reading active trajectories:", error);
+    const activeFiles = await this.collectTrajectoryFiles(this.activeDir);
+    if (activeFiles.length === 0) {
       return null;
     }
+    let mostRecent = null;
+    let mostRecentTime = 0;
+    for (const filePath of activeFiles) {
+      const trajectory = await this.readTrajectoryOrNull(filePath);
+      if (trajectory?.status !== "active") continue;
+      const startTime = new Date(trajectory.startedAt).getTime();
+      if (startTime > mostRecentTime) {
+        mostRecentTime = startTime;
+        mostRecent = trajectory;
+      }
+    }
+    return mostRecent;
   }
   /**
    * List trajectories with optional filtering
    */
   async list(query) {
-    const index = await this.loadIndex();
-    let entries = Object.entries(index.trajectories);
+    let trajectories = await this.loadAllTrajectories();
     if (query.status) {
-      entries = entries.filter(([, entry]) => entry.status === query.status);
+      trajectories = trajectories.filter((t) => t.status === query.status);
     }
     if (query.since) {
       const sinceTime = new Date(query.since).getTime();
-      entries = entries.filter(
-        ([, entry]) => new Date(entry.startedAt).getTime() >= sinceTime
+      trajectories = trajectories.filter(
+        (trajectory) => new Date(trajectory.startedAt).getTime() >= sinceTime
       );
     }
     if (query.until) {
       const untilTime = new Date(query.until).getTime();
-      entries = entries.filter(
-        ([, entry]) => new Date(entry.startedAt).getTime() <= untilTime
+      trajectories = trajectories.filter(
+        (trajectory) => new Date(trajectory.startedAt).getTime() <= untilTime
       );
     }
     const sortBy = query.sortBy ?? "startedAt";
     const sortOrder = query.sortOrder ?? "desc";
-    entries.sort((a, b) => {
-      const aVal = a[1][sortBy] ?? "";
-      const bVal = b[1][sortBy] ?? "";
+    trajectories.sort((a, b) => {
+      const aVal = this.getSortValue(a, sortBy);
+      const bVal = this.getSortValue(b, sortBy);
       const cmp = String(aVal).localeCompare(String(bVal));
       return sortOrder === "asc" ? cmp : -cmp;
     });
     const offset = query.offset ?? 0;
     const limit = query.limit ?? 500;
-    entries = entries.slice(offset, offset + limit);
-    return Promise.all(
-      entries.map(async ([id, entry]) => {
-        const trajectory = await this.get(id);
-        return {
-          id,
-          title: entry.title,
-          status: entry.status,
-          startedAt: entry.startedAt,
-          completedAt: entry.completedAt,
-          confidence: trajectory?.retrospective?.confidence,
-          chapterCount: trajectory?.chapters.length ?? 0,
-          decisionCount: trajectory?.chapters.reduce(
-            (count, chapter) => count + chapter.events.filter((e) => e.type === "decision").length,
-            0
-          ) ?? 0
-        };
-      })
-    );
+    trajectories = trajectories.slice(offset, offset + limit);
+    return trajectories.map((trajectory) => this.toSummary(trajectory));
   }
   /**
    * Delete a trajectory
    */
   async delete(id) {
-    const activePath = join(this.activeDir, `${id}.json`);
-    if (existsSync(activePath)) {
-      await unlink(activePath);
-    }
-    await withIndexLock(this.indexPath, async () => {
-      const index = await this.loadIndex();
-      const entry = index.trajectories[id];
-      if (entry?.path && existsSync(entry.path)) {
-        await unlink(entry.path);
-        const mdPath = entry.path.replace(".json", ".md");
-        if (existsSync(mdPath)) {
-          await unlink(mdPath);
-        }
-      }
-      delete index.trajectories[id];
-      await this.saveIndex(index);
-    });
+    await this.deleteWithSummary(id);
   }
   /**
    * Search trajectories by text
@@ -953,12 +944,395 @@ var FileStorage = class {
     }
     return matches;
   }
+  /**
+   * Mark a trajectory as compacted without writing to a shared index.
+   */
+  async markCompacted(id, compactedInto) {
+    const markedIds = await this.markCompactedMany([id], compactedInto);
+    return markedIds.has(id);
+  }
+  /**
+   * Mark multiple trajectories as compacted with one filesystem scan.
+   */
+  async markCompactedMany(ids, compactedInto) {
+    const pathsById = await this.findTrajectoryFilePathsForIds(ids);
+    const markedIds = /* @__PURE__ */ new Set();
+    const compactedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const writes = [];
+    for (const [id, paths] of pathsById.entries()) {
+      if (paths.length === 0) {
+        continue;
+      }
+      markedIds.add(id);
+      const marker = {
+        trajectoryId: id,
+        compactedInto,
+        compactedAt
+      };
+      for (const filePath of paths) {
+        writes.push(
+          writeFile(
+            this.getCompactionMarkerPath(filePath, id),
+            JSON.stringify(marker, null, 2),
+            "utf-8"
+          )
+        );
+      }
+    }
+    await Promise.all(writes);
+    return markedIds;
+  }
+  /**
+   * Return trajectory IDs that have a per-trajectory compaction marker.
+   */
+  async getCompactedTrajectoryIds() {
+    const markerPaths = await this.listCompactionMarkerFiles();
+    const compactedIds = /* @__PURE__ */ new Set();
+    for (const markerPath of markerPaths) {
+      try {
+        const marker = JSON.parse(
+          await readFile(markerPath, "utf-8")
+        );
+        const trajectoryId = typeof marker.trajectoryId === "string" ? marker.trajectoryId : this.getTrajectoryIdFromCompactionMarkerPath(markerPath);
+        if (trajectoryId && typeof marker.compactedInto === "string") {
+          compactedIds.add(trajectoryId);
+        }
+      } catch {
+      }
+    }
+    return compactedIds;
+  }
+  /**
+   * Delete a trajectory and return file counts for CLI reporting.
+   */
+  async deleteWithSummary(id) {
+    return this.deleteManyWithSummary([id]);
+  }
+  /**
+   * Delete multiple trajectories with one filesystem scan.
+   */
+  async deleteManyWithSummary(ids) {
+    const summary = {
+      removedTrajectories: 0,
+      deletedJsonFiles: 0,
+      deletedMarkdownFiles: 0,
+      deletedTraceFiles: 0,
+      deletedCompactionFiles: 0
+    };
+    const pathsById = await this.findTrajectoryFilePathsForIds(ids);
+    const deletedPaths = /* @__PURE__ */ new Set();
+    for (const paths of pathsById.values()) {
+      for (const filePath of paths) {
+        if (deletedPaths.has(filePath)) {
+          continue;
+        }
+        deletedPaths.add(filePath);
+        await this.removeTrajectoryFile(filePath, summary);
+      }
+    }
+    return summary;
+  }
   /**
    * Close storage (no-op for file storage)
    */
   async close() {
   }
   // Private helpers
+  getActiveCandidatePaths(id) {
+    if (!isSafeTrajectoryId(id)) {
+      return [];
+    }
+    return [
+      join(this.activeDir, id, TRAJECTORY_FILE),
+      // Legacy layout from v0.5.x and earlier.
+      join(this.activeDir, `${id}.json`)
+    ];
+  }
+  async loadAllTrajectories() {
+    const files = await this.listTrajectoryFiles();
+    const trajectories = /* @__PURE__ */ new Map();
+    for (const filePath of files) {
+      const trajectory = await this.readTrajectoryOrNull(filePath);
+      if (!trajectory) {
+        continue;
+      }
+      const current = trajectories.get(trajectory.id);
+      if (!current || this.isNewerTrajectory(trajectory, current)) {
+        trajectories.set(trajectory.id, trajectory);
+      }
+    }
+    return Array.from(trajectories.values());
+  }
+  async listTrajectoryFiles() {
+    const [activeFiles, completedFiles] = await Promise.all([
+      this.collectTrajectoryFiles(this.activeDir),
+      this.collectTrajectoryFiles(this.completedDir)
+    ]);
+    return [...activeFiles, ...completedFiles];
+  }
+  async collectTrajectoryFiles(dir) {
+    const files = [];
+    await this.walkJsonFilesInto(dir, files);
+    return files;
+  }
+  async findTrajectoryFilePaths(id) {
+    const pathsById = await this.findTrajectoryFilePathsForIds([id]);
+    return pathsById.get(id) ?? [];
+  }
+  async findTrajectoryFilePathsForIds(ids) {
+    const targetIds = new Set(Array.from(ids).filter(isSafeTrajectoryId));
+    const pathsById = new Map(
+      Array.from(targetIds).map((id) => [id, []])
+    );
+    if (targetIds.size === 0) {
+      return pathsById;
+    }
+    const allFiles = await this.listTrajectoryFiles();
+    for (const filePath of allFiles) {
+      const trajectoryId = this.getTrajectoryIdFromPath(filePath);
+      if (!trajectoryId || !targetIds.has(trajectoryId)) {
+        continue;
+      }
+      pathsById.get(trajectoryId)?.push(filePath);
+    }
+    return pathsById;
+  }
+  getTrajectoryIdFromPath(filePath) {
+    if (basename(filePath) === TRAJECTORY_FILE) {
+      const id = basename(dirname(filePath));
+      return isSafeTrajectoryId(id) ? id : void 0;
+    }
+    const name = basename(filePath);
+    if (name.endsWith(".json")) {
+      const id = name.slice(0, -".json".length);
+      return isSafeTrajectoryId(id) ? id : void 0;
+    }
+    return void 0;
+  }
+  async removeTrajectoryFiles(paths, exceptPath) {
+    const summary = this.emptyDeleteSummary();
+    for (const filePath of paths) {
+      if (filePath === exceptPath) {
+        continue;
+      }
+      await this.removeTrajectoryFile(filePath, summary);
+    }
+  }
+  async removeTrajectoryFile(filePath, summary) {
+    if (basename(filePath) === TRAJECTORY_FILE) {
+      const trajectoryDir = dirname(filePath);
+      await this.countDirectoryTrajectoryFiles(trajectoryDir, summary);
+      await this.removeFileIfExists(
+        join(dirname(trajectoryDir), `${basename(trajectoryDir)}.trace.json`),
+        "trace",
+        summary
+      );
+      await rm(trajectoryDir, { recursive: true, force: true });
+      return;
+    }
+    await this.removeFileIfExists(filePath, "json", summary);
+    await this.removeFileIfExists(
+      getMarkdownOutputPath(filePath),
+      "markdown",
+      summary
+    );
+    await this.removeFileIfExists(
+      getTraceOutputPath(filePath),
+      "trace",
+      summary
+    );
+    await this.removeFileIfExists(
+      getLegacyCompactionMarkerPath(filePath),
+      "compaction",
+      summary
+    );
+  }
+  async countDirectoryTrajectoryFiles(trajectoryDir, summary) {
+    await this.countFileIfExists(
+      join(trajectoryDir, TRAJECTORY_FILE),
+      "json",
+      summary
+    );
+    await this.countFileIfExists(
+      join(trajectoryDir, SUMMARY_FILE),
+      "markdown",
+      summary
+    );
+    await this.countFileIfExists(
+      join(trajectoryDir, `${basename(trajectoryDir)}.trace.json`),
+      "trace",
+      summary
+    );
+    await this.countFileIfExists(
+      join(trajectoryDir, "trace.json"),
+      "trace",
+      summary
+    );
+    await this.countFileIfExists(
+      join(trajectoryDir, COMPACTION_FILE),
+      "compaction",
+      summary
+    );
+  }
+  async removeFileIfExists(path2, kind, summary) {
+    if (!existsSync(path2)) {
+      return;
+    }
+    await rm(path2, { force: true });
+    this.incrementDeleteSummary(kind, summary);
+  }
+  async countFileIfExists(path2, kind, summary) {
+    if (existsSync(path2)) {
+      this.incrementDeleteSummary(kind, summary);
+    }
+  }
+  incrementDeleteSummary(kind, summary) {
+    if (kind === "json") {
+      summary.deletedJsonFiles += 1;
+      summary.removedTrajectories += 1;
+    } else if (kind === "markdown") {
+      summary.deletedMarkdownFiles += 1;
+    } else if (kind === "trace") {
+      summary.deletedTraceFiles += 1;
+    } else {
+      summary.deletedCompactionFiles += 1;
+    }
+  }
+  emptyDeleteSummary() {
+    return {
+      removedTrajectories: 0,
+      deletedJsonFiles: 0,
+      deletedMarkdownFiles: 0,
+      deletedTraceFiles: 0,
+      deletedCompactionFiles: 0
+    };
+  }
+  async listCompactionMarkerFiles() {
+    const markerPaths = [];
+    await this.walkFilesInto(
+      this.activeDir,
+      markerPaths,
+      isCompactionMarkerFile
+    );
+    await this.walkFilesInto(
+      this.completedDir,
+      markerPaths,
+      isCompactionMarkerFile
+    );
+    return markerPaths;
+  }
+  getCompactionMarkerPath(filePath, id) {
+    if (basename(filePath) === TRAJECTORY_FILE) {
+      return join(dirname(filePath), COMPACTION_FILE);
+    }
+    return join(dirname(filePath), `${id}${LEGACY_COMPACTION_SUFFIX}`);
+  }
+  getTrajectoryIdFromCompactionMarkerPath(markerPath) {
+    if (basename(markerPath) === COMPACTION_FILE) {
+      const id = basename(dirname(markerPath));
+      return id.startsWith("traj_") ? id : void 0;
+    }
+    const markerName = basename(markerPath);
+    return markerName.endsWith(LEGACY_COMPACTION_SUFFIX) ? markerName.slice(0, -LEGACY_COMPACTION_SUFFIX.length) : void 0;
+  }
+  async migrateLegacyIndexCompactionMarkers() {
+    const indexPath = join(this.trajectoriesDir, "index.json");
+    if (!existsSync(indexPath)) {
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(await readFile(indexPath, "utf-8"));
+    } catch {
+      return;
+    }
+    if (parsed === null || typeof parsed !== "object") {
+      return;
+    }
+    const trajectories = parsed.trajectories;
+    if (trajectories === null || typeof trajectories !== "object" || Array.isArray(trajectories)) {
+      return;
+    }
+    await Promise.all(
+      Object.entries(trajectories).map(async ([id, entry]) => {
+        if (entry === null || typeof entry !== "object" || !isSafeTrajectoryId(id)) {
+          return;
+        }
+        const compactedInto = entry.compactedInto;
+        const path2 = entry.path;
+        if (typeof compactedInto !== "string") {
+          return;
+        }
+        const paths = typeof path2 === "string" && existsSync(path2) && this.isPathInsideTrajectoriesDir(path2) ? [path2] : await this.findTrajectoryFilePaths(id);
+        if (paths.length === 0) return;
+        const marker = {
+          trajectoryId: id,
+          compactedInto,
+          compactedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        await Promise.all(
+          paths.map(
+            (filePath) => writeFile(
+              this.getCompactionMarkerPath(filePath, id),
+              JSON.stringify(marker, null, 2),
+              "utf-8"
+            )
+          )
+        );
+      })
+    );
+  }
+  isPathInsideTrajectoriesDir(path2) {
+    const rel = relative(resolve(this.trajectoriesDir), resolve(path2));
+    return Boolean(rel && !rel.startsWith("..") && !isAbsolute(rel));
+  }
+  async walkFilesInto(dir, out, predicate) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+    for (const entry of entries) {
+      const entryPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await this.walkFilesInto(entryPath, out, predicate);
+      } else if (entry.isFile() && predicate(entry.name)) {
+        out.push(entryPath);
+      }
+    }
+  }
+  getSortValue(trajectory, sortBy) {
+    if (sortBy === "title") {
+      return trajectory.task.title;
+    }
+    return trajectory[sortBy] ?? "";
+  }
+  toSummary(trajectory) {
+    return {
+      id: trajectory.id,
+      title: trajectory.task.title,
+      status: trajectory.status,
+      startedAt: trajectory.startedAt,
+      completedAt: trajectory.completedAt,
+      confidence: trajectory.retrospective?.confidence,
+      chapterCount: trajectory.chapters.length,
+      decisionCount: trajectory.chapters.reduce(
+        (count, chapter) => count + chapter.events.filter((event) => event.type === "decision").length,
+        0
+      )
+    };
+  }
+  isNewerTrajectory(candidate, current) {
+    const candidateTime = new Date(
+      candidate.completedAt ?? candidate.startedAt
+    ).getTime();
+    const currentTime = new Date(
+      current.completedAt ?? current.startedAt
+    ).getTime();
+    return candidateTime > currentTime;
+  }
   /**
    * Read a trajectory file and return a tagged result so callers can
    * distinguish missing files, malformed JSON, and schema violations.
@@ -998,82 +1372,25 @@ var FileStorage = class {
     const result = await this.readTrajectoryFile(path2);
     return result.ok ? result.trajectory : null;
   }
-  /**
-   * Read and parse the on-disk index.
-   *
-   * Tolerances (belt-and-braces against the read/write race):
-   *   - ENOENT: first-run, return an empty index silently.
-   *   - Empty file: a concurrent writer truncated index.json in "w" mode
-   *     right before we read. Return an empty index silently — this is
-   *     not a real corruption, just an interleaving the mutex + atomic
-   *     rename should already prevent. Logging here would be noise.
-   *   - Non-empty but malformed JSON: genuinely corrupted on disk (hand
-   *     edit, disk error, etc). Log it and return an empty index so the
-   *     caller can recover, but keep the log so the problem is visible.
-   */
-  async loadIndex() {
-    let content;
-    try {
-      content = await readFile(this.indexPath, "utf-8");
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        console.error(
-          "Error loading trajectory index, using empty index:",
-          error
-        );
-      }
-      return this.emptyIndex();
-    }
-    if (content.length === 0) {
-      return this.emptyIndex();
-    }
-    try {
-      return JSON.parse(content);
-    } catch (error) {
-      console.error(
-        "Error loading trajectory index, using empty index:",
-        error
-      );
-      return this.emptyIndex();
-    }
-  }
-  emptyIndex() {
-    return {
-      version: 1,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      trajectories: {}
-    };
-  }
-  /**
-   * Atomic write: stage into a process-unique temp path in the same directory
-   * and then rename over the live file. `rename` is atomic on POSIX, so
-   * concurrent readers in any process either see the old complete file or
-   * the new complete file — never a half-written / zero-byte state.
-   *
-   * Callers MUST hold `withIndexLock(this.indexPath, ...)` so the in-process
-   * read-modify-write cycle stays serialized; the unique temp name also keeps
-   * parallel writers in other processes from colliding on a shared tmp path.
-   */
-  async saveIndex(index) {
-    index.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-    const tmpPath = `${this.indexPath}.${process.pid}.${randomUUID()}.tmp`;
-    await writeFile(tmpPath, JSON.stringify(index, null, 2), "utf-8");
-    await rename(tmpPath, this.indexPath);
-  }
-  async updateIndex(trajectory, filePath) {
-    await withIndexLock(this.indexPath, async () => {
-      const index = await this.loadIndex();
-      index.trajectories[trajectory.id] = {
-        title: trajectory.task.title,
-        status: trajectory.status,
-        startedAt: trajectory.startedAt,
-        completedAt: trajectory.completedAt,
-        path: filePath
-      };
-      await this.saveIndex(index);
-    });
-  }
 };
+function isTrajectoryJsonFile(name) {
+  return name === TRAJECTORY_FILE || name.endsWith(".json") && name !== "index.json" && !name.endsWith(".trace.json") && !name.endsWith(LEGACY_COMPACTION_SUFFIX) && name !== COMPACTION_FILE;
+}
+function isSafeTrajectoryId(id) {
+  return id.length > 0 && !id.includes("..") && !id.includes("/") && !id.includes("\\");
+}
+function isCompactionMarkerFile(name) {
+  return name === COMPACTION_FILE || name.endsWith(LEGACY_COMPACTION_SUFFIX);
+}
+function getMarkdownOutputPath(outputPath) {
+  return outputPath.endsWith(".json") ? outputPath.slice(0, -".json".length).concat(".md") : `${outputPath}.md`;
+}
+function getTraceOutputPath(outputPath) {
+  return outputPath.endsWith(".json") ? outputPath.slice(0, -".json".length).concat(".trace.json") : `${outputPath}.trace.json`;
+}
+function getLegacyCompactionMarkerPath(outputPath) {
+  return outputPath.endsWith(".json") ? outputPath.slice(0, -".json".length).concat(LEGACY_COMPACTION_SUFFIX) : `${outputPath}${LEGACY_COMPACTION_SUFFIX}`;
+}
 
 // src/cli/commands/abandon.ts
 function registerAbandonCommand(program2) {
@@ -1096,14 +1413,8 @@ function registerAbandonCommand(program2) {
 
 // src/cli/commands/compact.ts
 import { execFileSync } from "child_process";
-import {
-  existsSync as existsSync3,
-  mkdirSync,
-  readFileSync as readFileSync2,
-  unlinkSync,
-  writeFileSync
-} from "fs";
-import { dirname, join as join4 } from "path";
+import { existsSync as existsSync3, mkdirSync, writeFileSync } from "fs";
+import { dirname as dirname2, join as join4 } from "path";
 
 // src/compact/config.ts
 import { existsSync as existsSync2, readFileSync } from "fs";
@@ -1807,7 +2118,7 @@ function buildCliArgs(cli) {
   }
 }
 function spawnWithStdin(command, args, input) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const child = spawn(command, args, {
       timeout: 3e5,
       stdio: ["pipe", "pipe", "pipe"]
@@ -1825,7 +2136,7 @@ function spawnWithStdin(command, args, input) {
           new Error(`CLI exited with code ${code}: ${stderr.slice(0, 200)}`)
         );
       } else {
-        resolve(Buffer.concat(chunks).toString().trim());
+        resolve2(Buffer.concat(chunks).toString().trim());
       }
     });
     child.stdin.write(input);
@@ -2250,7 +2561,7 @@ function registerCompactCommand(program2) {
     "Comma-separated focus areas to emphasize in LLM compaction"
   ).option("--markdown", "Also write a Markdown companion file").option("--no-markdown", "Skip writing a Markdown companion file").option(
     "--discard-sources",
-    "After saving the compaction, delete source trajectory JSON/MD/trace files and remove their index entries"
+    "After saving the compaction, delete source trajectory JSON/MD/trace files"
   ).option("--dry-run", "Preview what would be compacted without saving").option("--output <path>", "Output path for compacted trajectory").action(async (options) => {
     const trajectories = await loadTrajectories(options);
     if (trajectories.length === 0) {
@@ -2291,7 +2602,7 @@ function registerCompactCommand(program2) {
         markdownEnabled
       );
       if (options.discardSources) {
-        const discardSummary = discardSourceTrajectories(trajectories);
+        const discardSummary = await discardSourceTrajectories(trajectories);
         printDiscardSummary(discardSummary);
       } else {
         await markTrajectoriesAsCompacted(
@@ -2303,7 +2614,7 @@ function registerCompactCommand(program2) {
 Compacted trajectory saved to: ${outputPath2}`);
       if (markdownEnabled) {
         console.log(
-          `Markdown summary saved to: ${getMarkdownOutputPath(outputPath2)}`
+          `Markdown summary saved to: ${getMarkdownOutputPath2(outputPath2)}`
         );
       }
       printCompactedSummary(mechanicalCompacted);
@@ -2352,7 +2663,7 @@ Compacted trajectory saved to: ${outputPath2}`);
     const outputPath = options.output || getDefaultOutputPath(compacted, options.workflow);
     saveCompactionArtifacts(compacted, outputPath, markdownEnabled);
     if (options.discardSources) {
-      const discardSummary = discardSourceTrajectories(trajectories);
+      const discardSummary = await discardSourceTrajectories(trajectories);
       printDiscardSummary(discardSummary);
     } else {
       await markTrajectoriesAsCompacted(trajectories, compacted.id);
@@ -2361,7 +2672,7 @@ Compacted trajectory saved to: ${outputPath2}`);
 Compacted trajectory saved to: ${outputPath}`);
     if (markdownEnabled) {
       console.log(
-        `Markdown summary saved to: ${getMarkdownOutputPath(outputPath)}`
+        `Markdown summary saved to: ${getMarkdownOutputPath2(outputPath)}`
       );
     }
     printCompactedSummary(compacted);
@@ -2380,19 +2691,12 @@ async function loadTrajectories(options) {
       return [trimmed, trimmed.slice(0, 7)];
     })
   ) : null;
-  const compactedIds = options.all ? /* @__PURE__ */ new Set() : getCompactedTrajectoryIds();
+  const compactedIds = options.all ? /* @__PURE__ */ new Set() : await getCompactedTrajectoryIds();
   const searchPaths = getSearchPaths();
   const seenIds = /* @__PURE__ */ new Set();
   for (const searchPath of searchPaths) {
     if (!existsSync3(searchPath)) continue;
-    const originalDataDir = process.env.TRAJECTORIES_DATA_DIR;
-    process.env.TRAJECTORIES_DATA_DIR = searchPath;
-    const storage = new FileStorage();
-    if (originalDataDir !== void 0) {
-      process.env.TRAJECTORIES_DATA_DIR = originalDataDir;
-    } else {
-      delete process.env.TRAJECTORIES_DATA_DIR;
-    }
+    const storage = createStorageForSearchPath(searchPath);
     await storage.initialize();
     const summaries = await storage.list({
       status: "completed",
@@ -2438,6 +2742,19 @@ async function loadTrajectories(options) {
   }
   return trajectories;
 }
+function createStorageForSearchPath(searchPath) {
+  const originalDataDir = process.env.TRAJECTORIES_DATA_DIR;
+  process.env.TRAJECTORIES_DATA_DIR = searchPath;
+  try {
+    return new FileStorage();
+  } finally {
+    if (originalDataDir !== void 0) {
+      process.env.TRAJECTORIES_DATA_DIR = originalDataDir;
+    } else {
+      delete process.env.TRAJECTORIES_DATA_DIR;
+    }
+  }
+}
 function getBranchCommits(targetBranch) {
   const commits = /* @__PURE__ */ new Set();
   try {
@@ -2462,21 +2779,17 @@ function getBranchCommits(targetBranch) {
   }
   return commits;
 }
-function getCompactedTrajectoryIds() {
+async function getCompactedTrajectoryIds() {
   const compacted = /* @__PURE__ */ new Set();
   const searchPaths = getSearchPaths();
   for (const searchPath of searchPaths) {
-    const indexPath = join4(searchPath, "index.json");
-    if (!existsSync3(indexPath)) continue;
-    try {
-      const indexContent = readFileSync2(indexPath, "utf-8");
-      const index = JSON.parse(indexContent);
-      for (const [id, entry] of Object.entries(index.trajectories || {})) {
-        if (entry.compactedInto) {
-          compacted.add(id);
-        }
-      }
-    } catch {
+    if (!existsSync3(searchPath)) {
+      continue;
+    }
+    const storage = createStorageForSearchPath(searchPath);
+    await storage.initialize();
+    for (const id of await storage.getCompactedTrajectoryIds()) {
+      compacted.add(id);
     }
   }
   return compacted;
@@ -2484,92 +2797,45 @@ function getCompactedTrajectoryIds() {
 async function markTrajectoriesAsCompacted(trajectories, compactedIntoId) {
   const searchPaths = getSearchPaths();
   for (const searchPath of searchPaths) {
-    const indexPath = join4(searchPath, "index.json");
-    if (!existsSync3(indexPath)) continue;
-    try {
-      const indexContent = readFileSync2(indexPath, "utf-8");
-      const index = JSON.parse(indexContent);
-      let updated = false;
-      for (const traj of trajectories) {
-        if (index.trajectories[traj.id]) {
-          index.trajectories[traj.id].compactedInto = compactedIntoId;
-          updated = true;
-        }
-      }
-      if (updated) {
-        index.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-        writeFileSync(indexPath, JSON.stringify(index, null, 2));
-      }
-    } catch {
+    if (!existsSync3(searchPath)) {
+      continue;
     }
+    const storage = createStorageForSearchPath(searchPath);
+    await storage.initialize();
+    await storage.markCompactedMany(
+      trajectories.map((trajectory) => trajectory.id),
+      compactedIntoId
+    );
   }
 }
-function discardSourceTrajectories(trajectories) {
-  const sourceIds = new Set(trajectories.map((trajectory) => trajectory.id));
+async function discardSourceTrajectories(trajectories) {
   const summary = {
-    removedIndexEntries: 0,
+    removedTrajectories: 0,
     deletedJsonFiles: 0,
     deletedMarkdownFiles: 0,
-    deletedTraceFiles: 0
+    deletedTraceFiles: 0,
+    deletedCompactionFiles: 0
   };
   for (const searchPath of getSearchPaths()) {
-    const indexPath = join4(searchPath, "index.json");
-    if (!existsSync3(indexPath)) continue;
-    let index;
-    try {
-      const indexContent = readFileSync2(indexPath, "utf-8");
-      const parsedIndex = JSON.parse(indexContent);
-      if (!isTrajectoryIndex(parsedIndex)) {
-        continue;
-      }
-      index = parsedIndex;
-    } catch {
+    if (!existsSync3(searchPath)) {
       continue;
     }
-    let updated = false;
-    for (const id of sourceIds) {
-      const entry = index.trajectories[id];
-      if (!entry) continue;
-      if (deleteFileIfExists(entry.path)) {
-        summary.deletedJsonFiles += 1;
-      }
-      if (deleteFileIfExists(getMarkdownOutputPath(entry.path))) {
-        summary.deletedMarkdownFiles += 1;
-      }
-      if (deleteFileIfExists(getTraceOutputPath(entry.path))) {
-        summary.deletedTraceFiles += 1;
-      }
-      delete index.trajectories[id];
-      summary.removedIndexEntries += 1;
-      updated = true;
-    }
-    if (updated) {
-      index.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-      writeFileSync(indexPath, JSON.stringify(index, null, 2));
-    }
+    const storage = createStorageForSearchPath(searchPath);
+    await storage.initialize();
+    const deleteSummary = await storage.deleteManyWithSummary(
+      trajectories.map((trajectory) => trajectory.id)
+    );
+    summary.removedTrajectories += deleteSummary.removedTrajectories;
+    summary.deletedJsonFiles += deleteSummary.deletedJsonFiles;
+    summary.deletedMarkdownFiles += deleteSummary.deletedMarkdownFiles;
+    summary.deletedTraceFiles += deleteSummary.deletedTraceFiles;
+    summary.deletedCompactionFiles += deleteSummary.deletedCompactionFiles;
   }
   return summary;
 }
-function deleteFileIfExists(path2) {
-  if (!existsSync3(path2)) {
-    return false;
-  }
-  unlinkSync(path2);
-  return true;
-}
-function isTrajectoryIndex(value) {
-  if (value === null || typeof value !== "object") {
-    return false;
-  }
-  const candidate = value;
-  return candidate.trajectories !== null && typeof candidate.trajectories === "object" && !Array.isArray(candidate.trajectories);
-}
-function getTraceOutputPath(outputPath) {
-  return outputPath.endsWith(".json") ? outputPath.slice(0, -".json".length).concat(".trace.json") : `${outputPath}.trace.json`;
-}
 function printDiscardSummary(summary) {
   console.log(
-    `Discarded source trajectories: ${summary.removedIndexEntries} index entries, ${summary.deletedJsonFiles} JSON files, ${summary.deletedMarkdownFiles} Markdown files, ${summary.deletedTraceFiles} trace files`
+    `Discarded source trajectories: ${summary.removedTrajectories} trajectories, ${summary.deletedJsonFiles} JSON files, ${summary.deletedMarkdownFiles} Markdown files, ${summary.deletedTraceFiles} trace files, ${summary.deletedCompactionFiles} compaction markers`
   );
 }
 function parseRelativeDate(input) {
@@ -2807,19 +3073,19 @@ function getDefaultOutputPath(compacted, workflowId) {
   return join4(compactedDir, `${compacted.id}_${dateStr}.json`);
 }
 function saveCompactionArtifacts(compacted, outputPath, markdownEnabled) {
-  const dir = dirname(outputPath);
+  const dir = dirname2(outputPath);
   if (!existsSync3(dir)) {
     mkdirSync(dir, { recursive: true });
   }
   writeFileSync(outputPath, JSON.stringify(compacted, null, 2));
   if (markdownEnabled) {
     writeFileSync(
-      getMarkdownOutputPath(outputPath),
+      getMarkdownOutputPath2(outputPath),
       renderCompactionMarkdown(compacted)
     );
   }
 }
-function getMarkdownOutputPath(outputPath) {
+function getMarkdownOutputPath2(outputPath) {
   return outputPath.endsWith(".json") ? outputPath.slice(0, -".json".length).concat(".md") : `${outputPath}.md`;
 }
 function renderCompactionMarkdown(compacted) {
@@ -3142,7 +3408,7 @@ function createTraceRef(startRef, traceId) {
 
 // src/core/trailers.ts
 import { execSync as execSync2 } from "child_process";
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 function getCommitsBetween(startRef, endRef = "HEAD") {
   if (!isGitRepo()) {
     return [];
@@ -3255,7 +3521,7 @@ function detectExistingHook() {
     }).trim();
     const hookPath = `${hooksDir}/hooks/prepare-commit-msg`;
     try {
-      const content = readFileSync3(hookPath, "utf-8");
+      const content = readFileSync2(hookPath, "utf-8");
       if (content.includes("agent-trajectories")) {
         return "ours";
       }
@@ -3393,6 +3659,51 @@ function registerDecisionCommand(program2) {
   });
 }
 
+// src/cli/commands/doctor.ts
+function registerDoctorCommand(program2) {
+  program2.command("doctor").description(
+    "List trajectory files that fail to load; optionally quarantine them"
+  ).option(
+    "--quarantine",
+    "Move invalid files to .trajectories/invalid/ so reconcile stops scanning them"
+  ).action(async (opts) => {
+    const storage = new FileStorage();
+    await storage.initialize();
+    const summary = storage.getLastReconcileSummary();
+    const failures = summary?.failures ?? [];
+    if (failures.length === 0) {
+      console.log("No invalid trajectory files found.");
+      return;
+    }
+    console.log(`Found ${failures.length} invalid trajectory file(s):`);
+    for (const failure of failures) {
+      console.log(`  ${failure.path}`);
+      console.log(`    reason:  ${failure.reason}`);
+      console.log(`    detail:  ${failure.message}`);
+    }
+    if (!opts.quarantine) {
+      console.log(
+        "\nRun `trail doctor --quarantine` to move these files into .trajectories/invalid/."
+      );
+      return;
+    }
+    const result = await storage.quarantineInvalid();
+    if (result.moved.length === 0) {
+      console.log(
+        "\nNo files were moved (io_error failures are not auto-quarantined)."
+      );
+      return;
+    }
+    console.log(
+      `
+Moved ${result.moved.length} file(s) to ${result.targetDir}:`
+    );
+    for (const failure of result.moved) {
+      console.log(`  ${failure.path}`);
+    }
+  });
+}
+
 // src/cli/commands/enable.ts
 import { execSync as execSync3 } from "child_process";
 import { existsSync as existsSync5 } from "fs";
@@ -3470,8 +3781,8 @@ function registerEnableCommand(program2) {
       console.error("Remove it manually if needed");
       throw new Error("Hook not ours");
     }
-    const { unlink: unlink2 } = await import("fs/promises");
-    await unlink2(hookPath);
+    const { unlink } = await import("fs/promises");
+    await unlink(hookPath);
     console.log("Trajectory hook removed");
   });
 }
@@ -4627,9 +4938,32 @@ function registerStartCommand(program2) {
 
 // src/cli/commands/status.ts
 function registerStatusCommand(program2) {
-  program2.command("status").description("Show active trajectory status").action(async () => {
+  program2.command("status").description("Show active trajectory status").option(
+    "-v, --verbose",
+    "Show paths and validation errors for any trajectory files that failed to load"
+  ).action(async (opts) => {
     const storage = new FileStorage();
     await storage.initialize();
+    if (opts.verbose) {
+      const summary = storage.getLastReconcileSummary();
+      const failures = summary?.failures ?? [];
+      if (failures.length === 0) {
+        console.log("All trajectory files loaded cleanly.");
+      } else {
+        console.log(
+          `Skipped ${failures.length} trajectory file(s) during reconcile:`
+        );
+        for (const failure of failures) {
+          console.log(`  ${failure.path}`);
+          console.log(`    reason:  ${failure.reason}`);
+          console.log(`    detail:  ${failure.message}`);
+        }
+        console.log(
+          "\nRun `trail doctor --quarantine` to move them aside and silence this warning."
+        );
+      }
+      console.log("");
+    }
     const active = await storage.getActive();
     if (!active) {
       console.log("No active trajectory");
@@ -4702,6 +5036,7 @@ function registerCommands(program2) {
   registerExportCommand(program2);
   registerEnableCommand(program2);
   registerCompactCommand(program2);
+  registerDoctorCommand(program2);
 }
 
 // src/cli/version.ts