@poetic-ai/poetic 1.42.0

package/dist/chunk-PGSPX4SU.js

@@ -0,0 +1,15 @@
+import {
+  POETIC_LAB_MODE,
+  readRawEnv
+} from "./chunk-5DLKYTQX.js";
+
+// src/core/lab-mode-env.ts
+function isLabModeFromEnv() {
+  const val = readRawEnv(POETIC_LAB_MODE)?.trim().toLowerCase();
+  return val === "1" || val === "true";
+}
+
+export {
+  isLabModeFromEnv
+};
+//# sourceMappingURL=chunk-PGSPX4SU.js.map

package/dist/chunk-PIKLF7BM.js

@@ -0,0 +1,432 @@
+import {
+  getProviderRuntimeQuirks
+} from "./chunk-FC23CTXV.js";
+import {
+  getCapability
+} from "./chunk-AT4TNPWW.js";
+import {
+  normalizeReasoningEffortInput
+} from "./chunk-4BTDUT2S.js";
+
+// src/automation/execution-policy-applier.ts
+import { createHash } from "crypto";
+var EXECUTION_POLICY_STAMP_VERSION = 3;
+function hasCurrentExecutionPolicyStampShape(stamp) {
+  if (!stamp || stamp.applied !== true || stamp.version !== EXECUTION_POLICY_STAMP_VERSION) {
+    return false;
+  }
+  const assurance = stamp.reviewAssurance;
+  const preflight = stamp.preflight;
+  return Boolean(
+    /^[a-f0-9]{16}$/.test(stamp.rolesFingerprint) && assurance && assurance.executorSeparation === "separated" && assurance.invocationSeparation === "required-fresh-readonly" && assurance.invocationSeparationVerified === false && preflight?.executor.provider.trim() && preflight.reviewer.provider.trim() && preflight.reviewer.gate !== "off" && preflight.reviewer.sameVendorReview === false && !providerIdsEqual(preflight.executor.provider, preflight.reviewer.provider)
+  );
+}
+function providerIdsEqual(left, right) {
+  return left.trim().toLowerCase() === right.trim().toLowerCase();
+}
+function canonicalJson(value) {
+  if (value === void 0) return "null";
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  const entries = Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+  return `{${entries.map(([key, entryValue]) => `${JSON.stringify(key)}:${canonicalJson(entryValue)}`).join(",")}}`;
+}
+function computeExecutionPolicyFingerprint(stages, reviewAssurance, preflight) {
+  return createHash("sha256").update(canonicalJson({ stages, reviewAssurance, preflight })).digest("hex").slice(0, 16);
+}
+function describeExecutionPolicyStampMismatch(stamp) {
+  if (stamp.version !== EXECUTION_POLICY_STAMP_VERSION) {
+    return `found version ${String(stamp.version)}, expected ${EXECUTION_POLICY_STAMP_VERSION}`;
+  }
+  return `stamp version ${String(stamp.version)} is current, but the stamp no longer matches the persisted workflow (stage topology or role bindings drifted)`;
+}
+function hasCanonicalReviewTuple(stagesById, executionStage, preflight) {
+  const { reviewer } = preflight;
+  const isCompetition = executionStage.type === "competition";
+  const diffOutputName = isCompetition ? COMPETITION_WINNER_DIFF_OUTPUT : EXECUTION_DIFF_OUTPUT;
+  const reviewId = reviewerStageId(executionStage.id);
+  const reviewStage = stagesById.get(reviewId);
+  if (!reviewStage || reviewStage.type !== "standard" || !providerIdsEqual(reviewStage.provider ?? "", reviewer.provider) || reviewer.model && reviewStage.model !== reviewer.model || reviewStage.deps?.length !== 1 || reviewStage.deps[0] !== executionStage.id || reviewStage.capabilities?.modifiesFiles !== false || reviewStage.capabilities.executionIntent !== "analysis" || reviewStage.templateVariables?.reviewInvocationSeparation !== "required-fresh-readonly" || reviewStage.templateVariables.reviewInvocationSeparationVerified !== false || reviewStage.templateVariables.reviewRole !== "reviewer" || reviewStage.inputs?.length !== 1 || reviewStage.inputs[0] !== `${executionStage.id}.${diffOutputName}` || reviewStage.outputs?.findings !== "text" || reviewStage.prompt !== buildReviewerPrompt(executionStage.id, diffOutputName)) {
+    return false;
+  }
+  const gateStage = stagesById.get(gateStageId(executionStage.id));
+  const expectedGate = buildGateStage(executionStage, reviewStage, reviewer.gate);
+  return Boolean(
+    gateStage && gateStage.type === "verify" && JSON.stringify(gateStage.deps) === JSON.stringify(expectedGate.deps) && JSON.stringify(gateStage.inputs) === JSON.stringify(expectedGate.inputs) && JSON.stringify(gateStage.verify) === JSON.stringify(expectedGate.verify)
+  );
+}
+function isCurrentExecutionPolicyWorkflow(workflow) {
+  const stamp = workflow.metadata?.executionPolicy;
+  if (!hasCurrentExecutionPolicyStampShape(stamp) || !stamp?.preflight) return false;
+  const { executor, reviewer } = stamp.preflight;
+  if (stamp.rolesFingerprint !== computeExecutionPolicyFingerprint(workflow.stages, stamp.reviewAssurance, stamp.preflight)) {
+    return false;
+  }
+  const stageLists = [workflow.stages];
+  for (const stage of workflow.stages) {
+    if (stage.type === "orchestrator" && stage.seededPlan) {
+      stageLists.push(stage.seededPlan.subStages);
+    }
+  }
+  for (const stages of stageLists) {
+    const byId = new Map(stages.map((stage) => [stage.id, stage]));
+    const potentialExecutionStages = stages.filter(isExecutionStage);
+    const reviewerIds = /* @__PURE__ */ new Set();
+    for (const executionStage of potentialExecutionStages) {
+      if (hasCanonicalReviewTuple(byId, executionStage, stamp.preflight)) {
+        reviewerIds.add(reviewerStageId(executionStage.id));
+      }
+    }
+    const executionStages = potentialExecutionStages.filter((stage) => !reviewerIds.has(stage.id));
+    for (const executionStage of executionStages) {
+      const isCompetition = executionStage.type === "competition";
+      const diffOutputName = isCompetition ? COMPETITION_WINNER_DIFF_OUTPUT : EXECUTION_DIFF_OUTPUT;
+      if (executionStage.outputs?.[diffOutputName] !== "diff") return false;
+      if (isCompetition) {
+        const variants = executionStage.competition?.variants ?? [];
+        if (variants.length === 0 || variants.some(
+          (variant) => !variant.provider.trim() || providerIdsEqual(variant.provider, reviewer.provider)
+        )) {
+          return false;
+        }
+      } else if (!providerIdsEqual(executionStage.provider ?? "", executor.provider)) {
+        return false;
+      }
+      const reviewId = reviewerStageId(executionStage.id);
+      if (!hasCanonicalReviewTuple(byId, executionStage, stamp.preflight)) return false;
+      for (const stage of stages) {
+        if (stage.id !== reviewId && stage.deps?.includes(executionStage.id)) return false;
+      }
+    }
+  }
+  return true;
+}
+var EXECUTION_STAGE_TYPES = /* @__PURE__ */ new Set([
+  "standard",
+  "competition"
+]);
+var EXECUTION_DIFF_OUTPUT = "executionDiff";
+var COMPETITION_WINNER_DIFF_OUTPUT = "winnerDiff";
+function isExecutionPolicyEngaged(roles) {
+  const gate = roles.reviewer.gate;
+  return gate.source !== "fallback" && gate.value !== "off";
+}
+function applyExecutionPolicy(workflow, roles, opts = {}) {
+  const existingStamp = workflow.metadata?.executionPolicy;
+  if (existingStamp !== void 0) {
+    if (isCurrentExecutionPolicyWorkflow(workflow)) return workflow;
+    throw new Error(
+      `Execution policy stamp is stale or malformed (${describeExecutionPolicyStampMismatch(existingStamp)}); regenerate the workflow.`
+    );
+  }
+  if (!isExecutionPolicyEngaged(roles)) {
+    return workflow;
+  }
+  const rolesWithEffort = roles;
+  const gate = roles.reviewer.gate.value;
+  const orderedStages = materializeDefaultSequentialDeps(workflow);
+  const nextStages = processStageList(orderedStages, rolesWithEffort, gate, opts).map((stage) => {
+    if (stage.type !== "orchestrator") return stage;
+    const withProcessedPlan = stage.seededPlan ? {
+      ...stage,
+      seededPlan: {
+        ...stage.seededPlan,
+        subStages: processStageList(
+          stage.seededPlan.subStages,
+          rolesWithEffort,
+          gate,
+          opts
+        )
+      }
+    } : stage;
+    return bindOrchestratorRole(withProcessedPlan, rolesWithEffort, opts);
+  });
+  const reviewAssurance = roles.reviewAssurance ?? {
+    executorSeparation: roles.sameVendorReview ? "same-as-executor" : "separated",
+    invocationSeparation: "required-fresh-readonly",
+    invocationSeparationVerified: false
+  };
+  const stampedAssurance = {
+    executorSeparation: reviewAssurance.executorSeparation,
+    invocationSeparation: "required-fresh-readonly",
+    // Declared stage contract only — identity is not observable.
+    invocationSeparationVerified: false
+  };
+  const cliChangesExecutorProvider = Boolean(
+    opts.cliProviderOverride && !providerIdsEqual(opts.cliProviderOverride, roles.executor.provider.value)
+  );
+  const preflight = {
+    executor: {
+      provider: opts.cliProviderOverride ?? roles.executor.provider.value,
+      ...cliChangesExecutorProvider ? {} : { model: roles.executor.model.value }
+    },
+    reviewer: {
+      provider: roles.reviewer.provider.value,
+      model: roles.reviewer.model.value,
+      gate: roles.reviewer.gate.value,
+      // Compatibility: same meaning as reviewAssurance.executorSeparation === 'same-as-executor'.
+      sameVendorReview: reviewAssurance.executorSeparation === "same-as-executor",
+      ...roles.reviewer.provider.sourcePath ? { providerSource: roles.reviewer.provider.sourcePath } : {}
+    }
+  };
+  const stamp = {
+    applied: true,
+    version: EXECUTION_POLICY_STAMP_VERSION,
+    rolesFingerprint: computeExecutionPolicyFingerprint(nextStages, stampedAssurance, preflight),
+    reviewAssurance: stampedAssurance,
+    preflight
+  };
+  return {
+    ...workflow,
+    stages: nextStages,
+    metadata: {
+      ...workflow.metadata ?? {},
+      executionPolicy: stamp
+    }
+  };
+}
+function materializeDefaultSequentialDeps(workflow) {
+  if (workflow.strict?.requireExplicitDeps === true) return workflow.stages;
+  return workflow.stages.map((stage, index) => {
+    if (stage.deps !== void 0 || index === 0) return stage;
+    const prevStageId = workflow.stages[index - 1]?.id;
+    if (typeof prevStageId !== "string" || prevStageId.length === 0) return stage;
+    return { ...stage, deps: [prevStageId] };
+  });
+}
+function processStageList(stages, roles, gate, opts) {
+  const gateEnabled = gate !== "off";
+  const bound = stages.map(
+    (stage) => isExecutionStage(stage) && stage.type !== "competition" ? bindExecutorRole(stage, roles, opts) : stage
+  );
+  if (!gateEnabled) {
+    return bound;
+  }
+  const occupiedIds = new Set(bound.map((stage) => stage.id));
+  for (const stage of bound) {
+    if (!isExecutionStage(stage)) continue;
+    for (const reservedId of [reviewerStageId(stage.id), gateStageId(stage.id)]) {
+      if (occupiedIds.has(reservedId)) {
+        throw new Error(
+          `Execution policy cannot inject review stages: stage id '${reservedId}' is already taken by an existing stage. Rename that stage (ids '<exec>-review' and '<exec>-gate' are reserved for policy-injected stages).`
+        );
+      }
+    }
+  }
+  const gateIdByExecId = /* @__PURE__ */ new Map();
+  const injectedReviewerIds = /* @__PURE__ */ new Set();
+  const injected = [];
+  for (const stage of bound) {
+    if (!isExecutionStage(stage)) {
+      injected.push(stage);
+      continue;
+    }
+    const isCompetition = stage.type === "competition";
+    const diffOutputName = isCompetition ? COMPETITION_WINNER_DIFF_OUTPUT : EXECUTION_DIFF_OUTPUT;
+    const execWithDiff = {
+      ...stage,
+      outputs: { ...stage.outputs ?? {}, [diffOutputName]: "diff" }
+    };
+    injected.push(execWithDiff);
+    const reviewerStage = buildReviewerStage(execWithDiff, roles, diffOutputName);
+    const gateStage = buildGateStage(execWithDiff, reviewerStage, gate);
+    gateIdByExecId.set(stage.id, gateStage.id);
+    injectedReviewerIds.add(reviewerStage.id);
+    injected.push(reviewerStage, gateStage);
+  }
+  return injected.map((stage) => {
+    if (injectedReviewerIds.has(stage.id)) return stage;
+    if (!stage.deps || stage.deps.length === 0) return stage;
+    let changed = false;
+    const rewritten = stage.deps.map((dep) => {
+      const gateId = gateIdByExecId.get(dep);
+      if (gateId && stage.id !== gateId) {
+        changed = true;
+        return gateId;
+      }
+      return dep;
+    });
+    return changed ? { ...stage, deps: dedupe(rewritten) } : stage;
+  });
+}
+function isExecutionStage(stage) {
+  const type = stage.type ?? "standard";
+  return EXECUTION_STAGE_TYPES.has(type);
+}
+function reviewerStageId(execId) {
+  return `${execId}-review`;
+}
+function gateStageId(execId) {
+  return `${execId}-gate`;
+}
+function bindExecutorRole(stage, roles, opts) {
+  const next = { ...stage };
+  const executorProvider = opts.cliProviderOverride ?? roles.executor.provider.value;
+  next.provider = executorProvider;
+  if (!next.model && !opts.cliProviderOverride) {
+    next.model = roles.executor.model.value;
+  }
+  if (next.modelReasoningEffort == null) {
+    const effort = readRoleReasoningEffort(roles.executor);
+    if (effort) {
+      next.modelReasoningEffort = effort;
+    }
+  }
+  const subagents = roles.executor.subagents.value;
+  if (subagents !== "off") {
+    const supportsNativeSubagents = getCapability(executorProvider, "provider_native_subagents") === true;
+    if (supportsNativeSubagents) {
+      next.prompt = appendSubagentGuidance(next.prompt ?? "", subagents);
+      if (next.providerExecutionTransport == null) {
+        const rolesTransport = roles.executor.transport.value;
+        next.providerExecutionTransport = rolesTransport !== "auto" ? rolesTransport : resolveNativeSubagentsTransport(executorProvider) ?? "tmux-exec";
+      }
+    } else {
+      opts.onNotice?.(
+        `Execution policy: provider '${executorProvider}' does not support provider-native subagents; subagent guidance skipped for stage '${stage.id}'.`
+      );
+    }
+  }
+  return next;
+}
+function bindOrchestratorRole(stage, roles, opts) {
+  const orch = roles.orchestrator;
+  if (!orch) return stage;
+  const next = { ...stage };
+  const roleMayOverrideComputedDefaults = opts.cliProviderOverride == null;
+  if (orch.provider?.value && (!next.provider || roleMayOverrideComputedDefaults)) {
+    next.provider = orch.provider.value;
+    if (roleMayOverrideComputedDefaults && !orch.model?.value) {
+      next.model = void 0;
+    }
+  }
+  if (orch.model?.value && (!next.model || roleMayOverrideComputedDefaults)) {
+    next.model = orch.model.value;
+  }
+  if (next.modelReasoningEffort == null) {
+    const effort = readRoleReasoningEffort(orch);
+    if (effort) {
+      next.modelReasoningEffort = effort;
+    }
+  }
+  if (orch.provider?.value || orch.model?.value || orch.fallbackModel?.value) {
+    const fallbackModel = orch.fallbackModel?.value;
+    const clearComputedOrchestrationModel = roleMayOverrideComputedDefaults && orch.provider?.value && !orch.model?.value;
+    const retainedProvider = next.orchestrator?.orchestrationProvider ?? next.provider;
+    const retainedModel = next.orchestrator?.orchestrationModel ?? next.model;
+    const fallbackMatchesRetainedBinding = Boolean(
+      fallbackModel && orch.provider?.value && retainedProvider && providerIdsEqual(retainedProvider, orch.provider.value) && (!retainedModel || !orch.model?.value || retainedModel === orch.model.value)
+    );
+    const bindFallback = fallbackModel && (roleMayOverrideComputedDefaults || fallbackMatchesRetainedBinding);
+    next.orchestrator = {
+      ...next.orchestrator ?? {},
+      ...orch.provider?.value && (!next.orchestrator?.orchestrationProvider || roleMayOverrideComputedDefaults) ? { orchestrationProvider: orch.provider.value } : {},
+      ...orch.model?.value && (!next.orchestrator?.orchestrationModel || roleMayOverrideComputedDefaults) ? { orchestrationModel: orch.model.value } : {},
+      ...bindFallback ? { orchestrationFallbackModel: fallbackModel } : {},
+      ...clearComputedOrchestrationModel ? { orchestrationModel: void 0 } : {}
+    };
+  }
+  return next;
+}
+function readRoleReasoningEffort(role) {
+  if (!role?.reasoningEffort) return void 0;
+  return normalizeReasoningEffortInput(role.reasoningEffort.value);
+}
+function resolveNativeSubagentsTransport(provider) {
+  return getProviderRuntimeQuirks(provider)?.nativeSubagentsDefaultTransport;
+}
+function appendSubagentGuidance(prompt, subagents) {
+  const request = typeof subagents === "number" ? `Run ${subagents} native subagents for this task.` : "Run a swarm of native subagents for this task.";
+  const guidance = [
+    "",
+    "Provider-native subagents:",
+    request,
+    "Give the subagents disjoint responsibilities, ask them for concise findings or changes, then synthesize the final answer yourself.",
+    "About 8 subagents run simultaneously; if you need more, launch them in waves of about 8 rather than all at once.",
+    "Do not run Poetic commands recursively."
+  ].join("\n");
+  return `${prompt.trimEnd()}
+${guidance}`;
+}
+function buildReviewerStage(execStage, roles, diffOutputName = EXECUTION_DIFF_OUTPUT) {
+  const execId = execStage.id;
+  const reviewerEffort = readRoleReasoningEffort(roles.reviewer);
+  const reviewer = {
+    id: reviewerStageId(execId),
+    name: `Review: ${execStage.name ?? execId}`,
+    type: "standard",
+    deps: [execId],
+    provider: roles.reviewer.provider.value,
+    model: roles.reviewer.model.value,
+    modelRole: roles.reviewer.modelRole?.value ?? "reviewer",
+    ...reviewerEffort ? { modelReasoningEffort: reviewerEffort } : {},
+    capabilities: {
+      modifiesFiles: false,
+      producesText: true,
+      executionIntent: "analysis"
+    },
+    // Declared (not verified) assurance: review must be a fresh read-only context.
+    templateVariables: {
+      reviewInvocationSeparation: "required-fresh-readonly",
+      reviewInvocationSeparationVerified: false,
+      reviewRole: "reviewer"
+    },
+    inputs: [`${execId}.${diffOutputName}`],
+    outputs: { findings: "text" },
+    prompt: buildReviewerPrompt(execId, diffOutputName)
+  };
+  return reviewer;
+}
+function buildReviewerPrompt(execId, diffOutputName) {
+  return [
+    `You are performing a read-only code review of the diff produced by the '${execId}' execution stage.`,
+    "This is a fresh review invocation: do not continue any prior mutation-owning session, and do not modify any files.",
+    `The diff is provided as input artifact '${execId}.${diffOutputName}'.`,
+    "",
+    "Analyze the diff for correctness bugs, security issues, and clear regressions.",
+    "",
+    "Respond with ONLY a JSON object matching this exact contract:",
+    '{"findings":[{"severity":"high"|"medium"|"low","file":"<path>","line":<number optional>,"summary":"<one line>"}]}',
+    "",
+    "Rules:",
+    '- "findings" must be an array (empty when you find nothing).',
+    '- "severity" must be one of "high", "medium", or "low".',
+    "- Emit the JSON object as your entire response; wrapping it in a ```json fenced block is acceptable."
+  ].join("\n");
+}
+function buildGateStage(execStage, reviewerStage, gate) {
+  const execId = execStage.id;
+  const reviewerId = reviewerStage.id;
+  const mode = gate === "high-severity-blocks" ? "blocking" : "advisory";
+  const findingsFile = `.poetic-stage-inputs/${reviewerId}.findings.txt`;
+  const annotationFile = `.poetic-stage-inputs/${reviewerId}.gate-annotation.json`;
+  const command = [
+    "poetic internal review-gate",
+    `--findings ${findingsFile}`,
+    "--threshold high",
+    `--mode ${mode}`,
+    `--annotation-out ${annotationFile}`
+  ].join(" ");
+  return {
+    id: gateStageId(execId),
+    name: `Review gate: ${execStage.name ?? execId}`,
+    type: "verify",
+    deps: [reviewerId],
+    inputs: [`${reviewerId}.findings`],
+    verify: {
+      commands: [command]
+    }
+  };
+}
+function dedupe(values) {
+  return Array.from(new Set(values));
+}
+
+export {
+  EXECUTION_POLICY_STAMP_VERSION,
+  describeExecutionPolicyStampMismatch,
+  isCurrentExecutionPolicyWorkflow,
+  isExecutionPolicyEngaged,
+  applyExecutionPolicy
+};
+//# sourceMappingURL=chunk-PIKLF7BM.js.map

