@deftai/directive-core 0.55.0

package/dist/swarm/verify-review-clean-cli.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { verifyReviewClean } from "./verify-review-clean.js";
+export function verifyReviewCleanMain(argv = process.argv.slice(2)) {
+    const prNumbers = [];
+    const cohortGlobs = [];
+    let repo = null;
+    let emitJson = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--cohort" && argv[i + 1] !== undefined) {
+            cohortGlobs.push(argv[i + 1] ?? "");
+            i += 1;
+        }
+        else if (arg === "--repo" && argv[i + 1] !== undefined) {
+            repo = argv[i + 1] ?? null;
+            i += 1;
+        }
+        else if (arg === "--json") {
+            emitJson = true;
+        }
+        else if (arg !== undefined && /^\d+$/.test(arg)) {
+            prNumbers.push(Number.parseInt(arg, 10));
+        }
+    }
+    const result = verifyReviewClean({ prNumbers, cohortGlobs, repo, emitJson });
+    if (result.stdout.length > 0) {
+        process.stdout.write(result.stdout);
+    }
+    if (result.stderr.length > 0) {
+        process.stderr.write(result.stderr);
+    }
+    return result.exitCode;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(verifyReviewCleanMain());
+}
+//# sourceMappingURL=verify-review-clean-cli.js.map

package/dist/swarm/verify-review-clean.d.ts

@@ -0,0 +1,40 @@
+import type { RunGhFn } from "../pr-merge-readiness/types.js";
+import { EXIT_EXTERNAL_ERROR, EXIT_OK, EXIT_UNCLEAN } from "./constants.js";
+export interface CohortResolutionError {
+    vbrief_path: string;
+    reason: string;
+}
+export interface CohortPRResult {
+    pr_number: number;
+    head_sha: string | null;
+    verdict: Record<string, unknown>;
+    failures: string[];
+    clean: boolean;
+}
+export interface CohortResult {
+    repo: string | null;
+    pr_results: CohortPRResult[];
+    resolution_errors: CohortResolutionError[];
+    all_clean: boolean;
+}
+export declare function resolveCohortFromVbriefs(vbriefGlobs: readonly string[]): {
+    prNumbers: number[];
+    failures: CohortResolutionError[];
+};
+export declare function evaluatePr(prNumber: number, repo: string | null, runGh?: RunGhFn): CohortPRResult | null;
+export declare function cohortResultToDict(cohort: CohortResult): Record<string, unknown>;
+export declare function renderReviewCleanText(cohort: CohortResult): string;
+export interface VerifyReviewCleanArgs {
+    prNumbers?: readonly number[];
+    cohortGlobs?: readonly string[];
+    repo?: string | null;
+    emitJson?: boolean;
+    runGh?: RunGhFn;
+}
+export declare function verifyReviewClean(args: VerifyReviewCleanArgs): {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+};
+export { EXIT_EXTERNAL_ERROR, EXIT_OK, EXIT_UNCLEAN };
+//# sourceMappingURL=verify-review-clean.d.ts.map

package/dist/swarm/verify-review-clean.js

