p-dev-harness 0.3.0 → 0.3.1

package/workspace-snapshot/files/src/agents/cursor-provider.ts

@@ -0,0 +1,109 @@
+import {
+  createImplementationCloudAgent,
+  createIntegrationRepairCloudAgent,
+  createPlanningCloudAgent,
+  createRevisionCloudAgent,
+  disposeCloudAgent,
+} from "../cursor/agent-factory.js";
+import { resolveModelId as cursorResolveModelId } from "../cursor/model.js";
+import { sendAndObserve as cursorSendAndObserve } from "../cursor/run-observer.js";
+import type {
+  AgentHandle,
+  AgentProvider,
+  ImplementationAgentParams,
+  IntegrationRepairAgentParams,
+  ObservedAgentRun,
+  PlanningAgentParams,
+  RevisionAgentParams,
+  SendAndObserveOptions,
+} from "./types.js";
+import type { HarnessConfig } from "../config/types.js";
+import type { EventLogger } from "../artifacts/events.js";
+
+type CursorCloudAgent = Awaited<ReturnType<typeof createPlanningCloudAgent>>;
+
+const cursorAgents = new WeakMap<AgentHandle, CursorCloudAgent>();
+
+function wrapCursorAgent(agent: CursorCloudAgent): AgentHandle {
+  const handle = { __brand: Symbol("AgentHandle") } as AgentHandle;
+  cursorAgents.set(handle, agent);
+  return handle;
+}
+
+function unwrapCursorAgent(handle: AgentHandle): CursorCloudAgent {
+  const agent = cursorAgents.get(handle);
+  if (!agent) {
+    throw new Error("Invalid or disposed agent handle");
+  }
+  return agent;
+}
+
+function mapObservedRun(
+  observed: Awaited<ReturnType<typeof cursorSendAndObserve>>,
+): ObservedAgentRun {
+  return {
+    agentId: observed.agentId,
+    runId: observed.runId,
+    assistantText: observed.assistantText,
+    gitResult: observed.gitResult,
+    cancelOutcome: observed.cancelOutcome,
+  };
+}
+
+export const cursorAgentProvider: AgentProvider = {
+  id: "cursor",
+
+  resolveModelId(config: HarnessConfig): string {
+    return cursorResolveModelId(config);
+  },
+
+  async createPlanningAgent(params: PlanningAgentParams): Promise<AgentHandle> {
+    const agent = await createPlanningCloudAgent(params);
+    return wrapCursorAgent(agent);
+  },
+
+  async createImplementationAgent(
+    params: ImplementationAgentParams,
+  ): Promise<AgentHandle> {
+    const agent = await createImplementationCloudAgent(params);
+    return wrapCursorAgent(agent);
+  },
+
+  async createRevisionAgent(params: RevisionAgentParams): Promise<AgentHandle> {
+    const agent = await createRevisionCloudAgent(params);
+    return wrapCursorAgent(agent);
+  },
+
+  async createIntegrationRepairAgent(
+    params: IntegrationRepairAgentParams,
+  ): Promise<AgentHandle> {
+    const agent = await createIntegrationRepairCloudAgent(params);
+    return wrapCursorAgent(agent);
+  },
+
+  async sendAndObserve(
+    agent: AgentHandle,
+    prompt: string,
+    runDirectory: string,
+    events: EventLogger,
+    options: SendAndObserveOptions = {},
+  ): Promise<ObservedAgentRun> {
+    const observed = await cursorSendAndObserve(
+      unwrapCursorAgent(agent),
+      prompt,
+      runDirectory,
+      events,
+      options,
+    );
+    return mapObservedRun(observed);
+  },
+
+  async disposeAgent(agent: AgentHandle): Promise<void> {
+    const cursorAgent = cursorAgents.get(agent);
+    if (!cursorAgent) {
+      return;
+    }
+    cursorAgents.delete(agent);
+    await disposeCloudAgent(cursorAgent);
+  },
+};

package/workspace-snapshot/files/src/agents/index.ts

