pactwright 0.0.1

package/dist/graph/nodes.d.ts

@@ -0,0 +1,46 @@
+import type { Problem } from "../errors.js";
+import type { ParseResult } from "../config/config.js";
+import { type UnknownRecord } from "../validation.js";
+/**
+ * A Project Graph node: Markdown with YAML frontmatter (Delivery Graph §5).
+ * Only the common fields are typed here; type-specific fields stay in
+ * `frontmatter` for the schema layer to interpret.
+ */
+export interface GraphNode {
+    readonly id: string;
+    readonly type: string;
+    readonly title: string;
+    readonly created: string;
+    readonly frontmatter: Readonly<UnknownRecord>;
+    readonly body: string;
+    readonly path: string;
+}
+export declare const REQUIRED_NODE_FIELDS: readonly ["id", "type", "title", "created"];
+/** `<type>-<slug>-<short-hash>`; type and slug are lowercase kebab tokens. */
+export declare const NODE_TYPE_PATTERN: RegExp;
+export declare const NODE_ID_PATTERN: RegExp;
+export declare const CREATED_PATTERN: RegExp;
+/**
+ * Checks that `id` has the shape `<type>-<slug>-<short-hash>` and that its
+ * type prefix equals `type`. Returns problems (empty when valid).
+ */
+export declare function checkNodeId(id: string, type: string): string | undefined;
+export declare function parseNodeFile(text: string, path: string): ParseResult<GraphNode>;
+/**
+ * IDs never change (Delivery Graph §5) and records are superseded, not
+ * deleted. Compares a previous graph snapshot with a proposed one and reports
+ * `id-removed` for every id that no longer exists — which is exactly how a
+ * renamed-and-re-identified node file shows up. An in-place id edit is
+ * already rejected by `parseNodeFile` (`filename-mismatch`). New ids are fine.
+ */
+export declare function checkNodeIdImmutability(previous: readonly Pick<GraphNode, "id" | "path">[], proposed: readonly Pick<GraphNode, "id" | "path">[]): readonly Problem[];
+export interface NodesLoadResult {
+    /** Successfully parsed nodes, sorted by id. */
+    readonly nodes: readonly GraphNode[];
+    readonly problems: readonly Problem[];
+}
+/**
+ * Loads every `*.md` file directly inside `dir` as a node. A missing
+ * directory is a problem; an existing empty directory yields no nodes.
+ */
+export declare function loadNodes(dir: string): NodesLoadResult;

package/dist/graph/nodes.js

