@webpresso/agent-kit 3.3.2 → 3.3.4

package/dist/esm/compose/registry-resolve.js

@@ -0,0 +1,200 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { resolvePackageAssetPreferred } from "#utils/package-assets.js";
+import { z } from "zod";
+const REGISTRY_RELATIVE = join("generated", "frontend", "blocks", "registry.json");
+const MAX_WALK = 48;
+/**
+ * Local reader capability floor for project registries (agent-kit consumer).
+ * Bump in the same PR as catalog/compose/admin-blocks-registry.json major/minor
+ * advances. Does not import @webpresso/schema (SEA / nondeterminism lock).
+ */
+export const READER_REGISTRY_VERSION = "1.0.0";
+/** Stop climbing past these markers (mirrors project-root clamps elsewhere). */
+function isProjectBoundary(dir) {
+    return existsSync(join(dir, ".git")) || existsSync(join(dir, ".webpressorc.json"));
+}
+/**
+ * `~/.webpresso` is the managed-worktree host, never a product project root.
+ * Matching it would mis-label every uninitialized checkout under $HOME.
+ */
+function isManagedHostWebpresso(candidate) {
+    return resolve(candidate) === resolve(join(homedir(), ".webpresso"));
+}
+const blockDefinitionSchema = z
+    .object({
+    name: z.string(),
+    view: z.enum(["list", "detail", "form"]),
+    description: z.string().optional(),
+    props: z.array(z.unknown()).optional(),
+    variants: z.array(z.string()).optional(),
+    slots: z.array(z.unknown()).optional(),
+    permissions: z.array(z.unknown()).optional(),
+    deprecated: z.boolean().optional(),
+})
+    .passthrough();
+export const blockRegistrySchema = z.object({
+    $schema: z.string().optional(),
+    version: z.string(),
+    minVersion: z.string().optional(),
+    blocks: z.array(blockDefinitionSchema).min(1),
+});
+/**
+ * Walk up for nearest project `.webpresso` directory (not a file).
+ * Clamped at the enclosing project boundary (`.git` / `.webpressorc.json`)
+ * and never treats `~/.webpresso` (managed worktree host) as a project root.
+ */
+function walkUpForWebpressoDir(startDir) {
+    let dir = resolve(startDir);
+    for (let i = 0; i < MAX_WALK; i++) {
+        const candidate = join(dir, ".webpresso");
+        if (existsSync(candidate)) {
+            try {
+                if (statSync(candidate).isDirectory() && !isManagedHostWebpresso(candidate)) {
+                    return candidate;
+                }
+            }
+            catch {
+                // ignore unreadable markers
+            }
+        }
+        // Do not climb past the repo / consumer root into $HOME tooling dirs.
+        if (isProjectBoundary(dir))
+            return null;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+    return null;
+}
+export function defaultSnapshotPath() {
+    // Portable across src/ and dist/esm/ via package-root walk (no fixed-depth joins).
+    const assetPath = resolvePackageAssetPreferred(["catalog/compose/admin-blocks-registry.json"]);
+    if (!existsSync(assetPath)) {
+        throw new Error(`admin-blocks-registry.json snapshot not found at package asset path: ${assetPath}`);
+    }
+    return assetPath;
+}
+function loadRegistryFile(path) {
+    try {
+        const raw = readFileSync(path, "utf8");
+        const parsed = JSON.parse(raw);
+        return blockRegistrySchema.parse(parsed);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to load block registry at ${path}: ${detail}`, { cause: error });
+    }
+}
+function parseSemver(version) {
+    const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version.trim());
+    if (!match)
+        return null;
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+    };
+}
+/**
+ * Whether a loaded project registry is readable by this agent-kit consumer.
+ * - registry.version major must match the reader major
+ * - if registry.minVersion is set, reader must be >= that floor (semver order)
+ */
+export function isProjectRegistryCompatibleWithReader(registry, readerVersion = READER_REGISTRY_VERSION) {
+    const reader = parseSemver(readerVersion);
+    if (!reader) {
+        return { ok: false, reason: `reader version "${readerVersion}" is not semver` };
+    }
+    const produced = parseSemver(registry.version);
+    if (!produced) {
+        return { ok: false, reason: `registry version "${registry.version}" is not semver` };
+    }
+    if (produced.major !== reader.major) {
+        return {
+            ok: false,
+            reason: `registry major ${produced.major} incompatible with reader major ${reader.major} (${readerVersion})`,
+        };
+    }
+    if (registry.minVersion !== undefined) {
+        const min = parseSemver(registry.minVersion);
+        if (!min) {
+            return { ok: false, reason: `registry minVersion "${registry.minVersion}" is not semver` };
+        }
+        const belowMin = reader.major < min.major ||
+            (reader.major === min.major && reader.minor < min.minor) ||
+            (reader.major === min.major && reader.minor === min.minor && reader.patch < min.patch);
+        if (belowMin) {
+            return {
+                ok: false,
+                reason: `reader ${readerVersion} is below registry minVersion ${registry.minVersion}`,
+            };
+        }
+    }
+    return { ok: true };
+}
+/**
+ * Two-tier registry resolution (v0):
+ * 1. Nearest project `.webpresso/` (within git/webpressorc boundary) — if it has
+ *    generated blocks registry, use it
+ * 2. Else catalog snapshot (with warning when that project `.webpresso/` lacks registry)
+ *
+ * Never dynamically imports @webpresso/schema.
+ * Never climbs past the project boundary into `~/.webpresso` (managed worktree host)
+ * or other ancestor projects (avoids silent wrong-project catalog).
+ */
+export function resolveBlockRegistry(options = {}) {
+    const start = options.cwd
+        ? isAbsolute(options.cwd)
+            ? options.cwd
+            : resolve(process.cwd(), options.cwd)
+        : process.cwd();
+    const webpressoRoot = walkUpForWebpressoDir(start);
+    const warnings = [];
+    if (webpressoRoot) {
+        const projectPath = join(webpressoRoot, REGISTRY_RELATIVE);
+        if (existsSync(projectPath)) {
+            try {
+                const registry = loadRegistryFile(projectPath);
+                const compat = isProjectRegistryCompatibleWithReader(registry);
+                if (!compat.ok) {
+                    warnings.push(`Project registry at ${projectPath} incompatible with reader ${READER_REGISTRY_VERSION} (${compat.reason}); using catalog snapshot.`);
+                }
+                else {
+                    return {
+                        registry,
+                        source: "project",
+                        registryVersion: registry.version,
+                        path: projectPath,
+                        warnings,
+                        webpressoPresentWithoutRegistry: false,
+                    };
+                }
+            }
+            catch (error) {
+                // Producer codegen can advance ahead of this consumer's schema; prefer
+                // snapshot over hard-failing MCP tools on version skew.
+                const detail = error instanceof Error ? error.message : String(error);
+                warnings.push(`Project registry at ${projectPath} failed validation (${detail}); using catalog snapshot. Regenerate or align registry schema.`);
+            }
+        }
+    }
+    const snapshotPath = options.snapshotPath ?? defaultSnapshotPath();
+    const registry = loadRegistryFile(snapshotPath);
+    if (webpressoRoot && warnings.length === 0) {
+        warnings.push(`Project has .webpresso/ at ${webpressoRoot} but no ${join(".webpresso", REGISTRY_RELATIVE)}; using catalog snapshot ${registry.version}. Run schema frontend codegen / converge to materialize a project registry.`);
+    }
+    return {
+        registry,
+        source: "snapshot",
+        registryVersion: registry.version,
+        path: snapshotPath,
+        warnings,
+        webpressoPresentWithoutRegistry: webpressoRoot !== null && !existsSync(join(webpressoRoot, REGISTRY_RELATIVE)),
+    };
+}
+export function blockNamesForView(registry, view) {
+    return new Set(registry.blocks.filter((block) => block.view === view).map((block) => block.name));
+}

package/dist/esm/config/oxlint/graphql-conventions.js

@@ -7,6 +7,7 @@
 // causes runtime errors: "field 'user' not found in type: 'query_root'"
 //
 // This rule scans template literals and string literals for known singular patterns and reports them.
+import { isWebAppSurface, normalizeFilename } from "./path-roles.js";
 // Mapping of singular table patterns to their correct plural/actual GraphQL field names.
 // Format: [singular, correct, description]
 const SINGULAR_TABLE_RULES = [
@@ -76,9 +77,6 @@ const INLINE_GRAPHQL_EXEMPT_PATH_SEGMENTS = [
     "/packages/sdk/schema-engine/src/emitters/",
     "/packages/feature/app-core/src/daemon/",
 ];
-function normalizeFilename(filename) {
-    return typeof filename === "string" ? filename.replaceAll("\\", "/") : "";
-}
 function getFilename(context) {
     if (typeof context.getFilename === "function") {
         return normalizeFilename(context.getFilename());
@@ -92,9 +90,8 @@ function isClientQuerySurface(filename) {
     if (INLINE_GRAPHQL_EXEMPT_PATH_SEGMENTS.some((segment) => normalized.includes(segment))) {
         return false;
     }
-    const isWebAppSurface = normalized.includes("/apps/web/") && normalized.includes("/app/");
     const isFeatureSurface = normalized.includes("/packages/feature/") && normalized.includes("/src/");
-    return isWebAppSurface || isFeatureSurface;
+    return isWebAppSurface(normalized) || isFeatureSurface;
 }
 function getNodeStart(node) {
     if (Array.isArray(node?.range) && typeof node.range[0] === "number") {

package/dist/esm/config/oxlint/import-hygiene.js

@@ -4,6 +4,8 @@
 // - no-src-path-imports
 // - no-relative-mock-paths
 // - no-forbidden-package-imports
+import { isAgentKitSeaTreeFile, isPlatformAppFile, isSdkPackageFile, normalizeFilename, } from "./path-roles.js";
+export { isAgentKitSeaTreeFile, isPlatformAppFile, isSdkPackageFile, normalizeFilename, } from "./path-roles.js";
 const CROSS_PACKAGE_SEGMENT = /(?:^|\/)(packages|apps|tooling|infra|webpresso)\//;
 function isRelativeParentPath(source) {
     return typeof source === "string" && source.includes("../");
@@ -32,9 +34,6 @@ function reportCrossPackageImport(context, node) {
         message: "Do not reach into another package/app with a relative filesystem import. Add a proper package export and import it via the package name.",
     });
 }
-function normalizeFilename(filename) {
-    return typeof filename === "string" ? filename.replaceAll("\\", "/") : "";
-}
 function getFilename(context) {
     if (typeof context.getFilename === "function") {
         return normalizeFilename(context.getFilename());
@@ -46,12 +45,16 @@ function checkStaticModuleSource(node, callback) {
         return;
     callback(node.source.value, node.source);
 }
-function isPlatformAppFile(filename) {
-    return filename.includes("/apps/workers/") || filename.includes("/apps/web/");
-}
-function isSdkPackageFile(filename) {
-    return filename.includes("/packages/sdk/");
+/** Package imports forbidden in agent-kit SEA surfaces (schema + ui paint kits). */
+export function isSeaForbiddenPackageImport(source) {
+    if (typeof source !== "string")
+        return false;
+    return (source === "@webpresso/schema" ||
+        source.startsWith("@webpresso/schema/") ||
+        source === "@webpresso/ui" ||
+        source.startsWith("@webpresso/ui/"));
 }
+export const SEA_FORBIDDEN_IMPORT_MESSAGE = "Agent-kit SEA surfaces (compose / wp_ui_*) must not import `@webpresso/schema` or `@webpresso/ui`. Use the two-tier block registry snapshot/project file and local Zod/HTML paint instead (offline / nondeterminism lock).";
 function isSchemaEngineImport(source) {
     return typeof source === "string" && source.startsWith("@webpresso/schema/engine/");
 }
@@ -147,6 +150,16 @@ const noForbiddenPackageImports = {
         function checkImport(source, node) {
             if (typeof source !== "string")
                 return;
+            // Agent-kit SEA / offline compose — ban before monorepo platform allow rules.
+            // Consumers still get this rule via shipped oxlintrc; monorepo apps do not match
+            // isAgentKitSeaTreeFile so public schema imports remain allowed there.
+            if (isAgentKitSeaTreeFile(filename) && isSeaForbiddenPackageImport(source)) {
+                context.report({
+                    node,
+                    message: SEA_FORBIDDEN_IMPORT_MESSAGE,
+                });
+                return;
+            }
             if (isPlatformAppFile(filename) &&
                 isSchemaEngineImport(source) &&
                 source !== "@webpresso/schema/engine/api") {

package/dist/esm/config/oxlint/oxlint-config.fixture.d.ts

@@ -1,2 +1,2 @@
-import { config } from "./index.js";
+import { config } from "@webpresso/agent-config/oxlint";
 export default config;

package/dist/esm/config/oxlint/oxlint-config.fixture.js

@@ -1,4 +1,3 @@
-import { config } from "./index.js";
-// Consumer repos can use the same shape from the public subpath:
-// import { config } from 'webpresso/oxlint'
+import { config } from "@webpresso/agent-config/oxlint";
+// Shape parity for folded config consumers (agent-config is the SSOT).
 export default config;

package/dist/esm/config/oxlint/oxlintrc.d.ts

@@ -1,16 +1,13 @@
 /**
  * Compiled plugin module basenames shipped next to the generated oxlintrc.json.
- * Kept in lockstep with the plugin set in `index.ts` (guarded by the parity
- * test in `oxlintrc.test.ts`, which asserts one entry per registered plugin).
+ * Must match agent-config policy plugins (guarded by vendor + parity tests).
  */
 export declare const OXLINT_PLUGIN_BASENAMES: readonly ["code-safety", "foundation-purity", "graphql-conventions", "import-hygiene", "monorepo-paths", "query-patterns", "testing-quality", "tier-boundaries"];
 /** jsPlugins specifiers, sibling-relative to the shipped oxlintrc.json. */
 export declare const OXLINT_JS_PLUGIN_FILES: readonly string[];
 /**
  * Standard ignore patterns for every webpresso consumer: build output, vendored
- * deps, generated reports, and the regenerated agent-surface directories. These
- * are project-relative. Truly repo-specific extras belong in a consumer-local
- * `.oxlintignore`, never here.
+ * deps, generated reports, and the regenerated agent-surface directories.
  */
 export declare const STANDARD_IGNORE_PATTERNS: readonly string[];
 export interface ResolvedOxlintRc {
@@ -18,9 +15,10 @@ export interface ResolvedOxlintRc {
     readonly rules: Readonly<Record<string, "error">>;
     readonly ignorePatterns: readonly string[];
 }
+/** Rule map from agent-config SSOT (error severity for inject). */
+export declare const rules: Readonly<Record<string, "error">>;
 /**
  * Build the resolved oxlint config object that ships as `oxlintrc.json`. Pure:
- * the build-time generator serializes this return value verbatim, and the
- * parity test asserts it against the live `rules`/`plugins` exports.
+ * the build-time generator serializes this return value verbatim.
  */
 export declare function buildOxlintrc(): ResolvedOxlintRc;

package/dist/esm/config/oxlint/oxlintrc.js

@@ -1,26 +1,24 @@
 /**
  * Resolved, consumer-ready oxlint configuration (Tier-1 DRY model).
  *
- * agent-kit ships ONE resolved `.oxlintrc.json` — generated from this builder
- * at build time into `dist/esm/config/oxlint/oxlintrc.json` — and `wp lint`
- * points oxlint at it via `--config`. Consumers therefore carry no
- * `oxlint.config.ts` and no `oxlint` dependency; the linter version, plugins,
- * rules, and standard ignores are all gated to @webpresso/agent-kit.
+ * agent-kit ships ONE resolved `.oxlintrc.json` — generated at build time into
+ * `dist/esm/config/oxlint/oxlintrc.json` — and `wp lint` points oxlint at it via
+ * `--config` for consumers without a local oxlint config.
  *
- * Two oxlint resolution facts (verified against oxlint 1.67) make this work:
- * - `jsPlugins` are resolved relative to the CONFIG FILE's directory, so the
- *   specifiers below are sibling-relative (`./<plugin>.js`) to the shipped JSON
- *   — zero package-resolution machinery, no dependency on @webpresso/agent-kit
- *   being resolvable from the config's location.
- * - `ignorePatterns` are applied relative to the LINTED project (cwd), not the
- *   config-file directory, so `dist`/`node_modules`/etc. ignore the consumer's
- *   tree even though the config lives inside node_modules.
+ * Plugin *bodies* are authored in `@webpresso/agent-config/oxlint/*` (consumer
+ * SSOT). Build vendors compiled sibling `.js` next to oxlintrc.json so inject
+ * needs no runtime agent-config dependency. Monorepos with their own lint
+ * config load `@webpresso/agent-config/oxlint/*` package names directly.
+ *
+ * Two oxlint resolution facts (verified against oxlint 1.67) make inject work:
+ * - `jsPlugins` are resolved relative to the CONFIG FILE's directory
+ *   (`./<plugin>.js` siblings of the shipped JSON).
+ * - `ignorePatterns` apply relative to the LINTED project (cwd).
  */
-import { rules } from "./index.js";
+import { rules as agentConfigRules } from "@webpresso/agent-config/oxlint";
 /**
  * Compiled plugin module basenames shipped next to the generated oxlintrc.json.
- * Kept in lockstep with the plugin set in `index.ts` (guarded by the parity
- * test in `oxlintrc.test.ts`, which asserts one entry per registered plugin).
+ * Must match agent-config policy plugins (guarded by vendor + parity tests).
  */
 export const OXLINT_PLUGIN_BASENAMES = [
     "code-safety",
@@ -36,9 +34,7 @@ export const OXLINT_PLUGIN_BASENAMES = [
 export const OXLINT_JS_PLUGIN_FILES = OXLINT_PLUGIN_BASENAMES.map((name) => `./${name}.js`);
 /**
  * Standard ignore patterns for every webpresso consumer: build output, vendored
- * deps, generated reports, and the regenerated agent-surface directories. These
- * are project-relative. Truly repo-specific extras belong in a consumer-local
- * `.oxlintignore`, never here.
+ * deps, generated reports, and the regenerated agent-surface directories.
  */
 export const STANDARD_IGNORE_PATTERNS = [
     "dist",
@@ -53,10 +49,11 @@ export const STANDARD_IGNORE_PATTERNS = [
     ".opencode",
     ".runtime",
 ];
+/** Rule map from agent-config SSOT (error severity for inject). */
+export const rules = agentConfigRules;
 /**
  * Build the resolved oxlint config object that ships as `oxlintrc.json`. Pure:
- * the build-time generator serializes this return value verbatim, and the
- * parity test asserts it against the live `rules`/`plugins` exports.
+ * the build-time generator serializes this return value verbatim.
  */
 export function buildOxlintrc() {
     return {

package/dist/esm/config/oxlint/path-roles.js

@@ -0,0 +1,53 @@
+// @ts-nocheck
+/**
+ * Shared path classifiers for webpresso oxlint policy plugins.
+ * Pure functions only — no AST. Consumers resolve plugins from
+ * `@webpresso/agent-config/oxlint/*`; these markers must match real trees.
+ */
+/** Normalize Windows paths for substring role checks. */
+export function normalizeFilename(filename) {
+    return typeof filename === "string" ? filename.replaceAll("\\", "/") : "";
+}
+/**
+ * Offline / SEA-shaped agent-kit surfaces (compose + UI MCP tools).
+ * Monorepo apps never use these path segments.
+ */
+export function isAgentKitSeaTreeFile(filename) {
+    const n = normalizeFilename(filename);
+    if (n.includes("/node_modules/"))
+        return false;
+    return n.includes("/src/compose/") || n.includes("/src/mcp/tools/wp-ui-");
+}
+/** Platform web apps: real monorepo layout + legacy `/apps/web/`. */
+export function isPlatformWebFile(filename) {
+    const n = normalizeFilename(filename);
+    if (n.includes("/node_modules/"))
+        return false;
+    return n.includes("/apps/platform/web/") || n.includes("/apps/web/");
+}
+/** Platform workers: real monorepo layout + legacy `/apps/workers/`. */
+export function isPlatformWorkerFile(filename) {
+    const n = normalizeFilename(filename);
+    if (n.includes("/node_modules/"))
+        return false;
+    return n.includes("/apps/platform/workers/") || n.includes("/apps/workers/");
+}
+/** Platform apps (web or worker) for import-hygiene schema-surface rules. */
+export function isPlatformAppFile(filename) {
+    return isPlatformWebFile(filename) || isPlatformWorkerFile(filename);
+}
+/**
+ * Client UI surfaces for GraphQL/query-pattern rules.
+ * Real monorepo: apps/platform/web/.../app/; legacy apps/web/.../app/.
+ */
+export function isWebAppSurface(filename) {
+    const n = normalizeFilename(filename);
+    if (n.includes("/node_modules/"))
+        return false;
+    if (!n.includes("/app/"))
+        return false;
+    return n.includes("/apps/platform/web/") || n.includes("/apps/web/");
+}
+export function isSdkPackageFile(filename) {
+    return normalizeFilename(filename).includes("/packages/sdk/");
+}

package/dist/esm/config/oxlint/query-patterns.js

@@ -1,8 +1,6 @@
 // @ts-nocheck
+import { isWebAppSurface, normalizeFilename } from "./path-roles.js";
 const QUERY_HOOK_NAMES = new Set(["useQuery", "useSuspenseQuery", "useInfiniteQuery"]);
-function normalizeFilename(filename) {
-    return typeof filename === "string" ? filename.replaceAll("\\", "/") : "";
-}
 function getFilename(context) {
     if (typeof context.getFilename === "function") {
         return normalizeFilename(context.getFilename());
@@ -15,9 +13,8 @@ function isClientQuerySurface(filename) {
         return false;
     if (normalized.includes("/.webpresso/generated/"))
         return false;
-    const isWebAppSurface = normalized.includes("/apps/web/") && normalized.includes("/app/");
     const isFeatureSurface = normalized.includes("/packages/feature/") && normalized.includes("/src/");
-    return isWebAppSurface || isFeatureSurface;
+    return isWebAppSurface(normalized) || isFeatureSurface;
 }
 function getCalleeName(callee) {
     if (!callee)

package/dist/esm/daemon/domains/blueprint-exec-ledger.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Blueprint exec run ledger: durable job ↔ PTY session ↔ blueprint attribution.
+ *
+ * Why this exists separately from the launch ledger: a launch handle is
+ * single-use and is consumed the moment Rust claims it, and the PTY reaper
+ * reports that *a* session ended but not which blueprint it belonged to.
+ * Neither can answer "what is this terminal running?" after a UI restart. A
+ * job id that outlives both can.
+ *
+ * Rows are deliberately env-free and argv-free: this ledger is readable by the
+ * webview, so it must never carry launch material.
+ */
+export declare const BLUEPRINT_EXEC_JOB_STATES: readonly ["preparing", "running", "terminal"];
+export type BlueprintExecJobState = (typeof BLUEPRINT_EXEC_JOB_STATES)[number];
+export type BlueprintExecJob = {
+    readonly jobId: string;
+    readonly slug: string;
+    readonly taskId: string | null;
+    /** Opaque single-use launch handle; never the composed argv or env. */
+    readonly launchHandle: string;
+    readonly sessionId: number | null;
+    readonly startedAt: number;
+    readonly state: BlueprintExecJobState;
+};
+export type RegisterBlueprintExecJobInput = {
+    readonly slug: string;
+    readonly taskId: string | null;
+    readonly launchHandle: string;
+};
+/**
+ * Bounded, insertion-ordered job store.
+ *
+ * Complexity: `register`, `bindSession`, `markTerminal`, and `get` are all
+ * Map-keyed O(1). Eviction is O(1) too — terminal job ids are appended to a
+ * FIFO queue as they terminate, so making room pops the front instead of
+ * rescanning the map. `list` is O(#jobs) over a capped map.
+ */
+/**
+ * Construction options. Shared by the class and {@link createBlueprintExecLedger}
+ * so the factory's public surface cannot drift away from what the constructor
+ * actually accepts.
+ */
+export type BlueprintExecLedgerOptions = {
+    readonly maxJobs?: number;
+    readonly staleUnboundMs?: number;
+    /** Injectable clock (tests). */
+    readonly now?: () => number;
+};
+export declare class BlueprintExecLedger {
+    private readonly byJobId;
+    /** FIFO of job ids that reached `terminal`, oldest first. */
+    private readonly terminalOrder;
+    private readonly maxJobs;
+    private readonly staleUnboundMs;
+    private readonly now;
+    constructor(options?: BlueprintExecLedgerOptions);
+    /** Evict the oldest terminal job. O(1) amortized via the FIFO queue. */
+    private evictOneTerminal;
+    /**
+     * Last-resort reclaim: the oldest job that never bound a session and whose
+     * launch handle can no longer be claimed.
+     *
+     * Without this, a daemon that only ever prepared launches which were never
+     * claimed (a crashing Rust peer) would wedge at the cap forever, because
+     * nothing would ever transition those jobs to terminal.
+     *
+     * O(#jobs) and only on the eviction path when the terminal queue is empty.
+     */
+    private evictOneStaleUnbound;
+    register(input: RegisterBlueprintExecJobInput): {
+        readonly jobId: string;
+    };
+    /**
+     * Bind the spawned PTY session to a job. Rust-only caller.
+     *
+     * Single-assignment: a second bind for the same job is rejected so a
+     * compromised or buggy peer cannot re-point an existing job at another
+     * session.
+     */
+    bindSession(jobId: string, sessionId: number): BlueprintExecJob;
+    markTerminal(jobId: string): BlueprintExecJob | null;
+    get(jobId: string): BlueprintExecJob | undefined;
+    list(): readonly BlueprintExecJob[];
+    size(): number;
+}
+export declare function createBlueprintExecLedger(options?: BlueprintExecLedgerOptions): BlueprintExecLedger;