package/dist/chunk-PJWJ3SAV.js

@@ -0,0 +1,22 @@
+import {
+  createEngineMetadata
+} from "./chunk-GHHFDU2U.js";
+
+// src/core/providers/codex/metadata.ts
+var metadata = createEngineMetadata({
+  id: "codex",
+  name: "Codex",
+  description: "OpenAI Codex via Codex CLI (local exec)",
+  cliCommand: "codex",
+  cliBinary: "codex",
+  installCommand: "npm install -g @openai/codex",
+  authHint: "codex login",
+  setupCommand: "poetic provider setup --providers codex",
+  docsPath: "docs/PROVIDER_SETUP.md",
+  docsAnchor: "codex-cli"
+});
+
+export {
+  metadata
+};
+//# sourceMappingURL=chunk-PJWJ3SAV.js.map

package/dist/chunk-PKIFMV72.js

@@ -0,0 +1,100 @@
+// src/core/estimation/runtime-estimate-format.ts
+var AI_ESTIMATE_LABEL = "AI est";
+function formatRuntimeMinutes(minutes) {
+  if (typeof minutes !== "number" || !Number.isFinite(minutes) || minutes <= 0) {
+    return null;
+  }
+  const rounded = Math.max(1, Math.round(minutes));
+  if (rounded < 60) {
+    return `~${rounded}m`;
+  }
+  const hours = Math.floor(rounded / 60);
+  const remainder = rounded % 60;
+  return remainder === 0 ? `~${hours}h` : `~${hours}h ${remainder}m`;
+}
+function formatRuntimeEstimateCell(expectedRuntimeMinutes) {
+  const formatted = formatRuntimeMinutes(expectedRuntimeMinutes);
+  return formatted === null ? null : `${formatted} (${AI_ESTIMATE_LABEL})`;
+}
+function formatRuntimeEstimateCellCompact(expectedRuntimeMinutes) {
+  const formatted = formatRuntimeMinutes(expectedRuntimeMinutes);
+  return formatted === null ? null : `${formatted} (AI)`;
+}
+
+// src/cli/commands/planning-observational-presentation.ts
+function compareBacklogPriority(a, b) {
+  const priorityOrder = { P0: 0, P1: 1, P2: 2, P3: 3 };
+  const aOrder = a.priority ? priorityOrder[a.priority] ?? 99 : 99;
+  const bOrder = b.priority ? priorityOrder[b.priority] ?? 99 : 99;
+  if (aOrder !== bOrder) return aOrder - bOrder;
+  return a.id.localeCompare(b.id);
+}
+function hasDeclaredRelatedTasks(relatedTasks) {
+  return Array.isArray(relatedTasks) && relatedTasks.length > 0;
+}
+function formatDeclaredRelatedTaskLines(relatedTasks) {
+  return relatedTasks.map((entry) => {
+    if (typeof entry === "string") return `  ${entry}`;
+    const relationship = entry.relationship ? ` (${entry.relationship})` : "";
+    return `  ${entry.id}${relationship}`;
+  });
+}
+function formatLinkedTaskLines(linkedTasks) {
+  return linkedTasks.map(
+    (task) => `  ${task.id}  ${task.status}  sprint:${task.sprintId ?? "none"}  ${task.title}`
+  );
+}
+function formatHours(hours) {
+  if (typeof hours !== "number" || !Number.isFinite(hours)) return "unknown";
+  return `${Number.isInteger(hours) ? hours : Number(hours.toFixed(2))}h`;
+}
+function formatEstimateDisplay(expectedRuntimeMinutes, estimatedHours) {
+  const runtimeCell = formatRuntimeEstimateCell(expectedRuntimeMinutes);
+  if (runtimeCell !== null) return runtimeCell;
+  if (typeof estimatedHours === "number" && Number.isFinite(estimatedHours) && estimatedHours > 0) {
+    return formatHours(estimatedHours);
+  }
+  return "unestimated";
+}
+function extractTaskDescriptionSection(body) {
+  const heading = body.match(/^##\s+Description\b[^\n]*$/im);
+  if (heading?.index === void 0) return "";
+  const afterHeading = heading.index + heading[0].length;
+  const nextSectionRelative = body.slice(afterHeading).search(/\n##\s+/);
+  const sectionEnd = nextSectionRelative >= 0 ? afterHeading + nextSectionRelative : body.length;
+  return body.slice(afterHeading, sectionEnd).trim();
+}
+function isPositiveFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function formatSprintEstimate(task, compact = false) {
+  const runtimeCell = compact ? formatRuntimeEstimateCellCompact(task.expectedRuntimeMinutes) : formatRuntimeEstimateCell(task.expectedRuntimeMinutes);
+  if (runtimeCell !== null) return runtimeCell;
+  if (isPositiveFiniteNumber(task.estimatedHours)) return `${task.estimatedHours}h`;
+  return compact ? "-" : "unestimated";
+}
+function formatSprintNotFoundMessage(error, sprintId) {
+  if (!(error instanceof Error)) return null;
+  if (error.message.startsWith("Sprint not found:")) return error.message;
+  const errno = error;
+  if (errno.code === "ENOENT" || error.message.includes("ENOENT")) {
+    return sprintId ? `Sprint not found: ${sprintId}` : "Sprint not found";
+  }
+  return null;
+}
+
+export {
+  formatRuntimeEstimateCell,
+  formatRuntimeEstimateCellCompact,
+  compareBacklogPriority,
+  hasDeclaredRelatedTasks,
+  formatDeclaredRelatedTaskLines,
+  formatLinkedTaskLines,
+  formatHours,
+  formatEstimateDisplay,
+  extractTaskDescriptionSection,
+  isPositiveFiniteNumber,
+  formatSprintEstimate,
+  formatSprintNotFoundMessage
+};
+//# sourceMappingURL=chunk-PKIFMV72.js.map