@@ -0,0 +1,240 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { defaultRunGh, fetchGreptileCommentBody, fetchPrHeadSha, } from "../pr-merge-readiness/gh.js";
+import { evaluateGates, parseGreptileBody } from "../pr-merge-readiness/index.js";
+import { EXIT_EXTERNAL_ERROR, EXIT_OK, EXIT_UNCLEAN } from "./constants.js";
+function extractPrFromUri(uri) {
+    const pullIdx = uri.indexOf("/pull/");
+    if (pullIdx < 0) {
+        return null;
+    }
+    let i = pullIdx + "/pull/".length;
+    const digits = [];
+    while (i < uri.length) {
+        const ch = uri.charAt(i);
+        if (ch >= "0" && ch <= "9") {
+            digits.push(ch);
+            i += 1;
+        }
+        else {
+            break;
+        }
+    }
+    if (digits.length === 0) {
+        return null;
+    }
+    return Number.parseInt(digits.join(""), 10);
+}
+function globPaths(pattern) {
+    if (pattern.includes("*")) {
+        const slash = pattern.lastIndexOf("/");
+        const dir = slash >= 0 ? pattern.slice(0, slash) : ".";
+        const glob = slash >= 0 ? pattern.slice(slash + 1) : pattern;
+        if (!existsSync(dir)) {
+            return [];
+        }
+        return readdirSync(dir)
+            .filter((name) => (glob === "*.vbrief.json" ? name.endsWith(".vbrief.json") : name === glob))
+            .map((name) => resolve(dir, name));
+    }
+    return [resolve(pattern)];
+}
+export function resolveCohortFromVbriefs(vbriefGlobs) {
+    const seenPrs = [];
+    const seenSet = new Set();
+    const failures = [];
+    const paths = [];
+    for (const pattern of vbriefGlobs) {
+        const matched = globPaths(pattern).sort();
+        if (matched.length === 0) {
+            failures.push({
+                vbrief_path: pattern,
+                reason: `glob matched no files: ${JSON.stringify(pattern)}`,
+            });
+            continue;
+        }
+        paths.push(...matched);
+    }
+    for (const path of paths) {
+        let payload;
+        try {
+            payload = JSON.parse(readFileSync(path, "utf8"));
+        }
+        catch (exc) {
+            failures.push({ vbrief_path: path, reason: `unreadable: ${String(exc)}` });
+            continue;
+        }
+        const plan = payload.plan;
+        const references = typeof plan === "object" && plan !== null && !Array.isArray(plan)
+            ? plan.references
+            : [];
+        const refs = Array.isArray(references) ? references : [];
+        const prNumbersInFile = [];
+        for (const ref of refs) {
+            if (typeof ref !== "object" || ref === null || Array.isArray(ref)) {
+                continue;
+            }
+            const uri = ref.uri;
+            if (typeof uri !== "string" || uri.length === 0) {
+                continue;
+            }
+            const pr = extractPrFromUri(uri);
+            if (pr !== null) {
+                prNumbersInFile.push(pr);
+            }
+        }
+        if (prNumbersInFile.length === 0) {
+            failures.push({
+                vbrief_path: path,
+                reason: "no x-vbrief/github-pr-style references found",
+            });
+            continue;
+        }
+        for (const prNum of prNumbersInFile) {
+            if (seenSet.has(prNum)) {
+                continue;
+            }
+            seenSet.add(prNum);
+            seenPrs.push(prNum);
+        }
+    }
+    return { prNumbers: seenPrs, failures };
+}
+export function evaluatePr(prNumber, repo, runGh = defaultRunGh) {
+    const headSha = fetchPrHeadSha(prNumber, repo, runGh);
+    if (headSha === null) {
+        return null;
+    }
+    const body = fetchGreptileCommentBody(prNumber, repo, runGh);
+    if (body === null) {
+        return null;
+    }
+    const verdict = parseGreptileBody(body);
+    const failures = evaluateGates(prNumber, headSha, verdict);
+    return {
+        pr_number: prNumber,
+        head_sha: headSha,
+        verdict: { ...verdict },
+        failures: [...failures],
+        clean: failures.length === 0,
+    };
+}
+export function cohortResultToDict(cohort) {
+    return {
+        repo: cohort.repo,
+        all_clean: cohort.all_clean,
+        pr_count: cohort.pr_results.length,
+        pr_results: cohort.pr_results.map((r) => ({
+            pr_number: r.pr_number,
+            head_sha: r.head_sha,
+            clean: r.clean,
+            verdict: r.verdict,
+            failures: r.failures,
+        })),
+        resolution_errors: cohort.resolution_errors,
+    };
+}
+export function renderReviewCleanText(cohort) {
+    const n = cohort.pr_results.length;
+    const lines = [`Swarm cohort CLEAN verification (${n} PR${n === 1 ? "" : "s"})`];
+    if (cohort.repo) {
+        lines.push(`  Repo: ${cohort.repo}`);
+    }
+    if (cohort.resolution_errors.length > 0) {
+        lines.push("  Resolution errors:");
+        for (const err of cohort.resolution_errors) {
+            lines.push(`    [${err.vbrief_path}] ${err.reason}`);
+        }
+    }
+    for (const r of cohort.pr_results) {
+        const status = r.clean ? "CLEAN" : "UNCLEAN";
+        const v = r.verdict;
+        lines.push("");
+        lines.push(`  PR #${r.pr_number} -- ${status}`);
+        lines.push(`    HEAD SHA:           ${r.head_sha ?? "<unknown>"}`);
+        lines.push(`    Greptile reviewed:  ${String(v.lastReviewedSha ?? "<not parsed>")}`);
+        const conf = v.confidence;
+        lines.push(`    Confidence:         ${conf === null || conf === undefined ? "<not parsed>" : String(conf)}/5`);
+        lines.push(`    Findings:           P0=${String(v.p0Count ?? 0)}  ` +
+            `P1=${String(v.p1Count ?? 0)}  P2=${String(v.p2Count ?? 0)}`);
+        lines.push(`    Errored sentinel:   ${v.errored === true ? "True" : "False"}`);
+        r.failures.forEach((fail, index) => {
+            lines.push(`      [${index + 1}] ${fail}`);
+        });
+    }
+    lines.push("");
+    if (cohort.all_clean) {
+        lines.push("Result: COHORT CLEAN -- Phase 5 -> 6 merge discussion may proceed");
+    }
+    else {
+        const nUnclean = cohort.pr_results.filter((r) => !r.clean).length;
+        lines.push(`Result: COHORT BLOCKED -- ${nUnclean}/${n} PR(s) unclean. ` +
+            "Do NOT raise the Phase 5 -> 6 gate; re-dispatch pollers or " +
+            "address findings, then re-run task swarm:verify-review-clean.");
+    }
+    return lines.join("\n");
+}
+export function verifyReviewClean(args) {
+    const prNumbers = [...new Set(args.prNumbers ?? [])];
+    const resolutionErrors = [];
+    if (args.cohortGlobs !== undefined && args.cohortGlobs.length > 0) {
+        const discovered = resolveCohortFromVbriefs(args.cohortGlobs);
+        for (const pr of discovered.prNumbers) {
+            if (!prNumbers.includes(pr)) {
+                prNumbers.push(pr);
+            }
+        }
+        resolutionErrors.push(...discovered.failures);
+    }
+    if (prNumbers.length === 0) {
+        const msg = "Error: empty cohort. Pass one or more PR numbers as positional " +
+            "arguments and/or --cohort <glob> to discover PRs from vBRIEF references.";
+        const cohort = {
+            repo: args.repo ?? null,
+            pr_results: [],
+            resolution_errors: resolutionErrors,
+            all_clean: false,
+        };
+        if (args.emitJson) {
+            return {
+                exitCode: EXIT_EXTERNAL_ERROR,
+                stdout: `${JSON.stringify(cohortResultToDict(cohort), null, 2)}\n`,
+                stderr: "",
+            };
+        }
+        let stderr = `${msg}\n`;
+        for (const err of resolutionErrors) {
+            stderr += `  [${err.vbrief_path}] ${err.reason}\n`;
+        }
+        return { exitCode: EXIT_EXTERNAL_ERROR, stdout: "", stderr };
+    }
+    const runGh = args.runGh ?? defaultRunGh;
+    const prResults = [];
+    for (const prNum of prNumbers) {
+        const perPr = evaluatePr(prNum, args.repo ?? null, runGh);
+        if (perPr === null) {
+            return { exitCode: EXIT_EXTERNAL_ERROR, stdout: "", stderr: "" };
+        }
+        prResults.push(perPr);
+    }
+    const cohort = {
+        repo: args.repo ?? null,
+        pr_results: prResults,
+        resolution_errors: resolutionErrors,
+        all_clean: prResults.length > 0 && resolutionErrors.length === 0 && prResults.every((r) => r.clean),
+    };
+    if (args.emitJson) {
+        return {
+            exitCode: cohort.all_clean ? EXIT_OK : EXIT_UNCLEAN,
+            stdout: `${JSON.stringify(cohortResultToDict(cohort), null, 2)}\n`,
+            stderr: "",
+        };
+    }
+    return {
+        exitCode: cohort.all_clean ? EXIT_OK : EXIT_UNCLEAN,
+        stdout: `${renderReviewCleanText(cohort)}\n`,
+        stderr: "",
+    };
+}
+export { EXIT_EXTERNAL_ERROR, EXIT_OK, EXIT_UNCLEAN };
+//# sourceMappingURL=verify-review-clean.js.map

