@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-URMSZXAD.js

@@ -0,0 +1,43 @@
+import {
+  DEFAULT_TIMEOUT
+} from "./chunk-633XZ7UF.js";
+import {
+  ProviderRegistry
+} from "./chunk-QJ6OEH4K.js";
+import {
+  BUILD_TIMEOUT_MS,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/providers/shared/provider-timeout.ts
+function resolveProviderTimeoutMs(providerId, explicitTimeoutMs) {
+  if (typeof explicitTimeoutMs === "number" && explicitTimeoutMs > 0) {
+    return explicitTimeoutMs;
+  }
+  const parsedProviderEnv = readProviderTimeoutEnvMs(providerId);
+  if (parsedProviderEnv !== void 0) {
+    return parsedProviderEnv;
+  }
+  const parsedGlobalEnv = readEnv(BUILD_TIMEOUT_MS).value;
+  if (parsedGlobalEnv !== void 0 && parsedGlobalEnv > 0) {
+    return parsedGlobalEnv;
+  }
+  try {
+    const timeoutFromConfig = ProviderRegistry.getTimeout(providerId);
+    if (typeof timeoutFromConfig === "number" && timeoutFromConfig > 0) return timeoutFromConfig;
+  } catch {
+  }
+  return DEFAULT_TIMEOUT;
+}
+function readProviderTimeoutEnvMs(providerId) {
+  const providerEnvKey = `BUILD_TIMEOUT_${providerId.toUpperCase()}_MS`;
+  const providerEnv = process.env[providerEnvKey];
+  const parsed = providerEnv ? Number.parseInt(providerEnv, 10) : NaN;
+  return !Number.isNaN(parsed) && parsed > 0 ? parsed : void 0;
+}
+
+export {
+  resolveProviderTimeoutMs,
+  readProviderTimeoutEnvMs
+};
+//# sourceMappingURL=chunk-URMSZXAD.js.map

package/dist/chunk-US3RT6CY.js

@@ -0,0 +1,525 @@
+import {
+  classifyIntent,
+  inferActivity
+} from "./chunk-GI5M67YA.js";
+import {
+  extractAcceptanceCriteria
+} from "./chunk-XON4ZCYX.js";
+import {
+  bucketArchiveRootForContext
+} from "./chunk-VAG6GUBR.js";
+import {
+  getBucketArchivePath
+} from "./chunk-V3KLVK7B.js";
+import {
+  resolvePlanningContext
+} from "./chunk-BBPIILO2.js";
+import {
+  extractExplicitFileTargets
+} from "./chunk-KUEWV2JH.js";
+import {
+  findFencedCodeSpans,
+  isInsideFencedCodeSpan
+} from "./chunk-R2TIYG7U.js";
+import {
+  getProjectReferencePathExtensions,
+  isProjectSourcePath,
+  isProjectTestPath
+} from "./chunk-RPIMAMV7.js";
+import {
+  assertSafePlanningFileId
+} from "./chunk-352PCJLK.js";
+import {
+  isContainedPath
+} from "./chunk-RCP2Y6DQ.js";
+
+// src/planning/archive-sharding.ts
+import * as path from "path";
+function getArchiveShard(archivedAt) {
+  const date = typeof archivedAt === "string" ? new Date(archivedAt) : archivedAt;
+  if (Number.isNaN(date.getTime())) {
+    throw new Error(`Invalid archivedAt timestamp: ${archivedAt}`);
+  }
+  const year = date.getUTCFullYear().toString();
+  const month = (date.getUTCMonth() + 1).toString().padStart(2, "0");
+  return { year, month };
+}
+function getArchivedFilePath(bucket, id, archivedAt, repoRoot = process.cwd()) {
+  const safeId = assertSafePlanningFileId(id, "id");
+  const shard = getArchiveShard(archivedAt);
+  const archivePath = getBucketArchivePath(bucket, repoRoot);
+  const joined = path.join(archivePath, shard.year, shard.month, `${safeId}.md`);
+  const resolved = path.resolve(joined);
+  const resolvedArchive = path.resolve(archivePath);
+  const relative2 = path.relative(resolvedArchive, resolved);
+  if (relative2.startsWith("..") || path.isAbsolute(relative2)) {
+    throw new Error(`id must stay within ${archivePath}: ${id}`);
+  }
+  return resolved;
+}
+function resolveBucketArchiveRoot(kind, startDir) {
+  return bucketArchiveRootForContext(resolvePlanningContext(startDir), kind);
+}
+function isInArchive(archiveRoot, filePath) {
+  return isContainedPath(path.resolve(archiveRoot), path.resolve(filePath));
+}
+async function getShardFromFileMtime(filePath) {
+  const { promises: fs } = await import("fs");
+  try {
+    const stats = await fs.stat(filePath);
+    return getArchiveShard(stats.mtime);
+  } catch {
+    return null;
+  }
+}
+
+// src/planning/task-body-parser.ts
+function parseTaskBody(body) {
+  const result = {
+    description: "",
+    subtasks: [],
+    notes: "",
+    fileMarkers: [],
+    rawBody: body
+  };
+  const descriptionLines = [];
+  const subtaskLines = [];
+  const notesLines = [];
+  let currentSection = "ignored";
+  let sawCanonicalSection = false;
+  const classifyCanonicalHeading = (heading) => {
+    const normalized = heading.toLowerCase().trim();
+    if (normalized.startsWith("description")) return "description";
+    if (normalized.startsWith("subtasks") || normalized.startsWith("checklist")) return "subtasks";
+    if (normalized.startsWith("notes")) return "notes";
+    if (normalized.startsWith("activity")) return "ignored";
+    return null;
+  };
+  const fencedSpans = findFencedCodeSpans(body);
+  let offset = 0;
+  for (const line of body.split("\n")) {
+    const lineStart = offset;
+    offset += line.length + 1;
+    const headingMatch = !isInsideFencedCodeSpan(fencedSpans, lineStart) && line.match(/^##\s+(.+)$/);
+    if (headingMatch) {
+      const nextSection = classifyCanonicalHeading(headingMatch[1] ?? "");
+      if (nextSection) {
+        sawCanonicalSection = true;
+        currentSection = nextSection;
+        continue;
+      }
+      if (currentSection === "description") {
+        descriptionLines.push(line);
+        continue;
+      }
+    }
+    if (currentSection === "description") {
+      descriptionLines.push(line);
+    } else if (currentSection === "subtasks") {
+      subtaskLines.push(line);
+    } else if (currentSection === "notes") {
+      notesLines.push(line);
+    }
+  }
+  result.description = descriptionLines.join("\n").trim();
+  result.notes = notesLines.join("\n").trim();
+  if (!result.description && !sawCanonicalSection) {
+    result.description = extractUnstructuredDescription(body);
+  }
+  const subtaskContent = subtaskLines.join("\n").trim();
+  const bullets = subtaskContent.match(/^[-*]\s+\[?[x ]?\]?\s*(.+)$/gm);
+  if (bullets) {
+    result.subtasks = bullets.map((b) => b.replace(/^[-*]\s+\[?[x ]?\]?\s*/, "").trim());
+  }
+  result.fileMarkers = [...new Set(extractFileMarkers(body))];
+  return result;
+}
+function isMetadataLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return false;
+  if (/^#\s+Task:/i.test(trimmed)) return true;
+  if (/^\*\*(?:Sprint|Status|Estimated|Plan Artifact|Plan Stage)\*\*:/i.test(trimmed)) {
+    return true;
+  }
+  if (/^(?:Sprint|Status|Estimated|Priority|Assignee|Plan Artifact|Plan Stage):\s*/i.test(trimmed)) {
+    return true;
+  }
+  return false;
+}
+function extractUnstructuredDescription(body) {
+  const lines = body.split("\n");
+  const descriptionLines = [];
+  for (const line of lines) {
+    if (isMetadataLine(line)) continue;
+    descriptionLines.push(line);
+  }
+  return descriptionLines.join("\n").trim();
+}
+function buildPromptFromTask(task, body) {
+  const description = body.description || "No description provided.";
+  const fileMarkers = Array.isArray(body.fileMarkers) ? body.fileMarkers : [];
+  const fileBlock = fileMarkers.length > 0 ? `
+
+${fileMarkers.map((file) => `FILE: ${file}`).join("\n")}` : "";
+  const subtasks = Array.isArray(task.subtasks) ? task.subtasks : [];
+  const checklist = subtasks.length > 0 ? subtasks.map((st) => `- [ ] ${st.text}`).join("\n") : "(No subtasks defined)";
+  const prompt = `# Task: ${task.title}
+
+${description}
+${fileBlock}
+
+## Checklist
+${checklist}
+`;
+  const visibleTaskText = [description, ...subtasks.map((subtask) => subtask.text)].join("\n");
+  const missingCriteria = extractAcceptanceCriteria(body.rawBody, {
+    checkboxFallback: false
+  }).filter((criterion) => !visibleTaskText.includes(criterion));
+  return missingCriteria.length > 0 ? `${prompt}
+## Acceptance Criteria
+${missingCriteria.map((criterion) => `- ${criterion}`).join("\n")}
+` : prompt;
+}
+function extractFileMarkers(description) {
+  return extractExplicitFileTargets(description);
+}
+function isTaskHeaderMetadataLine(line) {
+  const trimmed = line.trim();
+  return /^#\s+Task:/i.test(trimmed) || /^\*\*(?:Sprint|Status|Estimated|Plan Artifact|Plan Stage)\*\*:/i.test(trimmed);
+}
+function stripTaskHeaderMetadata(text) {
+  const lines = text.split("\n");
+  const firstSection = lines.findIndex((line) => /^##\s/.test(line));
+  const headerEnd = firstSection < 0 ? lines.length : firstSection;
+  return lines.filter((line, index) => index >= headerEnd || !isTaskHeaderMetadataLine(line)).join("\n");
+}
+
+// src/planning/enhancement-template-data.ts
+var ENHANCEMENT_TEMPLATES = {
+  scope: {
+    title: "Define scope and touchpoints",
+    why: "Scope boundaries reduce drift and keep solutions comparable.",
+    hint: "Add a short Scope section (in scope / out of scope) to reduce drift.",
+    copyPaste: `Affects: <components, modules or areas this change touches>
+
+In scope:
+- ...
+
+Out of scope:
+- ...`
+  },
+  acceptance: {
+    title: "Define done-when criteria",
+    why: "Clear exit criteria prevent scope creep and clarify success.",
+    hint: 'Consider adding a short "Done when\u2026" checklist to define completion.',
+    copyPaste: `Done when:
+- [ ] Primary requirement met
+- [ ] Tests pass
+- [ ] No regressions`
+  },
+  reproducibility: {
+    title: "Make the bug reproducible",
+    why: "Steps to reproduce cut debugging time by 50%.",
+    hint: "Consider adding steps to reproduce plus expected vs actual behavior.",
+    copyPaste: `## Reproduction
+Steps:
+1.
+
+Expected:
+Actual:`
+  },
+  research: {
+    title: "Frame the research questions",
+    why: "Specific questions converge faster than open exploration.",
+    hint: "Consider adding 1\u20133 research questions and the expected deliverable format.",
+    copyPaste: `Questions to answer:
+- What approaches exist?
+- What are the trade-offs?
+
+Deliverable: Comparison table or recommendation`
+  },
+  adr: {
+    title: "Structure as an ADR",
+    why: "ADR format ensures all stakeholder concerns are addressed.",
+    hint: "Consider structuring this as an ADR (Context/Decision/Alternatives/Consequences).",
+    copyPaste: `## Context
+...
+
+## Decision
+...
+
+## Alternatives Considered
+...
+
+## Consequences
+...`
+  },
+  audience: {
+    title: "Define your audience",
+    why: "Knowing the reader shapes tone, depth, and structure.",
+    hint: "Consider defining the intended audience and assumed prior knowledge.",
+    copyPaste: `Audience: [developers/users/architects]
+Prior knowledge assumed: [...]`
+  },
+  testing: {
+    title: "Outline the test plan",
+    why: "A test plan upfront ensures comprehensive coverage.",
+    hint: "Consider outlining the test plan (unit/integration/edge cases).",
+    copyPaste: `Test coverage:
+- [ ] Unit tests for core logic
+- [ ] Integration tests for boundaries
+- [ ] Edge cases: [...]`
+  },
+  constraints: {
+    title: "Set explicit constraints",
+    why: "Constraints prevent over-engineering and scope creep.",
+    hint: 'Consider adding explicit constraints (in-scope/out-of-scope) to reduce drift. Use "Out of scope:" (not FILE:) for exclusions.',
+    copyPaste: `Constraints:
+- Do not introduce regressions outside the areas this item explicitly targets
+- Out of scope: (specify directories or concerns not to touch)`
+  }
+};
+
+// src/planning/task-creation-nudges.ts
+function getEnhancementPriorities(category, activity) {
+  if (activity === "debugging") {
+    return ["reproducibility", "scope", "acceptance"];
+  }
+  if (activity === "planning") {
+    return ["constraints", "acceptance", "scope"];
+  }
+  if (activity === "architecture") {
+    return ["adr", "constraints", "scope"];
+  }
+  if (activity === "research") {
+    return ["research", "constraints", "acceptance"];
+  }
+  if (category === "analyze") {
+    return ["acceptance", "constraints", "scope"];
+  }
+  if (activity === "design") {
+    return ["constraints", "scope", "acceptance"];
+  }
+  if (category === "document") {
+    return ["audience", "scope", "acceptance"];
+  }
+  if (category === "test") {
+    return ["testing", "scope", "acceptance"];
+  }
+  return ["scope", "acceptance", "testing"];
+}
+var PATH_REFERENCE_EXTENSION_ALTERNATION = getProjectReferencePathExtensions().map((ext) => ext.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+var FILE_PATH_LIKE = new RegExp(
+  String.raw`\b(?:[./~]|[a-zA-Z0-9_-]+\/)[a-zA-Z0-9_./-]+\.(?:${PATH_REFERENCE_EXTENSION_ALTERNATION})(?![\w-])`
+);
+function mentionsTestFileReference(text) {
+  const pathTokens = (text.match(/[\w./+-]+/g) ?? []).map((token) => token.replace(/[.,]+$/, "")).filter((token) => token.includes("."));
+  return pathTokens.some((token) => isProjectTestPath(token) && isProjectSourcePath(token));
+}
+function hasAcceptanceCriteria(text) {
+  if (/- \[[ xX]\]/.test(text)) return true;
+  if (/^\s*acceptance\s*:/im.test(text)) return true;
+  if (/^\s*#{1,6}\s*acceptance\b/im.test(text)) return true;
+  if (/(acceptance\s+criteria|done\s+when|definition\s+of\s+done)\b/i.test(text)) return true;
+  if (/\b(must|should)\b/i.test(text) && /\n/.test(text)) return true;
+  if (/\btests?\s+pass\b/i.test(text) || /\b(no|without)\s+regressions?\b/i.test(text)) return true;
+  return false;
+}
+var SCOPE_LANGUAGE = /\b(?:in\s+scope|out\s+of\s+scope|scope\b|touchpoints?|affected\s+(?:areas?|components?)|components?|modules?|services?)\b/i;
+function hasScopeSignal(text) {
+  if (extractFileMarkers(text).length > 0) return true;
+  if (FILE_PATH_LIKE.test(text)) return true;
+  if (SCOPE_LANGUAGE.test(text)) return true;
+  return false;
+}
+function looksMultiConcern(title) {
+  const normalized = title.trim();
+  if (normalized.length < 18) return false;
+  if (/\s+\+\s+/.test(normalized)) return true;
+  if (/\s+and\s+/i.test(normalized)) return true;
+  if (/,/.test(normalized)) return true;
+  return false;
+}
+function hasResearchFraming(text) {
+  if (/\b(output|deliverable|format|return)\b\s*:/i.test(text)) return true;
+  if (/\?/.test(text)) return true;
+  if (/^\s*[-*]\s*(what|why|how)\b/im.test(text)) return true;
+  return false;
+}
+function applyMultiConcernBias(title, priorities) {
+  if (!looksMultiConcern(title)) return priorities;
+  if (priorities.includes("constraints")) return priorities;
+  const next = [...priorities];
+  if (next.length > 0) next[next.length - 1] = "constraints";
+  return next;
+}
+function hasReproducibility(text) {
+  if (/\b(reproduction|repro(?:duce)?|steps?\s+to\s+reproduce)\b/i.test(text)) return true;
+  if (/\b(expected|actual)\s*:/i.test(text)) return true;
+  if (/^\s*\d+\.\s+.*\b(then|next|after|result(?:ing|s)?)\b/im.test(text)) return true;
+  return false;
+}
+function hasAdrStructure(text) {
+  const adrSections = ["context", "decision", "alternatives", "consequences", "status"];
+  let canonicalCount = 0;
+  for (const section of adrSections) {
+    if (new RegExp(`^##?\\s*${section}\\b`, "im").test(text)) {
+      canonicalCount++;
+    }
+  }
+  if (canonicalCount >= 2) return true;
+  const hasContextOrRationale = /^##?\s*(context|rationale|motivation|background|why)\b/im.test(
+    text
+  );
+  const hasDecisionOrGoal = /^##?\s*(decision|goal|objective|summary|proposal)\b/im.test(text);
+  const hasTradeoffSignal = /^##?\s*(alternatives|consequences|trade-?offs?|risks?|out\s+of\s+scope)\b/im.test(text) || /\b(alternatives?\s+considered|pros?\s+(?:and|&)\s+cons?)\b/i.test(text);
+  return hasContextOrRationale && hasDecisionOrGoal && hasTradeoffSignal;
+}
+function hasAudienceDefinition(text) {
+  if (/\b(audience|reader|user|developer|target)\s*:/i.test(text)) return true;
+  if (/\b(intended\s+for|written\s+for|aimed\s+at)\b/i.test(text)) return true;
+  return false;
+}
+var AUTOMATED_TEST_VOCABULARY = /\b(?:tests?\s+cover(?:ing)?|unit|integration|e2e|vitest|jest|playwright|cypress|npm\s+run\s+test|npx\s+vitest|pytest|go\s+test|cargo\s+test|rspec|xctest|junit|phpunit|gradle\s+test|mvn\s+test|dotnet\s+test)\b/i;
+function hasTestPlan(text) {
+  if (/\b(test\s+plan|test\s+coverage|coverage\s+plan)\b/i.test(text)) return true;
+  if (/\b(unit|integration|e2e)\s+test/i.test(text) && /- \[[ xX]?\]/.test(text)) return true;
+  if (/^\s*#{1,6}\s*how\s+to\s+verify\b/im.test(text) && AUTOMATED_TEST_VOCABULARY.test(text)) {
+    return true;
+  }
+  if (/\btests?\s+cover(?:ing)?\b/i.test(text)) return true;
+  if (mentionsTestFileReference(text)) return true;
+  return false;
+}
+function hasConstraints(text) {
+  if (/\b(constraint|out\s+of\s+scope|scope\s*:|boundary|limitation)\b/i.test(text)) return true;
+  if (/\b(must\s+not|should\s+not|won't|will\s+not)\b/i.test(text)) return true;
+  return false;
+}
+function hasSignalForEnhancement(text, kind) {
+  switch (kind) {
+    case "scope":
+      return hasScopeSignal(text);
+    case "acceptance":
+      return hasAcceptanceCriteria(text);
+    case "reproducibility":
+      return hasReproducibility(text);
+    case "research":
+      return hasResearchFraming(text);
+    case "adr":
+      return hasAdrStructure(text);
+    case "audience":
+      return hasAudienceDefinition(text);
+    case "testing":
+      return hasTestPlan(text);
+    case "constraints":
+      return hasConstraints(text);
+    default:
+      return false;
+  }
+}
+function buildEnhancement(kind) {
+  const template = ENHANCEMENT_TEMPLATES[kind];
+  return {
+    kind,
+    title: template.title,
+    why: template.why,
+    copyPaste: template.copyPaste
+  };
+}
+function suggestNextCommands(input) {
+  const commands = [];
+  if (input.itemKind === "backlog") {
+    commands.push(`build plan backlog review ${input.id}`);
+    commands.push(`build plan sprint add-task <sprint-id> ${input.id}`);
+    return commands;
+  }
+  commands.push(`build plan task start ${input.id}`);
+  if (typeof input.sprintId === "string" && input.sprintId.length > 0) {
+    commands.push(`build plan task list ${input.sprintId}`);
+  }
+  return commands;
+}
+function buildQuickReply(enhancements) {
+  if (enhancements.length === 0) return "";
+  const blocks = enhancements.map((e) => e.copyPaste.trim()).filter((b) => b.length > 0);
+  if (blocks.length === 0) return "";
+  return `Spec enhancement set (optional):
+
+${blocks.join("\n\n")}`.trim();
+}
+function generateEnhancements(input) {
+  const title = input.title.trim();
+  const description = (input.description ?? "").trim();
+  const prompt = description.length > 0 ? `${title}
+
+${description}` : title;
+  const classification = classifyIntent(prompt);
+  const activity = inferActivity(prompt, classification.category);
+  const priorities = applyMultiConcernBias(
+    title,
+    getEnhancementPriorities(classification.category, activity)
+  );
+  const enhancements = [];
+  for (const kind of priorities) {
+    if (enhancements.length >= 3) break;
+    if (!hasSignalForEnhancement(prompt, kind)) {
+      enhancements.push(buildEnhancement(kind));
+    }
+  }
+  const id = input.id ?? "<item-id>";
+  const itemKind = input.itemKind ?? "backlog";
+  const nextCommands = suggestNextCommands({
+    itemKind,
+    id,
+    sprintId: input.sprintId
+  });
+  const quickReply = buildQuickReply(enhancements);
+  const intent = {
+    category: classification.category,
+    activity,
+    confidence: classification.confidence
+  };
+  return { intent, enhancements, quickReply, nextCommands };
+}
+function toPersistedFormat(enhancements) {
+  return enhancements.map((enhancement) => ({
+    kind: enhancement.kind,
+    snippet: enhancement.copyPaste
+  }));
+}
+function toEnhancementSet(guidance) {
+  return {
+    version: 1,
+    intent: guidance.intent,
+    enhancements: toPersistedFormat(guidance.enhancements)
+  };
+}
+function fromPersistedFormat(persisted) {
+  return persisted.filter((p) => p.kind in ENHANCEMENT_TEMPLATES).map((p) => ({
+    ...buildEnhancement(p.kind),
+    copyPaste: p.snippet
+    // Use persisted snippet (may have been customized)
+  }));
+}
+function hintsFromEnhancements(enhancements) {
+  return enhancements.map((enhancement) => ENHANCEMENT_TEMPLATES[enhancement.kind]?.hint).filter((hint) => Boolean(hint));
+}
+
+export {
+  getArchiveShard,
+  getArchivedFilePath,
+  resolveBucketArchiveRoot,
+  isInArchive,
+  getShardFromFileMtime,
+  parseTaskBody,
+  buildPromptFromTask,
+  isTaskHeaderMetadataLine,
+  stripTaskHeaderMetadata,
+  generateEnhancements,
+  toPersistedFormat,
+  toEnhancementSet,
+  fromPersistedFormat,
+  hintsFromEnhancements
+};
+//# sourceMappingURL=chunk-US3RT6CY.js.map

package/dist/chunk-UTDEOPKV.js

@@ -0,0 +1,30 @@
+// src/core/git/worktree-porcelain.ts
+function parseGitWorktreePorcelain(stdout) {
+  const records = [];
+  let current;
+  for (const rawLine of stdout.split("\n")) {
+    if (rawLine.startsWith("worktree ")) {
+      current = { path: rawLine.slice("worktree ".length), fields: [] };
+      records.push(current);
+      continue;
+    }
+    if (!current) continue;
+    const separator = rawLine.indexOf(" ");
+    current.fields.push(
+      separator < 0 ? { name: rawLine, rawLine } : { name: rawLine.slice(0, separator), value: rawLine.slice(separator + 1), rawLine }
+    );
+  }
+  return records;
+}
+function parseGitWorktreeBranches(stdout) {
+  return parseGitWorktreePorcelain(stdout).map((record) => {
+    const branch = record.fields.find((field) => field.name === "branch")?.value?.trim().replace(/^refs\/heads\//, "");
+    return { path: record.path.trim(), ...branch ? { branch } : {} };
+  }).filter((entry) => entry.path.length > 0);
+}
+
+export {
+  parseGitWorktreePorcelain,
+  parseGitWorktreeBranches
+};
+//# sourceMappingURL=chunk-UTDEOPKV.js.map

package/dist/chunk-UUUDKV7N.js

@@ -0,0 +1,13 @@
+import {
+  TelemetryLogger
+} from "./chunk-PFCXFO7A.js";
+
+// src/telemetry/get-telemetry-logger.ts
+function getTelemetryLogger(options = {}) {
+  return TelemetryLogger.getInstance(options);
+}
+
+export {
+  getTelemetryLogger
+};
+//# sourceMappingURL=chunk-UUUDKV7N.js.map

package/dist/chunk-UVKWU3SM.js

@@ -0,0 +1,39 @@
+import {
+  detectRemoteConfiguration
+} from "./chunk-EPRMH6HO.js";
+
+// src/cli/commands/backlog-show-execute-guidance.ts
+import chalk from "chalk";
+var TRACKED_EXECUTE_NOTE = "Tracked: records provenance; --no-open-pr applies locally, otherwise finalize needs a merged GitHub PR.";
+async function printBacklogShowExecuteGuidance(projectRoot, safeId, relativeItemPath) {
+  const remote = await detectRemoteConfiguration(projectRoot).catch(() => "unknown");
+  console.log(chalk.cyan("\n--- Beta path (direct run, no remote) ---\n"));
+  console.log(chalk.white(`  build run --backlog-item ${safeId}`));
+  if (remote === "none") {
+    console.log(chalk.cyan("\n--- To Execute (canonical; advanced; local, no git remote) ---\n"));
+    console.log(chalk.white(`  build plan backlog execute ${safeId} --no-open-pr`));
+    console.log(
+      chalk.gray(
+        "    Tracked: records provenance, applies the result onto the starting branch and archives the item; no PR or finalize step. Run it from a non-protected branch. Use --review-only (or --dry-run) to validate readiness without executing."
+      )
+    );
+  } else {
+    console.log(chalk.cyan("\n--- To Execute (canonical; advanced; requires a git remote) ---\n"));
+    console.log(chalk.white(`  build plan backlog execute ${safeId}`));
+    console.log(
+      chalk.gray(
+        `    ${TRACKED_EXECUTE_NOTE} Use --review-only (or --dry-run) to validate readiness without executing.`
+      )
+    );
+    console.log(chalk.white(`  build plan backlog finalize ${safeId} --pr <n> --commit <sha>`));
+  }
+  console.log(chalk.gray("\n--- Alternatives (no execution provenance) ---\n"));
+  console.log(chalk.gray(`  build run competition --backlog-item ${safeId} --variant <provider>`));
+  console.log(chalk.gray(`  build run --task-file ${relativeItemPath}`));
+}
+
+export {
+  TRACKED_EXECUTE_NOTE,
+  printBacklogShowExecuteGuidance
+};
+//# sourceMappingURL=chunk-UVKWU3SM.js.map