@pourkit/cli 0.0.0-next-20260619074943 → 0.0.0-next-20260619094345

package/dist/cli.js

@@ -869,20 +869,6 @@ function parseConfig(raw) {
 function getVerificationCommands(target) {
   return target.strategy.verify?.commands ?? [];
 }
-function resolvePrdRunMode(target, opts) {
-  if (opts?.localOverride === true) {
-    return { mode: "local", source: "cli-override", targetName: target.name };
-  }
-  const configMode = target.prdRun?.mode;
-  if (configMode) {
-    return {
-      mode: configMode,
-      source: "target-config",
-      targetName: target.name
-    };
-  }
-  return { mode: "github", source: "default", targetName: target.name };
-}
 function shouldCleanupRepositoryAfterPrdDrain(target) {
   return target.prdRun?.cleanupRepository ?? true;
 }
@@ -894,11 +880,11 @@ var OBSOLETE_CONFIG_PATHS = [
 ];
 var CANONICAL_CONFIG_PATH = ".pourkit/config.json";
 async function loadRepoConfig(repoRoot2, _configFileName) {
-  const { existsSync: existsSync24 } = await import("fs");
+  const { existsSync: existsSync21 } = await import("fs");
   const { join: pjoin } = await import("path");
   for (const obPath of OBSOLETE_CONFIG_PATHS) {
     const fullPath = pjoin(repoRoot2, obPath);
-    if (existsSync24(fullPath)) {
+    if (existsSync21(fullPath)) {
       const isRootJson = obPath === "pourkit.json";
       throw new Error(
         isRootJson ? `Found root ${obPath}, but Pourkit config now lives at ${CANONICAL_CONFIG_PATH}. Move the file and update "$schema" to "./schema/pourkit.schema.json".` : `Found ${obPath}, but executable config is no longer supported. Move configuration to ${CANONICAL_CONFIG_PATH} with "$schema": "./schema/pourkit.schema.json".`
@@ -906,13 +892,13 @@ async function loadRepoConfig(repoRoot2, _configFileName) {
     }
   }
   const configPath = pjoin(repoRoot2, CANONICAL_CONFIG_PATH);
-  if (!existsSync24(configPath)) {
+  if (!existsSync21(configPath)) {
     throw new Error(
       `No Pourkit config found at ${CANONICAL_CONFIG_PATH}. Run pourkit init or create ${CANONICAL_CONFIG_PATH} with "$schema": "./schema/pourkit.schema.json".`
     );
   }
-  const { readFile: readFile8 } = await import("fs/promises");
-  const raw = await readFile8(configPath, "utf-8");
+  const { readFile: readFile7 } = await import("fs/promises");
+  const raw = await readFile7(configPath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -923,10 +909,10 @@ async function loadRepoConfig(repoRoot2, _configFileName) {
   return parseConfig(parsed);
 }
 async function loadConfig(configPath) {
-  const { readFile: readFile8 } = await import("fs/promises");
+  const { readFile: readFile7 } = await import("fs/promises");
   const ext = configPath.split(".").pop()?.toLowerCase();
   if (ext === "json") {
-    const raw = await readFile8(configPath, "utf-8");
+    const raw = await readFile7(configPath, "utf-8");
     return parseConfig(JSON.parse(raw));
   }
   if (ext === "mjs" || ext === "js" || ext === "ts") {
@@ -1148,10 +1134,9 @@ async function cleanupRepository(options) {
 }
 
 // commands/artifact-validation.ts
-import { createHash } from "crypto";
 import { execSync } from "child_process";
-import { existsSync as existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync7 } from "fs";
-import { isAbsolute as isAbsolute3, join as join7, resolve as resolve3 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
+import { isAbsolute as isAbsolute3, resolve as resolve3 } from "path";
 
 // pr/review-verdict.ts
 var ReviewVerdictProtocolError = class extends Error {
@@ -3670,18 +3655,6 @@ function validateAgentArtifact(options) {
         }
         return valid(options, [`decision: ${parsed.json.recoveryDecision}`]);
       }
-      case "local-prd":
-      case "local-issue":
-      case "local-triage":
-        return invalid(
-          options,
-          `Local artifact kind must be validated through runLocalValidateArtifactCommand`
-        );
-      case "local-prepare":
-        return invalid(
-          options,
-          `Artifact kind "${options.kind}" has been removed from PRD Run validation`
-        );
     }
   } catch (error) {
     if (error instanceof ReviewArtifactValidationError || error instanceof ReviewVerdictProtocolError || error instanceof PrDescriptionProtocolError || error instanceof ConflictResolutionArtifactProtocolError || error instanceof RecoveryArtifactInvalid || error instanceof Error) {
@@ -3735,874 +3708,127 @@ function isIssueFinalReviewAuditedPath(path9) {
 function shellQuote(value) {
   return `'${value.replace(/'/g, `'"'"'`)}'`;
 }
-function runLocalValidateArtifactCommand(options) {
-  const resolvedPath = resolve3(options.repoRoot, options.artifactPath);
-  const resolvedExtra = (options.extraArgs ?? []).map(
-    (p) => isAbsolute3(p) ? p : resolve3(options.repoRoot, p)
-  );
-  let localResult;
-  switch (options.kind) {
-    case "local-prd":
-      localResult = validateLocalPrd(resolvedPath);
-      break;
-    case "local-issue":
-      localResult = validateLocalIssue(resolvedPath);
-      break;
-    case "local-triage":
-      localResult = validateLocalTriage(resolvedPath, resolvedExtra);
-      break;
-    default:
-      return {
-        ok: false,
-        kind: options.kind,
-        artifactPath: resolvedPath,
-        reason: `Unsupported local artifact kind "${options.kind}"`,
-        diagnostics: []
-      };
-  }
-  if (localResult.ok) {
-    return {
-      ok: true,
-      kind: options.kind,
-      artifactPath: resolvedPath,
-      diagnostics: []
-    };
-  }
-  const diagnostics = [];
-  if (localResult.gate) diagnostics.push(`gate: ${localResult.gate}`);
-  if (localResult.failureCode)
-    diagnostics.push(`failureCode: ${localResult.failureCode}`);
-  if (localResult.offendingPath)
-    diagnostics.push(`offendingPath: ${localResult.offendingPath}`);
-  if (localResult.message) diagnostics.push(localResult.message);
-  return {
-    ok: false,
-    kind: options.kind,
-    artifactPath: resolvedPath,
-    reason: localResult.message ?? "Validation failed",
-    diagnostics
-  };
+
+// commands/issue-run.ts
+import { existsSync as existsSync12, readFileSync as readFileSync14 } from "fs";
+import { isAbsolute as isAbsolute5, join as join14 } from "path";
+
+// pr/templates.ts
+init_common();
+function renderBranchName(template, issue) {
+  return renderTemplate(template, issue);
 }
-function readLocalArtifact(path9, failureCode) {
-  try {
-    const raw = readFileSync7(path9, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return {
-        ok: false,
-        failureCode: failureCode ?? "invalid_prd_artifact",
-        offendingPath: path9,
-        message: `Expected a JSON object, got ${Array.isArray(parsed) ? "array" : parsed === null ? "null" : typeof parsed}`
-      };
-    }
-    return { ok: true, data: parsed };
-  } catch (e) {
-    return {
-      ok: false,
-      failureCode: failureCode ?? "invalid_prd_artifact",
-      offendingPath: path9,
-      message: `Failed to read or parse: ${e}`
-    };
-  }
+function renderTemplate(template, issue) {
+  const issueSlug = slugify(issue.title);
+  return template.replace(/\{\{issue\.number\}\}/g, String(issue.number)).replace(/\{\{issue\.title\}\}/g, issue.title).replace(/\{\{issue\.body\}\}/g, issue.body).replace(/\{\{issue\.slug\}\}/g, issueSlug).replace(/\{\{issue\.state\}\}/g, issue.state);
 }
-var VALID_LOCAL_PRD_STATUSES = [
-  "draft",
-  "ready",
-  "prepared",
-  "running",
-  "final-review",
-  "reconciliation",
-  "complete",
-  "blocked"
-];
-var TO_PRD_REQUIRED_HEADINGS = [
-  "Problem Statement",
-  "Solution",
-  "Plan Documents",
-  "User Stories",
-  "Implementation Decisions",
-  "Testing Decisions",
-  "Out of Scope",
-  "Further Notes"
-];
-var TO_ISSUES_REQUIRED_HEADINGS = [
-  "Parent",
-  "Plan Documents",
-  "Source of truth for behavior",
-  "What to build",
-  "High-level explanation",
-  "Affected code paths",
-  "Exploration evidence",
-  "Contract decisions",
-  "Execution path matrix",
-  "Regression contract (CRITICAL)",
-  "Step-by-step implementation",
-  "Contracts / interfaces",
-  "Edge cases",
-  "Validation",
-  "Out of scope",
-  "Priority",
-  "Acceptance criteria",
-  "Blocked by"
-];
-var VALID_LOCAL_ISSUE_STATUSES = [
-  "needs-triage",
-  "ready-for-agent",
-  "blocked",
-  "ready-for-human",
-  "wontfix",
-  "running",
-  "complete"
-];
-var VALID_ISSUE_TRIAGE_LABELS = [
-  "needs-triage",
-  "ready-for-agent",
-  "blocked",
-  "ready-for-human",
-  "wontfix",
-  "running",
-  "complete"
-];
-var VALID_ISSUE_CATEGORY_LABELS = ["bug", "enhancement"];
-var VALID_ISSUE_TYPE_LABELS = [
-  "type:bugfix",
-  "type:infra",
-  "type:feature",
-  "type:polish",
-  "type:refactor"
-];
-var ISSUE_RECEIPT_FIELDS = [
-  "createdAt",
-  "updatedAt",
-  "preparedAt",
-  "startedAt",
-  "completedAt",
-  "reviewedAt",
-  "mergedAt"
-];
-var ISSUE_PROJECTION_FIELDS = [
-  "issueNumber",
-  "issueUrl",
-  "publishedAt",
-  "syncedAt"
-];
-function getMarkdownHeadings(markdown) {
-  const headingRegex = /^## (.+)$/gm;
-  const headings = [];
-  let match;
-  while ((match = headingRegex.exec(markdown)) !== null) {
-    headings.push(match[1].trim());
+
+// commands/issue-run.ts
+init_common();
+
+// commands/base-refresh.ts
+init_common();
+async function isIssueBranchStale(worktreePath, baseBranch, logger) {
+  try {
+    await execCapture(
+      "git",
+      ["merge-base", "--is-ancestor", baseBranch, "HEAD"],
+      {
+        cwd: worktreePath,
+        logger,
+        label: "git merge-base --is-ancestor"
+      }
+    );
+    return false;
+  } catch {
+    return true;
   }
-  return headings;
 }
-function validateLocalPrd(path9) {
-  const parsed = readLocalArtifact(path9);
-  if (!parsed.ok) return parsed;
-  const data = parsed.data;
-  if (data.schemaVersion !== 1) {
-    return {
-      ok: false,
-      failureCode: "invalid_prd_artifact",
-      offendingPath: path9,
-      message: "schemaVersion must be 1"
-    };
-  }
-  if (data.kind !== "prd") {
-    return {
-      ok: false,
-      failureCode: "invalid_prd_artifact",
-      offendingPath: path9,
-      message: "kind must be prd"
-    };
-  }
-  if (typeof data.id !== "string" || data.id.trim() === "") {
-    return {
-      ok: false,
-      failureCode: "invalid_prd_artifact",
-      offendingPath: path9,
-      message: "id must be a non-empty string"
-    };
-  }
-  if (typeof data.title !== "string" || data.title.trim() === "") {
-    return {
-      ok: false,
-      failureCode: "invalid_prd_artifact",
-      offendingPath: path9,
-      message: "title must be a non-empty string"
-    };
-  }
-  if (typeof data.status !== "string" || !VALID_LOCAL_PRD_STATUSES.includes(data.status)) {
-    return {
-      ok: false,
-      failureCode: "invalid_prd_artifact",
-      offendingPath: path9,
-      message: `status must be one of: ${VALID_LOCAL_PRD_STATUSES.join(", ")}`
-    };
-  }
-  if (!Array.isArray(data.childIssueIds)) {
-    return {
-      ok: false,
-      failureCode: "invalid_prd_artifact",
-      offendingPath: path9,
-      message: "childIssueIds must be an array"
-    };
-  }
-  if (!Array.isArray(data.linkedDecisionIds)) {
-    return {
-      ok: false,
-      failureCode: "invalid_prd_artifact",
-      offendingPath: path9,
-      message: "linkedDecisionIds must be an array"
-    };
-  }
-  if (!data.reconciliationTarget || typeof data.reconciliationTarget !== "object") {
-    return {
-      ok: false,
-      failureCode: "invalid_prd_artifact",
-      offendingPath: path9,
-      message: "reconciliationTarget must be an object"
-    };
-  }
-  const reconciliationTarget = data.reconciliationTarget;
-  if (typeof reconciliationTarget.localPrdBranch !== "string" || reconciliationTarget.localPrdBranch.trim() === "") {
-    return {
-      ok: false,
-      failureCode: "invalid_prd_artifact",
-      offendingPath: path9,
-      message: "reconciliationTarget.localPrdBranch must be a non-empty string"
-    };
-  }
-  if (typeof reconciliationTarget.integrationBranch !== "string" || reconciliationTarget.integrationBranch.trim() === "") {
-    return {
-      ok: false,
-      failureCode: "invalid_prd_artifact",
-      offendingPath: path9,
-      message: "reconciliationTarget.integrationBranch must be a non-empty string"
-    };
-  }
-  if (typeof data.bodyMarkdown !== "string" || data.bodyMarkdown.trim() === "") {
-    return {
-      ok: false,
-      failureCode: "invalid_prd_artifact",
-      offendingPath: path9,
-      message: "bodyMarkdown must be a non-empty string"
-    };
-  }
-  if (!data.bodyContract || typeof data.bodyContract !== "object") {
-    return {
-      ok: false,
-      failureCode: "invalid_prd_artifact",
-      offendingPath: path9,
-      message: "bodyContract must be an object"
-    };
-  }
-  const bodyContract = data.bodyContract;
-  if (bodyContract.contract !== "to-prd") {
-    return {
-      ok: false,
-      failureCode: "invalid_prd_artifact",
-      offendingPath: path9,
-      message: 'bodyContract.contract must be "to-prd"'
-    };
-  }
-  if (!Array.isArray(bodyContract.requiredHeadings)) {
-    return {
-      ok: false,
-      failureCode: "invalid_prd_artifact",
-      offendingPath: path9,
-      message: "bodyContract.requiredHeadings must be an array"
-    };
-  }
-  const requiredHeadings = bodyContract.requiredHeadings;
-  const missingHeadings = TO_PRD_REQUIRED_HEADINGS.filter(
-    (h) => !requiredHeadings.includes(h)
-  );
-  if (missingHeadings.length > 0) {
-    return {
-      ok: false,
-      failureCode: "invalid_prd_artifact",
-      offendingPath: path9,
-      message: `bodyContract.requiredHeadings missing: ${missingHeadings.join(", ")}`
-    };
-  }
-  const markdownHeadings = getMarkdownHeadings(data.bodyMarkdown);
-  const missingInMarkdown = TO_PRD_REQUIRED_HEADINGS.filter(
-    (h) => !markdownHeadings.includes(h)
-  );
-  if (missingInMarkdown.length > 0) {
-    return {
-      ok: false,
-      failureCode: "invalid_prd_artifact",
-      offendingPath: path9,
-      message: `bodyMarkdown missing headings: ${missingInMarkdown.join(", ")}`
-    };
+async function refreshStaleIssueBranch(options) {
+  const {
+    worktreePath,
+    baseBranch,
+    localGitBaseRef,
+    logger,
+    prNumber,
+    prState
+  } = options;
+  const stale = await isIssueBranchStale(worktreePath, localGitBaseRef, logger);
+  if (!stale) {
+    return { status: "skipped-current" };
   }
-  if (!data.receipts || typeof data.receipts !== "object") {
+  if (prNumber !== void 0 && prState !== void 0) {
     return {
-      ok: false,
-      failureCode: "invalid_prd_artifact",
-      offendingPath: path9,
-      message: "receipts must be an object"
+      status: "refused-published-history",
+      prNumber,
+      prState
     };
   }
-  const receipts = data.receipts;
-  const expectedReceiptFields = [
-    "createdAt",
-    "updatedAt",
-    "preparedAt",
-    "startedAt",
-    "finalReviewedAt",
-    "reconciledAt",
-    "completedAt"
-  ];
-  for (const field of expectedReceiptFields) {
-    if (!(field in receipts)) {
-      return {
-        ok: false,
-        failureCode: "invalid_prd_artifact",
-        offendingPath: path9,
-        message: `receipts.${field} is missing`
-      };
+  try {
+    await execCapture("git", ["rebase", "--autostash", localGitBaseRef], {
+      cwd: worktreePath,
+      logger,
+      label: "git rebase --autostash"
+    });
+    return { status: "refreshed" };
+  } catch (error) {
+    let conflictedPaths = [];
+    try {
+      const statusResult = await execCapture("git", ["status", "--porcelain"], {
+        cwd: worktreePath,
+        logger,
+        label: "git status"
+      });
+      conflictedPaths = statusResult.stdout.split("\n").filter((line) => /^(AA|DD|UU|AU|UA|DU|UD)\s/.test(line)).map((line) => line.slice(3).trim()).filter(Boolean);
+    } catch {
     }
-  }
-  if (!data.githubProjection || typeof data.githubProjection !== "object") {
     return {
-      ok: false,
-      failureCode: "invalid_prd_artifact",
-      offendingPath: path9,
-      message: "githubProjection must be an object"
+      status: "conflicted",
+      message: error instanceof Error ? error.message : String(error),
+      conflictedPaths
     };
   }
-  const githubProjection = data.githubProjection;
-  const expectedProjectionFields = [
-    "issueNumber",
-    "issueUrl",
-    "publishedAt",
-    "syncedAt"
-  ];
-  for (const field of expectedProjectionFields) {
-    if (!(field in githubProjection)) {
-      return {
-        ok: false,
-        failureCode: "invalid_prd_artifact",
-        offendingPath: path9,
-        message: `githubProjection.${field} is missing`
-      };
+}
+function invalidateAfterBaseRefresh(state) {
+  return {
+    issueNumber: state.issueNumber,
+    targetName: state.targetName,
+    branchName: state.branchName,
+    baseBranch: state.baseBranch,
+    createdAt: state.createdAt,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    completedStages: {
+      builder: state.completedStages.builder
+    },
+    review: {
+      lifetimeIterations: 0
     }
-  }
-  return { ok: true };
+  };
 }
-function validateLocalIssue(path9) {
-  const parsed = readLocalArtifact(path9);
-  if (!parsed.ok) {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: parsed.message
-    };
-  }
-  const data = parsed.data;
-  if (data.schemaVersion !== 1) {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: "schemaVersion must be 1"
-    };
-  }
-  if (data.kind !== "issue") {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: 'kind must be "issue"'
-    };
-  }
-  if (typeof data.id !== "string" || data.id.trim() === "") {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: "id must be a non-empty string"
-    };
-  }
-  if (typeof data.parentPrdId !== "string" || !/^PRD-\d{4}$/.test(data.parentPrdId.trim())) {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: "parentPrdId must match PRD-0000N format"
-    };
+
+// failure-resolution/effect-runtime.ts
+import { Effect as Effect4 } from "effect";
+
+// shared/effect-runtime.ts
+import { Effect as Effect3, Exit } from "effect";
+import { UnknownException } from "effect/Cause";
+var initialized = false;
+function initializeEffectRuntime() {
+  if (initialized) return;
+  initialized = true;
+}
+function runEffect(program) {
+  ensureEffectRuntime();
+  return Effect3.runPromiseExit(program);
+}
+function ensureEffectRuntime() {
+  if (!initialized) {
+    initializeEffectRuntime();
   }
-  if (typeof data.title !== "string" || data.title.trim() === "") {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: "title must be a non-empty string"
-    };
-  }
-  if (typeof data.status !== "string" || !VALID_LOCAL_ISSUE_STATUSES.includes(data.status)) {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: `status must be one of: ${VALID_LOCAL_ISSUE_STATUSES.join(", ")}`
-    };
-  }
-  if (!Array.isArray(data.labels)) {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: "labels must be an array"
-    };
-  }
-  const labels = data.labels;
-  const triageLabel = labels.find((l) => VALID_ISSUE_TRIAGE_LABELS.includes(l));
-  const categoryLabel = labels.find(
-    (l) => VALID_ISSUE_CATEGORY_LABELS.includes(l)
-  );
-  const typeLabel = labels.find((l) => VALID_ISSUE_TYPE_LABELS.includes(l));
-  const unknownLabels = labels.filter(
-    (l) => !VALID_ISSUE_TRIAGE_LABELS.includes(l) && !VALID_ISSUE_CATEGORY_LABELS.includes(l) && !VALID_ISSUE_TYPE_LABELS.includes(l)
-  );
-  if (!triageLabel) {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: `labels must include one triage-state label from: ${VALID_ISSUE_TRIAGE_LABELS.join(", ")}`
-    };
-  }
-  if (!categoryLabel) {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: `labels must include one category label from: ${VALID_ISSUE_CATEGORY_LABELS.join(", ")}`
-    };
-  }
-  if (!typeLabel) {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: `labels must include one type label from: ${VALID_ISSUE_TYPE_LABELS.join(", ")}`
-    };
-  }
-  if (data.status !== "running" && data.status !== "complete" && triageLabel !== data.status) {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: `triage-state label must match status: expected "${data.status}", got "${triageLabel}"`
-    };
-  }
-  const typeLabels = labels.filter((l) => l.startsWith("type:"));
-  if (typeLabels.length > 1) {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: "more than one type:* label found"
-    };
-  }
-  if (labels.length !== 3 || unknownLabels.length > 0) {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: "labels must contain exactly 3 entries: one triage-state, one category, one type:*"
-    };
-  }
-  if (!Array.isArray(data.dependencyIssueIds)) {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: "dependencyIssueIds must be an array"
-    };
-  }
-  if (typeof data.branchName !== "string" || !/^local\/PRD-\d{4}\/I-\d{2}-[a-z0-9-]+$/.test(data.branchName)) {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: "branchName must match local/PRD-0000N/I-0N-slug pattern"
-    };
-  }
-  if (!(data.blockedReason === null || typeof data.blockedReason === "string")) {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: "blockedReason must be a string or null"
-    };
-  }
-  if (!(data.readyForHumanReason === null || typeof data.readyForHumanReason === "string")) {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: "readyForHumanReason must be a string or null"
-    };
-  }
-  if (typeof data.bodyMarkdown !== "string" || data.bodyMarkdown.trim() === "") {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: "bodyMarkdown must be a non-empty string"
-    };
-  }
-  if (!data.bodyContract || typeof data.bodyContract !== "object") {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: "bodyContract must be an object"
-    };
-  }
-  const bodyContract = data.bodyContract;
-  if (bodyContract.contract !== "to-issues") {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: 'bodyContract.contract must be "to-issues"'
-    };
-  }
-  if (!Array.isArray(bodyContract.requiredHeadings)) {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: "bodyContract.requiredHeadings must be an array"
-    };
-  }
-  const requiredHeadings = bodyContract.requiredHeadings;
-  const missingHeadings = TO_ISSUES_REQUIRED_HEADINGS.filter(
-    (h) => !requiredHeadings.includes(h)
-  );
-  if (missingHeadings.length > 0) {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: `bodyContract.requiredHeadings missing: ${missingHeadings.join(", ")}`
-    };
-  }
-  const markdownHeadings = getMarkdownHeadings(data.bodyMarkdown);
-  const missingInMarkdown = TO_ISSUES_REQUIRED_HEADINGS.filter(
-    (h) => !markdownHeadings.includes(h)
-  );
-  if (missingInMarkdown.length > 0) {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: `bodyMarkdown missing headings: ${missingInMarkdown.join(", ")}`
-    };
-  }
-  if (!data.receipts || typeof data.receipts !== "object") {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: "receipts must be an object"
-    };
-  }
-  const receipts = data.receipts;
-  for (const field of ISSUE_RECEIPT_FIELDS) {
-    if (!(field in receipts)) {
-      return {
-        ok: false,
-        failureCode: "invalid_issue_artifact",
-        offendingPath: path9,
-        message: `receipts.${field} is missing`
-      };
-    }
-  }
-  if (!data.githubProjection || typeof data.githubProjection !== "object") {
-    return {
-      ok: false,
-      failureCode: "invalid_issue_artifact",
-      offendingPath: path9,
-      message: "githubProjection must be an object"
-    };
-  }
-  const githubProjection = data.githubProjection;
-  for (const field of ISSUE_PROJECTION_FIELDS) {
-    if (!(field in githubProjection)) {
-      return {
-        ok: false,
-        failureCode: "invalid_issue_artifact",
-        offendingPath: path9,
-        message: `githubProjection.${field} is missing`
-      };
-    }
-  }
-  return { ok: true };
-}
-function validateLocalTriage(prdPath, issuePaths) {
-  const prd = readLocalArtifact(
-    prdPath,
-    "triage_inconsistent"
-  );
-  if (!prd.ok || !prd.data) {
-    return {
-      ok: false,
-      failureCode: "triage_inconsistent",
-      offendingPath: prdPath,
-      message: prd.message ?? "Invalid PRD artifact"
-    };
-  }
-  if (issuePaths.length === 0) {
-    return { ok: true };
-  }
-  const issues = [];
-  for (const issuePath of issuePaths) {
-    const issue = readLocalArtifact(
-      issuePath,
-      "triage_inconsistent"
-    );
-    if (!issue.ok || !issue.data) {
-      return {
-        ok: false,
-        failureCode: "triage_inconsistent",
-        offendingPath: issuePath,
-        message: issue.message ?? "Invalid Issue artifact"
-      };
-    }
-    issues.push({ path: issuePath, data: issue.data });
-  }
-  const issuesById = new Map(issues.map((i) => [i.data.id, i]));
-  const needsTriage = issues.filter((i) => i.data.status === "needs-triage");
-  if (needsTriage.length > 0) {
-    return {
-      ok: false,
-      failureCode: "triage_inconsistent",
-      message: `Parent PRD cannot prepare: child Issue(s) still in needs-triage: ${needsTriage.map((i) => i.data.id).join(", ")}`
-    };
-  }
-  for (const issue of issues.filter((i) => i.data.status === "blocked")) {
-    const deps = issue.data.dependencyIssueIds ?? [];
-    const blockedReason = issue.data.blockedReason;
-    const readyForHumanReason = issue.data.readyForHumanReason;
-    if (deps.length === 0 && blockedReason == null && readyForHumanReason == null) {
-      return {
-        ok: false,
-        failureCode: "triage_inconsistent",
-        offendingPath: issue.path,
-        message: `Blocked Issue ${issue.data.id} requires at least one blocker source: dependencyIssueIds, blockedReason, or readyForHumanReason`
-      };
-    }
-  }
-  for (const issue of issues.filter(
-    (i) => i.data.status === "ready-for-human"
-  )) {
-    if (issue.data.readyForHumanReason == null) {
-      return {
-        ok: false,
-        failureCode: "triage_inconsistent",
-        offendingPath: issue.path,
-        message: `ready-for-human Issue ${issue.data.id} must have a readyForHumanReason`
-      };
-    }
-  }
-  for (const issue of issues.filter((i) => i.data.status === "wontfix")) {
-    if (issue.data.blockedReason == null) {
-      return {
-        ok: false,
-        failureCode: "triage_inconsistent",
-        offendingPath: issue.path,
-        message: `wontfix Issue ${issue.data.id} must have a blockedReason`
-      };
-    }
-  }
-  const blockedCount = issues.filter((i) => i.data.status === "blocked").length;
-  if (blockedCount > 0) {
-    const readyForAgentCount = issues.filter(
-      (i) => i.data.status === "ready-for-agent"
-    ).length;
-    if (readyForAgentCount === 0) {
-      return {
-        ok: false,
-        failureCode: "triage_inconsistent",
-        message: "At least one child Issue must be ready-for-agent when blocked children exist"
-      };
-    }
-  }
-  for (const issue of issues) {
-    const labels = issue.data.labels ?? [];
-    const status = issue.data.status;
-    const triageLabel = labels.find(
-      (l) => VALID_ISSUE_TRIAGE_LABELS.includes(l)
-    );
-    if (triageLabel && status !== "running" && status !== "complete" && triageLabel !== status) {
-      return {
-        ok: false,
-        failureCode: "triage_inconsistent",
-        offendingPath: issue.path,
-        message: `Issue ${issue.data.id} has status "${status}" but triage-state label "${triageLabel}"`
-      };
-    }
-  }
-  for (const issue of issues) {
-    const labels = issue.data.labels ?? [];
-    const triageLabels = labels.filter(
-      (l) => VALID_ISSUE_TRIAGE_LABELS.includes(l)
-    );
-    if (triageLabels.length !== 1) {
-      return {
-        ok: false,
-        failureCode: "triage_inconsistent",
-        offendingPath: issue.path,
-        message: `Issue ${issue.data.id} must have exactly one triage-state label, got ${triageLabels.length}`
-      };
-    }
-  }
-  for (const issue of issues.filter(
-    (i) => i.data.status === "ready-for-agent"
-  )) {
-    const deps = issue.data.dependencyIssueIds ?? [];
-    for (const depId of deps) {
-      const dep = issuesById.get(depId);
-      if (dep && dep.data.status !== "complete") {
-        return {
-          ok: false,
-          failureCode: "triage_inconsistent",
-          offendingPath: issue.path,
-          message: `ready-for-agent Issue ${issue.data.id} has unresolved dependency ${depId} (status: ${dep.data.status})`
-        };
-      }
-    }
-  }
-  return { ok: true };
-}
-
-// commands/issue-run.ts
-import { existsSync as existsSync13, readFileSync as readFileSync15 } from "fs";
-import { isAbsolute as isAbsolute5, join as join16 } from "path";
-
-// pr/templates.ts
-init_common();
-function renderBranchName(template, issue) {
-  return renderTemplate(template, issue);
-}
-function renderTemplate(template, issue) {
-  const issueSlug = slugify(issue.title);
-  return template.replace(/\{\{issue\.number\}\}/g, String(issue.number)).replace(/\{\{issue\.title\}\}/g, issue.title).replace(/\{\{issue\.body\}\}/g, issue.body).replace(/\{\{issue\.slug\}\}/g, issueSlug).replace(/\{\{issue\.state\}\}/g, issue.state);
-}
-
-// commands/issue-run.ts
-init_common();
-
-// commands/base-refresh.ts
-init_common();
-async function isIssueBranchStale(worktreePath, baseBranch, logger) {
-  try {
-    await execCapture(
-      "git",
-      ["merge-base", "--is-ancestor", baseBranch, "HEAD"],
-      {
-        cwd: worktreePath,
-        logger,
-        label: "git merge-base --is-ancestor"
-      }
-    );
-    return false;
-  } catch {
-    return true;
-  }
-}
-async function refreshStaleIssueBranch(options) {
-  const {
-    worktreePath,
-    baseBranch,
-    localGitBaseRef,
-    logger,
-    prNumber,
-    prState
-  } = options;
-  const stale = await isIssueBranchStale(worktreePath, localGitBaseRef, logger);
-  if (!stale) {
-    return { status: "skipped-current" };
-  }
-  if (prNumber !== void 0 && prState !== void 0) {
-    return {
-      status: "refused-published-history",
-      prNumber,
-      prState
-    };
-  }
-  try {
-    await execCapture("git", ["rebase", "--autostash", localGitBaseRef], {
-      cwd: worktreePath,
-      logger,
-      label: "git rebase --autostash"
-    });
-    return { status: "refreshed" };
-  } catch (error) {
-    let conflictedPaths = [];
-    try {
-      const statusResult = await execCapture("git", ["status", "--porcelain"], {
-        cwd: worktreePath,
-        logger,
-        label: "git status"
-      });
-      conflictedPaths = statusResult.stdout.split("\n").filter((line) => /^(AA|DD|UU|AU|UA|DU|UD)\s/.test(line)).map((line) => line.slice(3).trim()).filter(Boolean);
-    } catch {
-    }
-    return {
-      status: "conflicted",
-      message: error instanceof Error ? error.message : String(error),
-      conflictedPaths
-    };
-  }
-}
-function invalidateAfterBaseRefresh(state) {
-  return {
-    issueNumber: state.issueNumber,
-    targetName: state.targetName,
-    branchName: state.branchName,
-    baseBranch: state.baseBranch,
-    createdAt: state.createdAt,
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    completedStages: {
-      builder: state.completedStages.builder
-    },
-    review: {
-      lifetimeIterations: 0
-    }
-  };
-}
-
-// failure-resolution/effect-runtime.ts
-import { Effect as Effect4 } from "effect";
-
-// shared/effect-runtime.ts
-import { Effect as Effect3, Exit } from "effect";
-import { UnknownException } from "effect/Cause";
-var initialized = false;
-function initializeEffectRuntime() {
-  if (initialized) return;
-  initialized = true;
-}
-function runEffect(program) {
-  ensureEffectRuntime();
-  return Effect3.runPromiseExit(program);
-}
-function ensureEffectRuntime() {
-  if (!initialized) {
-    initializeEffectRuntime();
-  }
-}
-function unwrapError(error) {
-  if (error instanceof UnknownException && error.error !== void 0) {
-    return error.error;
+}
+function unwrapError(error) {
+  if (error instanceof UnknownException && error.error !== void 0) {
+    return error.error;
   }
   return error;
 }
@@ -4621,15 +3847,15 @@ function runEffectAndMapExit(program) {
 
 // shared/attempt-log.ts
 import { appendFileSync, existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync8 } from "fs";
-import { dirname as dirname4, join as join8 } from "path";
+import { dirname as dirname4, join as join7 } from "path";
 var ATTEMPT_LOG_PATH = ".pourkit/attempt-log.jsonl";
 function writeAttemptLog(worktreePath, entry) {
-  const logPath = join8(worktreePath, ATTEMPT_LOG_PATH);
+  const logPath = join7(worktreePath, ATTEMPT_LOG_PATH);
   mkdirSync6(dirname4(logPath), { recursive: true });
   appendFileSync(logPath, JSON.stringify(entry) + "\n", "utf-8");
 }
 function readAttemptLog(worktreePath) {
-  const logPath = join8(worktreePath, ATTEMPT_LOG_PATH);
+  const logPath = join7(worktreePath, ATTEMPT_LOG_PATH);
   if (!existsSync8(logPath)) {
     return [];
   }
@@ -4753,12 +3979,12 @@ async function runBaseRefreshAttempt(options) {
 
 // commands/conflict-resolution.ts
 import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
-import { join as join9 } from "path";
+import { join as join8 } from "path";
 init_common();
 var CONFLICT_MARKER_PATTERN2 = /<<<<<<<|=======|>>>>>>>/m;
 async function hasUnresolvedConflictMarkers(worktreePath, files) {
   for (const file of files) {
-    const filePath = join9(worktreePath, file);
+    const filePath = join8(worktreePath, file);
     try {
       const content = readFileSync9(filePath, "utf-8");
       if (CONFLICT_MARKER_PATTERN2.test(content)) {
@@ -5092,7 +4318,7 @@ async function prepareSerenaForTarget(options) {
 
 // failure-resolution/failure-resolution-agent.ts
 import { readFileSync as readFileSync10 } from "fs";
-import { join as join10 } from "path";
+import { join as join9 } from "path";
 
 // failure-resolution/recovery-policy.ts
 function isSecuritySensitiveFailure(failure) {
@@ -5168,7 +4394,7 @@ async function runFailureResolutionAgent(options) {
   } = options;
   const frConfig = target.strategy.failureResolution;
   const artifactPath = packet.artifactTarget;
-  const fullArtifactPath = join10(worktreePath, artifactPath);
+  const fullArtifactPath = join9(worktreePath, artifactPath);
   const fingerprint = computeFailureFingerprint(packet.stageName, failure._tag);
   const prompt = [
     `# Failure Resolution: ${packet.failureType}`,
@@ -5339,12 +4565,12 @@ async function writeRecoveryAttempt(worktreePath, outcome, fingerprint, summary,
 }
 
 // commands/pr-description-agent.ts
-import { join as join12 } from "path";
+import { join as join11 } from "path";
 import { readFileSync as readFileSync11 } from "fs";
 
 // pr/pr-description-context.ts
 init_common();
-import { join as join11 } from "path";
+import { join as join10 } from "path";
 import { readFile } from "fs/promises";
 import { Effect as Effect5 } from "effect";
 function collectFinalizerContextEffect(options) {
@@ -5409,7 +4635,7 @@ function remoteTargetBase(targetBase) {
   return targetBase.includes("/") ? targetBase : `origin/${targetBase}`;
 }
 function buildFinalizerPrompt(context, promptTemplate) {
-  const artifactPathInWorktree = join11(
+  const artifactPathInWorktree = join10(
     ".pourkit",
     ".tmp",
     "finalizer",
@@ -5479,13 +4705,13 @@ function bridgeExecutionProvider2(ep) {
 }
 function runFinalizerAgent(options) {
   const { executionProvider } = options;
-  const artifactPathInWorktree = join12(
+  const artifactPathInWorktree = join11(
     ".pourkit",
     ".tmp",
     "finalizer",
     "agent-output.md"
   );
-  const artifactPath = join12(options.worktreePath, artifactPathInWorktree);
+  const artifactPath = join11(options.worktreePath, artifactPathInWorktree);
   const program = Effect6.gen(function* () {
     const fs = yield* FileSystem;
     const context = yield* collectFinalizerContextEffect({
@@ -5547,7 +4773,7 @@ function runFinalizerAgent(options) {
   );
 }
 function runPrDescriptionFinalizerCore(options) {
-  const artifactPath = join12(
+  const artifactPath = join11(
     options.worktreePath,
     options.artifactPathInWorktree
   );
@@ -5656,300 +4882,12 @@ function loadFinalizerPromptEffect(repoRoot2, promptTemplate, fs) {
 }
 function persistGeneratedArtifactEffect(worktreePath, output, fs) {
   return Effect6.gen(function* () {
-    const dir = join12(worktreePath, ".pourkit", ".tmp", "finalizer");
+    const dir = join11(worktreePath, ".pourkit", ".tmp", "finalizer");
     yield* fs.mkdir(dir).pipe(Effect6.catchAll(() => Effect6.void));
-    yield* fs.writeFile(join12(dir, "generated.md"), output).pipe(Effect6.catchAll(() => Effect6.void));
+    yield* fs.writeFile(join11(dir, "generated.md"), output).pipe(Effect6.catchAll(() => Effect6.void));
   });
 }
 
-// prd-run/local-merge-coordinator.ts
-import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync4 } from "fs";
-import { join as join13 } from "path";
-
-// prd-run/local-branches.ts
-import { execFileSync, spawnSync as spawnSync2 } from "child_process";
-function getLocalPrdBranchName(prdId) {
-  return `local/${prdId}`;
-}
-function materializeLocalPrdBranch(prdId, startBaseCommit, repoRoot2) {
-  const branch = getLocalPrdBranchName(prdId);
-  const root = repoRoot2 ?? process.cwd();
-  const branchExists = (() => {
-    try {
-      return spawnSync2("git", ["rev-parse", "--verify", "--quiet", branch], {
-        cwd: root,
-        encoding: "utf8",
-        stdio: "pipe"
-      }).status === 0;
-    } catch {
-      return false;
-    }
-  })();
-  if (branchExists) {
-    const currentCommit = spawnSync2("git", ["rev-parse", branch], {
-      cwd: root,
-      encoding: "utf8",
-      stdio: "pipe"
-    }).stdout?.toString?.().trim() ?? "";
-    if (currentCommit !== startBaseCommit) {
-      return {
-        ok: false,
-        failureCode: "branch_commit_mismatch",
-        message: `Local PRD branch ${branch} exists at commit ${currentCommit} but expected commit ${startBaseCommit}. The branch has diverged from the start base. To resolve, delete the local branch and rerun start, or manually reset it to the expected commit.`
-      };
-    }
-    return {
-      ok: true,
-      created: false
-    };
-  }
-  const branchResult = spawnSync2("git", ["branch", branch, startBaseCommit], {
-    cwd: root,
-    encoding: "utf8",
-    stdio: "pipe"
-  });
-  if (branchResult.status !== 0) {
-    const stderr = branchResult.stderr?.toString?.() ?? "unknown error";
-    return {
-      ok: false,
-      failureCode: "branch_creation_failed",
-      message: `Failed to create local PRD branch ${branch} at ${startBaseCommit}: ${stderr}`
-    };
-  }
-  return { ok: true, created: true };
-}
-var PROTECTED_BRANCHES = /* @__PURE__ */ new Set(["dev", "next", "main"]);
-var LOCAL_BRANCH_PATTERN = /^local\/PRD-\d{4}(\/(I-\d{2}(-[a-z0-9-]+)?)?)?$/;
-function validateLocalBranchName(name) {
-  if (!name || name.length === 0) {
-    return {
-      ok: false,
-      failureCode: "invalid_format",
-      message: "Branch name is empty."
-    };
-  }
-  if (isProtectedBranch(name)) {
-    return {
-      ok: false,
-      failureCode: "protected_branch",
-      message: `Branch "${name}" is protected.`
-    };
-  }
-  if (!LOCAL_BRANCH_PATTERN.test(name)) {
-    return {
-      ok: false,
-      failureCode: "invalid_format",
-      message: `Branch "${name}" does not match the local branch pattern.`
-    };
-  }
-  return { ok: true };
-}
-function isProtectedBranch(name) {
-  return PROTECTED_BRANCHES.has(name);
-}
-
-// prd-run/local-merge-coordinator.ts
-function getLocalStorePath(repoRoot2, prdId) {
-  return join13(repoRoot2, ".pourkit", "local-prd-runs", prdId);
-}
-function getMergeReceiptPath(repoRoot2, prdId, issueId) {
-  return join13(
-    getLocalStorePath(repoRoot2, prdId),
-    "merge-receipts",
-    `${issueId}.json`
-  );
-}
-function getIssueArtifactPath(repoRoot2, prdId, issueId) {
-  return join13(getLocalStorePath(repoRoot2, prdId), "issues", `${issueId}.json`);
-}
-function readIssueBranchName(repoRoot2, prdId, issueId) {
-  const issuePath = getIssueArtifactPath(repoRoot2, prdId, issueId);
-  if (!existsSync10(issuePath)) return null;
-  try {
-    const content = readFileSync12(issuePath, "utf-8");
-    const parsed = JSON.parse(content);
-    return typeof parsed.branchName === "string" && parsed.branchName ? parsed.branchName : null;
-  } catch {
-    return null;
-  }
-}
-async function hasLocalIssueMergeReceipt(prdId, issueId, repoRoot2) {
-  const root = repoRoot2 ?? process.cwd();
-  const receiptPath = getMergeReceiptPath(root, prdId, issueId);
-  if (!existsSync10(receiptPath)) return null;
-  try {
-    const content = readFileSync12(receiptPath, "utf-8");
-    const parsed = JSON.parse(content);
-    if (typeof parsed.prdId === "string" && typeof parsed.issueId === "string" && typeof parsed.stage === "string" && typeof parsed.sourceBranch === "string" && typeof parsed.localPrdBranch === "string" && typeof parsed.mergeCommit === "string" && typeof parsed.completedAt === "string") {
-      return parsed;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-async function squashMergeLocalIssue(prdId, issueId, input, repoRoot2) {
-  const root = repoRoot2 ?? process.cwd();
-  const receiptPath = getMergeReceiptPath(root, prdId, issueId);
-  if (existsSync10(receiptPath)) {
-    try {
-      const existing = JSON.parse(
-        readFileSync12(receiptPath, "utf-8")
-      );
-      if (existing.prdId === prdId && existing.issueId === issueId && existing.mergeCommit) {
-        return {
-          ok: false,
-          failureCode: "already_merged",
-          repairGuidance: `Issue ${issueId} was already merged into ${existing.localPrdBranch}. Merge commit: ${existing.mergeCommit}`
-        };
-      }
-      return {
-        ok: false,
-        failureCode: "invalid_receipt",
-        repairGuidance: `Merge receipt for ${issueId} belongs to different prd/issue. Remove it manually: ${receiptPath}`
-      };
-    } catch {
-      return {
-        ok: false,
-        failureCode: "invalid_receipt",
-        repairGuidance: `Merge receipt for ${issueId} is corrupted. Remove it manually: ${receiptPath}`
-      };
-    }
-  }
-  const sourceBranch = input?.sourceBranch ?? readIssueBranchName(root, prdId, issueId);
-  if (!sourceBranch) {
-    return {
-      ok: false,
-      failureCode: "not_found",
-      repairGuidance: `No source branch found for issue ${issueId} under PRD ${prdId}. Ensure the issue artifact exists with a valid branchName field.`
-    };
-  }
-  try {
-    execFileSync2(
-      "git",
-      ["show-ref", "--verify", "--quiet", `refs/heads/${sourceBranch}`],
-      { cwd: root, encoding: "utf8", stdio: "pipe" }
-    );
-  } catch {
-    return {
-      ok: false,
-      failureCode: "not_found",
-      repairGuidance: `Source branch "${sourceBranch}" does not exist locally. Check that the branch was created and not deleted.`
-    };
-  }
-  const targetBranch = getLocalPrdBranchName(prdId);
-  try {
-    execFileSync2(
-      "git",
-      ["show-ref", "--verify", "--quiet", `refs/heads/${targetBranch}`],
-      { cwd: root, encoding: "utf8", stdio: "pipe" }
-    );
-  } catch {
-    return {
-      ok: false,
-      failureCode: "not_found",
-      repairGuidance: `Local PRD branch "${targetBranch}" does not exist. Run \`prd-run start\` first to create it.`
-    };
-  }
-  try {
-    execFileSync2("git", ["checkout", targetBranch], {
-      cwd: root,
-      encoding: "utf8",
-      stdio: "pipe"
-    });
-    let preMergeHead;
-    try {
-      preMergeHead = execFileSync2("git", ["rev-parse", "HEAD"], {
-        cwd: root,
-        encoding: "utf8",
-        stdio: "pipe"
-      }).trim();
-    } catch {
-      return {
-        ok: false,
-        failureCode: "merge_error",
-        repairGuidance: "Failed to read current HEAD before merge."
-      };
-    }
-    execFileSync2("git", ["merge", "--squash", sourceBranch], {
-      cwd: root,
-      encoding: "utf8",
-      stdio: "pipe"
-    });
-    if (input) {
-      execFileSync2(
-        "git",
-        ["commit", "-m", input.finalizerTitle, "-m", input.finalizerBody],
-        { cwd: root, encoding: "utf8", stdio: "pipe" }
-      );
-    } else {
-      execFileSync2(
-        "git",
-        ["commit", "-m", `Squash merge ${sourceBranch} into ${targetBranch}`],
-        { cwd: root, encoding: "utf8", stdio: "pipe" }
-      );
-    }
-    const revParseResult = execFileSync2("git", ["rev-parse", "HEAD"], {
-      cwd: root,
-      encoding: "utf8",
-      stdio: "pipe"
-    });
-    const mergeCommit = revParseResult.trim();
-    const receipt = {
-      prdId,
-      issueId,
-      stage: "child-issue",
-      sourceBranch,
-      localPrdBranch: targetBranch,
-      mergeCommit,
-      finalizerArtifactPath: input?.finalizerArtifactPath ?? "",
-      completedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    try {
-      const receiptsDir = join13(
-        root,
-        ".pourkit",
-        "local-prd-runs",
-        prdId,
-        "merge-receipts"
-      );
-      mkdirSync7(receiptsDir, { recursive: true });
-      writeFileSync4(receiptPath, JSON.stringify(receipt, null, 2), "utf-8");
-    } catch {
-      try {
-        execFileSync2("git", ["reset", "--hard", preMergeHead], {
-          cwd: root,
-          encoding: "utf8",
-          stdio: "pipe"
-        });
-      } catch {
-      }
-      return {
-        ok: false,
-        failureCode: "receipt_error",
-        repairGuidance: "Failed to write merge receipt. Check disk space and permissions on .pourkit/local-prd-runs/. The merge commit has been rolled back."
-      };
-    }
-    return { ok: true, receipt };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (message.toLowerCase().includes("conflict")) {
-      return {
-        ok: false,
-        failureCode: "conflict",
-        repairGuidance: "Merge conflict during squash. Resolve conflicts in the working tree, then retry."
-      };
-    }
-    const stderr = error instanceof Error && "stderr" in error ? error.stderr : void 0;
-    return {
-      ok: false,
-      failureCode: "merge_error",
-      repairGuidance: stderr ? `Merge failed: ${stderr}` : `Merge failed: ${message}`
-    };
-  }
-}
-
 // pr/pr-body.ts
 import { readFile as readFile2 } from "fs/promises";
 var DEFAULT_MANUAL_PR_BODY = `## Summary
@@ -6020,8 +4958,8 @@ function extractClosingRefs(body) {
 
 // issues/github-issue-publication.ts
 init_common();
-import { existsSync as existsSync11, readFileSync as readFileSync13 } from "fs";
-import { isAbsolute as isAbsolute4, join as join14 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync12 } from "fs";
+import { isAbsolute as isAbsolute4, join as join12 } from "path";
 
 // issues/issue-transitions.ts
 function createIssueTransitions(deps, labels) {
@@ -6496,11 +5434,11 @@ function readIssueFinalReviewArtifact(worktreeState, worktreePath) {
   if (!configuredPath) {
     return null;
   }
-  const artifactPath = isAbsolute4(configuredPath) ? configuredPath : join14(worktreePath, configuredPath);
-  if (!existsSync11(artifactPath)) return null;
+  const artifactPath = isAbsolute4(configuredPath) ? configuredPath : join12(worktreePath, configuredPath);
+  if (!existsSync10(artifactPath)) return null;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync13(artifactPath, "utf-8"));
+    parsed = JSON.parse(readFileSync12(artifactPath, "utf-8"));
   } catch {
     return null;
   }
@@ -6755,9 +5693,9 @@ function isAllowedSecretPlaceholder(value) {
 }
 
 // commands/issue-final-review-agent.ts
-import { existsSync as existsSync12, readFileSync as readFileSync14 } from "fs";
-import { join as join15 } from "path";
-var ISSUE_FINAL_REVIEW_ARTIFACT_PATH = join15(
+import { existsSync as existsSync11, readFileSync as readFileSync13 } from "fs";
+import { join as join13 } from "path";
+var ISSUE_FINAL_REVIEW_ARTIFACT_PATH = join13(
   ".pourkit",
   ".tmp",
   "issue-final-review",
@@ -6775,7 +5713,7 @@ async function runIssueFinalReviewAgent(options) {
     logger
   } = options;
   const artifactPathInWorktree = ISSUE_FINAL_REVIEW_ARTIFACT_PATH;
-  const artifactPath = join15(worktreePath, artifactPathInWorktree);
+  const artifactPath = join13(worktreePath, artifactPathInWorktree);
   const strategy = target.strategy;
   const issueFinalReview = strategy.issueFinalReview;
   const agent = issueFinalReview;
@@ -6880,7 +5818,7 @@ function extractChangedPaths(parsed) {
 function loadIssueFinalReviewPrompt(options) {
   const { repoRoot: repoRoot2, promptTemplate, validationCommand } = options;
   const promptPath = resolvePromptTemplatePath(repoRoot2, promptTemplate);
-  const promptBody = existsSync12(promptPath) ? readFileSync14(promptPath, "utf-8") : promptTemplate;
+  const promptBody = existsSync11(promptPath) ? readFileSync13(promptPath, "utf-8") : promptTemplate;
   return appendProtectedWorkGuidance(`${promptBody}
 
 ## Shared Run Context
@@ -6991,7 +5929,7 @@ async function advanceIssueFinalReview(options) {
         "Issue Final Review state is incomplete: missing artifactPath"
       );
     }
-    const artifactPath = isAbsolute5(ifrFromState.artifactPath) ? ifrFromState.artifactPath : join16(worktreePath, ifrFromState.artifactPath);
+    const artifactPath = isAbsolute5(ifrFromState.artifactPath) ? ifrFromState.artifactPath : join14(worktreePath, ifrFromState.artifactPath);
     const validation = validateAgentArtifact({
       kind: "issue-final-review",
       artifactPath,
@@ -7396,7 +6334,6 @@ async function completeIssueRun(options) {
   let prTitle = issue.title;
   let prBody;
   let finalizerResult;
-  const isLocalModeForFinalizer = options.prdRunMode?.mode === "local";
   const finalizerFromState = worktreeState?.finalizer?.completed ? worktreeState.finalizer : null;
   if (finalizerFromState) {
     try {
@@ -7404,12 +6341,12 @@ async function completeIssueRun(options) {
         prTitle = finalizerFromState.title;
         prBody = finalizerFromState.body;
       } else if (finalizerFromState.artifactPath) {
-        if (!existsSync13(finalizerFromState.artifactPath)) {
+        if (!existsSync12(finalizerFromState.artifactPath)) {
           throw new FinalizerFailure({
             message: `Finalizer artifact missing at ${finalizerFromState.artifactPath}`
           });
         }
-        const artifactContent = readFileSync15(
+        const artifactContent = readFileSync14(
           finalizerFromState.artifactPath,
           "utf-8"
         );
@@ -7422,17 +6359,6 @@ async function completeIssueRun(options) {
         });
       }
     } catch (error) {
-      if (isLocalModeForFinalizer) {
-        return {
-          branchName,
-          target,
-          issue,
-          noOp: false,
-          mode: "local",
-          failureCode: "finalizer_failed",
-          repairGuidance: error instanceof Error ? error.message : "Finalizer state is invalid"
-        };
-      }
       throw error;
     }
   } else {
@@ -7453,17 +6379,6 @@ async function completeIssueRun(options) {
         })
       );
     } catch (error) {
-      if (isLocalModeForFinalizer) {
-        return {
-          branchName,
-          target,
-          issue,
-          noOp: false,
-          mode: "local",
-          failureCode: "finalizer_failed",
-          repairGuidance: error instanceof Error ? error.message : "Finalizer execution failed"
-        };
-      }
       throw error;
     }
     prTitle = finalizerResult.title;
@@ -7498,150 +6413,25 @@ async function completeIssueRun(options) {
   const finalCommitFromState = worktreeState?.finalCommit?.completed;
   if (!finalCommitFromState) {
     await finalizeWorktreeCommit({
-      worktreePath: executionResult.worktreePath,
-      baseRef: `origin/${effectiveBaseBranch}`,
-      title: prTitle,
-      body: finalBody,
-      logger
-    });
-    if (executionResult.worktreePath) {
-      const revParse = await execCapture("git", ["rev-parse", "HEAD"], {
-        cwd: executionResult.worktreePath,
-        logger,
-        label: "git rev-parse HEAD"
-      });
-      updateWorktreeRunState(executionResult.worktreePath, {
-        finalCommit: {
-          completed: true,
-          sha: revParse.stdout.trim()
-        }
-      });
-    }
-  }
-  const isLocalMode = options.prdRunMode?.mode === "local";
-  if (isLocalMode) {
-    const parsed = parseStackedIssue(issue.title, issue.body);
-    const prdId = parsed.parentRef;
-    if (!prdId) {
-      return {
-        branchName,
-        target,
-        issue,
-        noOp: false,
-        mode: "local",
-        failureCode: "finalizer_failed",
-        repairGuidance: "Local mode requires a PRD reference (## Parent) in the issue body or title. Add the parent PRD reference and retry."
-      };
-    }
-    const finalizerFromWorktreeState = worktreeState?.finalizer;
-    if (finalizerFromWorktreeState && !finalizerFromWorktreeState.completed) {
-      return {
-        branchName,
-        target,
-        issue,
-        noOp: false,
-        mode: "local",
-        failureCode: "finalizer_failed",
-        repairGuidance: "Finalizer did not complete on previous run. Re-run the issue finalizer and try again."
-      };
-    }
-    if (!prTitle || !finalBody) {
-      return {
-        branchName,
-        target,
-        issue,
-        noOp: false,
-        mode: "local",
-        failureCode: "finalizer_failed",
-        repairGuidance: "Finalizer produced empty title or body. Re-run the issue finalizer and try again."
-      };
-    }
-    const existingReceipt = await hasLocalIssueMergeReceipt(
-      prdId,
-      `issue-${issueNumber}`,
-      ROOT
-    );
-    if (existingReceipt) {
-      return {
-        branchName,
-        target,
-        issue,
-        noOp: false,
-        mode: "local",
-        failureCode: "already_merged",
-        localPrdBranch: existingReceipt.localPrdBranch,
-        mergeCommit: existingReceipt.mergeCommit,
-        receiptPath: join16(
-          ROOT,
-          ".pourkit",
-          "local-prd-runs",
-          prdId,
-          "merge-receipts",
-          `issue-${issueNumber}.json`
-        )
-      };
-    }
-    const mergeResult = await squashMergeLocalIssue(
-      prdId,
-      `issue-${issueNumber}`,
-      {
-        finalizerTitle: prTitle,
-        finalizerBody: finalBody,
-        finalizerArtifactPath: worktreeState?.finalizer?.artifactPath ?? "",
-        sourceBranch: branchName
-      },
-      ROOT
-    );
-    if (!mergeResult.ok) {
-      return {
-        branchName,
-        target,
-        issue,
-        noOp: false,
-        mode: "local",
-        failureCode: mergeResult.failureCode,
-        repairGuidance: mergeResult.repairGuidance ?? `Local squash-merge failed: ${mergeResult.failureCode}`
-      };
-    }
-    await issueProvider.removeLabel(issueNumber, config.labels.agentInProgress);
-    await issueProvider.removeLabel(
-      issueNumber,
-      config.labels.prOpenAwaitingMerge
-    );
-    let childCloseSucceeded = false;
-    try {
-      await issueProvider.closeIssue(issueNumber);
-      childCloseSucceeded = true;
-    } catch (error) {
-      logger.step(
-        "warn",
-        `Issue #${issueNumber} could not be closed: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-    if (childCloseSucceeded) {
-      await maybeCloseParentAfterChildCompletion(
-        issueProvider,
-        issueNumber,
-        logger
-      );
+      worktreePath: executionResult.worktreePath,
+      baseRef: `origin/${effectiveBaseBranch}`,
+      title: prTitle,
+      body: finalBody,
+      logger
+    });
+    if (executionResult.worktreePath) {
+      const revParse = await execCapture("git", ["rev-parse", "HEAD"], {
+        cwd: executionResult.worktreePath,
+        logger,
+        label: "git rev-parse HEAD"
+      });
+      updateWorktreeRunState(executionResult.worktreePath, {
+        finalCommit: {
+          completed: true,
+          sha: revParse.stdout.trim()
+        }
+      });
     }
-    return {
-      branchName,
-      target,
-      issue,
-      noOp: false,
-      mode: "local",
-      localPrdBranch: getLocalPrdBranchName(prdId),
-      mergeCommit: mergeResult.receipt.mergeCommit,
-      receiptPath: join16(
-        ROOT,
-        ".pourkit",
-        "local-prd-runs",
-        prdId,
-        "merge-receipts",
-        `issue-${issueNumber}.json`
-      )
-    };
   }
   if (!executionResult.worktreePath) {
     throw new Error(
@@ -8008,7 +6798,7 @@ async function resolveIssueWorktree(root, branchName, baseBranch, logger) {
   return { mode: "new", branchName, baseRef };
 }
 function issueWorktreePath(root, branchName) {
-  return join16(root, ".sandcastle", "worktrees", branchName.replace(/\//g, "-"));
+  return join14(root, ".sandcastle", "worktrees", branchName.replace(/\//g, "-"));
 }
 function resolveRegisteredIssueWorktreePath(worktreeListPorcelain, root, branchName) {
   const branchWorktreePath = parseWorktreeListPorcelain(
@@ -8036,7 +6826,7 @@ async function syncTargetBranch(root, baseBranch, logger) {
 }
 function loadBuilderPrompt(repoRoot2, promptTemplate) {
   const promptPath = resolvePromptTemplatePath(repoRoot2, promptTemplate);
-  const promptBody = existsSync13(promptPath) ? readFileSync15(promptPath, "utf-8") : promptTemplate;
+  const promptBody = existsSync12(promptPath) ? readFileSync14(promptPath, "utf-8") : promptTemplate;
   return appendProtectedWorkGuidance(`${promptBody}
 
 ## Shared Run Context
@@ -8531,18 +7321,17 @@ async function runIssueCreateCommand(args, issueProvider, logger) {
 
 // commands/prd-run.ts
 import { lstatSync, realpathSync } from "fs";
-import { join as join21 } from "path";
+import { join as join16 } from "path";
 
 // prd-run/state.ts
 import {
-  existsSync as existsSync14,
-  mkdirSync as mkdirSync8,
-  readFileSync as readFileSync16,
-  readdirSync as readdirSync4,
-  writeFileSync as writeFileSync5
+  existsSync as existsSync13,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync15,
+  readdirSync as readdirSync3,
+  writeFileSync as writeFileSync4
 } from "fs";
-import { mkdir as mkdir4, readFile as readFile4, writeFile } from "fs/promises";
-import { join as join17 } from "path";
+import { join as join15 } from "path";
 import { z } from "zod";
 var PRD_RUN_STATE_DIR = ".pourkit/prd-runs";
 var PrdRunRecordSchema = z.object({
@@ -8559,11 +7348,9 @@ var PrdRunRecordSchema = z.object({
     "waiting_for_integration",
     "finalizing",
     "final_reviewed",
-    "complete",
-    "completed_local_branch"
+    "complete"
   ]),
   updatedAt: z.string().min(1),
-  mode: z.enum(["github", "local"]).optional(),
   blockedGate: z.enum(["receipt-check", "branch-state", "git", "queue", "final-review"]).optional(),
   targetName: z.string().min(1).optional(),
   prdBranch: z.string().min(1).optional(),
@@ -8633,16 +7420,16 @@ function normalizePrdRunRef(ref) {
 function readPrdRun(repoRoot2, prdRef) {
   const normalized = normalizePrdRunRef(prdRef);
   const recordPath = getRecordPath(repoRoot2, normalized);
-  if (!existsSync14(recordPath)) {
+  if (!existsSync13(recordPath)) {
     return { record: null, diagnostics: [] };
   }
   try {
-    const raw = JSON.parse(readFileSync16(recordPath, "utf-8"));
+    const raw = JSON.parse(readFileSync15(recordPath, "utf-8"));
     const parsed = normalizeLegacyPrdRunRecord(PrdRunRecordSchema.parse(raw));
     return { record: parsed, diagnostics: [] };
   } catch (error) {
     try {
-      const raw = JSON.parse(readFileSync16(recordPath, "utf-8"));
+      const raw = JSON.parse(readFileSync15(recordPath, "utf-8"));
       if (raw && typeof raw === "object" && raw.start && typeof raw.start === "object" && raw.start.startBaseBranch === void 0) {
         return {
           record: raw,
@@ -8663,20 +7450,20 @@ function readPrdRun(repoRoot2, prdRef) {
   }
 }
 function listPrdRuns(repoRoot2) {
-  const stateDir = join17(repoRoot2, PRD_RUN_STATE_DIR);
-  if (!existsSync14(stateDir)) {
+  const stateDir = join15(repoRoot2, PRD_RUN_STATE_DIR);
+  if (!existsSync13(stateDir)) {
     return { records: [], diagnostics: [] };
   }
   const records = [];
   const diagnostics = [];
-  for (const entry of readdirSync4(stateDir, { withFileTypes: true }).sort(
+  for (const entry of readdirSync3(stateDir, { withFileTypes: true }).sort(
     (left, right) => left.name.localeCompare(right.name)
   )) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-    const recordPath = join17(stateDir, entry.name);
+    const recordPath = join15(stateDir, entry.name);
     try {
       const record = normalizeLegacyPrdRunRecord(
-        PrdRunRecordSchema.parse(JSON.parse(readFileSync16(recordPath, "utf-8")))
+        PrdRunRecordSchema.parse(JSON.parse(readFileSync15(recordPath, "utf-8")))
       );
       records.push(record);
     } catch (error) {
@@ -8689,10 +7476,10 @@ function listPrdRuns(repoRoot2) {
 }
 function writePrdRunRecord(repoRoot2, record) {
   const normalized = normalizePrdRunRef(record.prdRef);
-  const stateDir = join17(repoRoot2, PRD_RUN_STATE_DIR);
+  const stateDir = join15(repoRoot2, PRD_RUN_STATE_DIR);
   const recordPath = getRecordPath(repoRoot2, normalized);
-  mkdirSync8(stateDir, { recursive: true });
-  writeFileSync5(
+  mkdirSync7(stateDir, { recursive: true });
+  writeFileSync4(
     recordPath,
     JSON.stringify({ ...record, prdRef: normalized }, null, 2),
     "utf-8"
@@ -8708,43 +7495,8 @@ function normalizeLegacyPrdRunRecord(record) {
     offendingPaths: void 0
   };
 }
-var LocalPrdRunRecordSchema = z.object({
-  prdId: z.string().regex(
-    /^PRD-\d{4}$/,
-    "PRD id must use four-digit format (e.g., PRD-0052)"
-  ),
-  createdAt: z.string().min(1),
-  receipts: z.object({
-    start: z.object({
-      startedAt: z.string().min(1),
-      branch: z.string().min(1),
-      baseCommit: z.string().min(1)
-    }).strict().optional(),
-    queue: z.object({ completedAt: z.string().min(1) }).strict().optional(),
-    finalReview: z.object({
-      completedAt: z.string().min(1),
-      targetName: z.string().optional(),
-      prdBranch: z.string().optional(),
-      mergeBase: z.string().optional(),
-      verdict: z.enum([
-        "pass_no_changes",
-        "pass_with_retouch",
-        "needs_human_review",
-        "blocked"
-      ]).optional(),
-      diagnostics: z.array(z.string()).optional(),
-      artifactPath: z.string().optional()
-    }).strict().optional(),
-    complete: z.object({
-      completedAt: z.string().min(1),
-      branch: z.string().min(1),
-      stages: z.array(z.string())
-    }).strict().optional()
-  }).strict(),
-  metadata: z.record(z.unknown())
-}).strict();
 function getRecordPath(repoRoot2, prdRef) {
-  return join17(
+  return join15(
     repoRoot2,
     PRD_RUN_STATE_DIR,
     `${normalizePrdRunRef(prdRef)}.json`
@@ -8752,567 +7504,9 @@ function getRecordPath(repoRoot2, prdRef) {
 }
 
 // prd-run/coordinator.ts
-import { spawnSync as spawnSync3 } from "child_process";
-import { existsSync as existsSync16, readFileSync as readFileSync18 } from "fs";
-import { join as join20 } from "path";
+import { spawnSync as spawnSync2 } from "child_process";
 import { Match, pipe } from "effect";
 
-// prd-run/local-queue-loop.ts
-import { readFileSync as readFileSync17, writeFileSync as writeFileSync6 } from "fs";
-import { join as join19 } from "path";
-
-// prd-run/local-artifacts.ts
-import { existsSync as existsSync15 } from "fs";
-import { join as join18 } from "path";
-var REQUIRED_PRD_FIELDS = [
-  "schemaVersion",
-  "kind",
-  "id",
-  "title",
-  "status",
-  "childIssueIds",
-  "linkedDecisionIds",
-  "reconciliationTarget",
-  "bodyMarkdown",
-  "bodyContract",
-  "receipts",
-  "githubProjection"
-];
-var REQUIRED_ISSUE_FIELDS = [
-  "schemaVersion",
-  "kind",
-  "id",
-  "parentPrdId",
-  "title",
-  "status",
-  "labels",
-  "dependencyIssueIds",
-  "branchName",
-  "blockedReason",
-  "readyForHumanReason",
-  "bodyMarkdown",
-  "bodyContract",
-  "receipts",
-  "githubProjection"
-];
-function prdStorePath(repoRoot2, prdId) {
-  return join18(repoRoot2, ".pourkit", "local-prd-runs", prdId);
-}
-function prdArtifactPath(repoRoot2, prdId) {
-  return join18(prdStorePath(repoRoot2, prdId), "prd.json");
-}
-function issueArtifactPath(repoRoot2, prdId, issueId) {
-  return join18(prdStorePath(repoRoot2, prdId), "issues", `${issueId}.json`);
-}
-function hasRequiredFields(data, requiredFields) {
-  for (const field of requiredFields) {
-    if (!(field in data)) {
-      return String(field);
-    }
-  }
-  return null;
-}
-async function resolveLocalPrdArtifact(prdId, repoRoot2) {
-  const root = repoRoot2 ?? process.cwd();
-  const prdPath = prdArtifactPath(root, prdId);
-  if (!existsSync15(prdPath)) {
-    return {
-      ok: false,
-      failureCode: "missing_prd_artifact",
-      message: `Local PRD artifact not found at ${prdPath}. Create the PRD artifact at .pourkit/local-prd-runs/${prdId}/prd.json using to-prd-local.`
-    };
-  }
-  const result = readLocalArtifact(prdPath);
-  if (!result.ok || !result.data) {
-    return {
-      ok: false,
-      failureCode: "invalid_artifact",
-      message: `Failed to read or parse PRD artifact at ${prdPath}: ${result.message}`
-    };
-  }
-  const missing = hasRequiredFields(
-    result.data,
-    REQUIRED_PRD_FIELDS
-  );
-  if (missing) {
-    return {
-      ok: false,
-      failureCode: "invalid_artifact",
-      message: `PRD artifact at ${prdPath} is missing required field: ${missing}`
-    };
-  }
-  if (result.data.kind !== "prd") {
-    return {
-      ok: false,
-      failureCode: "invalid_artifact",
-      message: `PRD artifact at ${prdPath} has kind "${result.data.kind}", expected "prd"`
-    };
-  }
-  return { ok: true, data: result.data };
-}
-async function resolveLocalIssueArtifacts(prdId, repoRoot2) {
-  const root = repoRoot2 ?? process.cwd();
-  const prdResult = await resolveLocalPrdArtifact(prdId, root);
-  if (!prdResult.ok) {
-    return prdResult;
-  }
-  const childIssueIds = prdResult.data.childIssueIds;
-  const issues = [];
-  for (const childId of childIssueIds) {
-    const issuePath = issueArtifactPath(root, prdId, childId);
-    if (!existsSync15(issuePath)) {
-      return {
-        ok: false,
-        failureCode: "missing_child_issue",
-        missingId: childId,
-        message: `Child Issue artifact "${childId}" not found at ${issuePath}. Ensure all child issues listed in childIssueIds have corresponding JSON artifacts under .pourkit/local-prd-runs/${prdId}/issues/.`
-      };
-    }
-    const result = readLocalArtifact(issuePath);
-    if (!result.ok || !result.data) {
-      return {
-        ok: false,
-        failureCode: "invalid_artifact",
-        missingId: childId,
-        message: `Failed to read or parse Issue artifact at ${issuePath}: ${result.message}`
-      };
-    }
-    const missing = hasRequiredFields(
-      result.data,
-      REQUIRED_ISSUE_FIELDS
-    );
-    if (missing) {
-      return {
-        ok: false,
-        failureCode: "invalid_artifact",
-        missingId: childId,
-        message: `Issue artifact at ${issuePath} is missing required field: ${missing}`
-      };
-    }
-    if (result.data.kind !== "issue") {
-      return {
-        ok: false,
-        failureCode: "invalid_artifact",
-        missingId: childId,
-        message: `Issue artifact at ${issuePath} has kind "${result.data.kind}", expected "issue"`
-      };
-    }
-    issues.push(result.data);
-  }
-  return { ok: true, data: issues };
-}
-
-// prd-run/local-issue-run.ts
-import { execFileSync as execFileSync3 } from "child_process";
-init_common();
-async function createLocalIssueBranch(prdId, issueId, repoRoot2) {
-  const root = repoRoot2 ?? process.cwd();
-  const issuesResult = await resolveLocalIssueArtifacts(prdId, root);
-  if (!issuesResult.ok) {
-    throw new Error(
-      `Cannot create local issue branch: ${issuesResult.message}`
-    );
-  }
-  const issue = issuesResult.data.find((i) => i.id === issueId);
-  if (!issue) {
-    throw new Error(`Issue "${issueId}" not found under PRD "${prdId}"`);
-  }
-  const slug = slugify(issue.title);
-  const branchName = `local/${prdId}/${issueId}-${slug}`;
-  const validation = validateLocalBranchName(branchName);
-  if (!validation.ok) {
-    throw new Error(
-      `Invalid local issue branch name "${branchName}": ${validation.message}`
-    );
-  }
-  const localPrdBranch = `local/${prdId}`;
-  try {
-    execFileSync3(
-      "git",
-      ["show-ref", "--verify", "--quiet", `refs/heads/${localPrdBranch}`],
-      {
-        cwd: root,
-        encoding: "utf8",
-        stdio: "pipe"
-      }
-    );
-  } catch {
-    throw new Error(
-      `Local PRD branch "${localPrdBranch}" does not exist. Create it first.`
-    );
-  }
-  let branchExists = false;
-  try {
-    execFileSync3(
-      "git",
-      ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`],
-      {
-        cwd: root,
-        encoding: "utf8",
-        stdio: "pipe"
-      }
-    );
-    branchExists = true;
-  } catch {
-  }
-  if (!branchExists) {
-    execFileSync3("git", ["checkout", "-b", branchName, localPrdBranch], {
-      cwd: root,
-      encoding: "utf8",
-      stdio: "pipe"
-    });
-  }
-  return { branchName, issue };
-}
-async function runLocalIssue(prdId, issueId, builder, repoRoot2, memory) {
-  try {
-    const root = repoRoot2 ?? process.cwd();
-    const { branchName: branch, issue } = await createLocalIssueBranch(
-      prdId,
-      issueId,
-      root
-    );
-    if (builder) {
-      const result = await builder.execute({
-        prdId,
-        issueId,
-        branch,
-        bodyMarkdown: issue.bodyMarkdown,
-        ...memory ? { memory } : {}
-      });
-      if (!result.ok) {
-        return {
-          ok: false,
-          issueId,
-          branch,
-          failureCode: result.error ?? "Builder execution failed"
-        };
-      }
-      if (!result.issueFinalReviewPassedAt || !result.finalizerTitle || !result.finalizerBody) {
-        return {
-          ok: false,
-          issueId,
-          branch,
-          failureCode: "Local issue run did not produce Issue Final Review and finalizer receipts"
-        };
-      }
-      return {
-        ok: true,
-        issueId,
-        branch,
-        issueFinalReviewPassedAt: result.issueFinalReviewPassedAt,
-        finalizerTitle: result.finalizerTitle,
-        finalizerBody: result.finalizerBody,
-        finalizerArtifactPath: result.finalizerArtifactPath
-      };
-    }
-    return {
-      ok: false,
-      issueId,
-      branch,
-      failureCode: "Local issue runner requires Issue Final Review and finalizer lifecycle execution before merge"
-    };
-  } catch (error) {
-    return {
-      ok: false,
-      issueId,
-      branch: "",
-      failureCode: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-
-// prd-run/local-issue-adapter.ts
-var VALID_TRIAGE_LABELS = /* @__PURE__ */ new Set([
-  "needs-triage",
-  "ready-for-agent",
-  "blocked",
-  "ready-for-human",
-  "wontfix"
-]);
-function countTypeLabels(labels) {
-  return labels.filter((l) => l.startsWith("type:")).length;
-}
-function countTriageLabels(labels) {
-  return labels.filter((l) => VALID_TRIAGE_LABELS.has(l)).length;
-}
-function countCategoryLabels(labels) {
-  const triageCount = countTriageLabels(labels);
-  const typeCount = countTypeLabels(labels);
-  return labels.length - triageCount - typeCount;
-}
-function hasValidLabels(labels) {
-  if (countTriageLabels(labels) !== 1) return false;
-  if (!labels.includes("ready-for-agent")) return false;
-  if (countTypeLabels(labels) !== 1) return false;
-  if (countCategoryLabels(labels) !== 1) return false;
-  return true;
-}
-function isIssueBlockedByDependencies(issue, issues) {
-  const blockers = [];
-  for (const depId of issue.dependencyIssueIds) {
-    const dep = issues.find((i) => i.id === depId);
-    if (!dep || dep.receipts.completedAt === null) {
-      blockers.push(depId);
-    }
-  }
-  return blockers;
-}
-async function getRunnableLocalIssues(prdId, repoRoot2) {
-  const issuesResult = await resolveLocalIssueArtifacts(prdId, repoRoot2);
-  if (!issuesResult.ok) return [];
-  const issues = issuesResult.data;
-  const runnable = [];
-  for (const issue of issues) {
-    if (!hasValidLabels(issue.labels)) continue;
-    if (issue.status !== "ready-for-agent") continue;
-    const blockers = isIssueBlockedByDependencies(issue, issues);
-    runnable.push({
-      id: issue.id,
-      title: issue.title,
-      labels: issue.labels,
-      blockedBy: blockers.length > 0 ? blockers : void 0
-    });
-  }
-  const filtered = runnable.filter(
-    (i) => !i.blockedBy || i.blockedBy.length === 0
-  );
-  return filtered;
-}
-
-// prd-run/local-queue-loop.ts
-var CHILD_CLEANUP_LABELS = ["agent-in-progress", "pr-open-awaiting-merge"];
-var LOCAL_ISSUE_ID_REGEX = /^I-(\d+)$/i;
-function getIssueArtifactPath2(repoRoot2, prdId, issueId) {
-  return join19(
-    repoRoot2,
-    ".pourkit",
-    "local-prd-runs",
-    prdId,
-    "issues",
-    `${issueId}.json`
-  );
-}
-function readIssueArtifact(repoRoot2, prdId, issueId) {
-  try {
-    const content = readFileSync17(
-      getIssueArtifactPath2(repoRoot2, prdId, issueId),
-      "utf-8"
-    );
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-function writeIssueArtifact(repoRoot2, prdId, issue) {
-  writeFileSync6(
-    getIssueArtifactPath2(repoRoot2, prdId, issue.id),
-    JSON.stringify(issue, null, 2),
-    "utf-8"
-  );
-}
-function compareLocalIssueIds(a, b) {
-  const aMatch = a.match(LOCAL_ISSUE_ID_REGEX);
-  const bMatch = b.match(LOCAL_ISSUE_ID_REGEX);
-  if (aMatch && bMatch) {
-    const aNumber = Number.parseInt(aMatch[1], 10);
-    const bNumber = Number.parseInt(bMatch[1], 10);
-    if (aNumber !== bNumber) return aNumber - bNumber;
-  }
-  return a.localeCompare(b);
-}
-async function reconcileLocalBlockedIssues(prdId, repoRoot2) {
-  const root = repoRoot2 ?? process.cwd();
-  const issuesResult = await resolveLocalIssueArtifacts(prdId, root);
-  if (!issuesResult.ok) return;
-  const issues = issuesResult.data;
-  for (const issue of issues) {
-    const isBlocked = issue.status === "blocked";
-    if (!isBlocked) continue;
-    if (issue.dependencyIssueIds.length === 0) continue;
-    const depResults = await Promise.all(
-      issue.dependencyIssueIds.map(
-        (depId) => hasLocalIssueMergeReceipt(prdId, depId, root)
-      )
-    );
-    if (!depResults.every(Boolean)) continue;
-    const updated = readIssueArtifact(root, prdId, issue.id);
-    if (!updated) continue;
-    updated.blockedReason = null;
-    updated.labels = updated.labels.filter((l) => l !== "blocked");
-    if (!updated.labels.includes("ready-for-agent")) {
-      updated.labels.push("ready-for-agent");
-    }
-    if (hasValidLabels(updated.labels)) {
-      updated.status = "ready-for-agent";
-    } else {
-      updated.status = "needs-triage";
-      updated.labels = updated.labels.filter((l) => l !== "ready-for-agent");
-      if (!updated.labels.includes("needs-triage")) {
-        updated.labels.push("needs-triage");
-      }
-    }
-    updated.receipts.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    writeIssueArtifact(root, prdId, updated);
-  }
-}
-async function cleanupChildGitHubIssue(issue, issueProvider) {
-  const issueNumber = issue.githubProjection.issueNumber;
-  if (!issueNumber) return { ok: true };
-  if (!issueProvider) {
-    return {
-      ok: false,
-      failureCode: "missing_issue_provider",
-      repairGuidance: "Issue provider is not available. Cannot close child GitHub Issue or remove labels. Configure a GitHub Issue provider to enable cleanup parity."
-    };
-  }
-  for (const label of CHILD_CLEANUP_LABELS) {
-    try {
-      await issueProvider.removeLabel(issueNumber, label);
-    } catch {
-    }
-  }
-  try {
-    await issueProvider.closeIssue(issueNumber);
-  } catch {
-  }
-  return { ok: true };
-}
-async function runLocalQueueLoop(prdId, repoRoot2, issueProvider, memory) {
-  const root = repoRoot2 ?? process.cwd();
-  const completedIssues = [];
-  const blockedIssues = [];
-  await reconcileLocalBlockedIssues(prdId, root);
-  for (; ; ) {
-    const runnable = await getRunnableLocalIssues(prdId, root);
-    if (runnable.length === 0) {
-      const issuesResult = await resolveLocalIssueArtifacts(prdId, root);
-      if (issuesResult.ok) {
-        for (const issue2 of issuesResult.data) {
-          if (issue2.status === "blocked") {
-            blockedIssues.push(issue2.id);
-          }
-        }
-      }
-      break;
-    }
-    const issue = [...runnable].sort(
-      (a, b) => compareLocalIssueIds(a.id, b.id)
-    )[0];
-    const runResult = memory ? await runLocalIssue(prdId, issue.id, void 0, root, memory) : await runLocalIssue(prdId, issue.id, void 0, root);
-    if (!runResult.ok) {
-      return {
-        ok: false,
-        completedIssues,
-        blockedIssues,
-        failureCode: runResult.failureCode ?? `Issue ${issue.id} failed`,
-        repairGuidance: `Local issue run failed for ${issue.id}. Check the issue artifact and branch state.`,
-        blockedGate: "queue"
-      };
-    }
-    if (!runResult.issueFinalReviewPassedAt || !runResult.finalizerTitle || !runResult.finalizerBody) {
-      return {
-        ok: false,
-        completedIssues,
-        blockedIssues,
-        failureCode: runResult.failureCode ?? "issue_final_review_not_passed",
-        repairGuidance: "Local issue run must complete Issue Final Review and finalizer before local squash merge.",
-        blockedGate: "queue"
-      };
-    }
-    const runArtifact = readIssueArtifact(root, prdId, issue.id);
-    if (!runArtifact) {
-      return {
-        ok: false,
-        completedIssues,
-        blockedIssues,
-        failureCode: "missing_issue_artifact",
-        repairGuidance: `Issue artifact not found for ${issue.id} under PRD ${prdId}. Ensure the issue exists before running the queue loop.`,
-        blockedGate: "queue"
-      };
-    }
-    runArtifact.issueFinalReviewPassedAt = runResult.issueFinalReviewPassedAt;
-    runArtifact.receipts.reviewedAt = runResult.issueFinalReviewPassedAt;
-    runArtifact.receipts.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    writeIssueArtifact(root, prdId, runArtifact);
-    const mergeResult = await squashMergeLocalIssue(
-      prdId,
-      issue.id,
-      {
-        finalizerTitle: runResult.finalizerTitle,
-        finalizerBody: runResult.finalizerBody,
-        finalizerArtifactPath: runResult.finalizerArtifactPath ?? "",
-        sourceBranch: runResult.branch
-      },
-      root
-    );
-    if (!mergeResult.ok) {
-      if (mergeResult.failureCode === "already_merged") {
-        const alreadyMergedArtifact = readIssueArtifact(root, prdId, issue.id);
-        if (alreadyMergedArtifact) {
-          alreadyMergedArtifact.status = "complete";
-          alreadyMergedArtifact.receipts.completedAt = mergeResult.receipt?.completedAt ?? (/* @__PURE__ */ new Date()).toISOString();
-          alreadyMergedArtifact.receipts.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-          writeIssueArtifact(root, prdId, alreadyMergedArtifact);
-          const cleanupResult = await cleanupChildGitHubIssue(
-            alreadyMergedArtifact,
-            issueProvider
-          );
-          if (!cleanupResult.ok) {
-            return {
-              ok: false,
-              completedIssues,
-              blockedIssues,
-              failureCode: cleanupResult.failureCode ?? "child_cleanup_failed",
-              repairGuidance: cleanupResult.repairGuidance ?? `Child GitHub Issue cleanup failed for ${issue.id}.`,
-              blockedGate: "queue"
-            };
-          }
-        }
-        completedIssues.push(issue.id);
-        await reconcileLocalBlockedIssues(prdId, root);
-        continue;
-      }
-      return {
-        ok: false,
-        completedIssues,
-        blockedIssues,
-        failureCode: mergeResult.failureCode ?? `Merge of ${issue.id} failed`,
-        repairGuidance: mergeResult.repairGuidance,
-        blockedGate: "queue"
-      };
-    }
-    const completedArtifact = readIssueArtifact(root, prdId, issue.id);
-    if (completedArtifact) {
-      completedArtifact.status = "complete";
-      completedArtifact.receipts.completedAt = mergeResult.receipt?.completedAt ?? (/* @__PURE__ */ new Date()).toISOString();
-      completedArtifact.receipts.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      writeIssueArtifact(root, prdId, completedArtifact);
-      const cleanupResult = await cleanupChildGitHubIssue(
-        completedArtifact,
-        issueProvider
-      );
-      if (!cleanupResult.ok) {
-        return {
-          ok: false,
-          completedIssues,
-          blockedIssues,
-          failureCode: cleanupResult.failureCode ?? "child_cleanup_failed",
-          repairGuidance: cleanupResult.repairGuidance ?? `Child GitHub Issue cleanup failed for ${issue.id}.`,
-          blockedGate: "queue"
-        };
-      }
-    }
-    completedIssues.push(issue.id);
-    await reconcileLocalBlockedIssues(prdId, root);
-  }
-  return {
-    ok: true,
-    completedIssues,
-    blockedIssues
-  };
-}
-
 // commands/queue.ts
 init_common();
 import { Effect as Effect8 } from "effect";
@@ -9670,7 +7864,6 @@ function runOneQueueIssueEffect(options) {
     }
     const { issue: selected } = outcome;
     const baseBranchOverride = options.queueRunContext?.prdBranch;
-    const prdRunMode = options.prdRunMode ?? options.queueRunContext?.prdRunMode;
     const runResult = yield* Effect8.tryPromise({
       try: () => runIssueCommand({
         issueNumber: selected.number,
@@ -9682,8 +7875,7 @@ function runOneQueueIssueEffect(options) {
         force,
         logger,
         repoRoot: repoRoot2,
-        ...baseBranchOverride ? { baseBranchOverride } : {},
-        ...prdRunMode ? { prdRunMode } : {}
+        ...baseBranchOverride ? { baseBranchOverride } : {}
       }),
       catch: (e) => {
         if (e instanceof Error && e.name === "HumanHandoffStop") {
@@ -9699,10 +7891,6 @@ function runOneQueueIssueEffect(options) {
     logger.raw(`  Branch: ${runResult.branchName}`);
     if (runResult.noOp) {
       logger.raw("  Status: no-op (closed without PR)");
-    } else if (runResult.mode === "local") {
-      logger.raw(`  Local PRD Branch: ${runResult.localPrdBranch}`);
-      logger.raw(`  Merge Commit: ${runResult.mergeCommit}`);
-      logger.raw(`  Receipt: ${runResult.receiptPath}`);
     } else {
       logger.raw(`  PR Title: ${runResult.prTitle}`);
       logger.raw(`  PR Number: ${runResult.prNumber}`);
@@ -9762,8 +7950,7 @@ async function runQueueCommand(options) {
     logger: options.logger,
     repoRoot: options.repoRoot,
     prdRef: options.prdRef,
-    queueRunContext: options.queueRunContext,
-    prdRunMode: options.queueRunContext?.prdRunMode
+    queueRunContext: options.queueRunContext
   };
   if (!options.loop) {
     return runEffectAndMapExit(runQueue(queueOptions));
@@ -9793,11 +7980,6 @@ function planPrdRunLaunchResume(record) {
       skipped: ["start", "queue"],
       resumed: []
     })),
-    Match.when({ status: "completed_local_branch" }, () => ({
-      attempted: [],
-      skipped: ["start", "queue"],
-      resumed: []
-    })),
     Match.when({ status: "complete" }, () => ({
       attempted: [],
       skipped: ["start", "queue"],
@@ -9936,51 +8118,25 @@ function resolvePrdRunBaseBranch(options) {
     return {
       ok: false,
       gate: "branch-state",
-      reason: `Invalid PRD Run base branch: "${trimmed}" must not end with a trailing slash.`,
-      diagnostics: [`Provided branch value: "${trimmed}"`],
-      offendingPaths: []
-    };
-  }
-  if (trimmed.endsWith(".lock")) {
-    return {
-      ok: false,
-      gate: "branch-state",
-      reason: `Invalid PRD Run base branch: "${trimmed}" must not end with ".lock" suffix.`,
-      diagnostics: [`Provided branch value: "${trimmed}"`],
-      offendingPaths: []
-    };
-  }
-  const source = options.baseBranchOverride !== void 0 ? "override" : "target";
-  return { ok: true, baseBranch: trimmed, source };
-}
-function validateLocalStartStore(repoRoot2, prdRef) {
-  const localStoreDir = join20(repoRoot2, ".pourkit", "local-prd-runs", prdRef);
-  const localStorePath = join20(localStoreDir, "prd.json");
-  let localStoreReady = false;
-  if (existsSync16(localStorePath)) {
-    try {
-      const content = JSON.parse(readFileSync18(localStorePath, "utf8"));
-      localStoreReady = content?.id === prdRef && content?.kind === "prd";
-    } catch {
-      localStoreReady = false;
-    }
+      reason: `Invalid PRD Run base branch: "${trimmed}" must not end with a trailing slash.`,
+      diagnostics: [`Provided branch value: "${trimmed}"`],
+      offendingPaths: []
+    };
   }
-  if (!localStoreReady) {
+  if (trimmed.endsWith(".lock")) {
     return {
       ok: false,
       gate: "branch-state",
-      reason: `Local PRD Run Store not ready for ${prdRef}. Expected valid prd.json at .pourkit/local-prd-runs/${prdRef}/prd.json with matching PRD ID. Ensure Local PRD Run Store is initialized before starting.`,
-      diagnostics: [
-        `Expected store path: .pourkit/local-prd-runs/${prdRef}/prd.json`,
-        `Expected PRD ID: ${prdRef}`
-      ],
+      reason: `Invalid PRD Run base branch: "${trimmed}" must not end with ".lock" suffix.`,
+      diagnostics: [`Provided branch value: "${trimmed}"`],
       offendingPaths: []
     };
   }
-  return { ok: true };
+  const source = options.baseBranchOverride !== void 0 ? "override" : "target";
+  return { ok: true, baseBranch: trimmed, source };
 }
 function fetchOriginBranch(repoRoot2, baseBranch) {
-  const fetchResult = spawnSync3("git", ["fetch", "origin", baseBranch], {
+  const fetchResult = spawnSync2("git", ["fetch", "origin", baseBranch], {
     cwd: repoRoot2,
     encoding: "utf8"
   });
@@ -9997,7 +8153,7 @@ function fetchOriginBranch(repoRoot2, baseBranch) {
       offendingPaths: []
     };
   }
-  const revParseResult = spawnSync3(
+  const revParseResult = spawnSync2(
     "git",
     ["rev-parse", `origin/${baseBranch}`],
     {
@@ -10021,7 +8177,7 @@ function fetchOriginBranch(repoRoot2, baseBranch) {
   return { ok: true, startBaseCommit: revParseResult.stdout.trim() };
 }
 function inspectRemotePrdBranch(repoRoot2, prdRef) {
-  const result = spawnSync3("git", ["ls-remote", "--heads", "origin", prdRef], {
+  const result = spawnSync2("git", ["ls-remote", "--heads", "origin", prdRef], {
     cwd: repoRoot2,
     encoding: "utf8"
   });
@@ -10045,7 +8201,7 @@ function inspectRemotePrdBranch(repoRoot2, prdRef) {
   return { ok: true, exists: true, headSha };
 }
 function fetchPrdBranch(repoRoot2, prdRef) {
-  const result = spawnSync3("git", ["fetch", "origin", prdRef], {
+  const result = spawnSync2("git", ["fetch", "origin", prdRef], {
     cwd: repoRoot2,
     encoding: "utf8"
   });
@@ -10065,7 +8221,7 @@ function fetchPrdBranch(repoRoot2, prdRef) {
   return { ok: true };
 }
 async function ensurePrdBranchPublished(repoRoot2, prdRef, startBaseCommit) {
-  const pushResult = spawnSync3(
+  const pushResult = spawnSync2(
     "git",
     ["push", "origin", `${startBaseCommit}:refs/heads/${prdRef}`],
     {
@@ -10124,8 +8280,7 @@ function persistStartingPrdRunRecord(repoRoot2, prdRef, existingRecord, start, c
     status: "starting",
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     targetName: context.targetName,
-    start,
-    mode: context.mode
+    start
   });
 }
 function blocked(repoRoot2, prdRef, gate, failureCode, reason, diagnostics, targetName) {
@@ -10155,28 +8310,6 @@ async function startPrdRun(options) {
     );
   }
   const existingRecord = readPrdRun(options.repoRoot, prdRef);
-  const resolvedMode = options.config ? (() => {
-    try {
-      const target = resolveTarget(options.config, targetName);
-      return resolvePrdRunMode(target).mode;
-    } catch {
-      return void 0;
-    }
-  })() : void 0;
-  if (resolvedMode && existingRecord.record?.mode && existingRecord.record.mode !== resolvedMode) {
-    return blocked(
-      options.repoRoot,
-      prdRef,
-      "branch-state",
-      "mode_mismatch",
-      `PRD Run ${prdRef} mode mismatch: recorded "${existingRecord.record.mode}" but resolved "${resolvedMode}". Resolve by using the correct target.`,
-      [
-        `Recorded mode: ${existingRecord.record.mode}`,
-        `Resolved mode: ${resolvedMode}`
-      ],
-      targetName
-    );
-  }
   const resolvedTarget = options.config ? resolveTarget(options.config, targetName) : null;
   const targetBaseBranch = resolvedTarget?.baseBranch ?? "main";
   const baseResolution = resolvePrdRunBaseBranch({
@@ -10222,11 +8355,10 @@ async function startPrdRun(options) {
       );
     }
     const currentStatus = existingRecord.record.status;
-    if (currentStatus === "running" || currentStatus === "drained" || currentStatus === "completed_prd_branch" || currentStatus === "completed_local_branch" || currentStatus === "complete") {
+    if (currentStatus === "running" || currentStatus === "drained" || currentStatus === "completed_prd_branch" || currentStatus === "complete") {
       return {
         kind: "started",
         prdRef,
-        mode: resolvedMode,
         start: existingRecord.record.start,
         diagnostics: [],
         preservedStatus: currentStatus
@@ -10267,12 +8399,11 @@ async function startPrdRun(options) {
           prdRef,
           existingRecord,
           reusedStart,
-          { targetName, mode: resolvedMode }
+          { targetName }
         );
         return {
           kind: "started",
           prdRef,
-          mode: resolvedMode,
           start: reusedStart,
           diagnostics: []
         };
@@ -10303,7 +8434,7 @@ async function startPrdRun(options) {
           fetchPrdResult.diagnostics
         );
       }
-      const ancestryResult = spawnSync3(
+      const ancestryResult = spawnSync2(
         "git",
         [
           "merge-base",
@@ -10340,12 +8471,11 @@ async function startPrdRun(options) {
         prdRef,
         existingRecord,
         adoptedStart,
-        { targetName, mode: resolvedMode }
+        { targetName }
       );
       return {
         kind: "started",
         prdRef,
-        mode: resolvedMode,
         start: adoptedStart,
         diagnostics: []
       };
@@ -10365,59 +8495,6 @@ async function startPrdRun(options) {
       fetchResult.diagnostics
     );
   }
-  if (resolvedMode === "local") {
-    const localStoreResult = validateLocalStartStore(options.repoRoot, prdRef);
-    if (!localStoreResult.ok) {
-      return blocked(
-        options.repoRoot,
-        prdRef,
-        localStoreResult.gate,
-        "local_store_invalid",
-        localStoreResult.reason,
-        localStoreResult.diagnostics
-      );
-    }
-    const localBranchName = getLocalPrdBranchName(prdRef);
-    const localBranchResult = materializeLocalPrdBranch(
-      prdRef,
-      fetchResult.startBaseCommit,
-      options.repoRoot
-    );
-    if (!localBranchResult.ok) {
-      return blocked(
-        options.repoRoot,
-        prdRef,
-        "branch-state",
-        "local_branch_failed",
-        localBranchResult.message,
-        [localBranchResult.message]
-      );
-    }
-    const updatedAt2 = (/* @__PURE__ */ new Date()).toISOString();
-    const start2 = buildStartReceipt({
-      status: "started",
-      targetName,
-      prdBranch: localBranchName,
-      startBaseBranch: baseResolution.baseBranch,
-      startBaseCommit: fetchResult.startBaseCommit,
-      branchAction: localBranchResult.created ? "created" : "reused",
-      startedAt: updatedAt2
-    });
-    persistStartingPrdRunRecord(
-      options.repoRoot,
-      prdRef,
-      existingRecord,
-      start2,
-      { targetName, mode: resolvedMode }
-    );
-    return {
-      kind: "started",
-      prdRef,
-      mode: resolvedMode,
-      start: start2,
-      diagnostics: []
-    };
-  }
   const branchResult = inspectRemotePrdBranch(options.repoRoot, prdRef);
   if (!branchResult.ok) {
     return blocked(
@@ -10456,7 +8533,7 @@ async function startPrdRun(options) {
         fetchPrdResult.diagnostics
       );
     }
-    const ancestryResult = spawnSync3(
+    const ancestryResult = spawnSync2(
       "git",
       [
         "merge-base",
@@ -10493,12 +8570,11 @@ async function startPrdRun(options) {
       prdRef,
       existingRecord,
       adoptedStart,
-      { targetName, mode: resolvedMode }
+      { targetName }
     );
     return {
       kind: "started",
       prdRef,
-      mode: resolvedMode,
       start: adoptedStart,
       diagnostics: []
     };
@@ -10532,13 +8608,11 @@ async function startPrdRun(options) {
     startedAt: updatedAt
   });
   persistStartingPrdRunRecord(options.repoRoot, prdRef, existingRecord, start, {
-    targetName,
-    mode: resolvedMode
+    targetName
   });
   return {
     kind: "started",
     prdRef,
-    mode: resolvedMode,
     start,
     diagnostics: []
   };
@@ -10552,25 +8626,23 @@ function buildLaunchBlockedOutcome(prdRef, guidance, resume, start) {
     resume
   };
 }
-function writeDrainedRecord(repoRoot2, prdRef, startReceipt, targetName, mode) {
+function writeDrainedRecord(repoRoot2, prdRef, startReceipt, targetName) {
   writePrdRunRecord(repoRoot2, {
     prdRef,
     status: "drained",
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     targetName,
-    start: startReceipt,
-    mode
+    start: startReceipt
   });
 }
-function writeTerminalRecord(repoRoot2, prdRef, status, targetName, startReceipt, prdBranch, mode) {
+function writeTerminalRecord(repoRoot2, prdRef, status, targetName, startReceipt, prdBranch) {
   writePrdRunRecord(repoRoot2, {
     prdRef,
     status,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     targetName,
     prdBranch,
-    start: startReceipt,
-    mode
+    start: startReceipt
   });
 }
 function validatePrdRunStartEvidence(record, context) {
@@ -10629,22 +8701,6 @@ function validatePrdRunStartEvidence(record, context) {
       }
     };
   }
-  if (record.mode && record.mode !== context.mode) {
-    return {
-      ok: false,
-      guidance: {
-        blockedGate: "branch-state",
-        failureCode: "mode_mismatch",
-        reason: `PRD Run ${context.prdRef} mode mismatch: recorded "${record.mode}" but expected "${context.mode}".`,
-        repairability: "operator-action",
-        diagnostics: [
-          `Recorded mode: ${record.mode}`,
-          `Expected mode: ${context.mode}`
-        ],
-        offendingPaths: []
-      }
-    };
-  }
   if (record.prdRef !== context.prdRef) {
     return {
       ok: false,
@@ -10764,31 +8820,6 @@ function validatePrdRunDrainEvidence(record, context) {
 async function launchPrdRun(options) {
   const prdRef = normalizePrdRunRef(options.prdRef);
   const existingRecord = readPrdRun(options.repoRoot, prdRef);
-  const resolvedLaunchMode = options.config ? (() => {
-    try {
-      const target = resolveTarget(options.config, options.targetName);
-      return resolvePrdRunMode(target).mode;
-    } catch {
-      return void 0;
-    }
-  })() : void 0;
-  if (resolvedLaunchMode && existingRecord.record?.mode && existingRecord.record.mode !== resolvedLaunchMode) {
-    return buildLaunchBlockedOutcome(
-      prdRef,
-      {
-        blockedGate: "branch-state",
-        failureCode: "mode_mismatch",
-        reason: `PRD Run ${prdRef} mode mismatch: recorded "${existingRecord.record.mode}" but resolved "${resolvedLaunchMode}". Resolve by using the correct target.`,
-        repairability: "operator-action",
-        diagnostics: [
-          `Recorded mode: ${existingRecord.record.mode}`,
-          `Resolved mode: ${resolvedLaunchMode}`
-        ],
-        offendingPaths: []
-      },
-      { attempted: [], skipped: ["start", "queue"], resumed: [] }
-    );
-  }
   const plan = planPrdRunLaunchResume(existingRecord.record);
   if (plan.blocked === "final_reviewed-incompatible") {
     return buildLaunchBlockedOutcome(
@@ -10806,7 +8837,7 @@ async function launchPrdRun(options) {
       plan
     );
   }
-  if (existingRecord.record?.status === "completed_prd_branch" || existingRecord.record?.status === "complete" || existingRecord.record?.status === "completed_local_branch") {
+  if (existingRecord.record?.status === "completed_prd_branch" || existingRecord.record?.status === "complete") {
     return {
       kind: "already-terminal",
       prdRef,
@@ -10834,7 +8865,6 @@ async function launchPrdRun(options) {
         plan
       );
     }
-    const drainMode = resolvedLaunchMode ?? record.mode ?? "github";
     const resolvedTarget = options.config ? resolveTarget(options.config, options.targetName) : null;
     const targetBaseBranch = resolvedTarget?.baseBranch ?? "main";
     const baseResolution = resolvePrdRunBaseBranch({
@@ -10857,7 +8887,6 @@ async function launchPrdRun(options) {
     }
     const drainContext = {
       prdRef,
-      mode: drainMode,
       baseBranch: baseResolution.baseBranch,
       prdBranch: record.start.prdBranch
     };
@@ -10869,20 +8898,18 @@ async function launchPrdRun(options) {
     if (!drainEvidence.ok) {
       return buildLaunchBlockedOutcome(prdRef, drainEvidence.guidance, plan);
     }
-    const terminalStatus = drainMode === "local" ? "completed_local_branch" : "completed_prd_branch";
     writeTerminalRecord(
       options.repoRoot,
       prdRef,
-      terminalStatus,
+      "completed_prd_branch",
       record.targetName ?? options.targetName,
       record.start,
-      record.start.prdBranch,
-      drainMode
+      record.start.prdBranch
     );
     return {
       kind: "completed",
       prdRef,
-      status: terminalStatus,
+      status: "completed_prd_branch",
       prdBranch: record.start.prdBranch,
       diagnostics: [
         `PRD Run ${prdRef} completed from drained state. Branch: ${record.start.prdBranch}.`
@@ -10933,7 +8960,6 @@ async function launchPrdRun(options) {
   const currentRecord = readPrdRun(options.repoRoot, prdRef).record;
   const startReceipt = currentRecord?.start;
   const targetName = currentRecord?.targetName ?? options.targetName;
-  const explicitMode = resolvedLaunchMode ?? currentRecord?.mode;
   if (startReceipt) {
     startReceipt.queueStartedAt = (/* @__PURE__ */ new Date()).toISOString();
     startReceipt.queueCommand = "queue-run";
@@ -10943,236 +8969,18 @@ async function launchPrdRun(options) {
     status: "running",
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     targetName,
-    start: startReceipt,
-    mode: explicitMode
+    start: startReceipt
   });
-  if (explicitMode === "local") {
-    return await launchLocalQueueDrain(
-      options,
-      prdRef,
-      startReceipt,
-      targetName,
-      explicitMode,
-      plan,
-      startOutcome
-    );
-  }
   return await launchGithubQueueDrain(
     options,
     prdRef,
     startReceipt,
     targetName,
-    explicitMode,
     plan,
     startOutcome
   );
 }
-async function launchLocalQueueDrain(options, prdRef, startReceipt, targetName, mode, plan, startOutcome) {
-  if (!startReceipt) {
-    writePrdRunRecord(options.repoRoot, {
-      prdRef,
-      status: "blocked",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      targetName,
-      blockedGate: "branch-state",
-      blockedReason: `PRD Run ${prdRef} is missing start receipt before local queue drain.`,
-      diagnostics: [],
-      offendingPaths: []
-    });
-    return buildLaunchBlockedOutcome(
-      prdRef,
-      {
-        blockedGate: "branch-state",
-        failureCode: "missing_start_receipt",
-        reason: `PRD Run ${prdRef} is missing start receipt before local queue drain.`,
-        repairability: "automatic-retry-safe",
-        diagnostics: [],
-        offendingPaths: []
-      },
-      plan,
-      startOutcome
-    );
-  }
-  const localStoreDir = join20(
-    options.repoRoot,
-    ".pourkit",
-    "local-prd-runs",
-    prdRef
-  );
-  let localStoreReady = false;
-  if (existsSync16(localStoreDir)) {
-    const localStorePath = join20(localStoreDir, "prd.json");
-    try {
-      const content = JSON.parse(readFileSync18(localStorePath, "utf8"));
-      localStoreReady = content?.id === prdRef && content?.kind === "prd";
-    } catch {
-      localStoreReady = false;
-    }
-  }
-  if (!localStoreReady) {
-    const reason = `Local PRD Run Store not ready for ${prdRef}. Expected valid prd.json at .pourkit/local-prd-runs/${prdRef}/prd.json with matching PRD ID.`;
-    writePrdRunRecord(options.repoRoot, {
-      prdRef,
-      status: "blocked",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      targetName,
-      start: startReceipt,
-      mode,
-      blockedGate: "branch-state",
-      blockedReason: reason,
-      diagnostics: [
-        `Expected store path: .pourkit/local-prd-runs/${prdRef}/prd.json`,
-        `Expected PRD ID: ${prdRef}`
-      ],
-      offendingPaths: []
-    });
-    return buildLaunchBlockedOutcome(
-      prdRef,
-      {
-        blockedGate: "branch-state",
-        failureCode: "local_store_invalid",
-        reason,
-        repairability: "operator-action",
-        diagnostics: [
-          `Expected store path: .pourkit/local-prd-runs/${prdRef}/prd.json`,
-          `Expected PRD ID: ${prdRef}`
-        ],
-        offendingPaths: []
-      },
-      plan,
-      startOutcome
-    );
-  }
-  const memoryExecutionContext = options.config?.memory?.enabled ? { available: true, sandboxDbPath: "/home/agent/.pourkit/icm/memories.db" } : void 0;
-  const queueResult = await runLocalQueueLoop(
-    prdRef,
-    options.repoRoot,
-    options.issueProvider,
-    memoryExecutionContext
-  );
-  if (!queueResult.ok) {
-    const failureCode = queueResult.failureCode ?? "queue_error";
-    const reason = queueResult.repairGuidance ?? `Local queue loop blocked: ${failureCode}`;
-    const diagnostics = [
-      `Local queue loop failed with failureCode "${failureCode}".`,
-      ...queueResult.repairGuidance ? [`Repair guidance: ${queueResult.repairGuidance}`] : []
-    ];
-    writePrdRunRecord(options.repoRoot, {
-      prdRef,
-      status: "blocked",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      targetName,
-      start: startReceipt,
-      mode,
-      blockedGate: "queue",
-      blockedReason: reason,
-      diagnostics,
-      offendingPaths: []
-    });
-    return buildLaunchBlockedOutcome(
-      prdRef,
-      {
-        blockedGate: "queue",
-        failureCode,
-        reason,
-        repairability: "automatic-retry-safe",
-        diagnostics,
-        offendingPaths: []
-      },
-      plan,
-      startOutcome
-    );
-  }
-  if (queueResult.blockedIssues.length > 0) {
-    const reason = `Queue processed complete but ${queueResult.blockedIssues.length} blocked child issue(s) remain.`;
-    const diagnostics = [
-      reason,
-      `Blocked issues: ${queueResult.blockedIssues.join(", ")}`,
-      "Resolve blocked children before parent close."
-    ];
-    writePrdRunRecord(options.repoRoot, {
-      prdRef,
-      status: "blocked",
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      targetName,
-      start: startReceipt,
-      mode,
-      blockedGate: "queue",
-      blockedReason: reason,
-      diagnostics,
-      offendingPaths: []
-    });
-    return buildLaunchBlockedOutcome(
-      prdRef,
-      {
-        blockedGate: "queue",
-        failureCode: "blocked_child_issues",
-        reason,
-        repairability: "operator-action",
-        diagnostics,
-        offendingPaths: []
-      },
-      plan,
-      startOutcome
-    );
-  }
-  startReceipt.queueDrainedAt = (/* @__PURE__ */ new Date()).toISOString();
-  startReceipt.queueProcessedCount = queueResult.completedIssues.length + queueResult.blockedIssues.length;
-  const prdBranch = startReceipt.prdBranch ?? `local/${prdRef}`;
-  writeDrainedRecord(options.repoRoot, prdRef, startReceipt, targetName, mode);
-  const drainRecord = readPrdRun(options.repoRoot, prdRef).record;
-  if (drainRecord) {
-    const drainContext = {
-      prdRef,
-      mode,
-      baseBranch: startReceipt.startBaseBranch,
-      prdBranch
-    };
-    const startEvidence = validatePrdRunStartEvidence(
-      drainRecord,
-      drainContext
-    );
-    if (!startEvidence.ok) {
-      return buildLaunchBlockedOutcome(
-        prdRef,
-        startEvidence.guidance,
-        plan,
-        startOutcome
-      );
-    }
-    const drainEvidence = validatePrdRunDrainEvidence(
-      drainRecord,
-      drainContext
-    );
-    if (!drainEvidence.ok) {
-      return buildLaunchBlockedOutcome(
-        prdRef,
-        drainEvidence.guidance,
-        plan,
-        startOutcome
-      );
-    }
-  }
-  writeTerminalRecord(
-    options.repoRoot,
-    prdRef,
-    "completed_local_branch",
-    targetName,
-    startReceipt,
-    prdBranch,
-    mode
-  );
-  return {
-    kind: "completed",
-    prdRef,
-    status: "completed_local_branch",
-    prdBranch,
-    diagnostics: [`Local PRD Run ${prdRef} completed. Branch: ${prdBranch}.`],
-    start: startOutcome,
-    resume: plan
-  };
-}
-async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName, mode, plan, startOutcome) {
+async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName, plan, startOutcome) {
   if (!options.issueProvider || !options.prProvider || !options.executionProvider || !options.logger) {
     const reason = `PRD Run ${prdRef} requires issueProvider, prProvider, executionProvider, and logger for GitHub-backed queue drain.`;
     writePrdRunRecord(options.repoRoot, {
@@ -11181,7 +8989,6 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       targetName,
       start: startReceipt,
-      mode,
       blockedGate: "queue",
       blockedReason: reason,
       diagnostics: [
@@ -11212,7 +9019,6 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
       status: "blocked",
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       targetName,
-      mode,
       blockedGate: "branch-state",
       blockedReason: `PRD Run ${prdRef} is missing start receipt before GitHub queue drain.`,
       diagnostics: [],
@@ -11240,7 +9046,6 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       targetName,
       start: startReceipt,
-      mode,
       blockedGate: "queue",
       blockedReason: reason,
       diagnostics: ["Missing config for GitHub-backed mode."],
@@ -11264,13 +9069,6 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
   const prProvider = options.prProvider;
   const executionProvider = options.executionProvider;
   const logger = options.logger;
-  let resolvedModeForQueue;
-  try {
-    const target = resolveTarget(options.config, options.targetName);
-    resolvedModeForQueue = resolvePrdRunMode(target);
-  } catch {
-    resolvedModeForQueue = void 0;
-  }
   try {
     const outcome = await runQueueCommand({
       targetName,
@@ -11285,8 +9083,7 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
       prdRef,
       queueRunContext: {
         prdRef,
-        prdBranch: startReceipt.prdBranch,
-        prdRunMode: resolvedModeForQueue
+        prdBranch: startReceipt.prdBranch
       }
     });
     if (outcome.selected === null && outcome.code === "drained") {
@@ -11300,7 +9097,6 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
           updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
           targetName,
           start: startReceipt,
-          mode,
           blockedGate: "queue",
           blockedReason: diagnostics[0],
           diagnostics,
@@ -11323,19 +9119,11 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
       startReceipt.queueDrainedAt = (/* @__PURE__ */ new Date()).toISOString();
       startReceipt.queueProcessedCount = outcome.processedCount;
       const prdBranch = startReceipt.prdBranch ?? prdRef;
-      writeDrainedRecord(
-        options.repoRoot,
-        prdRef,
-        startReceipt,
-        targetName,
-        mode
-      );
+      writeDrainedRecord(options.repoRoot, prdRef, startReceipt, targetName);
       const drainRecord = readPrdRun(options.repoRoot, prdRef).record;
       if (drainRecord) {
-        const drainMode = mode ?? "github";
         const drainContext = {
           prdRef,
-          mode: drainMode,
           baseBranch: startReceipt.startBaseBranch,
           prdBranch
         };
@@ -11370,8 +9158,7 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
         "completed_prd_branch",
         targetName,
         startReceipt,
-        prdBranch,
-        mode
+        prdBranch
       );
       return {
         kind: "completed",
@@ -11393,7 +9180,6 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
         updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
         targetName,
         start: startReceipt,
-        mode,
         blockedGate: "queue",
         blockedReason: outcome.reason,
         diagnostics,
@@ -11421,7 +9207,6 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       targetName,
       start: startReceipt,
-      mode,
       blockedGate: "queue",
       blockedReason: outcomeReason,
       diagnostics: outcomeDiagnostics,
@@ -11449,7 +9234,6 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       targetName,
       start: startReceipt,
-      mode,
       blockedGate: "queue",
       blockedReason: msg,
       diagnostics,
@@ -11472,13 +9256,13 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
 }
 
 // prd-run/final-review-validation.ts
-import { existsSync as existsSync17, readFileSync as readFileSync19 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync16 } from "fs";
 
 // commands/prd-run.ts
 async function runPrdRunLaunchCommand(options) {
   const outcome = await launchPrdRun(options);
   const result = mapLaunchPrdRunOutcomeToCommandResult(outcome, options);
-  if (options.config && options.logger && (result.status === "completed_prd_branch" || result.status === "completed_local_branch")) {
+  if (options.config && options.logger && result.status === "completed_prd_branch") {
     try {
       const target = resolveTarget(options.config, options.targetName);
       if (shouldCleanupRepositoryAfterPrdDrain(target)) {
@@ -11505,10 +9289,7 @@ function mapLaunchPrdRunOutcomeToCommandResult(outcome, options) {
   if (outcome.kind === "already-terminal") {
     const diagnostics = [
       `PRD Run ${prdRef} is already in status "${outcome.status}".`,
-      ...outcome.status === "completed_prd_branch" ? [buildCompletedPrdBranchHint(outcome.prdBranch ?? prdRef)] : [],
-      ...outcome.status === "completed_local_branch" ? [
-        `Local PRD Run ${prdRef} completed. Branch: ${outcome.prdBranch ?? `local/${prdRef}`}.`
-      ] : []
+      ...outcome.status === "completed_prd_branch" ? [buildCompletedPrdBranchHint(outcome.prdBranch ?? prdRef)] : []
     ];
     return {
       prdRef,
@@ -11985,16 +9766,16 @@ async function runPrMergeCommand(args, logger, prProvider, config) {
 }
 
 // commands/init.ts
-import { existsSync as existsSync18, statSync } from "fs";
+import { existsSync as existsSync15, statSync } from "fs";
 import {
   copyFile,
-  mkdir as mkdir5,
-  readFile as readFile5,
+  mkdir as mkdir4,
+  readFile as readFile4,
   readdir,
   rename,
-  writeFile as writeFile2
+  writeFile
 } from "fs/promises";
-import { createHash as createHash2, randomUUID } from "crypto";
+import { createHash, randomUUID } from "crypto";
 import path5 from "path";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
@@ -12301,7 +10082,7 @@ function resolveSourceAssetPath(sourceRoot, ...segments) {
     path5.join(sourceRoot, "dist", ...segments)
   ];
   for (const candidatePath of candidatePaths) {
-    if (existsSync18(candidatePath)) return candidatePath;
+    if (existsSync15(candidatePath)) return candidatePath;
   }
   return path5.join(sourceRoot, "pourkit", ...segments);
 }
@@ -12518,7 +10299,7 @@ function generateConfigTemplate(options) {
   }
   const config = {
     $schema: "./schema/pourkit.schema.json",
-    schemaVersion: 1,
+    schemaVersion: 2,
     targets: [target],
     workflowPack: {
       version: "1.0.0",
@@ -12707,11 +10488,11 @@ async function walkDir(dir) {
   return files;
 }
 async function computeFileChecksum(filePath) {
-  const content = await readFile5(filePath);
-  return createHash2("sha256").update(content).digest("hex");
+  const content = await readFile4(filePath);
+  return createHash("sha256").update(content).digest("hex");
 }
 function lockfileExists(root, name) {
-  return existsSync18(path5.join(root, name));
+  return existsSync15(path5.join(root, name));
 }
 function detectPackageManager(root) {
   if (lockfileExists(root, "pnpm-lock.yaml")) return "pnpm";
@@ -12755,7 +10536,7 @@ async function discoverLocalSource(sourcePath) {
 async function discoverReadme(root) {
   for (const name of ["README.md", "readme.md"]) {
     const p = path5.join(root, name);
-    if (existsSync18(p)) {
+    if (existsSync15(p)) {
       return p;
     }
   }
@@ -12765,7 +10546,7 @@ async function discoverAgentFiles(root) {
   const files = [];
   for (const name of ["AGENTS.md", "CLAUDE.md"]) {
     const p = path5.join(root, name);
-    if (existsSync18(p)) {
+    if (existsSync15(p)) {
       files.push(p);
     }
   }
@@ -12773,7 +10554,7 @@ async function discoverAgentFiles(root) {
 }
 async function discoverMerlleState(root) {
   const p = path5.join(root, ".pourkit", "state.json");
-  return existsSync18(p) ? p : null;
+  return existsSync15(p) ? p : null;
 }
 async function discoverAgentSkills(root) {
   const dirs = [
@@ -12782,7 +10563,7 @@ async function discoverAgentSkills(root) {
   ];
   const found = [];
   for (const d of dirs) {
-    if (existsSync18(d)) {
+    if (existsSync15(d)) {
       found.push(d);
     }
   }
@@ -12792,12 +10573,12 @@ async function discoverRootDomainDocs(root) {
   const docs = [];
   for (const name of ["CONTEXT.md", "CONTEXT-MAP.md"]) {
     const p = path5.join(root, name);
-    if (existsSync18(p)) {
+    if (existsSync15(p)) {
       docs.push(p);
     }
   }
   const adrDir = path5.join(root, "docs", "adr");
-  if (existsSync18(adrDir)) {
+  if (existsSync15(adrDir)) {
     const entries = await readdir(adrDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -12939,7 +10720,7 @@ async function planInit(options) {
       for (const file of skillFiles) {
         const relPath = path5.relative(s, file);
         const destPath = path5.join(targetRoot, ".agents", "skills", relPath);
-        if (!existsSync18(destPath)) {
+        if (!existsSync15(destPath)) {
           operations.push({
             kind: "copy",
             sourcePath: file,
@@ -13002,7 +10783,7 @@ async function planInit(options) {
     });
   }
   if (sourceRoot) {
-    if (!existsSync18(sourceRoot) || !statSync(sourceRoot).isDirectory()) {
+    if (!existsSync15(sourceRoot) || !statSync(sourceRoot).isDirectory()) {
       warnings.push(
         `--from-local path does not exist or is not a directory: ${sourceRoot}`
       );
@@ -13067,9 +10848,9 @@ async function planInit(options) {
         "release",
         "skills"
       );
-      const srcSkills = existsSync18(packagedManagedSkills) ? [
+      const srcSkills = existsSync15(packagedManagedSkills) ? [
         packagedManagedSkills,
-        ...existsSync18(packagedReleaseAddonSkills) ? [packagedReleaseAddonSkills] : []
+        ...existsSync15(packagedReleaseAddonSkills) ? [packagedReleaseAddonSkills] : []
       ] : await discoverAgentSkills(sourceRoot);
       for (const s of srcSkills) {
         const isOpenCode = s.includes(".opencode");
@@ -13092,7 +10873,7 @@ async function planInit(options) {
               "skills",
               relPath
             );
-            if (!existsSync18(destPath)) {
+            if (!existsSync15(destPath)) {
               operations.push({
                 kind: "copy",
                 sourcePath: file,
@@ -13179,7 +10960,7 @@ async function planInit(options) {
               });
               continue;
             }
-            const sourceContent = await readFile5(file, "utf-8");
+            const sourceContent = await readFile4(file, "utf-8");
             const managedSourcePath = isReleaseAddon ? `.pourkit/managed/addons/release/skills/${skillName}/${relPath}` : `.pourkit/managed/skills/${skillName}/${relPath}`;
             operations.push({
               kind: "create",
@@ -13224,7 +11005,7 @@ async function planInit(options) {
             requiresConfirmation: false,
             destructive: false
           });
-        } else if (existsSync18(destPath)) {
+        } else if (existsSync15(destPath)) {
           operations.push({
             kind: "skip",
             path: destPath,
@@ -13259,7 +11040,7 @@ async function planInit(options) {
       let packageScripts = {};
       let hasPackageJson = true;
       try {
-        const pkgContent = await readFile5(
+        const pkgContent = await readFile4(
           path5.join(targetRoot, "package.json"),
           "utf-8"
         );
@@ -13282,7 +11063,7 @@ async function planInit(options) {
         }
       }
       const contextPath = path5.join(targetRoot, ".pourkit", "CONTEXT.md");
-      if (!existsSync18(contextPath) && !merleDestPaths.has(contextPath)) {
+      if (!existsSync15(contextPath) && !merleDestPaths.has(contextPath)) {
         operations.push({
           kind: "create",
           path: contextPath,
@@ -13300,7 +11081,7 @@ async function planInit(options) {
         "adr",
         ".gitkeep"
       );
-      if (!existsSync18(adrGitkeep)) {
+      if (!existsSync15(adrGitkeep)) {
         operations.push({
           kind: "create",
           path: adrGitkeep,
@@ -13322,7 +11103,7 @@ async function planInit(options) {
         "docs",
         "agents"
       );
-      const srcDocAgents = existsSync18(packagedManagedDocAgents) ? packagedManagedDocAgents : legacyDocAgents;
+      const srcDocAgents = existsSync15(packagedManagedDocAgents) ? packagedManagedDocAgents : legacyDocAgents;
       const tgtManagedDocAgents = path5.join(
         targetRoot,
         ".pourkit",
@@ -13336,12 +11117,12 @@ async function planInit(options) {
         "docs",
         "agents"
       );
-      if (existsSync18(srcDocAgents)) {
+      if (existsSync15(srcDocAgents)) {
         const docFiles = await walkDir(srcDocAgents);
         for (const file of docFiles) {
           const relPath = path5.relative(srcDocAgents, file);
           const managedDocDest = path5.join(tgtManagedDocAgents, relPath);
-          if (!existsSync18(managedDocDest) && relPath === "triage-labels.md") {
+          if (!existsSync15(managedDocDest) && relPath === "triage-labels.md") {
             operations.push({
               kind: "create",
               path: managedDocDest,
@@ -13353,7 +11134,7 @@ async function planInit(options) {
                 options.labels ?? DEFAULT_RUNNER_LABELS
               )
             });
-          } else if (!existsSync18(managedDocDest)) {
+          } else if (!existsSync15(managedDocDest)) {
             const checksum = await computeFileChecksum(file);
             operations.push({
               kind: "copy",
@@ -13375,7 +11156,7 @@ async function planInit(options) {
             relPath
           );
           const stubDocDest = path5.join(tgtStubDocAgents, relPath);
-          if (existsSync18(stubDocDest)) continue;
+          if (existsSync15(stubDocDest)) continue;
           operations.push({
             kind: "create",
             path: stubDocDest,
@@ -13409,7 +11190,7 @@ Do not edit this file.
           "docs",
           "agents"
         );
-        if (existsSync18(packagedReleaseAddonDocs)) {
+        if (existsSync15(packagedReleaseAddonDocs)) {
           const docFiles = await walkDir(packagedReleaseAddonDocs);
           for (const file of docFiles) {
             const relPath = path5.relative(packagedReleaseAddonDocs, file);
@@ -13433,19 +11214,19 @@ Do not edit this file.
         "prompts"
       );
       const legacyPrompts = path5.join(sourceRoot, ".pourkit", "prompts");
-      const srcPrompts = existsSync18(packagedManagedPrompts) ? packagedManagedPrompts : legacyPrompts;
+      const srcPrompts = existsSync15(packagedManagedPrompts) ? packagedManagedPrompts : legacyPrompts;
       const tgtManagedPrompts = path5.join(
         targetRoot,
         ".pourkit",
         "managed",
         "prompts"
       );
-      if (existsSync18(srcPrompts)) {
+      if (existsSync15(srcPrompts)) {
         const promptFiles = await walkDir(srcPrompts);
         for (const file of promptFiles) {
           const relPath = path5.relative(srcPrompts, file);
           const promptDest = path5.join(tgtManagedPrompts, relPath);
-          if (existsSync18(promptDest)) continue;
+          if (existsSync15(promptDest)) continue;
           const checksum = await computeFileChecksum(file);
           operations.push({
             kind: "copy",
@@ -13469,7 +11250,7 @@ Do not edit this file.
         ".sandcastle",
         "Dockerfile"
       );
-      if (existsSync18(tgtSandboxDockerfile)) {
+      if (existsSync15(tgtSandboxDockerfile)) {
         operations.push({
           kind: "skip",
           path: tgtSandboxDockerfile,
@@ -13478,7 +11259,7 @@ Do not edit this file.
           requiresConfirmation: false,
           destructive: false
         });
-      } else if (existsSync18(srcSandboxDockerfile)) {
+      } else if (existsSync15(srcSandboxDockerfile)) {
         const checksum = await computeFileChecksum(srcSandboxDockerfile);
         operations.push({
           kind: "copy",
@@ -13492,7 +11273,7 @@ Do not edit this file.
         });
       }
       const configJsonPath = path5.join(targetRoot, ".pourkit", "config.json");
-      if (!existsSync18(configJsonPath)) {
+      if (!existsSync15(configJsonPath)) {
         const verifyCommands = inferVerificationCommands(
           packageScripts,
           pm || "npm"
@@ -13536,9 +11317,9 @@ Do not edit this file.
         "schema",
         "pourkit.schema.json"
       );
-      if (existsSync18(srcSchemaJson)) {
+      if (existsSync15(srcSchemaJson)) {
         const checksum = await computeFileChecksum(srcSchemaJson);
-        if (!existsSync18(schemaJsonPath)) {
+        if (!existsSync15(schemaJsonPath)) {
           operations.push({
             kind: "copy",
             sourcePath: srcSchemaJson,
@@ -13571,9 +11352,9 @@ Do not edit this file.
         "schema",
         "pourkit.schema.hash"
       );
-      if (existsSync18(srcSchemaHash)) {
+      if (existsSync15(srcSchemaHash)) {
         const checksum = await computeFileChecksum(srcSchemaHash);
-        if (!existsSync18(schemaHashPath)) {
+        if (!existsSync15(schemaHashPath)) {
           operations.push({
             kind: "copy",
             sourcePath: srcSchemaHash,
@@ -13599,7 +11380,7 @@ Do not edit this file.
       const hasExistingAgents = operations.some(
         (op) => (op.kind === "skip" || op.kind === "update") && op.path?.endsWith("AGENTS.md")
       );
-      if ((agentFileMode === "agents" || agentFileMode === "both") && !hasExistingAgents && !existsSync18(path5.join(targetRoot, "AGENTS.md"))) {
+      if ((agentFileMode === "agents" || agentFileMode === "both") && !hasExistingAgents && !existsSync15(path5.join(targetRoot, "AGENTS.md"))) {
         operations.push({
           kind: "create",
           path: path5.join(targetRoot, "AGENTS.md"),
@@ -13615,7 +11396,7 @@ ${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 && !existsSync18(path5.join(targetRoot, "CLAUDE.md"))) {
+      if ((agentFileMode === "claude" || agentFileMode === "both") && !hasExistingClaude && !existsSync15(path5.join(targetRoot, "CLAUDE.md"))) {
         operations.push({
           kind: "create",
           path: path5.join(targetRoot, "CLAUDE.md"),
@@ -13630,7 +11411,7 @@ ${managedAgentContent}${MANAGED_BLOCK_END}
       }
       const gitignoreTarget = path5.join(targetRoot, ".gitignore");
       const gitignoreContent = generateGitignoreBlock();
-      if (!existsSync18(gitignoreTarget)) {
+      if (!existsSync15(gitignoreTarget)) {
         operations.push({
           kind: "create",
           path: gitignoreTarget,
@@ -13654,7 +11435,7 @@ ${gitignoreContent}${MANAGED_BLOCK_END}
         });
       }
       const openCodePath = path5.join(targetRoot, "opencode.json");
-      if (!existsSync18(openCodePath)) {
+      if (!existsSync15(openCodePath)) {
         operations.push({
           kind: "create",
           path: openCodePath,
@@ -13666,7 +11447,7 @@ ${gitignoreContent}${MANAGED_BLOCK_END}
         });
       } else {
         try {
-          const existingContent = await readFile5(openCodePath, "utf-8");
+          const existingContent = await readFile4(openCodePath, "utf-8");
           const existingConfig = JSON.parse(existingContent);
           if (typeof existingConfig !== "object" || existingConfig === null || Array.isArray(existingConfig)) {
             warnings.push(
@@ -13711,7 +11492,7 @@ ${gitignoreContent}${MANAGED_BLOCK_END}
         }
       }
       const manifestPath = path5.join(targetRoot, ".pourkit", "manifest.json");
-      if (existsSync18(manifestPath)) {
+      if (existsSync15(manifestPath)) {
         operations.push({
           kind: "skip",
           path: manifestPath,
@@ -14092,7 +11873,7 @@ async function promptForInitChoices(plan, current) {
 }
 async function writeFileAtomic(filePath, content) {
   const tmpPath = `${filePath}.tmp.${randomUUID()}`;
-  await writeFile2(tmpPath, content, "utf-8");
+  await writeFile(tmpPath, content, "utf-8");
   await rename(tmpPath, filePath);
 }
 var MANAGED_BLOCK_BEGIN = "<!-- BEGIN POURKIT MANAGED BLOCK -->";
@@ -14101,13 +11882,13 @@ async function updateManagedBlock(filePath, content) {
   const blockContent = `${MANAGED_BLOCK_BEGIN}
 ${content}${MANAGED_BLOCK_END}
 `;
-  if (!existsSync18(filePath)) {
+  if (!existsSync15(filePath)) {
     const dir = path5.dirname(filePath);
-    await mkdir5(dir, { recursive: true });
+    await mkdir4(dir, { recursive: true });
     await writeFileAtomic(filePath, blockContent);
     return;
   }
-  const existing = await readFile5(filePath, "utf-8");
+  const existing = await readFile4(filePath, "utf-8");
   const beginIdx = existing.indexOf(MANAGED_BLOCK_BEGIN);
   const endIdx = existing.indexOf(MANAGED_BLOCK_END);
   if (beginIdx !== -1 && endIdx !== -1 && endIdx > beginIdx) {
@@ -14130,7 +11911,7 @@ async function writeManifest(plan, sourceMeta, agentFiles, packageManager) {
     if (op.requiresConfirmation) continue;
     const relPath = path5.relative(plan.targetRoot, op.path);
     if (relPath === ".pourkit/manifest.json") continue;
-    if (existsSync18(op.path)) {
+    if (existsSync15(op.path)) {
       const sha256 = await computeFileChecksum(op.path);
       assets[relPath] = {
         ownership: op.ownership || "managed",
@@ -14139,7 +11920,7 @@ async function writeManifest(plan, sourceMeta, agentFiles, packageManager) {
     }
   }
   const manifest = {
-    schemaVersion: 1,
+    schemaVersion: 2,
     initializedAt: (/* @__PURE__ */ new Date()).toISOString(),
     pourkit: {
       versionSource: sourceMeta.versionSource,
@@ -14155,7 +11936,7 @@ async function writeManifest(plan, sourceMeta, agentFiles, packageManager) {
     workflowPack: buildWorkflowPackMetadata(plan.enabledAddons ?? []),
     assets
   };
-  await mkdir5(manifestDir, { recursive: true });
+  await mkdir4(manifestDir, { recursive: true });
   await writeFileAtomic(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
   return manifest;
 }
@@ -14176,12 +11957,12 @@ async function applyInitPlan(plan, options) {
             skipped++;
             continue;
           }
-          if (existsSync18(op.path) && !op.destructive) {
+          if (existsSync15(op.path) && !op.destructive) {
             skipped++;
             continue;
           }
           const dir = path5.dirname(op.path);
-          await mkdir5(dir, { recursive: true });
+          await mkdir4(dir, { recursive: true });
           await writeFileAtomic(op.path, op.content ?? "");
           applied++;
           break;
@@ -14191,7 +11972,7 @@ async function applyInitPlan(plan, options) {
             skipped++;
             continue;
           }
-          if (existsSync18(op.path)) {
+          if (existsSync15(op.path)) {
             skipped++;
             continue;
           }
@@ -14200,7 +11981,7 @@ async function applyInitPlan(plan, options) {
             skipped++;
           } else {
             const dir = path5.dirname(op.path);
-            await mkdir5(dir, { recursive: true });
+            await mkdir4(dir, { recursive: true });
             await copyFile(op.sourcePath, op.path);
             applied++;
           }
@@ -14220,12 +12001,12 @@ async function applyInitPlan(plan, options) {
             skipped++;
             continue;
           }
-          if (existsSync18(op.path)) {
+          if (existsSync15(op.path)) {
             skipped++;
             continue;
           }
           const dir = path5.dirname(op.path);
-          await mkdir5(dir, { recursive: true });
+          await mkdir4(dir, { recursive: true });
           await rename(op.sourcePath, op.path);
           applied++;
           break;
@@ -14364,7 +12145,7 @@ async function applyInitFromSource(options) {
     if (!manifestSkipped) {
       const agentFiles = [];
       for (const name of ["AGENTS.md", "CLAUDE.md"]) {
-        if (existsSync18(path5.join(targetRoot, name))) {
+        if (existsSync15(path5.join(targetRoot, name))) {
           agentFiles.push(path5.join(targetRoot, name));
         }
       }
@@ -14540,18 +12321,18 @@ Init applied: ${result.applied} operations applied, ${result.skipped} skipped.`
 }
 
 // commands/memory-init.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync9, readFileSync as readFileSync20, writeFileSync as writeFileSync7 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync8, readFileSync as readFileSync17, writeFileSync as writeFileSync5 } from "fs";
+import { join as join17 } from "path";
 async function runMemoryInitCommand(options) {
   const cwd = options.cwd ?? process.cwd();
-  const configPath = join22(cwd, ".pourkit", "config.json");
-  if (!existsSync19(configPath)) {
+  const configPath = join17(cwd, ".pourkit", "config.json");
+  if (!existsSync16(configPath)) {
     return {
       ok: false,
       message: "No .pourkit/config.json found. Run `pourkit init` first to initialize Pourkit, then run `pourkit memory init`."
     };
   }
-  const raw = JSON.parse(readFileSync20(configPath, "utf8"));
+  const raw = JSON.parse(readFileSync17(configPath, "utf8"));
   let alreadyEnabled = false;
   if (Object.prototype.hasOwnProperty.call(raw, "memory")) {
     const m = raw.memory;
@@ -14574,10 +12355,10 @@ async function runMemoryInitCommand(options) {
   const memory = { enabled: true, provider: "icm" };
   if (!alreadyEnabled) {
     const next = { ...raw, memory };
-    writeFileSync7(configPath, JSON.stringify(next, null, 2) + "\n");
+    writeFileSync5(configPath, JSON.stringify(next, null, 2) + "\n");
   }
-  mkdirSync9(join22(cwd, ".pourkit", "icm"), { recursive: true });
-  const gitignorePath = join22(cwd, ".gitignore");
+  mkdirSync8(join17(cwd, ".pourkit", "icm"), { recursive: true });
+  const gitignorePath = join17(cwd, ".gitignore");
   updateManagedBlockSync(gitignorePath, generateGitignoreBlock());
   const managed = await generateManagedAgentInstructions({
     sourceRoot: cwd,
@@ -14585,14 +12366,14 @@ async function runMemoryInitCommand(options) {
   });
   let updatedAgentFile = false;
   for (const fileName of ["AGENTS.md", "CLAUDE.md"]) {
-    const agentPath = join22(cwd, fileName);
-    if (existsSync19(agentPath)) {
+    const agentPath = join17(cwd, fileName);
+    if (existsSync16(agentPath)) {
       updateManagedBlockSync(agentPath, managed);
       updatedAgentFile = true;
     }
   }
   if (!updatedAgentFile) {
-    updateManagedBlockSync(join22(cwd, "AGENTS.md"), managed);
+    updateManagedBlockSync(join17(cwd, "AGENTS.md"), managed);
   }
   return {
     ok: true,
@@ -14604,21 +12385,21 @@ function updateManagedBlockSync(filePath, content) {
   const blockContent = `${MANAGED_BLOCK_BEGIN}
 ${content}${MANAGED_BLOCK_END}
 `;
-  if (!existsSync19(filePath)) {
-    writeFileSync7(filePath, blockContent);
+  if (!existsSync16(filePath)) {
+    writeFileSync5(filePath, blockContent);
     return;
   }
-  const existing = readFileSync20(filePath, "utf8");
+  const existing = readFileSync17(filePath, "utf8");
   const beginIdx = existing.indexOf(MANAGED_BLOCK_BEGIN);
   const endIdx = existing.indexOf(MANAGED_BLOCK_END);
   if (beginIdx !== -1 && endIdx !== -1 && endIdx > beginIdx) {
     const before = existing.slice(0, beginIdx);
     const after = existing.slice(endIdx + MANAGED_BLOCK_END.length);
-    writeFileSync7(filePath, before + blockContent + after);
+    writeFileSync5(filePath, before + blockContent + after);
     return;
   }
   const suffix = existing.endsWith("\n") ? "" : "\n";
-  writeFileSync7(filePath, `${existing}${suffix}${blockContent}`);
+  writeFileSync5(filePath, `${existing}${suffix}${blockContent}`);
 }
 
 // commands/serena.ts
@@ -14737,8 +12518,8 @@ async function runSerenaStatusCommand(options) {
 }
 
 // commands/config-schema.ts
-import { readFileSync as readFileSync21, existsSync as existsSync20 } from "fs";
-import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile3, readdir as readdir2 } from "fs/promises";
+import { readFileSync as readFileSync18, existsSync as existsSync17 } from "fs";
+import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile2, readdir as readdir2 } from "fs/promises";
 import { resolve as resolve4, dirname as dirname5, relative as relative2 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import Ajv2 from "ajv";
@@ -14750,7 +12531,7 @@ function resolvePackagedAssetPath2(fileName) {
     resolve4(__dirname3, "schema", fileName),
     resolve4(__dirname3, "../schema", fileName)
   ];
-  return candidates.find((candidate) => existsSync20(candidate)) ?? candidates[0];
+  return candidates.find((candidate) => existsSync17(candidate)) ?? candidates[0];
 }
 var PACKAGED_SCHEMA_PATH = resolvePackagedAssetPath2("pourkit.schema.json");
 var PACKAGED_HASH_PATH = resolvePackagedAssetPath2("pourkit.schema.hash");
@@ -14758,7 +12539,7 @@ var _schemaValidator = null;
 var _schemaErrors = null;
 function getSchemaValidator() {
   if (!_schemaValidator) {
-    const schema = JSON.parse(readFileSync21(PACKAGED_SCHEMA_PATH, "utf-8"));
+    const schema = JSON.parse(readFileSync18(PACKAGED_SCHEMA_PATH, "utf-8"));
     const ajv = new Ajv2({ strict: true });
     ajv.addKeyword("x-pourkit-schema-version");
     const validate = ajv.compile(schema);
@@ -14772,7 +12553,7 @@ function getSchemaValidator() {
   return _schemaValidator;
 }
 function readPackagedHash() {
-  return readFileSync21(PACKAGED_HASH_PATH, "utf-8");
+  return readFileSync18(PACKAGED_HASH_PATH, "utf-8");
 }
 function localSchemaDir(repoRoot2) {
   return resolve4(repoRoot2, ".pourkit/schema");
@@ -14796,7 +12577,7 @@ function resolvePackagedReleaseAddonDocPath(docName) {
 }
 async function readPackagedTextFile(filePath) {
   try {
-    return await readFile6(filePath, "utf-8");
+    return await readFile5(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -14893,7 +12674,7 @@ async function validateWorkflowPack(cwd) {
   const baselineSkills = getBaselineManagedSkillNames();
   for (const docName of catalog.docs) {
     const localPath = resolve4(cwd, `.pourkit/managed/docs/agents/${docName}`);
-    if (!existsSync20(localPath)) {
+    if (!existsSync17(localPath)) {
       failures.push({
         severity: "failure",
         kind: "missing_managed_asset",
@@ -14905,13 +12686,13 @@ async function validateWorkflowPack(cwd) {
       const packagedContent = await readPackagedTextFile(packagedPath);
       if (packagedContent !== null) {
         try {
-          const localContent = await readFile6(localPath, "utf-8");
+          const localContent = await readFile5(localPath, "utf-8");
           if (localContent !== packagedContent) {
             const overridePath = resolve4(
               cwd,
               `.pourkit/overrides/docs/agents/${docName}`
             );
-            if (existsSync20(overridePath)) {
+            if (existsSync17(overridePath)) {
               warnings.push({
                 severity: "warning",
                 kind: "overridden",
@@ -14934,7 +12715,7 @@ async function validateWorkflowPack(cwd) {
   }
   for (const skillName of baselineSkills) {
     const skillDir = resolve4(cwd, `.pourkit/managed/skills/${skillName}`);
-    if (!existsSync20(skillDir)) {
+    if (!existsSync17(skillDir)) {
       failures.push({
         severity: "failure",
         kind: "missing_managed_asset",
@@ -14943,7 +12724,7 @@ async function validateWorkflowPack(cwd) {
       });
     } else {
       const skillSourcePath = resolve4(skillDir, "SKILL.md");
-      if (existsSync20(skillSourcePath)) {
+      if (existsSync17(skillSourcePath)) {
         const packagedSkillPath = resolvePackagedManagedPath(
           "skills",
           skillName,
@@ -14952,13 +12733,13 @@ async function validateWorkflowPack(cwd) {
         const packagedContent = await readPackagedTextFile(packagedSkillPath);
         if (packagedContent !== null) {
           try {
-            const localContent = await readFile6(skillSourcePath, "utf-8");
+            const localContent = await readFile5(skillSourcePath, "utf-8");
             if (localContent !== packagedContent) {
               const overridePath = resolve4(
                 cwd,
                 `.pourkit/overrides/skills/${skillName}/SKILL.md`
               );
-              if (existsSync20(overridePath)) {
+              if (existsSync17(overridePath)) {
                 warnings.push({
                   severity: "warning",
                   kind: "overridden",
@@ -14982,7 +12763,7 @@ async function validateWorkflowPack(cwd) {
   }
   for (const promptName of catalog.prompts) {
     const promptPath = resolve4(cwd, `.pourkit/managed/prompts/${promptName}`);
-    if (!existsSync20(promptPath)) {
+    if (!existsSync17(promptPath)) {
       failures.push({
         severity: "failure",
         kind: "missing_managed_asset",
@@ -14993,7 +12774,7 @@ async function validateWorkflowPack(cwd) {
   }
   for (const skillName of baselineSkills) {
     const projectionDir = resolve4(cwd, `.agents/skills/${skillName}`);
-    if (!existsSync20(projectionDir)) {
+    if (!existsSync17(projectionDir)) {
       warnings.push({
         severity: "warning",
         kind: "projection_stale",
@@ -15002,7 +12783,7 @@ async function validateWorkflowPack(cwd) {
       });
     } else {
       const projectionPath = resolve4(projectionDir, "SKILL.md");
-      if (existsSync20(projectionPath)) {
+      if (existsSync17(projectionPath)) {
         const managedSourcePath = resolvePackagedManagedPath(
           "skills",
           skillName,
@@ -15011,7 +12792,7 @@ async function validateWorkflowPack(cwd) {
         const packagedContent = await readPackagedTextFile(managedSourcePath);
         if (packagedContent !== null) {
           try {
-            const projectionContent = await readFile6(projectionPath, "utf-8");
+            const projectionContent = await readFile5(projectionPath, "utf-8");
             const managedSourceRelativePath = `.pourkit/managed/skills/${skillName}/SKILL.md`;
             if (projectionContent !== buildOpenCodeSkillProjectionContent(
               managedSourceRelativePath,
@@ -15031,9 +12812,9 @@ async function validateWorkflowPack(cwd) {
     }
   }
   const agentsPath = resolve4(cwd, "AGENTS.md");
-  if (existsSync20(agentsPath)) {
+  if (existsSync17(agentsPath)) {
     try {
-      const agentsContent = await readFile6(agentsPath, "utf-8");
+      const agentsContent = await readFile5(agentsPath, "utf-8");
       if (agentsContent.includes(OLD_DOCS_PATH_PATTERN)) {
         failures.push({
           severity: "failure",
@@ -15054,7 +12835,7 @@ async function validateWorkflowPack(cwd) {
     }
   }
   const overridesDir = resolve4(cwd, ".pourkit/overrides");
-  if (existsSync20(overridesDir)) {
+  if (existsSync17(overridesDir)) {
     const overrideFiles = await walkDir2(overridesDir);
     for (const file of overrideFiles) {
       const relPath = relative2(cwd, file);
@@ -15069,9 +12850,9 @@ async function validateWorkflowPack(cwd) {
     }
   }
   const configPath = resolve4(cwd, ".pourkit/config.json");
-  if (existsSync20(configPath)) {
+  if (existsSync17(configPath)) {
     try {
-      const configContent = await readFile6(configPath, "utf-8");
+      const configContent = await readFile5(configPath, "utf-8");
       const parsed = JSON.parse(configContent);
       const releaseEnabled = parsed.releaseWorkflow?.enabled === true;
       if (releaseEnabled) {
@@ -15080,7 +12861,7 @@ async function validateWorkflowPack(cwd) {
             cwd,
             `.pourkit/managed/addons/release/skills/${skillName}`
           );
-          if (!existsSync20(addonDir)) {
+          if (!existsSync17(addonDir)) {
             failures.push({
               severity: "failure",
               kind: "release_config_conflict",
@@ -15094,7 +12875,7 @@ async function validateWorkflowPack(cwd) {
             cwd,
             `.pourkit/managed/addons/release/docs/agents/${docName}`
           );
-          if (!existsSync20(addonDocPath)) {
+          if (!existsSync17(addonDocPath)) {
             failures.push({
               severity: "failure",
               kind: "release_config_conflict",
@@ -15106,7 +12887,7 @@ async function validateWorkflowPack(cwd) {
               resolvePackagedReleaseAddonDocPath(docName)
             );
             if (packagedContent !== null) {
-              const localContent = await readFile6(addonDocPath, "utf-8");
+              const localContent = await readFile5(addonDocPath, "utf-8");
               if (localContent !== packagedContent) {
                 failures.push({
                   severity: "failure",
@@ -15139,7 +12920,7 @@ async function validateWorkflowPack(cwd) {
             cwd,
             `.pourkit/managed/addons/release/skills/${skillName}`
           );
-          if (existsSync20(addonDir)) {
+          if (existsSync17(addonDir)) {
             failures.push({
               severity: "failure",
               kind: "release_config_conflict",
@@ -15153,7 +12934,7 @@ async function validateWorkflowPack(cwd) {
             cwd,
             `.pourkit/managed/addons/release/docs/agents/${docName}`
           );
-          if (existsSync20(addonDocPath)) {
+          if (existsSync17(addonDocPath)) {
             failures.push({
               severity: "failure",
               kind: "release_config_conflict",
@@ -15167,9 +12948,9 @@ async function validateWorkflowPack(cwd) {
     }
   }
   const manifestPath = resolve4(cwd, ".pourkit/manifest.json");
-  if (existsSync20(manifestPath)) {
+  if (existsSync17(manifestPath)) {
     try {
-      const manifestContent = await readFile6(manifestPath, "utf-8");
+      const manifestContent = await readFile5(manifestPath, "utf-8");
       const manifest = JSON.parse(manifestContent);
       const wp = manifest.workflowPack;
       if (wp?.projections) {
@@ -15190,7 +12971,7 @@ async function validateWorkflowPack(cwd) {
     }
   }
   const pathEscapeOverrideDir = resolve4(cwd, ".pourkit/overrides");
-  if (existsSync20(pathEscapeOverrideDir)) {
+  if (existsSync17(pathEscapeOverrideDir)) {
     const overrideFiles = await walkDir2(pathEscapeOverrideDir);
     for (const file of overrideFiles) {
       if (!isPathContained(cwd, file)) {
@@ -15204,12 +12985,12 @@ async function validateWorkflowPack(cwd) {
     }
   }
   const managedDocsDir = resolve4(cwd, ".pourkit/managed/docs/agents");
-  if (existsSync20(managedDocsDir)) {
+  if (existsSync17(managedDocsDir)) {
     const docFiles = await walkDir2(managedDocsDir);
     for (const file of docFiles) {
       if (!file.endsWith(".md")) continue;
       try {
-        const content = await readFile6(file, "utf-8");
+        const content = await readFile5(file, "utf-8");
         const relPath = relative2(cwd, file);
         const violations = scanManagedPolicyText(content, relPath);
         for (const v of violations) {
@@ -15225,14 +13006,14 @@ async function validateWorkflowPack(cwd) {
     }
   }
   const managedSkillsDir = resolve4(cwd, ".pourkit/managed/skills");
-  if (existsSync20(managedSkillsDir)) {
+  if (existsSync17(managedSkillsDir)) {
     const skillDirs = await readdir2(managedSkillsDir, { withFileTypes: true });
     for (const entry of skillDirs) {
       if (!entry.isDirectory()) continue;
       const skillFile = resolve4(managedSkillsDir, entry.name, "SKILL.md");
-      if (!existsSync20(skillFile)) continue;
+      if (!existsSync17(skillFile)) continue;
       try {
-        const content = await readFile6(skillFile, "utf-8");
+        const content = await readFile5(skillFile, "utf-8");
         const relPath = relative2(cwd, skillFile);
         const violations = scanManagedPolicyText(content, relPath);
         for (const v of violations) {
@@ -15248,12 +13029,12 @@ async function validateWorkflowPack(cwd) {
     }
   }
   const managedPromptsDir = resolve4(cwd, ".pourkit/managed/prompts");
-  if (existsSync20(managedPromptsDir)) {
+  if (existsSync17(managedPromptsDir)) {
     for (const promptName of catalog.prompts) {
       const promptFile = resolve4(managedPromptsDir, promptName);
-      if (!existsSync20(promptFile)) continue;
+      if (!existsSync17(promptFile)) continue;
       try {
-        const content = await readFile6(promptFile, "utf-8");
+        const content = await readFile5(promptFile, "utf-8");
         const relPath = relative2(cwd, promptFile);
         const violations = scanManagedPolicyText(content, relPath);
         for (const v of violations) {
@@ -15273,9 +13054,9 @@ async function validateWorkflowPack(cwd) {
       cwd,
       `.pourkit/managed/addons/release/skills/${skillName}/SKILL.md`
     );
-    if (!existsSync20(addonSkillFile)) continue;
+    if (!existsSync17(addonSkillFile)) continue;
     try {
-      const content = await readFile6(addonSkillFile, "utf-8");
+      const content = await readFile5(addonSkillFile, "utf-8");
       const relPath = relative2(cwd, addonSkillFile);
       const violations = scanManagedPolicyText(content, relPath);
       for (const v of violations) {
@@ -15294,9 +13075,9 @@ async function validateWorkflowPack(cwd) {
       cwd,
       `.pourkit/managed/addons/release/docs/agents/${docName}`
     );
-    if (!existsSync20(addonDocFile)) continue;
+    if (!existsSync17(addonDocFile)) continue;
     try {
-      const content = await readFile6(addonDocFile, "utf-8");
+      const content = await readFile5(addonDocFile, "utf-8");
       const relPath = relative2(cwd, addonDocFile);
       const violations = scanManagedPolicyText(content, relPath);
       for (const v of violations) {
@@ -15328,7 +13109,7 @@ async function validateMemoryHealth(cwd, memoryConfig) {
     detail: icmPath !== null ? icmPath : "icm not found on PATH"
   });
   const gitignorePath = resolve4(cwd, ".gitignore");
-  const gitignoreContent = existsSync20(gitignorePath) ? readFileSync21(gitignorePath, "utf-8") : "";
+  const gitignoreContent = existsSync17(gitignorePath) ? readFileSync18(gitignorePath, "utf-8") : "";
   const hasGitignoreEntry = gitignoreContent.includes(".pourkit/icm/");
   checks.push({
     name: "icm-gitignore",
@@ -15355,8 +13136,8 @@ async function runDoctorCommand(options) {
   const schemaDir = localSchemaDir(repoRootPath);
   const localSchemaPath = resolve4(schemaDir, "pourkit.schema.json");
   const localHashPath = resolve4(schemaDir, "pourkit.schema.hash");
-  const localSchemaExists = existsSync20(localSchemaPath);
-  const localHashExists = existsSync20(localHashPath);
+  const localSchemaExists = existsSync17(localSchemaPath);
+  const localHashExists = existsSync17(localHashPath);
   let packagedHash = null;
   try {
     packagedHash = readPackagedHash();
@@ -15365,7 +13146,7 @@ async function runDoctorCommand(options) {
   let localHashContent = null;
   if (localHashExists) {
     try {
-      localHashContent = await readFile6(localHashPath, "utf-8");
+      localHashContent = await readFile5(localHashPath, "utf-8");
     } catch {
     }
   }
@@ -15375,9 +13156,9 @@ async function runDoctorCommand(options) {
   const configPath = resolve4(repoRootPath, ".pourkit/config.json");
   let configValidation;
   let rawMemoryConfig;
-  if (existsSync20(configPath)) {
+  if (existsSync17(configPath)) {
     try {
-      const raw = JSON.parse(readFileSync21(configPath, "utf-8"));
+      const raw = JSON.parse(readFileSync18(configPath, "utf-8"));
       rawMemoryConfig = raw.memory;
       const validate = getSchemaValidator();
       const valid2 = validate(raw);
@@ -15410,7 +13191,7 @@ async function runDoctorCommand(options) {
     "pourkit.config.mjs",
     "pourkit.config.js",
     "pourkit.json"
-  ].filter((p) => existsSync20(resolve4(repoRootPath, p)));
+  ].filter((p) => existsSync17(resolve4(repoRootPath, p)));
   const workflowPack = await validateWorkflowPack(repoRootPath);
   const memory = await validateMemoryHealth(repoRootPath, rawMemoryConfig);
   let recommendation = null;
@@ -15453,31 +13234,31 @@ async function runDoctorCommand(options) {
 async function runConfigSyncSchemaCommand(options) {
   const repoRootPath = options.cwd ?? process.cwd();
   const schemaDir = localSchemaDir(repoRootPath);
-  await mkdir6(schemaDir, { recursive: true });
-  const packagedSchema = await readFile6(PACKAGED_SCHEMA_PATH, "utf-8");
-  const packagedHash = await readFile6(PACKAGED_HASH_PATH, "utf-8");
+  await mkdir5(schemaDir, { recursive: true });
+  const packagedSchema = await readFile5(PACKAGED_SCHEMA_PATH, "utf-8");
+  const packagedHash = await readFile5(PACKAGED_HASH_PATH, "utf-8");
   const localSchemaPath = resolve4(schemaDir, "pourkit.schema.json");
   const localHashPath = resolve4(schemaDir, "pourkit.schema.hash");
   let schemaWritten = false;
   let hashWritten = false;
-  if (existsSync20(localSchemaPath)) {
-    const existing = await readFile6(localSchemaPath, "utf-8");
+  if (existsSync17(localSchemaPath)) {
+    const existing = await readFile5(localSchemaPath, "utf-8");
     if (existing !== packagedSchema) {
-      await writeFile3(localSchemaPath, packagedSchema, "utf-8");
+      await writeFile2(localSchemaPath, packagedSchema, "utf-8");
       schemaWritten = true;
     }
   } else {
-    await writeFile3(localSchemaPath, packagedSchema, "utf-8");
+    await writeFile2(localSchemaPath, packagedSchema, "utf-8");
     schemaWritten = true;
   }
-  if (existsSync20(localHashPath)) {
-    const existing = await readFile6(localHashPath, "utf-8");
+  if (existsSync17(localHashPath)) {
+    const existing = await readFile5(localHashPath, "utf-8");
     if (existing !== packagedHash) {
-      await writeFile3(localHashPath, packagedHash, "utf-8");
+      await writeFile2(localHashPath, packagedHash, "utf-8");
       hashWritten = true;
     }
   } else {
-    await writeFile3(localHashPath, packagedHash, "utf-8");
+    await writeFile2(localHashPath, packagedHash, "utf-8");
     hashWritten = true;
   }
   return {
@@ -15488,8 +13269,8 @@ async function runConfigSyncSchemaCommand(options) {
 }
 
 // commands/workflow-pack-sync.ts
-import { existsSync as existsSync21, readdirSync as readdirSync5 } from "fs";
-import { mkdir as mkdir7, readFile as readFile7, writeFile as writeFile4, readdir as readdir3 } from "fs/promises";
+import { existsSync as existsSync18, readdirSync as readdirSync4 } from "fs";
+import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile3, readdir as readdir3 } from "fs/promises";
 import { resolve as resolve5, dirname as dirname6, relative as relative3, normalize as normalize2 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var __filename4 = fileURLToPath4(import.meta.url);
@@ -15527,7 +13308,7 @@ function resolvePackagedManagedPromptPath(promptName) {
 }
 async function readPackagedTextFile2(filePath) {
   try {
-    return await readFile7(filePath, "utf-8");
+    return await readFile6(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -15610,20 +13391,20 @@ async function syncFile(cwd, targetRelativePath, sourceContent, errors) {
     errors.push(escapeError);
     return false;
   }
-  await mkdir7(resolve5(targetPath, ".."), { recursive: true });
-  if (existsSync21(targetPath)) {
-    const existing = await readFile7(targetPath, "utf-8");
+  await mkdir6(resolve5(targetPath, ".."), { recursive: true });
+  if (existsSync18(targetPath)) {
+    const existing = await readFile6(targetPath, "utf-8");
     if (existing === sourceContent) {
       return false;
     }
   }
-  await writeFile4(targetPath, sourceContent, "utf-8");
+  await writeFile3(targetPath, sourceContent, "utf-8");
   return true;
 }
 function walkDirSync(dir) {
   const result = [];
   try {
-    const entries = readdirSync5(dir, { withFileTypes: true });
+    const entries = readdirSync4(dir, { withFileTypes: true });
     for (const entry of entries) {
       const full = resolve5(dir, entry.name);
       if (entry.isDirectory()) {
@@ -15638,7 +13419,7 @@ function walkDirSync(dir) {
 }
 async function detectOverrides(cwd) {
   const overridesDir = resolve5(cwd, OVERRIDES_DIR);
-  if (!existsSync21(overridesDir)) {
+  if (!existsSync18(overridesDir)) {
     return [];
   }
   const files = await walkDir3(overridesDir);
@@ -15648,13 +13429,13 @@ async function detectProjectOwnedFiles(cwd) {
   const found = [];
   for (const ownedPath of PROJECT_OWNED_PATHS) {
     const fullPath = resolve5(cwd, ownedPath);
-    if (existsSync21(fullPath)) {
+    if (existsSync18(fullPath)) {
       found.push(ownedPath);
     }
   }
   for (const ownedDir of PROJECT_OWNED_DIRECTORIES) {
     const fullDir = resolve5(cwd, ownedDir);
-    if (existsSync21(fullDir)) {
+    if (existsSync18(fullDir)) {
       const files = await walkDir3(fullDir);
       for (const file of files) {
         found.push(relative3(cwd, file));
@@ -15666,7 +13447,7 @@ async function detectProjectOwnedFiles(cwd) {
 async function isReleaseWorkflowEnabled(cwd) {
   try {
     const configPath = resolve5(cwd, ".pourkit", "config.json");
-    const content = await readFile7(configPath, "utf-8");
+    const content = await readFile6(configPath, "utf-8");
     const parsed = JSON.parse(content);
     return parsed.releaseWorkflow?.enabled === true;
   } catch {
@@ -15806,12 +13587,12 @@ async function runWorkflowPackSyncCommand(options) {
   const fullManagedBlock = `${MANAGED_BLOCK_BEGIN3}${managedBlockContent}${MANAGED_BLOCK_END2}`;
   async function syncManagedAgentFile(fileName, options2) {
     const filePath = resolve5(cwd, fileName);
-    if (!existsSync21(filePath)) {
+    if (!existsSync18(filePath)) {
       if (!options2.createIfMissing) return false;
-      await writeFile4(filePath, fullManagedBlock + "\n", "utf-8");
+      await writeFile3(filePath, fullManagedBlock + "\n", "utf-8");
       return true;
     }
-    const existing = await readFile7(filePath, "utf-8");
+    const existing = await readFile6(filePath, "utf-8");
     const beginIdx = existing.indexOf(MANAGED_BLOCK_BEGIN3);
     const endIdx = existing.indexOf(MANAGED_BLOCK_END2);
     if (beginIdx !== -1 && endIdx !== -1) {
@@ -15819,7 +13600,7 @@ async function runWorkflowPackSyncCommand(options) {
       const afterBlock = existing.slice(endIdx + MANAGED_BLOCK_END2.length);
       const newContent = `${beforeBlock}${fullManagedBlock}${afterBlock}`;
       if (newContent !== existing) {
-        await writeFile4(filePath, newContent, "utf-8");
+        await writeFile3(filePath, newContent, "utf-8");
         return true;
       }
     } else {
@@ -15828,7 +13609,7 @@ async function runWorkflowPackSyncCommand(options) {
 ${fullManagedBlock}
 `;
       if (newContent !== existing) {
-        await writeFile4(filePath, newContent, "utf-8");
+        await writeFile3(filePath, newContent, "utf-8");
         return true;
       }
     }
@@ -15846,7 +13627,7 @@ ${fullManagedBlock}
   let manifestWritten = false;
   let previousManifestWorkflowPack = void 0;
   try {
-    const existingRaw = await readFile7(manifestPath, "utf-8").catch(() => null);
+    const existingRaw = await readFile6(manifestPath, "utf-8").catch(() => null);
     if (existingRaw) {
       const existing = JSON.parse(existingRaw);
       previousManifestWorkflowPack = existing.workflowPack;
@@ -15855,13 +13636,13 @@ ${fullManagedBlock}
   }
   if (previousManifestWorkflowPack === void 0 || JSON.stringify(previousManifestWorkflowPack) !== JSON.stringify(manifestMeta)) {
     try {
-      const existingRaw = await readFile7(manifestPath, "utf-8").catch(
+      const existingRaw = await readFile6(manifestPath, "utf-8").catch(
         () => null
       );
       let manifest = existingRaw ? JSON.parse(existingRaw) : {};
       manifest.workflowPack = manifestMeta;
-      await mkdir7(resolve5(manifestPath, ".."), { recursive: true });
-      await writeFile4(
+      await mkdir6(resolve5(manifestPath, ".."), { recursive: true });
+      await writeFile3(
         manifestPath,
         JSON.stringify(manifest, null, 2) + "\n",
         "utf-8"
@@ -16581,22 +14362,22 @@ function formatChecks2(checks) {
 init_common();
 
 // execution/sandcastle-execution.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync10, statSync as statSync2, writeFileSync as writeFileSync8 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync9, statSync as statSync2, writeFileSync as writeFileSync6 } from "fs";
+import { join as join20 } from "path";
 import { createWorktree, opencode } from "@ai-hero/sandcastle";
 import { docker } from "@ai-hero/sandcastle/sandboxes/docker";
 
 // execution/execution-provider.ts
 init_common();
 import { mkdtempSync } from "fs";
-import { writeFile as writeFile5 } from "fs/promises";
+import { writeFile as writeFile4 } from "fs/promises";
 import { tmpdir } from "os";
-import { dirname as dirname7, join as join23 } from "path";
+import { dirname as dirname7, join as join18 } from "path";
 async function writeExecutionArtifacts(worktreePath, artifacts) {
   for (const artifact of artifacts) {
-    const filePath = join23(worktreePath, artifact.path);
+    const filePath = join18(worktreePath, artifact.path);
     await ensureDir(dirname7(filePath));
-    await writeFile5(filePath, artifact.content, "utf-8");
+    await writeFile4(filePath, artifact.content, "utf-8");
   }
 }
 
@@ -16608,19 +14389,19 @@ init_common();
 import path7 from "path";
 
 // execution/sandbox-image.ts
-import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync22, readFileSync as readFileSync22 } from "fs";
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync19, readFileSync as readFileSync19 } from "fs";
 import path6 from "path";
 function sandboxImageName(repoRoot2, installIcm) {
   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 (!existsSync22(dockerfilePath)) {
+  if (!existsSync19(dockerfilePath)) {
     const base2 = `sandcastle:${baseName}`;
     return installIcm ? `${base2}-icm` : base2;
   }
-  const fingerprint = createHash3("sha256").update(readFileSync22(dockerfilePath)).digest("hex").slice(0, 8);
+  const fingerprint = createHash2("sha256").update(readFileSync19(dockerfilePath)).digest("hex").slice(0, 8);
   const base = `sandcastle:${baseName}-${fingerprint}`;
   return installIcm ? `${base}-icm` : base;
 }
@@ -16656,7 +14437,7 @@ async function createSandboxFromExistingWorktree(options) {
 }
 
 // execution/sandbox-options.ts
-import { join as join24 } from "path";
+import { join as join19 } from "path";
 var POURKIT_ICM_CONTAINER_DIR = "/home/agent/.pourkit/icm";
 function buildSandboxOptions(repoRoot2, sandbox, memory) {
   const mounts = [];
@@ -16665,12 +14446,12 @@ function buildSandboxOptions(repoRoot2, sandbox, memory) {
   }
   if (memory?.available) {
     mounts.push({
-      hostPath: join24(repoRoot2, ".pourkit", "icm"),
+      hostPath: join19(repoRoot2, ".pourkit", "icm"),
       sandboxPath: POURKIT_ICM_CONTAINER_DIR,
       readonly: false
     });
     mounts.push({
-      hostPath: join24(repoRoot2, ".pourkit", "icm", "cache"),
+      hostPath: join19(repoRoot2, ".pourkit", "icm", "cache"),
       sandboxPath: "/home/agent/.cache/icm",
       readonly: false
     });
@@ -16804,13 +14585,13 @@ var SandcastleExecutionSession = class {
             "Memory enabled but memory context is invalid. Run `pourkit memory init` or install ICM for host planning use."
           );
         }
-        const hostMemoryDir = join25(repoRoot2, ".pourkit", "icm");
-        if (!existsSync23(hostMemoryDir) || !statSync2(hostMemoryDir).isDirectory()) {
+        const hostMemoryDir = join20(repoRoot2, ".pourkit", "icm");
+        if (!existsSync20(hostMemoryDir) || !statSync2(hostMemoryDir).isDirectory()) {
           throw new MissingHostMemoryDirError(
             "Memory enabled but host .pourkit/icm/ directory is missing. Run `pourkit memory init` to create the repo-scoped memory store."
           );
         }
-        mkdirSync10(join25(hostMemoryDir, "cache"), { recursive: true });
+        mkdirSync9(join20(hostMemoryDir, "cache"), { recursive: true });
       }
       const sandboxOptions = buildSandboxOptions(
         repoRoot2,
@@ -16969,8 +14750,8 @@ function sanitizeBranch(branchName) {
 }
 function safeCopyToWorktreePaths(paths, repoRoot2, worktreePath) {
   return paths.filter((relativePath) => {
-    const source = join25(repoRoot2, relativePath);
-    if (!existsSync23(source)) {
+    const source = join20(repoRoot2, relativePath);
+    if (!existsSync20(source)) {
       return true;
     }
     try {
@@ -16980,8 +14761,8 @@ function safeCopyToWorktreePaths(paths, repoRoot2, worktreePath) {
     } catch {
       return true;
     }
-    const destination = join25(worktreePath, relativePath);
-    return !existsSync23(destination);
+    const destination = join20(worktreePath, relativePath);
+    return !existsSync20(destination);
   });
 }
 function formatAgentStreamEvent(event) {
@@ -17045,13 +14826,13 @@ function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function savePromptToFile(repoRoot2, stage, iteration, prompt) {
-  const promptsDir = join25(repoRoot2, ".pourkit", ".tmp", "prompts");
-  mkdirSync10(promptsDir, { recursive: true });
+  const promptsDir = join20(repoRoot2, ".pourkit", ".tmp", "prompts");
+  mkdirSync9(promptsDir, { recursive: true });
   const timestamp2 = Date.now();
   const iterationSuffix = iteration !== void 0 ? `-iteration-${iteration}` : "";
   const filename = `${stage}${iterationSuffix}-${timestamp2}.md`;
-  const filePath = join25(promptsDir, filename);
-  writeFileSync8(filePath, prompt, "utf-8");
+  const filePath = join20(promptsDir, filename);
+  writeFileSync6(filePath, prompt, "utf-8");
 }
 
 // cli.ts
@@ -17151,8 +14932,8 @@ function createCliProgram(version) {
   });
   program.command("validate-artifact").description("Validate an agent handoff artifact").argument(
     "<kind>",
-    "artifact kind: reviewer, refactor, finalizer, conflict-resolution, failure-resolution, local-prd, local-issue, local-triage, or issue-final-review"
-  ).argument("<artifactPath>", "artifact path to validate").argument("[extraPaths...]", "additional artifact paths (for local-triage)").option("--iteration <number>", "review/refactor iteration", (value) => {
+    "artifact kind: reviewer, refactor, finalizer, conflict-resolution, failure-resolution, or issue-final-review"
+  ).argument("<artifactPath>", "artifact path to validate").argument("[extraPaths...]", "unused compatibility argument").option("--iteration <number>", "review/refactor iteration", (value) => {
     const parsed = Number.parseInt(value, 10);
     if (!Number.isInteger(parsed) || parsed < 1) {
       throw new CommanderError(
@@ -17205,16 +14986,13 @@ function createCliProgram(version) {
     "--base-ref <ref>",
     "canonical base ref for issue-final-review changedFiles coverage validation"
   ).option("--no-check-conflict-markers", "skip conflict marker scan").option("--cwd <path>", "target repository directory").action(
-    (kind, artifactPath, extraPaths, options) => {
+    (kind, artifactPath, _extraPaths, options) => {
       const allowedKinds = /* @__PURE__ */ new Set([
         "reviewer",
         "refactor",
         "finalizer",
         "conflict-resolution",
         "failure-resolution",
-        "local-prd",
-        "local-issue",
-        "local-triage",
         "issue-final-review"
       ]);
       if (!allowedKinds.has(kind)) {
@@ -17224,18 +15002,8 @@ function createCliProgram(version) {
           `Unsupported artifact kind "${kind}"`
         );
       }
-      const LOCAL_KINDS = /* @__PURE__ */ new Set([
-        "local-prd",
-        "local-issue",
-        "local-triage"
-      ]);
       const targetRepoRoot = options.cwd ? repoRoot(options.cwd) : repoRoot();
-      const result = LOCAL_KINDS.has(kind) ? runLocalValidateArtifactCommand({
-        repoRoot: targetRepoRoot,
-        kind,
-        artifactPath,
-        extraArgs: extraPaths
-      }) : runValidateArtifactCommand({
+      const result = runValidateArtifactCommand({
         repoRoot: targetRepoRoot,
         kind,
         artifactPath,
@@ -17518,15 +15286,14 @@ function createCliProgram(version) {
       const logger = createLogger("pourkit", logPath);
       try {
         const config = await loadRepoConfig(targetRepoRoot);
-        const target = resolveTarget(config, options.target);
-        const mode = resolvePrdRunMode(target).mode;
-        const client = mode === "local" ? void 0 : await requireGitHubClient({ cwd: targetRepoRoot });
-        const issueProvider = client ? new GitHubIssueProvider(client, {
+        resolveTarget(config, options.target);
+        const client = await requireGitHubClient({ cwd: targetRepoRoot });
+        const issueProvider = new GitHubIssueProvider(client, {
           readyForAgentLabel: config.labels.readyForAgent,
           blockedLabel: config.labels.blocked,
           issueListLimit: config.checks.issueListLimit
-        }) : void 0;
-        const prProvider = client ? new GitHubPRProvider(client, logger) : void 0;
+        });
+        const prProvider = new GitHubPRProvider(client, logger);
         const executionProvider = new SandcastleExecutionProvider();
         const result = await runPrdRunLaunchCommand({
           repoRoot: targetRepoRoot,
@@ -17785,11 +15552,11 @@ function createCliProgram(version) {
   return program;
 }
 async function resolveCliVersion() {
-  if (isPackageVersion("0.0.0-next-20260619074943")) {
-    return "0.0.0-next-20260619074943";
+  if (isPackageVersion("0.0.0-next-20260619094345")) {
+    return "0.0.0-next-20260619094345";
   }
-  if (isReleaseVersion("0.0.0-next-20260619074943")) {
-    return "0.0.0-next-20260619074943";
+  if (isReleaseVersion("0.0.0-next-20260619094345")) {
+    return "0.0.0-next-20260619094345";
   }
   try {
     const root = repoRoot();