@deftai/directive-core 0.69.0 → 0.71.0

package/dist/eval/crud-telemetry.js

@@ -0,0 +1,307 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname } from "node:path";
+import { readCorePackageVersion } from "../engine-version.js";
+import { resolveEvalPath } from "../layout/resolve.js";
+import { scanVbrief } from "../vbrief-validate/conformance.js";
+import { validateVbriefSchema } from "../vbrief-validate/schema.js";
+export const CRUD_METRICS_HISTORY_REL = "results/crud-metrics.jsonl";
+/** Whole-file rewrites change at least half of the bytes or re-serialize with high drift. */
+export const BYTE_DIFF_WHOLE_FILE_THRESHOLD = 0.5;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Edit distance between two UTF-8 strings (Levenshtein, two-row). */
+function levenshteinDistance(before, after) {
+    if (before === after) {
+        return 0;
+    }
+    if (before.length === 0) {
+        return after.length;
+    }
+    if (after.length === 0) {
+        return before.length;
+    }
+    let prev = Array.from({ length: after.length + 1 }, (_, index) => index);
+    let curr = new Array(after.length + 1).fill(0);
+    for (let row = 1; row <= before.length; row += 1) {
+        curr[0] = row;
+        for (let col = 1; col <= after.length; col += 1) {
+            const cost = before[row - 1] === after[col - 1] ? 0 : 1;
+            const up = prev[col] ?? 0;
+            const left = curr[col - 1] ?? 0;
+            const diag = prev[col - 1] ?? 0;
+            curr[col] = Math.min(up + 1, left + 1, diag + cost);
+        }
+        [prev, curr] = [curr, prev];
+    }
+    return prev[after.length] ?? 0;
+}
+/** Ratio of edit distance to the longer string length. */
+export function computeChangedByteRatio(before, after) {
+    const maxLen = Math.max(before.length, after.length);
+    if (maxLen === 0) {
+        return 0;
+    }
+    return levenshteinDistance(before, after) / maxLen;
+}
+/** Classify whether an update preserved bytes (surgical) or rewrote the file. */
+export function classifyByteDiffMinimality(before, after) {
+    const changedRatio = computeChangedByteRatio(before, after);
+    try {
+        const oldParsed = JSON.parse(before);
+        const newParsed = JSON.parse(after);
+        if (JSON.stringify(oldParsed) === JSON.stringify(newParsed) && changedRatio > 0) {
+            return { kind: "whole-file-rewrite", changedRatio };
+        }
+    }
+    catch {
+        // Fall through to byte-ratio classification.
+    }
+    if (changedRatio >= BYTE_DIFF_WHOLE_FILE_THRESHOLD) {
+        return { kind: "whole-file-rewrite", changedRatio };
+    }
+    return { kind: "surgical", changedRatio };
+}
+function assessDocument(path, parsed) {
+    if (!isRecord(parsed)) {
+        return {
+            schemaValid: false,
+            schemaErrors: [`${path}: document must be a JSON object`],
+            inventedKeys: [],
+        };
+    }
+    const schemaErrors = validateVbriefSchema(parsed, path);
+    const findings = scanVbrief(path, parsed);
+    const inventedKeys = findings.map((finding) => finding.key);
+    return {
+        schemaValid: schemaErrors.length === 0,
+        schemaErrors,
+        inventedKeys,
+    };
+}
+function sanitizeInlineMessage(message) {
+    return message.replace(/\r?\n/g, " ");
+}
+function ensureParentDir(path) {
+    mkdirSync(dirname(path), { recursive: true });
+}
+/** Absolute path to the versioned CRUD metrics ledger (#1703 Tier 1). */
+export function crudMetricsHistoryPath(projectRoot) {
+    return resolveEvalPath(projectRoot, CRUD_METRICS_HISTORY_REL);
+}
+/** Append CRUD operation metrics to the versioned ledger (#1703 Tier 1). */
+export function persistCrudMetrics(projectRoot, metrics) {
+    if (metrics.length === 0) {
+        return;
+    }
+    const path = crudMetricsHistoryPath(projectRoot);
+    mkdirSync(dirname(path), { recursive: true });
+    for (const metric of metrics) {
+        appendFileSync(path, `${JSON.stringify(metric)}\n`, "utf8");
+    }
+}
+/**
+ * Instrumented vBRIEF/xBRIEF CRUD chokepoint (#1703 Tier 1).
+ * Every operation emits a version-tagged metric covering schema validity,
+ * field invention, and (for updates) byte-diff minimality.
+ * Delete intentionally succeeds on schema-invalid files so corrupt artifacts can be removed.
+ */
+export class InstrumentedVbriefCrud {
+    directiveVersion;
+    now;
+    metrics = [];
+    constructor(options = {}) {
+        this.directiveVersion = options.directiveVersion ?? readCorePackageVersion();
+        this.now = options.now ?? (() => new Date());
+    }
+    getMetrics() {
+        return this.metrics;
+    }
+    clearMetrics() {
+        this.metrics.length = 0;
+    }
+    create(path, content) {
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        }
+        catch (err) {
+            const message = sanitizeInlineMessage(err instanceof Error ? err.message : String(err));
+            this.recordMetric({
+                operation: "create",
+                path,
+                schemaValid: false,
+                schemaErrors: [`${path}: invalid JSON -- ${message}`],
+                inventedKeys: [],
+                byteDiffMinimality: null,
+                byteDiffChangedRatio: null,
+            });
+            return { ok: false, error: message };
+        }
+        const assessment = assessDocument(path, parsed);
+        this.recordMetric({
+            operation: "create",
+            path,
+            schemaValid: assessment.schemaValid,
+            schemaErrors: assessment.schemaErrors,
+            inventedKeys: assessment.inventedKeys,
+            byteDiffMinimality: null,
+            byteDiffChangedRatio: null,
+        });
+        if (!assessment.schemaValid) {
+            return { ok: false, error: assessment.schemaErrors.join("; ") };
+        }
+        ensureParentDir(path);
+        writeFileSync(path, content, "utf8");
+        return { ok: true };
+    }
+    read(path) {
+        if (!existsSync(path)) {
+            this.recordMetric({
+                operation: "read",
+                path,
+                schemaValid: false,
+                schemaErrors: [`${path}: file not found`],
+                inventedKeys: [],
+                byteDiffMinimality: null,
+                byteDiffChangedRatio: null,
+            });
+            return { ok: false, error: "ENOENT" };
+        }
+        const content = readFileSync(path, "utf8");
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        }
+        catch (err) {
+            const message = sanitizeInlineMessage(err instanceof Error ? err.message : String(err));
+            this.recordMetric({
+                operation: "read",
+                path,
+                schemaValid: false,
+                schemaErrors: [`${path}: invalid JSON -- ${message}`],
+                inventedKeys: [],
+                byteDiffMinimality: null,
+                byteDiffChangedRatio: null,
+            });
+            return { ok: false, error: message };
+        }
+        const assessment = assessDocument(path, parsed);
+        this.recordMetric({
+            operation: "read",
+            path,
+            schemaValid: assessment.schemaValid,
+            schemaErrors: assessment.schemaErrors,
+            inventedKeys: assessment.inventedKeys,
+            byteDiffMinimality: null,
+            byteDiffChangedRatio: null,
+        });
+        if (!assessment.schemaValid) {
+            return { ok: false, error: assessment.schemaErrors.join("; ") };
+        }
+        return { ok: true, content };
+    }
+    update(path, content, options = {}) {
+        const previousBytes = options.trustedWrite || !existsSync(path) ? null : readFileSync(path, "utf8");
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        }
+        catch (err) {
+            const message = sanitizeInlineMessage(err instanceof Error ? err.message : String(err));
+            this.recordMetric({
+                operation: "update",
+                path,
+                schemaValid: false,
+                schemaErrors: [`${path}: invalid JSON -- ${message}`],
+                inventedKeys: [],
+                byteDiffMinimality: null,
+                byteDiffChangedRatio: null,
+            });
+            return { ok: false, error: message };
+        }
+        const assessment = assessDocument(path, parsed);
+        let byteDiffMinimality = null;
+        let byteDiffChangedRatio = null;
+        if (previousBytes !== null) {
+            const diff = classifyByteDiffMinimality(previousBytes, content);
+            byteDiffMinimality = diff.kind;
+            byteDiffChangedRatio = diff.changedRatio;
+        }
+        this.recordMetric({
+            operation: "update",
+            path,
+            schemaValid: assessment.schemaValid,
+            schemaErrors: assessment.schemaErrors,
+            inventedKeys: assessment.inventedKeys,
+            byteDiffMinimality,
+            byteDiffChangedRatio,
+        });
+        if (!assessment.schemaValid && !options.trustedWrite) {
+            return { ok: false, error: assessment.schemaErrors.join("; ") };
+        }
+        ensureParentDir(path);
+        writeFileSync(path, content, "utf8");
+        return { ok: true };
+    }
+    delete(path) {
+        if (!existsSync(path)) {
+            this.recordMetric({
+                operation: "delete",
+                path,
+                schemaValid: false,
+                schemaErrors: [`${path}: file not found`],
+                inventedKeys: [],
+                byteDiffMinimality: null,
+                byteDiffChangedRatio: null,
+            });
+            return { ok: false, error: "ENOENT" };
+        }
+        const content = readFileSync(path, "utf8");
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        }
+        catch (err) {
+            const message = sanitizeInlineMessage(err instanceof Error ? err.message : String(err));
+            this.recordMetric({
+                operation: "delete",
+                path,
+                schemaValid: false,
+                schemaErrors: [`${path}: invalid JSON -- ${message}`],
+                inventedKeys: [],
+                byteDiffMinimality: null,
+                byteDiffChangedRatio: null,
+            });
+            unlinkSync(path);
+            return { ok: true };
+        }
+        const assessment = assessDocument(path, parsed);
+        this.recordMetric({
+            operation: "delete",
+            path,
+            schemaValid: assessment.schemaValid,
+            schemaErrors: assessment.schemaErrors,
+            inventedKeys: assessment.inventedKeys,
+            byteDiffMinimality: null,
+            byteDiffChangedRatio: null,
+        });
+        unlinkSync(path);
+        return { ok: true };
+    }
+    recordMetric(input) {
+        this.metrics.push({
+            directiveVersion: this.directiveVersion,
+            operation: input.operation,
+            path: input.path,
+            schemaValid: input.schemaValid,
+            schemaErrors: input.schemaErrors,
+            fieldInventionCount: input.inventedKeys.length,
+            inventedKeys: input.inventedKeys,
+            byteDiffMinimality: input.byteDiffMinimality,
+            byteDiffChangedRatio: input.byteDiffChangedRatio,
+            recordedAt: this.now().toISOString(),
+        });
+    }
+}
+//# sourceMappingURL=crud-telemetry.js.map

