forgium 0.1.0

package/dist/core/errors/forgium-errors.js

@@ -0,0 +1,58 @@
+export class ForgiumError extends Error {
+    code;
+    exitCode;
+    constructor(message, code, exitCode = 1) {
+        super(message);
+        this.code = code;
+        this.exitCode = exitCode;
+        this.name = new.target.name;
+    }
+}
+export class ForgiumRepositoryNotFoundError extends ForgiumError {
+    constructor() { super("No Git repository found. Run inside a Git repository or pass an explicit root.", "FORGIUM_REPOSITORY_NOT_FOUND", 3); }
+}
+export class ForgiumNotInitializedError extends ForgiumError {
+    constructor() { super("Forgium is not initialized. Run `forgium init` first.", "FORGIUM_NOT_INITIALIZED", 3); }
+}
+export class InvalidInboxItemError extends ForgiumError {
+    constructor(message) { super(message, "INVALID_INBOX_ITEM", 2); }
+}
+export class InvalidDraftError extends ForgiumError {
+    constructor(message) { super(message, "INVALID_DRAFT", 2); }
+}
+export class InvalidManifestError extends ForgiumError {
+    constructor(message) { super(message, "INVALID_MANIFEST", 2); }
+}
+export class DraftNotFoundError extends ForgiumError {
+    constructor(id) { super(`Draft not found: ${id}`, "DRAFT_NOT_FOUND", 3); }
+}
+export class DraftAlreadyExistsError extends ForgiumError {
+    constructor(id) { super(`Draft already exists: ${id}`, "DRAFT_ALREADY_EXISTS", 3); }
+}
+export class EditorUnavailableError extends ForgiumError {
+    constructor() { super("No editor configured. Set $VISUAL or $EDITOR.", "EDITOR_UNAVAILABLE", 3); }
+}
+export class ReceiptAlreadyExistsError extends ForgiumError {
+    constructor(id) { super(`Receipt already exists: ${id}`, "RECEIPT_ALREADY_EXISTS", 3); }
+}
+export class InvalidReceiptError extends ForgiumError {
+    constructor(message) { super(message, "INVALID_RECEIPT", 2); }
+}
+export class ReviewReceiptRequiredError extends ForgiumError {
+    constructor(id) { super(`Approved review receipt required before completing Feature: ${id}`, "REVIEW_RECEIPT_REQUIRED", 2); }
+}
+export class RunOptionsInvalidError extends ForgiumError {
+    constructor(message) { super(message, "RUN_OPTIONS_INVALID", 2); }
+}
+export class FeatureNotFoundError extends ForgiumError {
+    constructor(id) { super(`Feature not found: ${id}`, "FEATURE_NOT_FOUND", 3); }
+}
+export class FeatureAlreadyExistsError extends ForgiumError {
+    constructor(id) { super(`Feature already exists: ${id}`, "FEATURE_ALREADY_EXISTS", 3); }
+}
+export class FeatureStateConflictError extends ForgiumError {
+    constructor(message) { super(message, "FEATURE_STATE_CONFLICT", 3); }
+}
+export class InvalidStateTransitionError extends ForgiumError {
+    constructor(from, to) { super(`Invalid Feature transition: ${from} → ${to}`, "INVALID_STATE_TRANSITION", 3); }
+}

package/dist/core/execution/execution-adapter.d.ts

@@ -0,0 +1,35 @@
+import type { ExecutionProfile, Feature } from "../domain/types.js";
+export type ExecutionOutcome = "completed" | "verification_failed" | "blocked" | "needs_human" | "cancelled";
+export interface ExecutionRequest {
+    root: string;
+    feature: Feature;
+    profile: ExecutionProfile;
+    runId: string;
+    permissions: "repository";
+    signal?: AbortSignal;
+}
+export interface ExecutionResult {
+    outcome: ExecutionOutcome;
+    summary: string;
+    artifacts?: string[];
+    reason?: string;
+}
+export interface ExecutionAdapter {
+    readonly id: string;
+    supports(profile: ExecutionProfile): boolean;
+    isAvailable(request: ExecutionRequest): Promise<boolean>;
+    execute(request: ExecutionRequest): Promise<ExecutionResult>;
+}
+export declare class ExecutionAdapterRegistry {
+    private readonly adapters;
+    constructor(adapters?: ExecutionAdapter[]);
+    resolve(request: ExecutionRequest): Promise<ExecutionAdapter | null>;
+}
+export declare class DeterministicExecutionAdapter implements ExecutionAdapter {
+    private readonly result;
+    readonly id = "deterministic-test";
+    constructor(result?: ExecutionResult | ((request: ExecutionRequest) => ExecutionResult | Promise<ExecutionResult>));
+    supports(_profile: ExecutionProfile): boolean;
+    isAvailable(_request: ExecutionRequest): Promise<boolean>;
+    execute(request: ExecutionRequest): Promise<ExecutionResult>;
+}

