agent-relay 4.0.19 → 4.0.21

package/node_modules/agent-trajectories/dist/chunk-W222QB6V.js

@@ -0,0 +1,2036 @@
+// src/sdk/client.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { createRequire } from "module";
+import { dirname, resolve as resolvePath } from "path";
+
+// 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()}`;
+}
+function isValidTrajectoryId(id) {
+  return /^traj_[a-z0-9_]+$/.test(id);
+}
+function isValidChapterId(id) {
+  return /^chap_[a-z0-9]{12}$/.test(id);
+}
+
+// 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 };
+}
+function validateCreateInput(data) {
+  const result = CreateTrajectoryInputSchema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, errors: result.error };
+}
+function validateCompleteInput(data) {
+  const result = CompleteTrajectoryInputSchema.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(trajectory2, input) {
+  if (trajectory2.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 = trajectory2.chapters.map((chapter, index) => {
+    if (index === trajectory2.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 = trajectory2.agents;
+  const agentExists = trajectory2.agents.some((a) => a.name === input.agentName);
+  if (!agentExists) {
+    const isFirstAgent = trajectory2.agents.length === 0;
+    updatedAgents = [
+      ...trajectory2.agents,
+      {
+        name: input.agentName,
+        role: isFirstAgent ? "lead" : "contributor",
+        joinedAt: now
+      }
+    ];
+  }
+  return {
+    ...trajectory2,
+    agents: updatedAgents,
+    chapters: [...updatedChapters, newChapter]
+  };
+}
+function addEvent(trajectory2, input) {
+  let updatedTrajectory = trajectory2;
+  if (trajectory2.chapters.length === 0) {
+    updatedTrajectory = addChapter(trajectory2, {
+      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(trajectory2, decision) {
+  return addEvent(trajectory2, {
+    type: "decision",
+    content: `${decision.question}: ${decision.chosen}`,
+    raw: decision,
+    significance: "high"
+  });
+}
+function completeTrajectory(trajectory2, input) {
+  if (trajectory2.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 = trajectory2.chapters.map((chapter, index) => {
+    if (index === trajectory2.chapters.length - 1 && !chapter.endedAt) {
+      return { ...chapter, endedAt: now };
+    }
+    return chapter;
+  });
+  return {
+    ...trajectory2,
+    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(trajectory2, reason) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const chapters = trajectory2.chapters.map((chapter, index) => {
+    if (index === trajectory2.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 {
+    ...trajectory2,
+    status: "abandoned",
+    completedAt: now,
+    chapters: updatedChapters
+  };
+}
+
+// src/export/json.ts
+function exportToJSON(trajectory2, options) {
+  if (options?.compact) {
+    return JSON.stringify(trajectory2);
+  }
+  return JSON.stringify(trajectory2, null, 2);
+}
+
+// src/export/markdown.ts
+function exportToMarkdown(trajectory2) {
+  const lines = [];
+  lines.push(`# Trajectory: ${trajectory2.task.title}`);
+  lines.push("");
+  lines.push(`> **Status:** ${formatStatus(trajectory2.status)}`);
+  if (trajectory2.task.source) {
+    const linkText = trajectory2.task.source.url ? `[${trajectory2.task.source.id}](${trajectory2.task.source.url})` : trajectory2.task.source.id;
+    lines.push(`> **Task:** ${linkText}`);
+  }
+  if (trajectory2.retrospective?.confidence !== void 0) {
+    lines.push(
+      `> **Confidence:** ${Math.round(trajectory2.retrospective.confidence * 100)}%`
+    );
+  }
+  lines.push(`> **Started:** ${formatDate(trajectory2.startedAt)}`);
+  if (trajectory2.completedAt) {
+    lines.push(`> **Completed:** ${formatDate(trajectory2.completedAt)}`);
+  }
+  lines.push("");
+  if (trajectory2.retrospective) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Summary");
+    lines.push("");
+    lines.push(trajectory2.retrospective.summary);
+    lines.push("");
+    if (trajectory2.retrospective.approach) {
+      lines.push(`**Approach:** ${trajectory2.retrospective.approach}`);
+      lines.push("");
+    }
+  }
+  const decisions = extractDecisions(trajectory2);
+  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 (trajectory2.chapters.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Chapters");
+    lines.push("");
+    trajectory2.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 (trajectory2.retrospective?.challenges && trajectory2.retrospective.challenges.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Challenges");
+    lines.push("");
+    for (const challenge of trajectory2.retrospective.challenges) {
+      lines.push(`- ${challenge}`);
+    }
+    lines.push("");
+  }
+  if (trajectory2.retrospective?.learnings && trajectory2.retrospective.learnings.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Learnings");
+    lines.push("");
+    for (const learning of trajectory2.retrospective.learnings) {
+      lines.push(`- ${learning}`);
+    }
+    lines.push("");
+  }
+  if (trajectory2.retrospective?.suggestions && trajectory2.retrospective.suggestions.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Suggestions");
+    lines.push("");
+    for (const suggestion of trajectory2.retrospective.suggestions) {
+      lines.push(`- ${suggestion}`);
+    }
+    lines.push("");
+  }
+  if (trajectory2.commits.length > 0 || trajectory2.filesChanged.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Artifacts");
+    lines.push("");
+    if (trajectory2.commits.length > 0) {
+      lines.push(`**Commits:** ${trajectory2.commits.join(", ")}`);
+    }
+    if (trajectory2.filesChanged.length > 0) {
+      lines.push(`**Files changed:** ${trajectory2.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(trajectory2) {
+  const decisions = [];
+  if (trajectory2.retrospective?.decisions) {
+    decisions.push(...trajectory2.retrospective.decisions);
+  }
+  for (const chapter of trajectory2.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/export/pr-summary.ts
+function exportToPRSummary(trajectory2, options) {
+  const lines = [];
+  lines.push("## Trajectory Summary");
+  lines.push("");
+  if (trajectory2.retrospective?.summary) {
+    lines.push(trajectory2.retrospective.summary);
+    lines.push("");
+  }
+  const decisionCount = trajectory2.chapters.reduce(
+    (count, chapter) => count + chapter.events.filter((e) => e.type === "decision").length,
+    0
+  );
+  lines.push(`**Key decisions:** ${decisionCount}`);
+  if (trajectory2.retrospective?.confidence !== void 0) {
+    lines.push(
+      `**Confidence:** ${Math.round(trajectory2.retrospective.confidence * 100)}%`
+    );
+  }
+  if (options?.trajectoryPath) {
+    lines.push("");
+    lines.push(`[Full trajectory](${options.trajectoryPath})`);
+  }
+  return lines.join("\n");
+}
+
+// src/export/timeline.ts
+function exportToTimeline(trajectory2) {
+  const lines = [];
+  lines.push(
+    `\u25CF ${formatTime(trajectory2.startedAt)}  Started: ${trajectory2.task.title}`
+  );
+  lines.push("\u2502");
+  for (const chapter of trajectory2.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 (trajectory2.completedAt) {
+    const status = trajectory2.status === "completed" ? "Completed" : "Abandoned";
+    lines.push(`\u25CB ${formatTime(trajectory2.completedAt)}  ${status}`);
+    if (trajectory2.retrospective) {
+      lines.push("");
+      lines.push(`  Summary: ${trajectory2.retrospective.summary}`);
+      lines.push(
+        `  Confidence: ${Math.round(trajectory2.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/storage/file.ts
+import { existsSync } from "fs";
+import { mkdir, readFile, readdir, unlink, writeFile } from "fs/promises";
+import { join } from "path";
+function expandPath(path) {
+  if (path.startsWith("~")) {
+    return join(process.env.HOME ?? "", path.slice(1));
+  }
+  return path;
+}
+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 trajectory2 = result.trajectory;
+      if (index.trajectories[trajectory2.id]) {
+        summary.alreadyIndexed += 1;
+        continue;
+      }
+      index.trajectories[trajectory2.id] = {
+        title: trajectory2.task.title,
+        status: trajectory2.status,
+        startedAt: trajectory2.startedAt,
+        completedAt: trajectory2.completedAt,
+        path: filePath
+      };
+      summary.added += 1;
+    }
+    if (Object.keys(index.trajectories).length !== before) {
+      await this.saveIndex(index);
+    }
+    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 path = issue.path.length > 0 ? issue.path.join(".") : "root";
+        return `${path}: ${issue.message}`;
+      }).join("; ") ?? "unknown validation error";
+      throw new Error(`Cannot save invalid trajectory: ${issues}`);
+    }
+    const trajectory2 = validation.data;
+    const isCompleted = trajectory2.status === "completed" || trajectory2.status === "abandoned";
+    let filePath;
+    if (isCompleted) {
+      const date = new Date(trajectory2.completedAt ?? trajectory2.startedAt);
+      const monthDir = join(
+        this.completedDir,
+        `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}`
+      );
+      await mkdir(monthDir, { recursive: true });
+      filePath = join(monthDir, `${trajectory2.id}.json`);
+      const activePath = join(this.activeDir, `${trajectory2.id}.json`);
+      if (existsSync(activePath)) {
+        await unlink(activePath);
+      }
+      const mdPath = join(monthDir, `${trajectory2.id}.md`);
+      const markdown = exportToMarkdown(trajectory2);
+      await writeFile(mdPath, markdown, "utf-8");
+    } else {
+      filePath = join(this.activeDir, `${trajectory2.id}.json`);
+    }
+    await writeFile(filePath, JSON.stringify(trajectory2, null, 2), "utf-8");
+    await this.updateIndex(trajectory2, filePath);
+  }
+  /**
+   * Get a trajectory by ID
+   */
+  async get(id) {
+    const activePath = join(this.activeDir, `${id}.json`);
+    if (existsSync(activePath)) {
+      return this.readTrajectoryOrNull(activePath);
+    }
+    const index = await this.loadIndex();
+    const entry = index.trajectories[id];
+    if (entry?.path && existsSync(entry.path)) {
+      return this.readTrajectoryOrNull(entry.path);
+    }
+    try {
+      const flatPath = join(this.completedDir, `${id}.json`);
+      if (existsSync(flatPath)) {
+        return this.readTrajectoryOrNull(flatPath);
+      }
+      const months = await readdir(this.completedDir);
+      for (const month of months) {
+        const filePath = join(this.completedDir, month, `${id}.json`);
+        if (existsSync(filePath)) {
+          return this.readTrajectoryOrNull(filePath);
+        }
+      }
+    } 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 trajectory2 = await this.readTrajectoryOrNull(
+          join(this.activeDir, file)
+        );
+        if (trajectory2) {
+          const startTime = new Date(trajectory2.startedAt).getTime();
+          if (startTime > mostRecentTime) {
+            mostRecentTime = startTime;
+            mostRecent = trajectory2;
+          }
+        }
+      }
+      return mostRecent;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return null;
+      }
+      console.error("Error reading active trajectories:", error);
+      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 trajectory2 = await this.get(id);
+        return {
+          id,
+          title: entry.title,
+          status: entry.status,
+          startedAt: entry.startedAt,
+          completedAt: entry.completedAt,
+          confidence: trajectory2?.retrospective?.confidence,
+          chapterCount: trajectory2?.chapters.length ?? 0,
+          decisionCount: trajectory2?.chapters.reduce(
+            (count, chapter) => count + chapter.events.filter((e) => e.type === "decision").length,
+            0
+          ) ?? 0
+        };
+      })
+    );
+  }
+  /**
+   * 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 trajectory2 = await this.get(summary.id);
+      if (!trajectory2) continue;
+      if (trajectory2.retrospective?.summary.toLowerCase().includes(searchLower)) {
+        matches.push(summary);
+        continue;
+      }
+      const hasMatchingDecision = trajectory2.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(path) {
+    let content;
+    try {
+      content = await readFile(path, "utf-8");
+    } catch (error) {
+      return { ok: false, reason: "io_error", path, error };
+    }
+    let data;
+    try {
+      data = JSON.parse(content);
+    } catch (error) {
+      return { ok: false, reason: "malformed_json", path, error };
+    }
+    const validation = validateTrajectory(data);
+    if (validation.success) {
+      return { ok: true, trajectory: validation.data };
+    }
+    return {
+      ok: false,
+      reason: "schema_violation",
+      path,
+      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(path) {
+    const result = await this.readTrajectoryFile(path);
+    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(trajectory2, filePath) {
+    const index = await this.loadIndex();
+    index.trajectories[trajectory2.id] = {
+      title: trajectory2.task.title,
+      status: trajectory2.status,
+      startedAt: trajectory2.startedAt,
+      completedAt: trajectory2.completedAt,
+      path: filePath
+    };
+    await this.saveIndex(index);
+  }
+};
+
+// src/sdk/client.ts
+var require2 = createRequire(import.meta.url);
+function normalizeOptionalString(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized : void 0;
+}
+function normalizeAutoCompactOptions(autoCompact) {
+  if (!autoCompact) {
+    return false;
+  }
+  if (autoCompact === true) {
+    return { mechanical: false, markdown: true };
+  }
+  return {
+    mechanical: autoCompact.mechanical ?? false,
+    markdown: autoCompact.markdown ?? true
+  };
+}
+function resolveStartWorkflowId(options) {
+  if (options !== void 0 && Object.prototype.hasOwnProperty.call(options, "workflowId")) {
+    return normalizeOptionalString(options.workflowId);
+  }
+  return normalizeOptionalString(process.env.TRAJECTORIES_WORKFLOW_ID);
+}
+function resolveTrajectoryCliInvocation() {
+  const explicitCli = normalizeOptionalString(process.env.TRAJECTORIES_CLI);
+  if (explicitCli) {
+    if (/\.(?:cjs|mjs|js)$/i.test(explicitCli)) {
+      return { command: process.execPath, args: [explicitCli] };
+    }
+    return { command: explicitCli, args: [] };
+  }
+  try {
+    const packageJsonPath = require2.resolve("agent-trajectories/package.json");
+    const pkg = JSON.parse(
+      readFileSync(packageJsonPath, "utf-8")
+    );
+    const binEntry = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.trail ?? (pkg.name ? pkg.bin?.[pkg.name] : void 0);
+    if (binEntry) {
+      const cliPath = resolvePath(dirname(packageJsonPath), binEntry);
+      if (existsSync2(cliPath)) {
+        return { command: process.execPath, args: [cliPath] };
+      }
+    }
+  } catch {
+  }
+  return { command: "trail", args: [] };
+}
+function parseCompactWorkflowOutput(stdout) {
+  const compactedPath = stdout.match(
+    /^\s*Compacted trajectory saved to:\s*(.+)$/m
+  )?.[1];
+  const markdownPath = stdout.match(
+    /^\s*Markdown summary saved to:\s*(.+)$/m
+  )?.[1];
+  if (!compactedPath) {
+    throw new Error("compactWorkflow failed: unable to parse compacted path");
+  }
+  return {
+    compactedPath: compactedPath.trim(),
+    ...markdownPath ? { markdownPath: markdownPath.trim() } : {}
+  };
+}
+async function compactWorkflow(workflowId, options) {
+  const normalizedWorkflowId = normalizeOptionalString(workflowId);
+  if (!normalizedWorkflowId) {
+    throw new Error("compactWorkflow failed: workflowId is required");
+  }
+  const cli = resolveTrajectoryCliInvocation();
+  const args = [
+    ...cli.args,
+    "compact",
+    "--workflow",
+    normalizedWorkflowId,
+    "--all"
+  ];
+  if (options?.markdown) {
+    args.push("--markdown");
+  }
+  if (options?.mechanical) {
+    args.push("--mechanical");
+  }
+  return new Promise((resolve, reject) => {
+    const child = spawn(cli.command, args, {
+      cwd: options?.cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdoutChunks = [];
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdoutChunks.push(Buffer.from(chunk));
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+      process.stderr.write(chunk);
+    });
+    child.on("error", (error) => {
+      reject(new Error(`compactWorkflow failed: ${error.message}`));
+    });
+    child.on("close", (code) => {
+      if (code !== 0) {
+        reject(
+          new Error(
+            `compactWorkflow failed: ${stderr.trim() || `exit code ${code}`}`
+          )
+        );
+        return;
+      }
+      try {
+        const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
+        resolve(parseCompactWorkflowOutput(stdout));
+      } catch (error) {
+        reject(
+          error instanceof Error ? error : new Error("compactWorkflow failed: unable to parse CLI output")
+        );
+      }
+    });
+  });
+}
+var TrajectorySession = class {
+  trajectory;
+  client;
+  autoSave;
+  constructor(trajectory2, client, autoSave) {
+    this.trajectory = trajectory2;
+    this.client = client;
+    this.autoSave = autoSave;
+  }
+  /**
+   * Get the current trajectory data
+   */
+  get data() {
+    return this.trajectory;
+  }
+  /**
+   * Get the trajectory ID
+   */
+  get id() {
+    return this.trajectory.id;
+  }
+  async autoCompactIfConfigured() {
+    const autoCompact = this.client.getAutoCompactOptions();
+    if (!autoCompact || !this.trajectory.workflowId) {
+      return;
+    }
+    try {
+      await compactWorkflow(this.trajectory.workflowId, {
+        ...autoCompact,
+        cwd: this.client.getAutoCompactCwd()
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(
+        `Warning: autoCompact failed for workflow ${this.trajectory.workflowId}: ${message}`
+      );
+    }
+  }
+  /**
+   * Start a new chapter
+   * @param title - Chapter title
+   * @param agentName - Agent name (uses default if not specified)
+   */
+  async chapter(title, agentName) {
+    const agent = agentName ?? this.client.defaultAgent ?? "default";
+    this.trajectory = addChapter(this.trajectory, { title, agentName: agent });
+    if (this.autoSave) {
+      await this.client.save(this.trajectory);
+    }
+    return this;
+  }
+  /**
+   * Record an event
+   * @param type - Event type
+   * @param content - Human-readable content
+   * @param options - Additional event options
+   */
+  async event(type, content, options) {
+    this.trajectory = addEvent(this.trajectory, {
+      type,
+      content,
+      ...options
+    });
+    if (this.autoSave) {
+      await this.client.save(this.trajectory);
+    }
+    return this;
+  }
+  /**
+   * Record a note
+   */
+  async note(content, significance) {
+    return this.event("note", content, { significance });
+  }
+  /**
+   * Record a finding
+   */
+  async finding(content, significance) {
+    return this.event("finding", content, {
+      significance: significance ?? "medium"
+    });
+  }
+  /**
+   * Record a reflection — a higher-level synthesis of recent observations.
+   * Used by workflow orchestrators and lead agents to periodically
+   * synthesize worker progress and course-correct.
+   */
+  async reflect(content, confidence) {
+    return this.event("reflection", content, {
+      significance: "high",
+      ...confidence !== void 0 ? { tags: [`confidence:${confidence}`] } : {}
+    });
+  }
+  /**
+   * Record an error
+   */
+  async error(content) {
+    return this.event("error", content, { significance: "high" });
+  }
+  /**
+   * Record a decision
+   * @param decision - Structured decision record
+   */
+  async decision(decision) {
+    this.trajectory = addDecision(this.trajectory, decision);
+    if (this.autoSave) {
+      await this.client.save(this.trajectory);
+    }
+    return this;
+  }
+  /**
+   * Quick decision helper for simple choices
+   * @param question - What was the question/choice?
+   * @param chosen - What was chosen
+   * @param reasoning - Why this choice was made
+   * @param alternatives - Optional list of alternatives considered
+   */
+  async decide(question, chosen, reasoning, alternatives) {
+    return this.decision({
+      question,
+      chosen,
+      reasoning,
+      alternatives: alternatives ?? []
+    });
+  }
+  /**
+   * Add a tag to the trajectory
+   */
+  async tag(tag) {
+    if (!this.trajectory.tags.includes(tag)) {
+      this.trajectory = {
+        ...this.trajectory,
+        tags: [...this.trajectory.tags, tag]
+      };
+      if (this.autoSave) {
+        await this.client.save(this.trajectory);
+      }
+    }
+    return this;
+  }
+  /**
+   * Complete the trajectory with a retrospective
+   * @param input - Retrospective details
+   */
+  async complete(input) {
+    this.trajectory = completeTrajectory(this.trajectory, input);
+    await this.client.save(this.trajectory);
+    await this.autoCompactIfConfigured();
+    return this.trajectory;
+  }
+  /**
+   * Quick complete with minimal required fields
+   * @param summary - What was accomplished
+   * @param confidence - Confidence level (0-1)
+   * @param options - Additional optional fields
+   */
+  async done(summary, confidence, options) {
+    return this.complete({
+      summary,
+      confidence,
+      approach: options?.approach ?? "Standard approach",
+      decisions: options?.decisions,
+      challenges: options?.challenges,
+      learnings: options?.learnings,
+      suggestions: options?.suggestions
+    });
+  }
+  /**
+   * Abandon the trajectory
+   * @param reason - Reason for abandonment
+   */
+  async abandon(reason) {
+    this.trajectory = abandonTrajectory(this.trajectory, reason);
+    await this.client.save(this.trajectory);
+    return this.trajectory;
+  }
+  /**
+   * Force save the current state
+   */
+  async save() {
+    await this.client.save(this.trajectory);
+  }
+  /**
+   * Export to markdown
+   */
+  toMarkdown() {
+    return exportToMarkdown(this.trajectory);
+  }
+  /**
+   * Export to JSON
+   */
+  toJSON(compact) {
+    return exportToJSON(this.trajectory, { compact });
+  }
+  /**
+   * Export to timeline format
+   */
+  toTimeline() {
+    return exportToTimeline(this.trajectory);
+  }
+  /**
+   * Export to PR summary format
+   */
+  toPRSummary() {
+    return exportToPRSummary(this.trajectory);
+  }
+};
+var TrajectoryClient = class {
+  storage;
+  initialized = false;
+  defaultAgent;
+  projectId;
+  autoSave;
+  autoCompactCwd;
+  autoCompact;
+  constructor(options = {}) {
+    this.storage = options.storage ?? new FileStorage(options.dataDir);
+    this.defaultAgent = options.defaultAgent ?? process.env.TRAJECTORIES_AGENT;
+    this.projectId = options.projectId ?? process.env.TRAJECTORIES_PROJECT;
+    this.autoSave = options.autoSave ?? true;
+    this.autoCompact = normalizeAutoCompactOptions(options.autoCompact);
+    this.autoCompactCwd = options.storage ? void 0 : options.dataDir;
+  }
+  getAutoCompactOptions() {
+    return this.autoCompact;
+  }
+  getAutoCompactCwd() {
+    return this.autoCompactCwd;
+  }
+  /**
+   * Initialize the client (creates storage directories, etc.)
+   * Must be called before using other methods.
+   */
+  async init() {
+    if (!this.initialized) {
+      await this.storage.initialize();
+      this.initialized = true;
+    }
+  }
+  /**
+   * Ensure the client is initialized
+   */
+  ensureInitialized() {
+    if (!this.initialized) {
+      throw new TrajectoryError(
+        "Client not initialized. Call init() first.",
+        "NOT_INITIALIZED",
+        "Add 'await client.init()' before using the client"
+      );
+    }
+  }
+  /**
+   * Start a new trajectory
+   * @param title - Task title
+   * @param options - Additional creation options
+   * @returns A session for the new trajectory
+   */
+  async start(title, options) {
+    this.ensureInitialized();
+    const active = await this.storage.getActive();
+    if (active) {
+      throw new TrajectoryError(
+        `Active trajectory already exists: ${active.id}`,
+        "ACTIVE_TRAJECTORY_EXISTS",
+        "Complete or abandon the active trajectory first"
+      );
+    }
+    const workflowId = resolveStartWorkflowId(options);
+    const { workflowId: _workflowId, ...createOptions } = options ?? {};
+    const trajectory2 = createTrajectory({
+      title,
+      projectId: this.projectId,
+      ...createOptions
+    });
+    const stampedTrajectory = workflowId ? { ...trajectory2, workflowId } : trajectory2;
+    await this.storage.save(stampedTrajectory);
+    return new TrajectorySession(stampedTrajectory, this, this.autoSave);
+  }
+  /**
+   * Resume the currently active trajectory
+   * @returns Session for active trajectory, or null if none active
+   */
+  async resume() {
+    this.ensureInitialized();
+    const active = await this.storage.getActive();
+    if (!active) {
+      return null;
+    }
+    return new TrajectorySession(active, this, this.autoSave);
+  }
+  /**
+   * Get the active trajectory (without creating a session)
+   */
+  async getActive() {
+    this.ensureInitialized();
+    return this.storage.getActive();
+  }
+  /**
+   * Get a trajectory by ID
+   * @param id - Trajectory ID
+   */
+  async get(id) {
+    this.ensureInitialized();
+    return this.storage.get(id);
+  }
+  /**
+   * Open a trajectory session by ID
+   * @param id - Trajectory ID
+   */
+  async open(id) {
+    this.ensureInitialized();
+    const trajectory2 = await this.storage.get(id);
+    if (!trajectory2) {
+      return null;
+    }
+    return new TrajectorySession(trajectory2, this, this.autoSave);
+  }
+  /**
+   * List trajectories with optional filtering
+   * @param query - Query options
+   */
+  async list(query) {
+    this.ensureInitialized();
+    return this.storage.list(query ?? {});
+  }
+  /**
+   * Search trajectories by text
+   * @param text - Search text
+   * @param limit - Maximum results
+   */
+  async search(text, limit) {
+    this.ensureInitialized();
+    return this.storage.search(
+      text,
+      limit !== void 0 ? { limit } : void 0
+    );
+  }
+  /**
+   * Delete a trajectory
+   * @param id - Trajectory ID
+   */
+  async delete(id) {
+    this.ensureInitialized();
+    await this.storage.delete(id);
+  }
+  /**
+   * Save a trajectory to storage
+   * @param trajectory - Trajectory to save
+   */
+  async save(trajectory2) {
+    this.ensureInitialized();
+    await this.storage.save(trajectory2);
+  }
+  /**
+   * Close the client and release resources
+   */
+  async close() {
+    if (this.initialized) {
+      await this.storage.close();
+      this.initialized = false;
+    }
+  }
+  /**
+   * Export a trajectory to markdown
+   * @param id - Trajectory ID
+   */
+  async exportMarkdown(id) {
+    const trajectory2 = await this.get(id);
+    if (!trajectory2) return null;
+    return exportToMarkdown(trajectory2);
+  }
+  /**
+   * Export a trajectory to JSON
+   * @param id - Trajectory ID
+   * @param compact - Whether to use compact format
+   */
+  async exportJSON(id, compact) {
+    const trajectory2 = await this.get(id);
+    if (!trajectory2) return null;
+    return exportToJSON(trajectory2, { compact });
+  }
+  /**
+   * Export a trajectory to timeline format
+   * @param id - Trajectory ID
+   */
+  async exportTimeline(id) {
+    const trajectory2 = await this.get(id);
+    if (!trajectory2) return null;
+    return exportToTimeline(trajectory2);
+  }
+  /**
+   * Export a trajectory to PR summary format
+   * @param id - Trajectory ID
+   */
+  async exportPRSummary(id) {
+    const trajectory2 = await this.get(id);
+    if (!trajectory2) return null;
+    return exportToPRSummary(trajectory2);
+  }
+};
+
+// src/sdk/builder.ts
+var TrajectoryBuilder = class _TrajectoryBuilder {
+  trajectory;
+  constructor(input) {
+    this.trajectory = createTrajectory(input);
+  }
+  /**
+   * Create a new trajectory builder
+   * @param title - Task title
+   */
+  static create(title) {
+    return new _TrajectoryBuilder({ title });
+  }
+  /**
+   * Set the task description
+   */
+  withDescription(description) {
+    this.trajectory = {
+      ...this.trajectory,
+      task: {
+        ...this.trajectory.task,
+        description
+      }
+    };
+    return this;
+  }
+  /**
+   * Set the external task source
+   */
+  withSource(source) {
+    this.trajectory = {
+      ...this.trajectory,
+      task: {
+        ...this.trajectory.task,
+        source
+      }
+    };
+    return this;
+  }
+  /**
+   * Set the project ID
+   */
+  withProject(projectId) {
+    this.trajectory = {
+      ...this.trajectory,
+      projectId
+    };
+    return this;
+  }
+  /**
+   * Add tags
+   */
+  withTags(...tags) {
+    this.trajectory = {
+      ...this.trajectory,
+      tags: [...this.trajectory.tags, ...tags]
+    };
+    return this;
+  }
+  /**
+   * Add a single tag
+   */
+  tag(tag) {
+    if (!this.trajectory.tags.includes(tag)) {
+      this.trajectory = {
+        ...this.trajectory,
+        tags: [...this.trajectory.tags, tag]
+      };
+    }
+    return this;
+  }
+  /**
+   * Start a new chapter
+   * @param title - Chapter title
+   * @param agentName - Agent name
+   */
+  chapter(title, agentName) {
+    this.trajectory = addChapter(this.trajectory, { title, agentName });
+    return this;
+  }
+  /**
+   * Add a generic event
+   */
+  event(type, content, options) {
+    this.trajectory = addEvent(this.trajectory, {
+      type,
+      content,
+      ...options
+    });
+    return this;
+  }
+  /**
+   * Add a note event
+   */
+  note(content, significance) {
+    return this.event("note", content, { significance });
+  }
+  /**
+   * Add a finding event
+   */
+  finding(content, significance) {
+    return this.event("finding", content, {
+      significance: significance ?? "medium"
+    });
+  }
+  /**
+   * Add a reflection event — a higher-level synthesis of recent observations.
+   * Reflections are always high significance since they represent
+   * periodic course-correction insights.
+   */
+  reflect(content, confidence) {
+    return this.event("reflection", content, {
+      significance: "high",
+      ...confidence !== void 0 ? { tags: [`confidence:${confidence}`] } : {}
+    });
+  }
+  /**
+   * Add an error event
+   */
+  error(content) {
+    return this.event("error", content, { significance: "high" });
+  }
+  /**
+   * Add a thinking event
+   */
+  thinking(content) {
+    return this.event("thinking", content, { significance: "low" });
+  }
+  /**
+   * Add a tool call event
+   */
+  toolCall(content, raw) {
+    return this.event("tool_call", content, { raw });
+  }
+  /**
+   * Add a tool result event
+   */
+  toolResult(content, raw) {
+    return this.event("tool_result", content, { raw });
+  }
+  /**
+   * Add a prompt event
+   */
+  prompt(content) {
+    return this.event("prompt", content, { significance: "medium" });
+  }
+  /**
+   * Add a message sent event
+   */
+  messageSent(content) {
+    return this.event("message_sent", content);
+  }
+  /**
+   * Add a message received event
+   */
+  messageReceived(content) {
+    return this.event("message_received", content);
+  }
+  /**
+   * Add a structured decision
+   */
+  decision(decision) {
+    this.trajectory = addDecision(this.trajectory, decision);
+    return this;
+  }
+  /**
+   * Quick decision helper
+   */
+  decide(question, chosen, reasoning, alternatives) {
+    return this.decision({
+      question,
+      chosen,
+      reasoning,
+      alternatives: alternatives ?? []
+    });
+  }
+  /**
+   * Record git commits
+   */
+  commits(...hashes) {
+    this.trajectory = {
+      ...this.trajectory,
+      commits: [...this.trajectory.commits, ...hashes]
+    };
+    return this;
+  }
+  /**
+   * Record files changed
+   */
+  filesChanged(...paths) {
+    this.trajectory = {
+      ...this.trajectory,
+      filesChanged: [...this.trajectory.filesChanged, ...paths]
+    };
+    return this;
+  }
+  /**
+   * Complete the trajectory with a retrospective
+   * @param input - Retrospective details
+   * @returns The completed trajectory
+   */
+  complete(input) {
+    this.trajectory = completeTrajectory(this.trajectory, input);
+    return this.trajectory;
+  }
+  /**
+   * Quick complete with minimal fields
+   */
+  done(summary, confidence, approach) {
+    return this.complete({
+      summary,
+      confidence,
+      approach: approach ?? "Standard approach"
+    });
+  }
+  /**
+   * Abandon the trajectory
+   */
+  abandon(reason) {
+    this.trajectory = abandonTrajectory(this.trajectory, reason);
+    return this.trajectory;
+  }
+  /**
+   * Get the current trajectory (without completing)
+   */
+  build() {
+    return this.trajectory;
+  }
+  /**
+   * Export to markdown
+   */
+  toMarkdown() {
+    return exportToMarkdown(this.trajectory);
+  }
+  /**
+   * Export to JSON
+   */
+  toJSON(compact) {
+    return exportToJSON(this.trajectory, { compact });
+  }
+  /**
+   * Export to timeline format
+   */
+  toTimeline() {
+    return exportToTimeline(this.trajectory);
+  }
+  /**
+   * Export to PR summary format
+   */
+  toPRSummary() {
+    return exportToPRSummary(this.trajectory);
+  }
+};
+function trajectory(title) {
+  return TrajectoryBuilder.create(title);
+}
+
+// src/core/trailers.ts
+import { execSync as execSync2 } from "child_process";
+import { readFileSync as readFileSync2 } from "fs";
+
+// 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;
+  }
+}
+
+// src/core/trailers.ts
+var TRAJECTORY_TRAILER_KEY = "Trajectory";
+function formatTrailer(trajectoryId) {
+  return `${TRAJECTORY_TRAILER_KEY}: ${trajectoryId}`;
+}
+function parseTrajectoryFromMessage(commitMessage) {
+  const lines = commitMessage.split("\n");
+  for (const line of lines) {
+    const match = line.match(
+      new RegExp(`^${TRAJECTORY_TRAILER_KEY}:\\s*(traj_[a-z0-9_]+)$`)
+    );
+    if (match) {
+      return match[1];
+    }
+  }
+  return null;
+}
+function getTrajectoryFromCommit(commitHash) {
+  if (!isGitRepo() || !isValidGitRef(commitHash)) {
+    return null;
+  }
+  try {
+    const message = execSync2(`git log -1 --format=%B ${commitHash}`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return parseTrajectoryFromMessage(message);
+  } catch {
+    return null;
+  }
+}
+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 [];
+  }
+}
+
+export {
+  generateTrajectoryId,
+  generateChapterId,
+  isValidTrajectoryId,
+  isValidChapterId,
+  TrajectoryEventSchema,
+  DecisionSchema,
+  ChapterSchema,
+  RetrospectiveSchema,
+  TrajectorySchema,
+  validateTrajectory,
+  validateCreateInput,
+  validateCompleteInput,
+  TrajectoryError,
+  createTrajectory,
+  addChapter,
+  addEvent,
+  addDecision,
+  completeTrajectory,
+  abandonTrajectory,
+  exportToJSON,
+  exportToMarkdown,
+  exportToPRSummary,
+  exportToTimeline,
+  FileStorage,
+  compactWorkflow,
+  TrajectorySession,
+  TrajectoryClient,
+  TrajectoryBuilder,
+  trajectory,
+  TRAJECTORY_TRAILER_KEY,
+  formatTrailer,
+  parseTrajectoryFromMessage,
+  getTrajectoryFromCommit,
+  getCommitsBetween,
+  getFilesChangedBetween
+};
+//# sourceMappingURL=chunk-W222QB6V.js.map