package/dist/eval/health.d.ts

@@ -0,0 +1,52 @@
+export declare const HEALTH_SCHEMA_VERSION: 1;
+export declare const HEALTH_HISTORY_REL = "results/health-history.jsonl";
+/** One static Tier-0 gate probe aggregated into the health score. */
+export interface GateProbeResult {
+    readonly id: string;
+    readonly title: string;
+    readonly pass: boolean;
+    readonly exitCode: number;
+    readonly detail?: string;
+    readonly skipped?: boolean;
+    readonly skipReason?: string;
+}
+/** Evidence for a contradictory / unsatisfiable gate pair (#1694 class). */
+export interface ContradictionEvidence {
+    readonly id: string;
+    readonly kind: "unsatisfiable-nudge";
+    readonly summary: string;
+    readonly signals: readonly string[];
+}
+/** Versioned Tier-0 health run persisted for trending (#1703). */
+export interface HealthReport {
+    readonly schemaVersion: typeof HEALTH_SCHEMA_VERSION;
+    readonly version: string;
+    readonly recordedAt: string;
+    readonly score: number;
+    readonly gates: readonly GateProbeResult[];
+    readonly contradictions: readonly ContradictionEvidence[];
+}
+export interface EvaluateHealthOptions {
+    readonly projectRoot?: string;
+    readonly persist?: boolean;
+    readonly now?: () => Date;
+    readonly frameworkSource?: boolean;
+}
+export interface EvaluateHealthResult {
+    readonly code: 0 | 1 | 2;
+    readonly report: HealthReport | null;
+    readonly message: string;
+}
+/** Absolute path to the versioned health history ledger. */
+export declare function healthHistoryPath(projectRoot: string): string;
+/** Detect the canonical wipCap unsatisfiable-nudge contradiction (#1694). */
+export declare function detectWipCapUnsatisfiableNudge(projectRoot: string): ContradictionEvidence | null;
+/** Run all registered contradictory-gate detectors. */
+export declare function detectContradictoryGates(projectRoot: string): ContradictionEvidence[];
+/** Compute a 0-100 score from gate pass rate minus contradiction penalty. */
+export declare function computeHealthScore(gates: readonly GateProbeResult[], contradictions: readonly ContradictionEvidence[]): number;
+/** Append one health run to the versioned ledger (#1703 Tier 0). */
+export declare function persistHealthRun(projectRoot: string, report: HealthReport): void;
+/** Aggregate Tier-0 static gates into a versioned framework health score (#1703). */
+export declare function evaluateHealth(options?: EvaluateHealthOptions): EvaluateHealthResult;
+//# sourceMappingURL=health.d.ts.map

