@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-3H3EY6U7.js

@@ -0,0 +1,1225 @@
+import {
+  resolveTaskStatusForStageOutcome
+} from "./chunk-FSJ5TTZ3.js";
+import {
+  mapGateStagesToExecutionStages
+} from "./chunk-YTVVTIWJ.js";
+import {
+  resolvePlanArtifactPath
+} from "./chunk-V3YFFHDR.js";
+import {
+  addTaskToSprint,
+  calculateCapacity,
+  checkCapacityWarning,
+  createSprint,
+  listSprints,
+  listTasksInSprint,
+  refreshSprintLock,
+  removeTaskFromSprint
+} from "./chunk-L2CBG5IX.js";
+import {
+  clearArchivedTaskIndex,
+  createTask,
+  getAllTasks,
+  getTask,
+  updateTaskStatusWithTransitionValidation
+} from "./chunk-7LHJDJB3.js";
+import {
+  getPlanningRoot,
+  withIndexRegeneration,
+  withPlanningLock
+} from "./chunk-CSXLLEGB.js";
+import {
+  getBucketArchivePathByKind,
+  getBucketPathByKind
+} from "./chunk-V3KLVK7B.js";
+import {
+  getProjectRoot
+} from "./chunk-6TRD7TEE.js";
+import {
+  signalCoordinator
+} from "./chunk-GC4CRMTS.js";
+import {
+  evaluateStaleReclaim
+} from "./chunk-P7CQGPLS.js";
+import {
+  redactBlockerContext
+} from "./chunk-XV7NZL4B.js";
+import {
+  listMarkdownFilesRecursiveStrict,
+  readMarkdownFile,
+  writeMarkdownFile
+} from "./chunk-352PCJLK.js";
+import {
+  processIsAlive
+} from "./chunk-MT2WAIR3.js";
+import {
+  isQuietOutputRequested,
+  shouldShowLifecycleDiagnostics
+} from "./chunk-XWIZ6B5S.js";
+import {
+  emitCustomWarning,
+  findRepoRoot
+} from "./chunk-7VRJHTGZ.js";
+
+// src/planning/sprint-bridge.ts
+import * as fs4 from "fs";
+import * as fsp2 from "fs/promises";
+import * as path4 from "path";
+
+// src/planning/blocker-telemetry.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+async function appendJsonLine(filePath, line) {
+  const handle = await fs.open(filePath, "a");
+  try {
+    await handle.writeFile(line, "utf-8");
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+function getTelemetryDir() {
+  const buildDir = process.env.BUILD_TELEMETRY_DIR || path.join(getProjectRoot(), ".build-project");
+  return path.join(buildDir, "telemetry");
+}
+async function emitBlockerTelemetryEvent(event) {
+  try {
+    const dir = getTelemetryDir();
+    await fs.mkdir(dir, { recursive: true });
+    const filePath = path.join(dir, "blocker-events.jsonl");
+    const line = redactBlockerContext(JSON.stringify(event));
+    await appendJsonLine(filePath, `${line}
+`);
+  } catch {
+  }
+}
+function emitBlockerDetected(runId, blockerId, category, severity, stageIds) {
+  return emitBlockerTelemetryEvent({
+    event: "blocker_detected",
+    runId,
+    blockerId,
+    category,
+    severity,
+    stageIds,
+    timestamp: Date.now()
+  });
+}
+function emitBlockerRuntimeFailure(runId, stageId, options = {}) {
+  return emitBlockerTelemetryEvent({
+    event: "blocker_runtime_failure",
+    runId,
+    blockerId: options.blockerId ?? `runtime:${stageId}`,
+    category: options.category ?? "credentials",
+    severity: options.severity ?? "nice_to_have",
+    stageIds: [stageId],
+    runtimeFailureStageId: stageId,
+    timestamp: Date.now()
+  });
+}
+function emitSprintBridgeCreated(runId, sprintId, taskCount, planArtifactPath) {
+  return emitBlockerTelemetryEvent({
+    event: "sprint_bridge_created",
+    runId,
+    sprintId,
+    taskCount,
+    planArtifactPath,
+    timestamp: Date.now()
+  });
+}
+function emitPlanProvenanceMissing(runId, sprintId, taskCount) {
+  return emitBlockerTelemetryEvent({
+    event: "plan_provenance_missing",
+    runId,
+    sprintId,
+    taskCount,
+    timestamp: Date.now()
+  });
+}
+function emitSprintBridgeTaskStatusUpdated(runId, sprintId, taskId, fromStatus, toStatus) {
+  return emitBlockerTelemetryEvent({
+    event: "sprint_bridge_task_status_updated",
+    runId,
+    sprintId,
+    taskId,
+    fromStatus,
+    toStatus,
+    timestamp: Date.now()
+  });
+}
+function emitSprintBridgeRolledBack(runId, sprintId, taskCount) {
+  return emitBlockerTelemetryEvent({
+    event: "sprint_bridge_rolled_back",
+    runId,
+    sprintId,
+    taskCount,
+    rollbackStatus: "success",
+    timestamp: Date.now()
+  });
+}
+function emitSprintBridgeRollbackFailed(runId, sprintId, taskCount, errorMessage) {
+  return emitBlockerTelemetryEvent({
+    event: "sprint_bridge_rollback_failed",
+    runId,
+    sprintId,
+    taskCount,
+    rollbackStatus: "failed",
+    errorMessage,
+    timestamp: Date.now()
+  });
+}
+function emitDecompositionCost(runId, provider, model, durationMs, tokenUsage, timing) {
+  return emitBlockerTelemetryEvent({
+    event: "decomposition_cost",
+    runId,
+    provider,
+    model,
+    durationMs,
+    firstOutputMs: timing?.firstOutputMs,
+    longestSilentSpanMs: timing?.longestSilentSpanMs,
+    tokenUsage,
+    timestamp: Date.now()
+  });
+}
+function emitTaskTypeOverride(options) {
+  return emitBlockerTelemetryEvent({
+    event: "task_type_override",
+    ...options,
+    timestamp: Date.now()
+  });
+}
+function emitSplitShadowComparison(options) {
+  return emitBlockerTelemetryEvent({
+    event: "split_shadow_comparison",
+    ...options,
+    timestamp: Date.now()
+  });
+}
+
+// src/planning/ingest-lock.ts
+import { randomUUID } from "crypto";
+import * as fs2 from "fs/promises";
+import * as os from "os";
+import * as path2 from "path";
+var DEFAULTS = {
+  timeoutMs: 6e4,
+  staleThresholdMs: 3e5,
+  initialRetryMs: 50,
+  maxRetryMs: 2e3,
+  backoffFactor: 2
+};
+var CROSS_HOST_STALE_MULTIPLIER = 3;
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function getHostIdentity() {
+  const envHostname = process.env.HOSTNAME?.trim();
+  return envHostname || os.hostname() || "unknown";
+}
+async function readLockPayload(lockFile) {
+  const read = await readLockPayloadWithRaw(lockFile);
+  return read?.payload ?? null;
+}
+async function readLockPayloadWithRaw(lockFile) {
+  try {
+    const content = await fs2.readFile(lockFile, "utf-8");
+    let payload = null;
+    try {
+      payload = JSON.parse(content);
+    } catch {
+      payload = null;
+    }
+    return { payload, rawContent: content };
+  } catch {
+    return null;
+  }
+}
+async function isLockStaleAndAbandoned(lockFile, staleThresholdMs) {
+  try {
+    const stat2 = await fs2.stat(lockFile);
+    const ageMs = Date.now() - stat2.mtimeMs;
+    const read = await readLockPayloadWithRaw(lockFile);
+    if (!read) {
+      return null;
+    }
+    const payload = read.payload;
+    let holder = null;
+    if (payload && typeof payload.pid === "number") {
+      const currentHostname = getHostIdentity();
+      const hasUnknownHost = payload.hostname === "unknown" || currentHostname === "unknown";
+      const sameHost = !hasUnknownHost && payload.hostname === currentHostname;
+      holder = { sameHost, pidAlive: sameHost ? processIsAlive(payload.pid) : false };
+    }
+    const decision = evaluateStaleReclaim(
+      { ageMs, holder },
+      {
+        staleMs: staleThresholdMs,
+        corruptPayload: "reclaim",
+        foreignHost: { kind: "after-multiplier", multiplier: CROSS_HOST_STALE_MULTIPLIER },
+        // Preserve the original strict-greater-than age boundary (age <= stale
+        // holds; reclaim only strictly past stale / past 3x for foreign hosts).
+        ageBoundary: "gt"
+      }
+    );
+    return decision === "reclaim" ? { dev: stat2.dev, ino: stat2.ino, rawContent: read.rawContent } : null;
+  } catch {
+    return null;
+  }
+}
+async function releaseOwnLock(lockFile, snapshot) {
+  try {
+    if (!await lockSnapshotStillMatches(lockFile, snapshot)) {
+      return;
+    }
+    try {
+      await fs2.unlink(lockFile);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+      }
+    }
+  } finally {
+    await snapshot.fileHandle?.close().catch(() => {
+    });
+  }
+}
+async function lockSnapshotStillMatches(lockFile, snapshot) {
+  try {
+    const [openFileStat, stat2, rawContent] = await Promise.all([
+      snapshot.fileHandle?.stat(),
+      fs2.stat(lockFile),
+      fs2.readFile(lockFile, "utf-8")
+    ]);
+    const acquiredDev = openFileStat?.dev ?? snapshot.dev;
+    const acquiredIno = openFileStat?.ino ?? snapshot.ino;
+    return stat2.dev === acquiredDev && stat2.ino === acquiredIno && rawContent === snapshot.rawContent;
+  } catch {
+    return false;
+  }
+}
+async function forceRelease(lockFile, snapshot) {
+  if (!await lockSnapshotStillMatches(lockFile, snapshot)) {
+    return;
+  }
+  try {
+    await fs2.unlink(lockFile);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+async function withIngestLock(planningRoot, fn, options) {
+  const timeoutMs = options?.timeoutMs ?? DEFAULTS.timeoutMs;
+  const staleThresholdMs = options?.staleThresholdMs ?? DEFAULTS.staleThresholdMs;
+  const initialRetryMs = options?.initialRetryMs ?? DEFAULTS.initialRetryMs;
+  const maxRetryMs = options?.maxRetryMs ?? DEFAULTS.maxRetryMs;
+  const backoffFactor = options?.backoffFactor ?? DEFAULTS.backoffFactor;
+  const operation = options?.operation ?? "ingest";
+  const lockDir = options?.lockDir ?? path2.join(planningRoot, ".build-project", "planning", "locks");
+  const lockFile = path2.join(lockDir, "ingest.lock");
+  await fs2.mkdir(lockDir, { recursive: true });
+  const startTime = Date.now();
+  let retryMs = initialRetryMs;
+  while (Date.now() - startTime < timeoutMs) {
+    const staleSnapshot = await isLockStaleAndAbandoned(lockFile, staleThresholdMs);
+    if (staleSnapshot) {
+      await forceRelease(lockFile, staleSnapshot);
+    }
+    try {
+      const ownerId = randomUUID();
+      const payload = {
+        pid: process.pid,
+        hostname: getHostIdentity(),
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        operation,
+        ownerId
+      };
+      const rawContent = JSON.stringify(payload, null, 2);
+      const fileHandle = await fs2.open(lockFile, "wx");
+      let lockSnapshot;
+      try {
+        await fileHandle.writeFile(rawContent, "utf-8");
+        const lockStat = await fileHandle.stat();
+        lockSnapshot = { dev: lockStat.dev, ino: lockStat.ino, rawContent, fileHandle };
+      } catch (writeError) {
+        await fileHandle.close().catch(() => {
+        });
+        await fs2.unlink(lockFile).catch(() => {
+        });
+        throw writeError;
+      }
+      const cleanupName = `planning-ingest-lock:${process.pid}:${operation}`;
+      const release = async () => {
+        try {
+          await releaseOwnLock(lockFile, lockSnapshot);
+        } finally {
+          signalCoordinator.unregister(cleanupName);
+        }
+      };
+      signalCoordinator.register(cleanupName, release, {
+        priority: "critical",
+        phase: "artifact-cleanup"
+      });
+      try {
+        return await fn();
+      } finally {
+        await release();
+      }
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        await sleep(retryMs);
+        retryMs = Math.min(retryMs * backoffFactor, maxRetryMs);
+        continue;
+      }
+      throw error;
+    }
+  }
+  const lockInfo = await readLockPayload(lockFile);
+  throw new Error(
+    `Ingest lock acquisition timed out after ${timeoutMs}ms. Lock held by PID ${lockInfo?.pid ?? "unknown"} since ${lockInfo?.createdAt ?? "unknown"} (operation: ${lockInfo?.operation ?? "unknown"})`
+  );
+}
+
+// src/planning/sprint-bridge-rollback.ts
+import * as fs3 from "fs";
+import * as fsp from "fs/promises";
+import * as path3 from "path";
+async function rollbackSprintBridge(result) {
+  const repoRoot = findRepoRoot();
+  const totalTaskCount = result.createdTaskIds.length + result.reattachedTaskIds.length;
+  try {
+    await withIngestLock(
+      repoRoot,
+      async () => {
+        await rollbackSprintBridgeArtifacts(result);
+      },
+      { operation: "sprint-bridge-rollback" }
+    );
+    if (result.runId) {
+      await emitSprintBridgeRolledBack(result.runId, result.sprintId, totalTaskCount);
+    }
+  } catch (error) {
+    if (result.runId) {
+      const message = error instanceof Error ? error.message : String(error);
+      await emitSprintBridgeRollbackFailed(result.runId, result.sprintId, totalTaskCount, message);
+    }
+    throw error;
+  }
+}
+async function rollbackSprintBridgeArtifacts(result) {
+  const planningRoot = getPlanningRoot();
+  const tasksDir = getBucketPathByKind("task", planningRoot);
+  const sprintsDir = getBucketPathByKind("sprint", planningRoot);
+  const sprintPath = path3.join(sprintsDir, `${result.sprintId}.md`);
+  const rollbackErrors = [];
+  const recordRollbackError = (operation, error) => {
+    const nodeError = error;
+    if (nodeError?.code === "ENOENT") {
+      return;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    rollbackErrors.push(`${operation}: ${message}`);
+  };
+  await withIndexRegeneration(planningRoot, async () => {
+    const detachedCreatedTaskIds = /* @__PURE__ */ new Set();
+    if (!result.createdSprint) {
+      for (const taskId of result.createdTaskIds) {
+        await removeTaskFromSprint(result.sprintId, taskId).then(() => {
+          detachedCreatedTaskIds.add(taskId);
+        }).catch((error) => recordRollbackError(`detach created task ${taskId}`, error));
+      }
+      for (const taskId of result.reattachedTaskIds) {
+        await removeTaskFromSprint(result.sprintId, taskId).catch(
+          (error) => recordRollbackError(`detach reattached task ${taskId}`, error)
+        );
+      }
+    }
+    for (const [taskId, snapshot] of result.reusedTaskSnapshots ?? []) {
+      await fsp.writeFile(snapshot.filePath, snapshot.contents).catch((error) => recordRollbackError(`restore reused task ${taskId}`, error));
+    }
+    const deletableTaskIds = result.createdTaskIds.filter(
+      (taskId) => result.createdSprint || Boolean(result.reusedSprintSnapshot) || detachedCreatedTaskIds.has(taskId)
+    );
+    for (const taskId of deletableTaskIds) {
+      await fsp.unlink(path3.join(tasksDir, `${taskId}.md`)).catch((error) => recordRollbackError(`delete task ${taskId}`, error));
+    }
+    await deleteArchivedTaskCopies(planningRoot, deletableTaskIds, recordRollbackError);
+    if (result.createdSprint) {
+      await fsp.unlink(sprintPath).catch((error) => recordRollbackError(`delete sprint ${result.sprintId}`, error));
+    } else if (result.reusedSprintSnapshot) {
+      await fsp.writeFile(sprintPath, result.reusedSprintSnapshot);
+    }
+    await pruneCreatedPlanningDirs(result.createdPlanningDirs ?? []);
+    if (rollbackErrors.length > 0) {
+      throw new Error(`Rollback incomplete: ${rollbackErrors.join("; ")}`);
+    }
+  });
+}
+function listMissingBucketDirs(planningRoot) {
+  const roots = [path3.resolve(planningRoot)];
+  try {
+    roots.push(fs3.realpathSync(planningRoot));
+  } catch {
+  }
+  const missing = /* @__PURE__ */ new Set();
+  for (const kind of ["sprint", "task"]) {
+    let dir = path3.resolve(getBucketPathByKind(kind, planningRoot));
+    while (roots.some((root) => isStrictlyInside(root, dir)) && !fs3.existsSync(dir)) {
+      missing.add(dir);
+      dir = path3.dirname(dir);
+    }
+  }
+  return [...missing];
+}
+function isStrictlyInside(root, dir) {
+  const relative2 = path3.relative(root, dir);
+  return relative2 !== "" && !relative2.startsWith("..") && !path3.isAbsolute(relative2);
+}
+async function pruneCreatedPlanningDirs(dirs) {
+  const deepestFirst = [...dirs].sort((a, b) => b.length - a.length);
+  for (const dir of deepestFirst) {
+    await removeEmptyDirTree(dir);
+  }
+}
+async function removeEmptyDirTree(dir) {
+  const entries = await fsp.readdir(dir, { withFileTypes: true }).catch(() => []);
+  for (const entry of entries) {
+    if (entry.isDirectory()) await removeEmptyDirTree(path3.join(dir, entry.name));
+  }
+  await fsp.rmdir(dir).catch(() => void 0);
+}
+async function deleteArchivedTaskCopies(planningRoot, taskIds, recordRollbackError) {
+  if (taskIds.length === 0) return;
+  const wanted = new Set(taskIds.map((taskId) => `${taskId}.md`));
+  let archivedFiles;
+  try {
+    archivedFiles = await listMarkdownFilesRecursiveStrict(
+      getBucketArchivePathByKind("task", planningRoot)
+    );
+  } catch (error) {
+    recordRollbackError("list archived tasks", error);
+    return;
+  }
+  let deleted = false;
+  for (const filePath of archivedFiles) {
+    const fileName = path3.basename(filePath);
+    if (!wanted.has(fileName)) continue;
+    await fsp.unlink(filePath).then(() => {
+      deleted = true;
+    }).catch(
+      (error) => recordRollbackError(`delete archived task ${fileName.slice(0, -3)}`, error)
+    );
+  }
+  if (deleted) clearArchivedTaskIndex();
+}
+
+// src/planning/stage-skip-dependencies.ts
+function buildStageTaskOwnership(stageToTaskMap, gateToExecution, workflow) {
+  const owners = new Map(stageToTaskMap);
+  for (const [gateStageId, executionStageId] of gateToExecution) {
+    const taskId = stageToTaskMap.get(executionStageId);
+    if (!taskId) continue;
+    owners.set(gateStageId, taskId);
+    const reviewerStageId = workflow?.stages.find((stage) => stage.id === gateStageId)?.deps?.[0];
+    if (reviewerStageId) owners.set(reviewerStageId, taskId);
+  }
+  return owners;
+}
+function createDeclaredDependencyReader(readTaskDependencies) {
+  const cache = /* @__PURE__ */ new Map();
+  return async (taskId) => {
+    const cached = cache.get(taskId);
+    if (cached) return cached;
+    let declared = [];
+    try {
+      declared = await readTaskDependencies(taskId) ?? [];
+    } catch {
+    }
+    cache.set(taskId, declared);
+    return declared;
+  };
+}
+async function skipHasUnmetDeclaredDependency(event, taskId, stageOwners, readDeclaredDependencies) {
+  const unmetDependencyStageIds = event.metadata?.unmetDependencyStageIds;
+  if (event.eventType !== "skipped" || !unmetDependencyStageIds) return void 0;
+  const unmetOwners = new Set(
+    unmetDependencyStageIds.map((stageId) => stageOwners.get(stageId)).filter((owner) => owner !== void 0 && owner !== taskId)
+  );
+  if (unmetOwners.size === 0) return false;
+  const declared = await readDeclaredDependencies(taskId);
+  return declared.some((dependencyTaskId) => unmetOwners.has(dependencyTaskId));
+}
+
+// src/planning/sprint-bridge.ts
+function isDuplicateSprintDateError(error) {
+  if (!error || typeof error !== "object") return false;
+  const candidate = error;
+  if (candidate.code === "SPRINT_ALREADY_EXISTS_FOR_DATE") return true;
+  if (candidate.name === "SprintAlreadyExistsError") return true;
+  return typeof candidate.message === "string" && candidate.message.includes("Sprint already exists for date");
+}
+function isSprintDateRangeOverlapError(error) {
+  if (!error || typeof error !== "object") return false;
+  const message = error.message;
+  return typeof message === "string" && message.includes("Sprint date range overlaps existing sprint");
+}
+function isSprintCollisionError(error) {
+  return isDuplicateSprintDateError(error) || isSprintDateRangeOverlapError(error);
+}
+function parseDateOnly(value) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value.trim());
+  if (!match) return null;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const date = new Date(Date.UTC(year, month - 1, day));
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month - 1 || date.getUTCDate() !== day) {
+    return null;
+  }
+  return date;
+}
+function dateRangesOverlap(startA, endA, startB, endB) {
+  const aStart = parseDateOnly(startA);
+  const aEnd = parseDateOnly(endA);
+  const bStart = parseDateOnly(startB);
+  const bEnd = parseDateOnly(endB);
+  if (!aStart || !aEnd || !bStart || !bEnd) return false;
+  return aStart.getTime() < bEnd.getTime() && aEnd.getTime() > bStart.getTime();
+}
+function findReusableSprint(sprints, startDate, endDate) {
+  const active = sprints.filter(
+    (candidate) => candidate.status === "planning" || candidate.status === "active"
+  );
+  const sameStart = active.find((candidate) => candidate.startDate === startDate);
+  if (sameStart) return sameStart;
+  return active.find(
+    (candidate) => dateRangesOverlap(startDate, endDate, candidate.startDate, candidate.endDate)
+  );
+}
+function emitLifecycleDiagnostic(message, error) {
+  if (isQuietOutputRequested() || !shouldShowLifecycleDiagnostics()) {
+    return;
+  }
+  process.stderr.write(`${message} ${error instanceof Error ? error.message : String(error)}
+`);
+}
+function emitSprintBridgeDiagnostic(message, metadata) {
+  emitCustomWarning(
+    "WARN" /* WARN */,
+    "configuration" /* CONFIGURATION */,
+    message,
+    {
+      subsystem: "planning/sprint-bridge",
+      executionPhase: "execution"
+    },
+    {
+      metadata,
+      skipConsole: isQuietOutputRequested() || !shouldShowLifecycleDiagnostics()
+    }
+  );
+}
+function topologicalSort(stages) {
+  const stageMap = new Map(stages.map((s) => [s.id, s]));
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const sorted = [];
+  function visit(id) {
+    if (visited.has(id)) return;
+    if (visiting.has(id)) {
+      throw new Error(`Cyclic stage dependency detected at ${id}`);
+    }
+    visiting.add(id);
+    const stage = stageMap.get(id);
+    if (!stage) {
+      visiting.delete(id);
+      return;
+    }
+    for (const dep of stage.deps ?? []) {
+      visit(dep);
+    }
+    visiting.delete(id);
+    visited.add(id);
+    sorted.push(stage);
+  }
+  for (const stage of stages) {
+    visit(stage.id);
+  }
+  return sorted;
+}
+function toStageType(value) {
+  if (value === "standard" || value === "competition" || value === "verify" || value === "refinement" || value === "autoloop" || value === "orchestrator") {
+    return value;
+  }
+  return void 0;
+}
+function deriveStageRuntimeOptions(stage, plan) {
+  let durationMs = stage.estimatedDurationMs;
+  if (!(typeof durationMs === "number" && Number.isFinite(durationMs) && durationMs > 0) && typeof plan?.estimatedDurationMs === "number" && Number.isFinite(plan.estimatedDurationMs) && plan.estimatedDurationMs > 0) {
+    durationMs = plan.estimatedDurationMs / Math.max(1, plan.stageCount ?? 1);
+  }
+  if (typeof durationMs === "number" && Number.isFinite(durationMs) && durationMs > 0) {
+    return {
+      expectedRuntimeMinutes: Math.max(1, Math.round(durationMs / 6e4)),
+      runtimeEstimateProvenance: "explicit"
+    };
+  }
+  return {};
+}
+function normalizePlanArtifactPath(planArtifactPath) {
+  if (typeof planArtifactPath !== "string") return void 0;
+  const normalized = path4.posix.normalize(planArtifactPath.replace(/\\/g, "/").trim());
+  return normalized.length > 0 && normalized !== "." ? normalized : void 0;
+}
+function normalizeStageDescription(description) {
+  if (typeof description !== "string") return void 0;
+  const normalized = description.trim().replace(/\s+/g, " ");
+  return normalized.length > 0 ? normalized : void 0;
+}
+var MAX_TASK_TITLE_LENGTH = 120;
+function truncateTaskTitle(title) {
+  if (title.length <= MAX_TASK_TITLE_LENGTH) return title;
+  return `${title.slice(0, MAX_TASK_TITLE_LENGTH - 1).trimEnd()}\u2026`;
+}
+function deriveTaskTitleFromStage(stage) {
+  const name = stage.name?.trim();
+  if (name) return truncateTaskTitle(name);
+  const desc = (stage.description ?? "").trim();
+  if (desc.length === 0) return stage.id;
+  const firstSentence = desc.split(/(?<=[.!?])\s+|\n+/, 1)[0]?.trim() ?? desc;
+  const candidate = firstSentence.length > 0 ? firstSentence : desc;
+  return truncateTaskTitle(candidate);
+}
+function buildStageDedupKey(planArtifactPath, stageId, intentHash) {
+  if (intentHash) {
+    return `intent:${intentHash}::${stageId}`;
+  }
+  const normalizedPlanArtifactPath = normalizePlanArtifactPath(planArtifactPath);
+  if (!normalizedPlanArtifactPath) {
+    return void 0;
+  }
+  return `${normalizedPlanArtifactPath}::${stageId}`;
+}
+function validatePlanStages(stages) {
+  const stageIds = stages.map((stage) => stage.id);
+  const duplicateIds = stageIds.filter((id, index) => stageIds.indexOf(id) !== index);
+  if (duplicateIds.length > 0) {
+    throw new Error(`Duplicate stage IDs in plan: ${[...new Set(duplicateIds)].join(", ")}`);
+  }
+  const knownStageIds = new Set(stageIds);
+  for (const stage of stages) {
+    const unknownDeps = (stage.deps ?? []).filter((dep) => !knownStageIds.has(dep));
+    if (unknownDeps.length > 0) {
+      throw new Error(
+        `Plan stage ${stage.id} references unknown dependency stage(s): ${unknownDeps.join(", ")}`
+      );
+    }
+  }
+  return topologicalSort(stages);
+}
+async function snapshotTaskFile(taskId, tasksDir) {
+  const filePath = path4.join(tasksDir, `${taskId}.md`);
+  try {
+    return { filePath, contents: await fsp2.readFile(filePath) };
+  } catch {
+    return void 0;
+  }
+}
+async function setTaskSprintId(taskPath, sprintId) {
+  const { frontMatter, body } = await readMarkdownFile(taskPath);
+  const current = frontMatter;
+  const rawTask = {
+    ...current,
+    sprintId,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    // Managed task writes retain the monotonic version under the planning lock.
+    version: (typeof current.version === "number" ? current.version : 0) + 1
+  };
+  delete rawTask.sprint_id;
+  await writeMarkdownFile(taskPath, rawTask, body);
+}
+async function createSprintFromPlan(plan, options) {
+  const repoRoot = findRepoRoot();
+  return withIngestLock(
+    repoRoot,
+    () => withPlanningLock(getPlanningRoot(), async () => {
+      const now = /* @__PURE__ */ new Date();
+      const startDate = now.toISOString().split("T")[0];
+      const endDate = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1e3).toISOString().split("T")[0];
+      const sprintName = options.sprintName ?? `auto-${plan.goal.slice(0, 40).replace(/\s+/g, "-").toLowerCase()}`;
+      if (options.planArtifactPath) {
+        const resolvedPath = resolvePlanArtifactPath(options.planArtifactPath, repoRoot);
+        if (!fs4.existsSync(resolvedPath)) {
+          throw new Error(`Plan artifact not found: ${options.planArtifactPath}`);
+        }
+      }
+      const sortedStages = validatePlanStages(plan.subStages);
+      const shouldReuseExistingSprint = options.reuseExistingSprint !== false;
+      let reusingExistingSprint = false;
+      let reusedSprintSnapshot;
+      const planningRoot = getPlanningRoot();
+      const createdPlanningDirs = listMissingBucketDirs(planningRoot);
+      const sprint = await createSprint(sprintName, startDate, endDate, {
+        allowDuplicateStartDate: !shouldReuseExistingSprint
+      }).catch(async (error) => {
+        if (!isSprintCollisionError(error)) {
+          throw error;
+        }
+        if (!shouldReuseExistingSprint) {
+          throw error;
+        }
+        const existing = await listSprints(false);
+        const matching = findReusableSprint(existing, startDate, endDate);
+        if (!matching) {
+          throw error;
+        }
+        reusingExistingSprint = true;
+        const sprintsDir = getBucketPathByKind("sprint", planningRoot);
+        reusedSprintSnapshot = await fsp2.readFile(path4.join(sprintsDir, `${matching.id}.md`));
+        const reuseReason = matching.startDate === startDate ? `started ${startDate}` : `overlaps ${matching.startDate} to ${matching.endDate}`;
+        emitSprintBridgeDiagnostic(`Reusing existing sprint ${matching.id} (${reuseReason})`);
+        return matching;
+      });
+      const sprintId = sprint.id;
+      const tasksDir = getBucketPathByKind("task", planningRoot);
+      const existingStageTaskIds = /* @__PURE__ */ new Map();
+      if (reusingExistingSprint) {
+        const sprintMemberTaskIds = new Set(
+          (await listTasksInSprint(sprintId)).map((task) => task.id)
+        );
+        const allTaskRecords = await getAllTasks({ includeArchive: true });
+        for (const taskRecord of allTaskRecords) {
+          const t = taskRecord.yaml;
+          if (!t.planStageId) continue;
+          const dedupKey = buildStageDedupKey(
+            t.planArtifactPath,
+            t.planStageId,
+            t.planIntentHash
+          );
+          if (!dedupKey) continue;
+          const inSprint = t.sprintId === sprintId && sprintMemberTaskIds.has(t.id);
+          const current = existingStageTaskIds.get(dedupKey);
+          if (!current || !current.inSprint && inSprint) {
+            existingStageTaskIds.set(dedupKey, {
+              taskId: t.id,
+              inSprint,
+              title: t.title,
+              filePath: taskRecord.filePath
+            });
+          }
+        }
+        const matchingExistingStageCount = sortedStages.filter((stage) => {
+          const stageDedupKey = buildStageDedupKey(
+            options.planArtifactPath,
+            stage.id,
+            options.intentHash
+          );
+          if (!stageDedupKey) return false;
+          const candidate = existingStageTaskIds.get(stageDedupKey);
+          if (!candidate) return false;
+          return !(options.intentHash && normalizeStageDescription(candidate.title) !== normalizeStageDescription(deriveTaskTitleFromStage(stage)));
+        }).length;
+        if (matchingExistingStageCount > 0) {
+          emitSprintBridgeDiagnostic(
+            `Reusing sprint ${sprintId} \u2014 found ${matchingExistingStageCount} matching existing plan stage(s); duplicates will be skipped`
+          );
+        }
+      }
+      const stageToTaskMap = /* @__PURE__ */ new Map();
+      const taskIds = [];
+      const createdTaskIds = [];
+      const reattachedTaskIds = [];
+      const reusedTaskSnapshots = /* @__PURE__ */ new Map();
+      try {
+        for (const stage of sortedStages) {
+          const stageDedupKey = buildStageDedupKey(
+            options.planArtifactPath,
+            stage.id,
+            options.intentHash
+          );
+          const existingStageTask = stageDedupKey && (() => {
+            const candidate = existingStageTaskIds.get(stageDedupKey);
+            if (!candidate) return void 0;
+            if (options.intentHash && normalizeStageDescription(candidate.title) !== normalizeStageDescription(deriveTaskTitleFromStage(stage))) {
+              return void 0;
+            }
+            return candidate;
+          })();
+          if (existingStageTask) {
+            if (!existingStageTask.inSprint) {
+              const snapshot = existingStageTask.filePath ? {
+                filePath: existingStageTask.filePath,
+                contents: await fsp2.readFile(existingStageTask.filePath)
+              } : await snapshotTaskFile(existingStageTask.taskId, tasksDir);
+              if (snapshot) {
+                reusedTaskSnapshots.set(existingStageTask.taskId, snapshot);
+              }
+              await addTaskToSprint(sprintId, existingStageTask.taskId, 0);
+              await setTaskSprintId(
+                existingStageTask.filePath ?? path4.join(tasksDir, `${existingStageTask.taskId}.md`),
+                sprintId
+              );
+              existingStageTask.inSprint = true;
+              taskIds.push(existingStageTask.taskId);
+              reattachedTaskIds.push(existingStageTask.taskId);
+              emitSprintBridgeDiagnostic(
+                `Reattached orphaned task ${existingStageTask.taskId} for stage ${stage.id} to sprint ${sprintId}`
+              );
+            } else {
+              emitSprintBridgeDiagnostic(
+                `Skipping duplicate task for stage ${stage.id} (already exists in sprint)`
+              );
+            }
+            stageToTaskMap.set(stage.id, existingStageTask.taskId);
+            continue;
+          }
+          const taskDeps = (stage.deps ?? []).map((depStageId) => stageToTaskMap.get(depStageId)).filter((id) => id !== void 0);
+          const mappedStageType = toStageType(stage.type);
+          const { modelReasoningEffort } = stage;
+          const hasVerify = mappedStageType === "verify" && stage.verify?.commands && Array.isArray(stage.verify.commands) && stage.verify.commands.length > 0;
+          const task = await createTask(deriveTaskTitleFromStage(stage), sprintId, {
+            description: stage.description,
+            dependencies: taskDeps,
+            // Persist advisory AI wall-clock runtime ([B5]) as expectedRuntimeMinutes;
+            // never derive human-hour Scrum estimates from runtime or USD cost.
+            ...deriveStageRuntimeOptions(stage, {
+              estimatedDurationMs: plan.estimatedDurationMs,
+              stageCount: plan.subStages.length
+            }),
+            planArtifactPath: options.planArtifactPath,
+            planIntentHash: options.intentHash,
+            planStageId: stage.id,
+            routing: stage.provider || stage.model ? {
+              ...stage.provider ? { provider: stage.provider } : {},
+              ...stage.model ? { model: stage.model } : {}
+            } : void 0,
+            flywheel: stage.type || stage.allowlist && stage.allowlist.length > 0 || hasVerify || stage.competition || stage.autoloop || modelReasoningEffort || stage.validation ? {
+              ...mappedStageType ? { type: mappedStageType } : {},
+              ...stage.allowlist && stage.allowlist.length > 0 ? { allowlist: stage.allowlist } : {},
+              ...hasVerify ? { verify: stage.verify } : {},
+              ...stage.competition ? { competition: stage.competition } : {},
+              ...stage.autoloop ? { autoloop: stage.autoloop } : {},
+              ...modelReasoningEffort ? { modelReasoningEffort } : {},
+              ...stage.validation ? { validation: stage.validation } : {}
+            } : void 0
+          });
+          const missingProvenance = [];
+          if (!task.planArtifactPath) missingProvenance.push("planArtifactPath");
+          if (!task.planStageId) missingProvenance.push("planStageId");
+          if (missingProvenance.length > 0) {
+            emitSprintBridgeDiagnostic(
+              `Task ${task.id} (stage ${stage.id}) created without provenance field(s): ${missingProvenance.join(", ")}`
+            );
+            await emitPlanProvenanceMissing(options.runId, sprintId, 1);
+          }
+          stageToTaskMap.set(stage.id, task.id);
+          taskIds.push(task.id);
+          createdTaskIds.push(task.id);
+          try {
+            await addTaskToSprint(sprintId, task.id, 0);
+          } catch (error) {
+            throw new Error(
+              `Created task ${task.id} for stage ${stage.id} but failed to attach it to sprint ${sprintId}: ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
+        }
+      } catch (error) {
+        await rollbackSprintBridgeArtifacts({
+          runId: options.runId,
+          sprintId,
+          stageToTaskMap,
+          taskIds,
+          createdSprint: !reusingExistingSprint,
+          createdTaskIds,
+          reattachedTaskIds,
+          reusedSprintSnapshot,
+          reusedTaskSnapshots,
+          createdPlanningDirs
+        });
+        throw error;
+      }
+      try {
+        const capacity = await calculateCapacity(sprintId);
+        const warning = checkCapacityWarning(capacity);
+        if (warning) {
+          emitSprintBridgeDiagnostic(`[capacity] ${warning.message}`);
+        }
+      } catch {
+      }
+      await emitSprintBridgeCreated(
+        options.runId,
+        sprintId,
+        taskIds.length,
+        options.planArtifactPath
+      );
+      return {
+        runId: options.runId,
+        sprintId,
+        stageToTaskMap,
+        taskIds,
+        createdSprint: !reusingExistingSprint,
+        createdTaskIds,
+        reattachedTaskIds,
+        reusedSprintSnapshot,
+        reusedTaskSnapshots,
+        createdPlanningDirs
+      };
+    }),
+    { operation: "sprint-bridge" }
+  );
+}
+function isTransientIOError(err) {
+  if (!(err instanceof Error)) return false;
+  const code = err.code;
+  return code === "ENOENT" || code === "EACCES" || code === "EAGAIN" || code === "EBUSY";
+}
+async function applyStageEventToTask(event, taskId, apply, normalizeBlockedReason, telemetry, recordedTransitions, writeTaskStatus, binding = {}) {
+  await refreshSprintLock(telemetry.sprintId);
+  const targetStatus = resolveTaskStatusForStageOutcome({
+    kind: "lifecycle-event",
+    event,
+    apply,
+    stageRole: binding.stageRole,
+    gatePending: binding.gatePending
+  });
+  const isGate = binding.stageRole === "gate";
+  switch (event.eventType) {
+    case "started": {
+      if (targetStatus === "in_progress") {
+        if (!writeTaskStatus) {
+          recordedTransitions.set(taskId, { taskId, targetStatus });
+          break;
+        }
+        await updateTaskStatusWithTransitionValidation(taskId, targetStatus);
+        recordedTransitions.set(taskId, { taskId, targetStatus });
+        await emitSprintBridgeTaskStatusUpdated(
+          telemetry.runId,
+          telemetry.sprintId,
+          taskId,
+          "todo",
+          "in_progress"
+        );
+      }
+      break;
+    }
+    case "succeeded": {
+      if (targetStatus === "review" || targetStatus === "done") {
+        if (!writeTaskStatus) {
+          recordedTransitions.set(taskId, { taskId, targetStatus });
+          break;
+        }
+        await updateTaskStatusWithTransitionValidation(taskId, "review");
+        recordedTransitions.set(taskId, { taskId, targetStatus });
+        if (!isGate) {
+          await emitSprintBridgeTaskStatusUpdated(
+            telemetry.runId,
+            telemetry.sprintId,
+            taskId,
+            "in_progress",
+            "review"
+          );
+        }
+      }
+      break;
+    }
+    case "failed": {
+      if (targetStatus === "blocked" || targetStatus === "in_progress") {
+        const reason = normalizeBlockedReason(
+          event.metadata?.errorSummary,
+          isGate ? "Review gate failed" : "Stage execution failed"
+        );
+        if (!writeTaskStatus) {
+          recordedTransitions.set(taskId, { taskId, targetStatus, reason });
+          break;
+        }
+        const blocker = targetStatus === "blocked" ? { blockedReason: reason } : void 0;
+        await updateTaskStatusWithTransitionValidation(taskId, targetStatus, blocker);
+        recordedTransitions.set(taskId, { taskId, targetStatus, reason });
+        await emitBlockerRuntimeFailure(telemetry.runId, event.stageId);
+        await emitSprintBridgeTaskStatusUpdated(
+          telemetry.runId,
+          telemetry.sprintId,
+          taskId,
+          "in_progress",
+          targetStatus
+        );
+      }
+      break;
+    }
+    case "skipped": {
+      if (await binding.resolveUnmetDeclaredDependency?.() === false) {
+        break;
+      }
+      if (targetStatus === "blocked") {
+        const reason = normalizeBlockedReason(
+          event.metadata?.skipReason,
+          isGate ? "Review gate skipped" : "Stage skipped"
+        );
+        if (!writeTaskStatus) {
+          recordedTransitions.set(taskId, { taskId, targetStatus: "blocked", reason });
+          break;
+        }
+        await updateTaskStatusWithTransitionValidation(taskId, "blocked", {
+          blockedReason: reason
+        });
+        recordedTransitions.set(taskId, { taskId, targetStatus: "blocked", reason });
+        await emitBlockerRuntimeFailure(telemetry.runId, event.stageId);
+        await emitSprintBridgeTaskStatusUpdated(
+          telemetry.runId,
+          telemetry.sprintId,
+          taskId,
+          "todo",
+          "blocked"
+        );
+      }
+      break;
+    }
+  }
+}
+async function replayStageEvent(event, taskId, apply, normalizeBlockedReason, telemetry, recordedTransitions, writeTaskStatus, shouldSkipUpdates, binding = {}) {
+  if (shouldSkipUpdates?.()) {
+    return;
+  }
+  await applyStageEventToTask(
+    event,
+    taskId,
+    apply,
+    normalizeBlockedReason,
+    telemetry,
+    recordedTransitions,
+    writeTaskStatus,
+    binding
+  );
+}
+function buildLifecycleCallbacks(stageToTaskMap, options) {
+  const apply = options.apply ?? false;
+  const writeTaskStatus = options.writeTaskStatus ?? true;
+  const gateToExecution = options.workflow ? mapGateStagesToExecutionStages(options.workflow) : /* @__PURE__ */ new Map();
+  const gatedExecutionIds = new Set(gateToExecution.values());
+  const stageOwners = buildStageTaskOwnership(stageToTaskMap, gateToExecution, options.workflow);
+  const readDeclaredDependencies = createDeclaredDependencyReader(
+    async (id) => (await getTask(id)).yaml.dependencies
+  );
+  const gateDecidedTasks = /* @__PURE__ */ new Set();
+  const taskEventChains = /* @__PURE__ */ new Map();
+  const resolveBinding = (stageId) => {
+    const direct = stageToTaskMap.get(stageId);
+    if (direct) {
+      return {
+        taskId: direct,
+        binding: gatedExecutionIds.has(stageId) ? { stageRole: "implement", gatePending: true } : {}
+      };
+    }
+    const executionId = gateToExecution.get(stageId);
+    const gatedTaskId = executionId ? stageToTaskMap.get(executionId) : void 0;
+    if (gatedTaskId) {
+      return { taskId: gatedTaskId, binding: { stageRole: "gate" } };
+    }
+    return void 0;
+  };
+  const normalizeBlockedReason = (reason, fallback) => {
+    const trimmed = reason?.trim();
+    return trimmed && trimmed.length > 0 ? trimmed : fallback;
+  };
+  const recordedTransitions = /* @__PURE__ */ new Map();
+  const pendingEvents = /* @__PURE__ */ new Set();
+  const shouldSkipUpdates = () => Boolean(options.signal?.aborted) || signalCoordinator.isShuttingDown;
+  const callbacks = {
+    onStageEvent: async (event) => {
+      const resolved = resolveBinding(event.stageId);
+      if (!resolved) return;
+      const { taskId } = resolved;
+      const binding = {
+        ...resolved.binding,
+        resolveUnmetDeclaredDependency: () => skipHasUnmetDeclaredDependency(event, taskId, stageOwners, readDeclaredDependencies)
+      };
+      const previous = taskEventChains.get(taskId) ?? Promise.resolve();
+      const next = previous.catch(() => void 0).then(() => processStageEvent(event, taskId, binding));
+      taskEventChains.set(taskId, next);
+      await next;
+    }
+  };
+  const processStageEvent = async (event, taskId, binding) => {
+    if (binding.stageRole === "implement" && event.terminal && gateDecidedTasks.has(taskId)) {
+      return;
+    }
+    if (shouldSkipUpdates()) return;
+    try {
+      await applyStageEventToTask(
+        event,
+        taskId,
+        apply,
+        normalizeBlockedReason,
+        {
+          runId: options.runId,
+          sprintId: options.sprintId
+        },
+        recordedTransitions,
+        writeTaskStatus,
+        binding
+      );
+      if (binding.stageRole === "gate" && event.terminal) gateDecidedTasks.add(taskId);
+    } catch (err) {
+      if (isTransientIOError(err)) {
+        try {
+          if (shouldSkipUpdates()) return;
+          await new Promise((resolve2) => setTimeout(resolve2, 100));
+          if (shouldSkipUpdates()) return;
+          await replayStageEvent(
+            event,
+            taskId,
+            apply,
+            normalizeBlockedReason,
+            {
+              runId: options.runId,
+              sprintId: options.sprintId
+            },
+            recordedTransitions,
+            writeTaskStatus,
+            shouldSkipUpdates,
+            binding
+          );
+          if (binding.stageRole === "gate" && event.terminal) gateDecidedTasks.add(taskId);
+          return;
+        } catch (retryErr) {
+          emitLifecycleDiagnostic(
+            `[sprint-bridge] retry also failed for task ${taskId} stage ${event.stageId}:`,
+            retryErr
+          );
+          return;
+        }
+      }
+      emitLifecycleDiagnostic(
+        `[sprint-bridge] failed to update task ${taskId} for stage ${event.stageId}:`,
+        err
+      );
+    }
+  };
+  const trackedCallbacks = {
+    onStageEvent: (event) => {
+      const pending = Promise.resolve(callbacks.onStageEvent(event));
+      pendingEvents.add(pending);
+      void pending.finally(() => pendingEvents.delete(pending));
+      return pending;
+    }
+  };
+  const awaitDrain = async () => {
+    while (pendingEvents.size > 0) {
+      await Promise.allSettled(Array.from(pendingEvents));
+    }
+  };
+  trackedCallbacks.awaitDrain = awaitDrain;
+  return { callbacks: trackedCallbacks, recordedTransitions, awaitDrain };
+}
+
+export {
+  emitBlockerTelemetryEvent,
+  emitBlockerDetected,
+  emitDecompositionCost,
+  emitTaskTypeOverride,
+  emitSplitShadowComparison,
+  withIngestLock,
+  rollbackSprintBridge,
+  createSprintFromPlan,
+  buildLifecycleCallbacks
+};
+//# sourceMappingURL=chunk-3H3EY6U7.js.map