@@ -0,0 +1,68 @@
+import { cursorAgentProvider } from "./cursor-provider.js";
+import { getAgentProvider } from "./provider.js";
+import type {
+  AgentHandle,
+  ImplementationAgentParams,
+  IntegrationRepairAgentParams,
+  PlanningAgentParams,
+  RevisionAgentParams,
+  SendAndObserveOptions,
+} from "./types.js";
+import type { HarnessConfig } from "../config/types.js";
+import type { EventLogger } from "../artifacts/events.js";
+
+export function resolveModelId(config: HarnessConfig): string {
+  return getAgentProvider(config).resolveModelId(config);
+}
+
+export function createPlanningAgent(
+  params: PlanningAgentParams,
+): Promise<AgentHandle> {
+  return getAgentProvider(params.config).createPlanningAgent(params);
+}
+
+export function createImplementationAgent(
+  params: ImplementationAgentParams,
+): Promise<AgentHandle> {
+  return getAgentProvider(params.config).createImplementationAgent(params);
+}
+
+export function createRevisionAgent(
+  params: RevisionAgentParams,
+): Promise<AgentHandle> {
+  return getAgentProvider(params.config).createRevisionAgent(params);
+}
+
+export function createIntegrationRepairAgent(
+  params: IntegrationRepairAgentParams,
+): Promise<AgentHandle> {
+  return getAgentProvider(params.config).createIntegrationRepairAgent(params);
+}
+
+export function sendAndObserve(
+  agent: AgentHandle,
+  prompt: string,
+  runDirectory: string,
+  events: EventLogger,
+  options?: SendAndObserveOptions,
+): Promise<import("./types.js").ObservedAgentRun> {
+  return cursorAgentProvider.sendAndObserve(
+    agent,
+    prompt,
+    runDirectory,
+    events,
+    options,
+  );
+}
+
+export function disposeAgent(agent: AgentHandle): Promise<void> {
+  return cursorAgentProvider.disposeAgent(agent);
+}
+
+export type {
+  AgentHandle,
+  CapturedGitResult,
+  CursorCancelOutcome,
+  ObservedAgentRun,
+  SendAndObserveOptions,
+} from "./types.js";

package/workspace-snapshot/files/src/agents/provider.ts

@@ -0,0 +1,7 @@
+import { cursorAgentProvider } from "./cursor-provider.js";
+import type { AgentProvider } from "./types.js";
+import type { HarnessConfig } from "../config/types.js";
+
+export function getAgentProvider(_config: HarnessConfig): AgentProvider {
+  return cursorAgentProvider;
+}

package/workspace-snapshot/files/src/agents/types.ts

@@ -0,0 +1,85 @@
+import type { HarnessConfig } from "../config/types.js";
+import type { EventLogger } from "../artifacts/events.js";
+
+export type AgentObservePhase =
+  | "planning"
+  | "implementation"
+  | "revision"
+  | "integration_repair";
+
+export type CursorCancelOutcome =
+  | "cancelled"
+  | "cancel_unavailable"
+  | "cancel_failed";
+
+export interface CapturedGitResult {
+  repoUrl: string;
+  branch: string;
+  prUrl: string;
+}
+
+export interface ObservedAgentRun {
+  agentId: string;
+  runId: string;
+  assistantText: string;
+  gitResult: CapturedGitResult | null;
+  cancelOutcome: CursorCancelOutcome | null;
+}
+
+export interface AgentHandle {
+  readonly __brand: unique symbol;
+}
+
+export interface PlanningAgentParams {
+  apiKey: string;
+  config: HarnessConfig;
+  targetRepo: string;
+  baseBranch: string;
+}
+
+export type ImplementationAgentParams = PlanningAgentParams;
+
+export interface BranchAgentParams {
+  apiKey: string;
+  config: HarnessConfig;
+  targetRepo: string;
+  branch: string;
+  prUrl: string;
+}
+
+export type RevisionAgentParams = BranchAgentParams;
+export type IntegrationRepairAgentParams = BranchAgentParams;
+
+export interface SendAndObserveOptions {
+  phase?: AgentObservePhase;
+  targetRepo?: string;
+  expectedBranch?: string;
+  expectedPrUrl?: string;
+  abortSignal?: AbortSignal;
+  apiKey?: string;
+  pollIntervalMs?: number;
+  onAgentCreated?: (details: { agentId: string; runId: string }) => Promise<void>;
+}
+
+export interface AgentProvider {
+  readonly id: "cursor";
+
+  resolveModelId(config: HarnessConfig): string;
+
+  createPlanningAgent(params: PlanningAgentParams): Promise<AgentHandle>;
+  createImplementationAgent(params: ImplementationAgentParams): Promise<AgentHandle>;
+  createRevisionAgent(params: RevisionAgentParams): Promise<AgentHandle>;
+  createIntegrationRepairAgent(
+    params: IntegrationRepairAgentParams,
+  ): Promise<AgentHandle>;
+
+  sendAndObserve(
+    agent: AgentHandle,
+    prompt: string,
+    runDirectory: string,
+    events: EventLogger,
+    options?: SendAndObserveOptions,
+  ): Promise<ObservedAgentRun>;
+
+  disposeAgent(agent: AgentHandle): Promise<void>;
+}