@@ -0,0 +1,137 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { basename, join } from "node:path";
+import { Checker, expectRecord, expectString, requireKeys, } from "../validation.js";
+import { parseYaml } from "../yaml.js";
+export const REQUIRED_NODE_FIELDS = ["id", "type", "title", "created"];
+/** `<type>-<slug>-<short-hash>`; type and slug are lowercase kebab tokens. */
+export const NODE_TYPE_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+export const NODE_ID_PATTERN = /^([a-z][a-z0-9]*(?:-[a-z0-9]+)*)-([a-z0-9]+(?:-[a-z0-9]+)*)-([0-9a-f]{4,})$/;
+export const CREATED_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+const FRONTMATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)([\s\S]*)$/;
+/**
+ * Checks that `id` has the shape `<type>-<slug>-<short-hash>` and that its
+ * type prefix equals `type`. Returns problems (empty when valid).
+ */
+export function checkNodeId(id, type) {
+    const match = NODE_ID_PATTERN.exec(id);
+    if (match === null)
+        return `id "${id}" must match <type>-<slug>-<short-hash>`;
+    if (!id.startsWith(`${type}-`)) {
+        return `id "${id}" must start with the node type "${type}-"`;
+    }
+    const rest = id.slice(type.length + 1);
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*-[0-9a-f]{4,}$/.test(rest)) {
+        return `id "${id}" must be "${type}-<slug>-<short-hash>"`;
+    }
+    return undefined;
+}
+export function parseNodeFile(text, path) {
+    const c = new Checker(path);
+    const match = FRONTMATTER_PATTERN.exec(text);
+    if (match === null) {
+        c.fail("missing-frontmatter", "node file must start with a YAML frontmatter block delimited by ---");
+        return { value: undefined, problems: c.problems };
+    }
+    const yaml = parseYaml(match[1] ?? "", path);
+    if (yaml.problems.length > 0)
+        return { value: undefined, problems: yaml.problems };
+    const front = expectRecord(c, yaml.value, "frontmatter");
+    if (front === undefined)
+        return { value: undefined, problems: c.problems };
+    requireKeys(c, front, "frontmatter", REQUIRED_NODE_FIELDS);
+    const id = expectString(c, front["id"], "frontmatter.id");
+    const type = expectString(c, front["type"], "frontmatter.type");
+    const title = expectString(c, front["title"], "frontmatter.title");
+    const created = expectString(c, front["created"], "frontmatter.created");
+    if (type !== undefined && !NODE_TYPE_PATTERN.test(type)) {
+        c.fail("invalid-type", `frontmatter.type "${type}" must be a lowercase kebab-case token`);
+    }
+    if (id !== undefined && type !== undefined && NODE_TYPE_PATTERN.test(type)) {
+        const idProblem = checkNodeId(id, type);
+        if (idProblem !== undefined)
+            c.fail("invalid-id", idProblem);
+    }
+    if (created !== undefined && !CREATED_PATTERN.test(created)) {
+        c.fail("invalid-value", `frontmatter.created "${created}" must be an ISO date (YYYY-MM-DD)`);
+    }
+    if (id !== undefined && basename(path) !== `${id}.md`) {
+        c.fail("filename-mismatch", `node file must be named "${id}.md" to match its id`);
+    }
+    const body = (match[2] ?? "").trim();
+    if (body.length === 0)
+        c.fail("missing-body", "node must have a Markdown body after the frontmatter");
+    if (!c.ok ||
+        id === undefined ||
+        type === undefined ||
+        title === undefined ||
+        created === undefined) {
+        return { value: undefined, problems: c.problems };
+    }
+    return { value: { id, type, title, created, frontmatter: front, body, path }, problems: [] };
+}
+/**
+ * IDs never change (Delivery Graph §5) and records are superseded, not
+ * deleted. Compares a previous graph snapshot with a proposed one and reports
+ * `id-removed` for every id that no longer exists — which is exactly how a
+ * renamed-and-re-identified node file shows up. An in-place id edit is
+ * already rejected by `parseNodeFile` (`filename-mismatch`). New ids are fine.
+ */
+export function checkNodeIdImmutability(previous, proposed) {
+    const current = new Set(proposed.map((node) => node.id));
+    return previous
+        .filter((node) => !current.has(node.id))
+        .map((node) => ({
+        code: "id-removed",
+        message: `node id "${node.id}" is missing from the proposed graph; IDs never change and nodes are superseded, not deleted`,
+        path: node.path,
+    }));
+}
+/**
+ * Loads every `*.md` file directly inside `dir` as a node. A missing
+ * directory is a problem; an existing empty directory yields no nodes.
+ */
+export function loadNodes(dir) {
+    if (!existsSync(dir) || !statSync(dir).isDirectory()) {
+        return {
+            nodes: [],
+            problems: [{ code: "missing-directory", message: "nodes directory not found", path: dir }],
+        };
+    }
+    const problems = [];
+    const nodes = [];
+    const seen = new Map();
+    const files = readdirSync(dir)
+        .filter((name) => name.endsWith(".md"))
+        .sort();
+    for (const name of files) {
+        const path = join(dir, name);
+        let content;
+        try {
+            content = readFileSync(path, "utf8");
+        }
+        catch (error) {
+            // A directory named *.md, unreadable permissions, a broken symlink:
+            // a Problem, never a raw filesystem throw out of the loader.
+            const detail = error instanceof Error ? error.message : String(error);
+            problems.push({ code: "unreadable-file", message: `cannot read file: ${detail}`, path });
+            continue;
+        }
+        const parsed = parseNodeFile(content, path);
+        problems.push(...parsed.problems);
+        if (parsed.value === undefined)
+            continue;
+        const previous = seen.get(parsed.value.id);
+        if (previous !== undefined) {
+            problems.push({
+                code: "duplicate-id",
+                message: `node id "${parsed.value.id}" is already declared in ${previous}`,
+                path,
+            });
+            continue;
+        }
+        seen.set(parsed.value.id, path);
+        nodes.push(parsed.value);
+    }
+    nodes.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    return { nodes, problems };
+}

package/dist/graph/revision.d.ts

