agent-trajectories 0.5.6 → 0.5.8

package/dist/cli/index.js

@@ -404,9 +404,17 @@ function abandonTrajectory(trajectory, reason) {
 }
 
 // src/storage/file.ts
+import { randomUUID } from "crypto";
 import { existsSync } from "fs";
-import { mkdir, readFile, readdir, unlink, writeFile } from "fs/promises";
-import { join } from "path";
+import {
+  mkdir,
+  readFile,
+  readdir,
+  rename,
+  unlink,
+  writeFile
+} from "fs/promises";
+import { basename, dirname, isAbsolute, join, relative } from "path";
 
 // src/export/markdown.ts
 function exportToMarkdown(trajectory) {
@@ -586,12 +594,37 @@ function getSearchPaths() {
   }
   return [join(process.cwd(), ".trajectories")];
 }
+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 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;
+}
 var FileStorage = class {
   baseDir;
   trajectoriesDir;
   activeDir;
   completedDir;
   indexPath;
+  lastReconcileSummary;
   constructor(baseDir) {
     this.baseDir = baseDir ?? process.cwd();
     const dataDir = process.env.TRAJECTORIES_DATA_DIR;
@@ -612,10 +645,10 @@ var FileStorage = class {
     await mkdir(this.activeDir, { recursive: true });
     await mkdir(this.completedDir, { recursive: true });
     if (!existsSync(this.indexPath)) {
-      await this.saveIndex({
-        version: 1,
-        lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-        trajectories: {}
+      await withIndexLock(this.indexPath, async () => {
+        if (!existsSync(this.indexPath)) {
+          await this.saveIndex(this.emptyIndex());
+        }
       });
     }
     await this.reconcileIndex();
@@ -641,51 +674,59 @@ var FileStorage = class {
       alreadyIndexed: 0,
       skippedMalformedJson: 0,
       skippedSchemaViolation: 0,
-      skippedIoError: 0
+      skippedIoError: 0,
+      failures: []
     };
-    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));
+    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;
       }
-    } 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;
+      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;
         }
-        continue;
+        const trajectory = result.trajectory;
+        if (index.trajectories[trajectory.id]) {
+          summary.alreadyIndexed += 1;
+          continue;
+        }
+        index.trajectories[trajectory.id] = {
+          title: trajectory.task.title,
+          status: trajectory.status,
+          startedAt: trajectory.startedAt,
+          completedAt: trajectory.completedAt,
+          path: filePath
+        };
+        summary.added += 1;
       }
-      const trajectory = result.trajectory;
-      if (index.trajectories[trajectory.id]) {
-        summary.alreadyIndexed += 1;
-        continue;
+      if (Object.keys(index.trajectories).length !== before) {
+        await this.saveIndex(index);
       }
-      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);
-    }
+    });
     const hadSkips = summary.skippedMalformedJson + summary.skippedSchemaViolation + summary.skippedIoError > 0;
     if (summary.added > 0 || hadSkips) {
       const parts = [`reconciled ${summary.added}/${summary.scanned}`];
@@ -700,8 +741,74 @@ var FileStorage = class {
       }
       console.warn(`[trajectories] ${parts.join(", ")}`);
     }
+    this.lastReconcileSummary = summary;
     return summary;
   }
+  /**
+   * 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 all .json file paths under `dir` into `out`.
    * Silently treats a missing directory as empty.
@@ -888,17 +995,19 @@ var FileStorage = class {
     if (existsSync(activePath)) {
       await unlink(activePath);
     }
-    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);
+    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);
+      delete index.trajectories[id];
+      await this.saveIndex(index);
+    });
   }
   /**
    * Search trajectories by text
@@ -976,10 +1085,23 @@ 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 {
-      const content = await readFile(this.indexPath, "utf-8");
-      return JSON.parse(content);
+      content = await readFile(this.indexPath, "utf-8");
     } catch (error) {
       if (error.code !== "ENOENT") {
         console.error(
@@ -987,27 +1109,56 @@ var FileStorage = class {
           error
         );
       }
-      return {
-        version: 1,
-        lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-        trajectories: {}
-      };
+      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();
-    await writeFile(this.indexPath, JSON.stringify(index, null, 2), "utf-8");
+    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) {
-    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);
+    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);
+    });
   }
 };
 
@@ -1039,7 +1190,7 @@ import {
   unlinkSync,
   writeFileSync
 } from "fs";
-import { dirname, join as join4 } from "path";
+import { dirname as dirname2, join as join4 } from "path";
 
 // src/compact/config.ts
 import { existsSync as existsSync2, readFileSync } from "fs";
@@ -2743,7 +2894,7 @@ 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 });
   }
@@ -3329,6 +3480,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";
@@ -4563,9 +4759,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");
@@ -4638,6 +4857,7 @@ function registerCommands(program2) {
   registerExportCommand(program2);
   registerEnableCommand(program2);
   registerCompactCommand(program2);
+  registerDoctorCommand(program2);
 }
 
 // src/cli/version.ts