@deftai/directive-core 0.55.0

package/dist/session/git.js

@@ -0,0 +1,49 @@
+import { execFileSync } from "node:child_process";
+import { resolve } from "node:path";
+export const defaultGitRunner = (projectRoot, args) => {
+    try {
+        const stdout = execFileSync("git", [...args], {
+            cwd: projectRoot,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return { code: 0, stdout: stdout.trimEnd(), stderr: "" };
+    }
+    catch (err) {
+        const e = err;
+        if (e.code === "ENOENT") {
+            return { code: 127, stdout: "", stderr: "git executable not found on PATH" };
+        }
+        return {
+            code: typeof e.status === "number" ? e.status : 2,
+            stdout: typeof e.stdout === "string" ? e.stdout.trimEnd() : "",
+            stderr: typeof e.stderr === "string" ? e.stderr.trimEnd() : "",
+        };
+    }
+};
+export function gitHead(projectRoot, runGit = defaultGitRunner) {
+    const { code, stdout, stderr } = runGit(projectRoot, ["rev-parse", "--verify", "HEAD"]);
+    if (code !== 0 || !stdout) {
+        return { head: null, error: stderr || "could not resolve git HEAD" };
+    }
+    return { head: stdout, error: null };
+}
+export function worktreePath(projectRoot, runGit = defaultGitRunner) {
+    const { code, stdout } = runGit(projectRoot, ["rev-parse", "--show-toplevel"]);
+    if (code === 0 && stdout) {
+        return resolve(stdout);
+    }
+    return resolve(projectRoot);
+}
+export function detectBranch(projectRoot, runGit = defaultGitRunner) {
+    const sym = runGit(projectRoot, ["symbolic-ref", "--short", "HEAD"]);
+    if (sym.code === 0 && sym.stdout.trim()) {
+        return sym.stdout.trim();
+    }
+    const rev = runGit(projectRoot, ["rev-parse", "--short", "HEAD"]);
+    if (rev.code === 0 && rev.stdout.trim()) {
+        return `detached:${rev.stdout.trim()}`;
+    }
+    return null;
+}
+//# sourceMappingURL=git.js.map

package/dist/session/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./git.js";
+export * from "./json.js";
+export * from "./resume-conditions.js";
+export * from "./ritual-sentinel.js";
+export * from "./session-start.js";
+export * from "./session-start-hook.js";
+export * from "./time.js";
+export * from "./verify-session-ritual.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/session/index.js

@@ -0,0 +1,9 @@
+export * from "./git.js";
+export * from "./json.js";
+export * from "./resume-conditions.js";
+export * from "./ritual-sentinel.js";
+export * from "./session-start.js";
+export * from "./session-start-hook.js";
+export * from "./time.js";
+export * from "./verify-session-ritual.js";
+//# sourceMappingURL=index.js.map

package/dist/session/json.d.ts

@@ -0,0 +1,7 @@
+/** Recursively sort object keys to match Python ``json.dumps(..., sort_keys=True)``. */
+export declare function sortKeys(value: unknown): unknown;
+/** Stable JSON text matching Python ritual-state writers (indent=2, sort_keys=True). */
+export declare function stableJson(value: unknown, indent?: number): string;
+/** Python ``json.dumps(..., sort_keys=True)`` compact form for verify JSON. */
+export declare function pythonJsonDump(value: unknown): string;
+//# sourceMappingURL=json.d.ts.map

package/dist/session/json.js

@@ -0,0 +1,29 @@
+import { expandPythonJsonSeparators } from "../text/redos-safe.js";
+/** Recursively sort object keys to match Python ``json.dumps(..., sort_keys=True)``. */
+export function sortKeys(value) {
+    if (Array.isArray(value)) {
+        return value.map(sortKeys);
+    }
+    if (value !== null && typeof value === "object") {
+        const obj = value;
+        const out = {};
+        for (const key of Object.keys(obj).sort()) {
+            out[key] = sortKeys(obj[key]);
+        }
+        return out;
+    }
+    return value;
+}
+/** Stable JSON text matching Python ritual-state writers (indent=2, sort_keys=True). */
+export function stableJson(value, indent = 0) {
+    const normalized = sortKeys(value);
+    if (indent > 0) {
+        return `${JSON.stringify(normalized, null, indent)}\n`.slice(0, -1);
+    }
+    return expandPythonJsonSeparators(JSON.stringify(normalized));
+}
+/** Python ``json.dumps(..., sort_keys=True)`` compact form for verify JSON. */
+export function pythonJsonDump(value) {
+    return stableJson(value, 0);
+}
+//# sourceMappingURL=json.js.map

package/dist/session/resume-conditions.d.ts

@@ -0,0 +1,56 @@
+export declare const RESUME_ELIGIBLE_DECISION = "resume-eligible";
+export declare const EVALUATOR_ACTOR = "agent:resume-evaluator";
+export declare const CACHE_DIR_NAME = ".deft-cache";
+export declare const CACHE_SOURCE_GITHUB_ISSUE = "github-issue";
+export declare const PENDING_LIFECYCLE_DIR = "pending";
+export declare class ResumeGrammarError extends Error {
+    constructor(message: string);
+}
+export interface Atomic {
+    readonly kind: string;
+    readonly value: number | string;
+    readonly raw: string;
+    readonly sliceId: string;
+}
+export interface Expression {
+    readonly op: "ATOM" | "AND" | "OR";
+    readonly left: Atomic;
+    readonly right: Atomic | null;
+    readonly raw: string;
+}
+export interface ResumeContext {
+    readonly today: string;
+    readonly closedRefs: ReadonlySet<number>;
+    readonly mergedRefs: ReadonlySet<number>;
+    readonly pendingCount: number;
+    readonly slices: readonly Record<string, unknown>[];
+}
+export declare function parse(expr: string): Expression;
+export declare function evaluate(expr: Expression, ctx: ResumeContext): boolean;
+export declare function buildContext(projectRoot: string, options?: {
+    cacheRoot?: string;
+    today?: string;
+    repo?: string | null;
+    slices?: readonly Record<string, unknown>[];
+}): ResumeContext;
+export interface AuditLogModule {
+    readAll: (options?: {
+        repo?: string | null;
+        path?: string;
+    }) => readonly Record<string, unknown>[];
+    append: (entry: Record<string, unknown>, options?: {
+        path?: string;
+    }) => void;
+    newDecisionId?: () => string;
+}
+export declare function evaluateResumeEligibility(projectRoot: string, options?: {
+    cacheRoot?: string;
+    auditLogPath?: string;
+    today?: string;
+    repo?: string | null;
+    logModule?: AuditLogModule | null;
+    newId?: () => string;
+    nowIso?: () => string;
+    slices?: readonly Record<string, unknown>[];
+}): Record<string, unknown>[];
+//# sourceMappingURL=resume-conditions.d.ts.map

package/dist/session/resume-conditions.js

@@ -0,0 +1,486 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+export const RESUME_ELIGIBLE_DECISION = "resume-eligible";
+export const EVALUATOR_ACTOR = "agent:resume-evaluator";
+export const CACHE_DIR_NAME = ".deft-cache";
+export const CACHE_SOURCE_GITHUB_ISSUE = "github-issue";
+export const PENDING_LIFECYCLE_DIR = "pending";
+export class ResumeGrammarError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ResumeGrammarError";
+    }
+}
+function isDigits(text) {
+    if (text.length === 0)
+        return false;
+    for (let i = 0; i < text.length; i += 1) {
+        const c = text.charCodeAt(i);
+        if (c < 48 || c > 57)
+            return false;
+    }
+    return true;
+}
+function parseIsoDate(text) {
+    if (text.length !== 10)
+        return null;
+    if (text.charCodeAt(4) !== 45 || text.charCodeAt(7) !== 45)
+        return null;
+    const y = text.slice(0, 4);
+    const m = text.slice(5, 7);
+    const d = text.slice(8, 10);
+    if (!isDigits(y) || !isDigits(m) || !isDigits(d))
+        return null;
+    return text;
+}
+function isHex(c) {
+    return (c >= 48 && c <= 57) || (c >= 97 && c <= 102) || (c >= 65 && c <= 70);
+}
+function parseUuidSegment(text, length) {
+    if (text.length !== length)
+        return false;
+    for (let i = 0; i < text.length; i += 1) {
+        if (!isHex(text.charCodeAt(i)))
+            return false;
+    }
+    return true;
+}
+function parseSliceWaveReady(text) {
+    const prefix = "slice-wave-ready:";
+    if (!text.startsWith(prefix))
+        return null;
+    const rest = text.slice(prefix.length);
+    const parts = [];
+    let current = "";
+    for (let i = 0; i < rest.length; i += 1) {
+        const ch = rest[i];
+        if (ch === ":") {
+            parts.push(current);
+            current = "";
+        }
+        else {
+            current += ch;
+        }
+    }
+    parts.push(current);
+    if (parts.length !== 2)
+        return null;
+    const sliceId = parts[0] ?? "";
+    const waveText = parts[1] ?? "";
+    const uuidParts = sliceId.split("-");
+    if (uuidParts.length !== 5 ||
+        !parseUuidSegment(uuidParts[0] ?? "", 8) ||
+        !parseUuidSegment(uuidParts[1] ?? "", 4) ||
+        !parseUuidSegment(uuidParts[2] ?? "", 4) ||
+        !parseUuidSegment(uuidParts[3] ?? "", 4) ||
+        !parseUuidSegment(uuidParts[4] ?? "", 12)) {
+        return null;
+    }
+    if (!isDigits(waveText))
+        return null;
+    const wave = Number.parseInt(waveText, 10);
+    if (wave < 1) {
+        throw new ResumeGrammarError(`slice-wave-ready wave must be a positive int, got ${wave}`);
+    }
+    return {
+        kind: "slice-wave-ready",
+        value: wave,
+        raw: text,
+        sliceId: sliceId.toLowerCase(),
+    };
+}
+function parseAtomic(raw) {
+    const text = raw.trim();
+    if (text.length === 0) {
+        throw new ResumeGrammarError("empty atomic condition");
+    }
+    const refClosedPrefix = "ref:closed:#";
+    if (text.startsWith(refClosedPrefix)) {
+        const num = text.slice(refClosedPrefix.length);
+        if (!isDigits(num)) {
+            throw new ResumeGrammarError(`unrecognised atomic condition ${JSON.stringify(text)}; expected one of: ref:closed:#N, ref:merged:#N, date:>=YYYY-MM-DD, pending-count:>=N, pending-count:<=N, slice-wave-ready:<slice_id>:<wave>`);
+        }
+        return { kind: "ref-closed", value: Number.parseInt(num, 10), raw: text, sliceId: "" };
+    }
+    const refMergedPrefix = "ref:merged:#";
+    if (text.startsWith(refMergedPrefix)) {
+        const num = text.slice(refMergedPrefix.length);
+        if (!isDigits(num)) {
+            throw new ResumeGrammarError(`unrecognised atomic condition ${JSON.stringify(text)}; expected one of: ref:closed:#N, ref:merged:#N, date:>=YYYY-MM-DD, pending-count:>=N, pending-count:<=N, slice-wave-ready:<slice_id>:<wave>`);
+        }
+        return { kind: "ref-merged", value: Number.parseInt(num, 10), raw: text, sliceId: "" };
+    }
+    const datePrefix = "date:>=";
+    if (text.startsWith(datePrefix)) {
+        const dateText = text.slice(datePrefix.length);
+        const parsed = parseIsoDate(dateText);
+        if (parsed === null) {
+            throw new ResumeGrammarError(`invalid date in ${JSON.stringify(text)}: invalid isoformat`);
+        }
+        return { kind: "date-ge", value: parsed, raw: text, sliceId: "" };
+    }
+    const pendingGePrefix = "pending-count:>=";
+    if (text.startsWith(pendingGePrefix)) {
+        const num = text.slice(pendingGePrefix.length);
+        if (!isDigits(num)) {
+            throw new ResumeGrammarError(`unrecognised atomic condition ${JSON.stringify(text)}; expected one of: ref:closed:#N, ref:merged:#N, date:>=YYYY-MM-DD, pending-count:>=N, pending-count:<=N, slice-wave-ready:<slice_id>:<wave>`);
+        }
+        return { kind: "pending-count-ge", value: Number.parseInt(num, 10), raw: text, sliceId: "" };
+    }
+    const pendingLePrefix = "pending-count:<=";
+    if (text.startsWith(pendingLePrefix)) {
+        const num = text.slice(pendingLePrefix.length);
+        if (!isDigits(num)) {
+            throw new ResumeGrammarError(`unrecognised atomic condition ${JSON.stringify(text)}; expected one of: ref:closed:#N, ref:merged:#N, date:>=YYYY-MM-DD, pending-count:>=N, pending-count:<=N, slice-wave-ready:<slice_id>:<wave>`);
+        }
+        return { kind: "pending-count-le", value: Number.parseInt(num, 10), raw: text, sliceId: "" };
+    }
+    const slice = parseSliceWaveReady(text);
+    if (slice !== null) {
+        return slice;
+    }
+    throw new ResumeGrammarError(`unrecognised atomic condition ${JSON.stringify(text)}; expected one of: ref:closed:#N, ref:merged:#N, date:>=YYYY-MM-DD, pending-count:>=N, pending-count:<=N, slice-wave-ready:<slice_id>:<wave>`);
+}
+function splitComposition(text) {
+    const andToken = " AND ";
+    const orToken = " OR ";
+    const andIdx = text.indexOf(andToken);
+    const orIdx = text.indexOf(orToken);
+    if (andIdx < 0 && orIdx < 0) {
+        return null;
+    }
+    if (andIdx >= 0 && orIdx >= 0) {
+        return null;
+    }
+    const token = andIdx >= 0 ? andToken : orToken;
+    const idx = andIdx >= 0 ? andIdx : orIdx;
+    const left = text.slice(0, idx);
+    const right = text.slice(idx + token.length);
+    if (left.includes(andToken) ||
+        left.includes(orToken) ||
+        right.includes(andToken) ||
+        right.includes(orToken)) {
+        return null;
+    }
+    const op = token.trim();
+    return [left, op, right];
+}
+export function parse(expr) {
+    if (typeof expr !== "string") {
+        throw new ResumeGrammarError(`resume_on must be a string, got ${typeof expr}`);
+    }
+    const text = expr.trim();
+    if (text.length === 0) {
+        throw new ResumeGrammarError("resume_on must be a non-empty string");
+    }
+    const parts = splitComposition(text);
+    if (parts === null) {
+        const atom = parseAtomic(text);
+        return { op: "ATOM", left: atom, right: null, raw: text };
+    }
+    const [leftRaw, op, rightRaw] = parts;
+    if (op !== "AND" && op !== "OR") {
+        throw new ResumeGrammarError(`unknown composition operator ${JSON.stringify(op)}; expected AND or OR`);
+    }
+    const left = parseAtomic(leftRaw ?? "");
+    const right = parseAtomic(rightRaw ?? "");
+    return { op, left, right, raw: text };
+}
+function sliceWaveReady(ctx, sliceId, wave) {
+    const sidNorm = sliceId.toLowerCase();
+    let record = null;
+    for (const entry of ctx.slices) {
+        const candidate = entry.slice_id;
+        if (typeof candidate === "string" && candidate.toLowerCase() === sidNorm) {
+            record = entry;
+            break;
+        }
+    }
+    if (record === null)
+        return false;
+    const children = record.children;
+    if (!Array.isArray(children))
+        return false;
+    const earlier = [];
+    for (const child of children) {
+        if (typeof child !== "object" || child === null || Array.isArray(child))
+            continue;
+        const cwave = child.wave;
+        const cn = child.n;
+        if (typeof cwave !== "number" || typeof cn !== "number")
+            continue;
+        if (cwave < wave)
+            earlier.push(cn);
+    }
+    if (earlier.length === 0)
+        return false;
+    return earlier.every((n) => ctx.closedRefs.has(n));
+}
+function evalAtomic(atom, ctx) {
+    if (atom.kind === "ref-closed") {
+        return ctx.closedRefs.has(atom.value);
+    }
+    if (atom.kind === "ref-merged") {
+        return ctx.mergedRefs.has(atom.value);
+    }
+    if (atom.kind === "date-ge") {
+        return ctx.today >= atom.value;
+    }
+    if (atom.kind === "pending-count-ge") {
+        return ctx.pendingCount >= atom.value;
+    }
+    if (atom.kind === "pending-count-le") {
+        return ctx.pendingCount <= atom.value;
+    }
+    if (atom.kind === "slice-wave-ready") {
+        return sliceWaveReady(ctx, atom.sliceId, atom.value);
+    }
+    throw new ResumeGrammarError(`evaluator missing branch for atomic kind ${JSON.stringify(atom.kind)}`);
+}
+export function evaluate(expr, ctx) {
+    if (expr.op === "ATOM") {
+        return evalAtomic(expr.left, ctx);
+    }
+    if (expr.op === "AND") {
+        if (expr.right === null) {
+            throw new ResumeGrammarError("AND expression missing right-hand atom");
+        }
+        return evalAtomic(expr.left, ctx) && evalAtomic(expr.right, ctx);
+    }
+    if (expr.op === "OR") {
+        if (expr.right === null) {
+            throw new ResumeGrammarError("OR expression missing right-hand atom");
+        }
+        return evalAtomic(expr.left, ctx) || evalAtomic(expr.right, ctx);
+    }
+    throw new ResumeGrammarError(`unknown composition op ${JSON.stringify(expr.op)}`);
+}
+function countPending(projectRoot) {
+    const folder = join(resolve(projectRoot), "vbrief", PENDING_LIFECYCLE_DIR);
+    try {
+        if (!statSync(folder).isDirectory())
+            return 0;
+    }
+    catch {
+        return 0;
+    }
+    let count = 0;
+    try {
+        for (const name of readdirSync(folder)) {
+            const full = join(folder, name);
+            try {
+                if (statSync(full).isFile() && name.endsWith(".vbrief.json")) {
+                    count += 1;
+                }
+            }
+            catch { }
+        }
+    }
+    catch {
+        return 0;
+    }
+    return count;
+}
+function* iterCachedPayloads(projectRoot, cacheRoot, repo) {
+    const base = join(cacheRoot ?? join(resolve(projectRoot), CACHE_DIR_NAME), CACHE_SOURCE_GITHUB_ISSUE);
+    try {
+        if (!statSync(base).isDirectory())
+            return;
+    }
+    catch {
+        return;
+    }
+    let targetOwner = null;
+    let targetName = null;
+    if (repo?.includes("/")) {
+        const slash = repo.indexOf("/");
+        targetOwner = repo.slice(0, slash);
+        targetName = repo.slice(slash + 1);
+    }
+    let ownerDirs;
+    try {
+        ownerDirs = readdirSync(base);
+    }
+    catch {
+        return;
+    }
+    for (const owner of ownerDirs) {
+        const ownerDir = join(base, owner);
+        try {
+            if (!statSync(ownerDir).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        if (targetOwner !== null && owner !== targetOwner)
+            continue;
+        let repoDirs;
+        try {
+            repoDirs = readdirSync(ownerDir);
+        }
+        catch {
+            continue;
+        }
+        for (const repoName of repoDirs) {
+            const repoDir = join(ownerDir, repoName);
+            try {
+                if (!statSync(repoDir).isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            if (targetName !== null && repoName !== targetName)
+                continue;
+            let issueDirs;
+            try {
+                issueDirs = readdirSync(repoDir);
+            }
+            catch {
+                continue;
+            }
+            for (const issueName of issueDirs) {
+                if (!isDigits(issueName))
+                    continue;
+                const rawPath = join(repoDir, issueName, "raw.json");
+                try {
+                    if (!existsSync(rawPath))
+                        continue;
+                    const payload = JSON.parse(readFileSync(rawPath, { encoding: "utf8" }));
+                    if (typeof payload !== "object" || payload === null || Array.isArray(payload))
+                        continue;
+                    yield [
+                        `${owner}/${repoName}`,
+                        Number.parseInt(issueName, 10),
+                        payload,
+                    ];
+                }
+                catch { }
+            }
+        }
+    }
+}
+export function buildContext(projectRoot, options = {}) {
+    const today = options.today ?? new Date().toISOString().slice(0, 10);
+    const closed = new Set();
+    const merged = new Set();
+    for (const [_slug, n, payload] of iterCachedPayloads(projectRoot, options.cacheRoot, options.repo)) {
+        const state = payload.state;
+        if (typeof state === "string" && state.toLowerCase() === "closed") {
+            closed.add(n);
+        }
+        if (payload.merged === true || payload.mergedAt) {
+            merged.add(n);
+        }
+    }
+    return {
+        today,
+        closedRefs: closed,
+        mergedRefs: merged,
+        pendingCount: countPending(projectRoot),
+        slices: options.slices ?? [],
+    };
+}
+const SUPERSEDING = new Set([
+    "accept",
+    "reject",
+    "mark-duplicate",
+    "reset",
+    RESUME_ELIGIBLE_DECISION,
+]);
+function openDeferEntries(entries) {
+    const byIssue = new Map();
+    for (const entry of entries) {
+        const repo = entry.repo;
+        const number = entry.issue_number;
+        if (typeof repo !== "string" || typeof number !== "number")
+            continue;
+        const key = `${repo}\0${number}`;
+        const rows = byIssue.get(key) ?? [];
+        rows.push(entry);
+        byIssue.set(key, rows);
+    }
+    const openDefers = [];
+    for (const rows of byIssue.values()) {
+        rows.sort((a, b) => String(a.timestamp ?? "").localeCompare(String(b.timestamp ?? "")));
+        let targetDefer = null;
+        let superseded = false;
+        for (const row of rows) {
+            const decision = row.decision;
+            if (decision === "defer") {
+                targetDefer = row;
+                superseded = false;
+            }
+            else if (typeof decision === "string" &&
+                SUPERSEDING.has(decision) &&
+                targetDefer !== null) {
+                superseded = true;
+                targetDefer = null;
+            }
+        }
+        if (targetDefer === null || superseded)
+            continue;
+        if (!targetDefer.resume_on)
+            continue;
+        openDefers.push(targetDefer);
+    }
+    return openDefers;
+}
+export function evaluateResumeEligibility(projectRoot, options = {}) {
+    const log = options.logModule ?? null;
+    if (log === null)
+        return [];
+    const newDecisionId = options.newId ?? log.newDecisionId ?? (() => randomUUID());
+    const timestampFn = options.nowIso ?? (() => new Date().toISOString().replace(/\.\d{3}Z$/, "Z"));
+    const entries = [...log.readAll({ repo: options.repo ?? null, path: options.auditLogPath })];
+    const openDefers = openDeferEntries(entries);
+    if (openDefers.length === 0)
+        return [];
+    const ctx = buildContext(projectRoot, {
+        cacheRoot: options.cacheRoot,
+        today: options.today,
+        repo: options.repo,
+        slices: options.slices,
+    });
+    const appended = [];
+    for (const deferEntry of openDefers) {
+        const expressionText = deferEntry.resume_on;
+        if (typeof expressionText !== "string")
+            continue;
+        let ast;
+        try {
+            ast = parse(expressionText);
+        }
+        catch {
+            continue;
+        }
+        if (!evaluate(ast, ctx))
+            continue;
+        const newEntry = {
+            decision_id: String(newDecisionId()),
+            timestamp: timestampFn(),
+            repo: String(deferEntry.repo),
+            issue_number: Number(deferEntry.issue_number),
+            decision: RESUME_ELIGIBLE_DECISION,
+            actor: EVALUATOR_ACTOR,
+            prior_decision_id: String(deferEntry.decision_id),
+            reason: `resume_on fired: ${expressionText}`,
+        };
+        try {
+            if (options.auditLogPath) {
+                log.append(newEntry, { path: options.auditLogPath });
+            }
+            else {
+                log.append(newEntry);
+            }
+        }
+        catch {
+            continue;
+        }
+        appended.push(newEntry);
+    }
+    return appended;
+}
+//# sourceMappingURL=resume-conditions.js.map

package/dist/session/ritual-entrypoint.d.ts

@@ -0,0 +1,20 @@
+export declare const ENTRYPOINT_TIMEOUT_SECONDS = 300;
+export declare const ENTRYPOINT_TIMEOUT_EXIT_CODE = 124;
+export type RitualEntrypointFn = (argv: readonly string[]) => number;
+/** Run an in-process ritual entrypoint with stdout/stderr capture. */
+export declare function callMain(mainFn: RitualEntrypointFn, argv: readonly string[], _options?: {
+    label?: string;
+}): {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+/** CLI-shaped cache-fresh entrypoint (mirrors scripts/preflight_cache.py main). */
+export declare function runCacheFreshMain(argv: readonly string[]): number;
+/** Default gated-tier runner: in-process doctor + cache-fresh (mirrors verify_session_ritual.py). */
+export declare function defaultRitualRunner(command: readonly string[], projectRoot: string): {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+//# sourceMappingURL=ritual-entrypoint.d.ts.map