@@ -0,0 +1,50 @@
+import type { Edge } from "./edges.js";
+import type { GraphNode } from "./nodes.js";
+/**
+ * An extension-owned canonical graph record (Assets, Publications,
+ * Deployments, Observations…). Extensions hand these to `graphRevision`; the
+ * core never interprets `record`, it only canonicalises and hashes it.
+ */
+export interface CanonicalRecord {
+    /** Extension id that owns the record. */
+    readonly owner: string;
+    /** Record kind within that extension. */
+    readonly kind: string;
+    readonly id: string;
+    /** JSON-like data: records, arrays, strings, numbers, booleans, null. */
+    readonly record: unknown;
+}
+/** Everything that contributes to the Project Graph revision (Delivery Graph §5). */
+export interface RevisionInput {
+    readonly nodes: readonly GraphNode[];
+    readonly edges: readonly Edge[];
+    /** Extension canonical records; absent means none. */
+    readonly records?: readonly CanonicalRecord[];
+}
+/** Bump only when the canonical payload shape changes; every revision changes with it. */
+export declare const REVISION_VERSION = 1;
+/** A revision is `sha256:<64 hex>`, the same shape as lock-file hashes. */
+export declare const REVISION_PATTERN: RegExp;
+/**
+ * JSON with object keys sorted recursively, `undefined` members dropped and
+ * no whitespace, so equal values always serialise to equal bytes.
+ */
+export declare function canonicalJson(value: unknown): string;
+/**
+ * The exact bytes hashed by `graphRevision`, exposed for tests and tooling.
+ *
+ * Canonicalisation (Delivery Graph §5, "canonicalise ordering before hashing"):
+ * nodes reduce to `{ id, frontmatter, body }` sorted by id — the file path is
+ * where the record sits, not graph state, and the common fields already live
+ * in the frontmatter; bodies use LF line endings; edges sort by
+ * (source, type, target); extension records sort by (owner, kind, id).
+ * Config, lock, lifecycle, lineage, reports, adapter output and any other
+ * derived or operational state never enter the payload.
+ */
+export declare function canonicalGraphPayload(input: RevisionInput): string;
+/**
+ * The deterministic Project Graph revision: sha256 over the canonical
+ * payload. The same canonical graph state always yields the same revision;
+ * nothing outside it can move it.
+ */
+export declare function graphRevision(input: RevisionInput): string;

package/dist/graph/revision.js

@@ -0,0 +1,75 @@
+import { createHash } from "node:crypto";
+import { HASH_PATTERN } from "../config/lock.js";
+import { PactwrightError } from "../errors.js";
+/** Bump only when the canonical payload shape changes; every revision changes with it. */
+export const REVISION_VERSION = 1;
+/** A revision is `sha256:<64 hex>`, the same shape as lock-file hashes. */
+export const REVISION_PATTERN = HASH_PATTERN;
+function compare(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+/**
+ * JSON with object keys sorted recursively, `undefined` members dropped and
+ * no whitespace, so equal values always serialise to equal bytes.
+ */
+export function canonicalJson(value) {
+    return canonicalise(value, new Set());
+}
+function canonicalise(value, path) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value) ?? "null";
+    if (path.has(value)) {
+        throw new PactwrightError("cyclic-value", "cannot canonicalise a value that contains itself");
+    }
+    path.add(value);
+    try {
+        if (Array.isArray(value)) {
+            return `[${value.map((item) => canonicalise(item, path)).join(",")}]`;
+        }
+        const record = value;
+        const members = Object.keys(record)
+            .filter((key) => record[key] !== undefined)
+            .sort(compare)
+            .map((key) => `${JSON.stringify(key)}:${canonicalise(record[key], path)}`);
+        return `{${members.join(",")}}`;
+    }
+    finally {
+        path.delete(value);
+    }
+}
+/**
+ * The exact bytes hashed by `graphRevision`, exposed for tests and tooling.
+ *
+ * Canonicalisation (Delivery Graph §5, "canonicalise ordering before hashing"):
+ * nodes reduce to `{ id, frontmatter, body }` sorted by id — the file path is
+ * where the record sits, not graph state, and the common fields already live
+ * in the frontmatter; bodies use LF line endings; edges sort by
+ * (source, type, target); extension records sort by (owner, kind, id).
+ * Config, lock, lifecycle, lineage, reports, adapter output and any other
+ * derived or operational state never enter the payload.
+ */
+export function canonicalGraphPayload(input) {
+    const nodes = [...input.nodes]
+        .sort((a, b) => compare(a.id, b.id))
+        .map((node) => ({
+        id: node.id,
+        frontmatter: node.frontmatter,
+        body: node.body.replace(/\r\n/g, "\n"),
+    }));
+    const edges = [...input.edges]
+        .sort((a, b) => compare(a.source, b.source) || compare(a.type, b.type) || compare(a.target, b.target))
+        .map((edge) => ({ source: edge.source, type: edge.type, target: edge.target }));
+    const records = [...(input.records ?? [])]
+        .sort((a, b) => compare(a.owner, b.owner) || compare(a.kind, b.kind) || compare(a.id, b.id))
+        .map((item) => ({ owner: item.owner, kind: item.kind, id: item.id, record: item.record }));
+    return canonicalJson({ version: REVISION_VERSION, nodes, edges, records });
+}
+/**
+ * The deterministic Project Graph revision: sha256 over the canonical
+ * payload. The same canonical graph state always yields the same revision;
+ * nothing outside it can move it.
+ */
+export function graphRevision(input) {
+    const digest = createHash("sha256").update(canonicalGraphPayload(input), "utf8").digest("hex");
+    return `sha256:${digest}`;
+}

