@noopolis/daimon 0.1.2 → 0.2.1

package/dist/runtime/grokSlotPreflightReceipt.js

@@ -0,0 +1,101 @@
+import path from "node:path";
+import { z } from "zod";
+import { GROK_ENGINE_BROKER } from "../contracts/runtimeContractManifest.js";
+import { grokBrokerProjectionSha256 } from "./grokBrokerProjection.js";
+export const GROK_SLOT_PREFLIGHT_VERSION = GROK_ENGINE_BROKER.slotPreflightVersion;
+const sha256 = z.string().regex(/^[a-f0-9]{64}$/u);
+const NONCE = /^[a-f0-9]{64}$/u;
+const canonicalAbsolute = z.string().max(4_096).refine((value) => path.posix.isAbsolute(value) && path.posix.normalize(value) === value && value !== "/" && !value.endsWith("/") && !value.includes("\0"), "canonical absolute path");
+/**
+ * One denied-path canary: the root supervisor ran a real sandboxed read of
+ * `path` as the slot's worker uid (a stub-model turn under the attested
+ * profile) and the read was denied. Only denials are representable — a
+ * supervisor that observed a readable path writes no receipt at all.
+ */
+export const grokSlotPreflightCanarySchema = z.strictObject({
+    path: canonicalAbsolute,
+    method: z.literal("sandboxed-read"),
+    result: z.literal("denied")
+});
+/**
+ * `noopolis.daimon.grok-slot-preflight.v2`: what the root slot supervisor (P5)
+ * writes after provisioning or recycling one broker slot, and what an
+ * evaluator (Paideia, P4) must hold before it runs a Grok subject turn in that
+ * slot. It binds the slot to one exact projection by digest, so any change to
+ * the model, limits, deny list, profile, worker config, or pinned executable
+ * invalidates it.
+ *
+ * The projection digest is identical across recycles of the same slot, so v1
+ * could not tell this recycle's receipt from an earlier one. v2 adds
+ * freshness: `generation` is the supervisor-owned per-slot counter, strictly
+ * increasing on every provision/recycle, and `nonce` echoes the 32 random
+ * bytes (hex) the evaluator passed in its recycle request. A v1 receipt is
+ * refused.
+ */
+export const grokSlotPreflightReceiptSchema = z.strictObject({
+    version: z.literal(GROK_SLOT_PREFLIGHT_VERSION),
+    slot: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+    worker_uid: z.number().int().min(GROK_ENGINE_BROKER.identities.firstWorkerUid).max(4_294_967_294),
+    /** Supervisor-owned, strictly increasing per slot across provisions and recycles; starts at 1. */
+    generation: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER),
+    /** The caller's recycle nonce: 32 random bytes, lowercase hex. */
+    nonce: z.string().regex(NONCE),
+    projection_sha256: sha256,
+    /** The bubblewrap/Landlock `daimon-strict` profile bytes' digest (the projection's `profileSha256`). */
+    sandbox_profile_sha256: sha256,
+    /** The container seccomp profile the worker ran under. */
+    seccomp_profile_sha256: sha256,
+    /** Grok 1.0.34 runs every profile inside bubblewrap; the supervisor observed it present and working. */
+    sandbox_runtime: z.literal("bubblewrap"),
+    grok_executable_sha256: sha256,
+    canaries: z.array(grokSlotPreflightCanarySchema).min(1).max(256),
+    created_at: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u).refine((value) => !Number.isNaN(Date.parse(value)) && new Date(value).toISOString() === value, "exact RFC3339 timestamp")
+}).superRefine((receipt, context) => {
+    const paths = receipt.canaries.map((canary) => canary.path);
+    if (new Set(paths).size !== paths.length)
+        context.addIssue({ code: "custom", path: ["canaries"], message: "duplicate canary path" });
+});
+/** Strict parse: unknown members, off-contract values, or duplicate canaries throw. */
+export function parseGrokSlotPreflightReceipt(value) {
+    const result = grokSlotPreflightReceiptSchema.safeParse(value);
+    if (!result.success)
+        throw new TypeError(`invalid Grok slot preflight receipt: ${result.error.issues.map((issue) => `${issue.path.join(".") || "receipt"}: ${issue.message}`).join("; ")}`);
+    return result.data;
+}
+/**
+ * Parse a receipt and require that it proves *this* projection's slot: same
+ * digest, slot, worker uid, profile and executable, and a denied canary for
+ * exactly every projected deny path (no more, no fewer), under the projected
+ * seccomp profile and sandbox runtime — and that it is *this* recycle's
+ * receipt: the caller's nonce, at or above the caller's minimum generation.
+ * A receipt replayed from an earlier recycle fails on the nonce, and one
+ * whose generation went backwards fails on the generation.
+ */
+export function verifyGrokSlotPreflightReceipt(value, projection, freshness) {
+    if (freshness === null || typeof freshness !== "object" || typeof freshness.expectedNonce !== "string" || !NONCE.test(freshness.expectedNonce) || !Number.isSafeInteger(freshness.minGeneration) || freshness.minGeneration < 1)
+        throw new TypeError("invalid Grok slot preflight freshness");
+    const receipt = parseGrokSlotPreflightReceipt(value);
+    const mismatch = (member) => { throw new Error(`Grok slot preflight receipt does not match the projection: ${member}`); };
+    if (receipt.nonce !== freshness.expectedNonce)
+        throw new Error("Grok slot preflight receipt is stale: nonce");
+    if (receipt.generation < freshness.minGeneration)
+        throw new Error("Grok slot preflight receipt is stale: generation");
+    if (receipt.projection_sha256 !== grokBrokerProjectionSha256(projection))
+        mismatch("projection_sha256");
+    if (receipt.slot !== projection.slot)
+        mismatch("slot");
+    if (receipt.worker_uid !== projection.workerUid)
+        mismatch("worker_uid");
+    if (receipt.sandbox_profile_sha256 !== projection.profileSha256)
+        mismatch("sandbox_profile_sha256");
+    if (receipt.grok_executable_sha256 !== projection.grokExecutableSha256)
+        mismatch("grok_executable_sha256");
+    if (receipt.seccomp_profile_sha256 !== projection.seccompProfileSha256)
+        mismatch("seccomp_profile_sha256");
+    if (receipt.sandbox_runtime !== projection.attestation.sandboxRuntime)
+        mismatch("sandbox_runtime");
+    const denied = receipt.canaries.map((canary) => canary.path).sort();
+    if (denied.length !== projection.denyPaths.length || denied.some((entry, index) => entry !== projection.denyPaths[index]))
+        mismatch("canaries");
+    return receipt;
+}

