@poetic-ai/poetic 1.42.0

package/dist/chunk-DBFS4HMH.js

@@ -0,0 +1,751 @@
+import {
+  withIngestLock
+} from "./chunk-MQ4WA34C.js";
+import {
+  resolveTaskStatusForStageOutcome
+} from "./chunk-D5EP5D2W.js";
+import {
+  emitBlockerRuntimeFailure,
+  emitPlanProvenanceMissing,
+  emitSprintBridgeCreated,
+  emitSprintBridgeRollbackFailed,
+  emitSprintBridgeRolledBack,
+  emitSprintBridgeTaskStatusUpdated
+} from "./chunk-SCW4ZF6R.js";
+import {
+  resolvePlanArtifactPath
+} from "./chunk-RJAAKDRX.js";
+import {
+  createTask,
+  getAllTasks,
+  updateTaskStatusWithTransitionValidation
+} from "./chunk-5LTN43AS.js";
+import {
+  addTaskToSprint,
+  calculateCapacity,
+  checkCapacityWarning,
+  createSprint,
+  listSprints,
+  listTasksInSprint,
+  refreshSprintLock,
+  removeTaskFromSprint
+} from "./chunk-4YX7J6QL.js";
+import {
+  getPlanningRoot,
+  withIndexRegeneration
+} from "./chunk-OPYFYTWQ.js";
+import {
+  getBucketPathByKind
+} from "./chunk-HOYBYAOA.js";
+import {
+  readMarkdownFile,
+  writeMarkdownFile
+} from "./chunk-OIS7J26S.js";
+import {
+  signalCoordinator
+} from "./chunk-72YTZMAM.js";
+import {
+  isQuietOutputRequested,
+  shouldShowLifecycleDiagnostics
+} from "./chunk-FKAUPHMR.js";
+import {
+  findRepoRoot
+} from "./chunk-L7JZLXQL.js";
+import {
+  emitCustomWarning
+} from "./chunk-EJGCZGUF.js";
+
+// src/planning/sprint-bridge.ts
+import * as fs from "fs";
+import * as fsp from "fs/promises";
+import * as path from "path";
+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 {
+      estimatedHours: 0,
+      expectedRuntimeMinutes: Math.max(1, Math.round(durationMs / 6e4)),
+      runtimeEstimateProvenance: "explicit"
+    };
+  }
+  return { estimatedHours: 0 };
+}
+function normalizePlanArtifactPath(planArtifactPath) {
+  if (typeof planArtifactPath !== "string") return void 0;
+  const normalized = path.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 = path.join(tasksDir, `${taskId}.md`);
+  try {
+    return { filePath, contents: await fsp.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(),
+    // CAS invariant (TaskYAML.version): every managed task write bumps version
+    // so concurrency / TOCTOU guards observe this sprintId rewrite.
+    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,
+    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 (!fs.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 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 planningRoot2 = getPlanningRoot();
+        const sprintPath = path.join(
+          getBucketPathByKind("sprint", planningRoot2),
+          `${matching.id}.md`
+        );
+        reusedSprintSnapshot = await fsp.readFile(sprintPath);
+        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 planningRoot = getPlanningRoot();
+      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 fsp.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 ?? path.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 hasVerify = mappedStageType === "verify" && stage.verify && Array.isArray(stage.verify.commands) && stage.verify.commands.length > 0;
+          const taskTitle = deriveTaskTitleFromStage(stage);
+          const task = await createTask(taskTitle, sprintId, {
+            description: stage.description,
+            dependencies: taskDeps,
+            // AI-era estimate: use the plan's expected wall-clock runtime
+            // (advisory, [B5]) as expectedRuntimeMinutes, with explicit 0h so
+            // createTask's ?? 4 default cannot fabricate legacy capacity. Do
+            // NOT convert the advisory USD cost into fake human-hours
+            // (previous `estimatedCost * 2`).
+            ...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 || 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 } : {},
+              ...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
+        });
+        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
+      };
+    },
+    { operation: "sprint-bridge" }
+  );
+}
+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 = path.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));
+    }
+    for (const taskId of result.createdTaskIds) {
+      if (!result.createdSprint && !result.reusedSprintSnapshot && !detachedCreatedTaskIds.has(taskId)) {
+        continue;
+      }
+      await fsp.unlink(path.join(tasksDir, `${taskId}.md`)).catch((error) => recordRollbackError(`delete task ${taskId}`, error));
+    }
+    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);
+    }
+    if (rollbackErrors.length > 0) {
+      throw new Error(`Rollback incomplete: ${rollbackErrors.join("; ")}`);
+    }
+  });
+}
+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) {
+  await refreshSprintLock(telemetry.sprintId);
+  const targetStatus = resolveTaskStatusForStageOutcome({
+    kind: "lifecycle-event",
+    event,
+    apply
+  });
+  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, targetStatus);
+        recordedTransitions.set(taskId, {
+          taskId,
+          targetStatus
+        });
+        await emitSprintBridgeTaskStatusUpdated(
+          telemetry.runId,
+          telemetry.sprintId,
+          taskId,
+          "in_progress",
+          targetStatus
+        );
+      }
+      break;
+    }
+    case "failed": {
+      if (targetStatus === "blocked") {
+        const reason = normalizeBlockedReason(
+          event.metadata?.errorSummary,
+          "Stage execution failed"
+        );
+        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,
+          "in_progress",
+          "blocked"
+        );
+      }
+      break;
+    }
+    case "skipped": {
+      if (targetStatus === "blocked") {
+        const reason = normalizeBlockedReason(event.metadata?.skipReason, "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) {
+  if (shouldSkipUpdates?.()) {
+    return;
+  }
+  await applyStageEventToTask(
+    event,
+    taskId,
+    apply,
+    normalizeBlockedReason,
+    telemetry,
+    recordedTransitions,
+    writeTaskStatus
+  );
+}
+function buildLifecycleCallbacks(stageToTaskMap, options) {
+  const apply = options.apply ?? false;
+  const writeTaskStatus = options.writeTaskStatus ?? true;
+  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 taskId = stageToTaskMap.get(event.stageId);
+      if (!taskId) return;
+      if (shouldSkipUpdates()) return;
+      try {
+        await applyStageEventToTask(
+          event,
+          taskId,
+          apply,
+          normalizeBlockedReason,
+          {
+            runId: options.runId,
+            sprintId: options.sprintId
+          },
+          recordedTransitions,
+          writeTaskStatus
+        );
+      } catch (err) {
+        if (isTransientIOError(err)) {
+          try {
+            if (shouldSkipUpdates()) return;
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            if (shouldSkipUpdates()) return;
+            await replayStageEvent(
+              event,
+              taskId,
+              apply,
+              normalizeBlockedReason,
+              {
+                runId: options.runId,
+                sprintId: options.sprintId
+              },
+              recordedTransitions,
+              writeTaskStatus,
+              shouldSkipUpdates
+            );
+            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 {
+  createSprintFromPlan,
+  rollbackSprintBridge,
+  buildLifecycleCallbacks
+};
+//# sourceMappingURL=chunk-DBFS4HMH.js.map