@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-KUEWV2JH.js

@@ -0,0 +1,593 @@
+import {
+  findFencedCodeSpans,
+  isInsideFencedCodeSpan
+} from "./chunk-R2TIYG7U.js";
+import {
+  checkVerifyCommandSafety,
+  detectProjectCapabilities,
+  withProjectVenvPythonTool
+} from "./chunk-AHU3FKPA.js";
+import {
+  isGeneratedLockfilePath
+} from "./chunk-D4VJFCGZ.js";
+import {
+  isProjectConfigPath,
+  isProjectDocsPath,
+  isProjectSourcePath
+} from "./chunk-RPIMAMV7.js";
+
+// src/core/project/agent-verification-commands.ts
+function quoteIfNeeded(token) {
+  return /^[A-Za-z0-9_@%+=:,./-]+$/.test(token) ? token : `'${token.replace(/'/g, "'\\''")}'`;
+}
+function renderSegment(root, segment) {
+  const argv = segment.trim().split(/\s+/);
+  if (argv.length === 0 || argv[0] === "") return void 0;
+  const rendered = withProjectVenvPythonTool(root, argv).map(quoteIfNeeded).join(" ");
+  return /[`\r\n]/.test(rendered) ? void 0 : rendered;
+}
+function renderAgentCommand(root, command) {
+  if (/["'\\$`;|<>!]/.test(command) || !checkVerifyCommandSafety(command).safe) return command;
+  try {
+    const segments = [];
+    for (const segment of command.split("&&")) {
+      const rendered = renderSegment(root, segment);
+      if (rendered === void 0) return command;
+      segments.push(rendered);
+    }
+    return segments.join(" && ");
+  } catch {
+    return command;
+  }
+}
+function renderAgentVerificationCommands(root, commands) {
+  return commands.map((command) => renderAgentCommand(root, command));
+}
+
+// src/core/project/spec-harness-convergence.ts
+function pushFirstAvailable(out, commands) {
+  const command = commands.find((entry) => entry.trim().length > 0);
+  if (command && !out.includes(command)) {
+    out.push(command);
+  }
+}
+function resolveSpecHarnessConvergenceCommands(root) {
+  const capabilities = detectProjectCapabilities(root);
+  const commands = [];
+  pushFirstAvailable(commands, capabilities.verification.test);
+  pushFirstAvailable(commands, capabilities.verification.typecheck);
+  return commands;
+}
+function resolveSpecHarnessTestCommands(root) {
+  const unique = /* @__PURE__ */ new Set();
+  for (const command of detectProjectCapabilities(root).verification.test) {
+    if (command.trim().length > 0) unique.add(command);
+  }
+  return [...unique];
+}
+
+// src/core/providers/shared/completion-directive.ts
+var COMPLETION_DIRECTIVE_VARIANT_A = `## REQUIRED: Completion Signal
+
+Before finishing, emit exactly ONE completion signal (as a JSON line, not in code fences):
+
+{"type":"build_completion","filesEdited":["path/to/file.ts"],"editIntent":"edited","reason":"<what you did>"}
+
+**editIntent values:**
+- "edited": You made changes to files
+- "no-op": No changes needed (MUST explain why in reason)
+- "partial": Some changes made but incomplete (explain what's missing)
+
+**Examples:**
+{"type":"build_completion","filesEdited":["src/auth.ts"],"editIntent":"edited","reason":"Added null check for user object"}
+{"type":"build_completion","filesEdited":[],"editIntent":"no-op","reason":"File already contains all specified functions"}
+{"type":"build_completion","filesEdited":["src/api.ts"],"editIntent":"partial","reason":"Added 2/3 endpoints; third needs schema change"}
+
+If you cannot complete the task, still emit with "partial" and explain why.`;
+var COMPLETION_DIRECTIVE_VARIANT_B = `## MANDATORY: Task Completion Signal
+
+When done, output exactly ONE completion record (raw JSON line \u2014 no markdown fences):
+
+{"type":"build_completion","filesEdited":["path/to/file.ts"],"editIntent":"edited","reason":"<summary of what you did>"}
+
+**editIntent options:**
+- "edited": files were modified
+- "no-op": nothing to change (reason field must explain why)
+- "partial": work is incomplete (reason field must describe what remains)
+
+**Examples:**
+{"type":"build_completion","filesEdited":["src/auth.ts"],"editIntent":"edited","reason":"Added null check for user object"}
+{"type":"build_completion","filesEdited":[],"editIntent":"no-op","reason":"File already contains all specified functions"}
+{"type":"build_completion","filesEdited":["src/api.ts"],"editIntent":"partial","reason":"Added 2/3 endpoints; third needs schema change"}
+
+Always emit this record \u2014 even if the task could not be completed. Use "partial" and describe why.`;
+function generateCompletionDirectiveWithVariant(forceVariant) {
+  const variant = forceVariant ?? (Math.random() < 0.5 ? "A" : "B");
+  const text = variant === "A" ? COMPLETION_DIRECTIVE_VARIANT_A : COMPLETION_DIRECTIVE_VARIANT_B;
+  return { text, completion_signal_variant: variant };
+}
+function findCompletionDirectiveVariant(prompt) {
+  if (prompt.includes(COMPLETION_DIRECTIVE_VARIANT_A)) return "A";
+  if (prompt.includes(COMPLETION_DIRECTIVE_VARIANT_B)) return "B";
+  return void 0;
+}
+function ensureCompletionDirective(prompt) {
+  const existing = findCompletionDirectiveVariant(prompt);
+  if (existing) return { text: prompt, completionSignalVariant: existing };
+  const directive = generateCompletionDirectiveWithVariant();
+  return {
+    text: `${prompt}
+
+${directive.text}`,
+    completionSignalVariant: directive.completion_signal_variant
+  };
+}
+
+// src/core/providers/shared/harness-verification-permission.ts
+var MAX_FOCUSED_REPAIR_ATTEMPTS = 2;
+function renderEditVerificationPermission(testCommands) {
+  const taskCommands = "If the task lists commands under How to Verify, you may run those exact commands, and only those, before completing, and fix what they reveal.";
+  const other = "Do not run any other test, lint, or build command.";
+  if (testCommands.length === 0) {
+    return `${taskCommands} ${other}`;
+  }
+  const listed = testCommands.map((command) => `\`${command}\``).join(", ");
+  return `${taskCommands} If it lists none, you may run the project's test command (${listed}), limited to the tests that cover your changes where the runner supports it and only for the ecosystems you changed; fix failures, with at most ${MAX_FOCUSED_REPAIR_ATTEMPTS} repair attempts. Do not run a full suite for extra assurance. ${other}`;
+}
+function hostLaunchedTestCommands(root) {
+  return renderAgentVerificationCommands(root, resolveSpecHarnessTestCommands(root));
+}
+
+// src/core/providers/shared/prompt-adapter-core.ts
+var BUILD_CONTEXT_MARKER_NAMES = [
+  "BUILD_ANALYSIS_CONTEXT",
+  "BUILD_STAGE_CONTEXT",
+  "BUILD_CONTEXT_INJECTION"
+];
+var BUILD_CONTEXT_MARKER_PATTERN = BUILD_CONTEXT_MARKER_NAMES.join("|");
+var BUILD_CONTEXT_BLOCK_RE = new RegExp(
+  `<!--\\s*(?:${BUILD_CONTEXT_MARKER_PATTERN})\\s*-->\\r?\\n?[\\s\\S]*?\\r?\\n?<!--\\s*\\/(?:${BUILD_CONTEXT_MARKER_PATTERN})\\s*-->`,
+  "g"
+);
+var BUILD_CONTEXT_MARKER_RE = new RegExp(
+  `<!--\\s*(\\/)?\\s*(${BUILD_CONTEXT_MARKER_PATTERN})\\s*-->`,
+  "g"
+);
+function neutralizeBuildContextMarkers(text) {
+  return text.replace(
+    BUILD_CONTEXT_MARKER_RE,
+    (_match, closing, marker) => `[${closing ? "/" : ""}${marker}]`
+  );
+}
+function neutralizeUnpairedBuildContextMarkers(text) {
+  const sections = [];
+  let cursor = 0;
+  for (const match of text.matchAll(BUILD_CONTEXT_BLOCK_RE)) {
+    const index = match.index ?? 0;
+    sections.push(neutralizeBuildContextMarkers(text.slice(cursor, index)));
+    sections.push(match[0]);
+    cursor = index + match[0].length;
+  }
+  sections.push(neutralizeBuildContextMarkers(text.slice(cursor)));
+  return sections.join("");
+}
+function stripBuildContextBlocks(text) {
+  return text.replace(BUILD_CONTEXT_BLOCK_RE, "");
+}
+function normalizePath(pathStr) {
+  return pathStr.replace(/\\/g, "/").replace(/^\.\//, "").trim();
+}
+function stripTrailingPunctuation(value) {
+  return value.replace(/[.,;:]+$/g, "").trim();
+}
+function stripTrailingKnownAnnotation(value) {
+  return value.replace(
+    /\s*\((?:create|new|modify|out\s+of\s+scope|out-of-scope|read[\s-]?only|optional|reference|related|info\s+only)\)\s*$/i,
+    ""
+  ).trim();
+}
+var NEUTRAL_ROOT_MANIFEST_BASENAMES = /* @__PURE__ */ new Set([
+  "go.mod",
+  "go.work",
+  "go.work.sum",
+  "cargo.toml",
+  "pom.xml",
+  "setup.py",
+  "pipfile"
+]);
+function isLikelyFilePathToken(value) {
+  const file = value.trim();
+  if (!file) return false;
+  if (file.match(/^[A-Z]:?$/)) return false;
+  if (file.includes("/")) return true;
+  if (file.startsWith(".")) return true;
+  if (file === "Makefile" || file === "Dockerfile" || file === "LICENSE") return true;
+  if (isProjectConfigPath(file) || isProjectDocsPath(file)) {
+    return true;
+  }
+  if (NEUTRAL_ROOT_MANIFEST_BASENAMES.has(file.toLowerCase())) return true;
+  if (isGeneratedLockfilePath(file)) return true;
+  return false;
+}
+function normalizeFileTargetToken(raw) {
+  const stripPathWrappers = (value) => value.replace(/^[`'"]+|[`'"]+$/g, "").trim();
+  const stripTrailingLineReference = (value) => value.replace(/(?:#L?\d+(?::\d+)?(?:-L?\d+(?::\d+)?)?|:\d+(?::\d+)?)$/i, "").trim();
+  let trimmed = raw.trim().replace(/^[`'"]+|[`'"]+$/g, "").trim();
+  trimmed = stripTrailingPunctuation(trimmed);
+  trimmed = stripTrailingKnownAnnotation(trimmed);
+  trimmed = stripTrailingPunctuation(trimmed);
+  const extMatch = /^(.+?\.(?:ts|tsx|js|jsx|json|md|yaml|yml|toml|go|rs|py|c|cc|cpp|h|hpp))(?:(?::\d+)+|[`'"()[\]*_]|\s|$)/i.exec(
+    trimmed
+  );
+  let candidate = (extMatch?.[1] ?? trimmed).replace(/[;,]$/, "").trim();
+  candidate = candidate.replace(/(\.[A-Za-z0-9]+)\*+$/u, "$1");
+  if (!extMatch && candidate.includes("/") && /\s/.test(candidate)) {
+    candidate = candidate.split(/\s+/)[0]?.trim() ?? candidate;
+  }
+  candidate = stripPathWrappers(candidate);
+  candidate = stripTrailingLineReference(candidate);
+  candidate = stripTrailingPunctuation(candidate);
+  return normalizePath(candidate);
+}
+var SCOPED_EDIT_ONLY_CLAUSE_RE = /\b(?:edit|update|modify|change)\s+only\s+([\s\S]+?)(?=\.\s*(?:Do\s+not|Don't)\b|\.\s*$|$)/i;
+var FILE_PATH_IN_SEGMENT_RE = /(?:`([^`\n]+)`|([A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)+\.[A-Za-z0-9]{1,12}))/g;
+function stripNegatedFileClauses(prompt) {
+  let result = prompt;
+  const patterns = [
+    /\bdo\s+not\s+(?:inspect\s+or\s+)?(?:modify|edit)\s+[^.\n]+/gi,
+    /\bdon't\s+(?:modify|edit)\s+[^.\n]+/gi,
+    /\bdo\s+not\s+modify\s+files\s+outside\s+[^.\n]+/gi
+  ];
+  for (const pattern of patterns) {
+    result = result.replace(pattern, " ");
+  }
+  return result;
+}
+function extractPathsFromTextSegment(segment) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const match of segment.matchAll(FILE_PATH_IN_SEGMENT_RE)) {
+    const raw = match[1] ?? match[2] ?? "";
+    const normalized = normalizeFileTargetToken(raw);
+    if (normalized.length > 0 && isLikelyFilePathToken(normalized)) {
+      paths.add(normalized);
+    }
+  }
+  return Array.from(paths);
+}
+function extractScopedEditOnlyPaths(prompt) {
+  const match = SCOPED_EDIT_ONLY_CLAUSE_RE.exec(prompt);
+  if (!match?.[1]) {
+    return [];
+  }
+  return extractPathsFromTextSegment(match[1]);
+}
+function renderFileTargets(targets, options = {}) {
+  const uniqueTargets = Array.from(new Set(targets.filter((target) => target.trim().length > 0)));
+  if (uniqueTargets.length === 0) return "";
+  if (options.style === "single") {
+    return uniqueTargets.map((target) => `FILE: ${target}`).join("\n");
+  }
+  if (uniqueTargets.length === 1) {
+    return `FILE: ${uniqueTargets[0]}`;
+  }
+  if (options.style === "list" || uniqueTargets.length > 2) {
+    return `FILES:
+${uniqueTargets.map((target) => `- ${target}`).join("\n")}`;
+  }
+  return uniqueTargets.map((target) => `FILE: ${target}`).join("\n");
+}
+var SCOPED_SECTION_RE = /(?:^|\n)\s*#{1,6}\s*(?:scope(?:\s*\/\s*surfaces?\s+affected)?(?:\s*\(optional\))?|files?\s+to\s+modify)\s*\n((?:\s*[-*]\s*[^\n]+\n?)+)/i;
+function extractScopedSourceFiles(text) {
+  const block = SCOPED_SECTION_RE.exec(stripBuildContextBlocks(text))?.[1];
+  const files = [];
+  for (const bullet of block?.match(/^\s*[-*]\s*[^\n]+/gm) ?? []) {
+    const line = bullet.replace(/^\s*[-*]\s*/, "");
+    const tokens = [...line.matchAll(/`([^`\n]+)`/g)].map((m) => m[1] ?? "");
+    const leading = /^([\w./-]+)(?=\s*(?:$|[:(,;]|\s[-\u2013\u2014]\s))/.exec(line)?.[1];
+    if (leading) tokens.push(leading);
+    for (const token of tokens) {
+      const file = normalizeFileTargetToken(token);
+      if (file && !/\s/.test(file) && isProjectSourcePath(file)) files.push(file);
+    }
+  }
+  return files;
+}
+function hasExplicitFileTargets(text, options = {}) {
+  return extractExplicitFileTargets(text, options).length > 0;
+}
+function extractExplicitFileTargets(prompt, options = {}) {
+  const { includeProseMarkers = false, includeScopedSections = false } = options;
+  const targets = /* @__PURE__ */ new Set();
+  const addCandidate = (raw, declared = false) => {
+    const candidate = normalizeFileTargetToken(declared ? raw.replace(/^@/, "") : raw);
+    if (candidate && (declared || isLikelyFilePathToken(candidate))) {
+      targets.add(candidate);
+    }
+  };
+  let cleanPrompt = stripBuildContextBlocks(prompt);
+  const toolPolicySplit = cleanPrompt.split(/\n---\n\n/);
+  if (toolPolicySplit.length > 1 && /##\s*Tool Usage Policy/i.test(toolPolicySplit[0] ?? "")) {
+    cleanPrompt = toolPolicySplit.slice(1).join("\n---\n\n");
+  }
+  cleanPrompt = cleanPrompt.replace(/##\s+Recent Git History[\s\S]*?(?=\n##\s+|\n$)/gi, "");
+  cleanPrompt = cleanPrompt.replace(/##\s+Relevant Files[\s\S]*?(?=\n##\s+|\n$)/gi, "");
+  cleanPrompt = cleanPrompt.replace(/##\s+Architecture Context[\s\S]*?(?=\n##\s+|\n$)/gi, "");
+  const fencedSpans = findFencedCodeSpans(cleanPrompt);
+  const isDeclaredDirective = (index) => {
+    const lineStart = cleanPrompt.lastIndexOf("\n", index - 1) + 1;
+    return !isInsideFencedCodeSpan(fencedSpans, index) && cleanPrompt.slice(lineStart, index).trim() === "" && /^[ \t]*FILES?:/.test(cleanPrompt.slice(lineStart));
+  };
+  const singleFileRegex = /\bfile:\s*([^\n,;]+?)(?=(?:\s+\band\b|\s*\bfile:|$)|\n|[,;]|$)/gi;
+  const multiLineRegex = /\bfiles:\s*\n((?:\s*[-*]\s*[^\n]+\n?)+)/i;
+  const fileTargetsBlockRegex = /file targets:\s*\n((?:\s*[-•]\s*[^\n]+\n?)+)/i;
+  for (const match of cleanPrompt.matchAll(singleFileRegex)) {
+    if (match[1]) {
+      addCandidate(
+        match[1].trim().replace(/^FILE:?\s*/i, "").trim(),
+        isDeclaredDirective(match.index)
+      );
+    }
+  }
+  const inlineLists = /^[ \t]*files:[ \t]*([^\n]+)$/gim;
+  for (const match of cleanPrompt.matchAll(inlineLists)) {
+    if (!isDeclaredDirective(match.index)) continue;
+    for (const token of match[1]?.match(/`[^`]+`|"[^"]+"|'[^']+'|[^\s,;]+/g) ?? []) {
+      if (!/^(?:and|or|&)$/i.test(token)) addCandidate(token, true);
+    }
+  }
+  const indentedLists = /^([ \t]*)FILES:[ \t]*\r?$/gm;
+  for (const match of cleanPrompt.matchAll(indentedLists)) {
+    if (!isDeclaredDirective(match.index)) continue;
+    const headerIndent = match[1]?.length ?? 0;
+    const followingLines = cleanPrompt.slice(match.index + match[0].length).split("\n").slice(1);
+    for (const line of followingLines) {
+      if ((line.match(/^[ \t]*/)?.[0].length ?? 0) <= headerIndent) break;
+      if (line.trim()) addCandidate(line.trim().replace(/^[-*]\s*/, ""), true);
+    }
+  }
+  const processListBlock = (block, linePattern, trimPattern, declared = false) => {
+    if (!block) return;
+    const lines = block.match(linePattern);
+    if (!lines) return;
+    for (const line of lines) {
+      addCandidate(
+        line.replace(trimPattern, "").replace(/^FILE:?\s*/i, "").trim(),
+        declared
+      );
+    }
+  };
+  const multiLineMatch = multiLineRegex.exec(cleanPrompt);
+  processListBlock(
+    multiLineMatch?.[1],
+    /^\s*[-*]\s*[^\n]+/gm,
+    /^\s*[-*]\s*/,
+    multiLineMatch != null && isDeclaredDirective(multiLineMatch.index)
+  );
+  processListBlock(
+    fileTargetsBlockRegex.exec(cleanPrompt)?.[1],
+    /^\s*[-•]\s*[^\n]+/gm,
+    /^\s*[-•]\s*/
+  );
+  if (includeProseMarkers) {
+    const proseRegex = /files?\s+to\s+(?:modify|change|update|touch)[:\s]*\n((?:\s*[-*]\s*[^\n]+\n?)+)/gim;
+    for (const match of cleanPrompt.matchAll(proseRegex)) {
+      processListBlock(match[1], /^\s*[-*]\s*[^\n]+/gm, /^\s*[-*]\s*/);
+    }
+  }
+  if (includeScopedSections) {
+    processListBlock(
+      SCOPED_SECTION_RE.exec(cleanPrompt)?.[1],
+      /^\s*[-*]\s*[^\n]+/gm,
+      /^\s*[-*]\s*/
+    );
+  }
+  return Array.from(targets);
+}
+function generateWorkspaceAgentHeader(provider, executionIntent) {
+  switch (executionIntent) {
+    case "code":
+      return `# ${provider} Workspace Agent: Code Generation Mode
+You are editing an isolated workspace
+Output must be executable code`;
+    case "analysis":
+      return `# ${provider} Workspace Agent: Analysis Mode
+You are analyzing an isolated git worktree
+Provide detailed analysis`;
+    case "mixed":
+      return `# ${provider} Workspace Agent: Mixed Mode
+analysis + implementation
+Both investigation and executable code`;
+    default:
+      return "# Workspace Agent: Default Mode";
+  }
+}
+function generateAnalysisModeInstructions(executionIntent) {
+  switch (executionIntent) {
+    case "code":
+      return "";
+    case "analysis":
+      return "PRIMARY FOCUS: Analysis, insights, and recommendations\nCODE CHANGES: Optional";
+    case "mixed":
+      return "BALANCED APPROACH: Both planning and implementation are expected";
+    default:
+      return "";
+  }
+}
+function extractFileTargets(prompt) {
+  return extractExplicitFileTargets(prompt);
+}
+function generateMinimalAdaptation(options) {
+  const intent = options.executionIntent || "code";
+  const files = options.targetFiles?.length ? options.targetFiles.join(", ") : "";
+  const intentGuide = {
+    code: "Simplified code generation guidance: Focus on direct implementation.",
+    analysis: "Simplified analysis guidance: Provide concise, targeted insights.",
+    mixed: "Simplified mixed-mode guidance: Balance analysis and implementation."
+  };
+  const fileContext = files ? `Target: ${files}` : "";
+  return ["Simplified Guidance:", intentGuide[intent], fileContext].filter(Boolean).join("\n");
+}
+function injectBacklogReviewContract(prompt, targetFiles) {
+  const normalizedPrompt = prompt.toLowerCase();
+  const touchesBacklog = targetFiles.some((file) => file.toLowerCase().includes("backlog/"));
+  const looksLikeReview = normalizedPrompt.includes("you are reviewing") || normalizedPrompt.includes("review this backlog") || normalizedPrompt.includes("review") && normalizedPrompt.includes("backlog");
+  const isBacklogReview = touchesBacklog && looksLikeReview;
+  if (!isBacklogReview) {
+    return prompt;
+  }
+  const contractLines = [
+    "## BACKLOG REVIEW CONTRACT",
+    "**Do not delete or rewrite existing sections.** Only append a 'Review' section at the top of the file.",
+    "",
+    "Keep all existing content intact (implementation plan, references, timestamps, etc.).",
+    "",
+    "**Output expectations:**",
+    "- Target length: ~25\u201360 lines total (for the Review section)",
+    "- Cover all required sections; 3\u20135 bullets per section",
+    "- End with a short 'Recommended next action' (1\u20132 bullets)",
+    ""
+  ];
+  const fileSpecPattern = /^FILE:/im;
+  if (fileSpecPattern.test(prompt)) {
+    const lines = prompt.split("\n");
+    let insertIndex = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line && /^FILE:/i.test(line)) {
+        insertIndex = i + 1;
+        while (insertIndex < lines.length) {
+          const nextLine = lines[insertIndex];
+          if (nextLine && /^FILE:/i.test(nextLine)) {
+            insertIndex++;
+          } else {
+            break;
+          }
+        }
+        break;
+      }
+    }
+    lines.splice(insertIndex, 0, ...contractLines);
+    return lines.join("\n");
+  }
+  return `${contractLines.join("\n")}
+${prompt}`;
+}
+function generateSpecHarness(root, executionIntent) {
+  return `## Spec Harness v1: Deterministic Output Expectations
+
+**Purpose:** Ensure consistent, testable outputs across all providers
+
+### Required Semantics
+- All file paths MUST be repo-relative (not absolute)
+- All edits MUST target files within the repository
+- Do NOT edit generated, dependency, or build output directories (e.g. vendor/, node_modules/, .git/, dist/, target/, __pycache__/, build/)
+- Do NOT edit \`.build-project/\` except for required control files (e.g. \`.build-project/edits.jsonl\`) or when explicitly requested
+- Configuration files require explicit justification in completion signal
+
+### Must-Fail Inputs (Your output should handle these gracefully)
+- Empty/null file paths
+- Paths outside repository boundaries
+- Circular dependencies in imports
+- Syntax errors in generated code
+
+### Output Stability Rules
+1. **Deterministic ordering**: Always process files in lexicographic order
+2. **Consistent formatting**: Use project's existing style (respect .editorconfig, biome.json, etc.)
+3. **Stable identifiers**: Generated names should be predictable (avoid random suffixes unless required)
+4. **Idempotency**: Running the same task twice should produce equivalent results
+
+${renderSmokeCommandsSection(root, executionIntent)}`;
+}
+function renderSmokeCommandsSection(root, executionIntent) {
+  const header = "### Verification Build Will Run";
+  const analysis = executionIntent === "analysis";
+  const permission = analysis ? "Do NOT run tests, linters, or build commands yourself." : renderEditVerificationPermission([]);
+  const trailer = analysis ? "**Note:** These are validation expectations, not commands for you to execute. Build runs them after you finish. If you cannot review your changes against them, say that explicitly in your completion signal rather than claiming the output is clean, and still emit the completion signal." : "**Note:** Apart from the commands you are permitted to run above, these are validation expectations, not commands for you to execute. Build runs them after you finish. If you cannot review your changes against them, say that explicitly in your completion signal rather than claiming the output is clean, and still emit the completion signal.";
+  if (root) {
+    const commands = resolveSpecHarnessConvergenceCommands(root);
+    if (commands.length > 0) {
+      const resolvedPermission = analysis ? permission : renderEditVerificationPermission(hostLaunchedTestCommands(root));
+      const bullets = renderAgentVerificationCommands(root, commands).map((command) => `- \`${command}\``).join("\n");
+      return `${header}
+Build runs the project's verification after you finish. For reference, the checks Build will apply are:
+${bullets}
+${resolvedPermission} Review the rest of your changes by inspection against these expectations, especially touched code or tests. Build also applies the project's documented lint and build checks when you touch relevant code; review against those too.
+
+${trailer}`;
+    }
+    return `${header}
+${permission} Build runs the project's own test, lint, and build commands as documented for this project separately after you finish. Before completing, review your changes by inspection against those documented verification expectations. If this project's language is not recognized or has no verification commands, report verification as unavailable in your completion signal rather than claiming the output is clean.
+
+${trailer}`;
+  }
+  return `${header}
+${permission} Build runs the project's own test, lint, and build commands as documented for this project separately after you finish. Before completing, review your changes by inspection against those documented verification expectations. If this project's language is not recognized or has no verification commands, report verification as unavailable in your completion signal rather than claiming the output is clean.
+
+${trailer}`;
+}
+function appendWorkspaceEditInstructions(prompt, options) {
+  const {
+    targetFiles: _targetFiles = [],
+    // FILE: enforcement disabled per A/B test results (2026-02-02)
+    includeExamples = true,
+    executionIntent,
+    projectRoot
+  } = options;
+  const fileContext = "";
+  const editInstructions = [
+    "Workspace Edit Protocol:",
+    "1. For every file change, write ONE JSON line to `.build-project/edits.jsonl` in this worktree.",
+    '   Format: {"type":"build_edit","op":"writeFile","path":"relative/path.ts","contents":"FULL FILE CONTENT"}',
+    "2. Supported ops:",
+    "   - writeFile: complete file replacement",
+    "   - appendFile: add content to end of file",
+    "   - renameFile, deleteFile as needed",
+    "3. Paths must be repo-relative and must not target generated, dependency, or build output directories (e.g. vendor/, node_modules/, .git/, dist/, target/, __pycache__/, build/).",
+    "   Note: `.build-project/edits.jsonl` is required for edit events; avoid other `.build-project/` writes unless explicitly requested."
+  ];
+  const exampleSection = includeExamples ? [
+    "\nEdit Event Examples:",
+    '{"type":"build_edit","op":"writeFile","path":"src/utils/logger.ts","contents":"...full file content..."}',
+    '{"type":"build_edit","op":"appendFile","path":"src/config.ts","contents":"// New configuration added"}'
+  ] : [];
+  const carriedVariant = findCompletionDirectiveVariant(prompt);
+  const completionDirective = carriedVariant ? { text: void 0, completion_signal_variant: carriedVariant } : generateCompletionDirectiveWithVariant();
+  return {
+    text: [
+      prompt,
+      "\n",
+      generateSpecHarness(projectRoot, executionIntent),
+      "\n",
+      fileContext,
+      editInstructions.join("\n"),
+      ...exampleSection,
+      ...completionDirective.text ? ["\n", completionDirective.text] : []
+    ].join("\n"),
+    completionSignalVariant: completionDirective.completion_signal_variant
+  };
+}
+
+export {
+  renderAgentVerificationCommands,
+  generateCompletionDirectiveWithVariant,
+  findCompletionDirectiveVariant,
+  ensureCompletionDirective,
+  neutralizeBuildContextMarkers,
+  neutralizeUnpairedBuildContextMarkers,
+  stripBuildContextBlocks,
+  normalizePath,
+  normalizeFileTargetToken,
+  stripNegatedFileClauses,
+  extractScopedEditOnlyPaths,
+  renderFileTargets,
+  extractScopedSourceFiles,
+  hasExplicitFileTargets,
+  extractExplicitFileTargets,
+  generateWorkspaceAgentHeader,
+  generateAnalysisModeInstructions,
+  extractFileTargets,
+  generateMinimalAdaptation,
+  injectBacklogReviewContract,
+  appendWorkspaceEditInstructions
+};
+//# sourceMappingURL=chunk-KUEWV2JH.js.map