@pourkit/cli 0.0.0-next-20260714073403 → 0.0.0-next-20260715085442

package/dist/cli.js

@@ -370,10 +370,26 @@ function applyOutputRetriesDefaults(retries) {
 }
 function applyStageAgentDefaults(agent) {
   return {
-    ...agent,
+    agent: agent.agent,
+    model: agent.model,
+    variant: agent.variant,
+    env: agent.env,
+    promptTemplate: agent.promptTemplate,
     outputRetries: applyOutputRetriesDefaults(agent.outputRetries)
   };
 }
+var DEFAULT_POST_COMPLETION_FINAL_REVIEW_PROMPT = "post-completion-final-review.prompt.md";
+function applyPostCompletionFinalReviewDefaults(agent, issueFinalReview) {
+  if (agent) return applyStageAgentDefaults(agent);
+  return applyStageAgentDefaults({
+    agent: issueFinalReview.agent,
+    model: issueFinalReview.model,
+    variant: issueFinalReview.variant,
+    env: issueFinalReview.env,
+    promptTemplate: DEFAULT_POST_COMPLETION_FINAL_REVIEW_PROMPT,
+    outputRetries: issueFinalReview.outputRetries
+  });
+}
 function assertRepoRelativePath(value, location) {
   const normalized = normalize(value);
   if (isAbsolute(value) || isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${sep}`)) {
@@ -432,6 +448,10 @@ function validateConfigSemantics(input) {
       target.strategy.issueFinalReview,
       `targets[${targetIndex}].strategy.issueFinalReview`
     );
+    assertStageAgentPath(
+      target.strategy.postCompletionFinalReview,
+      `targets[${targetIndex}].strategy.postCompletionFinalReview`
+    );
     assertStageAgentPath(
       target.strategy.finalize.prDescriptionAgent,
       `targets[${targetIndex}].strategy.finalize.prDescriptionAgent`
@@ -506,6 +526,10 @@ function normalizePourkitConfig(input) {
           ),
           maxAttempts: t.strategy.issueFinalReview.maxAttempts
         },
+        postCompletionFinalReview: applyPostCompletionFinalReviewDefaults(
+          t.strategy.postCompletionFinalReview,
+          t.strategy.issueFinalReview
+        ),
         finalize: {
           prDescriptionAgent: applyStageAgentDefaults(
             t.strategy.finalize.prDescriptionAgent
@@ -4257,6 +4281,20 @@ var POST_COMPLETION_FINAL_REVIEW_ARTIFACT_PATH = join9(
   "post-completion-final-review",
   "agent-output.json"
 );
+var DEFAULT_POST_COMPLETION_FINAL_REVIEW_PROMPT2 = "post-completion-final-review.prompt.md";
+function resolvePostCompletionFinalReviewAgent(target) {
+  const configured = target.strategy.postCompletionFinalReview;
+  if (configured) return configured;
+  const fallback = target.strategy.issueFinalReview;
+  return {
+    agent: fallback.agent,
+    model: fallback.model,
+    variant: fallback.variant,
+    env: fallback.env,
+    outputRetries: fallback.outputRetries,
+    promptTemplate: DEFAULT_POST_COMPLETION_FINAL_REVIEW_PROMPT2
+  };
+}
 async function runPostCompletionFinalReview(options) {
   const {
     executionProvider,
@@ -4308,9 +4346,10 @@ async function runPostCompletionFinalReview(options) {
     };
   }
   const strategy = target.strategy;
-  const agent = strategy.issueFinalReview;
+  const agent = resolvePostCompletionFinalReviewAgent(target);
   const prompt = loadPostCompletionFinalReviewPrompt({
     repoRoot: repoRoot2,
+    promptTemplate: agent.promptTemplate,
     sourceDocumentPath,
     completedBranch,
     validationCommand: `pourkit validate-artifact post-completion-final-review ${artifactPathInWorktree}`,
@@ -4452,11 +4491,14 @@ Completed branch: ${completedBranch}`,
   );
 }
 function loadPostCompletionFinalReviewPrompt(options) {
-  const { repoRoot: repoRoot2, sourceDocumentPath, completedBranch, validationCommand } = options;
-  const promptPath = resolvePromptTemplatePath(
-    repoRoot2,
-    "post-completion-final-review.prompt.md"
-  );
+  const {
+    repoRoot: repoRoot2,
+    promptTemplate,
+    sourceDocumentPath,
+    completedBranch,
+    validationCommand
+  } = options;
+  const promptPath = resolvePromptTemplatePath(repoRoot2, promptTemplate);
   const promptBody = existsSync9(promptPath) ? readFileSync8(promptPath, "utf-8") : `Review the completed branch against the source document.
 
 ## Source Document
@@ -11090,10 +11132,11 @@ async function runPrdPlanWorkspacePublishCommand(options) {
 
 // commands/prd-run.ts
 import { lstatSync, realpathSync } from "fs";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 
 // prd-run/coordinator.ts
 import { spawnSync as spawnSync2 } from "child_process";
+import { join as join23 } from "path";
 import { Match, pipe } from "effect";
 init_common();
 
@@ -11810,7 +11853,8 @@ function validatePrdRunTerminalEvidence(record, context) {
         humanReadableReason: `PRD Run ${context.prdRef} is missing proof that all child Issues finalized into ${context.prdBranch}.`,
         repairability: "operator-action",
         nextAction: "inspect-and-retry",
-        nextRecommendedCommand: "pourkit prd-run launch"
+        nextRecommendedCommand: "pourkit prd-run launch",
+        diagnostics: [...context.childFinalizationDiagnostics ?? []]
       })
     };
   }
@@ -13239,6 +13283,105 @@ async function selectPrdRunCoordinatorMode(options) {
     })
   };
 }
+function escapeRegExp3(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizeChildRef2(value) {
+  const match = value.match(/^I-0*(\d+)$/i);
+  if (!match) return null;
+  return `I-${match[1].padStart(2, "0")}`;
+}
+function issueChildRef(prdRef, issue) {
+  const match = issue.title.match(
+    new RegExp(`^${escapeRegExp3(prdRef)}\\s*/\\s*(I-0*\\d+)\\s*:`, "i")
+  );
+  return match ? normalizeChildRef2(match[1]) : null;
+}
+function issueSummary(issue) {
+  return `#${issue.number} ${issue.title}`;
+}
+async function readPlannedChildRefs(options) {
+  const sourceDocument = await resolvePrdPostCompletionSourceDocument(options);
+  if (!sourceDocument || sourceDocument.status !== "resolved") {
+    return {
+      ok: false,
+      diagnostics: sourceDocument && sourceDocument.status === "blocked" ? [...sourceDocument.diagnostics] : [
+        sourceDocument?.reason ?? `Unable to resolve source document for ${options.prdRef}.`
+      ]
+    };
+  }
+  const parsed = await parsePrdPlanWorkspace({
+    workspacePath: join23(options.repoRoot, sourceDocument.workspacePath),
+    prdRef: options.prdRef
+  });
+  if (!parsed.ok) {
+    return {
+      ok: false,
+      diagnostics: parsed.diagnostics.map((diagnostic) => diagnostic.message)
+    };
+  }
+  return {
+    ok: true,
+    childRefs: parsed.workspace.children.map((child) => child.childRef)
+  };
+}
+async function verifyPrdChildFinalizationEvidence(options) {
+  const diagnostics = [];
+  const unfinalizedProcessed = options.processedResults.filter(
+    (result) => !result.noOp && result.publicationStatus !== "merged"
+  );
+  if (unfinalizedProcessed.length > 0) {
+    diagnostics.push(
+      `Processed child Issues missing PRD Branch merge/no-op evidence: ${unfinalizedProcessed.map((result) => `#${result.issueNumber}`).join(", ")}.`
+    );
+  }
+  let relatedIssues;
+  try {
+    relatedIssues = await options.issueProvider.listRelatedIssues(
+      options.prdRef
+    );
+  } catch (error) {
+    return {
+      ok: false,
+      diagnostics: [
+        `Failed to list child Issues for ${options.prdRef}: ${error instanceof Error ? error.message : String(error)}`
+      ]
+    };
+  }
+  if (relatedIssues.length === 0) {
+    diagnostics.push(`No child Issue projections found for ${options.prdRef}.`);
+  }
+  const planned = await readPlannedChildRefs({
+    repoRoot: options.repoRoot,
+    prdRef: options.prdRef
+  });
+  if (!planned.ok) {
+    diagnostics.push(...planned.diagnostics);
+  } else if (planned.childRefs.length === 0) {
+    diagnostics.push(`No planned child Issues found for ${options.prdRef}.`);
+  } else {
+    const relatedRefs = new Set(
+      relatedIssues.map((issue) => issueChildRef(options.prdRef, issue)).filter((ref) => ref !== null)
+    );
+    const missingRefs = planned.childRefs.filter(
+      (ref) => !relatedRefs.has(ref)
+    );
+    if (missingRefs.length > 0) {
+      diagnostics.push(
+        `Planned child Issues without published Issue projections: ${missingRefs.join(", ")}.`
+      );
+    }
+  }
+  const openRelatedIssues = relatedIssues.filter(
+    (issue) => issue.state !== "closed"
+  );
+  if (openRelatedIssues.length > 0) {
+    diagnostics.push(
+      `Child Issues still open: ${openRelatedIssues.map(issueSummary).join(", ")}.`
+    );
+  }
+  return { ok: diagnostics.length === 0, diagnostics };
+}
 async function runPostCompletionAfterTerminal(options, prdRef, record, resumeFacts, startOutcome) {
   const receipt = record.postCompletionFinalReview;
   if (receipt?.status === "passed" || receipt?.status === "overridden") {
@@ -13798,17 +13941,25 @@ async function launchPrdRun(options) {
       logger: options.logger
     });
   }