package/dist/swarm/worktrees-cli.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+export declare function parseWorktreesArgv(argv: readonly string[]): {
+    mapPath: string;
+    baseBranch: string;
+    repoRoot: string;
+    createMissing: boolean;
+};
+export declare function worktreesMain(argv?: string[]): number;
+//# sourceMappingURL=worktrees-cli.d.ts.map

package/dist/swarm/worktrees-cli.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { loadWorktreeMapFile, resolveWorktreeMap, WorktreeMapConfigError, WorktreeMapError, } from "./worktrees.js";
+export function parseWorktreesArgv(argv) {
+    let mapPath = "";
+    let baseBranch = "";
+    let repoRoot = ".";
+    let createMissing = true;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--map" && argv[i + 1] !== undefined) {
+            mapPath = argv[i + 1] ?? "";
+            i += 1;
+        }
+        else if (arg === "--base-branch" && argv[i + 1] !== undefined) {
+            baseBranch = argv[i + 1] ?? "";
+            i += 1;
+        }
+        else if (arg === "--repo-root" && argv[i + 1] !== undefined) {
+            repoRoot = argv[i + 1] ?? ".";
+            i += 1;
+        }
+        else if (arg === "--no-create-missing") {
+            createMissing = false;
+        }
+    }
+    return { mapPath, baseBranch, repoRoot, createMissing };
+}
+export function worktreesMain(argv = process.argv.slice(2)) {
+    const { mapPath, baseBranch, repoRoot, createMissing } = parseWorktreesArgv(argv);
+    if (mapPath.length === 0 || baseBranch.length === 0) {
+        process.stderr.write("config error: --map and --base-branch are required\n");
+        return 2;
+    }
+    try {
+        const mapping = loadWorktreeMapFile(mapPath);
+        const resolved = resolveWorktreeMap(mapping, baseBranch, createMissing, { repoRoot });
+        process.stdout.write(`${JSON.stringify(resolved, null, 2)}\n`);
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof WorktreeMapError) {
+            process.stderr.write(`error: ${err.message}\n`);
+            return 1;
+        }
+        if (err instanceof WorktreeMapConfigError) {
+            process.stderr.write(`config error: ${String(err)}\n`);
+            return 2;
+        }
+        process.stderr.write(`config error: ${String(err)}\n`);
+        return 2;
+    }
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(worktreesMain());
+}
+//# sourceMappingURL=worktrees-cli.js.map

