@pourkit/cli 0.0.0-next-20260621233457 → 0.0.0-next-20260622201317

package/dist/cli.js

@@ -1513,16 +1513,6 @@ function renderCommandList(target, heading, repoRoot2) {
     "Use the wrapper as the configured verification method for Builder, Reviewer, Refactor, and Issue Final Review handoffs. Run the underlying commands directly only when no wrapper path can run, and record that degraded path in the role's artifact or handoff notes.",
     ""
   ];
-  if (isPourkitSourceRepo(repoRoot2)) {
-    parts.push(
-      "Pourkit self-development fallback:",
-      "",
-      `- If \`${wrapperCommand}\` fails before running configured commands because the installed CLI rejects this worktree's config schemaVersion, build and rerun the same target with the worktree-local CLI: \`npm run build --workspace pourkit\`, then \`node pourkit/dist/cli.js run-verification --target ${target.name}\`.`,
-      '- Treat local CLI wrapper success as valid configured verification and record it as `verification.method: "local-wrapper"` in Issue Final Review artifacts, or as local-wrapper verification in Builder/Reviewer/Refactor handoff notes.',
-      '- Fall back to the underlying configured commands only if the worktree-local CLI cannot be built or invoked; record that degraded path as `verification.method: "commands"` in Issue Final Review artifacts, or as direct-command verification in Builder/Reviewer/Refactor handoff notes, and explain why the wrapper path could not run.',
-      ""
-    );
-  }
   if (commands.length > 0) {
     parts.push(
       "Configured commands executed by the wrapper:",
@@ -1535,17 +1525,6 @@ function renderCommandList(target, heading, repoRoot2) {
   }
   return parts;
 }
-function isPourkitSourceRepo(repoRoot2) {
-  if (!repoRoot2) return false;
-  const packagePath = join5(repoRoot2, "pourkit", "package.json");
-  if (!existsSync4(packagePath)) return false;
-  try {
-    const parsed = JSON.parse(readFileSync4(packagePath, "utf-8"));
-    return parsed.name === "@pourkit/cli";
-  } catch {
-    return false;
-  }
-}
 function renderParentPrdContext(issue, parentPrdIssue, repoRoot2) {
   const parent = extractIssueSection(issue.body, "Parent");
   const parentRef = parent?.match(/\bPRD-\d+\b/i)?.[0]?.toUpperCase() ?? issue.title.match(/^\s*(PRD-\d+)\s*\/\s*I-\d+\b/i)?.[1]?.toUpperCase();
@@ -2291,7 +2270,6 @@ Read the selected issue requirements, planning context (including plan and PRD c
 
 - First read ${RUN_CONTEXT_PATH_IN_WORKTREE} only far enough to identify the configured verification commands.
 - Before reviewing code, diffs, artifacts, or prior findings, run the configured verification wrapper yourself from the Worktree.
-- If ${RUN_CONTEXT_PATH_IN_WORKTREE} provides a worktree-local CLI fallback, use that fallback before considering direct command execution.
 - Run underlying verification commands directly only when no wrapper path can run, and record why verification used direct commands.
 - If a configured command fails, keep reviewing after recording the failure details; use the failure output as review evidence.
 - If a command cannot run because the environment is missing required setup, dependencies, or scripts outside agent control, treat it as a human handoff blocker.
@@ -2542,7 +2520,6 @@ Read the selected issue requirements, planning context (including plan and PRD c
 ## Verification Handoff
 
 - Run the verification wrapper listed in ${RUN_CONTEXT_PATH_IN_WORKTREE} after making changes.
-- If ${RUN_CONTEXT_PATH_IN_WORKTREE} provides a worktree-local CLI fallback, use that fallback before considering direct command execution.
 - Run underlying verification commands directly only when no wrapper path can run, and record why verification used direct commands in the Refactor Artifact.
 - If configured verification fails because of fixable Issue work, fix the work and rerun verification before handoff.
 - Failed or blocked verification prohibits <promise>COMPLETE</promise>.
@@ -3260,12 +3237,6 @@ var ISSUE_FINAL_REVIEW_SCOPE_VERDICTS = [
   "incidental",
   "out-of-scope"
 ];
-var ISSUE_FINAL_REVIEW_VERIFICATION_METHODS = [
-  "wrapper",
-  "local-wrapper",
-  "commands",
-  "none"
-];
 function invalid(options, reason, diagnostics = []) {
   return {
     ok: false,
@@ -3573,15 +3544,6 @@ function validateIssueFinalReviewArtifact(parsed, options) {
       diagnostics
     };
   }
-  if ("method" in verification && !ISSUE_FINAL_REVIEW_VERIFICATION_METHODS.includes(
-    verification.method
-  )) {
-    return {
-      ok: false,
-      reason: 'verification.method must be "wrapper", "local-wrapper", "commands", or "none"',
-      diagnostics
-    };
-  }
   diagnostics.push("verification: present");
   const verificationWasRecorded = verification.required === true || Array.isArray(verification.commands) && verification.commands.length > 0;
   if (parsed.verdict === "pass" && verificationWasRecorded) {
@@ -3596,20 +3558,6 @@ function validateIssueFinalReviewArtifact(parsed, options) {
         ]
       };
     }
-    if (typeof verification.method !== "string") {
-      return {
-        ok: false,
-        reason: "Issue Final Review pass with verification evidence requires verification.method",
-        diagnostics
-      };
-    }
-    if (verification.method === "none") {
-      return {
-        ok: false,
-        reason: 'Issue Final Review pass with verification evidence requires verification.method other than "none"',
-        diagnostics
-      };
-    }
     diagnostics.push("pass verification: valid");
   }
   if (parsed.selfRetouched === true && parsed.verdict === "pass") {
@@ -3794,7 +3742,6 @@ function shellQuote(value) {
 
 // commands/issue-run.ts
 import { existsSync as existsSync13, readFileSync as readFileSync15 } from "fs";
-import { isAbsolute as isAbsolute4, join as join15 } from "path";
 
 // pr/templates.ts
 init_common();
@@ -4973,7 +4920,6 @@ Read the selected issue requirements, planning context (including plan and PRD c
 ## Verification Handoff
 
 - Run the verification wrapper listed in ${RUN_CONTEXT_PATH_IN_WORKTREE}.
-- If ${RUN_CONTEXT_PATH_IN_WORKTREE} provides a worktree-local CLI fallback, use that fallback before considering direct command execution.
 - Run underlying verification commands directly only when no wrapper path can run, and report why verification used direct commands.
 - If configured verification fails because of fixable Issue work, fix the work and rerun verification before handoff.
 - Failed or blocked verification prohibits <promise>COMPLETE</promise>.`);
@@ -5922,9 +5868,6 @@ function buildIssueFinalReviewPrComment(artifact) {
       `- **Required:** ${formatBoolean(artifact.verification.required)}`,
       `- **Passed:** ${formatBoolean(artifact.verification.passed)}`
     );
-    if (typeof artifact.verification.method === "string") {
-      lines.push(`- **Method:** ${formatLabel(artifact.verification.method)}`);
-    }
     const commands = Array.isArray(artifact.verification.commands) ? artifact.verification.commands.filter(
       (command) => typeof command === "string"
     ) : [];
@@ -6147,16 +6090,17 @@ function isAllowedDocumentationTokenReference(value) {
   return /^token\s*:\s*["']?<verdict>/i.test(value);
 }
 
-// commands/issue-final-review-agent.ts
+// issues/issue-final-review.ts
 import { existsSync as existsSync12, readFileSync as readFileSync14 } from "fs";
-import { join as join13 } from "path";
+import { isAbsolute as isAbsolute4, join as join13 } from "path";
+init_common();
 var ISSUE_FINAL_REVIEW_ARTIFACT_PATH = join13(
   ".pourkit",
   ".tmp",
   "issue-final-review",
   "agent-output.json"
 );
-async function runIssueFinalReviewAgent(options) {
+async function runIssueFinalReview(options) {
   const {
     executionProvider,
     target,
@@ -6169,6 +6113,34 @@ async function runIssueFinalReviewAgent(options) {
   } = options;
   const artifactPathInWorktree = ISSUE_FINAL_REVIEW_ARTIFACT_PATH;
   const artifactPath = join13(worktreePath, artifactPathInWorktree);
+  const ifrFromState = options.worktreeState?.issueFinalReview;
+  if (ifrFromState?.completed && ifrFromState.verdict === "pass") {
+    if (!ifrFromState.artifactPath) {
+      throw new Error(
+        "Issue Final Review state is incomplete: missing artifactPath"
+      );
+    }
+    const cachedArtifactPath = isAbsolute4(ifrFromState.artifactPath) ? ifrFromState.artifactPath : join13(worktreePath, ifrFromState.artifactPath);
+    const validation2 = validateAgentArtifact({
+      kind: "issue-final-review",
+      artifactPath: cachedArtifactPath,
+      issueNumber: issue.number,
+      branchName: builderBranch
+    });
+    if (!validation2.ok) {
+      throw new Error(
+        `Issue Final Review state artifact is invalid: ${validation2.reason}`
+      );
+    }
+    return {
+      status: "skipped",
+      verdict: "pass",
+      artifactPath: cachedArtifactPath,
+      selfRetouched: ifrFromState.selfRetouched ?? false,
+      changedPaths: ifrFromState.changedPaths ?? [],
+      verificationPassed: ifrFromState.verificationPassed ?? false
+    };
+  }
   const strategy = target.strategy;
   const issueFinalReview = strategy.issueFinalReview;
   const agent = issueFinalReview;
@@ -6245,17 +6217,42 @@ async function runIssueFinalReviewAgent(options) {
   }
   const parsed = JSON.parse(content);
   const verdict = parsed.verdict;
+  const baseRef = `origin/${target.baseBranch}`;
+  await assertCanonicalBaseAncestor2({
+    worktreePath,
+    baseRef,
+    stageName: "Issue Final Review",
+    logger
+  });
   if (verdict === "pass") {
+    const changedPaths = await completeIssueFinalReviewChangedPaths({
+      worktreePath,
+      baseRef,
+      declaredChangedPaths: extractChangedPaths(parsed),
+      logger
+    });
+    updateWorktreeRunState(worktreePath, {
+      issueFinalReview: {
+        completed: true,
+        verdict: "pass",
+        artifactPath,
+        selfRetouched: parsed.selfRetouched === true,
+        changedPaths,
+        verificationPassed: parsed.verification?.passed === true
+      }
+    });
     return {
+      status: "passed",
       verdict: "pass",
       artifactPath,
       selfRetouched: parsed.selfRetouched === true,
-      changedPaths: extractChangedPaths(parsed),
+      changedPaths,
       verificationPassed: parsed.verification?.passed === true
     };
   }
   if (verdict === "needs_human_review") {
     return {
+      status: "needs_human_review",
       verdict: "needs_human_review",
       artifactPath,
       needsHumanReason: parsed.needsHumanReason,
@@ -6267,6 +6264,89 @@ async function runIssueFinalReviewAgent(options) {
     `Unknown Issue Final Review verdict: ${JSON.stringify(verdict)}`
   );
 }
+async function assertCanonicalBaseAncestor2(options) {
+  const { worktreePath, baseRef, stageName, logger } = options;
+  await syncRemoteBaseRef2(worktreePath, baseRef, logger);
+  try {
+    await execCapture("git", ["merge-base", "--is-ancestor", baseRef, "HEAD"], {
+      cwd: worktreePath,
+      logger,
+      label: "git merge-base --is-ancestor"
+    });
+  } catch {
+    throw new Error(
+      `Cannot continue after ${stageName}: ${baseRef} is not an ancestor of HEAD. An agent may have moved the issue branch behind the canonical base; refresh the branch onto the latest target base before continuing.`
+    );
+  }
+}
+async function syncRemoteBaseRef2(worktreePath, baseRef, logger) {
+  const remoteBase = parseRemoteBaseRef2(baseRef);
+  if (!remoteBase) {
+    return;
+  }
+  await execCapture("git", ["fetch", remoteBase.remote, remoteBase.branch], {
+    cwd: worktreePath,
+    logger,
+    label: "git fetch target"
+  });
+}
+function parseRemoteBaseRef2(baseRef) {
+  const [remote, ...branchParts] = baseRef.split("/");
+  const branch = branchParts.join("/");
+  if (!remote || !branch) {
+    return null;
+  }
+  return { remote, branch };
+}
+async function completeIssueFinalReviewChangedPaths(options) {
+  const actualChangedPaths = await listIssueFinalReviewChangedPaths2(options);
+  const declared = new Set(options.declaredChangedPaths.map(normalizeGitPath2));
+  const missing = actualChangedPaths.filter((path9) => !declared.has(path9));
+  if (missing.length === 0) {
+    return actualChangedPaths;
+  }
+  options.logger.step(
+    "warn",
+    `Issue Final Review pass omitted ${missing.length} changed file(s) from changedFiles; using git inventory for finalization state.`
+  );
+  options.logger.kv("MISSING_CHANGED_FILES", missing.join(", "));
+  return actualChangedPaths;
+}
+async function listIssueFinalReviewChangedPaths2(options) {
+  const trackedDiff = await execCapture(
+    "git",
+    ["diff-index", "--name-only", options.baseRef, "--"],
+    {
+      cwd: options.worktreePath,
+      logger: options.logger,
+      label: "git diff-index Issue Final Review paths"
+    }
+  );
+  const untrackedFiles = await execCapture(
+    "git",
+    ["ls-files", "--others", "--exclude-standard"],
+    {
+      cwd: options.worktreePath,
+      logger: options.logger,
+      label: "git ls-files Issue Final Review paths"
+    }
+  );
+  return Array.from(
+    /* @__PURE__ */ new Set([
+      ...parseGitPathList2(trackedDiff.stdout),
+      ...parseGitPathList2(untrackedFiles.stdout)
+    ])
+  ).filter(isIssueFinalReviewAuditedPath2);
+}
+function parseGitPathList2(output) {
+  return output.split(/\r?\n/).map(normalizeGitPath2).filter((path9) => path9.length > 0);
+}
+function normalizeGitPath2(path9) {
+  return path9.replace(/^"|"$/g, "").replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/\/+$/, "");
+}
+function isIssueFinalReviewAuditedPath2(path9) {
+  return path9 !== "" && path9 !== WORKTREE_RUN_STATE_PATH && !path9.startsWith(".pourkit/.tmp/") && !path9.startsWith(".pourkit/logs/");
+}
 function extractChangedPaths(parsed) {
   return Array.isArray(parsed.changedFiles) ? parsed.changedFiles.map(
     (file) => file && typeof file === "object" ? file.path : void 0
@@ -6292,9 +6372,7 @@ Read the selected issue requirements, planning context (including plan and PRD c
 
 - First read ${RUN_CONTEXT_PATH_IN_WORKTREE} only far enough to identify the configured verification commands.
 - Before reviewing code, diffs, artifacts, or prior findings, run the verification wrapper from the Worktree.
-- If the installed Pourkit CLI rejects the worktree config schemaVersion and the Run Context provides a Pourkit self-development fallback, build and run the worktree-local CLI wrapper exactly as instructed.
-- Do not substitute direct underlying commands unless neither wrapper path can run; if you must use direct commands, record degraded verification with \`verification.method: "commands"\` and explain why in \`verification.summary\`.
-- Record successful wrapper verification with \`verification.method: "wrapper"\`, or worktree-local CLI wrapper verification with \`verification.method: "local-wrapper"\`.
+- Do not substitute direct underlying commands unless no wrapper path can run; if you must use direct commands, explain why in \`verification.summary\`.
 - If a configured verification command fails because of fixable Issue work, self-retouch the Worktree, then rerun all configured verification commands.
 - Do not return \`pass\` while any configured verification command is failing.
 - If a command cannot run because the environment is missing required setup, dependencies, or scripts outside agent control, treat it as a human handoff blocker.
@@ -6507,90 +6585,7 @@ function assertIssueFinalReviewPassed(worktreeState) {
   }
 }
 async function advanceIssueFinalReview(options) {
-  const {
-    executionProvider,
-    config,
-    target,
-    issue,
-    parentPrdIssue,
-    builderBranch,
-    worktreePath,
-    repoRoot: repoRoot2,
-    logger,
-    reviewArtifactPath,
-    reviewVerdict,
-    worktreeState
-  } = options;
-  const ifrFromState = worktreeState?.issueFinalReview;
-  if (ifrFromState?.completed && ifrFromState.verdict === "pass") {
-    if (!ifrFromState.artifactPath) {
-      throw new Error(
-        "Issue Final Review state is incomplete: missing artifactPath"
-      );
-    }
-    const artifactPath = isAbsolute4(ifrFromState.artifactPath) ? ifrFromState.artifactPath : join15(worktreePath, ifrFromState.artifactPath);
-    const validation = validateAgentArtifact({
-      kind: "issue-final-review",
-      artifactPath,
-      issueNumber: issue.number,
-      branchName: builderBranch
-    });
-    if (!validation.ok) {
-      throw new Error(
-        `Issue Final Review state artifact is invalid: ${validation.reason}`
-      );
-    }
-    return {
-      verdict: "pass",
-      artifactPath,
-      selfRetouched: ifrFromState.selfRetouched ?? false,
-      changedPaths: ifrFromState.changedPaths ?? [],
-      verificationPassed: ifrFromState.verificationPassed ?? false
-    };
-  }
-  const result = await runIssueFinalReviewAgent({
-    executionProvider,
-    config,
-    target,
-    issue,
-    parentPrdIssue,
-    builderBranch,
-    worktreePath,
-    repoRoot: repoRoot2,
-    logger,
-    reviewArtifactPath,
-    reviewVerdict,
-    ...options.memory ? { memory: options.memory } : {}
-  });
-  await assertCanonicalBaseAncestor2({
-    worktreePath,
-    baseRef: `origin/${target.baseBranch}`,
-    stageName: "Issue Final Review",
-    logger
-  });
-  if (result.verdict === "pass") {
-    const changedPaths = await completeIssueFinalReviewChangedPaths({
-      worktreePath,
-      baseRef: `origin/${target.baseBranch}`,
-      declaredChangedPaths: result.changedPaths,
-      logger
-    });
-    updateWorktreeRunState(worktreePath, {
-      issueFinalReview: {
-        completed: true,
-        verdict: "pass",
-        artifactPath: result.artifactPath,
-        selfRetouched: result.selfRetouched,
-        changedPaths,
-        verificationPassed: result.verificationPassed
-      }
-    });
-    return {
-      ...result,
-      changedPaths
-    };
-  }
-  return result;
+  return runIssueFinalReview(options);
 }
 async function startIssueRun(options) {
   const {
@@ -7026,89 +7021,6 @@ async function finalizeWorktreeCommit(options) {
     label: "git commit"
   });
 }
-async function assertCanonicalBaseAncestor2(options) {
-  const { worktreePath, baseRef, stageName, logger } = options;
-  await syncRemoteBaseRef2(worktreePath, baseRef, logger);
-  try {
-    await execCapture("git", ["merge-base", "--is-ancestor", baseRef, "HEAD"], {
-      cwd: worktreePath,
-      logger,
-      label: "git merge-base --is-ancestor"
-    });
-  } catch {
-    throw new Error(
-      `Cannot continue after ${stageName}: ${baseRef} is not an ancestor of HEAD. An agent may have moved the issue branch behind the canonical base; refresh the branch onto the latest target base before continuing.`
-    );
-  }
-}
-async function completeIssueFinalReviewChangedPaths(options) {
-  const actualChangedPaths = await listIssueFinalReviewChangedPaths2(options);
-  const declared = new Set(options.declaredChangedPaths.map(normalizeGitPath2));
-  const missing = actualChangedPaths.filter((path9) => !declared.has(path9));
-  if (missing.length === 0) {
-    return actualChangedPaths;
-  }
-  options.logger.step(
-    "warn",
-    `Issue Final Review pass omitted ${missing.length} changed file(s) from changedFiles; using git inventory for finalization state.`
-  );
-  options.logger.kv("MISSING_CHANGED_FILES", missing.join(", "));
-  return actualChangedPaths;
-}
-async function listIssueFinalReviewChangedPaths2(options) {
-  const trackedDiff = await execCapture(
-    "git",
-    ["diff-index", "--name-only", options.baseRef, "--"],
-    {
-      cwd: options.worktreePath,
-      logger: options.logger,
-      label: "git diff-index Issue Final Review paths"
-    }
-  );
-  const untrackedFiles = await execCapture(
-    "git",
-    ["ls-files", "--others", "--exclude-standard"],
-    {
-      cwd: options.worktreePath,
-      logger: options.logger,
-      label: "git ls-files Issue Final Review paths"
-    }
-  );
-  return Array.from(
-    /* @__PURE__ */ new Set([
-      ...parseGitPathList2(trackedDiff.stdout),
-      ...parseGitPathList2(untrackedFiles.stdout)
-    ])
-  ).filter(isIssueFinalReviewAuditedPath2);
-}
-function parseGitPathList2(output) {
-  return output.split(/\r?\n/).map(normalizeGitPath2).filter((path9) => path9.length > 0);
-}
-function normalizeGitPath2(path9) {
-  return path9.replace(/^"|"$/g, "").replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/\/+$/, "");
-}
-function isIssueFinalReviewAuditedPath2(path9) {
-  return path9 !== "" && path9 !== WORKTREE_RUN_STATE_PATH && !path9.startsWith(".pourkit/.tmp/") && !path9.startsWith(".pourkit/logs/");
-}
-async function syncRemoteBaseRef2(worktreePath, baseRef, logger) {
-  const remoteBase = parseRemoteBaseRef2(baseRef);
-  if (!remoteBase) {
-    return;
-  }
-  await execCapture("git", ["fetch", remoteBase.remote, remoteBase.branch], {
-    cwd: worktreePath,
-    logger,
-    label: "git fetch target"
-  });
-}
-function parseRemoteBaseRef2(baseRef) {
-  const [remote, ...branchParts] = baseRef.split("/");
-  const branch = branchParts.join("/");
-  if (!remote || !branch) {
-    return null;
-  }
-  return { remote, branch };
-}
 function makeIssueTransitions2(provider, config) {
   return createIssueTransitions(
     {
@@ -7257,7 +7169,7 @@ async function runIssueLifecycle(options) {
       worktreeState: startResult.worktreeState,
       memory: startResult.memory
     });
-    if (finalReviewResult.verdict === "needs_human_review") {
+    if (finalReviewResult.status === "needs_human_review") {
       await options.deps.transitionIssueFinalReviewNeedsHumanToHandoff({
         issueNumber: options.issueNumber,
         finalReviewResult
@@ -7451,7 +7363,7 @@ async function runIssueCreateCommand(args, issueProvider, logger) {
 
 // commands/prd-run.ts
 import { lstatSync, realpathSync } from "fs";
-import { join as join17 } from "path";
+import { join as join16 } from "path";
 
 // prd-run/state.ts
 import {
@@ -7461,7 +7373,7 @@ import {
   readdirSync as readdirSync3,
   writeFileSync as writeFileSync4
 } from "fs";
-import { join as join16 } from "path";
+import { join as join15 } from "path";
 import { z } from "zod";
 var PRD_RUN_STATE_DIR = ".pourkit/prd-runs";
 var PrdRunRecordSchema = z.object({
@@ -7576,7 +7488,7 @@ function readPrdRun(repoRoot2, prdRef) {
   }
 }
 function listPrdRuns(repoRoot2) {
-  const stateDir = join16(repoRoot2, PRD_RUN_STATE_DIR);
+  const stateDir = join15(repoRoot2, PRD_RUN_STATE_DIR);
   if (!existsSync14(stateDir)) {
     return { records: [], diagnostics: [] };
   }
@@ -7586,7 +7498,7 @@ function listPrdRuns(repoRoot2) {
     (left, right) => left.name.localeCompare(right.name)
   )) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-    const recordPath = join16(stateDir, entry.name);
+    const recordPath = join15(stateDir, entry.name);
     try {
       const record = PrdRunRecordSchema.parse(
         JSON.parse(readFileSync16(recordPath, "utf-8"))
@@ -7602,7 +7514,7 @@ function listPrdRuns(repoRoot2) {
 }
 function writePrdRunRecord(repoRoot2, record) {
   const normalized = normalizePrdRunRef(record.prdRef);
-  const stateDir = join16(repoRoot2, PRD_RUN_STATE_DIR);
+  const stateDir = join15(repoRoot2, PRD_RUN_STATE_DIR);
   const recordPath = getRecordPath(repoRoot2, normalized);
   mkdirSync7(stateDir, { recursive: true });
   writeFileSync4(
@@ -7612,7 +7524,7 @@ function writePrdRunRecord(repoRoot2, record) {
   );
 }
 function getRecordPath(repoRoot2, prdRef) {
-  return join16(
+  return join15(
     repoRoot2,
     PRD_RUN_STATE_DIR,
     `${normalizePrdRunRef(prdRef)}.json`
@@ -12383,10 +12295,10 @@ Init applied: ${result.applied} operations applied, ${result.skipped} skipped.`
 
 // commands/memory-init.ts
 import { existsSync as existsSync17, mkdirSync as mkdirSync8, readFileSync as readFileSync18, writeFileSync as writeFileSync5 } from "fs";
-import { join as join18 } from "path";
+import { join as join17 } from "path";
 async function runMemoryInitCommand(options) {
   const cwd = options.cwd ?? process.cwd();
-  const configPath = join18(cwd, ".pourkit", "config.json");
+  const configPath = join17(cwd, ".pourkit", "config.json");
   if (!existsSync17(configPath)) {
     return {
       ok: false,
@@ -12418,8 +12330,8 @@ async function runMemoryInitCommand(options) {
     const next = { ...raw, memory };
     writeFileSync5(configPath, JSON.stringify(next, null, 2) + "\n");
   }
-  mkdirSync8(join18(cwd, ".pourkit", "icm"), { recursive: true });
-  const gitignorePath = join18(cwd, ".gitignore");
+  mkdirSync8(join17(cwd, ".pourkit", "icm"), { recursive: true });
+  const gitignorePath = join17(cwd, ".gitignore");
   updateManagedBlockSync(gitignorePath, generateGitignoreBlock());
   const managed = await generateManagedAgentInstructions({
     sourceRoot: cwd,
@@ -12427,14 +12339,14 @@ async function runMemoryInitCommand(options) {
   });
   let updatedAgentFile = false;
   for (const fileName of ["AGENTS.md", "CLAUDE.md"]) {
-    const agentPath = join18(cwd, fileName);
+    const agentPath = join17(cwd, fileName);
     if (existsSync17(agentPath)) {
       updateManagedBlockSync(agentPath, managed);
       updatedAgentFile = true;
     }
   }
   if (!updatedAgentFile) {
-    updateManagedBlockSync(join18(cwd, "AGENTS.md"), managed);
+    updateManagedBlockSync(join17(cwd, "AGENTS.md"), managed);
   }
   return {
     ok: true,
@@ -14431,7 +14343,7 @@ init_common();
 
 // execution/sandcastle-execution.ts
 import { existsSync as existsSync21, mkdirSync as mkdirSync9, statSync as statSync2, writeFileSync as writeFileSync6 } from "fs";
-import { join as join21 } from "path";
+import { join as join20 } from "path";
 import { createWorktree, opencode } from "@ai-hero/sandcastle";
 import { docker } from "@ai-hero/sandcastle/sandboxes/docker";
 
@@ -14440,10 +14352,10 @@ init_common();
 import { mkdtempSync } from "fs";
 import { writeFile as writeFile4 } from "fs/promises";
 import { tmpdir } from "os";
-import { dirname as dirname7, join as join19 } from "path";
+import { dirname as dirname7, join as join18 } from "path";
 async function writeExecutionArtifacts(worktreePath, artifacts) {
   for (const artifact of artifacts) {
-    const filePath = join19(worktreePath, artifact.path);
+    const filePath = join18(worktreePath, artifact.path);
     await ensureDir(dirname7(filePath));
     await writeFile4(filePath, artifact.content, "utf-8");
   }
@@ -14505,7 +14417,7 @@ async function createSandboxFromExistingWorktree(options) {
 }
 
 // execution/sandbox-options.ts
-import { join as join20 } from "path";
+import { join as join19 } from "path";
 var POURKIT_ICM_CONTAINER_DIR = "/home/agent/.pourkit/icm";
 function buildSandboxOptions(repoRoot2, sandbox, memory) {
   const mounts = [];
@@ -14514,12 +14426,12 @@ function buildSandboxOptions(repoRoot2, sandbox, memory) {
   }
   if (memory?.available) {
     mounts.push({
-      hostPath: join20(repoRoot2, ".pourkit", "icm"),
+      hostPath: join19(repoRoot2, ".pourkit", "icm"),
       sandboxPath: POURKIT_ICM_CONTAINER_DIR,
       readonly: false
     });
     mounts.push({
-      hostPath: join20(repoRoot2, ".pourkit", "icm", "cache"),
+      hostPath: join19(repoRoot2, ".pourkit", "icm", "cache"),
       sandboxPath: "/home/agent/.cache/icm",
       readonly: false
     });
@@ -14653,13 +14565,13 @@ var SandcastleExecutionSession = class {
             "Memory enabled but memory context is invalid. Run `pourkit memory init` or install ICM for host planning use."
           );
         }
-        const hostMemoryDir = join21(repoRoot2, ".pourkit", "icm");
+        const hostMemoryDir = join20(repoRoot2, ".pourkit", "icm");
         if (!existsSync21(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."
           );
         }
-        mkdirSync9(join21(hostMemoryDir, "cache"), { recursive: true });
+        mkdirSync9(join20(hostMemoryDir, "cache"), { recursive: true });
       }
       const sandboxOptions = buildSandboxOptions(
         repoRoot2,
@@ -14818,7 +14730,7 @@ function sanitizeBranch(branchName) {
 }
 function safeCopyToWorktreePaths(paths, repoRoot2, worktreePath) {
   return paths.filter((relativePath) => {
-    const source = join21(repoRoot2, relativePath);
+    const source = join20(repoRoot2, relativePath);
     if (!existsSync21(source)) {
       return true;
     }
@@ -14829,7 +14741,7 @@ function safeCopyToWorktreePaths(paths, repoRoot2, worktreePath) {
     } catch {
       return true;
     }
-    const destination = join21(worktreePath, relativePath);
+    const destination = join20(worktreePath, relativePath);
     return !existsSync21(destination);
   });
 }
@@ -14894,12 +14806,12 @@ function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function savePromptToFile(repoRoot2, stage, iteration, prompt) {
-  const promptsDir = join21(repoRoot2, ".pourkit", ".tmp", "prompts");
+  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 = join21(promptsDir, filename);
+  const filePath = join20(promptsDir, filename);
   writeFileSync6(filePath, prompt, "utf-8");
 }
 
@@ -15620,11 +15532,11 @@ function createCliProgram(version) {
   return program;
 }
 async function resolveCliVersion() {
-  if (isPackageVersion("0.0.0-next-20260621233457")) {
-    return "0.0.0-next-20260621233457";
+  if (isPackageVersion("0.0.0-next-20260622201317")) {
+    return "0.0.0-next-20260622201317";
   }
-  if (isReleaseVersion("0.0.0-next-20260621233457")) {
-    return "0.0.0-next-20260621233457";
+  if (isReleaseVersion("0.0.0-next-20260622201317")) {
+    return "0.0.0-next-20260622201317";
   }
   try {
     const root = repoRoot();