package/dist/eval/health.js

@@ -0,0 +1,240 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { agentsRefreshPlan } from "../doctor/agents-md.js";
+import { evaluate as evaluateEncoding } from "../encoding/evaluate.js";
+import { readCorePackageVersion } from "../engine-version.js";
+import { resolveEvalPath, resolveProjectDefinitionPath } from "../layout/resolve.js";
+import { readPlanPolicy } from "../policy/plan-extensions.js";
+import { classifyOnboarding, detectPriorState } from "../triage/welcome/prior-state.js";
+import { validateLinks } from "../validate-content/index.js";
+import { evaluateConformance } from "../vbrief-validate/conformance.js";
+import { validateWipCapOnPlan } from "../vbrief-validate/plan-hooks.js";
+import { evaluateContentManifest } from "../verify-source/content-manifest.js";
+export const HEALTH_SCHEMA_VERSION = 1;
+export const HEALTH_HISTORY_REL = "results/health-history.jsonl";
+function sanitizeOneLine(value) {
+    return value.replace(/\r?\n/g, " ");
+}
+function isFrameworkSourceCheckout(projectRoot) {
+    const manifest = resolve(projectRoot, "conventions/content-manifest.json");
+    const cliPkg = resolve(projectRoot, "packages/cli/package.json");
+    return existsSync(manifest) && existsSync(cliPkg);
+}
+function loadPlan(projectRoot) {
+    const filepath = resolveProjectDefinitionPath(projectRoot);
+    if (!existsSync(filepath)) {
+        return null;
+    }
+    try {
+        const data = JSON.parse(readFileSync(filepath, "utf8"));
+        if (data === null || typeof data !== "object" || Array.isArray(data)) {
+            return null;
+        }
+        return { plan: data.plan, filepath };
+    }
+    catch {
+        return null;
+    }
+}
+function probeEncoding(projectRoot) {
+    const result = evaluateEncoding(projectRoot, { mode: "all" });
+    return {
+        id: "encoding",
+        title: "verify:encoding",
+        pass: result.exitCode === 0,
+        exitCode: result.exitCode,
+        detail: result.exitCode === 0 ? undefined : result.message.split("\n")[0],
+    };
+}
+function probeLinks(projectRoot) {
+    const result = validateLinks.evaluate({
+        cwd: projectRoot,
+        strict: false,
+        argv: [],
+        linkCheckStrict: process.env.LINK_CHECK_STRICT === "1",
+    });
+    return {
+        id: "links",
+        title: "verify:links",
+        pass: result.code === 0,
+        exitCode: result.code,
+        detail: result.code === 0 ? undefined : result.message.split("\n")[0],
+    };
+}
+function probeVbriefConformance(projectRoot) {
+    const result = evaluateConformance(projectRoot, { mode: "all" });
+    return {
+        id: "vbrief-conformance",
+        title: "verify:vbrief-conformance",
+        pass: result.exitCode === 0,
+        exitCode: result.exitCode,
+        detail: result.exitCode === 0 ? undefined : result.message.split("\n")[0],
+    };
+}
+function probeAgentsMdFreshness(projectRoot) {
+    const plan = agentsRefreshPlan(projectRoot);
+    const state = String(plan.state ?? "unknown");
+    const pass = state === "current";
+    return {
+        id: "agents-md-freshness",
+        title: "AGENTS.md managed-section freshness",
+        pass,
+        exitCode: pass ? 0 : 1,
+        detail: pass ? undefined : `state=${state}`,
+    };
+}
+function probeContentManifest(projectRoot) {
+    const result = evaluateContentManifest(projectRoot, { root: projectRoot });
+    return {
+        id: "content-manifest",
+        title: "verify:content-manifest",
+        pass: result.code === 0,
+        exitCode: result.code,
+        detail: result.code === 0 ? undefined : result.message.split("\n")[0],
+    };
+}
+/** Absolute path to the versioned health history ledger. */
+export function healthHistoryPath(projectRoot) {
+    return resolveEvalPath(projectRoot, HEALTH_HISTORY_REL);
+}
+/** Detect the canonical wipCap unsatisfiable-nudge contradiction (#1694). */
+export function detectWipCapUnsatisfiableNudge(projectRoot) {
+    const loaded = loadPlan(projectRoot);
+    if (loaded === null) {
+        return null;
+    }
+    const { plan, filepath } = loaded;
+    const policy = readPlanPolicy(plan);
+    const wipCapPresent = typeof policy === "object" &&
+        policy !== null &&
+        !Array.isArray(policy) &&
+        "wipCap" in policy;
+    if (wipCapPresent) {
+        return null;
+    }
+    const state = detectPriorState(projectRoot);
+    const [, missing] = classifyOnboarding(state);
+    if (!missing.includes("wipCap")) {
+        return null;
+    }
+    const validatorErrors = validateWipCapOnPlan(plan, filepath);
+    if (validatorErrors.length > 0) {
+        return null;
+    }
+    return {
+        id: "wipCap-unsatisfiable-nudge",
+        kind: "unsatisfiable-nudge",
+        summary: "Onboarding completeness treats absent plan.policy.wipCap as incomplete, but omit-by-design accepts absence as valid (#1694 / #1186 D1).",
+        signals: [
+            "classifyOnboarding: wipCap listed in missing onboarding signals",
+            "validateWipCapOnPlan: omitted wipCap is valid",
+            "triage:welcome --onboard nudge cannot clear without violating omit-by-design contract",
+        ],
+    };
+}
+/** Run all registered contradictory-gate detectors. */
+export function detectContradictoryGates(projectRoot) {
+    const wipCap = detectWipCapUnsatisfiableNudge(projectRoot);
+    return wipCap === null ? [] : [wipCap];
+}
+/** Compute a 0-100 score from gate pass rate minus contradiction penalty. */
+export function computeHealthScore(gates, contradictions) {
+    const active = gates.filter((g) => !g.skipped);
+    if (active.length === 0) {
+        return contradictions.length > 0 ? 0 : 100;
+    }
+    const passed = active.filter((g) => g.pass).length;
+    const base = Math.round((passed / active.length) * 100);
+    const penalty = contradictions.length * 15;
+    return Math.max(0, base - penalty);
+}
+/** Append one health run to the versioned ledger (#1703 Tier 0). */
+export function persistHealthRun(projectRoot, report) {
+    const path = healthHistoryPath(projectRoot);
+    mkdirSync(dirname(path), { recursive: true });
+    appendFileSync(path, `${JSON.stringify(report)}\n`, "utf8");
+}
+function collectStaticGates(projectRoot, frameworkSource) {
+    const gates = [
+        probeEncoding(projectRoot),
+        probeLinks(projectRoot),
+        probeVbriefConformance(projectRoot),
+        probeAgentsMdFreshness(projectRoot),
+    ];
+    if (frameworkSource) {
+        gates.push(probeContentManifest(projectRoot));
+    }
+    else {
+        gates.push({
+            id: "content-manifest",
+            title: "verify:content-manifest",
+            pass: true,
+            exitCode: 0,
+            skipped: true,
+            skipReason: "framework-source-only gate",
+        });
+    }
+    return gates;
+}
+function formatHumanReport(report) {
+    const lines = [
+        `eval:health v${report.version} score=${report.score}/100 (${report.recordedAt})`,
+        ...report.gates.map((g) => {
+            const status = g.skipped ? "SKIP" : g.pass ? "PASS" : "FAIL";
+            const suffix = g.skipped
+                ? ` (${sanitizeOneLine(g.skipReason ?? "")})`
+                : g.detail
+                    ? ` -- ${sanitizeOneLine(g.detail)}`
+                    : "";
+            return `  [${status}] ${g.title}${suffix}`;
+        }),
+    ];
+    if (report.contradictions.length > 0) {
+        lines.push("  Contradictory gates:");
+        for (const c of report.contradictions) {
+            lines.push(`    - ${c.id}: ${sanitizeOneLine(c.summary)}`);
+        }
+    }
+    return lines.join("\n");
+}
+/** Aggregate Tier-0 static gates into a versioned framework health score (#1703). */
+export function evaluateHealth(options = {}) {
+    const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    const frameworkSource = options.frameworkSource ?? isFrameworkSourceCheckout(projectRoot);
+    const now = options.now ?? (() => new Date());
+    const persist = options.persist ?? true;
+    const gates = collectStaticGates(projectRoot, frameworkSource);
+    const contradictions = detectContradictoryGates(projectRoot);
+    const score = computeHealthScore(gates, contradictions);
+    const report = {
+        schemaVersion: HEALTH_SCHEMA_VERSION,
+        version: readCorePackageVersion(),
+        recordedAt: now()
+            .toISOString()
+            .replace(/\.\d{3}Z$/, "Z"),
+        score,
+        gates,
+        contradictions,
+    };
+    if (persist) {
+        try {
+            persistHealthRun(projectRoot, report);
+        }
+        catch (err) {
+            const persistError = `eval:health: failed to persist health history: ${String(err)}`;
+            const healthy = score === 100 && contradictions.length === 0;
+            return {
+                code: healthy ? 0 : 1,
+                report,
+                message: `${formatHumanReport(report)}\n${persistError}`,
+            };
+        }
+    }
+    const healthy = score === 100 && contradictions.length === 0;
+    return {
+        code: healthy ? 0 : 1,
+        report,
+        message: formatHumanReport(report),
+    };
+}
+//# sourceMappingURL=health.js.map

