@pourkit/cli 0.0.0-next-20260531213458 → 0.0.0-next-20260601224754

package/dist/cli.js

@@ -333,6 +333,426 @@ var init_common = __esm({
   }
 });
 
+// providers/github-client.ts
+var github_client_exports = {};
+__export(github_client_exports, {
+  requireGitHubClient: () => requireGitHubClient,
+  resolveGitHubRepository: () => resolveGitHubRepository,
+  resolveGitHubToken: () => resolveGitHubToken,
+  tryCreateGitHubClient: () => tryCreateGitHubClient
+});
+import { Octokit } from "octokit";
+function resolveGitHubToken(env) {
+  const token = env.POURKIT_GITHUB_TOKEN ?? env.GH_TOKEN ?? env.GITHUB_TOKEN;
+  if (!token) {
+    throw new Error(
+      "GitHub token is required. Set POURKIT_GITHUB_TOKEN, GH_TOKEN, or GITHUB_TOKEN."
+    );
+  }
+  return token;
+}
+async function resolveGitHubRepository(options) {
+  if (options?.repository) {
+    const parts = options.repository.split("/");
+    if (parts.length !== 2 || !parts[0] || !parts[1]) {
+      throw new Error(
+        `Invalid repository format: "${options.repository}". Expected "owner/repo".`
+      );
+    }
+    return { owner: parts[0], repo: parts[1] };
+  }
+  const env = options?.env ?? process.env;
+  const envRepo = env.GITHUB_REPOSITORY;
+  if (envRepo) {
+    const parts = envRepo.split("/");
+    if (parts.length === 2 && parts[0] && parts[1]) {
+      return { owner: parts[0], repo: parts[1] };
+    }
+    throw new Error(
+      `Invalid repository format: "${envRepo}". Expected "owner/repo".`
+    );
+  }
+  const { execCapture: execCapture2 } = await Promise.resolve().then(() => (init_common(), common_exports));
+  const cwd = options?.cwd;
+  try {
+    const result = await execCapture2("git", ["remote", "get-url", "origin"], {
+      cwd
+    });
+    const remote = result.stdout.trim();
+    const match = remote.match(REMOTE_PATTERN);
+    if (match) {
+      return { owner: match[1], repo: match[2] };
+    }
+  } catch {
+  }
+  throw new Error(
+    "Could not resolve GitHub repository. Set GITHUB_REPOSITORY env var or ensure a valid 'origin' remote exists."
+  );
+}
+async function requireGitHubClient(options) {
+  const env = options?.env ?? process.env;
+  const token = resolveGitHubToken(env);
+  const repo = await resolveGitHubRepository(options);
+  const octokit = new Octokit({ auth: token });
+  return { octokit, ...repo };
+}
+async function tryCreateGitHubClient(options) {
+  const env = options?.env ?? process.env;
+  let token;
+  try {
+    token = resolveGitHubToken(env);
+  } catch {
+    return {
+      ok: false,
+      reason: "missing-token",
+      message: "GitHub token is not configured."
+    };
+  }
+  let repo;
+  try {
+    repo = await resolveGitHubRepository(options);
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    if (message.includes("Invalid repository format")) {
+      return { ok: false, reason: "invalid-repository", message };
+    }
+    return { ok: false, reason: "missing-repository", message };
+  }
+  const octokit = new Octokit({ auth: token });
+  return { ok: true, client: { octokit, ...repo } };
+}
+var REMOTE_PATTERN;
+var init_github_client = __esm({
+  "providers/github-client.ts"() {
+    "use strict";
+    REMOTE_PATTERN = /github\.com[:/]([^/]+)\/([^/]+?)(?:\.git)?$/;
+  }
+});
+
+// execution/execution-provider.ts
+import { writeFile } from "fs/promises";
+import { dirname as dirname3, join as join7 } from "path";
+async function writeExecutionArtifacts(worktreePath, artifacts) {
+  for (const artifact of artifacts) {
+    const filePath = join7(worktreePath, artifact.path);
+    await ensureDir(dirname3(filePath));
+    await writeFile(filePath, artifact.content, "utf-8");
+  }
+}
+var init_execution_provider = __esm({
+  "execution/execution-provider.ts"() {
+    "use strict";
+    init_common();
+  }
+});
+
+// execution/sandbox-image.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import path5 from "path";
+function sandboxImageName(repoRoot2) {
+  const dirName = path5.basename(repoRoot2.replace(/[\\/]+$/, "")) || "local";
+  const sanitized = dirName.toLowerCase().replace(/[^a-z0-9_.-]/g, "-");
+  const baseName = sanitized || "local";
+  const dockerfilePath = path5.join(repoRoot2, ".sandcastle", "Dockerfile");
+  if (!existsSync5(dockerfilePath)) {
+    return `sandcastle:${baseName}`;
+  }
+  const fingerprint = createHash("sha256").update(readFileSync5(dockerfilePath)).digest("hex").slice(0, 8);
+  return `sandcastle:${baseName}-${fingerprint}`;
+}
+var init_sandbox_image = __esm({
+  "execution/sandbox-image.ts"() {
+    "use strict";
+  }
+});
+
+// execution/sandbox-image-build.ts
+import path6 from "path";
+async function ensureSandboxImageBuilt(repoRoot2, options) {
+  const imageName = sandboxImageName(repoRoot2);
+  const dockerfilePath = path6.join(repoRoot2, ".sandcastle", "Dockerfile");
+  if (!options?.force) {
+    try {
+      await execCapture("docker", ["image", "inspect", imageName]);
+      return;
+    } catch {
+    }
+  }
+  const buildArgs = ["build", "-t", imageName, "-f", dockerfilePath];
+  if (options?.force) {
+    buildArgs.push("--pull", "--no-cache");
+  }
+  buildArgs.push(repoRoot2);
+  await execCapture("docker", buildArgs);
+}
+var init_sandbox_image_build = __esm({
+  "execution/sandbox-image-build.ts"() {
+    "use strict";
+    init_common();
+    init_sandbox_image();
+  }
+});
+
+// execution/sandcastle-existing-worktree.ts
+async function createSandboxFromExistingWorktree(options) {
+  const sandcastleEntryUrl = import.meta.resolve("@ai-hero/sandcastle");
+  const createSandboxUrl = new URL("./createSandbox.js", sandcastleEntryUrl);
+  const sandcastleCreateSandbox = await import(createSandboxUrl.href);
+  return sandcastleCreateSandbox.createSandboxFromWorktree(options);
+}
+var init_sandcastle_existing_worktree = __esm({
+  "execution/sandcastle-existing-worktree.ts"() {
+    "use strict";
+  }
+});
+
+// execution/sandbox-options.ts
+function buildSandboxOptions(repoRoot2, sandbox) {
+  const mounts = [];
+  if (sandbox.mounts !== void 0) {
+    mounts.push(...sandbox.mounts);
+  }
+  return {
+    imageName: sandboxImageName(repoRoot2),
+    ...mounts.length > 0 ? { mounts } : {},
+    ...sandbox.env !== void 0 ? { env: sandbox.env } : {},
+    ...sandbox.idleTimeoutSeconds !== void 0 ? { idleTimeoutSeconds: sandbox.idleTimeoutSeconds } : {}
+  };
+}
+var init_sandbox_options = __esm({
+  "execution/sandbox-options.ts"() {
+    "use strict";
+    init_sandbox_image();
+  }
+});
+
+// execution/opencode-config.ts
+function isSerenaEligibleStage(stage) {
+  return stage === "builder" || stage === "refactor";
+}
+function buildSerenaOpenCodeConfig(stage, serena) {
+  if (!serena?.available || !isSerenaEligibleStage(stage)) {
+    return void 0;
+  }
+  return {
+    mcp: {
+      serena: {
+        type: "remote",
+        url: serena.sandboxMcpUrl,
+        enabled: true
+      }
+    }
+  };
+}
+var init_opencode_config = __esm({
+  "execution/opencode-config.ts"() {
+    "use strict";
+  }
+});
+
+// execution/sandcastle-execution.ts
+var sandcastle_execution_exports = {};
+__export(sandcastle_execution_exports, {
+  SandcastleExecutionProvider: () => SandcastleExecutionProvider
+});
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync2 } from "fs";
+import { join as join8 } from "path";
+import { createWorktree, opencode } from "@ai-hero/sandcastle";
+import { docker } from "@ai-hero/sandcastle/sandboxes/docker";
+function resolveSandboxProvider(provider, dockerFactory) {
+  if (provider === "docker") {
+    return dockerFactory;
+  }
+  throw new Error(`Unsupported sandbox provider: ${provider}`);
+}
+function sanitizeBranch(branchName) {
+  return branchName.replace(/[^A-Za-z0-9._-]/g, "-");
+}
+function savePromptToFile(repoRoot2, stage, iteration, prompt) {
+  const promptsDir = join8(repoRoot2, ".pourkit", ".tmp", "prompts");
+  mkdirSync4(promptsDir, { recursive: true });
+  const timestamp2 = Date.now();
+  const iterationSuffix = iteration !== void 0 ? `-iteration-${iteration}` : "";
+  const filename = `${stage}${iterationSuffix}-${timestamp2}.md`;
+  const filePath = join8(promptsDir, filename);
+  writeFileSync2(filePath, prompt, "utf-8");
+}
+var SandcastleExecutionProvider, SandcastleExecutionSession;
+var init_sandcastle_execution = __esm({
+  "execution/sandcastle-execution.ts"() {
+    "use strict";
+    init_execution_provider();
+    init_sandbox_image_build();
+    init_sandcastle_existing_worktree();
+    init_sandbox_options();
+    init_opencode_config();
+    SandcastleExecutionProvider = class {
+      async createSession() {
+        return new SandcastleExecutionSession();
+      }
+      async execute(options) {
+        const session = await this.createSession();
+        try {
+          return await session.execute(options);
+        } finally {
+          await session.close();
+        }
+      }
+    };
+    SandcastleExecutionSession = class {
+      sandboxHandle = null;
+      worktreeHandle = null;
+      async close() {
+        try {
+          await this.sandboxHandle?.close?.();
+        } finally {
+          this.sandboxHandle = null;
+        }
+      }
+      async execute(options) {
+        const {
+          stage,
+          iteration,
+          agent,
+          model,
+          prompt,
+          target,
+          repoRoot: repoRoot2,
+          branchName,
+          worktreePath,
+          baseRef,
+          sandbox,
+          autoApprove = false,
+          timeoutMs,
+          artifacts = [],
+          logger
+        } = options;
+        const stageLabel = iteration !== void 0 ? `${stage}:${iteration}` : stage;
+        logger.step(
+          "sandcastle",
+          `[${stageLabel}] running agent "${agent}" with model "${model}"`
+        );
+        try {
+          const env = {};
+          if (autoApprove) {
+            env.OPENCODE_AUTO_APPROVE = "true";
+          }
+          const serenaConfig = buildSerenaOpenCodeConfig(stage, options.serena);
+          if (serenaConfig) {
+            env.OPENCODE_CONFIG_CONTENT = JSON.stringify(serenaConfig);
+          }
+          const logPath = `${repoRoot2}/.pourkit/logs/${sanitizeBranch(branchName)}-${Date.now()}.log`;
+          await ensureSandboxImageBuilt(repoRoot2, { force: sandbox.forceRebuild });
+          try {
+            savePromptToFile(repoRoot2, stage, iteration, prompt);
+          } catch {
+          }
+          const agentProvider = opencode(model, { env, agent });
+          const sandboxOptions = buildSandboxOptions(repoRoot2, sandbox);
+          const sandboxProvider = resolveSandboxProvider(sandbox.provider, docker);
+          const activeSandbox = await this.getOrCreateSandbox({
+            repoRoot: repoRoot2,
+            branchName,
+            baseBranch: baseRef ?? target.baseBranch,
+            worktreePath,
+            sandboxProvider: sandboxProvider(sandboxOptions),
+            setupCommands: target.setupCommands ?? [],
+            copyToWorktree: sandbox.copyToWorktree ?? []
+          });
+          await writeExecutionArtifacts(activeSandbox.worktreePath, artifacts);
+          const result = await activeSandbox.run({
+            agent: agentProvider,
+            prompt,
+            maxIterations: 1,
+            name: stageLabel,
+            logging: {
+              type: "file",
+              path: logPath,
+              onAgentStreamEvent: (event) => {
+                if (event.type === "text") {
+                  logger.raw(event.message);
+                } else if (event.type === "toolCall") {
+                  logger.raw(`${event.name}(${event.formattedArgs})`);
+                }
+              }
+            },
+            completionSignal: "<promise>COMPLETE</promise>",
+            ...timeoutMs ? { signal: AbortSignal.timeout(timeoutMs) } : {},
+            ...sandboxOptions.idleTimeoutSeconds ? { idleTimeoutSeconds: sandboxOptions.idleTimeoutSeconds } : {}
+          });
+          const commits = result.commits.map((c) => c.sha);
+          const resultBranch = result.branch ?? activeSandbox.branch ?? branchName;
+          logger.kv("SANDBOX_SUCCESS", "true");
+          logger.kv("COMMITS_CREATED", String(commits.length));
+          logger.kv("WORKTREE_BRANCH", resultBranch);
+          if (result.logFilePath) {
+            logger.kv("LOG_FILE", result.logFilePath);
+          }
+          return {
+            success: true,
+            branch: resultBranch,
+            worktreePath: activeSandbox.worktreePath,
+            commits,
+            logPath
+          };
+        } catch (error) {
+          logger.step(
+            "error",
+            `Sandcastle failed: ${error instanceof Error ? error.message : String(error)}`
+          );
+          return {
+            success: false,
+            branch: "",
+            worktreePath: "",
+            commits: [],
+            logPath: null,
+            error: error instanceof Error ? error.message : String(error)
+          };
+        }
+      }
+      async getOrCreateSandbox(options) {
+        if (this.sandboxHandle) {
+          return this.sandboxHandle;
+        }
+        const hooks = {
+          sandbox: {
+            onSandboxReady: options.setupCommands.map((command) => ({
+              command: command.command
+            }))
+          }
+        };
+        if (options.worktreePath) {
+          this.sandboxHandle = await createSandboxFromExistingWorktree({
+            branch: options.branchName,
+            hostRepoDir: options.repoRoot,
+            worktreePath: options.worktreePath,
+            sandbox: options.sandboxProvider,
+            ...options.copyToWorktree.length > 0 ? { copyToWorktree: options.copyToWorktree } : {},
+            hooks
+          });
+          return this.sandboxHandle;
+        }
+        this.worktreeHandle = await createWorktree({
+          cwd: options.repoRoot,
+          branchStrategy: {
+            type: "branch",
+            branch: options.branchName,
+            baseBranch: options.baseBranch
+          },
+          ...options.copyToWorktree.length > 0 ? { copyToWorktree: options.copyToWorktree } : {}
+        });
+        this.sandboxHandle = await this.worktreeHandle.createSandbox({
+          sandbox: options.sandboxProvider,
+          ...options.copyToWorktree.length > 0 ? { copyToWorktree: options.copyToWorktree } : {},
+          hooks
+        });
+        return this.sandboxHandle;
+      }
+    };
+  }
+});
+
 // cli.ts
 import path8 from "path";
 import { realpathSync } from "fs";
@@ -997,8 +1417,8 @@ async function cleanupRepository(options) {
 }
 
 // commands/issue-run.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
+import { join as join12 } from "path";
 
 // pr/templates.ts
 init_common();
@@ -1262,7 +1682,43 @@ function invalidateAfterBaseRefresh(state) {
 }
 
 // failure-resolution/effect-runtime.ts
-import { Effect } from "effect";
+import { Effect as Effect2 } from "effect";
+
+// shared/effect-runtime.ts
+import { Effect, Exit } from "effect";
+import { UnknownException } from "effect/Cause";
+var initialized = false;
+function initializeEffectRuntime() {
+  if (initialized) return;
+  initialized = true;
+}
+function runEffect(program) {
+  ensureEffectRuntime();
+  return Effect.runPromiseExit(program);
+}
+function ensureEffectRuntime() {
+  if (!initialized) {
+    initializeEffectRuntime();
+  }
+}
+function unwrapError(error) {
+  if (error instanceof UnknownException && error.error !== void 0) {
+    return error.error;
+  }
+  return error;
+}
+function runEffectAndMapExit(program) {
+  return runEffect(program).then((exit) => {
+    if (Exit.isSuccess(exit)) return exit.value;
+    const cause = exit.cause;
+    if (cause._tag === "Fail") {
+      const error = unwrapError(cause.error);
+      throw error instanceof Error ? error : new Error(String(error));
+    }
+    const defect = cause._tag === "Die" ? cause.defect : cause._tag === "Interrupt" ? "interrupted" : `unhandled cause: ${cause._tag}`;
+    throw defect instanceof Error ? defect : new Error(`Unexpected defect: ${String(defect)}`);
+  });
+}
 
 // failure-resolution/types.ts
 var RebaseConflict = class extends Error {
@@ -1320,8 +1776,26 @@ var SafetyFailure = class extends Error {
     this.message = args.message;
   }
 };
