pactwright 0.0.1

package/dist/init.js

@@ -0,0 +1,132 @@
+import { existsSync, mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { MANAGED_DIRS } from "./adapter/claude-code.js";
+import { tempSibling } from "./atomic.js";
+import { loadConfig } from "./config/config.js";
+import { serialiseEdges } from "./graph/mutations.js";
+import { resolveDesiredState, writeLock } from "./pack/resolve.js";
+import { runtimeVersion } from "./version.js";
+import { CONFIG_FILE, EDGES_FILE, LIFECYCLE_FILE, LOCK_FILE, NODES_DIR, projectPaths, } from "./project.js";
+import { validateProject } from "./validate.js";
+/**
+ * Default `.pactwright/config.yml` (Distribution §3): the `@pactwright/standard`
+ * pack with Claude Code defaults. `github.enabled` stays `false` until GitHub
+ * provisioning exists (Distribution §§9–14); `init` creates no `.github/`
+ * content.
+ */
+export const CONFIG_TEMPLATE = `version: 1
+
+agent_pack:
+  source: "@pactwright/standard"
+  version: "^${runtimeVersion()}"
+
+adapter:
+  type: claude-code
+
+extensions: {}
+
+github:
+  enabled: false
+`;
+/** Default `.pactwright/lifecycle.yml`: the human-gated core Delivery lifecycle (Delivery Graph §17). */
+export const LIFECYCLE_TEMPLATE = `version: 1
+
+stages:
+  capture-intent:
+    execution: manual
+  propose-contracts:
+    execution: automatic
+  approve-contract:
+    execution: manual
+    actor: human
+  write-brief:
+    execution: automatic
+  deliver-brief:
+    execution: automatic
+  review:
+    execution: automatic
+  prepare-evidence:
+    execution: automatic
+`;
+/** Keeps `specs/nodes/` tracked by git; `loadNodes` reads only `*.md` and never sees it. */
+const NODES_KEEP_FILE = `${NODES_DIR}/.gitkeep`;
+/**
+ * The files `init` owns, in report order: relative path → content. The lock
+ * is not a template — it is resolved from the on-disk configuration after
+ * these files exist.
+ */
+export function initTemplates() {
+    return new Map([
+        [CONFIG_FILE, CONFIG_TEMPLATE],
+        [LIFECYCLE_FILE, LIFECYCLE_TEMPLATE],
+        [NODES_KEEP_FILE, ""],
+        [EDGES_FILE, serialiseEdges([])],
+    ]);
+}
+/**
+ * Directories `init` creates empty: the Claude Code adapter surface, filled
+ * by `pactwright sync` (Distribution §8) — `init` never copies runtime
+ * scripts, agents or commands into the repository (Distribution §2).
+ */
+export const INIT_DIRS = MANAGED_DIRS;
+/**
+ * Initialises the Pactwright-owned core structure (Distribution §§2–3) in
+ * `root`: configuration, lifecycle, the empty graph, the empty adapter
+ * directories, then the resolved `.pactwright/lock.yml`. Existing paths are
+ * never read or overwritten — each is reported `skipped` — so re-running in
+ * an initialised repository changes nothing. Finishes by validating the
+ * resulting project state; never throws for expected failures.
+ */
+export function initProject(root = process.cwd()) {
+    const paths = projectPaths(root);
+    const entries = [];
+    const problems = [];
+    const failed = () => ({ ok: false, root: paths.root, entries, problems });
+    for (const [relPath, content] of initTemplates()) {
+        const target = join(paths.root, relPath);
+        if (existsSync(target)) {
+            entries.push({ path: relPath, kind: "file", action: "skipped" });
+            continue;
+        }
+        mkdirSync(dirname(target), { recursive: true });
+        const temp = tempSibling(target);
+        writeFileSync(temp, content, "utf8");
+        renameSync(temp, target);
+        entries.push({ path: relPath, kind: "file", action: "created" });
+    }
+    for (const relPath of INIT_DIRS) {
+        const target = join(paths.root, relPath);
+        if (existsSync(target)) {
+            entries.push({ path: relPath, kind: "dir", action: "skipped" });
+        }
+        else {
+            mkdirSync(target, { recursive: true });
+            entries.push({ path: relPath, kind: "dir", action: "created" });
+        }
+    }
+    // The lock records exact resolved state (Distribution §3), so a fresh one
+    // is derived from whatever configuration is on disk — which after the step
+    // above is either the template or pre-existing user content. An existing
+    // lock is trusted as-is; `resolveDesiredState` is used rather than
+    // `resolveAndLock` because the latter loads the full project, which
+    // requires the lock to already exist.
+    if (existsSync(paths.lock)) {
+        entries.push({ path: LOCK_FILE, kind: "file", action: "skipped" });
+    }
+    else {
+        const config = loadConfig(paths.config);
+        if (config.value === undefined) {
+            problems.push(...config.problems);
+            return failed();
+        }
+        const resolved = resolveDesiredState({ root: paths.root, config: config.value });
+        if (resolved.value === undefined) {
+            problems.push(...resolved.problems);
+            return failed();
+        }
+        writeLock(paths.lock, resolved.value.lock);
+        entries.push({ path: LOCK_FILE, kind: "file", action: "created" });
+    }
+    problems.push(...validateProject({ root: paths.root }).problems);
+    return { ok: problems.length === 0, root: paths.root, entries, problems };
+}

package/dist/lifecycle/engine.d.ts

@@ -0,0 +1,75 @@
+import type { Problem } from "../errors.js";
+import { type Actor, type ExecutionMode, type StageName } from "../config/lifecycle.js";
+import { type DeliveryState, type Lineage } from "../graph/lineage.js";
+import type { Project } from "../loader.js";
+/**
+ * Stages that leave a durable record in the Delivery Graph, and the record
+ * they leave (Delivery Graph §§6–12): capture-intent → Intent,
+ * approve-contract → Decision (+ Contract), write-brief → Brief,
+ * prepare-evidence → Evidence.
+ */
+export declare const GRAPH_MARKING_STAGES: readonly ["capture-intent", "approve-contract", "write-brief", "prepare-evidence"];
+/**
+ * Stages whose output is transient (§7 alternatives, §11 delivery execution
+ * and review): they never mutate the graph, so completion is only known
+ * inside the `lifecycle run` that executed them.
+ */
+export declare const TRANSIENT_STAGES: readonly ["propose-contracts", "deliver-brief", "review"];
+export declare function isTransientStage(stage: StageName): boolean;
+/** Stages already completed by a lineage, in lifecycle order. */
+export declare function completedStages(lineage: Lineage | undefined): readonly StageName[];
+/**
+ * Stages still to run for a lineage, in order. Empty for terminal lineages.
+ * With no lineage, the only pending stage is capture-intent.
+ */
+export declare function pendingStages(lineage: Lineage | undefined): readonly StageName[];
+/** A lineage still progressing through the core lifecycle. */
+export declare function isActive(lineage: Lineage): boolean;
+/** `lifecycle status` for one lineage (Delivery Graph §20). */
+export interface LineageStatus {
+    /** Absent for the "no lineage yet" entry. */
+    readonly intent?: string;
+    readonly state: DeliveryState | "none";
+    /** Set when the intent itself is superseded: the lineage is frozen (§15). */
+    readonly superseded?: true;
+    readonly completed: readonly StageName[];
+    /** First pending stage; absent when the core lifecycle has no next stage. */
+    readonly currentStage?: StageName;
+    /** Set when `currentStage` is a human gate. */
+    readonly blockedStage?: StageName;
+    readonly requiredActor?: Actor;
+    readonly lineage?: Lineage;
+}
+export interface LifecycleStatus {
+    readonly lineages: readonly LineageStatus[];
+    /** Current-lineage problems found while deriving (empty for a loaded project). */
+    readonly problems: readonly Problem[];
+}
+/** `lifecycle next` for one lineage: the next permitted action, not executed. */
+export interface NextAction {
+    readonly intent?: string;
+    /** Absent when there is no further core Delivery stage. */
+    readonly stage?: StageName;
+    readonly execution?: ExecutionMode;
+    readonly actor?: Actor;
+    /** True when the stage needs a human: `lifecycle run` stops here. */
+    readonly gate: boolean;
+    readonly reason: string;
+}
+/**
+ * The lineages `status`/`next`/`run` operate on: the one named by `intentId`,
+ * else every lineage sorted by intent id. When the graph has no active
+ * lineage and no id was given, one `undefined` entry stands for the
+ * capture-intent entry point.
+ */
+export declare function selectLineages(project: Project, intentId?: string): readonly (Lineage | undefined)[];
+/**
+ * Derives lifecycle status from graph state + lifecycle.yml (§18, §20).
+ * Validation problems of a project that failed to load are the caller's to
+ * report: a `Project` here has already passed the canonical loader.
+ */
+export declare function lifecycleStatus(project: Project, intentId?: string): LifecycleStatus;
+/** The next permitted action for one lineage, given optionally which transient stages already ran. */
+export declare function nextActionFor(project: Project, lineage: Lineage | undefined, done?: ReadonlySet<StageName>): NextAction;
+/** `lifecycle next`: the next permitted core Delivery action per lineage (§20). */
+export declare function lifecycleNext(project: Project, intentId?: string): readonly NextAction[];

package/dist/lifecycle/engine.js

@@ -0,0 +1,146 @@
+import { PactwrightError } from "../errors.js";
+import { CORE_STAGES, isHumanGate, } from "../config/lifecycle.js";
+import { deriveLineages } from "../graph/lineage.js";
+/**
+ * Stages that leave a durable record in the Delivery Graph, and the record
+ * they leave (Delivery Graph §§6–12): capture-intent → Intent,
+ * approve-contract → Decision (+ Contract), write-brief → Brief,
+ * prepare-evidence → Evidence.
+ */
+export const GRAPH_MARKING_STAGES = [
+    "capture-intent",
+    "approve-contract",
+    "write-brief",
+    "prepare-evidence",
+];
+/**
+ * Stages whose output is transient (§7 alternatives, §11 delivery execution
+ * and review): they never mutate the graph, so completion is only known
+ * inside the `lifecycle run` that executed them.
+ */
+export const TRANSIENT_STAGES = [
+    "propose-contracts",
+    "deliver-brief",
+    "review",
+];
+export function isTransientStage(stage) {
+    return TRANSIENT_STAGES.includes(stage);
+}
+/**
+ * How many leading core stages each derived state has completed (§14, §18).
+ * `deferred`/`rejected` completed the decision stage and are terminal for the
+ * core lifecycle: resuming needs a new Decision (§15), which is not a stage
+ * the engine loops back to. `undefined` = no lineage yet: nothing completed.
+ */
+const COMPLETED_COUNT = {
+    open: 1, // capture-intent
+    deferred: 3, // …propose-contracts, approve-contract
+    rejected: 3,
+    contracted: 3,
+    delivering: 4, // …write-brief
+    done: 7,
+};
+const TERMINAL_STATES = ["deferred", "rejected", "done"];
+/** Stages already completed by a lineage, in lifecycle order. */
+export function completedStages(lineage) {
+    return CORE_STAGES.slice(0, lineage === undefined ? 0 : COMPLETED_COUNT[lineage.state]);
+}
+/**
+ * Stages still to run for a lineage, in order. Empty for terminal lineages.
+ * With no lineage, the only pending stage is capture-intent.
+ */
+export function pendingStages(lineage) {
+    if (lineage === undefined)
+        return ["capture-intent"];
+    if (lineage.superseded)
+        return [];
+    if (TERMINAL_STATES.includes(lineage.state))
+        return [];
+    return CORE_STAGES.slice(COMPLETED_COUNT[lineage.state]);
+}
+/** A lineage still progressing through the core lifecycle. */
+export function isActive(lineage) {
+    return !lineage.superseded && !TERMINAL_STATES.includes(lineage.state);
+}
+function findLineage(project, intentId, lineages) {
+    const lineage = lineages.find((candidate) => candidate.intent.id === intentId);
+    if (lineage === undefined) {
+        const exists = project.graph.nodes.some((node) => node.id === intentId && node.type === "intent");
+        throw new PactwrightError(exists ? "ambiguous-lineage" : "unknown-intent", exists
+            ? `intent "${intentId}" has an ambiguous lineage; fix validation problems first`
+            : `"${intentId}" is not an intent in this project`);
+    }
+    return lineage;
+}
+/**
+ * The lineages `status`/`next`/`run` operate on: the one named by `intentId`,
+ * else every lineage sorted by intent id. When the graph has no active
+ * lineage and no id was given, one `undefined` entry stands for the
+ * capture-intent entry point.
+ */
+export function selectLineages(project, intentId) {
+    const { lineages } = deriveLineages(project.graph.nodes, project.graph.edges);
+    if (intentId !== undefined)
+        return [findLineage(project, intentId, lineages)];
+    if (!lineages.some(isActive))
+        return [...lineages, undefined];
+    return lineages;
+}
+function statusOf(project, lineage) {
+    const currentStage = pendingStages(lineage)[0];
+    const base = {
+        ...(lineage === undefined ? {} : { intent: lineage.intent.id, lineage }),
+        state: lineage === undefined ? "none" : lineage.state,
+        ...(lineage?.superseded === true ? { superseded: true } : {}),
+        completed: completedStages(lineage),
+        ...(currentStage === undefined ? {} : { currentStage }),
+    };
+    if (currentStage === undefined)
+        return base;
+    const config = project.lifecycle.stages[currentStage];
+    if (!isHumanGate(config))
+        return base;
+    return { ...base, blockedStage: currentStage, requiredActor: "human" };
+}
+/**
+ * Derives lifecycle status from graph state + lifecycle.yml (§18, §20).
+ * Validation problems of a project that failed to load are the caller's to
+ * report: a `Project` here has already passed the canonical loader.
+ */
+export function lifecycleStatus(project, intentId) {
+    const { problems } = deriveLineages(project.graph.nodes, project.graph.edges);
+    return {
+        lineages: selectLineages(project, intentId).map((lineage) => statusOf(project, lineage)),
+        problems,
+    };
+}
+/** The next permitted action for one lineage, given optionally which transient stages already ran. */
+export function nextActionFor(project, lineage, done = new Set()) {
+    const intent = lineage === undefined ? {} : { intent: lineage.intent.id };
+    const stage = pendingStages(lineage).find((candidate) => !done.has(candidate));
+    if (stage === undefined) {
+        const reason = lineage?.superseded === true
+            ? `intent "${lineage.intent.id}" is superseded; work continues on the superseding intent's lineage (Delivery Graph §15)`
+            : lineage?.state === "done"
+                ? "current Evidence exists; the core Delivery lifecycle is complete and has no next stage"
+                : `lineage is ${lineage?.state}; record a new Decision with approve-contract to resume (Delivery Graph §15)`;
+        return { ...intent, gate: false, reason };
+    }
+    const config = project.lifecycle.stages[stage];
+    const gate = isHumanGate(config);
+    const who = config.actor === undefined ? "" : ` by ${config.actor}`;
+    return {
+        ...intent,
+        stage,
+        execution: config.execution,
+        ...(config.actor === undefined ? {} : { actor: config.actor }),
+        gate,
+        reason: gate
+            ? `${stage} is a human gate (${config.execution}${who}); it waits for a human`
+            : `${stage} runs ${config.execution}${who}`,
+    };
+}
+/** `lifecycle next`: the next permitted core Delivery action per lineage (§20). */
+export function lifecycleNext(project, intentId) {
+    return selectLineages(project, intentId).map((lineage) => nextActionFor(project, lineage));
+}

package/dist/lifecycle/record.d.ts

@@ -0,0 +1,18 @@
+import type { StageName } from "../config/lifecycle.js";
+import type { GraphNode } from "../graph/nodes.js";
+import { GRAPH_MARKING_STAGES } from "./engine.js";
+/** A stage that leaves a durable record (Delivery Graph §§6–12). */
+export type RecordingStage = (typeof GRAPH_MARKING_STAGES)[number];
+export declare function isRecordingStage(stage: string): stage is RecordingStage;
+/** The nodes one `lifecycle record` created, in creation order. */
+export interface RecordResult {
+    readonly stage: RecordingStage;
+    readonly created: readonly GraphNode[];
+}
+/**
+ * `pactwright lifecycle record <stage> --file <yaml>`: the runtime
+ * responsibility an adapter command hands finished content to. The runtime
+ * checks the transition, then the Step 7 mutation validates and writes the
+ * complete proposed state atomically. Nothing is written on any failure.
+ */
+export declare function recordStage(root: string, stage: StageName, inputPath: string): RecordResult;

package/dist/lifecycle/record.js

@@ -0,0 +1,157 @@
+import { PactwrightError } from "../errors.js";
+import { findIntentOf } from "../context.js";
+import { createBrief, createEvidence, createIntent, recordDecision, } from "../graph/mutations.js";
+import { DECISION_OUTCOMES } from "../graph/schema.js";
+import { loadProject } from "../loader.js";
+import { Checker, expectEnum, expectRecord, expectString, isRecord, rejectUnknownKeys, requireKeys, } from "../validation.js";
+import { readYamlFile } from "../yaml.js";
+import { GRAPH_MARKING_STAGES, isTransientStage, nextActionFor, pendingStages, selectLineages, } from "./engine.js";
+export function isRecordingStage(stage) {
+    return GRAPH_MARKING_STAGES.includes(stage);
+}
+/**
+ * Reads the content file an adapter command hands to the runtime. The
+ * shape is per stage (see `REQUIRED`/`ALLOWED`); every problem in the file
+ * is reported in one pass.
+ */
+const REQUIRED = {
+    "capture-intent": ["title", "body"],
+    "approve-contract": ["intent", "outcome", "decided_by", "body"],
+    "write-brief": ["contract", "title", "body"],
+    "prepare-evidence": ["brief", "title", "body"],
+};
+const ALLOWED = {
+    "capture-intent": ["title", "body"],
+    "approve-contract": ["intent", "outcome", "decided_by", "title", "body", "contract"],
+    "write-brief": ["contract", "title", "body"],
+    "prepare-evidence": ["brief", "title", "body"],
+};
+function readFields(stage, path) {
+    const file = readYamlFile(path);
+    if (file.problems.length > 0)
+        throw PactwrightError.fromProblems("invalid-record-input", file.problems);
+    const c = new Checker(path);
+    if (!isRecord(file.value)) {
+        c.fail("invalid-type", "record input must be a mapping");
+        throw PactwrightError.fromProblems("invalid-record-input", c.problems);
+    }
+    const record = file.value;
+    requireKeys(c, record, "record input", REQUIRED[stage]);
+    rejectUnknownKeys(c, record, "record input", ALLOWED[stage]);
+    const fields = {};
+    for (const key of ALLOWED[stage]) {
+        if (!(key in record))
+            continue;
+        if (stage === "approve-contract" && key === "contract") {
+            const contract = expectRecord(c, record[key], "contract");
+            if (contract !== undefined) {
+                requireKeys(c, contract, "contract", ["title", "body"]);
+                rejectUnknownKeys(c, contract, "contract", ["title", "body"]);
+                fields[key] = {
+                    title: expectString(c, contract["title"], "contract.title"),
+                    body: expectString(c, contract["body"], "contract.body"),
+                };
+            }
+        }
+        else if (key === "outcome") {
+            fields[key] = expectEnum(c, record[key], "outcome", DECISION_OUTCOMES);
+        }
+        else {
+            fields[key] = expectString(c, record[key], key);
+        }
+    }
+    if (!c.ok)
+        throw PactwrightError.fromProblems("invalid-record-input", c.problems);
+    return fields;
+}
+/**
+ * The runtime's transition check (Delivery Graph §18): the stage being
+ * recorded must be pending for the lineage the input refers to, with only
+ * transient stages (whose completion the graph cannot show) before it.
+ * capture-intent starts a new lineage and is always permitted.
+ */
+function assertPermitted(project, stage, anchor) {
+    if (stage === "capture-intent")
+        return;
+    const intent = stage === "approve-contract"
+        ? project.graph.nodes.find((node) => node.id === anchor && node.type === "intent")
+        : findIntentOf(anchor, project.graph.nodes, project.graph.edges);
+    if (intent === undefined) {
+        throw new PactwrightError("unknown-node", `"${anchor}" is not part of any Delivery lineage`);
+    }
+    const [lineage] = selectLineages(project, intent.id);
+    // §15: deferred and rejected lineages resume by recording a new Decision,
+    // which is exactly what approve-contract does. Frozen (superseded)
+    // lineages stay refused.
+    if (stage === "approve-contract" &&
+        lineage !== undefined &&
+        !lineage.superseded &&
+        (lineage.state === "deferred" || lineage.state === "rejected")) {
+        return;
+    }
+    const pending = pendingStages(lineage);
+    const index = pending.indexOf(stage);
+    if (index < 0 || !pending.slice(0, index).every(isTransientStage)) {
+        const action = nextActionFor(project, lineage);
+        throw new PactwrightError("stage-not-permitted", `${stage} is not a permitted action for intent "${intent.id}" now: ${action.reason}`);
+    }
+}
+/**
+ * `pactwright lifecycle record <stage> --file <yaml>`: the runtime
+ * responsibility an adapter command hands finished content to. The runtime
+ * checks the transition, then the Step 7 mutation validates and writes the
+ * complete proposed state atomically. Nothing is written on any failure.
+ */
+export function recordStage(root, stage, inputPath) {
+    if (!isRecordingStage(stage)) {
+        throw new PactwrightError("no-graph-record", `stage "${stage}" leaves no graph record; only ${GRAPH_MARKING_STAGES.join(", ")} can be recorded`);
+    }
+    const fields = readFields(stage, inputPath);
+    const project = loadProject({ root });
+    switch (stage) {
+        case "capture-intent":
+            return { stage, created: [createIntent(root, { title: fields.title, body: fields.body })] };
+        case "approve-contract": {
+            assertPermitted(project, stage, fields.intent);
+            const input = {
+                intentId: fields.intent,
+                outcome: fields.outcome,
+                decidedBy: fields.decided_by,
+                body: fields.body,
+                ...(fields.title === undefined ? {} : { title: fields.title }),
+                ...(fields.contract === undefined || typeof fields.contract === "string"
+                    ? {}
+                    : { contract: fields.contract }),
+            };
+            const result = recordDecision(root, input);
+            return {
+                stage,
+                created: result.contract === undefined ? [result.decision] : [result.decision, result.contract],
+            };
+        }
+        case "write-brief":
+            assertPermitted(project, stage, fields.contract);
+            return {
+                stage,
+                created: [
+                    createBrief(root, {
+                        contractId: fields.contract,
+                        title: fields.title,
+                        body: fields.body,
+                    }),
+                ],
+            };
+        case "prepare-evidence":
+            assertPermitted(project, stage, fields.brief);
+            return {
+                stage,
+                created: [
+                    createEvidence(root, {
+                        briefId: fields.brief,
+                        title: fields.title,
+                        body: fields.body,
+                    }),
+                ],
+            };
+    }
+}

package/dist/lifecycle/run.d.ts

@@ -0,0 +1,62 @@
+import { type Problem } from "../errors.js";
+import type { Actor, StageName } from "../config/lifecycle.js";
+import { type Lineage } from "../graph/lineage.js";
+import { type Project } from "../loader.js";
+/** What a stage executor reports back to the runtime. */
+export type StageOutcome = {
+    readonly status: "completed";
+} | {
+    readonly status: "failed";
+    readonly message: string;
+};
+export interface StageRequest {
+    readonly stage: StageName;
+    /**
+     * Read-only derivation input (which lineage, which config) — never a
+     * mutation base. Executors that mutate the graph pass
+     * `project.paths.root` to the typed mutations, which load and validate
+     * the current graph state themselves at commit time.
+     */
+    readonly project: Project;
+    /** Absent for capture-intent on a graph with no active lineage. */
+    readonly lineage?: Lineage;
+}
+/**
+ * Executes one automatic stage's responsibility (Delivery Graph §16). The
+ * runtime decides *which* stage runs and when; the executor only performs
+ * it, mutating the graph through the Step 7 mutations where the stage
+ * leaves a record. Later checkpoints plug the agent pack in here.
+ */
+export type StageExecutor = (request: StageRequest) => StageOutcome | Promise<StageOutcome>;
+/** Why `lifecycle run` stopped (Delivery Graph §20). */
+export type RunStop = "completed" | "human-gate" | "stage-failed" | "validation-error";
+export interface RunResult {
+    readonly intent?: string;
+    readonly stop: RunStop;
+    /** The gate reached or the stage that failed. */
+    readonly stage?: StageName;
+    readonly requiredActor?: Actor;
+    /** Stages executed in this run, in order. */
+    readonly executed: readonly StageName[];
+    readonly message?: string;
+    readonly problems?: readonly Problem[];
+}
+export interface RunOptions {
+    readonly root: string;
+    readonly execute: StageExecutor;
+    readonly intentId?: string;
+}
+/**
+ * The runtime has no way to perform automatic stages until an agent pack is
+ * installed (Checkpoint 1, Step 10): every automatic stage fails, so `run`
+ * stops there instead of pretending.
+ */
+export declare const noExecutor: StageExecutor;
+/**
+ * `lifecycle run` (Delivery Graph §20): runs automatic stages of every
+ * active lineage (or the one `intentId`) until a human gate, completion, a
+ * stage failure or a validation error. Gates are checked by the runtime on
+ * every step, so a configured gate is never skipped whatever the executor
+ * could do. Never throws for expected failures.
+ */
+export declare function runLifecycle(options: RunOptions): Promise<readonly RunResult[]>;