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

package/dist/cli.js

@@ -3742,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();
@@ -6091,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,
@@ -6113,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;
@@ -6189,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,
@@ -6211,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
@@ -6449,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 {
@@ -6968,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(
     {
@@ -7199,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
@@ -7393,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 {
@@ -7403,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({
@@ -7518,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: [] };
   }
@@ -7528,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"))
@@ -7544,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(
@@ -7554,7 +7524,7 @@ function writePrdRunRecord(repoRoot2, record) {
   );
 }
 function getRecordPath(repoRoot2, prdRef) {
-  return join16(
+  return join15(
     repoRoot2,
     PRD_RUN_STATE_DIR,
     `${normalizePrdRunRef(prdRef)}.json`
@@ -12325,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,
@@ -12360,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,
@@ -12369,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,
@@ -14373,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";
 
@@ -14382,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");
   }
@@ -14447,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 = [];
@@ -14456,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
     });
@@ -14595,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,
@@ -14760,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;
     }
@@ -14771,7 +14741,7 @@ function safeCopyToWorktreePaths(paths, repoRoot2, worktreePath) {
     } catch {
       return true;
     }
-    const destination = join21(worktreePath, relativePath);
+    const destination = join20(worktreePath, relativePath);
     return !existsSync21(destination);
   });
 }
@@ -14836,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");
 }
 
@@ -15562,11 +15532,11 @@ function createCliProgram(version) {
   return program;
 }
 async function resolveCliVersion() {
-  if (isPackageVersion("0.0.0-next-20260622055621")) {
-    return "0.0.0-next-20260622055621";
+  if (isPackageVersion("0.0.0-next-20260622201317")) {
+    return "0.0.0-next-20260622201317";
   }
-  if (isReleaseVersion("0.0.0-next-20260622055621")) {
-    return "0.0.0-next-20260622055621";
+  if (isReleaseVersion("0.0.0-next-20260622201317")) {
+    return "0.0.0-next-20260622201317";
   }
   try {
     const root = repoRoot();