@poetic-ai/poetic 1.42.0

package/dist/chunk-VPHVFK4A.js

@@ -0,0 +1,1984 @@
+import {
+  CIRCUIT_BREAKER_WARNING_INTERVAL_MS,
+  EXPONENTIAL_BACKOFF_MULTIPLIER,
+  GITHUB_API_RETRY_ATTEMPTS,
+  GITHUB_API_RETRY_BACKOFF_CAP_MS,
+  MAX_FILE_COUNT,
+  MAX_FILE_SIZE_BYTES,
+  MS_PER_SECOND
+} from "./chunk-3AOKYKA7.js";
+import {
+  recordMetric
+} from "./chunk-5RBHQYDB.js";
+import {
+  enqueueRemoteBranchCleanup,
+  isRemoteBranchMissingError,
+  isRetryableRemoteDeleteError,
+  resolveExpectedRemoteShaForQueuedBranch
+} from "./chunk-BXI4NXL3.js";
+import {
+  resolveVariantStrategy
+} from "./chunk-LWTN3WRV.js";
+import {
+  getWorktreeManager
+} from "./chunk-4IYIZQWV.js";
+import {
+  gitLock
+} from "./chunk-N65O4XTH.js";
+import {
+  matchesErrorPattern
+} from "./chunk-2YFUIER7.js";
+import {
+  parseJsonWithContext
+} from "./chunk-QVZMFDYG.js";
+import {
+  emitTelemetryFallbackWarning
+} from "./chunk-YMX76IOS.js";
+import {
+  isEphemeralPoeticBranchDeletionCandidate,
+  resolveDefaultBranch
+} from "./chunk-XQD2B6BB.js";
+import {
+  execGit
+} from "./chunk-KNDYMVWN.js";
+import {
+  formatBytes
+} from "./chunk-JLS65NUQ.js";
+import {
+  GitError,
+  PRCreationError,
+  wrapError
+} from "./chunk-LUVKFFWR.js";
+import {
+  findProjectRoot
+} from "./chunk-L6OM4A22.js";
+import {
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+
+// src/orchestrator/github-pr-manager.ts
+import { execa as execa2 } from "execa";
+
+// src/orchestrator/pr-manager-core.ts
+import * as fsp2 from "fs/promises";
+import * as path2 from "path";
+import chalk2 from "chalk";
+import { execa } from "execa";
+
+// src/core/cleanup/artifact-lifecycle-manager.ts
+import { createHash } from "crypto";
+import { EventEmitter } from "events";
+import * as fsp from "fs/promises";
+import * as path from "path";
+import { promisify } from "util";
+import * as zlib from "zlib";
+import chalk from "chalk";
+var SmartAgingAlgorithm = class {
+  weights = {
+    age: 0.3,
+    size: 0.2,
+    access: 0.25,
+    tags: 0.15,
+    dependencies: 0.1
+  };
+  calculateRetentionScore(metadata) {
+    const now = /* @__PURE__ */ new Date();
+    const ageDays = (now.getTime() - metadata.createdAt.getTime()) / (1e3 * 60 * 60 * 24);
+    const ageScore = Math.max(0, 1 - ageDays / 365);
+    const sizeScore = Math.min(1, metadata.size / (10 * 1024 * 1024));
+    const accessDays = (now.getTime() - metadata.lastAccessed.getTime()) / (1e3 * 60 * 60 * 24);
+    const accessScore = Math.max(0, 1 - accessDays / 30);
+    const tagScore = this.calculateTagScore(metadata.tags);
+    const dependencyScore = 0.5;
+    return ageScore * this.weights.age + sizeScore * this.weights.size + accessScore * this.weights.access + tagScore * this.weights.tags + dependencyScore * this.weights.dependencies;
+  }
+  calculateTagScore(tags) {
+    const importantTags = ["critical", "production", "reference", "template"];
+    let score = 0;
+    for (const tag of tags) {
+      if (importantTags.includes(tag.toLowerCase())) {
+        score += 0.3;
+      } else if (tag.startsWith("v")) {
+        score += 0.1;
+      }
+    }
+    return Math.min(1, score);
+  }
+};
+var WorkerPool = class {
+  queue = [];
+  maxWorkers;
+  activeWorkers = 0;
+  constructor(maxWorkers) {
+    this.maxWorkers = maxWorkers;
+  }
+  async execute(task) {
+    return new Promise((resolve, reject) => {
+      const wrappedTask = async () => {
+        try {
+          const result = await task();
+          resolve(result);
+        } catch (error) {
+          reject(error);
+        }
+      };
+      if (this.activeWorkers < this.maxWorkers) {
+        this.runTask(wrappedTask);
+      } else {
+        this.queue.push(wrappedTask);
+      }
+    });
+  }
+  async runTask(task) {
+    this.activeWorkers++;
+    try {
+      await task();
+    } finally {
+      this.activeWorkers--;
+      if (this.queue.length > 0) {
+        const nextTask = this.queue.shift();
+        if (nextTask) {
+          this.runTask(nextTask);
+        }
+      }
+    }
+  }
+  async close() {
+    while (this.activeWorkers > 0) {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+  }
+};
+async function compressBuffer(data, algorithm = "gzip") {
+  switch (algorithm) {
+    case "gzip":
+      return promisify(zlib.gzip)(data);
+    case "deflate":
+      return promisify(zlib.deflate)(data);
+    case "brotli":
+      return promisify(zlib.brotliCompress)(data);
+    default:
+      throw new Error(`Unsupported compression algorithm: ${algorithm}`);
+  }
+}
+var ArtifactLifecycleManager = class extends EventEmitter {
+  config;
+  smartAging;
+  workerPool;
+  telemetry = /* @__PURE__ */ new Map();
+  isRunning = false;
+  constructor(config = {}) {
+    super();
+    this.config = this.mergeWithDefaults(config);
+    this.smartAging = new SmartAgingAlgorithm();
+    this.workerPool = new WorkerPool(this.config.parallelWorkers);
+    this.setupEventHandlers();
+  }
+  mergeWithDefaults(config) {
+    const defaults = {
+      basePath: ".poetic/implementations",
+      retentionPolicy: {
+        maxAgeDays: 30,
+        maxSizeBytes: 100 * 1024 * 1024,
+        // 100MB
+        maxCount: 1e3,
+        archiveBeforeDelete: true,
+        compressionLevel: 6,
+        preserveMetadata: true,
+        smartAging: true,
+        priorityTags: /* @__PURE__ */ new Set(["critical", "production", "reference"]),
+        exclusionPatterns: [/\.git\//, /node_modules\//, /\.DS_Store$/]
+      },
+      parallelWorkers: 4,
+      batchSize: 50,
+      enableTelemetry: true,
+      enableSmartAging: true,
+      enableCompression: true,
+      archiveFormat: "zip",
+      dryRun: false,
+      verbose: false
+    };
+    return this.deepMerge(defaults, config);
+  }
+  deepMerge(target, source) {
+    const result = { ...target };
+    for (const key in source) {
+      if (source[key] !== void 0) {
+        if (typeof source[key] === "object" && source[key] !== null && !Array.isArray(source[key])) {
+          result[key] = this.deepMerge(
+            target[key],
+            source[key]
+          );
+        } else {
+          result[key] = source[key];
+        }
+      }
+    }
+    return result;
+  }
+  setupEventHandlers() {
+    this.on("cleanup:error", (error) => {
+      if (this.config.verbose) {
+        console.error(chalk.red(`Cleanup error: ${error.message}`));
+        if (error.suggestion) {
+          console.error(chalk.yellow(`Suggestion: ${error.suggestion}`));
+        }
+      }
+    });
+  }
+  /**
+   * Scan directory for artifacts and build metadata.
+   *
+   * Walks the base path RECURSIVELY, treating every nested file as an
+   * individual artifact. Per-file recursion (rather than treating a
+   * first-level directory as one archive unit) is deliberate: it preserves
+   * the existing archive format exactly — each artifact is compressed to a
+   * single `.archive/<id>.<format>` entry with an optional metadata sidecar —
+   * and each nested file's own age/retention score decides its fate, so
+   * young files inside an otherwise-old directory always survive.
+   *
+   * The `.archive` directory is never descended into: archived content is
+   * terminal and must not be re-scanned as live artifacts.
+   */
+  async scanArtifacts() {
+    const startTime = Date.now();
+    const artifacts = [];
+    try {
+      await fsp.mkdir(this.config.basePath, { recursive: true });
+      await this.scanDirectory(this.config.basePath, artifacts);
+      if (this.config.enableTelemetry) {
+        this.telemetry.set("scan:duration", Date.now() - startTime);
+        this.telemetry.set("scan:artifactsFound", artifacts.length);
+      }
+      return artifacts;
+    } catch (error) {
+      const cleanupError = {
+        code: "SCAN_ERROR",
+        message: `Failed to scan artifacts: ${error instanceof Error ? error.message : String(error)}`,
+        artifactPath: this.config.basePath,
+        operation: "scan",
+        timestamp: /* @__PURE__ */ new Date(),
+        recoverable: true,
+        suggestion: "Check directory permissions and ensure path exists"
+      };
+      this.emit("cleanup:error", cleanupError);
+      throw error;
+    }
+  }
+  /**
+   * Recursively walk a directory, collecting artifact metadata for every
+   * nested file. Exclusion patterns are tested against the path relative to
+   * the base path (with `/` separators) so directory patterns like
+   * `/\.git\//` and `/node_modules\//` match at any depth; for first-level
+   * files the relative path equals the filename, preserving prior behavior.
+   */
+  async scanDirectory(dir, artifacts) {
+    const entries = await fsp.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryPath = path.join(dir, entry.name);
+      const relativePath = path.relative(this.config.basePath, entryPath).split(path.sep).join("/");
+      if (entry.isDirectory()) {
+        if (dir === this.config.basePath && entry.name === ".archive") {
+          continue;
+        }
+        if (this.shouldExclude(`${relativePath}/`)) {
+          continue;
+        }
+        await this.scanDirectory(entryPath, artifacts);
+        continue;
+      }
+      if (entry.isFile() && !this.shouldExclude(relativePath)) {
+        const metadata = await this.buildArtifactMetadata(entryPath);
+        if (metadata) {
+          artifacts.push(metadata);
+          this.emit("artifact:discovered", metadata);
+        }
+      }
+    }
+  }
+  shouldExclude(relativePath) {
+    return this.config.retentionPolicy.exclusionPatterns.some(
+      (pattern) => pattern.test(relativePath)
+    );
+  }
+  /**
+   * Derive a stable artifact id from the path relative to the base path.
+   * Path separators become `__` so nested files with the same basename get
+   * distinct archive entries; first-level files keep their historical
+   * basename-derived ids.
+   *
+   * Collision hardening: the plain `__` join is not injective when a path
+   * segment itself contains `_` (e.g. `a/b__c.md` and `a/b/c.md` both join
+   * to `a__b__c`, so the second archive entry would overwrite the first and
+   * both originals would then be deleted). To keep the encoding injective
+   * without renaming any existing archive entries, ids stay the plain join
+   * when no segment contains `_` (the historical format — nothing parses ids
+   * back into paths, and all underscore-free ids are unambiguous), and only
+   * ambiguous paths (any segment containing `_`) get a deterministic
+   * `--<sha256(relPath)[0..8]>` suffix. Every id containing `_` therefore
+   * carries a path-hash discriminator, so distinct paths produce distinct
+   * ids (modulo an 8-hex-digit hash collision between two different paths,
+   * which is accepted as negligible).
+   */
+  artifactId(artifactPath) {
+    const relative2 = path.relative(this.config.basePath, artifactPath);
+    const withoutExt = relative2.slice(0, relative2.length - path.extname(relative2).length);
+    const segments = withoutExt.split(path.sep);
+    const joined = segments.join("__");
+    if (!segments.some((segment) => segment.includes("_"))) {
+      return joined;
+    }
+    const pathHash = createHash("sha256").update(relative2.split(path.sep).join("/")).digest("hex").slice(0, 8);
+    return `${joined}--${pathHash}`;
+  }
+  async buildArtifactMetadata(artifactPath) {
+    try {
+      const stats = await fsp.stat(artifactPath);
+      const content = await fsp.readFile(artifactPath);
+      const checksum = createHash("sha256").update(content).digest("hex");
+      const tags = this.extractTags(artifactPath, content);
+      const baseMetadata = {
+        id: this.artifactId(artifactPath),
+        path: artifactPath,
+        size: stats.size,
+        createdAt: stats.birthtime,
+        lastAccessed: stats.atime,
+        lastModified: stats.mtime,
+        checksum,
+        tags
+      };
+      const retentionScore = this.config.enableSmartAging ? this.smartAging.calculateRetentionScore(baseMetadata) : 0.5;
+      const metadata = {
+        ...baseMetadata,
+        retentionScore
+      };
+      this.emit("retention:scored", metadata, retentionScore);
+      return metadata;
+    } catch (error) {
+      if (this.config.verbose) {
+        emitWarning(
+          "WS-003",
+          {
+            subsystem: "cleanup",
+            executionPhase: "execution"
+          },
+          {
+            severity: "WARN" /* WARN */,
+            metadata: {
+              artifactPath,
+              error: error instanceof Error ? error.message : String(error),
+              operation: "buildMetadata"
+            }
+          }
+        );
+      }
+      return null;
+    }
+  }
+  extractTags(artifactPath, content) {
+    const tags = /* @__PURE__ */ new Set();
+    const filename = path.basename(artifactPath);
+    const filenameTags = filename.match(/-([a-z]+)-/gi);
+    if (filenameTags) {
+      filenameTags.forEach((tag) => {
+        tags.add(tag.slice(1, -1).toLowerCase());
+      });
+    }
+    const contentStr = content.toString("utf8", 0, Math.min(1024, content.length));
+    const yamlMatch = contentStr.match(/^---\s*\n([\s\S]*?)\n---/m);
+    if (yamlMatch) {
+      const yamlContent = yamlMatch[1] ?? "";
+      const tagMatches = yamlContent.match(/tags?:\s*\[(.*?)\]/i);
+      if (tagMatches) {
+        const list = tagMatches[1] ?? "";
+        list.split(",").forEach((tag) => {
+          const cleanTag = tag.trim().replace(/['"]/g, "");
+          if (cleanTag) tags.add(cleanTag.toLowerCase());
+        });
+      }
+    }
+    return tags;
+  }
+  /**
+   * Archive artifacts before deletion
+   */
+  async archiveArtifacts(artifacts, options = {}) {
+    const dryRun = options.dryRun ?? this.config.dryRun;
+    const startTime = Date.now();
+    let artifactsProcessed = 0;
+    let bytesProcessed = 0;
+    const errors = [];
+    this.emit("cleanup:started", this.config.retentionPolicy);
+    try {
+      const archiveDir = path.join(this.config.basePath, ".archive");
+      if (!dryRun) {
+        await fsp.mkdir(archiveDir, { recursive: true });
+      }
+      const archivePromises = artifacts.map(
+        (artifact) => this.workerPool.execute(() => this.archiveSingleArtifact(artifact, archiveDir, dryRun))
+      );
+      const results = await Promise.allSettled(archivePromises);
+      results.forEach((result, i) => {
+        const artifact = artifacts[i];
+        if (!artifact) {
+          return;
+        }
+        if (result.status === "fulfilled") {
+          artifactsProcessed++;
+          bytesProcessed += artifact.size;
+          this.emit("artifact:archived", artifact, result.value);
+        } else {
+          const error = {
+            code: "ARCHIVE_ERROR",
+            message: `Failed to archive ${artifact.path}: ${result.reason}`,
+            artifactPath: artifact.path,
+            operation: "archive",
+            timestamp: /* @__PURE__ */ new Date(),
+            recoverable: true,
+            suggestion: "Check disk space and permissions"
+          };
+          errors.push(error);
+          this.emit("cleanup:error", error);
+        }
+      });
+      const duration = Date.now() - startTime;
+      const efficiency = artifactsProcessed / artifacts.length;
+      const cleanupResult = {
+        operation: "archive",
+        artifactsProcessed,
+        bytesProcessed,
+        bytesFreed: 0,
+        // Archives don't free space immediately
+        errors,
+        duration,
+        efficiency
+      };
+      this.emit("cleanup:completed", cleanupResult);
+      return cleanupResult;
+    } catch (error) {
+      const cleanupError = {
+        code: "ARCHIVE_BATCH_ERROR",
+        message: `Batch archive failed: ${error instanceof Error ? error.message : String(error)}`,
+        artifactPath: this.config.basePath,
+        operation: "archive",
+        timestamp: /* @__PURE__ */ new Date(),
+        recoverable: true,
+        suggestion: "Check archive directory permissions"
+      };
+      this.emit("cleanup:error", cleanupError);
+      throw error;
+    }
+  }
+  async archiveSingleArtifact(artifact, archiveDir, dryRun) {
+    const archivePath = path.join(archiveDir, `${artifact.id}.${this.config.archiveFormat}`);
+    if (dryRun) {
+      if (this.config.verbose) {
+        console.log(chalk.blue(`[DRY RUN] Would archive ${artifact.path} -> ${archivePath}`));
+      }
+      return archivePath;
+    }
+    try {
+      const content = await fsp.readFile(artifact.path);
+      if (this.config.enableCompression) {
+        const compressed = await compressBuffer(content, "gzip");
+        await fsp.writeFile(archivePath, compressed);
+      } else {
+        await fsp.writeFile(archivePath, content);
+      }
+      if (this.config.retentionPolicy.preserveMetadata) {
+        const metadataPath = `${archivePath}.meta.json`;
+        const metadata = {
+          ...artifact,
+          archivedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          originalSize: artifact.size,
+          compressedSize: this.config.enableCompression ? (await fsp.stat(archivePath)).size : void 0
+        };
+        await fsp.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+      }
+      return archivePath;
+    } catch (error) {
+      throw new Error(`Failed to archive ${artifact.path}: ${error}`);
+    }
+  }
+  /**
+   * Delete artifacts based on retention policy
+   */
+  async deleteArtifacts(artifacts, options = {}) {
+    const dryRun = options.dryRun ?? this.config.dryRun;
+    const startTime = Date.now();
+    let artifactsProcessed = 0;
+    let bytesFreed = 0;
+    const errors = [];
+    try {
+      const deletePromises = artifacts.map(
+        (artifact) => this.workerPool.execute(() => this.deleteSingleArtifact(artifact, dryRun))
+      );
+      const results = await Promise.allSettled(deletePromises);
+      results.forEach((result, i) => {
+        const artifact = artifacts[i];
+        if (!artifact) {
+          return;
+        }
+        if (result.status === "fulfilled") {
+          artifactsProcessed++;
+          bytesFreed += artifact.size;
+          this.emit("artifact:deleted", artifact);
+        } else {
+          const error = {
+            code: "DELETE_ERROR",
+            message: `Failed to delete ${artifact.path}: ${result.reason}`,
+            artifactPath: artifact.path,
+            operation: "delete",
+            timestamp: /* @__PURE__ */ new Date(),
+            recoverable: true,
+            suggestion: "Check file permissions and locks"
+          };
+          errors.push(error);
+          this.emit("cleanup:error", error);
+        }
+      });
+      const duration = Date.now() - startTime;
+      const efficiency = artifacts.length === 0 ? 1 : artifactsProcessed / artifacts.length;
+      const cleanupResult = {
+        operation: "delete",
+        artifactsProcessed,
+        bytesProcessed: 0,
+        bytesFreed,
+        errors,
+        duration,
+        efficiency
+      };
+      this.emit("cleanup:completed", cleanupResult);
+      return cleanupResult;
+    } catch (error) {
+      const cleanupError = {
+        code: "DELETE_BATCH_ERROR",
+        message: `Batch delete failed: ${error instanceof Error ? error.message : String(error)}`,
+        artifactPath: this.config.basePath,
+        operation: "delete",
+        timestamp: /* @__PURE__ */ new Date(),
+        recoverable: true,
+        suggestion: "Check file permissions and system resources"
+      };
+      this.emit("cleanup:error", cleanupError);
+      throw error;
+    }
+  }
+  async deleteSingleArtifact(artifact, dryRun) {
+    if (dryRun) {
+      if (this.config.verbose) {
+        console.log(chalk.red(`[DRY RUN] Would delete ${artifact.path}`));
+      }
+      return;
+    }
+    try {
+      await fsp.unlink(artifact.path);
+    } catch (error) {
+      throw new Error(`Failed to delete ${artifact.path}: ${error}`);
+    }
+  }
+  /**
+   * Main cleanup orchestration method
+   */
+  async cleanup(options = {}) {
+    if (this.isRunning) {
+      throw new Error("Cleanup already in progress");
+    }
+    this.isRunning = true;
+    const results = [];
+    try {
+      const dryRun = options.dryRun ?? this.config.dryRun;
+      if (this.config.verbose) {
+        console.log(chalk.cyan("Scanning for artifacts..."));
+      }
+      const allArtifacts = await this.scanArtifacts();
+      if (allArtifacts.length === 0) {
+        if (this.config.verbose) {
+          console.log(chalk.green("No artifacts found to clean up"));
+        }
+        return results;
+      }
+      const artifactsToClean = this.applyRetentionPolicy(allArtifacts);
+      if (artifactsToClean.length === 0) {
+        if (this.config.verbose) {
+          console.log(chalk.green("No artifacts need cleanup based on retention policy"));
+        }
+        return results;
+      }
+      if (this.config.verbose) {
+        console.log(chalk.yellow(`Found ${artifactsToClean.length} artifacts to clean up`));
+      }
+      let artifactsToDelete = artifactsToClean;
+      if (this.config.retentionPolicy.archiveBeforeDelete && options.archiveFirst !== false) {
+        if (this.config.verbose) {
+          console.log(chalk.blue("Archiving artifacts..."));
+        }
+        const archiveResult = await this.archiveArtifacts(artifactsToClean, { dryRun });
+        results.push(archiveResult);
+        const failedArchivePaths = new Set(archiveResult.errors.map((error) => error.artifactPath));
+        artifactsToDelete = artifactsToClean.filter(
+          (artifact) => !failedArchivePaths.has(artifact.path)
+        );
+        if (this.config.verbose) {
+          console.log(chalk.green(`Archived ${archiveResult.artifactsProcessed} artifacts`));
+          if (failedArchivePaths.size > 0) {
+            console.log(
+              chalk.yellow(
+                `Skipping delete for ${failedArchivePaths.size} artifact(s) that failed to archive`
+              )
+            );
+          }
+        }
+      }
+      if (this.config.verbose) {
+        console.log(chalk.red("Deleting artifacts..."));
+      }
+      const deleteResult = await this.deleteArtifacts(artifactsToDelete, { dryRun });
+      results.push(deleteResult);
+      if (this.config.verbose) {
+        console.log(
+          chalk.green(
+            `Deleted ${deleteResult.artifactsProcessed} artifacts, freed ${formatBytes(deleteResult.bytesFreed)}`
+          )
+        );
+      }
+      return results;
+    } finally {
+      this.isRunning = false;
+      await this.workerPool.close();
+    }
+  }
+  applyRetentionPolicy(artifacts) {
+    const policy = this.config.retentionPolicy;
+    const now = /* @__PURE__ */ new Date();
+    return artifacts.filter((artifact) => {
+      const ageDays = (now.getTime() - artifact.createdAt.getTime()) / (1e3 * 60 * 60 * 24);
+      if (ageDays > policy.maxAgeDays) {
+        return true;
+      }
+      if (artifact.size > policy.maxSizeBytes) {
+        return true;
+      }
+      if (policy.smartAging && artifact.retentionScore < 0.3) {
+        return true;
+      }
+      const hasPriorityTag = Array.from(artifact.tags).some(
+        (tag) => policy.priorityTags.has(tag.toLowerCase())
+      );
+      if (hasPriorityTag) {
+        return false;
+      }
+      return false;
+    });
+  }
+  /**
+   * Get telemetry data
+   */
+  getTelemetry() {
+    return new Map(this.telemetry);
+  }
+  /**
+   * Close the manager and cleanup resources
+   */
+  async close() {
+    await this.workerPool.close();
+    this.removeAllListeners();
+  }
+};
+function createArtifactLifecycleManager(config = {}) {
+  return new ArtifactLifecycleManager(config);
+}
+var DefaultConfigs = {
+  development: {
+    retentionPolicy: {
+      maxAgeDays: 7,
+      maxSizeBytes: 50 * 1024 * 1024,
+      maxCount: 100,
+      archiveBeforeDelete: false
+    },
+    parallelWorkers: 2,
+    enableTelemetry: true
+  },
+  production: {
+    retentionPolicy: {
+      maxAgeDays: 30,
+      maxSizeBytes: 100 * 1024 * 1024,
+      maxCount: 1e3,
+      archiveBeforeDelete: true,
+      preserveMetadata: true
+    },
+    parallelWorkers: 4,
+    enableTelemetry: true,
+    enableSmartAging: true
+  },
+  aggressive: {
+    retentionPolicy: {
+      maxAgeDays: 3,
+      maxSizeBytes: 10 * 1024 * 1024,
+      maxCount: 50,
+      archiveBeforeDelete: false
+    },
+    parallelWorkers: 6,
+    enableTelemetry: false
+  }
+};
+
+// src/orchestrator/pr-manager-core.ts
+function stdoutToString(stdout) {
+  if (stdout === void 0 || stdout === null) {
+    return "";
+  }
+  if (typeof stdout === "string") {
+    return stdout;
+  }
+  if (Array.isArray(stdout)) {
+    return stdout.join("\n");
+  }
+  if (stdout instanceof Uint8Array) {
+    return new TextDecoder().decode(stdout);
+  }
+  return String(stdout);
+}
+function formatGitCommandFailure(operation, result) {
+  const stderr = result.stderr?.trim();
+  const stdout = result.stdout?.trim();
+  const detail = stderr || stdout || "no output";
+  return `${operation} failed with exit code ${result.exitCode ?? "unknown"}: ${detail}`;
+}
+var PRManagerCore = class _PRManagerCore {
+  artifactManager;
+  ghCircuitConfig = {
+    failureThreshold: 3,
+    baseCooldownMs: 15e3,
+    maxCooldownMs: 5 * 6e4
+  };
+  static ghCircuitState = {
+    failureCount: 0,
+    cooldownUntil: 0
+  };
+  static lastCircuitWarningAt = 0;
+  constructor() {
+    this.artifactManager = createArtifactLifecycleManager({
+      basePath: ".poetic/implementations",
+      verbose: false,
+      retentionPolicy: {
+        maxAgeDays: 30,
+        maxSizeBytes: MAX_FILE_SIZE_BYTES,
+        maxCount: MAX_FILE_COUNT,
+        archiveBeforeDelete: true,
+        compressionLevel: 6,
+        preserveMetadata: true,
+        smartAging: true,
+        priorityTags: /* @__PURE__ */ new Set(["critical", "production", "reference"]),
+        exclusionPatterns: [/\.git\//, /node_modules\//, /\.DS_Store$/]
+      }
+    });
+  }
+  /**
+   * Cleanup artifacts after PR operations
+   */
+  async cleanupArtifacts(options = {}) {
+    if (!this.artifactManager) {
+      emitWarning(
+        "CFG-001",
+        {
+          taskId: "unknown",
+          subsystem: "pr-manager",
+          executionPhase: "cleanup"
+        },
+        {
+          metadata: {
+            message: "Artifact manager not initialized"
+          }
+        }
+      );
+      return;
+    }
+    try {
+      const results = await this.artifactManager.cleanup({
+        dryRun: options.dryRun ?? false,
+        force: options.force ?? false,
+        archiveFirst: options.archiveFirst ?? true
+      });
+      if (results.length > 0) {
+        const totalProcessed = results.reduce((sum, result) => sum + result.artifactsProcessed, 0);
+        const totalFreed = results.reduce((sum, result) => sum + result.bytesFreed, 0);
+        console.log(`Cleaned up ${totalProcessed} artifacts, freed ${formatBytes(totalFreed)}`);
+      }
+    } catch (error) {
+      emitWarning(
+        "WS-003",
+        {
+          taskId: "unknown",
+          subsystem: "pr-manager",
+          executionPhase: "cleanup"
+        },
+        {
+          severity: "ERROR" /* ERROR */,
+          metadata: {
+            error: error instanceof Error ? error.message : String(error),
+            operation: "artifactCleanup"
+          }
+        }
+      );
+      throw wrapError(error);
+    }
+  }
+  /**
+   * Get artifact statistics
+   */
+  async getArtifactStats() {
+    if (!this.artifactManager) {
+      return { totalArtifacts: 0, totalSize: 0 };
+    }
+    try {
+      const artifacts = await this.artifactManager.scanArtifacts();
+      const totalSize = artifacts.reduce((sum, artifact) => sum + artifact.size, 0);
+      const dates = artifacts.map((artifact) => artifact.createdAt).sort();
+      return {
+        totalArtifacts: artifacts.length,
+        totalSize,
+        oldestArtifact: dates[0],
+        newestArtifact: dates[dates.length - 1]
+      };
+    } catch (error) {
+      emitWarning(
+        "WS-003",
+        {
+          taskId: "unknown",
+          subsystem: "pr-manager",
+          executionPhase: "validation"
+        },
+        {
+          severity: "ERROR" /* ERROR */,
+          metadata: {
+            error: error instanceof Error ? error.message : String(error),
+            operation: "getArtifactStats"
+          }
+        }
+      );
+      return { totalArtifacts: 0, totalSize: 0 };
+    }
+  }
+  /**
+   * Format bytes to human readable string
+   */
+  /**
+   * Close the manager and cleanup resources
+   */
+  async close() {
+    if (this.artifactManager) {
+      await this.artifactManager.close();
+    }
+  }
+  getRepositoryRoot(cwd) {
+    const startDir = cwd ?? process.cwd();
+    return findProjectRoot(startDir, { honorPoeticRepo: cwd === void 0 }) ?? startDir;
+  }
+  async captureExpectedRemoteSha(branch, repositoryRoot) {
+    if (!isEphemeralPoeticBranchDeletionCandidate(branch)) {
+      return void 0;
+    }
+    try {
+      return await resolveExpectedRemoteShaForQueuedBranch(branch, {
+        remote: "origin",
+        cwd: repositoryRoot
+      });
+    } catch {
+      return void 0;
+    }
+  }
+  async enqueueFailedPRBranchCleanup(options) {
+    const { branch, repositoryRoot, reason, expectedRemoteSha, taskId = "unknown" } = options;
+    if (!isEphemeralPoeticBranchDeletionCandidate(branch)) {
+      return;
+    }
+    try {
+      await enqueueRemoteBranchCleanup(branch, {
+        remote: "origin",
+        reason,
+        expectedRemoteSha,
+        cwd: repositoryRoot
+      });
+    } catch (cleanupError) {
+      emitWarning(
+        "PR-001",
+        { taskId, subsystem: "pr-manager", executionPhase: "cleanup" },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError),
+            branch,
+            operation: "queueFailedPRBranchCleanup"
+          }
+        }
+      );
+    }
+  }
+  async assertCleanForInPlaceCheckout(cwd) {
+    if (await this.isWorkingDirectoryClean(cwd)) {
+      return;
+    }
+    throw new GitError(
+      "Refusing in-place branch checkout because the working tree is dirty. Commit or preserve the changes, or use an isolated worktree, before switching branches."
+    );
+  }
+  /**
+   * Create feature branch and PR for a variant
+   */
+  async createVariantPR(options) {
+    const { taskId, variant, branch, planContent } = options;
+    const repositoryRoot = this.getRepositoryRoot();
+    const baseBranch = options.baseBranch ?? await resolveDefaultBranch(repositoryRoot);
+    let lock = null;
+    let lockReleased = false;
+    const releaseLock = () => {
+      if (!lock || lockReleased) {
+        return;
+      }
+      lockReleased = true;
+      lock.release();
+    };
+    const worktreeManager = getWorktreeManager({ gitCwd: repositoryRoot });
+    let worktreePath = null;
+    let branchPushed = false;
+    let expectedRemoteSha;
+    try {
+      worktreePath = await worktreeManager.create(
+        taskId,
+        branch,
+        variant.strategy,
+        variant.provider
+      );
+      lock = await gitLock.acquire();
+      const placeholderRelativePath = `.poetic/implementations/${variant.provider}-${variant.strategy}-${taskId}.md`;
+      const placeholderPath = path2.join(worktreePath, placeholderRelativePath);
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const placeholderStrategy = resolveVariantStrategy(variant.strategy);
+      const placeholder = `# ${variant.strategy.charAt(0).toUpperCase() + variant.strategy.slice(1)} Implementation for ${taskId}
+
+**Variant**: ${variant.strategy}
+**Provider**: ${variant.provider}
+**Model**: ${variant.model || "default"}
+**Execution Mode**: ${variant.executionMode}
+**Created**: ${timestamp}
+
+## Approach
+${placeholderStrategy.description}
+
+## Status
+- [ ] Implementation started
+- [ ] Tests passing
+- [ ] Coverage >80%
+- [ ] Ready for review
+
+## Plan
+${planContent}
+`;
+      let placeholderCreated = false;
+      const allowPlaceholder = process.env.POETIC_ALLOW_PLACEHOLDER_COMMITS !== "0";
+      if (allowPlaceholder) {
+        await fsp2.mkdir(path2.dirname(placeholderPath), { recursive: true });
+        await fsp2.writeFile(placeholderPath, placeholder, "utf8");
+        await this.runGitMutation(["add", placeholderRelativePath], worktreePath);
+        await this.runGitMutation(
+          [
+            "commit",
+            "--no-verify",
+            "-m",
+            `init: ${taskId} ${variant.strategy} variant placeholder`
+          ],
+          worktreePath
+        );
+        await this.runGitMutation(["push", "-u", "origin", branch], worktreePath);
+        placeholderCreated = true;
+        branchPushed = true;
+        expectedRemoteSha = await this.captureExpectedRemoteSha(branch, repositoryRoot);
+      } else {
+        emitTelemetryFallbackWarning(
+          "Placeholder commits disabled (POETIC_ALLOW_PLACEHOLDER_COMMITS=0); skipping placeholder file creation."
+        );
+      }
+      if (worktreePath) {
+        await worktreeManager.cleanup(worktreePath);
+        worktreePath = null;
+      }
+      releaseLock();
+      const prTitle = `[${taskId}] ${variant.strategy.charAt(0).toUpperCase() + variant.strategy.slice(1)} Implementation (${variant.provider})`;
+      const prBody = `**Variant**: ${variant.strategy}
+**Provider**: ${variant.provider}
+**Model**: ${variant.model || "default"}
+**Execution Mode**: ${variant.executionMode}
+
+## Approach
+${placeholderStrategy.description}
+
+## Status
+ **Draft PR** - Will be marked ready for review after implementation completes.
+ **Do not merge** until after batch evaluation and synthesis.
+
+## Plan
+${planContent}
+${placeholderCreated ? "" : "\n\n**Note**: Placeholder file was omitted because POETIC_ALLOW_PLACEHOLDER_COMMITS=0. Placeholder commits are enabled by default to support local variant execution. Set POETIC_ALLOW_PLACEHOLDER_COMMITS=0 to disable if needed."}
+`;
+      const createResult = await this.runGhCommand(
+        [
+          "pr",
+          "create",
+          "--draft",
+          "--title",
+          prTitle,
+          "--body",
+          prBody,
+          "--base",
+          baseBranch,
+          "--head",
+          branch
+        ],
+        {
+          operationName: "gh pr create",
+          telemetryTags: { phase: "create_pr" },
+          cwd: repositoryRoot
+        }
+      );
+      const stdout = stdoutToString(createResult.stdout);
+      const prUrl = stdout.match(/https:\/\/github\.com[^\s]*\/pull\/\d+[^\s]*/)?.[0];
+      if (!prUrl) {
+        throw new PRCreationError(branch, "Failed to extract PR URL from gh CLI output");
+      }
+      const prNumberMatch = prUrl.match(/\/pull\/(\d+)/);
+      const prNumber = prNumberMatch?.[1] ? parseInt(prNumberMatch[1], 10) : 0;
+      if (!prNumber) {
+        throw new PRCreationError(branch, "Failed to extract PR number from URL");
+      }
+      return {
+        number: prNumber,
+        url: prUrl,
+        branch
+      };
+    } catch (error) {
+      if (worktreePath) {
+        try {
+          await worktreeManager.cleanup(worktreePath);
+        } catch (cleanupError) {
+          emitWarning(
+            "WS-003",
+            {
+              taskId,
+              subsystem: "pr-manager",
+              executionPhase: "cleanup"
+            },
+            {
+              severity: "ERROR" /* ERROR */,
+              metadata: {
+                error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError),
+                worktreePath,
+                operation: "worktreeCleanupOnError"
+              }
+            }
+          );
+        }
+      }
+      if (branchPushed) {
+        await this.enqueueFailedPRBranchCleanup({
+          branch,
+          repositoryRoot,
+          reason: "createVariantPR failed after remote branch push",
+          expectedRemoteSha,
+          taskId
+        });
+      }
+      releaseLock();
+      throw wrapError(error);
+    }
+  }
+  async createDraftPRForBranch(options) {
+    const { branch, title, body, draft = true, timeoutMs } = options;
+    const repositoryRoot = this.getRepositoryRoot();
+    const baseBranch = options.baseBranch ?? await resolveDefaultBranch(repositoryRoot);
+    const expectedRemoteSha = await this.captureExpectedRemoteSha(branch, repositoryRoot);
+    try {
+      const result = await this.runGhCommand(
+        [
+          "pr",
+          "create",
+          ...draft ? ["--draft"] : [],
+          "--title",
+          title,
+          "--body",
+          body,
+          "--base",
+          baseBranch,
+          "--head",
+          branch
+        ],
+        {
+          operationName: "gh pr create",
+          telemetryTags: { phase: "create_pr", branch },
+          cwd: repositoryRoot,
+          ...typeof timeoutMs === "number" ? { timeout: timeoutMs } : {}
+        }
+      );
+      const stdout = stdoutToString(result.stdout);
+      const prUrl = stdout.match(/https:\/\/github\.com[^\s]+/)?.[0];
+      if (!prUrl) {
+        throw new PRCreationError(branch, "Failed to extract PR URL from gh CLI output");
+      }
+      const prNumberMatch = prUrl.match(/\/pull\/(\d+)/);
+      const prNumber = prNumberMatch?.[1] ? parseInt(prNumberMatch[1], 10) : 0;
+      if (!prNumber) {
+        throw new PRCreationError(branch, "Failed to extract PR number from URL");
+      }
+      return {
+        number: prNumber,
+        url: prUrl,
+        branch
+      };
+    } catch (error) {
+      await this.enqueueFailedPRBranchCleanup({
+        branch,
+        repositoryRoot,
+        reason: "createDraftPRForBranch failed",
+        expectedRemoteSha
+      });
+      throw error;
+    }
+  }
+  /**
+   * Get owner/repo from git remote
+   * Returns format: "owner/repo"
+   */
+  async getOwnerRepo() {
+    try {
+      const result = await execa("git", ["remote", "get-url", "origin"]);
+      const match = result.stdout.match(/github\.com[:/](.+\/.+?)(?:\.git)?$/);
+      if (!match || !match[1]) {
+        throw new GitError("Could not determine GitHub owner/repo from git remote");
+      }
+      return match[1];
+    } catch (error) {
+      throw wrapError(error);
+    }
+  }
+  /**
+   * Get PR branch name
+   */
+  async getPRBranch(prNumber) {
+    const result = await this.runGhCommand(
+      ["pr", "view", String(prNumber), "--json", "headRefName", "--jq", ".headRefName"],
+      {
+        operationName: "gh pr view headRefName",
+        telemetryTags: { pr: String(prNumber) }
+      }
+    );
+    return stdoutToString(result.stdout).trim();
+  }
+  /**
+   * Check if branch exists locally
+   */
+  async branchExists(branch, cwd) {
+    try {
+      if (cwd) {
+        await execa("git", ["rev-parse", "--verify", branch], { cwd });
+      } else {
+        await execa("git", ["rev-parse", "--verify", branch]);
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Checkout branch (creates if needed from remote)
+   */
+  async checkoutBranch(branch) {
+    const lock = await gitLock.acquire();
+    try {
+      const repositoryRoot = this.getRepositoryRoot();
+      await this.assertCleanForInPlaceCheckout(repositoryRoot);
+      const exists = await this.branchExists(branch, repositoryRoot);
+      if (exists) {
+        await this.runGitMutation(["checkout", branch], repositoryRoot);
+        await this.runGitMutation(["pull", "origin", branch], repositoryRoot);
+      } else {
+        await this.runGitMutation(["fetch", "origin", branch], repositoryRoot);
+        await this.runGitMutation(["checkout", "-b", branch, `origin/${branch}`], repositoryRoot);
+      }
+      const currentBranch = await this.getCurrentBranch(repositoryRoot);
+      if (currentBranch !== branch) {
+        throw new Error(
+          `Branch checkout validation failed: Expected branch "${branch}", but git is on "${currentBranch}". This indicates the checkout command failed silently. Check git output above.`
+        );
+      }
+    } finally {
+      lock.release();
+    }
+  }
+  /**
+   * Get current git branch
+   */
+  async getCurrentBranch(cwd) {
+    const result = await execa("git", ["branch", "--show-current"], { cwd });
+    return result.stdout.trim();
+  }
+  async runGitMutation(args, cwd) {
+    const result = await execGit(args, { cwd });
+    if (result.exitCode !== 0) {
+      throw new GitError(result.stderr || `git ${args.join(" ")} exited ${result.exitCode}`);
+    }
+    return result;
+  }
+  /**
+   * Check if working directory is clean
+   */
+  async isWorkingDirectoryClean(cwd) {
+    try {
+      const result = await execa("git", ["status", "--porcelain", "--untracked-files=all"], {
+        cwd
+      });
+      return result.stdout.trim().length === 0;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Stage all changes
+   */
+  async stageAll() {
+    const lock = await gitLock.acquire();
+    try {
+      await this.runGitMutation(["add", "."], this.getRepositoryRoot());
+    } finally {
+      lock.release();
+    }
+  }
+  /**
+   * Commit changes
+   */
+  async commit(message) {
+    const lock = await gitLock.acquire();
+    try {
+      await this.runGitMutation(["commit", "-m", message], this.getRepositoryRoot());
+    } finally {
+      lock.release();
+    }
+  }
+  /**
+   * Commit changes to a specific branch with branch validation.
+   *
+   * DEFENSIVE VALIDATION: Verifies we're on the expected branch before committing.
+   */
+  async commitToBranch(branchName, message, cwd) {
+    const lock = await gitLock.acquire();
+    try {
+      const currentBranch = await this.getCurrentBranch(cwd);
+      if (currentBranch !== branchName) {
+        throw new Error(
+          `SAFETY: Prevented commit to wrong branch!
+Expected: ${branchName}
+Current:  ${currentBranch}
+This indicates a git lock race condition. The commit was blocked to prevent data corruption.`
+        );
+      }
+      const commitResult = await execGit(["commit", "-m", message], {
+        cwd: this.getRepositoryRoot(cwd)
+      });
+      if (commitResult.exitCode !== 0) {
+        emitWarning(
+          "PR-001",
+          {
+            taskId: "unknown",
+            subsystem: "pr-manager",
+            executionPhase: "execution"
+          },
+          {
+            severity: "WARN" /* WARN */,
+            metadata: {
+              operation: "gitCommitToBranch",
+              branch: branchName,
+              message,
+              exitCode: commitResult.exitCode,
+              stderr: commitResult.stderr,
+              stdout: commitResult.stdout
+            }
+          }
+        );
+        throw new GitError(formatGitCommandFailure("git commit", commitResult));
+      }
+    } finally {
+      lock.release();
+    }
+  }
+  /**
+   * Push to remote
+   */
+  async push(branch) {
+    const lock = await gitLock.acquire();
+    try {
+      await this.runGitMutation(["push", "origin", branch], this.getRepositoryRoot());
+    } finally {
+      lock.release();
+    }
+  }
+  /**
+   * Get PR URL
+   */
+  async getPRUrl(prNumber) {
+    const result = await this.runGhCommand(
+      ["pr", "view", String(prNumber), "--json", "url", "--jq", ".url"],
+      {
+        operationName: "gh pr view url",
+        telemetryTags: { pr: String(prNumber) }
+      }
+    );
+    return stdoutToString(result.stdout).trim();
+  }
+  /**
+   * Close PR without merging
+   */
+  async closePR(prNumber) {
+    try {
+      await this.runGhCommand(["pr", "close", prNumber.toString()], {
+        operationName: "gh pr close",
+        telemetryTags: { pr: String(prNumber) }
+      });
+    } catch (error) {
+      throw wrapError(error);
+    }
+  }
+  /**
+   * Delete branch (both local and remote)
+   */
+  async deleteBranch(branch, options = {}) {
+    const { deleteLocal = true, deleteRemote = true, force = false, cwd } = options;
+    const repositoryRoot = this.getRepositoryRoot(cwd);
+    const runGit = (args) => this.runGitMutation(args, repositoryRoot);
+    const lock = await gitLock.acquire();
+    try {
+      const currentBranch = await this.getCurrentBranch(cwd);
+      if (currentBranch === branch) {
+        await this.assertCleanForInPlaceCheckout(repositoryRoot);
+        const defaultBranch = await resolveDefaultBranch(repositoryRoot);
+        await runGit(["checkout", defaultBranch]);
+        const { stdout: verifiedBranch } = await runGit(["rev-parse", "--abbrev-ref", "HEAD"]);
+        const normalizedVerified = verifiedBranch.trim() || defaultBranch;
+        if (normalizedVerified !== defaultBranch) {
+          throw new Error(`Branch mismatch: expected ${defaultBranch}, got ${normalizedVerified}`);
+        }
+      }
+      const errors = [];
+      if (deleteLocal) {
+        const exists = await this.branchExists(branch, cwd);
+        if (exists) {
+          try {
+            const deleteFlag = force ? "-D" : "-d";
+            await runGit(["branch", deleteFlag, branch]);
+            console.log(chalk2.green(`  Deleted local branch: ${branch}`));
+          } catch (error) {
+            const errorMsg = `Failed to delete local branch ${branch}: ${error instanceof Error ? error.message : String(error)}`;
+            errors.push(errorMsg);
+            console.log(chalk2.yellow(`  ${errorMsg}`));
+          }
+        }
+      }
+      if (deleteRemote) {
+        try {
+          await runGit(["push", "origin", "--delete", branch]);
+          console.log(chalk2.green(`  Deleted remote branch: ${branch}`));
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          if (isRemoteBranchMissingError(message)) {
+            console.log(chalk2.gray(`  Remote branch ${branch} already absent`));
+          } else {
+            const errorMsg = `Failed to delete remote branch ${branch}: ${message}`;
+            if (isRetryableRemoteDeleteError(message)) {
+              try {
+                const cleanupCwd = cwd ?? findProjectRoot(process.cwd()) ?? process.cwd();
+                const expectedRemoteSha = await resolveExpectedRemoteShaForQueuedBranch(branch, {
+                  remote: "origin",
+                  cwd: cleanupCwd
+                });
+                await enqueueRemoteBranchCleanup(branch, {
+                  remote: "origin",
+                  reason: "deleteBranch(remote)",
+                  expectedRemoteSha,
+                  cwd: cleanupCwd
+                });
+                console.log(
+                  chalk2.yellow(
+                    `  \u21AA Queued remote branch deletion for cleanup: ${branch} (run 'poetic cleanup stale --include-branches --execute')`
+                  )
+                );
+              } catch (_queueErr) {
+              }
+            }
+            errors.push(errorMsg);
+            console.log(chalk2.yellow(`  ${errorMsg}`));
+          }
+        }
+      }
+      if (errors.length > 0) {
+        throw new Error(`Branch deletion failed:
+${errors.join("\n")}`);
+      }
+    } finally {
+      lock.release();
+    }
+  }
+  /**
+   * Find PR by branch name
+   */
+  async findPRByBranch(branch) {
+    try {
+      const result = await this.runGhCommand(
+        [
+          "pr",
+          "list",
+          "--json",
+          "number,url,headRefName",
+          "--jq",
+          `.[] | select(.headRefName == "${branch}")`
+        ],
+        {
+          operationName: "gh pr list",
+          telemetryTags: { branch }
+        }
+      );
+      const stdout = stdoutToString(result.stdout);
+      if (!stdout.trim()) {
+        return null;
+      }
+      const data = parseJsonWithContext(stdout, "GitHub PR info");
+      return {
+        number: data.number ?? 0,
+        url: data.url ?? "",
+        branch: data.headRefName ?? ""
+      };
+    } catch {
+      return null;
+    }
+  }
+  async listOpenPullRequests(limit = 50) {
+    try {
+      const result = await this.runGhCommand(
+        [
+          "pr",
+          "list",
+          "--state",
+          "open",
+          "--json",
+          "number,url,headRefName",
+          "--limit",
+          String(limit)
+        ],
+        {
+          operationName: "gh pr list"
+        }
+      );
+      const stdout = stdoutToString(result.stdout);
+      const trimmed = stdout.trim();
+      if (!trimmed) {
+        return [];
+      }
+      const parsed = parseJsonWithContext(trimmed, "GitHub PR list");
+      return parsed.map((pr) => ({
+        number: Number(pr.number ?? 0),
+        url: pr.url ?? "",
+        branch: pr.headRefName ?? ""
+      })).filter((pr) => pr.number > 0 && pr.branch.trim().length > 0);
+    } catch (error) {
+      const wrapped = wrapError(error, "Failed to list open pull requests");
+      if (wrapped instanceof GitError) {
+        throw wrapped;
+      }
+      throw new GitError(wrapped.message, {
+        operation: "gh pr list"
+      });
+    }
+  }
+  /**
+   * Execute gh command with circuit breaker pattern and timeout
+   *
+   * **CRITICAL FIX (CC-009)**: Added default timeout to prevent hangs.
+   * All GitHub API calls now have 30s timeout unless explicitly overridden.
+   */
+  async runGhCommand(args, options) {
+    const opts = options ?? {};
+    const operationName = opts.operationName;
+    const telemetryTags = opts.telemetryTags;
+    const { operationName: _, telemetryTags: __, ...execaOptions } = opts;
+    const timeout = execaOptions.timeout ?? 3e4;
+    const execaOptionsWithTimeout = {
+      ...execaOptions,
+      timeout,
+      killSignal: "SIGTERM"
+      // Graceful termination on timeout
+    };
+    const now = Date.now();
+    if (_PRManagerCore.ghCircuitState.cooldownUntil && now < _PRManagerCore.ghCircuitState.cooldownUntil) {
+      const remainingMs = _PRManagerCore.ghCircuitState.cooldownUntil - now;
+      try {
+        recordMetric("github_api_circuit_block", 1, {
+          provider: "github",
+          operation: operationName ?? args.join(" ")
+        });
+      } catch {
+      }
+      const seconds = Math.ceil(remainingMs / MS_PER_SECOND);
+      throw new Error(
+        `GitHub API temporarily unavailable (circuit breaker cooldown ${seconds}s remaining)`
+      );
+    }
+    try {
+      const result = await execa("gh", args, execaOptionsWithTimeout);
+      this.resetGhCircuit();
+      return result;
+    } catch (error) {
+      if (error && typeof error === "object" && "timedOut" in error && error.timedOut) {
+        const timeoutError = new Error(
+          `GitHub CLI command timed out after ${timeout}ms: gh ${args.join(" ")}`
+        );
+        this.noteGhFailure(operationName ?? args.join(" "), telemetryTags, timeoutError);
+        throw timeoutError;
+      }
+      this.noteGhFailure(operationName ?? args.join(" "), telemetryTags, error);
+      throw error;
+    }
+  }
+  resetGhCircuit() {
+    if (_PRManagerCore.ghCircuitState.failureCount === 0 && _PRManagerCore.ghCircuitState.cooldownUntil === 0) {
+      return;
+    }
+    _PRManagerCore.ghCircuitState = { failureCount: 0, cooldownUntil: 0 };
+  }
+  noteGhFailure(operationName, telemetryTags, error) {
+    _PRManagerCore.ghCircuitState.failureCount += 1;
+    try {
+      recordMetric("github_api_failure", 1, {
+        provider: "github",
+        operation: operationName,
+        ...telemetryTags
+      });
+    } catch {
+    }
+    const { failureThreshold, baseCooldownMs, maxCooldownMs } = this.ghCircuitConfig;
+    if (_PRManagerCore.ghCircuitState.failureCount >= failureThreshold) {
+      const exponent = _PRManagerCore.ghCircuitState.failureCount - failureThreshold;
+      const backoff = Math.min(baseCooldownMs * 2 ** Math.max(0, exponent), maxCooldownMs);
+      _PRManagerCore.ghCircuitState.cooldownUntil = Date.now() + backoff;
+      const now = Date.now();
+      if (now - _PRManagerCore.lastCircuitWarningAt > CIRCUIT_BREAKER_WARNING_INTERVAL_MS) {
+        emitWarning(
+          "PR-003",
+          {
+            taskId: "unknown",
+            subsystem: "pr-manager",
+            provider: "github",
+            executionPhase: "execution"
+          },
+          {
+            metadata: {
+              operation: operationName,
+              error: error instanceof Error ? error.message : String(error),
+              cooldownSeconds: Math.round(backoff / MS_PER_SECOND),
+              failureCount: _PRManagerCore.ghCircuitState.failureCount
+            }
+          }
+        );
+        _PRManagerCore.lastCircuitWarningAt = now;
+      }
+      try {
+        recordMetric("github_api_circuit_open", 1, {
+          provider: "github",
+          operation: operationName,
+          cooldown_ms: String(backoff),
+          ...telemetryTags
+        });
+      } catch {
+      }
+    }
+  }
+  /**
+   * Execute with retry logic and exponential backoff
+   */
+  async executeWithRetry(operation, operationName, maxRetries = GITHUB_API_RETRY_ATTEMPTS) {
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error;
+        const err = error;
+        const errMsg = err?.message?.toLowerCase() ?? "";
+        const isTransient = err?.code === "ECONNRESET" || err?.code === "ETIMEDOUT" || errMsg.includes("rate limit") || errMsg.includes("secondary rate limit") || matchesErrorPattern(errMsg, "429") || matchesErrorPattern(errMsg, "403") || errMsg.includes("timeout");
+        if (isTransient && attempt < maxRetries) {
+          const backoffMs = Math.min(
+            1e3 * EXPONENTIAL_BACKOFF_MULTIPLIER ** (attempt - 1),
+            GITHUB_API_RETRY_BACKOFF_CAP_MS
+          );
+          emitWarning(
+            "PR-001",
+            {
+              taskId: "unknown",
+              subsystem: "pr-manager",
+              provider: "github",
+              executionPhase: "execution"
+            },
+            {
+              severity: "WARN" /* WARN */,
+              metadata: {
+                operation: operationName,
+                error: err.message || String(error),
+                attempt,
+                maxRetries,
+                backoffMs,
+                isTransient
+              }
+            }
+          );
+          await new Promise((resolve) => setTimeout(resolve, backoffMs));
+        } else {
+          emitWarning(
+            "PR-001",
+            {
+              taskId: "unknown",
+              subsystem: "pr-manager",
+              provider: "github",
+              executionPhase: "execution"
+            },
+            {
+              severity: "ERROR" /* ERROR */,
+              metadata: {
+                operation: operationName,
+                error: err.message || String(error),
+                attempt,
+                exhaustedRetries: true
+              }
+            }
+          );
+          throw lastError ?? new Error(`Retries exhausted for ${operationName}`);
+        }
+      }
+    }
+    if (lastError) {
+      emitWarning(
+        "PR-001",
+        {
+          taskId: "unknown",
+          subsystem: "pr-manager",
+          provider: "github",
+          executionPhase: "execution"
+        },
+        {
+          severity: "ERROR" /* ERROR */,
+          metadata: {
+            operation: operationName,
+            error: lastError.message,
+            exhaustedRetries: true,
+            totalAttempts: maxRetries
+          }
+        }
+      );
+    }
+    throw lastError ?? new Error(`Retries exhausted for ${operationName}`);
+  }
+};
+
+// src/orchestrator/pr-analyzer.ts
+var PRAnalyzer = class {
+  constructor(core) {
+    this.core = core;
+  }
+  core;
+  /**
+   * Get PR statistics (files changed, additions, deletions, commits)
+   */
+  async getPRStats(prNumber) {
+    const result = await this.core.runGhCommand(
+      ["pr", "view", prNumber.toString(), "--json", "additions,deletions,files,commits,url"],
+      {
+        operationName: "gh pr view stats",
+        telemetryTags: { pr: String(prNumber) }
+      }
+    );
+    const stdout = stdoutToString(result.stdout);
+    const data = parseJsonWithContext(stdout, "GitHub PR stats");
+    const files = Array.isArray(data.files) ? data.files.map((file) => file.path || "").filter(Boolean) : [];
+    return {
+      additions: data.additions ?? 0,
+      deletions: data.deletions ?? 0,
+      changedFiles: files.length,
+      commits: Array.isArray(data.commits) ? data.commits.length : 0,
+      url: data.url ?? "",
+      files
+    };
+  }
+  /**
+   * Fetch PR commits for validation
+   */
+  async fetchPRCommits(prNumber) {
+    const result = await this.core.executeWithRetry(async () => {
+      const execResult = await this.core.runGhCommand(
+        [
+          "pr",
+          "view",
+          String(prNumber),
+          "--json",
+          "commits",
+          "--jq",
+          ".commits[] | {sha: .oid, message: .messageHeadline}"
+        ],
+        {
+          operationName: "gh pr view commits",
+          telemetryTags: { pr: String(prNumber) }
+        }
+      );
+      const stdout = stdoutToString(execResult.stdout);
+      if (!stdout.trim()) {
+        return [];
+      }
+      return stdout.trim().split("\n").map((line) => {
+        const parsed = parseJsonWithContext(
+          line,
+          `PR commit line (PR #${prNumber})`
+        );
+        return {
+          sha: String(parsed.sha ?? ""),
+          message: String(parsed.message ?? "")
+        };
+      });
+    }, `fetchPRCommits(PR #${prNumber})`);
+    return result || [];
+  }
+  async getPRCommits(prNumber) {
+    const result = await this.core.executeWithRetry(async () => {
+      const execResult = await this.core.runGhCommand(
+        [
+          "pr",
+          "view",
+          String(prNumber),
+          "--json",
+          "commits",
+          "--jq",
+          ".commits[] | {sha: .oid, message: .messageHeadline, createdAt: .committedDate}"
+        ],
+        {
+          operationName: "gh pr view commits",
+          telemetryTags: { pr: String(prNumber), detail: "timestamps" }
+        }
+      );
+      const stdout = stdoutToString(execResult.stdout);
+      if (!stdout.trim()) {
+        return [];
+      }
+      return stdout.trim().split("\n").map((line) => {
+        const parsed = parseJsonWithContext(line, `PR commit line (PR #${prNumber})`);
+        return {
+          sha: String(parsed.sha ?? ""),
+          message: String(parsed.message ?? ""),
+          createdAt: parsed.createdAt
+        };
+      });
+    }, `getPRCommits(PR #${prNumber})`);
+    return result || [];
+  }
+  /**
+   * Fetch modified files for a specific commit
+   */
+  async fetchCommitFiles(sha) {
+    const result = await this.core.executeWithRetry(async () => {
+      const ownerRepo = await this.core.getOwnerRepo();
+      const execResult = await this.core.runGhCommand(
+        ["api", `/repos/${ownerRepo}/commits/${sha}`, "--jq", ".files[].filename"],
+        {
+          operationName: "gh api commit files",
+          telemetryTags: { commit: sha.slice(0, 7) }
+        }
+      );
+      const stdout = stdoutToString(execResult.stdout);
+      if (!stdout.trim()) {
+        return [];
+      }
+      return stdout.split("\n").filter(Boolean);
+    }, `fetchCommitFiles(${sha})`);
+    return result || [];
+  }
+  /**
+   * Get all modified files across all commits in a PR
+   */
+  async getPRModifiedFiles(prNumber) {
+    const commits = await this.fetchPRCommits(prNumber);
+    if (commits.length === 0) {
+      return [];
+    }
+    const modifiedFilesPerCommit = await Promise.all(
+      commits.map((commit) => this.fetchCommitFiles(commit.sha))
+    );
+    const allFiles = modifiedFilesPerCommit.flat();
+    return Array.from(new Set(allFiles));
+  }
+  /**
+   * Get modified files for PR commits created after a specific timestamp.
+   * Used to prevent stale commits (from previous tasks) from passing validation.
+   */
+  async getPRModifiedFilesAfter(prNumber, after) {
+    const threshold = after.getTime();
+    if (Number.isNaN(threshold)) {
+      return [];
+    }
+    const commits = await this.getPRCommits(prNumber);
+    if (commits.length === 0) {
+      return [];
+    }
+    const recentCommits = commits.filter((commit) => {
+      if (!commit.createdAt) {
+        return false;
+      }
+      const created = new Date(commit.createdAt);
+      return !Number.isNaN(created.getTime()) && created.getTime() > threshold;
+    });
+    if (recentCommits.length === 0) {
+      return [];
+    }
+    const modifiedFilesPerCommit = await Promise.all(
+      recentCommits.map((commit) => this.fetchCommitFiles(commit.sha))
+    );
+    const allFiles = modifiedFilesPerCommit.flat();
+    return Array.from(new Set(allFiles));
+  }
+};
+
+// src/orchestrator/github-pr-manager.ts
+var GitHubPRManager = class {
+  core;
+  analyzer;
+  constructor() {
+    this.core = new PRManagerCore();
+    this.analyzer = new PRAnalyzer(this.core);
+  }
+  // ===== Artifact Management (from PRManagerCore) =====
+  async cleanupArtifacts(options = {}) {
+    return this.core.cleanupArtifacts(options);
+  }
+  async getArtifactStats() {
+    return this.core.getArtifactStats();
+  }
+  async close() {
+    return this.core.close();
+  }
+  // ===== PR Creation and Branch Management (from PRManagerCore) =====
+  async createVariantPR(options) {
+    return this.core.createVariantPR(options);
+  }
+  async createDraftPRForBranch(options) {
+    return this.core.createDraftPRForBranch(options);
+  }
+  async getOwnerRepo() {
+    return this.core.getOwnerRepo();
+  }
+  async checkCursorCloudAvailability() {
+    const status = await this.getCursorCloudPrerequisitesStatus();
+    return status.isAvailable;
+  }
+  async getCursorCloudPrerequisitesStatus() {
+    const missingPrerequisites = [];
+    const suggestions = [];
+    try {
+      await execa2("gh", ["--version"]);
+    } catch {
+      missingPrerequisites.push("GitHub CLI (gh) not installed");
+      suggestions.push("Install GitHub CLI: https://cli.github.com/");
+      return { isAvailable: false, missingPrerequisites, suggestions };
+    }
+    try {
+      await execa2("gh", ["auth", "status"]);
+    } catch {
+      missingPrerequisites.push("GitHub CLI not authenticated");
+      suggestions.push("Run: gh auth login");
+    }
+    try {
+      const { stdout } = await execa2("git", ["remote", "get-url", "origin"]);
+      if (!/github\.com[:/][^/\s]+\/[^/\s]+(?:\.git)?$/i.test(stdout.trim())) {
+        missingPrerequisites.push("No git remote origin configured");
+        suggestions.push("Set up git remote: git remote add origin <github-repo-url>");
+      }
+    } catch {
+      missingPrerequisites.push("No git remote origin configured");
+      suggestions.push("Set up git remote: git remote add origin <github-repo-url>");
+    }
+    return {
+      isAvailable: missingPrerequisites.length === 0,
+      missingPrerequisites,
+      suggestions
+    };
+  }
+  async getPRBranch(prNumber) {
+    return this.core.getPRBranch(prNumber);
+  }
+  async branchExists(branch, cwd) {
+    return this.core.branchExists(branch, cwd);
+  }
+  async checkoutBranch(branch) {
+    return this.core.checkoutBranch(branch);
+  }
+  async getCurrentBranch(cwd) {
+    return this.core.getCurrentBranch(cwd);
+  }
+  async isWorkingDirectoryClean(cwd) {
+    return this.core.isWorkingDirectoryClean(cwd);
+  }
+  async stageAll() {
+    return this.core.stageAll();
+  }
+  async commit(message) {
+    return this.core.commit(message);
+  }
+  async commitToBranch(branchName, message, cwd) {
+    return this.core.commitToBranch(branchName, message, cwd);
+  }
+  async push(branch) {
+    return this.core.push(branch);
+  }
+  async getPRUrl(prNumber) {
+    return this.core.getPRUrl(prNumber);
+  }
+  async closePR(prNumber) {
+    return this.core.closePR(prNumber);
+  }
+  async deleteBranch(branch, options = {}) {
+    return this.core.deleteBranch(branch, options);
+  }
+  async findPRByBranch(branch) {
+    return this.core.findPRByBranch(branch);
+  }
+  async listOpenPullRequests(limit = 50) {
+    return this.core.listOpenPullRequests(limit);
+  }
+  async executeWithRetry(operation, operationName, maxRetries = 3) {
+    return this.core.executeWithRetry(operation, operationName, maxRetries);
+  }
+  // ===== PR Analysis (from PRAnalyzer) =====
+  async getPRStats(prNumber) {
+    return this.analyzer.getPRStats(prNumber);
+  }
+  async fetchPRCommits(prNumber) {
+    return this.analyzer.fetchPRCommits(prNumber);
+  }
+  async getPRCommits(prNumber) {
+    return this.analyzer.getPRCommits(prNumber);
+  }
+  async fetchCommitFiles(sha) {
+    return this.analyzer.fetchCommitFiles(sha);
+  }
+  async getPRModifiedFiles(prNumber) {
+    return this.analyzer.getPRModifiedFiles(prNumber);
+  }
+  async getPRModifiedFilesAfter(prNumber, after) {
+    return this.analyzer.getPRModifiedFilesAfter(prNumber, after);
+  }
+};
+
+export {
+  GitHubPRManager
+};
+//# sourceMappingURL=chunk-VPHVFK4A.js.map