package/dist/core/execution/execution-adapter.js

@@ -0,0 +1,25 @@
+export class ExecutionAdapterRegistry {
+    adapters;
+    constructor(adapters = []) {
+        this.adapters = adapters;
+    }
+    async resolve(request) {
+        for (const adapter of this.adapters) {
+            if (adapter.supports(request.profile) && await adapter.isAvailable(request))
+                return adapter;
+        }
+        return null;
+    }
+}
+export class DeterministicExecutionAdapter {
+    result;
+    id = "deterministic-test";
+    constructor(result = { outcome: "completed", summary: "Deterministic execution completed." }) {
+        this.result = result;
+    }
+    supports(_profile) { return true; }
+    async isAvailable(_request) { return true; }
+    async execute(request) {
+        return typeof this.result === "function" ? this.result(request) : this.result;
+    }
+}

package/dist/core/execution/pi-rpc-execution-adapter.d.ts

@@ -0,0 +1,13 @@
+import type { ExecutionProfile } from "../domain/types.js";
+import type { ExecutionAdapter, ExecutionRequest, ExecutionResult } from "./execution-adapter.js";
+export declare class PiRpcExecutionAdapter implements ExecutionAdapter {
+    private readonly command;
+    private readonly timeoutMs;
+    readonly id = "pi-rpc";
+    constructor(command?: string, timeoutMs?: number);
+    supports(profile: ExecutionProfile): boolean;
+    isAvailable(_request: ExecutionRequest): Promise<boolean>;
+    execute(request: ExecutionRequest): Promise<ExecutionResult>;
+}
+export declare function buildPiPrompt(request: ExecutionRequest): string;
+export declare function parsePiResult(text: string): ExecutionResult;

package/dist/core/execution/pi-rpc-execution-adapter.js