package/dist/swarm/worktrees.d.ts

@@ -0,0 +1,39 @@
+import { C3_FIELDS } from "./constants.js";
+import { type TextCaptureResult } from "./subprocess.js";
+export declare class WorktreeMapError extends Error {
+    name: string;
+}
+export declare class WorktreeCollisionError extends WorktreeMapError {
+    name: string;
+}
+export declare class BaseBranchMismatchError extends WorktreeMapError {
+    name: string;
+}
+export declare class MissingWorktreeError extends WorktreeMapError {
+    name: string;
+}
+export declare class DuplicateStoryError extends WorktreeMapError {
+    name: string;
+}
+export declare class WorktreeMapConfigError extends Error {
+    name: string;
+}
+export type GitRunner = (args: readonly string[], cwd: string) => TextCaptureResult;
+export declare const defaultGitRunner: GitRunner;
+/** Case-normalized comparison key for worktree-path equality. */
+export declare function compareKey(pathStr: string): string;
+export interface WorktreeRecord {
+    readonly story_id: string;
+    readonly worktree_path: string;
+    readonly base_branch: string;
+}
+/** Parse `git worktree list --porcelain` into `{compareKey: branch|null}`. */
+export declare function parseWorktreePorcelain(text: string): Map<string, string | null>;
+/** Resolve a story-to-worktree mapping into normalized C3 records (frozen contract). */
+export declare function resolveWorktreeMap(mapping: readonly Record<string, unknown>[], baseBranch: string, createMissing?: boolean, options?: {
+    repoRoot?: string;
+    git?: GitRunner;
+}): WorktreeRecord[];
+export declare function loadWorktreeMapFile(mapPath: string): Record<string, unknown>[];
+export { C3_FIELDS };
+//# sourceMappingURL=worktrees.d.ts.map

package/dist/swarm/worktrees.js