-var SUPPORTED_DECISIONS = /* @__PURE__ */ new Set([
-  "RETRY_STAGE",
+var ReviewerFailure = class extends Error {
+  _tag = "ReviewerFailure";
+  message;
+  constructor(args) {
+    super(args.message);
+    this.name = "ReviewerFailure";
+    this.message = args.message;
+  }
+};
+var FinalizerFailure = class extends Error {
+  _tag = "FinalizerFailure";
+  message;
+  constructor(args) {
+    super(args.message);
+    this.name = "FinalizerFailure";
+    this.message = args.message;
+  }
+};
+var SUPPORTED_DECISIONS = /* @__PURE__ */ new Set([
+  "RETRY_STAGE",
   "HANDOFF_TO_HUMAN",
   "FAIL_RUN"
 ]);
@@ -1495,23 +1969,23 @@ function recordStageAttempt(worktreePath, record) {
 
 // failure-resolution/effect-runtime.ts
 function baseRefreshEffect(options) {
-  return Effect.promise(() => refreshStaleIssueBranch(options)).pipe(
-    Effect.flatMap(
+  return Effect2.promise(() => refreshStaleIssueBranch(options)).pipe(
+    Effect2.flatMap(
       (result) => {
         switch (result.status) {
           case "refreshed":
-            return Effect.succeed({ status: "refreshed" });
+            return Effect2.succeed({ status: "refreshed" });
           case "skipped-current":
-            return Effect.succeed({ status: "skipped-current" });
+            return Effect2.succeed({ status: "skipped-current" });
           case "conflicted":
-            return Effect.fail(
+            return Effect2.fail(
               new RebaseConflict({
                 conflictedPaths: result.conflictedPaths,
                 message: result.message
               })
             );
           case "refused-published-history":
-            return Effect.fail(
+            return Effect2.fail(
               new PublishedHistoryRisk({
                 prNumber: result.prNumber,
                 prState: result.prState
@@ -1526,8 +2000,8 @@ async function runBaseRefreshAttempt(options) {
   const attemptId = createStageAttemptId();
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const program = baseRefreshEffect(options).pipe(
-    Effect.tapBoth({
-      onSuccess: (success) => Effect.sync(() => {
+    Effect2.tapBoth({
+      onSuccess: (success) => Effect2.sync(() => {
         recordStageAttempt(options.worktreePath, {
           id: attemptId,
           stage: "baseRefresh",
@@ -1536,7 +2010,7 @@ async function runBaseRefreshAttempt(options) {
           outcome: "success"
         });
       }),
-      onFailure: (failure) => Effect.sync(() => {
+      onFailure: (failure) => Effect2.sync(() => {
         recordStageAttempt(options.worktreePath, {
           id: attemptId,
           stage: "baseRefresh",
@@ -1552,7 +2026,7 @@ async function runBaseRefreshAttempt(options) {
       })
     })
   );
-  return Effect.runPromiseExit(program);
+  return runEffect(program);
 }
 
 // commands/conflict-resolution.ts
@@ -1575,7 +2049,7 @@ async function hasUnresolvedConflictMarkers(worktreePath, files) {
 }
 
 // commands/issue-run.ts
-import { Exit as Exit2 } from "effect";
+import { Exit as Exit3 } from "effect";
 
 // serena/baseline.ts
 init_common();
@@ -2124,8 +2598,7 @@ async function writeRecoveryAttempt(worktreePath, outcome, fingerprint, summary,
 }
 
 // commands/pr-description-agent.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname3, join as join8 } from "path";
+import { dirname as dirname4, join as join10 } from "path";
 
 // pr/pr-description.ts
 var CONVENTIONAL_TITLE_PATTERN = /^(feat|fix|perf|refactor|docs|test|chore|ci|build)(\([^)]+\))?!?:\s+\S/;
@@ -2213,68 +2686,363 @@ function inferConventionalType(commitSummaries) {
 
 // pr/pr-description-context.ts
 init_common();
-import { join as join7 } from "path";
+import { join as join9 } from "path";
 import { readFile } from "fs/promises";
-async function collectFinalizerContext(options) {
-  const { targetBase, branchName, worktreePath, reviewArtifactPath, logger } = options;
-  const commits = await collectCommitRange(
-    targetBase,
-    branchName,
-    worktreePath,
-    logger
-  );
-  const reviewArtifact = reviewArtifactPath ? await readReviewArtifact(reviewArtifactPath) : "(no review artifact provided)";
-  return {
-    commits,
-    reviewArtifact,
-    targetBase,
-    branchName
-  };
-}
-async function collectCommitRange(targetBase, branchName, worktreePath, logger) {
-  const result = await execCapture(
-    "git",
-    [
-      "log",
-      `${remoteTargetBase(targetBase)}..${branchName}`,
-      "--oneline",
-      "--no-decorate"
-    ],
-    { cwd: worktreePath, logger, label: "git log" }
-  );
-  const commits = result.stdout.trim();
-  if (!commits) {
-    logger.step(
-      "warn",
-      `No commits found between ${targetBase} and ${branchName}, proceeding with empty commit range`
-    );
+import { Effect as Effect4 } from "effect";
+
+// shared/effect-services.ts
+import { Context, Effect as Effect3, Layer } from "effect";
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync3, rmSync } from "fs";
+var GitExecutionError = class extends Error {
+  _tag = "GitExecutionError";
+  message;
+  constructor(args) {
+    super(args.message);
+    this.name = "GitExecutionError";
+    this.message = args.message;
   }
-  return commits;
+};
+var FileSystem = class extends Context.Tag("FileSystem")() {
+};
+var FileSystemDefault = Layer.succeed(
+  FileSystem,
+  FileSystem.of({
+    readFile: (path9) => Effect3.try({
+      try: () => readFileSync6(path9, "utf-8"),
+      catch: (error) => new Error(
+        `Failed to read file ${path9}: ${error instanceof Error ? error.message : String(error)}`
+      )
+    }),
+    writeFile: (path9, content) => Effect3.try({
+      try: () => writeFileSync3(path9, content, "utf-8"),
+      catch: (error) => new Error(
+        `Failed to write file ${path9}: ${error instanceof Error ? error.message : String(error)}`
+      )
+    }),
+    exists: (path9) => Effect3.try({
+      try: () => existsSync6(path9),
+      catch: (error) => new Error(
+        `Failed to check existence of ${path9}: ${error instanceof Error ? error.message : String(error)}`
+      )
+    }),
+    mkdir: (path9) => Effect3.try({
+      try: () => mkdirSync5(path9, { recursive: true }),
+      catch: (error) => new Error(
+        `Failed to create directory ${path9}: ${error instanceof Error ? error.message : String(error)}`
+      )
+    }),
+    remove: (path9) => Effect3.try({
+      try: () => rmSync(path9, { recursive: true, force: true }),
+      catch: (error) => new Error(
+        `Failed to remove ${path9}: ${error instanceof Error ? error.message : String(error)}`
+      )
+    })
+  })
+);
+var FileSystemTest = Layer.succeed(
+  FileSystem,
+  FileSystem.of({
+    readFile: (path9) => Effect3.succeed(`test content for ${path9}`),
+    writeFile: (_path, _content) => Effect3.void,
+    exists: (_path) => Effect3.succeed(true),
+    mkdir: (_path) => Effect3.void,
+    remove: (_path) => Effect3.void
+  })
+);
+var GitOperations = class extends Context.Tag("GitOperations")() {
+};
+var GitOperationsDefault = Layer.succeed(
+  GitOperations,
+  GitOperations.of({
+    exec: (args, options) => Effect3.tryPromise({
+      try: async () => {
+        const { execCapture: execCapture2 } = await Promise.resolve().then(() => (init_common(), common_exports));
+        const result = await execCapture2("git", args, {
+          cwd: options?.cwd
+        });
+        return { stdout: result.stdout, stderr: result.stderr };
+      },
+      catch: (error) => new GitExecutionError({
+        message: error instanceof Error ? error.message : `git exec failed: ${String(error)}`
+      })
+    }),
+    revParse: (ref, cwd) => Effect3.tryPromise({
+      try: async () => {
+        const { execCapture: execCapture2 } = await Promise.resolve().then(() => (init_common(), common_exports));
+        const result = await execCapture2("git", ["rev-parse", ref], {
+          cwd
+        });
+        return result.stdout.trim();
+      },
+      catch: (error) => new GitExecutionError({
+        message: error instanceof Error ? error.message : `git rev-parse failed: ${String(error)}`
+      })
+    }),
+    fetch: (remote, branch, cwd) => Effect3.tryPromise({
+      try: async () => {
+        const { execCapture: execCapture2 } = await Promise.resolve().then(() => (init_common(), common_exports));
+        await execCapture2("git", ["fetch", remote, branch], { cwd });
+      },
+      catch: (error) => new GitExecutionError({
+        message: error instanceof Error ? error.message : `git fetch failed: ${String(error)}`
+      })
+    }),
+    mergeBaseIsAncestor: (baseRef, cwd) => Effect3.tryPromise({
+      try: async () => {
+        const { execCapture: execCapture2 } = await Promise.resolve().then(() => (init_common(), common_exports));
+        await execCapture2(
+          "git",
+          ["merge-base", "--is-ancestor", baseRef, "HEAD"],
+          { cwd }
+        );
+        return true;
+      },
+      catch: (error) => new GitExecutionError({
+        message: error instanceof Error ? error.message : `git merge-base failed: ${String(error)}`
+      })
+    }).pipe(
+      Effect3.catchIf(
+        (error) => error instanceof GitExecutionError && error.message.includes("merge-base --is-ancestor") && error.message.includes("exit code: 1"),
+        () => Effect3.succeed(false)
+      )
+    )
+  })
+);
+var GitOperationsTest = Layer.succeed(
+  GitOperations,
+  GitOperations.of({
+    exec: (_args, _options) => Effect3.succeed({ stdout: "", stderr: "" }),
+    revParse: (_ref, _cwd) => Effect3.succeed("abc123def456"),
+    fetch: (_remote, _branch, _cwd) => Effect3.void,
+    mergeBaseIsAncestor: (_baseRef, _cwd) => Effect3.succeed(true)
+  })
+);
+var GitHubApiClient = class extends Context.Tag("GitHubApiClient")() {
+};
+var GitHubApiClientDefault = Layer.succeed(
+  GitHubApiClient,
+  GitHubApiClient.of({
+    getIssue: (owner, repo, issueNumber) => Effect3.tryPromise({
+      try: async () => {
+        const { requireGitHubClient: requireGitHubClient2 } = await Promise.resolve().then(() => (init_github_client(), github_client_exports));
+        const client = await requireGitHubClient2();
+        return await client.octokit.rest.issues.get({
+          owner,
+          repo,
+          issue_number: issueNumber
+        });
+      },
+      catch: (error) => new Error(
+        error instanceof Error ? error.message : `GitHub API getIssue failed: ${String(error)}`
+      )
+    }),
+    createIssueComment: (owner, repo, issueNumber, body) => Effect3.tryPromise({
+      try: async () => {
+        const { requireGitHubClient: requireGitHubClient2 } = await Promise.resolve().then(() => (init_github_client(), github_client_exports));
+        const client = await requireGitHubClient2();
+        return await client.octokit.rest.issues.createComment({
+          owner,
+          repo,
+          issue_number: issueNumber,
+          body
+        });
+      },
+      catch: (error) => new Error(
+        error instanceof Error ? error.message : `GitHub API createIssueComment failed: ${String(error)}`
+      )
+    }),
+    updateIssue: (owner, repo, issueNumber, update) => Effect3.tryPromise({
+      try: async () => {
+        const { requireGitHubClient: requireGitHubClient2 } = await Promise.resolve().then(() => (init_github_client(), github_client_exports));
+        const client = await requireGitHubClient2();
+        return await client.octokit.rest.issues.update({
+          owner,
+          repo,
+          issue_number: issueNumber,
+          ...update
+        });
+      },
+      catch: (error) => new Error(
+        error instanceof Error ? error.message : `GitHub API updateIssue failed: ${String(error)}`
+      )
+    })
+  })
+);
+var GitHubApiClientTest = Layer.succeed(
+  GitHubApiClient,
+  GitHubApiClient.of({
+    getIssue: (_owner, _repo, _issueNumber) => Effect3.succeed({ data: { title: "Test Issue", state: "open" } }),
+    createIssueComment: (_owner, _repo, _issueNumber, _body) => Effect3.succeed({ data: { id: 1 } }),
+    updateIssue: (_owner, _repo, _issueNumber, _update) => Effect3.succeed({ data: { number: _issueNumber } })
+  })
+);
+var ExecutionProvider = class extends Context.Tag("ExecutionProvider")() {
+};
+var ExecutionProviderDefault = Layer.succeed(
+  ExecutionProvider,
+  ExecutionProvider.of({
+    execute: (options) => Effect3.tryPromise({
+      try: async () => {
+        const { SandcastleExecutionProvider: SandcastleExecutionProvider2 } = await Promise.resolve().then(() => (init_sandcastle_execution(), sandcastle_execution_exports));
+        const provider = new SandcastleExecutionProvider2();
+        return await provider.execute(options);
+      },
+      catch: (error) => new Error(
+        error instanceof Error ? error.message : `Execution failed: ${String(error)}`
+      )
+    })
+  })
+);
+var ExecutionProviderTest = Layer.succeed(
+  ExecutionProvider,
+  ExecutionProvider.of({
+    execute: (_options) => Effect3.succeed({
+      success: true,
+      branch: "test-branch",
+      worktreePath: _options.worktreePath ?? "/tmp/worktree",
+      commits: ["abc123"],
+      logPath: "/tmp/test-log"
+    })
+  })
+);
+var AttemptLogService = class extends Context.Tag("AttemptLogService")() {
+};
+var AttemptLogServiceDefault = Layer.succeed(
+  AttemptLogService,
+  AttemptLogService.of({
+    writeEntry: (worktreePath, entry) => Effect3.try({
+      try: () => writeAttemptLog(worktreePath, entry),
+      catch: (error) => new Error(
+        `Failed to write attempt log: ${error instanceof Error ? error.message : String(error)}`
+      )
+    }),
+    readEntries: (worktreePath) => Effect3.try({
+      try: () => readAttemptLog(worktreePath),
+      catch: (error) => new Error(
+        `Failed to read attempt log: ${error instanceof Error ? error.message : String(error)}`
+      )
+    })
+  })
+);
+var AttemptLogServiceTest = Layer.succeed(
+  AttemptLogService,
+  AttemptLogService.of({
+    writeEntry: (_worktreePath, _entry) => Effect3.void,
+    readEntries: (_worktreePath) => Effect3.succeed([])
+  })
+);
+var WorktreeRunStateService = class extends Context.Tag(
+  "WorktreeRunStateService"
+)() {
+};
+var WorktreeRunStateServiceDefault = Layer.succeed(
+  WorktreeRunStateService,
+  WorktreeRunStateService.of({
+    read: (worktreePath) => Effect3.try({
+      try: () => readWorktreeRunState(worktreePath),
+      catch: (error) => new Error(
+        `Failed to read worktree run state: ${error instanceof Error ? error.message : String(error)}`
+      )
+    }),
+    write: (worktreePath, state) => Effect3.try({
+      try: () => writeWorktreeRunState(worktreePath, state),
+      catch: (error) => new Error(
+        `Failed to write worktree run state: ${error instanceof Error ? error.message : String(error)}`
+      )
+    }),
+    update: (worktreePath, update) => Effect3.try({
+      try: () => updateWorktreeRunState(worktreePath, update),
+      catch: (error) => new Error(
+        `Failed to update worktree run state: ${error instanceof Error ? error.message : String(error)}`
+      )
+    })
+  })
+);
+var WorktreeRunStateServiceTestTimestamp = "2026-01-01T00:00:00.000Z";
+var WorktreeRunStateServiceTest = Layer.succeed(
+  WorktreeRunStateService,
+  WorktreeRunStateService.of({
+    read: (_worktreePath) => Effect3.succeed({
+      issueNumber: 0,
+      targetName: "test",
+      branchName: "test-branch",
+      baseBranch: "main",
+      createdAt: WorktreeRunStateServiceTestTimestamp,
+      updatedAt: WorktreeRunStateServiceTestTimestamp,
+      completedStages: {},
+      review: {
+        lifetimeIterations: 0
+      }
+    }),
+    write: (_worktreePath, _state) => Effect3.void,
+    update: (_worktreePath, _update) => Effect3.void
+  })
+);
+
+// pr/pr-description-context.ts
+function collectFinalizerContextEffect(options) {
+  return Effect4.gen(function* () {
+    const git = yield* GitOperations;
+    const fs = yield* FileSystem;
+    const remoteBase = remoteTargetBase(options.targetBase);
+    const result = yield* git.exec(
+      [
+        "log",
+        `${remoteBase}..${options.branchName}`,
+        "--oneline",
+        "--no-decorate"
+      ],
+      { cwd: options.worktreePath }
+    ).pipe(
+      Effect4.catchAll(
+        (error) => Effect4.fail(
+          new Error(`Failed to collect commit range: ${error.message}`)
+        )
+      )
+    );
+    const commits = result.stdout.trim();
+    if (!commits) {
+      options.logger.step(
+        "warn",
+        `No commits found between ${options.targetBase} and ${options.branchName}, proceeding with empty commit range`
+      );
+    }
+    let reviewArtifact;
+    if (options.reviewArtifactPath) {
+      const content = yield* fs.readFile(options.reviewArtifactPath).pipe(
+        Effect4.catchIf(
+          (error) => error.message.includes("ENOENT") || error.message.includes("no such file"),
+          () => Effect4.fail(
+            new Error(
+              `Review artifact not found at ${options.reviewArtifactPath}. Ensure the review stage completed before running finalizer generation.`
+            )
+          )
+        )
+      );
+      if (!content.trim()) {
+        return yield* Effect4.fail(
+          new Error(
+            `Review artifact at ${options.reviewArtifactPath} is empty. Ensure the review stage produced output before running finalizer generation.`
+          )
+        );
+      }
+      reviewArtifact = content;
+    } else {
+      reviewArtifact = "(no review artifact provided)";
+    }
+    return {
+      commits,
+      reviewArtifact,
+      targetBase: options.targetBase,
+      branchName: options.branchName
+    };
+  });
 }
 function remoteTargetBase(targetBase) {
   return targetBase.includes("/") ? targetBase : `origin/${targetBase}`;
 }
-async function readReviewArtifact(artifactPath) {
-  let content;
-  try {
-    content = await readFile(artifactPath, "utf-8");
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      throw new Error(
-        `Review artifact not found at ${artifactPath}. Ensure the review stage completed before running finalizer generation.`
-      );
-    }
-    throw error;
-  }
-  if (!content.trim()) {
-    throw new Error(
-      `Review artifact at ${artifactPath} is empty. Ensure the review stage produced output before running finalizer generation.`
-    );
-  }
-  return content;
-}
 function buildFinalizerPrompt(context, promptTemplate) {
-  const artifactPathInWorktree = join7(
+  const artifactPathInWorktree = join9(
     ".pourkit",
     ".tmp",
     "finalizer",
@@ -2326,133 +3094,182 @@ Write your finalizer output to: ${artifactPathInWorktree}`;
 }
 
 // commands/pr-description-agent.ts
-async function runFinalizerAgent(options) {
-  const {
-    executionProvider,
-    config,
-    target,
-    issue,
-    builderBranch,
-    worktreePath,
-    reviewArtifactPath,
-    repoRoot: repoRoot2,
-    logger
-  } = options;
-  const strategy = target.strategy;
-  const finalizer = strategy.finalize.prDescriptionAgent;
-  const context = await collectFinalizerContext({
-    targetBase: target.baseBranch,
-    branchName: builderBranch,
-    worktreePath,
-    reviewArtifactPath,
-    logger
-  });
-  const resolvedPrompt = loadFinalizerPrompt(
-    repoRoot2,
-    finalizer.promptTemplate
+import { Effect as Effect5, Layer as Layer2 } from "effect";
+function bridgeExecutionProvider(ep) {
+  return Layer2.succeed(
+    ExecutionProvider,
+    ExecutionProvider.of({
+      execute: (opts) => Effect5.tryPromise({
+        try: () => ep.execute(opts),
+        catch: (e) => new Error(
+          e instanceof Error ? e.message : `Execution failed: ${String(e)}`
+        )
+      })
+    })
   );
-  const prompt = buildFinalizerPrompt(context, resolvedPrompt);
-  const artifactPathInWorktree = join8(
+}
+function runFinalizerAgent(options) {
+  const { executionProvider } = options;
+  const artifactPathInWorktree = join10(
     ".pourkit",
     ".tmp",
     "finalizer",
     "agent-output.md"
   );
-  const artifactPath = join8(worktreePath, artifactPathInWorktree);
-  prepareArtifactPath(artifactPath);
-  let output = "";
-  let parsed;
-  let lastValidationError;
-  for (let attempt = 1; attempt <= strategy.finalize.maxAttempts; attempt++) {
-    logger.step(
-      "info",
-      `Running finalizer agent (${attempt}/${strategy.finalize.maxAttempts})`
+  const artifactPath = join10(options.worktreePath, artifactPathInWorktree);
+  const program = Effect5.gen(function* () {
+    const exec = yield* ExecutionProvider;
+    const fs = yield* FileSystem;
+    const context = yield* collectFinalizerContextEffect({
+      targetBase: options.target.baseBranch,
+      branchName: options.builderBranch,
+      worktreePath: options.worktreePath,
+      reviewArtifactPath: options.reviewArtifactPath,
+      logger: options.logger
+    }).pipe(
+      Effect5.catchAll(
+        (error) => Effect5.fail(
+          new FinalizerFailure({
+            message: `Failed to collect finalizer context: ${error.message}`
+          })
+        )
+      )
     );
-    const executionResult = await executionProvider.execute({
-      stage: "finalizer",
-      agent: finalizer.agent,
-      model: finalizer.model,
-      prompt,
-      target,
-      repoRoot: repoRoot2,
-      branchName: builderBranch,
-      sandbox: config.sandbox,
-      autoApprove: true,
-      artifactPath: artifactPathInWorktree,
-      worktreePath,
-      artifacts: [
-        buildRunContextArtifact({
-          issue,
-          target,
-          branchName: builderBranch,
-          reviewerCriteria: strategy.review.reviewer.criteria,
-          sections: STAGE_SECTIONS.finalizer
-        })
-      ],
-      logger
-    });
-    if (!executionResult.success) {
-      throw new Error(
-        `Finalizer agent execution failed: ${executionResult.error}`
+    const strategy = options.target.strategy;
+    const finalizer = strategy.finalize.prDescriptionAgent;
+    const resolvedPrompt = yield* loadFinalizerPromptEffect(
+      options.repoRoot,
+      finalizer.promptTemplate,
+      fs
+    );
+    const prompt = buildFinalizerPrompt(context, resolvedPrompt);
+    yield* prepareArtifactPathEffect(artifactPath, fs);
+    let output = "";
+    let parsed;
+    let lastValidationError;
+    for (let attempt = 1; attempt <= strategy.finalize.maxAttempts; attempt++) {
+      options.logger.step(
+        "info",
+        `Running finalizer agent (${attempt}/${strategy.finalize.maxAttempts})`
       );
-    }
-    try {
-      output = readAgentOutput(artifactPath);
-      parsed = parsePrDescription(output);
-      lastValidationError = void 0;
-      break;
-    } catch (error) {
-      lastValidationError = error instanceof PrDescriptionProtocolError ? new Error(`Finalizer protocol error: ${error.message}`) : error instanceof Error ? error : new Error(String(error));
-      if (attempt === strategy.finalize.maxAttempts) {
-        break;
+      const executionResult = yield* exec.execute({
+        stage: "finalizer",
+        agent: finalizer.agent,
+        model: finalizer.model,
+        prompt,
+        target: options.target,
+        repoRoot: options.repoRoot,
+        branchName: options.builderBranch,
+        sandbox: options.config.sandbox,
+        autoApprove: true,
+        artifactPath: artifactPathInWorktree,
+        worktreePath: options.worktreePath,
+        artifacts: [
+          buildRunContextArtifact({
+            issue: options.issue,
+            target: options.target,
+            branchName: options.builderBranch,
+            reviewerCriteria: strategy.review.reviewer.criteria,
+            sections: STAGE_SECTIONS.finalizer
+          })
+        ],
+        logger: options.logger
+      });
+      if (!executionResult.success) {
+        return yield* Effect5.fail(
+          new FinalizerFailure({
+            message: `Finalizer agent execution failed: ${executionResult.error}`
+          })
+        );
+      }
+      const readResult = yield* readAgentOutputEffect(artifactPath, fs);
+      if (readResult._tag === "content") {
+        output = readResult.value;
+        try {
+          parsed = parsePrDescription(output);
+          lastValidationError = void 0;
+          break;
+        } catch (error) {
+          lastValidationError = error instanceof PrDescriptionProtocolError ? new Error(`Finalizer protocol error: ${error.message}`) : error instanceof Error ? error : new Error(String(error));
+          if (attempt === strategy.finalize.maxAttempts) {
+            break;
+          }
+          yield* prepareArtifactPathEffect(artifactPath, fs);
+        }
+      } else if (readResult._tag === "empty") {
+        lastValidationError = new Error(
+          `Finalizer agent produced empty output at ${artifactPath}`
+        );
+        if (attempt === strategy.finalize.maxAttempts) {
+          break;
+        }
+        yield* prepareArtifactPathEffect(artifactPath, fs);
+      } else {
+        lastValidationError = new Error(
+          `Finalizer agent did not produce output at ${artifactPath}`
+        );
+        if (attempt === strategy.finalize.maxAttempts) {
+          break;
+        }
+        yield* prepareArtifactPathEffect(artifactPath, fs);
       }
-      prepareArtifactPath(artifactPath);
     }
-  }
-  if (!parsed) {
-    throw lastValidationError ?? new Error("Finalizer validation failed");
-  }
-  await persistGeneratedArtifact(worktreePath, output);
-  const title = ensureConventionalPrTitle(parsed.title, context.commits);
-  logger.step("info", "Finalizer output generated successfully");
-  return {
-    title,
-    body: parsed.body,
-    artifactPath
-  };
+    if (!parsed) {
+      return yield* Effect5.fail(
+        new FinalizerFailure({
+          message: lastValidationError?.message ?? "Finalizer validation failed"
+        })
+      );
+    }
+    yield* persistGeneratedArtifactEffect(options.worktreePath, output, fs);
+    options.logger.step("info", "Finalizer output generated successfully");
+    return {
+      title: ensureConventionalPrTitle(parsed.title, context.commits),
+      body: parsed.body,
+      artifactPath
+    };
+  });
+  const executionLayer = bridgeExecutionProvider(executionProvider);
+  return program.pipe(
+    Effect5.provide(
+      Layer2.mergeAll(executionLayer, FileSystemDefault, GitOperationsDefault)
+    )
+  );
 }
-function loadFinalizerPrompt(repoRoot2, promptTemplate) {
-  const promptPath = resolvePromptTemplatePath(repoRoot2, promptTemplate);
-  if (existsSync5(promptPath)) {
-    return readFileSync5(promptPath, "utf-8");
-  }
-  return promptTemplate;
+function loadFinalizerPromptEffect(repoRoot2, promptTemplate, fs) {
+  return Effect5.gen(function* () {
+    const promptPath = resolvePromptTemplatePath(repoRoot2, promptTemplate);
+    const exists = yield* fs.exists(promptPath).pipe(Effect5.orDie);
+    if (exists) {
+      return yield* fs.readFile(promptPath).pipe(Effect5.orDie);
+    }
+    return promptTemplate;
+  });
 }
-function prepareArtifactPath(artifactPath) {
-  mkdirSync4(dirname3(artifactPath), { recursive: true });
-  if (existsSync5(artifactPath)) {
-    rmSync(artifactPath);
-  }
+function prepareArtifactPathEffect(artifactPath, fs) {
+  return Effect5.gen(function* () {
+    yield* fs.mkdir(dirname4(artifactPath)).pipe(Effect5.orDie);
+    const exists = yield* fs.exists(artifactPath).pipe(Effect5.orDie);
+    if (exists) {
+      yield* fs.remove(artifactPath).pipe(Effect5.orDie);
+    }
+  });
 }
-function readAgentOutput(artifactPath) {
-  if (!existsSync5(artifactPath)) {
-    throw new Error(
-      `Finalizer agent did not produce output at ${artifactPath}`
-    );
-  }
-  const output = readFileSync5(artifactPath, "utf-8");
-  if (!output.trim()) {
-    throw new Error(`Finalizer agent produced empty output at ${artifactPath}`);
-  }
-  return output;
+function readAgentOutputEffect(artifactPath, fs) {
+  return Effect5.gen(function* () {
+    const exists = yield* fs.exists(artifactPath).pipe(Effect5.orDie);
+    if (!exists) return { _tag: "missing" };
+    const output = yield* fs.readFile(artifactPath).pipe(Effect5.catchAll(() => Effect5.succeed("")));
+    if (!output.trim()) return { _tag: "empty" };
+    return { _tag: "content", value: output };
+  });
 }
-async function persistGeneratedArtifact(worktreePath, output) {
-  try {
-    const dir = join8(worktreePath, ".pourkit", ".tmp", "finalizer");
-    mkdirSync4(dir, { recursive: true });
-    writeFileSync2(join8(dir, "generated.md"), output, "utf-8");
-  } catch {
-  }
+function persistGeneratedArtifactEffect(worktreePath, output, fs) {
+  return Effect5.gen(function* () {
+    const dir = join10(worktreePath, ".pourkit", ".tmp", "finalizer");
+    yield* fs.mkdir(dir).pipe(Effect5.catchAll(() => Effect5.void));
+    yield* fs.writeFile(join10(dir, "generated.md"), output).pipe(Effect5.catchAll(() => Effect5.void));
+  });
 }
 
 // pr/pr-body.ts
@@ -2635,7 +3452,15 @@ function secondsRemaining(deadline, observedAt) {
 }
 
 // issues/merge-coordinator.ts
-async function runMergeCoordinator(options) {
+import { Effect as Effect6, Either } from "effect";
+import { UnknownException as UnknownException2 } from "effect/Cause";
+function unwrapError2(error) {
+  if (error instanceof UnknownException2 && error.error !== void 0) {
+    return error.error;
+  }
+  return error;
+}
+function runMergeCoordinator(options) {
   const {
     prProvider,
     logger,
@@ -2646,56 +3471,70 @@ async function runMergeCoordinator(options) {
   } = options;
   const method = options.method ?? "squash";
   const waitForTargetGreen = options.waitForTargetGreen ?? true;
-  try {
-    await prProvider.waitForPrChecks(prNumber, checkWaitOptions);
-  } catch (error) {
-    return {
-      stage: "merge",
-      merged: false,
-      error: error instanceof Error ? error : new Error(String(error))
-    };
-  }
-  try {
-    await prProvider.mergePr(prNumber, {
-      method,
-      matchHeadCommit
-    });
-  } catch (error) {
-    return {
-      stage: "merge",
-      merged: false,
-      error: error instanceof Error ? error : new Error(String(error))
-    };
-  }
-  if (waitForTargetGreen) {
-    try {
-      await waitForBranchChecks(prProvider, logger, {
-        branchName: targetBranch,
-        checksFoundTimeoutMs: checkWaitOptions.checksFoundTimeoutMs,
-        checksCompletionTimeoutMs: checkWaitOptions.checksCompletionTimeoutMs,
-        pollIntervalMs: checkWaitOptions.pollIntervalMs
-      });
-    } catch (error) {
+  return Effect6.gen(function* () {
+    const checksEither = yield* Effect6.either(
+      Effect6.tryPromise(
+        () => prProvider.waitForPrChecks(prNumber, checkWaitOptions)
+      )
+    );
+    if (Either.isLeft(checksEither)) {
+      const rawError = checksEither.left;
+      const error = unwrapError2(rawError);
       return {
-        stage: "target-green",
-        merged: true,
+        stage: "merge",
+        merged: false,
         error: error instanceof Error ? error : new Error(String(error))
       };
     }
-  }
-  return { stage: "completed", merged: true };
+    const mergeEither = yield* Effect6.either(
+      Effect6.tryPromise(
+        () => prProvider.mergePr(prNumber, { method, matchHeadCommit })
+      )
+    );
+    if (Either.isLeft(mergeEither)) {
+      const rawError = mergeEither.left;
+      const error = unwrapError2(rawError);
+      return {
+        stage: "merge",
+        merged: false,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    }
+    if (waitForTargetGreen) {
+      const targetEither = yield* Effect6.either(
+        Effect6.tryPromise(
+          () => waitForBranchChecks(prProvider, logger, {
+            branchName: targetBranch,
+            checksFoundTimeoutMs: checkWaitOptions.checksFoundTimeoutMs,
+            checksCompletionTimeoutMs: checkWaitOptions.checksCompletionTimeoutMs,
+            pollIntervalMs: checkWaitOptions.pollIntervalMs
+          })
+        )
+      );
+      if (Either.isLeft(targetEither)) {
+        const rawError = targetEither.left;
+        const error = unwrapError2(rawError);
+        return {
+          stage: "target-green",
+          merged: true,
+          error: error instanceof Error ? error : new Error(String(error))
+        };
+      }
+    }
+    return { stage: "completed", merged: true };
+  });
 }
 
 // commands/review.ts
 import {
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync5,
-  readFileSync as readFileSync6,
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync7,
   readdirSync,
   rmSync as rmSync2,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "fs";
-import { dirname as dirname4, join as join9 } from "path";
+import { dirname as dirname5, join as join11 } from "path";
 
 // pr/review-verdict.ts
 var ReviewVerdictProtocolError = class extends Error {
@@ -2727,6 +3566,7 @@ function parseReviewVerdict(output) {
 }
 
 // commands/review.ts
+import { Effect as Effect7, Layer as Layer3 } from "effect";
 var ReviewArtifactValidationError = class extends Error {
   constructor(message) {
     super(message);
@@ -2777,12 +3617,12 @@ function extractLatestFindingIds(reviewOutput, iteration) {
   return ids;
 }
 function validateRefactorArtifact(artifactPath, findingIds) {
-  if (!existsSync6(artifactPath)) {
+  if (!existsSync7(artifactPath)) {
     throw new RefactorArtifactValidationError(
       `Refactor artifact missing at ${artifactPath}`
     );
   }
-  const content = readFileSync6(artifactPath, "utf-8");
+  const content = readFileSync7(artifactPath, "utf-8");
   if (!content.trim()) {
     throw new RefactorArtifactValidationError("Refactor artifact is empty");
   }
@@ -2881,7 +3721,7 @@ function validateReviewArtifact(output, verdict, iteration, priorRefactorArtifac
       );
     }
     const supersedesCell = cells[1];
-    if (supersedesCell !== "-" && supersedesCell !== "n/a" && !supersedesIdRegex.test(supersedesCell)) {
+    if (supersedesCell !== "-" && !supersedesIdRegex.test(supersedesCell)) {
       throw new ReviewArtifactValidationError(
         `Supersedes must be a hyphen for new findings or a valid finding ID, got: ${supersedesCell}`
       );
@@ -2900,16 +3740,25 @@ function validateReviewArtifact(output, verdict, iteration, priorRefactorArtifac
     }
   }
   if (priorRefactorArtifactsProvided) {
-    if (!output.includes("## Prior Refactor Response Assessment")) {
+    const verdictIndex = output.indexOf("<verdict>");
+    const assessmentIndex = output.indexOf(
+      "## Prior Refactor Response Assessment"
+    );
+    if (assessmentIndex === -1) {
       throw new ReviewArtifactValidationError(
         "Prior Refactor Artifacts were provided but the review is missing a ## Prior Refactor Response Assessment section"
       );
     }
+    if (verdictIndex !== -1 && assessmentIndex > verdictIndex) {
+      throw new ReviewArtifactValidationError(
+        "## Prior Refactor Response Assessment must appear before <verdict>"
+      );
+    }
   }
 }
-async function runReviewCommand(options) {
+function runReviewCommandEffect(options) {
   const {
-    executionProvider,
+    executionProvider: _executionProvider,
     config,
     target,
     issue,
@@ -2925,87 +3774,145 @@ async function runReviewCommand(options) {
   } = options;
   const reviewer = target.strategy.review.reviewer;
   if (!reviewer) {
-    throw new Error("No reviewer config found");
+    return Effect7.fail(
+      new ReviewerFailure({ message: "No reviewer config found" })
+    );
   }
-  const artifactPathInWorktree = join9(
+  const artifactPathInWorktree = join11(
     ".pourkit",
     ".tmp",
     "reviewers",
     `iteration-${iteration ?? 1}.md`
   );
-  const artifactPath = join9(worktreePath, artifactPathInWorktree);
-  prepareReviewArtifactPath(artifactPath);
-  const prompt = buildReviewerPrompt(
-    repoRoot2,
-    reviewer.promptTemplate,
-    reviewer.criteria,
-    artifactPathInWorktree,
-    iteration ?? 1,
-    reviewHistory,
-    priorRefactorArtifacts,
-    humanHandoffResolved,
-    priorReviewerArtifacts
-  );
-  logger.step("info", "Running reviewer");
-  const executionResult = await executionProvider.execute({
-    stage: "reviewer",
-    iteration,
-    agent: reviewer.agent,
-    model: reviewer.model,
-    prompt,
-    target,
-    repoRoot: repoRoot2,
-    branchName: builderBranch,
-    sandbox: config.sandbox,
-    autoApprove: true,
-    artifactPath: artifactPathInWorktree,
-    worktreePath,
-    artifacts: [
-      buildRunContextArtifact({
-        issue,
-        target,
-        branchName: builderBranch,
-        reviewerCriteria: reviewer.criteria,
-        sections: STAGE_SECTIONS.reviewer
-      })
-    ],
-    logger
-  });
-  if (!executionResult.success) {
-    throw new Error(`Reviewer execution failed: ${executionResult.error}`);
-  }
-  const output = readReviewArtifact2(artifactPath, executionResult.logPath);
-  let verdict;
-  try {
-    verdict = parseReviewVerdict(output);
-  } catch (error) {
-    if (error instanceof ReviewVerdictProtocolError) {
-      throw new Error(`Review protocol error: ${error.message}`);
+  const artifactPath = join11(worktreePath, artifactPathInWorktree);
+  return Effect7.gen(function* () {
+    const exec = yield* ExecutionProvider;
+    const fs = yield* FileSystem;
+    const prompt = yield* buildReviewerPromptEffect(
+      repoRoot2,
+      reviewer.promptTemplate,
+      reviewer.criteria,
+      artifactPathInWorktree,
+      iteration ?? 1,
+      fs,
+      reviewHistory,
+      priorRefactorArtifacts,
+      humanHandoffResolved,
+      priorReviewerArtifacts
+    );
+    yield* prepareReviewArtifactPathEffect(artifactPath, fs);
+    logger.step("info", "Running reviewer");
+    const executionResult = yield* exec.execute({
+      stage: "reviewer",
+      iteration,
+      agent: reviewer.agent,
+      model: reviewer.model,
+      prompt,
+      target,
+      repoRoot: repoRoot2,
+      branchName: builderBranch,
+      sandbox: config.sandbox,
+      autoApprove: true,
+      artifactPath: artifactPathInWorktree,
+      worktreePath,
+      artifacts: [
+        buildRunContextArtifact({
+          issue,
+          target,
+          branchName: builderBranch,
+          reviewerCriteria: reviewer.criteria,
+          sections: STAGE_SECTIONS.reviewer
+        })
+      ],
+      logger
+    });
+    if (!executionResult.success) {
+      return yield* Effect7.fail(
+        new ReviewerFailure({
+          message: `Reviewer execution failed: ${executionResult.error}`
+        })
+      );
     }
-    throw error;
-  }
-  logger.step("info", `Review verdict: ${verdict}`);
-  validateReviewArtifact(
-    output,
-    verdict,
-    iteration ?? 1,
-    !!priorRefactorArtifacts
+    const output = yield* readReviewArtifactEffect(
+      artifactPath,
+      executionResult.logPath,
+      fs
+    );
+    const parsedVerdict = yield* Effect7.try({
+      try: () => parseReviewVerdict(output),
+      catch: (error) => {
+        if (error instanceof ReviewVerdictProtocolError) {
+          return new ReviewerFailure({
+            message: `Review protocol error: ${error.message}`
+          });
+        }
+        throw error;
+      }
+    }).pipe(
+      Effect7.catchAll(
+        (error) => error instanceof ReviewerFailure ? Effect7.fail(error) : Effect7.die(error)
+      )
+    );
+    logger.step("info", `Review verdict: ${parsedVerdict}`);
+    try {
+      validateReviewArtifact(
+        output,
+        parsedVerdict,
+        iteration ?? 1,
+        !!priorRefactorArtifacts
+      );
+    } catch (error) {
+      if (error instanceof ReviewArtifactValidationError) {
+        return yield* Effect7.fail(
+          new ReviewerFailure({ message: error.message })
+        );
+      }
+      yield* Effect7.die(error);
+    }
+    return { verdict: parsedVerdict, output, artifactPath };
+  });
+}
+function bridgeExecutionProvider2(ep) {
+  return Layer3.succeed(
+    ExecutionProvider,
+    ExecutionProvider.of({
+      execute: (opts) => Effect7.tryPromise({
+        try: () => ep.execute(opts),
+        catch: (e) => new Error(
+          e instanceof Error ? e.message : `Execution failed: ${String(e)}`
+        )
+      })
+    })
   );
-  return { verdict, output, artifactPath };
 }
-function buildReviewerPrompt(repoRoot2, promptTemplate, criteria, artifactPathInWorktree, iteration, reviewHistory = [], priorRefactorArtifacts, humanHandoffResolved, priorReviewerArtifacts) {
-  const criteriaBlock = renderReviewCriteria(repoRoot2, criteria);
-  const { content: renderedTemplate, hasCriteriaPlaceholder } = loadReviewerPromptTemplate(repoRoot2, promptTemplate, criteriaBlock);
-  const priorRefactorBlock = priorRefactorArtifacts ? `${priorRefactorArtifacts}` : "";
-  const priorReviewerBlock = priorReviewerArtifacts ? `${priorReviewerArtifacts}` : "";
-  const humanHandoffBoundary = humanHandoffResolved ? `## Human-Resolved Handoff Boundary
+function buildReviewerPromptEffect(repoRoot2, promptTemplate, criteria, artifactPathInWorktree, iteration, fs, reviewHistory = [], priorRefactorArtifacts, humanHandoffResolved, priorReviewerArtifacts) {
+  return Effect7.gen(function* () {
+    const criteriaBlock = yield* renderReviewCriteriaEffect(
+      repoRoot2,
+      criteria,
+      fs
+    );
+    const { content: renderedTemplate, hasCriteriaPlaceholder } = yield* loadReviewerPromptTemplateEffect(
+      repoRoot2,
+      promptTemplate,
+      criteriaBlock,
+      fs
+    );
+    const priorRefactorBlock = priorRefactorArtifacts ? `${priorRefactorArtifacts}` : "";
+    const priorRefactorProtocolReminder = priorRefactorArtifacts ? `## Prior Refactor Protocol Reminder
+
+MANDATORY: because this prompt contains ## Prior Refactor Artifacts, your artifact must contain ## Prior Refactor Response Assessment exactly, before verdict. Section headings must match the names defined in this protocol exactly.
+
+` : "";
+    const priorReviewerBlock = priorReviewerArtifacts ? `${priorReviewerArtifacts}` : "";
+    const humanHandoffBoundary = humanHandoffResolved ? `## Human-Resolved Handoff Boundary
 
 A prior review emitted \`NEEDS_HUMAN\` and stopped the agent loop. The issue has since been moved back to \`ready-for-agent\`.
 
 Before carrying forward old blockers, inspect newer issue comments and the current worktree. Treat prior Reviewer and Refactor Artifacts as historical context, not active findings unless they still apply.
 
 ` : "";
-  return `${renderedTemplate}
+    return `${renderedTemplate}
 
 ## Shared Run Context
 
@@ -3015,7 +3922,7 @@ ${hasCriteriaPlaceholder ? "" : `## Review Criteria
 
 ${criteriaBlock}
 
-`}${humanHandoffBoundary}${priorReviewerBlock}${renderReviewHistory(reviewHistory)}${priorRefactorBlock}## Output
+`}${humanHandoffBoundary}${priorReviewerBlock}${renderReviewHistory(reviewHistory)}${priorRefactorBlock}${priorRefactorProtocolReminder}## Output
 
 Write your review to: ${artifactPathInWorktree}
 
@@ -3026,6 +3933,7 @@ End the file with exactly one wrapped verdict token: <verdict>PASS</verdict>, <v
 Findings must include an ID column with values in the format R${iteration}.F{findingNumber} (e.g., R${iteration}.F1, R${iteration}.F2) and a Supersedes column referencing the finding ID being superseded (or a hyphen for new findings).
 
 When verdict is NEEDS_HUMAN, include Human Handoff Summary and Human Handoff Reason sections before the final verdict token.`;
+  });
 }
 function renderReviewHistory(reviewHistory) {
   if (reviewHistory.length === 0) {
@@ -3039,150 +3947,147 @@ ${entry.trimEnd()}`).join("\n\n")}
 
 `;
 }
-function renderPriorRefactorArtifacts(worktreePath, currentIteration) {
-  const refactorsDir = join9(worktreePath, ".pourkit", ".tmp", "refactors");
-  if (!existsSync6(refactorsDir)) {
-    return "";
-  }
-  const files = readdirSync(refactorsDir);
-  const iterationFiles = [];
-  for (const file of files) {
-    const match = file.match(/^iteration-(\d+)\.md$/);
-    if (match) {
-      const num = parseInt(match[1], 10);
-      if (num < currentIteration) {
-        const filePath = join9(refactorsDir, file);
-        try {
-          const content = readFileSync6(filePath, "utf-8");
-          if (content.trim()) {
-            iterationFiles.push({ num, content });
-          }
-        } catch {
-        }
-      }
-    }
-  }
-  if (iterationFiles.length === 0) {
-    return "";
-  }
-  iterationFiles.sort((a, b) => a.num - b.num);
-  const iterationsBlocks = iterationFiles.map((f) => `### Refactor Iteration ${f.num}
+function renderPriorRefactorArtifactsEffect(worktreePath, currentIteration) {
+  return Effect7.gen(function* () {
+    const fb = yield* FileSystem;
+    const refactorsDir = join11(worktreePath, ".pourkit", ".tmp", "refactors");
+    const dirExists = yield* fb.exists(refactorsDir).pipe(Effect7.catchAll(() => Effect7.succeed(false)));
+    if (!dirExists) return "";
+    const iterationFiles = [];
+    for (let i = 0; i < currentIteration; i++) {
+      const filePath = join11(refactorsDir, `iteration-${i}.md`);
+      const fileExists = yield* fb.exists(filePath).pipe(Effect7.catchAll(() => Effect7.succeed(false)));
+      if (!fileExists) continue;
+      const content = yield* fb.readFile(filePath).pipe(Effect7.catchAll(() => Effect7.succeed("")));
+      if (content.trim()) {
+        iterationFiles.push({ num: i, content });
+      }
+    }
+    if (iterationFiles.length === 0) return "";
+    iterationFiles.sort((a, b) => a.num - b.num);
+    const iterationsBlocks = iterationFiles.map((f) => `### Refactor Iteration ${f.num}
 
 ${f.content.trimEnd()}`).join("\n\n");
-  return `## Prior Refactor Artifacts
+    return `## Prior Refactor Artifacts
 
 Treat these as conversational context, not source of truth. Inspect the current code independently.
 
 ${iterationsBlocks}
 
 `;
+  });
 }
-function renderPriorReviewerArtifacts(worktreePath, currentIteration) {
-  const reviewersDir = join9(worktreePath, ".pourkit", ".tmp", "reviewers");
-  if (!existsSync6(reviewersDir)) {
-    return "";
-  }
-  const files = readdirSync(reviewersDir);
-  const iterationFiles = [];
-  for (const file of files) {
-    const match = file.match(/^iteration-(\d+)\.md$/);
-    if (match) {
-      const num = parseInt(match[1], 10);
-      if (num < currentIteration) {
-        const filePath = join9(reviewersDir, file);
-        try {
-          const content = readFileSync6(filePath, "utf-8");
-          if (content.trim()) {
-            iterationFiles.push({ num, content });
-          }
-        } catch {
-        }
-      }
-    }
-  }
-  if (iterationFiles.length === 0) {
-    return "";
-  }
-  iterationFiles.sort((a, b) => a.num - b.num);
-  const iterationsBlocks = iterationFiles.map((f) => `### Reviewer Iteration ${f.num}
+function renderPriorReviewerArtifactsEffect(worktreePath, currentIteration) {
+  return Effect7.gen(function* () {
+    const fb = yield* FileSystem;
+    const reviewersDir = join11(worktreePath, ".pourkit", ".tmp", "reviewers");
+    const dirExists = yield* fb.exists(reviewersDir).pipe(Effect7.catchAll(() => Effect7.succeed(false)));
+    if (!dirExists) return "";
+    const iterationFiles = [];
+    for (let i = 0; i < currentIteration; i++) {
+      const filePath = join11(reviewersDir, `iteration-${i}.md`);
+      const fileExists = yield* fb.exists(filePath).pipe(Effect7.catchAll(() => Effect7.succeed(false)));
+      if (!fileExists) continue;
+      const content = yield* fb.readFile(filePath).pipe(Effect7.catchAll(() => Effect7.succeed("")));
+      if (content.trim()) {
+        iterationFiles.push({ num: i, content });
+      }
+    }
+    if (iterationFiles.length === 0) return "";
+    iterationFiles.sort((a, b) => a.num - b.num);
+    const iterationsBlocks = iterationFiles.map((f) => `### Reviewer Iteration ${f.num}
 
 ${f.content.trimEnd()}`).join("\n\n");
-  return `## Prior Reviewer Artifacts
+    return `## Prior Reviewer Artifacts
 
 A prior review was resolved by a human. These artifacts are historical context from before the handoff. Treat them as background, not active findings.
 
 ${iterationsBlocks}
 
 `;
+  });
 }
-function loadReviewerPromptTemplate(repoRoot2, promptTemplate, criteriaBlock) {
-  const promptTemplatePath = resolvePromptTemplatePath(
-    repoRoot2,
-    promptTemplate
-  );
-  const promptBody = existsSync6(promptTemplatePath) ? readFileSync6(promptTemplatePath, "utf-8") : promptTemplate;
-  const hasCriteriaPlaceholder = promptBody.includes("{{REVIEW_CRITERIA}}");
-  return {
-    content: promptBody.replace(/\{\{REVIEW_CRITERIA\}\}/g, criteriaBlock),
-    hasCriteriaPlaceholder
-  };
-}
-function renderReviewCriteria(repoRoot2, criteria) {
-  return criteria.map((criterion) => {
-    const snippetPath = join9(
+function loadReviewerPromptTemplateEffect(repoRoot2, promptTemplate, criteriaBlock, fs) {
+  return Effect7.gen(function* () {
+    const promptTemplatePath = resolvePromptTemplatePath(
       repoRoot2,
-      ".pourkit",
-      "prompts",
-      `reviewer-${criterion}.snippet.md`
+      promptTemplate
     );
-    if (existsSync6(snippetPath)) {
-      return readFileSync6(snippetPath, "utf-8").trimEnd();
-    }
-    return `- ${criterion}`;
-  }).join("\n\n");
+    const exists = yield* fs.exists(promptTemplatePath).pipe(Effect7.orDie);
+    const promptBody = exists ? yield* fs.readFile(promptTemplatePath).pipe(Effect7.orDie) : promptTemplate;
+    const hasCriteriaPlaceholder = promptBody.includes("{{REVIEW_CRITERIA}}");
+    return {
+      content: promptBody.replace(/\{\{REVIEW_CRITERIA\}\}/g, criteriaBlock),
+      hasCriteriaPlaceholder
+    };
+  });
 }
-function prepareReviewArtifactPath(artifactPath) {
-  mkdirSync5(dirname4(artifactPath), { recursive: true });
-  if (existsSync6(artifactPath)) {
-    rmSync2(artifactPath);
-  }
+function renderReviewCriteriaEffect(repoRoot2, criteria, fs) {
+  return Effect7.gen(function* () {
+    const parts = [];
+    for (const criterion of criteria) {
+      const snippetPath = join11(
+        repoRoot2,
+        ".pourkit",
+        "prompts",
+        `reviewer-${criterion}.snippet.md`
+      );
+      const exists = yield* fs.exists(snippetPath).pipe(Effect7.orDie);
+      if (exists) {
+        const content = yield* fs.readFile(snippetPath).pipe(Effect7.orDie);
+        parts.push(content.trimEnd());
+      } else {
+        parts.push(`- ${criterion}`);
+      }
+    }
+    return parts.join("\n\n");
+  });
 }
-function recoverReviewOutputFromLog(logPath) {
-  if (!existsSync6(logPath)) {
-    return null;
-  }
-  const logContent = readFileSync6(logPath, "utf-8");
+function recoverReviewOutputFromString(logContent) {
   const startIndex = logContent.indexOf("## Findings");
-  if (startIndex === -1) {
-    return null;
-  }
+  if (startIndex === -1) return null;
   const verdictMatch = logContent.slice(startIndex).match(
     /<verdict>(PASS|PASS_WITH_NOTES|NEEDS_REFACTOR|FAIL|NEEDS_HUMAN)<\/verdict>/
   );
-  if (!verdictMatch || verdictMatch.index === void 0) {
-    return null;
-  }
+  if (!verdictMatch || verdictMatch.index === void 0) return null;
   const recoveredOutput = logContent.slice(startIndex, startIndex + verdictMatch.index + verdictMatch[0].length).trim();
   return recoveredOutput.length > 0 ? recoveredOutput : null;
 }
-function readReviewArtifact2(artifactPath, logPath) {
-  if (existsSync6(artifactPath)) {
-    const output = readFileSync6(artifactPath, "utf-8");
-    if (output.trim()) {
-      return output;
+function prepareReviewArtifactPathEffect(artifactPath, fs) {
+  return Effect7.gen(function* () {
+    yield* fs.mkdir(dirname5(artifactPath)).pipe(Effect7.orDie);
+    const exists = yield* fs.exists(artifactPath).pipe(Effect7.orDie);
+    if (exists) {
+      yield* fs.remove(artifactPath).pipe(Effect7.orDie);
     }
-  }
-  const recoveredOutput = logPath ? recoverReviewOutputFromLog(logPath) : null;
-  if (recoveredOutput) {
-    writeFileSync3(artifactPath, recoveredOutput, "utf-8");
-    return recoveredOutput;
-  }
-  if (!existsSync6(artifactPath)) {
-    throw new Error(`Reviewer did not produce output at ${artifactPath}`);
-  }
-  throw new Error(`Reviewer produced empty output at ${artifactPath}`);
+  });
 }
-async function runReviewWithRefactorLoop(options) {
+function readReviewArtifactEffect(artifactPath, logPath, fs) {
+  return Effect7.gen(function* () {
+    const artifactExists = yield* fs.exists(artifactPath).pipe(Effect7.orDie);
+    if (artifactExists) {
+      const output = yield* fs.readFile(artifactPath).pipe(Effect7.orDie);
+      if (output.trim()) return output;
+    }
+    if (logPath) {
+      const logExists = yield* fs.exists(logPath).pipe(Effect7.orDie);
+      if (logExists) {
+        const logContent = yield* fs.readFile(logPath).pipe(Effect7.orDie);
+        const recovered = recoverReviewOutputFromString(logContent);
+        if (recovered) {
+          yield* fs.writeFile(artifactPath, recovered).pipe(Effect7.orDie);
+          return recovered;
+        }
+      }
+    }
+    return yield* Effect7.fail(
+      new ReviewerFailure({
+        message: artifactExists ? `Reviewer produced empty output at ${artifactPath}` : `Reviewer did not produce output at ${artifactPath}`
+      })
+    );
+  });
+}
+function runReviewWithRefactorLoop(options) {
   const {
     executionProvider,
     config,
@@ -3199,247 +4104,325 @@ async function runReviewWithRefactorLoop(options) {
   const strategy = target.strategy;
   const reviewer = strategy.review.reviewer;
   if (!reviewer) {
-    throw new Error("No reviewer config found");
+    return Effect7.die(new Error("No reviewer config found"));
   }
   const refactorer = strategy.review.refactor;
   if (!refactorer) {
-    throw new Error("No refactorer config found");
+    return Effect7.die(new Error("No refactorer config found"));
   }
   const maxIterations = strategy.review.maxIterations;
   const passWithNotesRefactorAttempts = strategy.review.passWithNotesRefactorAttempts;
-  let resolvedStartingIteration = startingLifetimeIteration;
-  {
-    const reviewersDir = join9(worktreePath, ".pourkit", ".tmp", "reviewers");
-    try {
-      const files = readdirSync(reviewersDir);
-      let maxExistingIteration = 0;
-      for (const file of files) {
-        const match = file.match(/^iteration-(\d+)\.md$/);
-        if (match) {
-          const num = parseInt(match[1], 10);
-          if (num > maxExistingIteration) {
-            maxExistingIteration = num;
-          }
-        }
-      }
-      if (maxExistingIteration > resolvedStartingIteration) {
-        resolvedStartingIteration = maxExistingIteration;
-      }
-    } catch {
-    }
-  }
-  const accumulatedRefactorPaths = [];
-  let iteration = 0;
-  let lastResult = null;
-  const reviewHistory = [];
-  let passWithNotesRefactorAttemptsRemaining = passWithNotesRefactorAttempts;
-  const priorReviewerArtifacts = humanHandoffResolved ? renderPriorReviewerArtifacts(
-    worktreePath,
-    resolvedStartingIteration + 1
-  ) || void 0 : void 0;
-  while (iteration < maxIterations) {
-    iteration++;
-    const lifetimeIteration = resolvedStartingIteration + iteration;
-    logger.step("info", `Review iteration ${lifetimeIteration}`);
-    const priorRefactorArtifacts = renderPriorRefactorArtifacts(
-      worktreePath,
-      lifetimeIteration
-    );
-    const reviewResult = await runReviewCommand({
-      executionProvider,
-      config,
-      target,
-      issue,
-      builderBranch,
-      worktreePath,
-      repoRoot: repoRoot2,
-      logger,
-      iteration: lifetimeIteration,
-      priorRefactorArtifacts: priorRefactorArtifacts || void 0,
-      humanHandoffResolved,
-      priorReviewerArtifacts,
-      reviewHistory: reviewer.includeReviewHistory && reviewHistory.length > 0 ? [...reviewHistory] : void 0
-    });
-    lastResult = reviewResult;
-    reviewHistory.push(reviewResult.output);
-    await persistIterationArtifact(
-      worktreePath,
-      reviewResult.output,
-      lifetimeIteration
-    );
-    if (reviewResult.verdict === "PASS") {
-      return {
-        verdict: reviewResult.verdict,
-        output: reviewResult.output,
-        artifactPath: reviewResult.artifactPath,
-        iterations: iteration,
-        lifetimeIterations: lifetimeIteration,
-        exhaustedMaxIterations: false,
-        refactorCompletedForLastReview: false,
-        refactorArtifactPaths: accumulatedRefactorPaths.length > 0 ? accumulatedRefactorPaths : void 0
-      };
-    }
-    if (reviewResult.verdict === "PASS_WITH_NOTES" && passWithNotesRefactorAttemptsRemaining === 0) {
-      logger.step(
-        "info",
-        "PASS_WITH_NOTES refactor attempts exhausted, treating as PASS"
-      );
-      return {
-        verdict: "PASS",
-        output: reviewResult.output,
-        artifactPath: reviewResult.artifactPath,
-        iterations: iteration,
-        lifetimeIterations: lifetimeIteration,
-        exhaustedMaxIterations: false,
-        refactorCompletedForLastReview: false,
-        refactorArtifactPaths: accumulatedRefactorPaths.length > 0 ? accumulatedRefactorPaths : void 0
-      };
-    }
-    if (reviewResult.verdict === "PASS_WITH_NOTES") {
-      passWithNotesRefactorAttemptsRemaining--;
-      logger.step(
-        "info",
-        `PASS_WITH_NOTES refactor attempts remaining: ${passWithNotesRefactorAttemptsRemaining}`
-      );
-    }
-    if (reviewResult.verdict === "NEEDS_HUMAN") {
-      logger.step("info", "NEEDS_HUMAN verdict, stopping review loop");
-      return {
-        verdict: "NEEDS_HUMAN",
-        output: reviewResult.output,
-        artifactPath: reviewResult.artifactPath,
-        iterations: iteration,
-        lifetimeIterations: lifetimeIteration,
-        exhaustedMaxIterations: false,
-        refactorCompletedForLastReview: false,
-        refactorArtifactPaths: accumulatedRefactorPaths.length > 0 ? accumulatedRefactorPaths : void 0
-      };
+  let resolvedStartingIteration = startingLifetimeIteration;
+  {
+    const reviewersDir = join11(worktreePath, ".pourkit", ".tmp", "reviewers");
+    try {
+      const files = readdirSync(reviewersDir);
+      let maxExistingIteration = 0;
+      for (const file of files) {
+        const match = file.match(/^iteration-(\d+)\.md$/);
+        if (match) {
+          const num = parseInt(match[1], 10);
+          if (num > maxExistingIteration) {
+            maxExistingIteration = num;
+          }
+        }
+      }
+      if (maxExistingIteration > resolvedStartingIteration) {
+        resolvedStartingIteration = maxExistingIteration;
+      }
+    } catch {
     }
-    if (reviewResult.verdict === "NEEDS_REFACTOR" || reviewResult.verdict === "PASS_WITH_NOTES" || reviewResult.verdict === "FAIL") {
-      logger.step("info", "Running refactor agent");
-      const refactorArtifactPathInWorktree = join9(
-        ".pourkit",
-        ".tmp",
-        "refactors",
-        `iteration-${lifetimeIteration}.md`
-      );
-      const refactorPrompt = buildRefactorPrompt(
-        repoRoot2,
-        refactorer.promptTemplate,
-        reviewResult.output,
-        refactorArtifactPathInWorktree
-      );
-      const refactorResult = await executionProvider.execute({
-        stage: "refactor",
-        iteration: lifetimeIteration,
-        agent: refactorer.agent,
-        model: refactorer.model,
-        prompt: refactorPrompt,
-        target,
-        repoRoot: repoRoot2,
-        branchName: builderBranch,
-        sandbox: config.sandbox,
-        autoApprove: true,
-        artifactPath: refactorArtifactPathInWorktree,
-        worktreePath,
-        artifacts: [
-          buildRunContextArtifact({
-            issue,
-            target,
-            branchName: builderBranch,
-            reviewerCriteria: reviewer.criteria,
-            sections: STAGE_SECTIONS.refactor
-          })
-        ],
-        ...serena ? { serena } : {},
-        logger
-      });
-      if (!refactorResult.success) {
-        logger.step(
-          "warn",
-          "Refactor execution failed, transitioning to ready-for-human"
+  }
+  const program = Effect7.gen(function* () {
+    const exec = yield* ExecutionProvider;
+    const fs = yield* FileSystem;
+    const priorReviewerArtifacts = humanHandoffResolved ? (yield* renderPriorReviewerArtifactsEffect(
+      worktreePath,
+      resolvedStartingIteration + 1
+    )) || void 0 : void 0;
+    const initialState = {
+      done: false,
+      iteration: 0,
+      lastResult: null,
+      reviewHistory: [],
+      passWithNotesRefactorAttemptsRemaining: passWithNotesRefactorAttempts,
+      accumulatedRefactorPaths: [],
+      doneResult: null
+    };
+    const finalState = yield* Effect7.iterate(initialState, {
+      while: (s) => !s.done && s.iteration < maxIterations,
+      body: (s) => Effect7.gen(function* () {
+        const iteration = s.iteration + 1;
+        const lifetimeIteration = resolvedStartingIteration + iteration;
+        logger.step("info", `Review iteration ${lifetimeIteration}`);
+        const priorRefactorArtifactsStr = yield* renderPriorRefactorArtifactsEffect(
+          worktreePath,
+          lifetimeIteration
         );
-        return {
-          verdict: "FAIL",
-          output: reviewResult.output,
-          artifactPath: reviewResult.artifactPath,
-          iterations: iteration,
-          lifetimeIterations: resolvedStartingIteration + iteration,
-          exhaustedMaxIterations: false,
-          refactorCompletedForLastReview: false,
-          refactorArtifactPaths: accumulatedRefactorPaths.length > 0 ? accumulatedRefactorPaths : void 0
-        };
-      }
-      const latestFindingIds = extractLatestFindingIds(
-        reviewResult.output,
-        lifetimeIteration
-      );
-      const refactorArtifactPath = join9(
-        worktreePath,
-        refactorArtifactPathInWorktree
-      );
-      try {
-        validateRefactorArtifact(refactorArtifactPath, latestFindingIds);
-      } catch (error) {
-        if (error instanceof RefactorArtifactValidationError) {
+        const reviewResult = yield* runReviewCommandEffect({
+          executionProvider: null,
+          config,
+          target,
+          issue,
+          builderBranch,
+          worktreePath,
+          repoRoot: repoRoot2,
+          logger,
+          iteration: lifetimeIteration,
+          priorRefactorArtifacts: priorRefactorArtifactsStr || void 0,
+          humanHandoffResolved,
+          priorReviewerArtifacts,
+          reviewHistory: reviewer.includeReviewHistory && s.reviewHistory.length > 0 ? [...s.reviewHistory] : void 0
+        });
+        const updatedHistory = [...s.reviewHistory, reviewResult.output];
+        yield* persistIterationArtifactEffect(
+          worktreePath,
+          reviewResult.output,
+          lifetimeIteration,
+          fs
+        );
+        if (reviewResult.verdict === "PASS") {
+          return {
+            ...s,
+            done: true,
+            iteration,
+            lastResult: reviewResult,
+            reviewHistory: updatedHistory,
+            doneResult: {
+              verdict: reviewResult.verdict,
+              output: reviewResult.output,
+              artifactPath: reviewResult.artifactPath,
+              iterations: iteration,
+              lifetimeIterations: lifetimeIteration,
+              exhaustedMaxIterations: false,
+              refactorCompletedForLastReview: false,
+              refactorArtifactPaths: s.accumulatedRefactorPaths.length > 0 ? [...s.accumulatedRefactorPaths] : void 0
+            }
+          };
+        }
+        if (reviewResult.verdict === "PASS_WITH_NOTES" && s.passWithNotesRefactorAttemptsRemaining === 0) {
           logger.step(
-            "warn",
-            `Refactor artifact validation failed: ${error.message}`
+            "info",
+            "PASS_WITH_NOTES refactor attempts exhausted, treating as PASS"
           );
           return {
-            verdict: "FAIL",
-            output: reviewResult.output,
-            artifactPath: reviewResult.artifactPath,
-            iterations: iteration,
-            lifetimeIterations: resolvedStartingIteration + iteration,
-            exhaustedMaxIterations: false,
-            refactorCompletedForLastReview: false,
-            refactorArtifactPaths: accumulatedRefactorPaths.length > 0 ? accumulatedRefactorPaths : void 0
+            ...s,
+            done: true,
+            iteration,
+            lastResult: reviewResult,
+            reviewHistory: updatedHistory,
+            doneResult: {
+              verdict: "PASS",
+              output: reviewResult.output,
+              artifactPath: reviewResult.artifactPath,
+              iterations: iteration,
+              lifetimeIterations: lifetimeIteration,
+              exhaustedMaxIterations: false,
+              refactorCompletedForLastReview: false,
+              refactorArtifactPaths: s.accumulatedRefactorPaths.length > 0 ? [...s.accumulatedRefactorPaths] : void 0
+            }
           };
         }
-        throw error;
-      }
-      accumulatedRefactorPaths.push(refactorArtifactPath);
-      if (options.onRefactorProgress) {
-        await options.onRefactorProgress({
-          lifetimeIterations: resolvedStartingIteration + iteration,
-          lastVerdict: reviewResult.verdict,
-          lastArtifactPath: reviewResult.artifactPath,
-          refactorArtifactPath
-        });
-      }
+        let updatedPassWithNotesRefactorAttemptsRemaining = s.passWithNotesRefactorAttemptsRemaining;
+        if (reviewResult.verdict === "PASS_WITH_NOTES") {
+          updatedPassWithNotesRefactorAttemptsRemaining--;
+          logger.step(
+            "info",
+            `PASS_WITH_NOTES refactor attempts remaining: ${updatedPassWithNotesRefactorAttemptsRemaining}`
+          );
+        }
+        if (reviewResult.verdict === "NEEDS_HUMAN") {
+          logger.step("info", "NEEDS_HUMAN verdict, stopping review loop");
+          return {
+            ...s,
+            done: true,
+            iteration,
+            lastResult: reviewResult,
+            reviewHistory: updatedHistory,
+            doneResult: {
+              verdict: "NEEDS_HUMAN",
+              output: reviewResult.output,
+              artifactPath: reviewResult.artifactPath,
+              iterations: iteration,
+              lifetimeIterations: lifetimeIteration,
+              exhaustedMaxIterations: false,
+              refactorCompletedForLastReview: false,
+              refactorArtifactPaths: s.accumulatedRefactorPaths.length > 0 ? [...s.accumulatedRefactorPaths] : void 0
+            }
+          };
+        }
+        if (reviewResult.verdict === "NEEDS_REFACTOR" || reviewResult.verdict === "PASS_WITH_NOTES" || reviewResult.verdict === "FAIL") {
+          logger.step("info", "Running refactor agent");
+          const refactorArtifactPathInWorktree = join11(
+            ".pourkit",
+            ".tmp",
+            "refactors",
+            `iteration-${lifetimeIteration}.md`
+          );
+          const refactorPrompt = yield* buildRefactorPromptEffect(
+            repoRoot2,
+            refactorer.promptTemplate,
+            reviewResult.output,
+            refactorArtifactPathInWorktree,
+            fs
+          );
+          const refactorResult = yield* exec.execute({
+            stage: "refactor",
+            iteration: lifetimeIteration,
+            agent: refactorer.agent,
+            model: refactorer.model,
+            prompt: refactorPrompt,
+            target,
+            repoRoot: repoRoot2,
+            branchName: builderBranch,
+            sandbox: config.sandbox,
+            autoApprove: true,
+            artifactPath: refactorArtifactPathInWorktree,
+            worktreePath,
+            artifacts: [
+              buildRunContextArtifact({
+                issue,
+                target,
+                branchName: builderBranch,
+                reviewerCriteria: reviewer.criteria,
+                sections: STAGE_SECTIONS.refactor
+              })
+            ],
+            ...serena ? { serena } : {},
+            logger
+          });
+          if (!refactorResult.success) {
+            logger.step(
+              "warn",
+              "Refactor execution failed, transitioning to ready-for-human"
+            );
+            return {
+              ...s,
+              done: true,
+              iteration,
+              lastResult: reviewResult,
+              reviewHistory: updatedHistory,
+              doneResult: {
+                verdict: "FAIL",
+                output: reviewResult.output,
+                artifactPath: reviewResult.artifactPath,
+                iterations: iteration,
+                lifetimeIterations: resolvedStartingIteration + iteration,
+                exhaustedMaxIterations: false,
+                refactorCompletedForLastReview: false,
+                refactorArtifactPaths: s.accumulatedRefactorPaths.length > 0 ? [...s.accumulatedRefactorPaths] : void 0
+              }
+            };
+          }
+          const latestFindingIds = extractLatestFindingIds(
+            reviewResult.output,
+            lifetimeIteration
+          );
+          const refactorArtifactPath = join11(
+            worktreePath,
+            refactorArtifactPathInWorktree
+          );
+          try {
+            validateRefactorArtifact(refactorArtifactPath, latestFindingIds);
+          } catch (error) {
+            if (error instanceof RefactorArtifactValidationError) {
+              logger.step(
+                "warn",
+                `Refactor artifact validation failed: ${error.message}`
+              );
+              return {
+                ...s,
+                done: true,
+                iteration,
+                lastResult: reviewResult,
+                reviewHistory: updatedHistory,
+                doneResult: {
+                  verdict: "FAIL",
+                  output: reviewResult.output,
+                  artifactPath: reviewResult.artifactPath,
+                  iterations: iteration,
+                  lifetimeIterations: resolvedStartingIteration + iteration,
+                  exhaustedMaxIterations: false,
+                  refactorCompletedForLastReview: false,
+                  refactorArtifactPaths: s.accumulatedRefactorPaths.length > 0 ? [...s.accumulatedRefactorPaths] : void 0
+                }
+              };
+            }
+            yield* Effect7.die(error);
+          }
+          const updatedAccumulated = [
+            ...s.accumulatedRefactorPaths,
+            refactorArtifactPath
+          ];
+          if (options.onRefactorProgress) {
+            yield* Effect7.promise(
+              () => Promise.resolve(
+                options.onRefactorProgress({
+                  lifetimeIterations: resolvedStartingIteration + iteration,
+                  lastVerdict: reviewResult.verdict,
+                  lastArtifactPath: reviewResult.artifactPath,
+                  refactorArtifactPath
+                })
+              )
+            );
+          }
+          return {
+            done: false,
+            iteration,
+            lastResult: reviewResult,
+            reviewHistory: updatedHistory,
+            passWithNotesRefactorAttemptsRemaining: updatedPassWithNotesRefactorAttemptsRemaining,
+            accumulatedRefactorPaths: updatedAccumulated,
+            doneResult: null
+          };
+        }
+        return {
+          done: false,
+          iteration,
+          lastResult: reviewResult,
+          reviewHistory: updatedHistory,
+          passWithNotesRefactorAttemptsRemaining: updatedPassWithNotesRefactorAttemptsRemaining,
+          accumulatedRefactorPaths: s.accumulatedRefactorPaths,
+          doneResult: null
+        };
+      })
+    });
+    if (finalState.done && finalState.doneResult) {
+      return finalState.doneResult;
     }
-  }
-  logger.step("warn", `Max review iterations (${maxIterations}) exhausted`);
-  return {
-    verdict: "FAIL",
-    output: lastResult?.output ?? "",
-    artifactPath: lastResult?.artifactPath ?? "",
-    iterations: iteration,
-    lifetimeIterations: resolvedStartingIteration + iteration,
-    exhaustedMaxIterations: true,
-    refactorCompletedForLastReview: true,
-    refactorArtifactPaths: accumulatedRefactorPaths.length > 0 ? accumulatedRefactorPaths : void 0
-  };
-}
-async function writeArtifact(worktreePath, filename, output) {
-  try {
-    const dir = join9(worktreePath, ".pourkit", ".tmp", "reviewers");
-    mkdirSync5(dir, { recursive: true });
-    writeFileSync3(join9(dir, filename), output, "utf-8");
-  } catch {
-  }
+    logger.step("warn", `Max review iterations (${maxIterations}) exhausted`);
+    return {
+      verdict: "FAIL",
+      output: finalState.lastResult?.output ?? "",
+      artifactPath: finalState.lastResult?.artifactPath ?? "",
+      iterations: finalState.iteration,
+      lifetimeIterations: resolvedStartingIteration + finalState.iteration,
+      exhaustedMaxIterations: true,
+      refactorCompletedForLastReview: true,
+      refactorArtifactPaths: finalState.accumulatedRefactorPaths.length > 0 ? [...finalState.accumulatedRefactorPaths] : void 0
+    };
+  });
+  const executionLayer = bridgeExecutionProvider2(executionProvider);
+  return program.pipe(
+    Effect7.provide(Layer3.merge(executionLayer, FileSystemDefault))
+  );
 }
-async function persistIterationArtifact(worktreePath, output, iteration) {
-  await writeArtifact(worktreePath, `iteration-${iteration}.md`, output);
+function persistIterationArtifactEffect(worktreePath, output, iteration, fs) {
+  return Effect7.gen(function* () {
+    const dir = join11(worktreePath, ".pourkit", ".tmp", "reviewers");
+    yield* fs.mkdir(dir).pipe(Effect7.catchAll(() => Effect7.void));
+    yield* fs.writeFile(join11(dir, `iteration-${iteration}.md`), output).pipe(Effect7.catchAll(() => Effect7.void));
+  });
 }
-function buildRefactorPrompt(repoRoot2, promptTemplate, latestReview, artifactPathInWorktree) {
-  const promptTemplatePath = resolvePromptTemplatePath(
-    repoRoot2,
-    promptTemplate
-  );
-  const promptBody = existsSync6(promptTemplatePath) ? readFileSync6(promptTemplatePath, "utf-8") : promptTemplate;
-  return appendProtectedWorkGuidance(`${promptBody}
+function buildRefactorPromptEffect(repoRoot2, promptTemplate, latestReview, artifactPathInWorktree, fs) {
+  return Effect7.gen(function* () {
+    const promptTemplatePath = resolvePromptTemplatePath(
+      repoRoot2,
+      promptTemplate
+    );
+    const exists = yield* fs.exists(promptTemplatePath).pipe(Effect7.orDie);
+    const promptBody = exists ? yield* fs.readFile(promptTemplatePath).pipe(Effect7.orDie) : promptTemplate;
+    return appendProtectedWorkGuidance(`${promptBody}
 
 ## Shared Run Context
 
@@ -3454,6 +4437,7 @@ ${latestReview.trimEnd()}
 Write your refactor artifact to: ${artifactPathInWorktree}
 
 When you are done, finish with <promise>COMPLETE</promise>.`);
+  });
 }
 
 // issues/issue-transitions.ts
@@ -3706,7 +4690,7 @@ async function startIssueRun(options) {
       prNumber: existingPr?.number,
       prState: existingPr?.state
     });
-    if (Exit2.isSuccess(exit)) {
+    if (Exit3.isSuccess(exit)) {
       const refreshResult = exit.value;
       if (refreshResult.status === "refreshed") {
         if (worktreeState?.completedStages.builder) {
@@ -3858,22 +4842,24 @@ async function startIssueRun(options) {
 }
 async function advanceIssueRunReview(options) {
   const accumulatedRefactorPaths = [];
-  const reviewResult = await runReviewWithRefactorLoop({
-    ...options,
-    onRefactorProgress: async (progress) => {
-      if (progress.refactorArtifactPath) {
-        accumulatedRefactorPaths.push(progress.refactorArtifactPath);
-      }
-      updateWorktreeRunState(options.worktreePath, {
-        review: {
-          lifetimeIterations: progress.lifetimeIterations,
-          lastVerdict: progress.lastVerdict,
-          lastArtifactPath: progress.lastArtifactPath,
-          refactorCompletedForLastReview: true
+  const reviewResult = await runEffectAndMapExit(
+    runReviewWithRefactorLoop({
+      ...options,
+      onRefactorProgress: (progress) => {
+        if (progress.refactorArtifactPath) {
+          accumulatedRefactorPaths.push(progress.refactorArtifactPath);
         }
-      });
-    }
-  });
+        updateWorktreeRunState(options.worktreePath, {
+          review: {
+            lifetimeIterations: progress.lifetimeIterations,
+            lastVerdict: progress.lastVerdict,
+            lastArtifactPath: progress.lastArtifactPath,
+            refactorCompletedForLastReview: true
+          }
+        });
+      }
+    })
+  );
   updateWorktreeRunState(options.worktreePath, {
     review: {
       lifetimeIterations: reviewResult.lifetimeIterations,
@@ -3932,12 +4918,12 @@ async function completeIssueRun(options) {
         prTitle = finalizerFromState.title;
         prBody = finalizerFromState.body;
       } else if (finalizerFromState.artifactPath) {
-        if (!existsSync7(finalizerFromState.artifactPath)) {
-          throw new Error(
-            `Finalizer artifact missing at ${finalizerFromState.artifactPath}`
-          );
+        if (!existsSync8(finalizerFromState.artifactPath)) {
+          throw new FinalizerFailure({
+            message: `Finalizer artifact missing at ${finalizerFromState.artifactPath}`
+          });
         }
-        const artifactContent = readFileSync7(
+        const artifactContent = readFileSync8(
           finalizerFromState.artifactPath,
           "utf-8"
         );
@@ -3945,22 +4931,24 @@ async function completeIssueRun(options) {
         prTitle = parsed.title;
         prBody = parsed.body;
       } else {
-        throw new Error(
-          "Finalizer state is incomplete: missing title, body, and artifactPath"
-        );
+        throw new FinalizerFailure({
+          message: "Finalizer state is incomplete: missing title, body, and artifactPath"
+        });
       }
     } else {
-      finalizerResult = await runFinalizerAgent({
-        executionProvider,
-        config,
-        target,
-        issue,
-        builderBranch: branchName,
-        worktreePath: executionResult.worktreePath,
-        reviewArtifactPath,
-        repoRoot: ROOT,
-        logger
-      });
+      finalizerResult = await runEffectAndMapExit(
+        runFinalizerAgent({
+          executionProvider,
+          config,
+          target,
+          issue,
+          builderBranch: branchName,
+          worktreePath: executionResult.worktreePath,
+          reviewArtifactPath,
+          repoRoot: ROOT,
+          logger
+        })
+      );
       prTitle = finalizerResult.title;
       prBody = finalizerResult.body;
     }
@@ -4070,16 +5058,18 @@ async function completeIssueRun(options) {
       await issueProvider.addLabels(issueNumber, [
         config.labels.prOpenAwaitingMerge
       ]);
-      const coordinatorResult = await runMergeCoordinator({
-        prProvider,
-        logger,
-        prNumber: pr.number,
-        targetBranch: target.baseBranch,
-        matchHeadCommit: pr.headRefOid,
-        checkWaitOptions,
-        autoMerge: true,
-        pr
-      });
+      const coordinatorResult = await runEffectAndMapExit(
+        runMergeCoordinator({
+          prProvider,
+          logger,
+          prNumber: pr.number,
+          targetBranch: target.baseBranch,
+          matchHeadCommit: pr.headRefOid,
+          checkWaitOptions,
+          autoMerge: true,
+          pr
+        })
+      );
       if (coordinatorResult.stage === "merge") {
         throw coordinatorResult.error;
       }
@@ -4250,7 +5240,10 @@ async function guardFinalCommitContent(options) {
     label: "git diff --cached secret guard"
   });
   assertNoSecretLikeContent([
-    { source: "staged diff", content: stagedDiff.stdout },
+    {
+      source: "staged diff",
+      content: extractAddedDiffContent(stagedDiff.stdout)
+    },
     { source: "commit title", content: title },
     { source: "commit body", content: body }
   ]);
@@ -4263,11 +5256,17 @@ async function guardFinalPublishContent(options) {
     label: "git diff final secret guard"
   });
   assertNoSecretLikeContent([
-    { source: "final diff", content: finalDiff.stdout },
+    {
+      source: "final diff",
+      content: extractAddedDiffContent(finalDiff.stdout)
+    },
     { source: "PR title", content: title },
     { source: "PR body", content: body }
   ]);
 }
+function extractAddedDiffContent(diff) {
+  return diff.split(/\r?\n/).filter((line) => line.startsWith("+") && !line.startsWith("+++")).map((line) => line.slice(1)).join("\n");
+}
 function assertNoSecretLikeContent(inputs) {
   const findings = inputs.flatMap(
     ({ source, content }) => findSecretLikeContent(source, content ?? "")
@@ -4545,7 +5544,7 @@ async function resolveIssueWorktree(root, branchName, baseBranch, logger) {
   return { mode: "new", branchName, baseRef };
 }
 function issueWorktreePath(root, branchName) {
-  return join10(root, ".sandcastle", "worktrees", branchName.replace(/\//g, "-"));
+  return join12(root, ".sandcastle", "worktrees", branchName.replace(/\//g, "-"));
 }
 function resolveRegisteredIssueWorktreePath(worktreeListPorcelain, root, branchName) {
   const branchWorktreePath = parseWorktreeListPorcelain(
@@ -4573,7 +5572,7 @@ async function syncTargetBranch(root, baseBranch, logger) {
 }
 function loadBuilderPrompt(repoRoot2, promptTemplate) {
   const promptPath = resolvePromptTemplatePath(repoRoot2, promptTemplate);
-  const promptBody = existsSync7(promptPath) ? readFileSync7(promptPath, "utf-8") : promptTemplate;
+  const promptBody = existsSync8(promptPath) ? readFileSync8(promptPath, "utf-8") : promptTemplate;
   return appendProtectedWorkGuidance(`${promptBody}
 
 ## Shared Run Context
@@ -4891,7 +5890,18 @@ async function runIssueCommand(options) {
       reviewArtifactPath
     });
   } catch (error) {
-    if (!(error instanceof HumanHandoffStop)) {
+    if (error instanceof HumanHandoffStop) {
+      throw error;
+    }
+    if (error instanceof Error && "_tag" in error) {
+      await failIssueRun({
+        issueProvider,
+        issueNumber,
+        config,
+        logger,
+        error: `[${error._tag}] ${error.message}`
+      });
+    } else {
       await failIssueRun({
         issueProvider,
         issueNumber,
@@ -4997,6 +6007,7 @@ async function runIssueCreateCommand(args, issueProvider, logger) {
 
 // commands/queue.ts
 init_common();
+import { Effect as Effect8 } from "effect";
 
 // issues/select-issue.ts
 init_common();
@@ -5109,6 +6120,13 @@ async function anyBlockerStillOpen(refs, getIssueState) {
 }
 
 // commands/queue.ts
+var QueueProviderError = class extends Error {
+  _tag = "QueueProviderError";
+  constructor(message) {
+    super(message);
+    this.name = "QueueProviderError";
+  }
+};
 function issueDataToCandidate(issue) {
   return {
     number: issue.number,
@@ -5117,72 +6135,93 @@ function issueDataToCandidate(issue) {
     createdAt: issue.createdAt ? issue.createdAt.toISOString() : (/* @__PURE__ */ new Date(0)).toISOString()
   };
 }
-async function selectNextQueueIssue(options) {
+function selectNextQueueIssue(options) {
   const { config, issueProvider, logger, prdRef } = options;
   logger.step("info", "Loading candidate issues from provider");
-  const candidates = await issueProvider.listCandidates();
-  if (candidates.length === 0) {
-    logger.step("warn", "No candidate issues found");
-    return {
-      ok: false,
-      reason: "No candidate issues found.",
-      code: "no-candidates"
-    };
-  }
-  logger.raw(`Found ${candidates.length} candidate(s):`);
-  for (const c of candidates) {
-    logger.raw(`  #${c.number}: ${c.title} [${c.labels.join(", ")}]`);
-  }
-  const scopedCandidates = prdRef ? candidates.filter((issue) => {
-    const parsed = parseStackedIssue(issue.title, issue.body);
-    for (const warning of parsed.warnings) {
-      logger.raw(`  #${issue.number}: ${warning}`);
+  return Effect8.gen(function* () {
+    const candidates = yield* Effect8.tryPromise({
+      try: () => issueProvider.listCandidates(),
+      catch: (e) => {
+        if (e instanceof Error) {
+          return new QueueProviderError(e.message);
+        }
+        throw e;
+      }
+    });
+    if (candidates.length === 0) {
+      logger.step("warn", "No candidate issues found");
+      return {
+        ok: false,
+        reason: "No candidate issues found.",
+        code: "no-candidates"
+      };
+    }
+    logger.raw(`Found ${candidates.length} candidate(s):`);
+    for (const c of candidates) {
+      logger.raw(`  #${c.number}: ${c.title} [${c.labels.join(", ")}]`);
     }
-    if (!parsed.parentRef) {
-      logger.raw(
-        `  #${issue.number}: no parent found, excluding from PRD scope`
+    const scopedCandidates = prdRef ? candidates.filter((issue) => {
+      const parsed = parseStackedIssue(issue.title, issue.body);
+      for (const warning of parsed.warnings) {
+        logger.raw(`  #${issue.number}: ${warning}`);
+      }
+      if (!parsed.parentRef) {
+        logger.raw(
+          `  #${issue.number}: no parent found, excluding from PRD scope`
+        );
+        return false;
+      }
+      const matches = parsed.parentRef === prdRef;
+      if (!matches) {
+        logger.raw(
+          `  #${issue.number}: parent ${parsed.parentRef} does not match ${prdRef}`
+        );
+      }
+      return matches;
+    }) : candidates;
+    if (prdRef) {
+      logger.step(
+        "info",
+        `PRD-scoped selection: ${scopedCandidates.length} of ${candidates.length} candidate(s) match ${prdRef}`
       );
-      return false;
     }
-    const matches = parsed.parentRef === prdRef;
-    if (!matches) {
-      logger.raw(
-        `  #${issue.number}: parent ${parsed.parentRef} does not match ${prdRef}`
+    if (prdRef && scopedCandidates.length === 0) {
+      logger.step("warn", `No candidate issues found for ${prdRef}.`);
+      return {
+        ok: false,
+        reason: `No candidate issues found for ${prdRef}.`,
+        code: "no-candidates"
+      };
+    }
+    const candidateIssues = scopedCandidates.map(issueDataToCandidate);
+    const selection = selectIssue(candidateIssues, {
+      blockedLabel: config.labels.blocked,
+      agentInProgressLabel: config.labels.agentInProgress
+    });
+    if (!selection.ok) {
+      logger.step("warn", `No runnable issue: ${selection.reason}`);
+      return {
+        ok: false,
+        reason: selection.reason,
+        code: "no-runnable"
+      };
+    }
+    const selected = candidates.find(
+      (c) => c.number === selection.issue.number
+    );
+    if (!selected) {
+      return yield* Effect8.die(
+        new Error(
+          `Selected issue #${selection.issue.number} not found in candidate list`
+        )
       );
     }
-    return matches;
-  }) : candidates;
-  if (prdRef) {
     logger.step(
       "info",
-      `PRD-scoped selection: ${scopedCandidates.length} of ${candidates.length} candidate(s) match ${prdRef}`
+      `Selected issue #${selected.number}: ${selected.title}`
     );
-  }
-  if (prdRef && scopedCandidates.length === 0) {
-    logger.step("warn", `No candidate issues found for ${prdRef}.`);
-    return {
-      ok: false,
-      reason: `No candidate issues found for ${prdRef}.`,
-      code: "no-candidates"
-    };
-  }
-  const candidateIssues = scopedCandidates.map(issueDataToCandidate);
-  const selection = selectIssue(candidateIssues, {
-    blockedLabel: config.labels.blocked,
-    agentInProgressLabel: config.labels.agentInProgress
+    return { ok: true, issue: selected };
   });
-  if (!selection.ok) {
-    logger.step("warn", `No runnable issue: ${selection.reason}`);
-    return { ok: false, reason: selection.reason, code: "no-runnable" };
-  }
-  const selected = candidates.find((c) => c.number === selection.issue.number);
-  if (!selected) {
-    throw new Error(
-      `Selected issue #${selection.issue.number} not found in candidate list`
-    );
-  }
-  logger.step("info", `Selected issue #${selected.number}: ${selected.title}`);
-  return { ok: true, issue: selected };
 }
 function makeReconcileDeps(options) {
   const transitions = createIssueTransitions(
@@ -5215,17 +6254,35 @@ function makeReconcileDeps(options) {
     readyLabel: options.config.labels.readyForAgent
   };
 }
-async function reconcileBlocked(options) {
-  const blocked = await options.issueProvider.listBlockedIssues();
-  if (blocked.length > 0) {
-    options.logger.step(
-      "info",
-      `Reconciling ${blocked.length} blocked issue(s)`
-    );
-    await reconcileBlockedIssues(blocked, makeReconcileDeps(options));
-  }
+function reconcileBlockedEffect(options) {
+  return Effect8.gen(function* () {
+    const blocked = yield* Effect8.tryPromise({
+      try: () => options.issueProvider.listBlockedIssues(),
+      catch: (e) => {
+        if (e instanceof Error) {
+          return new QueueProviderError(e.message);
+        }
+        throw e;
+      }
+    });
+    if (blocked.length > 0) {
+      options.logger.step(
+        "info",
+        `Reconciling ${blocked.length} blocked issue(s)`
+      );
+      yield* Effect8.tryPromise({
+        try: () => reconcileBlockedIssues(blocked, makeReconcileDeps(options)),
+        catch: (e) => {
+          if (e instanceof Error) {
+            return new QueueProviderError(e.message);
+          }
+          throw e;
+        }
+      });
+    }
+  });
 }
-async function runOneQueueIssue(options) {
+function runOneQueueIssueEffect(options) {
   const {
     targetName,
     config,
@@ -5237,47 +6294,57 @@ async function runOneQueueIssue(options) {
     repoRoot: repoRoot2,
     prdRef
   } = options;
-  const outcome = await selectNextQueueIssue({
-    config,
-    issueProvider,
-    logger,
-    prdRef
-  });
-  if (!outcome.ok) {
-    return { selected: null, reason: outcome.reason, code: outcome.code };
-  }
-  const { issue: selected } = outcome;
-  const runResult = await runIssueCommand({
-    issueNumber: selected.number,
-    targetName,
-    config,
-    issueProvider,
-    prProvider,
-    executionProvider,
-    force,
-    logger,
-    repoRoot: repoRoot2
+  return Effect8.gen(function* () {
+    const outcome = yield* selectNextQueueIssue({
+      config,
+      issueProvider,
+      logger,
+      prdRef
+    });
+    if (!outcome.ok) {
+      return {
+        selected: null,
+        reason: outcome.reason,
+        code: outcome.code
+      };
+    }
+    const { issue: selected } = outcome;
+    const runResult = yield* Effect8.tryPromise({
+      try: () => runIssueCommand({
+        issueNumber: selected.number,
+        targetName,
+        config,
+        issueProvider,
+        prProvider,
+        executionProvider,
+        force,
+        logger,
+        repoRoot: repoRoot2
+      }),
+      catch: (e) => {
+        throw e;
+      }
+    });
+    logger.raw("Issue completed successfully:");
+    logger.raw(`  Branch: ${runResult.branchName}`);
+    if (runResult.noOp) {
+      logger.raw("  Status: no-op (closed without PR)");
+    } else {
+      logger.raw(`  PR Title: ${runResult.prTitle}`);
+      logger.raw(`  PR Number: ${runResult.prNumber}`);
+      logger.raw(`  PR URL: ${runResult.prUrl}`);
+    }
+    logger.raw(`  Target: ${runResult.target.name}`);
+    return { selected, runResult };
   });
-  logger.raw("Issue completed successfully:");
-  logger.raw(`  Branch: ${runResult.branchName}`);
-  if (runResult.noOp) {
-    logger.raw("  Status: no-op (closed without PR)");
-  } else {
-    logger.raw(`  PR Title: ${runResult.prTitle}`);
-    logger.raw(`  PR Number: ${runResult.prNumber}`);
-    logger.raw(`  PR URL: ${runResult.prUrl}`);
-  }
-  logger.raw(`  Target: ${runResult.target.name}`);
-  return { selected, runResult };
-}
-async function runQueue(options) {
-  return runOneQueueIssue(options);
 }
-async function runQueueLoop(options) {
-  const results = [];
-  while (true) {
-    await reconcileBlocked(options);
-    const outcome = await runOneQueueIssue(options);
+function runQueue(options) {
+  return runOneQueueIssueEffect(options);
+}
+function runQueueLoopEffect(options, results) {
+  return Effect8.gen(function* () {
+    yield* reconcileBlockedEffect(options);
+    const outcome = yield* runOneQueueIssueEffect(options);
     if (outcome.selected === null) {
       return {
         drained: true,
@@ -5288,18 +6355,29 @@ async function runQueueLoop(options) {
         code: "drained"
       };
     }
-    results.push(outcome);
-    const processedIssue = await options.issueProvider.fetchIssue(
-      outcome.selected.number
-    );
+    const newResults = [...results, outcome];
+    const processedIssue = yield* Effect8.tryPromise({
+      try: () => options.issueProvider.fetchIssue(outcome.selected.number),
+      catch: (e) => {
+        if (e instanceof Error) {
+          return new QueueProviderError(e.message);
+        }
+        throw e;
+      }
+    });
     if (processedIssue.state === "closed") {
-      await reconcileBlocked(options);
+      yield* reconcileBlockedEffect(options);
     }
-  }
+    return yield* runQueueLoopEffect(options, newResults);
+  });
+}
+function runQueueLoop(options) {
+  return runQueueLoopEffect(options, []);
 }
 
 // commands/queue-run.ts
 async function runQueueCommand(options) {
+  initializeEffectRuntime();
   const queueOptions = {
     targetName: options.targetName,
     config: options.config,
@@ -5312,9 +6390,9 @@ async function runQueueCommand(options) {
     prdRef: options.prdRef
   };
   if (!options.loop) {
-    return runQueue(queueOptions);
+    return runEffectAndMapExit(runQueue(queueOptions));
   }
-  return runQueueLoop(queueOptions);
+  return runEffectAndMapExit(runQueueLoop(queueOptions));
 }
 
 // commands/pr-create.ts
@@ -5684,16 +6762,18 @@ async function runPrMergeCommand(args, logger, prProvider, config) {
         matchHeadCommit: pr.headRefOid
       });
     } else {
-      const coordinatorResult = await runMergeCoordinator({
-        prProvider,
-        logger: ownLogger,
-        prNumber: pr.number,
-        targetBranch: pr.baseRefName,
-        matchHeadCommit: pr.headRefOid,
-        checkWaitOptions,
-        method: options.method,
-        waitForTargetGreen: options.targetGreen
-      });
+      const coordinatorResult = await runEffectAndMapExit(
+        runMergeCoordinator({
+          prProvider,
+          logger: ownLogger,
+          prNumber: pr.number,
+          targetBranch: pr.baseRefName,
+          matchHeadCommit: pr.headRefOid,
+          checkWaitOptions,
+          method: options.method,
+          waitForTargetGreen: options.targetGreen
+        })
+      );
       if (coordinatorResult.stage !== "completed") {
         throw coordinatorResult.error;
       }
@@ -5716,105 +6796,21 @@ async function runPrMergeCommand(args, logger, prProvider, config) {
 }
 
 // commands/init.ts
-import { existsSync as existsSync8, statSync } from "fs";
+init_github_client();
+import { existsSync as existsSync9, statSync } from "fs";
 import {
   copyFile,
   mkdir as mkdir4,
   readFile as readFile4,
   readdir,
   rename,
-  writeFile
+  writeFile as writeFile2
 } from "fs/promises";
-import { createHash, randomUUID } from "crypto";
-import path5 from "path";
+import { createHash as createHash2, randomUUID } from "crypto";
+import path7 from "path";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
 import { confirm, isCancel, log, select, text } from "@clack/prompts";
-
-// providers/github-client.ts
-import { Octokit } from "octokit";
-var REMOTE_PATTERN = /github\.com[:/]([^/]+)\/([^/]+?)(?:\.git)?$/;
-function resolveGitHubToken(env) {
-  const token = env.POURKIT_GITHUB_TOKEN ?? env.GH_TOKEN ?? env.GITHUB_TOKEN;
-  if (!token) {
-    throw new Error(
-      "GitHub token is required. Set POURKIT_GITHUB_TOKEN, GH_TOKEN, or GITHUB_TOKEN."
-    );
-  }
-  return token;
-}
-async function resolveGitHubRepository(options) {
-  if (options?.repository) {
-    const parts = options.repository.split("/");
-    if (parts.length !== 2 || !parts[0] || !parts[1]) {
-      throw new Error(
-        `Invalid repository format: "${options.repository}". Expected "owner/repo".`
-      );
-    }
-    return { owner: parts[0], repo: parts[1] };
-  }
-  const env = options?.env ?? process.env;
-  const envRepo = env.GITHUB_REPOSITORY;
-  if (envRepo) {
-    const parts = envRepo.split("/");
-    if (parts.length === 2 && parts[0] && parts[1]) {
-      return { owner: parts[0], repo: parts[1] };
-    }
-    throw new Error(
-      `Invalid repository format: "${envRepo}". Expected "owner/repo".`
-    );
-  }
-  const { execCapture: execCapture2 } = await Promise.resolve().then(() => (init_common(), common_exports));
-  const cwd = options?.cwd;
-  try {
-    const result = await execCapture2("git", ["remote", "get-url", "origin"], {
-      cwd
-    });
-    const remote = result.stdout.trim();
-    const match = remote.match(REMOTE_PATTERN);
-    if (match) {
-      return { owner: match[1], repo: match[2] };
-    }
-  } catch {
-  }
-  throw new Error(
-    "Could not resolve GitHub repository. Set GITHUB_REPOSITORY env var or ensure a valid 'origin' remote exists."
-  );
-}
-async function requireGitHubClient(options) {
-  const env = options?.env ?? process.env;
-  const token = resolveGitHubToken(env);
-  const repo = await resolveGitHubRepository(options);
-  const octokit = new Octokit({ auth: token });
-  return { octokit, ...repo };
-}
-async function tryCreateGitHubClient(options) {
-  const env = options?.env ?? process.env;
-  let token;
-  try {
-    token = resolveGitHubToken(env);
-  } catch {
-    return {
-      ok: false,
-      reason: "missing-token",
-      message: "GitHub token is not configured."
-    };
-  }
-  let repo;
-  try {
-    repo = await resolveGitHubRepository(options);
-  } catch (e) {
-    const message = e instanceof Error ? e.message : String(e);
-    if (message.includes("Invalid repository format")) {
-      return { ok: false, reason: "invalid-repository", message };
-    }
-    return { ok: false, reason: "missing-repository", message };
-  }
-  const octokit = new Octokit({ auth: token });
-  return { ok: true, client: { octokit, ...repo } };
-}
-
-// commands/init.ts
 var execFileAsync2 = promisify2(execFile2);
 var NO_TOKEN_LABEL_PROVISIONING_WARNING = "Skipped GitHub label provisioning because no GitHub token was provided.";
 var ALLOWED_VERIFICATION_SCRIPTS = [
@@ -5951,7 +6947,7 @@ function generateConfigTemplate(options) {
     labels: maybeLabels
   } = options;
   const labels = maybeLabels ?? DEFAULT_RUNNER_LABELS;
-  const relPath = path5.relative(targetRoot, sourceRoot).replace(/\\/g, "/");
+  const relPath = path7.relative(targetRoot, sourceRoot).replace(/\\/g, "/");
   const importPath = relPath || ".";
   const setupCommand = `${packageManager} install`;
   let setupSection;
@@ -6199,7 +7195,7 @@ _Avoid_: Alternative terms
 `;
 }
 async function generateManagedAgentInstructions(options) {
-  const sourcePath = path5.join(options.sourceRoot, "AGENTS.md");
+  const sourcePath = path7.join(options.sourceRoot, "AGENTS.md");
   try {
     return await readFile4(sourcePath, "utf-8");
   } catch {
@@ -6229,7 +7225,7 @@ async function walkDir(dir) {
   const files = [];
   const entries = await readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const full = path5.join(dir, entry.name);
+    const full = path7.join(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...await walkDir(full));
     } else {
@@ -6240,10 +7236,10 @@ async function walkDir(dir) {
 }
 async function computeFileChecksum(filePath) {
   const content = await readFile4(filePath);
-  return createHash("sha256").update(content).digest("hex");
+  return createHash2("sha256").update(content).digest("hex");
 }
 function lockfileExists(root, name) {
-  return existsSync8(path5.join(root, name));
+  return existsSync9(path7.join(root, name));
 }
 function detectPackageManager(root) {
   if (lockfileExists(root, "pnpm-lock.yaml")) return "pnpm";
@@ -6286,8 +7282,8 @@ async function discoverLocalSource(sourcePath) {
 }
 async function discoverReadme(root) {
   for (const name of ["README.md", "readme.md"]) {
-    const p = path5.join(root, name);
-    if (existsSync8(p)) {
+    const p = path7.join(root, name);
+    if (existsSync9(p)) {
       return p;
     }
   }
@@ -6296,25 +7292,25 @@ async function discoverReadme(root) {
 async function discoverAgentFiles(root) {
   const files = [];
   for (const name of ["AGENTS.md", "CLAUDE.md"]) {
-    const p = path5.join(root, name);
-    if (existsSync8(p)) {
+    const p = path7.join(root, name);
+    if (existsSync9(p)) {
       files.push(p);
     }
   }
   return files;
 }
 async function discoverMerlleState(root) {
-  const p = path5.join(root, ".pourkit", "state.json");
-  return existsSync8(p) ? p : null;
+  const p = path7.join(root, ".pourkit", "state.json");
+  return existsSync9(p) ? p : null;
 }
 async function discoverAgentSkills(root) {
   const dirs = [
-    path5.join(root, ".agents", "skills"),
-    path5.join(root, ".opencode", "skills")
+    path7.join(root, ".agents", "skills"),
+    path7.join(root, ".opencode", "skills")
   ];
   const found = [];
   for (const d of dirs) {
-    if (existsSync8(d)) {
+    if (existsSync9(d)) {
       found.push(d);
     }
   }
@@ -6323,17 +7319,17 @@ async function discoverAgentSkills(root) {
 async function discoverRootDomainDocs(root) {
   const docs = [];
   for (const name of ["CONTEXT.md", "CONTEXT-MAP.md"]) {
-    const p = path5.join(root, name);
-    if (existsSync8(p)) {
+    const p = path7.join(root, name);
+    if (existsSync9(p)) {
       docs.push(p);
     }
   }
-  const adrDir = path5.join(root, "docs", "adr");
-  if (existsSync8(adrDir)) {
+  const adrDir = path7.join(root, "docs", "adr");
+  if (existsSync9(adrDir)) {
     const entries = await readdir(adrDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".md")) {
-        docs.push(path5.join(adrDir, entry.name));
+        docs.push(path7.join(adrDir, entry.name));
       }
     }
   }
@@ -6421,7 +7417,7 @@ async function planInit(options) {
     for (const f of agentFiles) {
       if (sourceRoot) {
         const agentFileMode = options.conflictPolicy?.agentFile ?? "both";
-        const basename = path5.basename(f);
+        const basename = path7.basename(f);
         if (agentFileMode === "skip" || agentFileMode === "agents" && basename !== "AGENTS.md" || agentFileMode === "claude" && basename !== "CLAUDE.md") {
           operations.push({
             kind: "skip",
@@ -6447,7 +7443,7 @@ async function planInit(options) {
           kind: "skip",
           path: f,
           ownership: "project-owned",
-          reason: `Existing agent file: ${path5.basename(f)}`,
+          reason: `Existing agent file: ${path7.basename(f)}`,
           requiresConfirmation: false,
           destructive: false
         });
@@ -6470,15 +7466,15 @@ async function planInit(options) {
     if (s.includes(".opencode") && options.legacySkills) {
       const skillFiles = await walkDir(s);
       for (const file of skillFiles) {
-        const relPath = path5.relative(s, file);
-        const destPath = path5.join(targetRoot, ".agents", "skills", relPath);
-        if (!existsSync8(destPath)) {
+        const relPath = path7.relative(s, file);
+        const destPath = path7.join(targetRoot, ".agents", "skills", relPath);
+        if (!existsSync9(destPath)) {
           operations.push({
             kind: "copy",
             sourcePath: file,
             path: destPath,
             ownership: "project-owned",
-            reason: `Migrate legacy skill: ${path5.join(".opencode/skills", relPath)}`,
+            reason: `Migrate legacy skill: ${path7.join(".opencode/skills", relPath)}`,
             requiresConfirmation: false,
             destructive: false
           });
@@ -6535,7 +7531,7 @@ async function planInit(options) {
     });
   }
   if (sourceRoot) {
-    if (!existsSync8(sourceRoot) || !statSync(sourceRoot).isDirectory()) {
+    if (!existsSync9(sourceRoot) || !statSync(sourceRoot).isDirectory()) {
       warnings.push(
         `--from-local path does not exist or is not a directory: ${sourceRoot}`
       );
@@ -6596,17 +7592,17 @@ async function planInit(options) {
           continue;
         }
         const targetDirName = ".agents/skills";
-        const targetPath = path5.join(targetRoot, targetDirName);
+        const targetPath = path7.join(targetRoot, targetDirName);
         const skillFiles = await walkDir(s);
         for (const file of skillFiles) {
-          const relPath = path5.relative(s, file);
-          const destPath = path5.join(targetPath, relPath);
+          const relPath = path7.relative(s, file);
+          const destPath = path7.join(targetPath, relPath);
           if (plannedSkillDests.has(destPath)) {
             operations.push({
               kind: "skip",
               path: destPath,
               ownership: "project-owned",
-              reason: `Skill destination conflict, skipping source copy: ${path5.join(targetDirName, relPath)}`,
+              reason: `Skill destination conflict, skipping source copy: ${path7.join(targetDirName, relPath)}`,
               requiresConfirmation: false,
               destructive: false,
               conflict: "destination already planned"
@@ -6619,7 +7615,7 @@ async function planInit(options) {
             sourcePath: file,
             path: destPath,
             ownership: "copied-customizable",
-            reason: `Copy skill: ${path5.join(targetDirName, relPath)}`,
+            reason: `Copy skill: ${path7.join(targetDirName, relPath)}`,
             requiresConfirmation: false,
             destructive: false,
             checksum
@@ -6631,7 +7627,7 @@ async function planInit(options) {
         operations.push({
           kind: "copy",
           sourcePath: srcReadme,
-          path: path5.join(targetRoot, "README.md"),
+          path: path7.join(targetRoot, "README.md"),
           ownership: "project-owned",
           reason: "Copy README.md from source",
           requiresConfirmation: false,
@@ -6642,8 +7638,8 @@ async function planInit(options) {
       const rootDocs = await discoverRootDomainDocs(targetRoot);
       const merleDestPaths = /* @__PURE__ */ new Set();
       for (const docPath of rootDocs) {
-        const relPath = path5.relative(targetRoot, docPath);
-        const destPath = path5.join(targetRoot, ".pourkit", relPath);
+        const relPath = path7.relative(targetRoot, docPath);
+        const destPath = path7.join(targetRoot, ".pourkit", relPath);
         merleDestPaths.add(destPath);
         if (docsMigration === "skip") {
           operations.push({
@@ -6654,7 +7650,7 @@ async function planInit(options) {
             requiresConfirmation: false,
             destructive: false
           });
-        } else if (existsSync8(destPath)) {
+        } else if (existsSync9(destPath)) {
           operations.push({
             kind: "skip",
             path: destPath,
@@ -6690,7 +7686,7 @@ async function planInit(options) {
       let hasPackageJson = true;
       try {
         const pkgContent = await readFile4(
-          path5.join(targetRoot, "package.json"),
+          path7.join(targetRoot, "package.json"),
           "utf-8"
         );
         const pkg = JSON.parse(pkgContent);
@@ -6711,8 +7707,8 @@ async function planInit(options) {
         } catch {
         }
       }
-      const contextPath = path5.join(targetRoot, ".pourkit", "CONTEXT.md");
-      if (!existsSync8(contextPath) && !merleDestPaths.has(contextPath)) {
+      const contextPath = path7.join(targetRoot, ".pourkit", "CONTEXT.md");
+      if (!existsSync9(contextPath) && !merleDestPaths.has(contextPath)) {
         operations.push({
           kind: "create",
           path: contextPath,
@@ -6723,14 +7719,14 @@ async function planInit(options) {
           content: generateContextScaffold()
         });
       }
-      const adrGitkeep = path5.join(
+      const adrGitkeep = path7.join(
         targetRoot,
         ".pourkit",
         "docs",
         "adr",
         ".gitkeep"
       );
-      if (!existsSync8(adrGitkeep)) {
+      if (!existsSync9(adrGitkeep)) {
         operations.push({
           kind: "create",
           path: adrGitkeep,
@@ -6740,16 +7736,16 @@ async function planInit(options) {
           destructive: false
         });
       }
-      const srcDocAgents = path5.join(sourceRoot, ".pourkit", "docs", "agents");
-      const tgtDocAgents = path5.join(targetRoot, ".pourkit", "docs", "agents");
-      if (existsSync8(srcDocAgents) && !existsSync8(tgtDocAgents)) {
+      const srcDocAgents = path7.join(sourceRoot, ".pourkit", "docs", "agents");
+      const tgtDocAgents = path7.join(targetRoot, ".pourkit", "docs", "agents");
+      if (existsSync9(srcDocAgents) && !existsSync9(tgtDocAgents)) {
         const docFiles = await walkDir(srcDocAgents);
         for (const file of docFiles) {
-          const relPath = path5.relative(srcDocAgents, file);
+          const relPath = path7.relative(srcDocAgents, file);
           if (relPath === "triage-labels.md") {
             operations.push({
               kind: "create",
-              path: path5.join(tgtDocAgents, relPath),
+              path: path7.join(tgtDocAgents, relPath),
               ownership: "managed",
               reason: "Init triage labels doc",
               requiresConfirmation: false,
@@ -6764,7 +7760,7 @@ async function planInit(options) {
           operations.push({
             kind: "copy",
             sourcePath: file,
-            path: path5.join(tgtDocAgents, relPath),
+            path: path7.join(tgtDocAgents, relPath),
             ownership: "managed",
             reason: `Copy agent doc: ${relPath}`,
             requiresConfirmation: false,
@@ -6773,17 +7769,17 @@ async function planInit(options) {
           });
         }
       }
-      const srcPrompts = path5.join(sourceRoot, ".pourkit", "prompts");
-      const tgtPrompts = path5.join(targetRoot, ".pourkit", "prompts");
-      if (existsSync8(srcPrompts) && !existsSync8(tgtPrompts)) {
+      const srcPrompts = path7.join(sourceRoot, ".pourkit", "prompts");
+      const tgtPrompts = path7.join(targetRoot, ".pourkit", "prompts");
+      if (existsSync9(srcPrompts) && !existsSync9(tgtPrompts)) {
         const promptFiles = await walkDir(srcPrompts);
         for (const file of promptFiles) {
-          const relPath = path5.relative(srcPrompts, file);
+          const relPath = path7.relative(srcPrompts, file);
           const checksum = await computeFileChecksum(file);
           operations.push({
             kind: "copy",
             sourcePath: file,
-            path: path5.join(tgtPrompts, relPath),
+            path: path7.join(tgtPrompts, relPath),
             ownership: "managed",
             reason: `Copy prompt: ${relPath}`,
             requiresConfirmation: false,
@@ -6792,17 +7788,17 @@ async function planInit(options) {
           });
         }
       }
-      const srcSandboxDockerfile = path5.join(
+      const srcSandboxDockerfile = path7.join(
         sourceRoot,
         ".sandcastle",
         "Dockerfile"
       );
-      const tgtSandboxDockerfile = path5.join(
+      const tgtSandboxDockerfile = path7.join(
         targetRoot,
         ".sandcastle",
         "Dockerfile"
       );
-      if (existsSync8(tgtSandboxDockerfile)) {
+      if (existsSync9(tgtSandboxDockerfile)) {
         operations.push({
           kind: "skip",
           path: tgtSandboxDockerfile,
@@ -6811,7 +7807,7 @@ async function planInit(options) {
           requiresConfirmation: false,
           destructive: false
         });
-      } else if (existsSync8(srcSandboxDockerfile)) {
+      } else if (existsSync9(srcSandboxDockerfile)) {
         const checksum = await computeFileChecksum(srcSandboxDockerfile);
         operations.push({
           kind: "copy",
@@ -6824,8 +7820,8 @@ async function planInit(options) {
           checksum
         });
       }
-      const configTsPath = path5.join(targetRoot, "pourkit.config.ts");
-      if (!existsSync8(configTsPath)) {
+      const configTsPath = path7.join(targetRoot, "pourkit.config.ts");
+      if (!existsSync9(configTsPath)) {
         const verifyCommands = inferVerificationCommands(
           packageScripts,
           pm || "npm"
@@ -6862,10 +7858,10 @@ async function planInit(options) {
       const hasExistingAgents = operations.some(
         (op) => (op.kind === "skip" || op.kind === "update") && op.path?.endsWith("AGENTS.md")
       );
-      if ((agentFileMode === "agents" || agentFileMode === "both") && !hasExistingAgents && !existsSync8(path5.join(targetRoot, "AGENTS.md"))) {
+      if ((agentFileMode === "agents" || agentFileMode === "both") && !hasExistingAgents && !existsSync9(path7.join(targetRoot, "AGENTS.md"))) {
         operations.push({
           kind: "create",
-          path: path5.join(targetRoot, "AGENTS.md"),
+          path: path7.join(targetRoot, "AGENTS.md"),
           ownership: "managed",
           reason: "Init AGENTS.md with Pourkit managed block",
           requiresConfirmation: false,
@@ -6878,10 +7874,10 @@ ${managedAgentContent}${MANAGED_BLOCK_END}
       const hasExistingClaude = operations.some(
         (op) => (op.kind === "skip" || op.kind === "update") && op.path?.endsWith("CLAUDE.md")
       );
-      if ((agentFileMode === "claude" || agentFileMode === "both") && !hasExistingClaude && !existsSync8(path5.join(targetRoot, "CLAUDE.md"))) {
+      if ((agentFileMode === "claude" || agentFileMode === "both") && !hasExistingClaude && !existsSync9(path7.join(targetRoot, "CLAUDE.md"))) {
         operations.push({
           kind: "create",
-          path: path5.join(targetRoot, "CLAUDE.md"),
+          path: path7.join(targetRoot, "CLAUDE.md"),
           ownership: "managed",
           reason: "Init CLAUDE.md with Pourkit managed block",
           requiresConfirmation: false,
@@ -6891,9 +7887,9 @@ ${managedAgentContent}${MANAGED_BLOCK_END}
 `
         });
       }
-      const gitignoreTarget = path5.join(targetRoot, ".gitignore");
+      const gitignoreTarget = path7.join(targetRoot, ".gitignore");
       const gitignoreContent = generateGitignoreBlock();
-      if (!existsSync8(gitignoreTarget)) {
+      if (!existsSync9(gitignoreTarget)) {
         operations.push({
           kind: "create",
           path: gitignoreTarget,
@@ -6916,8 +7912,8 @@ ${gitignoreContent}${MANAGED_BLOCK_END}
           content: gitignoreContent
         });
       }
-      const openCodePath = path5.join(targetRoot, "opencode.json");
-      if (!existsSync8(openCodePath)) {
+      const openCodePath = path7.join(targetRoot, "opencode.json");
+      if (!existsSync9(openCodePath)) {
         operations.push({
           kind: "create",
           path: openCodePath,
@@ -6973,8 +7969,8 @@ ${gitignoreContent}${MANAGED_BLOCK_END}
           });
         }
       }
-      const manifestPath = path5.join(targetRoot, ".pourkit", "manifest.json");
-      if (existsSync8(manifestPath)) {
+      const manifestPath = path7.join(targetRoot, ".pourkit", "manifest.json");
+      if (existsSync9(manifestPath)) {
         operations.push({
           kind: "skip",
           path: manifestPath,
@@ -7284,7 +8280,7 @@ async function promptForInitChoices(plan, current) {
 }
 async function writeFileAtomic(filePath, content) {
   const tmpPath = `${filePath}.tmp.${randomUUID()}`;
-  await writeFile(tmpPath, content, "utf-8");
+  await writeFile2(tmpPath, content, "utf-8");
   await rename(tmpPath, filePath);
 }
 var MANAGED_BLOCK_BEGIN = "<!-- BEGIN POURKIT MANAGED BLOCK -->";
@@ -7293,8 +8289,8 @@ async function updateManagedBlock(filePath, content) {
   const blockContent = `${MANAGED_BLOCK_BEGIN}
 ${content}${MANAGED_BLOCK_END}
 `;
-  if (!existsSync8(filePath)) {
-    const dir = path5.dirname(filePath);
+  if (!existsSync9(filePath)) {
+    const dir = path7.dirname(filePath);
     await mkdir4(dir, { recursive: true });
     await writeFileAtomic(filePath, blockContent);
     return;
@@ -7312,17 +8308,17 @@ ${content}${MANAGED_BLOCK_END}
   }
 }
 async function writeManifest(plan, sourceMeta, agentFiles, packageManager) {
-  const manifestDir = path5.join(plan.targetRoot, ".pourkit");
-  const manifestPath = path5.join(manifestDir, "manifest.json");
+  const manifestDir = path7.join(plan.targetRoot, ".pourkit");
+  const manifestPath = path7.join(manifestDir, "manifest.json");
   const assets = {};
   for (const op of plan.operations) {
     if (!op.path) continue;
     if (op.kind !== "create" && op.kind !== "copy" && op.kind !== "update" && op.kind !== "move")
       continue;
     if (op.requiresConfirmation) continue;
-    const relPath = path5.relative(plan.targetRoot, op.path);
+    const relPath = path7.relative(plan.targetRoot, op.path);
     if (relPath === ".pourkit/manifest.json") continue;
-    if (existsSync8(op.path)) {
+    if (existsSync9(op.path)) {
       const sha256 = await computeFileChecksum(op.path);
       assets[relPath] = {
         ownership: op.ownership || "managed",
@@ -7367,11 +8363,11 @@ async function applyInitPlan(plan, options) {
             skipped++;
             continue;
           }
-          if (existsSync8(op.path) && !op.destructive) {
+          if (existsSync9(op.path) && !op.destructive) {
             skipped++;
             continue;
           }
-          const dir = path5.dirname(op.path);
+          const dir = path7.dirname(op.path);
           await mkdir4(dir, { recursive: true });
           await writeFileAtomic(op.path, op.content ?? "");
           applied++;
@@ -7382,7 +8378,7 @@ async function applyInitPlan(plan, options) {
             skipped++;
             continue;
           }
-          if (existsSync8(op.path)) {
+          if (existsSync9(op.path)) {
             skipped++;
             continue;
           }
@@ -7390,7 +8386,7 @@ async function applyInitPlan(plan, options) {
           if (srcStat.isDirectory()) {
             skipped++;
           } else {
-            const dir = path5.dirname(op.path);
+            const dir = path7.dirname(op.path);
             await mkdir4(dir, { recursive: true });
             await copyFile(op.sourcePath, op.path);
             applied++;
@@ -7411,11 +8407,11 @@ async function applyInitPlan(plan, options) {
             skipped++;
             continue;
           }
-          if (existsSync8(op.path)) {
+          if (existsSync9(op.path)) {
             skipped++;
             continue;
           }
-          const dir = path5.dirname(op.path);
+          const dir = path7.dirname(op.path);
           await mkdir4(dir, { recursive: true });
           await rename(op.sourcePath, op.path);
           applied++;
@@ -7546,13 +8542,13 @@ async function applyInitFromSource(options) {
   let manifestWritten = false;
   if (result.errors.length === 0) {
     const manifestSkipped = plan.operations.some(
-      (op) => op.kind === "skip" && op.path === path5.join(targetRoot, ".pourkit", "manifest.json")
+      (op) => op.kind === "skip" && op.path === path7.join(targetRoot, ".pourkit", "manifest.json")
     );
     if (!manifestSkipped) {
       const agentFiles = [];
       for (const name of ["AGENTS.md", "CLAUDE.md"]) {
-        if (existsSync8(path5.join(targetRoot, name))) {
-          agentFiles.push(path5.join(targetRoot, name));
+        if (existsSync9(path7.join(targetRoot, name))) {
+          agentFiles.push(path7.join(targetRoot, name));
         }
       }
       const pm = detectPackageManager(targetRoot);
@@ -8366,290 +9362,9 @@ function formatChecks2(checks) {
 }
 
 // cli.ts
+init_github_client();
 init_common();
-
-// execution/sandcastle-execution.ts
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync4 } from "fs";
-import { join as join12 } from "path";
-import { createWorktree, opencode } from "@ai-hero/sandcastle";
-import { docker } from "@ai-hero/sandcastle/sandboxes/docker";
-
-// execution/execution-provider.ts
-init_common();
-import { writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname5, join as join11 } from "path";
-async function writeExecutionArtifacts(worktreePath, artifacts) {
-  for (const artifact of artifacts) {
-    const filePath = join11(worktreePath, artifact.path);
-    await ensureDir(dirname5(filePath));
-    await writeFile2(filePath, artifact.content, "utf-8");
-  }
-}
-
-// execution/sandbox-image-build.ts
-init_common();
-import path7 from "path";
-
-// execution/sandbox-image.ts
-import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
-import path6 from "path";
-function sandboxImageName(repoRoot2) {
-  const dirName = path6.basename(repoRoot2.replace(/[\\/]+$/, "")) || "local";
-  const sanitized = dirName.toLowerCase().replace(/[^a-z0-9_.-]/g, "-");
-  const baseName = sanitized || "local";
-  const dockerfilePath = path6.join(repoRoot2, ".sandcastle", "Dockerfile");
-  if (!existsSync9(dockerfilePath)) {
-    return `sandcastle:${baseName}`;
-  }
-  const fingerprint = createHash2("sha256").update(readFileSync8(dockerfilePath)).digest("hex").slice(0, 8);
-  return `sandcastle:${baseName}-${fingerprint}`;
-}
-
-// execution/sandbox-image-build.ts
-async function ensureSandboxImageBuilt(repoRoot2, options) {
-  const imageName = sandboxImageName(repoRoot2);
-  const dockerfilePath = path7.join(repoRoot2, ".sandcastle", "Dockerfile");
-  if (!options?.force) {
-    try {
-      await execCapture("docker", ["image", "inspect", imageName]);
-      return;
-    } catch {
-    }
-  }
-  const buildArgs = ["build", "-t", imageName, "-f", dockerfilePath];
-  if (options?.force) {
-    buildArgs.push("--pull", "--no-cache");
-  }
-  buildArgs.push(repoRoot2);
-  await execCapture("docker", buildArgs);
-}
-
-// execution/sandcastle-existing-worktree.ts
-async function createSandboxFromExistingWorktree(options) {
-  const sandcastleEntryUrl = import.meta.resolve("@ai-hero/sandcastle");
-  const createSandboxUrl = new URL("./createSandbox.js", sandcastleEntryUrl);
-  const sandcastleCreateSandbox = await import(createSandboxUrl.href);
-  return sandcastleCreateSandbox.createSandboxFromWorktree(options);
-}
-
-// execution/sandbox-options.ts
-function buildSandboxOptions(repoRoot2, sandbox) {
-  const mounts = [];
-  if (sandbox.mounts !== void 0) {
-    mounts.push(...sandbox.mounts);
-  }
-  return {
-    imageName: sandboxImageName(repoRoot2),
-    ...mounts.length > 0 ? { mounts } : {},
-    ...sandbox.env !== void 0 ? { env: sandbox.env } : {},
-    ...sandbox.idleTimeoutSeconds !== void 0 ? { idleTimeoutSeconds: sandbox.idleTimeoutSeconds } : {}
-  };
-}
-
-// execution/opencode-config.ts
-function isSerenaEligibleStage(stage) {
-  return stage === "builder" || stage === "refactor";
-}
-function buildSerenaOpenCodeConfig(stage, serena) {
-  if (!serena?.available || !isSerenaEligibleStage(stage)) {
-    return void 0;
-  }
-  return {
-    mcp: {
-      serena: {
-        type: "remote",
-        url: serena.sandboxMcpUrl,
-        enabled: true
-      }
-    }
-  };
-}
-
-// execution/sandcastle-execution.ts
-var SandcastleExecutionProvider = class {
-  async createSession() {
-    return new SandcastleExecutionSession();
-  }
-  async execute(options) {
-    const session = await this.createSession();
-    try {
-      return await session.execute(options);
-    } finally {
-      await session.close();
-    }
-  }
-};
-var SandcastleExecutionSession = class {
-  sandboxHandle = null;
-  worktreeHandle = null;
-  async close() {
-    try {
-      await this.sandboxHandle?.close?.();
-    } finally {
-      this.sandboxHandle = null;
-    }
-  }
-  async execute(options) {
-    const {
-      stage,
-      iteration,
-      agent,
-      model,
-      prompt,
-      target,
-      repoRoot: repoRoot2,
-      branchName,
-      worktreePath,
-      baseRef,
-      sandbox,
-      autoApprove = false,
-      timeoutMs,
-      artifacts = [],
-      logger
-    } = options;
-    const stageLabel = iteration !== void 0 ? `${stage}:${iteration}` : stage;
-    logger.step(
-      "sandcastle",
-      `[${stageLabel}] running agent "${agent}" with model "${model}"`
-    );
-    try {
-      const env = {};
-      if (autoApprove) {
-        env.OPENCODE_AUTO_APPROVE = "true";
-      }
-      const serenaConfig = buildSerenaOpenCodeConfig(stage, options.serena);
-      if (serenaConfig) {
-        env.OPENCODE_CONFIG_CONTENT = JSON.stringify(serenaConfig);
-      }
-      const logPath = `${repoRoot2}/.pourkit/logs/${sanitizeBranch(branchName)}-${Date.now()}.log`;
-      await ensureSandboxImageBuilt(repoRoot2, { force: sandbox.forceRebuild });
-      try {
-        savePromptToFile(repoRoot2, stage, iteration, prompt);
-      } catch {
-      }
-      const agentProvider = opencode(model, { env, agent });
-      const sandboxOptions = buildSandboxOptions(repoRoot2, sandbox);
-      const sandboxProvider = resolveSandboxProvider(sandbox.provider, docker);
-      const activeSandbox = await this.getOrCreateSandbox({
-        repoRoot: repoRoot2,
-        branchName,
-        baseBranch: baseRef ?? target.baseBranch,
-        worktreePath,
-        sandboxProvider: sandboxProvider(sandboxOptions),
-        setupCommands: target.setupCommands ?? [],
-        copyToWorktree: sandbox.copyToWorktree ?? []
-      });
-      await writeExecutionArtifacts(activeSandbox.worktreePath, artifacts);
-      const result = await activeSandbox.run({
-        agent: agentProvider,
-        prompt,
-        maxIterations: 1,
-        name: stageLabel,
-        logging: {
-          type: "file",
-          path: logPath,
-          onAgentStreamEvent: (event) => {
-            if (event.type === "text") {
-              logger.raw(event.message);
-            } else if (event.type === "toolCall") {
-              logger.raw(`${event.name}(${event.formattedArgs})`);
-            }
-          }
-        },
-        completionSignal: "<promise>COMPLETE</promise>",
-        ...timeoutMs ? { signal: AbortSignal.timeout(timeoutMs) } : {},
-        ...sandboxOptions.idleTimeoutSeconds ? { idleTimeoutSeconds: sandboxOptions.idleTimeoutSeconds } : {}
-      });
-      const commits = result.commits.map((c) => c.sha);
-      const resultBranch = result.branch ?? activeSandbox.branch ?? branchName;
-      logger.kv("SANDBOX_SUCCESS", "true");
-      logger.kv("COMMITS_CREATED", String(commits.length));
-      logger.kv("WORKTREE_BRANCH", resultBranch);
-      if (result.logFilePath) {
-        logger.kv("LOG_FILE", result.logFilePath);
-      }
-      return {
-        success: true,
-        branch: resultBranch,
-        worktreePath: activeSandbox.worktreePath,
-        commits,
-        logPath
-      };
-    } catch (error) {
-      logger.step(
-        "error",
-        `Sandcastle failed: ${error instanceof Error ? error.message : String(error)}`
-      );
-      return {
-        success: false,
-        branch: "",
-        worktreePath: "",
-        commits: [],
-        logPath: null,
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-  async getOrCreateSandbox(options) {
-    if (this.sandboxHandle) {
-      return this.sandboxHandle;
-    }
-    const hooks = {
-      sandbox: {
-        onSandboxReady: options.setupCommands.map((command) => ({
-          command: command.command
-        }))
-      }
-    };
-    if (options.worktreePath) {
-      this.sandboxHandle = await createSandboxFromExistingWorktree({
-        branch: options.branchName,
-        hostRepoDir: options.repoRoot,
-        worktreePath: options.worktreePath,
-        sandbox: options.sandboxProvider,
-        ...options.copyToWorktree.length > 0 ? { copyToWorktree: options.copyToWorktree } : {},
-        hooks
-      });
-      return this.sandboxHandle;
-    }
-    this.worktreeHandle = await createWorktree({
-      cwd: options.repoRoot,
-      branchStrategy: {
-        type: "branch",
-        branch: options.branchName,
-        baseBranch: options.baseBranch
-      },
-      ...options.copyToWorktree.length > 0 ? { copyToWorktree: options.copyToWorktree } : {}
-    });
-    this.sandboxHandle = await this.worktreeHandle.createSandbox({
-      sandbox: options.sandboxProvider,
-      ...options.copyToWorktree.length > 0 ? { copyToWorktree: options.copyToWorktree } : {},
-      hooks
-    });
-    return this.sandboxHandle;
-  }
-};
-function resolveSandboxProvider(provider, dockerFactory) {
-  if (provider === "docker") {
-    return dockerFactory;
-  }
-  throw new Error(`Unsupported sandbox provider: ${provider}`);
-}
-function sanitizeBranch(branchName) {
-  return branchName.replace(/[^A-Za-z0-9._-]/g, "-");
-}
-function savePromptToFile(repoRoot2, stage, iteration, prompt) {
-  const promptsDir = join12(repoRoot2, ".pourkit", ".tmp", "prompts");
-  mkdirSync6(promptsDir, { recursive: true });
-  const timestamp2 = Date.now();
-  const iterationSuffix = iteration !== void 0 ? `-iteration-${iteration}` : "";
-  const filename = `${stage}${iterationSuffix}-${timestamp2}.md`;
-  const filePath = join12(promptsDir, filename);
-  writeFileSync4(filePath, prompt, "utf-8");
-}
-
-// cli.ts
+init_sandcastle_execution();
 function normalizePrdRef(ref) {
   const normalized = ref.trim().toUpperCase();
   if (!/^PRD-\d+$/.test(normalized)) {
@@ -9076,11 +9791,11 @@ function createCliProgram(version) {
   return program;
 }
 async function resolveCliVersion() {
-  if (isPackageVersion("0.0.0-next-20260531213458")) {
-    return "0.0.0-next-20260531213458";
+  if (isPackageVersion("0.0.0-next-20260601224754")) {
+    return "0.0.0-next-20260601224754";
   }
-  if (isReleaseVersion("0.0.0-next-20260531213458")) {
-    return "0.0.0-next-20260531213458";
+  if (isReleaseVersion("0.0.0-next-20260601224754")) {
+    return "0.0.0-next-20260601224754";
   }
   try {
     const root = repoRoot();
@@ -9106,6 +9821,7 @@ async function resolveCliVersion() {
   return DEVELOPMENT_VERSION;
 }
 async function main(argv = process.argv.slice(2)) {
+  initializeEffectRuntime();
   const version = await resolveCliVersion();
   const program = createCliProgram(version);
   if (argv.length === 0) {