@deftai/directive-core 0.55.0

package/dist/vbrief-reconcile/reconciliation.js

@@ -0,0 +1,542 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { pyRepr } from "./py-repr.js";
+const DONE_MARKERS = ["[done]", "[x]", "[X]", "\u2713", "\u2705"];
+const WIP_MARKERS = ["[wip]", "[in progress]", "[in-progress]", "[running]", "[active]"];
+const BLOCKED_MARKERS = ["[blocked]"];
+const CANCELLED_MARKERS = ["[cancelled]", "[canceled]"];
+export const OVERRIDES_FILENAME = "migration-overrides.yaml";
+const GITHUB_ISSUE_REF_TYPES = new Set(["github-issue", "x-vbrief/github-issue"]);
+const GITHUB_ISSUE_URI_RE = /https:\/\/github\.com\/[^/]+\/[^/]+\/issues\/(\d+)/;
+const PHASE_TITLE_RE = /^(Phase\s+\d|IP[-\s]\d|Milestone\s+\d)/i;
+const STATUS_TO_FOLDER = {
+    draft: "proposed",
+    proposed: "proposed",
+    approved: "pending",
+    pending: "pending",
+    running: "active",
+    blocked: "active",
+    completed: "completed",
+    cancelled: "cancelled",
+};
+export function detectStatusMarker(text) {
+    if (!text)
+        return null;
+    const lower = text.toLowerCase();
+    if (CANCELLED_MARKERS.some((m) => lower.includes(m.toLowerCase())))
+        return "cancelled";
+    if (BLOCKED_MARKERS.some((m) => lower.includes(m.toLowerCase())))
+        return "blocked";
+    if (DONE_MARKERS.some((m) => text.includes(m) || lower.includes(m.toLowerCase())))
+        return "completed";
+    if (WIP_MARKERS.some((m) => lower.includes(m.toLowerCase())))
+        return "running";
+    return null;
+}
+function stripQuotes(value) {
+    const v = value.trim();
+    if (v.length >= 2 && v[0] === v[v.length - 1] && (v[0] === "'" || v[0] === '"')) {
+        return v.slice(1, -1);
+    }
+    return v;
+}
+function coerceScalar(value) {
+    const v = stripQuotes(value);
+    const lower = v.toLowerCase();
+    if (lower === "true" || lower === "yes" || lower === "on")
+        return true;
+    if (lower === "false" || lower === "no" || lower === "off")
+        return false;
+    if (lower === "null" || lower === "none" || lower === "~" || lower === "")
+        return null;
+    return v;
+}
+export function parseOverridesYaml(text) {
+    const result = {};
+    let currentTask = null;
+    let currentTaskIndent = 0;
+    let inOverrides = false;
+    for (const rawLine of text.split("\n")) {
+        // ReDoS-hardened (#1782 s4 / CodeQL js/polynomial-redos): replace the
+        // `/\s+$/` trailing-strip with String.prototype.trimEnd(), which removes
+        // exactly the JS `\s` set (WhiteSpace + LineTerminator) and so is
+        // byte-identical to the prior regex while being linear-time. Mirrors the
+        // Python oracle's `raw_line.rstrip()`.
+        const line = rawLine.trimEnd();
+        const stripped = line.trimStart();
+        if (!stripped || stripped.startsWith("#"))
+            continue;
+        const indent = line.length - stripped.length;
+        if (indent === 0) {
+            const key = stripped.split(":", 1)[0]?.trim() ?? "";
+            inOverrides = key === "overrides";
+            currentTask = null;
+            currentTaskIndent = 0;
+            continue;
+        }
+        if (!inOverrides)
+            continue;
+        if (stripped.endsWith(":") && !stripped.slice(0, -1).includes(":") && indent >= 2) {
+            currentTask = stripped.slice(0, -1).trim();
+            currentTaskIndent = indent;
+            if (!result[currentTask])
+                result[currentTask] = {};
+            continue;
+        }
+        if (currentTask !== null && stripped.includes(":") && indent > currentTaskIndent) {
+            const colonIdx = stripped.indexOf(":");
+            const key = stripped.slice(0, colonIdx).trim();
+            const value = stripped.slice(colonIdx + 1);
+            const bucket = result[currentTask];
+            if (bucket)
+                bucket[key] = coerceScalar(value);
+        }
+    }
+    return result;
+}
+export function loadOverrides(vbriefDir) {
+    const path = join(vbriefDir, OVERRIDES_FILENAME);
+    if (!existsSync(path))
+        return {};
+    try {
+        return parseOverridesYaml(readFileSync(path, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function normalizeTaskId(taskId) {
+    if (!taskId)
+        return "";
+    const s = taskId.trim();
+    if (s.length >= 2 && (s[0] === "t" || s[0] === "T") && (/\d/.test(s[1] ?? "") || s[1] === ".")) {
+        return s
+            .slice(1)
+            .replace(/^[-.]+/, "")
+            .trim();
+    }
+    return s;
+}
+function collectIssueNumbers(item) {
+    const numbers = [];
+    const refs = item.references;
+    if (!Array.isArray(refs))
+        return numbers;
+    for (const ref of refs) {
+        if (typeof ref !== "object" || ref === null || Array.isArray(ref))
+            continue;
+        const rec = ref;
+        if (!GITHUB_ISSUE_REF_TYPES.has(String(rec.type ?? "")))
+            continue;
+        const uri = rec.uri;
+        if (typeof uri === "string" && uri) {
+            const match = GITHUB_ISSUE_URI_RE.exec(uri);
+            if (match?.[1]) {
+                numbers.push(match[1]);
+                continue;
+            }
+        }
+        const rid = String(rec.id ?? "").replace(/^#/, "");
+        if (rid)
+            numbers.push(rid);
+    }
+    return numbers;
+}
+export function buildSpecTaskIndex(specVbrief) {
+    const index = {};
+    if (!specVbrief || typeof specVbrief !== "object")
+        return index;
+    const plan = specVbrief.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan))
+        return index;
+    const walk = (items, parentPhase) => {
+        if (!Array.isArray(items))
+            return;
+        for (const item of items) {
+            if (typeof item !== "object" || item === null || Array.isArray(item))
+                continue;
+            const rec = item;
+            const title = String(rec.title ?? "");
+            const childPhase = PHASE_TITLE_RE.test(title) ? title : parentPhase;
+            const itemId = String(rec.id ?? "");
+            const entry = { item: rec, specPhase: parentPhase };
+            if (itemId) {
+                if (!index[itemId])
+                    index[itemId] = entry;
+                const normalised = normalizeTaskId(itemId);
+                if (normalised && normalised !== itemId && !index[normalised])
+                    index[normalised] = entry;
+            }
+            for (const num of collectIssueNumbers(rec)) {
+                if (!index[num])
+                    index[num] = entry;
+                if (!index[`#${num}`])
+                    index[`#${num}`] = entry;
+            }
+            walk(rec.subItems, childPhase);
+        }
+    };
+    walk(plan.items, "");
+    return index;
+}
+function pickNarrative(item, ...keys) {
+    const narrative = item.narrative;
+    if (typeof narrative !== "object" || narrative === null || Array.isArray(narrative))
+        return "";
+    const narr = narrative;
+    for (const key of keys) {
+        const value = narr[key];
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return "";
+}
+function specBody(item, defaultVal) {
+    const body = pickNarrative(item, "Description", "Summary", "Body", "Overview");
+    if (body)
+        return body;
+    return String(item.title ?? "").trim() || defaultVal;
+}
+export function hasDisagreement(report) {
+    return Boolean(report.conflicts.length || report.orphans.length || report.overridesTriggered.length);
+}
+function statusFromSpec(entry) {
+    if (!entry)
+        return null;
+    const status = entry.item.status;
+    const valid = new Set([
+        "draft",
+        "proposed",
+        "approved",
+        "pending",
+        "running",
+        "completed",
+        "blocked",
+        "cancelled",
+    ]);
+    if (typeof status === "string" && valid.has(status))
+        return status;
+    return detectStatusMarker(String(entry.item.title ?? ""));
+}
+function roadmapStatus(roadmapItem, completed) {
+    if (completed)
+        return "completed";
+    return detectStatusMarker(String(roadmapItem.title ?? ""));
+}
+function chooseStatus(specEntry, roadmapStat, overrideStatus) {
+    if (overrideStatus)
+        return [overrideStatus, "migration-overrides.yaml", null];
+    const specStatus = statusFromSpec(specEntry);
+    if (roadmapStat) {
+        if (specStatus && specStatus !== roadmapStat) {
+            const conflict = `SPEC status = ${pyRepr(specStatus)}; ` +
+                `ROADMAP status = ${pyRepr(roadmapStat)}; ` +
+                "ROADMAP wins (D3 role policy).";
+            return [roadmapStat, "ROADMAP.md", conflict];
+        }
+        return [roadmapStat, "ROADMAP.md", null];
+    }
+    if (specStatus)
+        return [specStatus, "SPECIFICATION.md (tiebreaker)", null];
+    return ["pending", "default", null];
+}
+function titleConflict(specEntry, roadmapTitle) {
+    const rt = (roadmapTitle || "").trim();
+    if (!specEntry)
+        return [rt, "ROADMAP.md", null, ""];
+    const specTitle = String(specEntry.item.title ?? "").trim();
+    if (!specTitle)
+        return [rt, "ROADMAP.md", null, ""];
+    if (specTitle === rt)
+        return [specTitle, "SPECIFICATION.md", null, ""];
+    const conflict = `SPEC title = ${pyRepr(specTitle)}; ROADMAP title = ${pyRepr(rt)}; ` +
+        "SPEC wins; ROADMAP preserved in narrative.RoadmapSummary.";
+    return [specTitle, "SPECIFICATION.md", conflict, rt];
+}
+function description(specEntry, roadmapTitle, bodySourceOverride) {
+    if (bodySourceOverride === "roadmap")
+        return [(roadmapTitle || "").trim(), "ROADMAP.md (override)"];
+    if (bodySourceOverride === "spec") {
+        if (specEntry)
+            return [specBody(specEntry.item, roadmapTitle), "SPECIFICATION.md (override)"];
+        return [(roadmapTitle || "").trim(), "ROADMAP.md (override fallback: no SPEC match)"];
+    }
+    if (specEntry)
+        return [specBody(specEntry.item, roadmapTitle), "SPECIFICATION.md"];
+    return [(roadmapTitle || "").trim(), "ROADMAP.md"];
+}
+function overrideStatus(override) {
+    if (!override)
+        return null;
+    const status = override.status;
+    return typeof status === "string" && status ? status : null;
+}
+function overrideBodySource(override) {
+    if (!override)
+        return null;
+    const bodySource = override.body_source;
+    if (bodySource === "spec" || bodySource === "roadmap")
+        return bodySource;
+    return null;
+}
+function overrideDrop(override) {
+    return Boolean(override?.drop);
+}
+function taskIdForItem(item, isCompleted) {
+    const number = item.number;
+    if (number)
+        return `#${number}`;
+    const taskId = item.task_id;
+    if (taskId)
+        return String(taskId);
+    const synthetic = item.synthetic_id;
+    if (synthetic)
+        return String(synthetic);
+    const suffix = isCompleted ? "completed" : "active";
+    return `${suffix}:${item.title ?? "untitled"}`;
+}
+function lookupOverride(item, canonicalKey, overrides) {
+    if (!overrides || Object.keys(overrides).length === 0)
+        return [null, null];
+    const candidates = [canonicalKey];
+    const taskId = String(item.task_id ?? "");
+    if (taskId) {
+        const normalised = normalizeTaskId(taskId);
+        candidates.push(taskId, normalised, `t${taskId}`, `t${normalised}`);
+    }
+    const number = String(item.number ?? "");
+    if (number)
+        candidates.push(number, `#${number}`);
+    const synthetic = String(item.synthetic_id ?? "");
+    if (synthetic)
+        candidates.push(synthetic);
+    for (const key of candidates) {
+        if (key && overrides[key])
+            return [overrides[key], key];
+    }
+    return [null, null];
+}
+function matchSpecEntry(item, specIndex) {
+    if (!specIndex || Object.keys(specIndex).length === 0)
+        return null;
+    const number = String(item.number ?? "");
+    if (number) {
+        for (const key of [number, `#${number}`]) {
+            if (specIndex[key])
+                return specIndex[key];
+        }
+    }
+    const taskId = String(item.task_id ?? "");
+    if (taskId) {
+        for (const key of [taskId, normalizeTaskId(taskId), `t${taskId}`]) {
+            if (specIndex[key])
+                return specIndex[key];
+        }
+    }
+    return null;
+}
+export function folderFromStatus(status) {
+    return STATUS_TO_FOLDER[status] ?? "pending";
+}
+export function reconcileScopeItems(options) {
+    const overrides = options.overrides ?? {};
+    const phaseDescriptions = options.phaseDescriptions ?? {};
+    const specIndex = buildSpecTaskIndex(options.specVbrief);
+    const specHasItems = Object.keys(specIndex).length > 0;
+    const reconciled = [];
+    const conflicts = [];
+    const orphans = [];
+    const overridesTriggered = [];
+    const overridesUnused = [];
+    const usedOverrideKeys = new Set();
+    const handle = (item, isCompleted) => {
+        const taskKey = taskIdForItem(item, isCompleted);
+        const [override, matchedKey] = lookupOverride(item, taskKey, overrides);
+        if (override !== null && matchedKey !== null)
+            usedOverrideKeys.add(matchedKey);
+        if (overrideDrop(override)) {
+            overridesTriggered.push({
+                task_id: taskKey,
+                title: String(item.title ?? ""),
+                action: "dropped from migration",
+            });
+            return;
+        }
+        const specEntry = matchSpecEntry(item, specIndex);
+        const [title, titleSource, titleConflictNote, roadmapSummary] = titleConflict(specEntry, String(item.title ?? ""));
+        const [desc, descriptionSource] = description(specEntry, String(item.title ?? ""), overrideBodySource(override));
+        const roadmapStat = roadmapStatus(item, isCompleted);
+        let [status, statusSource, statusConflict] = chooseStatus(specEntry, roadmapStat, overrideStatus(override));
+        let sourceConflict = "";
+        let folder;
+        if (specHasItems && specEntry === null) {
+            sourceConflict = "missing-from-spec";
+            if (isCompleted) {
+                folder = "completed";
+                status = "completed";
+                statusSource = "orphan: ROADMAP Completed section (#593)";
+            }
+            else {
+                folder = "proposed";
+                status = "proposed";
+                statusSource = "orphan: proposed default";
+            }
+            orphans.push({ task_id: taskKey, title: title || String(item.title ?? "") });
+        }
+        else {
+            folder = folderFromStatus(status);
+        }
+        const phase = String(item.phase ?? "");
+        const tier = String(item.tier ?? "");
+        const phaseDesc = phase ? (phaseDescriptions[phase] ?? "") : "";
+        const specPhase = specEntry?.specPhase ?? "";
+        const sourceSection = isCompleted ? "ROADMAP Completed section" : "ROADMAP active phase";
+        reconciled.push({
+            task_id: taskKey,
+            number: String(item.number ?? ""),
+            title,
+            title_source: titleConflictNote ? titleSource : "",
+            description: desc,
+            description_source: descriptionSource,
+            status,
+            status_source: statusSource,
+            folder,
+            phase,
+            phase_description: phaseDesc,
+            tier,
+            spec_phase: specPhase !== phase ? specPhase : "",
+            roadmap_summary: roadmapSummary,
+            source_conflict: sourceConflict,
+            source_section: sourceSection,
+            is_completed: isCompleted,
+            override_applied: override !== null,
+            synthetic_id: String(item.synthetic_id ?? ""),
+            original_task_id: String(item.task_id ?? ""),
+        });
+        const dims = [];
+        if (titleConflictNote) {
+            dims.push({
+                dimension: "TITLE drift",
+                spec: specEntry ? String(specEntry.item.title ?? "") : "",
+                roadmap: String(item.title ?? ""),
+                resolution: titleConflictNote,
+            });
+        }
+        if (statusConflict) {
+            dims.push({
+                dimension: "STATUS conflict",
+                spec: specEntry ? statusFromSpec(specEntry) || "(none)" : "(no match)",
+                roadmap: roadmapStat || "(none)",
+                resolution: statusConflict,
+            });
+        }
+        const triggeredFields = [];
+        if (override !== null) {
+            for (const key of ["status", "body_source"]) {
+                if (key in override)
+                    triggeredFields.push(key);
+            }
+            if (override.drop)
+                triggeredFields.push("drop");
+            if (triggeredFields.length > 0) {
+                overridesTriggered.push({
+                    task_id: taskKey,
+                    title,
+                    fields: triggeredFields.join(", "),
+                });
+            }
+        }
+        if (dims.length > 0 || triggeredFields.length > 0) {
+            conflicts.push({
+                taskId: taskKey,
+                title: title || String(item.title ?? ""),
+                dimensions: dims,
+                overridesApplied: triggeredFields,
+            });
+        }
+    };
+    for (const item of options.roadmapActive)
+        handle(item, false);
+    for (const item of options.roadmapCompleted)
+        handle(item, true);
+    for (const key of Object.keys(overrides)) {
+        if (!usedOverrideKeys.has(key))
+            overridesUnused.push(key);
+    }
+    return [reconciled, { conflicts, orphans, overridesTriggered, overridesUnused }];
+}
+function formatConflictEntry(entry) {
+    const lines = [`## ${entry.taskId} -- ${entry.title}`, ""];
+    for (const dim of entry.dimensions) {
+        lines.push(`- ${dim.dimension}`);
+        if (dim.spec)
+            lines.push(`  - SPEC: ${dim.spec}`);
+        if (dim.roadmap)
+            lines.push(`  - ROADMAP: ${dim.roadmap}`);
+        lines.push(`  - Resolution: ${dim.resolution}`);
+    }
+    if (entry.overridesApplied.length > 0) {
+        lines.push(`- Overrides applied: ${entry.overridesApplied.join(", ")} (migration-overrides.yaml)`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+export function formatReconciliationMarkdown(report, now = new Date()) {
+    const timestamp = now.toISOString().replace(/\.\d{3}Z$/, "Z");
+    const parts = [
+        "# Migration reconciliation report",
+        "",
+        `Generated: ${timestamp}`,
+        "",
+        "Per #496 this file is emitted whenever SPECIFICATION.md and ROADMAP.md " +
+            "disagreed on any dimension during `task migrate:vbrief`, or when any " +
+            "override from `vbrief/migration-overrides.yaml` triggered.",
+        "",
+    ];
+    parts.push("## Per-task conflicts", "");
+    if (report.conflicts.length > 0) {
+        for (const entry of report.conflicts)
+            parts.push(formatConflictEntry(entry));
+    }
+    else {
+        parts.push("(none)", "");
+    }
+    parts.push("## Orphans in ROADMAP (no matching SPEC task)", "");
+    if (report.orphans.length > 0) {
+        for (const orph of report.orphans) {
+            parts.push(`- \`${orph.task_id}\` -- ${orph.title}`, '  - Resolution: emitted to vbrief/proposed/ with narrative.SourceConflict = "missing-from-spec".');
+        }
+    }
+    else {
+        parts.push("(none)");
+    }
+    parts.push("");
+    parts.push("## Overrides applied (vbrief/migration-overrides.yaml)", "");
+    if (report.overridesTriggered.length > 0) {
+        for (const ov of report.overridesTriggered) {
+            const fields = ov.fields ?? ov.action ?? "";
+            parts.push(`- \`${ov.task_id}\` -- ${ov.title ?? ""}: ${fields}`);
+        }
+    }
+    else {
+        parts.push("(none)");
+    }
+    parts.push("");
+    if (report.overridesUnused.length > 0) {
+        parts.push("## Overrides defined but not triggered", "");
+        for (const key of report.overridesUnused)
+            parts.push(`- \`${key}\``);
+        parts.push("");
+    }
+    return `${parts.join("\n").trimEnd()}\n`;
+}
+export function writeReconciliationReport(report, vbriefDir, now) {
+    if (!hasDisagreement(report))
+        return null;
+    const targetDir = join(vbriefDir, "migration");
+    mkdirSync(targetDir, { recursive: true });
+    const target = join(targetDir, "RECONCILIATION.md");
+    writeFileSync(target, formatReconciliationMarkdown(report, now), "utf8");
+    return target;
+}
+//# sourceMappingURL=reconciliation.js.map

package/dist/vbrief-reconcile/swarm-deps.d.ts

@@ -0,0 +1,8 @@
+import type { Candidate } from "./types.js";
+export declare const LIFECYCLE_FOLDERS: readonly ["proposed", "pending", "active", "completed", "cancelled"];
+export declare function asStrList(value: unknown): string[];
+export declare function allScopeIds(projectRoot: string): Record<string, [string, string]>;
+export declare function candidateFromPath(path: string, _projectRoot: string): Candidate | null;
+export declare function candidateDepGraph(candidates: Candidate[], knownIds: Record<string, [string, string]>): Record<string, string[]>;
+export declare function markCycles(candidates: Candidate[], graph: Record<string, string[]>): void;
+//# sourceMappingURL=swarm-deps.d.ts.map

package/dist/vbrief-reconcile/swarm-deps.js

@@ -0,0 +1,142 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { pyRepr } from "./py-repr.js";
+export const LIFECYCLE_FOLDERS = [
+    "proposed",
+    "pending",
+    "active",
+    "completed",
+    "cancelled",
+];
+export function asStrList(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((v) => typeof v === "string");
+}
+function loadJson(path) {
+    try {
+        const data = JSON.parse(readFileSync(path, "utf8"));
+        return typeof data === "object" && data !== null && !Array.isArray(data)
+            ? data
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function planOf(data) {
+    const plan = data.plan;
+    return typeof plan === "object" && plan !== null && !Array.isArray(plan)
+        ? plan
+        : {};
+}
+function metadataOf(plan) {
+    const metadata = plan.metadata;
+    return typeof metadata === "object" && metadata !== null && !Array.isArray(metadata)
+        ? metadata
+        : {};
+}
+function swarmOf(metadata) {
+    const swarm = metadata.swarm;
+    return typeof swarm === "object" && swarm !== null && !Array.isArray(swarm)
+        ? swarm
+        : {};
+}
+function storyId(path, plan) {
+    const value = plan.id;
+    if (typeof value === "string" && value.trim())
+        return value.trim();
+    const name = path.split(/[/\\]/).pop() ?? "";
+    return name.endsWith(".vbrief.json") ? name.slice(0, -".vbrief.json".length) : name;
+}
+export function allScopeIds(projectRoot) {
+    const ids = {};
+    const vbriefDir = join(resolve(projectRoot), "vbrief");
+    for (const folder of LIFECYCLE_FOLDERS) {
+        const folderPath = join(vbriefDir, folder);
+        if (!existsSync(folderPath))
+            continue;
+        const files = readdirSync(folderPath)
+            .filter((f) => f.endsWith(".vbrief.json"))
+            .sort();
+        for (const file of files) {
+            const path = join(folderPath, file);
+            const data = loadJson(path);
+            if (!data)
+                continue;
+            const plan = planOf(data);
+            const scopeId = storyId(path, plan);
+            const status = String(plan.status ?? "");
+            ids[scopeId] = [path, status];
+            const stem = file.endsWith(".vbrief.json") ? file.slice(0, -".vbrief.json".length) : file;
+            if (!ids[stem])
+                ids[stem] = [path, status];
+        }
+    }
+    return ids;
+}
+export function candidateFromPath(path, _projectRoot) {
+    const data = loadJson(path);
+    if (!data)
+        return null;
+    const plan = planOf(data);
+    const metadata = metadataOf(plan);
+    const swarm = swarmOf(metadata);
+    return {
+        path,
+        storyId: storyId(path, plan),
+        status: String(plan.status ?? ""),
+        swarm,
+        blocked: [],
+    };
+}
+export function candidateDepGraph(candidates, knownIds) {
+    const candidateIds = new Set(candidates.map((c) => c.storyId));
+    const graph = {};
+    for (const cand of candidates) {
+        const deps = [];
+        for (const dep of asStrList(cand.swarm.depends_on)) {
+            if (candidateIds.has(dep)) {
+                deps.push(dep);
+                continue;
+            }
+            const known = knownIds[dep];
+            if (!known)
+                continue;
+            const [, depStatus] = known;
+            if (!["completed", "failed", "cancelled"].includes(depStatus)) {
+                cand.blocked.push(`dependency ${pyRepr(dep)} is not completed or a candidate`);
+            }
+        }
+        graph[cand.storyId] = deps;
+    }
+    return graph;
+}
+export function markCycles(candidates, graph) {
+    const byId = Object.fromEntries(candidates.map((c) => [c.storyId, c]));
+    const visiting = new Set();
+    const visited = new Set();
+    const visit = (storyId, path) => {
+        if (visited.has(storyId))
+            return;
+        if (visiting.has(storyId)) {
+            const start = path.indexOf(storyId);
+            const cycle = [...path.slice(start >= 0 ? start : 0), storyId];
+            const message = `dependency cycle: ${cycle.join(" -> ")}`;
+            for (const node of cycle) {
+                const cand = byId[node];
+                if (cand && !cand.blocked.includes(message))
+                    cand.blocked.push(message);
+            }
+            return;
+        }
+        visiting.add(storyId);
+        for (const dep of graph[storyId] ?? [])
+            visit(dep, [...path, storyId]);
+        visiting.delete(storyId);
+        visited.add(storyId);
+    };
+    for (const cand of candidates)
+        visit(cand.storyId, []);
+}
+//# sourceMappingURL=swarm-deps.js.map