package/dist/runtime/grokSubscriptionRealm.d.ts

@@ -0,0 +1,4 @@
+import type { GrokAgent, GrokSubscriptionRealm, GrokSubscriptionRealmOptions } from "./grokSubscriptionRealmTypes.js";
+export type { GrokSubscriptionRealm, GrokSubscriptionRealmOptions } from "./grokSubscriptionRealmTypes.js";
+export declare function startGrokSubscriptionRealm(configuredAgents: readonly GrokAgent[], options?: GrokSubscriptionRealmOptions): Promise<GrokSubscriptionRealm>;
+//# sourceMappingURL=grokSubscriptionRealm.d.ts.map

package/dist/runtime/grokSubscriptionRealm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grokSubscriptionRealm.d.ts","sourceRoot":"","sources":["../../src/runtime/grokSubscriptionRealm.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,SAAS,EAET,qBAAqB,EACrB,4BAA4B,EAC7B,MAAM,iCAAiC,CAAC;AACzC,YAAY,EAAE,qBAAqB,EAAE,4BAA4B,EAAE,MAAM,iCAAiC,CAAC;AAO3G,wBAAsB,0BAA0B,CAC9C,gBAAgB,EAAE,SAAS,SAAS,EAAE,EACtC,OAAO,GAAE,4BAAiC,GACzC,OAAO,CAAC,qBAAqB,CAAC,CAqChC"}

package/dist/runtime/grokSubscriptionRealm.js