package/dist/graph/schema.d.ts

@@ -0,0 +1,54 @@
+import { type Problem } from "../errors.js";
+import { Checker } from "../validation.js";
+import type { GraphNode } from "./nodes.js";
+/** The five durable core Delivery node types (Delivery Graph §5). */
+export declare const CORE_NODE_TYPES: readonly ["intent", "decision", "contract", "brief", "evidence"];
+export type CoreNodeType = (typeof CORE_NODE_TYPES)[number];
+/** Allowed Decision outcomes (Delivery Graph §8). */
+export declare const DECISION_OUTCOMES: readonly ["proceed", "reject", "defer"];
+export type DecisionOutcome = (typeof DECISION_OUTCOMES)[number];
+/** `decided_by` records the actual actor as `<kind>:<name>` (Delivery Graph §8). */
+export declare const DECIDED_BY_KINDS: readonly ["human", "agent", "automation"];
+export type DecidedByKind = (typeof DECIDED_BY_KINDS)[number];
+export declare const DECIDED_BY_PATTERN: RegExp;
+export interface DecidedBy {
+    readonly kind: DecidedByKind;
+    readonly name: string;
+}
+/** Splits `human:samir` into `{ kind: "human", name: "samir" }`; `undefined` when malformed. */
+export declare function parseDecidedBy(value: string): DecidedBy | undefined;
+/**
+ * A node type schema: the type-specific frontmatter fields required beyond
+ * the common ones, plus an optional deeper check run only when those fields
+ * are present.
+ */
+export interface NodeSchema {
+    readonly type: string;
+    readonly requiredFields: readonly string[];
+    readonly validate?: (node: GraphNode, c: Checker) => void;
+}
+/** Node schemas keyed by node type. */
+export type NodeSchemaRegistry = Readonly<Record<string, NodeSchema>>;
+/**
+ * Builds a frozen registry. Throws `duplicate-node-type` when two schemas
+ * claim the same type; later extensions compose registries with
+ * `createNodeSchemaRegistry([...Object.values(CORE_NODE_SCHEMAS), ...own])`.
+ */
+export declare function createNodeSchemaRegistry(schemas: readonly NodeSchema[]): NodeSchemaRegistry;
+/** Registered node types, sorted. */
+export declare function nodeTypes(registry: NodeSchemaRegistry): readonly string[];
+/**
+ * The core Delivery schema registry: exactly the five durable node types.
+ * Contract alternatives (§7), Delivery execution and Review (§11) are
+ * transient and deliberately absent.
+ */
+export declare const CORE_NODE_SCHEMAS: NodeSchemaRegistry;
+/** Validates one parsed node against the registry (Delivery Graph §21, Nodes). */
+export declare function validateNode(node: GraphNode, registry: NodeSchemaRegistry): readonly Problem[];
+export declare function validateNodes(nodes: readonly GraphNode[], registry: NodeSchemaRegistry): readonly Problem[];
+export interface DecisionFields {
+    readonly outcome: DecisionOutcome;
+    readonly decidedBy: DecidedBy;
+}
+/** Typed view of a valid decision's fields; `undefined` for any other or invalid node. */
+export declare function decisionFields(node: GraphNode): DecisionFields | undefined;