package/workspace-snapshot/files/src/artifacts/events.ts

@@ -0,0 +1,31 @@
+import { appendFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import type { RunEvent } from "../types/run.js";
+import { getEventsPath } from "./paths.js";
+import { redactSecrets } from "./redact.js";
+
+export class EventLogger {
+  private readonly eventsPath: string;
+
+  constructor(runDirectory: string) {
+    this.eventsPath = getEventsPath(runDirectory);
+  }
+
+  async init(): Promise<void> {
+    await mkdir(path.dirname(this.eventsPath), { recursive: true });
+  }
+
+  async log(
+    event: RunEvent["event"],
+    level: RunEvent["level"] = "info",
+    data?: Record<string, unknown>,
+  ): Promise<void> {
+    const entry: RunEvent = {
+      ts: new Date().toISOString(),
+      level,
+      event,
+      data: data ? (redactSecrets(data) as Record<string, unknown>) : undefined,
+    };
+    await appendFile(this.eventsPath, `${JSON.stringify(entry)}\n`, "utf8");
+  }
+}

package/workspace-snapshot/files/src/artifacts/manifest-fields.ts

@@ -0,0 +1,9 @@
+export function emptyMergeManifestFields() {
+  return {
+    previousRevisionRunId: null as string | null,
+    mergeCommitSha: null as string | null,
+    mergeMethod: null as string | null,
+    mergedAt: null as string | null,
+    deploymentUrl: null as string | null,
+  };
+}

package/workspace-snapshot/files/src/artifacts/manifest.ts

@@ -0,0 +1,20 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import type { RunManifest } from "../types/run.js";
+import { getManifestPath } from "./paths.js";
+
+export async function writeManifest(
+  runDirectory: string,
+  manifest: RunManifest,
+): Promise<void> {
+  await mkdir(runDirectory, { recursive: true });
+  await writeFile(
+    getManifestPath(runDirectory),
+    `${JSON.stringify(manifest, null, 2)}\n`,
+    "utf8",
+  );
+}
+
+export async function readManifest(runDirectory: string): Promise<RunManifest> {
+  const raw = await readFile(getManifestPath(runDirectory), "utf8");
+  return JSON.parse(raw) as RunManifest;
+}

package/workspace-snapshot/files/src/artifacts/paths.ts

@@ -0,0 +1,145 @@
+import path from "node:path";
+
+export function getRunDirectory(
+  logDirectory: string,
+  issueKey: string,
+  runId: string,
+): string {
+  return path.join(logDirectory, issueKey, runId);
+}
+
+export function getManifestPath(runDirectory: string): string {
+  return path.join(runDirectory, "manifest.json");
+}
+
+export function getEventsPath(runDirectory: string): string {
+  return path.join(runDirectory, "events.jsonl");
+}
+
+export function getSummaryPath(runDirectory: string): string {
+  return path.join(runDirectory, "run-summary.md");
+}
+
+export function getIssueSnapshotPath(runDirectory: string): string {
+  return path.join(runDirectory, "linear", "issue-snapshot-before.json");
+}
+
+export function getIssueSnapshotAfterPath(runDirectory: string): string {
+  return path.join(runDirectory, "linear", "issue-snapshot-after.json");
+}
+
+export function getPlanningPromptPath(runDirectory: string): string {
+  return path.join(runDirectory, "prompts", "planning-agent.md");
+}
+
+export function getPlanningResultPath(runDirectory: string): string {
+  return path.join(runDirectory, "outputs", "planning-result.md");
+}
+
+export function getImplementationPromptPath(runDirectory: string): string {
+  return path.join(runDirectory, "prompts", "implementation-agent.md");
+}
+
+export function getImplementationResultPath(runDirectory: string): string {
+  return path.join(runDirectory, "outputs", "implementation-result.md");
+}
+
+export function getCursorRunResultPath(runDirectory: string): string {
+  return path.join(runDirectory, "cursor", "run-result.json");
+}
+
+export function getPrMetadataPath(runDirectory: string): string {
+  return path.join(runDirectory, "github", "pr-metadata.json");
+}
+
+export function getPlanningCommentLoadedPath(runDirectory: string): string {
+  return path.join(runDirectory, "linear", "planning-comment-loaded.md");
+}
+
+export function getImplementationCommentLoadedPath(runDirectory: string): string {
+  return path.join(runDirectory, "linear", "implementation-comment-loaded.md");
+}
+
+export function getHandoffCommentPath(runDirectory: string): string {
+  return path.join(runDirectory, "linear", "handoff-comment.md");
+}
+
+export function getGithubPrPath(runDirectory: string): string {
+  return path.join(runDirectory, "github", "pr.json");
+}
+
+export function getGithubChecksPath(runDirectory: string): string {
+  return path.join(runDirectory, "github", "checks.json");
+}
+
+export function getVercelDeploymentPath(runDirectory: string): string {
+  return path.join(runDirectory, "vercel", "deployment.json");
+}
+
+export function getCommentsWrittenPath(runDirectory: string): string {
+  return path.join(runDirectory, "linear", "comments-written.md");
+}
+
+export function getHandoffCommentLoadedPath(runDirectory: string): string {
+  return path.join(runDirectory, "linear", "handoff-comment-loaded.md");
+}
+
+export function getPmFeedbackCommentLoadedPath(runDirectory: string): string {
+  return path.join(runDirectory, "linear", "pm-feedback-comment-loaded.md");
+}
+
+export function getRevisionPromptPath(runDirectory: string): string {
+  return path.join(runDirectory, "prompts", "revision-agent.md");
+}
+
+export function getRevisionResultPath(runDirectory: string): string {
+  return path.join(runDirectory, "outputs", "revision-result.md");
+}
+
+export function getRevisionCommentPath(runDirectory: string): string {
+  return path.join(runDirectory, "linear", "revision-comment.md");
+}
+
+export function getGithubPrBeforePath(runDirectory: string): string {
+  return path.join(runDirectory, "github", "pr-before.json");
+}
+
+export function getGithubPrAfterPath(runDirectory: string): string {
+  return path.join(runDirectory, "github", "pr-after.json");
+}
+
+export function getGithubPrBeforeMergePath(runDirectory: string): string {
+  return path.join(runDirectory, "github", "pr-before-merge.json");
+}
+
+export function getGithubPrAfterMergePath(runDirectory: string): string {
+  return path.join(runDirectory, "github", "pr-after-merge.json");
+}
+
+export function getGithubChecksBeforeMergePath(runDirectory: string): string {
+  return path.join(runDirectory, "github", "checks-before-merge.json");
+}
+
+export function getGithubMergeResultPath(runDirectory: string): string {
+  return path.join(runDirectory, "github", "merge-result.json");
+}
+
+export function getMergeSourceCommentLoadedPath(runDirectory: string): string {
+  return path.join(runDirectory, "linear", "merge-source-comment-loaded.md");
+}
+
+export function getMergeCompletionCommentPath(runDirectory: string): string {
+  return path.join(runDirectory, "linear", "merge-completion-comment.md");
+}
+
+export function getProductionDeploymentPath(runDirectory: string): string {
+  return path.join(runDirectory, "vercel", "production-deployment.json");
+}
+
+export function getMergeRecoveryPath(runDirectory: string): string {
+  return path.join(runDirectory, "outputs", "merge-recovery.json");
+}
+
+export function getErrorPath(runDirectory: string): string {
+  return path.join(runDirectory, "errors", "error.json");
+}

package/workspace-snapshot/files/src/artifacts/redact.ts

@@ -0,0 +1,50 @@
+const SECRET_PATTERNS = [
+  /lin_api_[A-Za-z0-9_]+/gi,
+  /ghp_[A-Za-z0-9]+/gi,
+  /github_pat_[A-Za-z0-9_]+/gi,
+  /cursor_[A-Za-z0-9_]+/gi,
+  /sk-[A-Za-z0-9_-]+/gi,
+  /xox[baprs]-[A-Za-z0-9-]+/gi,
+  /Bearer\s+[A-Za-z0-9._-]+/gi,
+];
+
+const MAX_REDACTED_ERROR_LENGTH = 200;
+
+export function redactSecrets<T>(value: T): T {
+  return redactValue(value) as T;
+}
+
+export function redactSecretsString(value: string): string {
+  let redacted = value;
+  for (const pattern of SECRET_PATTERNS) {
+    redacted = redacted.replace(pattern, "[REDACTED]");
+  }
+  if (redacted.length > MAX_REDACTED_ERROR_LENGTH) {
+    return `${redacted.slice(0, MAX_REDACTED_ERROR_LENGTH)}…`;
+  }
+  return redacted;
+}
+
+function redactValue(value: unknown): unknown {
+  if (typeof value === "string") {
+    return redactSecretsString(value);
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((item) => redactValue(item));
+  }
+
+  if (value && typeof value === "object") {
+    const result: Record<string, unknown> = {};
+    for (const [key, nested] of Object.entries(value)) {
+      if (/api[_-]?key|token|secret|authorization/i.test(key)) {
+        result[key] = "[REDACTED]";
+      } else {
+        result[key] = redactValue(nested);
+      }
+    }
+    return result;
+  }
+
+  return value;
+}

package/workspace-snapshot/files/src/artifacts/run-id.ts

@@ -0,0 +1,4 @@
+export function createRunId(issueKey: string, date = new Date()): string {
+  const iso = date.toISOString().replace(/[:.]/g, "-");
+  return `${iso}-${issueKey}`;
+}

package/workspace-snapshot/files/src/artifacts/snapshot.ts

@@ -0,0 +1,13 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import type { LinearIssueSnapshot } from "../linear/client.js";
+import { getIssueSnapshotPath } from "./paths.js";
+
+export async function writeIssueSnapshot(
+  runDirectory: string,
+  snapshot: LinearIssueSnapshot,
+): Promise<void> {
+  const snapshotPath = getIssueSnapshotPath(runDirectory);
+  await mkdir(path.dirname(snapshotPath), { recursive: true });
+  await writeFile(snapshotPath, `${JSON.stringify(snapshot, null, 2)}\n`, "utf8");
+}

package/workspace-snapshot/files/src/artifacts/summary.ts

@@ -0,0 +1,116 @@
+import { writeFile } from "node:fs/promises";
+import type { RunManifest } from "../types/run.js";
+import type { ParsedIssue } from "../types/parsed-issue.js";
+import type { ResolvedTarget } from "../resolver/target-repo.js";
+import type { CursorCancelOutcome } from "../agents/types.js";
+import { getSummaryPath } from "./paths.js";
+import { detectExecutionEnvironment } from "../runner/execution-environment.js";
+
+export interface RunSummaryExtras {
+  cursorCleanup?: CursorCancelOutcome | null;
+}
+
+function formatCursorCleanup(status: CursorCancelOutcome | null | undefined): string {
+  switch (status) {
+    case "cancelled":
+      return "Cursor run cancel requested and completed";
+    case "cancel_unavailable":
+      return "Cursor run cancel unavailable (SDK does not support cancel for this run)";
+    case "cancel_failed":
+      return "Cursor run cancel requested but failed";
+    default:
+      return "n/a";
+  }
+}
+
+export async function writeRunSummary(
+  runDirectory: string,
+  manifest: RunManifest,
+  parsed: ParsedIssue,
+  resolved: ResolvedTarget | null,
+  extras: RunSummaryExtras = {},
+): Promise<void> {
+  const executionEnvironment = detectExecutionEnvironment();
+  const lines = [
+    "# Harness run summary",
+    "",
+    `- **Execution environment:** ${executionEnvironment.marker}`,
+    `- **Run ID:** ${manifest.runId}`,
+    `- **Issue:** ${manifest.issueKey}`,
+    `- **Milestone:** ${manifest.milestone}`,
+    `- **Dry run:** ${manifest.dryRun}`,
+    `- **Outcome:** ${manifest.finalOutcome}`,
+    `- **Error classification:** ${manifest.errorClassification ?? "none"}`,
+    `- **Phase (inferred):** ${manifest.phase}`,
+    `- **Status:** ${manifest.phaseInferredFromStatus ?? "unknown"}`,
+    `- **Linear status before:** ${manifest.linearStatusBefore ?? "unknown"}`,
+    `- **Linear status after:** ${manifest.linearStatusAfter ?? "unknown"}`,
+    `- **Model:** ${manifest.model ?? "n/a"}`,
+    `- **Prompt version:** ${manifest.promptVersion ?? "n/a"}`,
+    `- **Cursor agent ID:** ${manifest.cursorAgentId ?? "n/a"}`,
+    `- **Cursor run ID:** ${manifest.cursorRunId ?? "n/a"}`,
+    `- **Branch:** ${manifest.branch ?? "n/a"}`,
+    `- **PR URL:** ${manifest.prUrl ?? "n/a"}`,
+    `- **Preview URL:** ${manifest.previewUrl ?? "n/a"}`,
+    `- **Changed files:** ${manifest.changedFiles?.length ?? 0}`,
+    `- **Check summary:** ${manifest.checkSummary ?? "n/a"}`,
+    `- **Previous implementation run ID:** ${manifest.previousImplementationRunId ?? "n/a"}`,
+    `- **Previous handoff run ID:** ${manifest.previousHandoffRunId ?? "n/a"}`,
+    `- **PM feedback comment ID:** ${manifest.pmFeedbackCommentId ?? "n/a"}`,
+    `- **Previous revision run ID:** ${manifest.previousRevisionRunId ?? "n/a"}`,
+    `- **Merge commit SHA:** ${manifest.mergeCommitSha ?? "n/a"}`,
+    `- **Merge method:** ${manifest.mergeMethod ?? "n/a"}`,
+    `- **Merged at:** ${manifest.mergedAt ?? "n/a"}`,
+    `- **Deployment URL:** ${manifest.deploymentUrl ?? "n/a"}`,
+    `- **Validation summary:** ${manifest.validationSummary ?? "n/a"}`,
+    `- **Cursor cleanup:** ${formatCursorCleanup(extras.cursorCleanup)}`,
+    "",
+    "## Task",
+    parsed.task || "_not parsed_",
+    "",
+  ];
+
+  if (resolved) {
+    lines.push(
+      "## Target repo resolution",
+      `- **Repo:** ${resolved.targetRepo}`,
+      `- **Base branch:** ${resolved.baseBranch}`,
+      `- **Config ID:** ${resolved.repoConfigId}`,
+      `- **Source:** ${resolved.resolutionSource}`,
+      `- **Preview provider:** ${resolved.previewProvider}`,
+      "",
+    );
+  } else {
+    lines.push("## Target repo resolution", "_not resolved_", "");
+  }
+
+  if (parsed.parseErrors.length > 0) {
+    lines.push("## Parse errors", ...parsed.parseErrors.map((e) => `- ${e}`), "");
+  }
+
+  lines.push(
+    "## Artifacts",
+    `- Manifest: \`${runDirectory}/manifest.json\``,
+    `- Events: \`${runDirectory}/events.jsonl\``,
+    `- Issue snapshot (before): \`${runDirectory}/linear/issue-snapshot-before.json\``,
+    `- Issue snapshot (after): \`${runDirectory}/linear/issue-snapshot-after.json\``,
+    `- Planning prompt: \`${runDirectory}/prompts/planning-agent.md\``,
+    `- Planning result: \`${runDirectory}/outputs/planning-result.md\``,
+    `- Planning comment loaded: \`${runDirectory}/linear/planning-comment-loaded.md\``,
+    `- Implementation prompt: \`${runDirectory}/prompts/implementation-agent.md\``,
+    `- Implementation result: \`${runDirectory}/outputs/implementation-result.md\``,
+    `- Cursor run result: \`${runDirectory}/cursor/run-result.json\``,
+    `- PR metadata: \`${runDirectory}/github/pr-metadata.json\``,
+    `- GitHub PR inspect: \`${runDirectory}/github/pr.json\``,
+    `- GitHub checks: \`${runDirectory}/github/checks.json\``,
+    `- Vercel deployment: \`${runDirectory}/vercel/deployment.json\``,
+    `- Implementation comment loaded: \`${runDirectory}/linear/implementation-comment-loaded.md\``,
+    `- Handoff comment: \`${runDirectory}/linear/handoff-comment.md\``,
+    `- Merge source comment loaded: \`${runDirectory}/linear/merge-source-comment-loaded.md\``,
+    `- Merge completion comment: \`${runDirectory}/linear/merge-completion-comment.md\``,
+    `- Comments written: \`${runDirectory}/linear/comments-written.md\``,
+    "",
+  );
+
+  await writeFile(getSummaryPath(runDirectory), `${lines.join("\n")}\n`, "utf8");
+}