agent-trajectories 0.5.2 → 0.5.4

package/dist/cli/index.js

@@ -49,18 +49,20 @@ var TrajectoryStatusSchema = z.enum([
   "completed",
   "abandoned"
 ]);
-var TrajectoryEventTypeSchema = z.enum([
-  "prompt",
-  "thinking",
-  "tool_call",
-  "tool_result",
-  "message_sent",
-  "message_received",
-  "decision",
-  "finding",
-  "reflection",
-  "note",
-  "error"
+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",
@@ -90,7 +92,7 @@ var DecisionSchema = z.object({
 });
 var AgentParticipationSchema = z.object({
   name: z.string().min(1, "Agent name is required"),
-  role: z.enum(["lead", "contributor", "reviewer"]),
+  role: z.string().min(1, "Agent role is required"),
   joinedAt: z.string().datetime(),
   leftAt: z.string().datetime().optional()
 });
@@ -150,7 +152,7 @@ var TrajectoryTraceRefSchema = z.object({
   traceId: z.string().optional()
 });
 var TrajectorySchema = z.object({
-  id: z.string().regex(/^traj_[a-z0-9]+$/, "Invalid trajectory ID format"),
+  id: z.string().regex(/^traj_[a-z0-9_]+$/, "Invalid trajectory ID format"),
   version: z.literal(1),
   task: TaskReferenceSchema,
   status: TrajectoryStatusSchema,
@@ -159,10 +161,11 @@ var TrajectorySchema = z.object({
   agents: z.array(AgentParticipationSchema),
   chapters: z.array(ChapterSchema),
   retrospective: RetrospectiveSchema.optional(),
-  commits: z.array(z.string()),
-  filesChanged: z.array(z.string()),
-  projectId: z.string(),
-  tags: z.array(z.string()),
+  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({
@@ -564,11 +567,11 @@ function extractDecisions(trajectory) {
 }
 
 // src/storage/file.ts
-function expandPath(path) {
-  if (path.startsWith("~")) {
-    return join(process.env.HOME ?? "", path.slice(1));
+function expandPath(path2) {
+  if (path2.startsWith("~")) {
+    return join(process.env.HOME ?? "", path2.slice(1));
   }
-  return path;
+  return path2;
 }
 function getSearchPaths() {
   const searchPathsEnv = process.env.TRAJECTORIES_SEARCH_PATHS;
@@ -613,11 +616,129 @@ var FileStorage = class {
         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;
   }
   /**
-   * Save a trajectory
+   * Recursively collect all .json file paths under `dir` into `out`.
+   * Silently treats a missing directory as empty.
    */
-  async save(trajectory) {
+  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) {
@@ -647,19 +768,23 @@ var FileStorage = class {
   async get(id) {
     const activePath = join(this.activeDir, `${id}.json`);
     if (existsSync(activePath)) {
-      return this.readTrajectoryFile(activePath);
+      return this.readTrajectoryOrNull(activePath);
     }
     const index = await this.loadIndex();
     const entry = index.trajectories[id];
     if (entry?.path && existsSync(entry.path)) {
-      return this.readTrajectoryFile(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.readTrajectoryFile(filePath);
+          return this.readTrajectoryOrNull(filePath);
         }
       }
     } catch (error) {
@@ -682,7 +807,7 @@ var FileStorage = class {
       let mostRecent = null;
       let mostRecentTime = 0;
       for (const file of jsonFiles) {
-        const trajectory = await this.readTrajectoryFile(
+        const trajectory = await this.readTrajectoryOrNull(
           join(this.activeDir, file)
         );
         if (trajectory) {
@@ -810,20 +935,44 @@ var FileStorage = class {
   async close() {
   }
   // Private helpers
-  async readTrajectoryFile(path) {
+  /**
+   * 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 {
-      const content = await readFile(path, "utf-8");
-      const data = JSON.parse(content);
-      const validation = validateTrajectory(data);
-      if (validation.success) {
-        return validation.data;
-      }
-      console.error(`Invalid trajectory at ${path}:`, validation.errors);
-      return null;
+      content = await readFile(path2, "utf-8");
     } catch (error) {
-      console.error(`Failed to read trajectory at ${path}:`, error);
-      return null;
+      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 {
@@ -880,9 +1029,1132 @@ function registerAbandonCommand(program2) {
 }
 
 // src/cli/commands/compact.ts
-import { execSync } from "child_process";
-import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "fs";
+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)"
@@ -892,16 +2164,22 @@ function registerCompactCommand(program2) {
   ).option(
     "--until <date>",
     "Include trajectories until this date (ISO format)"
-  ).option("--ids <ids>", "Comma-separated list of trajectory IDs to compact").option("--pr <number>", "Compact trajectories associated with a PR number").option(
+  ).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("--dry-run", "Preview what would be compacted without saving").option("--output <path>", "Output path for compacted trajectory").action(async (options) => {
+  ).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.pr || options.branch || options.commits) {
+      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(
@@ -912,17 +2190,92 @@ function registerCompactCommand(program2) {
     }
     console.log(`Compacting ${trajectories.length} trajectories...
 `);
-    const compacted = compactTrajectories(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) {
-      console.log("=== DRY RUN - Preview ===\n");
-      printCompactedSummary(compacted);
+      printLLMDryRun(llmPlan, config.model, options.workflow);
       return;
     }
-    const outputPath = options.output || getDefaultOutputPath(compacted);
-    saveCompactedTrajectory(compacted, outputPath);
+    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);
   });
 }
@@ -943,55 +2296,55 @@ async function loadTrajectories(options) {
   const searchPaths = getSearchPaths();
   const seenIds = /* @__PURE__ */ new Set();
   for (const searchPath of searchPaths) {
-    if (!existsSync2(searchPath)) continue;
+    if (!existsSync3(searchPath)) continue;
     const originalDataDir = process.env.TRAJECTORIES_DATA_DIR;
     process.env.TRAJECTORIES_DATA_DIR = searchPath;
-    try {
-      const storage = new FileStorage();
-      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.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);
+    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;
         }
-      }
-    } finally {
-      if (originalDataDir !== void 0) {
-        process.env.TRAJECTORIES_DATA_DIR = originalDataDir;
-      } else {
-        delete process.env.TRAJECTORIES_DATA_DIR;
+        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);
       }
     }
   }
@@ -1000,8 +2353,9 @@ async function loadTrajectories(options) {
 function getBranchCommits(targetBranch) {
   const commits = /* @__PURE__ */ new Set();
   try {
-    const output = execSync(
-      `git log '${targetBranch.replace(/'/g, "'\\''")}'..HEAD --format=%H`,
+    const output = execFileSync(
+      "git",
+      ["log", `${targetBranch}..HEAD`, "--format=%H"],
       {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -1024,10 +2378,10 @@ function getCompactedTrajectoryIds() {
   const compacted = /* @__PURE__ */ new Set();
   const searchPaths = getSearchPaths();
   for (const searchPath of searchPaths) {
-    const indexPath = join2(searchPath, "index.json");
-    if (!existsSync2(indexPath)) continue;
+    const indexPath = join4(searchPath, "index.json");
+    if (!existsSync3(indexPath)) continue;
     try {
-      const indexContent = readFileSync(indexPath, "utf-8");
+      const indexContent = readFileSync2(indexPath, "utf-8");
       const index = JSON.parse(indexContent);
       for (const [id, entry] of Object.entries(index.trajectories || {})) {
         if (entry.compactedInto) {
@@ -1042,10 +2396,10 @@ function getCompactedTrajectoryIds() {
 async function markTrajectoriesAsCompacted(trajectories, compactedIntoId) {
   const searchPaths = getSearchPaths();
   for (const searchPath of searchPaths) {
-    const indexPath = join2(searchPath, "index.json");
-    if (!existsSync2(indexPath)) continue;
+    const indexPath = join4(searchPath, "index.json");
+    if (!existsSync3(indexPath)) continue;
     try {
-      const indexContent = readFileSync(indexPath, "utf-8");
+      const indexContent = readFileSync2(indexPath, "utf-8");
       const index = JSON.parse(indexContent);
       let updated = false;
       for (const traj of trajectories) {
@@ -1081,7 +2435,7 @@ function parseRelativeDate(input) {
   }
   return new Date(input);
 }
-function compactTrajectories(trajectories) {
+function compactTrajectories(trajectories, workflowId) {
   const allDecisions = [];
   const allLearnings = [];
   const allFindings = [];
@@ -1144,6 +2498,7 @@ function compactTrajectories(trajectories) {
     version: 1,
     type: "compacted",
     compactedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workflowId,
     sourceTrajectories: trajectories.map((t) => t.id),
     dateRange: {
       start: minDate.toISOString(),
@@ -1214,56 +2569,206 @@ function groupDecisions(decisions) {
     (a, b) => b.decisions.length - a.decisions.length
   );
 }
-function getDefaultOutputPath(compacted) {
+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 = join2(trajDir, "compacted");
-  if (!existsSync2(compactedDir)) {
+  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 join2(compactedDir, `${compacted.id}_${dateStr}.json`);
+  return join4(compactedDir, `${compacted.id}_${dateStr}.json`);
 }
-function saveCompactedTrajectory(compacted, outputPath) {
-  const dir = join2(outputPath, "..");
-  if (!existsSync2(dir)) {
+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: ${formatDate2(compacted.dateRange.start)} - ${formatDate2(compacted.dateRange.end)}`
+    `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("");
-  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 (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 (group.decisions.length > 3) {
-      console.log(`  ... and ${group.decisions.length - 3} more`);
+    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("");
     }
-    console.log("");
-  }
-  if (compacted.keyLearnings.length > 0) {
-    console.log("=== Key Learnings ===\n");
-    for (const learning of compacted.keyLearnings.slice(0, 5)) {
-      console.log(`  - ${learning}`);
+  } 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 > 5) {
-      console.log(`  ... and ${compacted.keyLearnings.length - 5} more`);
+    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("");
     }
-    console.log("");
   }
   if (compacted.filesAffected.length > 0) {
     console.log(`Files affected: ${compacted.filesAffected.length}`);
@@ -1272,7 +2777,7 @@ function printCompactedSummary(compacted) {
     console.log(`Commits: ${compacted.commits.length}`);
   }
 }
-function formatDate2(isoString) {
+function formatDate3(isoString) {
   return new Date(isoString).toLocaleDateString("en-US", {
     month: "short",
     day: "numeric",
@@ -1284,12 +2789,12 @@ function capitalize(str) {
 }
 
 // src/cli/commands/complete.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join5 } from "path";
 
 // src/core/trace.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync } from "child_process";
 import { createHash } from "crypto";
 function isValidGitRef(ref) {
   const validRefPattern = /^[a-zA-Z0-9_\-./]+$/;
@@ -1309,7 +2814,7 @@ function isValidGitRef(ref) {
 }
 function isGitRepo() {
   try {
-    execSync2("git rev-parse --is-inside-work-tree", {
+    execSync("git rev-parse --is-inside-work-tree", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -1323,7 +2828,7 @@ function getGitHead() {
     return null;
   }
   try {
-    const head = execSync2("git rev-parse HEAD", {
+    const head = execSync("git rev-parse HEAD", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -1375,7 +2880,7 @@ function getChangedFiles(startRef, endRef = "HEAD") {
     return [];
   }
   try {
-    const diffOutput = execSync2(`git diff ${startRef}..${endRef}`, {
+    const diffOutput = execSync(`git diff ${startRef}..${endRef}`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       maxBuffer: 10 * 1024 * 1024
@@ -1416,8 +2921,8 @@ function generateTrace(trajectory, startRef) {
     return null;
   }
   const model = detectModel();
-  const traceFiles = changedFiles.map(({ path, ranges }) => ({
-    path,
+  const traceFiles = changedFiles.map(({ path: path2, ranges }) => ({
+    path: path2,
     conversations: [
       {
         contributor: {
@@ -1480,8 +2985,8 @@ function createTraceRef(startRef, traceId) {
 }
 
 // src/core/trailers.ts
-import { execSync as execSync3 } from "child_process";
-import { readFileSync as readFileSync2 } from "fs";
+import { execSync as execSync2 } from "child_process";
+import { readFileSync as readFileSync3 } from "fs";
 function getCommitsBetween(startRef, endRef = "HEAD") {
   if (!isGitRepo()) {
     return [];
@@ -1490,7 +2995,7 @@ function getCommitsBetween(startRef, endRef = "HEAD") {
     return [];
   }
   try {
-    const output = execSync3(
+    const output = execSync2(
       `git log --format=%H%n%h%n%s%n%an%n%aI%n--- ${startRef}..${endRef}`,
       {
         encoding: "utf-8",
@@ -1527,7 +3032,7 @@ function getFilesChangedBetween(startRef, endRef = "HEAD") {
     return [];
   }
   try {
-    const output = execSync3(`git diff --name-only ${startRef}..${endRef}`, {
+    const output = execSync2(`git diff --name-only ${startRef}..${endRef}`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -1564,8 +3069,11 @@ if [ -z "$ACTIVE_FILE" ]; then
   exit 0
 fi
 
-# Extract trajectory ID (grep for the "id" field)
-TRAJ_ID=$(grep -o '"id"[[:space:]]*:[[:space:]]*"traj_[a-z0-9]*"' "$ACTIVE_FILE" | head -1 | grep -o 'traj_[a-z0-9]*')
+# 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
@@ -1585,13 +3093,13 @@ function detectExistingHook() {
     return "none";
   }
   try {
-    const hooksDir = execSync3("git rev-parse --git-dir", {
+    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 = readFileSync2(hookPath, "utf-8");
+      const content = readFileSync3(hookPath, "utf-8");
       if (content.includes("agent-trajectories")) {
         return "ours";
       }
@@ -1607,17 +3115,17 @@ function detectExistingHook() {
 // src/cli/commands/complete.ts
 async function saveTraceFile(trajectory, trace) {
   const dataDir = process.env.TRAJECTORIES_DATA_DIR;
-  const baseDir = dataDir ? dataDir : join3(process.cwd(), ".trajectories");
-  const completedDir = join3(baseDir, "completed");
+  const baseDir = dataDir ? dataDir : join5(process.cwd(), ".trajectories");
+  const completedDir = join5(baseDir, "completed");
   const date = new Date(trajectory.completedAt ?? trajectory.startedAt);
-  const monthDir = join3(
+  const monthDir = join5(
     completedDir,
     `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}`
   );
-  if (!existsSync3(monthDir)) {
+  if (!existsSync4(monthDir)) {
     await mkdir2(monthDir, { recursive: true });
   }
-  const tracePath = join3(monthDir, `${trajectory.id}.trace.json`);
+  const tracePath = join5(monthDir, `${trajectory.id}.trace.json`);
   await writeFile2(tracePath, JSON.stringify(trace, null, 2), "utf-8");
 }
 function registerCompleteCommand(program2) {
@@ -1730,17 +3238,17 @@ function registerDecisionCommand(program2) {
 }
 
 // src/cli/commands/enable.ts
-import { execSync as execSync4 } from "child_process";
-import { existsSync as existsSync4 } from "fs";
+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 join4 } from "path";
+import { join as join6 } from "path";
 function getHooksDir() {
   try {
-    const gitDir = execSync4("git rev-parse --git-dir", {
+    const gitDir = execSync3("git rev-parse --git-dir", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    return join4(gitDir, "hooks");
+    return join6(gitDir, "hooks");
   } catch {
     return null;
   }
@@ -1758,7 +3266,7 @@ function registerEnableCommand(program2) {
       console.error("Error: Could not determine git hooks directory");
       throw new Error("Cannot find hooks directory");
     }
-    const hookPath = join4(hooksDir, "prepare-commit-msg");
+    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");
@@ -1771,7 +3279,7 @@ function registerEnableCommand(program2) {
       console.log("Trajectory hook is already installed");
       return;
     }
-    if (!existsSync4(hooksDir)) {
+    if (!existsSync5(hooksDir)) {
       await mkdir3(hooksDir, { recursive: true });
     }
     const hookContent = generateHookScript();
@@ -1793,7 +3301,7 @@ function registerEnableCommand(program2) {
       console.error("Error: Could not determine git hooks directory");
       throw new Error("Cannot find hooks directory");
     }
-    const hookPath = join4(hooksDir, "prepare-commit-msg");
+    const hookPath = join6(hooksDir, "prepare-commit-msg");
     const existing = detectExistingHook();
     if (existing === "none") {
       console.log("No trajectory hook installed");
@@ -1815,7 +3323,7 @@ function registerEnableCommand(program2) {
 // src/cli/commands/export.ts
 import { exec } from "child_process";
 import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join7 } from "path";
 
 // src/export/json.ts
 function exportToJSON(trajectory, options) {
@@ -2229,7 +3737,7 @@ h2 {
 function escapeHtml(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
 }
-function formatDate3(isoDate) {
+function formatDate4(isoDate) {
   const date = new Date(isoDate);
   return date.toLocaleDateString("en-US", {
     month: "short",
@@ -2239,7 +3747,7 @@ function formatDate3(isoDate) {
     minute: "2-digit"
   });
 }
-function formatDuration(startDate, endDate) {
+function formatDuration2(startDate, endDate) {
   const start = new Date(startDate).getTime();
   const end = endDate ? new Date(endDate).getTime() : Date.now();
   const ms = end - start;
@@ -2278,7 +3786,7 @@ function renderDecision(decision) {
   `;
 }
 function renderEvent(event) {
-  const time = formatDate3(new Date(event.ts).toISOString());
+  const time = formatDate4(new Date(event.ts).toISOString());
   let content = "";
   let typeClass = "";
   const rawData = event.raw;
@@ -2324,7 +3832,7 @@ function renderEvent(event) {
     </div>
   `;
 }
-function renderChapter(chapter, index) {
+function renderChapter2(chapter, index) {
   const events = chapter.events.map(renderEvent).join("");
   return `
     <div class="chapter">
@@ -2341,7 +3849,7 @@ function renderChapter(chapter, index) {
     </div>
   `;
 }
-function renderRetrospective(trajectory) {
+function renderRetrospective2(trajectory) {
   if (!trajectory.retrospective) {
     return "";
   }
@@ -2373,7 +3881,7 @@ function renderRetrospective(trajectory) {
 }
 function generateTrajectoryHtml(trajectory) {
   const statusClass = getStatusClass(trajectory.status);
-  const duration = formatDuration(trajectory.startedAt, trajectory.completedAt);
+  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"
@@ -2392,7 +3900,7 @@ function generateTrajectoryHtml(trajectory) {
         Chapters (${trajectory.chapters.length})
       </h2>
       <div class="collapsible-content">
-        ${trajectory.chapters.map(renderChapter).join("")}
+        ${trajectory.chapters.map(renderChapter2).join("")}
       </div>
     ` : "";
   const filesHtml = trajectory.filesChanged.length ? `
@@ -2433,7 +3941,7 @@ function generateTrajectoryHtml(trajectory) {
       </div>
       <div class="meta-item">
         <span class="meta-label">Started</span>
-        <span class="meta-value">${formatDate3(trajectory.startedAt)}</span>
+        <span class="meta-value">${formatDate4(trajectory.startedAt)}</span>
       </div>
       ${trajectory.task.source ? `
       <div class="meta-item">
@@ -2448,7 +3956,7 @@ function generateTrajectoryHtml(trajectory) {
     </div>
   </div>
 
-  ${renderRetrospective(trajectory)}
+  ${renderRetrospective2(trajectory)}
   ${decisionsHtml}
   ${chaptersHtml}
   ${filesHtml}
@@ -2512,9 +4020,9 @@ function registerExportCommand(program2) {
         openInBrowser(options.output);
       }
     } else if (options.open && options.format === "html") {
-      const outputDir = join5(process.cwd(), ".trajectories", "html");
+      const outputDir = join7(process.cwd(), ".trajectories", "html");
       await mkdir4(outputDir, { recursive: true });
-      const filePath = join5(outputDir, `${trajectory.id}.html`);
+      const filePath = join7(outputDir, `${trajectory.id}.html`);
       await writeFile4(filePath, output, "utf-8");
       console.log(`\u2713 Generated: ${filePath}`);
       openInBrowser(filePath);
@@ -2523,25 +4031,25 @@ function registerExportCommand(program2) {
     }
   });
 }
-function openInBrowser(path) {
+function openInBrowser(path2) {
   const platform = process.platform;
   let command;
   if (platform === "darwin") {
-    command = `open "${path}"`;
+    command = `open "${path2}"`;
   } else if (platform === "win32") {
-    command = `start "" "${path}"`;
+    command = `start "" "${path2}"`;
   } else {
-    command = `xdg-open "${path}"`;
+    command = `xdg-open "${path2}"`;
   }
   exec(command, (error) => {
     if (error) {
-      console.log(`Open manually: file://${path}`);
+      console.log(`Open manually: file://${path2}`);
     }
   });
 }
 
 // src/cli/commands/list.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 function registerListCommand(program2) {
   program2.command("list").description("List and search trajectories").option(
     "-s, --status <status>",
@@ -2551,7 +4059,7 @@ function registerListCommand(program2) {
     let allTrajectories = [];
     const seenIds = /* @__PURE__ */ new Set();
     for (const searchPath of searchPaths) {
-      if (!existsSync5(searchPath)) {
+      if (!existsSync6(searchPath)) {
         continue;
       }
       const originalDataDir = process.env.TRAJECTORIES_DATA_DIR;
@@ -2610,9 +4118,9 @@ function registerListCommand(program2) {
       const confidence = traj.confidence ? ` (${Math.round(traj.confidence * 100)}%)` : "";
       console.log(`${statusIcon} ${traj.id}`);
       console.log(`   ${traj.title}${confidence}`);
-      console.log(`   Started: ${formatDate4(traj.startedAt)}`);
+      console.log(`   Started: ${formatDate5(traj.startedAt)}`);
       if (traj.completedAt) {
-        console.log(`   Completed: ${formatDate4(traj.completedAt)}`);
+        console.log(`   Completed: ${formatDate5(traj.completedAt)}`);
       }
       console.log("");
     }
@@ -2630,7 +4138,7 @@ function getStatusIcon(status) {
       return "\u2022";
   }
 }
-function formatDate4(isoString) {
+function formatDate5(isoString) {
   return new Date(isoString).toLocaleDateString("en-US", {
     month: "short",
     day: "numeric",
@@ -2700,13 +4208,13 @@ function registerReflectCommand(program2) {
 }
 
 // src/cli/commands/show.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { readFile as readFile2 } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join8 } from "path";
 async function findTrajectory(id) {
   const searchPaths = getSearchPaths();
   for (const searchPath of searchPaths) {
-    if (!existsSync6(searchPath)) {
+    if (!existsSync7(searchPath)) {
       continue;
     }
     const originalDataDir = process.env.TRAJECTORIES_DATA_DIR;
@@ -2731,19 +4239,19 @@ async function findTrajectory(id) {
 async function findTraceFile(id) {
   const searchPaths = getSearchPaths();
   for (const searchPath of searchPaths) {
-    if (!existsSync6(searchPath)) {
+    if (!existsSync7(searchPath)) {
       continue;
     }
-    const completedDir = join6(searchPath, "completed");
-    if (!existsSync6(completedDir)) {
+    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 = join6(completedDir, month, `${id}.trace.json`);
-        if (existsSync6(tracePath)) {
+        const tracePath = join8(completedDir, month, `${id}.trace.json`);
+        if (existsSync7(tracePath)) {
           let record;
           let migrated;
           try {
@@ -2894,7 +4402,10 @@ 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("-q, --quiet", "Only output trajectory ID (for scripting)").action(async (title, options) => {
+  ).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();
@@ -2917,12 +4428,16 @@ function registerStartCommand(program2) {
     }
     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,
@@ -2965,7 +4480,7 @@ function registerStatusCommand(program2) {
       console.log('Start one with: trail start "Task description"');
       return;
     }
-    const duration = formatDuration2(
+    const duration = formatDuration3(
       (/* @__PURE__ */ new Date()).getTime() - new Date(active.startedAt).getTime()
     );
     const eventCount = active.chapters.reduce(
@@ -3007,7 +4522,7 @@ Current Chapter: ${currentChapter.title}`);
     }
   });
 }
-function formatDuration2(ms) {
+function formatDuration3(ms) {
   const seconds = Math.floor(ms / 1e3);
   const minutes = Math.floor(seconds / 60);
   const hours = Math.floor(minutes / 60);
@@ -3033,8 +4548,37 @@ function registerCommands(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("0.1.0").option(
+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) => {