@slowcook-ai/cli 0.19.0-alpha.41 → 0.19.0

package/dist/commands/chef/drift-fix.js

@@ -8,9 +8,17 @@
  * ChefVerdict, applies edits surgically, validates, commits, posts an
  * audit comment.
  *
- * Frozen surface (HARD): never edits tests/, vitest.config.*,
- * .brewing/{auto-gen}/. If a fix requires test edits → escalates to PM
- * via a two-option pm_comment (option B = `testgen --regenerate`).
+ * Frozen surface (HARD): tests/integration/, tests/schema/,
+ * tests/acceptance/ (spec-contract assertions) + .brewing/auto-gen/,
+ * .brewing/code-map.*, .brewing/recon-result.json, .brewing/history-
+ * index.json (slowcook-managed artifacts). If a fix requires an
+ * ASSERTION change → escalates to PM via pm_comment (option B =
+ * testgen --regenerate).
+ *
+ * NOT frozen (α.54 — chef owns test infrastructure):
+ * tests/helpers/, vitest.config.*, playwright.config.*, package.json
+ * (devDeps), tsconfig.json, setup files. Chef can fix the runner
+ * machinery freehand.
  *
  * Ledger at .brewing/chef/<story-id>.json tracks moves + cost. Cycle
  * detection + budget cap enforce convergence.
@@ -26,15 +34,71 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from
 import { dirname, join } from "node:path";
 import { AnthropicClient, CHEF_SYSTEM, buildChefPrompt, } from "@slowcook-ai/llm-anthropic";
 import { isReadOnlyMode, logReadOnlyBanner } from "../../lib/read-only.js";
+import { knowledgeAddCore } from "../knowledge-add.js";
+/**
+ * α.67 — distil a chef rationale into a one-line curated insight.
+ * The rationale is typically a paragraph explaining what+why+how;
+ * curated/ entries should be a single class-of-problem claim
+ * (≤250 chars). Strategy: take the first sentence, cap, strip
+ * trailing whitespace. The full rationale lives in the ledger for
+ * deep audit.
+ */
+function distilRationaleToClaim(rationale) {
+    const firstSentence = rationale.split(/(?<=[.!?])\s/)[0] ?? rationale;
+    const trimmed = firstSentence.trim().replace(/\s+/g, " ");
+    if (trimmed.length <= 250)
+        return trimmed;
+    return trimmed.slice(0, 247) + "…";
+}
+/**
+ * Paths chef MAY edit even though they "live under tests/" or look
+ * config-shaped. α.54: chef gains ownership of test INFRASTRUCTURE —
+ * runner config, helpers, setup files — because those are
+ * agent-fixable failures that previously had no owner.
+ *
+ * Principle: tests encode the spec CONTRACT (the assertions that
+ * define what "story-N done" means). Their enforcement MACHINERY
+ * (vitest config, helpers, setup) is not the contract. Distinguishing
+ * by file content/location, not by folder.
+ *
+ * Caught dogfooding delgoosh#656 — chef diagnosed a missing JSX
+ * transform but couldn't fix vitest.config.ts. PM, brew, testgen,
+ * and chef were ALL blocked from owning it. α.54 closes that gap by
+ * giving chef the editing rights.
+ */
+const TEST_INFRA_ESCAPE_PATTERNS = [
+    /^tests\/helpers\//, // render, a11y, mock helpers
+    /^tests\/setup\.(ts|tsx|js)$/, // vitest globalSetup / setupFiles
+    /^vitest\.setup\.(ts|tsx|js)$/,
+];
+/**
+ * Paths chef NEVER edits:
+ *   - tests/integration/**, tests/schema/**, tests/acceptance/** —
+ *     spec-contract assertions. If a test is wrong, the right fix is
+ *     testgen --regenerate, not chef rewriting the assertion.
+ *   - .brewing/auto-gen/**, code-map, history-index, recon-result —
+ *     slowcook-managed artifacts other agents derive from.
+ *
+ * vitest.config.*, playwright.config.*, package.json, tsconfig.json
+ * are NOT frozen — they're infra chef can fix.
+ */
 const FROZEN_PATH_PATTERNS = [
-    /^tests\//,
-    /^vitest\.config\.(ts|mjs|js)$/,
+    /^tests\/integration\//,
+    /^tests\/schema\//,
+    /^tests\/acceptance\//,
     /^\.brewing\/code-map\.(json|md|target\.md)$/,
     /^\.brewing\/recon-result\.json$/,
     /^\.brewing\/history-index\.json$/,
     /^\.brewing\/auto-gen\//,
 ];
