issue-flow 0.11.0 → 0.12.0

package/dist/chunk-DIDUVL6O.js

@@ -0,0 +1,1365 @@
+#!/usr/bin/env node
+import {
+  printInfo
+} from "./chunk-BYZDPR7N.js";
+import {
+  isoNow,
+  pullRequestRefSchema,
+  webConfigSchema,
+  writeFileAtomic
+} from "./chunk-CD5ULRVC.js";
+
+// src/resilience/errors.ts
+var RETRYABLE_KINDS = /* @__PURE__ */ new Set([
+  "network",
+  "timeout",
+  "stalled",
+  "rate_limit",
+  "provider_down",
+  "provider_crash"
+]);
+var HUMAN_ACTION_KINDS = /* @__PURE__ */ new Set([
+  "authentication",
+  "configuration",
+  "repository_state",
+  "task_execution"
+]);
+function isRetryableKind(kind) {
+  return RETRYABLE_KINDS.has(kind);
+}
+function requiresHumanAction(kind) {
+  return HUMAN_ACTION_KINDS.has(kind);
+}
+var ClassifiedError = class extends Error {
+  failure;
+  action;
+  constructor(message, failure, action) {
+    super(message);
+    this.name = "ClassifiedError";
+    this.failure = failure;
+    this.action = action;
+  }
+};
+function failureOf(error) {
+  return error instanceof ClassifiedError ? error.failure : null;
+}
+function actionOf(error) {
+  return error instanceof ClassifiedError ? error.action ?? null : null;
+}
+var ERRNO_KINDS = {
+  ENOTFOUND: "network",
+  EAI_AGAIN: "network",
+  ECONNRESET: "network",
+  ECONNREFUSED: "network",
+  ECONNABORTED: "network",
+  EHOSTUNREACH: "network",
+  ENETUNREACH: "network",
+  ENETDOWN: "network",
+  EPIPE: "network",
+  ETIMEDOUT: "timeout",
+  ENOENT: "configuration",
+  EACCES: "configuration",
+  EPERM: "configuration"
+};
+function kindFromErrno(errno) {
+  if (!errno) return void 0;
+  return ERRNO_KINDS[errno.toUpperCase()];
+}
+function kindFromHttpStatus(status, lowered) {
+  if (status === void 0 || status < 400) return void 0;
+  if (status === 429) return "rate_limit";
+  if (status === 401) return "authentication";
+  if (status === 403)
+    return matchesAny(lowered, RATE_LIMIT_PATTERNS) ? "rate_limit" : "authentication";
+  if (status === 408) return "timeout";
+  if (status >= 500) return "provider_down";
+  return "configuration";
+}
+var CRASH_SIGNALS = /* @__PURE__ */ new Set(["SIGKILL", "SIGABRT", "SIGSEGV", "SIGBUS"]);
+function kindFromTermination(signal) {
+  if (signal.stalled === true) return "stalled";
+  if (signal.timedOut === true) return "timeout";
+  const name = signal.signal?.toUpperCase();
+  if (!name) return void 0;
+  if (name === "SIGTERM") return "timeout";
+  if (CRASH_SIGNALS.has(name)) return "provider_crash";
+  return void 0;
+}
+var EXIT_CODE_KINDS = {
+  75: "provider_down",
+  // EX_TEMPFAIL
+  126: "configuration",
+  // found, not executable
+  127: "configuration",
+  // command not found
+  137: "provider_crash",
+  // 128 + SIGKILL, typically the OOM killer
+  139: "provider_crash"
+  // 128 + SIGSEGV
+};
+function kindFromExitCode(exitCode) {
+  if (exitCode === null || exitCode === void 0) return void 0;
+  return EXIT_CODE_KINDS[exitCode];
+}
+var RATE_LIMIT_PATTERNS = [
+  "rate limit",
+  "rate-limit",
+  "ratelimit",
+  "too many requests",
+  "http 429"
+];
+var TEXT_RULES = [
+  { kind: "rate_limit", patterns: RATE_LIMIT_PATTERNS },
+  {
+    kind: "authentication",
+    patterns: [
+      "authentication failed",
+      "authentication_error",
+      "gh auth login",
+      "not logged into",
+      "bad credentials",
+      "invalid api key",
+      "invalid_api_key",
+      "token expired",
+      "expired token",
+      "unauthorized",
+      "http 401",
+      "http 403"
+    ]
+  },
+  {
+    kind: "network",
+    patterns: [
+      "connection reset",
+      "connection refused",
+      "connection aborted",
+      "network error",
+      "network unavailable",
+      "temporary failure",
+      "econnreset",
+      "econnrefused",
+      "enotfound",
+      "eai_again",
+      "socket hang up",
+      // What Go prints, and therefore what `gh` prints: its network errors
+      // never mention "connection reset", they mention the resolver.
+      "no such host",
+      "dial tcp",
+      "i/o timeout",
+      "tls handshake timeout",
+      "server misbehaving",
+      "error connecting to"
+    ]
+  },
+  // Before the timeout rule: a stall *is* a kind of timeout, and the specific
+  // reading is the useful one — it has its own budget and its own escalation.
+  { kind: "stalled", patterns: ["produced no output for", "(stalled)"] },
+  { kind: "timeout", patterns: ["timed out", "timeout", "etimedout"] },
+  {
+    kind: "provider_down",
+    patterns: [
+      "service unavailable",
+      "temporarily unavailable",
+      "overloaded",
+      "bad gateway",
+      "gateway timeout",
+      "internal server error",
+      "http 500",
+      "http 502",
+      "http 503",
+      "http 504"
+    ]
+  },
+  {
+    kind: "provider_crash",
+    patterns: ["segmentation fault", "core dumped", "out of memory", "killed by signal"]
+  },
+  {
+    kind: "repository_state",
+    patterns: [
+      "unmerged paths",
+      "needs merge",
+      "automatic merge failed",
+      "rebase in progress",
+      "you are in the middle of",
+      "cherry-pick is in progress",
+      "not a git repository"
+    ]
+  },
+  {
+    kind: "configuration",
+    patterns: ["command not found", "unknown flag", "unknown option", "no such file or directory"]
+  },
+  {
+    kind: "task_execution",
+    patterns: [
+      "test failed",
+      "tests failed",
+      "failed tests",
+      "failing test",
+      "assertion failed",
+      "assertionerror",
+      "expect(received)",
+      "typecheck failed",
+      "npm err! test failed",
+      "lint failed",
+      "build failed",
+      "compilation failed",
+      "syntaxerror",
+      "typeerror",
+      "referenceerror",
+      // What a runner actually prints: "Tests  3 failed | 41 passed",
+      // "Test Files  1 failed (12)", "Tests: 2 failed, 8 total".
+      /\b\d+\s+failed\b/
+    ]
+  }
+];
+function matchesAny(lowered, patterns) {
+  return patterns.some(
+    (pattern) => typeof pattern === "string" ? lowered.includes(pattern) : pattern.test(lowered)
+  );
+}
+function kindFromText(lowered) {
+  if (!lowered) return void 0;
+  for (const rule of TEXT_RULES) {
+    if (matchesAny(lowered, rule.patterns)) return rule.kind;
+  }
+  return void 0;
+}
+var RETRY_AFTER_IN_TEXT = /retry[\s-]?after:?\s*(\d+)/i;
+function parseRetryAfter(value, now) {
+  if (value === void 0) return void 0;
+  if (typeof value === "number")
+    return Number.isFinite(value) && value >= 0 ? value * 1e3 : void 0;
+  const trimmed = value.trim();
+  if (trimmed === "") return void 0;
+  if (/^\d+$/.test(trimmed)) return Number(trimmed) * 1e3;
+  const at = Date.parse(trimmed);
+  if (Number.isNaN(at)) return void 0;
+  return at > now ? at - now : void 0;
+}
+function resolveRetryAfterMs(signal, text, now) {
+  const explicit = parseRetryAfter(signal.retryAfter, now);
+  if (explicit !== void 0) return explicit;
+  const inText = RETRY_AFTER_IN_TEXT.exec(text);
+  return inText ? Number(inText[1]) * 1e3 : void 0;
+}
+function combineOutput(signal) {
+  return [signal.stderr, signal.stdout].filter((part) => part && part.trim() !== "").join("\n");
+}
+function describe(signal, text) {
+  const trimmed = text.trim();
+  if (trimmed !== "") return trimmed;
+  if (signal.errno) return `${signal.source} failed with ${signal.errno}`;
+  if (signal.httpStatus !== void 0)
+    return `${signal.source} responded HTTP ${signal.httpStatus}`;
+  if (signal.timedOut === true) return `${signal.source} timed out`;
+  if (signal.signal) return `${signal.source} was terminated by ${signal.signal}`;
+  if (signal.exitCode !== null && signal.exitCode !== void 0) {
+    return `${signal.source} exited with code ${signal.exitCode}`;
+  }
+  return `${signal.source} failed for an unreported reason`;
+}
+function classify(signal, options = {}) {
+  const now = options.now?.() ?? Date.now();
+  const text = combineOutput(signal);
+  const lowered = text.toLowerCase();
+  const kind = kindFromErrno(signal.errno) ?? kindFromHttpStatus(signal.httpStatus, lowered) ?? kindFromTermination(signal) ?? kindFromExitCode(signal.exitCode) ?? kindFromText(lowered) ?? "unknown";
+  const retryAfterMs = resolveRetryAfterMs(signal, text, now);
+  return {
+    kind,
+    message: describe(signal, text),
+    retryable: isRetryableKind(kind),
+    source: signal.source,
+    ...retryAfterMs === void 0 ? {} : { retryAfterMs }
+  };
+}
+
+// src/resilience/policy.ts
+var CONFIG_KEYS = {
+  network: "network",
+  timeout: "timeout",
+  stalled: "stalled",
+  rate_limit: "rateLimit",
+  provider_down: "providerDown",
+  provider_crash: "providerCrash",
+  authentication: "authentication",
+  configuration: "configuration",
+  repository_state: "repositoryState",
+  task_execution: "taskExecution",
+  internal: "internal",
+  unknown: "unknown"
+};
+function retryConfigKey(kind) {
+  return CONFIG_KEYS[kind];
+}
+var RETRY_CONFIG_KEYS = Object.values(CONFIG_KEYS);
+var SECOND = 1e3;
+function policy(overrides) {
+  return {
+    maxAttempts: 0,
+    initialDelayMs: 0,
+    maxDelayMs: 0,
+    backoffFactor: 2,
+    jitter: "full",
+    retryForever: false,
+    failover: "never",
+    failoverAfterAttempts: 2,
+    onExhausted: "fail",
+    ...overrides
+  };
+}
+var BASE_POLICIES = {
+  network: policy({ maxAttempts: 8, initialDelayMs: 2 * SECOND, maxDelayMs: 120 * SECOND }),
+  timeout: policy({
+    maxAttempts: 2,
+    initialDelayMs: 30 * SECOND,
+    maxDelayMs: 120 * SECOND,
+    failover: "after_attempts"
+  }),
+  stalled: policy({
+    maxAttempts: 2,
+    initialDelayMs: 15 * SECOND,
+    maxDelayMs: 15 * SECOND,
+    failover: "after_attempts"
+  }),
+  rate_limit: policy({
+    maxAttempts: 6,
+    initialDelayMs: 60 * SECOND,
+    maxDelayMs: 900 * SECOND,
+    failover: "after_attempts"
+  }),
+  provider_down: policy({
+    maxAttempts: 4,
+    initialDelayMs: 10 * SECOND,
+    maxDelayMs: 300 * SECOND,
+    failover: "after_attempts"
+  }),
+  provider_crash: policy({
+    maxAttempts: 3,
+    initialDelayMs: 5 * SECOND,
+    maxDelayMs: 60 * SECOND,
+    failover: "after_attempts"
+  }),
+  authentication: policy({ maxAttempts: 0, onExhausted: "block" }),
+  configuration: policy({ maxAttempts: 0 }),
+  repository_state: policy({ maxAttempts: 0, onExhausted: "block" }),
+  task_execution: policy({ maxAttempts: 0 }),
+  internal: policy({ maxAttempts: 2, initialDelayMs: 5 * SECOND, maxDelayMs: 5 * SECOND }),
+  unknown: policy({ maxAttempts: 2, initialDelayMs: 5 * SECOND, maxDelayMs: 5 * SECOND })
+};
+var CONTINUOUS_OVERRIDES = {
+  network: { retryForever: true },
+  timeout: { maxAttempts: 3 },
+  stalled: { maxAttempts: 3 },
+  rate_limit: { retryForever: true },
+  provider_down: { retryForever: true, failover: "after_attempts" },
+  provider_crash: { maxAttempts: 5 }
+};
+function resolvePolicy(kind, config = {}) {
+  const base = BASE_POLICIES[kind];
+  const profile = config.profile === "continuous" ? CONTINUOUS_OVERRIDES[kind] : void 0;
+  const user = config.retry?.[retryConfigKey(kind)];
+  const resolved = { ...base, ...profile, ...user };
+  if (!requiresHumanAction(kind)) return sanitize(resolved);
+  return sanitize({
+    ...resolved,
+    maxAttempts: 0,
+    retryForever: false,
+    failover: kind === "authentication" && config.failoverOnAuth === true ? resolved.failover : "never"
+  });
+}
+function sanitize(value) {
+  return {
+    ...value,
+    maxAttempts: Math.max(0, Math.trunc(value.maxAttempts)),
+    initialDelayMs: Math.max(0, value.initialDelayMs),
+    maxDelayMs: Math.max(0, value.maxDelayMs),
+    backoffFactor: value.backoffFactor >= 1 ? value.backoffFactor : 1,
+    failoverAfterAttempts: Math.max(1, Math.trunc(value.failoverAfterAttempts))
+  };
+}
+function shouldRetry(policy2, attemptsMade) {
+  if (policy2.maxAttempts <= 0) return false;
+  if (policy2.retryForever) return true;
+  return attemptsMade < policy2.maxAttempts;
+}
+function computeDelayMs(policy2, attemptsMade, options = {}) {
+  if (options.retryAfterMs !== void 0 && options.retryAfterMs >= 0) {
+    return Math.round(options.retryAfterMs);
+  }
+  const exponent = Math.max(0, attemptsMade - 1);
+  const growth = policy2.initialDelayMs * policy2.backoffFactor ** exponent;
+  const ceiling = Math.min(policy2.maxDelayMs, growth);
+  if (ceiling <= 0) return 0;
+  if (policy2.jitter === "none") return Math.round(ceiling);
+  const random = options.random ?? Math.random;
+  return Math.round(random() * ceiling);
+}
+function abortableDelay(ms, options = {}) {
+  const { signal } = options;
+  if (signal?.aborted === true) return Promise.resolve(false);
+  if (ms <= 0) return Promise.resolve(true);
+  return new Promise((resolve4) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve4(false);
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve4(true);
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/utils/shell.ts
+import { basename } from "path";
+import { execa } from "execa";
+
+// src/resilience/retry.ts
+async function withRetry(fn, options) {
+  const { policy: policy2, evaluate, signal, onAttempt, random } = options;
+  const delay = options.delay ?? abortableDelay;
+  const policyFor = typeof policy2 === "function" ? policy2 : () => policy2;
+  for (let attempt = 1; ; attempt++) {
+    const value = await fn(attempt);
+    const failure = evaluate(value, attempt);
+    if (failure === null) {
+      await onAttempt?.({ attempt, value, failure, willRetry: false, delayMs: 0 });
+      return { value, attempts: attempt, failure: null, exhausted: false, aborted: false };
+    }
+    const active = policyFor(failure);
+    const eligible = failure.retryable && !requiresHumanAction(failure.kind);
+    const willRetry = eligible && shouldRetry(active, attempt);
+    const delayMs = willRetry ? computeDelayMs(active, attempt, { random, retryAfterMs: failure.retryAfterMs }) : 0;
+    await onAttempt?.({ attempt, value, failure, willRetry, delayMs });
+    if (!willRetry) {
+      return { value, attempts: attempt, failure, exhausted: eligible, aborted: false };
+    }
+    if (!await delay(delayMs, { signal })) {
+      return { value, attempts: attempt, failure, exhausted: false, aborted: true };
+    }
+  }
+}
+function fixedBackoffPolicy(maxAttempts, baseSeconds, maxSeconds, overrides = {}) {
+  return {
+    maxAttempts,
+    initialDelayMs: baseSeconds * 1e3,
+    maxDelayMs: maxSeconds * 1e3,
+    backoffFactor: 2,
+    jitter: "none",
+    retryForever: false,
+    failover: "never",
+    failoverAfterAttempts: 2,
+    onExhausted: "fail",
+    ...overrides
+  };
+}
+
+// src/utils/shell.ts
+var SOURCE_BY_COMMAND = {
+  git: "git",
+  gh: "github"
+};
+function inferSource(command) {
+  return SOURCE_BY_COMMAND[basename(command)] ?? "internal";
+}
+var GIT_GLOBAL_OPTIONS_WITH_VALUE = /* @__PURE__ */ new Set([
+  "-C",
+  "-c",
+  "--git-dir",
+  "--work-tree",
+  "--namespace",
+  "--exec-path",
+  "--super-prefix"
+]);
+var DESTRUCTIVE_GIT_COMMANDS = {
+  rebase: true,
+  "cherry-pick": true,
+  revert: true,
+  merge: true,
+  am: true,
+  restore: true,
+  "filter-branch": true,
+  gc: true,
+  prune: true,
+  "update-ref": true,
+  push: ["-f", "--force", "--force-with-lease", "--force-if-includes", "--delete", "--mirror"],
+  reset: ["--hard", "--merge", "--keep"],
+  clean: ["-f", "--force"],
+  checkout: ["-f", "--force", "-B"],
+  switch: ["-f", "--force", "--discard-changes"],
+  branch: ["-d", "-D", "--delete", "-M"],
+  tag: ["-d", "--delete", "-f", "--force"],
+  stash: ["drop", "clear", "pop"],
+  worktree: ["remove", "prune"],
+  submodule: ["deinit"]
+};
+function gitSubcommand(args) {
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === void 0) continue;
+    if (GIT_GLOBAL_OPTIONS_WITH_VALUE.has(arg)) {
+      index++;
+      continue;
+    }
+    if (arg.startsWith("-")) continue;
+    return { name: arg, rest: args.slice(index + 1) };
+  }
+  return null;
+}
+function hasToken(rest, token) {
+  if (token.startsWith("--")) {
+    return rest.some((arg) => arg === token || arg.startsWith(`${token}=`));
+  }
+  if (token.startsWith("-")) {
+    const letter = token.slice(1);
+    return rest.some((arg) => /^-[A-Za-z]+$/.test(arg) && arg.slice(1).includes(letter));
+  }
+  return rest.includes(token);
+}
+function isRetryableInvocation(command, args) {
+  if (basename(command) !== "git") return true;
+  const subcommand = gitSubcommand(args);
+  if (subcommand === null) return true;
+  const rule = DESTRUCTIVE_GIT_COMMANDS[subcommand.name];
+  if (rule === void 0) return true;
+  if (rule === true) return false;
+  return !rule.some((token) => hasToken(subcommand.rest, token));
+}
+function asString(value) {
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function toFailureSignal(raw, result, source) {
+  const fields = raw ?? {};
+  const errno = asString(fields.code);
+  const signal = asString(fields.signal);
+  const stderr = result.stderr.trim() !== "" ? result.stderr : asString(fields.originalMessage) ?? asString(fields.shortMessage) ?? "";
+  return {
+    source,
+    exitCode: result.exitCode,
+    stdout: result.stdout,
+    stderr,
+    ...errno === void 0 ? {} : { errno },
+    ...signal === void 0 ? {} : { signal },
+    ...fields.timedOut === true ? { timedOut: true } : {}
+  };
+}
+async function execOnce(command, args, options) {
+  const raw = await execa(command, args, {
+    reject: false,
+    ...options
+  });
+  return {
+    raw,
+    result: {
+      stdout: raw.stdout?.toString() ?? "",
+      stderr: raw.stderr?.toString() ?? "",
+      exitCode: raw.exitCode ?? 1
+    }
+  };
+}
+async function run(command, args = [], options) {
+  const { retry, source, retrySignal, onRetryAttempt, ...execaOptions } = options ?? {};
+  if (retry === void 0 || !isRetryableInvocation(command, args)) {
+    return (await execOnce(command, args, execaOptions)).result;
+  }
+  const failureSource = source ?? inferSource(command);
+  const outcome = await withRetry(
+    async () => {
+      const { result, raw } = await execOnce(command, args, execaOptions);
+      const failure = result.exitCode === 0 ? null : classify(toFailureSignal(raw, result, failureSource));
+      return { result, failure };
+    },
+    {
+      policy: retry,
+      evaluate: (attempt) => attempt.failure,
+      ...retrySignal === void 0 ? {} : { signal: retrySignal },
+      ...onRetryAttempt === void 0 ? {} : {
+        onAttempt: (info) => onRetryAttempt({
+          attempt: info.attempt,
+          result: info.value.result,
+          failure: info.value.failure,
+          willRetry: info.willRetry,
+          delayMs: info.delayMs
+        })
+      }
+    }
+  );
+  return {
+    ...outcome.value.result,
+    attempts: outcome.attempts,
+    ...outcome.failure === null ? {} : { failure: outcome.failure }
+  };
+}
+
+// src/utils/git.ts
+async function getProjectRoot() {
+  const result = await run("git", ["rev-parse", "--show-toplevel"]);
+  if (result.exitCode !== 0) {
+    throw new Error(
+      "Not inside a git repository. Please run issue-flow from within a git project."
+    );
+  }
+  return result.stdout.trim();
+}
+async function getCurrentBranch() {
+  const result = await run("git", ["branch", "--show-current"]);
+  if (result.exitCode !== 0) {
+    throw new Error(
+      "Failed to detect git branch. Ensure git is installed and you are inside a repository."
+    );
+  }
+  return result.stdout.trim();
+}
+async function getBaseBranch() {
+  const remoteHead = await run("git", ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
+  if (remoteHead.exitCode === 0) {
+    const name = remoteHead.stdout.trim().replace(/^origin\//, "");
+    if (name) return name;
+  }
+  for (const candidate of ["main", "master"]) {
+    const check = await run("git", ["rev-parse", "--verify", "--quiet", `refs/heads/${candidate}`]);
+    if (check.exitCode === 0) return candidate;
+  }
+  return "main";
+}
+async function getRemoteUrl(cwd) {
+  let result;
+  try {
+    result = await run("git", ["remote", "get-url", "origin"], { cwd });
+  } catch {
+    return null;
+  }
+  if (result.exitCode !== 0) return null;
+  const url = result.stdout.trim();
+  return url === "" ? null : url;
+}
+async function getHeadCommit(cwd) {
+  let result;
+  try {
+    result = await run("git", ["rev-parse", "--short", "HEAD"], { cwd });
+  } catch {
+    return null;
+  }
+  if (result.exitCode !== 0) return null;
+  const hash = result.stdout.trim();
+  return hash === "" ? null : hash;
+}
+function normalizeRemoteUrl(url) {
+  if (typeof url !== "string") return null;
+  const trimmed = url.trim();
+  if (trimmed === "") return null;
+  let authority;
+  let path;
+  const scheme = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.exec(trimmed);
+  if (scheme) {
+    const rest = trimmed.slice(scheme[0].length);
+    const slash = rest.indexOf("/");
+    if (slash === -1) return null;
+    authority = rest.slice(0, slash);
+    path = rest.slice(slash + 1);
+  } else {
+    const colon = trimmed.indexOf(":");
+    if (colon === -1) return null;
+    authority = trimmed.slice(0, colon);
+    path = trimmed.slice(colon + 1);
+  }
+  const at = authority.lastIndexOf("@");
+  if (at !== -1) authority = authority.slice(at + 1);
+  const host = authority.replace(/:\d+$/, "").toLowerCase();
+  if (host === "") return null;
+  const normalizedPath = path.replace(/[?#].*$/, "").replace(/\/+/g, "/").replace(/^\/+|\/+$/g, "").replace(/\.git$/i, "").replace(/\/+$/, "").toLowerCase();
+  if (normalizedPath === "") return null;
+  return `${host}/${normalizedPath}`;
+}
+function stripRemoteUrlCredentials(url) {
+  if (typeof url !== "string") return null;
+  const trimmed = url.trim();
+  if (trimmed === "") return null;
+  const httpScheme = /^https?:\/\//i.exec(trimmed);
+  if (!httpScheme) return trimmed;
+  const rest = trimmed.slice(httpScheme[0].length);
+  const slash = rest.indexOf("/");
+  const authority = slash === -1 ? rest : rest.slice(0, slash);
+  const remainder = slash === -1 ? "" : rest.slice(slash);
+  const at = authority.lastIndexOf("@");
+  if (at === -1) return trimmed;
+  return `${httpScheme[0]}${authority.slice(at + 1)}${remainder}`;
+}
+async function getCommitsSince(base) {
+  const result = await run("git", ["log", "--pretty=format:%h%x09%s", `${base}..HEAD`]);
+  if (result.exitCode !== 0) return [];
+  return result.stdout.split("\n").filter((line) => line.trim() !== "").map((line) => {
+    const tab = line.indexOf("	");
+    return tab === -1 ? { hash: line.trim(), subject: "" } : { hash: line.slice(0, tab), subject: line.slice(tab + 1) };
+  });
+}
+async function refExists(ref, cwd) {
+  const result = await run("git", ["rev-parse", "--verify", "--quiet", ref], {
+    ...cwd === void 0 ? {} : { cwd }
+  });
+  return result.exitCode === 0;
+}
+var SEQUENCER_REFS = [
+  {
+    ref: "REBASE_HEAD",
+    kind: "rebase_in_progress",
+    name: "a rebase",
+    suggestion: "git rebase --continue (or git rebase --abort)"
+  },
+  {
+    ref: "MERGE_HEAD",
+    kind: "merge_in_progress",
+    name: "a merge",
+    suggestion: "git merge --continue (or git merge --abort)"
+  },
+  {
+    ref: "CHERRY_PICK_HEAD",
+    kind: "cherry_pick_in_progress",
+    name: "a cherry-pick",
+    suggestion: "git cherry-pick --continue (or git cherry-pick --abort)"
+  },
+  {
+    ref: "REVERT_HEAD",
+    kind: "revert_in_progress",
+    name: "a revert",
+    suggestion: "git revert --continue (or git revert --abort)"
+  }
+];
+async function preflightRepository(options = {}) {
+  const { cwd, expectedBranch, intent = "new-phase" } = options;
+  const at = cwd === void 0 ? {} : { cwd };
+  const blocks = [];
+  for (const sequencer of SEQUENCER_REFS) {
+    if (await refExists(sequencer.ref, cwd)) {
+      blocks.push({
+        kind: sequencer.kind,
+        message: `The repository is in the middle of ${sequencer.name} (${sequencer.ref} is present).`,
+        suggestion: sequencer.suggestion
+      });
+    }
+  }
+  const unmerged = await run("git", ["diff", "--name-only", "--diff-filter=U"], at);
+  const conflicted = unmerged.stdout.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+  if (conflicted.length > 0) {
+    blocks.push({
+      kind: "unmerged_paths",
+      message: `${conflicted.length} file(s) still have unresolved conflicts: ${conflicted.slice(0, 5).join(", ")}${conflicted.length > 5 ? ", \u2026" : ""}.`,
+      suggestion: "Resolve them, then git add the files"
+    });
+  }
+  const symbolic = await run("git", ["symbolic-ref", "-q", "HEAD"], at);
+  const detached = symbolic.exitCode !== 0;
+  const branch = detached ? null : symbolic.stdout.trim().replace(/^refs\/heads\//, "");
+  if (detached) {
+    blocks.push({
+      kind: "detached_head",
+      message: "HEAD is detached, so a commit would belong to no branch.",
+      suggestion: `git switch ${expectedBranch ?? "<branch>"}`
+    });
+  } else if (expectedBranch !== void 0 && expectedBranch !== null && expectedBranch !== "" && branch !== expectedBranch) {
+    blocks.push({
+      kind: "branch_mismatch",
+      message: `The plan works on '${expectedBranch}' but the repository is on '${branch}'.`,
+      suggestion: `git switch ${expectedBranch}`
+    });
+  }
+  const status = await run("git", ["status", "--porcelain"], at);
+  const dirty = status.stdout.trim() !== "";
+  if (dirty && intent !== "resume-same-phase") {
+    blocks.push({
+      kind: "dirty_tree",
+      message: "The working tree has uncommitted changes that do not belong to this phase.",
+      suggestion: "Commit or stash them yourself, then run again"
+    });
+  }
+  return { ok: blocks.length === 0, blocks, branch, dirty };
+}
+function describePreflight(result) {
+  return result.blocks.map((block) => `${block.message} Suggested: ${block.suggestion}`);
+}
+var STORY_ID_IN_SUBJECT = /\bUS-\d+\b/g;
+async function committedStoryIds(baseBranch, cwd) {
+  const at = cwd === void 0 ? {} : { cwd };
+  const range = baseBranch === "" ? "HEAD" : `${baseBranch}..HEAD`;
+  const result = await run("git", ["log", range, "--format=%s"], at);
+  if (result.exitCode !== 0) return /* @__PURE__ */ new Set();
+  const ids = /* @__PURE__ */ new Set();
+  for (const subject of result.stdout.split("\n")) {
+    for (const match of subject.matchAll(STORY_ID_IN_SUBJECT)) {
+      ids.add(match[0]);
+    }
+  }
+  return ids;
+}
+async function isWorkingTreeClean(cwd) {
+  const at = cwd === void 0 ? {} : { cwd };
+  const result = await run("git", ["status", "--porcelain"], at);
+  if (result.exitCode !== 0) return false;
+  return result.stdout.trim() === "";
+}
+
+// src/storage/paths.ts
+import { createHash } from "crypto";
+import { homedir } from "os";
+import { basename as basename2, join, resolve } from "path";
+var GLOBAL_DIR_NAME = ".issue-flow";
+var GLOBAL_ROOT_ENV = "ISSUE_FLOW_HOME";
+var PROJECTS_DIR_NAME = "projects";
+var ISSUES_DIR_NAME = "issues";
+var QUEUES_DIR_NAME = "queues";
+var RUN_LOCK_FILENAME = "run.lock";
+function getGlobalRoot(options = {}) {
+  const env = options.env ?? process.env;
+  const override = env[GLOBAL_ROOT_ENV]?.trim();
+  if (override) {
+    return resolve(override);
+  }
+  let home;
+  try {
+    home = homedir();
+  } catch {
+    home = "";
+  }
+  if (home.trim() === "") {
+    throw new Error(
+      `Unable to resolve the home directory for the global storage. Set ${GLOBAL_ROOT_ENV} to an explicit path.`
+    );
+  }
+  return join(home, GLOBAL_DIR_NAME);
+}
+var SLUG_MAX_LENGTH = 32;
+var HASH_LENGTH = 12;
+var FALLBACK_SLUG = "project";
+function slugify(name) {
+  const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, SLUG_MAX_LENGTH).replace(/-+$/g, "");
+  return slug === "" ? FALLBACK_SLUG : slug;
+}
+function projectIdFromRemote(remote, projectRoot) {
+  let seed;
+  let name;
+  if (remote) {
+    seed = `remote:${remote}`;
+    name = remote.split("/").pop() ?? "";
+  } else {
+    const absolute = resolve(projectRoot);
+    seed = `path:${absolute}`;
+    name = basename2(absolute);
+  }
+  const hash = createHash("sha256").update(seed).digest("hex").slice(0, HASH_LENGTH);
+  return `${slugify(name)}-${hash}`;
+}
+function getProjectDir(projectId, options = {}) {
+  return join(getGlobalRoot(options), PROJECTS_DIR_NAME, projectId);
+}
+function getQueuePaths(projectId, queueId, options = {}) {
+  const queueDir = join(
+    getProjectDir(projectId, options),
+    QUEUES_DIR_NAME,
+    normalizeIssueNumber(queueId)
+  );
+  return { queueDir, planFile: join(queueDir, "execution-plan.json") };
+}
+function normalizeIssueNumber(issueNumber) {
+  const normalized = String(issueNumber).trim().replace(/^#/, "");
+  if (normalized.length === 0) {
+    throw new Error("Issue identifier cannot be empty");
+  }
+  if (/[/\\]/.test(normalized) || normalized === "." || normalized === "..") {
+    throw new Error(`Invalid issue identifier: '${issueNumber}'`);
+  }
+  return normalized;
+}
+function getIssuePaths(projectId, issueNumber, options = {}) {
+  const issueDir = join(
+    getProjectDir(projectId, options),
+    ISSUES_DIR_NAME,
+    normalizeIssueNumber(issueNumber)
+  );
+  return {
+    issueDir,
+    issueFile: join(issueDir, "issue.md"),
+    metadataFile: join(issueDir, "metadata.json"),
+    prdFile: join(issueDir, "prd.md"),
+    tasksFile: join(issueDir, "tasks.json"),
+    progressFile: join(issueDir, "progress.txt"),
+    analysisFile: join(issueDir, "analysis.md"),
+    sessionFile: join(issueDir, "session.json"),
+    // The journal, and the single generation kept when it rotates. The
+    // snapshot above is the projection; this pair is the history.
+    eventsFile: join(issueDir, "events.jsonl"),
+    rotatedEventsFile: join(issueDir, "events.1.jsonl"),
+    // "This issue looks larger than one run": written only when the signals
+    // agree, and read by a person rather than by the pipeline.
+    decompositionFile: join(issueDir, "decomposition.md"),
+    lastBranchFile: join(issueDir, ".last-branch"),
+    archiveDir: join(issueDir, "archive"),
+    prReviewDir: join(issueDir, "pr-review")
+  };
+}
+
+// src/storage/schemas.ts
+import { z } from "zod";
+var STORAGE_SCHEMA_VERSION = 1;
+var userStoryNumberingSourceSchema = z.enum(["history", "start-us", "none"]);
+var userStoryNumberingDecisionSchema = z.object({
+  /** The `US-NNN` number the `plan` prompt was told to continue from. */
+  nextNumber: z.number().int().positive(),
+  source: userStoryNumberingSourceSchema,
+  /** Issue the decision was made for. */
+  issueNumber: z.string().min(1),
+  decidedAt: z.string().min(1),
+  /** Human-readable origin, e.g. the previous story id and issue it came from. */
+  detail: z.string().optional()
+});
+var projectMetadataSchema = z.object({
+  schemaVersion: z.number().int().positive(),
+  projectId: z.string().min(1),
+  root: z.string().min(1),
+  /** Normalized remote (`host/org/repo`), or null when the project has none. */
+  remoteUrl: z.string().nullable(),
+  createdAt: z.string().min(1),
+  updatedAt: z.string().min(1),
+  /** Null until the project is used by a pipeline run. */
+  lastAttemptAt: z.string().nullable(),
+  /**
+   * Most recent User Story numbering decision made by `plan` (issue #36).
+   * Absent on a project whose `plan` never ran through the numbering
+   * resolver, or on a `metadata.json` written before the feature existed.
+   */
+  userStoryNumbering: userStoryNumberingDecisionSchema.optional()
+});
+var webShape = webConfigSchema.shape;
+var globalWebConfigSchema = z.object({
+  port: webShape.port.unwrap(),
+  host: webShape.host.unwrap(),
+  refreshSeconds: webShape.refreshSeconds.unwrap(),
+  logLimit: webShape.logLimit.unwrap()
+}).partial();
+var globalRetryConfigSchema = z.object({
+  retryLimit: z.number().int().nonnegative(),
+  retryForever: z.boolean(),
+  backoffBaseSeconds: z.number().nonnegative(),
+  backoffMaxSeconds: z.number().nonnegative()
+}).partial();
+var resilienceProfileSchema = z.enum([
+  "default",
+  "continuous"
+]);
+var jitterSchema = z.enum(["none", "full"]);
+var failoverModeSchema = z.enum([
+  "never",
+  "after_attempts",
+  "immediate"
+]);
+var exhaustedActionSchema = z.enum(["fail", "block"]);
+var retryPolicyOverrideSchema = z.object({
+  maxAttempts: z.number().int().nonnegative(),
+  initialDelayMs: z.number().nonnegative(),
+  maxDelayMs: z.number().nonnegative(),
+  backoffFactor: z.number().min(1),
+  jitter: jitterSchema,
+  retryForever: z.boolean(),
+  failover: failoverModeSchema,
+  failoverAfterAttempts: z.number().int().positive(),
+  onExhausted: exhaustedActionSchema
+}).partial();
+var retryOverridesByKind = {
+  network: retryPolicyOverrideSchema,
+  timeout: retryPolicyOverrideSchema,
+  stalled: retryPolicyOverrideSchema,
+  rateLimit: retryPolicyOverrideSchema,
+  providerDown: retryPolicyOverrideSchema,
+  providerCrash: retryPolicyOverrideSchema,
+  authentication: retryPolicyOverrideSchema,
+  configuration: retryPolicyOverrideSchema,
+  repositoryState: retryPolicyOverrideSchema,
+  taskExecution: retryPolicyOverrideSchema,
+  internal: retryPolicyOverrideSchema,
+  unknown: retryPolicyOverrideSchema
+};
+var resilienceRetryConfigSchema = z.object(retryOverridesByKind).partial();
+var resilienceProvidersConfigSchema = z.object({
+  failover: z.boolean(),
+  chain: z.array(z.string().min(1)),
+  cooldownMs: z.number().nonnegative()
+}).partial();
+var resilienceQueueConfigSchema = z.object({
+  onIssueFailure: z.enum(["stop", "skip", "block"]),
+  maxIssueAttempts: z.number().int().positive()
+}).partial();
+var resilienceWatchdogConfigSchema = z.object({
+  inactivityTimeoutMs: z.number().int().nonnegative()
+}).partial();
+var resilienceJournalConfigSchema = z.object({
+  enabled: z.boolean(),
+  maxFileBytes: z.number().int().positive()
+}).partial();
+var resilienceDecomposeConfigSchema = z.object({
+  auto: z.boolean()
+}).partial();
+var resilienceConfigSchema = z.object({
+  profile: resilienceProfileSchema,
+  /** Whether a credential failure may migrate to another provider. */
+  failoverOnAuth: z.boolean(),
+  retry: resilienceRetryConfigSchema,
+  providers: resilienceProvidersConfigSchema,
+  queue: resilienceQueueConfigSchema,
+  watchdog: resilienceWatchdogConfigSchema,
+  journal: resilienceJournalConfigSchema,
+  decompose: resilienceDecomposeConfigSchema
+}).partial();
+var globalCommitConfigSchema = z.object({
+  signoff: z.boolean(),
+  conventional: z.boolean()
+}).partial();
+var globalConfigSchema = z.object({
+  schemaVersion: z.number().int().positive(),
+  /** Override for the directory holding `projects/`. */
+  storageDir: z.string().min(1),
+  web: globalWebConfigSchema,
+  retry: globalRetryConfigSchema,
+  commit: globalCommitConfigSchema,
+  resilience: resilienceConfigSchema
+}).partial();
+var webLockSchema = z.object({
+  pid: z.number().int().positive(),
+  port: z.number().int().positive(),
+  host: z.string().min(1),
+  startedAt: z.string().min(1)
+});
+var runLockSchema = z.object({
+  pid: z.number().int().positive(),
+  /** `os.hostname()`. A pid only means something on the host that wrote it. */
+  host: z.string().min(1),
+  /** The issue (or queue) identifier the owner is running. */
+  target: z.string().min(1),
+  startedAt: z.string().min(1),
+  lastHeartbeatAt: z.string().min(1)
+});
+var executionPlanIssueSchema = z.object({
+  id: z.string().min(1),
+  number: z.number().int().positive().nullable(),
+  title: z.string(),
+  url: z.string().nullable(),
+  source: z.string().min(1),
+  position: z.number().int().positive(),
+  // `blocked` and `skipped` are additive: no plan written before them can
+  // carry one, and a reader that does not know them was never given one.
+  status: z.enum(["pending", "in_progress", "completed", "failed", "blocked", "skipped"]),
+  origin: z.enum(["requested", "discovered"]),
+  dependsOn: z.array(z.string()).default([]),
+  parent: z.string().nullable().default(null),
+  priority: z.enum(["high", "medium", "low"]).nullable().default(null),
+  heuristic: z.boolean().default(false),
+  failedPhase: z.string().nullable().default(null),
+  lastError: z.object({ category: z.string(), message: z.string(), at: z.string() }).nullable().default(null),
+  startedAt: z.string().nullable().default(null),
+  completedAt: z.string().nullable().default(null),
+  // Both default, so an execution-plan.json written by an earlier release
+  // parses unchanged and reads as "never attempted, not blocked".
+  attempts: z.number().int().min(0).default(0),
+  blockedReason: z.string().nullable().default(null)
+});
+var executionPlanSchema = z.object({
+  schemaVersion: z.literal(1),
+  id: z.string().min(1),
+  project: z.string().min(1),
+  requested: z.array(z.string().min(1)),
+  branchName: z.string().nullable().default(null),
+  noBranch: z.boolean().default(false),
+  prReview: z.boolean().default(false),
+  status: z.enum(["pending", "in_progress", "completed", "failed"]),
+  createdAt: z.string().min(1),
+  updatedAt: z.string().min(1),
+  truncated: z.boolean().default(false),
+  issues: z.array(executionPlanIssueSchema),
+  excluded: z.array(
+    z.object({
+      id: z.string().min(1),
+      number: z.number().int().positive().nullable(),
+      title: z.string(),
+      url: z.string().nullable(),
+      reason: z.string()
+    })
+  ).default([]),
+  pullRequest: pullRequestRefSchema.optional()
+});
+
+// src/storage/resolve.ts
+import { stat as stat2 } from "fs/promises";
+import { basename as basename3, join as join3, resolve as resolve3 } from "path";
+
+// src/storage/compat.ts
+import { copyFile, mkdir, readdir, readFile, stat } from "fs/promises";
+import { join as join2, resolve as resolve2, sep } from "path";
+var LEGACY_ISSUES_DIR_NAME = "issues";
+var METADATA_FILENAME = "metadata.json";
+async function directoryExists(path) {
+  try {
+    return (await stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveStorageMode(projectRoot, options = {}) {
+  const remoteUrl = normalizeRemoteUrl(await getRemoteUrl(projectRoot));
+  const projectId = projectIdFromRemote(remoteUrl, projectRoot);
+  const globalDir = getProjectDir(projectId, options);
+  const legacyDir = join2(resolve2(projectRoot), LEGACY_ISSUES_DIR_NAME);
+  const [globalExists, legacyExists] = await Promise.all([
+    directoryExists(globalDir),
+    directoryExists(legacyDir)
+  ]);
+  return {
+    // Only one state calls for work: legacy content that has nowhere to be read
+    // from yet. Everything else — including "neither exists" — is already the
+    // global layout.
+    mode: legacyExists && !globalExists ? "needs-migration" : "global",
+    projectId,
+    globalDir,
+    legacyDir,
+    globalExists,
+    legacyExists,
+    remoteUrl
+  };
+}
+function migrationFailure(issue, relativePath, err) {
+  const reason = err instanceof Error ? err.message : String(err);
+  return new Error(
+    `Failed to migrate '${relativePath}' (issue '${issue}'): ${reason}. The legacy directory was left untouched \u2014 fix the cause and run the migration again.`
+  );
+}
+function issueOf(relativePath) {
+  return relativePath.split(sep)[0] || ".";
+}
+async function copyTree(sourceRoot, targetRoot, relativeDir, result) {
+  const source = join2(sourceRoot, relativeDir);
+  const target = join2(targetRoot, relativeDir);
+  let entries;
+  try {
+    entries = await readdir(source, { withFileTypes: true });
+  } catch (err) {
+    throw migrationFailure(issueOf(relativeDir), relativeDir || ".", err);
+  }
+  try {
+    await mkdir(target, { recursive: true });
+  } catch (err) {
+    throw migrationFailure(issueOf(relativeDir), relativeDir || ".", err);
+  }
+  for (const entry of entries) {
+    const relativePath = join2(relativeDir, entry.name);
+    if (entry.isDirectory()) {
+      await copyTree(sourceRoot, targetRoot, relativePath, result);
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    const to = join2(targetRoot, relativePath);
+    try {
+      if (await pathExists(to)) {
+        result.skipped.push(relativePath);
+        continue;
+      }
+      await copyFile(join2(sourceRoot, relativePath), to);
+      result.copied.push(relativePath);
+    } catch (err) {
+      throw migrationFailure(issueOf(relativePath), relativePath, err);
+    }
+  }
+}
+async function readExistingMetadata(file) {
+  let raw;
+  try {
+    raw = await readFile(file, "utf-8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = projectMetadataSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+async function migrateLegacyStorage(projectRoot, options = {}) {
+  const status = await resolveStorageMode(projectRoot, { env: options.env });
+  const result = { copied: [], skipped: [] };
+  try {
+    await mkdir(status.globalDir, { recursive: true });
+  } catch (err) {
+    throw migrationFailure(".", status.globalDir, err);
+  }
+  if (status.legacyExists) {
+    await copyTree(status.legacyDir, join2(status.globalDir, ISSUES_DIR_NAME), "", result);
+  }
+  const now = (options.now ?? isoNow)();
+  const metadataFile = join2(status.globalDir, METADATA_FILENAME);
+  const existing = await readExistingMetadata(metadataFile);
+  const metadata = {
+    schemaVersion: STORAGE_SCHEMA_VERSION,
+    projectId: status.projectId,
+    root: resolve2(projectRoot),
+    remoteUrl: status.remoteUrl,
+    // The project was first seen whenever it was first written, not now.
+    createdAt: existing?.createdAt ?? now,
+    updatedAt: now,
+    lastAttemptAt: existing?.lastAttemptAt ?? null
+  };
+  await writeFileAtomic(metadataFile, `${JSON.stringify(metadata, null, 2)}
+`);
+  return {
+    projectId: status.projectId,
+    globalDir: status.globalDir,
+    legacyDir: status.legacyDir,
+    previousMode: status.mode,
+    ...result,
+    metadataFile,
+    metadata
+  };
+}
+async function recordUserStoryNumbering(projectRoot, decision, options = {}) {
+  const status = await resolveStorageMode(projectRoot, { env: options.env });
+  const metadataFile = join2(status.globalDir, METADATA_FILENAME);
+  const existing = await readExistingMetadata(metadataFile);
+  const now = (options.now ?? isoNow)();
+  const metadata = {
+    schemaVersion: STORAGE_SCHEMA_VERSION,
+    projectId: status.projectId,
+    root: resolve2(projectRoot),
+    remoteUrl: status.remoteUrl,
+    createdAt: existing?.createdAt ?? now,
+    updatedAt: now,
+    lastAttemptAt: existing?.lastAttemptAt ?? null,
+    userStoryNumbering: decision
+  };
+  await mkdir(status.globalDir, { recursive: true });
+  await writeFileAtomic(metadataFile, `${JSON.stringify(metadata, null, 2)}
+`);
+}
+
+// src/storage/resolve.ts
+var projectCache = /* @__PURE__ */ new Map();
+var checkedIssues = /* @__PURE__ */ new Set();
+async function directoryExists2(path) {
+  try {
+    return (await stat2(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function announceMigration(result) {
+  if (result.copied.length === 0) return;
+  const count = result.copied.length;
+  const target = join3(result.globalDir, ISSUES_DIR_NAME);
+  printInfo(
+    `Migrated ${count} file${count === 1 ? "" : "s"} from ${result.legacyDir} to ${target}`
+  );
+  printInfo(
+    `The legacy directory was not modified or removed \u2014 ${result.legacyDir} is kept as-is, read-only, for compatibility.`
+  );
+}
+async function resolveProject(projectRoot, options) {
+  const status = await resolveStorageMode(projectRoot, options);
+  if (status.mode === "needs-migration") {
+    announceMigration(await migrateLegacyStorage(projectRoot, options));
+  }
+  return {
+    projectId: status.projectId,
+    legacyDir: status.legacyDir
+  };
+}
+function getProjectResolution(projectRoot, options) {
+  const key = `${getGlobalRoot(options)}::${projectRoot}`;
+  const cached = projectCache.get(key);
+  if (cached) return cached;
+  const pending = resolveProject(projectRoot, options).catch((err) => {
+    projectCache.delete(key);
+    throw err;
+  });
+  projectCache.set(key, pending);
+  return pending;
+}
+async function resolveProjectPaths(options = {}) {
+  const { projectRoot: projectRootOption, ...rootOptions } = options;
+  const projectRoot = resolve3(projectRootOption ?? await getProjectRoot());
+  const project = await getProjectResolution(projectRoot, rootOptions);
+  const projectDir = getProjectDir(project.projectId, rootOptions);
+  return {
+    projectId: project.projectId,
+    projectDir,
+    issuesDir: join3(projectDir, ISSUES_DIR_NAME),
+    runLockFile: join3(projectDir, RUN_LOCK_FILENAME)
+  };
+}
+async function resolveQueuePaths(queueId, options = {}) {
+  const { projectRoot: projectRootOption, ...rootOptions } = options;
+  const projectRoot = resolve3(projectRootOption ?? await getProjectRoot());
+  const project = await getProjectResolution(projectRoot, rootOptions);
+  return getQueuePaths(project.projectId, queueId, rootOptions);
+}
+async function resolveIssuePaths(issueNumber, options = {}) {
+  const { projectRoot: projectRootOption, ...rootOptions } = options;
+  const projectRoot = resolve3(projectRootOption ?? await getProjectRoot());
+  const project = await getProjectResolution(projectRoot, rootOptions);
+  const paths = getIssuePaths(project.projectId, issueNumber, rootOptions);
+  if (!checkedIssues.has(paths.issueDir)) {
+    const legacyIssueDir = join3(project.legacyDir, basename3(paths.issueDir));
+    if (!await directoryExists2(paths.issueDir) && await directoryExists2(legacyIssueDir)) {
+      announceMigration(await migrateLegacyStorage(projectRoot, rootOptions));
+    }
+    checkedIssues.add(paths.issueDir);
+  }
+  return paths;
+}
+
+export {
+  requiresHumanAction,
+  ClassifiedError,
+  failureOf,
+  actionOf,
+  classify,
+  RETRY_CONFIG_KEYS,
+  resolvePolicy,
+  withRetry,
+  fixedBackoffPolicy,
+  run,
+  getProjectRoot,
+  getCurrentBranch,
+  getBaseBranch,
+  getRemoteUrl,
+  getHeadCommit,
+  normalizeRemoteUrl,
+  stripRemoteUrlCredentials,
+  getCommitsSince,
+  preflightRepository,
+  describePreflight,
+  committedStoryIds,
+  isWorkingTreeClean,
+  PROJECTS_DIR_NAME,
+  ISSUES_DIR_NAME,
+  QUEUES_DIR_NAME,
+  getGlobalRoot,
+  getIssuePaths,
+  resilienceConfigSchema,
+  globalConfigSchema,
+  webLockSchema,
+  runLockSchema,
+  executionPlanSchema,
+  recordUserStoryNumbering,
+  resolveProjectPaths,
+  resolveQueuePaths,
+  resolveIssuePaths
+};
+//# sourceMappingURL=chunk-DIDUVL6O.js.map