@poetic-ai/poetic 1.42.0

package/dist/chunk-CQM3A35X.js

@@ -0,0 +1,844 @@
+import {
+  atomicWriteJson
+} from "./chunk-A3YGID55.js";
+import {
+  findProjectRoot
+} from "./chunk-L6OM4A22.js";
+import {
+  hasExplicitPoeticRoot,
+  resolvePoeticRepoStartDir,
+  resolveRepoRootOverride
+} from "./chunk-L7JZLXQL.js";
+
+// src/automation/flywheel-manifest.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { existsSync } from "fs";
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import { execa, execaSync } from "execa";
+import lockfile from "proper-lockfile";
+var CURRENT_MANIFEST_SCHEMA_VERSION = 1;
+var manifestLocks = /* @__PURE__ */ new Map();
+var manifestLockOwners = /* @__PURE__ */ new Map();
+var manifestLockContext = new AsyncLocalStorage();
+var MANIFEST_LOCK_DISABLE_ENV = "POETIC_FLYWHEEL_MANIFEST_FILE_LOCK_DISABLE";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+function isFileLockDisabled() {
+  const raw = process.env[MANIFEST_LOCK_DISABLE_ENV]?.trim().toLowerCase() ?? "";
+  return raw === "1" || raw === "true" || raw === "yes" || raw === "on";
+}
+function findPackageRoot(startDir) {
+  let current = startDir;
+  for (let i = 0; i < 12; i++) {
+    const pkgJsonPath = path.join(current, "package.json");
+    const templatesDir = path.join(current, "templates", ".poetic");
+    if (existsSync(pkgJsonPath) && existsSync(templatesDir)) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return path.resolve(startDir, "..");
+}
+var PACKAGE_ROOT = findPackageRoot(__dirname);
+function getManifestLockFilePath(workflowId) {
+  return path.join(getArtifactDir(workflowId), "manifest.lock");
+}
+async function acquireManifestFileLock(workflowId) {
+  if (isFileLockDisabled()) {
+    return async () => {
+    };
+  }
+  const lockTarget = getManifestLockFilePath(workflowId);
+  await fs.mkdir(path.dirname(lockTarget), { recursive: true });
+  try {
+    const handle = await fs.open(lockTarget, "a");
+    await handle.close();
+  } catch {
+  }
+  return lockfile.lock(lockTarget, {
+    stale: 3e4,
+    realpath: false,
+    retries: { retries: 200, minTimeout: 25, maxTimeout: 250, factor: 1.5 }
+  });
+}
+function withManifestLock(workflowId, fn) {
+  const currentOwners = manifestLockContext.getStore();
+  const currentOwner = currentOwners?.get(workflowId);
+  if (currentOwner && manifestLockOwners.get(workflowId) === currentOwner) {
+    return fn();
+  }
+  const previous = (manifestLocks.get(workflowId) ?? Promise.resolve()).catch(() => {
+  });
+  let releaseLock;
+  const nextLock = new Promise((resolve2) => {
+    releaseLock = resolve2;
+  });
+  const lockTail = previous.then(() => nextLock);
+  manifestLocks.set(workflowId, lockTail);
+  return previous.then(async () => {
+    const owner = /* @__PURE__ */ Symbol(`manifest-lock:${workflowId}`);
+    const nextOwners = new Map(currentOwners ?? []);
+    nextOwners.set(workflowId, owner);
+    manifestLockOwners.set(workflowId, owner);
+    let releaseFileLock;
+    try {
+      releaseFileLock = await acquireManifestFileLock(workflowId);
+      return await manifestLockContext.run(nextOwners, fn);
+    } finally {
+      if (releaseFileLock) {
+        try {
+          await releaseFileLock();
+        } catch {
+        }
+      }
+      if (manifestLockOwners.get(workflowId) === owner) {
+        manifestLockOwners.delete(workflowId);
+      }
+      releaseLock?.();
+      if (manifestLocks.get(workflowId) === lockTail) {
+        manifestLocks.delete(workflowId);
+      }
+    }
+  });
+}
+var WORKTREE_RECORD_RECOVERY_REASON = {
+  PATH_ALREADY_ABSENT: "recovery_reconcile:worktree_path_already_absent",
+  PATH_INVALID_DURING_STATUS_PROBE: "recovery_reconcile:worktree_path_invalid_during_status_probe"
+};
+var WORKTREE_RECORD_CLEANUP_REASON = {
+  PATH_STILL_PRESENT_AFTER_SUCCESSFUL_CLEANUP: "cleanup_state:path_still_present_after_successful_cleanup"
+};
+function hasRecoverableCompletedSubStageProof(snapshot) {
+  if (snapshot.integrationStatus !== "cherry_picked") {
+    return true;
+  }
+  const hasCommit = (snapshot.integratedCommitShas ?? []).some((sha) => sha.trim().length > 0);
+  return hasCommit || snapshot.integrationProof === "no_commits";
+}
+var FLYWHEEL_MANIFEST_STATUSES = [
+  "pending",
+  "applied",
+  "staged",
+  "failed"
+];
+var FLYWHEEL_STATUS_ALIASES = {
+  // `merged` is historical UX wording for an applied run.
+  merged: "applied"
+};
+var FLYWHEEL_STATUS_FILTER_INPUTS = [
+  ...FLYWHEEL_MANIFEST_STATUSES,
+  ...Object.keys(FLYWHEEL_STATUS_ALIASES)
+];
+function normalizeFlywheelStatusFilter(input) {
+  if (FLYWHEEL_MANIFEST_STATUSES.includes(input)) {
+    return input;
+  }
+  return FLYWHEEL_STATUS_ALIASES[input] ?? null;
+}
+var WORKFLOW_HEARTBEAT_STALE_AFTER_MS = 12e4;
+var MANIFEST_WORKTREE_RECONCILE_ENV = "POETIC_FLYWHEEL_MANIFEST_WORKTREE_RECONCILE";
+function isManifestWorktreeReconcileEnabled() {
+  const raw = process.env[MANIFEST_WORKTREE_RECONCILE_ENV]?.trim().toLowerCase() ?? "";
+  if (raw === "0" || raw === "false" || raw === "off" || raw === "no") {
+    return false;
+  }
+  return true;
+}
+function deriveWorktreeOwnershipMetadata(workflowId, owner) {
+  const ownerId = owner.trim() || "unknown";
+  if (ownerId === "integration") {
+    return { workflowId, kind: "integration", ownerId };
+  }
+  if (ownerId === "verify-baseline" || ownerId === "baseline") {
+    return { workflowId, kind: "baseline", ownerId };
+  }
+  if (ownerId.startsWith("stage-") || ownerId.includes("/") || ownerId.includes("-")) {
+    return { workflowId, kind: "stage", ownerId };
+  }
+  return { workflowId, kind: "other", ownerId };
+}
+function ensureWorktreeOwnershipMetadata(workflowId, record) {
+  if (record.ownership) {
+    return false;
+  }
+  record.ownership = deriveWorktreeOwnershipMetadata(workflowId, record.owner);
+  return true;
+}
+function resolveWorktreeAbsolutePath(worktreePath) {
+  const trimmed = worktreePath.trim();
+  if (!trimmed) {
+    return "";
+  }
+  return path.isAbsolute(trimmed) ? trimmed : path.resolve(getProjectRoot(), trimmed);
+}
+async function isWorktreeDirectoryPresent(absPath) {
+  if (!absPath) {
+    return false;
+  }
+  try {
+    const st = await fs.stat(absPath);
+    return st.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function reconcileManifestWorktreesWithDisk(manifest) {
+  if (!isManifestWorktreeReconcileEnabled()) {
+    return false;
+  }
+  const records = manifest.worktreeRecords;
+  if (!records?.length) {
+    return false;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let changed = false;
+  for (const record of records) {
+    changed = ensureWorktreeOwnershipMetadata(manifest.workflowId, record) || changed;
+    const abs = resolveWorktreeAbsolutePath(record.worktreePath);
+    const present = await isWorktreeDirectoryPresent(abs);
+    const cleanedPathStillPresentIsExpected = record.status === "cleaned" && present && record.retentionReason === WORKTREE_RECORD_CLEANUP_REASON.PATH_STILL_PRESENT_AFTER_SUCCESSFUL_CLEANUP;
+    if (cleanedPathStillPresentIsExpected) {
+      continue;
+    }
+    if (record.status === "cleaned" && present) {
+      record.status = "cleanup_failed";
+      record.retentionReason = "manifest_reconcile:cleaned_status_but_worktree_path_still_exists";
+      record.updatedAt = now;
+      changed = true;
+      continue;
+    }
+    if ((record.status === "pending" || record.status === "retained") && !present) {
+      record.status = "cleanup_failed";
+      record.retentionReason = "manifest_reconcile:expected_worktree_path_missing";
+      record.updatedAt = now;
+      changed = true;
+    }
+  }
+  return changed;
+}
+function getConfiguredWorkflowHeartbeatStaleAfterMs(overrideMs) {
+  if (typeof overrideMs === "number" && Number.isFinite(overrideMs) && overrideMs > 0) {
+    return overrideMs;
+  }
+  const rawEnv = process.env.POETIC_FLYWHEEL_WORKFLOW_HEARTBEAT_STALE_AFTER_MS ?? "";
+  const parsedEnv = Number.parseInt(rawEnv, 10);
+  if (Number.isFinite(parsedEnv) && parsedEnv > 0) {
+    return parsedEnv;
+  }
+  return WORKFLOW_HEARTBEAT_STALE_AFTER_MS;
+}
+function getWorkflowLastActivityMs(manifest) {
+  const pendingRecords = (manifest.worktreeRecords ?? []).filter(
+    (record) => record.status === "pending"
+  );
+  const values = [
+    manifest.lastHeartbeatAt,
+    manifest.executedAt,
+    ...pendingRecords.map((record) => record.updatedAt)
+  ];
+  let lastActivityMs;
+  for (const raw of values) {
+    const parsed = Date.parse(raw ?? "");
+    if (!Number.isFinite(parsed)) {
+      continue;
+    }
+    if (lastActivityMs === void 0) {
+      lastActivityMs = parsed;
+    } else if (parsed > lastActivityMs) {
+      lastActivityMs = parsed;
+    }
+  }
+  return lastActivityMs;
+}
+function isWorkflowHeartbeatStale(options) {
+  const { manifest, now = Date.now(), runningHeartbeatStaleAfterMs } = options;
+  const lastActivityMs = getWorkflowLastActivityMs(manifest);
+  if (lastActivityMs === void 0) {
+    return void 0;
+  }
+  const thresholdMs = getConfiguredWorkflowHeartbeatStaleAfterMs(runningHeartbeatStaleAfterMs);
+  return now - lastActivityMs > thresholdMs;
+}
+function getManifestStatus(manifest) {
+  if (manifest.applyError) {
+    return "failed";
+  }
+  if (manifest.appliedAt) {
+    return "applied";
+  }
+  if (manifest.stagedAt) {
+    return "staged";
+  }
+  return "pending";
+}
+function getWorkflowExecutionStatus(options) {
+  const {
+    manifest,
+    workflowResult,
+    branchExists = false,
+    now = Date.now(),
+    runningHeartbeatStaleAfterMs,
+    syncWorktreePathPresent
+  } = options;
+  const manifestStatus = getManifestStatus(manifest);
+  const rawPendingRecords = (manifest.worktreeRecords ?? []).filter(
+    (record) => record.status === "pending"
+  );
+  const pendingPathDrift = typeof syncWorktreePathPresent === "function" ? rawPendingRecords.some(
+    (record) => !syncWorktreePathPresent(resolveWorktreeAbsolutePath(record.worktreePath))
+  ) : false;
+  const pendingRecords = typeof syncWorktreePathPresent === "function" ? rawPendingRecords.filter(
+    (record) => syncWorktreePathPresent(resolveWorktreeAbsolutePath(record.worktreePath))
+  ) : rawPendingRecords;
+  let heartbeatStale;
+  let isInRecoveryWindow = false;
+  if (manifestStatus === "pending" && pendingRecords.length > 0) {
+    heartbeatStale = isWorkflowHeartbeatStale({
+      manifest,
+      now,
+      runningHeartbeatStaleAfterMs
+    });
+    const activityStaleOrUnknown = heartbeatStale !== false;
+    isInRecoveryWindow = activityStaleOrUnknown;
+  }
+  if (workflowResult && typeof workflowResult === "object" && "success" in workflowResult && typeof workflowResult.success === "boolean") {
+    const success = workflowResult.success;
+    if (success && (isInRecoveryWindow || pendingPathDrift)) {
+      return "unknown";
+    }
+    return success ? "succeeded" : "failed";
+  }
+  if (manifestStatus !== "pending") {
+    return "unknown";
+  }
+  if (!branchExists) {
+    return "unknown";
+  }
+  if (pendingRecords.length === 0) {
+    return "unknown";
+  }
+  if (heartbeatStale === void 0) {
+    return "unknown";
+  }
+  return heartbeatStale ? "unknown" : "running";
+}
+function hasPendingWorktreePathAbsentOnDisk(manifest, existsSyncFn = existsSync) {
+  for (const record of manifest.worktreeRecords ?? []) {
+    if (record.status !== "pending") {
+      continue;
+    }
+    const abs = resolveWorktreeAbsolutePath(record.worktreePath);
+    if (!abs) {
+      continue;
+    }
+    if (!existsSyncFn(abs)) {
+      return true;
+    }
+  }
+  return false;
+}
+function getProjectRoot() {
+  if (hasExplicitPoeticRoot()) {
+    const override = resolveRepoRootOverride();
+    if (override) {
+      return override;
+    }
+  }
+  const cwd = resolvePoeticRepoStartDir(process.cwd());
+  const worktreeMarker = `${path.sep}.poetic${path.sep}tmp${path.sep}worktrees${path.sep}`;
+  const markerIndex = cwd.indexOf(worktreeMarker);
+  if (markerIndex > 0) return cwd.slice(0, markerIndex);
+  try {
+    const result = execaSync("git", ["rev-parse", "--path-format=absolute", "--show-toplevel"], {
+      cwd,
+      timeout: 1500,
+      stdio: "pipe"
+    });
+    const topLevel = result.stdout?.trim();
+    if (topLevel) {
+      return path.resolve(cwd, topLevel);
+    }
+  } catch {
+  }
+  const projectRoot = findProjectRoot(cwd);
+  if (projectRoot) {
+    return projectRoot;
+  }
+  try {
+    const result = execaSync("git", ["rev-parse", "--git-common-dir"], {
+      cwd,
+      timeout: 1500,
+      stdio: "pipe"
+    });
+    const commonDirRaw = result.stdout?.trim();
+    if (commonDirRaw) {
+      const commonDir = path.isAbsolute(commonDirRaw) ? commonDirRaw : path.resolve(cwd, commonDirRaw);
+      if (path.basename(commonDir) === ".git") {
+        return path.dirname(commonDir);
+      }
+    }
+  } catch {
+  }
+  return cwd;
+}
+var WORKFLOW_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]*$/;
+function assertSafeWorkflowId(workflowId) {
+  if (typeof workflowId !== "string" || workflowId.length === 0 || workflowId.length > 256) {
+    throw new Error("Invalid workflow ID");
+  }
+  if (!WORKFLOW_ID_PATTERN.test(workflowId)) {
+    throw new Error("Invalid workflow ID");
+  }
+}
+function getArtifactDirForRoot(projectRoot, workflowId) {
+  assertSafeWorkflowId(workflowId);
+  const baseDir = path.resolve(projectRoot, ".poetic", "tmp", "flywheel");
+  const resolved = path.resolve(baseDir, workflowId);
+  const rel = path.relative(baseDir, resolved);
+  if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel)) {
+    throw new Error("Invalid workflow ID");
+  }
+  return resolved;
+}
+function getArtifactDir(workflowId) {
+  return getArtifactDirForRoot(getProjectRoot(), workflowId);
+}
+function getManifestPath(workflowId) {
+  return path.join(getArtifactDir(workflowId), "manifest.json");
+}
+function getWorkflowYamlPath(workflowId) {
+  return path.join(getArtifactDir(workflowId), "workflow.yaml");
+}
+function getResultPath(workflowId) {
+  return path.join(getArtifactDir(workflowId), "result.json");
+}
+function getPartialResultPath(workflowId) {
+  return path.join(getArtifactDir(workflowId), "result.partial.json");
+}
+function getResultPathForRoot(projectRoot, workflowId) {
+  return path.join(getArtifactDirForRoot(projectRoot, workflowId), "result.json");
+}
+async function readManifestFromDisk(workflowId) {
+  const manifestPath = getManifestPath(workflowId);
+  try {
+    const content = await fs.readFile(manifestPath, "utf-8");
+    return normalizeManifestSchema(JSON.parse(content), workflowId);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Manifest not found for workflow: ${workflowId}`);
+    }
+    throw error;
+  }
+}
+function normalizeManifestSchema(manifest, workflowId = manifest.workflowId) {
+  const schemaVersion = manifest.schemaVersion;
+  if (schemaVersion === void 0) {
+    return {
+      ...manifest,
+      schemaVersion: CURRENT_MANIFEST_SCHEMA_VERSION
+    };
+  }
+  if (schemaVersion !== CURRENT_MANIFEST_SCHEMA_VERSION) {
+    throw new Error(
+      `Unsupported manifest schema version ${String(schemaVersion)} for workflow ${workflowId}; supported version: ${CURRENT_MANIFEST_SCHEMA_VERSION}`
+    );
+  }
+  return manifest;
+}
+function getTriagePath(workflowId) {
+  return path.join(getArtifactDir(workflowId), "triage.json");
+}
+async function getPoeticVersion() {
+  try {
+    const packagePath = path.join(PACKAGE_ROOT, "package.json");
+    const packageJson = JSON.parse(await fs.readFile(packagePath, "utf-8"));
+    return packageJson.version || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+async function getPoeticCommit() {
+  try {
+    const { stdout } = await execa("git", ["rev-parse", "HEAD"], {
+      cwd: PACKAGE_ROOT,
+      timeout: 5e3
+    });
+    return stdout.trim();
+  } catch {
+    return "unknown";
+  }
+}
+async function getGitUsername() {
+  try {
+    const { stdout } = await execa("git", ["config", "user.name"], {
+      timeout: 5e3
+    });
+    const name = stdout.trim();
+    if (name) {
+      return name;
+    }
+  } catch {
+  }
+  try {
+    return os.userInfo().username || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+async function createManifest(options) {
+  const [poeticVersion, poeticCommit, executedBy] = await Promise.all([
+    getPoeticVersion(),
+    getPoeticCommit(),
+    getGitUsername()
+  ]);
+  const executedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let generatedYamlPath = options.generatedYamlPath;
+  if (generatedYamlPath) {
+    const projectRoot = getProjectRoot();
+    generatedYamlPath = path.isAbsolute(generatedYamlPath) ? path.relative(projectRoot, generatedYamlPath) : generatedYamlPath;
+    generatedYamlPath = generatedYamlPath.replaceAll("\\", "/");
+  }
+  return {
+    schemaVersion: CURRENT_MANIFEST_SCHEMA_VERSION,
+    workflowId: options.workflowId,
+    sourceType: options.sourceType,
+    sprintId: options.sprintId,
+    integrationBranch: options.integrationBranch,
+    baseSha: options.baseSha,
+    generatedYamlPath,
+    stageIds: options.stageIds?.map((id) => id.trim()).filter(Boolean),
+    executedAt,
+    lastHeartbeatAt: executedAt,
+    executedBy,
+    executedFrom: process.cwd(),
+    originalCommand: options.originalCommand || process.argv.slice(2),
+    planArtifactPath: options.planArtifactPath,
+    verificationPolicy: options.verificationPolicy ?? "findings",
+    poeticVersion,
+    poeticCommit
+  };
+}
+async function saveManifest(manifest) {
+  const manifestPath = getManifestPath(manifest.workflowId);
+  const artifactDir = path.dirname(manifestPath);
+  await fs.mkdir(artifactDir, { recursive: true });
+  await atomicWriteJson(manifestPath, normalizeManifestSchema(manifest));
+}
+async function loadManifest(workflowId) {
+  return readManifestFromDisk(workflowId);
+}
+async function updateManifest(workflowId, updater) {
+  return withManifestLock(workflowId, async () => {
+    const manifest = await readManifestFromDisk(workflowId);
+    await updater(manifest);
+    if (manifest.workflowId !== workflowId) {
+      throw new Error(
+        `Manifest workflow ID cannot change during locked update: expected ${workflowId}, received ${manifest.workflowId}`
+      );
+    }
+    await saveManifest(manifest);
+    return manifest;
+  });
+}
+async function reconcileAndSaveManifest(workflowId) {
+  return withManifestLock(workflowId, async () => {
+    const manifest = await readManifestFromDisk(workflowId);
+    const changed = await reconcileManifestWorktreesWithDisk(manifest);
+    if (changed) {
+      await saveManifest(manifest);
+    }
+    return manifest;
+  });
+}
+async function updateManifestApplyStatus(workflowId, status) {
+  return withManifestLock(workflowId, async () => {
+    const manifest = await loadManifest(workflowId);
+    if (status.appliedAt) {
+      manifest.appliedAt = status.appliedAt;
+      delete manifest.applyError;
+    }
+    if (status.appliedBy) {
+      manifest.appliedBy = status.appliedBy;
+    }
+    if (status.stagedAt) {
+      manifest.stagedAt = status.stagedAt;
+    }
+    if (status.verifiedTreeFingerprint !== void 0) {
+      manifest.verifiedTreeFingerprint = status.verifiedTreeFingerprint;
+    }
+    if (status.appliedCommitSha !== void 0) {
+      manifest.appliedCommitSha = status.appliedCommitSha;
+    }
+    if (status.postApplyError) {
+      manifest.postApplyError = status.postApplyError;
+    }
+    if (status.prUrl !== void 0) {
+      manifest.prUrl = status.prUrl;
+    }
+    if (status.prNumber !== void 0) {
+      manifest.prNumber = status.prNumber;
+    }
+    if (status.prHeadSha !== void 0) {
+      manifest.prHeadSha = status.prHeadSha;
+    }
+    if (status.sourceBranch !== void 0) {
+      manifest.sourceBranch = status.sourceBranch;
+    }
+    if (status.sourceBranchRole !== void 0) {
+      manifest.sourceBranchRole = status.sourceBranchRole;
+    }
+    if (status.applyTargetBranch !== void 0) {
+      manifest.applyTargetBranch = status.applyTargetBranch;
+    }
+    if (status.applyTargetBranchRole !== void 0) {
+      manifest.applyTargetBranchRole = status.applyTargetBranchRole;
+    }
+    if (status.branchRoleAction !== void 0) {
+      manifest.branchRoleAction = status.branchRoleAction;
+    }
+    if (status.branchRoleOverride !== void 0) {
+      manifest.branchRoleOverride = status.branchRoleOverride;
+    }
+    if (status.branchRoleRefused !== void 0) {
+      manifest.branchRoleRefused = status.branchRoleRefused;
+    }
+    if (status.applyError) {
+      manifest.applyError = status.applyError;
+      delete manifest.appliedAt;
+      delete manifest.appliedBy;
+      delete manifest.appliedCommitSha;
+    } else if (status.applyError === null) {
+      delete manifest.applyError;
+    }
+    await saveManifest(manifest);
+  });
+}
+async function updateManifestHeartbeat(workflowId, heartbeatAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  return withManifestLock(workflowId, async () => {
+    const manifest = await loadManifest(workflowId);
+    manifest.lastHeartbeatAt = heartbeatAt;
+    await saveManifest(manifest);
+  });
+}
+function getManifestStageProgress(manifest, stageId) {
+  return manifest.stageProgress?.[stageId];
+}
+async function recordManifestCompletedSubStage(workflowId, stageId, snapshot) {
+  return withManifestLock(workflowId, async () => {
+    const manifest = await loadManifest(workflowId);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existingStageProgress = manifest.stageProgress?.[stageId];
+    const completedSubStages = [...existingStageProgress?.completedSubStages ?? []];
+    const existingIndex = completedSubStages.findIndex((entry) => entry.id === snapshot.id);
+    const existingSnapshot = existingIndex >= 0 ? completedSubStages[existingIndex] : void 0;
+    const nextSnapshot = {
+      ...snapshot,
+      commitBranch: snapshot.commitBranch ?? existingSnapshot?.commitBranch,
+      integrationProof: snapshot.integrationProof ?? existingSnapshot?.integrationProof,
+      updatedAt: now
+    };
+    if (existingIndex >= 0) {
+      completedSubStages[existingIndex] = nextSnapshot;
+    } else {
+      completedSubStages.push(nextSnapshot);
+    }
+    manifest.stageProgress = {
+      ...manifest.stageProgress ?? {},
+      [stageId]: {
+        ...existingStageProgress,
+        completedSubStages,
+        updatedAt: now
+      }
+    };
+    await saveManifest(manifest);
+  });
+}
+async function recordManifestCompletedStage(workflowId, stageResult) {
+  return withManifestLock(workflowId, async () => {
+    const manifest = await loadManifest(workflowId);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existingStageProgress = manifest.stageProgress?.[stageResult.stageId];
+    manifest.stageProgress = {
+      ...manifest.stageProgress ?? {},
+      [stageResult.stageId]: {
+        completedSubStages: existingStageProgress?.completedSubStages ?? [],
+        stageResult,
+        updatedAt: now
+      }
+    };
+    await saveManifest(manifest);
+  });
+}
+async function appendManifestRelatedTaskIds(workflowId, taskIds) {
+  const filtered = (taskIds ?? []).map((t) => t.trim()).filter(Boolean);
+  if (filtered.length === 0) return;
+  return withManifestLock(workflowId, async () => {
+    const manifest = await loadManifest(workflowId);
+    const existing = new Set(manifest.relatedTaskIds ?? []);
+    for (const id of filtered) existing.add(id);
+    manifest.relatedTaskIds = Array.from(existing);
+    await saveManifest(manifest);
+  });
+}
+async function listManifests() {
+  const flywheelDir = path.join(getProjectRoot(), ".poetic", "tmp", "flywheel");
+  try {
+    const entries = await fs.readdir(flywheelDir, { withFileTypes: true });
+    const manifests = [];
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const workflowId = entry.name;
+        try {
+          const manifest = await loadManifest(workflowId);
+          manifests.push(manifest);
+        } catch {
+        }
+      }
+    }
+    manifests.sort((a, b) => {
+      return new Date(b.executedAt).getTime() - new Date(a.executedAt).getTime();
+    });
+    return manifests;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+async function registerWorktreeRecord(workflowId, record) {
+  return withManifestLock(workflowId, async () => {
+    const manifest = await loadManifest(workflowId);
+    const records = manifest.worktreeRecords ?? [];
+    const existingIdx = records.findIndex((r) => r.worktreePath === record.worktreePath);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const prev = existingIdx >= 0 ? records[existingIdx] : void 0;
+    if (prev) {
+      records[existingIdx] = {
+        ...record,
+        ownership: record.ownership ?? prev.ownership ?? deriveWorktreeOwnershipMetadata(workflowId, record.owner),
+        status: "pending",
+        createdAt: prev.createdAt,
+        updatedAt: now
+      };
+    } else {
+      records.push({
+        ...record,
+        ownership: record.ownership ?? deriveWorktreeOwnershipMetadata(workflowId, record.owner),
+        status: "pending",
+        createdAt: now,
+        updatedAt: now
+      });
+    }
+    manifest.worktreeRecords = records;
+    await saveManifest(manifest);
+  });
+}
+async function updateWorktreeRecordStatus(workflowId, worktreePath, status, retentionReason) {
+  return withManifestLock(workflowId, async () => {
+    const manifest = await loadManifest(workflowId);
+    const records = manifest.worktreeRecords ?? [];
+    const record = records.find((r) => r.worktreePath === worktreePath);
+    if (record) {
+      ensureWorktreeOwnershipMetadata(manifest.workflowId, record);
+      record.status = status;
+      record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (retentionReason !== void 0) {
+        if (retentionReason === null) {
+          delete record.retentionReason;
+        } else {
+          record.retentionReason = retentionReason;
+        }
+      }
+      manifest.worktreeRecords = records;
+      await saveManifest(manifest);
+    }
+  });
+}
+function getTrackedCleanupTargets(manifest) {
+  const trackedBranches = Array.from(
+    new Set((manifest.worktreeRecords ?? []).map((record) => record.branch.trim()).filter(Boolean))
+  );
+  const trackedWorktrees = Array.from(
+    new Set(
+      (manifest.worktreeRecords ?? []).map((record) => record.worktreePath.trim()).filter(Boolean)
+    )
+  );
+  return { trackedBranches, trackedWorktrees };
+}
+function getWorktreeRecordsByStatus(manifest, status) {
+  return (manifest.worktreeRecords ?? []).filter((r) => r.status === status);
+}
+async function saveTriage(triage) {
+  const triagePath = getTriagePath(triage.workflowId);
+  const artifactDir = path.dirname(triagePath);
+  await fs.mkdir(artifactDir, { recursive: true });
+  await atomicWriteJson(triagePath, triage);
+}
+async function loadTriage(workflowId) {
+  const triagePath = getTriagePath(workflowId);
+  try {
+    const content = await fs.readFile(triagePath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+
+export {
+  withManifestLock,
+  WORKTREE_RECORD_RECOVERY_REASON,
+  WORKTREE_RECORD_CLEANUP_REASON,
+  hasRecoverableCompletedSubStageProof,
+  FLYWHEEL_MANIFEST_STATUSES,
+  FLYWHEEL_STATUS_ALIASES,
+  FLYWHEEL_STATUS_FILTER_INPUTS,
+  normalizeFlywheelStatusFilter,
+  WORKFLOW_HEARTBEAT_STALE_AFTER_MS,
+  MANIFEST_WORKTREE_RECONCILE_ENV,
+  isManifestWorktreeReconcileEnabled,
+  deriveWorktreeOwnershipMetadata,
+  reconcileManifestWorktreesWithDisk,
+  getConfiguredWorkflowHeartbeatStaleAfterMs,
+  getWorkflowLastActivityMs,
+  isWorkflowHeartbeatStale,
+  getManifestStatus,
+  getWorkflowExecutionStatus,
+  hasPendingWorktreePathAbsentOnDisk,
+  getProjectRoot,
+  getArtifactDirForRoot,
+  getArtifactDir,
+  getManifestPath,
+  getWorkflowYamlPath,
+  getResultPath,
+  getPartialResultPath,
+  getResultPathForRoot,
+  getTriagePath,
+  createManifest,
+  saveManifest,
+  loadManifest,
+  updateManifest,
+  reconcileAndSaveManifest,
+  updateManifestApplyStatus,
+  updateManifestHeartbeat,
+  getManifestStageProgress,
+  recordManifestCompletedSubStage,
+  recordManifestCompletedStage,
+  appendManifestRelatedTaskIds,
+  listManifests,
+  registerWorktreeRecord,
+  updateWorktreeRecordStatus,
+  getTrackedCleanupTargets,
+  getWorktreeRecordsByStatus,
+  saveTriage,
+  loadTriage
+};
+//# sourceMappingURL=chunk-CQM3A35X.js.map