fifony 0.1.47 → 0.1.48

package/dist/{chunk-QH6VCTET.js → chunk-RCSJFMQG.js}

@@ -1,38 +1,58 @@
 import {
   markIssueDirty,
   normalizeAgentProvider
-} from "./chunk-PI7Y77R3.js";
+} from "./chunk-OFIVTM2E.js";
+import {
+  init_template_variants,
+  template_variants_exports
+} from "./chunk-AFP36N23.js";
+import {
+  finalizeAttemptManifest,
+  loadAttemptManifest,
+  readTraceContent,
+  traceDir
+} from "./chunk-APJOZXRP.js";
 import {
   renderPrompt
-} from "./chunk-AAZKYWOY.js";
+} from "./chunk-AFYKGVSP.js";
+import {
+  appendFileTail,
+  idToSafePath,
+  init_helpers,
+  now
+} from "./chunk-DLSPRIQL.js";
 import {
   SOURCE_MARKER,
   SOURCE_ROOT,
   TARGET_ROOT,
   WORKSPACE_ROOT,
-  appendFileTail,
-  idToSafePath,
-  now
-} from "./chunk-VM5QAYP5.js";
+  init_constants
+} from "./chunk-X37RNTWU.js";
 import {
   logger
 } from "./chunk-PXTIWKLQ.js";
+import {
+  __toCommonJS
+} from "./chunk-Z6ZWNWWR.js";
 
 // src/domains/workspace.ts
+init_constants();
+init_helpers();
 import {
-  existsSync as existsSync5,
+  existsSync as existsSync8,
   mkdirSync as mkdirSync3,
-  readdirSync as readdirSync2,
-  readFileSync as readFileSync3,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync5,
   rmSync as rmSync2,
   statSync,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync5
 } from "fs";
 import { copyFile, mkdir, readdir, stat, writeFile } from "fs/promises";
-import { extname, join as join4, resolve } from "path";
+import { extname, join as join7, resolve } from "path";
 import { execSync as execSync2 } from "child_process";
 
 // src/agents/command-executor.ts