package/dist/graph/schema.js

@@ -0,0 +1,90 @@
+import { PactwrightError } from "../errors.js";
+import { Checker, requireKeys } from "../validation.js";
+/** The five durable core Delivery node types (Delivery Graph §5). */
+export const CORE_NODE_TYPES = ["intent", "decision", "contract", "brief", "evidence"];
+/** Allowed Decision outcomes (Delivery Graph §8). */
+export const DECISION_OUTCOMES = ["proceed", "reject", "defer"];
+/** `decided_by` records the actual actor as `<kind>:<name>` (Delivery Graph §8). */
+export const DECIDED_BY_KINDS = ["human", "agent", "automation"];
+export const DECIDED_BY_PATTERN = /^(human|agent|automation):\S+$/;
+/** Splits `human:samir` into `{ kind: "human", name: "samir" }`; `undefined` when malformed. */
+export function parseDecidedBy(value) {
+    if (!DECIDED_BY_PATTERN.test(value))
+        return undefined;
+    const separator = value.indexOf(":");
+    return { kind: value.slice(0, separator), name: value.slice(separator + 1) };
+}
+/**
+ * Builds a frozen registry. Throws `duplicate-node-type` when two schemas
+ * claim the same type; later extensions compose registries with
+ * `createNodeSchemaRegistry([...Object.values(CORE_NODE_SCHEMAS), ...own])`.
+ */
+export function createNodeSchemaRegistry(schemas) {
+    // Prototype-less, so a type like "constructor" can never resolve to an
+    // Object.prototype member instead of a registered schema.
+    const registry = Object.create(null);
+    for (const schema of schemas) {
+        if (Object.hasOwn(registry, schema.type)) {
+            throw new PactwrightError("duplicate-node-type", `node type "${schema.type}" is already registered`);
+        }
+        registry[schema.type] = schema;
+    }
+    return Object.freeze(registry);
+}
+/** Registered node types, sorted. */
+export function nodeTypes(registry) {
+    return Object.keys(registry).sort();
+}
+function validateDecision(node, c) {
+    const outcome = node.frontmatter["outcome"];
+    if (outcome !== undefined && !DECISION_OUTCOMES.includes(outcome)) {
+        c.fail("invalid-outcome", `frontmatter.outcome must be one of: ${DECISION_OUTCOMES.join(", ")}`);
+    }
+    const decidedBy = node.frontmatter["decided_by"];
+    if (decidedBy !== undefined &&
+        (typeof decidedBy !== "string" || !DECIDED_BY_PATTERN.test(decidedBy))) {
+        c.fail("invalid-actor", `frontmatter.decided_by must be "<kind>:<name>" with kind one of: ${DECIDED_BY_KINDS.join(", ")}`);
+    }
+}
+/**
+ * The core Delivery schema registry: exactly the five durable node types.
+ * Contract alternatives (§7), Delivery execution and Review (§11) are
+ * transient and deliberately absent.
+ */
+export const CORE_NODE_SCHEMAS = createNodeSchemaRegistry([
+    { type: "intent", requiredFields: [] },
+    { type: "decision", requiredFields: ["decided_by", "outcome"], validate: validateDecision },
+    { type: "contract", requiredFields: [] },
+    { type: "brief", requiredFields: [] },
+    { type: "evidence", requiredFields: [] },
+]);
+/** Validates one parsed node against the registry (Delivery Graph §21, Nodes). */
+export function validateNode(node, registry) {
+    const c = new Checker(node.path);
+    const schema = registry[node.type];
+    if (schema === undefined) {
+        c.fail("unknown-node-type", `node type "${node.type}" is not a registered node type (known: ${nodeTypes(registry).join(", ")})`);
+        return c.problems;
+    }
+    requireKeys(c, node.frontmatter, "frontmatter", schema.requiredFields);
+    schema.validate?.(node, c);
+    return c.problems;
+}
+export function validateNodes(nodes, registry) {
+    return nodes.flatMap((node) => validateNode(node, registry));
+}
+/** Typed view of a valid decision's fields; `undefined` for any other or invalid node. */
+export function decisionFields(node) {
+    if (node.type !== "decision")
+        return undefined;
+    const outcome = node.frontmatter["outcome"];
+    const rawActor = node.frontmatter["decided_by"];
+    if (!DECISION_OUTCOMES.includes(outcome))
+        return undefined;
+    if (typeof rawActor !== "string")
+        return undefined;
+    const decidedBy = parseDecidedBy(rawActor);
+    if (decidedBy === undefined)
+        return undefined;
+    return { outcome: outcome, decidedBy };
+}

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+export { PactwrightError, formatProblem, type Problem } from "./errors.js";
+export { ADAPTER_TYPES, CONFIG_VERSION, loadConfig, parseConfig, rewriteConfig, serialiseConfig, type ConfigExtension, type PactwrightConfig, type ParseResult, } from "./config/config.js";
+export { ACTORS, CORE_STAGES, DECISION_STAGE, EXECUTION_MODES, LIFECYCLE_VERSION, decisionActor, humanGates, isHumanGate, loadLifecycle, parseLifecycle, type Actor, type ExecutionMode, type LifecycleConfig, type StageConfig, type StageName, } from "./config/lifecycle.js";
+export { EXTENSION_ID_PATTERN, HASH_PATTERN, loadLock, parseLock, type LockExtension, type LockFile, } from "./config/lock.js";
+export { CREATED_PATTERN, NODE_ID_PATTERN, NODE_TYPE_PATTERN, REQUIRED_NODE_FIELDS, checkNodeId, checkNodeIdImmutability, loadNodes, parseNodeFile, type GraphNode, type NodesLoadResult, } from "./graph/nodes.js";
+export { CORE_NODE_SCHEMAS, CORE_NODE_TYPES, DECIDED_BY_KINDS, DECIDED_BY_PATTERN, DECISION_OUTCOMES, createNodeSchemaRegistry, decisionFields, nodeTypes, parseDecidedBy, validateNode, validateNodes, type CoreNodeType, type DecidedBy, type DecidedByKind, type DecisionFields, type DecisionOutcome, type NodeSchema, type NodeSchemaRegistry, } from "./graph/schema.js";
+export { CORE_EDGE_OWNER, CORE_EDGE_SCHEMAS, CORE_EDGE_TYPES, createEdgeSchemaRegistry, edgeTypes, validateEdges, type CoreEdgeType, type EdgeSchema, type EdgeSchemaRegistry, } from "./graph/edge-schema.js";
+export { DELIVERY_STATES, deriveLineage, deriveLineages, isCurrent, validateLineages, type DeliveryState, type Lineage, type LineageResult, } from "./graph/lineage.js";
+export { EDGE_TYPE_PATTERN, edgeKey, loadEdges, parseEdges, type Edge, type EdgesParseResult, } from "./graph/edges.js";
+export { mintNodeId, slugify } from "./graph/ids.js";
+export { createBrief, createEvidence, createIntent, recordDecision, type CreateBriefInput, type CreateEvidenceInput, type CreateIntentInput, type RecordDecisionInput, type RecordedDecision, } from "./graph/mutations.js";
+export { REVISION_PATTERN, REVISION_VERSION, canonicalGraphPayload, canonicalJson, graphRevision, type CanonicalRecord, type RevisionInput, } from "./graph/revision.js";
+export { CONFIG_FILE, EDGES_FILE, LIFECYCLE_FILE, LOCK_FILE, NODES_DIR, findProjectRoot, projectPaths, type ProjectPaths, } from "./project.js";
+export { loadProject, type LoadProjectOptions, type Project } from "./loader.js";
+export { CONFIG_TEMPLATE, INIT_DIRS, LIFECYCLE_TEMPLATE, initProject, initTemplates, type InitEntry, type InitReport, } from "./init.js";
+export { runtimeVersion } from "./version.js";
+export { GRAPH_MARKING_STAGES, TRANSIENT_STAGES, completedStages, isActive, isTransientStage, lifecycleNext, lifecycleStatus, nextActionFor, pendingStages, selectLineages, type LifecycleStatus, type LineageStatus, type NextAction, } from "./lifecycle/engine.js";
+export { noExecutor, runLifecycle, type RunOptions, type RunResult, type RunStop, type StageExecutor, type StageOutcome, type StageRequest, } from "./lifecycle/run.js";
+export { validateProject, type ValidationReport } from "./validate.js";
+export { renderGitHubWorkflows, syncProject, type SyncReport } from "./sync.js";
+export { findIntentOf, loadContext, type ContextContributor, type ContextOptions, type DeliveryContext, type ExtensionContext, type HistoryRecord, } from "./context.js";
+export { CAPABILITY_PATTERN, CORE_CAPABILITIES, missingCapabilities, requiredCapabilities, type CoreCapability, } from "./pack/capabilities.js";
+export { PACK_MANIFEST_FILE, SKILLS_DIR, loadPackManifest, parsePackManifest, skillPath, type PackAgent, type PackManifest, } from "./pack/manifest.js";
+export { agentFor, assertPackComplete, locatePack, lockEntriesFor, resolveAndLock, resolveDesiredState, resolvePack, satisfiesRange, serialiseLock, writeLock, type DesiredState, type ResolvePackOptions, type ResolvedPack, } from "./pack/resolve.js";
+export { isRecordingStage, recordStage, type RecordResult, type RecordingStage, } from "./lifecycle/record.js";
+export { EXTENSION_MANIFEST_FILE, loadExtensionManifest, parseExtensionManifest, type ExtensionManifest, } from "./extension/manifest.js";
+export { RESERVED_NAMESPACES, composedRegistries, enabledManifests, extensionLockEntries, extensionSchemas, resolveExtensions, type ResolveExtensionsOptions, type ResolvedExtension, } from "./extension/resolve.js";
+export { addExtension, removeExtension, upgradeExtension, type ExtensionChange, type ExtensionChangeReport, } from "./extension/manage.js";
+export { GENERATED_MARKER, MANAGED_DIRS, isGenerated, renderClaudeCodeAdapter, writeAdapter, type RenderedFiles, type WriteAdapterResult, } from "./adapter/claude-code.js";
+export { COMMAND_TEMPLATES, templateFor, type CommandTemplate } from "./adapter/commands.js";
+export { type AssertionResult, type CandidateRunner, type CandidateTask, type DeterministicAssertion, type EvalCase, type EvalSuite, type Observation, type ScriptedCandidate, type SemanticDimension, type SemanticJudge, type SemanticJudgement, type ViolationCandidate, } from "./eval/case.js";
+export { evalPassed, runEval, type DeterministicResult, type EvalCaseResult, type EvalOptions, type EvalReport, type SemanticResult, } from "./eval/runner.js";
+export { CORE_DELIVERY_SUITE } from "./eval/core-suite.js";