@@ -0,0 +1,119 @@
+import { spawn } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+const RESULT_PATTERN = /FORGIUM_RESULT:\s*(completed|verification_failed|blocked|needs_human|cancelled)/i;
+export class PiRpcExecutionAdapter {
+    command;
+    timeoutMs;
+    id = "pi-rpc";
+    constructor(command = process.env.FORGIUM_PI_COMMAND ?? "pi", timeoutMs = 30 * 60 * 1000) {
+        this.command = command;
+        this.timeoutMs = timeoutMs;
+    }
+    supports(profile) { return profile.kind === "direct"; }
+    async isAvailable(_request) {
+        return new Promise((resolve) => {
+            const child = spawn(this.command, ["--version"], { stdio: ["ignore", "ignore", "ignore"] });
+            child.once("error", () => resolve(false));
+            child.once("close", (code) => resolve(code === 0));
+        });
+    }
+    async execute(request) {
+        const child = spawn(this.command, ["--mode", "rpc", "--no-session"], { cwd: request.root, stdio: ["pipe", "pipe", "pipe"] });
+        const decoder = new StringDecoder("utf8");
+        let buffer = "";
+        let assistantText = "";
+        let settled = false;
+        return new Promise((resolve, reject) => {
+            const finish = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                request.signal?.removeEventListener("abort", abort);
+                child.kill();
+                resolve(result);
+            };
+            const abort = () => {
+                child.stdin.write(`${JSON.stringify({ type: "abort" })}\n`);
+                finish({ outcome: "cancelled", summary: "Pi execution was cancelled." });
+            };
+            const timeout = setTimeout(() => finish({ outcome: "cancelled", summary: `Pi execution exceeded ${this.timeoutMs}ms.` }), this.timeoutMs);
+            const handleLine = (line) => {
+                if (!line.trim())
+                    return;
+                let event;
+                try {
+                    event = JSON.parse(line);
+                }
+                catch {
+                    return;
+                }
+                if (event.type === "message_end" && event.message?.role === "assistant")
+                    assistantText = assistantTextFrom(event.message.content);
+                if (event.type === "agent_end") {
+                    const messages = event.messages ?? [];
+                    const lastAssistant = [...messages].reverse().find((message) => message.role === "assistant");
+                    if (lastAssistant)
+                        assistantText = assistantTextFrom(lastAssistant.content);
+                }
+                if (event.type === "agent_settled")
+                    finish(parsePiResult(assistantText));
+            };
+            child.stdout.on("data", (chunk) => {
+                buffer += decoder.write(chunk);
+                let newline = buffer.indexOf("\n");
+                while (newline >= 0) {
+                    const line = buffer.slice(0, newline).replace(/\r$/, "");
+                    buffer = buffer.slice(newline + 1);
+                    handleLine(line);
+                    newline = buffer.indexOf("\n");
+                }
+            });
+            child.once("error", (error) => {
+                if (!settled) {
+                    clearTimeout(timeout);
+                    reject(error);
+                }
+            });
+            child.once("close", (code) => {
+                if (!settled) {
+                    clearTimeout(timeout);
+                    resolve(code === 0 ? parsePiResult(assistantText) : { outcome: "needs_human", summary: `Pi exited before producing a Forgium result (code ${code ?? "unknown"}).` });
+                }
+            });
+            request.signal?.addEventListener("abort", abort, { once: true });
+            child.stdin.write(`${JSON.stringify({ id: request.runId, type: "prompt", message: buildPiPrompt(request) })}\n`);
+        });
+    }
+}
+export function buildPiPrompt(request) {
+    const profile = request.profile.kind === "direct"
+        ? "Implement the Feature directly."
+        : `Follow the repository's spec-driven workflow using ${request.profile.specPath}.`;
+    return [
+        "You are the execution engine for Forgium.",
+        `Work only inside repository: ${request.root}`,
+        `Feature: ${request.feature.id}`,
+        `Title: ${request.feature.manifest.title}`,
+        `Goal: ${request.feature.manifest.goal}`,
+        `Acceptance criteria:\n${request.feature.manifest.acceptance.map((criterion) => `- ${criterion}`).join("\n")}`,
+        profile,
+        "Do not edit Forgium state directories, manifests, or receipts.",
+        "When finished, print exactly one final line: FORGIUM_RESULT: completed, verification_failed, blocked, needs_human, or cancelled.",
+        "If you cannot establish completion safely, use FORGIUM_RESULT: needs_human."
+    ].join("\n\n");
+}
+export function parsePiResult(text) {
+    const match = text.match(RESULT_PATTERN);
+    if (!match)
+        return { outcome: "needs_human", summary: "Pi finished without a recognized Forgium result marker." };
+    const outcome = match[1].toLowerCase();
+    return { outcome, summary: `Pi reported ${outcome}.` };
+}
+function assistantTextFrom(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content.filter((part) => typeof part === "object" && part !== null && part.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n");
+}

package/dist/core/execution/spec-flow-execution-adapter.d.ts

@@ -0,0 +1,14 @@
+import type { ExecutionProfile } from "../domain/types.js";
+import type { ExecutionAdapter, ExecutionRequest, ExecutionResult } from "./execution-adapter.js";
+export declare class SpecFlowExecutionAdapter implements ExecutionAdapter {
+    private readonly command;
+    private readonly timeoutMs;
+    readonly id = "pi-spec-flow";
+    constructor(command?: string, timeoutMs?: number);
+    supports(profile: ExecutionProfile): boolean;
+    isAvailable(_request: ExecutionRequest): Promise<boolean>;
+    execute(request: ExecutionRequest): Promise<ExecutionResult>;
+}
+export declare function buildSpecFlowStatusPrompt(request: ExecutionRequest): string;
+export declare function buildSpecFlowSafetyPrompt(request: ExecutionRequest): string;
+export declare function parseSpecFlowStatusResult(value: unknown): ExecutionResult | null;

package/dist/core/execution/spec-flow-execution-adapter.js

@@ -0,0 +1,233 @@
+import { spawn } from "node:child_process";
+import { appendFileSync } from "node:fs";
+import { StringDecoder } from "node:string_decoder";
+const RESULT_PATTERN = /FORGIUM_SPEC_FLOW_RESULT:\s*(completed|blocked|needs_human|cancelled)/i;
+export class SpecFlowExecutionAdapter {
+    command;
+    timeoutMs;
+    id = "pi-spec-flow";
+    constructor(command = process.env.FORGIUM_PI_COMMAND ?? "pi", timeoutMs = 30 * 60 * 1000) {
+        this.command = command;
+        this.timeoutMs = timeoutMs;
+    }
+    supports(profile) {
+        return profile.kind === "spec-flow";
+    }
+    async isAvailable(_request) {
+        return new Promise((resolve) => {
+            const child = spawn(this.command, ["--version"], { stdio: ["ignore", "ignore", "ignore"] });
+            child.once("error", () => resolve(false));
+            child.once("close", (code) => resolve(code === 0));
+        });
+    }
+    async execute(request) {
+        const profile = request.profile;
+        if (profile.kind !== "spec-flow") {
+            return { outcome: "needs_human", summary: "Spec Flow adapter received an unsupported execution profile." };
+        }
+        const child = spawn(this.command, [
+            "--mode",
+            "rpc",
+            "--no-session",
+            "--append-system-prompt",
+            buildSpecFlowSafetyPrompt(request),
+        ], {
+            cwd: request.root,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const decoder = new StringDecoder("utf8");
+        let buffer = "";
+        let assistantText = "";
+        let statusResult = null;
+        let statusRequested = false;
+        let settled = false;
+        return new Promise((resolve, reject) => {
+            const finish = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                request.signal?.removeEventListener("abort", abort);
+                child.kill();
+                resolve(result);
+            };
+            const send = (message) => {
+                if (child.stdin.destroyed)
+                    return;
+                child.stdin.write(`${JSON.stringify(message)}\n`);
+            };
+            const abort = () => {
+                send({ type: "abort" });
+                finish({ outcome: "cancelled", summary: "Spec Flow execution was cancelled." });
+            };
+            const timeout = setTimeout(() => finish({ outcome: "needs_human", summary: `Spec Flow execution exceeded ${this.timeoutMs}ms.` }), this.timeoutMs);
+            const requestStatus = () => {
+                if (statusRequested)
+                    return;
+                statusRequested = true;
+                send({
+                    id: `${request.runId}-status`,
+                    type: "prompt",
+                    message: buildSpecFlowStatusPrompt(request),
+                });
+            };
+            const handleUiRequest = (event) => {
+                if (!event.id || !event.method)
+                    return;
+                if (event.method === "select") {
+                    const options = Array.isArray(event.options)
+                        ? event.options.filter((option) => typeof option === "string")
+                        : [];
+                    const proceed = options.find((option) => /yes,? proceed/i.test(option));
+                    send(proceed
+                        ? { type: "extension_ui_response", id: event.id, value: proceed }
+                        : { type: "extension_ui_response", id: event.id, cancelled: true });
+                    return;
+                }
+                if (event.method === "confirm") {
+                    send({ type: "extension_ui_response", id: event.id, confirmed: false });
+                }
+            };
+            const handleLine = (line) => {
+                if (!line.trim())
+                    return;
+                appendRpcDebugLine(line);
+                let event;
+                try {
+                    event = JSON.parse(line);
+                }
+                catch {
+                    return;
+                }
+                if (event.type === "extension_ui_request")
+                    handleUiRequest(event);
+                if (event.type === "tool_execution_end" && event.toolName === "spec_flow_status") {
+                    statusResult = parseSpecFlowStatusResult(event.result?.details);
+                }
+                if (event.type === "message_end" && event.message?.role === "assistant") {
+                    assistantText = assistantTextFrom(event.message.content);
+                }
+                if (event.type === "agent_end") {
+                    const messages = event.messages ?? [];
+                    const lastAssistant = [...messages].reverse().find((message) => message.role === "assistant");
+                    if (lastAssistant)
+                        assistantText = assistantTextFrom(lastAssistant.content);
+                }
+                if (event.type === "agent_settled") {
+                    if (!statusRequested) {
+                        requestStatus();
+                        return;
+                    }
+                    finish(statusResult
+                        ?? parseSpecFlowMarker(assistantText)
+                        ?? { outcome: "needs_human", summary: "Spec Flow finished without a structured status result." });
+                }
+            };
+            child.stdout.on("data", (chunk) => {
+                buffer += decoder.write(chunk);
+                let newline = buffer.indexOf("\n");
+                while (newline >= 0) {
+                    const line = buffer.slice(0, newline).replace(/\r$/, "");
+                    buffer = buffer.slice(newline + 1);
+                    handleLine(line);
+                    newline = buffer.indexOf("\n");
+                }
+            });
+            child.once("error", (error) => {
+                if (!settled) {
+                    clearTimeout(timeout);
+                    reject(error);
+                }
+            });
+            child.once("close", (code) => {
+                if (!settled) {
+                    clearTimeout(timeout);
+                    resolve(code === 0
+                        ? statusResult ?? { outcome: "needs_human", summary: "Spec Flow exited without a structured status result." }
+                        : { outcome: "needs_human", summary: `Pi exited before producing a Spec Flow status (code ${code ?? "unknown"}).` });
+                }
+            });
+            request.signal?.addEventListener("abort", abort, { once: true });
+            send({ id: request.runId, type: "prompt", message: profile.commands.implement });
+        });
+    }
+}
+function appendRpcDebugLine(line) {
+    const debugPath = process.env.FORGIUM_PI_RPC_LOG;
+    if (!debugPath)
+        return;
+    try {
+        appendFileSync(debugPath, `${line}\n`, "utf8");
+    }
+    catch {
+        // Diagnostics must never alter execution behaviour.
+    }
+}
+export function buildSpecFlowStatusPrompt(request) {
+    if (request.profile.kind !== "spec-flow")
+        return "";
+    return [
+        "The Spec Flow implementation command has settled.",
+        "Do not edit files or start another implementation block.",
+        `Call the read-only spec_flow_status tool with spec_path: ${JSON.stringify(request.profile.specPath)}.`,
+        "Use the tool result as the only source of truth.",
+        "If complete is true, report FORGIUM_SPEC_FLOW_RESULT: completed.",
+        "Otherwise report FORGIUM_SPEC_FLOW_RESULT: needs_human.",
+    ].join("\n");
+}
+export function buildSpecFlowSafetyPrompt(request) {
+    return [
+        "You are operating as a delegated Spec Flow implementation agent inside Forgium.",
+        "Modify only files required by the current Spec Flow ticket.",
+        "Never modify, move, delete, or create files under product/, features/, or .forgium/.",
+        "Forgium owns Feature manifests, Feature state directories, leases, and receipts.",
+        `The repository root is ${request.root}.`,
+    ].join("\n");
+}
+export function parseSpecFlowStatusResult(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const status = value;
+    if (typeof status.complete !== "boolean") {
+        return { outcome: "needs_human", summary: "Spec Flow returned an invalid status payload." };
+    }
+    if (typeof status.total !== "number" || status.total < 1) {
+        return { outcome: "needs_human", summary: "Spec Flow has no inspectable tickets." };
+    }
+    if (status.complete) {
+        return {
+            outcome: "completed",
+            summary: `Spec Flow completed ${status.done ?? status.total}/${status.total} tickets.`,
+        };
+    }
+    const pendingReview = status.checkpoints?.pendingReview ?? 0;
+    const issueSummary = status.issues?.filter(Boolean).slice(0, 3).join(" ");
+    const reason = pendingReview > 0
+        ? `${pendingReview} checkpoint review(s) are pending.`
+        : issueSummary || `Spec Flow has not completed all ${status.total} tickets.`;
+    return {
+        outcome: "needs_human",
+        summary: `Spec Flow requires human attention: ${reason}`,
+        reason,
+    };
+}
+function parseSpecFlowMarker(text) {
+    const match = text.match(RESULT_PATTERN);
+    if (!match)
+        return null;
+    const outcome = match[1].toLowerCase();
+    return { outcome, summary: `Spec Flow reported ${outcome}.` };
+}
+function assistantTextFrom(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((part) => typeof part === "object"
+        && part !== null
+        && part.type === "text"
+        && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("\n");
+}

package/dist/core/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./domain/types.js";
+export * from "./errors/forgium-errors.js";
+export * from "./repository/filesystem-forgium-repository.js";
+export * from "./repository/repo-discovery.js";
+export * from "./services/id.js";
+export * from "./services/spec-flow-commands.js";
+export * from "./schemas/draft.schema.js";
+export * from "./schemas/receipt.schema.js";
+export * from "./execution/execution-adapter.js";
+export * from "./execution/pi-rpc-execution-adapter.js";
+export * from "./execution/spec-flow-execution-adapter.js";

package/dist/core/index.js

@@ -0,0 +1,11 @@
+export * from "./domain/types.js";
+export * from "./errors/forgium-errors.js";
+export * from "./repository/filesystem-forgium-repository.js";
+export * from "./repository/repo-discovery.js";
+export * from "./services/id.js";
+export * from "./services/spec-flow-commands.js";
+export * from "./schemas/draft.schema.js";
+export * from "./schemas/receipt.schema.js";
+export * from "./execution/execution-adapter.js";
+export * from "./execution/pi-rpc-execution-adapter.js";
+export * from "./execution/spec-flow-execution-adapter.js";

package/dist/core/repository/filesystem-forgium-repository.d.ts

@@ -0,0 +1,68 @@
+import type { CaptureInput, CreateFeatureInput, Draft, ExecutionProfile, Feature, FeatureState, InboxItem, Receipt, ReceiptEvidence, RepositoryStatus, ReviewDecision, ValidationReport, VerificationReceipt } from "../domain/types.js";
+import type { ExecutionOutcome } from "../execution/execution-adapter.js";
+import { ExecutionAdapterRegistry } from "../execution/execution-adapter.js";
+export declare class FilesystemForgiumRepository {
+    readonly root: string;
+    private readonly paths;
+    constructor(root: string);
+    init(): Promise<void>;
+    capture(input: CaptureInput): Promise<InboxItem>;
+    listInbox(): Promise<InboxItem[]>;
+    listDrafts(): Promise<Draft[]>;
+    getDraft(id: string): Promise<Draft | null>;
+    createDraftFromInbox(id: string): Promise<Draft>;
+    deferInbox(id: string): Promise<InboxItem>;
+    mergeInbox(id: string, featureId: string): Promise<InboxItem>;
+    promoteDraft(id: string): Promise<Feature>;
+    createFeature(input: CreateFeatureInput): Promise<Feature>;
+    listReceipts(featureId: string): Promise<Receipt[]>;
+    verifyFeature(id: string, options?: {
+        evidence?: ReceiptEvidence[];
+        runId?: string;
+    }): Promise<VerificationReceipt>;
+    reviewFeature(id: string, decision: ReviewDecision, summary: string, actorName?: string): Promise<Feature>;
+    executeFeature(id: string, registry: ExecutionAdapterRegistry): Promise<{
+        outcome: ExecutionOutcome | "needs_human";
+        feature: Feature;
+        summary: string;
+        adapterId?: string;
+    }>;
+    listFeatures(state?: FeatureState): Promise<Feature[]>;
+    getFeature(id: string): Promise<Feature | null>;
+    getNextReady(): Promise<Feature | null>;
+    startFeature(id: string): Promise<Feature>;
+    submitForReview(id: string): Promise<Feature>;
+    completeFeature(id: string): Promise<Feature>;
+    returnToDoing(id: string): Promise<Feature>;
+    unblockFeature(id: string): Promise<Feature>;
+    blockFeature(id: string, reason: string): Promise<Feature>;
+    inspectExecutionMode(id: string): Promise<ExecutionProfile>;
+    getStatus(): Promise<RepositoryStatus>;
+    validate(): Promise<ValidationReport>;
+    private transition;
+    private createLease;
+    private requireFeature;
+    private requireInbox;
+    private requireDraft;
+    private assertInitialized;
+    private createVerificationReceipt;
+    private createReviewReceipt;
+    private createExecutionReceipt;
+    private createHandoffReceipt;
+    private receiptBase;
+    private persistReceipt;
+    private validateReceiptFiles;
+    private validateReceiptReferences;
+    private hasApprovedReviewReceipt;
+    private readFeature;
+    private readDraft;
+    private readInboxFile;
+    private writeInboxItem;
+    private renderDraft;
+    private parsePromotableDraft;
+    private featureIdExists;
+    private countDirectories;
+    private renderInbox;
+    private ensureGitignoreRuntime;
+    private writeFileAtomic;
+}