agent-relay 4.0.19 → 4.0.21

package/node_modules/agent-trajectories/dist/cli/index.js

@@ -0,0 +1,4592 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { program } from "commander";
+
+// src/core/id.ts
+import { webcrypto } from "crypto";
+var ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
+var ID_LENGTH = 12;
+function generateRandomId(length = ID_LENGTH) {
+  let id = "";
+  const randomValues = new Uint8Array(length);
+  webcrypto.getRandomValues(randomValues);
+  for (let i = 0; i < length; i++) {
+    id += ALPHABET[randomValues[i] % ALPHABET.length];
+  }
+  return id;
+}
+function generateTrajectoryId() {
+  return `traj_${generateRandomId()}`;
+}
+function generateChapterId() {
+  return `chap_${generateRandomId()}`;
+}
+
+// src/core/schema.ts
+import { z } from "zod";
+var TaskSourceSystemSchema = z.union([
+  z.literal("beads"),
+  z.literal("github"),
+  z.literal("linear"),
+  z.literal("jira"),
+  z.literal("plain"),
+  z.string()
+  // Allow custom systems
+]);
+var TaskSourceSchema = z.object({
+  system: TaskSourceSystemSchema,
+  id: z.string().min(1, "Task ID is required"),
+  url: z.string().url().optional()
+});
+var TaskReferenceSchema = z.object({
+  title: z.string().min(1, "Trajectory title is required").max(500, "Trajectory title must be 500 characters or less"),
+  description: z.string().optional(),
+  source: TaskSourceSchema.optional()
+});
+var TrajectoryStatusSchema = z.enum([
+  "active",
+  "completed",
+  "abandoned"
+]);
+var TrajectoryEventTypeSchema = z.union([
+  z.literal("prompt"),
+  z.literal("thinking"),
+  z.literal("tool_call"),
+  z.literal("tool_result"),
+  z.literal("message_sent"),
+  z.literal("message_received"),
+  z.literal("decision"),
+  z.literal("finding"),
+  z.literal("reflection"),
+  z.literal("note"),
+  z.literal("error"),
+  z.string()
+  // Allow event types emitted by other tools (e.g. agent-relay's completion-evidence / completion-marker). Downstream code filters to known types.
+]);
+var EventSignificanceSchema = z.enum([
+  "low",
+  "medium",
+  "high",
+  "critical"
+]);
+var TrajectoryEventSchema = z.object({
+  ts: z.number().int().positive(),
+  type: TrajectoryEventTypeSchema,
+  content: z.string().min(1, "Event content is required"),
+  raw: z.unknown().optional(),
+  significance: EventSignificanceSchema.optional(),
+  tags: z.array(z.string()).optional(),
+  confidence: z.number().min(0, "Confidence must be between 0 and 1").max(1, "Confidence must be between 0 and 1").optional()
+});
+var AlternativeSchema = z.object({
+  option: z.string().min(1, "Alternative option is required"),
+  reason: z.string().optional()
+});
+var DecisionSchema = z.object({
+  question: z.string().min(1, "Decision question is required"),
+  chosen: z.string().min(1, "Chosen option is required"),
+  alternatives: z.array(z.union([z.string(), AlternativeSchema])),
+  reasoning: z.string().min(1, "Decision reasoning is required"),
+  confidence: z.number().min(0, "Confidence must be between 0 and 1").max(1, "Confidence must be between 0 and 1").optional()
+});
+var AgentParticipationSchema = z.object({
+  name: z.string().min(1, "Agent name is required"),
+  role: z.string().min(1, "Agent role is required"),
+  joinedAt: z.string().datetime(),
+  leftAt: z.string().datetime().optional()
+});
+var ChapterSchema = z.object({
+  id: z.string().min(1),
+  title: z.string().min(1, "Chapter title is required"),
+  agentName: z.string().min(1, "Agent name is required"),
+  startedAt: z.string().datetime(),
+  endedAt: z.string().datetime().optional(),
+  events: z.array(TrajectoryEventSchema)
+});
+var RetrospectiveSchema = z.object({
+  summary: z.string().min(1, "Retrospective summary is required"),
+  approach: z.string().min(1, "Approach description is required"),
+  decisions: z.array(DecisionSchema).optional(),
+  challenges: z.array(z.string()).optional(),
+  learnings: z.array(z.string()).optional(),
+  suggestions: z.array(z.string()).optional(),
+  confidence: z.number().min(0, "Confidence must be between 0 and 1").max(1, "Confidence must be between 0 and 1"),
+  timeSpent: z.string().optional()
+});
+var TraceRangeSchema = z.object({
+  start_line: z.number().int().positive("Start line must be positive"),
+  end_line: z.number().int().positive("End line must be positive"),
+  revision: z.string().optional(),
+  content_hash: z.string().optional()
+});
+var ContributorTypeSchema = z.enum([
+  "human",
+  "ai",
+  "mixed",
+  "unknown"
+]);
+var TraceContributorSchema = z.object({
+  type: ContributorTypeSchema,
+  model_id: z.string().max(250).optional()
+});
+var TraceConversationSchema = z.object({
+  contributor: TraceContributorSchema,
+  url: z.string().url().optional(),
+  ranges: z.array(TraceRangeSchema)
+});
+var TraceFileSchema = z.object({
+  path: z.string().min(1, "File path is required"),
+  conversations: z.array(TraceConversationSchema)
+});
+var TraceRecordSchema = z.object({
+  version: z.string().min(1, "Version is required"),
+  id: z.string().min(1, "Trace ID is required"),
+  timestamp: z.string().datetime(),
+  trajectory: z.string().optional(),
+  files: z.array(TraceFileSchema)
+});
+var TrajectoryTraceRefSchema = z.object({
+  startRef: z.string().min(1, "Start ref is required"),
+  endRef: z.string().optional(),
+  traceId: z.string().optional()
+});
+var TrajectorySchema = z.object({
+  id: z.string().regex(/^traj_[a-z0-9_]+$/, "Invalid trajectory ID format"),
+  version: z.literal(1),
+  task: TaskReferenceSchema,
+  status: TrajectoryStatusSchema,
+  startedAt: z.string().datetime(),
+  completedAt: z.string().datetime().optional(),
+  agents: z.array(AgentParticipationSchema),
+  chapters: z.array(ChapterSchema),
+  retrospective: RetrospectiveSchema.optional(),
+  commits: z.array(z.string()).default([]),
+  filesChanged: z.array(z.string()).default([]),
+  projectId: z.string().optional(),
+  workflowId: z.string().optional(),
+  tags: z.array(z.string()).default([]),
+  _trace: TrajectoryTraceRefSchema.optional()
+});
+var CreateTrajectoryInputSchema = z.object({
+  title: z.string().min(1, "Trajectory title is required").max(500, "Trajectory title must be 500 characters or less"),
+  description: z.string().optional(),
+  source: TaskSourceSchema.optional(),
+  projectId: z.string().optional(),
+  tags: z.array(z.string()).optional()
+});
+var AddChapterInputSchema = z.object({
+  title: z.string().min(1, "Chapter title is required"),
+  agentName: z.string().min(1, "Agent name is required")
+});
+var AddEventInputSchema = z.object({
+  type: TrajectoryEventTypeSchema,
+  content: z.string().min(1, "Event content is required"),
+  raw: z.unknown().optional(),
+  significance: EventSignificanceSchema.optional(),
+  tags: z.array(z.string()).optional()
+});
+var CompleteTrajectoryInputSchema = z.object({
+  summary: z.string().min(1, "Retrospective summary is required"),
+  approach: z.string().min(1, "Approach description is required"),
+  decisions: z.array(DecisionSchema).optional(),
+  challenges: z.array(z.string()).optional(),
+  learnings: z.array(z.string()).optional(),
+  suggestions: z.array(z.string()).optional(),
+  confidence: z.number().min(0, "Confidence must be between 0 and 1").max(1, "Confidence must be between 0 and 1")
+});
+var TrajectoryQuerySchema = z.object({
+  status: TrajectoryStatusSchema.optional(),
+  since: z.string().datetime().optional(),
+  until: z.string().datetime().optional(),
+  limit: z.number().int().positive().max(100).optional(),
+  offset: z.number().int().nonnegative().optional(),
+  sortBy: z.enum(["startedAt", "completedAt", "title"]).optional(),
+  sortOrder: z.enum(["asc", "desc"]).optional()
+});
+function validateTrajectory(data) {
+  const result = TrajectorySchema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, errors: result.error };
+}
+
+// src/core/trajectory.ts
+var TrajectoryError = class extends Error {
+  constructor(message, code, suggestion) {
+    super(message);
+    this.code = code;
+    this.suggestion = suggestion;
+    this.name = "TrajectoryError";
+  }
+};
+function createTrajectory(input) {
+  const validation = CreateTrajectoryInputSchema.safeParse(input);
+  if (!validation.success) {
+    const firstError = validation.error.errors[0];
+    throw new TrajectoryError(
+      firstError.message,
+      "VALIDATION_ERROR",
+      "Check your input and try again"
+    );
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: generateTrajectoryId(),
+    version: 1,
+    task: {
+      title: input.title,
+      description: input.description,
+      source: input.source
+    },
+    status: "active",
+    startedAt: now,
+    agents: [],
+    chapters: [],
+    commits: [],
+    filesChanged: [],
+    projectId: input.projectId ?? process.cwd(),
+    tags: input.tags ?? []
+  };
+}
+function addChapter(trajectory, input) {
+  if (trajectory.status === "completed") {
+    throw new TrajectoryError(
+      "Cannot add chapter to completed trajectory",
+      "TRAJECTORY_ALREADY_COMPLETED",
+      "Start a new trajectory instead"
+    );
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const updatedChapters = trajectory.chapters.map((chapter, index) => {
+    if (index === trajectory.chapters.length - 1 && !chapter.endedAt) {
+      return { ...chapter, endedAt: now };
+    }
+    return chapter;
+  });
+  const newChapter = {
+    id: generateChapterId(),
+    title: input.title,
+    agentName: input.agentName,
+    startedAt: now,
+    events: []
+  };
+  let updatedAgents = trajectory.agents;
+  const agentExists = trajectory.agents.some((a) => a.name === input.agentName);
+  if (!agentExists) {
+    const isFirstAgent = trajectory.agents.length === 0;
+    updatedAgents = [
+      ...trajectory.agents,
+      {
+        name: input.agentName,
+        role: isFirstAgent ? "lead" : "contributor",
+        joinedAt: now
+      }
+    ];
+  }
+  return {
+    ...trajectory,
+    agents: updatedAgents,
+    chapters: [...updatedChapters, newChapter]
+  };
+}
+function addEvent(trajectory, input) {
+  let updatedTrajectory = trajectory;
+  if (trajectory.chapters.length === 0) {
+    updatedTrajectory = addChapter(trajectory, {
+      title: "Work",
+      agentName: "default"
+    });
+  }
+  const event = {
+    ts: Date.now(),
+    type: input.type,
+    content: input.content,
+    raw: input.raw,
+    significance: input.significance,
+    tags: input.tags
+  };
+  const chapters = [...updatedTrajectory.chapters];
+  const lastChapter = chapters[chapters.length - 1];
+  chapters[chapters.length - 1] = {
+    ...lastChapter,
+    events: [...lastChapter.events, event]
+  };
+  return {
+    ...updatedTrajectory,
+    chapters
+  };
+}
+function addDecision(trajectory, decision) {
+  return addEvent(trajectory, {
+    type: "decision",
+    content: `${decision.question}: ${decision.chosen}`,
+    raw: decision,
+    significance: "high"
+  });
+}
+function completeTrajectory(trajectory, input) {
+  if (trajectory.status === "completed") {
+    throw new TrajectoryError(
+      "Trajectory is already completed",
+      "TRAJECTORY_ALREADY_COMPLETED",
+      "Start a new trajectory instead"
+    );
+  }
+  const validation = CompleteTrajectoryInputSchema.safeParse(input);
+  if (!validation.success) {
+    const firstError = validation.error.errors[0];
+    throw new TrajectoryError(
+      firstError.message,
+      "VALIDATION_ERROR",
+      "Check your input and try again"
+    );
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const chapters = trajectory.chapters.map((chapter, index) => {
+    if (index === trajectory.chapters.length - 1 && !chapter.endedAt) {
+      return { ...chapter, endedAt: now };
+    }
+    return chapter;
+  });
+  return {
+    ...trajectory,
+    status: "completed",
+    completedAt: now,
+    chapters,
+    retrospective: {
+      summary: input.summary,
+      approach: input.approach,
+      decisions: input.decisions,
+      challenges: input.challenges,
+      learnings: input.learnings,
+      suggestions: input.suggestions,
+      confidence: input.confidence
+    }
+  };
+}
+function abandonTrajectory(trajectory, reason) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const chapters = trajectory.chapters.map((chapter, index) => {
+    if (index === trajectory.chapters.length - 1 && !chapter.endedAt) {
+      return { ...chapter, endedAt: now };
+    }
+    return chapter;
+  });
+  let updatedChapters = chapters;
+  if (reason && chapters.length > 0) {
+    const lastChapter = chapters[chapters.length - 1];
+    updatedChapters = [
+      ...chapters.slice(0, -1),
+      {
+        ...lastChapter,
+        events: [
+          ...lastChapter.events,
+          {
+            ts: Date.now(),
+            type: "note",
+            content: `Abandoned: ${reason}`,
+            significance: "high"
+          }
+        ]
+      }
+    ];
+  }
+  return {
+    ...trajectory,
+    status: "abandoned",
+    completedAt: now,
+    chapters: updatedChapters
+  };
+}
+
+// src/storage/file.ts
+import { existsSync } from "fs";
+import { mkdir, readFile, readdir, unlink, writeFile } from "fs/promises";
+import { join } from "path";
+
+// src/export/markdown.ts
+function exportToMarkdown(trajectory) {
+  const lines = [];
+  lines.push(`# Trajectory: ${trajectory.task.title}`);
+  lines.push("");
+  lines.push(`> **Status:** ${formatStatus(trajectory.status)}`);
+  if (trajectory.task.source) {
+    const linkText = trajectory.task.source.url ? `[${trajectory.task.source.id}](${trajectory.task.source.url})` : trajectory.task.source.id;
+    lines.push(`> **Task:** ${linkText}`);
+  }
+  if (trajectory.retrospective?.confidence !== void 0) {
+    lines.push(
+      `> **Confidence:** ${Math.round(trajectory.retrospective.confidence * 100)}%`
+    );
+  }
+  lines.push(`> **Started:** ${formatDate(trajectory.startedAt)}`);
+  if (trajectory.completedAt) {
+    lines.push(`> **Completed:** ${formatDate(trajectory.completedAt)}`);
+  }
+  lines.push("");
+  if (trajectory.retrospective) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Summary");
+    lines.push("");
+    lines.push(trajectory.retrospective.summary);
+    lines.push("");
+    if (trajectory.retrospective.approach) {
+      lines.push(`**Approach:** ${trajectory.retrospective.approach}`);
+      lines.push("");
+    }
+  }
+  const decisions = extractDecisions(trajectory);
+  if (decisions.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Key Decisions");
+    lines.push("");
+    for (const decision of decisions) {
+      lines.push(`### ${decision.question}`);
+      lines.push(`- **Chose:** ${decision.chosen}`);
+      if (decision.alternatives.length > 0) {
+        const altStrings = decision.alternatives.map(
+          (a) => typeof a === "string" ? a : a.option
+        );
+        lines.push(`- **Rejected:** ${altStrings.join(", ")}`);
+      }
+      lines.push(`- **Reasoning:** ${decision.reasoning}`);
+      lines.push("");
+    }
+  }
+  if (trajectory.chapters.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Chapters");
+    lines.push("");
+    trajectory.chapters.forEach((chapter, index) => {
+      lines.push(`### ${index + 1}. ${chapter.title}`);
+      lines.push(`*Agent: ${chapter.agentName}*`);
+      lines.push("");
+      if (chapter.events.length > 0) {
+        const significantEvents = chapter.events.filter(
+          (e) => e.significance === "high" || e.significance === "critical" || e.type === "decision"
+        );
+        if (significantEvents.length > 0) {
+          for (const event of significantEvents) {
+            lines.push(`- ${event.content}`);
+          }
+          lines.push("");
+        }
+      }
+    });
+  }
+  if (trajectory.retrospective?.challenges && trajectory.retrospective.challenges.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Challenges");
+    lines.push("");
+    for (const challenge of trajectory.retrospective.challenges) {
+      lines.push(`- ${challenge}`);
+    }
+    lines.push("");
+  }
+  if (trajectory.retrospective?.learnings && trajectory.retrospective.learnings.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Learnings");
+    lines.push("");
+    for (const learning of trajectory.retrospective.learnings) {
+      lines.push(`- ${learning}`);
+    }
+    lines.push("");
+  }
+  if (trajectory.retrospective?.suggestions && trajectory.retrospective.suggestions.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Suggestions");
+    lines.push("");
+    for (const suggestion of trajectory.retrospective.suggestions) {
+      lines.push(`- ${suggestion}`);
+    }
+    lines.push("");
+  }
+  if (trajectory.commits.length > 0 || trajectory.filesChanged.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Artifacts");
+    lines.push("");
+    if (trajectory.commits.length > 0) {
+      lines.push(`**Commits:** ${trajectory.commits.join(", ")}`);
+    }
+    if (trajectory.filesChanged.length > 0) {
+      lines.push(`**Files changed:** ${trajectory.filesChanged.length}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatStatus(status) {
+  switch (status) {
+    case "active":
+      return "\u{1F504} Active";
+    case "completed":
+      return "\u2705 Completed";
+    case "abandoned":
+      return "\u274C Abandoned";
+    default:
+      return status;
+  }
+}
+function formatDate(isoString) {
+  const date = new Date(isoString);
+  return date.toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+function extractDecisions(trajectory) {
+  const decisions = [];
+  if (trajectory.retrospective?.decisions) {
+    decisions.push(...trajectory.retrospective.decisions);
+  }
+  for (const chapter of trajectory.chapters) {
+    for (const event of chapter.events) {
+      if (event.type === "decision" && event.raw) {
+        const raw = event.raw;
+        if (raw.question && raw.chosen && raw.reasoning) {
+          if (!decisions.some((d) => d.question === raw.question)) {
+            decisions.push(raw);
+          }
+        }
+      }
+    }
+  }
+  return decisions;
+}
+
+// src/storage/file.ts
+function expandPath(path2) {
+  if (path2.startsWith("~")) {
+    return join(process.env.HOME ?? "", path2.slice(1));
+  }
+  return path2;
+}
+function getSearchPaths() {
+  const searchPathsEnv = process.env.TRAJECTORIES_SEARCH_PATHS;
+  if (searchPathsEnv) {
+    return searchPathsEnv.split(":").map((p) => p.trim()).filter(Boolean).map(expandPath);
+  }
+  const dataDir = process.env.TRAJECTORIES_DATA_DIR;
+  if (dataDir) {
+    return [expandPath(dataDir)];
+  }
+  return [join(process.cwd(), ".trajectories")];
+}
+var FileStorage = class {
+  baseDir;
+  trajectoriesDir;
+  activeDir;
+  completedDir;
+  indexPath;
+  constructor(baseDir) {
+    this.baseDir = baseDir ?? process.cwd();
+    const dataDir = process.env.TRAJECTORIES_DATA_DIR;
+    if (dataDir) {
+      this.trajectoriesDir = expandPath(dataDir);
+    } else {
+      this.trajectoriesDir = join(this.baseDir, ".trajectories");
+    }
+    this.activeDir = join(this.trajectoriesDir, "active");
+    this.completedDir = join(this.trajectoriesDir, "completed");
+    this.indexPath = join(this.trajectoriesDir, "index.json");
+  }
+  /**
+   * Initialize storage directories
+   */
+  async initialize() {
+    await mkdir(this.trajectoriesDir, { recursive: true });
+    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 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.
+   *
+   * Handles three on-disk layouts in completed/:
+   *   - flat:      completed/{id}.json         (legacy workforce data)
+   *   - monthly:   completed/YYYY-MM/{id}.json (current save() writes)
+   *   - 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.
+   */
+  async reconcileIndex() {
+    const summary = {
+      scanned: 0,
+      added: 0,
+      alreadyIndexed: 0,
+      skippedMalformedJson: 0,
+      skippedSchemaViolation: 0,
+      skippedIoError: 0
+    };
+    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;
+      }
+      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}`];
+      if (summary.skippedMalformedJson > 0) {
+        parts.push(`malformed: ${summary.skippedMalformedJson}`);
+      }
+      if (summary.skippedSchemaViolation > 0) {
+        parts.push(`invalid: ${summary.skippedSchemaViolation}`);
+      }
+      if (summary.skippedIoError > 0) {
+        parts.push(`io: ${summary.skippedIoError}`);
+      }
+      console.warn(`[trajectories] ${parts.join(", ")}`);
+    }
+    return summary;
+  }
+  /**
+   * Recursively collect all .json file paths under `dir` into `out`.
+   * Silently treats a missing directory as empty.
+   */
+  async walkJsonFilesInto(dir, out) {
+    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.walkJsonFilesInto(entryPath, out);
+      } else if (entry.isFile() && entry.name.endsWith(".json")) {
+        out.push(entryPath);
+      }
+    }
+  }
+  /**
+   * Save a trajectory.
+   *
+   * Validates the input against the trajectory schema before touching
+   * disk. Closes the historical read/write asymmetry where save() would
+   * happily write data that the reader then rejected, producing files
+   * that could never be loaded back.
+   */
+  async save(input) {
+    const validation = validateTrajectory(input);
+    if (!validation.success) {
+      const issues = validation.errors?.issues.map((issue) => {
+        const path2 = issue.path.length > 0 ? issue.path.join(".") : "root";
+        return `${path2}: ${issue.message}`;
+      }).join("; ") ?? "unknown validation error";
+      throw new Error(`Cannot save invalid trajectory: ${issues}`);
+    }
+    const trajectory = validation.data;
+    const isCompleted = trajectory.status === "completed" || trajectory.status === "abandoned";
+    let filePath;
+    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");
+    } else {
+      filePath = join(this.activeDir, `${trajectory.id}.json`);
+    }
+    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);
+        }
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        console.error("Error searching completed trajectories:", error);
+      }
+    }
+    return null;
+  }
+  /**
+   * 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);
+      return null;
+    }
+  }
+  /**
+   * List trajectories with optional filtering
+   */
+  async list(query) {
+    const index = await this.loadIndex();
+    let entries = Object.entries(index.trajectories);
+    if (query.status) {
+      entries = entries.filter(([, entry]) => entry.status === query.status);
+    }
+    if (query.since) {
+      const sinceTime = new Date(query.since).getTime();
+      entries = entries.filter(
+        ([, entry]) => new Date(entry.startedAt).getTime() >= sinceTime
+      );
+    }
+    if (query.until) {
+      const untilTime = new Date(query.until).getTime();
+      entries = entries.filter(
+        ([, entry]) => new Date(entry.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] ?? "";
+      const cmp = String(aVal).localeCompare(String(bVal));
+      return sortOrder === "asc" ? cmp : -cmp;
+    });
+    const offset = query.offset ?? 0;
+    const limit = query.limit ?? 50;
+    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
+        };
+      })
+    );
+  }
+  /**
+   * Delete a trajectory
+   */
+  async delete(id) {
+    const activePath = join(this.activeDir, `${id}.json`);
+    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);
+      }
+    }
+    delete index.trajectories[id];
+    await this.saveIndex(index);
+  }
+  /**
+   * Search trajectories by text
+   */
+  async search(text, options) {
+    const allTrajectories = await this.list({});
+    const searchLower = text.toLowerCase();
+    const limit = options?.limit ?? 20;
+    const matches = [];
+    for (const summary of allTrajectories) {
+      if (matches.length >= limit) break;
+      if (summary.title.toLowerCase().includes(searchLower)) {
+        matches.push(summary);
+        continue;
+      }
+      const trajectory = await this.get(summary.id);
+      if (!trajectory) continue;
+      if (trajectory.retrospective?.summary.toLowerCase().includes(searchLower)) {
+        matches.push(summary);
+        continue;
+      }
+      const hasMatchingDecision = trajectory.chapters.some(
+        (chapter) => chapter.events.some(
+          (event) => event.type === "decision" && event.content.toLowerCase().includes(searchLower)
+        )
+      );
+      if (hasMatchingDecision) {
+        matches.push(summary);
+      }
+    }
+    return matches;
+  }
+  /**
+   * Close storage (no-op for file storage)
+   */
+  async close() {
+  }
+  // Private helpers
+  /**
+   * Read a trajectory file and return a tagged result so callers can
+   * distinguish missing files, malformed JSON, and schema violations.
+   *
+   * Does NOT log. Callers choose whether to warn, swallow, or throw.
+   */
+  async readTrajectoryFile(path2) {
+    let content;
+    try {
+      content = await readFile(path2, "utf-8");
+    } catch (error) {
+      return { ok: false, reason: "io_error", path: path2, error };
+    }
+    let data;
+    try {
+      data = JSON.parse(content);
+    } catch (error) {
+      return { ok: false, reason: "malformed_json", path: path2, error };
+    }
+    const validation = validateTrajectory(data);
+    if (validation.success) {
+      return { ok: true, trajectory: validation.data };
+    }
+    return {
+      ok: false,
+      reason: "schema_violation",
+      path: path2,
+      error: validation.errors
+    };
+  }
+  /**
+   * Convenience wrapper for callers that only care whether they got a
+   * trajectory. Returns null for any failure and writes nothing to the
+   * console — so nothing leaks into test output or the CLI spinner.
+   */
+  async readTrajectoryOrNull(path2) {
+    const result = await this.readTrajectoryFile(path2);
+    return result.ok ? result.trajectory : null;
+  }
+  async loadIndex() {
+    try {
+      const content = await readFile(this.indexPath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        console.error(
+          "Error loading trajectory index, using empty index:",
+          error
+        );
+      }
+      return {
+        version: 1,
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+        trajectories: {}
+      };
+    }
+  }
+  async saveIndex(index) {
+    index.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    await writeFile(this.indexPath, JSON.stringify(index, null, 2), "utf-8");
+  }
+  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);
+  }
+};
+
+// src/cli/commands/abandon.ts
+function registerAbandonCommand(program2) {
+  program2.command("abandon").description("Abandon the active trajectory").option("-r, --reason <text>", "Reason for abandonment").action(async (options) => {
+    const storage = new FileStorage();
+    await storage.initialize();
+    const active = await storage.getActive();
+    if (!active) {
+      console.error("Error: No active trajectory");
+      throw new Error("No active trajectory");
+    }
+    const abandoned = abandonTrajectory(active, options.reason);
+    await storage.save(abandoned);
+    console.log(`\u2713 Trajectory abandoned: ${abandoned.id}`);
+    if (options.reason) {
+      console.log(`  Reason: ${options.reason}`);
+    }
+  });
+}
+
+// src/cli/commands/compact.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { dirname, join as join4 } from "path";
+
+// src/compact/config.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { join as join2 } from "path";
+var DEFAULT_CONFIG = {
+  provider: "auto",
+  model: void 0,
+  maxInputTokens: 3e4,
+  maxOutputTokens: 4e3,
+  temperature: 0.3
+};
+function getCompactionConfig() {
+  const fileConfig = loadFileConfig();
+  return {
+    provider: readStringEnv("TRAJECTORIES_LLM_PROVIDER") ?? readString(fileConfig.provider) ?? DEFAULT_CONFIG.provider,
+    model: readStringEnv("TRAJECTORIES_LLM_MODEL") ?? readString(fileConfig.model) ?? DEFAULT_CONFIG.model,
+    maxInputTokens: readNumberEnv("TRAJECTORIES_LLM_MAX_INPUT_TOKENS") ?? readNumber(fileConfig.maxInputTokens) ?? DEFAULT_CONFIG.maxInputTokens,
+    maxOutputTokens: readNumberEnv("TRAJECTORIES_LLM_MAX_OUTPUT_TOKENS") ?? readNumber(fileConfig.maxOutputTokens) ?? DEFAULT_CONFIG.maxOutputTokens,
+    temperature: readNumberEnv("TRAJECTORIES_LLM_TEMPERATURE") ?? readNumber(fileConfig.temperature) ?? DEFAULT_CONFIG.temperature
+  };
+}
+function loadFileConfig() {
+  const configPath = join2(getPrimaryConfigDir(), "config.json");
+  if (!existsSync2(configPath)) {
+    return {};
+  }
+  try {
+    const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+    if (!isRecord(raw)) {
+      return {};
+    }
+    const merged = {};
+    for (const section of [raw, raw.compaction, raw.llm]) {
+      if (!isRecord(section)) {
+        continue;
+      }
+      for (const [key, value] of Object.entries(section)) {
+        if (key === "compaction" || key === "llm") {
+          continue;
+        }
+        merged[key] = value;
+      }
+    }
+    return {
+      provider: readString(merged.provider),
+      model: readString(merged.model),
+      maxInputTokens: readNumber(merged.maxInputTokens),
+      maxOutputTokens: readNumber(merged.maxOutputTokens),
+      temperature: readNumber(merged.temperature)
+    };
+  } catch {
+    return {};
+  }
+}
+function getPrimaryConfigDir() {
+  const searchPaths = getSearchPaths();
+  return searchPaths[0] ?? join2(process.cwd(), ".trajectories");
+}
+function readStringEnv(name) {
+  return readString(process.env[name]);
+}
+function readNumberEnv(name) {
+  return readNumber(process.env[name]);
+}
+function readString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function readNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  const parsed = Number(trimmed);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/compact/markdown.ts
+function generateCompactionMarkdown(compacted) {
+  const dateRange = `${formatDate2(compacted.dateRange.start)} - ${formatDate2(compacted.dateRange.end)}`;
+  const agents = compacted.summary.uniqueAgents.length > 0 ? compacted.summary.uniqueAgents.join(", ") : "None";
+  const decisionRows = compacted.decisions.length > 0 ? compacted.decisions.map(
+    (decision) => `| ${escapeTableCell(decision.question)} | ${escapeTableCell(decision.chosen)} | ${escapeTableCell(decision.impact)} |`
+  ).join("\n") : "| None identified |  |  |";
+  const conventions = compacted.conventions.length > 0 ? compacted.conventions.map(
+    (convention) => `- **${convention.pattern || "Unnamed pattern"}**: ${convention.rationale || "No rationale captured."} (scope: ${convention.scope || "unspecified"})`
+  ).join("\n") : "- None established.";
+  const lessons = compacted.lessons.length > 0 ? compacted.lessons.map((lesson) => {
+    const context = lesson.context ? ` (${lesson.context})` : "";
+    const recommendation = lesson.recommendation ? ` - ${lesson.recommendation}` : "";
+    return `- ${lesson.lesson}${context}${recommendation}`;
+  }).join("\n") : "- None captured.";
+  const openQuestions = compacted.openQuestions.length > 0 ? compacted.openQuestions.map((question) => `- ${question}`).join("\n") : "- None.";
+  return [
+    `# Trajectory Compaction: ${dateRange}`,
+    "",
+    "## Summary",
+    compacted.narrative || "No narrative available.",
+    "",
+    `## Key Decisions (${compacted.decisions.length})`,
+    "| Question | Decision | Impact |",
+    "|----------|----------|--------|",
+    decisionRows,
+    "",
+    "## Conventions Established",
+    conventions,
+    "",
+    "## Lessons Learned",
+    lessons,
+    "",
+    "## Open Questions",
+    openQuestions,
+    "",
+    "## Stats",
+    `- Sessions: ${compacted.sourceTrajectories.length}, Agents: ${agents}, Files: ${compacted.filesAffected.length}, Commits: ${compacted.commits.length}`,
+    `- Date range: ${compacted.dateRange.start} - ${compacted.dateRange.end}`
+  ].join("\n");
+}
+function formatDate2(value) {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return value;
+  }
+  return date.toISOString().slice(0, 10);
+}
+function escapeTableCell(value) {
+  return value.replace(/\|/g, "\\|").replace(/\n/g, " ");
+}
+
+// src/compact/parser.ts
+function parseCompactionResponse(llmOutput) {
+  const trimmed = llmOutput.trim();
+  const parsedJson = parseJsonCandidate(trimmed) ?? parseJsonCandidate(extractFirstMarkdownJsonBlock(trimmed)) ?? parseJsonCandidate(extractBalancedJsonObject(trimmed));
+  if (parsedJson) {
+    return normalizeCompactionOutput(parsedJson, trimmed);
+  }
+  return normalizeCompactionOutput(extractFromProse(trimmed), trimmed);
+}
+function mergeCompactionWithMetadata(metadata, llmOutput) {
+  return {
+    ...metadata,
+    ...llmOutput
+  };
+}
+function parseJsonCandidate(candidate) {
+  if (!candidate) {
+    return null;
+  }
+  try {
+    return JSON.parse(candidate);
+  } catch {
+    return null;
+  }
+}
+function extractFirstMarkdownJsonBlock(text) {
+  const match = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  return match ? match[1].trim() : null;
+}
+function extractBalancedJsonObject(text) {
+  const start = text.indexOf("{");
+  if (start === -1) {
+    return null;
+  }
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let index = start; index < text.length; index += 1) {
+    const char = text[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) {
+      continue;
+    }
+    if (char === "{") {
+      depth += 1;
+    } else if (char === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return text.slice(start, index + 1);
+      }
+    }
+  }
+  return null;
+}
+function extractFromProse(text) {
+  const sections = splitSections(text);
+  const narrativeSection = sections.narrative ?? sections.summary ?? leadingNarrative(text);
+  return {
+    narrative: normalizeText(narrativeSection),
+    decisions: parseDecisionSection(
+      sections["key decisions"] ?? sections.decisions ?? ""
+    ),
+    conventions: parseConventionSection(
+      sections["conventions established"] ?? sections.conventions ?? ""
+    ),
+    lessons: parseLessonSection(
+      sections["lessons learned"] ?? sections.lessons ?? ""
+    ),
+    openQuestions: parseStringList(
+      sections["open questions"] ?? sections.questions ?? ""
+    )
+  };
+}
+function splitSections(text) {
+  const matches = [...text.matchAll(/^##+\s+(.+?)\s*$/gm)];
+  const sections = {};
+  for (let index = 0; index < matches.length; index += 1) {
+    const current = matches[index];
+    const next = matches[index + 1];
+    const title = normalizeHeading(current[1]);
+    const start = current.index === void 0 ? 0 : current.index + current[0].length;
+    const end = next?.index ?? text.length;
+    sections[title] = text.slice(start, end).trim();
+  }
+  return sections;
+}
+function normalizeHeading(value) {
+  return value.toLowerCase().replace(/\(\d+\)/g, "").replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
+}
+function leadingNarrative(text) {
+  const beforeHeading = text.split(/^##+\s+/m, 1)[0] ?? "";
+  const withoutCode = beforeHeading.replace(/```[\s\S]*?```/g, "").trim();
+  return withoutCode;
+}
+function normalizeCompactionOutput(raw, fallbackNarrativeSource) {
+  const candidate = isRecord2(raw) ? raw : {};
+  const narrative = normalizeText(
+    typeof candidate.narrative === "string" ? candidate.narrative : typeof candidate.summary === "string" ? candidate.summary : typeof candidate.overview === "string" ? candidate.overview : leadingNarrative(fallbackNarrativeSource)
+  );
+  return {
+    narrative: narrative || normalizeText(fallbackNarrativeSource) || "No narrative provided.",
+    decisions: normalizeDecisionArray(candidate.decisions),
+    conventions: normalizeConventionArray(candidate.conventions),
+    lessons: normalizeLessonArray(candidate.lessons),
+    openQuestions: normalizeStringArray(
+      candidate.openQuestions ?? candidate.open_questions ?? candidate.questions
+    )
+  };
+}
+function normalizeDecisionArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => {
+    if (typeof entry === "string") {
+      return {
+        question: normalizeText(entry),
+        chosen: "",
+        reasoning: "",
+        impact: ""
+      };
+    }
+    if (!isRecord2(entry)) {
+      return null;
+    }
+    return {
+      question: readString2(entry, ["question", "prompt", "topic"]),
+      chosen: readString2(entry, ["chosen", "decision", "answer"]),
+      reasoning: readString2(entry, ["reasoning", "why", "rationale"]),
+      impact: readString2(entry, ["impact", "result", "outcome"])
+    };
+  }).filter((entry) => {
+    return entry !== null && hasContent(Object.values(entry));
+  });
+}
+function normalizeConventionArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => {
+    if (typeof entry === "string") {
+      return {
+        pattern: normalizeText(entry),
+        rationale: "",
+        scope: ""
+      };
+    }
+    if (!isRecord2(entry)) {
+      return null;
+    }
+    return {
+      pattern: readString2(entry, ["pattern", "rule", "convention"]),
+      rationale: readString2(entry, ["rationale", "reasoning", "why"]),
+      scope: readString2(entry, ["scope", "appliesTo", "applies_to"])
+    };
+  }).filter((entry) => {
+    return entry !== null && hasContent(Object.values(entry));
+  });
+}
+function normalizeLessonArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => {
+    if (typeof entry === "string") {
+      return {
+        lesson: normalizeText(entry),
+        context: "",
+        recommendation: ""
+      };
+    }
+    if (!isRecord2(entry)) {
+      return null;
+    }
+    return {
+      lesson: readString2(entry, ["lesson", "learning", "takeaway"]),
+      context: readString2(entry, ["context", "situation", "when"]),
+      recommendation: readString2(entry, [
+        "recommendation",
+        "suggestion",
+        "nextStep",
+        "next_step"
+      ])
+    };
+  }).filter((entry) => {
+    return entry !== null && hasContent(Object.values(entry));
+  });
+}
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => typeof entry === "string" ? normalizeText(entry) : "").filter(Boolean);
+}
+function parseDecisionSection(section) {
+  const tableDecisions = parseMarkdownTable(section).map((row) => ({
+    question: row[0] ?? "",
+    chosen: row[1] ?? "",
+    reasoning: row[2] ?? "",
+    impact: row[3] ?? row[2] ?? ""
+  }));
+  if (tableDecisions.length > 0) {
+    return tableDecisions.filter((entry) => hasContent(Object.values(entry)));
+  }
+  return parseListItems(section).map((item) => {
+    const fields = parseFieldMap(item);
+    return {
+      question: fields.question ?? fields.prompt ?? fields.topic ?? fields.title ?? item,
+      chosen: fields.chosen ?? fields.decision ?? fields.answer ?? "",
+      reasoning: fields.reasoning ?? fields.rationale ?? fields.why ?? "",
+      impact: fields.impact ?? fields.outcome ?? fields.result ?? ""
+    };
+  }).filter((entry) => hasContent(Object.values(entry)));
+}
+function parseConventionSection(section) {
+  return parseListItems(section).map((item) => {
+    const emphasized = item.match(/^\*\*(.+?)\*\*:\s*(.+)$/);
+    const scopeMatch = item.match(/\((?:scope|applies to):\s*([^)]+)\)\s*$/i);
+    const withoutScope = scopeMatch ? item.slice(0, scopeMatch.index).trim() : item;
+    if (emphasized) {
+      return {
+        pattern: normalizeText(emphasized[1]),
+        rationale: normalizeText(
+          withoutScope.replace(/^\*\*(.+?)\*\*:\s*/, "")
+        ),
+        scope: normalizeText(scopeMatch?.[1] ?? "")
+      };
+    }
+    const fields = parseFieldMap(item);
+    return {
+      pattern: fields.pattern ?? fields.convention ?? fields.rule ?? item,
+      rationale: fields.rationale ?? fields.reasoning ?? fields.why ?? "",
+      scope: fields.scope ?? fields.applies ?? ""
+    };
+  }).filter((entry) => hasContent(Object.values(entry)));
+}
+function parseLessonSection(section) {
+  return parseListItems(section).map((item) => {
+    const fields = parseFieldMap(item);
+    const dashParts = item.split(/\s[—-]\s/, 2);
+    return {
+      lesson: fields.lesson ?? fields.learning ?? fields.takeaway ?? dashParts[0] ?? item,
+      context: fields.context ?? "",
+      recommendation: fields.recommendation ?? fields.suggestion ?? fields.nextstep ?? dashParts[1] ?? ""
+    };
+  }).filter((entry) => hasContent(Object.values(entry)));
+}
+function parseStringList(section) {
+  return parseListItems(section).map(normalizeText).filter(Boolean);
+}
+function parseMarkdownTable(section) {
+  const lines = section.split("\n").map((line) => line.trim()).filter((line) => line.startsWith("|"));
+  if (lines.length < 2) {
+    return [];
+  }
+  return lines.slice(1).filter((line) => !/^\|?\s*:?-{3,}/.test(line.replace(/\|/g, ""))).map(
+    (line) => line.split("|").slice(1, -1).map((cell) => normalizeText(cell))
+  );
+}
+function parseListItems(section) {
+  return section.split("\n").map((line) => line.trim()).filter((line) => /^[-*] |\d+\.\s/.test(line)).map((line) => line.replace(/^[-*]\s+|\d+\.\s+/, "").trim()).filter(Boolean);
+}
+function parseFieldMap(item) {
+  const normalized = item.replace(/\s+\|\s+/g, "; ");
+  const segments = normalized.split(/;\s+/);
+  const fields = {};
+  for (const segment of segments) {
+    const match = segment.match(/^([A-Za-z ]+):\s*(.+)$/);
+    if (!match) {
+      continue;
+    }
+    const key = match[1].toLowerCase().replace(/\s+/g, "");
+    fields[key] = normalizeText(match[2]);
+  }
+  return fields;
+}
+function readString2(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string") {
+      return normalizeText(value);
+    }
+  }
+  return "";
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function normalizeText(value) {
+  return value.replace(/\r\n/g, "\n").replace(/\s+/g, " ").trim();
+}
+function hasContent(values) {
+  return values.some((value) => value.trim().length > 0);
+}
+
+// src/compact/prompts.ts
+var COMPACTION_SYSTEM_PROMPT = `You are a technical analyst reviewing agent work sessions (trajectories).
+Your job is to produce a concise, insightful summary that captures:
+- What was accomplished and how
+- Key decisions and their reasoning
+- Patterns/conventions established that should be followed in future work
+- Lessons learned from challenges and failures
+- Open questions or unresolved issues
+
+Be specific. Reference actual file paths, function names, and technical details.
+Don't be generic - this summary replaces the raw data.`;
+var COMPACTED_OUTPUT_SCHEMA = `{
+  "narrative": "string",
+  "decisions": [
+    {
+      "question": "string",
+      "chosen": "string",
+      "reasoning": "string",
+      "impact": "string"
+    }
+  ],
+  "conventions": [
+    {
+      "pattern": "string",
+      "rationale": "string",
+      "scope": "string"
+    }
+  ],
+  "lessons": [
+    {
+      "lesson": "string",
+      "context": "string",
+      "recommendation": "string"
+    }
+  ],
+  "openQuestions": ["string"]
+}`;
+function buildCompactionPrompt(serializedTrajectories, options = {}) {
+  const focusAreas = options.focusAreas && options.focusAreas.length > 0 ? options.focusAreas.map((area) => `- ${area}`).join("\n") : [
+    "- What work was attempted, completed, or abandoned",
+    "- Why specific technical decisions were made",
+    "- Which conventions should carry forward",
+    "- What broke, what worked, and what should change next time"
+  ].join("\n");
+  const maxOutputInstruction = options.maxOutputTokens ? `Keep the full response within approximately ${options.maxOutputTokens} tokens while preserving technical specificity.` : "Keep the response concise, dense with signal, and avoid filler.";
+  const userPrompt = [
+    "Review the following serialized agent trajectories and return a single JSON object.",
+    "The JSON must match this schema exactly:",
+    COMPACTED_OUTPUT_SCHEMA,
+    "",
+    "Requirements:",
+    "- Output raw JSON only. Do not wrap it in markdown fences.",
+    "- `narrative` should be 2-3 tight paragraphs.",
+    "- `decisions`, `conventions`, and `lessons` must always be arrays, even if empty.",
+    "- Prefer concrete file paths, symbols, commands, and implementation details over generic summaries.",
+    maxOutputInstruction,
+    "",
+    "Focus areas:",
+    focusAreas,
+    "",
+    "Serialized trajectories:",
+    serializedTrajectories.trim()
+  ].join("\n");
+  return [
+    {
+      role: "system",
+      content: COMPACTION_SYSTEM_PROMPT
+    },
+    {
+      role: "user",
+      content: userPrompt
+    }
+  ];
+}
+
+// src/compact/provider.ts
+import { execFile, spawn } from "child_process";
+import { constants, accessSync } from "fs";
+import { homedir } from "os";
+import { join as join3 } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var DEFAULT_OPENAI_MODEL = "gpt-4o";
+var DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-4-20250514";
+var DEFAULT_OPENAI_BASE_URL = "https://api.openai.com";
+var DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com";
+var DEFAULT_MAX_TOKENS = 4096;
+var OpenAIProvider = class {
+  apiKey;
+  model;
+  baseUrl;
+  constructor(config = {}) {
+    this.apiKey = config.apiKey?.trim() || process.env.OPENAI_API_KEY?.trim() || "";
+    this.model = normalizeModel(config.model) ?? normalizeModel(process.env.TRAJECTORIES_LLM_MODEL) ?? DEFAULT_OPENAI_MODEL;
+    this.baseUrl = config.baseUrl ?? process.env.OPENAI_BASE_URL ?? DEFAULT_OPENAI_BASE_URL;
+    if (this.baseUrl !== DEFAULT_OPENAI_BASE_URL) {
+      console.warn(
+        `[trajectories] OpenAI base URL overridden to: ${this.baseUrl}`
+      );
+    }
+    if (!this.apiKey) {
+      throw new Error("OPENAI_API_KEY is required for OpenAIProvider");
+    }
+  }
+  async complete(messages, options = {}) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3e5);
+    try {
+      const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          model: this.model,
+          messages,
+          max_tokens: options.maxTokens ?? DEFAULT_MAX_TOKENS,
+          temperature: options.temperature ?? 0.2,
+          response_format: options.jsonMode ? { type: "json_object" } : void 0
+        }),
+        signal: controller.signal
+      });
+      const body = await parseJson(response);
+      if (!response.ok) {
+        throw new Error(
+          body.error?.message ?? `OpenAI request failed with status ${response.status}`
+        );
+      }
+      const content = body.choices?.[0]?.message?.content;
+      if (!content) {
+        throw new Error("OpenAI response did not include completion content");
+      }
+      return content;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+var AnthropicProvider = class {
+  apiKey;
+  model;
+  baseUrl;
+  constructor(config = {}) {
+    this.apiKey = config.apiKey?.trim() || process.env.ANTHROPIC_API_KEY?.trim() || "";
+    this.model = normalizeModel(config.model) ?? normalizeModel(process.env.TRAJECTORIES_LLM_MODEL) ?? DEFAULT_ANTHROPIC_MODEL;
+    this.baseUrl = config.baseUrl ?? process.env.ANTHROPIC_BASE_URL ?? DEFAULT_ANTHROPIC_BASE_URL;
+    if (this.baseUrl !== DEFAULT_ANTHROPIC_BASE_URL) {
+      console.warn(
+        `[trajectories] Anthropic base URL overridden to: ${this.baseUrl}`
+      );
+    }
+    if (!this.apiKey) {
+      throw new Error("ANTHROPIC_API_KEY is required for AnthropicProvider");
+    }
+  }
+  async complete(messages, options = {}) {
+    const systemMessages = messages.filter((message) => message.role === "system").map((message) => message.content.trim()).filter(Boolean);
+    const conversation = messages.filter((message) => message.role !== "system").map((message) => ({
+      role: message.role,
+      content: message.content
+    }));
+    if (conversation.length === 0) {
+      throw new Error("AnthropicProvider requires at least one user message");
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3e5);
+    try {
+      const response = await fetch(`${this.baseUrl}/v1/messages`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "anthropic-version": "2024-10-22",
+          "x-api-key": this.apiKey
+        },
+        body: JSON.stringify({
+          model: this.model,
+          system: systemMessages.length > 0 ? systemMessages.join("\n\n") : void 0,
+          messages: conversation,
+          max_tokens: options.maxTokens ?? DEFAULT_MAX_TOKENS,
+          temperature: options.temperature ?? 0.2
+        }),
+        signal: controller.signal
+      });
+      const body = await parseJson(response);
+      if (!response.ok) {
+        throw new Error(
+          body.error?.message ?? `Anthropic request failed with status ${response.status}`
+        );
+      }
+      const textBlocks = (body.content ?? []).filter(
+        (block) => block.type === "text" && typeof block.text === "string"
+      );
+      const content = textBlocks.map((block) => block.text).join("\n").trim();
+      if (!content) {
+        throw new Error("Anthropic response did not include text content");
+      }
+      return content;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+var SUPPORTED_CLIS = ["claude", "codex", "gemini", "opencode"];
+var CLIProvider = class {
+  cli;
+  binaryPath;
+  constructor(cli, binaryPath) {
+    this.cli = cli;
+    this.binaryPath = binaryPath;
+  }
+  get cliName() {
+    return this.cli;
+  }
+  async complete(messages, _options = {}) {
+    const prompt = messagesToPrompt(messages);
+    const args = buildCliArgs(this.cli);
+    const output = await spawnWithStdin(this.binaryPath, args, prompt);
+    if (!output) {
+      throw new Error(`${this.cli} CLI returned empty output`);
+    }
+    return output;
+  }
+};
+function messagesToPrompt(messages) {
+  const systemParts = [];
+  const conversationParts = [];
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      systemParts.push(msg.content.trim());
+    } else {
+      conversationParts.push(msg.content.trim());
+    }
+  }
+  const parts = [];
+  if (systemParts.length > 0) {
+    parts.push(systemParts.join("\n\n"));
+  }
+  if (conversationParts.length > 0) {
+    parts.push(conversationParts.join("\n\n"));
+  }
+  return parts.join("\n\n---\n\n");
+}
+function buildCliArgs(cli) {
+  switch (cli) {
+    case "claude":
+      return ["-p", "--output-format", "text"];
+    case "codex":
+      return ["exec", "-q"];
+    case "gemini":
+      return ["-p"];
+    case "opencode":
+      return ["run", "--no-color"];
+  }
+}
+function spawnWithStdin(command, args, input) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      timeout: 3e5,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const chunks = [];
+    child.stdout.on("data", (chunk) => chunks.push(chunk));
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code !== 0) {
+        reject(
+          new Error(`CLI exited with code ${code}: ${stderr.slice(0, 200)}`)
+        );
+      } else {
+        resolve(Buffer.concat(chunks).toString().trim());
+      }
+    });
+    child.stdin.write(input);
+    child.stdin.end();
+  });
+}
+async function resolveProvider(config = {}) {
+  const explicitProvider = (config.provider ?? process.env.TRAJECTORIES_LLM_PROVIDER)?.toLowerCase();
+  const model = normalizeModel(config.model);
+  if (explicitProvider === "openai") {
+    return process.env.OPENAI_API_KEY ? new OpenAIProvider({ model }) : null;
+  }
+  if (explicitProvider === "anthropic") {
+    return process.env.ANTHROPIC_API_KEY ? new AnthropicProvider({ model }) : null;
+  }
+  if (explicitProvider === "cli") {
+    return resolveCLIProvider();
+  }
+  if (explicitProvider && explicitProvider !== "auto") {
+    return null;
+  }
+  const cliProvider = await resolveCLIProvider();
+  if (cliProvider) {
+    return cliProvider;
+  }
+  if (process.env.OPENAI_API_KEY) {
+    return new OpenAIProvider({ model });
+  }
+  if (process.env.ANTHROPIC_API_KEY) {
+    return new AnthropicProvider({ model });
+  }
+  return null;
+}
+var CLI_SEARCH_PATHS = [
+  "~/.local/bin",
+  "~/.claude/local",
+  "/usr/local/bin",
+  "/opt/homebrew/bin"
+];
+async function resolveCLIProvider() {
+  const requestedCli = process.env.TRAJECTORIES_LLM_CLI?.trim().toLowerCase();
+  const clisToTry = (() => {
+    if (!requestedCli) {
+      return SUPPORTED_CLIS;
+    }
+    if (SUPPORTED_CLIS.includes(requestedCli)) {
+      return [requestedCli];
+    }
+    console.warn(
+      `[trajectories] Unsupported TRAJECTORIES_LLM_CLI value "${requestedCli}", falling back to auto-detect`
+    );
+    return SUPPORTED_CLIS;
+  })();
+  for (const cli of clisToTry) {
+    const path2 = await findBinary(cli);
+    if (path2) {
+      return new CLIProvider(cli, path2);
+    }
+  }
+  return null;
+}
+async function findBinary(name) {
+  try {
+    const { stdout } = await execFileAsync("which", [name]);
+    const path2 = stdout.trim();
+    if (path2) return path2;
+  } catch {
+  }
+  const home = homedir();
+  for (const dir of CLI_SEARCH_PATHS) {
+    const expanded = dir.startsWith("~/") ? join3(home, dir.slice(2)) : dir;
+    const candidate = join3(expanded, name);
+    try {
+      accessSync(candidate, constants.X_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function normalizeModel(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+async function parseJson(response) {
+  const text = await response.text();
+  if (!text) {
+    return {};
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(
+      `Invalid JSON response (status ${response.status}, length ${text.length})`
+    );
+  }
+}
+
+// src/compact/serializer.ts
+var DEFAULT_MAX_TOKENS2 = 3e4;
+var CHARS_PER_TOKEN = 4;
+var INCLUDED_SIGNIFICANCE = /* @__PURE__ */ new Set([
+  "medium",
+  "high",
+  "critical"
+]);
+function serializeForLLM(trajectories, maxTokens = DEFAULT_MAX_TOKENS2) {
+  const maxChars = Math.max(0, maxTokens * CHARS_PER_TOKEN);
+  const sessions = trajectories.map(renderSession);
+  let document = joinSessions(sessions);
+  if (document.length <= maxChars || sessions.length === 0) {
+    return document;
+  }
+  const fixedChars = sessions.reduce(
+    (total, session) => total + session.header.length + session.agents.length + session.decisions.length + session.findings.length + session.retrospective.length + session.filesAndCommits.length,
+    0
+  );
+  const chapterChars = sessions.reduce(
+    (total, session) => total + session.chapters.reduce((sum, chapter) => sum + chapter.length, 0),
+    0
+  );
+  const remainingChapterChars = maxChars - fixedChars;
+  if (remainingChapterChars <= 0 || chapterChars === 0) {
+    return truncateText(document, maxChars);
+  }
+  const ratio = Math.min(1, remainingChapterChars / chapterChars);
+  const truncatedSessions = sessions.map((session) => ({
+    ...session,
+    chapters: truncateChapters(
+      session.chapters,
+      session.chapters.reduce((sum, chapter) => sum + chapter.length, 0),
+      ratio
+    )
+  }));
+  document = joinSessions(truncatedSessions);
+  return document.length <= maxChars ? document : truncateText(document, maxChars);
+}
+function renderSession(trajectory) {
+  const sessionTitle = trajectory.task.title.trim() || trajectory.id;
+  const duration = formatDuration(trajectory.startedAt, trajectory.completedAt);
+  const header = [
+    `## Session: ${sessionTitle} (${trajectory.status}, ${duration})`,
+    trajectory.task.description ? `Description: ${trajectory.task.description}` : "",
+    `Started: ${trajectory.startedAt}`,
+    trajectory.completedAt ? `Completed: ${trajectory.completedAt}` : ""
+  ].filter(Boolean).join("\n").concat("\n");
+  const agents = trajectory.agents.length > 0 ? `Agents: ${trajectory.agents.map((agent) => `${agent.name} (${agent.role})`).join(", ")}
+` : "Agents: none recorded\n";
+  const chapters = trajectory.chapters.map(renderChapter);
+  const decisions = renderDecisions(trajectory);
+  const findings = renderFindings(trajectory);
+  const retrospective = renderRetrospective(trajectory.retrospective);
+  const filesAndCommits = [
+    `Files changed: ${formatList(trajectory.filesChanged)}`,
+    `Commits: ${formatList(trajectory.commits)}`
+  ].join("\n").concat("\n");
+  return {
+    header,
+    agents,
+    chapters,
+    decisions,
+    findings,
+    retrospective,
+    filesAndCommits
+  };
+}
+function renderChapter(chapter) {
+  const lines = chapter.events.filter(shouldIncludeEvent).map((event) => formatEvent(event));
+  const chapterBody = lines.length > 0 ? lines.map((line) => `- ${line}`).join("\n") : "- No medium/high/critical events captured";
+  return [
+    `### Chapter: ${chapter.title}`,
+    `Agent: ${chapter.agentName}`,
+    `Window: ${chapter.startedAt} -> ${chapter.endedAt ?? "ongoing"}`,
+    chapterBody
+  ].join("\n").concat("\n");
+}
+function renderDecisions(trajectory) {
+  const seen = /* @__PURE__ */ new Set();
+  const decisions = [];
+  for (const chapter of trajectory.chapters) {
+    for (const event of chapter.events) {
+      if (event.type !== "decision") {
+        continue;
+      }
+      const decision = asDecision(event.raw);
+      if (!decision) {
+        continue;
+      }
+      const key = `${decision.question}
+${decision.chosen}
+${decision.reasoning}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        decisions.push(decision);
+      }
+    }
+  }
+  for (const decision of trajectory.retrospective?.decisions ?? []) {
+    const key = `${decision.question}
+${decision.chosen}
+${decision.reasoning}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      decisions.push(decision);
+    }
+  }
+  if (decisions.length === 0) {
+    return "Decisions:\n- None recorded\n";
+  }
+  return [
+    "Decisions:",
+    ...decisions.map(
+      (decision) => [
+        `- Question: ${decision.question}`,
+        `  Chosen: ${decision.chosen}`,
+        `  Reasoning: ${decision.reasoning}`
+      ].join("\n")
+    )
+  ].join("\n").concat("\n");
+}
+function renderFindings(trajectory) {
+  const findings = trajectory.chapters.flatMap(
+    (chapter) => chapter.events.filter((event) => event.type === "finding").map((event) => asFinding(event.raw, event.content))
+  );
+  if (findings.length === 0) {
+    return "Findings:\n- None recorded\n";
+  }
+  return [
+    "Findings:",
+    ...findings.map(
+      (finding) => [
+        `- What: ${finding.what}`,
+        `  Where: ${finding.where}`,
+        `  Significance: ${finding.significance}`
+      ].join("\n")
+    )
+  ].join("\n").concat("\n");
+}
+function renderRetrospective(retrospective) {
+  if (!retrospective) {
+    return "Retrospective:\n- None recorded\n";
+  }
+  const lines = [
+    "Retrospective:",
+    `- Summary: ${retrospective.summary}`,
+    `  Approach: ${retrospective.approach}`
+  ];
+  if (retrospective.challenges && retrospective.challenges.length > 0) {
+    lines.push(`  Challenges: ${retrospective.challenges.join("; ")}`);
+  }
+  if (retrospective.learnings && retrospective.learnings.length > 0) {
+    lines.push(`  Learnings: ${retrospective.learnings.join("; ")}`);
+  }
+  if (retrospective.suggestions && retrospective.suggestions.length > 0) {
+    lines.push(`  Suggestions: ${retrospective.suggestions.join("; ")}`);
+  }
+  if (retrospective.timeSpent) {
+    lines.push(`  Time spent: ${retrospective.timeSpent}`);
+  }
+  return lines.join("\n").concat("\n");
+}
+function shouldIncludeEvent(event) {
+  if (event.type === "tool_call" || event.type === "tool_result") {
+    return false;
+  }
+  return INCLUDED_SIGNIFICANCE.has(resolveSignificance(event));
+}
+function resolveSignificance(event) {
+  if (event.significance) {
+    return event.significance;
+  }
+  switch (event.type) {
+    case "decision":
+    case "finding":
+    case "error":
+      return "high";
+    case "reflection":
+    case "note":
+    case "message_sent":
+    case "message_received":
+      return "medium";
+    default:
+      return "low";
+  }
+}
+function formatEvent(event) {
+  if (event.type === "decision") {
+    const decision = asDecision(event.raw);
+    if (decision) {
+      return `[decision/${resolveSignificance(event)}] ${decision.question} -> ${decision.chosen}`;
+    }
+  }
+  if (event.type === "finding") {
+    const finding = asFinding(event.raw, event.content);
+    return `[finding/${resolveSignificance(event)}] ${finding.what} @ ${finding.where}`;
+  }
+  return `[${event.type}/${resolveSignificance(event)}] ${event.content}`;
+}
+function asDecision(raw) {
+  if (!raw || typeof raw !== "object") {
+    return null;
+  }
+  const candidate = raw;
+  if (typeof candidate.question !== "string" || typeof candidate.chosen !== "string" || typeof candidate.reasoning !== "string") {
+    return null;
+  }
+  return {
+    question: candidate.question,
+    chosen: candidate.chosen,
+    reasoning: candidate.reasoning,
+    alternatives: Array.isArray(candidate.alternatives) ? candidate.alternatives : [],
+    confidence: candidate.confidence
+  };
+}
+function asFinding(raw, fallbackContent) {
+  if (!raw || typeof raw !== "object") {
+    return {
+      what: fallbackContent,
+      where: "unknown",
+      significance: "Not structured",
+      category: "other"
+    };
+  }
+  const candidate = raw;
+  return {
+    what: typeof candidate.what === "string" && candidate.what.trim().length > 0 ? candidate.what : fallbackContent,
+    where: typeof candidate.where === "string" && candidate.where.trim().length > 0 ? candidate.where : "unknown",
+    significance: typeof candidate.significance === "string" && candidate.significance.trim().length > 0 ? candidate.significance : "Not structured",
+    category: candidate.category ?? "other",
+    suggestedAction: typeof candidate.suggestedAction === "string" ? candidate.suggestedAction : void 0,
+    confidence: candidate.confidence
+  };
+}
+function truncateChapters(chapters, totalChapterChars, ratio) {
+  if (ratio >= 1 || totalChapterChars === 0) {
+    return chapters;
+  }
+  let remaining = Math.floor(totalChapterChars * ratio);
+  return chapters.map((chapter, index) => {
+    if (remaining <= 0) {
+      return "### Chapter: Truncated\n- Omitted due to token budget\n";
+    }
+    const proportionalTarget = index === chapters.length - 1 ? remaining : Math.floor(chapter.length * ratio);
+    const allowance = Math.max(0, Math.min(chapter.length, proportionalTarget));
+    remaining -= allowance;
+    return truncateText(chapter, allowance);
+  });
+}
+function joinSessions(sessions) {
+  return sessions.map(
+    (session) => [
+      session.header,
+      session.agents,
+      ...session.chapters,
+      session.decisions,
+      session.findings,
+      session.retrospective,
+      session.filesAndCommits
+    ].filter(Boolean).join("\n").trim()
+  ).join("\n\n");
+}
+function truncateText(text, maxChars) {
+  if (maxChars <= 0) {
+    return "";
+  }
+  if (text.length <= maxChars) {
+    return text;
+  }
+  if (maxChars <= 16) {
+    return text.slice(0, maxChars);
+  }
+  return `${text.slice(0, maxChars - 16).trimEnd()}
+[truncated]
+`;
+}
+function formatList(values) {
+  return values.length > 0 ? values.join(", ") : "none";
+}
+function formatDuration(startedAt, completedAt) {
+  const start = new Date(startedAt).getTime();
+  const end = new Date(completedAt ?? startedAt).getTime();
+  const elapsedMs = Math.max(0, end - start);
+  const minutes = Math.floor(elapsedMs / 6e4);
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  if (hours > 0 && remainingMinutes > 0) {
+    return `${hours}h ${remainingMinutes}m`;
+  }
+  if (hours > 0) {
+    return `${hours}h`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m`;
+  }
+  return completedAt ? "0m" : "ongoing";
+}
+
+// src/cli/commands/compact.ts
+function registerCompactCommand(program2) {
+  program2.command("compact").description(
+    "Compact trajectories into a summarized form (default: uncompacted only)"
+  ).option(
+    "--since <date>",
+    "Include trajectories since this date (ISO format or relative like '7d')"
+  ).option(
+    "--until <date>",
+    "Include trajectories until this date (ISO format)"
+  ).option("--ids <ids>", "Comma-separated list of trajectory IDs to compact").option(
+    "--workflow <id>",
+    "Compact trajectories with the specified workflow ID"
+  ).option("--pr <number>", "Compact trajectories associated with a PR number").option(
+    "--branch <name>",
+    "Compact trajectories with commits not in the specified branch (e.g., main)"
+  ).option(
+    "--commits <shas>",
+    "Comma-separated commit SHAs to match trajectories against"
+  ).option("--all", "Include all trajectories, even previously compacted ones").option("--llm", "Use LLM-based compaction when a provider is available").option("--no-llm", "Disable LLM-based compaction").option("--mechanical", "Force the original mechanical compaction flow").option(
+    "--focus <areas>",
+    "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("--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) {
+      if (options.all || options.since || options.ids || options.workflow || options.pr || options.branch || options.commits) {
+        console.log("No trajectories found matching criteria");
+      } else {
+        console.log(
+          "No uncompacted trajectories found. Use --all to include previously compacted."
+        );
+      }
+      return;
+    }
+    console.log(`Compacting ${trajectories.length} trajectories...
+`);
+    const config = getCompactionConfig();
+    const provider = await resolveProvider(config);
+    const useLLM = shouldUseLLM(options, provider !== null);
+    const markdownEnabled = options.markdown !== false;
+    const mechanicalCompacted = compactTrajectories(
+      trajectories,
+      options.workflow
+    );
+    if (!useLLM || provider === null) {
+      if (options.llm && provider === null && !options.mechanical) {
+        console.log(
+          "No LLM provider detected; falling back to mechanical compaction.\n"
+        );
+      }
+      if (options.dryRun) {
+        console.log("=== DRY RUN - Preview ===\n");
+        printCompactedSummary(mechanicalCompacted);
+        return;
+      }
+      const outputPath2 = options.output || getDefaultOutputPath(mechanicalCompacted, options.workflow);
+      saveCompactionArtifacts(
+        mechanicalCompacted,
+        outputPath2,
+        markdownEnabled
+      );
+      await markTrajectoriesAsCompacted(trajectories, mechanicalCompacted.id);
+      console.log(`
+Compacted trajectory saved to: ${outputPath2}`);
+      if (markdownEnabled) {
+        console.log(
+          `Markdown summary saved to: ${getMarkdownOutputPath(outputPath2)}`
+        );
+      }
+      printCompactedSummary(mechanicalCompacted);
+      return;
+    }
+    const llmPlan = buildLLMCompactionPlan(
+      trajectories,
+      parseFocusAreas(options.focus),
+      config.maxInputTokens,
+      config.maxOutputTokens
+    );
+    console.log(
+      `Using ${getProviderLabel(provider)} compaction${config.model ? ` with model ${config.model}` : ""}.`
+    );
+    console.log(
+      `Estimated: ~${llmPlan.estimatedInputTokens} input tokens, ~${llmPlan.estimatedOutputTokens} output tokens`
+    );
+    if (options.dryRun) {
+      printLLMDryRun(llmPlan, config.model, options.workflow);
+      return;
+    }
+    const llmOutput = await provider.complete(llmPlan.messages, {
+      maxTokens: config.maxOutputTokens,
+      temperature: config.temperature,
+      jsonMode: provider instanceof OpenAIProvider
+    });
+    const llmCompacted = parseCompactionResponse(llmOutput);
+    const mergedCompaction = mergeCompactionWithMetadata(
+      {
+        id: mechanicalCompacted.id,
+        version: mechanicalCompacted.version,
+        type: mechanicalCompacted.type,
+        compactedAt: mechanicalCompacted.compactedAt,
+        sourceTrajectories: mechanicalCompacted.sourceTrajectories,
+        dateRange: mechanicalCompacted.dateRange,
+        summary: mechanicalCompacted.summary,
+        filesAffected: mechanicalCompacted.filesAffected,
+        commits: mechanicalCompacted.commits
+      },
+      llmCompacted
+    );
+    const compacted = {
+      ...mechanicalCompacted,
+      ...mergedCompaction
+    };
+    const outputPath = options.output || getDefaultOutputPath(compacted, options.workflow);
+    saveCompactionArtifacts(compacted, outputPath, markdownEnabled);
+    await markTrajectoriesAsCompacted(trajectories, compacted.id);
+    console.log(`
+Compacted trajectory saved to: ${outputPath}`);
+    if (markdownEnabled) {
+      console.log(
+        `Markdown summary saved to: ${getMarkdownOutputPath(outputPath)}`
+      );
+    }
+    printCompactedSummary(compacted);
+  });
+}
+async function loadTrajectories(options) {
+  const trajectories = [];
+  const targetIds = options.ids ? options.ids.split(",").map((s) => s.trim()) : null;
+  const sinceDate = options.since ? parseRelativeDate(options.since) : null;
+  const untilDate = options.until ? new Date(options.until) : null;
+  const branchCommits = options.branch ? getBranchCommits(options.branch) : null;
+  const targetCommits = options.commits ? new Set(
+    options.commits.split(",").flatMap((sha) => {
+      const trimmed = sha.trim();
+      if (!trimmed) return [];
+      return [trimmed, trimmed.slice(0, 7)];
+    })
+  ) : null;
+  const compactedIds = options.all ? /* @__PURE__ */ new Set() : 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;
+    }
+    await storage.initialize();
+    const summaries = await storage.list({
+      status: "completed",
+      limit: Number.MAX_SAFE_INTEGER
+    });
+    for (const summary of summaries) {
+      if (seenIds.has(summary.id)) continue;
+      if (compactedIds.has(summary.id)) continue;
+      if (targetIds && !targetIds.includes(summary.id)) continue;
+      const startDate = new Date(summary.startedAt);
+      if (sinceDate && startDate < sinceDate) continue;
+      if (untilDate && startDate > untilDate) continue;
+      const trajectory = await storage.get(summary.id);
+      if (trajectory) {
+        seenIds.add(summary.id);
+        if (options.workflow && trajectory.workflowId !== options.workflow) {
+          continue;
+        }
+        if (options.pr) {
+          const escaped = options.pr.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+          const prPattern = new RegExp(
+            `#${escaped}\\b|\\bPR\\s*#?\\s*${escaped}\\b`,
+            "i"
+          );
+          const matchesPR = prPattern.test(trajectory.task.title) || prPattern.test(trajectory.task.description || "") || trajectory.commits.some((c) => prPattern.test(c));
+          if (!matchesPR) continue;
+        }
+        if (branchCommits) {
+          const hasMatchingCommit = trajectory.commits.some(
+            (c) => branchCommits.has(c.slice(0, 7)) || branchCommits.has(c)
+          );
+          if (!hasMatchingCommit && trajectory.commits.length > 0) continue;
+        }
+        if (targetCommits) {
+          const hasMatchingCommit = trajectory.commits.some(
+            (c) => targetCommits.has(c) || targetCommits.has(c.slice(0, 7))
+          );
+          if (!hasMatchingCommit) continue;
+        }
+        trajectories.push(trajectory);
+      }
+    }
+  }
+  return trajectories;
+}
+function getBranchCommits(targetBranch) {
+  const commits = /* @__PURE__ */ new Set();
+  try {
+    const output = execFileSync(
+      "git",
+      ["log", `${targetBranch}..HEAD`, "--format=%H"],
+      {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }
+    );
+    for (const line of output.trim().split("\n")) {
+      if (line) {
+        commits.add(line);
+        commits.add(line.slice(0, 7));
+      }
+    }
+  } catch {
+    console.warn(
+      `Warning: Could not get commits for branch comparison with ${targetBranch}`
+    );
+  }
+  return commits;
+}
+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 {
+    }
+  }
+  return compacted;
+}
+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 {
+    }
+  }
+}
+function parseRelativeDate(input) {
+  const match = input.match(/^(\d+)([dwmh])$/);
+  if (match) {
+    const amount = Number.parseInt(match[1], 10);
+    const unit = match[2];
+    const now = /* @__PURE__ */ new Date();
+    switch (unit) {
+      case "h":
+        return new Date(now.getTime() - amount * 60 * 60 * 1e3);
+      case "d":
+        return new Date(now.getTime() - amount * 24 * 60 * 60 * 1e3);
+      case "w":
+        return new Date(now.getTime() - amount * 7 * 24 * 60 * 60 * 1e3);
+      case "m":
+        return new Date(now.getTime() - amount * 30 * 24 * 60 * 60 * 1e3);
+    }
+  }
+  return new Date(input);
+}
+function compactTrajectories(trajectories, workflowId) {
+  const allDecisions = [];
+  const allLearnings = [];
+  const allFindings = [];
+  const allFiles = /* @__PURE__ */ new Set();
+  const allCommits = /* @__PURE__ */ new Set();
+  const allAgents = /* @__PURE__ */ new Set();
+  let totalEvents = 0;
+  for (const traj of trajectories) {
+    for (const agent of traj.agents) {
+      allAgents.add(agent.name);
+    }
+    for (const file of traj.filesChanged) {
+      allFiles.add(file);
+    }
+    for (const commit of traj.commits) {
+      allCommits.add(commit);
+    }
+    for (const chapter of traj.chapters) {
+      totalEvents += chapter.events.length;
+      for (const event of chapter.events) {
+        if (event.type === "decision" && event.raw) {
+          const decision = event.raw;
+          allDecisions.push({
+            decision,
+            fromTrajectory: traj.id,
+            timestamp: event.ts
+          });
+        }
+        if (event.type === "finding" && event.content) {
+          allFindings.push(event.content);
+        }
+      }
+    }
+    if (traj.retrospective?.learnings) {
+      allLearnings.push(...traj.retrospective.learnings);
+    }
+    if (traj.retrospective?.decisions) {
+      for (const decision of traj.retrospective.decisions) {
+        allDecisions.push({
+          decision,
+          fromTrajectory: traj.id,
+          timestamp: new Date(traj.completedAt || traj.startedAt).getTime()
+        });
+      }
+    }
+  }
+  const decisionGroups = groupDecisions(allDecisions);
+  const uniqueLearnings = [...new Set(allLearnings)];
+  const dates = trajectories.map((t) => new Date(t.startedAt).getTime());
+  const minDate = new Date(Math.min(...dates));
+  const maxDate = new Date(
+    Math.max(
+      ...trajectories.map(
+        (t) => new Date(t.completedAt || t.startedAt).getTime()
+      )
+    )
+  );
+  return {
+    id: `compact_${generateRandomId()}`,
+    version: 1,
+    type: "compacted",
+    compactedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workflowId,
+    sourceTrajectories: trajectories.map((t) => t.id),
+    dateRange: {
+      start: minDate.toISOString(),
+      end: maxDate.toISOString()
+    },
+    summary: {
+      totalDecisions: allDecisions.length,
+      totalEvents,
+      uniqueAgents: [...allAgents]
+    },
+    decisionGroups,
+    keyLearnings: uniqueLearnings,
+    keyFindings: [...new Set(allFindings)],
+    filesAffected: [...allFiles],
+    commits: [...allCommits]
+  };
+}
+function groupDecisions(decisions) {
+  const categories = {};
+  const categoryKeywords = {
+    architecture: [
+      "architecture",
+      "structure",
+      "pattern",
+      "design",
+      "module",
+      "component"
+    ],
+    api: ["api", "endpoint", "rest", "graphql", "http", "request", "response"],
+    database: ["database", "schema", "migration", "query", "sql", "model"],
+    testing: ["test", "spec", "coverage", "assertion", "mock"],
+    security: [
+      "security",
+      "auth",
+      "permission",
+      "token",
+      "credential",
+      "encrypt"
+    ],
+    performance: ["performance", "optimize", "cache", "speed", "memory"],
+    tooling: ["tool", "config", "build", "lint", "format", "ci", "cd"],
+    naming: ["name", "rename", "convention", "format"],
+    compliance: ["spec", "standard", "compliance", "convention", "align"]
+  };
+  for (const { decision, fromTrajectory } of decisions) {
+    const text = `${decision.question} ${decision.reasoning}`.toLowerCase();
+    let matchedCategory = "other";
+    for (const [category, keywords] of Object.entries(categoryKeywords)) {
+      if (keywords.some((kw) => text.includes(kw))) {
+        matchedCategory = category;
+        break;
+      }
+    }
+    if (!categories[matchedCategory]) {
+      categories[matchedCategory] = {
+        category: matchedCategory,
+        decisions: []
+      };
+    }
+    categories[matchedCategory].decisions.push({
+      question: decision.question,
+      chosen: decision.chosen,
+      reasoning: decision.reasoning,
+      fromTrajectory
+    });
+  }
+  return Object.values(categories).sort(
+    (a, b) => b.decisions.length - a.decisions.length
+  );
+}
+function shouldUseLLM(options, providerAvailable) {
+  if (options.mechanical) {
+    return false;
+  }
+  if (options.llm === false) {
+    return false;
+  }
+  if (options.llm === true) {
+    return providerAvailable;
+  }
+  return providerAvailable;
+}
+function buildLLMCompactionPlan(trajectories, focusAreas, maxInputTokens, maxOutputTokens) {
+  const serialized = serializeForLLM(trajectories, maxInputTokens);
+  const messages = buildCompactionPrompt(serialized, {
+    focusAreas,
+    maxOutputTokens
+  });
+  return {
+    messages,
+    estimatedInputTokens: estimateTokens(
+      messages.map((message) => message.content).join("\n\n")
+    ),
+    estimatedOutputTokens: maxOutputTokens,
+    focusAreas
+  };
+}
+function parseFocusAreas(focus) {
+  if (!focus) {
+    return [];
+  }
+  return focus.split(",").map((area) => area.trim()).filter(Boolean);
+}
+function estimateTokens(text) {
+  return Math.max(1, Math.ceil(text.length / 4));
+}
+function printLLMDryRun(plan, model, workflowId) {
+  console.log("=== DRY RUN - LLM Prompt Preview ===\n");
+  console.log(
+    `Estimated: ~${plan.estimatedInputTokens} input tokens, ~${plan.estimatedOutputTokens} output tokens`
+  );
+  if (model) {
+    console.log(`Configured model: ${model}`);
+  }
+  if (workflowId) {
+    console.log(`Workflow: ${workflowId}`);
+  }
+  if (plan.focusAreas.length > 0) {
+    console.log(`Focus: ${plan.focusAreas.join(", ")}`);
+  }
+  console.log("");
+  for (const message of plan.messages) {
+    console.log(`[${message.role.toUpperCase()}]`);
+    console.log(message.content);
+    console.log("");
+  }
+}
+function getProviderLabel(provider) {
+  if (provider instanceof OpenAIProvider) {
+    return "OpenAI";
+  }
+  if (provider instanceof AnthropicProvider) {
+    return "Anthropic";
+  }
+  if (provider instanceof CLIProvider) {
+    return `CLI (${provider.cliName})`;
+  }
+  return "LLM";
+}
+function getDefaultOutputPath(compacted, workflowId) {
+  const trajDir = process.env.TRAJECTORIES_DATA_DIR || ".trajectories";
+  const compactedDir = join4(trajDir, "compacted");
+  if (!existsSync3(compactedDir)) {
+    mkdirSync(compactedDir, { recursive: true });
+  }
+  if (workflowId) {
+    return join4(compactedDir, `workflow-${workflowId}.json`);
+  }
+  const dateStr = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return join4(compactedDir, `${compacted.id}_${dateStr}.json`);
+}
+function saveCompactionArtifacts(compacted, outputPath, markdownEnabled) {
+  const dir = dirname(outputPath);
+  if (!existsSync3(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(outputPath, JSON.stringify(compacted, null, 2));
+  if (markdownEnabled) {
+    writeFileSync(
+      getMarkdownOutputPath(outputPath),
+      renderCompactionMarkdown(compacted)
+    );
+  }
+}
+function getMarkdownOutputPath(outputPath) {
+  return outputPath.endsWith(".json") ? outputPath.slice(0, -".json".length).concat(".md") : `${outputPath}.md`;
+}
+function renderCompactionMarkdown(compacted) {
+  if (compacted.narrative) {
+    return generateCompactionMarkdown(
+      compacted
+    );
+  }
+  const decisionGroups = compacted.decisionGroups.length > 0 ? compacted.decisionGroups.map((group) => {
+    const decisions = group.decisions.length > 0 ? group.decisions.map(
+      (decision) => `- ${decision.question} -> ${decision.chosen} (${decision.fromTrajectory})`
+    ).join("\n") : "- None";
+    return `## ${capitalize(group.category)}
+${decisions}`;
+  }).join("\n\n") : "## Decision Groups\n- None";
+  const learnings = compacted.keyLearnings.length > 0 ? compacted.keyLearnings.map((learning) => `- ${learning}`).join("\n") : "- None";
+  const findings = compacted.keyFindings.length > 0 ? compacted.keyFindings.map((finding) => `- ${finding}`).join("\n") : "- None";
+  return [
+    `# Trajectory Compaction: ${formatDate3(compacted.dateRange.start)} - ${formatDate3(compacted.dateRange.end)}`,
+    "",
+    "## Summary",
+    `- Sessions: ${compacted.sourceTrajectories.length}`,
+    ...compacted.workflowId ? [`- Workflow: ${compacted.workflowId}`] : [],
+    `- Decisions: ${compacted.summary.totalDecisions}`,
+    `- Events: ${compacted.summary.totalEvents}`,
+    `- Agents: ${compacted.summary.uniqueAgents.join(", ") || "None"}`,
+    `- Files: ${compacted.filesAffected.length}`,
+    `- Commits: ${compacted.commits.length}`,
+    "",
+    decisionGroups,
+    "",
+    "## Key Learnings",
+    learnings,
+    "",
+    "## Key Findings",
+    findings
+  ].join("\n");
+}
+function printCompactedSummary(compacted) {
+  console.log("=== Compacted Trajectory Summary ===\n");
+  console.log(`ID: ${compacted.id}`);
+  if (compacted.workflowId) {
+    console.log(`Workflow: ${compacted.workflowId}`);
+  }
+  console.log(`Source trajectories: ${compacted.sourceTrajectories.length}`);
+  console.log(
+    `Date range: ${formatDate3(compacted.dateRange.start)} - ${formatDate3(compacted.dateRange.end)}`
+  );
+  console.log(`Total decisions: ${compacted.summary.totalDecisions}`);
+  console.log(`Total events: ${compacted.summary.totalEvents}`);
+  console.log(`Agents: ${compacted.summary.uniqueAgents.join(", ")}`);
+  console.log("");
+  if (compacted.narrative) {
+    console.log("=== Narrative ===\n");
+    console.log(compacted.narrative);
+    console.log("");
+    if (compacted.decisions && compacted.decisions.length > 0) {
+      console.log("=== Key Decisions ===\n");
+      for (const decision of compacted.decisions.slice(0, 5)) {
+        console.log(`  - ${decision.question}`);
+        console.log(`    Chosen: ${decision.chosen}`);
+        if (decision.impact) {
+          console.log(`    Impact: ${decision.impact}`);
+        }
+      }
+      if (compacted.decisions.length > 5) {
+        console.log(`  ... and ${compacted.decisions.length - 5} more`);
+      }
+      console.log("");
+    }
+    if (compacted.openQuestions && compacted.openQuestions.length > 0) {
+      console.log("=== Open Questions ===\n");
+      for (const question of compacted.openQuestions.slice(0, 5)) {
+        console.log(`  - ${question}`);
+      }
+      if (compacted.openQuestions.length > 5) {
+        console.log(`  ... and ${compacted.openQuestions.length - 5} more`);
+      }
+      console.log("");
+    }
+  } else {
+    console.log("=== Decision Groups ===\n");
+    for (const group of compacted.decisionGroups) {
+      console.log(
+        `${capitalize(group.category)} (${group.decisions.length} decisions):`
+      );
+      for (const decision of group.decisions.slice(0, 3)) {
+        console.log(`  - ${decision.question}`);
+        console.log(`    Chose: ${decision.chosen}`);
+      }
+      if (group.decisions.length > 3) {
+        console.log(`  ... and ${group.decisions.length - 3} more`);
+      }
+      console.log("");
+    }
+    if (compacted.keyLearnings.length > 0) {
+      console.log("=== Key Learnings ===\n");
+      for (const learning of compacted.keyLearnings.slice(0, 5)) {
+        console.log(`  - ${learning}`);
+      }
+      if (compacted.keyLearnings.length > 5) {
+        console.log(`  ... and ${compacted.keyLearnings.length - 5} more`);
+      }
+      console.log("");
+    }
+  }
+  if (compacted.filesAffected.length > 0) {
+    console.log(`Files affected: ${compacted.filesAffected.length}`);
+  }
+  if (compacted.commits.length > 0) {
+    console.log(`Commits: ${compacted.commits.length}`);
+  }
+}
+function formatDate3(isoString) {
+  return new Date(isoString).toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  });
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// src/cli/commands/complete.ts
+import { existsSync as existsSync4 } from "fs";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { join as join5 } from "path";
+
+// src/core/trace.ts
+import { execSync } from "child_process";
+import { createHash } from "crypto";
+function isValidGitRef(ref) {
+  const validRefPattern = /^[a-zA-Z0-9_\-./]+$/;
+  const commitHashPattern = /^[a-fA-F0-9]{7,40}$/;
+  if (ref === "HEAD" || ref === "working") {
+    return true;
+  }
+  if (commitHashPattern.test(ref)) {
+    return true;
+  }
+  if (validRefPattern.test(ref) && ref.length <= 255) {
+    if (!ref.includes("..") || ref.split("..").every((p) => p.length > 0)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isGitRepo() {
+  try {
+    execSync("git rev-parse --is-inside-work-tree", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getGitHead() {
+  if (!isGitRepo()) {
+    return null;
+  }
+  try {
+    const head = execSync("git rev-parse HEAD", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return head;
+  } catch {
+    return null;
+  }
+}
+function captureGitState() {
+  return getGitHead();
+}
+function parseDiffOutput(diffOutput) {
+  const files = [];
+  const lines = diffOutput.split("\n");
+  let currentFile = null;
+  let currentRanges = [];
+  for (const line of lines) {
+    const diffHeaderMatch = line.match(/^diff --git a\/.+ b\/(.+)$/);
+    if (diffHeaderMatch) {
+      if (currentFile) {
+        files.push({ path: currentFile, ranges: currentRanges });
+      }
+      currentFile = diffHeaderMatch[1];
+      currentRanges = [];
+      continue;
+    }
+    const hunkMatch = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
+    if (hunkMatch && currentFile) {
+      const startLine = Number.parseInt(hunkMatch[1], 10);
+      const lineCount = hunkMatch[2] ? Number.parseInt(hunkMatch[2], 10) : 1;
+      if (lineCount > 0) {
+        currentRanges.push({
+          start_line: startLine,
+          end_line: startLine + lineCount - 1
+        });
+      }
+    }
+  }
+  if (currentFile) {
+    files.push({ path: currentFile, ranges: currentRanges });
+  }
+  return files;
+}
+function getChangedFiles(startRef, endRef = "HEAD") {
+  if (!isGitRepo()) {
+    return [];
+  }
+  if (!isValidGitRef(startRef) || !isValidGitRef(endRef)) {
+    return [];
+  }
+  try {
+    const diffOutput = execSync(`git diff ${startRef}..${endRef}`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      maxBuffer: 10 * 1024 * 1024
+      // 10MB buffer for large diffs
+    });
+    return parseDiffOutput(diffOutput);
+  } catch {
+    return [];
+  }
+}
+function detectModel() {
+  if (process.env.TRAIL_TRACE_MODEL) {
+    return process.env.TRAIL_TRACE_MODEL;
+  }
+  if (process.env.ANTHROPIC_MODEL) {
+    const model = process.env.ANTHROPIC_MODEL;
+    return model.includes("/") ? model : `anthropic/${model}`;
+  }
+  if (process.env.OPENAI_MODEL) {
+    const model = process.env.OPENAI_MODEL;
+    return model.includes("/") ? model : `openai/${model}`;
+  }
+  return "unknown";
+}
+function generateTraceId() {
+  return crypto.randomUUID();
+}
+function generateTrace(trajectory, startRef) {
+  if (!isGitRepo()) {
+    return null;
+  }
+  const endRef = getGitHead();
+  if (!endRef) {
+    return null;
+  }
+  const changedFiles = getChangedFiles(startRef, endRef);
+  if (changedFiles.length === 0) {
+    return null;
+  }
+  const model = detectModel();
+  const traceFiles = changedFiles.map(({ path: path2, ranges }) => ({
+    path: path2,
+    conversations: [
+      {
+        contributor: {
+          type: "ai",
+          ...model !== "unknown" ? { model_id: model } : {}
+        },
+        ranges: ranges.map((range) => ({
+          ...range,
+          revision: endRef
+        }))
+      }
+    ]
+  }));
+  return {
+    version: "1.0.0",
+    id: generateTraceId(),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    trajectory: trajectory.id,
+    files: traceFiles
+  };
+}
+function migrateTraceRecord(raw) {
+  const data = raw;
+  let migrated = false;
+  if (typeof data.version === "number") {
+    data.version = "1.0.0";
+    migrated = true;
+  }
+  if (Array.isArray(data.files)) {
+    for (const file of data.files) {
+      if (Array.isArray(file.conversations)) {
+        for (const conv of file.conversations) {
+          const contributor = conv.contributor;
+          if (!contributor) continue;
+          if (contributor.type === "agent") {
+            contributor.type = "ai";
+            migrated = true;
+          }
+          if ("model" in contributor) {
+            const modelValue = contributor.model;
+            contributor.model = void 0;
+            if (modelValue && modelValue !== "unknown") {
+              contributor.model_id = modelValue;
+            }
+            migrated = true;
+          }
+        }
+      }
+    }
+  }
+  return { record: data, migrated };
+}
+function createTraceRef(startRef, traceId) {
+  const endRef = getGitHead();
+  return {
+    startRef,
+    endRef: endRef ?? void 0,
+    traceId
+  };
+}
+
+// src/core/trailers.ts
+import { execSync as execSync2 } from "child_process";
+import { readFileSync as readFileSync3 } from "fs";
+function getCommitsBetween(startRef, endRef = "HEAD") {
+  if (!isGitRepo()) {
+    return [];
+  }
+  if (!isValidGitRef(startRef) || !isValidGitRef(endRef)) {
+    return [];
+  }
+  try {
+    const output = execSync2(
+      `git log --format=%H%n%h%n%s%n%an%n%aI%n--- ${startRef}..${endRef}`,
+      {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }
+    );
+    if (!output.trim()) {
+      return [];
+    }
+    const commits = [];
+    const entries = output.trim().split("\n---\n");
+    for (const entry of entries) {
+      const lines = entry.trim().split("\n");
+      if (lines.length >= 5) {
+        commits.push({
+          fullHash: lines[0],
+          hash: lines[1],
+          subject: lines[2],
+          author: lines[3],
+          date: lines[4]
+        });
+      }
+    }
+    return commits;
+  } catch {
+    return [];
+  }
+}
+function getFilesChangedBetween(startRef, endRef = "HEAD") {
+  if (!isGitRepo()) {
+    return [];
+  }
+  if (!isValidGitRef(startRef) || !isValidGitRef(endRef)) {
+    return [];
+  }
+  try {
+    const output = execSync2(`git diff --name-only ${startRef}..${endRef}`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return output.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function generateHookScript() {
+  return `#!/bin/sh
+# Added by agent-trajectories - appends Trajectory trailer to commits
+# This hook reads the active trajectory and links it to your commit.
+
+COMMIT_MSG_FILE="$1"
+COMMIT_SOURCE="$2"
+
+# Skip for merge, squash, and amend commits
+if [ "$COMMIT_SOURCE" = "merge" ] || [ "$COMMIT_SOURCE" = "squash" ] || [ "$COMMIT_SOURCE" = "commit" ]; then
+  exit 0
+fi
+
+# Find the trajectories data directory
+TRAJ_DIR="\${TRAJECTORIES_DATA_DIR:-$(git rev-parse --show-toplevel)/.trajectories}"
+ACTIVE_DIR="$TRAJ_DIR/active"
+
+# Check if there's an active trajectory
+if [ ! -d "$ACTIVE_DIR" ]; then
+  exit 0
+fi
+
+# Find the most recent active trajectory file
+ACTIVE_FILE=$(ls -t "$ACTIVE_DIR"/*.json 2>/dev/null | head -1)
+if [ -z "$ACTIVE_FILE" ]; then
+  exit 0
+fi
+
+# Extract trajectory ID (grep for the "id" field). Character class must
+# include underscore to match legacy traj_<timestamp>_<hex> ids -- without
+# it, grep -o silently truncates at the first internal underscore and
+# emits a wrong (shorter) id into the commit trailer.
+TRAJ_ID=$(grep -o '"id"[[:space:]]*:[[:space:]]*"traj_[a-z0-9_]*"' "$ACTIVE_FILE" | head -1 | grep -o 'traj_[a-z0-9_]*')
+if [ -z "$TRAJ_ID" ]; then
+  exit 0
+fi
+
+# Check if trailer already exists in the message
+if grep -q "^Trajectory: " "$COMMIT_MSG_FILE" 2>/dev/null; then
+  exit 0
+fi
+
+# Append the trailer with a blank line separator
+echo "" >> "$COMMIT_MSG_FILE"
+echo "Trajectory: $TRAJ_ID" >> "$COMMIT_MSG_FILE"
+`;
+}
+function detectExistingHook() {
+  if (!isGitRepo()) {
+    return "none";
+  }
+  try {
+    const hooksDir = execSync2("git rev-parse --git-dir", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const hookPath = `${hooksDir}/hooks/prepare-commit-msg`;
+    try {
+      const content = readFileSync3(hookPath, "utf-8");
+      if (content.includes("agent-trajectories")) {
+        return "ours";
+      }
+      return "other";
+    } catch {
+      return "none";
+    }
+  } catch {
+    return "none";
+  }
+}
+
+// src/cli/commands/complete.ts
+async function saveTraceFile(trajectory, trace) {
+  const dataDir = process.env.TRAJECTORIES_DATA_DIR;
+  const baseDir = dataDir ? dataDir : join5(process.cwd(), ".trajectories");
+  const completedDir = join5(baseDir, "completed");
+  const date = new Date(trajectory.completedAt ?? trajectory.startedAt);
+  const monthDir = join5(
+    completedDir,
+    `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}`
+  );
+  if (!existsSync4(monthDir)) {
+    await mkdir2(monthDir, { recursive: true });
+  }
+  const tracePath = join5(monthDir, `${trajectory.id}.trace.json`);
+  await writeFile2(tracePath, JSON.stringify(trace, null, 2), "utf-8");
+}
+function registerCompleteCommand(program2) {
+  program2.command("complete").description("Complete the active trajectory with retrospective").option("--summary <text>", "Summary of what was accomplished").option("--approach <text>", "How the work was approached").option("--confidence <number>", "Confidence level 0-1", Number.parseFloat).action(async (options) => {
+    const storage = new FileStorage();
+    await storage.initialize();
+    const active = await storage.getActive();
+    if (!active) {
+      console.error("Error: No active trajectory");
+      console.error('Start one with: trail start "Task description"');
+      throw new Error("No active trajectory");
+    }
+    if (!options.summary) {
+      console.error("Error: --summary is required");
+      throw new Error("Summary required");
+    }
+    const confidence = options.confidence ?? 0.8;
+    if (confidence < 0 || confidence > 1) {
+      console.error("Error: --confidence must be between 0 and 1");
+      throw new Error("Invalid confidence");
+    }
+    let completed = completeTrajectory(active, {
+      summary: options.summary,
+      approach: options.approach || "Standard approach",
+      confidence
+    });
+    let trace = null;
+    if (active._trace?.startRef) {
+      trace = generateTrace(completed, active._trace.startRef);
+      if (trace) {
+        const endRef = getGitHead();
+        completed = {
+          ...completed,
+          _trace: {
+            ...completed._trace,
+            startRef: active._trace.startRef,
+            endRef: endRef ?? void 0,
+            traceId: trace.id
+          }
+        };
+      }
+    }
+    if (active._trace?.startRef) {
+      const commits = getCommitsBetween(active._trace.startRef);
+      const filesChanged = getFilesChangedBetween(active._trace.startRef);
+      if (commits.length > 0 || filesChanged.length > 0) {
+        completed = {
+          ...completed,
+          commits: commits.map((c) => c.hash),
+          filesChanged
+        };
+      }
+    }
+    await storage.save(completed);
+    if (trace) {
+      await saveTraceFile(completed, trace);
+    }
+    console.log(`\u2713 Trajectory completed: ${completed.id}`);
+    console.log(`  Summary: ${options.summary}`);
+    console.log(`  Confidence: ${Math.round(confidence * 100)}%`);
+    if (completed.commits.length > 0) {
+      console.log(`  Commits: ${completed.commits.length}`);
+    }
+    if (completed.filesChanged.length > 0) {
+      console.log(`  Files changed: ${completed.filesChanged.length}`);
+    }
+    if (trace) {
+      console.log(`  Trace: ${trace.id} (${trace.files.length} files)`);
+    }
+  });
+}
+
+// src/cli/commands/decision.ts
+function registerDecisionCommand(program2) {
+  program2.command("decision <choice>").description("Record a decision").option(
+    "-r, --reasoning <text>",
+    "Why this choice was made (optional for minor decisions)"
+  ).option(
+    "-a, --alternatives <items>",
+    "Comma-separated alternatives considered"
+  ).action(async (choice, options) => {
+    const storage = new FileStorage();
+    await storage.initialize();
+    const active = await storage.getActive();
+    if (!active) {
+      console.error("Error: No active trajectory");
+      console.error('Start one with: trail start "Task description"');
+      throw new Error("No active trajectory");
+    }
+    const alternatives = options.alternatives ? options.alternatives.split(",").map((s) => ({ option: s.trim(), reason: "" })) : [];
+    const reasoning = options.reasoning || "";
+    const updated = addDecision(active, {
+      question: choice,
+      chosen: choice,
+      alternatives,
+      reasoning
+    });
+    await storage.save(updated);
+    console.log(`\u2713 Decision recorded: ${choice}`);
+    if (reasoning) {
+      console.log(`  Reasoning: ${reasoning}`);
+    }
+    if (alternatives.length > 0) {
+      const altStrings = alternatives.map(
+        (a) => a.option
+      );
+      console.log(`  Alternatives: ${altStrings.join(", ")}`);
+    }
+  });
+}
+
+// src/cli/commands/enable.ts
+import { execSync as execSync3 } from "child_process";
+import { existsSync as existsSync5 } from "fs";
+import { chmod, mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
+import { join as join6 } from "path";
+function getHooksDir() {
+  try {
+    const gitDir = execSync3("git rev-parse --git-dir", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return join6(gitDir, "hooks");
+  } catch {
+    return null;
+  }
+}
+function registerEnableCommand(program2) {
+  program2.command("enable").description(
+    "Install git hook to automatically link commits to trajectories"
+  ).option("--force", "Overwrite existing prepare-commit-msg hook").action(async (options) => {
+    if (!isGitRepo()) {
+      console.error("Error: Not inside a git repository");
+      throw new Error("Not a git repository");
+    }
+    const hooksDir = getHooksDir();
+    if (!hooksDir) {
+      console.error("Error: Could not determine git hooks directory");
+      throw new Error("Cannot find hooks directory");
+    }
+    const hookPath = join6(hooksDir, "prepare-commit-msg");
+    const existing = detectExistingHook();
+    if (existing === "other" && !options.force) {
+      console.error("Error: A prepare-commit-msg hook already exists");
+      console.error(
+        "Use --force to overwrite, or manually add the trailer logic"
+      );
+      throw new Error("Hook already exists");
+    }
+    if (existing === "ours") {
+      console.log("Trajectory hook is already installed");
+      return;
+    }
+    if (!existsSync5(hooksDir)) {
+      await mkdir3(hooksDir, { recursive: true });
+    }
+    const hookContent = generateHookScript();
+    await writeFile3(hookPath, hookContent, "utf-8");
+    await chmod(hookPath, 493);
+    console.log("Trajectory hook installed");
+    console.log(`  Hook: ${hookPath}`);
+    console.log(
+      "  Commits will now include a Trajectory trailer when a trajectory is active"
+    );
+  });
+  program2.command("disable").description("Remove the trajectory git hook").action(async () => {
+    if (!isGitRepo()) {
+      console.error("Error: Not inside a git repository");
+      throw new Error("Not a git repository");
+    }
+    const hooksDir = getHooksDir();
+    if (!hooksDir) {
+      console.error("Error: Could not determine git hooks directory");
+      throw new Error("Cannot find hooks directory");
+    }
+    const hookPath = join6(hooksDir, "prepare-commit-msg");
+    const existing = detectExistingHook();
+    if (existing === "none") {
+      console.log("No trajectory hook installed");
+      return;
+    }
+    if (existing === "other") {
+      console.error(
+        "Error: The prepare-commit-msg hook was not installed by agent-trajectories"
+      );
+      console.error("Remove it manually if needed");
+      throw new Error("Hook not ours");
+    }
+    const { unlink: unlink2 } = await import("fs/promises");
+    await unlink2(hookPath);
+    console.log("Trajectory hook removed");
+  });
+}
+
+// src/cli/commands/export.ts
+import { exec } from "child_process";
+import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
+import { join as join7 } from "path";
+
+// src/export/json.ts
+function exportToJSON(trajectory, options) {
+  if (options?.compact) {
+    return JSON.stringify(trajectory);
+  }
+  return JSON.stringify(trajectory, null, 2);
+}
+
+// src/export/timeline.ts
+function exportToTimeline(trajectory) {
+  const lines = [];
+  lines.push(
+    `\u25CF ${formatTime(trajectory.startedAt)}  Started: ${trajectory.task.title}`
+  );
+  lines.push("\u2502");
+  for (const chapter of trajectory.chapters) {
+    lines.push(
+      `\u251C\u2500 ${formatTime(chapter.startedAt)}  Chapter: ${chapter.title}`
+    );
+    lines.push(`\u2502         Agent: ${chapter.agentName}`);
+    lines.push("\u2502");
+    for (const event of chapter.events) {
+      const prefix = event.type === "decision" ? "\u251C\u2500 Decision: " : "\u251C\u2500 ";
+      const timeStr = formatTime(new Date(event.ts).toISOString());
+      if (event.type === "decision") {
+        lines.push(`\u2502  ${timeStr}  ${prefix}${event.content}`);
+      } else if (event.significance === "high" || event.significance === "critical") {
+        lines.push(`\u2502  ${timeStr}  ${prefix}${event.content}`);
+      }
+    }
+    if (chapter.endedAt) {
+      lines.push("\u2502");
+    }
+  }
+  if (trajectory.completedAt) {
+    const status = trajectory.status === "completed" ? "Completed" : "Abandoned";
+    lines.push(`\u25CB ${formatTime(trajectory.completedAt)}  ${status}`);
+    if (trajectory.retrospective) {
+      lines.push("");
+      lines.push(`  Summary: ${trajectory.retrospective.summary}`);
+      lines.push(
+        `  Confidence: ${Math.round(trajectory.retrospective.confidence * 100)}%`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+function formatTime(isoString) {
+  const date = new Date(isoString);
+  return date.toLocaleTimeString("en-US", {
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+
+// src/web/styles.ts
+var styles = `
+:root {
+  --bg: #ffffff;
+  --bg-secondary: #f8f9fa;
+  --text: #1a1a2e;
+  --text-muted: #6c757d;
+  --border: #e9ecef;
+  --accent: #4f46e5;
+  --accent-light: #eef2ff;
+  --success: #10b981;
+  --warning: #f59e0b;
+  --error: #ef4444;
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --bg: #1a1a2e;
+    --bg-secondary: #16213e;
+    --text: #e9ecef;
+    --text-muted: #adb5bd;
+    --border: #2d3748;
+    --accent: #818cf8;
+    --accent-light: #1e1b4b;
+  }
+}
+
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+  background: var(--bg);
+  color: var(--text);
+  line-height: 1.6;
+  padding: 2rem;
+  max-width: 900px;
+  margin: 0 auto;
+}
+
+h1, h2, h3 {
+  margin-bottom: 0.5rem;
+}
+
+h1 {
+  font-size: 1.75rem;
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+}
+
+h2 {
+  font-size: 1.25rem;
+  color: var(--text-muted);
+  border-bottom: 1px solid var(--border);
+  padding-bottom: 0.5rem;
+  margin-top: 1.5rem;
+}
+
+.header {
+  border-bottom: 2px solid var(--border);
+  padding-bottom: 1rem;
+  margin-bottom: 1.5rem;
+}
+
+.meta {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+  gap: 1rem;
+  margin: 1rem 0;
+  padding: 1rem;
+  background: var(--bg-secondary);
+  border-radius: 8px;
+}
+
+.meta-item {
+  display: flex;
+  flex-direction: column;
+}
+
+.meta-label {
+  font-size: 0.75rem;
+  text-transform: uppercase;
+  color: var(--text-muted);
+  letter-spacing: 0.05em;
+}
+
+.meta-value {
+  font-weight: 500;
+}
+
+.status {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.25rem;
+  padding: 0.25rem 0.5rem;
+  border-radius: 4px;
+  font-size: 0.875rem;
+  font-weight: 500;
+}
+
+.status-active {
+  background: var(--accent-light);
+  color: var(--accent);
+}
+
+.status-completed {
+  background: #d1fae5;
+  color: #065f46;
+}
+
+.status-abandoned {
+  background: #fee2e2;
+  color: #991b1b;
+}
+
+.section {
+  margin: 1.5rem 0;
+}
+
+.collapsible {
+  cursor: pointer;
+  user-select: none;
+}
+
+.collapsible::before {
+  content: '\u25B8 ';
+  display: inline-block;
+  transition: transform 0.2s;
+}
+
+.collapsible.open::before {
+  transform: rotate(90deg);
+}
+
+.collapsible-content {
+  display: none;
+  margin-top: 0.5rem;
+  padding-left: 1rem;
+  border-left: 2px solid var(--border);
+}
+
+.collapsible.open + .collapsible-content {
+  display: block;
+}
+
+.decision {
+  background: var(--bg-secondary);
+  border-radius: 8px;
+  padding: 1rem;
+  margin: 0.75rem 0;
+  border-left: 3px solid var(--accent);
+}
+
+.decision-title {
+  font-weight: 600;
+  margin-bottom: 0.5rem;
+}
+
+.decision-reasoning {
+  color: var(--text-muted);
+  font-size: 0.9rem;
+}
+
+.alternatives {
+  margin-top: 0.5rem;
+  font-size: 0.85rem;
+}
+
+.alternatives-label {
+  color: var(--text-muted);
+}
+
+.timeline {
+  position: relative;
+  padding-left: 1.5rem;
+}
+
+.timeline::before {
+  content: '';
+  position: absolute;
+  left: 0.35rem;
+  top: 0;
+  bottom: 0;
+  width: 2px;
+  background: var(--border);
+}
+
+.timeline-item {
+  position: relative;
+  margin: 1rem 0;
+  padding-left: 1rem;
+}
+
+.timeline-item::before {
+  content: '';
+  position: absolute;
+  left: -1.15rem;
+  top: 0.5rem;
+  width: 10px;
+  height: 10px;
+  border-radius: 50%;
+  background: var(--accent);
+  border: 2px solid var(--bg);
+}
+
+.timeline-item.decision::before {
+  background: var(--warning);
+}
+
+.timeline-item.chapter::before {
+  background: var(--success);
+}
+
+.timeline-time {
+  font-size: 0.75rem;
+  color: var(--text-muted);
+}
+
+.timeline-content {
+  margin-top: 0.25rem;
+}
+
+.chapter {
+  background: var(--bg-secondary);
+  border-radius: 8px;
+  padding: 1rem;
+  margin: 1rem 0;
+}
+
+.chapter-title {
+  font-weight: 600;
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+}
+
+.chapter-agent {
+  font-size: 0.85rem;
+  color: var(--text-muted);
+}
+
+.retrospective {
+  background: linear-gradient(135deg, var(--accent-light), var(--bg-secondary));
+  border-radius: 8px;
+  padding: 1.5rem;
+  margin: 1.5rem 0;
+}
+
+.retrospective h3 {
+  margin-bottom: 1rem;
+}
+
+.confidence {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  margin: 0.5rem 0;
+}
+
+.confidence-bar {
+  flex: 1;
+  height: 8px;
+  background: var(--border);
+  border-radius: 4px;
+  overflow: hidden;
+  max-width: 200px;
+}
+
+.confidence-fill {
+  height: 100%;
+  background: var(--accent);
+  transition: width 0.3s;
+}
+
+.list {
+  list-style: none;
+}
+
+.list li {
+  padding: 0.25rem 0;
+  padding-left: 1rem;
+  position: relative;
+}
+
+.list li::before {
+  content: '\u2022';
+  position: absolute;
+  left: 0;
+  color: var(--accent);
+}
+
+.files-changed {
+  font-family: monospace;
+  font-size: 0.85rem;
+  background: var(--bg-secondary);
+  padding: 0.75rem;
+  border-radius: 4px;
+  margin: 0.5rem 0;
+}
+
+.empty {
+  color: var(--text-muted);
+  font-style: italic;
+}
+
+/* Index page styles */
+.trajectory-list {
+  list-style: none;
+}
+
+.trajectory-card {
+  display: block;
+  padding: 1rem;
+  margin: 0.5rem 0;
+  background: var(--bg-secondary);
+  border-radius: 8px;
+  text-decoration: none;
+  color: var(--text);
+  border: 1px solid var(--border);
+  transition: border-color 0.2s, box-shadow 0.2s;
+}
+
+.trajectory-card:hover {
+  border-color: var(--accent);
+  box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+}
+
+.trajectory-card-title {
+  font-weight: 600;
+  margin-bottom: 0.25rem;
+}
+
+.trajectory-card-meta {
+  font-size: 0.85rem;
+  color: var(--text-muted);
+  display: flex;
+  gap: 1rem;
+}
+
+.group-header {
+  font-size: 0.85rem;
+  text-transform: uppercase;
+  color: var(--text-muted);
+  letter-spacing: 0.05em;
+  margin-top: 1.5rem;
+  margin-bottom: 0.5rem;
+}
+`;
+
+// src/web/generator.ts
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function formatDate4(isoDate) {
+  const date = new Date(isoDate);
+  return date.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+function formatDuration2(startDate, endDate) {
+  const start = new Date(startDate).getTime();
+  const end = endDate ? new Date(endDate).getTime() : Date.now();
+  const ms = end - start;
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days}d ${hours % 24}h`;
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m`;
+  return `${seconds}s`;
+}
+function getStatusClass(status) {
+  switch (status) {
+    case "active":
+      return "status-active";
+    case "completed":
+      return "status-completed";
+    case "abandoned":
+      return "status-abandoned";
+    default:
+      return "";
+  }
+}
+function renderDecision(decision) {
+  const alternatives = decision.alternatives?.length ? `<div class="alternatives">
+        <span class="alternatives-label">Considered:</span>
+        ${decision.alternatives.map((a) => escapeHtml(typeof a === "string" ? a : a.option)).join(", ")}
+       </div>` : "";
+  return `
+    <div class="decision">
+      <div class="decision-title">${escapeHtml(decision.question)}: ${escapeHtml(decision.chosen)}</div>
+      <div class="decision-reasoning">${escapeHtml(decision.reasoning)}</div>
+      ${alternatives}
+    </div>
+  `;
+}
+function renderEvent(event) {
+  const time = formatDate4(new Date(event.ts).toISOString());
+  let content = "";
+  let typeClass = "";
+  const rawData = event.raw;
+  switch (event.type) {
+    case "decision":
+      typeClass = "decision";
+      content = `
+        <strong>Decision:</strong> ${escapeHtml(event.content)}
+        ${rawData?.reasoning ? `<div class="decision-reasoning">${escapeHtml(String(rawData.reasoning))}</div>` : ""}
+      `;
+      break;
+    case "thinking":
+      content = `<strong>Thinking:</strong> ${escapeHtml(event.content)}`;
+      break;
+    case "prompt":
+      content = `<strong>Prompt:</strong> ${escapeHtml(event.content)}`;
+      break;
+    case "tool_call":
+      content = `<strong>Tool:</strong> <code>${escapeHtml(event.content)}</code>`;
+      break;
+    case "tool_result":
+      content = `<strong>Result:</strong> ${escapeHtml(event.content)}`;
+      break;
+    case "message_sent":
+      content = `<strong>Sent:</strong> ${escapeHtml(event.content)}`;
+      break;
+    case "message_received":
+      content = `<strong>Received:</strong> ${escapeHtml(event.content)}`;
+      break;
+    case "error":
+      content = `<strong style="color: var(--error)">Error:</strong> ${escapeHtml(event.content)}`;
+      break;
+    case "note":
+      content = escapeHtml(event.content);
+      break;
+    default:
+      content = escapeHtml(event.content);
+  }
+  return `
+    <div class="timeline-item ${typeClass}">
+      <div class="timeline-time">${time}</div>
+      <div class="timeline-content">${content}</div>
+    </div>
+  `;
+}
+function renderChapter2(chapter, index) {
+  const events = chapter.events.map(renderEvent).join("");
+  return `
+    <div class="chapter">
+      <div class="chapter-title">
+        Chapter ${index + 1}: ${escapeHtml(chapter.title)}
+      </div>
+      <div class="chapter-agent">Agent: ${escapeHtml(chapter.agentName)}</div>
+      ${chapter.events.length > 0 ? `
+        <h3 class="collapsible" onclick="this.classList.toggle('open')">Events (${chapter.events.length})</h3>
+        <div class="collapsible-content">
+          <div class="timeline">${events}</div>
+        </div>
+      ` : ""}
+    </div>
+  `;
+}
+function renderRetrospective2(trajectory) {
+  if (!trajectory.retrospective) {
+    return "";
+  }
+  const retro = trajectory.retrospective;
+  const confidencePercent = Math.round(retro.confidence * 100);
+  const approach = retro.approach ? `<div><strong>Approach:</strong><p>${escapeHtml(retro.approach)}</p></div>` : "";
+  const learnings = retro.learnings?.length ? `<div><strong>Learnings:</strong><ul class="list">${retro.learnings.map((l) => `<li>${escapeHtml(l)}</li>`).join("")}</ul></div>` : "";
+  const challenges = retro.challenges?.length ? `<div><strong>Challenges:</strong><ul class="list">${retro.challenges.map((c) => `<li>${escapeHtml(c)}</li>`).join("")}</ul></div>` : "";
+  const suggestions = retro.suggestions?.length ? `<div><strong>Suggestions:</strong><ul class="list">${retro.suggestions.map((s) => `<li>${escapeHtml(s)}</li>`).join("")}</ul></div>` : "";
+  return `
+    <div class="retrospective">
+      <h3>\u{1F4DD} Retrospective</h3>
+      <p>${escapeHtml(retro.summary)}</p>
+
+      <div class="confidence">
+        <span>Confidence:</span>
+        <div class="confidence-bar">
+          <div class="confidence-fill" style="width: ${confidencePercent}%"></div>
+        </div>
+        <span>${confidencePercent}%</span>
+      </div>
+
+      ${approach}
+      ${learnings}
+      ${challenges}
+      ${suggestions}
+    </div>
+  `;
+}
+function generateTrajectoryHtml(trajectory) {
+  const statusClass = getStatusClass(trajectory.status);
+  const duration = formatDuration2(trajectory.startedAt, trajectory.completedAt);
+  const decisions = trajectory.chapters.flatMap(
+    (ch) => ch.events.filter((e) => e.type === "decision" && e.raw).map((e) => e.raw).filter(
+      (d) => d !== void 0 && typeof d.question === "string"
+    )
+  );
+  const decisionsHtml = decisions.length ? `
+      <h2 class="collapsible open" onclick="this.classList.toggle('open')">
+        Key Decisions (${decisions.length})
+      </h2>
+      <div class="collapsible-content">
+        ${decisions.map(renderDecision).join("")}
+      </div>
+    ` : "";
+  const chaptersHtml = trajectory.chapters.length ? `
+      <h2 class="collapsible open" onclick="this.classList.toggle('open')">
+        Chapters (${trajectory.chapters.length})
+      </h2>
+      <div class="collapsible-content">
+        ${trajectory.chapters.map(renderChapter2).join("")}
+      </div>
+    ` : "";
+  const filesHtml = trajectory.filesChanged.length ? `
+      <h2>Files Changed (${trajectory.filesChanged.length})</h2>
+      <div class="files-changed">
+        ${trajectory.filesChanged.map((f) => escapeHtml(f)).join("<br>")}
+      </div>
+    ` : "";
+  const commitsHtml = trajectory.commits.length ? `
+      <h2>Commits (${trajectory.commits.length})</h2>
+      <div class="files-changed">
+        ${trajectory.commits.map((c) => `<code>${escapeHtml(c)}</code>`).join("<br>")}
+      </div>
+    ` : "";
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHtml(trajectory.task.title)} - Trajectory</title>
+  <style>${styles}</style>
+</head>
+<body>
+  <div class="header">
+    <h1>\u{1F6E4}\uFE0F ${escapeHtml(trajectory.task.title)}</h1>
+    <div class="meta">
+      <div class="meta-item">
+        <span class="meta-label">ID</span>
+        <span class="meta-value"><code>${trajectory.id}</code></span>
+      </div>
+      <div class="meta-item">
+        <span class="meta-label">Status</span>
+        <span class="meta-value"><span class="status ${statusClass}">${trajectory.status}</span></span>
+      </div>
+      <div class="meta-item">
+        <span class="meta-label">Duration</span>
+        <span class="meta-value">${duration}</span>
+      </div>
+      <div class="meta-item">
+        <span class="meta-label">Started</span>
+        <span class="meta-value">${formatDate4(trajectory.startedAt)}</span>
+      </div>
+      ${trajectory.task.source ? `
+      <div class="meta-item">
+        <span class="meta-label">Source</span>
+        <span class="meta-value">${escapeHtml(trajectory.task.source.system)}:${escapeHtml(trajectory.task.source.id)}</span>
+      </div>
+      ` : ""}
+      <div class="meta-item">
+        <span class="meta-label">Agents</span>
+        <span class="meta-value">${trajectory.agents.map((a) => escapeHtml(a.name)).join(", ") || "\u2014"}</span>
+      </div>
+    </div>
+  </div>
+
+  ${renderRetrospective2(trajectory)}
+  ${decisionsHtml}
+  ${chaptersHtml}
+  ${filesHtml}
+  ${commitsHtml}
+
+  <script>
+    // Initialize all collapsible sections
+    document.querySelectorAll('.collapsible.open').forEach(el => {
+      el.nextElementSibling?.style && (el.nextElementSibling.style.display = 'block');
+    });
+  </script>
+</body>
+</html>`;
+}
+
+// src/cli/commands/export.ts
+function registerExportCommand(program2) {
+  program2.command("export [id]").description("Export a trajectory").option(
+    "-f, --format <format>",
+    "Export format (md, json, timeline, html)",
+    "md"
+  ).option("-o, --output <path>", "Output file path").option("--open", "Open in browser (html format only)").action(async (id, options) => {
+    const storage = new FileStorage();
+    await storage.initialize();
+    let trajectory;
+    if (id) {
+      trajectory = await storage.get(id);
+      if (!trajectory) {
+        console.error(`Error: Trajectory not found: ${id}`);
+        throw new Error("Trajectory not found");
+      }
+    } else {
+      trajectory = await storage.getActive();
+      if (!trajectory) {
+        console.error("Error: No active trajectory and no ID provided");
+        console.error(
+          "Usage: trail export <id> or trail export (with active trajectory)"
+        );
+        throw new Error("No trajectory specified");
+      }
+    }
+    let output;
+    switch (options.format) {
+      case "json":
+        output = exportToJSON(trajectory);
+        break;
+      case "timeline":
+        output = exportToTimeline(trajectory);
+        break;
+      case "html":
+        output = generateTrajectoryHtml(trajectory);
+        break;
+      default:
+        output = exportToMarkdown(trajectory);
+        break;
+    }
+    if (options.output) {
+      await writeFile4(options.output, output, "utf-8");
+      console.log(`\u2713 Exported to ${options.output}`);
+      if (options.open && options.format === "html") {
+        openInBrowser(options.output);
+      }
+    } else if (options.open && options.format === "html") {
+      const outputDir = join7(process.cwd(), ".trajectories", "html");
+      await mkdir4(outputDir, { recursive: true });
+      const filePath = join7(outputDir, `${trajectory.id}.html`);
+      await writeFile4(filePath, output, "utf-8");
+      console.log(`\u2713 Generated: ${filePath}`);
+      openInBrowser(filePath);
+    } else {
+      console.log(output);
+    }
+  });
+}
+function openInBrowser(path2) {
+  const platform = process.platform;
+  let command;
+  if (platform === "darwin") {
+    command = `open "${path2}"`;
+  } else if (platform === "win32") {
+    command = `start "" "${path2}"`;
+  } else {
+    command = `xdg-open "${path2}"`;
+  }
+  exec(command, (error) => {
+    if (error) {
+      console.log(`Open manually: file://${path2}`);
+    }
+  });
+}
+
+// src/cli/commands/list.ts
+import { existsSync as existsSync6 } from "fs";
+function registerListCommand(program2) {
+  program2.command("list").description("List and search trajectories").option(
+    "-s, --status <status>",
+    "Filter by status (active, completed, abandoned)"
+  ).option("-l, --limit <number>", "Limit results", Number.parseInt).option("--search <query>", "Search trajectories by title or content").action(async (options) => {
+    const searchPaths = getSearchPaths();
+    let allTrajectories = [];
+    const seenIds = /* @__PURE__ */ new Set();
+    for (const searchPath of searchPaths) {
+      if (!existsSync6(searchPath)) {
+        continue;
+      }
+      const originalDataDir = process.env.TRAJECTORIES_DATA_DIR;
+      process.env.TRAJECTORIES_DATA_DIR = searchPath;
+      try {
+        const storage = new FileStorage();
+        await storage.initialize();
+        const trajectories = await storage.list({
+          status: options.status,
+          limit: options.search ? void 0 : void 0
+          // Don't limit per-path
+        });
+        for (const traj of trajectories) {
+          if (!seenIds.has(traj.id)) {
+            seenIds.add(traj.id);
+            allTrajectories.push(traj);
+          }
+        }
+      } finally {
+        if (originalDataDir !== void 0) {
+          process.env.TRAJECTORIES_DATA_DIR = originalDataDir;
+        } else {
+          process.env.TRAJECTORIES_DATA_DIR = void 0;
+        }
+      }
+    }
+    allTrajectories.sort(
+      (a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime()
+    );
+    if (options.search) {
+      const query = options.search.toLowerCase();
+      allTrajectories = allTrajectories.filter((traj) => {
+        if (traj.title.toLowerCase().includes(query)) return true;
+        if (traj.id.toLowerCase().includes(query)) return true;
+        return false;
+      });
+    }
+    if (options.limit) {
+      allTrajectories = allTrajectories.slice(0, options.limit);
+    }
+    if (allTrajectories.length === 0) {
+      if (options.search) {
+        console.log(`No trajectories found matching "${options.search}"`);
+      } else {
+        console.log("No trajectories found");
+      }
+      return;
+    }
+    const searchNote = options.search ? ` matching "${options.search}"` : "";
+    console.log(
+      `Found ${allTrajectories.length} trajectories${searchNote}:
+`
+    );
+    for (const traj of allTrajectories) {
+      const statusIcon = getStatusIcon(traj.status);
+      const confidence = traj.confidence ? ` (${Math.round(traj.confidence * 100)}%)` : "";
+      console.log(`${statusIcon} ${traj.id}`);
+      console.log(`   ${traj.title}${confidence}`);
+      console.log(`   Started: ${formatDate5(traj.startedAt)}`);
+      if (traj.completedAt) {
+        console.log(`   Completed: ${formatDate5(traj.completedAt)}`);
+      }
+      console.log("");
+    }
+  });
+}
+function getStatusIcon(status) {
+  switch (status) {
+    case "active":
+      return "\u{1F504}";
+    case "completed":
+      return "\u2705";
+    case "abandoned":
+      return "\u274C";
+    default:
+      return "\u2022";
+  }
+}
+function formatDate5(isoString) {
+  return new Date(isoString).toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  });
+}
+
+// src/cli/commands/reflect.ts
+function registerReflectCommand(program2) {
+  program2.command("reflect <synthesis>").description("Record a reflection (periodic synthesis of progress)").option(
+    "-f, --focal-points <items>",
+    "Comma-separated focal points that prompted this reflection"
+  ).option(
+    "-c, --confidence <number>",
+    "Confidence in current trajectory (0-1)",
+    Number.parseFloat
+  ).option(
+    "-a, --adjustments <text>",
+    "Course corrections triggered by this reflection"
+  ).action(async (synthesis, options) => {
+    const storage = new FileStorage();
+    await storage.initialize();
+    const active = await storage.getActive();
+    if (!active) {
+      console.error("Error: No active trajectory");
+      console.error('Start one with: trail start "Task description"');
+      throw new Error("No active trajectory");
+    }
+    const tags = [];
+    if (options.focalPoints) {
+      for (const fp of options.focalPoints.split(",")) {
+        tags.push(`focal:${fp.trim()}`);
+      }
+    }
+    if (options.confidence !== void 0) {
+      tags.push(`confidence:${options.confidence}`);
+    }
+    const raw = {};
+    if (options.focalPoints) {
+      raw.focalPoints = options.focalPoints.split(",").map((s) => s.trim());
+    }
+    if (options.adjustments) {
+      raw.adjustments = options.adjustments;
+    }
+    if (options.confidence !== void 0) {
+      raw.confidence = options.confidence;
+    }
+    const updated = addEvent(active, {
+      type: "reflection",
+      content: synthesis,
+      significance: "high",
+      tags: tags.length > 0 ? tags : void 0,
+      raw: Object.keys(raw).length > 0 ? raw : void 0
+    });
+    await storage.save(updated);
+    console.log(`\u2713 Reflection recorded: ${synthesis}`);
+    if (options.focalPoints) {
+      console.log(`  Focal points: ${options.focalPoints}`);
+    }
+    if (options.confidence !== void 0) {
+      console.log(`  Confidence: ${options.confidence}`);
+    }
+    if (options.adjustments) {
+      console.log(`  Adjustments: ${options.adjustments}`);
+    }
+  });
+}
+
+// src/cli/commands/show.ts
+import { existsSync as existsSync7 } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import { join as join8 } from "path";
+async function findTrajectory(id) {
+  const searchPaths = getSearchPaths();
+  for (const searchPath of searchPaths) {
+    if (!existsSync7(searchPath)) {
+      continue;
+    }
+    const originalDataDir = process.env.TRAJECTORIES_DATA_DIR;
+    process.env.TRAJECTORIES_DATA_DIR = searchPath;
+    try {
+      const storage = new FileStorage();
+      await storage.initialize();
+      const trajectory = await storage.get(id);
+      if (trajectory) {
+        return trajectory;
+      }
+    } finally {
+      if (originalDataDir !== void 0) {
+        process.env.TRAJECTORIES_DATA_DIR = originalDataDir;
+      } else {
+        process.env.TRAJECTORIES_DATA_DIR = void 0;
+      }
+    }
+  }
+  return null;
+}
+async function findTraceFile(id) {
+  const searchPaths = getSearchPaths();
+  for (const searchPath of searchPaths) {
+    if (!existsSync7(searchPath)) {
+      continue;
+    }
+    const completedDir = join8(searchPath, "completed");
+    if (!existsSync7(completedDir)) {
+      continue;
+    }
+    try {
+      const { readdirSync } = await import("fs");
+      const months = readdirSync(completedDir);
+      for (const month of months) {
+        const tracePath = join8(completedDir, month, `${id}.trace.json`);
+        if (existsSync7(tracePath)) {
+          let record;
+          let migrated;
+          try {
+            const content = await readFile2(tracePath, "utf-8");
+            ({ record, migrated } = migrateTraceRecord(JSON.parse(content)));
+          } catch {
+            continue;
+          }
+          if (migrated) {
+            try {
+              const { writeFile: writeFile5 } = await import("fs/promises");
+              await writeFile5(
+                tracePath,
+                JSON.stringify(record, null, 2),
+                "utf-8"
+              );
+            } catch {
+            }
+          }
+          return record;
+        }
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function registerShowCommand(program2) {
+  program2.command("show <id>").description("Show trajectory details").option("-d, --decisions", "Show decisions only").option("-t, --trace", "Show trace information").action(async (id, options) => {
+    const trajectory = await findTrajectory(id);
+    if (!trajectory) {
+      console.error(`Error: Trajectory not found: ${id}`);
+      throw new Error("Trajectory not found");
+    }
+    if (options.trace) {
+      console.log(`Trace for ${trajectory.task.title}:
+`);
+      if (trajectory._trace) {
+        console.log("Trace Reference:");
+        console.log(`  Start Ref: ${trajectory._trace.startRef}`);
+        if (trajectory._trace.endRef) {
+          console.log(`  End Ref:   ${trajectory._trace.endRef}`);
+        }
+        if (trajectory._trace.traceId) {
+          console.log(`  Trace ID:  ${trajectory._trace.traceId}`);
+        }
+        console.log("");
+      }
+      const trace = await findTraceFile(id);
+      if (trace) {
+        console.log("Trace Details:");
+        console.log(`  ID:        ${trace.id}`);
+        console.log(`  Timestamp: ${trace.timestamp}`);
+        console.log(`  Files:     ${trace.files.length}`);
+        console.log("");
+        if (trace.files.length > 0) {
+          console.log("Modified Files:");
+          for (const file of trace.files) {
+            const rangeCount = file.conversations.reduce(
+              (sum, conv) => sum + conv.ranges.length,
+              0
+            );
+            const model = file.conversations[0]?.contributor.model_id ?? "unknown";
+            console.log(`  \u2022 ${file.path}`);
+            console.log(`    Ranges: ${rangeCount}, Model: ${model}`);
+          }
+        }
+      } else if (!trajectory._trace) {
+        console.log("No trace information available");
+        console.log(
+          "Trace is captured when starting a trajectory in a git repo"
+        );
+      }
+      return;
+    }
+    if (options.decisions) {
+      const decisions = extractDecisions2(trajectory);
+      if (decisions.length === 0) {
+        console.log("No decisions recorded");
+        return;
+      }
+      console.log(`Decisions for ${trajectory.task.title}:
+`);
+      for (const decision of decisions) {
+        console.log(`\u2022 ${decision.question}`);
+        console.log(`  Chose: ${decision.chosen}`);
+        console.log(`  Reasoning: ${decision.reasoning}`);
+        if (decision.alternatives.length > 0) {
+          const altStrings = decision.alternatives.map(
+            (a) => typeof a === "string" ? a : a.option
+          );
+          console.log(`  Alternatives: ${altStrings.join(", ")}`);
+        }
+        console.log("");
+      }
+      return;
+    }
+    console.log(`Trajectory: ${trajectory.id}`);
+    console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+    console.log(`Title:   ${trajectory.task.title}`);
+    console.log(`Status:  ${trajectory.status}`);
+    console.log(`Started: ${trajectory.startedAt}`);
+    if (trajectory.completedAt) {
+      console.log(`Ended:   ${trajectory.completedAt}`);
+    }
+    if (trajectory.task.source) {
+      console.log(
+        `Source:  ${trajectory.task.source.system}:${trajectory.task.source.id}`
+      );
+    }
+    console.log(`
+Chapters: ${trajectory.chapters.length}`);
+    for (const chapter of trajectory.chapters) {
+      console.log(`  \u2022 ${chapter.title} (${chapter.agentName})`);
+      console.log(`    Events: ${chapter.events.length}`);
+    }
+    if (trajectory.retrospective) {
+      console.log("\nRetrospective:");
+      console.log(`  Summary: ${trajectory.retrospective.summary}`);
+      console.log(
+        `  Confidence: ${Math.round(trajectory.retrospective.confidence * 100)}%`
+      );
+    }
+  });
+}
+function extractDecisions2(trajectory) {
+  const decisions = [];
+  if (trajectory.retrospective?.decisions) {
+    decisions.push(...trajectory.retrospective.decisions);
+  }
+  for (const chapter of trajectory.chapters) {
+    for (const event of chapter.events) {
+      if (event.type === "decision" && event.raw) {
+        const raw = event.raw;
+        if (raw.question && raw.chosen && raw.reasoning) {
+          if (!decisions.some((d) => d.question === raw.question)) {
+            decisions.push(raw);
+          }
+        }
+      }
+    }
+  }
+  return decisions;
+}
+
+// src/cli/commands/start.ts
+function registerStartCommand(program2) {
+  program2.command("start <title>").description("Start a new trajectory").option("-t, --task <id>", "External task ID").option(
+    "-s, --source <system>",
+    "Task system (github, linear, jira, beads)"
+  ).option("--url <url>", "URL to external task").option("-a, --agent <name>", "Agent name (or set TRAJECTORIES_AGENT)").option("-p, --project <id>", "Project ID (or set TRAJECTORIES_PROJECT)").option(
+    "-w, --workflow <id>",
+    "Workflow run id (or set TRAJECTORIES_WORKFLOW_ID). Stamped onto the trajectory so `trail compact --workflow <id>` can collate a run."
+  ).option("-q, --quiet", "Only output trajectory ID (for scripting)").action(async (title, options) => {
+    const storage = new FileStorage();
+    await storage.initialize();
+    const active = await storage.getActive();
+    if (active) {
+      if (!options.quiet) {
+        console.error(`Error: Trajectory already active: ${active.id}`);
+        console.error(
+          "Complete or abandon it first with: trail complete or trail abandon"
+        );
+      }
+      throw new Error("Trajectory already active");
+    }
+    let source;
+    if (options.task) {
+      source = {
+        system: options.source || "plain",
+        id: options.task,
+        url: options.url
+      };
+    }
+    const agentName = options.agent ?? process.env.TRAJECTORIES_AGENT ?? void 0;
+    const projectId = options.project ?? process.env.TRAJECTORIES_PROJECT ?? void 0;
+    const workflowId = typeof options.workflow === "string" && options.workflow.trim() || typeof process.env.TRAJECTORIES_WORKFLOW_ID === "string" && process.env.TRAJECTORIES_WORKFLOW_ID.trim() || void 0;
+    const startRef = captureGitState();
+    let trajectory = createTrajectory({
+      title,
+      source,
+      projectId
+    });
+    if (workflowId) {
+      trajectory = { ...trajectory, workflowId };
+    }
+    if (startRef) {
+      trajectory = {
+        ...trajectory,
+        _trace: createTraceRef(startRef)
+      };
+    }
+    if (agentName) {
+      trajectory = addChapter(trajectory, {
+        title: "Initial work",
+        agentName
+      });
+    }
+    await storage.save(trajectory);
+    if (options.quiet) {
+      console.log(trajectory.id);
+    } else {
+      console.log(`\u2713 Trajectory started: ${trajectory.id}`);
+      console.log(`  Title: ${title}`);
+      if (agentName) {
+        console.log(`  Agent: ${agentName}`);
+      }
+      if (projectId) {
+        console.log(`  Project: ${projectId}`);
+      }
+      if (source) {
+        console.log(`  Linked to: ${source.id} (${source.system})`);
+      }
+    }
+  });
+}
+
+// src/cli/commands/status.ts
+function registerStatusCommand(program2) {
+  program2.command("status").description("Show active trajectory status").action(async () => {
+    const storage = new FileStorage();
+    await storage.initialize();
+    const active = await storage.getActive();
+    if (!active) {
+      console.log("No active trajectory");
+      console.log('Start one with: trail start "Task description"');
+      return;
+    }
+    const duration = formatDuration3(
+      (/* @__PURE__ */ new Date()).getTime() - new Date(active.startedAt).getTime()
+    );
+    const eventCount = active.chapters.reduce(
+      (sum, ch) => sum + ch.events.length,
+      0
+    );
+    const decisionCount = active.chapters.reduce(
+      (sum, ch) => sum + ch.events.filter((e) => e.type === "decision").length,
+      0
+    );
+    console.log(`Active Trajectory: ${active.id}`);
+    console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+    console.log(`Task:      ${active.task.title}`);
+    if (active.task.source) {
+      console.log(
+        `Source:    ${active.task.source.system}:${active.task.source.id}`
+      );
+    }
+    console.log(`Status:    ${active.status}`);
+    console.log(`Started:   ${duration} ago`);
+    console.log(`Chapters:  ${active.chapters.length}`);
+    console.log(`Events:    ${eventCount}`);
+    console.log(`Decisions: ${decisionCount}`);
+    if (active._trace?.startRef) {
+      const commits = getCommitsBetween(active._trace.startRef);
+      const filesChanged = getFilesChangedBetween(active._trace.startRef);
+      if (commits.length > 0) {
+        console.log(`Commits:   ${commits.length}`);
+      }
+      if (filesChanged.length > 0) {
+        console.log(`Files:     ${filesChanged.length}`);
+      }
+    }
+    if (active.chapters.length > 0) {
+      const currentChapter = active.chapters[active.chapters.length - 1];
+      console.log(`
+Current Chapter: ${currentChapter.title}`);
+      console.log(`  Agent: ${currentChapter.agentName}`);
+    }
+  });
+}
+function formatDuration3(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days}d ${hours % 24}h`;
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m`;
+  return `${seconds}s`;
+}
+
+// src/cli/commands/index.ts
+function registerCommands(program2) {
+  registerStartCommand(program2);
+  registerStatusCommand(program2);
+  registerCompleteCommand(program2);
+  registerAbandonCommand(program2);
+  registerDecisionCommand(program2);
+  registerReflectCommand(program2);
+  registerListCommand(program2);
+  registerShowCommand(program2);
+  registerExportCommand(program2);
+  registerEnableCommand(program2);
+  registerCompactCommand(program2);
+}
+
+// src/cli/version.ts
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function findPackageJson(startDir) {
+  let dir = startDir;
+  while (dir !== path.dirname(dir)) {
+    const candidate = path.join(dir, "package.json");
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+    dir = path.dirname(dir);
+  }
+  throw new Error("Could not find package.json");
+}
+function resolveCliVersion() {
+  try {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const packageJsonPath = findPackageJson(here);
+    const packageJson = JSON.parse(
+      fs.readFileSync(packageJsonPath, "utf-8")
+    );
+    return packageJson.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+var VERSION = resolveCliVersion();
+
+// src/cli/index.ts
+program.name("trail").description("Leave a trail of your work for others to follow").version(VERSION).option(
+  "--data-dir <path>",
+  "Override trajectory storage directory (or set TRAJECTORIES_DATA_DIR)"
+).hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  if (opts.dataDir) {
+    process.env.TRAJECTORIES_DATA_DIR = opts.dataDir;
+  }
+});
+registerCommands(program);
+program.parse();
+//# sourceMappingURL=index.js.map