package/dist/eval/readback.d.ts

@@ -0,0 +1,38 @@
+import { type HealthReport } from "./health.js";
+/** Repeat-suppression window for the budgeted eval session nudge (#1703 / #1279 parity). */
+export declare const EVAL_READBACK_SUPPRESSION_HOURS = 4;
+export declare const EVAL_READBACK_HISTORY_REL: string;
+export declare const EVAL_READBACK_HISTORY_SCHEMA = "deft.eval.readback.v1";
+export interface SessionEvalReadbackResult {
+    readonly line: string | null;
+    readonly suppressed: boolean;
+}
+/** Stable nudge key for debounce — score + contradiction ids. */
+export declare function evalReadbackNudgeKey(report: HealthReport): string;
+/** True when the same eval nudge was read back within the suppression window. */
+export declare function shouldSuppressEvalReadback(nudgeKey: string, historyFile: string, options?: {
+    now?: Date;
+}): boolean;
+/** Whether the current health report warrants a session-start advisory nudge (#2336). */
+export declare function shouldNudgeEvalHealth(report: HealthReport, previous: HealthReport | null): boolean;
+export declare function formatEvalHealthSessionLine(report: HealthReport, previous: HealthReport | null): string;
+export interface RenderSessionEvalReadbackOptions {
+    readonly now?: Date;
+    readonly maxChars?: number;
+    readonly writeHistory?: boolean;
+    readonly evaluate?: (projectRoot: string) => {
+        report: HealthReport | null;
+    };
+}
+/** Budgeted session eval one-liner — silent when healthy or debounced (#1703 / #2336). */
+export declare function renderSessionEvalReadback(projectRoot: string, options?: RenderSessionEvalReadbackOptions): SessionEvalReadbackResult;
+/** Emit the eval session readback line when present. Returns the line or null. */
+export declare function emitSessionEvalReadback(projectRoot: string, options?: {
+    output?: (line: string) => void;
+    now?: Date;
+    writeHistory?: boolean;
+    evaluate?: (projectRoot: string) => {
+        report: HealthReport | null;
+    };
+}): string | null;
+//# sourceMappingURL=readback.d.ts.map