fifony 0.1.42 → 0.1.43

package/dist/chunk-SOBLO4YZ.js

@@ -0,0 +1,2016 @@
+import {
+  markIssueDirty,
+  normalizeAgentProvider
+} from "./chunk-FJNH3G2Z.js";
+import {
+  logger
+} from "./chunk-DVU3CXWA.js";
+import {
+  renderPrompt
+} from "./chunk-ESWHDHH6.js";
+import {
+  SOURCE_MARKER,
+  SOURCE_ROOT,
+  TARGET_ROOT,
+  WORKSPACE_ROOT,
+  appendFileTail,
+  idToSafePath,
+  now
+} from "./chunk-42AMQAJG.js";
+
+// src/domains/workspace.ts
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync3,
+  rmSync as rmSync2,
+  statSync,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { copyFile, mkdir, readdir, stat, writeFile } from "fs/promises";
+import { extname, join as join3, resolve } from "path";
+import { execSync } from "child_process";
+
+// src/agents/command-executor.ts
+import {
+  appendFileSync,
+  existsSync as existsSync2,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { join } from "path";
+import { env, execPath } from "process";
+import { spawn } from "child_process";
+import { createConnection } from "net";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+
+// src/agents/docker-runner.ts
+import { existsSync } from "fs";
+import { homedir, userInfo } from "os";
+var CONTAINER_WORKSPACE = "/workspace";
+var CONTAINER_PLANNING = "/planning";
+function translatePaths(value, workspacePath) {
+  return value.replaceAll(workspacePath, CONTAINER_WORKSPACE);
+}
+function authMounts(home) {
+  const mounts = [];
+  for (const dir of [".claude", ".codex", ".gemini"]) {
+    const p = `${home}/${dir}`;
+    if (existsSync(p)) mounts.push(`-v "${p}:${home}/${dir}:ro,z"`);
+  }
+  const gitconfig = `${home}/.gitconfig`;
+  if (existsSync(gitconfig)) mounts.push(`-v "${gitconfig}:${home}/.gitconfig:ro"`);
+  const sshDir = `${home}/.ssh`;
+  if (existsSync(sshDir)) mounts.push(`-v "${sshDir}:${home}/.ssh:ro"`);
+  return mounts;
+}
+function buildDockerRunCommand(innerCommand, workspacePath, worktreePath, targetRoot, image) {
+  const home = homedir();
+  const ui = userInfo();
+  const cwd = worktreePath ? `${CONTAINER_WORKSPACE}/worktree` : CONTAINER_WORKSPACE;
+  const mounts = [
+    `-v "${workspacePath}:${CONTAINER_WORKSPACE}:z"`,
+    `-v "${targetRoot}/.git:${targetRoot}/.git:z"`,
+    ...authMounts(home)
+  ];
+  const escapedInner = innerCommand.replace(/'/g, "'\\''");
+  return [
+    "docker run --rm --init",
+    `--user ${ui.uid}:${ui.gid}`,
+    "--network host",
+    "--cap-drop ALL",
+    "--security-opt no-new-privileges",
+    ...mounts,
+    `-w "${cwd}"`,
+    image,
+    "sh",
+    "-c",
+    `'. ${CONTAINER_WORKSPACE}/.env.sh && ${escapedInner}'`
+  ].join(" ");
+}
+function buildDockerPlanCommand(innerCommand, tempDir, image) {
+  const home = homedir();
+  const ui = userInfo();
+  const translatedCommand = innerCommand.replaceAll(tempDir, CONTAINER_PLANNING);
+  const escapedInner = translatedCommand.replace(/'/g, "'\\''");
+  const mounts = [
+    `-v "${tempDir}:${CONTAINER_PLANNING}:z"`,
+    ...authMounts(home)
+  ];
+  return [
+    "docker run --rm --init",
+    `--user ${ui.uid}:${ui.gid}`,
+    "--network host",
+    "--cap-drop ALL",
+    "--security-opt no-new-privileges",
+    ...mounts,
+    `-w "${CONTAINER_PLANNING}"`,
+    image,
+    "sh",
+    "-c",
+    `'. ${CONTAINER_PLANNING}/.env.sh && ${escapedInner}'`
+  ].join(" ");
+}
+
+// src/agents/command-executor.ts
+function resolveDaemonScript() {
+  const pkgRoot = process.env.FIFONY_PKG_ROOT;
+  if (!pkgRoot) return null;
+  const compiled = join(pkgRoot, "dist", "agent", "pty-daemon.js");
+  if (existsSync2(compiled)) {
+    return { command: execPath, args: [compiled] };
+  }
+  const source = join(pkgRoot, "src", "agents", "pty-daemon.ts");
+  if (existsSync2(source)) {
+    try {
+      const require2 = createRequire(fileURLToPath(import.meta.url));
+      const tsxCli = require2.resolve("tsx/cli");
+      return { command: execPath, args: [tsxCli, source] };
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+var DAEMON_SCRIPT = resolveDaemonScript();
+var HOOK_RUNTIME_CONFIG = {
+  pollIntervalMs: 0,
+  workerConcurrency: 1,
+  maxConcurrentByState: {},
+  commandTimeoutMs: 18e5,
+  maxAttemptsDefault: 1,
+  maxTurns: 1,
+  retryDelayMs: 0,
+  staleInProgressTimeoutMs: 0,
+  logLinesTail: 12e3,
+  maxPreviousOutputChars: 12e3,
+  agentProvider: "codex",
+  agentCommand: "",
+  defaultEffort: { default: "medium" },
+  runMode: "filesystem",
+  autoReviewApproval: true,
+  dockerExecution: false,
+  dockerImage: "fifony-agent:latest",
+  afterCreateHook: "",
+  beforeRunHook: "",
+  afterRunHook: "",
+  beforeRemoveHook: ""
+};
+async function waitForSocket(socketPath, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (existsSync2(socketPath)) return true;
+    await new Promise((r) => setTimeout(r, 50));
+  }
+  return false;
+}
+async function runCommandWithTimeout(command, workspacePath, issue, config, promptFile, extraEnv = {}, outputFile) {
+  const started = Date.now();
+  const resultFile = extraEnv.FIFONY_RESULT_FILE;
+  const allVars = {
+    FIFONY_ISSUE_ID: issue.id,
+    FIFONY_ISSUE_IDENTIFIER: issue.identifier,
+    FIFONY_ISSUE_TITLE: issue.title,
+    FIFONY_WORKSPACE_PATH: issue.worktreePath ?? workspacePath,
+    FIFONY_PROMPT_FILE: promptFile
+  };
+  for (const [key, value] of Object.entries(extraEnv)) {
+    if (value.length > 4e3) {
+      const valFile = join(workspacePath, `${key.toLowerCase()}.txt`);
+      writeFileSync(valFile, value, "utf8");
+      allVars[`${key}_FILE`] = valFile;
+    } else {
+      allVars[key] = value;
+    }
+  }
+  if (config.dockerExecution) {
+    for (const key of Object.keys(allVars)) {
+      allVars[key] = translatePaths(allVars[key], workspacePath);
+    }
+  }
+  const envFilePath = join(workspacePath, ".env.sh");
+  const envFileLines = Object.entries(allVars).map(([k, v]) => `export ${k}='${String(v).replace(/'/g, "'\\''")}'`).join("\n");
+  writeFileSync(envFilePath, envFileLines, "utf8");
+  let effectiveCommand;
+  if (config.dockerExecution && config.dockerImage) {
+    const translatedCmd = translatePaths(command, workspacePath);
+    effectiveCommand = buildDockerRunCommand(
+      translatedCmd,
+      workspacePath,
+      issue.worktreePath,
+      TARGET_ROOT,
+      config.dockerImage
+    );
+  } else {
+    effectiveCommand = `. "${envFilePath}" && ${command}`;
+  }
+  const liveLogFile = join(workspacePath, "live-output.log");
+  if (outputFile) {
+    try {
+      const header = `# fifony stdout capture
+# turn: ${extraEnv.FIFONY_TURN_INDEX ?? "?"}
+# provider: ${extraEnv.FIFONY_AGENT_PROVIDER ?? "?"}
+# role: ${extraEnv.FIFONY_AGENT_ROLE ?? "?"}
+# timestamp: ${(/* @__PURE__ */ new Date()).toISOString()}
+---
+`;
+      writeFileSync(outputFile, header, "utf8");
+    } catch {
+    }
+  }
+  if (!config.dockerExecution && DAEMON_SCRIPT) {
+    const socketPath = join(workspacePath, "agent.sock");
+    if (existsSync2(socketPath)) {
+      const { isDaemonAlive } = await import("./pid-manager-UBWXVSMD.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);
+      }
+      try {
+        rmSync(socketPath, { force: true });
+      } catch {
+      }
+    }
+    if (resultFile && extraEnv.FIFONY_PRESERVE_RESULT_FILE !== "1") {
+      rmSync(resultFile, { force: true });
+    }
+    writeFileSync(liveLogFile, "", "utf8");
+    const daemonArgs = JSON.stringify({
+      command: effectiveCommand,
+      workspacePath,
+      issueId: issue.id,
+      startedAt: new Date(started).toISOString(),
+      commandSlice: command.slice(0, 200)
+    });
+    const daemonProcess = spawn(DAEMON_SCRIPT.command, [...DAEMON_SCRIPT.args, daemonArgs], {
+      detached: true,
+      stdio: "ignore",
+      cwd: workspacePath
+    });
+    daemonProcess.unref();
+    logger.debug({ issueId: issue.id, daemonPid: daemonProcess.pid, command: command.slice(0, 120), cwd: workspacePath }, "[Agent] PTY daemon spawned");
+    const socketReady = await waitForSocket(socketPath, 1e4);
+    if (!socketReady) {
+      logger.warn({ issueId: issue.id }, "[Agent] PTY daemon socket not ready \u2014 falling back to inline PTY");
+    } else {
+      return attachToDaemon(socketPath, workspacePath, issue, config, started, outputFile, resultFile);
+    }
+  }
+  if (!config.dockerExecution) {
+    let nodePty = null;
+    try {
+      const mod = await import("node-pty");
+      if (typeof mod.spawn === "function") nodePty = mod;
+    } catch {
+    }
+    if (nodePty) {
+      if (resultFile && extraEnv.FIFONY_PRESERVE_RESULT_FILE !== "1") {
+        rmSync(resultFile, { force: true });
+      }
+      writeFileSync(liveLogFile, "", "utf8");
+      return new Promise((resolve2) => {
+        const ptyProcess = nodePty.spawn("sh", ["-c", effectiveCommand], {
+          name: "xterm-256color",
+          cols: 220,
+          rows: 50,
+          cwd: workspacePath,
+          env: process.env
+        });
+        const pid = ptyProcess.pid;
+        const pidFile = join(workspacePath, "agent.pid");
+        if (pid) {
+          logger.debug({ issueId: issue.id, pid, command: command.slice(0, 120), cwd: workspacePath }, "[Agent] Process spawned (PTY)");
+          writeFileSync(pidFile, JSON.stringify({
+            pid,
+            issueId: issue.id,
+            startedAt: new Date(started).toISOString(),
+            command: command.slice(0, 200)
+          }), "utf8");
+        }
+        let output = "";
+        let timedOut = false;
+        let outputBytes = 0;
+        let outputHeader = "";
+        const onChunk = (chunk) => {
+          const text = String(chunk);
+          if (outputHeader.length < 2e3) outputHeader = (outputHeader + text).slice(0, 2e3);
+          output = appendFileTail(output, text, config.logLinesTail);
+          outputBytes += text.length;
+          try {
+            appendFileSync(liveLogFile, text);
+          } catch {
+          }
+          if (outputFile) {
+            try {
+              appendFileSync(outputFile, text);
+            } catch {
+            }
+          }
+          issue.commandOutputTail = output;
+        };
+        ptyProcess.onData(onChunk);
+        const AGENT_STALE_OUTPUT_MS = 18e5;
+        const killPty = () => {
+          try {
+            ptyProcess.kill();
+          } catch {
+          }
+        };
+        const timer = setTimeout(() => {
+          timedOut = true;
+          killPty();
+        }, config.commandTimeoutMs);
+        let lastWatchdogBytes = 0;
+        let lastOutputGrowthAt = Date.now();
+        let watchdogKilled = false;
+        const watchdog = setInterval(() => {
+          if (pid) {
+            try {
+              process.kill(pid, 0);
+            } catch {
+              clearInterval(watchdog);
+              clearTimeout(timer);
+              watchdogKilled = true;
+              try {
+                rmSync(pidFile, { force: true });
+              } catch {
+              }
+              resolve2({ success: false, code: null, output: appendFileTail(output, `
+Agent process died unexpectedly (PID ${pid}).`, config.logLinesTail) });
+              return;
+            }
+          }
+          if (outputBytes > lastWatchdogBytes) {
+            lastWatchdogBytes = outputBytes;
+            lastOutputGrowthAt = Date.now();
+          } else if (Date.now() - lastOutputGrowthAt > AGENT_STALE_OUTPUT_MS) {
+            clearInterval(watchdog);
+            clearTimeout(timer);
+            timedOut = true;
+            watchdogKilled = true;
+            killPty();
+            try {
+              rmSync(pidFile, { force: true });
+            } catch {
+            }
+            resolve2({ success: false, code: null, output: appendFileTail(output, `
+Agent process stuck \u2014 no output for ${Math.round(AGENT_STALE_OUTPUT_MS / 6e4)} minutes.`, config.logLinesTail) });
+          }
+        }, 3e4);
+        const cleanup = () => {
+          clearInterval(watchdog);
+          try {
+            rmSync(pidFile, { force: true });
+          } catch {
+          }
+        };
+        ptyProcess.onExit(({ exitCode }) => {
+          clearTimeout(timer);
+          cleanup();
+          if (watchdogKilled) return;
+          const buildOutput = (suffix) => {
+            const tail = appendFileTail(output, suffix, config.logLinesTail);
+            return outputHeader.length > 0 && !tail.startsWith(outputHeader.slice(0, 80)) ? `${outputHeader}
+${tail}` : tail;
+          };
+          if (timedOut) {
+            resolve2({ success: false, code: null, output: buildOutput(`
+Execution timeout after ${config.commandTimeoutMs}ms.`) });
+            return;
+          }
+          const duration = Math.max(0, Date.now() - started);
+          if (exitCode === 0) {
+            resolve2({ success: true, code: exitCode, output: buildOutput(`
+Execution succeeded in ${duration}ms.`) });
+            return;
+          }
+          resolve2({ success: false, code: exitCode ?? null, output: buildOutput(`
+Command exit code ${exitCode ?? "unknown"} after ${duration}ms.`) });
+        });
+      });
+    }
+  }
+  if (resultFile && extraEnv.FIFONY_PRESERVE_RESULT_FILE !== "1") {
+    rmSync(resultFile, { force: true });
+  }
+  writeFileSync(liveLogFile, "", "utf8");
+  return new Promise((resolve2) => {
+    const child = spawn(effectiveCommand, {
+      shell: true,
+      cwd: workspacePath,
+      detached: !config.dockerExecution,
+      // Docker containers don't need detached mode
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (!config.dockerExecution) child.unref();
+    if (child.stdin) {
+      child.stdin.end();
+    }
+    const pidFile = join(workspacePath, "agent.pid");
+    const pid = child.pid;
+    if (pid) {
+      logger.debug({ issueId: issue.id, pid, command: command.slice(0, 120), cwd: workspacePath }, "[Agent] Process spawned");
+      writeFileSync(pidFile, JSON.stringify({
+        pid,
+        issueId: issue.id,
+        startedAt: new Date(started).toISOString(),
+        command: command.slice(0, 200)
+      }), "utf8");
+    }
+    let output = "";
+    let timedOut = false;
+    let outputBytes = 0;
+    let outputHeader = "";
+    const onChunk = (chunk) => {
+      const text = String(chunk);
+      if (outputHeader.length < 2e3) outputHeader = (outputHeader + text).slice(0, 2e3);
+      output = appendFileTail(output, text, config.logLinesTail);
+      outputBytes += text.length;
+      try {
+        appendFileSync(liveLogFile, text);
+      } catch {
+      }
+      if (outputFile) {
+        try {
+          appendFileSync(outputFile, text);
+        } catch {
+        }
+      }
+      issue.commandOutputTail = output;
+    };
+    child.stdout?.on("data", onChunk);
+    child.stderr?.on("data", onChunk);
+    const AGENT_STALE_OUTPUT_MS = 18e5;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      if (pid) {
+        try {
+          process.kill(-pid, "SIGTERM");
+        } catch {
+        }
+      } else {
+        child.kill("SIGTERM");
+      }
+    }, config.commandTimeoutMs);
+    let lastWatchdogBytes = 0;
+    let lastOutputGrowthAt = Date.now();
+    let watchdogKilled = false;
+    const watchdog = setInterval(() => {
+      if (pid) {
+        try {
+          process.kill(pid, 0);
+        } catch {
+          clearInterval(watchdog);
+          clearTimeout(timer);
+          watchdogKilled = true;
+          try {
+            rmSync(pidFile, { force: true });
+          } catch {
+          }
+          resolve2({ success: false, code: null, output: appendFileTail(output, `
+Agent process died unexpectedly (PID ${pid}).`, config.logLinesTail) });
+          return;
+        }
+      }
+      if (outputBytes > lastWatchdogBytes) {
+        lastWatchdogBytes = outputBytes;
+        lastOutputGrowthAt = Date.now();
+      } else if (Date.now() - lastOutputGrowthAt > AGENT_STALE_OUTPUT_MS) {
+        clearInterval(watchdog);
+        clearTimeout(timer);
+        timedOut = true;
+        watchdogKilled = true;
+        if (pid) {
+          try {
+            process.kill(-pid, "SIGTERM");
+          } catch {
+          }
+        } else {
+          child.kill("SIGTERM");
+        }
+        try {
+          rmSync(pidFile, { force: true });
+        } catch {
+        }
+        resolve2({ success: false, code: null, output: appendFileTail(output, `
+Agent process stuck \u2014 no output for ${Math.round(AGENT_STALE_OUTPUT_MS / 6e4)} minutes.`, config.logLinesTail) });
+      }
+    }, 3e4);
+    const cleanup = () => {
+      clearInterval(watchdog);
+      try {
+        rmSync(pidFile, { force: true });
+      } catch {
+      }
+    };
+    child.on("error", () => {
+      clearTimeout(timer);
+      cleanup();
+      if (watchdogKilled) return;
+      resolve2({ success: false, code: null, output: `Command execution failed for issue ${issue.id}.` });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      cleanup();
+      if (watchdogKilled) return;
+      const buildOutput = (suffix) => {
+        const tail = appendFileTail(output, suffix, config.logLinesTail);
+        return outputHeader.length > 0 && !tail.startsWith(outputHeader.slice(0, 80)) ? `${outputHeader}
+${tail}` : tail;
+      };
+      if (timedOut) {
+        resolve2({ success: false, code: null, output: buildOutput(`
+Execution timeout after ${config.commandTimeoutMs}ms.`) });
+        return;
+      }
+      const duration = Math.max(0, Date.now() - started);
+      if (code === 0) {
+        resolve2({ success: true, code, output: buildOutput(`
+Execution succeeded in ${duration}ms.`) });
+        return;
+      }
+      resolve2({ success: false, code, output: buildOutput(`
+Command exit code ${code ?? "unknown"} after ${duration}ms.`) });
+    });
+  });
+}
+function attachToDaemon(socketPath, workspacePath, issue, config, started, outputFile, resultFile) {
+  return new Promise((resolve2) => {
+    const daemonExitFile = join(workspacePath, "daemon.exit.json");
+    let output = "";
+    let outputHeader = "";
+    let outputBytes = 0;
+    let timedOut = false;
+    let resolved = false;
+    let sockBuf = "";
+    const onChunk = (text) => {
+      if (outputHeader.length < 2e3) outputHeader = (outputHeader + text).slice(0, 2e3);
+      output = appendFileTail(output, text, config.logLinesTail);
+      outputBytes += text.length;
+      if (outputFile) {
+        try {
+          appendFileSync(outputFile, text);
+        } catch {
+        }
+      }
+      issue.commandOutputTail = output;
+    };
+    const buildOutput = (suffix) => {
+      const tail = appendFileTail(output, suffix, config.logLinesTail);
+      return outputHeader.length > 0 && !tail.startsWith(outputHeader.slice(0, 80)) ? `${outputHeader}
+${tail}` : tail;
+    };
+    const finish = (success, code, suffix) => {
+      if (resolved) return;
+      resolved = true;
+      clearTimeout(timer);
+      clearInterval(watchdog);
+      sock.destroy();
+      if (resultFile) {
+        try {
+          rmSync(daemonExitFile, { force: true });
+        } catch {
+        }
+      }
+      resolve2({ success, code, output: buildOutput(suffix) });
+    };
+    const sock = createConnection(socketPath);
+    sock.on("connect", () => {
+      sock.write(JSON.stringify({ t: "tail" }) + "\n");
+    });
+    sock.on("data", (chunk) => {
+      sockBuf += chunk.toString();
+      const lines = sockBuf.split("\n");
+      sockBuf = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const msg = JSON.parse(line);
+          if (msg.t === "d" && typeof msg.v === "string") {
+            onChunk(msg.v);
+          } else if (msg.t === "tail" && typeof msg.v === "string") {
+            output = msg.v.slice(-config.logLinesTail * 4);
+            if (outputHeader.length === 0) outputHeader = output.slice(0, 2e3);
+            outputBytes = output.length;
+            issue.commandOutputTail = output;
+          } else if (msg.t === "x") {
+            const exitCode = msg.c ?? null;
+            const success = exitCode === 0;
+            const duration = Math.max(0, Date.now() - started);
+            const suffix = success ? `
+Execution succeeded in ${duration}ms.` : `
+Command exit code ${exitCode ?? "unknown"} after ${duration}ms.`;
+            finish(success, exitCode, suffix);
+          }
+        } catch {
+        }
+      }
+    });
+    sock.on("error", (err) => {
+      logger.warn({ issueId: issue.id, err: String(err) }, "[Agent] Daemon socket error");
+      tryRecoverFromExitFile();
+    });
+    sock.on("close", () => {
+      if (!resolved) tryRecoverFromExitFile();
+    });
+    const tryRecoverFromExitFile = () => {
+      if (resolved) return;
+      try {
+        const raw = readFileSync(daemonExitFile, "utf8");
+        const rec = JSON.parse(raw);
+        const duration = Math.max(0, Date.now() - started);
+        finish(rec.success, rec.code, `
+Recovered from daemon exit record after ${duration}ms.`);
+      } catch {
+        finish(false, null, "\nDaemon socket closed unexpectedly and no exit record found.");
+      }
+    };
+    const AGENT_STALE_OUTPUT_MS = 18e5;
+    let lastWatchdogBytes = 0;
+    let lastOutputGrowthAt = Date.now();
+    const timer = setTimeout(() => {
+      timedOut = true;
+      sock.write(JSON.stringify({ t: "cancel" }) + "\n");
+      finish(false, null, `
+Execution timeout after ${config.commandTimeoutMs}ms.`);
+    }, config.commandTimeoutMs);
+    const watchdog = setInterval(() => {
+      if (outputBytes > lastWatchdogBytes) {
+        lastWatchdogBytes = outputBytes;
+        lastOutputGrowthAt = Date.now();
+      } else if (Date.now() - lastOutputGrowthAt > AGENT_STALE_OUTPUT_MS) {
+        sock.write(JSON.stringify({ t: "cancel" }) + "\n");
+        finish(false, null, `
+Agent process stuck \u2014 no output for ${Math.round(AGENT_STALE_OUTPUT_MS / 6e4)} minutes.`);
+      }
+      void timedOut;
+    }, 3e4);
+  });
+}
+async function writeToDaemon(workspacePath, text) {
+  const socketPath = join(workspacePath, "agent.sock");
+  if (!existsSync2(socketPath)) return;
+  return new Promise((resolve2) => {
+    const sock = createConnection(socketPath);
+    const cleanup = () => {
+      try {
+        sock.destroy();
+      } catch {
+      }
+      resolve2();
+    };
+    sock.on("connect", () => {
+      try {
+        sock.write(JSON.stringify({ t: "write", v: text }) + "\n");
+      } catch {
+      }
+      setImmediate(cleanup);
+    });
+    sock.on("error", cleanup);
+    sock.on("timeout", cleanup);
+    sock.setTimeout(3e3);
+  });
+}
+async function runHook(command, workspacePath, issue, hookName, extraEnv = {}) {
+  if (!command.trim()) return;
+  const result = await runCommandWithTimeout(command, workspacePath, issue, {
+    ...HOOK_RUNTIME_CONFIG,
+    agentProvider: normalizeAgentProvider(env.FIFONY_AGENT_PROVIDER ?? "codex"),
+    agentCommand: command
+  }, "", { FIFONY_HOOK_NAME: hookName, ...extraEnv });
+  if (!result.success) {
+    throw new Error(`${hookName} hook failed: ${result.output}`);
+  }
+}
+
+// src/agents/review-failure-history.ts
+function sortFailureHistory(history) {
+  return [...history].sort((left, right) => {
+    const leftAt = Date.parse(left.recordedAt);
+    const rightAt = Date.parse(right.recordedAt);
+    if (!Number.isNaN(leftAt) && !Number.isNaN(rightAt) && leftAt !== rightAt) return rightAt - leftAt;
+    return left.id.localeCompare(right.id);
+  });
+}
+function recordReviewFailures(issue, reviewRun, gradingReport, recordedAt) {
+  if (!reviewRun || !gradingReport) return issue.reviewFailureHistory ?? [];
+  const failedCriteria = gradingReport.criteria.filter((criterion) => criterion.result === "FAIL");
+  if (failedCriteria.length === 0) return issue.reviewFailureHistory ?? [];
+  const existing = Array.isArray(issue.reviewFailureHistory) ? issue.reviewFailureHistory : [];
+  const next = [...existing];
+  for (const criterion of failedCriteria) {
+    const record = {
+      id: `${reviewRun.id}:${criterion.id}`,
+      runId: reviewRun.id,
+      scope: reviewRun.scope,
+      planVersion: reviewRun.planVersion ?? (issue.planVersion ?? 1),
+      attempt: reviewRun.attempt ?? gradingReport.reviewAttempt ?? 1,
+      criterionId: criterion.id,
+      description: criterion.description,
+      category: criterion.category,
+      verificationMethod: criterion.verificationMethod,
+      blocking: criterion.blocking,
+      weight: criterion.weight,
+      evidence: criterion.evidence,
+      recordedAt,
+      reviewProfile: reviewRun.reviewProfile?.primary,
+      routing: reviewRun.routing
+    };
+    const existingIndex = next.findIndex((entry) => entry.id === record.id);
+    if (existingIndex >= 0) {
+      next[existingIndex] = record;
+    } else {
+      next.push(record);
+    }
+  }
+  issue.reviewFailureHistory = sortFailureHistory(next);
+  return issue.reviewFailureHistory;
+}
+function collectRecurringFailurePatterns(issue, options = {}) {
+  const {
+    scope,
+    blockingOnly = false,
+    currentPlanVersionOnly = false,
+    minOccurrences = 2,
+    limit = 6
+  } = options;
+  const currentPlanVersion = issue.planVersion ?? 1;
+  const history = (issue.reviewFailureHistory ?? []).filter((entry) => {
+    if (scope && entry.scope !== scope) return false;
+    if (blockingOnly && !entry.blocking) return false;
+    if (currentPlanVersionOnly && entry.planVersion !== currentPlanVersion) return false;
+    return true;
+  });
+  const patterns = /* @__PURE__ */ new Map();
+  for (const entry of history) {
+    const key = `${entry.scope}:${entry.criterionId}`;
+    const existing = patterns.get(key);
+    if (!existing) {
+      patterns.set(key, {
+        criterionId: entry.criterionId,
+        description: entry.description,
+        category: entry.category,
+        blocking: entry.blocking,
+        count: 1,
+        attempts: [entry.attempt],
+        scopes: [entry.scope],
+        latestEvidence: entry.evidence,
+        latestRecordedAt: entry.recordedAt
+      });
+      continue;
+    }
+    existing.count += 1;
+    if (!existing.attempts.includes(entry.attempt)) existing.attempts.push(entry.attempt);
+    if (!existing.scopes.includes(entry.scope)) existing.scopes.push(entry.scope);
+    if (Date.parse(entry.recordedAt) >= Date.parse(existing.latestRecordedAt)) {
+      existing.latestEvidence = entry.evidence;
+      existing.latestRecordedAt = entry.recordedAt;
+    }
+  }
+  return [...patterns.values()].filter((pattern) => pattern.count >= minOccurrences).sort((left, right) => {
+    if (right.count !== left.count) return right.count - left.count;
+    return right.latestRecordedAt.localeCompare(left.latestRecordedAt);
+  }).slice(0, limit);
+}
+function findRecurringBlockingFailures(issue, gradingReport, scope, minOccurrences = 2) {
+  const currentBlockingIds = new Set(
+    gradingReport.criteria.filter((criterion) => criterion.result === "FAIL" && criterion.blocking).map((criterion) => criterion.id)
+  );
+  if (currentBlockingIds.size === 0) return [];
+  return collectRecurringFailurePatterns(issue, {
+    scope,
+    blockingOnly: true,
+    currentPlanVersionOnly: true,
+    minOccurrences,
+    limit: currentBlockingIds.size
+  }).filter((pattern) => currentBlockingIds.has(pattern.criterionId));
+}
+function buildRecurringFailureContext(issue, scope) {
+  const patterns = collectRecurringFailurePatterns(issue, {
+    scope,
+    currentPlanVersionOnly: true,
+    minOccurrences: 2,
+    limit: 5
+  });
+  if (patterns.length === 0) return "";
+  const lines = ["## Recurring Reviewer Failures", ""];
+  lines.push("The reviewer has already flagged these patterns more than once. Treat them as the highest-priority risks before asking for another review.", "");
+  for (const pattern of patterns) {
+    const attemptLabel = pattern.attempts.length > 0 ? `attempts ${pattern.attempts.sort((a, b) => a - b).join(", ")}` : "multiple attempts";
+    lines.push(`- **${pattern.criterionId}** [${pattern.category}] failed ${pattern.count} time(s) across ${attemptLabel}: ${pattern.description}`);
+    if (pattern.latestEvidence) {
+      lines.push(`  Latest evidence: ${pattern.latestEvidence}`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/agents/prompt-builder.ts
+function buildRetryContext(issue) {
+  const summaries = issue.previousAttemptSummaries;
+  const recurringFailureContext = buildRecurringFailureContext(issue);
+  if ((!summaries || summaries.length === 0) && !recurringFailureContext) return "";
+  const lines = [];
+  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");
+  }
+  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(", ")}`);
+      }
+      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("");
+  }
+  if (issue.lastFailedPhase === "review" && issue.gradingReport) {
+    const failedCriteria = issue.gradingReport.criteria.filter(
+      (c) => c.result === "FAIL" && ((issue.gradingReport?.blockingVerdict ?? "FAIL") === "FAIL" ? c.blocking : true)
+    );
+    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:");
+      for (const c of failedCriteria) {
+        lines.push(`- **${c.id}** [${c.category}] FAILED: ${c.description} \u2014 ${c.evidence}`);
+      }
+      lines.push("\nYou MUST address ALL of these before submitting. The reviewer will check each one again.\n");
+    }
+  }
+  if (recurringFailureContext) {
+    lines.push(recurringFailureContext);
+  }
+  const full = lines.join("\n");
+  return full.length > 8e3 ? full.slice(0, 8e3) + "\n[...truncated]" : full;
+}
+async function buildPrompt(issue, _workflowDefinition) {
+  const rendered = await renderPrompt("workflow-default", { issue, attempt: issue.attempts || 0 });
+  if (!issue.plan?.steps?.length) {
+    return rendered;
+  }
+  const planSection = await renderPrompt("workflow-plan-section", {
+    estimatedComplexity: issue.plan.estimatedComplexity,
+    summary: issue.plan.summary,
+    steps: issue.plan.steps.map((step) => ({
+      step: step.step,
+      action: step.action,
+      files: step.files ?? [],
+      details: step.details ?? ""
+    }))
+  });
+  return `${rendered}
+
+${planSection}`;
+}
+var CONTEXT_WINDOW_BY_MODEL = [
+  ["claude-3-5", 2e5],
+  ["claude-3-7", 2e5],
+  ["claude-opus-4", 2e5],
+  ["claude-sonnet-4", 2e5],
+  ["claude-haiku-4", 2e5],
+  ["claude", 2e5],
+  ["gemini-2.5", 1e6],
+  ["gemini-2.0", 1e6],
+  ["gemini-1.5", 1e6],
+  ["gemini", 128e3],
+  ["gpt-4o", 128e3],
+  ["gpt-4", 128e3],
+  ["o1", 2e5],
+  ["o3", 2e5],
+  ["codex", 128e3]
+];
+function resolveContextWindow(model) {
+  if (!model) return null;
+  const lc = model.toLowerCase();
+  for (const [fragment, size] of CONTEXT_WINDOW_BY_MODEL) {
+    if (lc.includes(fragment)) return size;
+  }
+  return null;
+}
+async function buildTurnPrompt(issue, basePrompt, previousOutput, turnIndex, maxTurns, nextPrompt) {
+  if (turnIndex === 1) return basePrompt;
+  const turnsRemaining = maxTurns - turnIndex + 1;
+  const isFinalTurns = turnsRemaining <= 2;
+  const cumulativeTokens = issue.tokenUsage?.totalTokens ?? 0;
+  const contextWindow = resolveContextWindow(issue.tokenUsage?.model);
+  const contextWindowPct = contextWindow && cumulativeTokens > 0 ? Math.round(cumulativeTokens / contextWindow * 100) : null;
+  const isContextPressure = contextWindowPct !== null && contextWindowPct >= 70;
+  return renderPrompt("agent-turn", {
+    issueIdentifier: issue.identifier,
+    turnIndex,
+    maxTurns,
+    turnsRemaining,
+    isFinalTurns,
+    isContextPressure,
+    contextWindowPct: contextWindowPct ?? 0,
+    basePrompt,
+    continuation: nextPrompt.trim() || "Continue the work, inspect the workspace, and move the issue toward completion.",
+    outputTail: previousOutput.trim() || "No previous output captured."
+  });
+}
+async function buildProviderBasePrompt(provider, issue, basePrompt, workspacePath, skillContext, capabilitiesManifest) {
+  return renderPrompt("agent-provider-base", {
+    isPlanner: provider.role === "planner",
+    isReviewer: provider.role === "reviewer",
+    hasImpeccableOverlay: provider.overlays?.includes("impeccable") ?? false,
+    hasFrontendDesignOverlay: provider.overlays?.includes("frontend-design") ?? false,
+    profileInstructions: provider.profileInstructions || "",
+    skillContext,
+    capabilitiesManifest: capabilitiesManifest || "",
+    capabilityCategory: "",
+    selectionReason: provider.selectionReason ?? "",
+    overlays: provider.overlays ?? [],
+    targetPaths: issue.paths ?? [],
+    workspacePath,
+    basePrompt
+  });
+}
+
+// src/agents/memory-engine.ts
+import {
+  existsSync as existsSync3,
+  mkdirSync,
+  readdirSync,
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { join as join2 } from "path";
+var MEMORY_DIRNAME = "memory";
+var WORKFLOW_FILE = "WORKFLOW.md";
+var MEMORY_FILE = "MEMORY.md";
+var HEARTBEAT_FILE = "HEARTBEAT.md";
+function resolveTodayDate(value = now()) {
+  return value.slice(0, 10);
+}
+function resolvePaths(workspacePath, date = resolveTodayDate()) {
+  const memoryDir = join2(workspacePath, MEMORY_DIRNAME);
+  return {
+    root: workspacePath,
+    memoryDir,
+    workflowFile: join2(workspacePath, WORKFLOW_FILE),
+    memoryFile: join2(workspacePath, MEMORY_FILE),
+    heartbeatFile: join2(workspacePath, HEARTBEAT_FILE),
+    dailyFile: join2(memoryDir, `${date}.md`)
+  };
+}
+function readText(filePath) {
+  try {
+    return existsSync3(filePath) ? readFileSync2(filePath, "utf8") : "";
+  } catch {
+    return "";
+  }
+}
+function writeIfChanged(filePath, next) {
+  const current = readText(filePath);
+  if (current === next) return false;
+  writeFileSync2(filePath, next, "utf8");
+  return true;
+}
+function ensureFile(filePath, initial) {
+  if (existsSync3(filePath)) return false;
+  writeFileSync2(filePath, initial, "utf8");
+  return true;
+}
+function renderWorkflowDocument(issue) {
+  const plan = issue.plan;
+  const lines = [
+    "# Fifony Workflow Context",
+    "",
+    `Updated: ${now()}`,
+    `Issue: ${issue.identifier} - ${issue.title}`,
+    `State: ${issue.state}`,
+    `Plan version: ${issue.planVersion ?? 0}`,
+    `Execute attempt: ${issue.executeAttempt ?? 0}`,
+    `Review attempt: ${issue.reviewAttempt ?? 0}`,
+    `Harness mode: ${plan?.harnessMode ?? "unknown"}`,
+    ""
+  ];
+  if (plan?.summary) {
+    lines.push("## Current Plan", "", plan.summary, "");
+  }
+  if (plan?.executionContract) {
+    lines.push("## Execution Contract", "");
+    lines.push(`Summary: ${plan.executionContract.summary}`);
+    lines.push(`Checkpoint policy: ${plan.executionContract.checkpointPolicy}`);
+    if (plan.executionContract.focusAreas.length > 0) {
+      lines.push("", "Focus areas:");
+      for (const focusArea of plan.executionContract.focusAreas) lines.push(`- ${focusArea}`);
+    }
+    if (plan.executionContract.requiredChecks.length > 0) {
+      lines.push("", "Required checks:");
+      for (const check of plan.executionContract.requiredChecks) lines.push(`- ${check}`);
+    }
+    lines.push("");
+  }
+  if (plan?.acceptanceCriteria?.length) {
+    lines.push("## Acceptance Criteria", "");
+    for (const criterion of plan.acceptanceCriteria) {
+      lines.push(`- ${criterion.id} [${criterion.category}] ${criterion.blocking ? "blocking" : "advisory"}: ${criterion.description}`);
+    }
+    lines.push("");
+  }
+  const recurringFailures = collectRecurringFailurePatterns(issue, {
+    currentPlanVersionOnly: true,
+    minOccurrences: 2,
+    limit: 5
+  });
+  if (recurringFailures.length > 0) {
+    lines.push("## Recurring Failure Patterns", "");
+    for (const failure of recurringFailures) {
+      lines.push(`- ${failure.criterionId} failed ${failure.count}x: ${failure.description}`);
+    }
+    lines.push("");
+  }
+  return `${lines.join("\n").trim()}
+`;
+}
+function renderHeartbeatDocument(issue) {
+  const lines = [
+    "# Fifony Heartbeat",
+    "",
+    "Use this file as the short operational checklist for the current issue workspace.",
+    "",
+    "## Current Checks",
+    "",
+    `- Current state: ${issue.state}`,
+    `- Review attempts: ${issue.reviewAttempt ?? 0}`,
+    `- Checkpoint status: ${issue.checkpointStatus ?? "n/a"}`,
+    `- Last error: ${issue.lastError ?? "none"}`
+  ];
+  if (issue.plan?.executionContract.focusAreas?.length) {
+    lines.push("", "## Focus Next", "");
+    for (const focusArea of issue.plan.executionContract.focusAreas) {
+      lines.push(`- Inspect ${focusArea}`);
+    }
+  }
+  const recentPolicyDecisions = (issue.policyDecisions ?? []).slice(0, 3);
+  if (recentPolicyDecisions.length > 0) {
+    lines.push("", "## Recent Policy Decisions", "");
+    for (const decision of recentPolicyDecisions) {
+      lines.push(`- ${decision.kind}: ${decision.rationale}`);
+    }
+  }
+  return `${lines.join("\n").trim()}
+`;
+}
+function renderMemoryHeader(issue) {
+  return [
+    "# Durable Workspace Memory",
+    "",
+    "This file keeps high-value lessons for the current issue workspace.",
+    "",
+    `Issue: ${issue.identifier} - ${issue.title}`,
+    "",
+    "## Durable Learnings",
+    ""
+  ].join("\n");
+}
+function buildDurableEntries(issue) {
+  const entries = [];
+  for (const failure of collectRecurringFailurePatterns(issue, {
+    currentPlanVersionOnly: true,
+    minOccurrences: 2,
+    limit: 10
+  })) {
+    entries.push({
+      id: `failure-${failure.criterionId}`,
+      kind: "review-failure",
+      issueId: issue.id,
+      issueIdentifier: issue.identifier,
+      title: `Recurring blocking failure: ${failure.criterionId}`,
+      summary: `${failure.description} Failed ${failure.count} times.`,
+      details: failure.latestEvidence ? [failure.latestEvidence] : void 0,
+      source: "review",
+      createdAt: failure.latestRecordedAt,
+      planVersion: issue.planVersion,
+      reviewAttempt: issue.reviewAttempt,
+      persistLongTerm: true,
+      tags: [failure.category, "recurring-failure"]
+    });
+  }
+  for (const decision of issue.policyDecisions ?? []) {
+    entries.push({
+      id: `policy-${decision.id}`,
+      kind: "policy-decision",
+      issueId: issue.id,
+      issueIdentifier: issue.identifier,
+      title: `Policy decision: ${decision.kind}`,
+      summary: decision.rationale,
+      source: "runtime",
+      createdAt: decision.recordedAt,
+      planVersion: decision.planVersion,
+      reviewScope: decision.reviewScope,
+      persistLongTerm: true,
+      tags: [decision.kind, decision.basis]
+    });
+  }
+  const latestNegotiation = [...issue.contractNegotiationRuns ?? []].filter((entry) => entry.status === "completed" && entry.blockingConcernsCount && entry.blockingConcernsCount > 0).sort((left, right) => Date.parse(right.completedAt ?? right.startedAt) - Date.parse(left.completedAt ?? left.startedAt))[0];
+  if (latestNegotiation) {
+    entries.push({
+      id: `contract-${latestNegotiation.id}`,
+      kind: "contract-negotiation",
+      issueId: issue.id,
+      issueIdentifier: issue.identifier,
+      title: "Contract negotiation concern",
+      summary: latestNegotiation.summary || "Execution contract required revision before code could be written.",
+      details: (latestNegotiation.concerns ?? []).slice(0, 3).map((concern) => `${concern.id}: ${concern.requiredChange}`),
+      source: "planning",
+      createdAt: latestNegotiation.completedAt ?? latestNegotiation.startedAt,
+      planVersion: latestNegotiation.planVersion,
+      persistLongTerm: true,
+      tags: ["contractual", "planning"]
+    });
+  }
+  return entries;
+}
+function renderEntry(entry) {
+  const lines = [
+    `<!-- fifony-memory:${entry.id} -->`,
+    `### ${entry.title}`,
+    "",
+    `- kind: ${entry.kind}`,
+    `- source: ${entry.source}`,
+    `- createdAt: ${entry.createdAt}`,
+    `- planVersion: ${entry.planVersion ?? 0}`,
+    entry.reviewAttempt ? `- reviewAttempt: ${entry.reviewAttempt}` : "",
+    entry.reviewScope ? `- reviewScope: ${entry.reviewScope}` : "",
+    entry.tags?.length ? `- tags: ${entry.tags.join(", ")}` : "",
+    "",
+    entry.summary,
+    ""
+  ].filter(Boolean);
+  if (entry.details?.length) {
+    lines.push("Details:");
+    for (const detail of entry.details) lines.push(`- ${detail}`);
+    lines.push("");
+  }
+  return `${lines.join("\n")}
+`;
+}
+function appendUniqueEntry(filePath, entry) {
+  const marker = `<!-- fifony-memory:${entry.id} -->`;
+  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");
+  return true;
+}
+function listRecentDailyFiles(memoryDir) {
+  if (!existsSync3(memoryDir)) return [];
+  return readdirSync(memoryDir).filter((entry) => entry.endsWith(".md")).sort((left, right) => right.localeCompare(left)).slice(0, 3).map((entry) => join2(memoryDir, entry));
+}
+function ensureWorkspaceMemoryFiles(issue, workspacePath) {
+  const paths = resolvePaths(workspacePath);
+  mkdirSync(paths.root, { recursive: true });
+  mkdirSync(paths.memoryDir, { recursive: true });
+  ensureFile(paths.workflowFile, renderWorkflowDocument(issue));
+  ensureFile(paths.memoryFile, renderMemoryHeader(issue));
+  ensureFile(paths.heartbeatFile, renderHeartbeatDocument(issue));
+  ensureFile(paths.dailyFile, `# Daily Memory - ${resolveTodayDate()}
+
+`);
+  return paths;
+}
+function flushWorkspaceMemory(issue, workspacePath, reason) {
+  if (!workspacePath) return null;
+  const paths = ensureWorkspaceMemoryFiles(issue, workspacePath);
+  const changedFiles = [];
+  let promotedEntries = 0;
+  if (writeIfChanged(paths.workflowFile, renderWorkflowDocument(issue))) changedFiles.push(paths.workflowFile);
+  if (writeIfChanged(paths.heartbeatFile, renderHeartbeatDocument(issue))) changedFiles.push(paths.heartbeatFile);
+  if (!existsSync3(paths.memoryFile)) {
+    writeFileSync2(paths.memoryFile, renderMemoryHeader(issue), "utf8");
+    changedFiles.push(paths.memoryFile);
+  }
+  for (const entry of buildDurableEntries(issue)) {
+    if (appendUniqueEntry(paths.memoryFile, entry)) promotedEntries += 1;
+  }
+  if (promotedEntries > 0 && !changedFiles.includes(paths.memoryFile)) changedFiles.push(paths.memoryFile);
+  if (changedFiles.length === 0 && issue.memoryFlushAt) return null;
+  issue.memoryFlushAt = now();
+  issue.memoryFlushCount = (issue.memoryFlushCount ?? 0) + 1;
+  markIssueDirty(issue.id);
+  return {
+    flushedAt: issue.memoryFlushAt,
+    reason,
+    changedFiles,
+    entriesWritten: changedFiles.length,
+    promotedEntries
+  };
+}
+function recordWorkspaceMemoryEvent(issue, workspacePath, entry) {
+  if (!workspacePath) return false;
+  const paths = ensureWorkspaceMemoryFiles(issue, workspacePath);
+  const wroteDaily = appendUniqueEntry(paths.dailyFile, entry);
+  const wroteLongTerm = entry.persistLongTerm ? appendUniqueEntry(paths.memoryFile, entry) : false;
+  if (!wroteDaily && !wroteLongTerm) return false;
+  issue.memoryFlushAt = now();
+  issue.memoryFlushCount = (issue.memoryFlushCount ?? 0) + 1;
+  markIssueDirty(issue.id);
+  return true;
+}
+function listWorkspaceMemoryContextDocuments(workspacePath) {
+  const paths = resolvePaths(workspacePath);
+  const docs = [];
+  const bootstrapFiles = [
+    { path: paths.workflowFile, layer: "bootstrap", kind: "doc" },
+    { path: paths.heartbeatFile, layer: "bootstrap", kind: "doc" },
+    { path: paths.memoryFile, layer: "workspace-memory", kind: "issue-memory" }
+  ];
+  for (const file of bootstrapFiles) {
+    const text = readText(file.path);
+    if (!text.trim()) continue;
+    docs.push({
+      layer: file.layer,
+      kind: file.kind,
+      path: file.path.slice(workspacePath.length + 1).replace(/\\/g, "/"),
+      sourceId: `workspace:${file.path}`,
+      text
+    });
+  }
+  for (const dailyFile of listRecentDailyFiles(paths.memoryDir)) {
+    const text = readText(dailyFile);
+    if (!text.trim()) continue;
+    docs.push({
+      layer: "workspace-memory",
+      kind: "issue-memory",
+      path: dailyFile.slice(workspacePath.length + 1).replace(/\\/g, "/"),
+      sourceId: `workspace:${dailyFile}`,
+      text
+    });
+  }
+  return docs;
+}
+var DEFAULT_MEMORY_ENGINE = {
+  ensureWorkspaceArtifacts: ensureWorkspaceMemoryFiles,
+  flushIssueMemory: flushWorkspaceMemory,
+  recordIssueEvent: recordWorkspaceMemoryEvent,
+  listContextDocuments: listWorkspaceMemoryContextDocuments
+};
+function getMemoryEngine() {
+  return DEFAULT_MEMORY_ENGINE;
+}
+
+// src/domains/workspace.ts
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".fifony",
+  "node_modules",
+  ".venv",
+  "data",
+  "dist",
+  "build",
+  ".turbo",
+  ".next",
+  ".nuxt",
+  ".tanstack",
+  "coverage",
+  "artifacts",
+  "captures",
+  "tmp",
+  "temp"
+]);
+function shouldSkipPath(relativePath) {
+  const parts = relativePath.split("/");
+  if (parts.some((segment) => SKIP_DIRS.has(segment))) return true;
+  const base = parts.at(-1) ?? "";
+  if (base.startsWith("map_scan_") && extname(base) === ".json") return true;
+  if (extname(base) === ".xlsx") return true;
+  return false;
+}
+function bootstrapSource() {
+  if (existsSync4(SOURCE_MARKER)) return;
+  logger.info("Creating local source snapshot for Fifony (local-only runtime)...");
+  const copyRecursive = (source, target, rel = "") => {
+    mkdirSync2(target, { recursive: true });
+    const items = readdirSync2(source, { withFileTypes: true });
+    for (const item of items) {
+      const nextRel = rel ? `${rel}/${item.name}` : item.name;
+      if (shouldSkipPath(nextRel)) continue;
+      const sourcePath = `${source}/${item.name}`;
+      const targetPath = `${target}/${item.name}`;
+      const itemStat = statSync(sourcePath);
+      if (item.isDirectory()) {
+        copyRecursive(sourcePath, targetPath, nextRel);
+        continue;
+      }
+      if (item.isSymbolicLink() || itemStat.isSymbolicLink()) continue;
+      if (itemStat.isFile() || itemStat.isFIFO()) {
+        try {
+          const file = readFileSync3(sourcePath);
+          writeFileSync3(targetPath, file);
+        } catch (error) {
+          if (error.code === "ENOENT") {
+            logger.debug(`Skipped missing source file: ${sourcePath}`);
+          } else {
+            throw error;
+          }
+        }
+      }
+    }
+  };
+  mkdirSync2(SOURCE_ROOT, { recursive: true });
+  copyRecursive(TARGET_ROOT, SOURCE_ROOT);
+  writeFileSync3(SOURCE_MARKER, `${now()}
+`, "utf8");
+}
+var sourceReadyPromise = null;
+var skipSourceFlag = false;
+function setSkipSource(skip) {
+  skipSourceFlag = skip;
+}
+async function ensureSourceReady(onProgress) {
+  if (skipSourceFlag) {
+    onProgress?.("ready");
+    return;
+  }
+  if (existsSync4(SOURCE_MARKER)) {
+    onProgress?.("ready");
+    return;
+  }
+  if (sourceReadyPromise) return sourceReadyPromise;
+  sourceReadyPromise = (async () => {
+    onProgress?.("copying");
+    logger.info("Creating local source snapshot (async) for Fifony...");
+    const copyRecursiveAsync = async (source, target, rel = "") => {
+      await mkdir(target, { recursive: true });
+      const items = await readdir(source, { withFileTypes: true });
+      for (const item of items) {
+        const nextRel = rel ? `${rel}/${item.name}` : item.name;
+        if (shouldSkipPath(nextRel)) continue;
+        const sourcePath = `${source}/${item.name}`;
+        const targetPath = `${target}/${item.name}`;
+        const itemStat = await stat(sourcePath);
+        if (item.isDirectory()) {
+          await copyRecursiveAsync(sourcePath, targetPath, nextRel);
+          continue;
+        }
+        if (item.isSymbolicLink() || itemStat.isSymbolicLink()) continue;
+        if (itemStat.isFile() || itemStat.isFIFO()) {
+          try {
+            await copyFile(sourcePath, targetPath);
+          } catch (error) {
+            if (error.code === "ENOENT") {
+              logger.debug(`Skipped missing source file: ${sourcePath}`);
+            } else {
+              throw error;
+            }
+          }
+        }
+      }
+    };
+    await mkdir(SOURCE_ROOT, { recursive: true });
+    await copyRecursiveAsync(TARGET_ROOT, SOURCE_ROOT);
+    await writeFile(SOURCE_MARKER, `${now()}
+`, "utf8");
+    onProgress?.("ready");
+    logger.info("Source snapshot ready (async).");
+  })();
+  return sourceReadyPromise;
+}
+function getGitRepoStatus(dir) {
+  const isGit = (() => {
+    try {
+      execSync("git rev-parse --git-dir", { cwd: dir, stdio: "pipe" });
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  if (!isGit) {
+    return { isGit: false, hasCommits: false, branch: null };
+  }
+  const branch = (() => {
+    try {
+      return execSync("git symbolic-ref --short HEAD", { cwd: dir, encoding: "utf8", stdio: "pipe" }).trim() || null;
+    } catch {
+      try {
+        return execSync("git rev-parse --abbrev-ref HEAD", { cwd: dir, encoding: "utf8", stdio: "pipe" }).trim() || null;
+      } catch {
+        return null;
+      }
+    }
+  })();
+  const hasCommits = (() => {
+    try {
+      execSync("git rev-parse --verify HEAD", { cwd: dir, stdio: "pipe" });
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  let isClean = true;
+  let untrackedCount = 0;
+  if (hasCommits) {
+    try {
+      const porcelain = execSync("git status --porcelain", { cwd: dir, encoding: "utf8", timeout: 5e3 }).trim();
+      isClean = porcelain.length === 0;
+      untrackedCount = porcelain.split("\n").filter((l) => l.startsWith("??")).length;
+    } catch {
+    }
+  }
+  return { isGit: true, hasCommits, branch, isClean, untrackedCount };
+}
+function gitRequirementMessage(action) {
+  return `fifony requires a git repository with at least one commit to ${action}. Initialize git in this project and create an initial commit, or use the onboarding Setup step.`;
+}
+function ensureGitRepoReadyForWorktrees(dir, action = "run issue worktrees") {
+  const status = getGitRepoStatus(dir);
+  if (!status.isGit) {
+    throw new Error(gitRequirementMessage(action));
+  }
+  if (!status.hasCommits) {
+    throw new Error(`fifony requires at least one commit to ${action} because git worktree needs a base commit. Create an initial commit, then retry.`);
+  }
+  return status;
+}
+function initializeGitRepoForWorktrees(dir) {
+  let status = getGitRepoStatus(dir);
+  if (!status.isGit) {
+    try {
+      execSync("git init -b main", { cwd: dir, stdio: "pipe" });
+    } catch {
+      execSync("git init", { cwd: dir, stdio: "pipe" });
+    }
+    status = getGitRepoStatus(dir);
+  }
+  if (!status.hasCommits) {
+    execSync(
+      'git -c user.name="fifony" -c user.email="fifony@local.invalid" commit --allow-empty -m "Initial commit"',
+      { cwd: dir, stdio: "pipe" }
+    );
+    status = getGitRepoStatus(dir);
+  }
+  return status;
+}
+function assertIssueHasGitWorktree(issue, action) {
+  if (!issue.branchName || !issue.baseBranch || !issue.worktreePath) {
+    throw new Error(
+      `Issue ${issue.identifier} has no git worktree \u2014 cannot ${action}. This usually means the issue was executed before git was initialized for the project. Initialize git, then re-run the issue.`
+    );
+  }
+}
+function detectDefaultBranch(dir) {
+  try {
+    const current = execSync("git rev-parse --abbrev-ref HEAD", { cwd: dir, encoding: "utf8" }).trim();
+    if (current && current !== "HEAD") return current;
+    const remote = execSync("git symbolic-ref refs/remotes/origin/HEAD", { cwd: dir, encoding: "utf8" }).trim();
+    return remote.replace("refs/remotes/origin/", "");
+  } catch {
+    return "main";
+  }
+}
+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 = join3(sourceRoot, dir);
+    const dst = join3(worktreePath, dir);
+    if (existsSync4(src) && statSync(src).isDirectory() && !existsSync4(dst)) {
+      try {
+        execSync(`cp -R "${src}" "${dst}"`, { stdio: "pipe", timeout: 1e4 });
+        logger.debug({ dir, worktreePath }, "[Workspace] Copied CLI config dir to worktree");
+      } catch (err) {
+        logger.warn({ err: String(err), dir }, "[Workspace] Failed to copy CLI config dir");
+      }
+    }
+  }
+  for (const file of CLI_CONFIG_FILES) {
+    const src = join3(sourceRoot, file);
+    const dst = join3(worktreePath, file);
+    if (existsSync4(src) && !existsSync4(dst)) {
+      try {
+        execSync(`cp "${src}" "${dst}"`, { stdio: "pipe", timeout: 5e3 });
+        logger.debug({ file, worktreePath }, "[Workspace] Copied CLI config file to worktree");
+      } catch (err) {
+        logger.warn({ err: String(err), file }, "[Workspace] Failed to copy CLI config file");
+      }
+    }
+  }
+}
+function isGitWorkingTree(dir) {
+  try {
+    execSync("git rev-parse --git-dir", { cwd: dir, stdio: "pipe", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveTestWorkspacePath(issue) {
+  const workspaceRoot = issue.workspacePath ?? join3(WORKSPACE_ROOT, idToSafePath(issue.id));
+  return join3(workspaceRoot, "test-worktree");
+}
+function createTestWorkspace(issue) {
+  ensureGitRepoReadyForWorktrees(TARGET_ROOT, "create isolated test workspaces");
+  assertIssueHasGitWorktree(issue, "create a test workspace");
+  const workspaceRoot = issue.workspacePath ?? join3(WORKSPACE_ROOT, idToSafePath(issue.id));
+  const testWorkspacePath = issue.testWorkspacePath ?? resolveTestWorkspacePath(issue);
+  mkdirSync2(workspaceRoot, { recursive: true });
+  if (existsSync4(testWorkspacePath)) {
+    if (isGitWorkingTree(testWorkspacePath)) {
+      issue.testWorkspacePath = testWorkspacePath;
+      issue.testApplied = true;
+      return testWorkspacePath;
+    }
+    rmSync2(testWorkspacePath, { recursive: true, force: true });
+  }
+  try {
+    execSync(`git worktree add --detach "${testWorkspacePath}" "${issue.branchName}"`, {
+      cwd: TARGET_ROOT,
+      stdio: "pipe",
+      timeout: 3e4
+    });
+  } catch (err) {
+    const msg = err.stderr || err.stdout || String(err);
+    throw new Error(`Failed to create isolated test workspace: ${msg}`);
+  }
+  copyCliConfigDirs(TARGET_ROOT, testWorkspacePath);
+  issue.testWorkspacePath = testWorkspacePath;
+  issue.testApplied = true;
+  return testWorkspacePath;
+}
+function removeTestWorkspace(issue) {
+  const testWorkspacePath = issue.testWorkspacePath;
+  issue.testApplied = false;
+  issue.testWorkspacePath = void 0;
+  if (!testWorkspacePath) return;
+  try {
+    execSync(`git worktree remove --force "${testWorkspacePath}"`, {
+      cwd: TARGET_ROOT,
+      stdio: "pipe",
+      timeout: 3e4
+    });
+    logger.info({ issueId: issue.id, testWorkspacePath }, "[Workspace] Removed isolated test workspace");
+    return;
+  } catch (error) {
+    logger.warn({ issueId: issue.id, testWorkspacePath, err: String(error) }, "[Workspace] Failed to remove isolated test workspace via git worktree");
+  }
+  try {
+    rmSync2(testWorkspacePath, { recursive: true, force: true });
+  } catch (error) {
+    logger.warn({ issueId: issue.id, testWorkspacePath, err: String(error) }, "[Workspace] Failed to remove isolated test workspace directory");
+  }
+}
+async function createGitWorktree(issue, worktreePath, baseBranch) {
+  let headCommitAtStart = "";
+  const resolvedBaseBranch = baseBranch ?? detectDefaultBranch(TARGET_ROOT);
+  try {
+    headCommitAtStart = execSync("git rev-parse HEAD", { cwd: TARGET_ROOT, encoding: "utf8" }).trim();
+  } catch {
+  }
+  const branchName = `fifony/${issue.id}`;
+  execSync(`git worktree add "${worktreePath}" -B "${branchName}"`, {
+    cwd: TARGET_ROOT,
+    stdio: "pipe"
+  });
+  try {
+    const gitFileContent = readFileSync3(join3(worktreePath, ".git"), "utf8").trim();
+    const gitDirRel = gitFileContent.replace("gitdir: ", "").trim();
+    const gitDirPath = resolve(worktreePath, gitDirRel);
+    mkdirSync2(join3(gitDirPath, "info"), { recursive: true });
+    writeFileSync3(join3(gitDirPath, "info", "exclude"), "fifony-*\n.fifony-*\nfifony_*\n", "utf8");
+  } catch (err) {
+    logger.warn({ err: String(err) }, "[Agent] Failed to write worktree excludes");
+  }
+  issue.branchName = branchName;
+  issue.baseBranch = resolvedBaseBranch;
+  issue.headCommitAtStart = headCommitAtStart;
+  issue.worktreePath = worktreePath;
+  copyCliConfigDirs(TARGET_ROOT, worktreePath);
+  logger.debug({ issueId: issue.id, branchName, baseBranch: resolvedBaseBranch, worktreePath }, "[Agent] Git worktree created");
+}
+async function prepareWorkspace(issue, state, defaultBranch) {
+  const safeId = idToSafePath(issue.id);
+  const workspaceRoot = join3(WORKSPACE_ROOT, safeId);
+  const worktreePath = join3(workspaceRoot, "worktree");
+  const createdNow = !existsSync4(worktreePath);
+  if (createdNow) {
+    mkdirSync2(workspaceRoot, { recursive: true });
+    logger.debug({ issueId: issue.id, identifier: issue.identifier, workspacePath: workspaceRoot }, "[Agent] Creating workspace");
+    ensureGitRepoReadyForWorktrees(TARGET_ROOT, "execute issues");
+    if (state.config.afterCreateHook) {
+      mkdirSync2(worktreePath, { recursive: true });
+      await runHook(state.config.afterCreateHook, worktreePath, issue, "after_create");
+    } else {
+      await createGitWorktree(issue, worktreePath, defaultBranch);
+    }
+    logger.debug({ issueId: issue.id, workspacePath: workspaceRoot, worktreePath }, "[Agent] Workspace created");
+  } else {
+    logger.debug({ issueId: issue.id, workspacePath: workspaceRoot }, "[Agent] Reusing existing workspace");
+  }
+  const metaPath = join3(workspaceRoot, "issue.json");
+  const promptText = await buildPrompt(issue, null);
+  const promptFile = join3(workspaceRoot, "prompt.md");
+  ensureWorkspaceMemoryFiles(issue, workspaceRoot);
+  if (createdNow) {
+    recordWorkspaceMemoryEvent(issue, workspaceRoot, {
+      id: `bootstrap-v${issue.planVersion ?? 0}`,
+      kind: "bootstrap",
+      issueId: issue.id,
+      issueIdentifier: issue.identifier,
+      title: "Workspace bootstrap",
+      summary: "Issue workspace prepared with worktree, prompt scaffold, and durable memory files.",
+      source: "runtime",
+      createdAt: now(),
+      planVersion: issue.planVersion,
+      persistLongTerm: false,
+      tags: ["workspace", "bootstrap"]
+    });
+  }
+  writeFileSync3(metaPath, JSON.stringify({ ...issue, runtimeSource: SOURCE_ROOT, bootstrapAt: now() }, null, 2), "utf8");
+  writeFileSync3(promptFile, `${promptText}
+`, "utf8");
+  issue.workspacePath = workspaceRoot;
+  issue.worktreePath = worktreePath;
+  issue.workspacePreparedAt = now();
+  return { workspacePath: workspaceRoot, promptText, promptFile };
+}
+async function cleanWorkspace(issueId, issue, state) {
+  const safeId = idToSafePath(issueId);
+  const workspacePath = issue?.workspacePath ?? join3(WORKSPACE_ROOT, safeId);
+  if (!existsSync4(workspacePath)) return;
+  if (state.config.beforeRemoveHook) {
+    try {
+      const dummyIssue = issue ?? { id: issueId, identifier: issueId };
+      await runHook(state.config.beforeRemoveHook, workspacePath, dummyIssue, "before_remove");
+    } catch (error) {
+      logger.warn(`before_remove hook failed for ${issueId}: ${String(error)}`);
+    }
+  }
+  if (issue?.testWorkspacePath) {
+    removeTestWorkspace(issue);
+  }
+  if (issue?.branchName && issue.worktreePath) {
+    try {
+      execSync(`git worktree remove --force "${issue.worktreePath}"`, { cwd: TARGET_ROOT, stdio: "pipe" });
+      logger.info(`Removed worktree for ${issueId}: ${issue.worktreePath}`);
+    } catch (error) {
+      logger.warn(`Failed to remove worktree for ${issueId}: ${String(error)}`);
+      try {
+        rmSync2(issue.worktreePath, { recursive: true, force: true });
+      } catch {
+      }
+    }
+    try {
+      execSync(`git branch -D "${issue.branchName}"`, { cwd: TARGET_ROOT, stdio: "pipe" });
+    } catch {
+    }
+    try {
+      rmSync2(workspacePath, { recursive: true, force: true });
+    } catch {
+    }
+    return;
+  }
+  try {
+    rmSync2(workspacePath, { recursive: true, force: true });
+    logger.info(`Cleaned workspace for ${issueId}: ${workspacePath}`);
+  } catch (error) {
+    logger.warn(`Failed to clean workspace for ${issueId}: ${String(error)}`);
+  }
+}
+function inferChangedWorkspacePaths(_workspacePath, limit = 32, issue) {
+  if (!issue?.baseBranch || !issue.branchName) return [];
+  try {
+    const output = execSync(
+      `git diff --name-only "${issue.baseBranch}"..."${issue.branchName}"`,
+      { cwd: TARGET_ROOT, encoding: "utf8", timeout: 1e4, stdio: "pipe" }
+    );
+    return output.trim().split("\n").filter(Boolean).slice(0, limit);
+  } catch {
+    return [];
+  }
+}
+function computeDiffStats(issue) {
+  if (!issue.baseBranch || !issue.branchName) return;
+  try {
+    let raw = "";
+    try {
+      raw = execSync(
+        `git diff --stat "${issue.baseBranch}"..."${issue.branchName}"`,
+        { cwd: TARGET_ROOT, encoding: "utf8", maxBuffer: 512e3, timeout: 1e4, stdio: "pipe" }
+      );
+    } catch (err) {
+      raw = err.stdout || "";
+    }
+    if (raw) parseDiffStats(issue, raw);
+  } catch {
+  }
+}
+function parseDiffStats(issue, raw) {
+  const lines = raw.trim().split("\n");
+  const summary = lines[lines.length - 1] || "";
+  const filesMatch = summary.match(/(\d+)\s+files?\s+changed/);
+  const addMatch = summary.match(/(\d+)\s+insertions?\(\+\)/);
+  const delMatch = summary.match(/(\d+)\s+deletions?\(-\)/);
+  const internalRe = /fifony[-_]|\.fifony-|WORKFLOW\.local/;
+  const fileLines = lines.slice(0, -1).filter((l) => {
+    const name = l.trim().split("|")[0]?.trim().split("/").pop() || "";
+    return !internalRe.test(name);
+  });
+  const regexFiles = filesMatch ? parseInt(filesMatch[1], 10) : 0;
+  issue.filesChanged = fileLines.length > 0 ? fileLines.length : regexFiles;
+  issue.linesAdded = addMatch ? parseInt(addMatch[1], 10) : 0;
+  issue.linesRemoved = delMatch ? parseInt(delMatch[1], 10) : 0;
+}
+async function syncIssueDiffStatsToStore(issue) {
+  if (!issue?.id) return;
+  const { getIssueStateResource } = await import("./store-M6NCKMZY.js");
+  const issueResource = getIssueStateResource();
+  if (!issueResource) return;
+  const toNumber = (value) => {
+    const parsed = typeof value === "number" ? value : Number(value ?? 0);
+    return Number.isFinite(parsed) ? parsed : 0;
+  };
+  const nextLinesAdded = toNumber(issue.linesAdded);
+  const nextLinesRemoved = toNumber(issue.linesRemoved);
+  const nextFilesChanged = toNumber(issue.filesChanged);
+  if (nextLinesAdded === 0 && nextLinesRemoved === 0 && nextFilesChanged === 0 && !issue.branchName) {
+    return;
+  }
+  const current = await issueResource.get?.(issue.id).catch(() => null);
+  const previousLinesAdded = toNumber(current?.linesAdded);
+  const previousLinesRemoved = toNumber(current?.linesRemoved);
+  const previousFilesChanged = toNumber(current?.filesChanged);
+  await issueResource.patch(issue.id, {
+    linesAdded: nextLinesAdded,
+    linesRemoved: nextLinesRemoved,
+    filesChanged: nextFilesChanged,
+    branchName: issue.branchName
+  });
+  const add = issueResource.add;
+  const sub = issueResource.sub;
+  if (typeof add !== "function" || typeof sub !== "function") {
+    logger.debug({ issueId: issue.id }, "[DiffStats] resource.add/sub not available \u2014 EC plugin may not be installed");
+    return;
+  }
+  const deltaAdded = nextLinesAdded - previousLinesAdded;
+  const deltaRemoved = nextLinesRemoved - previousLinesRemoved;
+  const deltaFiles = nextFilesChanged - previousFilesChanged;
+  if (deltaAdded === 0 && deltaRemoved === 0 && deltaFiles === 0) {
+    logger.debug({ issueId: issue.id, nextLinesAdded, previousLinesAdded }, "[DiffStats] No delta to send to EC (values already synced)");
+    return;
+  }
+  logger.debug({ issueId: issue.id, deltaAdded, deltaRemoved, deltaFiles }, "[DiffStats] Sending deltas to EC");
+  const applyDelta = async (field, delta) => {
+    if (delta > 0) {
+      await add.call(issueResource, issue.id, field, delta);
+    } else if (delta < 0) {
+      await sub.call(issueResource, issue.id, field, Math.abs(delta));
+    }
+  };
+  await Promise.all([
+    applyDelta("linesAdded", deltaAdded),
+    applyDelta("linesRemoved", deltaRemoved),
+    applyDelta("filesChanged", deltaFiles)
+  ]);
+}
+function ensureWorktreeCommitted(issue) {
+  const worktreePath = issue.worktreePath;
+  if (!worktreePath || !issue.branchName) return;
+  execSync("git add -A", { cwd: worktreePath, stdio: "pipe" });
+  const statusBeforeCommit = execSync("git status --porcelain", { cwd: worktreePath, encoding: "utf8" }).trim();
+  if (!statusBeforeCommit) return;
+  try {
+    execSync(`git commit -m "fifony: agent changes for ${issue.identifier}"`, { cwd: worktreePath, stdio: "pipe" });
+  } catch (error) {
+    const remaining = execSync("git status --porcelain", { cwd: worktreePath, encoding: "utf8" }).trim();
+    if (remaining) {
+      throw new Error(`Failed to commit agent changes for ${issue.identifier}: ${String(error)}`);
+    }
+  }
+  const statusAfterCommit = execSync("git status --porcelain", { cwd: worktreePath, encoding: "utf8" }).trim();
+  if (statusAfterCommit) {
+    throw new Error(`Worktree for ${issue.identifier} still has uncommitted changes after commit.`);
+  }
+}
+function mergeWorktree(issue, abortOnConflict = true) {
+  const result = { copied: [], deleted: [], skipped: [], conflicts: [] };
+  ensureWorktreeCommitted(issue);
+  const currentBranch = execSync("git rev-parse --abbrev-ref HEAD", { cwd: TARGET_ROOT, encoding: "utf8" }).trim();
+  if (currentBranch !== issue.baseBranch) {
+    throw new Error(`Cannot merge ${issue.identifier}: current branch is ${currentBranch}, expected ${issue.baseBranch}.`);
+  }
+  const targetStatus = execSync("git status --porcelain", { cwd: TARGET_ROOT, encoding: "utf8" }).trim();
+  if (targetStatus) {
+    throw new Error(`Cannot merge ${issue.identifier}: target repository has uncommitted changes.`);
+  }
+  try {
+    const diffOut = execSync(
+      `git diff --name-status "${issue.baseBranch}"..."${issue.branchName}"`,
+      { cwd: TARGET_ROOT, encoding: "utf8" }
+    );
+    for (const line of diffOut.trim().split("\n").filter(Boolean)) {
+      const [statusChar, ...parts] = line.split("	");
+      const filePath = parts.join("	");
+      if (statusChar === "D") result.deleted.push(filePath);
+      else result.copied.push(filePath);
+    }
+  } catch {
+  }
+  try {
+    execSync(
+      `git merge --no-ff "${issue.branchName}" -m "fifony: merge ${issue.identifier}"`,
+      { cwd: TARGET_ROOT, stdio: "pipe" }
+    );
+  } catch (err) {
+    try {
+      const conflictOut = execSync(
+        "git diff --name-only --diff-filter=U",
+        { cwd: TARGET_ROOT, encoding: "utf8" }
+      );
+      result.conflicts.push(...conflictOut.trim().split("\n").filter(Boolean));
+    } catch {
+    }
+    if (abortOnConflict) {
+      try {
+        execSync("git merge --abort", { cwd: TARGET_ROOT, stdio: "pipe" });
+      } catch {
+      }
+      logger.warn({ issueId: issue.id, err: String(err) }, "[Agent] Git merge failed, aborted");
+    } else {
+      logger.info({ issueId: issue.id, conflicts: result.conflicts }, "[Agent] Git merge has conflicts \u2014 leaving markers for agent resolution");
+    }
+  }
+  return result;
+}
+function shouldSkipMergePath(relativePath) {
+  const parts = relativePath.split("/");
+  if (parts.some((s) => s === ".git" || s === "node_modules" || s === ".fifony" || s === "dist" || s === ".tanstack")) {
+    return true;
+  }
+  const base = parts.at(-1) ?? "";
+  return base === "WORKFLOW.local.md" || base === ".fifony-env.sh" || base === ".fifony-compiled-env.sh" || base === ".fifony-local-source-ready" || base.startsWith("fifony-") || base.startsWith("fifony_");
+}
+function mergeWorkspace(issue, abortOnConflict = true) {
+  ensureGitRepoReadyForWorktrees(TARGET_ROOT, "merge issues");
+  assertIssueHasGitWorktree(issue, "merge");
+  return mergeWorktree(issue, abortOnConflict);
+}
+function dryMerge(issue) {
+  ensureGitRepoReadyForWorktrees(TARGET_ROOT, "preview merges");
+  assertIssueHasGitWorktree(issue, "preview merge");
+  ensureWorktreeCommitted(issue);
+  const currentBranch = execSync("git rev-parse --abbrev-ref HEAD", { cwd: TARGET_ROOT, encoding: "utf8" }).trim();
+  if (currentBranch !== issue.baseBranch) {
+    throw new Error(`Cannot preview merge: current branch is ${currentBranch}, expected ${issue.baseBranch}.`);
+  }
+  const targetStatus = execSync("git status --porcelain", { cwd: TARGET_ROOT, encoding: "utf8" }).trim();
+  if (targetStatus) {
+    throw new Error(`Cannot preview merge: target repository has uncommitted changes.`);
+  }
+  let conflictFiles = [];
+  let willConflict = false;
+  try {
+    execSync(
+      `git merge --no-commit --no-ff "${issue.branchName}"`,
+      { cwd: TARGET_ROOT, stdio: "pipe" }
+    );
+  } catch {
+    willConflict = true;
+    try {
+      const conflictOut = execSync(
+        "git diff --name-only --diff-filter=U",
+        { cwd: TARGET_ROOT, encoding: "utf8" }
+      );
+      conflictFiles = conflictOut.trim().split("\n").filter(Boolean);
+    } catch {
+    }
+  }
+  try {
+    execSync("git merge --abort", { cwd: TARGET_ROOT, stdio: "pipe" });
+  } catch {
+    try {
+      execSync("git reset --merge ORIG_HEAD", { cwd: TARGET_ROOT, stdio: "pipe" });
+    } catch {
+      try {
+        execSync("git reset --merge", { cwd: TARGET_ROOT, stdio: "pipe" });
+      } catch (error) {
+        logger.warn({ issueId: issue.id, err: String(error) }, "[Workspace] Failed to safely clean dry-merge state");
+      }
+    }
+  }
+  let changedFiles = 0;
+  try {
+    const diffOut = execSync(
+      `git diff --name-only "${issue.baseBranch}"..."${issue.branchName}"`,
+      { cwd: TARGET_ROOT, encoding: "utf8" }
+    );
+    changedFiles = diffOut.trim().split("\n").filter(Boolean).length;
+  } catch {
+  }
+  return { willConflict, conflictFiles, canMerge: !willConflict, changedFiles };
+}
+function rebaseWorktree(issue) {
+  ensureGitRepoReadyForWorktrees(TARGET_ROOT, "rebase worktrees");
+  assertIssueHasGitWorktree(issue, "rebase");
+  ensureWorktreeCommitted(issue);
+  try {
+    execSync(
+      `git rebase "${issue.baseBranch}"`,
+      { cwd: issue.worktreePath, stdio: "pipe" }
+    );
+    return { success: true, conflictFiles: [] };
+  } catch {
+    let conflictFiles = [];
+    try {
+      const conflictOut = execSync(
+        "git diff --name-only --diff-filter=U",
+        { cwd: issue.worktreePath, encoding: "utf8" }
+      );
+      conflictFiles = conflictOut.trim().split("\n").filter(Boolean);
+    } catch {
+    }
+    try {
+      execSync("git rebase --abort", { cwd: issue.worktreePath, stdio: "pipe" });
+    } catch {
+    }
+    return { success: false, conflictFiles };
+  }
+}
+function hydrateIssuePathsFromWorkspace(issue) {
+  const inferredPaths = inferChangedWorkspacePaths(issue.workspacePath ?? "", 32, issue);
+  if (inferredPaths.length === 0) return [];
+  issue.paths = [.../* @__PURE__ */ new Set([...issue.paths ?? [], ...inferredPaths])];
+  return inferredPaths;
+}
+function writeVersionedArtifacts(workspacePath, prefix, planVersion, attempt, sources) {
+  const { writeFileSync: _wfs, readFileSync: _rfs, existsSync: _es } = { writeFileSync: writeFileSync3, readFileSync: readFileSync3, existsSync: existsSync4 };
+  for (const { srcFile, destSuffix } of sources) {
+    const src = join3(workspacePath, srcFile);
+    if (_es(src)) {
+      _wfs(join3(workspacePath, `${prefix}.v${planVersion}a${attempt}.${destSuffix}`), _rfs(src, "utf8"), "utf8");
+    }
+  }
+}
+
+export {
+  CONTAINER_PLANNING,
+  buildDockerPlanCommand,
+  runCommandWithTimeout,
+  attachToDaemon,
+  writeToDaemon,
+  runHook,
+  recordReviewFailures,
+  findRecurringBlockingFailures,
+  buildRetryContext,
+  buildPrompt,
+  resolveContextWindow,
+  buildTurnPrompt,
+  buildProviderBasePrompt,
+  recordWorkspaceMemoryEvent,
+  getMemoryEngine,
+  bootstrapSource,
+  setSkipSource,
+  ensureSourceReady,
+  getGitRepoStatus,
+  ensureGitRepoReadyForWorktrees,
+  initializeGitRepoForWorktrees,
+  assertIssueHasGitWorktree,
+  detectDefaultBranch,
+  createTestWorkspace,
+  removeTestWorkspace,
+  createGitWorktree,
+  prepareWorkspace,
+  cleanWorkspace,
+  inferChangedWorkspacePaths,
+  computeDiffStats,
+  parseDiffStats,
+  syncIssueDiffStatsToStore,
+  ensureWorktreeCommitted,
+  shouldSkipMergePath,
+  mergeWorkspace,
+  dryMerge,
+  rebaseWorktree,
+  hydrateIssuePathsFromWorkspace,
+  writeVersionedArtifacts
+};
+//# sourceMappingURL=chunk-SOBLO4YZ.js.map