fifony 0.1.47 → 0.1.48

package/dist/chunk-APJOZXRP.js

@@ -0,0 +1,737 @@
+import {
+  init_helpers,
+  now
+} from "./chunk-DLSPRIQL.js";
+import {
+  STATE_ROOT,
+  init_constants
+} from "./chunk-X37RNTWU.js";
+import {
+  logger
+} from "./chunk-PXTIWKLQ.js";
+import {
+  __require
+} from "./chunk-Z6ZWNWWR.js";
+
+// src/domains/trace-bundle.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync, writeFileSync } from "fs";
+import { dirname, join as join2, relative } from "path";
+init_helpers();
+
+// src/agents/transcript.ts
+init_constants();
+import { mkdirSync, appendFileSync, readFileSync, existsSync } from "fs";
+import { join } from "path";
+var TRANSCRIPTS_ROOT = join(STATE_ROOT, "transcripts");
+function transcriptDir(issueId) {
+  return join(TRANSCRIPTS_ROOT, issueId);
+}
+function transcriptFile(issueId, planVersion, attempt) {
+  return join(transcriptDir(issueId), `v${planVersion}a${attempt}.jsonl`);
+}
+function recordTranscriptTurn(issue, turn, provider) {
+  try {
+    const dir = transcriptDir(issue.id);
+    mkdirSync(dir, { recursive: true });
+    const pv = issue.planVersion ?? 1;
+    const ea = issue.executeAttempt ?? 1;
+    const filePath = transcriptFile(issue.id, pv, ea);
+    const outputPreview = turn.output.length > 500 ? turn.output.slice(-500) : turn.output;
+    const entry = {
+      ts: turn.completedAt || turn.startedAt,
+      turn: turn.turn,
+      role: turn.role || "unknown",
+      model: turn.model,
+      provider,
+      directiveStatus: turn.directiveStatus,
+      directiveSummary: turn.directiveSummary,
+      exitCode: turn.code,
+      success: turn.success,
+      tokens: turn.tokenUsage ? {
+        input: turn.tokenUsage.inputTokens,
+        output: turn.tokenUsage.outputTokens,
+        total: turn.tokenUsage.totalTokens
+      } : void 0,
+      toolsUsed: turn.toolsUsed,
+      skillsUsed: turn.skillsUsed,
+      agentsUsed: turn.agentsUsed,
+      commandsRun: turn.commandsRun,
+      outputPreview
+    };
+    appendFileSync(filePath, JSON.stringify(entry) + "\n", "utf8");
+  } catch (err) {
+    logger.warn({ err: String(err), issueId: issue.id }, "[Transcript] Failed to record turn");
+  }
+}
+function readTranscript(issueId, planVersion, attempt) {
+  const filePath = transcriptFile(issueId, planVersion, attempt);
+  if (!existsSync(filePath)) return [];
+  try {
+    const lines = readFileSync(filePath, "utf8").trim().split("\n").filter(Boolean);
+    return lines.map((line) => JSON.parse(line));
+  } catch (err) {
+    logger.warn({ err: String(err), issueId }, "[Transcript] Failed to read transcript");
+    return [];
+  }
+}
+function readAllTranscripts(issueId) {
+  const dir = transcriptDir(issueId);
+  if (!existsSync(dir)) return {};
+  try {
+    const { readdirSync: readdirSync2 } = __require("fs");
+    const files = readdirSync2(dir).filter((f) => f.endsWith(".jsonl"));
+    const result = {};
+    for (const file of files) {
+      const key = file.replace(".jsonl", "");
+      const lines = readFileSync(join(dir, file), "utf8").trim().split("\n").filter(Boolean);
+      result[key] = lines.map((line) => JSON.parse(line));
+    }
+    return result;
+  } catch (err) {
+    logger.warn({ err: String(err), issueId }, "[Transcript] Failed to read all transcripts");
+    return {};
+  }
+}
+function getTranscriptSummary(issueId) {
+  const all = readAllTranscripts(issueId);
+  const attempts = Object.entries(all).map(([key, entries]) => {
+    const totalTokens = entries.reduce((sum, e) => sum + (e.tokens?.total ?? 0), 0);
+    const last = entries[entries.length - 1];
+    return {
+      key,
+      turns: entries.length,
+      totalTokens,
+      success: last?.success ?? false,
+      lastRole: last?.role
+    };
+  });
+  return { attempts };
+}
+
+// src/domains/trace-bundle.ts
+var TRACE_DIR = "traces";
+var ATTEMPT_MANIFEST_FILE = "attempt.json";
+var TRANSCRIPT_MIRROR_FILE = "transcript.jsonl";
+var CHANGED_FILES_FILE = "changed-files.json";
+var DIFF_STAT_FILE = "diff.stat";
+var DIFF_PATCH_FILE = "diff.patch";
+var CHECKPOINT_FILE = "checkpoint.json";
+var HANDOFF_FILE = "handoff.md";
+var RAILS_FILE = "rails.json";
+var SIMILAR_TRACES_FILE = "similar-traces.json";
+function traceManifestPath(traceDirectory) {
+  return join2(traceDirectory, ATTEMPT_MANIFEST_FILE);
+}
+function traceTranscriptPath(traceDirectory) {
+  return join2(traceDirectory, TRANSCRIPT_MIRROR_FILE);
+}
+function traceTurnsPath(traceDirectory) {
+  return join2(traceDirectory, "turns");
+}
+function safeReadChangedFiles(traceDirectory) {
+  try {
+    const raw = readFileSync2(join2(traceDirectory, CHANGED_FILES_FILE), "utf8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((entry) => typeof entry === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function safeReadDiffStatExcerpt(traceDirectory) {
+  try {
+    return readFileSync2(join2(traceDirectory, DIFF_STAT_FILE), "utf8").split("\n").map((line) => line.trimEnd()).filter(Boolean).slice(0, 6);
+  } catch {
+    return [];
+  }
+}
+function safeReadJsonFile(path) {
+  try {
+    return JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function findLastDirectiveArtifact(traceDirectory) {
+  const turnsDir = traceTurnsPath(traceDirectory);
+  if (!existsSync2(turnsDir)) return void 0;
+  try {
+    const directives = readdirSync(turnsDir).filter((entry) => entry.endsWith(".directive.json")).sort((left, right) => left.localeCompare(right));
+    return directives.length > 0 ? `turns/${directives[directives.length - 1]}` : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function collectReviewBlockers(issue) {
+  const criteria = issue.gradingReport?.criteria ?? [];
+  return criteria.filter((criterion) => criterion.result === "FAIL" && criterion.blocking).slice(0, 5).map((criterion) => ({
+    id: criterion.id,
+    category: criterion.category,
+    description: criterion.description,
+    evidence: criterion.evidence
+  }));
+}
+function deriveRemainingWork(issue, patch, changedFiles, reviewBlockers) {
+  const items = [];
+  if (reviewBlockers.length > 0) {
+    items.push(`Address ${reviewBlockers.length} blocking review criteria before resubmitting.`);
+  }
+  if (patch.outcome === "failure" || patch.outcome === "timeout" || patch.outcome === "crash") {
+    if (changedFiles.length > 0) {
+      items.push("Inspect `diff.patch` and `changed-files.json` before retrying the same implementation path.");
+    } else {
+      items.push("The previous attempt left no workspace diff. Take a materially different execution strategy.");
+    }
+  }
+  if (patch.nextIssueState === "Blocked") {
+    items.push("Unblock the current execution path or adjust the plan before resuming.");
+  }
+  const priorSuggestion = issue.previousAttemptSummaries?.[issue.previousAttemptSummaries.length - 1]?.insight?.suggestion;
+  if (priorSuggestion) {
+    items.push(`Prior heuristic suggestion: ${priorSuggestion}`);
+  }
+  return Array.from(new Set(items)).slice(0, 5);
+}
+function buildRailsArtifact(worktreePath, issue, manifest) {
+  const relevantDecisions = (issue.policyDecisions ?? []).filter((decision) => (decision.planVersion ?? manifest.planVersion) === manifest.planVersion).slice(0, 8).map((decision) => ({
+    id: decision.id,
+    kind: decision.kind,
+    scope: decision.scope,
+    basis: decision.basis,
+    from: decision.from,
+    to: decision.to,
+    rationale: decision.rationale,
+    recordedAt: decision.recordedAt
+  }));
+  return {
+    generatedAt: now(),
+    issue: {
+      id: issue.id,
+      identifier: issue.identifier
+    },
+    attempt: {
+      planVersion: manifest.planVersion,
+      executeAttempt: manifest.executeAttempt,
+      role: manifest.role,
+      provider: manifest.provider
+    },
+    harness: {
+      mode: issue.plan?.harnessMode ?? "standard",
+      checkpointPolicy: issue.plan?.executionContract?.checkpointPolicy ?? "final_only",
+      checkpointStatus: issue.checkpointStatus,
+      contractNegotiationStatus: issue.contractNegotiationStatus
+    },
+    budget: {
+      retryBudget: {
+        used: issue.attempts ?? 0,
+        max: issue.maxAttempts ?? 0,
+        remaining: Math.max(0, (issue.maxAttempts ?? 0) - (issue.attempts ?? 0))
+      },
+      executeAttempt: issue.executeAttempt ?? manifest.executeAttempt,
+      reviewAttempt: issue.reviewAttempt ?? 0,
+      checkpointAttempt: issue.checkpointAttempt ?? 0,
+      contractNegotiationAttempt: issue.contractNegotiationAttempt ?? 0,
+      budgetPolicy: issue.plan?.executionContract?.budgetPolicy ?? null
+    },
+    runtimeRails: {
+      contextResetCount: issue.contextResetCount ?? 0,
+      lastHandoffFile: issue.lastHandoffFile ? relative(worktreePath, issue.lastHandoffFile) : void 0,
+      lastFailedPhase: issue.lastFailedPhase
+    },
+    policyDecisions: relevantDecisions
+  };
+}
+function finalizeSimilarTraceSelectionArtifact(traceDirectory, worktreePath, patch) {
+  const artifactPath = join2(traceDirectory, SIMILAR_TRACES_FILE);
+  if (!existsSync2(artifactPath)) return {};
+  try {
+    const artifact = safeReadJsonFile(artifactPath);
+    if (!artifact) return {};
+    const changedFiles = safeReadChangedFiles(traceDirectory);
+    let likelyFollowedHit = null;
+    let bestOverlapScore = 0;
+    for (const hit of artifact.hits ?? []) {
+      const relativeAttemptPath = hit.files?.attempt;
+      if (!relativeAttemptPath) continue;
+      const candidateAttemptPath = join2(worktreePath, relativeAttemptPath);
+      const candidateChangedFilesPath = join2(dirname(candidateAttemptPath), CHANGED_FILES_FILE);
+      const candidateChangedFiles = safeReadJsonFile(candidateChangedFilesPath);
+      const candidateFiles = Array.isArray(candidateChangedFiles) ? candidateChangedFiles.filter((value) => typeof value === "string" && value.length > 0) : [];
+      const overlapFiles = candidateFiles.filter((file) => changedFiles.includes(file));
+      if (overlapFiles.length === 0) continue;
+      const overlapScore = overlapFiles.length * 10 + (hit.score ?? 0);
+      if (overlapScore <= bestOverlapScore) continue;
+      bestOverlapScore = overlapScore;
+      likelyFollowedHit = {
+        issueId: hit.issueId ?? "",
+        issueIdentifier: hit.issueIdentifier ?? "",
+        score: hit.score ?? 0,
+        overlapFiles,
+        reasons: hit.reasons ?? []
+      };
+    }
+    artifact.postAttemptAnalysis = {
+      analyzedAt: now(),
+      attemptOutcome: patch.outcome,
+      attemptChangedFiles: changedFiles,
+      likelyFollowedHit
+    };
+    writeFileSync(artifactPath, `${JSON.stringify(artifact, null, 2)}
+`, "utf8");
+    return { similarTraces: SIMILAR_TRACES_FILE };
+  } catch (error) {
+    logger.warn({ error: String(error), traceDirectory }, "[TraceBundle] Failed to finalize similar trace selection artifact");
+    return {};
+  }
+}
+function writeRailsArtifact(traceDirectory, worktreePath, issue) {
+  const manifest = readExistingManifest(traceDirectory);
+  if (!manifest) return {};
+  try {
+    const rails = buildRailsArtifact(worktreePath, issue, manifest);
+    writeFileSync(join2(traceDirectory, RAILS_FILE), `${JSON.stringify(rails, null, 2)}
+`, "utf8");
+    return { rails: RAILS_FILE };
+  } catch (error) {
+    logger.warn({ error: String(error), traceDirectory, issueId: issue.id }, "[TraceBundle] Failed to write rails artifact");
+    return {};
+  }
+}
+function renderHandoffMarkdown(checkpoint) {
+  const lines = [
+    "# Attempt Handoff",
+    "",
+    `- Issue: ${checkpoint.issue.identifier} \u2014 ${checkpoint.issue.title}`,
+    `- Attempt: v${checkpoint.attempt.planVersion}a${checkpoint.attempt.executeAttempt}`,
+    `- Outcome: ${checkpoint.attempt.outcome ?? "unknown"}`,
+    `- Next state: ${checkpoint.attempt.nextIssueState ?? "unknown"}`,
+    "",
+    "## Resume Order",
+    "- Start with `handoff.md` for the concise summary.",
+    "- Read `checkpoint.json` for structured resume state.",
+    "- Open `attempt.json`, the last `directive.json`, and `diff.patch` only if they are relevant to the failure mode.",
+    ""
+  ];
+  if (checkpoint.changedFiles.length > 0) {
+    lines.push("## Changed Files");
+    lines.push(...checkpoint.changedFiles.map((file) => `- \`${file}\``));
+    lines.push("");
+  }
+  if (checkpoint.diffStatExcerpt.length > 0) {
+    lines.push("## Diff Summary");
+    lines.push("```text");
+    lines.push(...checkpoint.diffStatExcerpt);
+    lines.push("```");
+    lines.push("");
+  }
+  if (checkpoint.lastTurn) {
+    lines.push("## Last Turn");
+    lines.push(`- Turn: ${checkpoint.lastTurn.turn}`);
+    if (checkpoint.lastTurn.directiveStatus) lines.push(`- Directive status: ${checkpoint.lastTurn.directiveStatus}`);
+    if (checkpoint.lastTurn.directiveSummary) lines.push(`- Directive summary: ${checkpoint.lastTurn.directiveSummary}`);
+    if (checkpoint.lastTurn.outputPreview) lines.push(`- Output preview: ${checkpoint.lastTurn.outputPreview}`);
+    lines.push("");
+  }
+  if (checkpoint.reviewBlockers.length > 0) {
+    lines.push("## Blocking Review Evidence");
+    for (const blocker of checkpoint.reviewBlockers) {
+      lines.push(`- **${blocker.id}**${blocker.category ? ` [${blocker.category}]` : ""}: ${blocker.description ?? "Blocking review failure"}`);
+      if (blocker.evidence) {
+        lines.push(`  Evidence: ${blocker.evidence}`);
+      }
+    }
+    lines.push("");
+  }
+  if (checkpoint.remainingWork.length > 0) {
+    lines.push("## Remaining Work");
+    lines.push(...checkpoint.remainingWork.map((item) => `- ${item}`));
+    lines.push("");
+  }
+  lines.push("## Key Artifacts");
+  lines.push(`- \`${checkpoint.resumeArtifacts.checkpoint}\``);
+  if (checkpoint.resumeArtifacts.rails) lines.push(`- \`${checkpoint.resumeArtifacts.rails}\``);
+  if (checkpoint.resumeArtifacts.similarTraces) lines.push(`- \`${checkpoint.resumeArtifacts.similarTraces}\``);
+  lines.push(`- \`${checkpoint.resumeArtifacts.attemptManifest}\``);
+  if (checkpoint.resumeArtifacts.lastDirective) lines.push(`- \`${checkpoint.resumeArtifacts.lastDirective}\``);
+  if (checkpoint.resumeArtifacts.diffPatch) lines.push(`- \`${checkpoint.resumeArtifacts.diffPatch}\``);
+  lines.push(`- \`${checkpoint.resumeArtifacts.transcript}\``);
+  lines.push(`- \`${checkpoint.resumeArtifacts.changedFiles}\``);
+  lines.push(`- \`${checkpoint.resumeArtifacts.diffStat}\``);
+  if (checkpoint.resumeArtifacts.bootstrap) lines.push(`- \`${checkpoint.resumeArtifacts.bootstrap}\``);
+  lines.push("");
+  return `${lines.join("\n")}
+`;
+}
+function writeHandoffArtifacts(traceDirectory, issue, patch, transcriptEntries) {
+  const manifest = readExistingManifest(traceDirectory);
+  if (!manifest) return {};
+  try {
+    const changedFiles = safeReadChangedFiles(traceDirectory);
+    const reviewBlockers = collectReviewBlockers(issue);
+    const checkpoint = {
+      generatedAt: now(),
+      issue: {
+        id: issue.id,
+        identifier: issue.identifier,
+        title: issue.title
+      },
+      attempt: {
+        planVersion: manifest.planVersion,
+        executeAttempt: manifest.executeAttempt,
+        role: manifest.role,
+        provider: manifest.provider,
+        outcome: patch.outcome,
+        nextIssueState: patch.nextIssueState,
+        error: patch.error
+      },
+      lastTurn: transcriptEntries.length > 0 ? {
+        turn: transcriptEntries[transcriptEntries.length - 1].turn,
+        directiveStatus: transcriptEntries[transcriptEntries.length - 1].directiveStatus,
+        directiveSummary: transcriptEntries[transcriptEntries.length - 1].directiveSummary,
+        exitCode: transcriptEntries[transcriptEntries.length - 1].exitCode,
+        outputPreview: transcriptEntries[transcriptEntries.length - 1].outputPreview
+      } : null,
+      changedFiles,
+      diffStatExcerpt: safeReadDiffStatExcerpt(traceDirectory),
+      reviewBlockers,
+      priorAttemptSuggestion: issue.previousAttemptSummaries?.[issue.previousAttemptSummaries.length - 1]?.insight?.suggestion,
+      remainingWork: deriveRemainingWork(issue, patch, changedFiles, reviewBlockers),
+      resumeArtifacts: {
+        attemptManifest: ATTEMPT_MANIFEST_FILE,
+        checkpoint: CHECKPOINT_FILE,
+        handoff: HANDOFF_FILE,
+        rails: existsSync2(join2(traceDirectory, RAILS_FILE)) ? RAILS_FILE : void 0,
+        similarTraces: existsSync2(join2(traceDirectory, SIMILAR_TRACES_FILE)) ? SIMILAR_TRACES_FILE : void 0,
+        transcript: TRANSCRIPT_MIRROR_FILE,
+        changedFiles: CHANGED_FILES_FILE,
+        diffStat: DIFF_STAT_FILE,
+        diffPatch: existsSync2(join2(traceDirectory, DIFF_PATCH_FILE)) ? DIFF_PATCH_FILE : void 0,
+        bootstrap: existsSync2(join2(traceDirectory, "bootstrap.md")) ? "bootstrap.md" : void 0,
+        lastDirective: findLastDirectiveArtifact(traceDirectory)
+      }
+    };
+    writeFileSync(join2(traceDirectory, CHECKPOINT_FILE), `${JSON.stringify(checkpoint, null, 2)}
+`, "utf8");
+    writeFileSync(join2(traceDirectory, HANDOFF_FILE), renderHandoffMarkdown(checkpoint), "utf8");
+    return { checkpoint: CHECKPOINT_FILE, handoff: HANDOFF_FILE };
+  } catch (error) {
+    logger.warn({ error: String(error), traceDirectory, issueId: issue.id }, "[TraceBundle] Failed to write handoff artifacts");
+    return {};
+  }
+}
+function traceDir(worktreePath, planVersion, executeAttempt) {
+  return join2(workspaceSafePath(worktreePath), TRACE_DIR, `v${planVersion}a${executeAttempt}`);
+}
+function safeReadFileSlice(filePath, maxChars) {
+  try {
+    if (!existsSync2(filePath)) return null;
+    const raw = readFileSync2(filePath, "utf8");
+    return raw.length > maxChars ? raw.slice(0, maxChars) + "\n[...truncated]" : raw;
+  } catch {
+    return null;
+  }
+}
+function extractCheckpointSummary(filePath, maxChars) {
+  try {
+    if (!existsSync2(filePath)) return null;
+    const raw = readFileSync2(filePath, "utf8");
+    const data = JSON.parse(raw);
+    const parts = [];
+    if (data.outcome) parts.push(`**Outcome:** ${data.outcome}`);
+    if (data.error) parts.push(`**Error:** ${String(data.error).slice(0, 200)}`);
+    if (Array.isArray(data.reviewBlockers) && data.reviewBlockers.length > 0) {
+      parts.push(`**Review blockers:** ${data.reviewBlockers.map((b) => `${b.id ?? "?"}: ${b.description ?? ""}`).join("; ")}`);
+    }
+    if (Array.isArray(data.remainingWork) && data.remainingWork.length > 0) {
+      parts.push(`**Remaining work:**
+${data.remainingWork.map((w) => `- ${w}`).join("\n")}`);
+    }
+    if (data.lastTurn) {
+      const lt = data.lastTurn;
+      if (lt.summary) parts.push(`**Last turn:** ${lt.summary}`);
+    }
+    const result = parts.join("\n");
+    return result.length > maxChars ? result.slice(0, maxChars) + "\n[...truncated]" : result;
+  } catch {
+    return null;
+  }
+}
+function extractLastDirectiveSummary(traceDirectory, maxChars) {
+  const turnsDir = join2(traceDirectory, "turns");
+  try {
+    if (!existsSync2(turnsDir)) return null;
+    const directives = readdirSync(turnsDir).filter((f) => f.endsWith(".directive.json")).sort();
+    if (directives.length === 0) return null;
+    const last = readFileSync2(join2(turnsDir, directives[directives.length - 1]), "utf8");
+    const data = JSON.parse(last);
+    const parts = [];
+    if (data.directiveSummary || data.summary) parts.push(String(data.directiveSummary ?? data.summary));
+    if (data.outputPreview) parts.push(`Output: ${String(data.outputPreview).slice(0, 300)}`);
+    if (data.status) parts.push(`Status: ${data.status}`);
+    const result = parts.join("\n");
+    return result.length > maxChars ? result.slice(0, maxChars) + "\n[...truncated]" : result;
+  } catch {
+    return null;
+  }
+}
+function readTraceContent(traceDirectory, budget) {
+  let remaining = budget;
+  let truncated = false;
+  const handoffBudget = Math.min(Math.floor(budget * 0.35), 2500);
+  const handoffMarkdown = safeReadFileSlice(join2(traceDirectory, "handoff.md"), handoffBudget);
+  if (handoffMarkdown) remaining -= handoffMarkdown.length;
+  const checkpointBudget = Math.min(Math.floor(budget * 0.2), 1500);
+  const checkpointSummary = remaining > 200 ? extractCheckpointSummary(join2(traceDirectory, "checkpoint.json"), Math.min(checkpointBudget, remaining)) : null;
+  if (checkpointSummary) remaining -= checkpointSummary.length;
+  const diffBudget = Math.min(Math.floor(budget * 0.3), remaining);
+  const diffPatch = remaining > 200 ? safeReadFileSlice(join2(traceDirectory, "diff.patch"), Math.min(diffBudget, remaining)) : null;
+  if (diffPatch) remaining -= diffPatch.length;
+  const directiveBudget = Math.min(Math.floor(budget * 0.15), remaining);
+  const lastDirectiveSummary = remaining > 100 ? extractLastDirectiveSummary(traceDirectory, Math.min(directiveBudget, remaining)) : null;
+  if (lastDirectiveSummary) remaining -= lastDirectiveSummary.length;
+  const totalChars = budget - remaining;
+  if (totalChars >= budget * 0.95) truncated = true;
+  return { handoffMarkdown, checkpointSummary, diffPatch, lastDirectiveSummary, totalChars, truncated };
+}
+function workspaceSafePath(workspacePath) {
+  return workspacePath.replace(/\\/g, "/");
+}
+function ensureTraceDir(worktreePath, planVersion, executeAttempt) {
+  const dir = traceDir(worktreePath, planVersion, executeAttempt);
+  try {
+    mkdirSync2(traceTurnsPath(dir), { recursive: true });
+    return dir;
+  } catch (error) {
+    logger.warn({ error: String(error), issueWorkspace: worktreePath, planVersion, executeAttempt }, "[TraceBundle] Failed to create trace directory");
+    return null;
+  }
+}
+function toTraceBundle(traceDirectory) {
+  return {
+    dir: traceDirectory,
+    manifestFile: ATTEMPT_MANIFEST_FILE,
+    transcriptFile: TRANSCRIPT_MIRROR_FILE,
+    turnsDir: "turns"
+  };
+}
+function readExistingManifest(traceDirectory) {
+  const path = traceManifestPath(traceDirectory);
+  if (!existsSync2(path)) return null;
+  try {
+    const raw = readFileSync2(path, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed;
+  } catch (error) {
+    logger.warn({ error: String(error), traceDirectory }, "[TraceBundle] Failed to read existing attempt manifest");
+    return null;
+  }
+}
+function loadAttemptManifest(traceDirectory) {
+  return readExistingManifest(traceDirectory);
+}
+function writeAttemptManifest(traceDirectory, manifest) {
+  const path = traceManifestPath(traceDirectory);
+  try {
+    writeFileSync(path, JSON.stringify(manifest, null, 2), "utf8");
+  } catch (error) {
+    logger.warn({ error: String(error), traceDirectory }, "[TraceBundle] Failed to write attempt manifest");
+  }
+}
+function finalizeAttemptManifest(traceDirectory, patch) {
+  const path = traceManifestPath(traceDirectory);
+  const existing = readExistingManifest(traceDirectory);
+  if (!existing) {
+    logger.warn({ traceDirectory }, "[TraceBundle] Attempt manifest missing \u2014 skip finalization");
+    return;
+  }
+  const finalized = {
+    ...existing,
+    ...patch,
+    files: {
+      ...existing.files,
+      ...patch.files ?? {}
+    }
+  };
+  if (patch.rawOutputs) {
+    finalized.rawOutputs = Array.from(/* @__PURE__ */ new Set([...existing.rawOutputs ?? [], ...patch.rawOutputs]));
+  }
+  writeAttemptManifest(traceDirectory, finalized);
+}
+function buildInitialAttemptManifest(issue, provider, role) {
+  const planVersion = issue.planVersion ?? 1;
+  const executeAttempt = issue.executeAttempt ?? 1;
+  return {
+    manifestVersion: 1,
+    issueId: issue.id,
+    issueIdentifier: issue.identifier,
+    planVersion,
+    executeAttempt,
+    provider,
+    role,
+    startedAt: now(),
+    files: {
+      attemptManifest: ATTEMPT_MANIFEST_FILE,
+      transcript: TRANSCRIPT_MIRROR_FILE,
+      turnsDir: "turns",
+      changedFiles: CHANGED_FILES_FILE,
+      diffStat: DIFF_STAT_FILE,
+      rawOutputTemplate: `outputs/execute.v${planVersion}a${executeAttempt}.t{turn}.stdout.log`
+    },
+    rawOutputs: []
+  };
+}
+function captureWorkspaceDelta(traceDirectory, worktreePath) {
+  try {
+    const changedOutput = execSync("git diff --name-only", { cwd: worktreePath, encoding: "utf8", maxBuffer: 1e6 });
+    const changedFiles = (changedOutput || "").split("\n").map((f) => f.trim()).filter(Boolean);
+    writeFileSync(join2(traceDirectory, CHANGED_FILES_FILE), JSON.stringify(changedFiles, null, 2), "utf8");
+    const diffStat = execSync("git diff --stat", { cwd: worktreePath, encoding: "utf8", maxBuffer: 1e6 });
+    writeFileSync(join2(traceDirectory, DIFF_STAT_FILE), diffStat || "", "utf8");
+    if (changedFiles.length > 0) {
+      const diffOutput = execSync("git diff", { cwd: worktreePath, encoding: "utf8", maxBuffer: 4e6 });
+      writeFileSync(join2(traceDirectory, DIFF_PATCH_FILE), diffOutput || "", "utf8");
+      finalizeAttemptManifest(traceDirectory, { files: { diffPatch: DIFF_PATCH_FILE } });
+    } else {
+      logger.debug({ traceDirectory, issuePath: worktreePath }, "[TraceBundle] No changed files, skipping diff.patch");
+    }
+  } catch (error) {
+    logger.warn({ error: String(error), traceDirectory, worktreePath }, "[TraceBundle] Failed to capture workspace delta");
+    writeFileSync(join2(traceDirectory, CHANGED_FILES_FILE), "[]", "utf8");
+    writeFileSync(join2(traceDirectory, DIFF_STAT_FILE), "", "utf8");
+  }
+}
+function writeTranscriptMirror(traceDirectory, transcriptEntries) {
+  try {
+    const lines = transcriptEntries.map((entry) => JSON.stringify({
+      ts: entry.ts,
+      turn: entry.turn,
+      role: entry.role,
+      model: entry.model,
+      provider: entry.provider,
+      directiveStatus: entry.directiveStatus,
+      directiveSummary: entry.directiveSummary,
+      exitCode: entry.exitCode,
+      success: entry.success,
+      tokens: entry.tokens,
+      toolsUsed: entry.toolsUsed,
+      skillsUsed: entry.skillsUsed,
+      agentsUsed: entry.agentsUsed,
+      commandsRun: entry.commandsRun,
+      durationMs: entry.durationMs,
+      contextPct: entry.contextPct,
+      outputPreview: entry.outputPreview
+    }));
+    const path = traceTranscriptPath(traceDirectory);
+    writeFileSync(path, lines.join("\n") + (lines.length > 0 ? "\n" : ""), "utf8");
+  } catch (error) {
+    logger.warn({ error: String(error), traceDirectory }, "[TraceBundle] Failed to write transcript mirror");
+  }
+}
+function finalizeAttemptForIssue(worktreePath, issue, patch) {
+  const planVersion = issue.planVersion ?? 1;
+  const executeAttempt = issue.executeAttempt ?? 1;
+  const dir = traceDir(worktreePath, planVersion, executeAttempt);
+  if (!existsSync2(dir)) return;
+  captureWorkspaceDelta(dir, worktreePath);
+  const transcriptEntries = readTranscript(issue.id, planVersion, executeAttempt);
+  writeTranscriptMirror(dir, transcriptEntries);
+  const railsFiles = writeRailsArtifact(dir, worktreePath, issue);
+  const similarTraceFiles = finalizeSimilarTraceSelectionArtifact(dir, worktreePath, patch);
+  const handoffFiles = writeHandoffArtifacts(dir, issue, patch, transcriptEntries);
+  finalizeAttemptManifest(dir, {
+    ...patch,
+    files: {
+      ...patch.files ?? {},
+      ...railsFiles,
+      ...similarTraceFiles,
+      ...handoffFiles
+    }
+  });
+  try {
+    const contextMetrics = loadContextMetrics(dir);
+    if (contextMetrics) {
+      const crossAttemptPath = join2(dir, "cross-attempt.json");
+      let hypothesesCount = 0;
+      let pivotTriggered = false;
+      if (existsSync2(crossAttemptPath)) {
+        const ca = JSON.parse(readFileSync2(crossAttemptPath, "utf8"));
+        hypothesesCount = Array.isArray(ca?.hypotheses) ? ca.hypotheses.length : 0;
+        pivotTriggered = Boolean(ca?.strategyPivot);
+      }
+      const similarPath = join2(dir, "similar-traces.json");
+      let similarCount = 0;
+      if (existsSync2(similarPath)) {
+        const st = JSON.parse(readFileSync2(similarPath, "utf8"));
+        similarCount = Array.isArray(st?.hits) ? st.hits.length : 0;
+      }
+      writeHarnessOutcome(dir, {
+        issueId: issue.id,
+        issueIdentifier: issue.identifier,
+        planVersion,
+        executeAttempt,
+        outcome: patch.outcome ?? "unknown",
+        contextMetrics,
+        hypothesesGenerated: hypothesesCount,
+        strategyPivotTriggered: pivotTriggered,
+        similarIssuesUsed: similarCount
+      });
+    }
+  } catch {
+  }
+}
+function persistContextMetrics(traceDirectory, metrics) {
+  try {
+    writeFileSync(join2(traceDirectory, "context-metrics.json"), JSON.stringify(metrics, null, 2), "utf8");
+  } catch (error) {
+    logger.debug({ err: String(error), traceDirectory }, "[TraceBundle] Failed to write context metrics");
+  }
+}
+function loadContextMetrics(traceDirectory) {
+  const filePath = join2(traceDirectory, "context-metrics.json");
+  if (!existsSync2(filePath)) return null;
+  try {
+    return JSON.parse(readFileSync2(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeHarnessOutcome(traceDirectory, outcome) {
+  try {
+    writeFileSync(join2(traceDirectory, "harness-outcome.json"), JSON.stringify(outcome, null, 2), "utf8");
+  } catch (error) {
+    logger.debug({ err: String(error), traceDirectory }, "[TraceBundle] Failed to write harness outcome");
+  }
+}
+function loadHarnessOutcome(traceDirectory) {
+  const filePath = join2(traceDirectory, "harness-outcome.json");
+  if (!existsSync2(filePath)) return null;
+  try {
+    return JSON.parse(readFileSync2(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+export {
+  recordTranscriptTurn,
+  readTranscript,
+  readAllTranscripts,
+  getTranscriptSummary,
+  TRACE_DIR,
+  traceDir,
+  readTraceContent,
+  ensureTraceDir,
+  toTraceBundle,
+  loadAttemptManifest,
+  writeAttemptManifest,
+  finalizeAttemptManifest,
+  buildInitialAttemptManifest,
+  captureWorkspaceDelta,
+  writeTranscriptMirror,
+  finalizeAttemptForIssue,
+  persistContextMetrics,
+  loadContextMetrics,
+  writeHarnessOutcome,
+  loadHarnessOutcome
+};
+//# sourceMappingURL=chunk-APJOZXRP.js.map