@@ -0,0 +1,435 @@
+import { createHash, randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { spawnRealTime as spawn } from "./taskClockProcess.js";
+import { lstat, open, rename, unlink } from "node:fs/promises";
+import path from "node:path";
+import { terminateChild, trackCliChild } from "../pi/cliProcess.js";
+import { GROK_SUBSCRIPTION_REALM } from "./contractManifest.js";
+import { hasRefreshablePortableCredential } from "./portableCredentialAuth.js";
+import { asGrokAuthenticationRejected } from "./grokAuthenticationError.js";
+const AUTH_FILE = "auth.json";
+const JOURNAL_FILE = "lease.json";
+const STALE_FILE = "stale.json";
+const BOOTSTRAP_FILE = "bootstrap.json";
+const LEASE_FILE = ".daimon-lease";
+const MAX_CONTROL_BYTES = 4_096;
+export async function startGrokSubscriptionRealm(configuredAgents, options = {}) {
+    const durablePath = options.durablePath ?? GROK_SUBSCRIPTION_REALM.durableMountPath;
+    const bootstrapPath = options.bootstrapPath ?? GROK_SUBSCRIPTION_REALM.bootstrapMountPath;
+    await verifyPrivateDirectory(durablePath);
+    const lease = await acquireRealmLease(durablePath, options);
+    const agents = new Map(configuredAgents.map((agent) => [agent.id, agent]));
+    let tail = Promise.resolve();
+    let closed = false;
+    let closePromise;
+    let bootstrapDigest;
+    try {
+        bootstrapDigest = await initializeRealm(durablePath, bootstrapPath, agents);
+    }
+    catch (error) {
+        await terminateChild(lease).catch(() => undefined);
+        throw redact(error);
+    }
+    const withCredential = async (agent, operation) => {
+        if (closed || agents.get(agent.id)?.runtimeHomePath !== agent.runtimeHomePath)
+            throw redact();
+        let release;
+        const prior = tail;
+        tail = new Promise((resolve) => { release = resolve; });
+        await prior;
+        try {
+            if (closed)
+                throw redact();
+            return await runLeasedTurn(durablePath, bootstrapDigest, agent, operation, options.onTransitionForTest);
+        }
+        finally {
+            release();
+        }
+    };
+    return {
+        withCredential,
+        close: () => closePromise ??= (async () => {
+            closed = true;
+            await tail;
+            await terminateChild(lease);
+        })()
+    };
+}
+async function initializeRealm(durablePath, bootstrapPath, agents) {
+    const bootstrap = await readCredential(bootstrapPath);
+    try {
+        const observedBootstrap = await readBootstrap(path.join(durablePath, BOOTSTRAP_FILE));
+        const journal = await readJournal(path.join(durablePath, JOURNAL_FILE));
+        if (journal !== undefined) {
+            await recoverJournal(durablePath, journal, agents, observedBootstrap?.bootstrap_digest ?? bootstrap.digest);
+        }
+        const stale = await readStale(path.join(durablePath, STALE_FILE));
+        const authority = await readOptionalAuthority(path.join(durablePath, AUTH_FILE));
+        const shouldImport = stale !== undefined
+            ? stale.bootstrap_digest !== bootstrap.digest
+            : authority === undefined || (observedBootstrap !== undefined
+                && observedBootstrap.bootstrap_digest !== bootstrap.digest);
+        authority?.bytes.fill(0);
+        if (shouldImport) {
+            await atomicCredentialWrite(path.join(durablePath, AUTH_FILE), bootstrap.bytes);
+            await unlink(path.join(durablePath, STALE_FILE)).catch(ignoreMissing);
+            await syncDirectory(durablePath);
+        }
+        if (shouldImport || observedBootstrap === undefined) {
+            await writeBootstrap(path.join(durablePath, BOOTSTRAP_FILE), bootstrap.digest);
+        }
+        if (await readStale(path.join(durablePath, STALE_FILE)) !== undefined)
+            throw redact();
+        return bootstrap.digest;
+    }
+    finally {
+        bootstrap.bytes.fill(0);
+    }
+}
+async function runLeasedTurn(durablePath, bootstrapDigest, agent, operation, onTransition) {
+    if (await readStale(path.join(durablePath, STALE_FILE)) !== undefined)
+        throw redact();
+    await verifyPrivateDirectory(path.dirname(path.join(agent.runtimeHomePath, GROK_SUBSCRIPTION_REALM.agentCredentialRelativePath)));
+    const target = path.join(agent.runtimeHomePath, GROK_SUBSCRIPTION_REALM.agentCredentialRelativePath);
+    await assertAbsent(target);
+    const authority = await readCredential(path.join(durablePath, AUTH_FILE));
+    const journalPath = path.join(durablePath, JOURNAL_FILE);
+    try {
+        await writeJournal(journalPath, { agent_id: agent.id, source_digest: authority.digest, state: "preparing", version: "noopolis.daimon.grok-credential-lease.v1" });
+        await atomicCredentialWrite(target, authority.bytes);
+        await writeJournal(journalPath, { agent_id: agent.id, source_digest: authority.digest, state: "active", version: "noopolis.daimon.grok-credential-lease.v1" });
+    }
+    finally {
+        authority.bytes.fill(0);
+    }
+    let result;
+    let operationError;
+    try {
+        result = await operation();
+    }
+    catch (error) {
+        operationError = error;
+    }
+    if (asGrokAuthenticationRejected(operationError) !== undefined) {
+        await unlink(target).catch(ignoreMissing);
+        await syncDirectory(path.dirname(target));
+        await markStale(durablePath, bootstrapDigest);
+        throw redact();
+    }
+    const candidate = await tryReadCredential(target);
+    if (candidate === undefined) {
+        await unlink(target).catch(ignoreMissing);
+        await syncDirectory(path.dirname(target));
+        await markStale(durablePath, bootstrapDigest);
+        throw redact(operationError);
+    }
+    try {
+        await writeJournal(journalPath, {
+            agent_id: agent.id,
+            promoted_digest: candidate.digest,
+            source_digest: authority.digest,
+            state: "promoting",
+            version: "noopolis.daimon.grok-credential-lease.v1"
+        });
+        await onTransition?.("promotion_prepared");
+        await atomicCredentialWrite(path.join(durablePath, AUTH_FILE), candidate.bytes);
+        await onTransition?.("authority_replaced");
+        await writeJournal(journalPath, {
+            agent_id: agent.id,
+            promoted_digest: candidate.digest,
+            source_digest: authority.digest,
+            state: "promoted",
+            version: "noopolis.daimon.grok-credential-lease.v1"
+        });
+        await unlink(target).catch(ignoreMissing);
+        await syncDirectory(path.dirname(target));
+        await unlink(journalPath).catch(ignoreMissing);
+        await syncDirectory(durablePath);
+    }
+    finally {
+        candidate.bytes.fill(0);
+    }
+    if (operationError !== undefined)
+        throw operationError;
+    return result;
+}
+async function recoverJournal(durablePath, journal, agents, bootstrapDigest) {
+    const agent = agents.get(journal.agent_id);
+    const target = agent === undefined ? undefined
+        : path.join(agent.runtimeHomePath, GROK_SUBSCRIPTION_REALM.agentCredentialRelativePath);
+    if (target !== undefined)
+        await verifyPrivateDirectory(path.dirname(target));
+    const authority = await readCredential(path.join(durablePath, AUTH_FILE));
+    const authorityDigest = authority.digest;
+    try {
+        const expected = journal.state === "promoted" ? [journal.promoted_digest]
+            : journal.state === "promoting" ? [journal.source_digest, journal.promoted_digest]
+                : [journal.source_digest];
+        if (!expected.includes(authorityDigest)) {
+            if (target !== undefined) {
+                await unlink(target).catch(ignoreMissing);
+                await syncDirectory(path.dirname(target));
+            }
+            await markStale(durablePath, bootstrapDigest);
+            return;
+        }
+    }
+    finally {
+        authority.bytes.fill(0);
+    }
+    if (journal.state === "promoted") {
+        if (target !== undefined) {
+            await unlink(target).catch(ignoreMissing);
+            await syncDirectory(path.dirname(target));
+        }
+        await unlink(path.join(durablePath, JOURNAL_FILE)).catch(ignoreMissing);
+        await syncDirectory(durablePath);
+        return;
+    }
+    if (journal.state === "preparing") {
+        if (target !== undefined)
+            await unlink(target).catch(ignoreMissing);
+        await unlink(path.join(durablePath, JOURNAL_FILE)).catch(ignoreMissing);
+        await syncDirectory(durablePath);
+        return;
+    }
+    const candidate = target === undefined ? undefined : await tryReadCredential(target);
+    if (candidate === undefined) {
+        if (target !== undefined) {
+            await unlink(target).catch(ignoreMissing);
+            await syncDirectory(path.dirname(target));
+        }
+        await markStale(durablePath, bootstrapDigest);
+        return;
+    }
+    try {
+        if (journal.state === "promoting" && candidate.digest !== journal.promoted_digest) {
+            await markStale(durablePath, bootstrapDigest);
+            return;
+        }
+        if (journal.state === "active")
+            await writeJournal(path.join(durablePath, JOURNAL_FILE), { ...journal, promoted_digest: candidate.digest, state: "promoting" });
+        if (authorityDigest === journal.source_digest) {
+            await atomicCredentialWrite(path.join(durablePath, AUTH_FILE), candidate.bytes);
+        }
+        await writeJournal(path.join(durablePath, JOURNAL_FILE), {
+            ...journal, promoted_digest: candidate.digest, state: "promoted"
+        });
+        await unlink(target).catch(ignoreMissing);
+        await syncDirectory(path.dirname(target));
+        await unlink(path.join(durablePath, JOURNAL_FILE)).catch(ignoreMissing);
+        await syncDirectory(durablePath);
+    }
+    finally {
+        candidate.bytes.fill(0);
+    }
+}
+async function markStale(durablePath, bootstrapDigest) {
+    await atomicJsonWrite(path.join(durablePath, STALE_FILE), {
+        bootstrap_digest: bootstrapDigest,
+        version: "noopolis.daimon.grok-credential-stale.v1"
+    });
+    await unlink(path.join(durablePath, JOURNAL_FILE)).catch(ignoreMissing);
+    await syncDirectory(durablePath);
+}
+async function readCredential(file) {
+    let handle;
+    try {
+        const before = await lstat(file);
+        assertCredentialIdentity(before);
+        handle = await open(file, constants.O_RDONLY | noFollow());
+        const opened = await handle.stat();
+        assertCredentialIdentity(opened);
+        if (!sameIdentity(before, opened))
+            throw new Error("changed");
+        const bytes = await handle.readFile();
+        const after = await handle.stat();
+        if (!sameIdentity(opened, after) || !hasRefreshablePortableCredential("grok", bytes)) {
+            bytes.fill(0);
+            throw new Error("invalid");
+        }
+        return { bytes, digest: createHash("sha256").update(bytes).digest("hex") };
+    }
+    catch {
+        throw redact();
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+async function tryReadCredential(file) {
+    try {
+        return await readCredential(file);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readOptionalAuthority(file) {
+    try {
+        return await readCredential(file);
+    }
+    catch {
+        try {
+            await lstat(file);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return undefined;
+        }
+        throw redact();
+    }
+}
+async function atomicCredentialWrite(file, bytes) {
+    await atomicWrite(file, bytes, GROK_SUBSCRIPTION_REALM.fileMode);
+    const checked = await readCredential(file);
+    checked.bytes.fill(0);
+}
+async function atomicJsonWrite(file, value) {
+    await atomicWrite(file, Buffer.from(`${JSON.stringify(value)}\n`), 0o600);
+}
+async function atomicWrite(file, bytes, mode) {
+    const temporary = path.join(path.dirname(file), `.${path.basename(file)}.${randomUUID()}.tmp`);
+    let handle;
+    try {
+        handle = await open(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | noFollow(), mode);
+        await handle.writeFile(bytes);
+        await handle.chmod(mode);
+        await handle.sync();
+        await handle.close();
+        handle = undefined;
+        await rename(temporary, file);
+        await syncDirectory(path.dirname(file));
+    }
+    catch {
+        throw redact();
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+        await unlink(temporary).catch(() => undefined);
+    }
+}
+async function writeJournal(file, value) { await atomicJsonWrite(file, value); }
+async function readJournal(file) {
+    return readPrivateJson(file, (value) => {
+        const candidate = value;
+        if (candidate.version !== "noopolis.daimon.grok-credential-lease.v1" || !["active", "preparing", "promoted", "promoting"].includes(candidate.state ?? "")
+            || typeof candidate.agent_id !== "string" || !candidate.agent_id || !/^[a-f0-9]{64}$/u.test(candidate.source_digest ?? "")
+            || (["promoted", "promoting"].includes(candidate.state ?? "") && !/^[a-f0-9]{64}$/u.test(candidate.promoted_digest ?? "")))
+            throw new Error("invalid");
+        return candidate;
+    });
+}
+async function readStale(file) {
+    return readPrivateJson(file, (value) => {
+        const candidate = value;
+        if (candidate.version !== "noopolis.daimon.grok-credential-stale.v1" || typeof candidate.bootstrap_digest !== "string" || !/^[a-f0-9]{64}$/u.test(candidate.bootstrap_digest))
+            throw new Error("invalid");
+        return { bootstrap_digest: candidate.bootstrap_digest };
+    });
+}
+async function readBootstrap(file) {
+    return readPrivateJson(file, (value) => {
+        const candidate = value;
+        if (candidate.version !== "noopolis.daimon.grok-bootstrap-observation.v1" || typeof candidate.bootstrap_digest !== "string" || !/^[a-f0-9]{64}$/u.test(candidate.bootstrap_digest))
+            throw new Error("invalid");
+        return { bootstrap_digest: candidate.bootstrap_digest };
+    });
+}
+async function writeBootstrap(file, bootstrapDigest) {
+    await atomicJsonWrite(file, {
+        bootstrap_digest: bootstrapDigest,
+        version: "noopolis.daimon.grok-bootstrap-observation.v1"
+    });
+}
+async function readPrivateJson(file, parse) {
+    let handle;
+    let bytes;
+    try {
+        const before = await lstat(file);
+        assertPrivateFileIdentity(before, MAX_CONTROL_BYTES);
+        handle = await open(file, constants.O_RDONLY | noFollow());
+        const opened = await handle.stat();
+        assertPrivateFileIdentity(opened, MAX_CONTROL_BYTES);
+        if (!sameIdentity(before, opened))
+            throw new Error("changed");
+        bytes = await handle.readFile();
+        const after = await handle.stat();
+        if (!sameIdentity(opened, after))
+            throw new Error("changed");
+        return parse(JSON.parse(bytes.toString("utf8")));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw redact();
+    }
+    finally {
+        bytes?.fill(0);
+        await handle?.close().catch(() => undefined);
+    }
+}
+async function verifyPrivateDirectory(directory) {
+    try {
+        const entry = await lstat(directory);
+        if (!entry.isDirectory() || entry.isSymbolicLink() || entry.uid !== process.getuid?.() || (entry.mode & 0o777) !== GROK_SUBSCRIPTION_REALM.directoryMode)
+            throw new Error("unsafe");
+    }
+    catch {
+        throw redact();
+    }
+}
+async function assertAbsent(file) {
+    try {
+        await lstat(file);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+    }
+    throw redact();
+}
+async function acquireRealmLease(durablePath, options) {
+    let lock;
+    let child;
+    try {
+        lock = await open(path.join(durablePath, LEASE_FILE), constants.O_CREAT | constants.O_RDWR | noFollow(), 0o600);
+        const entry = await lock.stat();
+        if (!entry.isFile() || entry.uid !== process.getuid?.() || entry.nlink !== 1 || (entry.mode & 0o777) !== 0o600)
+            throw new Error("unsafe");
+        child = trackCliChild(spawn(options.shell ?? "/bin/sh", ["-c", "\"$1\" --exclusive --nonblock --conflict-exit-code 73 3 || exit 73; printf 'ready\\n'; IFS= read -r _hold || :", "daimon-grok-lease", options.flock ?? "flock"], { detached: process.platform !== "win32", env: { LANG: "C", LC_ALL: "C", PATH: process.env.PATH }, stdio: ["pipe", "pipe", "ignore", lock.fd] }));
+        await waitForReady(child);
+        return child;
+    }
+    catch {
+        if (child !== undefined)
+            await terminateChild(child).catch(() => undefined);
+        throw redact();
+    }
+    finally {
+        await lock?.close().catch(() => undefined);
+    }
+}
+async function waitForReady(child) {
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error("timeout")), 5_000);
+        child.stdout?.once("data", (value) => { clearTimeout(timer); value.toString("utf8") === "ready\n" ? resolve() : reject(new Error("invalid")); });
+        child.once("close", () => { clearTimeout(timer); reject(new Error("closed")); });
+        child.once("error", () => { clearTimeout(timer); reject(new Error("failed")); });
+    });
+}
+async function syncDirectory(directory) { const handle = await open(directory, constants.O_RDONLY); try {
+    await handle.sync();
+}
+finally {
+    await handle.close();
+} }
+const ignoreMissing = (error) => { if (error.code !== "ENOENT")
+    throw error; };
+const noFollow = () => constants.O_NOFOLLOW ?? 0;
+const sameIdentity = (left, right) => left.dev === right.dev && left.ino === right.ino && left.mode === right.mode && left.nlink === right.nlink && left.size === right.size && left.uid === right.uid && left.mtimeMs === right.mtimeMs;
+const assertCredentialIdentity = (entry) => { if (!entry.isFile() || entry.isSymbolicLink() || Number(entry.uid) !== process.getuid?.() || Number(entry.nlink) !== 1 || (Number(entry.mode) & 0o777) !== GROK_SUBSCRIPTION_REALM.fileMode || Number(entry.size) < 1 || Number(entry.size) > GROK_SUBSCRIPTION_REALM.maxCredentialBytes)
+    throw new Error("unsafe"); };
+const assertPrivateFileIdentity = (entry, maxBytes) => { if (!entry.isFile() || entry.isSymbolicLink() || Number(entry.uid) !== process.getuid?.() || Number(entry.nlink) !== 1 || (Number(entry.mode) & 0o777) !== 0o600 || Number(entry.size) < 1 || Number(entry.size) > maxBytes)
+    throw new Error("unsafe"); };
+const redact = (_cause) => new Error("Grok subscription credential realm is unavailable or stale");

package/dist/runtime/grokSubscriptionRealmTypes.d.ts

@@ -0,0 +1,26 @@
+import type { OrganizationRuntimeAgentConfig } from "./organizationRuntime.js";
+export type GrokAgent = OrganizationRuntimeAgentConfig & {
+    engine: {
+        kind: "grok";
+    };
+};
+export type GrokCredentialJournal = Readonly<{
+    agent_id: string;
+    promoted_digest?: string;
+    source_digest: string;
+    state: "active" | "preparing" | "promoted" | "promoting";
+    version: "noopolis.daimon.grok-credential-lease.v1";
+}>;
+export type GrokSubscriptionRealm = Readonly<{
+    withCredential<T>(agent: GrokAgent, operation: () => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}>;
+export type GrokSubscriptionRealmOptions = Readonly<{
+    bootstrapPath?: string;
+    durablePath?: string;
+    flock?: string;
+    /** @internal deterministic crash-transition test seam. */
+    onTransitionForTest?: (stage: "authority_replaced" | "promotion_prepared") => Promise<void> | void;
+    shell?: string;
+}>;
+//# sourceMappingURL=grokSubscriptionRealmTypes.d.ts.map

package/dist/runtime/grokSubscriptionRealmTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grokSubscriptionRealmTypes.d.ts","sourceRoot":"","sources":["../../src/runtime/grokSubscriptionRealmTypes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,0BAA0B,CAAC;AAE/E,MAAM,MAAM,SAAS,GAAG,8BAA8B,GAAG;IAAE,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC;AAEtF,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,QAAQ,GAAG,WAAW,GAAG,UAAU,GAAG,WAAW,CAAC;IACzD,OAAO,EAAE,0CAA0C,CAAC;CACrD,CAAC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAC3C,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC7E,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB,CAAC,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,QAAQ,CAAC;IAClD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0DAA0D;IAC1D,mBAAmB,CAAC,EAAE,CAAC,KAAK,EAAE,oBAAoB,GAAG,oBAAoB,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACnG,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC,CAAC"}

package/dist/runtime/grokSubscriptionRealmTypes.js

@@ -0,0 +1 @@
+export {};