@deftai/directive-core 0.73.0 → 0.74.0

package/dist/scope/open-umbrella-warning.js

@@ -0,0 +1,403 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { referenceTypeMatches } from "@deftai/directive-types";
+import { hasArtifactSuffix } from "../layout/resolve.js";
+import { CACHE_DIR_NAME, CACHE_SOURCE_GITHUB_ISSUE } from "../triage/queue/constants.js";
+import { parseGithubIssueUri } from "../triage/reconcile/parse-uri.js";
+import { collectPlanRefs, resolveVbriefRef } from "./vbrief-ref.js";
+const OPEN_FOLDERS = ["proposed", "pending", "active"];
+const TRACKER_LABELS = new Set(["epic", "meta", "tracker", "type:tracker", "status:tracker"]);
+function readJson(path) {
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function planOf(data) {
+    const plan = data?.plan;
+    return typeof plan === "object" && plan !== null && !Array.isArray(plan)
+        ? plan
+        : null;
+}
+function issueRefsFromPlan(plan) {
+    const refs = plan?.references;
+    if (!Array.isArray(refs)) {
+        return [];
+    }
+    const out = [];
+    const seen = new Set();
+    for (const ref of refs) {
+        if (typeof ref !== "object" || ref === null || Array.isArray(ref)) {
+            continue;
+        }
+        const typed = ref;
+        if (!referenceTypeMatches(String(typed.type ?? ""), "github-issue")) {
+            continue;
+        }
+        const [repo, number] = parseGithubIssueUri(typed.uri);
+        if (number === null) {
+            continue;
+        }
+        const key = repo === null ? `bare:${number}` : `${repo}:${number}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        out.push({ repo, number });
+    }
+    return out;
+}
+function labelsFromRaw(raw) {
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    const out = [];
+    for (const label of raw) {
+        if (typeof label === "string") {
+            out.push(label);
+        }
+        else if (typeof label === "object" && label !== null && !Array.isArray(label)) {
+            const name = label.name;
+            if (typeof name === "string") {
+                out.push(name);
+            }
+        }
+    }
+    return out;
+}
+function subIssueTotal(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        return 0;
+    }
+    const total = raw.total;
+    return typeof total === "number" && Number.isFinite(total) ? total : 0;
+}
+function readTextIfPresent(path) {
+    if (!existsSync(path)) {
+        return "";
+    }
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+function readCachedIssue(projectRoot, repo, number) {
+    const [owner, name] = repo.split("/", 2);
+    if (!owner || !name) {
+        return null;
+    }
+    const issueDir = join(projectRoot, CACHE_DIR_NAME, CACHE_SOURCE_GITHUB_ISSUE, owner, name, String(number));
+    const rawPath = join(issueDir, "raw.json");
+    const raw = readJson(rawPath);
+    if (raw === null) {
+        return null;
+    }
+    const body = typeof raw.body === "string" ? raw.body : "";
+    const content = readTextIfPresent(join(issueDir, "content.md"));
+    return {
+        repo,
+        number: typeof raw.number === "number" && Number.isFinite(raw.number) ? raw.number : number,
+        title: typeof raw.title === "string" ? raw.title : `#${number}`,
+        state: typeof raw.state === "string" ? raw.state.toLowerCase() : "open",
+        body: content.length > 0 ? `${body}\n${content}` : body,
+        labels: labelsFromRaw(raw.labels).map((label) => label.toLowerCase()),
+        subIssuesTotal: subIssueTotal(raw.sub_issues_summary),
+    };
+}
+function cachedState(projectRoot, ref) {
+    if (ref.repo === null) {
+        return null;
+    }
+    const cached = readCachedIssue(projectRoot, ref.repo, ref.number);
+    if (cached === null) {
+        return null;
+    }
+    return cached.state === "closed" ? "closed" : "open";
+}
+function chooseOpenIssueRef(projectRoot, refs) {
+    if (refs.length === 0) {
+        return null;
+    }
+    let firstUnknown = null;
+    for (const ref of refs) {
+        const state = cachedState(projectRoot, ref);
+        if (state === "open") {
+            return ref;
+        }
+        if (state === null && firstUnknown === null) {
+            firstUnknown = ref;
+        }
+    }
+    return firstUnknown;
+}
+function refUriMatchesPath(uri, targetPaths, vbriefRoot) {
+    if (typeof uri !== "string" || uri.length === 0) {
+        return false;
+    }
+    const resolved = resolveVbriefRef(uri, vbriefRoot);
+    if (resolved === null) {
+        return false;
+    }
+    return targetPaths.has(resolve(resolved));
+}
+function planReferenceMatchesTarget(ref, targetPaths, vbriefRoot) {
+    if (typeof ref !== "object" || ref === null || Array.isArray(ref)) {
+        return false;
+    }
+    const typed = ref;
+    if (!referenceTypeMatches(String(typed.type ?? ""), "plan")) {
+        return false;
+    }
+    return refUriMatchesPath(typed.uri, targetPaths, vbriefRoot);
+}
+function planReferencesTarget(plan, targetPaths, vbriefRoot) {
+    const refs = plan.references;
+    if (!Array.isArray(refs)) {
+        return false;
+    }
+    return refs.some((ref) => planReferenceMatchesTarget(ref, targetPaths, vbriefRoot));
+}
+function planRefsTarget(plan, targetPaths, vbriefRoot) {
+    return collectPlanRefs(plan).some((uri) => refUriMatchesPath(uri, targetPaths, vbriefRoot));
+}
+function relToRoot(path, root) {
+    return relative(resolve(root), resolve(path)).replace(/\\/g, "/");
+}
+function addReference(out, ref) {
+    const key = ref.repo !== null && ref.issueNumber !== null
+        ? `${ref.repo}#${ref.issueNumber}`
+        : (ref.path ?? ref.title);
+    const existing = out.get(key);
+    if (existing !== undefined) {
+        existing.sources.add(ref.source);
+        if (existing.title.startsWith("#") && !ref.title.startsWith("#")) {
+            existing.title = ref.title;
+        }
+        return;
+    }
+    out.set(key, {
+        repo: ref.repo,
+        issueNumber: ref.issueNumber,
+        title: ref.title,
+        path: ref.path,
+        sources: new Set([ref.source]),
+    });
+}
+function titleForLocalCandidate(plan, issueRef, projectRoot) {
+    if (issueRef?.repo !== null && issueRef?.repo !== undefined) {
+        const cached = readCachedIssue(projectRoot, issueRef.repo, issueRef.number);
+        if (cached !== null) {
+            return cached.title;
+        }
+    }
+    return typeof plan.title === "string" && plan.title.length > 0
+        ? plan.title
+        : issueRef !== null
+            ? `#${issueRef.number}`
+            : "open scope";
+}
+function findLocalReferences(projectRoot, completedScopePath, completedPlan, out) {
+    const vbriefRoot = dirname(dirname(resolve(completedScopePath)));
+    const targetScopePaths = new Set([
+        completedScopePath,
+        ...OPEN_FOLDERS.map((folder) => join(vbriefRoot, folder, basename(completedScopePath))),
+    ].map((path) => resolve(path)));
+    const targetParentPaths = collectPlanRefs(completedPlan)
+        .map((uri) => resolveVbriefRef(uri, vbriefRoot))
+        .filter((path) => path !== null)
+        .map((path) => resolve(path));
+    for (const folder of OPEN_FOLDERS) {
+        const folderPath = join(vbriefRoot, folder);
+        if (!existsSync(folderPath)) {
+            continue;
+        }
+        for (const name of readdirSync(folderPath)
+            .filter((entry) => hasArtifactSuffix(entry))
+            .sort()) {
+            const path = join(folderPath, name);
+            const plan = planOf(readJson(path));
+            if (plan === null) {
+                continue;
+            }
+            const sources = [];
+            if (planReferencesTarget(plan, targetScopePaths, vbriefRoot)) {
+                sources.push("plan.references");
+            }
+            if (planRefsTarget(plan, targetScopePaths, vbriefRoot)) {
+                sources.push("planRef");
+            }
+            if (targetParentPaths.includes(resolve(path))) {
+                sources.push("completed planRef");
+            }
+            if (sources.length === 0) {
+                continue;
+            }
+            const issueRefs = issueRefsFromPlan(plan);
+            const issueRef = chooseOpenIssueRef(projectRoot, issueRefs);
+            if (issueRefs.length > 0 && issueRef === null) {
+                continue;
+            }
+            const relPath = relToRoot(path, projectRoot);
+            for (const source of sources) {
+                addReference(out, {
+                    repo: issueRef?.repo ?? null,
+                    issueNumber: issueRef?.number ?? null,
+                    title: titleForLocalCandidate(plan, issueRef, projectRoot),
+                    path: relPath,
+                    source,
+                });
+            }
+        }
+    }
+}
+function cachedRepoDirs(projectRoot) {
+    const base = join(projectRoot, CACHE_DIR_NAME, CACHE_SOURCE_GITHUB_ISSUE);
+    if (!existsSync(base)) {
+        return [];
+    }
+    const repos = [];
+    for (const ownerEntry of readdirSync(base, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+        if (!ownerEntry.isDirectory()) {
+            continue;
+        }
+        const owner = ownerEntry.name;
+        const ownerPath = join(base, owner);
+        for (const repoEntry of readdirSync(ownerPath, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+            if (!repoEntry.isDirectory()) {
+                continue;
+            }
+            const name = repoEntry.name;
+            repos.push(`${owner}/${name}`);
+        }
+    }
+    return repos;
+}
+function issueNumberToken(issueNumber) {
+    return Number.isSafeInteger(issueNumber) && issueNumber > 0 ? String(issueNumber) : null;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function textMentionsIssue(text, ref, cachedRepo) {
+    const token = issueNumberToken(ref.number);
+    if (token === null) {
+        return false;
+    }
+    const hash = new RegExp(`(^|[^A-Za-z0-9_#])#${token}(?!\\d)`);
+    if (ref.repo === cachedRepo && hash.test(text)) {
+        return true;
+    }
+    if (ref.repo === null) {
+        return false;
+    }
+    const repo = escapeRegExp(ref.repo);
+    const qualifiedUrl = new RegExp(`(?:github\\.com|api\\.github\\.com/repos)/${repo}/issues/${token}(?:\\D|$)`);
+    return qualifiedUrl.test(text);
+}
+function looksLikeTracker(issue) {
+    if (issue.subIssuesTotal > 0) {
+        return true;
+    }
+    if (issue.labels.some((label) => TRACKER_LABELS.has(label) || label.includes("umbrella"))) {
+        return true;
+    }
+    return /\b(epic|omnibus|tracker|umbrella)\b/i.test(issue.title);
+}
+function findCachedIssueBodyReferences(projectRoot, targetIssueRefs, out) {
+    const targetNumbers = new Set(targetIssueRefs.map((ref) => ref.number));
+    if (targetNumbers.size === 0) {
+        return;
+    }
+    if (!targetIssueRefs.some((ref) => ref.repo !== null)) {
+        return;
+    }
+    for (const repo of cachedRepoDirs(projectRoot)) {
+        const [owner, name] = repo.split("/", 2);
+        if (!owner || !name) {
+            continue;
+        }
+        const repoDir = join(projectRoot, CACHE_DIR_NAME, CACHE_SOURCE_GITHUB_ISSUE, owner, name);
+        for (const entry of readdirSync(repoDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+            if (!entry.isDirectory() || !/^\d+$/.test(entry.name)) {
+                continue;
+            }
+            const issueNumber = Number(entry.name);
+            if (targetNumbers.has(issueNumber)) {
+                continue;
+            }
+            const issue = readCachedIssue(projectRoot, repo, issueNumber);
+            if (issue === null || issue.state !== "open" || !looksLikeTracker(issue)) {
+                continue;
+            }
+            const haystack = `${issue.title}\n${issue.body}`;
+            if (!targetIssueRefs.some((ref) => textMentionsIssue(haystack, ref, repo))) {
+                continue;
+            }
+            addReference(out, {
+                repo,
+                issueNumber: issue.number,
+                title: issue.title,
+                path: null,
+                source: "cached issue body",
+            });
+        }
+    }
+}
+/** Find open umbrella/tracker surfaces that still mention a just-completed scope. */
+export function findOpenUmbrellaReferences(projectRoot, completedScopePath) {
+    const data = readJson(completedScopePath);
+    const completedPlan = planOf(data);
+    if (completedPlan === null) {
+        return [];
+    }
+    const out = new Map();
+    findLocalReferences(projectRoot, completedScopePath, completedPlan, out);
+    findCachedIssueBodyReferences(projectRoot, issueRefsFromPlan(completedPlan), out);
+    return [...out.values()]
+        .map((ref) => ({
+        repo: ref.repo,
+        issueNumber: ref.issueNumber,
+        title: ref.title,
+        path: ref.path,
+        sources: [...ref.sources].sort(),
+    }))
+        .sort((a, b) => {
+        const aKey = a.issueNumber !== null
+            ? a.repo === null
+                ? `bare:#${a.issueNumber}`
+                : `${a.repo}#${a.issueNumber}`
+            : (a.path ?? "");
+        const bKey = b.issueNumber !== null
+            ? b.repo === null
+                ? `bare:#${b.issueNumber}`
+                : `${b.repo}#${b.issueNumber}`
+            : (b.path ?? "");
+        return aKey.localeCompare(bKey);
+    });
+}
+function displayReference(ref) {
+    const issue = ref.issueNumber !== null ? `#${ref.issueNumber}${ref.repo ? ` (${ref.repo})` : ""}` : null;
+    const path = ref.path !== null ? ref.path : null;
+    const name = issue ?? path ?? ref.title;
+    return `${name}: ${ref.title}`;
+}
+export function renderOpenUmbrellaWarning(refs) {
+    if (refs.length === 0) {
+        return "";
+    }
+    const names = refs.map(displayReference).join("; ");
+    return (`Warning: scope:complete found open umbrella/tracker reference(s) to the completed scope: ${names}. ` +
+        "Run `task vbrief:reconcile:umbrellas` to refresh current-shape comments.");
+}
+export function completedPathForScopeMove(filePath) {
+    const resolved = resolve(filePath);
+    return join(dirname(dirname(resolved)), "completed", basename(resolved));
+}
+//# sourceMappingURL=open-umbrella-warning.js.map

package/dist/swarm/constants.d.ts

@@ -7,7 +7,7 @@ export declare const EXIT_UNCLEAN = 1;
 export declare const EXIT_EXTERNAL_ERROR = 2;
 export declare const DEFAULT_BASE_BRANCH = "master";
 export declare const LEAF_CODING_WORKER_ROLE = "leaf-implementation";
-export declare const SUBAGENT_BACKEND_SET_CMD = "task policy:subagent-backend -- --set {backend_id}";
+export declare const SUBAGENT_BACKEND_SET_CMD: string;
 export declare const GATE_ADVISE = "advise";
 export declare const GATE_ENFORCE = "enforce";
 export declare const READY = "ready";

package/dist/swarm/constants.js

@@ -1,3 +1,4 @@
+import { policySetInvocation } from "../policy/policy-invocation.js";
 export const EXIT_OK = 0;
 export const EXIT_GATE_FAILED = 1;
 export const EXIT_CONFIG_ERROR = 2;
@@ -7,7 +8,7 @@ export const EXIT_UNCLEAN = 1;
 export const EXIT_EXTERNAL_ERROR = 2;
 export const DEFAULT_BASE_BRANCH = "master";
 export const LEAF_CODING_WORKER_ROLE = "leaf-implementation";
-export const SUBAGENT_BACKEND_SET_CMD = "task policy:subagent-backend -- --set {backend_id}";
+export const SUBAGENT_BACKEND_SET_CMD = `${policySetInvocation("subagent-backend", " -- --set {backend_id}")}`;
 export const GATE_ADVISE = "advise";
 export const GATE_ENFORCE = "enforce";
 export const READY = "ready";

package/dist/swarm/subagent-backend.js

@@ -12,6 +12,7 @@
  * @see {@link https://github.com/deftai/directive/issues/1860} Hard deletion tracking
  */
 import { readPlanPolicy } from "../policy/plan-extensions.js";
+import { policySetInvocation } from "../policy/policy-invocation.js";
 import { loadProjectDefinition } from "../policy/resolve.js";
 import { LEAF_CODING_WORKER_ROLE, SUBAGENT_BACKEND_SET_CMD } from "./constants.js";
 const TRUTHY = new Set(["1", "true", "yes", "on"]);
@@ -132,7 +133,7 @@ export function enforceSubagentBackendPolicy(projectRoot, environ = process.env)
             error: `${detail}\n` +
                 "Select a coding sub-agent backend before headless dispatch:\n" +
                 `${listing}\n` +
-                "Probe harness availability: task policy:subagent-backends\n" +
+                `Probe harness availability: ${policySetInvocation("subagent-backends")}\n` +
                 `Persist a choice: ${SUBAGENT_BACKEND_SET_CMD.replace("{backend_id}", "<id>")}`,
         };
     }

package/dist/triage/bootstrap/gitignore.d.ts

@@ -8,7 +8,7 @@ export declare function gitignoreTriageCacheEntries(projectRoot: string): readon
 export declare function gitattributesTriageCacheGlob(projectRoot: string): string;
 export declare const GITATTRIBUTES_EVAL_RULE = "vbrief/.triage-cache/*.jsonl  merge=union";
 export declare const FORBIDDEN_BLANKET_EVAL_LINES: readonly string[];
-export declare const EVAL_README_BODY = "# `vbrief/.triage-cache/` -- triage working-set artefacts\n\nThis directory holds the append-only JSON-lines logs that the triage and\nslicing skills emit. The framework governs which files in here are tracked\nby git versus gitignored using a **hybrid policy** (#1144, child of #1119).\n\n## Tracking policy\n\n| File | Tracked? | Why |\n| --- | --- | --- |\n| `slices.jsonl` | Yes -- **committed** | Team-shared cohort records produced by slicing skills (D13 / #1132). New operators joining the team need to see prior cohort outputs to detect orphans and avoid re-slicing the same scope. |\n| `candidates.jsonl` | No -- **gitignored** | Operator-private triage decisions (#845 Story 2). Each operator's local accept / defer / reject stream is per-machine state; sharing it would conflate operators' timing + identity across the team. Re-derive on a fresh clone via `task triage:bootstrap`. |\n| `summary-history.jsonl` | No -- **gitignored** | Operator-private observability for `task triage:summary` output time-series. Not load-bearing for any decision. |\n| `scope-lifecycle.jsonl` | No -- **gitignored** | Operator-private scope-lifecycle audit decisions (D1 / #1121). Each demote (`task scope:demote`) appends one entry including a `demote_meta` block (`was_promoted`, `original_promotion_decision_id`, `days_in_pending`, `demote_reason`, `demoted_from`). Per-operator stream; sharing would conflate operators' demote timing across the team. Lightweight metrics over this log are tracked separately at #1180. |\n| `decompositions/` | No -- **gitignored** | Temporary story-decomposition proposal drafts. These JSON drafts are local scratch artifacts, not vBRIEFs; generated child story vBRIEFs are created by `task scope:decompose` in lifecycle folders, defaulting to `vbrief/pending/`. |\n| `doctor-state.json` | No -- **gitignored** | Per-machine `task doctor` throttle state (last exit code + timestamps) persisted to gate the 24h/4h re-probe window (#1308 / #1464). Local to each clone; never committed. |\n\nThe gitignore lines live in the repo-root `.gitignore` (`vbrief/.triage-cache/candidates.jsonl`,\n`vbrief/.triage-cache/summary-history.jsonl`, `vbrief/.triage-cache/scope-lifecycle.jsonl`,\n`vbrief/.triage-cache/decompositions/`, and `vbrief/.triage-cache/doctor-state.json`). All paths\nnot listed above remain committed by default.\n\n## Fresh-clone regeneration\n\nOn a fresh clone (or any machine that has never run triage), `candidates.jsonl`\nis absent. Regenerate it with:\n\n```\ntask triage:bootstrap\n```\n\nThe bootstrap path detects the missing file, runs the auto-classifier, and\nwrites a fresh `vbrief/.triage-cache/candidates.jsonl`. It does NOT touch the tracked\n`slices.jsonl`; cohort records remain a team-shared resource.\n\n## `merge=union` policy for `*.jsonl`\n\nThe repo-root `.gitattributes` declares:\n\n```\nvbrief/.triage-cache/*.jsonl  merge=union\n```\n\nThe `union` merge driver concatenates both sides' appended lines on\nauto-merge, so two branches that each appended a different record to the\nsame JSON-lines file rebase cleanly without operator surgery. Two things\noperators should know:\n\n- **Concatenation, not set-union.** When two branches append DIFFERENT\n  records to the file, the merge driver concatenates both sides' lines\n  -- there is no smart deduplication of \"semantically similar\" records.\n  (Identical line-for-line appends collapse because git's three-way\n  merge sees them as the same change, but distinct records always\n  survive verbatim, even if a downstream reader would consider them\n  redundant.) The append-only writers in `scripts/candidates_log.py`\n  mint a fresh `decision_id` per call, so genuinely duplicate records\n  are not the expected case, but downstream readers MUST tolerate\n  multiple records describing the same logical decision.\n- **Single-operator scope only.** This is the foundational rebase\n  ergonomic for the single-operator case (operator A rebases their\n  feature branch onto a master that grew while they were AFK).\n  Multi-operator merge-conflict resolution is explicitly out of scope per\n  #1119 R4 (tracked separately as M1-M4 in #1183).\n\n## See also\n\n- Current Shape comment on #1144 for the canonical decisions (the source\n  of truth this README documents).\n- `.gitignore` -- selective gitignore entries for the operator-private\n  files.\n- `.gitattributes` -- the `merge=union` rule.\n- `scripts/candidates_log.py` -- the writer for `candidates.jsonl`.\n";
+export declare const EVAL_README_BODY = "# `vbrief/.triage-cache/` \u2014 triage working-set files\n\nThis directory holds JSON-lines logs and scratch files that Deft triage and\nslicing workflows emit. Deft configures your repo's `.gitignore` and\n`.gitattributes` so some files stay local while team-shared records can be\ncommitted.\n\n## What lives here\n\n| File | Committed? | Notes |\n| --- | --- | --- |\n| `slices.jsonl` | Yes | Team-shared cohort records from slicing skills. New teammates use prior cohort outputs to spot orphans and avoid re-slicing the same scope. |\n| `candidates.jsonl` | No | Your local triage accept / defer / reject stream. Re-create on a fresh clone with `deft triage:bootstrap`. |\n| `summary-history.jsonl` | No | Local history of `deft triage:summary` output; not required for day-to-day work. |\n| `scope-lifecycle.jsonl` | No | Local audit trail for scope demotions (`deft scope:demote`). Each operator's stream stays on their machine. |\n| `decompositions/` | No | Draft story-decomposition scratch. Produced child story xBRIEFs live in lifecycle folders via `deft scope:decompose`. |\n| `doctor-state.json` | No | Per-clone throttle state for `deft doctor` re-probe timing. |\n\nPaths listed as \"No\" above are added to `.gitignore` during bootstrap; anything\nnot listed remains committable by default. The selective ignore entries live in\nthe repo-root `.gitignore` (`vbrief/.triage-cache/candidates.jsonl`,\n`vbrief/.triage-cache/summary-history.jsonl`, `vbrief/.triage-cache/scope-lifecycle.jsonl`,\n`vbrief/.triage-cache/decompositions/`, and `vbrief/.triage-cache/doctor-state.json`).\n\n## Fresh clone\n\nIf `candidates.jsonl` is missing, run:\n\n```\ndeft triage:bootstrap\n```\n\nBootstrap rebuilds the local candidates log without altering committed\n`slices.jsonl`.\n\n## Merge behavior for `*.jsonl`\n\nThe repo-root `.gitattributes` may declare:\n\n```\nvbrief/.triage-cache/*.jsonl  merge=union\n```\n\nThe `union` merge driver concatenates both sides' appended lines on auto-merge,\nso parallel append-only edits to the same JSON-lines file rebase without manual\nconflict surgery. It does not dedupe semantically similar records \u2014 downstream\nreaders should tolerate duplicate-looking entries.\n\n## See also\n\n- `.gitignore` \u2014 selective ignore rules for operator-private files\n- `.gitattributes` \u2014 merge driver for committed JSON-lines logs\n";
 /** Layout-aware triage-cache README body for the active lifecycle tree (#2344 / #2349). */
 export declare function generateTriageCacheReadmeBody(projectRoot: string): string;
 /** Strip an inline `# ...` comment from a gitignore line. */