@popoverai/dotrequirements 0.29.1 → 0.29.2

package/dist/harness/finalize.js

@@ -12,7 +12,8 @@
 import { execSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { getProjectInfo } from "../utils/project-settings.js";
-import { cleanupTestRunId, deleteTrackingFile, findProjectRoot, findRequirementsDir, getTestRunId, needsReporting, readCoverageCache, readLookupCache, readTrackingEntries, updateCoverageCache, } from "./cache.js";
+import { cleanupTestRunId, clearCoverageReportFailure, deleteTrackingFile, findProjectRoot, findRequirementsDir, getTestRunId, needsReporting, readCoverageCache, readLookupCache, readTrackingEntries, recordCoverageReplayed, recordCoverageReported, recordCoverageReportFailure, updateCoverageCache, } from "./cache.js";
+import { formatFailureNotice, formatUnrecordedNotice, refusalReason, } from "./reportingStatus.js";
 import { toProjectRelativePath } from "./tracking.js";
 /**
  * Aggregate tracking entries by requirement key
@@ -68,7 +69,7 @@ function getLineAuthor(cwd, file, line) {
  * HARNESS-FINALIZE-1: Shows which requirements were tested
  */
 function printLocalReport(testedKeys, lookup, options) {
-    const { showSummary, showTestedList, showUntestedList } = options;
+    const { showSummary, showTestedList, showUntestedList, cloudUnrecorded } = options;
     const allKeys = lookup
         ? Object.keys(lookup.requirements).filter((k) => !lookup.requirements[k].isAlias)
         : [];
@@ -79,7 +80,9 @@ function printLocalReport(testedKeys, lookup, options) {
     let report = "";
     // Show summary stats
     if (showSummary) {
-        report += "\n=== Requirements Coverage Report ===\n";
+        report += cloudUnrecorded
+            ? "\n=== Requirements Coverage Report (local only — not recorded to cloud) ===\n"
+            : "\n=== Requirements Coverage Report ===\n";
         report += `\nTotal Requirements: ${total}\n`;
         report += `Tested Requirements: ${tested}\n`;
         report += `Untested Requirements: ${untestedKeys.length}\n`;
@@ -130,6 +133,122 @@ function printLocalReport(testedKeys, lookup, options) {
  * Production Convex deployment URL
  */
 const CONVEX_URL = "https://data.dotrequirements.io";
+/**
+ * Record a reporting attempt that did not reach the cloud, so later runs and
+ * `dotreq report` keep saying so (COVERAGE-REPORT-3), and hand the reason back
+ * for this run's notice.
+ */
+function fail(requirementsDir, reason, pending) {
+    const stated = asReason(reason);
+    persist(() => recordCoverageReportFailure(requirementsDir, stated, Date.now(), pending));
+    return { sent: false, count: 0, error: stated };
+}
+/**
+ * Run a coverage-cache write, swallowing IO errors.
+ *
+ * A read-only or full `.requirements/.cache` must never change the outcome of
+ * a test run (COVERAGE-REPORT-2.0) — nor, on the success path, turn a report
+ * that reached the cloud into one reported as failed.
+ *
+ * Returns whether the write landed, because a swallowed success-path write
+ * leaves the cache disagreeing with what just happened.
+ */
+function persist(write) {
+    try {
+        write();
+        return true;
+    }
+    catch {
+        // The run still says its piece; only the memory of it is lost.
+        return false;
+    }
+}
+/**
+ * How much of a server's response body to keep as a failure reason.
+ *
+ * The reason is persisted and reprinted on every later run, and the endpoint
+ * sits behind Cloudflare — an origin 5xx returns a multi-KB HTML page whose
+ * newlines would shred the notice.
+ */
+const MAX_REASON_LENGTH = 200;
+/** Collapse to a single line and cap, so a reason stays readable forever. */
+function asReason(body) {
+    const collapsed = body.replace(/\s+/g, " ").trim();
+    return collapsed.length > MAX_REASON_LENGTH
+        ? `${collapsed.slice(0, MAX_REASON_LENGTH)}…`
+        : collapsed;
+}
+/** How long to wait on the cloud before giving up and saying so. */
+const REPORT_TIMEOUT_MS = 15_000;
+/**
+ * Send one coverage report and say plainly whether it landed.
+ *
+ * Shared by this run's report and the replay of a previous run's, so both are
+ * judged by the same rule: success has to be stated by the cloud, never
+ * inferred from the absence of an error.
+ */
+async function postCoverage(credentials, report) {
+    // Note: projectId from env is always a slug (e.g., "reduced-cephalopod-288"),
+    // not a Convex ID. Use projectSlug field for authentication and slug for target.
+    const response = await fetch(`${CONVEX_URL}/api/mutation`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            path: "testCoverage/mutations:recordCoverage",
+            args: {
+                projectAuth: {
+                    projectSlug: credentials.projectId,
+                    projectSecret: credentials.projectSecret,
+                },
+                target: { type: "project", slug: credentials.projectId },
+                branch: report.branch,
+                context: report.context,
+                runId: report.runId,
+                coverage: report.coverage,
+            },
+            format: "json",
+        }),
+        // Without this a black-holed connection hangs teardown indefinitely,
+        // and the run never gets to say coverage didn't record.
+        signal: AbortSignal.timeout(REPORT_TIMEOUT_MS),
+    });
+    if (!response.ok) {
+        // Convex answers a rejected function with 200 and an error body, so a
+        // non-ok status is an HTTP-level problem — but the body may still say what
+        // was wrong (a 413 on an oversized payload, say), so don't discard it in
+        // favour of a blanket "could not be reached".
+        const body = await response.text().catch(() => "");
+        const detail = body.trim() ? ` ${body}` : "";
+        return {
+            ok: false,
+            reason: `The cloud refused the report (HTTP ${response.status}).${detail}`,
+        };
+    }
+    const responseText = await response.text();
+    let responseData;
+    try {
+        responseData = JSON.parse(responseText);
+    }
+    catch {
+        // Left undefined; handled as an unreadable answer below.
+    }
+    const convexResponse = responseData && typeof responseData === "object"
+        ? responseData
+        : undefined;
+    if (convexResponse?.status === "error") {
+        // COVERAGE-REPORT-1: the reason lives in errorData, not the raw
+        // errorMessage that production redacts.
+        return { ok: false, reason: refusalReason(convexResponse) };
+    }
+    // COVERAGE-REPORT-1.4: only an affirmative success may clear a failure.
+    if (convexResponse?.status !== "success") {
+        return {
+            ok: false,
+            reason: `The cloud's answer could not be read: ${responseText.trim() || "empty response"}`,
+        };
+    }
+    return { ok: true };
+}
 /**
  * Report coverage to Convex cloud
  *
@@ -137,6 +256,9 @@ const CONVEX_URL = "https://data.dotrequirements.io";
  * HARNESS-FINALIZE-3: Coverage records include requirement, file, line, branch
  */
 async function reportToConvex(projectRoot, testRunId, aggregated, showCloudStatus, context) {
+    // Hoisted so a transport failure — DNS, TLS, the timeout — records the
+    // report it was carrying, and not an unreplayable failure (COVERAGE-REPORT-3.4).
+    let thisRun;
     try {
         // Get project info from .requirements/project-settings.json
         const projectInfo = getProjectInfo(projectRoot);
@@ -147,9 +269,20 @@ async function reportToConvex(projectRoot, testRunId, aggregated, showCloudStatu
             if (showCloudStatus) {
                 console.log("\nℹ️  Skipping cloud coverage reporting (project not connected to cloud)");
             }
+            // An unlinked project is not failing to record — it has stopped trying.
+            // Without this the notice would outlive the link with no way out of it.
+            const dir = findRequirementsDir(projectRoot);
+            if (dir) {
+                try {
+                    clearCoverageReportFailure(dir);
+                }
+                catch {
+                    // Same reasoning as fail(): never let cache IO redden a run.
+                }
+            }
             return { sent: false, count: 0 };
         }
-        const { projectId, projectSecret } = projectInfo.credentials;
+        const credentials = projectInfo.credentials;
         const requirementsDir = findRequirementsDir(projectRoot);
         const branch = getCurrentBranch(projectRoot);
         // Build the full set of tuples for this run, one per tracked requirement
@@ -159,18 +292,59 @@ async function reportToConvex(projectRoot, testRunId, aggregated, showCloudStatu
             context,
             branch,
         }));
+        const coverageCache = readCoverageCache(requirementsDir);
+        // COVERAGE-REPORT-3.4: replay a report that didn't land, before anything
+        // else. It has to be replayed rather than recomputed: this run only knows
+        // the requirements it exercised, so a partial run (`vitest run one.test.ts`,
+        // a CI shard, watch mode) would otherwise never retry the rest and the
+        // failure would stand forever. Replaying verbatim also keeps the original
+        // branch and attribution, which a later run cannot reconstruct.
+        const pending = coverageCache.lastFailure?.pending;
+        let replayedCount = 0;
+        if (pending) {
+            // Hold it as the report in flight before going near the network:
+            // postCoverage doesn't catch its own transport errors, and a DNS blip
+            // reaching the catch-all with nothing held would replace the stored
+            // report with a bare reason — losing the branch, runId and attribution
+            // that are the whole reason it's kept whole.
+            thisRun = pending;
+            const replay = await postCoverage(credentials, pending);
+            if (!replay.ok) {
+                // Same cause will greet this run's own report; don't ask twice.
+                return fail(requirementsDir, replay.reason, pending);
+            }
+            replayedCount = pending.coverage.length;
+            if (showCloudStatus) {
+                console.log(`\n✓ Reported ${replayedCount} previously unrecorded requirement(s) to cloud`);
+            }
+            // Coverage reached the cloud, so this stamps when — a replay is a
+            // recording like any other.
+            persist(() => recordCoverageReplayed(requirementsDir));
+            thisRun = undefined;
+        }
+        // A failure written before replay existed has nothing to replay, so the
+        // only way out is to report this run in full and let success clear it.
+        // One run's cost, once, rather than a notice with no exit.
+        const strandedLegacyFailure = Boolean(coverageCache.lastFailure && !coverageCache.lastFailure.pending);
         // Local debounce (COVERAGE-DEBOUNCE-1): only report tuples not recently cached.
         // Server-side debounce is a backstop (COVERAGE-DEBOUNCE-4) — this layer just
         // prevents unnecessary HTTP calls.
-        const coverageCache = readCoverageCache(requirementsDir);
-        const tuplesToReport = allTuples.filter((tuple) => needsReporting(tuple, coverageCache));
+        const tuplesToReport = strandedLegacyFailure
+            ? allTuples
+            : allTuples.filter((tuple) => needsReporting(tuple, coverageCache));
         if (tuplesToReport.length === 0) {
-            if (showCloudStatus) {
+            // Only "unchanged" if nothing went to the cloud at all — saying it under
+            // a replay line that just reported N requirements contradicts it.
+            if (showCloudStatus && replayedCount === 0) {
                 console.log("\n✓ Coverage unchanged since last run (skipping cloud report)");
             }
-            // Still update the cache so the window continues tracking
-            updateCoverageCache(requirementsDir, testRunId, allTuples);
-            return { sent: false, count: 0 };
+            // Still update the cache so the window continues tracking. This branch
+            // contacts nothing, so it must not clear a standing failure — and it
+            // doesn't: updateCoverageCache carries lastFailure through untouched.
+            // Safe to reach with one standing: a pending report was already replayed
+            // above, and a legacy failure forced a full report rather than this path.
+            persist(() => updateCoverageCache(requirementsDir, testRunId, allTuples));
+            return { sent: replayedCount > 0, count: replayedCount };
         }
         // Deterministic runId for this finalize invocation (COVERAGE-CONTEXT-4)
         const runId = randomUUID();
@@ -220,73 +394,33 @@ async function reportToConvex(projectRoot, testRunId, aggregated, showCloudStatu
                 user,
             };
         });
-        // Send to Convex
-        // Note: projectId from env is always a slug (e.g., "reduced-cephalopod-288"),
-        // not a Convex ID. Use projectSlug field for authentication and slug for target.
-        const response = await fetch(`${CONVEX_URL}/api/mutation`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-                path: "testCoverage/mutations:recordCoverage",
-                args: {
-                    projectAuth: {
-                        projectSlug: projectId,
-                        projectSecret,
-                    },
-                    target: {
-                        type: "project",
-                        slug: projectId,
-                    },
-                    branch,
-                    context,
-                    runId,
-                    coverage,
-                },
-                format: "json",
-            }),
-        });
-        if (!response.ok) {
-            const error = await response.text();
-            if (showCloudStatus) {
-                console.warn(`\n⚠️  Failed to report coverage to cloud: ${response.status} ${error}`);
-            }
-            return { sent: false, count: 0, error: `${response.status} ${error}` };
-        }
-        // Check for Convex-level errors in the response body
-        // Convex returns 200 OK even for validation errors, with the error in the body
-        const responseText = await response.text();
-        let responseData;
-        try {
-            responseData = JSON.parse(responseText);
-        }
-        catch {
-            // Not JSON, treat as success
-        }
-        if (responseData &&
-            typeof responseData === "object" &&
-            "status" in responseData) {
-            const convexResponse = responseData;
-            if (convexResponse.status === "error") {
-                const errorMsg = convexResponse.errorMessage || "Unknown Convex error";
-                if (showCloudStatus) {
-                    console.warn(`\n⚠️  Failed to report coverage to cloud: ${errorMsg}`);
-                }
-                return { sent: false, count: 0, error: errorMsg };
-            }
+        thisRun = { branch, context, runId, coverage };
+        const posted = await postCoverage(credentials, thisRun);
+        if (!posted.ok) {
+            return fail(requirementsDir, posted.reason, thisRun);
         }
         if (showCloudStatus) {
             console.log(`\n✓ Reported ${tuplesToReport.length} requirement(s) to cloud (branch: ${branch})`);
         }
-        // Update coverage cache with the full tuple set (includes those not reported this run)
-        updateCoverageCache(requirementsDir, testRunId, allTuples);
-        return { sent: true, count: tuplesToReport.length };
+        // Update coverage cache with the full tuple set (includes those not
+        // reported this run). The only path that may stamp lastRecordedAt and drop
+        // a standing failure — the cloud has affirmatively said success here.
+        //
+        // Guarded: the report already landed, so a full or read-only disk must not
+        // demote it to "Coverage did not record" under the success line. It does
+        // mean the cache still holds a failure this report just disproved — say so
+        // rather than let the next run repeat a cause Sam has already fixed.
+        const remembered = persist(() => recordCoverageReported(requirementsDir, testRunId, allTuples));
+        if (!remembered && showCloudStatus) {
+            console.error("\n⚠️  Coverage recorded, but .requirements/.cache could not be written — the next run will report it again.");
+        }
+        return { sent: true, count: tuplesToReport.length + replayedCount };
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        if (showCloudStatus) {
-            console.warn(`\n⚠️  Error reporting coverage to cloud: ${errorMessage}`);
+        const requirementsDir = findRequirementsDir(projectRoot);
+        if (requirementsDir) {
+            return fail(requirementsDir, errorMessage, thisRun);
         }
         return { sent: false, count: 0, error: errorMessage };
     }
@@ -385,22 +519,48 @@ export async function finalize(options = {}) {
         ? Object.keys(lookup.requirements).filter((k) => !lookup.requirements[k].isAlias).length
         : 0;
     const coveragePercent = totalRequirements > 0 ? (testedKeys.length / totalRequirements) * 100 : 0;
-    // HARNESS-FINALIZE-1: Print local report
+    // HARNESS-FINALIZE-2, HARNESS-FINALIZE-3: Report to cloud.
+    // Runs before the local report so the report can say whether these figures
+    // reached the cloud (COVERAGE-REPORT-2.2).
+    let cloudResult = {
+        sent: false,
+        count: 0,
+    };
+    if (shouldReportToCloud) {
+        cloudResult = await reportToConvex(projectRoot, testRunId, aggregated, showCloudStatus, context);
+    }
+    // Read once, after reporting has had its say, for both the report header and
+    // the notice below.
+    const coverageCache = readCoverageCache(requirementsDir);
+    // This run's own report landing outranks anything the cache remembers: if
+    // the cache still holds a failure, this report just disproved it, and an
+    // unwritable cache must not make a landed report read as a failed one.
+    const recordedThisRun = cloudResult.sent;
+    // HARNESS-FINALIZE-1: Print local report.
+    // A run that didn't itself attempt a report (debounced, unlinked,
+    // reportToCloud off) can still be sitting on coverage that never landed —
+    // the header follows the cache, not just this run's outcome.
     const shouldPrintLocal = showSummary || showTestedList || showUntestedList;
     if (shouldPrintLocal) {
         printLocalReport(testedKeys, lookup, {
             showSummary,
             showTestedList,
             showUntestedList,
+            cloudUnrecorded: Boolean(cloudResult.error ??
+                (recordedThisRun ? null : coverageCache?.lastFailure)),
         });
     }
-    // HARNESS-FINALIZE-2, HARNESS-FINALIZE-3: Report to cloud
-    let cloudResult = {
-        sent: false,
-        count: 0,
-    };
-    if (shouldReportToCloud) {
-        cloudResult = await reportToConvex(projectRoot, testRunId, aggregated, showCloudStatus, context);
+    // COVERAGE-REPORT-2.1, -3.0: the run's last word is whether coverage
+    // recorded. Written to stderr so it cannot be silenced by a quiet run or
+    // swallowed by a caller parsing stdout — a failure nobody sees is the whole
+    // defect this replaces.
+    const unrecordedNotice = cloudResult.error
+        ? formatFailureNotice(cloudResult.error, coverageCache)
+        : recordedThisRun
+            ? null
+            : formatUnrecordedNotice(coverageCache);
+    if (unrecordedNotice) {
+        console.error(unrecordedNotice);
     }
     // HARNESS-FINALIZE-4: Clean up tracking data
     if (shouldCleanup && !cloudResult.error) {

package/dist/harness/reportingStatus.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Reading a cloud refusal, and saying plainly that coverage did not record.
+ *
+ * Covers COVERAGE-REPORT-1 (a refusal keeps its reason) and the wording of
+ * COVERAGE-REPORT-2 / -3 (the run says coverage did not record, and keeps
+ * saying it until it does).
+ */
+import type { CoverageCache } from "./cache.js";
+/**
+ * Shown when a refusal carries nothing a developer could act on
+ * (COVERAGE-REPORT-1.2). The raw `errorMessage` is deliberately not used in its
+ * place: production Convex redacts it to "[Request ID: …] Server Error", which
+ * tells the reader nothing and reads like a product defect.
+ */
+export declare const REFUSAL_WITHOUT_REASON = "the cloud refused the report without giving a reason";
+/**
+ * A Convex HTTP API response body. A ConvexError's `{kind, message}` arrives in
+ * `errorData`; `errorMessage` is the raw (production-redacted) string.
+ */
+export interface ConvexErrorResponse {
+    status?: string;
+    errorMessage?: string;
+    errorData?: unknown;
+}
+/**
+ * Pull the developer-facing reason out of a refused Convex call.
+ *
+ * Mirrors the selection rules in `packages/web/lib/convex-error.ts`: a
+ * ConvexError's data is either a plain string or an object carrying `message`.
+ */
+export declare function refusalReason(response: ConvexErrorResponse): string;
+/**
+ * The block a failing run ends with (COVERAGE-REPORT-2.1): what happened, why,
+ * and how long coverage has been out of date.
+ */
+export declare function formatFailureNotice(reason: string, cache: CoverageCache | null, now?: number): string;
+/**
+ * The standing notice for a run or report that did not itself attempt to
+ * report, but follows one that failed (COVERAGE-REPORT-3.0, -3.1).
+ *
+ * Returns null once a report has succeeded (COVERAGE-REPORT-3.3).
+ */
+export declare function formatUnrecordedNotice(cache: CoverageCache | null, now?: number): string | null;
+//# sourceMappingURL=reportingStatus.d.ts.map

package/dist/harness/reportingStatus.js

@@ -0,0 +1,123 @@
+/**
+ * Reading a cloud refusal, and saying plainly that coverage did not record.
+ *
+ * Covers COVERAGE-REPORT-1 (a refusal keeps its reason) and the wording of
+ * COVERAGE-REPORT-2 / -3 (the run says coverage did not record, and keeps
+ * saying it until it does).
+ */
+/**
+ * Shown when a refusal carries nothing a developer could act on
+ * (COVERAGE-REPORT-1.2). The raw `errorMessage` is deliberately not used in its
+ * place: production Convex redacts it to "[Request ID: …] Server Error", which
+ * tells the reader nothing and reads like a product defect.
+ */
+export const REFUSAL_WITHOUT_REASON = "the cloud refused the report without giving a reason";
+/**
+ * Pull the developer-facing reason out of a refused Convex call.
+ *
+ * Mirrors the selection rules in `packages/web/lib/convex-error.ts`: a
+ * ConvexError's data is either a plain string or an object carrying `message`.
+ */
+export function refusalReason(response) {
+    const data = response.errorData;
+    if (typeof data === "string" && data.trim()) {
+        return data;
+    }
+    if (data && typeof data === "object" && "message" in data) {
+        const { message } = data;
+        if (typeof message === "string" && message.trim()) {
+            return message;
+        }
+    }
+    return REFUSAL_WITHOUT_REASON;
+}
+const MONTHS = [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December",
+];
+function formatDate(timestamp) {
+    const d = new Date(timestamp);
+    return `${d.getDate()} ${MONTHS[d.getMonth()]}`;
+}
+/**
+ * How long ago, in the coarsest unit that still reads as a duration.
+ */
+function formatElapsed(ms) {
+    const minutes = Math.floor(ms / 60_000);
+    if (minutes < 1)
+        return "less than a minute";
+    if (minutes < 60)
+        return `${minutes} minute${minutes === 1 ? "" : "s"}`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours} hour${hours === 1 ? "" : "s"}`;
+    const days = Math.floor(hours / 24);
+    return `${days} day${days === 1 ? "" : "s"}`;
+}
+/**
+ * "Coverage last recorded 3 days ago (12 July)", or the never-recorded form
+ * for a checkout that has not had a successful report (COVERAGE-REPORT-3.2).
+ */
+function lastRecordedLine(cache, now) {
+    // Caches written before lastRecordedAt existed fall back to the debounce
+    // timestamp — telling someone who has reported for months that coverage has
+    // "never recorded" would be the worse lie. But that timestamp is refreshed
+    // by runs that contact nothing, so on its own it can claim coverage recorded
+    // a minute ago while reporting has been broken for days. A failure is proof
+    // coverage had not recorded by then: clamp to it.
+    const lastRecordedAt = cache?.lastRecordedAt ??
+        (cache?.current
+            ? Math.min(cache.current.timestamp, cache.lastFailure?.timestamp ?? cache.current.timestamp)
+            : undefined);
+    if (lastRecordedAt === undefined) {
+        return "Coverage has never recorded from this checkout.";
+    }
+    return `Coverage last recorded ${formatElapsed(now - lastRecordedAt)} ago (${formatDate(lastRecordedAt)}).`;
+}
+/**
+ * The block a failing run ends with (COVERAGE-REPORT-2.1): what happened, why,
+ * and how long coverage has been out of date.
+ */
+export function formatFailureNotice(reason, cache, now = Date.now()) {
+    return [
+        "",
+        "──────────────────────────────────────────────",
+        "  Coverage did not record.",
+        `  ${reason}`,
+        `  ${lastRecordedLine(cache, now)}`,
+        "  Your tests are unaffected.",
+        "──────────────────────────────────────────────",
+        "",
+    ].join("\n");
+}
+/**
+ * The standing notice for a run or report that did not itself attempt to
+ * report, but follows one that failed (COVERAGE-REPORT-3.0, -3.1).
+ *
+ * Returns null once a report has succeeded (COVERAGE-REPORT-3.3).
+ */
+export function formatUnrecordedNotice(cache, now = Date.now()) {
+    const failure = cache?.lastFailure;
+    if (!failure)
+        return null;
+    return [
+        "",
+        "──────────────────────────────────────────────",
+        `  ${lastRecordedLine(cache, now)}`,
+        `  The last attempt, ${formatElapsed(now - failure.timestamp)} ago, failed:`,
+        `  ${failure.reason}`,
+        "──────────────────────────────────────────────",
+        "",
+    ].join("\n");
+}
+//# sourceMappingURL=reportingStatus.js.map

package/dist/push/core.d.ts

@@ -16,12 +16,6 @@ export interface ParsedFile {
     markdownContent: string;
     /** Requirement count for display */
     requirementCount: number;
-    /**
-     * DOC-HEADER-14: the frontmatter exactly as the user wrote it, including
-     * keys the schema doesn't recognize — merged back on the post-sync rewrite
-     * so those keys survive.
-     */
-    rawFrontmatter?: Record<string, unknown>;
     /** DOC-HEADER-11.4: true when defaultPrefix was inferred from the first requirement rather than read from frontmatter */
     inferredDefaultPrefix?: boolean;
 }
@@ -31,12 +25,6 @@ export declare const WEB_APP_URL = "https://app.dotrequirements.io";
  * Extract markdown content from a file, stripping YAML frontmatter.
  */
 export declare function extractMarkdownContent(rawContent: string): string;
-/**
- * DOC-HEADER-14: merge the validated (and sync-updated) metadata over the raw
- * frontmatter so unrecognized keys survive the rewrite while the fields the
- * sync owns (document ID, pulledAt, defaultPrefix, version) stay updated.
- */
-export declare function mergeMetadataWithRawFrontmatter(metadata: Metadata, rawFrontmatter: Record<string, unknown> | undefined): Metadata;
 /**
  * Parse files for sync. Returns parsed files with metadata and content.
  *