-  if (currentRecord && startReceipt && activeRepairGuidance?.failureCode === "missing-child-finalization-evidence" && await prdParentIssueIsClosed({
-    issueProvider: options.issueProvider,
+  const parentClosureIssueProvider = options.issueProvider;
+  if (currentRecord && startReceipt && parentClosureIssueProvider && activeRepairGuidance?.failureCode === "missing-child-finalization-evidence" && await prdParentIssueIsClosed({
+    issueProvider: parentClosureIssueProvider,
     prdRef,
     logger: options.logger
   })) {
     const prdBranch = startReceipt.prdBranch ?? prdRef;
+    const childFinalizationEvidence = await verifyPrdChildFinalizationEvidence({
+      repoRoot: options.repoRoot,
+      prdRef,
+      issueProvider: parentClosureIssueProvider,
+      processedResults: []
+    });
     const terminalEvidence = validatePrdRunTerminalEvidence(currentRecord, {
       prdRef,
       baseBranch: startReceipt.startBaseBranch,
       prdBranch,
-      allChildIssuesFinalizedIntoPrdBranch: true
+      allChildIssuesFinalizedIntoPrdBranch: childFinalizationEvidence.ok,
+      childFinalizationDiagnostics: childFinalizationEvidence.diagnostics
     });
     if (!terminalEvidence.ok) {
       return buildLaunchBlockedOutcome(
@@ -14042,11 +14193,22 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
       writeDrainedRecord(options.repoRoot, prdRef, startReceipt, targetName);
       const drainRecord = readPrdRun(options.repoRoot, prdRef).record;
       if (drainRecord) {
+        const childFinalizationEvidence = await verifyPrdChildFinalizationEvidence({
+          repoRoot: options.repoRoot,
+          prdRef,
+          issueProvider,
+          processedResults: outcome.results.map((result2) => ({
+            issueNumber: result2.selected.number,
+            noOp: result2.runResult.noOp,
+            publicationStatus: result2.runResult.publicationStatus
+          }))
+        });
         const drainContext = {
           prdRef,
           baseBranch: startReceipt.startBaseBranch,
           prdBranch,
-          allChildIssuesFinalizedIntoPrdBranch: outcome.allProcessedIssuesFinalizedIntoPrdBranch === true
+          allChildIssuesFinalizedIntoPrdBranch: childFinalizationEvidence.ok,
+          childFinalizationDiagnostics: childFinalizationEvidence.diagnostics
         };
         const terminalEvidence = validatePrdRunTerminalEvidence(
           drainRecord,
@@ -14801,13 +14963,18 @@ async function launchBeadsQueueDrain(options, prdRef, startReceipt, targetName,
   writeDrainedRecord(options.repoRoot, prdRef, startReceipt, targetName);
   const drainRecord = readPrdRun(options.repoRoot, prdRef).record;
   if (drainRecord) {
+    const childFinalizationEvidence = await verifyPrdChildFinalizationEvidence({
+      repoRoot: options.repoRoot,
+      prdRef,
+      issueProvider,
+      processedResults
+    });
     const drainContext = {
       prdRef,
       baseBranch: startReceipt.startBaseBranch,
       prdBranch,
-      allChildIssuesFinalizedIntoPrdBranch: processedResults.length > 0 && processedResults.every(
-        (r) => r.noOp || r.publicationStatus === "merged"
-      )
+      allChildIssuesFinalizedIntoPrdBranch: childFinalizationEvidence.ok,
+      childFinalizationDiagnostics: childFinalizationEvidence.diagnostics
     };
     const terminalEvidence = validatePrdRunTerminalEvidence(
       drainRecord,
@@ -15764,12 +15931,12 @@ icm --db .pourkit/icm/memories.db topics                                # list a
 var MANAGED_BLOCK_BEGIN = "<!-- BEGIN POURKIT MANAGED BLOCK -->";
 var MANAGED_BLOCK_END = "<!-- END POURKIT MANAGED BLOCK -->";
 var MANAGED_BLOCK_PATTERN = new RegExp(
-  `${escapeRegExp3(MANAGED_BLOCK_BEGIN)}\\r?\\n[\\s\\S]*?${escapeRegExp3(
+  `${escapeRegExp4(MANAGED_BLOCK_BEGIN)}\\r?\\n[\\s\\S]*?${escapeRegExp4(
     MANAGED_BLOCK_END
   )}[ \\t]*(?:\\r?\\n)?`,
   "g"
 );
-function escapeRegExp3(value) {
+function escapeRegExp4(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function buildManagedBlock(content) {
@@ -15984,6 +16151,12 @@ function generateConfigTemplate(options) {
         promptTemplate: ".pourkit/managed/prompts/issue-final-review.prompt.md",
         maxAttempts: 3
       },
+      postCompletionFinalReview: {
+        agent: "pourkit-reviewer",
+        model: "openai/gpt-5.5",
+        variant: "max",
+        promptTemplate: ".pourkit/managed/prompts/post-completion-final-review.prompt.md"
+      },
       finalize: {
         prDescriptionAgent: {
           agent: "pourkit-pr-description",
@@ -16004,7 +16177,7 @@ function generateConfigTemplate(options) {
   };
   const config = {
     $schema: "./schema/pourkit.schema.json",
-    schemaVersion: 3,
+    schemaVersion: 4,
     targets: [target],
     workflowPack: {
       version: "1.0.0",
@@ -17947,13 +18120,13 @@ Init applied: ${result.applied} operations applied, ${result.skipped} skipped.`
 // commands/memory-init.ts
 import { existsSync as existsSync20, mkdirSync as mkdirSync8, readFileSync as readFileSync19, writeFileSync as writeFileSync5 } from "fs";
 import { execFile as execFile3 } from "child_process";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 import { promisify as promisify3 } from "util";
 var execFileAsync3 = promisify3(execFile3);
 async function runMemoryInitCommand(options) {
   const cwd = options.cwd ?? process.cwd();
   const execCommand = options.execCommand ?? execFileAsync3;
-  const configPath = join24(cwd, ".pourkit", "config.json");
+  const configPath = join25(cwd, ".pourkit", "config.json");
   if (!existsSync20(configPath)) {
     return {
       ok: false,
@@ -17985,8 +18158,8 @@ async function runMemoryInitCommand(options) {
     const next = { ...raw, memory };
     writeFileSync5(configPath, JSON.stringify(next, null, 2) + "\n");
   }
-  const memoryDir = join24(cwd, ".pourkit", "icm");
-  const memoryDbPath = join24(memoryDir, "memories.db");
+  const memoryDir = join25(cwd, ".pourkit", "icm");
+  const memoryDbPath = join25(memoryDir, "memories.db");
   mkdirSync8(memoryDir, { recursive: true });
   let dbInitialized = false;
   let warning;
@@ -18000,7 +18173,7 @@ async function runMemoryInitCommand(options) {
   } catch {
     warning = "ICM is not available or could not initialize .pourkit/icm/memories.db. Install ICM and run `pourkit doctor` to verify repo-scoped memory setup.";
   }
-  const gitignorePath = join24(cwd, ".gitignore");
+  const gitignorePath = join25(cwd, ".gitignore");
   updateManagedBlockSync(gitignorePath, generateGitignoreBlock());
   const managed = await generateManagedAgentInstructions({
     sourceRoot: cwd,
@@ -18008,14 +18181,14 @@ async function runMemoryInitCommand(options) {
   });
   let updatedAgentFile = false;
   for (const fileName of ["AGENTS.md", "CLAUDE.md"]) {
-    const agentPath = join24(cwd, fileName);
+    const agentPath = join25(cwd, fileName);
     if (existsSync20(agentPath)) {
       updateManagedBlockSync(agentPath, managed);
       updatedAgentFile = true;
     }
   }
   if (!updatedAgentFile) {
-    updateManagedBlockSync(join24(cwd, "AGENTS.md"), managed);
+    updateManagedBlockSync(join25(cwd, "AGENTS.md"), managed);
   }
   return {
     ok: true,
@@ -20287,7 +20460,7 @@ init_common();
 
 // execution/sandcastle-execution.ts
 import { existsSync as existsSync24, mkdirSync as mkdirSync9, statSync as statSync2, writeFileSync as writeFileSync6 } from "fs";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 import { createWorktree, opencode } from "@ai-hero/sandcastle";
 import { docker } from "@ai-hero/sandcastle/sandboxes/docker";
 
@@ -20296,10 +20469,10 @@ init_common();
 import { mkdtempSync } from "fs";
 import { writeFile as writeFile5 } from "fs/promises";
 import { tmpdir } from "os";
-import { dirname as dirname8, join as join25 } from "path";
+import { dirname as dirname8, join as join26 } from "path";
 async function writeExecutionArtifacts(worktreePath, artifacts) {
   for (const artifact of artifacts) {
-    const filePath = join25(worktreePath, artifact.path);
+    const filePath = join26(worktreePath, artifact.path);
     await ensureDir(dirname8(filePath));
     await writeFile5(filePath, artifact.content, "utf-8");
   }
@@ -20361,7 +20534,7 @@ async function createSandboxFromExistingWorktree(options) {
 }
 
 // execution/sandbox-options.ts
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 var POURKIT_ICM_CONTAINER_DIR = "/home/agent/.pourkit/icm";
 function buildSandboxOptions(repoRoot2, sandbox, memory) {
   const mounts = [];
@@ -20370,12 +20543,12 @@ function buildSandboxOptions(repoRoot2, sandbox, memory) {
   }
   if (memory?.available) {
     mounts.push({
-      hostPath: join26(repoRoot2, ".pourkit", "icm"),
+      hostPath: join27(repoRoot2, ".pourkit", "icm"),
       sandboxPath: POURKIT_ICM_CONTAINER_DIR,
       readonly: false
     });
     mounts.push({
-      hostPath: join26(repoRoot2, ".pourkit", "icm", "cache"),
+      hostPath: join27(repoRoot2, ".pourkit", "icm", "cache"),
       sandboxPath: "/home/agent/.cache/icm",
       readonly: false
     });
@@ -20509,13 +20682,13 @@ var SandcastleExecutionSession = class {
             "Memory enabled but memory context is invalid. Run `pourkit memory init` or install ICM for host planning use."
           );
         }
-        const hostMemoryDir = join27(repoRoot2, ".pourkit", "icm");
+        const hostMemoryDir = join28(repoRoot2, ".pourkit", "icm");
         if (!existsSync24(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(join27(hostMemoryDir, "cache"), { recursive: true });
+        mkdirSync9(join28(hostMemoryDir, "cache"), { recursive: true });
       }
       const sandboxOptions = buildSandboxOptions(
         repoRoot2,
@@ -20674,7 +20847,7 @@ function sanitizeBranch(branchName) {
 }
 function safeCopyToWorktreePaths(paths, repoRoot2, worktreePath) {
   return paths.filter((relativePath) => {
-    const source = join27(repoRoot2, relativePath);
+    const source = join28(repoRoot2, relativePath);
     if (!existsSync24(source)) {
       return true;
     }
@@ -20685,7 +20858,7 @@ function safeCopyToWorktreePaths(paths, repoRoot2, worktreePath) {
     } catch {
       return true;
     }
-    const destination = join27(worktreePath, relativePath);
+    const destination = join28(worktreePath, relativePath);
     return !existsSync24(destination);
   });
 }
@@ -20750,12 +20923,12 @@ function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function savePromptToFile(repoRoot2, stage, iteration, prompt) {
-  const promptsDir = join27(repoRoot2, ".pourkit", ".tmp", "prompts");
+  const promptsDir = join28(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 = join27(promptsDir, filename);
+  const filePath = join28(promptsDir, filename);
   writeFileSync6(filePath, prompt, "utf-8");
 }
 
@@ -21539,11 +21712,11 @@ function createCliProgram(version) {
   return program;
 }
 async function resolveCliVersion() {
-  if (isPackageVersion("0.0.0-next-20260714073403")) {
-    return "0.0.0-next-20260714073403";
+  if (isPackageVersion("0.0.0-next-20260715085442")) {
+    return "0.0.0-next-20260715085442";
   }
-  if (isReleaseVersion("0.0.0-next-20260714073403")) {
-    return "0.0.0-next-20260714073403";
+  if (isReleaseVersion("0.0.0-next-20260715085442")) {
+    return "0.0.0-next-20260715085442";
   }
   try {
     const root = repoRoot();