@@ -0,0 +1,178 @@
+import { mkdirSync, readFileSync } from "node:fs";
+import { resolve as pathResolve } from "node:path";
+import { C3_FIELDS } from "./constants.js";
+import { runText } from "./subprocess.js";
+export class WorktreeMapError extends Error {
+    name = "WorktreeMapError";
+}
+export class WorktreeCollisionError extends WorktreeMapError {
+    name = "WorktreeCollisionError";
+}
+export class BaseBranchMismatchError extends WorktreeMapError {
+    name = "BaseBranchMismatchError";
+}
+export class MissingWorktreeError extends WorktreeMapError {
+    name = "MissingWorktreeError";
+}
+export class DuplicateStoryError extends WorktreeMapError {
+    name = "DuplicateStoryError";
+}
+export class WorktreeMapConfigError extends Error {
+    name = "WorktreeMapConfigError";
+}
+export const defaultGitRunner = (args, cwd) => runText(["git", ...args], { cwd });
+function resolvePath(raw, repoRoot) {
+    const candidate = raw.startsWith("/") ? raw : pathResolve(repoRoot, raw);
+    return pathResolve(candidate);
+}
+/** Case-normalized comparison key for worktree-path equality. */
+export function compareKey(pathStr) {
+    return pathStr.replace(/\\/g, "/").toLowerCase();
+}
+/** Parse `git worktree list --porcelain` into `{compareKey: branch|null}`. */
+export function parseWorktreePorcelain(text) {
+    const registered = new Map();
+    let currentPath = null;
+    let currentBranch = null;
+    const flush = () => {
+        if (currentPath !== null) {
+            registered.set(compareKey(currentPath), currentBranch);
+        }
+    };
+    for (const line of text.split("\n")) {
+        if (line.startsWith("worktree ")) {
+            flush();
+            currentPath = pathResolve(line.slice("worktree ".length).trim());
+            currentBranch = null;
+        }
+        else if (line.startsWith("branch ")) {
+            const ref = line.slice("branch ".length).trim();
+            currentBranch = ref.startsWith("refs/heads/") ? ref.slice("refs/heads/".length) : ref;
+        }
+    }
+    flush();
+    return registered;
+}
+function gitWorktreeList(repoRoot, git) {
+    let proc;
+    try {
+        proc = git(["worktree", "list", "--porcelain"], repoRoot);
+    }
+    catch (exc) {
+        throw new WorktreeMapConfigError(`could not run \`git worktree list\` in ${repoRoot}: ${String(exc)}`);
+    }
+    if (proc.returncode !== 0) {
+        throw new WorktreeMapConfigError(`\`git worktree list\` failed in ${repoRoot} (rc=${proc.returncode}): ` +
+            `${proc.stderr.trim() || "<no stderr>"} -- is this a git work tree?`);
+    }
+    return parseWorktreePorcelain(proc.stdout);
+}
+function createWorktree(repoRoot, worktreePath, baseBranch, git) {
+    mkdirSync(pathResolve(worktreePath, ".."), { recursive: true });
+    let proc;
+    try {
+        proc = git(["worktree", "add", "--detach", worktreePath, baseBranch], repoRoot);
+    }
+    catch (exc) {
+        throw new WorktreeMapConfigError(`could not run \`git worktree add\` for ${worktreePath}: ${String(exc)}`);
+    }
+    if (proc.returncode !== 0) {
+        throw new WorktreeMapConfigError(`\`git worktree add --detach ${worktreePath} ${baseBranch}\` failed ` +
+            `(rc=${proc.returncode}): ${proc.stderr.trim() || "<no stderr>"}`);
+    }
+}
+/** Resolve a story-to-worktree mapping into normalized C3 records (frozen contract). */
+export function resolveWorktreeMap(mapping, baseBranch, createMissing = true, options = {}) {
+    if (!Array.isArray(mapping)) {
+        throw new WorktreeMapConfigError(`worktree map must be a list of records, got ${typeof mapping}`);
+    }
+    const trimmedBase = baseBranch.trim();
+    if (trimmedBase.length === 0) {
+        throw new WorktreeMapConfigError("base_branch must be a non-empty string");
+    }
+    const root = pathResolve(options.repoRoot ?? process.cwd());
+    const git = options.git ?? defaultGitRunner;
+    const resolved = [];
+    const seenPaths = new Map();
+    const seenStoryIds = new Map();
+    for (let index = 0; index < mapping.length; index += 1) {
+        const record = mapping[index];
+        if (record === null || typeof record !== "object" || Array.isArray(record)) {
+            throw new WorktreeMapConfigError(`record #${index} must be an object, got ${typeof record}`);
+        }
+        const storyIdRaw = record.story_id;
+        if (typeof storyIdRaw !== "string" || storyIdRaw.trim().length === 0) {
+            throw new WorktreeMapConfigError(`record #${index} is missing a non-empty 'story_id'`);
+        }
+        const storyId = storyIdRaw.trim();
+        const rawPath = record.worktree_path;
+        if (typeof rawPath !== "string" || rawPath.trim().length === 0) {
+            throw new WorktreeMapConfigError(`story ${JSON.stringify(storyId)} is missing a non-empty 'worktree_path'`);
+        }
+        const recordBase = record.base_branch;
+        if (recordBase !== undefined && recordBase !== null) {
+            if (typeof recordBase !== "string" || recordBase.trim().length === 0) {
+                throw new WorktreeMapConfigError(`story ${JSON.stringify(storyId)} has a non-string / blank 'base_branch'`);
+            }
+            if (recordBase.trim() !== trimmedBase) {
+                throw new BaseBranchMismatchError(`story '${storyId}' declares base_branch '${recordBase.trim()}' but the cohort base branch is '${trimmedBase}'`);
+            }
+        }
+        const worktreePath = resolvePath(rawPath.trim(), root);
+        const key = compareKey(worktreePath);
+        const posixPath = worktreePath.replace(/\\/g, "/");
+        if (seenPaths.has(key)) {
+            throw new WorktreeCollisionError(`worktree path collision: stories '${seenPaths.get(key)}' and '${storyId}' both map to '${posixPath}'`);
+        }
+        if (seenStoryIds.has(storyId)) {
+            throw new DuplicateStoryError(`duplicate story_id '${storyId}': mapped to both '${seenStoryIds.get(storyId)}' and '${posixPath}'`);
+        }
+        seenPaths.set(key, storyId);
+        seenStoryIds.set(storyId, posixPath);
+        resolved.push({
+            story_id: storyId,
+            worktree_path: posixPath,
+            base_branch: trimmedBase,
+            _key: key,
+            _abs: worktreePath,
+        });
+    }
+    const registered = gitWorktreeList(root, git);
+    for (const entry of resolved) {
+        if (registered.has(entry._key)) {
+            continue;
+        }
+        if (!createMissing) {
+            throw new MissingWorktreeError(`story '${entry.story_id}' maps to '${entry.worktree_path}' which is not a registered git worktree and create_missing is disabled`);
+        }
+        createWorktree(root, entry._abs, trimmedBase, git);
+    }
+    return resolved.map(({ story_id, worktree_path, base_branch }) => ({
+        story_id,
+        worktree_path,
+        base_branch,
+    }));
+}
+export function loadWorktreeMapFile(mapPath) {
+    let raw;
+    try {
+        raw = readFileSync(mapPath, "utf8");
+    }
+    catch (exc) {
+        throw new WorktreeMapConfigError(`could not read worktree map ${mapPath}: ${String(exc)}`);
+    }
+    let data;
+    try {
+        data = JSON.parse(raw);
+    }
+    catch (exc) {
+        const message = exc instanceof Error ? exc.message : String(exc);
+        throw new WorktreeMapConfigError(`worktree map ${mapPath} is not valid JSON: ${message}`);
+    }
+    if (!Array.isArray(data)) {
+        throw new WorktreeMapConfigError(`worktree map ${mapPath} top-level value must be a JSON array`);
+    }
+    return data;
+}
+export { C3_FIELDS };
+//# sourceMappingURL=worktrees.js.map

