@pourkit/cli 0.0.0-next-20260620182746 → 0.0.0-next-20260621003351

package/dist/cli.js

@@ -58,20 +58,20 @@ function createLogger(name, filePath) {
       );
     },
     async close() {
-      await new Promise((resolve6) => {
+      await new Promise((resolve5) => {
         if (!fileStream) {
-          resolve6();
+          resolve5();
           return;
         }
         const timer = setTimeout(() => {
           if (!fileStream.destroyed) {
             fileStream.destroy();
           }
-          resolve6();
+          resolve5();
         }, 2e3);
         fileStream.end(() => {
           clearTimeout(timer);
-          resolve6();
+          resolve5();
         });
       });
     }
@@ -266,7 +266,7 @@ async function execJson(command, args, options = {}) {
   return JSON.parse(result.stdout);
 }
 function sleep(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 async function execCaptureWithRetry(command, args, options = {}) {
   const retries = options.retries ?? 3;
@@ -1136,7 +1136,7 @@ async function cleanupRepository(options) {
 // commands/artifact-validation.ts
 import { execSync } from "child_process";
 import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
-import { isAbsolute as isAbsolute3, resolve as resolve3 } from "path";
+import { isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
 
 // pr/review-verdict.ts
 var ReviewVerdictProtocolError = class extends Error {
@@ -1252,7 +1252,7 @@ function prepareArtifactPath(artifactPath) {
 
 // shared/run-context.ts
 import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync } from "fs";
-import { isAbsolute as isAbsolute2, join as join5, relative, resolve as resolve2 } from "path";
+import { join as join5, relative } from "path";
 
 // commands/run-verification.ts
 init_common();
@@ -1420,20 +1420,19 @@ function buildRunContextMarkdown(options) {
   } = options;
   const parts = ["# Pourkit Run Context", ""];
   if (sections.includes("issue")) {
+    const issueBody = stripIssueSections(issue.body, [
+      "Parent",
+      "Plan Documents"
+    ]);
     parts.push(
-      "## Issue",
-      "",
-      `- Number: #${issue.number}`,
-      `- Title: ${issue.title}`,
+      `## Issue #${issue.number}: ${issue.title}`,
       "",
-      "### Body",
-      "",
-      issue.body.trim() || "(empty issue body)",
+      issueBody.trim() || "(empty issue body)",
       ""
     );
   }
   if (sections.includes("prd")) {
-    parts.push(...renderPlanningContext(issue, parentPrdIssue, repoRoot2));
+    parts.push(...renderParentPrdContext(issue, parentPrdIssue, repoRoot2));
   }
   if (sections.includes("comments")) {
     parts.push("## Comments", "");
@@ -1504,98 +1503,63 @@ function renderCommandList(target, heading) {
   }
   return parts;
 }
-function renderPlanningContext(issue, parentPrdIssue, repoRoot2) {
+function renderParentPrdContext(issue, parentPrdIssue, repoRoot2) {
   const parent = extractIssueSection(issue.body, "Parent");
-  const documents = extractIssueSection(issue.body, "Plan Documents");
-  const parentRef = parent?.match(/\bPRD-\d+\b/i)?.[0]?.toUpperCase();
+  const parentRef = parent?.match(/\bPRD-\d+\b/i)?.[0]?.toUpperCase() ?? issue.title.match(/^\s*(PRD-\d+)\s*\/\s*I-\d+\b/i)?.[1]?.toUpperCase();
   const parentPlanWorkspace = parentRef && repoRoot2 ? findParentPlanWorkspace(repoRoot2, parentRef) : null;
   const parentPrdPath = parentPlanWorkspace?.prdPath ?? null;
-  const discoveredPlanPath = parentPlanWorkspace?.planPath ?? null;
-  const documentPaths = repoRoot2 ? extractRepoPaths(documents) : [];
-  const planDocumentPaths = new Set(documentPaths);
-  if (discoveredPlanPath && repoRoot2) {
-    planDocumentPaths.add(relative(repoRoot2, discoveredPlanPath));
-  }
-  if (!parent && !documents && planDocumentPaths.size === 0) {
+  if (!parent && !parentPrdPath && !parentPrdIssue && !parentRef) {
     return [];
   }
-  const parts = ["## Planning Context", ""];
+  const parts = ["---", "", "## Parent PRD", ""];
   if (parent) {
-    parts.push("### Parent", "");
-    parts.push(parent, "");
-  } else {
-    parts.push("### Parent", "");
-    parts.push("(not declared in issue body)", "");
+    parts.push(...parent.split("\n").map((line) => `- ${line}`));
+  } else if (parentRef) {
+    parts.push(`- Parent: ${parentRef}`);
   }
   if (parentPrdPath && repoRoot2) {
     parts.push(
-      `### Parent PRD Content: \`${relative(repoRoot2, parentPrdPath)}\``,
+      `- Source: \`${relative(repoRoot2, parentPrdPath)}\``,
       "",
-      "```markdown",
       readFileSync4(parentPrdPath, "utf-8").trimEnd(),
-      "```",
       ""
     );
   } else if (parentPrdIssue) {
     parts.push(
-      `### Parent PRD Content: #${parentPrdIssue.number} ${parentPrdIssue.title}`,
+      `- Source: #${parentPrdIssue.number} ${parentPrdIssue.title}`,
       "",
-      "```markdown",
       parentPrdIssue.body.trimEnd() || "(empty PRD body)",
-      "```",
-      ""
-    );
-  }
-  parts.push("### Plan Documents", "");
-  if (documents) {
-    parts.push(documents, "");
-  } else if (planDocumentPaths.size > 0) {
-    parts.push(
-      ...Array.from(planDocumentPaths).map(
-        (documentPath) => `- \`${documentPath}\``
-      ),
-      ""
-    );
-  } else {
-    parts.push("(not declared in issue body)", "");
-  }
-  for (const documentPath of planDocumentPaths) {
-    const absolutePath = resolveRepoPath(repoRoot2, documentPath);
-    if (!absolutePath || !existsSync4(absolutePath)) continue;
-    parts.push(
-      `### Document Content: \`${documentPath}\``,
-      "",
-      "```markdown",
-      readFileSync4(absolutePath, "utf-8").trimEnd(),
-      "```",
       ""
     );
+  } else if (parent || parentRef) {
+    parts.push("", "(parent PRD body unavailable)", "");
   }
   return parts;
 }
 function extractIssueSection(body, heading) {
   const escapedHeading = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const section = body.match(
-    new RegExp(`^## ${escapedHeading}\\s*\\n([\\s\\S]*?)(?=\\n## |$)`, "im")
+    new RegExp(
+      `(?:^|\\n)## ${escapedHeading}\\s*\\n([\\s\\S]*?)(?=\\n## |$)`,
+      "i"
+    )
   )?.[1];
   const trimmed = section?.trim();
   return trimmed ? trimmed : null;
 }
-function extractRepoPaths(section) {
-  if (!section) return [];
-  const paths = /* @__PURE__ */ new Set();
-  for (const match of section.matchAll(/`([^`]+)`/g)) {
-    const value = match[1]?.trim();
-    if (value) paths.add(value);
+function stripIssueSections(body, headings) {
+  let stripped = body;
+  for (const heading of headings) {
+    const escapedHeading = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    stripped = stripped.replace(
+      new RegExp(
+        `(?:^|\\n)## ${escapedHeading}\\s*\\n[\\s\\S]*?(?=\\n## |$)`,
+        "gi"
+      ),
+      ""
+    );
   }
-  return Array.from(paths);
-}
-function resolveRepoPath(repoRoot2, path9) {
-  if (isAbsolute2(path9) || path9.includes("\0")) return null;
-  const resolved = resolve2(repoRoot2, path9);
-  const repoRelative2 = relative(repoRoot2, resolved);
-  if (repoRelative2.startsWith("..") || isAbsolute2(repoRelative2)) return null;
-  return resolved;
+  return stripped.trim();
 }
 function findParentPlanWorkspace(repoRoot2, parentRef) {
   const plansRoot = join5(repoRoot2, ".pourkit", "plans");
@@ -1609,11 +1573,9 @@ function findPlanWorkspaceInPlans(directory, parentRef) {
       const prdNumber = parentRef.match(/^PRD-(\d+)$/)?.[1];
       if (entry.name.startsWith(parentRef) || prdNumber && entry.name.startsWith(`${prdNumber}-`)) {
         const prdPath = join5(entryPath, "PRD.md");
-        const planPath = join5(entryPath, "PLAN.md");
-        if (existsSync4(prdPath) || existsSync4(planPath)) {
+        if (existsSync4(prdPath)) {
           return {
-            prdPath: existsSync4(prdPath) ? prdPath : null,
-            planPath: existsSync4(planPath) ? planPath : null
+            prdPath
           };
         }
       }
@@ -3244,7 +3206,7 @@ function validateRepoRelativePathField(pathValue, fieldName) {
   }
   const normalized = pathValue.replace(/\\/g, "/");
   const segments = normalized.split("/");
-  if (normalized.trim() === "" || normalized === "." || normalized === ".." || isAbsolute3(pathValue) || normalized.startsWith("/") || segments.some((segment) => segment === "..")) {
+  if (normalized.trim() === "" || normalized === "." || normalized === ".." || isAbsolute2(pathValue) || normalized.startsWith("/") || segments.some((segment) => segment === "..")) {
     return {
       ok: false,
       reason: `${fieldName} must not contain absolute paths or path traversal: ${pathValue}`
@@ -3597,7 +3559,7 @@ function validateAgentArtifact(options) {
         if (options.checkConflictMarkers !== false && parsed.status === "resolved") {
           const base = options.worktreePath ?? process.cwd();
           const filesWithMarkers = parsed.files.filter((file) => {
-            const filePath = resolve3(base, file);
+            const filePath = resolve2(base, file);
             try {
               return CONFLICT_MARKER_PATTERN.test(
                 readFileSync7(filePath, "utf-8")
@@ -3664,8 +3626,8 @@ function validateAgentArtifact(options) {
   }
 }
 function runValidateArtifactCommand(options) {
-  const artifactPath = resolve3(options.repoRoot, options.artifactPath);
-  const latestReviewArtifactPath = options.latestReviewArtifactPath ? resolve3(options.repoRoot, options.latestReviewArtifactPath) : void 0;
+  const artifactPath = resolve2(options.repoRoot, options.artifactPath);
+  const latestReviewArtifactPath = options.latestReviewArtifactPath ? resolve2(options.repoRoot, options.latestReviewArtifactPath) : void 0;
   return validateAgentArtifact({
     ...options,
     artifactPath,
@@ -3711,7 +3673,7 @@ function shellQuote(value) {
 
 // commands/issue-run.ts
 import { existsSync as existsSync12, readFileSync as readFileSync14 } from "fs";
-import { isAbsolute as isAbsolute5, join as join14 } from "path";
+import { isAbsolute as isAbsolute4, join as join14 } from "path";
 
 // pr/templates.ts
 init_common();
@@ -4266,7 +4228,7 @@ async function canReachMcp(url) {
       return true;
     } catch {
       if (attempt < 9) {
-        await new Promise((resolve6) => setTimeout(resolve6, 100));
+        await new Promise((resolve5) => setTimeout(resolve5, 100));
       }
     }
   }
@@ -4959,7 +4921,7 @@ function extractClosingRefs(body) {
 // issues/github-issue-publication.ts
 init_common();
 import { existsSync as existsSync10, readFileSync as readFileSync12 } from "fs";
-import { isAbsolute as isAbsolute4, join as join12 } from "path";
+import { isAbsolute as isAbsolute3, join as join12 } from "path";
 
 // issues/issue-transitions.ts
 function createIssueTransitions(deps, labels) {
@@ -5434,7 +5396,7 @@ function readIssueFinalReviewArtifact(worktreeState, worktreePath) {
   if (!configuredPath) {
     return null;
   }
-  const artifactPath = isAbsolute4(configuredPath) ? configuredPath : join12(worktreePath, configuredPath);
+  const artifactPath = isAbsolute3(configuredPath) ? configuredPath : join12(worktreePath, configuredPath);
   if (!existsSync10(artifactPath)) return null;
   let parsed;
   try {
@@ -5929,7 +5891,7 @@ async function advanceIssueFinalReview(options) {
         "Issue Final Review state is incomplete: missing artifactPath"
       );
     }
-    const artifactPath = isAbsolute5(ifrFromState.artifactPath) ? ifrFromState.artifactPath : join14(worktreePath, ifrFromState.artifactPath);
+    const artifactPath = isAbsolute4(ifrFromState.artifactPath) ? ifrFromState.artifactPath : join14(worktreePath, ifrFromState.artifactPath);
     const validation = validateAgentArtifact({
       kind: "issue-final-review",
       artifactPath,
@@ -7075,157 +7037,171 @@ async function handlePublishedHistoryRisk(failure, context) {
   throw new Error(message);
 }
 
-// commands/issue.ts
-var HumanHandoffStop = class extends Error {
+// issues/issue-run-lifecycle.ts
+var IssueRunHumanHandoffStop = class extends Error {
   constructor(message) {
     super(message);
     this.name = "HumanHandoffStop";
   }
 };
-async function runIssueCommand(options) {
-  const {
-    issueNumber,
-    config,
-    issueProvider,
-    prProvider,
-    executionProvider,
-    logger
-  } = options;
-  const ROOT = options.repoRoot;
-  let executionSession;
+async function runIssueLifecycle(options) {
   try {
-    executionSession = await executionProvider.createSession?.();
-    const runOptions = executionSession ? { ...options, executionProvider: executionSession } : options;
-    const startResult = await startIssueRun(runOptions);
-    const {
-      issue,
-      parentPrdIssue,
-      target,
-      effectiveTarget,
-      branchName,
-      worktreeState,
-      executionResult
-    } = startResult;
+    const startResult = await options.deps.startIssueRun(options.runOptions);
+    const reviewAlreadyPassed = startResult.worktreeState?.review.lastVerdict && !startResult.worktreeState.review.exhaustedPreviousRun && (startResult.worktreeState.review.lastVerdict === "PASS" || startResult.worktreeState.review.lastVerdict === "PASS_WITH_NOTES");
     let reviewArtifactPath;
-    const reviewAlreadyPassed = worktreeState?.review.lastVerdict && ["PASS", "PASS_WITH_NOTES"].includes(worktreeState.review.lastVerdict) && !worktreeState.review.exhaustedPreviousRun;
     if (reviewAlreadyPassed) {
-      reviewArtifactPath = worktreeState.review.lastArtifactPath;
+      reviewArtifactPath = startResult.worktreeState.review.lastArtifactPath;
     } else {
-      const lifetimeIterationsFromState = worktreeState?.review.lifetimeIterations ?? 0;
-      const humanHandoffResolved = worktreeState?.review.lastVerdict === "NEEDS_HUMAN";
-      const reviewResult = await advanceIssueRunReview({
-        executionProvider: runOptions.executionProvider,
-        config,
-        target: effectiveTarget,
-        issue,
-        parentPrdIssue,
-        builderBranch: branchName,
-        worktreePath: executionResult.worktreePath,
-        repoRoot: ROOT,
-        logger,
-        startingLifetimeIteration: lifetimeIterationsFromState,
-        humanHandoffResolved,
+      const reviewResult = await options.deps.advanceIssueRunReview({
+        executionProvider: options.runOptions.executionProvider,
+        config: options.config,
+        target: startResult.effectiveTarget,
+        issue: startResult.issue,
+        parentPrdIssue: startResult.parentPrdIssue,
+        builderBranch: startResult.branchName,
+        worktreePath: startResult.executionResult.worktreePath,
+        repoRoot: options.repoRoot,
+        logger: options.logger,
+        startingLifetimeIteration: startResult.worktreeState?.review.lifetimeIterations ?? 0,
+        humanHandoffResolved: startResult.worktreeState?.review.lastVerdict === "NEEDS_HUMAN",
         serena: startResult.serena,
         memory: startResult.memory
       });
       if (reviewResult.exhaustedMaxIterations) {
         throw new Error(
-          `Max review iterations (${reviewResult.iterations}) exhausted`
+          "Review loop exhausted maximum iterations without passing"
         );
       }
       if (reviewResult.verdict === "FAIL") {
-        throw new Error(`Review failed with FAIL verdict`);
+        const summary = reviewResult.output?.trim() || "no summary provided";
+        throw new Error(`Review loop failed: ${summary}`);
       }
       if (reviewResult.verdict === "NEEDS_HUMAN") {
-        await transitionIssueToHumanHandoff({
-          issueProvider,
-          issueNumber,
-          config,
-          logger,
+        await options.deps.transitionReviewNeedsHumanToHandoff({
+          issueProvider: options.issueProvider,
+          issueNumber: options.issueNumber,
+          config: options.config,
+          logger: options.logger,
           reviewResult
         });
-        throw new HumanHandoffStop(
-          `Review requires human handoff: NEEDS_HUMAN verdict`
+        throw new IssueRunHumanHandoffStop(
+          "Review requires human handoff: NEEDS_HUMAN verdict"
         );
       }
       reviewArtifactPath = reviewResult.artifactPath;
     }
-    const finalReviewResult = await advanceIssueFinalReview({
-      executionProvider: runOptions.executionProvider,
-      config,
-      target: effectiveTarget,
-      issue,
-      parentPrdIssue,
-      builderBranch: branchName,
-      worktreePath: executionResult.worktreePath,
-      repoRoot: ROOT,
-      logger,
+    const finalReviewResult = await options.deps.advanceIssueFinalReview({
+      executionProvider: options.runOptions.executionProvider,
+      config: options.config,
+      target: startResult.effectiveTarget,
+      issue: startResult.issue,
+      parentPrdIssue: startResult.parentPrdIssue,
+      builderBranch: startResult.branchName,
+      worktreePath: startResult.executionResult.worktreePath,
+      repoRoot: options.repoRoot,
+      logger: options.logger,
       reviewArtifactPath,
-      worktreeState,
+      worktreeState: startResult.worktreeState,
       memory: startResult.memory
     });
     if (finalReviewResult.verdict === "needs_human_review") {
-      const transitions = createIssueTransitions(
-        {
-          fetchIssue: issueProvider.fetchIssue.bind(issueProvider),
-          addLabels: issueProvider.addLabels.bind(issueProvider),
-          removeLabel: issueProvider.removeLabel.bind(issueProvider),
-          closeIssue: issueProvider.closeIssue.bind(issueProvider)
-        },
-        {
-          blocked: config.labels.blocked,
-          readyForAgent: config.labels.readyForAgent,
-          needsTriage: config.labels.needsTriage,
-          agentInProgress: config.labels.agentInProgress,
-          readyForHuman: config.labels.readyForHuman,
-          prOpenAwaitingMerge: config.labels.prOpenAwaitingMerge
-        }
-      );
-      await transitions.moveToReadyForHuman(issueNumber);
-      const comment = [
-        "Pourkit stopped the Issue Final Review because human review is needed.",
-        "",
-        finalReviewResult.needsHumanReason,
-        "",
-        "Artifacts:",
-        `- Issue Final Review: ${finalReviewResult.artifactPath}`
-      ].join("\n");
-      await issueProvider.commentIssue(issueNumber, comment);
-      logger.step(
-        "info",
-        `Issue Final Review requires human handoff for issue ${issueNumber}`
-      );
-      throw new HumanHandoffStop(
+      await options.deps.transitionIssueFinalReviewNeedsHumanToHandoff({
+        issueNumber: options.issueNumber,
+        finalReviewResult
+      });
+      throw new IssueRunHumanHandoffStop(
         `Issue Final Review requires human handoff: ${finalReviewResult.needsHumanReason}`
       );
     }
-    return await completeIssueRun({
-      ...runOptions,
+    return await options.deps.completeIssueRun({
+      ...options.runOptions,
       startResult,
       reviewArtifactPath
     });
   } catch (error) {
-    if (error instanceof HumanHandoffStop) {
+    if (error instanceof IssueRunHumanHandoffStop) {
       throw error;
     }
     if (error instanceof Error && "_tag" in error) {
-      await failIssueRun({
-        issueProvider,
-        issueNumber,
-        config,
-        logger,
+      await options.deps.failIssueRun({
+        issueProvider: options.issueProvider,
+        issueNumber: options.issueNumber,
+        config: options.config,
+        logger: options.logger,
         error: `[${error._tag}] ${error.message}`
       });
     } else {
-      await failIssueRun({
-        issueProvider,
-        issueNumber,
-        config,
-        logger,
+      await options.deps.failIssueRun({
+        issueProvider: options.issueProvider,
+        issueNumber: options.issueNumber,
+        config: options.config,
+        logger: options.logger,
         error: error instanceof Error ? error : String(error)
       });
     }
     throw error;
+  }
+}
+
+// commands/issue.ts
+async function runIssueCommand(options) {
+  const { issueNumber, config, issueProvider, executionProvider, logger } = options;
+  const ROOT = options.repoRoot;
+  let executionSession;
+  try {
+    executionSession = await executionProvider.createSession?.();
+    const runOptions = executionSession ? { ...options, executionProvider: executionSession } : options;
+    return await runIssueLifecycle({
+      issueNumber,
+      config,
+      issueProvider,
+      logger,
+      repoRoot: ROOT,
+      runOptions,
+      deps: {
+        startIssueRun,
+        advanceIssueRunReview,
+        advanceIssueFinalReview,
+        completeIssueRun,
+        failIssueRun,
+        transitionReviewNeedsHumanToHandoff: transitionIssueToHumanHandoff,
+        transitionIssueFinalReviewNeedsHumanToHandoff: async ({
+          issueNumber: issueNumber2,
+          finalReviewResult
+        }) => {
+          const transitions = createIssueTransitions(
+            {
+              fetchIssue: issueProvider.fetchIssue.bind(issueProvider),
+              addLabels: issueProvider.addLabels.bind(issueProvider),
+              removeLabel: issueProvider.removeLabel.bind(issueProvider),
+              closeIssue: issueProvider.closeIssue.bind(issueProvider)
+            },
+            {
+              blocked: config.labels.blocked,
+              readyForAgent: config.labels.readyForAgent,
+              needsTriage: config.labels.needsTriage,
+              agentInProgress: config.labels.agentInProgress,
+              readyForHuman: config.labels.readyForHuman,
+              prOpenAwaitingMerge: config.labels.prOpenAwaitingMerge
+            }
+          );
+          await transitions.moveToReadyForHuman(issueNumber2);
+          const comment = [
+            "Pourkit stopped the Issue Final Review because human review is needed.",
+            "",
+            finalReviewResult.needsHumanReason,
+            "",
+            "Artifacts:",
+            `- Issue Final Review: ${finalReviewResult.artifactPath}`
+          ].join("\n");
+          await issueProvider.commentIssue(issueNumber2, comment);
+          logger.step(
+            "info",
+            `Issue Final Review requires human handoff for issue ${issueNumber2}`
+          );
+        }
+      }
+    });
   } finally {
     await executionSession?.close();
   }
@@ -9866,7 +9842,6 @@ var BASELINE_MANAGED_SKILLS = [
   "ship-current-changes",
   "tdd",
   "to-issues",
-  "to-plan",
   "to-prd",
   "triage",
   "write-a-skill",
@@ -10086,7 +10061,6 @@ var BASELINE_SKILL_NAMES = [
   "ship-current-changes",
   "tdd",
   "to-issues",
-  "to-plan",
   "to-prd",
   "triage",
   "write-a-skill",
@@ -12445,7 +12419,7 @@ async function runSerenaStatusCommand(options) {
 // commands/config-schema.ts
 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 { resolve as resolve3, dirname as dirname5, relative as relative2 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import Ajv2 from "ajv";
 init_common();
@@ -12453,8 +12427,8 @@ var __filename3 = fileURLToPath3(import.meta.url);
 var __dirname3 = dirname5(__filename3);
 function resolvePackagedAssetPath2(fileName) {
   const candidates = [
-    resolve4(__dirname3, "schema", fileName),
-    resolve4(__dirname3, "../schema", fileName)
+    resolve3(__dirname3, "schema", fileName),
+    resolve3(__dirname3, "../schema", fileName)
   ];
   return candidates.find((candidate) => existsSync17(candidate)) ?? candidates[0];
 }
@@ -12481,12 +12455,12 @@ function readPackagedHash() {
   return readFileSync18(PACKAGED_HASH_PATH, "utf-8");
 }
 function localSchemaDir(repoRoot2) {
-  return resolve4(repoRoot2, ".pourkit/schema");
+  return resolve3(repoRoot2, ".pourkit/schema");
 }
 var MANAGED_BLOCK_BEGIN2 = "<!-- BEGIN POURKIT MANAGED BLOCK -->\n";
 var OLD_DOCS_PATH_PATTERN = ".pourkit/docs/agents/";
 function resolvePackagedManagedPath(...segments) {
-  return resolve4(__dirname3, "..", "managed", ...segments);
+  return resolve3(__dirname3, "..", "managed", ...segments);
 }
 function resolvePackagedManagedDocPath(docName) {
   return resolvePackagedManagedPath("docs", "agents", docName);
@@ -12516,7 +12490,7 @@ async function walkDir2(dir) {
   try {
     const entries = await readdir2(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = resolve4(dir, entry.name);
+      const full = resolve3(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...await walkDir2(full));
       } else {
@@ -12598,7 +12572,7 @@ async function validateWorkflowPack(cwd) {
   const catalog = getWorkflowPackCatalog();
   const baselineSkills = getBaselineManagedSkillNames();
   for (const docName of catalog.docs) {
-    const localPath = resolve4(cwd, `.pourkit/managed/docs/agents/${docName}`);
+    const localPath = resolve3(cwd, `.pourkit/managed/docs/agents/${docName}`);
     if (!existsSync17(localPath)) {
       failures.push({
         severity: "failure",
@@ -12613,7 +12587,7 @@ async function validateWorkflowPack(cwd) {
         try {
           const localContent = await readFile5(localPath, "utf-8");
           if (localContent !== packagedContent) {
-            const overridePath = resolve4(
+            const overridePath = resolve3(
               cwd,
               `.pourkit/overrides/docs/agents/${docName}`
             );
@@ -12639,7 +12613,7 @@ async function validateWorkflowPack(cwd) {
     }
   }
   for (const skillName of baselineSkills) {
-    const skillDir = resolve4(cwd, `.pourkit/managed/skills/${skillName}`);
+    const skillDir = resolve3(cwd, `.pourkit/managed/skills/${skillName}`);
     if (!existsSync17(skillDir)) {
       failures.push({
         severity: "failure",
@@ -12648,7 +12622,7 @@ async function validateWorkflowPack(cwd) {
         message: `Missing managed skill: ${skillName}`
       });
     } else {
-      const skillSourcePath = resolve4(skillDir, "SKILL.md");
+      const skillSourcePath = resolve3(skillDir, "SKILL.md");
       if (existsSync17(skillSourcePath)) {
         const packagedSkillPath = resolvePackagedManagedPath(
           "skills",
@@ -12660,7 +12634,7 @@ async function validateWorkflowPack(cwd) {
           try {
             const localContent = await readFile5(skillSourcePath, "utf-8");
             if (localContent !== packagedContent) {
-              const overridePath = resolve4(
+              const overridePath = resolve3(
                 cwd,
                 `.pourkit/overrides/skills/${skillName}/SKILL.md`
               );
@@ -12687,7 +12661,7 @@ async function validateWorkflowPack(cwd) {
     }
   }
   for (const promptName of catalog.prompts) {
-    const promptPath = resolve4(cwd, `.pourkit/managed/prompts/${promptName}`);
+    const promptPath = resolve3(cwd, `.pourkit/managed/prompts/${promptName}`);
     if (!existsSync17(promptPath)) {
       failures.push({
         severity: "failure",
@@ -12698,7 +12672,7 @@ async function validateWorkflowPack(cwd) {
     }
   }
   for (const skillName of baselineSkills) {
-    const projectionDir = resolve4(cwd, `.agents/skills/${skillName}`);
+    const projectionDir = resolve3(cwd, `.agents/skills/${skillName}`);
     if (!existsSync17(projectionDir)) {
       warnings.push({
         severity: "warning",
@@ -12707,7 +12681,7 @@ async function validateWorkflowPack(cwd) {
         message: `Missing skill projection for ${skillName}. Run 'pourkit sync workflow-pack' to regenerate.`
       });
     } else {
-      const projectionPath = resolve4(projectionDir, "SKILL.md");
+      const projectionPath = resolve3(projectionDir, "SKILL.md");
       if (existsSync17(projectionPath)) {
         const managedSourcePath = resolvePackagedManagedPath(
           "skills",
@@ -12736,7 +12710,7 @@ async function validateWorkflowPack(cwd) {
       }
     }
   }
-  const agentsPath = resolve4(cwd, "AGENTS.md");
+  const agentsPath = resolve3(cwd, "AGENTS.md");
   if (existsSync17(agentsPath)) {
     try {
       const agentsContent = await readFile5(agentsPath, "utf-8");
@@ -12759,7 +12733,7 @@ async function validateWorkflowPack(cwd) {
     } catch {
     }
   }
-  const overridesDir = resolve4(cwd, ".pourkit/overrides");
+  const overridesDir = resolve3(cwd, ".pourkit/overrides");
   if (existsSync17(overridesDir)) {
     const overrideFiles = await walkDir2(overridesDir);
     for (const file of overrideFiles) {
@@ -12774,7 +12748,7 @@ async function validateWorkflowPack(cwd) {
       }
     }
   }
-  const configPath = resolve4(cwd, ".pourkit/config.json");
+  const configPath = resolve3(cwd, ".pourkit/config.json");
   if (existsSync17(configPath)) {
     try {
       const configContent = await readFile5(configPath, "utf-8");
@@ -12782,7 +12756,7 @@ async function validateWorkflowPack(cwd) {
       const releaseEnabled = parsed.releaseWorkflow?.enabled === true;
       if (releaseEnabled) {
         for (const skillName of catalog.releaseAddonSkills) {
-          const addonDir = resolve4(
+          const addonDir = resolve3(
             cwd,
             `.pourkit/managed/addons/release/skills/${skillName}`
           );
@@ -12796,7 +12770,7 @@ async function validateWorkflowPack(cwd) {
           }
         }
         for (const docName of catalog.releaseAddonDocs) {
-          const addonDocPath = resolve4(
+          const addonDocPath = resolve3(
             cwd,
             `.pourkit/managed/addons/release/docs/agents/${docName}`
           );
@@ -12841,7 +12815,7 @@ async function validateWorkflowPack(cwd) {
         }
       } else {
         for (const skillName of catalog.releaseAddonSkills) {
-          const addonDir = resolve4(
+          const addonDir = resolve3(
             cwd,
             `.pourkit/managed/addons/release/skills/${skillName}`
           );
@@ -12855,7 +12829,7 @@ async function validateWorkflowPack(cwd) {
           }
         }
         for (const docName of catalog.releaseAddonDocs) {
-          const addonDocPath = resolve4(
+          const addonDocPath = resolve3(
             cwd,
             `.pourkit/managed/addons/release/docs/agents/${docName}`
           );
@@ -12872,7 +12846,7 @@ async function validateWorkflowPack(cwd) {
     } catch {
     }
   }
-  const manifestPath = resolve4(cwd, ".pourkit/manifest.json");
+  const manifestPath = resolve3(cwd, ".pourkit/manifest.json");
   if (existsSync17(manifestPath)) {
     try {
       const manifestContent = await readFile5(manifestPath, "utf-8");
@@ -12881,7 +12855,7 @@ async function validateWorkflowPack(cwd) {
       if (wp?.projections) {
         for (const proj of wp.projections) {
           if (proj.path) {
-            const resolved = resolve4(cwd, proj.path);
+            const resolved = resolve3(cwd, proj.path);
             if (!isPathContained(cwd, resolved)) {
               failures.push({
                 severity: "failure",
@@ -12895,7 +12869,7 @@ async function validateWorkflowPack(cwd) {
     } catch {
     }
   }
-  const pathEscapeOverrideDir = resolve4(cwd, ".pourkit/overrides");
+  const pathEscapeOverrideDir = resolve3(cwd, ".pourkit/overrides");
   if (existsSync17(pathEscapeOverrideDir)) {
     const overrideFiles = await walkDir2(pathEscapeOverrideDir);
     for (const file of overrideFiles) {
@@ -12909,7 +12883,7 @@ async function validateWorkflowPack(cwd) {
       }
     }
   }
-  const managedDocsDir = resolve4(cwd, ".pourkit/managed/docs/agents");
+  const managedDocsDir = resolve3(cwd, ".pourkit/managed/docs/agents");
   if (existsSync17(managedDocsDir)) {
     const docFiles = await walkDir2(managedDocsDir);
     for (const file of docFiles) {
@@ -12930,12 +12904,12 @@ async function validateWorkflowPack(cwd) {
       }
     }
   }
-  const managedSkillsDir = resolve4(cwd, ".pourkit/managed/skills");
+  const managedSkillsDir = resolve3(cwd, ".pourkit/managed/skills");
   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");
+      const skillFile = resolve3(managedSkillsDir, entry.name, "SKILL.md");
       if (!existsSync17(skillFile)) continue;
       try {
         const content = await readFile5(skillFile, "utf-8");
@@ -12953,10 +12927,10 @@ async function validateWorkflowPack(cwd) {
       }
     }
   }
-  const managedPromptsDir = resolve4(cwd, ".pourkit/managed/prompts");
+  const managedPromptsDir = resolve3(cwd, ".pourkit/managed/prompts");
   if (existsSync17(managedPromptsDir)) {
     for (const promptName of catalog.prompts) {
-      const promptFile = resolve4(managedPromptsDir, promptName);
+      const promptFile = resolve3(managedPromptsDir, promptName);
       if (!existsSync17(promptFile)) continue;
       try {
         const content = await readFile5(promptFile, "utf-8");
@@ -12975,7 +12949,7 @@ async function validateWorkflowPack(cwd) {
     }
   }
   for (const skillName of catalog.releaseAddonSkills) {
-    const addonSkillFile = resolve4(
+    const addonSkillFile = resolve3(
       cwd,
       `.pourkit/managed/addons/release/skills/${skillName}/SKILL.md`
     );
@@ -12996,7 +12970,7 @@ async function validateWorkflowPack(cwd) {
     }
   }
   for (const docName of catalog.releaseAddonDocs) {
-    const addonDocFile = resolve4(
+    const addonDocFile = resolve3(
       cwd,
       `.pourkit/managed/addons/release/docs/agents/${docName}`
     );
@@ -13033,7 +13007,7 @@ async function validateMemoryHealth(cwd, memoryConfig) {
     ok: icmPath !== null,
     detail: icmPath !== null ? icmPath : "icm not found on PATH"
   });
-  const gitignorePath = resolve4(cwd, ".gitignore");
+  const gitignorePath = resolve3(cwd, ".gitignore");
   const gitignoreContent = existsSync17(gitignorePath) ? readFileSync18(gitignorePath, "utf-8") : "";
   const hasGitignoreEntry = gitignoreContent.includes(".pourkit/icm/");
   checks.push({
@@ -13059,8 +13033,8 @@ async function validateMemoryHealth(cwd, memoryConfig) {
 async function runDoctorCommand(options) {
   const repoRootPath = options.cwd ?? process.cwd();
   const schemaDir = localSchemaDir(repoRootPath);
-  const localSchemaPath = resolve4(schemaDir, "pourkit.schema.json");
-  const localHashPath = resolve4(schemaDir, "pourkit.schema.hash");
+  const localSchemaPath = resolve3(schemaDir, "pourkit.schema.json");
+  const localHashPath = resolve3(schemaDir, "pourkit.schema.hash");
   const localSchemaExists = existsSync17(localSchemaPath);
   const localHashExists = existsSync17(localHashPath);
   let packagedHash = null;
@@ -13078,7 +13052,7 @@ async function runDoctorCommand(options) {
   const schema = !localSchemaExists ? "missing" : !packagedHash || !localHashContent ? "missing" : localHashContent.trim() === packagedHash.trim() ? "fresh" : "stale";
   const hash = !localHashExists ? "missing" : !packagedHash ? "missing" : localHashContent && localHashContent.trim() === packagedHash.trim() ? "fresh" : "stale";
   const overall = schema === "fresh" && hash === "fresh" ? "fresh" : schema === "missing" || hash === "missing" ? "missing" : "stale";
-  const configPath = resolve4(repoRootPath, ".pourkit/config.json");
+  const configPath = resolve3(repoRootPath, ".pourkit/config.json");
   let configValidation;
   let rawMemoryConfig;
   if (existsSync17(configPath)) {
@@ -13116,7 +13090,7 @@ async function runDoctorCommand(options) {
     "pourkit.config.mjs",
     "pourkit.config.js",
     "pourkit.json"
-  ].filter((p) => existsSync17(resolve4(repoRootPath, p)));
+  ].filter((p) => existsSync17(resolve3(repoRootPath, p)));
   const workflowPack = await validateWorkflowPack(repoRootPath);
   const memory = await validateMemoryHealth(repoRootPath, rawMemoryConfig);
   let recommendation = null;
@@ -13162,8 +13136,8 @@ async function runConfigSyncSchemaCommand(options) {
   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");
+  const localSchemaPath = resolve3(schemaDir, "pourkit.schema.json");
+  const localHashPath = resolve3(schemaDir, "pourkit.schema.hash");
   let schemaWritten = false;
   let hashWritten = false;
   if (existsSync17(localSchemaPath)) {
@@ -13196,7 +13170,7 @@ async function runConfigSyncSchemaCommand(options) {
 // commands/workflow-pack-sync.ts
 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 { resolve as resolve4, dirname as dirname6, relative as relative3, normalize as normalize2 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var __filename4 = fileURLToPath4(import.meta.url);
 var __dirname4 = dirname6(__filename4);
@@ -13210,7 +13184,7 @@ var OVERRIDES_DIR = ".pourkit/overrides";
 var MANAGED_BLOCK_BEGIN3 = "<!-- BEGIN POURKIT MANAGED BLOCK -->\n";
 var MANAGED_BLOCK_END2 = "\n<!-- END POURKIT MANAGED BLOCK -->";
 function resolvePackagedManagedPath2(...segments) {
-  const candidates = [resolve5(__dirname4, "..", "managed", ...segments)];
+  const candidates = [resolve4(__dirname4, "..", "managed", ...segments)];
   return candidates[0];
 }
 function resolvePackagedManagedDocPath2(docName) {
@@ -13292,7 +13266,7 @@ async function walkDir3(dir) {
   try {
     const entries = await readdir3(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = resolve5(dir, entry.name);
+      const full = resolve4(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...await walkDir3(full));
       } else {
@@ -13310,13 +13284,13 @@ async function syncFile(cwd, targetRelativePath, sourceContent, errors) {
   if (sourceContent === null) {
     return false;
   }
-  const targetPath = resolve5(cwd, targetRelativePath);
+  const targetPath = resolve4(cwd, targetRelativePath);
   const escapeError = checkForPathEscape(cwd, targetPath);
   if (escapeError) {
     errors.push(escapeError);
     return false;
   }
-  await mkdir6(resolve5(targetPath, ".."), { recursive: true });
+  await mkdir6(resolve4(targetPath, ".."), { recursive: true });
   if (existsSync18(targetPath)) {
     const existing = await readFile6(targetPath, "utf-8");
     if (existing === sourceContent) {
@@ -13331,7 +13305,7 @@ function walkDirSync(dir) {
   try {
     const entries = readdirSync4(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = resolve5(dir, entry.name);
+      const full = resolve4(dir, entry.name);
       if (entry.isDirectory()) {
         result.push(...walkDirSync(full));
       } else {
@@ -13343,7 +13317,7 @@ function walkDirSync(dir) {
   return result;
 }
 async function detectOverrides(cwd) {
-  const overridesDir = resolve5(cwd, OVERRIDES_DIR);
+  const overridesDir = resolve4(cwd, OVERRIDES_DIR);
   if (!existsSync18(overridesDir)) {
     return [];
   }
@@ -13353,13 +13327,13 @@ async function detectOverrides(cwd) {
 async function detectProjectOwnedFiles(cwd) {
   const found = [];
   for (const ownedPath of PROJECT_OWNED_PATHS) {
-    const fullPath = resolve5(cwd, ownedPath);
+    const fullPath = resolve4(cwd, ownedPath);
     if (existsSync18(fullPath)) {
       found.push(ownedPath);
     }
   }
   for (const ownedDir of PROJECT_OWNED_DIRECTORIES) {
-    const fullDir = resolve5(cwd, ownedDir);
+    const fullDir = resolve4(cwd, ownedDir);
     if (existsSync18(fullDir)) {
       const files = await walkDir3(fullDir);
       for (const file of files) {
@@ -13371,7 +13345,7 @@ async function detectProjectOwnedFiles(cwd) {
 }
 async function isReleaseWorkflowEnabled(cwd) {
   try {
-    const configPath = resolve5(cwd, ".pourkit", "config.json");
+    const configPath = resolve4(cwd, ".pourkit", "config.json");
     const content = await readFile6(configPath, "utf-8");
     const parsed = JSON.parse(content);
     return parsed.releaseWorkflow?.enabled === true;
@@ -13501,7 +13475,7 @@ async function runWorkflowPackSyncCommand(options) {
   const schemaResult = await runConfigSyncSchemaCommand({ cwd });
   let configMemory;
   try {
-    const configPath = resolve5(cwd, ".pourkit", "config.json");
+    const configPath = resolve4(cwd, ".pourkit", "config.json");
     const config = await loadConfig(configPath);
     if (config.memory?.enabled === true && config.memory?.provider === "icm") {
       configMemory = config.memory;
@@ -13511,7 +13485,7 @@ async function runWorkflowPackSyncCommand(options) {
   const managedBlockContent = generateManagedBlockContent(configMemory);
   const fullManagedBlock = `${MANAGED_BLOCK_BEGIN3}${managedBlockContent}${MANAGED_BLOCK_END2}`;
   async function syncManagedAgentFile(fileName, options2) {
-    const filePath = resolve5(cwd, fileName);
+    const filePath = resolve4(cwd, fileName);
     if (!existsSync18(filePath)) {
       if (!options2.createIfMissing) return false;
       await writeFile3(filePath, fullManagedBlock + "\n", "utf-8");
@@ -13548,7 +13522,7 @@ ${fullManagedBlock}
   }
   const enabledAddons = releaseEnabled ? ["release"] : [];
   const manifestMeta = buildWorkflowPackMetadata(enabledAddons);
-  const manifestPath = resolve5(cwd, ".pourkit", "manifest.json");
+  const manifestPath = resolve4(cwd, ".pourkit", "manifest.json");
   let manifestWritten = false;
   let previousManifestWorkflowPack = void 0;
   try {
@@ -13566,7 +13540,7 @@ ${fullManagedBlock}
       );
       let manifest = existingRaw ? JSON.parse(existingRaw) : {};
       manifest.workflowPack = manifestMeta;
-      await mkdir6(resolve5(manifestPath, ".."), { recursive: true });
+      await mkdir6(resolve4(manifestPath, ".."), { recursive: true });
       await writeFile3(
         manifestPath,
         JSON.stringify(manifest, null, 2) + "\n",
@@ -15484,11 +15458,11 @@ function createCliProgram(version) {
   return program;
 }
 async function resolveCliVersion() {
-  if (isPackageVersion("0.0.0-next-20260620182746")) {
-    return "0.0.0-next-20260620182746";
+  if (isPackageVersion("0.0.0-next-20260621003351")) {
+    return "0.0.0-next-20260621003351";
   }
-  if (isReleaseVersion("0.0.0-next-20260620182746")) {
-    return "0.0.0-next-20260620182746";
+  if (isReleaseVersion("0.0.0-next-20260621003351")) {
+    return "0.0.0-next-20260621003351";
   }
   try {
     const root = repoRoot();