-function isFrozenPath(path) {
+export function isFrozenPath(path) {
+    // α.54 — explicit escapes win first. A file under tests/helpers/
+    // shouldn't be caught by a generic tests/ rule (and the new
+    // FROZEN_PATH_PATTERNS list above is already specific to assertion
+    // subfolders, but keeping the escape-first check makes the policy
+    // intent visible at the call site for future readers).
+    if (TEST_INFRA_ESCAPE_PATTERNS.some((re) => re.test(path)))
+        return false;
     return FROZEN_PATH_PATTERNS.some((re) => re.test(path));
 }
 /**
@@ -99,12 +163,27 @@ export function collectImportedSourceFiles(testContents) {
     // (we exclude scoped packages by requiring the next char after "@"
     // to be "/", which rules out "@scope/pkg" forms).
     const importRe = /from\s+["'](\.{1,2}\/[^"']+|@\/[^"']+|~\/[^"']+)["']/g;
+    // α.59 — some tests do not `import` their target; the styling/shape
+    // presence pattern (slowcook 0.7.21+) uses `readFileSync` on a string
+    // literal source path. Also pick up these direct references so chef
+    // sees the file contents instead of guessing.
+    // Matches string literals like "src/foo/bar.tsx", 'src/foo', "mock/x.ts".
+    const literalRe = /["'](?:src|mock)\/[\w./-]+\.(?:ts|tsx|js|jsx)["']/g;
     for (const [testFile, content] of Object.entries(testContents)) {
         const sources = new Set();
         let m;
         while ((m = importRe.exec(content)) !== null) {
             sources.add(m[1]);
         }
+        while ((m = literalRe.exec(content)) !== null) {
+            // Strip the surrounding quotes; downstream resolver handles
+            // bare-repo-relative paths via the './' branch by anchoring on
+            // testFile's directory, which won't work for cross-directory
+            // paths like "src/components/...". So we mark these as a
+            // separate prefix that the resolver knows is repo-root-relative.
+            const literal = m[0].slice(1, -1);
+            sources.add("//" + literal); // sentinel for repo-root-relative
+        }
         out[testFile] = [...sources];
     }
     return out;
@@ -133,6 +212,13 @@ export function resolveImportToFile(importPath, testFile, repoRoot, exists) {
         baseDir = dirname(join(repoRoot, testFile));
         rest = importPath;
     }
+    else if (importPath.startsWith("//")) {
+        // α.59 — sentinel for repo-root-relative paths captured by the
+        // literal-path regex (collectImportedSourceFiles). Strip "//" and
+        // anchor at repoRoot.
+        baseDir = repoRoot;
+        rest = importPath.slice(2);
+    }
     else {
         return null;
     }
@@ -239,7 +325,7 @@ Options:
                            audit comment on the PR (not the source issue).
 
 Requires: ANTHROPIC_API_KEY in env. Run from consumer repo root.
-Frozen surface: tests/, vitest.config.*, .brewing/{auto-gen}/ — never edited.
+Frozen surface: tests/{integration,schema,acceptance}/ + .brewing/{auto-gen,code-map,history-index,recon-result} — never edited. Test INFRA (tests/helpers/, vitest.config.*, package.json devDeps, setup files) IS chef's to edit (α.54).
 `);
 }
 function loadHistoryIndex(repoRoot) {
@@ -486,6 +572,66 @@ function pushChefEditsToPrBranch(repoRoot, prBranch, localRef) {
         return false;
     }
 }
+/**
+ * α.58 — brew-halt finisher path. Called when chef-drift was invoked
+ * by chef-on-brew-halt (workflow_run trigger), which checked out the
+ * brew checkpoint branch + ran chef. Chef has committed locally;
+ * persist by pushing the current branch back to origin + opening a PR
+ * (brew_branch → main) so the maintainer sees the fix as a reviewable
+ * change instead of losing it with the ephemeral runner.
+ *
+ * Best-effort: any failure is logged but doesn't throw — the chef
+ * verdict is already audited via ledger + the source-issue comment.
+ */
+function publishChefBrewHaltFix(repoRoot, storyId, rationale) {
+    // Current branch is whatever the workflow checked out — chef-on-brew-halt
+    // switches to brew_branch from the halt artifact. Capturing it via
+    // `rev-parse --abbrev-ref HEAD` is more robust than carrying it through
+    // CLI args (which would require every consumer workflow to pass it).
+    const branch = execSync(`git -C "${repoRoot}" rev-parse --abbrev-ref HEAD`, { encoding: "utf8" }).trim();
+    if (!branch || branch === "HEAD") {
+        console.warn(`  warn: brew-halt publish skipped — detached or empty HEAD`);
+        return;
+    }
+    // Push the chef commit (now at HEAD of brew_branch) back to origin.
+    // Set-upstream so subsequent fetches see the chef SHA too.
+    execSync(`git -C "${repoRoot}" push --set-upstream origin "${branch}"`, { stdio: "inherit" });
+    console.log(`  brew-halt publish: pushed ${branch}`);
+    // Open a PR brew_branch → main if one doesn't already exist. gh is
+    // the only consumer-side dep we already assume (used by L2 finisher
+    // PR enrichment + audit comments). Repo slug derived from origin URL.
+    const repoSlug = execSync(`git -C "${repoRoot}" remote get-url origin | sed -E 's|^.*github\\.com[:/]||; s|\\.git$||'`, { encoding: "utf8" }).trim();
+    let existingPr = "";
+    try {
+        existingPr = execSync(`gh pr list --repo "${repoSlug}" --head "${branch}" --json number --jq '.[0].number // ""'`, { encoding: "utf8" }).trim();
+    }
+    catch { /* gh might be missing or token might be scoped narrow; let create-attempt log instead */ }
+    if (existingPr) {
+        console.log(`  brew-halt publish: PR already exists (#${existingPr}) for ${branch}`);
+        return;
+    }
+    const title = `[chef] story-${storyId}: autonomous fix after brew halt`;
+    // Trim rationale to keep the body tight; full rationale lives in the
+    // audit comment chef posts on the source issue.
+    const trimmedRationale = rationale.length > 500 ? rationale.slice(0, 500) + "…" : rationale;
+    const bodyFile = "/tmp/chef-brew-halt-pr-body.md";
+    writeFileSync(bodyFile, [
+        `Autonomous fix from \`slowcook chef-drift\` after brew halted on story-${storyId}.`,
+        ``,
+        `**Rationale:** ${trimmedRationale}`,
+        ``,
+        `Brew halted with checkpoints committed on this branch; chef applied a surgical edit + the failing test now passes locally on the runner. This PR persists chef's edit + the brew checkpoints together for review.`,
+        ``,
+        `_Generated by \`slowcook chef-drift\` brew-halt finisher (α.58)._`,
+    ].join("\n"), "utf8");
+    try {
+        execSync(`gh pr create --repo "${repoSlug}" --base main --head "${branch}" --title "${title.replace(/"/g, '\\"')}" --body-file "${bodyFile}"`, { stdio: "inherit" });
+        console.log(`  brew-halt publish: opened PR for ${branch}`);
+    }
+    catch (e) {
+        console.warn(`  warn: brew-halt PR create failed: ${e.message.slice(0, 200)}`);
+    }
+}
 function commitChefEdits(repoRoot, summary, edits) {
     // Stage ONLY the files chef edited (never `git add -A` — that
     // accidentally captures workflow-side clones like `_slowcook/` etc.
@@ -512,8 +658,13 @@ function commitChefEdits(repoRoot, summary, edits) {
         }
         catch { /* ledger dir may not exist if first move ran into early error */ }
         // Empty commit guard: if nothing staged, skip.
-        const status = execSync(`git -C "${repoRoot}" status --porcelain --cached`, { encoding: "utf8" }).trim();
-        if (!status)
+        // α.60 — was `git status --porcelain --cached` which is not a valid
+        // git status invocation (--cached isn't a status flag); execSync
+        // threw, the outer try/catch silently absorbed it, and chef NEVER
+        // actually committed in any drift-fix path. `diff --cached
+        // --name-only` lists staged files; empty output = nothing to commit.
+        const staged = execSync(`git -C "${repoRoot}" diff --cached --name-only`, { encoding: "utf8" }).trim();
+        if (!staged)
             return { sha: null, pushed: false };
         // Write commit message to file (handle quotes cleanly).
         const msgFile = "/tmp/chef-drift-commit-msg.txt";
@@ -704,8 +855,40 @@ export async function chefDrift(argv, cliVersion) {
     // material it needs to write surgical search_replace pairs.
     if (args.triggerKind === "brew_halt_class") {
         const runnerOutput = triggerRaw["runner_output"] ?? args.triggerDetail;
+        // α.56 — when runner_output is absent (typical for AGENT_STALLED /
+        // ITERATION_CAP halts where there's no vitest failure to parse),
+        // derive failing-test files from iteration_diffs[].target_test_id.
+        // Format: "tests/path/file.test.ts > suite > name" — split on " > "
+        // and take part[0] as the test file path. The same enrichment then
+        // loads file contents + imported source files. Without this, chef
+        // hallucinates target file contents (seen 2026-05-26 dogfood:
+        // delgoosh#003 chef invented two different "stub" source bodies).
+        let failingFiles = [];
+        let failingTestNames = [];
         if (typeof runnerOutput === "string" && runnerOutput.length > 0) {
-            const { failingFiles, failingTestNames } = parseBrewHaltOutput(runnerOutput);
+            const parsed = parseBrewHaltOutput(runnerOutput);
+            failingFiles = parsed.failingFiles;
+            failingTestNames = parsed.failingTestNames;
+        }
+        else if (Array.isArray(triggerRaw["iteration_diffs"])) {
+            const diffs = triggerRaw["iteration_diffs"];
+            const filesSet = new Set();
+            const namesSet = new Set();
+            for (const d of diffs) {
+                const tid = d?.target_test_id;
+                if (typeof tid !== "string" || tid.length === 0)
+                    continue;
+                const parts = tid.split(" > ");
+                const file = parts[0].trim();
+                if (file)
+                    filesSet.add(file);
+                if (parts.length > 1)
+                    namesSet.add(parts.slice(1).join(" > "));
+            }
+            failingFiles = Array.from(filesSet);
+            failingTestNames = Array.from(namesSet);
+        }
+        if (failingFiles.length > 0) {
             const failingTestContents = {};
             for (const f of failingFiles) {
                 const abs = join(args.repoRoot, f);
@@ -732,6 +915,25 @@ export async function chefDrift(argv, cliVersion) {
                     sourceContents[projRel] = c.length > 6000 ? c.slice(0, 6000) + "\n// ... truncated" : c;
                 }
             }
+            // α.59 — also load files brew itself touched across all iters.
+            // Even if the failing test doesn't import them, they're the live
+            // story state chef should reason about (e.g., the page.tsx brew
+            // wrote in iter 1 imports the component the styling test asserts
+            // on; chef needs both to make a coherent edit).
+            if (Array.isArray(triggerRaw["iteration_diffs"])) {
+                const diffs = triggerRaw["iteration_diffs"];
+                for (const d of diffs) {
+                    for (const f of d?.files_touched ?? []) {
+                        if (typeof f !== "string" || sourceContents[f])
+                            continue;
+                        const abs = join(args.repoRoot, f);
+                        if (!existsSync(abs))
+                            continue;
+                        const c = readFileSync(abs, "utf8");
+                        sourceContents[f] = c.length > 6000 ? c.slice(0, 6000) + "\n// ... truncated" : c;
+                    }
+                }
+            }
             triggerRaw = {
                 ...triggerRaw,
                 failing_test_files: failingFiles,
@@ -739,7 +941,8 @@ export async function chefDrift(argv, cliVersion) {
                 failing_test_contents: failingTestContents,
                 imported_source_files_per_test: importedSourcesMap,
                 source_file_contents: sourceContents,
-                enrichment_note: "cli-precomputed (chef has no read tools): failing_test_contents shows you each red test verbatim. source_file_contents gives you the full text of every source file imported by those tests. Plan search_replace pairs against source_file_contents — never edit failing_test_contents (tests/ is frozen). If the failure can only be fixed by changing a test, return pm_question instead.",
+                enrichment_note: "cli-precomputed (chef has no read tools): failing_test_contents shows you each red test verbatim. source_file_contents gives you the full text of every source file imported by those tests. Plan search_replace pairs against source_file_contents — never edit failing_test_contents (tests/ is frozen). If the failure can only be fixed by changing a test, return pm_question instead.\n\n" +
+                    "ALSO available straight from the halt JSON (already on trigger.raw): `brew_mode` (freehand | plate | auto) and `allowed_paths[]` (the runtime restriction brew enforced). If iteration_diffs show outcome=rejected-overflow, the fix is to widen brew's CLI --mode arg, NOT to edit the spec. `allowed_paths` is not a spec yaml field — see chef prompt §1.6.",
             };
             console.log(`  brew-halt enriched: ${failingFiles.length} failing test file(s), ${Object.keys(sourceContents).length} source file(s) under test`);
         }
@@ -778,6 +981,13 @@ export async function chefDrift(argv, cliVersion) {
         maxTokens: 8192,
     });
     console.log(`  chef LLM: ${resp.usage.inputTokens}→${resp.usage.outputTokens} tok · $${resp.costUsd.toFixed(4)}`);
+    // α.53 — parse-tolerant: a malformed JSON envelope (e.g. an
+    // unterminated string mid-rationale, observed on delgoosh#656
+    // story-003 chef run 26397941242) used to crash the workflow
+    // with exit 1, losing the entire run. Recover whatever signal we
+    // can (typically the rationale prose up to the truncation point)
+    // and escalate as a pm_question instead. The PM still gets
+    // actionable text; the workflow exits clean.
     let verdict;
     try {
         const text = resp.text.trim();
@@ -785,9 +995,10 @@ export async function chefDrift(argv, cliVersion) {
         verdict = JSON.parse(fence ? fence[1] : text);
     }
     catch (e) {
-        console.error(`  ! chef JSON parse failed: ${e.message}`);
-        console.error(`  raw: ${resp.text.slice(0, 500)}`);
-        process.exit(1);
+        const parseErr = e.message;
+        console.warn(`  ! chef JSON parse failed: ${parseErr}`);
+        console.warn(`  recovering rationale from raw text + escalating as pm_question`);
+        verdict = recoverChefVerdictFromMalformedJson(resp.text, parseErr, args.storyId, issueNumber);
     }
     console.log(`  chef verdict: ${verdict.kind.toUpperCase()}`);
     console.log(`  rationale: ${verdict.rationale}`);
@@ -916,6 +1127,47 @@ export async function chefDrift(argv, cliVersion) {
                 if (pushed)
                     console.log(`  finisher: pushed ${commitSha.slice(0, 7)} → ${prCheckout.branchName}`);
             }
+            // α.58 — brew-halt mode: chef-drift was invoked by chef-on-brew-halt
+            // (workflow_run-triggered). The workflow checked out brew_branch
+            // (see slowcook halt artifact field `brew_branch`); chef committed
+            // on top. Persist that work: push HEAD back to origin/<branch>,
+            // open a PR brew_branch → main if none exists. Without this the
+            // commit dies with the ephemeral runner.
+            if (commitSha && !prCheckout && args.triggerKind === "brew_halt_class") {
+                try {
+                    publishChefBrewHaltFix(args.repoRoot, args.storyId, verdict.rationale);
+                }
+                catch (e) {
+                    console.warn(`  warn: chef brew-halt publish failed: ${e.message.slice(0, 200)}`);
+                }
+            }
+            // α.67 — close the knowledge-layer loop: chef writes back to
+            // curated/chef-known-fixes.md so the next chef invocation (or
+            // refine reading the curated block) sees this fix as durable
+            // organizational memory. Soft signal — each entry carries
+            // evidence trail (PR + file + last-verified) so staleness is
+            // reviewable, not auto-invalidating. Best-effort.
+            if (commitSha) {
+                try {
+                    // Distil the chef rationale into a one-line claim. The
+                    // rationale is often a paragraph; we want the WHAT and the
+                    // HOW, compactly. Take the first sentence + cap at ~250
+                    // chars. The full rationale + the move ledger entry are
+                    // already in .brewing/chef/<story>.json for deep audit.
+                    const claim = distilRationaleToClaim(verdict.rationale);
+                    const evidenceFile = verdict.edits[0]?.file;
+                    knowledgeAddCore({
+                        repoRoot: args.repoRoot,
+                        agent: "chef",
+                        topic: "chef-known-fixes",
+                        claim,
+                        evidenceFile,
+                    });
+                }
+                catch (e) {
+                    console.warn(`  warn: knowledge-write skipped: ${e.message.slice(0, 200)}`);
+                }
+            }
         }
     }
     ledger.moves.push(moveEntry);
@@ -947,4 +1199,119 @@ export async function chefDrift(argv, cliVersion) {
     if (verdict.kind === "halt" || moveEntry.post_state === "still-broken")
         process.exit(1);
 }
+/**
+ * α.53 — extract whatever signal we can from a malformed chef JSON.
+ *
+ * The model often returns valid prose (`"rationale": "long sentence about
+ * what's wrong"`) but the JSON envelope breaks if the rationale runs past
+ * Anthropic's max-tokens midstring or contains an unescaped quote.
+ *
+ * Strategy:
+ *   1. Look for ```json fence — strip it.
+ *   2. Try a quick "auto-close unterminated string" repair: count
+ *      unescaped quotes; if odd, append a closing quote + `}` and retry
+ *      JSON.parse.
+ *   3. If still broken, regex-extract the `"rationale"` field value up
+ *      to wherever it terminates (literal quote or end of buffer).
+ *   4. Build a pm_question verdict with the recovered rationale plus a
+ *      bookkeeping note about the parse failure. Empty edits, no
+ *      next-dispatch — the PM is the next step.
+ */
+export function recoverChefVerdictFromMalformedJson(rawText, parseError, storyId, issueNumber) {
+    const text = rawText.trim();
+    const fence = text.match(/```json\s*([\s\S]*?)(?:```|$)/);
+    const body = fence ? fence[1] : text;
+    // Attempt 1: auto-close unterminated string + closing brace.
+    const repaired = autoCloseStringAndBrace(body);
+    if (repaired) {
+        try {
+            const v = JSON.parse(repaired);
+            if (typeof v.rationale === "string") {
+                return {
+                    rationale: v.rationale +
+                        "\n\n_(chef α.53: chef-drift recovered this verdict from a truncated JSON envelope. " +
+                        `Original parse error: ${parseError.slice(0, 120)})_`,
+                    kind: "pm_question",
+                    edits: [],
+                    validation: null,
+                    next_dispatch: null,
+                    pm_comment: {
+                        issue_number: issueNumber,
+                        body: "**[chef] Reasoning recovered from a truncated JSON envelope.**\n\n" +
+                            v.rationale +
+                            "\n\n---\n\n_chef α.53: the LLM produced valid reasoning but the JSON envelope was malformed " +
+                            "(likely a long rationale exceeded max-tokens midstring). Chef recovered the prose via auto-close repair. " +
+                            `Edits/validation/next-dispatch were not parseable. Original parse error: \`${parseError.slice(0, 200)}\`._`,
+                    },
+                };
+            }
+        }
+        catch {
+            // fall through to attempt 2
+        }
+    }
+    // Attempt 2: regex-extract just the rationale field's value.
+    const rationaleMatch = body.match(/"rationale"\s*:\s*"((?:[^"\\]|\\.)*)/);
+    const rationale = rationaleMatch
+        ? rationaleMatch[1].replace(/\\n/g, "\n").replace(/\\"/g, '"')
+        : "(chef returned a malformed JSON envelope and the rationale could not be recovered. See workflow log for raw text.)";
+    return {
+        rationale: rationale +
+            `\n\n_(chef α.53: parse error ${parseError.slice(0, 120)} on story-${storyId} — escalating as pm_question with recovered text only)_`,
+        kind: "pm_question",
+        edits: [],
+        validation: null,
+        next_dispatch: null,
+        pm_comment: {
+            issue_number: issueNumber,
+            body: "**[chef] Reasoning recovered from a malformed JSON envelope (partial).**\n\n" +
+                rationale +
+                "\n\n---\n\n_chef α.53: the LLM produced reasoning but the JSON envelope was malformed beyond auto-repair. " +
+                "What you see above is regex-extracted rationale prose; edits, validation, and next-dispatch fields were not " +
+                `recoverable. Original parse error: \`${parseError.slice(0, 200)}\`. Inspect the workflow log for the full raw text._`,
+        },
+    };
+}
+/**
+ * Conservative auto-close: if the body's quotes are imbalanced (one
+ * unterminated string), append `"` + a guess at how many braces are
+ * still open. Returns the repaired string or null if nothing salvageable.
+ */
+function autoCloseStringAndBrace(body) {
+    // Count unescaped quotes outside strings is structurally hard; the
+    // heuristic here: if quotes count is odd, append a closing quote.
+    let inString = false;
+    let escape = false;
+    let openBraces = 0;
+    for (const ch of body) {
+        if (escape) {
+            escape = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escape = true;
+            continue;
+        }
+        if (ch === '"') {
+            inString = !inString;
+            continue;
+        }
+        if (!inString) {
+            if (ch === "{")
+                openBraces++;
+            else if (ch === "}")
+                openBraces--;
+        }
+    }
+    if (!inString && openBraces === 0)
+        return null; // nothing to repair
+    let repaired = body;
+    if (inString)
+        repaired += '"';
+    while (openBraces > 0) {
+        repaired += "}";
+        openBraces--;
+    }
+    return repaired;
+}
 //# sourceMappingURL=drift-fix.js.map