@pourkit/cli 0.0.0-next-20260531183322 → 0.0.0-next-20260601025244

package/dist/cli.js

@@ -745,8 +745,7 @@ function getVerificationCommands(target) {
 }
 async function loadRepoConfig(repoRoot2, configFileName = "pourkit.config.ts") {
   const { existsSync: existsSync10 } = await import("fs");
-  const { readFile: readFile5, writeFile: writeFile3, rm } = await import("fs/promises");
-  const { tmpdir } = await import("os");
+  const { mkdir: mkdir5, writeFile: writeFile3, rm } = await import("fs/promises");
   const { join: pjoin, basename } = await import("path");
   const { pathToFileURL: pathToFileURL2 } = await import("url");
   const { build } = await import("esbuild");
@@ -756,8 +755,10 @@ async function loadRepoConfig(repoRoot2, configFileName = "pourkit.config.ts") {
       `No config file found at ${configPath}. Create a ${configFileName} that exports a default PourkitConfig.`
     );
   }
+  const tmpDir = pjoin(repoRoot2, ".pourkit", ".tmp", "config");
+  await mkdir5(tmpDir, { recursive: true });
   const tmpFile = pjoin(
-    tmpdir(),
+    tmpDir,
     `pourkit-config-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.mjs`
   );
   try {
@@ -1261,7 +1262,23 @@ function invalidateAfterBaseRefresh(state) {
 }
 
 // failure-resolution/effect-runtime.ts
+import { Effect as Effect2 } from "effect";
+
+// shared/effect-runtime.ts
 import { Effect } from "effect";
+var initialized = false;
+function initializeEffectRuntime() {
+  if (initialized) return;
+  initialized = true;
+}
+function runEffect(program) {
+  if (!initialized) {
+    throw new Error(
+      "Effect runtime not initialized. Call initializeEffectRuntime() at CLI startup."
+    );
+  }
+  return Effect.runPromiseExit(program);
+}
 
 // failure-resolution/types.ts
 var RebaseConflict = class extends Error {
@@ -1295,6 +1312,30 @@ var RecoveryArtifactInvalid = class extends Error {
     this.reason = args.reason;
   }
 };
+var ConfigFailure = class extends Error {
+  _tag = "ConfigFailure";
+  configKey;
+  expectedType;
+  message;
+  constructor(args) {
+    super(args.message);
+    this.name = "ConfigFailure";
+    this.configKey = args.configKey;
+    this.expectedType = args.expectedType;
+    this.message = args.message;
+  }
+};
+var SafetyFailure = class extends Error {
+  _tag = "SafetyFailure";
+  sensitivityKind;
+  message;
+  constructor(args) {
+    super(args.message);
+    this.name = "SafetyFailure";
+    this.sensitivityKind = args.sensitivityKind;
+    this.message = args.message;
+  }
+};
 var SUPPORTED_DECISIONS = /* @__PURE__ */ new Set([
   "RETRY_STAGE",
   "HANDOFF_TO_HUMAN",
@@ -1470,23 +1511,23 @@ function recordStageAttempt(worktreePath, record) {
 
 // failure-resolution/effect-runtime.ts
 function baseRefreshEffect(options) {
-  return Effect.promise(() => refreshStaleIssueBranch(options)).pipe(
-    Effect.flatMap(
+  return Effect2.promise(() => refreshStaleIssueBranch(options)).pipe(
+    Effect2.flatMap(
       (result) => {
         switch (result.status) {
           case "refreshed":
-            return Effect.succeed({ status: "refreshed" });
+            return Effect2.succeed({ status: "refreshed" });
           case "skipped-current":
-            return Effect.succeed({ status: "skipped-current" });
+            return Effect2.succeed({ status: "skipped-current" });
           case "conflicted":
-            return Effect.fail(
+            return Effect2.fail(
               new RebaseConflict({
                 conflictedPaths: result.conflictedPaths,
                 message: result.message
               })
             );
           case "refused-published-history":
-            return Effect.fail(
+            return Effect2.fail(
               new PublishedHistoryRisk({
                 prNumber: result.prNumber,
                 prState: result.prState
@@ -1501,8 +1542,8 @@ async function runBaseRefreshAttempt(options) {
   const attemptId = createStageAttemptId();
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const program = baseRefreshEffect(options).pipe(
-    Effect.tapBoth({
-      onSuccess: (success) => Effect.sync(() => {
+    Effect2.tapBoth({
+      onSuccess: (success) => Effect2.sync(() => {
         recordStageAttempt(options.worktreePath, {
           id: attemptId,
           stage: "baseRefresh",
@@ -1511,7 +1552,7 @@ async function runBaseRefreshAttempt(options) {
           outcome: "success"
         });
       }),
-      onFailure: (failure) => Effect.sync(() => {
+      onFailure: (failure) => Effect2.sync(() => {
         recordStageAttempt(options.worktreePath, {
           id: attemptId,
           stage: "baseRefresh",
@@ -1527,7 +1568,7 @@ async function runBaseRefreshAttempt(options) {
       })
     })
   );
-  return Effect.runPromiseExit(program);
+  return runEffect(program);
 }
 
 // commands/conflict-resolution.ts
@@ -1550,7 +1591,7 @@ async function hasUnresolvedConflictMarkers(worktreePath, files) {
 }
 
 // commands/issue-run.ts
-import { Exit as Exit2 } from "effect";
+import { Exit as Exit3 } from "effect";
 
 // serena/baseline.ts
 init_common();
@@ -1875,7 +1916,7 @@ import { join as join6 } from "path";
 
 // failure-resolution/recovery-policy.ts
 function isSecuritySensitiveFailure(failure) {
-  return failure instanceof PublishedHistoryRisk;
+  return failure instanceof PublishedHistoryRisk || failure instanceof SafetyFailure;
 }
 async function evaluateRecoveryPolicy(params) {
   if (isSecuritySensitiveFailure(params.failure)) {
@@ -1884,6 +1925,14 @@ async function evaluateRecoveryPolicy(params) {
       reason: "Security-sensitive failure \u2014 AI recovery bypassed"
     };
   }
+  if (params.failure instanceof ConfigFailure) {
+    if (params.agentRecommendedDecision !== "FAIL_RUN" && params.agentRecommendedDecision !== "HANDOFF_TO_HUMAN") {
+      return {
+        decision: "HANDOFF_TO_HUMAN",
+        reason: `ConfigFailure \u2014 agent recommended ${params.agentRecommendedDecision} but config errors are not AI-repairable`
+      };
+    }
+  }
   const budget = recoveryBudgetForFailure(
     params.worktreePath,
     params.fingerprint,
@@ -1913,13 +1962,13 @@ async function evaluateRecoveryPolicy(params) {
 // failure-resolution/failure-resolution-agent.ts
 function constructFailureResolutionPacket(failure, context) {
   return {
-    failureType: "RebaseConflict",
+    failureType: failure._tag,
     stageName: context.stageName,
     attemptNumber: context.attemptNumber,
     worktreePath: context.worktreePath,
     branchName: context.branchName,
     baseBranch: context.baseBranch,
-    conflictedPaths: failure.conflictedPaths,
+    conflictedPaths: failure instanceof RebaseConflict ? failure.conflictedPaths : void 0,
     failureSummary: failure.message,
     maxAttempts: context.maxAttempts,
     allowedDecisions: context.allowedDecisions,
@@ -1940,10 +1989,7 @@ async function runFailureResolutionAgent(options) {
   const frConfig = target.strategy.failureResolution;
   const artifactPath = packet.artifactTarget;
   const fullArtifactPath = join6(worktreePath, artifactPath);
-  const fingerprint = computeFailureFingerprint(
-    "baseRefresh",
-    "RebaseConflict"
-  );
+  const fingerprint = computeFailureFingerprint(packet.stageName, failure._tag);
   const prompt = [
     `# Failure Resolution: ${packet.failureType}`,
     "",
@@ -1982,7 +2028,8 @@ async function runFailureResolutionAgent(options) {
       fingerprint,
       `Agent execution failed: ${executionResult.error}`,
       void 0,
-      "HANDOFF_TO_HUMAN"
+      "HANDOFF_TO_HUMAN",
+      packet.stageName
     );
     return {
       status: "handoff",
@@ -1997,7 +2044,8 @@ async function runFailureResolutionAgent(options) {
       fingerprint,
       "Agent did not write artifact",
       void 0,
-      "HANDOFF_TO_HUMAN"
+      "HANDOFF_TO_HUMAN",
+      packet.stageName
     );
     return {
       status: "handoff",
@@ -2017,7 +2065,8 @@ async function runFailureResolutionAgent(options) {
       fingerprint,
       reason,
       void 0,
-      "HANDOFF_TO_HUMAN"
+      "HANDOFF_TO_HUMAN",
+      packet.stageName
     );
     return { status: "handoff", decision: "HANDOFF_TO_HUMAN", reason };
   }
@@ -2032,7 +2081,8 @@ async function runFailureResolutionAgent(options) {
       fingerprint,
       validation.reason,
       void 0,
-      "HANDOFF_TO_HUMAN"
+      "HANDOFF_TO_HUMAN",
+      packet.stageName
     );
     return {
       status: "handoff",
@@ -2054,7 +2104,8 @@ async function runFailureResolutionAgent(options) {
     fingerprint,
     policyResult.reason,
     artifactPath,
-    policyResult.decision
+    policyResult.decision,
+    packet.stageName
   );
   if (policyResult.decision === "HANDOFF_TO_HUMAN") {
     return {
@@ -2076,12 +2127,12 @@ async function runFailureResolutionAgent(options) {
     artifact
   };
 }
-async function writeRecoveryAttempt(worktreePath, outcome, fingerprint, summary, artifactRef, decision) {
+async function writeRecoveryAttempt(worktreePath, outcome, fingerprint, summary, artifactRef, decision, stageName = "baseRefresh") {
   writeAttemptLog(worktreePath, {
     attemptType: "recovery",
     fingerprint,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    stage: "baseRefresh",
+    stage: stageName,
     outcome,
     artifactRef,
     decision: decision ?? (outcome === "handoff" ? "HANDOFF_TO_HUMAN" : outcome === "success" ? "RETRY_STAGE" : void 0)
@@ -3671,7 +3722,7 @@ async function startIssueRun(options) {
       prNumber: existingPr?.number,
       prState: existingPr?.state
     });
-    if (Exit2.isSuccess(exit)) {
+    if (Exit3.isSuccess(exit)) {
       const refreshResult = exit.value;
       if (refreshResult.status === "refreshed") {
         if (worktreeState?.completedStages.builder) {
@@ -9041,11 +9092,11 @@ function createCliProgram(version) {
   return program;
 }
 async function resolveCliVersion() {
-  if (isPackageVersion("0.0.0-next-20260531183322")) {
-    return "0.0.0-next-20260531183322";
+  if (isPackageVersion("0.0.0-next-20260601025244")) {
+    return "0.0.0-next-20260601025244";
   }
-  if (isReleaseVersion("0.0.0-next-20260531183322")) {
-    return "0.0.0-next-20260531183322";
+  if (isReleaseVersion("0.0.0-next-20260601025244")) {
+    return "0.0.0-next-20260601025244";
   }
   try {
     const root = repoRoot();
@@ -9071,6 +9122,7 @@ async function resolveCliVersion() {
   return DEVELOPMENT_VERSION;
 }
 async function main(argv = process.argv.slice(2)) {
+  initializeEffectRuntime();
   const version = await resolveCliVersion();
   const program = createCliProgram(version);
   if (argv.length === 0) {