package/dist/text/redos-safe.d.ts

@@ -0,0 +1,29 @@
+/** Linear-time helpers replacing CodeQL-flagged polynomial regexes (#1810). */
+/** Equivalent of ``value.replace(/[\\/]+$/, "")`` without backtracking. */
+export declare function stripTrailingPathSeparators(value: string): string;
+/** Equivalent of ``value.replace(/^['"]|['"]$/g, "")`` without backtracking. */
+export declare function stripEdgeQuotes(value: string): string;
+/**
+ * Expand compact JSON structural ``:`` / ``,`` to Python ``json.dumps`` spacing
+ * without touching separators inside string literals.
+ */
+export declare function expandPythonJsonSeparators(compactJson: string): string;
+/** Mirrors ``^(#{1,6})\s+(.*\S.*)$`` without polynomial backtracking. */
+export declare function parseMarkdownHeading(line: string): {
+    hashes: string;
+    text: string;
+} | null;
+/** Mirrors doctor ``_SKILL_PATH_RE`` without non-greedy backtracking. */
+export declare function findSkillPathsInText(text: string): string[];
+/** Return the last Greptile ``Last reviewed commit:`` SHA (linear scan). */
+export declare function findLastReviewedCommitSha(body: string): string | null;
+/** Parse a single manifest ``key: value`` line (linear; mirrors MANIFEST_LINE_RE). */
+export declare function parseManifestKeyValueLine(line: string): {
+    key: string;
+    value: string;
+} | null;
+/** Accept OWNER/NAME or a GitHub remote URL with strict host checks. */
+export declare function parseGitHubRepoSlug(value: string): string | null;
+/** Infer owner/name from a git remote URL (strict github.com host; no substring checks). */
+export declare function parseGitHubRemoteRepo(url: string): string | null;
+//# sourceMappingURL=redos-safe.d.ts.map