+init_helpers();
 import {
   appendFileSync,
   existsSync as existsSync3,
@@ -46,6 +66,7 @@ import { spawn } from "child_process";
 import { createConnection } from "net";
 import { createRequire } from "module";
 import { fileURLToPath } from "url";
+init_constants();
 
 // src/agents/docker-runner.ts
 import { existsSync } from "fs";
@@ -356,7 +377,7 @@ async function runCommandWithTimeout(command, workspacePath, issue, config, prom
   if (!config.dockerExecution && DAEMON_SCRIPT) {
     const socketPath = join2(workspacePath, "agent.sock");
     if (existsSync3(socketPath)) {
-      const { isDaemonAlive } = await import("./pid-manager-UBWXVSMD.js");
+      const { isDaemonAlive } = await import("./pid-manager-EDT4DHAU.js");
       if (isDaemonAlive(workspacePath)) {
         logger.info({ issueId: issue.id }, "[Agent] Live PTY daemon detected \u2014 reattaching to existing session");
         return attachToDaemon(socketPath, workspacePath, issue, config, started, outputFile, resultFile);
@@ -821,6 +842,10 @@ async function runHook(command, workspacePath, issue, hookName, extraEnv = {}) {
   }
 }
 
+// src/agents/prompt-builder.ts
+import { existsSync as existsSync6, readdirSync as readdirSync3 } from "fs";
+import { join as join5, relative as relative2 } from "path";
+
 // src/agents/review-failure-history.ts
 function sortFailureHistory(history) {
   return [...history].sort((left, right) => {
@@ -944,49 +969,804 @@ function buildRecurringFailureContext(issue, scope) {
   return lines.join("\n");
 }
 
+// src/domains/cross-attempt-analysis.ts
+init_helpers();
+import { existsSync as existsSync4, readFileSync as readFileSync2, readdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
+var CROSS_ATTEMPT_FILE = "cross-attempt.json";
+function readJsonFile(filePath) {
+  if (!existsSync4(filePath)) return null;
+  try {
+    return JSON.parse(readFileSync2(filePath, "utf8"));
+  } catch (error) {
+    logger.debug({ err: String(error), filePath }, "[CrossAttempt] Failed to parse JSON file");
+    return null;
+  }
+}
+function diffStatSizeFor(traceDirectory) {
+  const filePath = join3(traceDirectory, "diff.stat");
+  if (!existsSync4(filePath)) return 0;
+  try {
+    return readFileSync2(filePath, "utf8").split("\n").map((line) => line.trim()).filter(Boolean).length;
+  } catch {
+    return 0;
+  }
+}
+function changedFilesFor(traceDirectory) {
+  return readJsonFile(join3(traceDirectory, "changed-files.json")) ?? [];
+}
+function buildAttemptRecords(worktreePath, previousAttemptSummaries) {
+  const deduped = /* @__PURE__ */ new Map();
+  for (const summary of previousAttemptSummaries ?? []) {
+    deduped.set(`${summary.planVersion}:${summary.executeAttempt}`, summary);
+  }
+  return [...deduped.values()].sort(
+    (left, right) => left.planVersion !== right.planVersion ? left.planVersion - right.planVersion : left.executeAttempt - right.executeAttempt
+  ).map((summary) => {
+    const directory = traceDir(worktreePath, summary.planVersion, summary.executeAttempt);
+    const manifest = loadAttemptManifest(directory);
+    return {
+      planVersion: summary.planVersion,
+      executeAttempt: summary.executeAttempt,
+      summary,
+      failureType: summary.insight?.errorType,
+      changedFiles: changedFilesFor(directory),
+      diffStatSize: diffStatSizeFor(directory),
+      outcome: manifest?.outcome ?? "failure",
+      nextIssueState: manifest?.nextIssueState
+    };
+  });
+}
+function persistCrossAttemptAnalysis(traceDirectory, analysis) {
+  try {
+    writeFileSync2(join3(traceDirectory, CROSS_ATTEMPT_FILE), JSON.stringify(analysis, null, 2), "utf8");
+  } catch (error) {
+    logger.warn({ err: String(error), traceDirectory }, "[CrossAttempt] Failed to write cross-attempt analysis");
+  }
+}
+function loadCrossAttemptAnalysis(traceDirectory) {
+  return readJsonFile(join3(traceDirectory, CROSS_ATTEMPT_FILE));
+}
+function formHypotheses(records) {
+  if (records.length < 2) return [];
+  const hypotheses = [];
+  const fileAppearances = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    for (const f of r.changedFiles) {
+      const entry = fileAppearances.get(f) ?? { count: 0, errorTypes: /* @__PURE__ */ new Set(), attempts: [] };
+      entry.count++;
+      if (r.failureType) entry.errorTypes.add(r.failureType);
+      entry.attempts.push(r.executeAttempt);
+      fileAppearances.set(f, entry);
+    }
+  }
+  for (const [file, data] of fileAppearances) {
+    if (data.count >= 3 && data.errorTypes.size === 1) {
+      const errorType = [...data.errorTypes][0];
+      hypotheses.push({
+        signal: `\`${file}\` modified in ${data.count} attempts, all with ${errorType} error`,
+        hypothesis: `The current approach to \`${file}\` is fundamentally wrong for this error class`,
+        evidence: [`Attempts ${data.attempts.join(", ")} all modified this file`, `Same error type (${errorType}) persists`],
+        suggestion: `Try a completely different strategy for \`${file}\` \u2014 the repeated approach is not converging`
+      });
+    }
+  }
+  if (records.length >= 3) {
+    const types = records.map((r) => r.failureType ?? "unknown");
+    let oscillating = true;
+    for (let i = 2; i < types.length; i++) {
+      if (types[i] !== types[i - 2] || types[i] === types[i - 1]) {
+        oscillating = false;
+        break;
+      }
+    }
+    if (oscillating && types.length >= 3) {
+      hypotheses.push({
+        signal: `Error types alternate: ${types.slice(-4).join(" \u2192 ")}`,
+        hypothesis: "Fixing one error class introduces the other \u2014 the two are coupled",
+        evidence: types.map((t, i) => `Attempt ${records[i].executeAttempt}: ${t}`),
+        suggestion: "Address both error classes simultaneously in a single coherent change"
+      });
+    }
+  }
+  if (records.length >= 2) {
+    const failedRecords = records.filter((r) => r.outcome === "failure");
+    if (failedRecords.length >= 3) {
+      const growing = failedRecords.every((r, i) => i === 0 || r.diffStatSize >= failedRecords[i - 1].diffStatSize);
+      const firstSize = failedRecords[0].diffStatSize;
+      const lastSize = failedRecords[failedRecords.length - 1].diffStatSize;
+      if (growing && lastSize > firstSize * 1.5 && lastSize > 5) {
+        hypotheses.push({
+          signal: `Diff size grew from ${firstSize} to ${lastSize} lines across ${failedRecords.length} failed attempts`,
+          hypothesis: "The approach is accumulating complexity without solving the root cause",
+          evidence: failedRecords.map((r) => `Attempt ${r.executeAttempt}: ${r.diffStatSize} lines, outcome: ${r.outcome}`),
+          suggestion: "Start with the minimal possible change \u2014 add one thing at a time and verify"
+        });
+      }
+    }
+  }
+  const zeroDiffs = records.filter((r) => r.changedFiles.length === 0 && r.diffStatSize === 0);
+  if (zeroDiffs.length > 0) {
+    hypotheses.push({
+      signal: `${zeroDiffs.length} attempt(s) produced no file changes`,
+      hypothesis: "The agent got stuck in analysis without making concrete modifications",
+      evidence: zeroDiffs.map((r) => `Attempt ${r.executeAttempt}: 0 files changed`),
+      suggestion: "Make the smallest possible edit first, then iterate \u2014 avoid analysis-only turns"
+    });
+  }
+  return hypotheses;
+}
+function detectStrategyPivot(records) {
+  if (records.length < 3) return null;
+  const recent = records.slice(-3);
+  const types = recent.map((r) => r.failureType).filter(Boolean);
+  if (types.length === 3 && types[0] === types[1] && types[1] === types[2]) {
+    return {
+      reason: `${types.length} consecutive ${types[0]} failures`,
+      consecutiveRegressions: types.length,
+      suggestedApproach: "The current implementation path is exhausted. Try a fundamentally different approach: different algorithm, different API surface, or different file structure."
+    };
+  }
+  const suggestions = records.map((r) => r.summary?.insight?.suggestion).filter(Boolean);
+  if (suggestions.length >= 2) {
+    const last = suggestions[suggestions.length - 1];
+    const secondLast = suggestions[suggestions.length - 2];
+    if (last && secondLast && last === secondLast) {
+      return {
+        reason: "Same corrective suggestion repeated without progress",
+        consecutiveRegressions: 2,
+        suggestedApproach: "The previous suggestion was attempted but did not resolve the issue. Apply a structurally different fix rather than retrying the same correction."
+      };
+    }
+  }
+  return null;
+}
+function isolateConfounds(records) {
+  if (records.length < 2) return [];
+  const confounds = [];
+  for (let i = 1; i < records.length; i++) {
+    const prev = records[i - 1];
+    const curr = records[i];
+    if (prev.outcome !== "failure" || curr.outcome !== "failure") continue;
+    const prevSet = new Set(prev.changedFiles);
+    const currSet = new Set(curr.changedFiles);
+    for (const f of prevSet) {
+      if (!currSet.has(f)) confounds.push(`\`${f}\` changed in attempt ${prev.executeAttempt} but not ${curr.executeAttempt} \u2014 likely irrelevant to the failure`);
+    }
+  }
+  return confounds.slice(0, 5);
+}
+function computeCrossAttemptAnalysis(worktreePath, currentPV, currentEA, previousAttemptSummaries) {
+  const records = buildAttemptRecords(worktreePath, previousAttemptSummaries).filter((record) => record.planVersion < currentPV || record.executeAttempt < currentEA);
+  const failureCounts = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (!record.failureType || record.failureType === "unknown") continue;
+    failureCounts.set(record.failureType, (failureCounts.get(record.failureType) ?? 0) + 1);
+  }
+  const repeatedFailureTypes = [...failureCounts.entries()].filter(([, count]) => count > 1).map(([failureType]) => failureType).sort((left, right) => left.localeCompare(right));
+  const overlap = /* @__PURE__ */ new Set();
+  for (let index = 1; index < records.length; index += 1) {
+    const previous = new Set(records[index - 1].changedFiles);
+    for (const filePath of records[index].changedFiles) {
+      if (previous.has(filePath)) overlap.add(filePath);
+    }
+  }
+  const outcomeTransitions = records.map((record) => ({
+    attempt: record.executeAttempt,
+    outcome: record.outcome,
+    nextIssueState: record.nextIssueState
+  }));
+  const summary = [];
+  if (records.length === 0) {
+    summary.push("No previous attempt artifacts were available; retry should rely on summary-only context.");
+  }
+  if (repeatedFailureTypes.length > 0) {
+    summary.push(`Repeated failure types: ${repeatedFailureTypes.join(", ")}.`);
+  }
+  if (overlap.size > 0) {
+    summary.push(`Repeated file edits across adjacent attempts: ${[...overlap].slice(0, 8).join(", ")}.`);
+  }
+  if (records.length >= 2) {
+    const previous = records[records.length - 2];
+    const latest = records[records.length - 1];
+    summary.push(
+      `Recent outcome transition: a${previous.executeAttempt} ${previous.outcome}/${previous.nextIssueState ?? "unknown"} -> a${latest.executeAttempt} ${latest.outcome}/${latest.nextIssueState ?? "unknown"}.`
+    );
+    summary.push(
+      `Diff footprint changed from ${previous.diffStatSize} diff.stat line(s) to ${latest.diffStatSize} diff.stat line(s).`
+    );
+  }
+  if (summary.length === 0) {
+    summary.push("No strong cross-attempt pattern detected.");
+  }
+  const hypotheses = formHypotheses(records);
+  const strategyPivot = detectStrategyPivot(records);
+  const confounds = isolateConfounds(records);
+  return {
+    generatedAt: now(),
+    repeatedFailureTypes,
+    changedFileOverlap: [...overlap].sort((left, right) => left.localeCompare(right)),
+    outcomeTransitions,
+    summary,
+    hypotheses,
+    strategyPivot,
+    confounds
+  };
+}
+
+// src/domains/trace-retrieval.ts
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname, join as join4, relative } from "path";
+var TRACE_DIR_NAME = "traces";
+var TRACE_NAME_PATTERN = /^v(\d+)a(\d+)$/;
+var MAX_WORKSPACES = 48;
+var MAX_ATTEMPTS_PER_WORKSPACE = 4;
+var MAX_RESULTS = 3;
+var MIN_SCORE = 4;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "with",
+  "from",
+  "that",
+  "this",
+  "into",
+  "while",
+  "when",
+  "then",
+  "failed",
+  "failure",
+  "error",
+  "issue",
+  "review",
+  "execution",
+  "attempt",
+  "previous",
+  "before",
+  "after",
+  "should",
+  "would",
+  "could",
+  "must",
+  "need",
+  "file",
+  "files"
+]);
+function readJsonFile2(path) {
+  try {
+    return JSON.parse(readFileSync3(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function tokenize(text) {
+  const matches = text.toLowerCase().match(/[a-z0-9_.-]{3,}/g) ?? [];
+  return new Set(
+    matches.filter(
+      (token) => !STOP_WORDS.has(token) && !/^\d+$/.test(token)
+    )
+  );
+}
+function buildQuerySignal(issue) {
+  const summaries = issue.previousAttemptSummaries ?? [];
+  const latest = summaries.length > 0 ? summaries[summaries.length - 1] : null;
+  const blockerIds = new Set(
+    (issue.gradingReport?.criteria ?? []).filter((criterion) => criterion.result === "FAIL" && criterion.blocking).map((criterion) => criterion.id).filter((value) => typeof value === "string" && value.length > 0)
+  );
+  const files = new Set(
+    latest?.insight?.filesInvolved?.filter((value) => typeof value === "string" && value.length > 0) ?? []
+  );
+  const errorType = (latest?.insight?.errorType ?? "").trim().toLowerCase();
+  const errorText = [
+    latest?.insight?.rootCause ?? "",
+    latest?.error ?? "",
+    latest?.outputTail ?? "",
+    issue.lastError ?? ""
+  ].join(" ");
+  return {
+    errorType,
+    tokens: tokenize(errorText),
+    files,
+    blockerIds,
+    harnessMode: issue.plan?.harnessMode ?? "standard",
+    checkpointPolicy: issue.plan?.executionContract?.checkpointPolicy ?? "final_only",
+    checkpointFailed: issue.checkpointStatus === "failed",
+    contractBlocked: Boolean(issue.contractNegotiationStatus && issue.contractNegotiationStatus !== "approved"),
+    contextResetCount: issue.contextResetCount ?? 0,
+    nearRetryBudget: (issue.maxAttempts ?? 0) > 0 ? Math.max(0, (issue.maxAttempts ?? 0) - (issue.attempts ?? 0)) <= 1 : false,
+    lastFailedPhase: (issue.lastFailedPhase ?? latest?.phase ?? "").trim().toLowerCase(),
+    policyDecisionKinds: new Set(
+      (issue.policyDecisions ?? []).map((decision) => decision.kind).filter((value) => typeof value === "string" && value.length > 0)
+    )
+  };
+}
+function parseTraceName(name) {
+  const match = name.match(TRACE_NAME_PATTERN);
+  if (!match) return null;
+  return {
+    planVersion: Number.parseInt(match[1] ?? "0", 10),
+    executeAttempt: Number.parseInt(match[2] ?? "0", 10)
+  };
+}
+function compareTraceNames(left, right) {
+  const leftParsed = parseTraceName(left);
+  const rightParsed = parseTraceName(right);
+  if (!leftParsed || !rightParsed) return right.localeCompare(left);
+  if (leftParsed.planVersion !== rightParsed.planVersion) {
+    return rightParsed.planVersion - leftParsed.planVersion;
+  }
+  return rightParsed.executeAttempt - leftParsed.executeAttempt;
+}
+function readChangedFiles(tracePath) {
+  const parsed = readJsonFile2(join4(tracePath, "changed-files.json"));
+  return Array.isArray(parsed) ? parsed.filter((value) => typeof value === "string" && value.length > 0) : [];
+}
+function contextResetBucket(count) {
+  if (count <= 0) return "none";
+  if (count === 1) return "low";
+  return "high";
+}
+function scoreCandidate(query, candidateText, changedFiles, blockerIds, rails) {
+  let score = 0;
+  const reasons = [];
+  if (query.errorType && candidateText.includes(query.errorType)) {
+    score += 5;
+    reasons.push(`shared error signal \`${query.errorType}\``);
+  }
+  const candidateTokens = tokenize(candidateText);
+  const sharedTokens = [...query.tokens].filter((token) => candidateTokens.has(token)).slice(0, 3);
+  if (sharedTokens.length > 0) {
+    score += sharedTokens.length;
+    reasons.push(`shared terms ${sharedTokens.map((token) => `\`${token}\``).join(", ")}`);
+  }
+  const overlappingFiles = changedFiles.filter((file) => query.files.has(file)).slice(0, 2);
+  if (overlappingFiles.length > 0) {
+    score += overlappingFiles.length * 3;
+    reasons.push(`shared files ${overlappingFiles.map((file) => `\`${file}\``).join(", ")}`);
+  }
+  const overlappingBlockers = blockerIds.filter((id) => query.blockerIds.has(id)).slice(0, 2);
+  if (overlappingBlockers.length > 0) {
+    score += overlappingBlockers.length * 4;
+    reasons.push(`shared review blockers ${overlappingBlockers.map((id) => `\`${id}\``).join(", ")}`);
+  }
+  const harnessMode = rails?.harness?.mode?.trim().toLowerCase() ?? "";
+  if (query.harnessMode && harnessMode === query.harnessMode) {
+    score += 2;
+    reasons.push(`same harness mode \`${query.harnessMode}\``);
+  }
+  const checkpointPolicy = rails?.harness?.checkpointPolicy?.trim().toLowerCase() ?? "";
+  if (query.checkpointPolicy && checkpointPolicy === query.checkpointPolicy) {
+    score += 2;
+    reasons.push(`same checkpoint policy \`${query.checkpointPolicy}\``);
+  }
+  const candidateContextResetCount = rails?.runtimeRails?.contextResetCount ?? 0;
+  if (query.contextResetCount > 0 && candidateContextResetCount > 0) {
+    score += contextResetBucket(candidateContextResetCount) === contextResetBucket(query.contextResetCount) ? 2 : 1;
+    reasons.push("similar context reset pressure");
+  }
+  const candidateRemaining = rails?.budget?.retryBudget?.remaining;
+  if (query.nearRetryBudget && typeof candidateRemaining === "number" && candidateRemaining <= 1) {
+    score += 2;
+    reasons.push("similar retry budget pressure");
+  }
+  const candidateLastFailedPhase = rails?.runtimeRails?.lastFailedPhase?.trim().toLowerCase() ?? "";
+  if (query.lastFailedPhase && candidateLastFailedPhase === query.lastFailedPhase) {
+    score += 1;
+    reasons.push(`same failed phase \`${query.lastFailedPhase}\``);
+  }
+  if (query.checkpointFailed && rails?.harness?.checkpointStatus === "failed") {
+    score += 2;
+    reasons.push("shared checkpoint failure state");
+  }
+  if (query.contractBlocked && rails?.harness?.contractNegotiationStatus && rails.harness.contractNegotiationStatus !== "approved") {
+    score += 2;
+    reasons.push("shared contract negotiation blocker");
+  }
+  const candidateDecisionKinds = new Set(
+    (rails?.policyDecisions ?? []).map((decision) => decision.kind).filter((value) => typeof value === "string" && value.length > 0)
+  );
+  const overlappingDecisionKinds = [...query.policyDecisionKinds].filter((kind) => candidateDecisionKinds.has(kind)).slice(0, 2);
+  if (overlappingDecisionKinds.length > 0) {
+    score += overlappingDecisionKinds.length;
+    reasons.push(`shared policy decisions ${overlappingDecisionKinds.map((kind) => `\`${kind}\``).join(", ")}`);
+  }
+  return { score, reasons };
+}
+function persistSimilarTraceSelection(traceDirectory, issue, hits) {
+  if (!existsSync5(traceDirectory) || hits.length === 0) return null;
+  const query = buildQuerySignal(issue);
+  const artifact = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    issue: {
+      id: issue.id,
+      identifier: issue.identifier,
+      planVersion: issue.planVersion ?? 1,
+      executeAttempt: issue.executeAttempt ?? 1
+    },
+    query: {
+      errorType: query.errorType,
+      files: [...query.files],
+      blockerIds: [...query.blockerIds],
+      harnessMode: query.harnessMode,
+      checkpointPolicy: query.checkpointPolicy,
+      checkpointFailed: query.checkpointFailed,
+      contractBlocked: query.contractBlocked,
+      contextResetCount: query.contextResetCount,
+      nearRetryBudget: query.nearRetryBudget,
+      lastFailedPhase: query.lastFailedPhase,
+      policyDecisionKinds: [...query.policyDecisionKinds]
+    },
+    hits
+  };
+  const fileName = "similar-traces.json";
+  try {
+    writeFileSync3(join4(traceDirectory, fileName), `${JSON.stringify(artifact, null, 2)}
+`, "utf8");
+    finalizeAttemptManifest(traceDirectory, {
+      files: {
+        similarTraces: fileName
+      }
+    });
+    return fileName;
+  } catch {
+    return null;
+  }
+}
+function extractLessonFromTrace(tracePath) {
+  const manifest = loadAttemptManifest(tracePath);
+  if (!manifest) return null;
+  const outcome = manifest.outcome ?? "unknown";
+  let handoffSummary = null;
+  try {
+    const handoffPath = join4(tracePath, "handoff.md");
+    if (existsSync5(handoffPath)) {
+      const raw = readFileSync3(handoffPath, "utf8");
+      handoffSummary = raw.length > 500 ? raw.slice(0, 500) + "..." : raw;
+    }
+  } catch {
+  }
+  const checkpoint = readJsonFile2(join4(tracePath, "checkpoint.json"));
+  const reviewBlockers = (checkpoint?.reviewBlockers ?? []).map((b) => b.id).filter((v) => typeof v === "string" && v.length > 0);
+  let whatWorked = null;
+  let whatFailed = null;
+  if (outcome === "success") {
+    const turnsDir = join4(tracePath, "turns");
+    try {
+      if (existsSync5(turnsDir)) {
+        const directives = readdirSync2(turnsDir).filter((f) => f.endsWith(".directive.json")).sort();
+        if (directives.length > 0) {
+          const last = readJsonFile2(join4(turnsDir, directives[directives.length - 1]));
+          whatWorked = last?.directiveSummary ?? last?.summary ?? null;
+        }
+      }
+    } catch {
+    }
+  } else {
+    whatFailed = manifest.error ?? null;
+    if (!whatFailed && checkpoint?.remainingWork?.length) {
+      whatFailed = `Remaining: ${checkpoint.remainingWork.slice(0, 3).join("; ")}`;
+    }
+  }
+  return { outcome, handoffSummary, reviewBlockers, whatWorked, whatFailed };
+}
+function findSimilarIssueTraces(issue, workspacePath, options = {}) {
+  const query = buildQuerySignal(issue);
+  if (!query.errorType && query.tokens.size === 0 && query.files.size === 0 && query.blockerIds.size === 0) {
+    return [];
+  }
+  const workspaceRoot = dirname(workspacePath);
+  let workspaces = [];
+  try {
+    workspaces = readdirSync2(workspaceRoot).map((name) => join4(workspaceRoot, name)).filter((path) => path !== workspacePath && existsSync5(join4(path, TRACE_DIR_NAME))).sort((left, right) => right.localeCompare(left)).slice(0, MAX_WORKSPACES);
+  } catch {
+    return [];
+  }
+  const hits = [];
+  for (const candidateWorkspace of workspaces) {
+    const tracesRoot = join4(candidateWorkspace, TRACE_DIR_NAME);
+    let traceNames = [];
+    try {
+      traceNames = readdirSync2(tracesRoot).filter((name) => TRACE_NAME_PATTERN.test(name)).sort(compareTraceNames).slice(0, MAX_ATTEMPTS_PER_WORKSPACE);
+    } catch {
+      continue;
+    }
+    for (const traceName of traceNames) {
+      const tracePath = join4(tracesRoot, traceName);
+      const manifest = loadAttemptManifest(tracePath);
+      if (!manifest || manifest.issueId === issue.id) continue;
+      const checkpoint = readJsonFile2(join4(tracePath, "checkpoint.json"));
+      const rails = readJsonFile2(join4(tracePath, "rails.json"));
+      const changedFiles = readChangedFiles(tracePath);
+      const blockerIds = (checkpoint?.reviewBlockers ?? []).map((entry) => entry.id).filter((value) => typeof value === "string" && value.length > 0);
+      const candidateText = [
+        manifest.error ?? "",
+        checkpoint?.lastTurn?.directiveSummary ?? "",
+        checkpoint?.lastTurn?.outputPreview ?? "",
+        ...checkpoint?.remainingWork ?? []
+      ].join(" ").toLowerCase();
+      const { score, reasons } = scoreCandidate(query, candidateText, changedFiles, blockerIds, rails);
+      if (score < MIN_SCORE) continue;
+      hits.push({
+        issueId: manifest.issueId,
+        issueIdentifier: manifest.issueIdentifier,
+        score,
+        reasons,
+        files: {
+          handoff: existsSync5(join4(tracePath, "handoff.md")) ? relative(workspacePath, join4(tracePath, "handoff.md")) : void 0,
+          checkpoint: existsSync5(join4(tracePath, "checkpoint.json")) ? relative(workspacePath, join4(tracePath, "checkpoint.json")) : void 0,
+          attempt: relative(workspacePath, join4(tracePath, "attempt.json")),
+          diffPatch: existsSync5(join4(tracePath, "diff.patch")) ? relative(workspacePath, join4(tracePath, "diff.patch")) : void 0
+        },
+        lesson: extractLessonFromTrace(tracePath)
+      });
+    }
+  }
+  return hits.sort((left, right) => {
+    if (left.score !== right.score) return right.score - left.score;
+    return left.issueIdentifier.localeCompare(right.issueIdentifier);
+  }).slice(0, options.maxResults ?? MAX_RESULTS);
+}
+
 // src/agents/prompt-builder.ts
-function buildRetryContext(issue) {
+function renderAttemptFull(s, index) {
+  const lines = [];
+  const phaseLabel = s.phase === "review" ? "review" : s.phase === "crash" ? "crash" : s.phase === "plan" ? "plan" : "execution";
+  lines.push(`### Attempt ${index + 1} \u2014 ${phaseLabel} failure (plan v${s.planVersion}, exec #${s.executeAttempt})`);
+  if (s.phase === "review") {
+    lines.push("*The reviewer identified issues with the previous implementation. Focus on addressing the reviewer's feedback \u2014 do not redo work that was already approved.*");
+  } else if (s.phase === "crash") {
+    lines.push("*The agent process crashed or timed out. Simplify the approach \u2014 break the work into smaller steps.*");
+  }
+  if (s.insight) {
+    lines.push(`**Failure type:** ${s.insight.errorType}`);
+    lines.push(`**Root cause:** ${s.insight.rootCause}`);
+    if (s.insight.failedCommand) lines.push(`**Failed command:** \`${s.insight.failedCommand}\``);
+    if (s.insight.filesInvolved.length > 0) {
+      lines.push(`**Files involved:** ${s.insight.filesInvolved.map((f) => `\`${f}\``).join(", ")}`);
+    }
+    lines.push(`**What to do differently:** ${s.insight.suggestion}`);
+  } else {
+    lines.push(`**Error:** ${s.error}`);
+  }
+  if (s.outputTail) {
+    lines.push(`
+<details><summary>Output tail</summary>
+
+\`\`\`
+${s.outputTail}
+\`\`\`
+</details>`);
+  }
+  if (s.outputFile) {
+    lines.push(`*Full output saved in: outputs/${s.outputFile}*`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function renderAttemptCompressed(s, index) {
+  const phaseLabel = s.phase === "review" ? "review" : s.phase === "crash" ? "crash" : s.phase === "plan" ? "plan" : "exec";
+  const errorType = s.insight?.errorType ?? "unknown";
+  const rootCause = s.insight?.rootCause ?? s.error?.slice(0, 120) ?? "no details";
+  const suggestion = s.insight?.suggestion ?? "";
+  return `- **Attempt ${index + 1}** (${phaseLabel}, v${s.planVersion}a${s.executeAttempt}): ${errorType} \u2014 ${rootCause}${suggestion ? ` \u2192 ${suggestion}` : ""}`;
+}
+var DEFAULT_RETRY_CONTEXT_MAX_CHARS = 1e4;
+var TRACE_REFERENCE_ATTEMPTS = 2;
+function computeRetryBudget(modelName) {
+  const ctxWindow = resolveContextWindow(modelName);
+  const totalChars = ctxWindow ? Math.min(6e4, Math.max(15e3, Math.round(ctxWindow * 0.04))) : DEFAULT_RETRY_CONTEXT_MAX_CHARS;
+  return {
+    totalChars,
+    traceContentChars: Math.round(totalChars * 0.5),
+    crossAttemptChars: Math.round(totalChars * 0.2),
+    similarIssueChars: Math.round(totalChars * 0.15),
+    gradingChars: Math.round(totalChars * 0.15)
+  };
+}
+function hasTraceArtifacts(issue, worktreePath) {
+  return (issue.previousAttemptSummaries ?? []).some(
+    (summary) => existsSync6(traceDir(worktreePath, summary.planVersion, summary.executeAttempt))
+  );
+}
+function renderTraceAttempt(worktreePath, summary, index, perAttemptBudget = 5e3) {
+  const tracePath = traceDir(worktreePath, summary.planVersion, summary.executeAttempt);
+  if (!existsSync6(tracePath)) {
+    return renderAttemptFull(summary, index);
+  }
+  const content = readTraceContent(tracePath, perAttemptBudget);
+  const lines = [renderAttemptFull(summary, index).trimEnd()];
+  if (content.handoffMarkdown) {
+    lines.push("\n**Handoff from previous attempt:**");
+    lines.push(content.handoffMarkdown.trim());
+  }
+  if (content.checkpointSummary) {
+    lines.push("\n**Checkpoint state:**");
+    lines.push(content.checkpointSummary.trim());
+  }
+  if (content.lastDirectiveSummary) {
+    lines.push("\n**Last agent directive:**");
+    lines.push(content.lastDirectiveSummary.trim());
+  }
+  if (content.diffPatch) {
+    lines.push("\n**Workspace changes (diff):**");
+    lines.push("```diff");
+    lines.push(content.diffPatch.trim());
+    lines.push("```");
+  }
+  if (content.truncated) {
+    const railsPath = relative2(worktreePath, join5(tracePath, "rails.json"));
+    const manifestPath = relative2(worktreePath, join5(tracePath, "attempt.json"));
+    lines.push(`
+*Additional trace artifacts (not inlined due to budget): \`${railsPath}\`, \`${manifestPath}\`*`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function renderCrossAttemptContext(issue, worktreePath) {
+  const currentTraceDir = traceDir(worktreePath, issue.planVersion ?? 1, issue.executeAttempt ?? 1);
+  const analysis = loadCrossAttemptAnalysis(currentTraceDir);
+  if (!analysis) return "";
+  const lines = [
+    "## Cross-Attempt Patterns\n",
+    ...analysis.summary.map((entry) => `- ${entry}`)
+  ];
+  if (analysis.hypotheses && analysis.hypotheses.length > 0) {
+    lines.push("\n### Causal Hypotheses\n");
+    for (const h of analysis.hypotheses) {
+      lines.push(`- **Signal:** ${h.signal}`);
+      lines.push(`  **Hypothesis:** ${h.hypothesis}`);
+      lines.push(`  **Try:** ${h.suggestion}`);
+    }
+  }
+  if (analysis.strategyPivot) {
+    lines.push(`
+### Strategy Pivot Required
+`);
+    lines.push(`**${analysis.strategyPivot.consecutiveRegressions} consecutive regressions.** ${analysis.strategyPivot.reason}.`);
+    lines.push(`**Action:** ${analysis.strategyPivot.suggestedApproach}`);
+  }
+  if (analysis.confounds && analysis.confounds.length > 0) {
+    lines.push(`
+### Likely Irrelevant Changes
+`);
+    for (const c of analysis.confounds) {
+      lines.push(`- ${c}`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function renderSimilarIssueTraceContext(_worktreePath, _currentTraceDir, hits) {
+  if (hits.length === 0) return "";
+  const lines = [
+    "## Similar Prior Failures Across Issues\n",
+    "These are lessons extracted from other issues with overlapping failure signals. Apply them only if the match is genuinely relevant.\n"
+  ];
+  for (const hit of hits) {
+    lines.push(`### ${hit.issueIdentifier} (score ${hit.score}): ${hit.reasons.join("; ")}`);
+    if (hit.lesson) {
+      lines.push(`**Outcome:** ${hit.lesson.outcome}`);
+      if (hit.lesson.whatFailed) {
+        lines.push(`**What failed:** ${hit.lesson.whatFailed}`);
+      }
+      if (hit.lesson.whatWorked) {
+        lines.push(`**What worked:** ${hit.lesson.whatWorked}`);
+      }
+      if (hit.lesson.reviewBlockers.length > 0) {
+        lines.push(`**Review blockers:** ${hit.lesson.reviewBlockers.join(", ")}`);
+      }
+      if (hit.lesson.handoffSummary) {
+        lines.push(`**Handoff excerpt:**`);
+        lines.push(hit.lesson.handoffSummary.trim());
+      }
+    } else {
+      if (hit.files.handoff) lines.push(`  - \`${hit.files.handoff}\``);
+      lines.push(`  - \`${hit.files.attempt}\``);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function buildRetryContext(issue, worktreePath, options = {}) {
   const summaries = issue.previousAttemptSummaries;
   const recurringFailureContext = buildRecurringFailureContext(issue);
   if ((!summaries || summaries.length === 0) && !recurringFailureContext) return "";
+  let variantParams = { inlineTraceContent: true, hypothesisGeneration: true, lessonExtraction: true, budgetMultiplier: 1 };
+  if (options.variantId) {
+    try {
+      const { getVariant } = (init_template_variants(), __toCommonJS(template_variants_exports));
+      const variant = getVariant(options.variantId);
+      if (variant?.parameters) {
+        variantParams = { ...variantParams, ...variant.parameters };
+      }
+    } catch {
+    }
+  }
+  const budget = options.budget ?? computeRetryBudget(options.modelName);
+  if (variantParams.budgetMultiplier !== 1) {
+    budget.totalChars = Math.round(budget.totalChars * variantParams.budgetMultiplier);
+    budget.traceContentChars = Math.round(budget.traceContentChars * variantParams.budgetMultiplier);
+    budget.crossAttemptChars = Math.round(budget.crossAttemptChars * variantParams.budgetMultiplier);
+    budget.similarIssueChars = Math.round(budget.similarIssueChars * variantParams.budgetMultiplier);
+    budget.gradingChars = Math.round(budget.gradingChars * variantParams.budgetMultiplier);
+  }
   const lines = [];
+  const maxChars = budget.totalChars;
+  const canUseTraces = variantParams.inlineTraceContent && Boolean(worktreePath && hasTraceArtifacts(issue, worktreePath));
+  const currentTraceDir = worktreePath ? traceDir(worktreePath, issue.planVersion ?? 1, issue.executeAttempt ?? 1) : "";
+  const crossAttemptContext = worktreePath && variantParams.hypothesisGeneration ? renderCrossAttemptContext(issue, worktreePath) : "";
+  const similarIssueTraceHits = worktreePath && variantParams.lessonExtraction ? findSimilarIssueTraces(issue, worktreePath, { maxResults: 2 }) : [];
+  if (worktreePath && currentTraceDir && similarIssueTraceHits.length > 0) {
+    persistSimilarTraceSelection(currentTraceDir, issue, similarIssueTraceHits);
+  }
+  const similarIssueTraceContext = worktreePath ? renderSimilarIssueTraceContext(worktreePath, currentTraceDir, similarIssueTraceHits) : "";
   if (summaries && summaries.length > 0) {
     lines.push("## Previous Attempts\n");
     lines.push("The following previous attempts FAILED. Do NOT repeat the same approach. Try a fundamentally different strategy.\n");
+    if (canUseTraces) {
+      lines.push("**This context includes inline trace content from prior attempts** \u2014 handoffs, diffs, and checkpoint data are embedded below. Use this evidence to understand exactly what was tried and why it failed.\n");
+    } else {
+      lines.push("**This context is self-contained** \u2014 all evidence you need is below. Do not assume prior knowledge. Read the specific errors, file paths, and suggestions carefully before starting.\n");
+    }
   }
-  for (let i = 0; i < (summaries?.length ?? 0); i++) {
-    const s = summaries[i];
-    const phaseLabel = s.phase === "review" ? "review" : s.phase === "crash" ? "crash" : s.phase === "plan" ? "plan" : "execution";
-    lines.push(`### Attempt ${i + 1} \u2014 ${phaseLabel} failure (plan v${s.planVersion}, exec #${s.executeAttempt})`);
-    if (s.phase === "review") {
-      lines.push("*The reviewer identified issues with the previous implementation. Focus on addressing the reviewer's feedback \u2014 do not redo work that was already approved.*");
-    } else if (s.phase === "crash") {
-      lines.push("*The agent process crashed or timed out. Simplify the approach \u2014 break the work into smaller steps.*");
-    }
-    if (s.insight) {
-      lines.push(`**Failure type:** ${s.insight.errorType}`);
-      lines.push(`**Root cause:** ${s.insight.rootCause}`);
-      if (s.insight.failedCommand) lines.push(`**Failed command:** \`${s.insight.failedCommand}\``);
-      if (s.insight.filesInvolved.length > 0) {
-        lines.push(`**Files involved:** ${s.insight.filesInvolved.map((f) => `\`${f}\``).join(", ")}`);
+  if (crossAttemptContext) {
+    lines.push(crossAttemptContext);
+  }
+  if (similarIssueTraceContext) {
+    lines.push(similarIssueTraceContext);
+  }
+  if (canUseTraces && summaries && summaries.length > 0) {
+    const recentAttempts = summaries.slice(-TRACE_REFERENCE_ATTEMPTS);
+    const perAttemptBudget = Math.floor(budget.traceContentChars / Math.max(1, recentAttempts.length));
+    lines.push("### Most Relevant Prior Attempts\n");
+    for (let i = 0; i < recentAttempts.length; i++) {
+      const absoluteIndex = summaries.length - recentAttempts.length + i;
+      lines.push(renderTraceAttempt(worktreePath, recentAttempts[i], absoluteIndex, perAttemptBudget));
+    }
+  } else if (summaries && summaries.length >= 5) {
+    const olderAttempts = summaries.slice(0, -2);
+    const recentAttempts = summaries.slice(-2);
+    const clusters = /* @__PURE__ */ new Map();
+    for (const s of olderAttempts) {
+      const key = s.insight?.errorType ?? "unknown";
+      if (!clusters.has(key)) clusters.set(key, []);
+      clusters.get(key).push(s);
+    }
+    lines.push(`### Failure Pattern Summary (${olderAttempts.length} earlier attempts)
+`);
+    lines.push("These error types have been encountered \u2014 avoid all of them:\n");
+    for (const [errorType, attempts] of clusters) {
+      const representative = attempts[attempts.length - 1];
+      const suggestion = representative.insight?.suggestion ?? "";
+      lines.push(`- **${errorType}** (${attempts.length}\xD7): ${representative.insight?.rootCause ?? representative.error?.slice(0, 120) ?? "unknown"}${suggestion ? ` \u2192 *${suggestion}*` : ""}`);
+      const allFiles = [...new Set(attempts.flatMap((a) => a.insight?.filesInvolved ?? []))];
+      if (allFiles.length > 0) {
+        lines.push(`  Files involved: ${allFiles.slice(0, 5).map((f) => `\`${f}\``).join(", ")}${allFiles.length > 5 ? ` (+${allFiles.length - 5} more)` : ""}`);
       }
-      lines.push(`**What to do differently:** ${s.insight.suggestion}`);
-    } else {
-      lines.push(`**Error:** ${s.error}`);
     }
-    if (s.outputTail) {
-      lines.push(`
-<details><summary>Output tail</summary>
-
-\`\`\`
-${s.outputTail}
-\`\`\`
-</details>`);
+    lines.push("");
+    lines.push("### Recent Attempts (detailed)\n");
+    for (let i = 0; i < recentAttempts.length; i++) {
+      lines.push(renderAttemptFull(recentAttempts[i], olderAttempts.length + i));
     }
-    if (s.outputFile) {
-      lines.push(`*Full output saved in: outputs/${s.outputFile}*`);
+  } else if (summaries && summaries.length >= 3) {
+    const olderAttempts = summaries.slice(0, -2);
+    const recentAttempts = summaries.slice(-2);
+    lines.push(`### Earlier Attempts (compressed, ${olderAttempts.length} total)
+`);
+    for (let i = 0; i < olderAttempts.length; i++) {
+      lines.push(renderAttemptCompressed(olderAttempts[i], i));
     }
     lines.push("");
+    lines.push("### Recent Attempts (detailed)\n");
+    for (let i = 0; i < recentAttempts.length; i++) {
+      lines.push(renderAttemptFull(recentAttempts[i], olderAttempts.length + i));
+    }
+  } else {
+    for (let i = 0; i < (summaries?.length ?? 0); i++) {
+      lines.push(renderAttemptFull(summaries[i], i));
+    }
   }
   if (issue.lastFailedPhase === "review" && issue.gradingReport) {
     const failedCriteria = issue.gradingReport.criteria.filter(
@@ -994,18 +1774,45 @@ ${s.outputTail}
     );
     if (failedCriteria.length > 0) {
       lines.push("## Previous Review Grade: FAIL\n");
-      lines.push("The automated reviewer graded your last submission and found these specific failures:");
+      lines.push("The automated reviewer graded your last submission and found these **specific failures with concrete evidence**. Each item below tells you exactly what was wrong and where. Fix the root cause for each \u2014 don't just make the symptom go away:");
       for (const c of failedCriteria) {
-        lines.push(`- **${c.id}** [${c.category}] FAILED: ${c.description} \u2014 ${c.evidence}`);
+        lines.push(`- **${c.id}** [${c.category}] FAILED: ${c.description}`);
+        lines.push(`  Evidence: ${c.evidence}`);
       }
-      lines.push("\nYou MUST address ALL of these before submitting. The reviewer will check each one again.\n");
+      lines.push("\nYou MUST address ALL of these before submitting. The reviewer will check each one again with the same criteria.\n");
     }
   }
   if (recurringFailureContext) {
     lines.push(recurringFailureContext);
   }
   const full = lines.join("\n");
-  return full.length > 8e3 ? full.slice(0, 8e3) + "\n[...truncated]" : full;
+  const text = full.length > maxChars ? full.slice(0, maxChars) + "\n[...truncated]" : full;
+  const analysis = worktreePath ? loadCrossAttemptAnalysis(traceDir(worktreePath, issue.planVersion ?? 1, issue.executeAttempt ?? 1)) : null;
+  const metrics = {
+    retryContextChars: text.length,
+    traceContentChars: canUseTraces ? Math.min(text.length, budget.traceContentChars) : 0,
+    crossAttemptChars: crossAttemptContext.length,
+    similarIssueChars: similarIssueTraceContext.length,
+    gradingChars: text.length - crossAttemptContext.length - similarIssueTraceContext.length,
+    budgetTotalChars: budget.totalChars,
+    budgetUtilizationPct: budget.totalChars > 0 ? Math.round(text.length / budget.totalChars * 100) : 0,
+    modelName: options.modelName ?? null
+  };
+  buildRetryContext.lastMetrics = metrics;
+  buildRetryContext.lastAnalysis = analysis;
+  return text;
+}
+function getLastRetryContextMetrics() {
+  const metrics = buildRetryContext.lastMetrics;
+  const analysis = buildRetryContext.lastAnalysis;
+  if (!metrics) return null;
+  return {
+    metrics,
+    hypothesesGenerated: analysis?.hypotheses?.length ?? 0,
+    strategyPivotTriggered: Boolean(analysis?.strategyPivot),
+    similarIssuesUsed: 0
+    // populated by caller if needed
+  };
 }
 async function buildPrompt(issue, _workflowDefinition) {
   const rendered = await renderPrompt("workflow-default", { issue, attempt: issue.attempts || 0 });
@@ -1091,14 +1898,15 @@ async function buildProviderBasePrompt(provider, issue, basePrompt, workspacePat
 }
 
 // src/agents/memory-engine.ts
+init_helpers();
 import {
-  existsSync as existsSync4,
+  existsSync as existsSync7,
   mkdirSync as mkdirSync2,
-  readdirSync,
-  readFileSync as readFileSync2,
-  writeFileSync as writeFileSync2
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync4,
+  writeFileSync as writeFileSync4
 } from "fs";
-import { join as join3 } from "path";
+import { join as join6 } from "path";
 var MEMORY_DIRNAME = "memory";
 var WORKFLOW_FILE = "WORKFLOW.md";
 var MEMORY_FILE = "MEMORY.md";
@@ -1107,19 +1915,19 @@ function resolveTodayDate(value = now()) {
   return value.slice(0, 10);
 }
 function resolvePaths(workspacePath, date = resolveTodayDate()) {
-  const memoryDir = join3(workspacePath, MEMORY_DIRNAME);
+  const memoryDir = join6(workspacePath, MEMORY_DIRNAME);
   return {
     root: workspacePath,
     memoryDir,
-    workflowFile: join3(workspacePath, WORKFLOW_FILE),
-    memoryFile: join3(workspacePath, MEMORY_FILE),
-    heartbeatFile: join3(workspacePath, HEARTBEAT_FILE),
-    dailyFile: join3(memoryDir, `${date}.md`)
+    workflowFile: join6(workspacePath, WORKFLOW_FILE),
+    memoryFile: join6(workspacePath, MEMORY_FILE),
+    heartbeatFile: join6(workspacePath, HEARTBEAT_FILE),
+    dailyFile: join6(memoryDir, `${date}.md`)
   };
 }
 function readText(filePath) {
   try {
-    return existsSync4(filePath) ? readFileSync2(filePath, "utf8") : "";
+    return existsSync7(filePath) ? readFileSync4(filePath, "utf8") : "";
   } catch {
     return "";
   }
@@ -1127,12 +1935,12 @@ function readText(filePath) {
 function writeIfChanged(filePath, next) {
   const current = readText(filePath);
   if (current === next) return false;
-  writeFileSync2(filePath, next, "utf8");
+  writeFileSync4(filePath, next, "utf8");
   return true;
 }
 function ensureFile(filePath, initial) {
-  if (existsSync4(filePath)) return false;
-  writeFileSync2(filePath, initial, "utf8");
+  if (existsSync7(filePath)) return false;
+  writeFileSync4(filePath, initial, "utf8");
   return true;
 }
 function renderWorkflowDocument(issue) {
@@ -1316,12 +2124,12 @@ function appendUniqueEntry(filePath, entry) {
   const current = readText(filePath);
   if (current.includes(marker)) return false;
   const prefix = current && !current.endsWith("\n") ? "\n\n" : current ? "\n" : "";
-  writeFileSync2(filePath, `${current}${prefix}${renderEntry(entry)}`, "utf8");
+  writeFileSync4(filePath, `${current}${prefix}${renderEntry(entry)}`, "utf8");
   return true;
 }
 function listRecentDailyFiles(memoryDir) {
-  if (!existsSync4(memoryDir)) return [];
-  return readdirSync(memoryDir).filter((entry) => entry.endsWith(".md")).sort((left, right) => right.localeCompare(left)).slice(0, 3).map((entry) => join3(memoryDir, entry));
+  if (!existsSync7(memoryDir)) return [];
+  return readdirSync4(memoryDir).filter((entry) => entry.endsWith(".md")).sort((left, right) => right.localeCompare(left)).slice(0, 3).map((entry) => join6(memoryDir, entry));
 }
 function ensureWorkspaceMemoryFiles(issue, workspacePath) {
   const paths = resolvePaths(workspacePath);
@@ -1342,8 +2150,8 @@ function flushWorkspaceMemory(issue, workspacePath, reason) {
   let promotedEntries = 0;
   if (writeIfChanged(paths.workflowFile, renderWorkflowDocument(issue))) changedFiles.push(paths.workflowFile);
   if (writeIfChanged(paths.heartbeatFile, renderHeartbeatDocument(issue))) changedFiles.push(paths.heartbeatFile);
-  if (!existsSync4(paths.memoryFile)) {
-    writeFileSync2(paths.memoryFile, renderMemoryHeader(issue), "utf8");
+  if (!existsSync7(paths.memoryFile)) {
+    writeFileSync4(paths.memoryFile, renderMemoryHeader(issue), "utf8");
     changedFiles.push(paths.memoryFile);
   }
   for (const entry of buildDurableEntries(issue)) {
@@ -1443,11 +2251,11 @@ function shouldSkipPath(relativePath) {
   return false;
 }
 function bootstrapSource() {
-  if (existsSync5(SOURCE_MARKER)) return;
+  if (existsSync8(SOURCE_MARKER)) return;
   logger.info("Creating local source snapshot for Fifony (local-only runtime)...");
   const copyRecursive = (source, target, rel = "") => {
     mkdirSync3(target, { recursive: true });
-    const items = readdirSync2(source, { withFileTypes: true });
+    const items = readdirSync5(source, { withFileTypes: true });
     for (const item of items) {
       const nextRel = rel ? `${rel}/${item.name}` : item.name;
       if (shouldSkipPath(nextRel)) continue;
@@ -1461,8 +2269,8 @@ function bootstrapSource() {
       if (item.isSymbolicLink() || itemStat.isSymbolicLink()) continue;
       if (itemStat.isFile() || itemStat.isFIFO()) {
         try {
-          const file = readFileSync3(sourcePath);
-          writeFileSync3(targetPath, file);
+          const file = readFileSync5(sourcePath);
+          writeFileSync5(targetPath, file);
         } catch (error) {
           if (error.code === "ENOENT") {
             logger.debug(`Skipped missing source file: ${sourcePath}`);
@@ -1475,7 +2283,7 @@ function bootstrapSource() {
   };
   mkdirSync3(SOURCE_ROOT, { recursive: true });
   copyRecursive(TARGET_ROOT, SOURCE_ROOT);
-  writeFileSync3(SOURCE_MARKER, `${now()}
+  writeFileSync5(SOURCE_MARKER, `${now()}
 `, "utf8");
 }
 var sourceReadyPromise = null;
@@ -1488,7 +2296,7 @@ async function ensureSourceReady(onProgress) {
     onProgress?.("ready");
     return;
   }
-  if (existsSync5(SOURCE_MARKER)) {
+  if (existsSync8(SOURCE_MARKER)) {
     onProgress?.("ready");
     return;
   }
@@ -1628,9 +2436,9 @@ var CLI_CONFIG_DIRS = [".claude", ".codex", ".gemini"];
 var CLI_CONFIG_FILES = ["CLAUDE.md"];
 function copyCliConfigDirs(sourceRoot, worktreePath) {
   for (const dir of CLI_CONFIG_DIRS) {
-    const src = join4(sourceRoot, dir);
-    const dst = join4(worktreePath, dir);
-    if (existsSync5(src) && statSync(src).isDirectory() && !existsSync5(dst)) {
+    const src = join7(sourceRoot, dir);
+    const dst = join7(worktreePath, dir);
+    if (existsSync8(src) && statSync(src).isDirectory() && !existsSync8(dst)) {
       try {
         execSync2(`cp -R "${src}" "${dst}"`, { stdio: "pipe", timeout: 1e4 });
         logger.debug({ dir, worktreePath }, "[Workspace] Copied CLI config dir to worktree");
@@ -1640,9 +2448,9 @@ function copyCliConfigDirs(sourceRoot, worktreePath) {
     }
   }
   for (const file of CLI_CONFIG_FILES) {
-    const src = join4(sourceRoot, file);
-    const dst = join4(worktreePath, file);
-    if (existsSync5(src) && !existsSync5(dst)) {
+    const src = join7(sourceRoot, file);
+    const dst = join7(worktreePath, file);
+    if (existsSync8(src) && !existsSync8(dst)) {
       try {
         execSync2(`cp "${src}" "${dst}"`, { stdio: "pipe", timeout: 5e3 });
         logger.debug({ file, worktreePath }, "[Workspace] Copied CLI config file to worktree");
@@ -1661,16 +2469,16 @@ function isGitWorkingTree(dir) {
   }
 }
 function resolveTestWorkspacePath(issue) {
-  const workspaceRoot = issue.workspacePath ?? join4(WORKSPACE_ROOT, idToSafePath(issue.id));
-  return join4(workspaceRoot, "test-worktree");
+  const workspaceRoot = issue.workspacePath ?? join7(WORKSPACE_ROOT, idToSafePath(issue.id));
+  return join7(workspaceRoot, "test-worktree");
 }
 function createTestWorkspace(issue) {
   ensureGitRepoReadyForWorktrees(TARGET_ROOT, "create isolated test workspaces");
   assertIssueHasGitWorktree(issue, "create a test workspace");
-  const workspaceRoot = issue.workspacePath ?? join4(WORKSPACE_ROOT, idToSafePath(issue.id));
+  const workspaceRoot = issue.workspacePath ?? join7(WORKSPACE_ROOT, idToSafePath(issue.id));
   const testWorkspacePath = issue.testWorkspacePath ?? resolveTestWorkspacePath(issue);
   mkdirSync3(workspaceRoot, { recursive: true });
-  if (existsSync5(testWorkspacePath)) {
+  if (existsSync8(testWorkspacePath)) {
     if (isGitWorkingTree(testWorkspacePath)) {
       issue.testWorkspacePath = testWorkspacePath;
       issue.testApplied = true;
@@ -1727,7 +2535,7 @@ async function createGitWorktree(issue, worktreePath, baseBranch) {
     execSync2("git worktree prune", { cwd: TARGET_ROOT, stdio: "pipe" });
   } catch {
   }
-  if (existsSync5(worktreePath)) {
+  if (existsSync8(worktreePath)) {
     try {
       execSync2(`git worktree remove --force "${worktreePath}"`, { cwd: TARGET_ROOT, stdio: "pipe" });
     } catch {
@@ -1763,11 +2571,11 @@ async function createGitWorktree(issue, worktreePath, baseBranch) {
     stdio: "pipe"
   });
   try {
-    const gitFileContent = readFileSync3(join4(worktreePath, ".git"), "utf8").trim();
+    const gitFileContent = readFileSync5(join7(worktreePath, ".git"), "utf8").trim();
     const gitDirRel = gitFileContent.replace("gitdir: ", "").trim();
     const gitDirPath = resolve(worktreePath, gitDirRel);
-    mkdirSync3(join4(gitDirPath, "info"), { recursive: true });
-    writeFileSync3(join4(gitDirPath, "info", "exclude"), "fifony-*\n.fifony-*\nfifony_*\n", "utf8");
+    mkdirSync3(join7(gitDirPath, "info"), { recursive: true });
+    writeFileSync5(join7(gitDirPath, "info", "exclude"), "fifony-*\n.fifony-*\nfifony_*\n", "utf8");
   } catch (err) {
     logger.warn({ err: String(err) }, "[Agent] Failed to write worktree excludes");
   }
@@ -1780,9 +2588,9 @@ async function createGitWorktree(issue, worktreePath, baseBranch) {
 }
 async function prepareWorkspace(issue, state, defaultBranch) {
   const safeId = idToSafePath(issue.id);
-  const workspaceRoot = join4(WORKSPACE_ROOT, safeId);
-  const worktreePath = join4(workspaceRoot, "worktree");
-  const createdNow = !existsSync5(worktreePath);
+  const workspaceRoot = join7(WORKSPACE_ROOT, safeId);
+  const worktreePath = join7(workspaceRoot, "worktree");
+  const createdNow = !existsSync8(worktreePath);
   if (createdNow) {
     mkdirSync3(workspaceRoot, { recursive: true });
     logger.debug({ issueId: issue.id, identifier: issue.identifier, workspacePath: workspaceRoot }, "[Agent] Creating workspace");
@@ -1797,9 +2605,9 @@ async function prepareWorkspace(issue, state, defaultBranch) {
   } else {
     logger.debug({ issueId: issue.id, workspacePath: workspaceRoot }, "[Agent] Reusing existing workspace");
   }
-  const metaPath = join4(workspaceRoot, "issue.json");
+  const metaPath = join7(workspaceRoot, "issue.json");
   const promptText = await buildPrompt(issue, null);
-  const promptFile = join4(workspaceRoot, "prompt.md");
+  const promptFile = join7(workspaceRoot, "prompt.md");
   ensureWorkspaceMemoryFiles(issue, workspaceRoot);
   if (createdNow) {
     recordWorkspaceMemoryEvent(issue, workspaceRoot, {
@@ -1816,8 +2624,8 @@ async function prepareWorkspace(issue, state, defaultBranch) {
       tags: ["workspace", "bootstrap"]
     });
   }
-  writeFileSync3(metaPath, JSON.stringify({ ...issue, runtimeSource: SOURCE_ROOT, bootstrapAt: now() }, null, 2), "utf8");
-  writeFileSync3(promptFile, `${promptText}
+  writeFileSync5(metaPath, JSON.stringify({ ...issue, runtimeSource: SOURCE_ROOT, bootstrapAt: now() }, null, 2), "utf8");
+  writeFileSync5(promptFile, `${promptText}
 `, "utf8");
   issue.workspacePath = workspaceRoot;
   issue.worktreePath = worktreePath;
@@ -1826,8 +2634,8 @@ async function prepareWorkspace(issue, state, defaultBranch) {
 }
 async function cleanWorkspace(issueId, issue, state) {
   const safeId = idToSafePath(issueId);
-  const workspacePath = issue?.workspacePath ?? join4(WORKSPACE_ROOT, safeId);
-  if (!existsSync5(workspacePath)) return;
+  const workspacePath = issue?.workspacePath ?? join7(WORKSPACE_ROOT, safeId);
+  if (!existsSync8(workspacePath)) return;
   if (state.config.beforeRemoveHook) {
     try {
       const dummyIssue = issue ?? { id: issueId, identifier: issueId };
@@ -1913,7 +2721,7 @@ function parseDiffStats(issue, raw) {
 }
 async function syncIssueDiffStatsToStore(issue) {
   if (!issue?.id) return;
-  const { getIssueStateResource } = await import("./store-S3NAYZ3S.js");
+  const { getIssueStateResource } = await import("./store-P3ACO6YA.js");
   const issueResource = getIssueStateResource();
   if (!issueResource) return;
   const toNumber = (value) => {
@@ -2152,11 +2960,11 @@ function hydrateIssuePathsFromWorkspace(issue) {
   return inferredPaths;
 }
 function writeVersionedArtifacts(workspacePath, prefix, planVersion, attempt, sources) {
-  const { writeFileSync: _wfs, readFileSync: _rfs, existsSync: _es } = { writeFileSync: writeFileSync3, readFileSync: readFileSync3, existsSync: existsSync5 };
+  const { writeFileSync: _wfs, readFileSync: _rfs, existsSync: _es } = { writeFileSync: writeFileSync5, readFileSync: readFileSync5, existsSync: existsSync8 };
   for (const { srcFile, destSuffix } of sources) {
-    const src = join4(workspacePath, srcFile);
+    const src = join7(workspacePath, srcFile);
     if (_es(src)) {
-      _wfs(join4(workspacePath, `${prefix}.v${planVersion}a${attempt}.${destSuffix}`), _rfs(src, "utf8"), "utf8");
+      _wfs(join7(workspacePath, `${prefix}.v${planVersion}a${attempt}.${destSuffix}`), _rfs(src, "utf8"), "utf8");
     }
   }
 }
@@ -2170,7 +2978,10 @@ export {
   runHook,
   recordReviewFailures,
   findRecurringBlockingFailures,
+  persistCrossAttemptAnalysis,
+  computeCrossAttemptAnalysis,
   buildRetryContext,
+  getLastRetryContextMetrics,
   buildPrompt,
   resolveContextWindow,
   buildTurnPrompt,
@@ -2202,4 +3013,4 @@ export {
   hydrateIssuePathsFromWorkspace,
   writeVersionedArtifacts
 };
-//# sourceMappingURL=chunk-QH6VCTET.js.map
+//# sourceMappingURL=chunk-RCSJFMQG.js.map