@pourkit/cli 0.0.0-next-20260621045826 → 0.0.0-next-20260621094003

package/dist/cli.js

@@ -880,11 +880,11 @@ var OBSOLETE_CONFIG_PATHS = [
 ];
 var CANONICAL_CONFIG_PATH = ".pourkit/config.json";
 async function loadRepoConfig(repoRoot2, _configFileName) {
-  const { existsSync: existsSync21 } = await import("fs");
+  const { existsSync: existsSync22 } = await import("fs");
   const { join: pjoin } = await import("path");
   for (const obPath of OBSOLETE_CONFIG_PATHS) {
     const fullPath = pjoin(repoRoot2, obPath);
-    if (existsSync21(fullPath)) {
+    if (existsSync22(fullPath)) {
       const isRootJson = obPath === "pourkit.json";
       throw new Error(
         isRootJson ? `Found root ${obPath}, but Pourkit config now lives at ${CANONICAL_CONFIG_PATH}. Move the file and update "$schema" to "./schema/pourkit.schema.json".` : `Found ${obPath}, but executable config is no longer supported. Move configuration to ${CANONICAL_CONFIG_PATH} with "$schema": "./schema/pourkit.schema.json".`
@@ -892,7 +892,7 @@ async function loadRepoConfig(repoRoot2, _configFileName) {
     }
   }
   const configPath = pjoin(repoRoot2, CANONICAL_CONFIG_PATH);
-  if (!existsSync21(configPath)) {
+  if (!existsSync22(configPath)) {
     throw new Error(
       `No Pourkit config found at ${CANONICAL_CONFIG_PATH}. Run pourkit init or create ${CANONICAL_CONFIG_PATH} with "$schema": "./schema/pourkit.schema.json".`
     );
@@ -3491,8 +3491,23 @@ function validateIssueFinalReviewArtifact(parsed, options) {
     };
   }
   diagnostics.push("verification: present");
-  if (parsed.selfRetouched === true && parsed.verdict === "pass") {
+  const verificationWasRecorded = verification.required === true || Array.isArray(verification.commands) && verification.commands.length > 0;
+  if (parsed.verdict === "pass" && verificationWasRecorded) {
     if (verification.required !== true || verification.passed !== true) {
+      return {
+        ok: false,
+        reason: "Issue Final Review pass with verification evidence requires verification.required === true and verification.passed === true",
+        diagnostics: [
+          ...diagnostics,
+          `verification.required: ${verification.required}`,
+          `verification.passed: ${verification.passed}`
+        ]
+      };
+    }
+    diagnostics.push("pass verification: valid");
+  }
+  if (parsed.selfRetouched === true && parsed.verdict === "pass") {
+    if (!verificationWasRecorded) {
       return {
         ok: false,
         reason: "Self-retouched pass requires verification.required === true and verification.passed === true",
@@ -3672,7 +3687,7 @@ function shellQuote(value) {
 }
 
 // commands/issue-run.ts
-import { existsSync as existsSync12, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync15 } from "fs";
 import { isAbsolute as isAbsolute4, join as join15 } from "path";
 
 // pr/templates.ts
@@ -4395,6 +4410,10 @@ function writeFailureState(options, message) {
   }
 }
 
+// issues/issue-builder.ts
+init_common();
+import { existsSync as existsSync10, readFileSync as readFileSync11 } from "fs";
+
 // serena/baseline.ts
 init_common();
 import path3 from "path";
@@ -4712,9 +4731,177 @@ async function prepareSerenaForTarget(options) {
   }
 }
 
+// issues/issue-builder.ts
+async function runIssueBuilder(options) {
+  const {
+    repoRoot: repoRoot2,
+    issueNumber,
+    target,
+    config,
+    branchName,
+    worktreePath,
+    baseRef,
+    worktreeState,
+    restartBuilder,
+    executionProvider,
+    runContextArtifact,
+    logger,
+    memory,
+    prepareSerena,
+    onSerenaExecutionContext,
+    timeoutMs
+  } = options;
+  const serenaRuntimeConfig = {
+    enabled: target.serena?.enabled ?? config.serena.enabled,
+    required: target.serena?.required ?? config.serena.required,
+    autoStart: config.serena.autoStart,
+    dataDir: config.serena.dataDir,
+    mcpUrl: config.serena.mcpUrl,
+    sandboxMcpUrl: config.serena.sandboxMcpUrl
+  };
+  let serenaExecutionContext;
+  if (serenaRuntimeConfig.enabled || serenaRuntimeConfig.required) {
+    const serenaPreflight = await (prepareSerena ?? prepareSerenaForTarget)({
+      repoRoot: repoRoot2,
+      targetName: target.name,
+      baseBranch: target.baseBranch,
+      dataDir: serenaRuntimeConfig.dataDir,
+      mcpUrl: serenaRuntimeConfig.mcpUrl,
+      enabled: serenaRuntimeConfig.enabled || serenaRuntimeConfig.required,
+      required: serenaRuntimeConfig.required,
+      autoStart: serenaRuntimeConfig.autoStart,
+      logger
+    });
+    if (serenaPreflight.enabled && serenaPreflight.available) {
+      serenaExecutionContext = {
+        available: true,
+        sandboxMcpUrl: serenaRuntimeConfig.sandboxMcpUrl
+      };
+      onSerenaExecutionContext?.(serenaExecutionContext);
+    }
+    if (serenaPreflight.enabled && !serenaPreflight.available) {
+      const message = `Serena preflight unavailable for target ${target.name}: ${serenaPreflight.error}`;
+      if (serenaRuntimeConfig.required) {
+        throw new Error(message);
+      }
+      logger.step("warn", message);
+    }
+  }
+  const shouldRunBuilder = restartBuilder || worktreeState === null || !worktreeState.completedStages.builder;
+  if (!shouldRunBuilder) {
+    return {
+      status: "skipped",
+      ...worktreePath ? { worktreePath } : {},
+      worktreeState
+    };
+  }
+  const strategy = target.strategy;
+  const prompt = loadBuilderPrompt(
+    repoRoot2,
+    strategy.implement.builder.promptTemplate
+  );
+  const executionResult = await executionProvider.execute({
+    stage: "builder",
+    agent: strategy.implement.builder.agent,
+    model: strategy.implement.builder.model,
+    variant: strategy.implement.builder.variant,
+    env: strategy.implement.builder.env,
+    prompt,
+    target,
+    repoRoot: repoRoot2,
+    branchName,
+    ...baseRef ? { baseRef } : {},
+    sandbox: config.sandbox,
+    ...serenaExecutionContext ? { serena: serenaExecutionContext } : {},
+    ...memory ? { memory } : {},
+    autoApprove: true,
+    timeoutMs,
+    ...worktreePath ? { worktreePath } : {},
+    artifacts: [runContextArtifact],
+    logger
+  });
+  if (!executionResult.success) {
+    throw new Error(`Sandcastle failed: ${executionResult.error}`);
+  }
+  const effectiveWorktreePath = worktreePath ?? executionResult.worktreePath;
+  if (effectiveWorktreePath) {
+    await assertCanonicalBaseAncestor({
+      worktreePath: effectiveWorktreePath,
+      baseRef: `origin/${target.baseBranch}`,
+      stageName: "Builder",
+      logger
+    });
+    if (worktreeState) {
+      updateWorktreeRunState(effectiveWorktreePath, {
+        completedStages: { builder: true }
+      });
+    } else {
+      writeWorktreeRunState(effectiveWorktreePath, {
+        issueNumber,
+        targetName: target.name,
+        branchName,
+        baseBranch: target.baseBranch,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        completedStages: { builder: true },
+        review: { lifetimeIterations: 0 }
+      });
+    }
+  }
+  const refreshedState = effectiveWorktreePath ? readWorktreeRunState(effectiveWorktreePath) : worktreeState;
+  return {
+    status: "ran",
+    ...effectiveWorktreePath ? { worktreePath: effectiveWorktreePath } : {},
+    worktreeState: refreshedState
+  };
+}
+function loadBuilderPrompt(repoRoot2, promptTemplate) {
+  const promptPath = resolvePromptTemplatePath(repoRoot2, promptTemplate);
+  const promptBody = existsSync10(promptPath) ? readFileSync11(promptPath, "utf-8") : promptTemplate;
+  return appendProtectedWorkGuidance(`${promptBody}
+
+## Shared Run Context
+
+Read the selected issue requirements, planning context (including plan and PRD content when present), comments, branch context, verification commands, and artifact paths from: ${RUN_CONTEXT_PATH_IN_WORKTREE}`);
+}
+async function syncRemoteBaseRef(worktreePath, baseRef, logger) {
+  const remoteBase = parseRemoteBaseRef(baseRef);
+  if (!remoteBase) {
+    return;
+  }
+  await execCapture("git", ["fetch", remoteBase.remote, remoteBase.branch], {
+    cwd: worktreePath,
+    logger,
+    label: "git fetch target"
+  });
+}
+function parseRemoteBaseRef(baseRef) {
+  const [remote, ...branchParts] = baseRef.split("/");
+  const branch = branchParts.join("/");
+  if (!remote || !branch) {
+    return null;
+  }
+  return { remote, branch };
+}
+async function assertCanonicalBaseAncestor(options) {
+  const { worktreePath, baseRef, stageName, logger } = options;
+  await syncRemoteBaseRef(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.`
+    );
+  }
+}
+
 // commands/pr-description-agent.ts
 import { join as join11 } from "path";
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 
 // pr/pr-description-context.ts
 init_common();
@@ -4909,7 +5096,7 @@ function runFinalizerAgent(options) {
       logger: options.logger,
       ...options.memory ? { memory: options.memory } : {}
     });
-    const output = readFileSync11(artifactPath, "utf-8");
+    const output = readFileSync12(artifactPath, "utf-8");
     yield* persistGeneratedArtifactEffect(options.worktreePath, output, fs);
     return result;
   });
@@ -5106,7 +5293,7 @@ function extractClosingRefs(body) {
 
 // issues/github-issue-publication.ts
 init_common();
-import { existsSync as existsSync10, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync13 } from "fs";
 import { isAbsolute as isAbsolute3, join as join12 } from "path";
 
 // issues/issue-transitions.ts
@@ -5583,10 +5770,10 @@ function readIssueFinalReviewArtifact(worktreeState, worktreePath) {
     return null;
   }
   const artifactPath = isAbsolute3(configuredPath) ? configuredPath : join12(worktreePath, configuredPath);
-  if (!existsSync10(artifactPath)) return null;
+  if (!existsSync11(artifactPath)) return null;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync12(artifactPath, "utf-8"));
+    parsed = JSON.parse(readFileSync13(artifactPath, "utf-8"));
   } catch {
     return null;
   }
@@ -5841,7 +6028,7 @@ function isAllowedSecretPlaceholder(value) {
 }
 
 // commands/issue-final-review-agent.ts
-import { existsSync as existsSync11, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync14 } from "fs";
 import { join as join13 } from "path";
 var ISSUE_FINAL_REVIEW_ARTIFACT_PATH = join13(
   ".pourkit",
@@ -5966,7 +6153,7 @@ function extractChangedPaths(parsed) {
 function loadIssueFinalReviewPrompt(options) {
   const { repoRoot: repoRoot2, promptTemplate, validationCommand } = options;
   const promptPath = resolvePromptTemplatePath(repoRoot2, promptTemplate);
-  const promptBody = existsSync11(promptPath) ? readFileSync13(promptPath, "utf-8") : promptTemplate;
+  const promptBody = existsSync12(promptPath) ? readFileSync14(promptPath, "utf-8") : promptTemplate;
   return appendProtectedWorkGuidance(`${promptBody}
 
 ## Shared Run Context
@@ -5978,7 +6165,8 @@ 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 each configured verification command yourself from the Worktree.
 - Run the commands exactly as configured. Do not substitute narrower commands unless the configured command cannot run.
-- If a configured command fails, keep reviewing after recording the failure details; use the failure output as review evidence.
+- 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.
 - If no verification commands are configured, note that and proceed with normal review.
 
@@ -6167,16 +6355,6 @@ function checkIssueGates(issue, config, force) {
   }
   return { allowed: true, gates };
 }
-function resolveSerenaRuntimeConfig(config, target) {
-  return {
-    enabled: target.serena?.enabled ?? config.serena.enabled,
-    required: target.serena?.required ?? config.serena.required,
-    autoStart: config.serena.autoStart,
-    dataDir: config.serena.dataDir,
-    mcpUrl: config.serena.mcpUrl,
-    sandboxMcpUrl: config.serena.sandboxMcpUrl
-  };
-}
 function assertIssueFinalReviewPassed(worktreeState) {
   const ifr = worktreeState?.issueFinalReview;
   if (!ifr || !ifr.completed || ifr.verdict !== "pass") {
@@ -6239,7 +6417,7 @@ async function advanceIssueFinalReview(options) {
     reviewArtifactPath,
     ...options.memory ? { memory: options.memory } : {}
   });
-  await assertCanonicalBaseAncestor({
+  await assertCanonicalBaseAncestor2({
     worktreePath,
     baseRef: `origin/${target.baseBranch}`,
     stageName: "Issue Final Review",
@@ -6292,35 +6470,7 @@ async function startIssueRun(options) {
   const effectiveTarget = { ...target, baseBranch: effectiveBaseBranch };
   const branchName = renderBranchName(target.branchTemplate, issue);
   const strategy = target.strategy;
-  const serenaRuntimeConfig = resolveSerenaRuntimeConfig(config, target);
-  const shouldPrepareSerena = serenaRuntimeConfig.enabled || serenaRuntimeConfig.required;
   let serenaExecutionContext;
-  if (shouldPrepareSerena) {
-    const serenaPreflight = await prepareSerenaForTarget({
-      repoRoot: ROOT,
-      targetName: target.name,
-      baseBranch: target.baseBranch,
-      dataDir: serenaRuntimeConfig.dataDir,
-      mcpUrl: serenaRuntimeConfig.mcpUrl,
-      enabled: shouldPrepareSerena,
-      required: serenaRuntimeConfig.required,
-      autoStart: serenaRuntimeConfig.autoStart,
-      logger
-    });
-    if (serenaPreflight.enabled && serenaPreflight.available) {
-      serenaExecutionContext = {
-        available: true,
-        sandboxMcpUrl: serenaRuntimeConfig.sandboxMcpUrl
-      };
-    }
-    if (serenaPreflight.enabled && !serenaPreflight.available) {
-      const message = `Serena preflight unavailable for target ${target.name}: ${serenaPreflight.error}`;
-      if (serenaRuntimeConfig.required) {
-        throw new Error(message);
-      }
-      logger.step("warn", message);
-    }
-  }
   const memoryExecutionContext = config.memory?.enabled ? { available: true, sandboxDbPath: "/home/agent/.pourkit/icm/memories.db" } : void 0;
   if (options.resetWorktree) {
     const existingPr = await prProvider.getPr(branchName);
@@ -6332,10 +6482,6 @@ async function startIssueRun(options) {
     await resetIssueWorktree(ROOT, branchName, logger);
     await syncTargetBranch(ROOT, effectiveBaseBranch, logger);
   }
-  const prompt = loadBuilderPrompt(
-    ROOT,
-    strategy.implement.builder.promptTemplate
-  );
   const resolution = await resolveIssueWorktree(
     ROOT,
     branchName,
@@ -6380,68 +6526,33 @@ async function startIssueRun(options) {
   });
   await issueProvider.addLabels(issueNumber, [config.labels.agentInProgress]);
   await issueProvider.removeLabel(issueNumber, config.labels.readyForAgent);
-  let executionResult;
-  const shouldRunBuilder = resolution.mode === "new" ? true : worktreeState === null || !worktreeState.completedStages.builder;
-  if (shouldRunBuilder) {
-    executionResult = await executionProvider.execute({
-      stage: "builder",
-      agent: strategy.implement.builder.agent,
-      model: strategy.implement.builder.model,
-      variant: strategy.implement.builder.variant,
-      env: strategy.implement.builder.env,
-      prompt,
-      target: effectiveTarget,
-      repoRoot: ROOT,
-      branchName,
-      ...resolution.mode === "new" ? { baseRef: resolution.baseRef } : {},
-      sandbox: config.sandbox,
-      ...serenaExecutionContext ? { serena: serenaExecutionContext } : {},
-      ...memoryExecutionContext ? { memory: memoryExecutionContext } : {},
-      autoApprove: true,
-      timeoutMs: EXECUTION_TIMEOUT_MS,
-      ...resolution.worktreePath ? { worktreePath: resolution.worktreePath } : {},
-      artifacts: [runContextArtifact],
-      logger
-    });
-    if (!executionResult.success) {
-      throw new Error(`Sandcastle failed: ${executionResult.error}`);
-    }
-  } else {
-    executionResult = {
-      success: true,
-      branch: branchName,
-      worktreePath: resolution.worktreePath,
-      commits: [],
-      logPath: null
-    };
-  }
-  if (executionResult.worktreePath) {
-    if (shouldRunBuilder) {
-      await assertCanonicalBaseAncestor({
-        worktreePath: executionResult.worktreePath,
-        baseRef: `origin/${effectiveBaseBranch}`,
-        stageName: "Builder",
-        logger
-      });
-    }
-    if (worktreeState) {
-      updateWorktreeRunState(executionResult.worktreePath, {
-        completedStages: { builder: true }
-      });
-    } else {
-      writeWorktreeRunState(executionResult.worktreePath, {
-        issueNumber,
-        targetName: target.name,
-        branchName,
-        baseBranch: effectiveBaseBranch,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        completedStages: { builder: true },
-        review: { lifetimeIterations: 0 }
-      });
+  const builderResult = await runIssueBuilder({
+    repoRoot: ROOT,
+    issueNumber,
+    target: effectiveTarget,
+    config,
+    branchName,
+    ...resolution.worktreePath ? { worktreePath: resolution.worktreePath } : {},
+    ...resolution.mode === "new" ? { baseRef: resolution.baseRef } : {},
+    worktreeState,
+    restartBuilder: resolution.mode === "new",
+    executionProvider,
+    runContextArtifact,
+    logger,
+    ...memoryExecutionContext ? { memory: memoryExecutionContext } : {},
+    timeoutMs: EXECUTION_TIMEOUT_MS,
+    onSerenaExecutionContext: (context) => {
+      serenaExecutionContext = context;
     }
-  }
-  const finalWorktreeState = executionResult.worktreePath ? readWorktreeRunState(executionResult.worktreePath) : worktreeState;
+  });
+  const executionResult = {
+    success: true,
+    branch: branchName,
+    worktreePath: builderResult.worktreePath ?? issueWorktreePath(ROOT, branchName),
+    commits: [],
+    logPath: null
+  };
+  const finalWorktreeState = builderResult.worktreeState;
   return {
     issue,
     parentPrdIssue,
@@ -6486,7 +6597,7 @@ async function advanceIssueRunReview(options) {
       }
     })
   );
-  await assertCanonicalBaseAncestor({
+  await assertCanonicalBaseAncestor2({
     worktreePath: options.worktreePath,
     baseRef: `origin/${options.target.baseBranch}`,
     stageName: "Review/Refactor",
@@ -6552,12 +6663,12 @@ async function completeIssueRun(options) {
         prTitle = finalizerFromState.title;
         prBody = finalizerFromState.body;
       } else if (finalizerFromState.artifactPath) {
-        if (!existsSync12(finalizerFromState.artifactPath)) {
+        if (!existsSync13(finalizerFromState.artifactPath)) {
           throw new FinalizerFailure({
             message: `Finalizer artifact missing at ${finalizerFromState.artifactPath}`
           });
         }
-        const artifactContent = readFileSync14(
+        const artifactContent = readFileSync15(
           finalizerFromState.artifactPath,
           "utf-8"
         );
@@ -6595,7 +6706,7 @@ async function completeIssueRun(options) {
     prTitle = finalizerResult.title;
     prBody = finalizerResult.body;
     if (executionResult.worktreePath) {
-      await assertCanonicalBaseAncestor({
+      await assertCanonicalBaseAncestor2({
         worktreePath: executionResult.worktreePath,
         baseRef: `origin/${effectiveBaseBranch}`,
         stageName: "Finalizer",
@@ -6735,7 +6846,7 @@ function getRefactorArtifactDir(artifactPath) {
 }
 async function finalizeWorktreeCommit(options) {
   const { worktreePath, baseRef, title, body, logger } = options;
-  await assertCanonicalBaseAncestor({
+  await assertCanonicalBaseAncestor2({
     worktreePath,
     baseRef,
     stageName: "final commit",
@@ -6757,9 +6868,9 @@ async function finalizeWorktreeCommit(options) {
     label: "git commit"
   });
 }
-async function assertCanonicalBaseAncestor(options) {
+async function assertCanonicalBaseAncestor2(options) {
   const { worktreePath, baseRef, stageName, logger } = options;
-  await syncRemoteBaseRef(worktreePath, baseRef, logger);
+  await syncRemoteBaseRef2(worktreePath, baseRef, logger);
   try {
     await execCapture("git", ["merge-base", "--is-ancestor", baseRef, "HEAD"], {
       cwd: worktreePath,
@@ -6821,8 +6932,8 @@ function normalizeGitPath2(path9) {
 function isIssueFinalReviewAuditedPath2(path9) {
   return path9 !== "" && path9 !== WORKTREE_RUN_STATE_PATH && !path9.startsWith(".pourkit/.tmp/") && !path9.startsWith(".pourkit/logs/");
 }
-async function syncRemoteBaseRef(worktreePath, baseRef, logger) {
-  const remoteBase = parseRemoteBaseRef(baseRef);
+async function syncRemoteBaseRef2(worktreePath, baseRef, logger) {
+  const remoteBase = parseRemoteBaseRef2(baseRef);
   if (!remoteBase) {
     return;
   }
@@ -6832,7 +6943,7 @@ async function syncRemoteBaseRef(worktreePath, baseRef, logger) {
     label: "git fetch target"
   });
 }
-function parseRemoteBaseRef(baseRef) {
+function parseRemoteBaseRef2(baseRef) {
   const [remote, ...branchParts] = baseRef.split("/");
   const branch = branchParts.join("/");
   if (!remote || !branch) {
@@ -6911,15 +7022,6 @@ async function closeNoOpIssue(provider, issueNumber, config, logger) {
     await maybeCloseParentAfterChildCompletion(provider, issueNumber, logger);
   }
 }
-function loadBuilderPrompt(repoRoot2, promptTemplate) {
-  const promptPath = resolvePromptTemplatePath(repoRoot2, promptTemplate);
-  const promptBody = existsSync12(promptPath) ? readFileSync14(promptPath, "utf-8") : promptTemplate;
-  return appendProtectedWorkGuidance(`${promptBody}
-
-## Shared Run Context
-
-Read the selected issue requirements, planning context (including plan and PRD content when present), comments, branch context, verification commands, and artifact paths from: ${RUN_CONTEXT_PATH_IN_WORKTREE}`);
-}
 
 // issues/issue-run-lifecycle.ts
 var IssueRunHumanHandoffStop = class extends Error {
@@ -7186,9 +7288,9 @@ import { join as join17 } from "path";
 
 // prd-run/state.ts
 import {
-  existsSync as existsSync13,
+  existsSync as existsSync14,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync16,
   readdirSync as readdirSync3,
   writeFileSync as writeFileSync4
 } from "fs";
@@ -7277,16 +7379,16 @@ function normalizePrdRunRef(ref) {
 function readPrdRun(repoRoot2, prdRef) {
   const normalized = normalizePrdRunRef(prdRef);
   const recordPath = getRecordPath(repoRoot2, normalized);
-  if (!existsSync13(recordPath)) {
+  if (!existsSync14(recordPath)) {
     return { record: null, diagnostics: [] };
   }
   try {
-    const raw = JSON.parse(readFileSync15(recordPath, "utf-8"));
+    const raw = JSON.parse(readFileSync16(recordPath, "utf-8"));
     const parsed = PrdRunRecordSchema.parse(raw);
     return { record: parsed, diagnostics: [] };
   } catch (error) {
     try {
-      const raw = JSON.parse(readFileSync15(recordPath, "utf-8"));
+      const raw = JSON.parse(readFileSync16(recordPath, "utf-8"));
       if (raw && typeof raw === "object" && raw.start && typeof raw.start === "object" && raw.start.startBaseBranch === void 0) {
         return {
           record: raw,
@@ -7308,7 +7410,7 @@ function readPrdRun(repoRoot2, prdRef) {
 }
 function listPrdRuns(repoRoot2) {
   const stateDir = join16(repoRoot2, PRD_RUN_STATE_DIR);
-  if (!existsSync13(stateDir)) {
+  if (!existsSync14(stateDir)) {
     return { records: [], diagnostics: [] };
   }
   const records = [];
@@ -7320,7 +7422,7 @@ function listPrdRuns(repoRoot2) {
     const recordPath = join16(stateDir, entry.name);
     try {
       const record = PrdRunRecordSchema.parse(
-        JSON.parse(readFileSync15(recordPath, "utf-8"))
+        JSON.parse(readFileSync16(recordPath, "utf-8"))
       );
       records.push(record);
     } catch (error) {
@@ -9103,7 +9205,7 @@ async function launchGithubQueueDrain(options, prdRef, startReceipt, targetName,
 }
 
 // prd-run/final-review-validation.ts
-import { existsSync as existsSync14, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync17 } from "fs";
 
 // commands/prd-run.ts
 async function runPrdRunLaunchCommand(options) {
@@ -9613,7 +9715,7 @@ async function runPrMergeCommand(args, logger, prProvider, config) {
 }
 
 // commands/init.ts
-import { existsSync as existsSync15, statSync } from "fs";
+import { existsSync as existsSync16, statSync } from "fs";
 import {
   copyFile,
   mkdir as mkdir4,
@@ -9819,7 +9921,17 @@ function buildManagedAgentInstructions(options) {
 
 Use \`fd\` for file discovery, \`rg\` for text search, and direct file reads for focused context.
 
-Use \`opensrc path <package>\` when implementation requires source code for repo dependencies, instead of relying only on package docs or generated type declarations. Search or read files under the returned source path with \`rg\` and direct file reads.
+For multi-step exploration, prefer the dedicated subagents in \`.opencode/agents\`:
+
+- Use \`codebase-locator\` when you need to find relevant files, directories, or entry points.
+- Use \`codebase-analyzer\` when you need to understand how a specific component or flow works.
+- Use \`codebase-pattern-finder\` when you need examples of similar implementations or test patterns.
+- Use \`pourkit-docs-locator\` when searching \`.pourkit/\` context docs or ADRs.
+- Use \`pourkit-docs-analyzer\` to explain specific context docs or ADRs after locating them.
+
+Use direct \`fd\`/\`rg\`/reads for focused checks; use subagents when the search would otherwise require several discovery/read steps.
+
+Use \`opensrc path <package-or-repo>\` whenever implementation requires reading external source code, not only package dependencies. If you would otherwise clone a repository to inspect its source, use \`opensrc\` first, then search or read files under the returned source path with \`rg\` and direct file reads.
 
 Follow the project's domain docs and workflow routes documented in the Pourkit managed block below.
 
@@ -9928,7 +10040,7 @@ function resolveSourceAssetPath(sourceRoot, ...segments) {
     path5.join(sourceRoot, "dist", ...segments)
   ];
   for (const candidatePath of candidatePaths) {
-    if (existsSync15(candidatePath)) return candidatePath;
+    if (existsSync16(candidatePath)) return candidatePath;
   }
   return path5.join(sourceRoot, "pourkit", ...segments);
 }
@@ -10291,7 +10403,7 @@ async function computeFileChecksum(filePath) {
   return createHash("sha256").update(content).digest("hex");
 }
 function lockfileExists(root, name) {
-  return existsSync15(path5.join(root, name));
+  return existsSync16(path5.join(root, name));
 }
 function detectPackageManager(root) {
   if (lockfileExists(root, "pnpm-lock.yaml")) return "pnpm";
@@ -10335,7 +10447,7 @@ async function discoverLocalSource(sourcePath) {
 async function discoverReadme(root) {
   for (const name of ["README.md", "readme.md"]) {
     const p = path5.join(root, name);
-    if (existsSync15(p)) {
+    if (existsSync16(p)) {
       return p;
     }
   }
@@ -10345,7 +10457,7 @@ async function discoverAgentFiles(root) {
   const files = [];
   for (const name of ["AGENTS.md", "CLAUDE.md"]) {
     const p = path5.join(root, name);
-    if (existsSync15(p)) {
+    if (existsSync16(p)) {
       files.push(p);
     }
   }
@@ -10353,7 +10465,7 @@ async function discoverAgentFiles(root) {
 }
 async function discoverMerlleState(root) {
   const p = path5.join(root, ".pourkit", "state.json");
-  return existsSync15(p) ? p : null;
+  return existsSync16(p) ? p : null;
 }
 async function discoverAgentSkills(root) {
   const dirs = [
@@ -10362,7 +10474,7 @@ async function discoverAgentSkills(root) {
   ];
   const found = [];
   for (const d of dirs) {
-    if (existsSync15(d)) {
+    if (existsSync16(d)) {
       found.push(d);
     }
   }
@@ -10373,7 +10485,7 @@ async function discoverOpenCodeAgentFiles(sourceRoot) {
     resolveSourceAssetPath(sourceRoot, ".opencode", "agents"),
     path5.join(sourceRoot, "..", ".opencode", "agents")
   ].find(
-    (candidate) => existsSync15(candidate) && statSync(candidate).isDirectory()
+    (candidate) => existsSync16(candidate) && statSync(candidate).isDirectory()
   );
   if (!agentsDir) return [];
   const entries = await readdir(agentsDir, { withFileTypes: true });
@@ -10383,12 +10495,12 @@ async function discoverRootDomainDocs(root) {
   const docs = [];
   for (const name of ["CONTEXT.md", "CONTEXT-MAP.md"]) {
     const p = path5.join(root, name);
-    if (existsSync15(p)) {
+    if (existsSync16(p)) {
       docs.push(p);
     }
   }
   const adrDir = path5.join(root, "docs", "adr");
-  if (existsSync15(adrDir)) {
+  if (existsSync16(adrDir)) {
     const entries = await readdir(adrDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -10530,7 +10642,7 @@ async function planInit(options) {
       for (const file of skillFiles) {
         const relPath = path5.relative(s, file);
         const destPath = path5.join(targetRoot, ".agents", "skills", relPath);
-        if (!existsSync15(destPath)) {
+        if (!existsSync16(destPath)) {
           operations.push({
             kind: "copy",
             sourcePath: file,
@@ -10593,7 +10705,7 @@ async function planInit(options) {
     });
   }
   if (sourceRoot) {
-    if (!existsSync15(sourceRoot) || !statSync(sourceRoot).isDirectory()) {
+    if (!existsSync16(sourceRoot) || !statSync(sourceRoot).isDirectory()) {
       warnings.push(
         `--from-local path does not exist or is not a directory: ${sourceRoot}`
       );
@@ -10658,9 +10770,9 @@ async function planInit(options) {
         "release",
         "skills"
       );
-      const srcSkills = existsSync15(packagedManagedSkills) ? [
+      const srcSkills = existsSync16(packagedManagedSkills) ? [
         packagedManagedSkills,
-        ...existsSync15(packagedReleaseAddonSkills) ? [packagedReleaseAddonSkills] : []
+        ...existsSync16(packagedReleaseAddonSkills) ? [packagedReleaseAddonSkills] : []
       ] : await discoverAgentSkills(sourceRoot);
       for (const s of srcSkills) {
         const isOpenCode = s.includes(".opencode");
@@ -10683,7 +10795,7 @@ async function planInit(options) {
               "skills",
               relPath
             );
-            if (!existsSync15(destPath)) {
+            if (!existsSync16(destPath)) {
               operations.push({
                 kind: "copy",
                 sourcePath: file,
@@ -10815,7 +10927,7 @@ async function planInit(options) {
             requiresConfirmation: false,
             destructive: false
           });
-        } else if (existsSync15(destPath)) {
+        } else if (existsSync16(destPath)) {
           operations.push({
             kind: "skip",
             path: destPath,
@@ -10873,7 +10985,7 @@ async function planInit(options) {
         }
       }
       const contextPath = path5.join(targetRoot, ".pourkit", "CONTEXT.md");
-      if (!existsSync15(contextPath) && !merleDestPaths.has(contextPath)) {
+      if (!existsSync16(contextPath) && !merleDestPaths.has(contextPath)) {
         operations.push({
           kind: "create",
           path: contextPath,
@@ -10891,7 +11003,7 @@ async function planInit(options) {
         "adr",
         ".gitkeep"
       );
-      if (!existsSync15(adrGitkeep)) {
+      if (!existsSync16(adrGitkeep)) {
         operations.push({
           kind: "create",
           path: adrGitkeep,
@@ -10913,7 +11025,7 @@ async function planInit(options) {
         "docs",
         "agents"
       );
-      const srcDocAgents = existsSync15(packagedManagedDocAgents) ? packagedManagedDocAgents : legacyDocAgents;
+      const srcDocAgents = existsSync16(packagedManagedDocAgents) ? packagedManagedDocAgents : legacyDocAgents;
       const tgtManagedDocAgents = path5.join(
         targetRoot,
         ".pourkit",
@@ -10927,12 +11039,12 @@ async function planInit(options) {
         "docs",
         "agents"
       );
-      if (existsSync15(srcDocAgents)) {
+      if (existsSync16(srcDocAgents)) {
         const docFiles = await walkDir(srcDocAgents);
         for (const file of docFiles) {
           const relPath = path5.relative(srcDocAgents, file);
           const managedDocDest = path5.join(tgtManagedDocAgents, relPath);
-          if (!existsSync15(managedDocDest) && relPath === "triage-labels.md") {
+          if (!existsSync16(managedDocDest) && relPath === "triage-labels.md") {
             operations.push({
               kind: "create",
               path: managedDocDest,
@@ -10944,7 +11056,7 @@ async function planInit(options) {
                 options.labels ?? DEFAULT_RUNNER_LABELS
               )
             });
-          } else if (!existsSync15(managedDocDest)) {
+          } else if (!existsSync16(managedDocDest)) {
             const checksum = await computeFileChecksum(file);
             operations.push({
               kind: "copy",
@@ -10966,7 +11078,7 @@ async function planInit(options) {
             relPath
           );
           const stubDocDest = path5.join(tgtStubDocAgents, relPath);
-          if (existsSync15(stubDocDest)) continue;
+          if (existsSync16(stubDocDest)) continue;
           operations.push({
             kind: "create",
             path: stubDocDest,
@@ -11000,7 +11112,7 @@ Do not edit this file.
           "docs",
           "agents"
         );
-        if (existsSync15(packagedReleaseAddonDocs)) {
+        if (existsSync16(packagedReleaseAddonDocs)) {
           const docFiles = await walkDir(packagedReleaseAddonDocs);
           for (const file of docFiles) {
             const relPath = path5.relative(packagedReleaseAddonDocs, file);
@@ -11024,19 +11136,19 @@ Do not edit this file.
         "prompts"
       );
       const legacyPrompts = path5.join(sourceRoot, ".pourkit", "prompts");
-      const srcPrompts = existsSync15(packagedManagedPrompts) ? packagedManagedPrompts : legacyPrompts;
+      const srcPrompts = existsSync16(packagedManagedPrompts) ? packagedManagedPrompts : legacyPrompts;
       const tgtManagedPrompts = path5.join(
         targetRoot,
         ".pourkit",
         "managed",
         "prompts"
       );
-      if (existsSync15(srcPrompts)) {
+      if (existsSync16(srcPrompts)) {
         const promptFiles = await walkDir(srcPrompts);
         for (const file of promptFiles) {
           const relPath = path5.relative(srcPrompts, file);
           const promptDest = path5.join(tgtManagedPrompts, relPath);
-          if (existsSync15(promptDest)) continue;
+          if (existsSync16(promptDest)) continue;
           const checksum = await computeFileChecksum(file);
           operations.push({
             kind: "copy",
@@ -11060,7 +11172,7 @@ Do not edit this file.
         ".sandcastle",
         "Dockerfile"
       );
-      if (existsSync15(tgtSandboxDockerfile)) {
+      if (existsSync16(tgtSandboxDockerfile)) {
         operations.push({
           kind: "skip",
           path: tgtSandboxDockerfile,
@@ -11069,7 +11181,7 @@ Do not edit this file.
           requiresConfirmation: false,
           destructive: false
         });
-      } else if (existsSync15(srcSandboxDockerfile)) {
+      } else if (existsSync16(srcSandboxDockerfile)) {
         const checksum = await computeFileChecksum(srcSandboxDockerfile);
         operations.push({
           kind: "copy",
@@ -11083,7 +11195,7 @@ Do not edit this file.
         });
       }
       const configJsonPath = path5.join(targetRoot, ".pourkit", "config.json");
-      if (!existsSync15(configJsonPath)) {
+      if (!existsSync16(configJsonPath)) {
         const verifyCommands = inferVerificationCommands(
           packageScripts,
           pm || "npm"
@@ -11127,9 +11239,9 @@ Do not edit this file.
         "schema",
         "pourkit.schema.json"
       );
-      if (existsSync15(srcSchemaJson)) {
+      if (existsSync16(srcSchemaJson)) {
         const checksum = await computeFileChecksum(srcSchemaJson);
-        if (!existsSync15(schemaJsonPath)) {
+        if (!existsSync16(schemaJsonPath)) {
           operations.push({
             kind: "copy",
             sourcePath: srcSchemaJson,
@@ -11162,9 +11274,9 @@ Do not edit this file.
         "schema",
         "pourkit.schema.hash"
       );
-      if (existsSync15(srcSchemaHash)) {
+      if (existsSync16(srcSchemaHash)) {
         const checksum = await computeFileChecksum(srcSchemaHash);
-        if (!existsSync15(schemaHashPath)) {
+        if (!existsSync16(schemaHashPath)) {
           operations.push({
             kind: "copy",
             sourcePath: srcSchemaHash,
@@ -11190,7 +11302,7 @@ Do not edit this file.
       const hasExistingAgents = operations.some(
         (op) => (op.kind === "skip" || op.kind === "update") && op.path?.endsWith("AGENTS.md")
       );
-      if ((agentFileMode === "agents" || agentFileMode === "both") && !hasExistingAgents && !existsSync15(path5.join(targetRoot, "AGENTS.md"))) {
+      if ((agentFileMode === "agents" || agentFileMode === "both") && !hasExistingAgents && !existsSync16(path5.join(targetRoot, "AGENTS.md"))) {
         operations.push({
           kind: "create",
           path: path5.join(targetRoot, "AGENTS.md"),
@@ -11206,7 +11318,7 @@ ${managedAgentContent}${MANAGED_BLOCK_END}
       const hasExistingClaude = operations.some(
         (op) => (op.kind === "skip" || op.kind === "update") && op.path?.endsWith("CLAUDE.md")
       );
-      if ((agentFileMode === "claude" || agentFileMode === "both") && !hasExistingClaude && !existsSync15(path5.join(targetRoot, "CLAUDE.md"))) {
+      if ((agentFileMode === "claude" || agentFileMode === "both") && !hasExistingClaude && !existsSync16(path5.join(targetRoot, "CLAUDE.md"))) {
         operations.push({
           kind: "create",
           path: path5.join(targetRoot, "CLAUDE.md"),
@@ -11221,7 +11333,7 @@ ${managedAgentContent}${MANAGED_BLOCK_END}
       }
       const gitignoreTarget = path5.join(targetRoot, ".gitignore");
       const gitignoreContent = generateGitignoreBlock();
-      if (!existsSync15(gitignoreTarget)) {
+      if (!existsSync16(gitignoreTarget)) {
         operations.push({
           kind: "create",
           path: gitignoreTarget,
@@ -11252,7 +11364,7 @@ ${gitignoreContent}${MANAGED_BLOCK_END}
           "agents",
           path5.basename(agentFile)
         );
-        if (!existsSync15(targetPath)) {
+        if (!existsSync16(targetPath)) {
           operations.push({
             kind: "copy",
             sourcePath: agentFile,
@@ -11275,7 +11387,7 @@ ${gitignoreContent}${MANAGED_BLOCK_END}
         }
       }
       const manifestPath = path5.join(targetRoot, ".pourkit", "manifest.json");
-      if (existsSync15(manifestPath)) {
+      if (existsSync16(manifestPath)) {
         operations.push({
           kind: "skip",
           path: manifestPath,
@@ -11665,7 +11777,7 @@ async function updateManagedBlock(filePath, content) {
   const blockContent = `${MANAGED_BLOCK_BEGIN}
 ${content}${MANAGED_BLOCK_END}
 `;
-  if (!existsSync15(filePath)) {
+  if (!existsSync16(filePath)) {
     const dir = path5.dirname(filePath);
     await mkdir4(dir, { recursive: true });
     await writeFileAtomic(filePath, blockContent);
@@ -11694,7 +11806,7 @@ async function writeManifest(plan, sourceMeta, agentFiles, packageManager) {
     if (op.requiresConfirmation) continue;
     const relPath = path5.relative(plan.targetRoot, op.path);
     if (relPath === ".pourkit/manifest.json") continue;
-    if (existsSync15(op.path)) {
+    if (existsSync16(op.path)) {
       const sha256 = await computeFileChecksum(op.path);
       assets[relPath] = {
         ownership: op.ownership || "managed",
@@ -11740,7 +11852,7 @@ async function applyInitPlan(plan, options) {
             skipped++;
             continue;
           }
-          if (existsSync15(op.path) && !op.destructive) {
+          if (existsSync16(op.path) && !op.destructive) {
             skipped++;
             continue;
           }
@@ -11755,7 +11867,7 @@ async function applyInitPlan(plan, options) {
             skipped++;
             continue;
           }
-          if (existsSync15(op.path)) {
+          if (existsSync16(op.path)) {
             skipped++;
             continue;
           }
@@ -11784,7 +11896,7 @@ async function applyInitPlan(plan, options) {
             skipped++;
             continue;
           }
-          if (existsSync15(op.path)) {
+          if (existsSync16(op.path)) {
             skipped++;
             continue;
           }
@@ -11928,7 +12040,7 @@ async function applyInitFromSource(options) {
     if (!manifestSkipped) {
       const agentFiles = [];
       for (const name of ["AGENTS.md", "CLAUDE.md"]) {
-        if (existsSync15(path5.join(targetRoot, name))) {
+        if (existsSync16(path5.join(targetRoot, name))) {
           agentFiles.push(path5.join(targetRoot, name));
         }
       }
@@ -12104,18 +12216,18 @@ Init applied: ${result.applied} operations applied, ${result.skipped} skipped.`
 }
 
 // commands/memory-init.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync8, readFileSync as readFileSync17, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync8, readFileSync as readFileSync18, writeFileSync as writeFileSync5 } from "fs";
 import { join as join18 } from "path";
 async function runMemoryInitCommand(options) {
   const cwd = options.cwd ?? process.cwd();
   const configPath = join18(cwd, ".pourkit", "config.json");
-  if (!existsSync16(configPath)) {
+  if (!existsSync17(configPath)) {
     return {
       ok: false,
       message: "No .pourkit/config.json found. Run `pourkit init` first to initialize Pourkit, then run `pourkit memory init`."
     };
   }
-  const raw = JSON.parse(readFileSync17(configPath, "utf8"));
+  const raw = JSON.parse(readFileSync18(configPath, "utf8"));
   let alreadyEnabled = false;
   if (Object.prototype.hasOwnProperty.call(raw, "memory")) {
     const m = raw.memory;
@@ -12150,7 +12262,7 @@ async function runMemoryInitCommand(options) {
   let updatedAgentFile = false;
   for (const fileName of ["AGENTS.md", "CLAUDE.md"]) {
     const agentPath = join18(cwd, fileName);
-    if (existsSync16(agentPath)) {
+    if (existsSync17(agentPath)) {
       updateManagedBlockSync(agentPath, managed);
       updatedAgentFile = true;
     }
@@ -12168,11 +12280,11 @@ function updateManagedBlockSync(filePath, content) {
   const blockContent = `${MANAGED_BLOCK_BEGIN}
 ${content}${MANAGED_BLOCK_END}
 `;
-  if (!existsSync16(filePath)) {
+  if (!existsSync17(filePath)) {
     writeFileSync5(filePath, blockContent);
     return;
   }
-  const existing = readFileSync17(filePath, "utf8");
+  const existing = readFileSync18(filePath, "utf8");
   const beginIdx = existing.indexOf(MANAGED_BLOCK_BEGIN);
   const endIdx = existing.indexOf(MANAGED_BLOCK_END);
   if (beginIdx !== -1 && endIdx !== -1 && endIdx > beginIdx) {
@@ -12301,7 +12413,7 @@ async function runSerenaStatusCommand(options) {
 }
 
 // commands/config-schema.ts
-import { readFileSync as readFileSync18, existsSync as existsSync17 } from "fs";
+import { readFileSync as readFileSync19, existsSync as existsSync18 } from "fs";
 import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile2, readdir as readdir2 } from "fs/promises";
 import { resolve as resolve3, dirname as dirname5, relative as relative2 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -12314,7 +12426,7 @@ function resolvePackagedAssetPath2(fileName) {
     resolve3(__dirname3, "schema", fileName),
     resolve3(__dirname3, "../schema", fileName)
   ];
-  return candidates.find((candidate) => existsSync17(candidate)) ?? candidates[0];
+  return candidates.find((candidate) => existsSync18(candidate)) ?? candidates[0];
 }
 var PACKAGED_SCHEMA_PATH = resolvePackagedAssetPath2("pourkit.schema.json");
 var PACKAGED_HASH_PATH = resolvePackagedAssetPath2("pourkit.schema.hash");
@@ -12322,7 +12434,7 @@ var _schemaValidator = null;
 var _schemaErrors = null;
 function getSchemaValidator() {
   if (!_schemaValidator) {
-    const schema = JSON.parse(readFileSync18(PACKAGED_SCHEMA_PATH, "utf-8"));
+    const schema = JSON.parse(readFileSync19(PACKAGED_SCHEMA_PATH, "utf-8"));
     const ajv = new Ajv2({ strict: true });
     ajv.addKeyword("x-pourkit-schema-version");
     const validate = ajv.compile(schema);
@@ -12336,7 +12448,7 @@ function getSchemaValidator() {
   return _schemaValidator;
 }
 function readPackagedHash() {
-  return readFileSync18(PACKAGED_HASH_PATH, "utf-8");
+  return readFileSync19(PACKAGED_HASH_PATH, "utf-8");
 }
 function localSchemaDir(repoRoot2) {
   return resolve3(repoRoot2, ".pourkit/schema");
@@ -12457,7 +12569,7 @@ async function validateWorkflowPack(cwd) {
   const baselineSkills = getBaselineManagedSkillNames();
   for (const docName of catalog.docs) {
     const localPath = resolve3(cwd, `.pourkit/managed/docs/agents/${docName}`);
-    if (!existsSync17(localPath)) {
+    if (!existsSync18(localPath)) {
       failures.push({
         severity: "failure",
         kind: "missing_managed_asset",
@@ -12475,7 +12587,7 @@ async function validateWorkflowPack(cwd) {
               cwd,
               `.pourkit/overrides/docs/agents/${docName}`
             );
-            if (existsSync17(overridePath)) {
+            if (existsSync18(overridePath)) {
               warnings.push({
                 severity: "warning",
                 kind: "overridden",
@@ -12498,7 +12610,7 @@ async function validateWorkflowPack(cwd) {
   }
   for (const skillName of baselineSkills) {
     const skillDir = resolve3(cwd, `.pourkit/managed/skills/${skillName}`);
-    if (!existsSync17(skillDir)) {
+    if (!existsSync18(skillDir)) {
       failures.push({
         severity: "failure",
         kind: "missing_managed_asset",
@@ -12507,7 +12619,7 @@ async function validateWorkflowPack(cwd) {
       });
     } else {
       const skillSourcePath = resolve3(skillDir, "SKILL.md");
-      if (existsSync17(skillSourcePath)) {
+      if (existsSync18(skillSourcePath)) {
         const packagedSkillPath = resolvePackagedManagedPath(
           "skills",
           skillName,
@@ -12522,7 +12634,7 @@ async function validateWorkflowPack(cwd) {
                 cwd,
                 `.pourkit/overrides/skills/${skillName}/SKILL.md`
               );
-              if (existsSync17(overridePath)) {
+              if (existsSync18(overridePath)) {
                 warnings.push({
                   severity: "warning",
                   kind: "overridden",
@@ -12546,7 +12658,7 @@ async function validateWorkflowPack(cwd) {
   }
   for (const promptName of catalog.prompts) {
     const promptPath = resolve3(cwd, `.pourkit/managed/prompts/${promptName}`);
-    if (!existsSync17(promptPath)) {
+    if (!existsSync18(promptPath)) {
       failures.push({
         severity: "failure",
         kind: "missing_managed_asset",
@@ -12557,7 +12669,7 @@ async function validateWorkflowPack(cwd) {
   }
   for (const skillName of baselineSkills) {
     const projectionDir = resolve3(cwd, `.agents/skills/${skillName}`);
-    if (!existsSync17(projectionDir)) {
+    if (!existsSync18(projectionDir)) {
       warnings.push({
         severity: "warning",
         kind: "projection_stale",
@@ -12566,7 +12678,7 @@ async function validateWorkflowPack(cwd) {
       });
     } else {
       const projectionPath = resolve3(projectionDir, "SKILL.md");
-      if (existsSync17(projectionPath)) {
+      if (existsSync18(projectionPath)) {
         const managedSourcePath = resolvePackagedManagedPath(
           "skills",
           skillName,
@@ -12595,7 +12707,7 @@ async function validateWorkflowPack(cwd) {
     }
   }
   const agentsPath = resolve3(cwd, "AGENTS.md");
-  if (existsSync17(agentsPath)) {
+  if (existsSync18(agentsPath)) {
     try {
       const agentsContent = await readFile5(agentsPath, "utf-8");
       if (agentsContent.includes(OLD_DOCS_PATH_PATTERN)) {
@@ -12618,7 +12730,7 @@ async function validateWorkflowPack(cwd) {
     }
   }
   const overridesDir = resolve3(cwd, ".pourkit/overrides");
-  if (existsSync17(overridesDir)) {
+  if (existsSync18(overridesDir)) {
     const overrideFiles = await walkDir2(overridesDir);
     for (const file of overrideFiles) {
       const relPath = relative2(cwd, file);
@@ -12633,7 +12745,7 @@ async function validateWorkflowPack(cwd) {
     }
   }
   const configPath = resolve3(cwd, ".pourkit/config.json");
-  if (existsSync17(configPath)) {
+  if (existsSync18(configPath)) {
     try {
       const configContent = await readFile5(configPath, "utf-8");
       const parsed = JSON.parse(configContent);
@@ -12644,7 +12756,7 @@ async function validateWorkflowPack(cwd) {
             cwd,
             `.pourkit/managed/addons/release/skills/${skillName}`
           );
-          if (!existsSync17(addonDir)) {
+          if (!existsSync18(addonDir)) {
             failures.push({
               severity: "failure",
               kind: "release_config_conflict",
@@ -12658,7 +12770,7 @@ async function validateWorkflowPack(cwd) {
             cwd,
             `.pourkit/managed/addons/release/docs/agents/${docName}`
           );
-          if (!existsSync17(addonDocPath)) {
+          if (!existsSync18(addonDocPath)) {
             failures.push({
               severity: "failure",
               kind: "release_config_conflict",
@@ -12703,7 +12815,7 @@ async function validateWorkflowPack(cwd) {
             cwd,
             `.pourkit/managed/addons/release/skills/${skillName}`
           );
-          if (existsSync17(addonDir)) {
+          if (existsSync18(addonDir)) {
             failures.push({
               severity: "failure",
               kind: "release_config_conflict",
@@ -12717,7 +12829,7 @@ async function validateWorkflowPack(cwd) {
             cwd,
             `.pourkit/managed/addons/release/docs/agents/${docName}`
           );
-          if (existsSync17(addonDocPath)) {
+          if (existsSync18(addonDocPath)) {
             failures.push({
               severity: "failure",
               kind: "release_config_conflict",
@@ -12731,7 +12843,7 @@ async function validateWorkflowPack(cwd) {
     }
   }
   const manifestPath = resolve3(cwd, ".pourkit/manifest.json");
-  if (existsSync17(manifestPath)) {
+  if (existsSync18(manifestPath)) {
     try {
       const manifestContent = await readFile5(manifestPath, "utf-8");
       const manifest = JSON.parse(manifestContent);
@@ -12754,7 +12866,7 @@ async function validateWorkflowPack(cwd) {
     }
   }
   const pathEscapeOverrideDir = resolve3(cwd, ".pourkit/overrides");
-  if (existsSync17(pathEscapeOverrideDir)) {
+  if (existsSync18(pathEscapeOverrideDir)) {
     const overrideFiles = await walkDir2(pathEscapeOverrideDir);
     for (const file of overrideFiles) {
       if (!isPathContained(cwd, file)) {
@@ -12768,7 +12880,7 @@ async function validateWorkflowPack(cwd) {
     }
   }
   const managedDocsDir = resolve3(cwd, ".pourkit/managed/docs/agents");
-  if (existsSync17(managedDocsDir)) {
+  if (existsSync18(managedDocsDir)) {
     const docFiles = await walkDir2(managedDocsDir);
     for (const file of docFiles) {
       if (!file.endsWith(".md")) continue;
@@ -12789,12 +12901,12 @@ async function validateWorkflowPack(cwd) {
     }
   }
   const managedSkillsDir = resolve3(cwd, ".pourkit/managed/skills");
-  if (existsSync17(managedSkillsDir)) {
+  if (existsSync18(managedSkillsDir)) {
     const skillDirs = await readdir2(managedSkillsDir, { withFileTypes: true });
     for (const entry of skillDirs) {
       if (!entry.isDirectory()) continue;
       const skillFile = resolve3(managedSkillsDir, entry.name, "SKILL.md");
-      if (!existsSync17(skillFile)) continue;
+      if (!existsSync18(skillFile)) continue;
       try {
         const content = await readFile5(skillFile, "utf-8");
         const relPath = relative2(cwd, skillFile);
@@ -12812,10 +12924,10 @@ async function validateWorkflowPack(cwd) {
     }
   }
   const managedPromptsDir = resolve3(cwd, ".pourkit/managed/prompts");
-  if (existsSync17(managedPromptsDir)) {
+  if (existsSync18(managedPromptsDir)) {
     for (const promptName of catalog.prompts) {
       const promptFile = resolve3(managedPromptsDir, promptName);
-      if (!existsSync17(promptFile)) continue;
+      if (!existsSync18(promptFile)) continue;
       try {
         const content = await readFile5(promptFile, "utf-8");
         const relPath = relative2(cwd, promptFile);
@@ -12837,7 +12949,7 @@ async function validateWorkflowPack(cwd) {
       cwd,
       `.pourkit/managed/addons/release/skills/${skillName}/SKILL.md`
     );
-    if (!existsSync17(addonSkillFile)) continue;
+    if (!existsSync18(addonSkillFile)) continue;
     try {
       const content = await readFile5(addonSkillFile, "utf-8");
       const relPath = relative2(cwd, addonSkillFile);
@@ -12858,7 +12970,7 @@ async function validateWorkflowPack(cwd) {
       cwd,
       `.pourkit/managed/addons/release/docs/agents/${docName}`
     );
-    if (!existsSync17(addonDocFile)) continue;
+    if (!existsSync18(addonDocFile)) continue;
     try {
       const content = await readFile5(addonDocFile, "utf-8");
       const relPath = relative2(cwd, addonDocFile);
@@ -12892,7 +13004,7 @@ async function validateMemoryHealth(cwd, memoryConfig) {
     detail: icmPath !== null ? icmPath : "icm not found on PATH"
   });
   const gitignorePath = resolve3(cwd, ".gitignore");
-  const gitignoreContent = existsSync17(gitignorePath) ? readFileSync18(gitignorePath, "utf-8") : "";
+  const gitignoreContent = existsSync18(gitignorePath) ? readFileSync19(gitignorePath, "utf-8") : "";
   const hasGitignoreEntry = gitignoreContent.includes(".pourkit/icm/");
   checks.push({
     name: "icm-gitignore",
@@ -12919,8 +13031,8 @@ async function runDoctorCommand(options) {
   const schemaDir = localSchemaDir(repoRootPath);
   const localSchemaPath = resolve3(schemaDir, "pourkit.schema.json");
   const localHashPath = resolve3(schemaDir, "pourkit.schema.hash");
-  const localSchemaExists = existsSync17(localSchemaPath);
-  const localHashExists = existsSync17(localHashPath);
+  const localSchemaExists = existsSync18(localSchemaPath);
+  const localHashExists = existsSync18(localHashPath);
   let packagedHash = null;
   try {
     packagedHash = readPackagedHash();
@@ -12939,9 +13051,9 @@ async function runDoctorCommand(options) {
   const configPath = resolve3(repoRootPath, ".pourkit/config.json");
   let configValidation;
   let rawMemoryConfig;
-  if (existsSync17(configPath)) {
+  if (existsSync18(configPath)) {
     try {
-      const raw = JSON.parse(readFileSync18(configPath, "utf-8"));
+      const raw = JSON.parse(readFileSync19(configPath, "utf-8"));
       rawMemoryConfig = raw.memory;
       const validate = getSchemaValidator();
       const valid2 = validate(raw);
@@ -12974,7 +13086,7 @@ async function runDoctorCommand(options) {
     "pourkit.config.mjs",
     "pourkit.config.js",
     "pourkit.json"
-  ].filter((p) => existsSync17(resolve3(repoRootPath, p)));
+  ].filter((p) => existsSync18(resolve3(repoRootPath, p)));
   const workflowPack = await validateWorkflowPack(repoRootPath);
   const memory = await validateMemoryHealth(repoRootPath, rawMemoryConfig);
   let recommendation = null;
@@ -13024,7 +13136,7 @@ async function runConfigSyncSchemaCommand(options) {
   const localHashPath = resolve3(schemaDir, "pourkit.schema.hash");
   let schemaWritten = false;
   let hashWritten = false;
-  if (existsSync17(localSchemaPath)) {
+  if (existsSync18(localSchemaPath)) {
     const existing = await readFile5(localSchemaPath, "utf-8");
     if (existing !== packagedSchema) {
       await writeFile2(localSchemaPath, packagedSchema, "utf-8");
@@ -13034,7 +13146,7 @@ async function runConfigSyncSchemaCommand(options) {
     await writeFile2(localSchemaPath, packagedSchema, "utf-8");
     schemaWritten = true;
   }
-  if (existsSync17(localHashPath)) {
+  if (existsSync18(localHashPath)) {
     const existing = await readFile5(localHashPath, "utf-8");
     if (existing !== packagedHash) {
       await writeFile2(localHashPath, packagedHash, "utf-8");
@@ -13052,7 +13164,7 @@ async function runConfigSyncSchemaCommand(options) {
 }
 
 // commands/workflow-pack-sync.ts
-import { existsSync as existsSync18, readdirSync as readdirSync4 } from "fs";
+import { existsSync as existsSync19, readdirSync as readdirSync4 } from "fs";
 import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile3, readdir as readdir3 } from "fs/promises";
 import { resolve as resolve4, dirname as dirname6, relative as relative3, normalize as normalize2 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -13175,7 +13287,7 @@ async function syncFile(cwd, targetRelativePath, sourceContent, errors) {
     return false;
   }
   await mkdir6(resolve4(targetPath, ".."), { recursive: true });
-  if (existsSync18(targetPath)) {
+  if (existsSync19(targetPath)) {
     const existing = await readFile6(targetPath, "utf-8");
     if (existing === sourceContent) {
       return false;
@@ -13202,7 +13314,7 @@ function walkDirSync(dir) {
 }
 async function detectOverrides(cwd) {
   const overridesDir = resolve4(cwd, OVERRIDES_DIR);
-  if (!existsSync18(overridesDir)) {
+  if (!existsSync19(overridesDir)) {
     return [];
   }
   const files = await walkDir3(overridesDir);
@@ -13212,13 +13324,13 @@ async function detectProjectOwnedFiles(cwd) {
   const found = [];
   for (const ownedPath of PROJECT_OWNED_PATHS) {
     const fullPath = resolve4(cwd, ownedPath);
-    if (existsSync18(fullPath)) {
+    if (existsSync19(fullPath)) {
       found.push(ownedPath);
     }
   }
   for (const ownedDir of PROJECT_OWNED_DIRECTORIES) {
     const fullDir = resolve4(cwd, ownedDir);
-    if (existsSync18(fullDir)) {
+    if (existsSync19(fullDir)) {
       const files = await walkDir3(fullDir);
       for (const file of files) {
         found.push(relative3(cwd, file));
@@ -13370,7 +13482,7 @@ async function runWorkflowPackSyncCommand(options) {
   const fullManagedBlock = `${MANAGED_BLOCK_BEGIN3}${managedBlockContent}${MANAGED_BLOCK_END2}`;
   async function syncManagedAgentFile(fileName, options2) {
     const filePath = resolve4(cwd, fileName);
-    if (!existsSync18(filePath)) {
+    if (!existsSync19(filePath)) {
       if (!options2.createIfMissing) return false;
       await writeFile3(filePath, fullManagedBlock + "\n", "utf-8");
       return true;
@@ -14152,7 +14264,7 @@ function formatChecks2(checks) {
 init_common();
 
 // execution/sandcastle-execution.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync9, statSync as statSync2, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync9, statSync as statSync2, writeFileSync as writeFileSync6 } from "fs";
 import { join as join21 } from "path";
 import { createWorktree, opencode } from "@ai-hero/sandcastle";
 import { docker } from "@ai-hero/sandcastle/sandboxes/docker";
@@ -14180,18 +14292,18 @@ import path7 from "path";
 
 // execution/sandbox-image.ts
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync19, readFileSync as readFileSync19 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync20 } from "fs";
 import path6 from "path";
 function sandboxImageName(repoRoot2, installIcm) {
   const dirName = path6.basename(repoRoot2.replace(/[\\/]+$/, "")) || "local";
   const sanitized = dirName.toLowerCase().replace(/[^a-z0-9_.-]/g, "-");
   const baseName = sanitized || "local";
   const dockerfilePath = path6.join(repoRoot2, ".sandcastle", "Dockerfile");
-  if (!existsSync19(dockerfilePath)) {
+  if (!existsSync20(dockerfilePath)) {
     const base2 = `sandcastle:${baseName}`;
     return installIcm ? `${base2}-icm` : base2;
   }
-  const fingerprint = createHash2("sha256").update(readFileSync19(dockerfilePath)).digest("hex").slice(0, 8);
+  const fingerprint = createHash2("sha256").update(readFileSync20(dockerfilePath)).digest("hex").slice(0, 8);
   const base = `sandcastle:${baseName}-${fingerprint}`;
   return installIcm ? `${base}-icm` : base;
 }
@@ -14376,7 +14488,7 @@ var SandcastleExecutionSession = class {
           );
         }
         const hostMemoryDir = join21(repoRoot2, ".pourkit", "icm");
-        if (!existsSync20(hostMemoryDir) || !statSync2(hostMemoryDir).isDirectory()) {
+        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."
           );
@@ -14541,7 +14653,7 @@ function sanitizeBranch(branchName) {
 function safeCopyToWorktreePaths(paths, repoRoot2, worktreePath) {
   return paths.filter((relativePath) => {
     const source = join21(repoRoot2, relativePath);
-    if (!existsSync20(source)) {
+    if (!existsSync21(source)) {
       return true;
     }
     try {
@@ -14552,7 +14664,7 @@ function safeCopyToWorktreePaths(paths, repoRoot2, worktreePath) {
       return true;
     }
     const destination = join21(worktreePath, relativePath);
-    return !existsSync20(destination);
+    return !existsSync21(destination);
   });
 }
 function formatAgentStreamEvent(event) {
@@ -15342,11 +15454,11 @@ function createCliProgram(version) {
   return program;
 }
 async function resolveCliVersion() {
-  if (isPackageVersion("0.0.0-next-20260621045826")) {
-    return "0.0.0-next-20260621045826";
+  if (isPackageVersion("0.0.0-next-20260621094003")) {
+    return "0.0.0-next-20260621094003";
   }
-  if (isReleaseVersion("0.0.0-next-20260621045826")) {
-    return "0.0.0-next-20260621045826";
+  if (isReleaseVersion("0.0.0-next-20260621094003")) {
+    return "0.0.0-next-20260621094003";
   }
   try {
     const root = repoRoot();