agent-trajectories 0.5.8 → 0.5.9

package/dist/{chunk-WMJRBQB4.js → chunk-JMH3Z5BB.js}

@@ -666,17 +666,27 @@ function formatTime(isoString) {
 }
 
 // src/storage/file.ts
-import { randomUUID } from "crypto";
 import { existsSync } from "fs";
 import {
   mkdir,
   readFile,
   readdir,
   rename,
-  unlink,
+  rm,
   writeFile
 } from "fs/promises";
-import { basename, dirname, isAbsolute, join, relative } from "path";
+import {
+  basename,
+  dirname,
+  isAbsolute,
+  join,
+  relative,
+  resolve
+} from "path";
+var TRAJECTORY_FILE = "trajectory.json";
+var SUMMARY_FILE = "summary.md";
+var COMPACTION_FILE = "compaction.json";
+var LEGACY_COMPACTION_SUFFIX = ".compaction.json";
 function expandPath(path) {
   if (path.startsWith("~")) {
     return join(process.env.HOME ?? "", path.slice(1));
@@ -697,22 +707,11 @@ function describeReadFailure(reason, error) {
   if (error instanceof Error) return error.message;
   return String(error);
 }
-var indexLocks = /* @__PURE__ */ new Map();
-function withIndexLock(path, task) {
-  const prev = indexLocks.get(path) ?? Promise.resolve();
-  const next = prev.then(task, task);
-  indexLocks.set(
-    path,
-    next.catch(() => void 0)
-  );
-  return next;
-}
 var FileStorage = class {
   baseDir;
   trajectoriesDir;
   activeDir;
   completedDir;
-  indexPath;
   lastReconcileSummary;
   constructor(baseDir) {
     this.baseDir = baseDir ?? process.cwd();
@@ -724,7 +723,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
@@ -733,28 +731,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 = {
@@ -766,58 +758,29 @@ var FileStorage = class {
       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;
-          }
-          summary.failures.push({
-            path: result.path,
-            reason: result.reason,
-            message: describeReadFailure(result.reason, result.error)
-          });
-          continue;
-        }
-        const trajectory2 = result.trajectory;
-        if (index.trajectories[trajectory2.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[trajectory2.id] = {
-          title: trajectory2.task.title,
-          status: trajectory2.status,
-          startedAt: trajectory2.startedAt,
-          completedAt: trajectory2.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}`);
@@ -899,7 +862,7 @@ var FileStorage = class {
     return dest;
   }
   /**
-   * Recursively collect all .json file paths under `dir` into `out`.
+   * Recursively collect trajectory JSON file paths under `dir` into `out`.
    * Silently treats a missing directory as empty.
    */
   async walkJsonFilesInto(dir, out) {
@@ -914,7 +877,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);
       }
     }
@@ -938,56 +901,43 @@ var FileStorage = class {
     }
     const trajectory2 = validation.data;
     const isCompleted = trajectory2.status === "completed" || trajectory2.status === "abandoned";
-    let filePath;
+    const existingPaths = await this.findTrajectoryFilePaths(trajectory2.id);
+    let trajectoryDir;
     if (isCompleted) {
       const date = new Date(trajectory2.completedAt ?? trajectory2.startedAt);
       const monthDir = join(
         this.completedDir,
         `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}`
       );
-      await mkdir(monthDir, { recursive: true });
-      filePath = join(monthDir, `${trajectory2.id}.json`);
-      const activePath = join(this.activeDir, `${trajectory2.id}.json`);
-      if (existsSync(activePath)) {
-        await unlink(activePath);
-      }
-      const mdPath = join(monthDir, `${trajectory2.id}.md`);
-      const markdown = exportToMarkdown(trajectory2);
-      await writeFile(mdPath, markdown, "utf-8");
+      trajectoryDir = join(monthDir, trajectory2.id);
     } else {
-      filePath = join(this.activeDir, `${trajectory2.id}.json`);
+      trajectoryDir = join(this.activeDir, trajectory2.id);
+    }
+    const filePath = join(trajectoryDir, TRAJECTORY_FILE);
+    await this.removeTrajectoryFiles(existingPaths, filePath);
+    await mkdir(trajectoryDir, { recursive: true });
+    if (isCompleted) {
+      const markdown = exportToMarkdown(trajectory2);
+      await writeFile(join(trajectoryDir, SUMMARY_FILE), markdown, "utf-8");
     }
     await writeFile(filePath, JSON.stringify(trajectory2, null, 2), "utf-8");
-    await this.updateIndex(trajectory2, 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 trajectory2 = await this.readTrajectoryOrNull(filePath);
+      if (trajectory2?.id === id) {
+        return trajectory2;
       }
-    } 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 trajectory2 = await this.readTrajectoryOrNull(filePath);
+      if (trajectory2?.id === id) {
+        return trajectory2;
       }
     }
     return null;
@@ -996,107 +946,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 trajectory2 = await this.readTrajectoryOrNull(
-          join(this.activeDir, file)
-        );
-        if (trajectory2) {
-          const startTime = new Date(trajectory2.startedAt).getTime();
-          if (startTime > mostRecentTime) {
-            mostRecentTime = startTime;
-            mostRecent = trajectory2;
-          }
-        }
-      }
-      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 trajectory2 = await this.readTrajectoryOrNull(filePath);
+      if (trajectory2?.status !== "active") continue;
+      const startTime = new Date(trajectory2.startedAt).getTime();
+      if (startTime > mostRecentTime) {
+        mostRecentTime = startTime;
+        mostRecent = trajectory2;
+      }
+    }
+    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(
+        (trajectory2) => new Date(trajectory2.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(
+        (trajectory2) => new Date(trajectory2.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 trajectory2 = await this.get(id);
-        return {
-          id,
-          title: entry.title,
-          status: entry.status,
-          startedAt: entry.startedAt,
-          completedAt: entry.completedAt,
-          confidence: trajectory2?.retrospective?.confidence,
-          chapterCount: trajectory2?.chapters.length ?? 0,
-          decisionCount: trajectory2?.chapters.reduce(
-            (count, chapter) => count + chapter.events.filter((e) => e.type === "decision").length,
-            0
-          ) ?? 0
-        };
-      })
-    );
+    trajectories = trajectories.slice(offset, offset + limit);
+    return trajectories.map((trajectory2) => this.toSummary(trajectory2));
   }
   /**
    * 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
@@ -1129,12 +1033,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 trajectory2 = await this.readTrajectoryOrNull(filePath);
+      if (!trajectory2) {
+        continue;
+      }
+      const current = trajectories.get(trajectory2.id);
+      if (!current || this.isNewerTrajectory(trajectory2, current)) {
+        trajectories.set(trajectory2.id, trajectory2);
+      }
+    }
+    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(path, kind, summary) {
+    if (!existsSync(path)) {
+      return;
+    }
+    await rm(path, { force: true });
+    this.incrementDeleteSummary(kind, summary);
+  }
+  async countFileIfExists(path, kind, summary) {
+    if (existsSync(path)) {
+      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 path = entry.path;
+        if (typeof compactedInto !== "string") {
+          return;
+        }
+        const paths = typeof path === "string" && existsSync(path) && this.isPathInsideTrajectoriesDir(path) ? [path] : 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(path) {
+    const rel = relative(resolve(this.trajectoriesDir), resolve(path));
+    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(trajectory2, sortBy) {
+    if (sortBy === "title") {
+      return trajectory2.task.title;
+    }
+    return trajectory2[sortBy] ?? "";
+  }
+  toSummary(trajectory2) {
+    return {
+      id: trajectory2.id,
+      title: trajectory2.task.title,
+      status: trajectory2.status,
+      startedAt: trajectory2.startedAt,
+      completedAt: trajectory2.completedAt,
+      confidence: trajectory2.retrospective?.confidence,
+      chapterCount: trajectory2.chapters.length,
+      decisionCount: trajectory2.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.
@@ -1174,82 +1461,25 @@ var FileStorage = class {
     const result = await this.readTrajectoryFile(path);
     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(trajectory2, filePath) {
-    await withIndexLock(this.indexPath, async () => {
-      const index = await this.loadIndex();
-      index.trajectories[trajectory2.id] = {
-        title: trajectory2.task.title,
-        status: trajectory2.status,
-        startedAt: trajectory2.startedAt,
-        completedAt: trajectory2.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/sdk/client.ts
 var require2 = createRequire(import.meta.url);
@@ -1337,7 +1567,7 @@ async function compactWorkflow(workflowId, options) {
   if (options?.discardSources) {
     args.push("--discard-sources");
   }
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const child = spawn(cli.command, args, {
       cwd: options?.cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -1365,7 +1595,7 @@ async function compactWorkflow(workflowId, options) {
       }
       try {
         const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
-        resolve(parseCompactWorkflowOutput(stdout));
+        resolve2(parseCompactWorkflowOutput(stdout));
       } catch (error) {
         reject(
           error instanceof Error ? error : new Error("compactWorkflow failed: unable to parse CLI output")
@@ -2190,4 +2420,4 @@ export {
   getCommitsBetween,
   getFilesChangedBetween
 };
-//# sourceMappingURL=chunk-WMJRBQB4.js.map
+//# sourceMappingURL=chunk-JMH3Z5BB.js.map