package/dist/index.js

@@ -0,0 +1,33 @@
+export { PactwrightError, formatProblem } from "./errors.js";
+export { ADAPTER_TYPES, CONFIG_VERSION, loadConfig, parseConfig, rewriteConfig, serialiseConfig, } from "./config/config.js";
+export { ACTORS, CORE_STAGES, DECISION_STAGE, EXECUTION_MODES, LIFECYCLE_VERSION, decisionActor, humanGates, isHumanGate, loadLifecycle, parseLifecycle, } from "./config/lifecycle.js";
+export { EXTENSION_ID_PATTERN, HASH_PATTERN, loadLock, parseLock, } from "./config/lock.js";
+export { CREATED_PATTERN, NODE_ID_PATTERN, NODE_TYPE_PATTERN, REQUIRED_NODE_FIELDS, checkNodeId, checkNodeIdImmutability, loadNodes, parseNodeFile, } from "./graph/nodes.js";
+export { CORE_NODE_SCHEMAS, CORE_NODE_TYPES, DECIDED_BY_KINDS, DECIDED_BY_PATTERN, DECISION_OUTCOMES, createNodeSchemaRegistry, decisionFields, nodeTypes, parseDecidedBy, validateNode, validateNodes, } from "./graph/schema.js";
+export { CORE_EDGE_OWNER, CORE_EDGE_SCHEMAS, CORE_EDGE_TYPES, createEdgeSchemaRegistry, edgeTypes, validateEdges, } from "./graph/edge-schema.js";
+export { DELIVERY_STATES, deriveLineage, deriveLineages, isCurrent, validateLineages, } from "./graph/lineage.js";
+export { EDGE_TYPE_PATTERN, edgeKey, loadEdges, parseEdges, } from "./graph/edges.js";
+export { mintNodeId, slugify } from "./graph/ids.js";
+export { createBrief, createEvidence, createIntent, recordDecision, } from "./graph/mutations.js";
+export { REVISION_PATTERN, REVISION_VERSION, canonicalGraphPayload, canonicalJson, graphRevision, } from "./graph/revision.js";
+export { CONFIG_FILE, EDGES_FILE, LIFECYCLE_FILE, LOCK_FILE, NODES_DIR, findProjectRoot, projectPaths, } from "./project.js";
+export { loadProject } from "./loader.js";
+export { CONFIG_TEMPLATE, INIT_DIRS, LIFECYCLE_TEMPLATE, initProject, initTemplates, } from "./init.js";
+export { runtimeVersion } from "./version.js";
+export { GRAPH_MARKING_STAGES, TRANSIENT_STAGES, completedStages, isActive, isTransientStage, lifecycleNext, lifecycleStatus, nextActionFor, pendingStages, selectLineages, } from "./lifecycle/engine.js";
+export { noExecutor, runLifecycle, } from "./lifecycle/run.js";
+export { validateProject } from "./validate.js";
+export { renderGitHubWorkflows, syncProject } from "./sync.js";
+export { findIntentOf, loadContext, } from "./context.js";
+export { CAPABILITY_PATTERN, CORE_CAPABILITIES, missingCapabilities, requiredCapabilities, } from "./pack/capabilities.js";
+export { PACK_MANIFEST_FILE, SKILLS_DIR, loadPackManifest, parsePackManifest, skillPath, } from "./pack/manifest.js";
+export { agentFor, assertPackComplete, locatePack, lockEntriesFor, resolveAndLock, resolveDesiredState, resolvePack, satisfiesRange, serialiseLock, writeLock, } from "./pack/resolve.js";
+export { isRecordingStage, recordStage, } from "./lifecycle/record.js";
+export { EXTENSION_MANIFEST_FILE, loadExtensionManifest, parseExtensionManifest, } from "./extension/manifest.js";
+export { RESERVED_NAMESPACES, composedRegistries, enabledManifests, extensionLockEntries, extensionSchemas, resolveExtensions, } from "./extension/resolve.js";
+export { addExtension, removeExtension, upgradeExtension, } from "./extension/manage.js";
+export { GENERATED_MARKER, MANAGED_DIRS, isGenerated, renderClaudeCodeAdapter, writeAdapter, } from "./adapter/claude-code.js";
+export { COMMAND_TEMPLATES, templateFor } from "./adapter/commands.js";
+export {} from "./eval/case.js";
+export { evalPassed, runEval, } from "./eval/runner.js";
+export { CORE_DELIVERY_SUITE } from "./eval/core-suite.js";

