@isaacriehm/cairn-core 0.1.0

package/dist/session-start/build.js

@@ -0,0 +1,645 @@
+/**
+ * `buildSessionStartContext` — composes the SessionStart payload from
+ * a cairn-adopted repo's state. Read-only; no side effects beyond
+ * filesystem reads.
+ */
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { buildHandoffBlock } from "../context/index.js";
+import { buildDecisionsLedger, buildInvariantsLedger, parseFrontmatter, } from "../ground/index.js";
+import { loadSensorRegistry } from "../sensors/catalog.js";
+import { SESSION_START_HEADER, TOOL_QUICK_REFERENCE, TWO_ZONE_REMINDER_BASE, } from "./templates.js";
+const DEFAULT_MAX_CHARS = 12_000;
+const DECISIONS_CAP = 15;
+const INVARIANTS_CAP = 10;
+const DRAFTS_CAP = 5;
+const QUALITY_TAIL_CAP = 3;
+const TASK_BODY_CAP = 800;
+/**
+ * Walk up from `cwd` looking for a `.cairn/` directory. Returns the
+ * dir containing it (the repo root) or null if none found within 12
+ * ancestors.
+ */
+export function resolveRepoRoot(cwd) {
+    let dir = resolve(cwd);
+    for (let i = 0; i < 12; i++) {
+        if (existsSync(join(dir, ".cairn")) && statSync(join(dir, ".cairn")).isDirectory()) {
+            return dir;
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+    return null;
+}
+export async function buildSessionStartContext(args) {
+    const maxChars = args.maxChars ?? DEFAULT_MAX_CHARS;
+    const includeToolReference = args.includeToolReference !== false;
+    const queryHistoryAvailable = args.queryHistoryAvailable !== false;
+    const warnings = [];
+    const counts = {
+        decisions: 0,
+        invariants: 0,
+        pendingDrafts: 0,
+        qualityGrades: 0,
+        activeTasks: 0,
+    };
+    const sectionsRendered = [];
+    const sectionsDropped = [];
+    // ── Section 0 — run handoff (CONTEXT_CONTINUITY_SPEC §4) ─────────────
+    // Inject the prior-run handoff block when the hook source indicates a
+    // boundary that benefits from it. `null` → no in-flight run / no
+    // commits since sha_pin → section omitted entirely.
+    let runHandoffSection = null;
+    if (args.source === "resume" || args.source === "compact" || args.source === "startup") {
+        try {
+            runHandoffSection = await buildHandoffBlock(args.repoRoot);
+        }
+        catch (err) {
+            warnings.push(`handoff builder failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    const fixedHeader = SESSION_START_HEADER;
+    const fixedTwoZone = composeTwoZoneReminder(queryHistoryAvailable);
+    const fixedToolReference = TOOL_QUICK_REFERENCE;
+    // ── Section 2 — decisions in scope ─────────────────────────────────
+    const decisionEntries = safeBuildDecisionsLedger(args.repoRoot, warnings);
+    counts.decisions = decisionEntries.length;
+    const filteredDecisions = filterDecisionsToScope(decisionEntries, args.scopeRelPath);
+    const decisionsSection = renderDecisionsSection(filteredDecisions);
+    // ── Section 3 — invariants active ──────────────────────────────────
+    const invariantEntries = safeBuildInvariantsLedger(args.repoRoot, warnings);
+    counts.invariants = invariantEntries.length;
+    const decisionScopeById = scopeMapFromDecisions(decisionEntries);
+    const filteredInvariants = filterInvariantsToScope(invariantEntries, decisionScopeById, args.scopeRelPath);
+    const invariantsSection = renderInvariantsSection(filteredInvariants);
+    // ── Section 4 — current task ───────────────────────────────────────
+    const tasks = listActiveTasks(args.repoRoot);
+    counts.activeTasks = tasks.length;
+    const currentTaskSection = renderCurrentTaskSection(args.repoRoot, tasks);
+    // ── Section 5 — quality grades ─────────────────────────────────────
+    const grades = readQualityGrades(args.repoRoot, warnings);
+    counts.qualityGrades = grades.length;
+    const qualityGradesSection = renderQualityGradesSection(grades);
+    // ── Section 6 — pending drafts ─────────────────────────────────────
+    const drafts = listPendingDrafts(args.repoRoot, warnings);
+    counts.pendingDrafts = drafts.length;
+    const pendingDraftsSection = renderPendingDraftsSection(drafts);
+    // ── Section 1.5 — brand + product positioning (always injected) ───
+    const brandAndPositioningSection = readBrandAndPositioning(args.repoRoot, warnings);
+    // ── First-session onboarding block (Phase 6.6) ────────────────────
+    // Fires once: decisions_count === 0 AND invariants_count === 0 AND a
+    // baseline audit yaml exists. After the first DEC is accepted, the
+    // condition no longer holds and this section disappears for good.
+    let firstSessionOnboardingSection = null;
+    if (counts.decisions === 0 && counts.invariants === 0) {
+        firstSessionOnboardingSection = renderFirstSessionOnboarding({
+            repoRoot: args.repoRoot,
+            pendingDrafts: counts.pendingDrafts,
+            warnings,
+        });
+    }
+    // Truncation strategy per spec: always include 1 + 7; then 4, 2, 3,
+    // 6, 5; drop in reverse order if over cap.
+    const orderedSections = [];
+    if (firstSessionOnboardingSection !== null) {
+        orderedSections.push({
+            id: "first_session_onboarding",
+            body: firstSessionOnboardingSection,
+        });
+    }
+    if (runHandoffSection !== null) {
+        orderedSections.push({ id: "run_handoff", body: runHandoffSection });
+    }
+    orderedSections.push({ id: "header", body: fixedHeader });
+    orderedSections.push({ id: "two_zone_reminder", body: fixedTwoZone });
+    if (brandAndPositioningSection !== null) {
+        orderedSections.push({ id: "brand_and_positioning", body: brandAndPositioningSection });
+    }
+    if (includeToolReference) {
+        orderedSections.push({ id: "tool_quick_reference", body: fixedToolReference });
+    }
+    else {
+        sectionsDropped.push("tool_quick_reference");
+    }
+    if (currentTaskSection !== null) {
+        orderedSections.push({ id: "current_task", body: currentTaskSection });
+    }
+    if (decisionsSection !== null) {
+        orderedSections.push({ id: "decisions_in_scope", body: decisionsSection });
+    }
+    if (invariantsSection !== null) {
+        orderedSections.push({ id: "invariants_active", body: invariantsSection });
+    }
+    if (pendingDraftsSection !== null) {
+        orderedSections.push({ id: "pending_drafts", body: pendingDraftsSection });
+    }
+    if (qualityGradesSection !== null) {
+        orderedSections.push({ id: "quality_grades_tail", body: qualityGradesSection });
+    }
+    // Greedy fill within budget; dropping in reverse order lets us keep
+    // the load-bearing sections (header / reminder / tools) while
+    // shedding optional context first.
+    const dropPriority = [
+        "quality_grades_tail",
+        "pending_drafts",
+        "brand_and_positioning",
+        "invariants_active",
+        "decisions_in_scope",
+        "current_task",
+        "tool_quick_reference",
+        "two_zone_reminder",
+        "header",
+        "run_handoff",
+        "first_session_onboarding",
+    ];
+    let kept = orderedSections.slice();
+    while (computeTotalChars(kept) > maxChars && kept.length > 0) {
+        let dropped = false;
+        for (const candidate of dropPriority) {
+            const idx = kept.findIndex((s) => s.id === candidate);
+            if (idx !== -1) {
+                sectionsDropped.push(candidate);
+                kept.splice(idx, 1);
+                dropped = true;
+                break;
+            }
+        }
+        if (!dropped)
+            break;
+    }
+    for (const s of kept)
+        sectionsRendered.push(s.id);
+    // Anything in orderedSections that ended up not in `kept` is in
+    // sectionsDropped above; deduplicate while preserving order.
+    const seenDropped = new Set(sectionsDropped);
+    for (const s of orderedSections) {
+        if (!sectionsRendered.includes(s.id) && !seenDropped.has(s.id)) {
+            sectionsDropped.push(s.id);
+            seenDropped.add(s.id);
+        }
+    }
+    const additionalContext = kept.map((s) => s.body).join("\n\n");
+    return {
+        additionalContext,
+        sectionsRendered,
+        sectionsDropped,
+        totalChars: additionalContext.length,
+        counts,
+        warnings,
+    };
+}
+function composeTwoZoneReminder(queryHistoryAvailable) {
+    if (queryHistoryAvailable)
+        return TWO_ZONE_REMINDER_BASE;
+    return `${TWO_ZONE_REMINDER_BASE}
+
+NOTE: cairn_query_history is not registered in this project's MCP
+configuration; archive reads are unreachable. Use cairn_decision_get
+or cairn_canonical_for_topic for current-canonical access only.`;
+}
+function readBrandAndPositioning(repoRoot, warnings) {
+    const brandPath = join(repoRoot, ".cairn", "ground", "brand", "overview.md");
+    const positioningPath = join(repoRoot, ".cairn", "ground", "product", "positioning.md");
+    const parts = [];
+    for (const [label, path] of [
+        ["Brand overview", brandPath],
+        ["Product positioning", positioningPath],
+    ]) {
+        if (!existsSync(path))
+            continue;
+        try {
+            const text = readFileSync(path, "utf8");
+            const parsed = parseFrontmatter(text);
+            const fm = (parsed.frontmatter ?? {});
+            const status = typeof fm["status"] === "string" ? fm["status"] : null;
+            const body = parsed.body.trim();
+            if (body.length === 0)
+                continue;
+            const draftHint = status === "draft"
+                ? "  [DRAFT — operator has not filled this in; ask before making design decisions]"
+                : "";
+            parts.push(`### ${label}${draftHint}\n\n${body}`);
+        }
+        catch (err) {
+            warnings.push(`${label} read failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (parts.length === 0)
+        return null;
+    return `## Brand and product context\n\n${parts.join("\n\n")}`;
+}
+function computeTotalChars(sections) {
+    return sections.reduce((sum, s) => sum + s.body.length + 2, 0);
+}
+function safeBuildDecisionsLedger(repoRoot, warnings) {
+    try {
+        return buildDecisionsLedger({ repoRoot });
+    }
+    catch (err) {
+        warnings.push(`decisions ledger read failed: ${err instanceof Error ? err.message : String(err)}`);
+        return [];
+    }
+}
+function safeBuildInvariantsLedger(repoRoot, warnings) {
+    try {
+        return buildInvariantsLedger({ repoRoot });
+    }
+    catch (err) {
+        warnings.push(`invariants ledger read failed: ${err instanceof Error ? err.message : String(err)}`);
+        return [];
+    }
+}
+function scopeMapFromDecisions(decisions) {
+    const out = new Map();
+    for (const d of decisions) {
+        if (d.scope_globs && d.scope_globs.length > 0)
+            out.set(d.id, d.scope_globs);
+    }
+    return out;
+}
+function filterDecisionsToScope(decisions, scopeRelPath) {
+    if (!scopeRelPath || scopeRelPath.length === 0 || scopeRelPath === ".")
+        return decisions;
+    const filtered = decisions.filter((d) => {
+        const globs = d.scope_globs ?? [];
+        if (globs.length === 0)
+            return true;
+        return globs.some((g) => relPathOverlapsGlob(scopeRelPath, g));
+    });
+    return filtered.length > 0 ? filtered : decisions;
+}
+function filterInvariantsToScope(invariants, decisionScopeById, scopeRelPath) {
+    if (!scopeRelPath || scopeRelPath.length === 0 || scopeRelPath === ".")
+        return invariants;
+    const filtered = invariants.filter((inv) => {
+        if (!inv.source_decision)
+            return true;
+        const globs = decisionScopeById.get(inv.source_decision);
+        if (!globs || globs.length === 0)
+            return true;
+        return globs.some((g) => relPathOverlapsGlob(scopeRelPath, g));
+    });
+    return filtered.length > 0 ? filtered : invariants;
+}
+function relPathOverlapsGlob(relPath, glob) {
+    const globPrefix = glob.replace(/\*\*.*$/, "").replace(/\*+$/, "");
+    if (globPrefix.length === 0)
+        return true;
+    return relPath.startsWith(globPrefix) || globPrefix.startsWith(relPath);
+}
+function renderDecisionsSection(decisions) {
+    if (decisions.length === 0)
+        return null;
+    const lines = [];
+    lines.push(`## Decisions in scope (${decisions.length} accepted)`);
+    lines.push("");
+    const slice = decisions.slice(0, DECISIONS_CAP);
+    for (const d of slice) {
+        const scope = d.scope_globs && d.scope_globs.length > 0 ? d.scope_globs.join(", ") : "(no scope)";
+        const supersedes = d.supersedes ? d.supersedes : "—";
+        lines.push(`- **${d.id}** — ${d.title}`);
+        lines.push(`  status: ${d.status}; scope: ${scope}; supersedes: ${supersedes}`);
+    }
+    if (decisions.length > DECISIONS_CAP) {
+        lines.push(`…${decisions.length - DECISIONS_CAP} additional decision${decisions.length - DECISIONS_CAP === 1 ? "" : "s"} — call \`cairn_decisions_in_scope(globs[])\` for the rest.`);
+    }
+    return lines.join("\n");
+}
+function renderInvariantsSection(invariants) {
+    if (invariants.length === 0)
+        return null;
+    const lines = [];
+    lines.push(`## §V invariants active (${invariants.length})`);
+    lines.push("");
+    const slice = invariants.slice(0, INVARIANTS_CAP);
+    for (const inv of slice) {
+        lines.push(`- **${inv.id}** — ${inv.title}  source_decision: ${inv.source_decision ?? "(none)"}`);
+    }
+    if (invariants.length > INVARIANTS_CAP) {
+        lines.push(`…${invariants.length - INVARIANTS_CAP} additional — call \`cairn_invariants_in_scope(globs[])\`.`);
+    }
+    return lines.join("\n");
+}
+function listActiveTasks(repoRoot) {
+    const dir = join(repoRoot, ".cairn", "tasks", "active");
+    if (!existsSync(dir))
+        return [];
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true, encoding: "utf8" });
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const e of entries) {
+        if (!e.isDirectory())
+            continue;
+        const candidates = [
+            join(dir, e.name, "spec.tightened.md"),
+            join(dir, e.name, "spec.md"),
+        ];
+        let target = null;
+        for (const c of candidates) {
+            if (existsSync(c)) {
+                target = c;
+                break;
+            }
+        }
+        if (!target)
+            continue;
+        let text = "";
+        let mtime = 0;
+        try {
+            text = readFileSync(target, "utf8");
+            mtime = statSync(target).mtimeMs;
+        }
+        catch {
+            continue;
+        }
+        const parsed = parseFrontmatter(text);
+        const fm = (parsed.frontmatter ?? {});
+        const status = typeof fm["status"] === "string" ? fm["status"] : null;
+        out.push({
+            id: e.name,
+            specPath: target.startsWith(repoRoot) ? target.slice(repoRoot.length + 1) : target,
+            specBody: parsed.body,
+            status,
+            mtime,
+        });
+    }
+    out.sort((a, b) => b.mtime - a.mtime);
+    return out;
+}
+function renderCurrentTaskSection(_repoRoot, tasks) {
+    if (tasks.length === 0)
+        return null;
+    const lines = [];
+    if (tasks.length === 1) {
+        const t = tasks[0];
+        if (t === undefined)
+            return null;
+        lines.push("## Current task");
+        lines.push("");
+        lines.push(`ID: ${t.id}`);
+        if (t.status !== null)
+            lines.push(`Status: ${t.status}`);
+        lines.push(`Path: ${t.specPath.replace(/\\/g, "/")}`);
+        lines.push("");
+        const body = t.specBody.trim();
+        const cap = body.length > TASK_BODY_CAP
+            ? `${body.slice(0, TASK_BODY_CAP).trimEnd()}\n…[truncated; full spec via cairn_get_full({id, kind:"task"})]`
+            : body;
+        lines.push(cap);
+        return lines.join("\n");
+    }
+    lines.push(`## Active tasks (${tasks.length})`);
+    lines.push("");
+    for (const t of tasks.slice(0, 8)) {
+        const titleMatch = t.specBody.match(/^#\s+(.+)$/m);
+        const title = titleMatch?.[1] ?? t.id;
+        lines.push(`- **${t.id}** — ${title}  status: ${t.status ?? "(unknown)"}`);
+    }
+    if (tasks.length > 8)
+        lines.push(`…${tasks.length - 8} more.`);
+    lines.push("");
+    lines.push("Multiple active tasks; call `cairn_get_full({id, kind:\"task\"})` to read any.");
+    return lines.join("\n");
+}
+function readQualityGrades(repoRoot, warnings) {
+    const path = join(repoRoot, ".cairn", "ground", "quality-grades.yaml");
+    if (!existsSync(path))
+        return [];
+    let parsed;
+    try {
+        parsed = parseYaml(readFileSync(path, "utf8"));
+    }
+    catch (err) {
+        warnings.push(`quality-grades.yaml unparseable: ${err instanceof Error ? err.message : String(err)}`);
+        return [];
+    }
+    if (typeof parsed !== "object" || parsed === null)
+        return [];
+    const modulesRaw = parsed.modules;
+    if (!Array.isArray(modulesRaw))
+        return [];
+    const out = [];
+    for (const m of modulesRaw) {
+        if (typeof m !== "object" || m === null)
+            continue;
+        const mm = m;
+        if (typeof mm["module"] !== "string")
+            continue;
+        if (typeof mm["score"] !== "number")
+            continue;
+        out.push({
+            module: mm["module"],
+            score: mm["score"],
+            pass_rate: typeof mm["pass_rate"] === "number" ? mm["pass_rate"] : 0,
+            drift_count: typeof mm["drift_count"] === "number" ? mm["drift_count"] : 0,
+        });
+    }
+    out.sort((a, b) => a.score - b.score);
+    return out;
+}
+function renderQualityGradesSection(grades) {
+    if (grades.length === 0)
+        return null;
+    const tail = grades.slice(0, QUALITY_TAIL_CAP);
+    const lines = [];
+    lines.push(`## Quality grades — weakest module${tail.length === 1 ? "" : "s"}`);
+    lines.push("");
+    for (const g of tail) {
+        lines.push(`- ${g.module}: score ${g.score}/100, pass_rate ${g.pass_rate.toFixed(2)}, drift_count ${g.drift_count}`);
+    }
+    return lines.join("\n");
+}
+function listPendingDrafts(repoRoot, warnings) {
+    const dir = join(repoRoot, ".cairn", "ground", "decisions", "_inbox");
+    if (!existsSync(dir))
+        return [];
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true, encoding: "utf8" });
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const e of entries) {
+        if (!e.isFile())
+            continue;
+        if (!e.name.endsWith(".draft.md"))
+            continue;
+        const abs = join(dir, e.name);
+        let text;
+        try {
+            text = readFileSync(abs, "utf8");
+        }
+        catch (err) {
+            warnings.push(`draft ${e.name} unreadable: ${err instanceof Error ? err.message : String(err)}`);
+            continue;
+        }
+        const parsed = parseFrontmatter(text);
+        const fm = (parsed.frontmatter ?? {});
+        const id = typeof fm["id"] === "string" ? fm["id"] : e.name.replace(/\.draft\.md$/, "");
+        const title = typeof fm["title"] === "string" ? fm["title"] : "(untitled draft)";
+        const captureSource = typeof fm["capture_source"] === "string" ? fm["capture_source"] : null;
+        const decidedAt = typeof fm["decided_at"] === "string" ? fm["decided_at"] : null;
+        out.push({ id, title, capture_source: captureSource, decided_at: decidedAt });
+    }
+    out.sort((a, b) => a.id.localeCompare(b.id));
+    return out;
+}
+function renderFirstSessionOnboarding(args) {
+    const audit = readLatestBaselineAudit(args.repoRoot, args.warnings);
+    if (audit === null)
+        return null;
+    const projectName = readProjectSlug(args.repoRoot) ?? basename(args.repoRoot);
+    const minutesAgo = audit.runAt !== null ? minutesSince(audit.runAt) : null;
+    const sensorIds = readActiveSensorIds(args.repoRoot, args.warnings);
+    const lines = [];
+    lines.push(`⬡ Cairn active — ${projectName}`);
+    lines.push("");
+    if (minutesAgo !== null) {
+        lines.push(`  This project was adopted ${humanizeMinutes(minutesAgo)}. Project brain is new.`);
+    }
+    else {
+        lines.push("  This project was adopted recently. Project brain is new.");
+    }
+    lines.push("");
+    if (sensorIds.length > 0) {
+        const head = sensorIds.slice(0, 3).join(" · ");
+        const more = sensorIds.length > 3
+            ? ` + ${sensorIds.length - 3} more`
+            : "";
+        lines.push("  Sensors active (run on complete diff after you emit attestation.yaml):");
+        lines.push(`    ${head}${more}`);
+        lines.push("");
+    }
+    if (audit.totalFindings > 0) {
+        lines.push(`  Baseline debt: ${audit.totalFindings} pre-Cairn violation${audit.totalFindings === 1 ? "" : "s"} found in existing code.`);
+        lines.push("  Run `cairn attention` to review before starting work.");
+        lines.push("");
+    }
+    else {
+        lines.push(`  Baseline scan ran clean — no pre-Cairn violations on ${audit.filesScanned} source file${audit.filesScanned === 1 ? "" : "s"}.`);
+        lines.push("");
+    }
+    if (args.pendingDrafts > 0) {
+        lines.push(`  DEC drafts awaiting review: ${args.pendingDrafts}`);
+        lines.push("  Run `cairn attention` to confirm or discard.");
+        lines.push("");
+    }
+    lines.push("  To capture a decision during this session: /direction <your instruction>");
+    return lines.join("\n");
+}
+function readLatestBaselineAudit(repoRoot, warnings) {
+    const dir = join(repoRoot, ".cairn", "baseline");
+    if (!existsSync(dir))
+        return null;
+    let entries;
+    try {
+        entries = readdirSync(dir, { encoding: "utf8" });
+    }
+    catch (err) {
+        warnings.push(`baseline dir read failed: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+    const matching = entries
+        .filter((name) => /^sensor-audit-.*\.yaml$/.test(name))
+        .sort();
+    const latest = matching.at(-1);
+    if (latest === undefined)
+        return null;
+    const abs = join(dir, latest);
+    try {
+        const parsed = parseYaml(readFileSync(abs, "utf8"));
+        const runAt = typeof parsed["run_at"] === "string" ? parsed["run_at"] : null;
+        const totalFindings = typeof parsed["total_findings"] === "number"
+            ? parsed["total_findings"]
+            : 0;
+        const filesScanned = typeof parsed["files_scanned"] === "number"
+            ? parsed["files_scanned"]
+            : 0;
+        return { runAt, totalFindings, filesScanned };
+    }
+    catch (err) {
+        warnings.push(`baseline audit unreadable: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
+function readActiveSensorIds(repoRoot, warnings) {
+    try {
+        const reg = loadSensorRegistry(repoRoot);
+        const disabled = new Set(reg.disabled_per_project ?? []);
+        return reg.sensors
+            .map((s) => s.id)
+            .filter((id) => id.length > 0)
+            .filter((id) => !disabled.has(id));
+    }
+    catch (err) {
+        warnings.push(`sensor registry read failed: ${err instanceof Error ? err.message : String(err)}`);
+        return [];
+    }
+}
+function readProjectSlug(repoRoot) {
+    const path = join(repoRoot, ".cairn", "config.yaml");
+    if (!existsSync(path))
+        return null;
+    try {
+        const parsed = parseYaml(readFileSync(path, "utf8"));
+        if (typeof parsed["slug"] === "string")
+            return parsed["slug"];
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function minutesSince(iso) {
+    const t = Date.parse(iso);
+    if (!Number.isFinite(t))
+        return null;
+    const diffMs = Date.now() - t;
+    if (diffMs < 0)
+        return 0;
+    return Math.floor(diffMs / 60_000);
+}
+function humanizeMinutes(minutes) {
+    if (minutes < 1)
+        return "moments ago";
+    if (minutes < 60)
+        return `${minutes} minute${minutes === 1 ? "" : "s"} ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours} hour${hours === 1 ? "" : "s"} ago`;
+    const days = Math.floor(hours / 24);
+    return `${days} day${days === 1 ? "" : "s"} ago`;
+}
+function renderPendingDraftsSection(drafts) {
+    if (drafts.length === 0)
+        return null;
+    const lines = [];
+    lines.push(`## Decision drafts pending operator confirm (${drafts.length})`);
+    lines.push("");
+    const slice = drafts.slice(0, DRAFTS_CAP);
+    for (const d of slice) {
+        const meta = [];
+        if (d.capture_source)
+            meta.push(`capture_source: ${d.capture_source}`);
+        if (d.decided_at)
+            meta.push(`received: ${d.decided_at}`);
+        lines.push(`- **${d.id}** (draft) — ${d.title}${meta.length > 0 ? `; ${meta.join("; ")}` : ""}`);
+    }
+    if (drafts.length > DRAFTS_CAP) {
+        lines.push(`…${drafts.length - DRAFTS_CAP} more in _inbox/.`);
+    }
+    lines.push("");
+    lines.push("These have been captured but not committed. The operator has not yet confirmed 🟢. Until they do, do not assume their content is binding.");
+    return lines.join("\n");
+}
+//# sourceMappingURL=build.js.map