package/dist/init.d.ts

@@ -0,0 +1,47 @@
+import type { Problem } from "./errors.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 declare const CONFIG_TEMPLATE: string;
+/** Default `.pactwright/lifecycle.yml`: the human-gated core Delivery lifecycle (Delivery Graph §17). */
+export declare const LIFECYCLE_TEMPLATE = "version: 1\n\nstages:\n  capture-intent:\n    execution: manual\n  propose-contracts:\n    execution: automatic\n  approve-contract:\n    execution: manual\n    actor: human\n  write-brief:\n    execution: automatic\n  deliver-brief:\n    execution: automatic\n  review:\n    execution: automatic\n  prepare-evidence:\n    execution: automatic\n";
+/**
+ * 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 declare function initTemplates(): ReadonlyMap<string, string>;
+/**
+ * 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 declare const INIT_DIRS: readonly string[];
+/** One path `init` considered: what it is and what happened to it. */
+export interface InitEntry {
+    /** Repository-relative path, e.g. `.pactwright/config.yml`. */
+    readonly path: string;
+    readonly kind: "file" | "dir";
+    /** `skipped` means the path already existed and was left untouched. */
+    readonly action: "created" | "skipped";
+}
+/** `pactwright init` result. */
+export interface InitReport {
+    readonly ok: boolean;
+    readonly root: string;
+    /** Every path considered, in order; empty `problems` when `ok`. */
+    readonly entries: readonly InitEntry[];
+    readonly problems: readonly Problem[];
+}
+/**
+ * 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 declare function initProject(root?: string): InitReport;