@zhin.js/agent 1.1.13 → 1.1.14

package/lib/plugin-runtime/workroom-profile-authority-runtime.js

@@ -0,0 +1,1132 @@
+import { createHash } from 'node:crypto';
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { compareCanonicalWorkroomText, canonicalWorkroomJson, deepFreezeWorkroomValue as deepFreeze, digestCanonicalWorkroomValue as digest, } from '../workroom/canonical-value.js';
+import { DurableFileStore, nodeDurableFileSystem, } from '../workroom/durable-file-store.js';
+import { compileWorkroomProfile, } from '../workroom/profile-compiler.js';
+import { ProjectProfileRegistry, } from '../workroom/profile-registry.js';
+import { createWorkroomDynamicPlanningPolicyAuthority, createWorkroomDynamicPlanningPolicySnapshot, } from './workroom-dynamic-planning-provider.js';
+import { createWorkroomSchedulerPolicySnapshot } from '../workroom/workroom-scheduler.js';
+export function createCapabilityPackManifest(input) {
+    assertKeys(input, [
+        'id', 'version', 'kind', 'requires', 'tools', 'skills', 'agents', 'workflows', 'memories', 'glossaries',
+        'acceptancePolicies',
+    ], 'Pack');
+    text(input.id, 'Pack id');
+    text(input.version, 'Pack version');
+    if (!['domain', 'competency', 'integration', 'policy'].includes(input.kind)) {
+        throw new Error('Capability Pack kind is invalid');
+    }
+    const body = deepFreeze({
+        id: input.id,
+        version: input.version,
+        kind: input.kind,
+        ...(input.requires ? { requires: sortPackRefs(input.requires) } : {}),
+        ...(input.tools ? { tools: sortDefinitions(input.tools) } : {}),
+        ...(input.skills ? { skills: [...input.skills].map(value => ({
+                id: requiredText(value.id, 'Skill id'),
+                digest: requiredDigest(value.digest, 'Skill digest'),
+                requiresTools: unique(value.requiresTools, 'Skill Tool requirement'),
+            })).sort(byId) } : {}),
+        ...(input.agents ? { agents: [...input.agents].map(value => ({
+                id: requiredText(value.id, 'Agent id'),
+                digest: requiredDigest(value.digest, 'Agent digest'),
+                role: requiredText(value.role, 'Agent role'),
+                allowedTools: unique(value.allowedTools, 'Agent Tool ceiling'),
+                allowedSkills: unique(value.allowedSkills, 'Agent Skill ceiling'),
+            })).sort(byId) } : {}),
+        ...(input.workflows ? { workflows: [...input.workflows].map(value => ({
+                id: requiredText(value.id, 'Workflow id'),
+                digest: requiredDigest(value.digest, 'Workflow digest'),
+                requiredByProfile: value.requiredByProfile === true,
+                tasks: [...value.tasks].map(task => ({
+                    key: requiredText(task.key, 'Workflow Task key'),
+                    role: requiredText(task.role, 'Workflow Task role'),
+                    requires: {
+                        ...(task.requires.tools ? { tools: unique(task.requires.tools, 'Workflow Tool requirement') } : {}),
+                        ...(task.requires.skills ? { skills: unique(task.requires.skills, 'Workflow Skill requirement') } : {}),
+                    },
+                })).sort((left, right) => compareCanonicalWorkroomText(left.key, right.key)),
+            })).sort(byId) } : {}),
+        ...(input.memories ? { memories: sortKnowledgeDefinitions(input.memories, 'Memory') } : {}),
+        ...(input.glossaries ? { glossaries: sortKnowledgeDefinitions(input.glossaries, 'Glossary') } : {}),
+        ...(input.acceptancePolicies
+            ? { acceptancePolicies: [...input.acceptancePolicies].map(canonicalAcceptancePolicy).sort(byId) }
+            : {}),
+    });
+    return deepFreeze({ ...body, digest: digest(body) });
+}
+export function createWorkroomProfileOverlay(input) {
+    assertKeys(input, [
+        'version', 'projectId', 'revisionId', 'charterRevisionId', 'parentRevisionId', 'packs',
+        'enabledTools', 'enabledSkills', 'enabledAgents', 'enabledWorkflows', 'enabledMemories', 'enabledGlossaries',
+        'enabledAcceptancePolicies',
+    ], 'Profile Overlay');
+    if (input.version !== 1)
+        throw new Error('Profile Overlay version is invalid');
+    const body = deepFreeze({
+        version: 1,
+        projectId: requiredText(input.projectId, 'Overlay projectId'),
+        revisionId: requiredText(input.revisionId, 'Overlay revisionId'),
+        charterRevisionId: requiredText(input.charterRevisionId, 'Overlay charterRevisionId'),
+        ...(input.parentRevisionId
+            ? { parentRevisionId: requiredText(input.parentRevisionId, 'Overlay parentRevisionId') }
+            : {}),
+        packs: sortPackRefs(input.packs),
+        enabledTools: unique(input.enabledTools, 'Overlay enabled Tool'),
+        enabledSkills: unique(input.enabledSkills, 'Overlay enabled Skill'),
+        enabledAgents: unique(input.enabledAgents, 'Overlay enabled Agent'),
+        enabledWorkflows: unique(input.enabledWorkflows, 'Overlay enabled Workflow'),
+        enabledMemories: unique(input.enabledMemories ?? [], 'Overlay enabled Memory'),
+        enabledGlossaries: unique(input.enabledGlossaries ?? [], 'Overlay enabled Glossary'),
+        enabledAcceptancePolicies: unique(input.enabledAcceptancePolicies ?? [], 'Overlay enabled Acceptance Policy'),
+    });
+    return deepFreeze({ ...body, digest: digest(body) });
+}
+/** Crash-durable File tracer. Parent `.zhin` must already exist. */
+export class FileWorkroomProfileAuthorityRepository {
+    directory;
+    verification;
+    #root;
+    #packs;
+    #overlays;
+    #profileProofs;
+    #policies;
+    #ready;
+    constructor(directory, verification, fileSystem = nodeDurableFileSystem) {
+        this.directory = directory;
+        this.verification = verification;
+        this.#root = new DurableFileStore(directory, fileSystem);
+        this.#packs = new DurableFileStore(join(directory, 'packs'), fileSystem);
+        this.#overlays = new DurableFileStore(join(directory, 'overlays'), fileSystem);
+        this.#profileProofs = new DurableFileStore(join(directory, 'profile-proofs'), fileSystem);
+        this.#policies = new DurableFileStore(join(directory, 'planning-policies'), fileSystem);
+    }
+    async readPack(ref) {
+        assertPackRef(ref);
+        const record = await readOptional(join(this.#packs.directory, `${keyHash(`${ref.id}@${ref.version}`)}.json`), parsePackPublication);
+        if (!record || record.pack.digest !== ref.digest)
+            return undefined;
+        await this.#verify(record.authorityRequest, record.governance);
+        return record;
+    }
+    async publishPack(publication) {
+        const canonical = canonicalPackPublication(publication);
+        await this.#verify(canonical.authorityRequest, canonical.governance);
+        await this.#ensureReady();
+        const target = join(this.#packs.directory, `${keyHash(`${canonical.pack.id}@${canonical.pack.version}`)}.json`);
+        const result = await this.#packs.publishCreateOnly({
+            target,
+            content: canonicalWorkroomJson(canonical),
+            createdValue: canonical,
+            onConflict: async () => {
+                const winner = await readRequired(target, parsePackPublication);
+                if (canonicalWorkroomJson(winner.pack) !== canonicalWorkroomJson(canonical.pack)) {
+                    throw new Error(`Capability Pack ${canonical.pack.id}@${canonical.pack.version} identity payload drift`);
+                }
+                return winner;
+            },
+        });
+        await this.#verify(result.value.authorityRequest, result.value.governance);
+        await this.#root.syncLeafAndParent();
+        return result.value;
+    }
+    async readOverlay(projectId, revisionId) {
+        text(projectId, 'Overlay projectId');
+        text(revisionId, 'Overlay revisionId');
+        return await readOptional(join(this.#overlays.directory, `${keyHash(`${projectId}:${revisionId}`)}.json`), parseOverlay);
+    }
+    async publishOverlay(overlay) {
+        const canonical = canonicalOverlay(overlay);
+        await this.#ensureReady();
+        const target = join(this.#overlays.directory, `${keyHash(`${canonical.projectId}:${canonical.revisionId}`)}.json`);
+        const result = await this.#overlays.publishCreateOnly({
+            target,
+            content: canonicalWorkroomJson(canonical),
+            createdValue: canonical,
+            onConflict: async () => {
+                const winner = await readRequired(target, parseOverlay);
+                if (winner.digest !== canonical.digest)
+                    throw new Error('Profile Overlay identity payload drift');
+                return winner;
+            },
+        });
+        await this.#root.syncLeafAndParent();
+        return result.value;
+    }
+    async readProfileProof(projectId, revisionId) {
+        text(projectId, 'Profile proof projectId');
+        text(revisionId, 'Profile proof revisionId');
+        const proof = await readOptional(join(this.#profileProofs.directory, `${keyHash(`${projectId}:${revisionId}`)}.json`), parseProfileProof);
+        if (proof)
+            await this.#verify(proof.authorityRequest, proof.governance);
+        return proof;
+    }
+    async publishProfileProof(proof) {
+        const canonical = canonicalProfileProof(proof);
+        await this.#verify(canonical.authorityRequest, canonical.governance);
+        await this.#ensureReady();
+        const target = join(this.#profileProofs.directory, `${keyHash(`${canonical.projectId}:${canonical.revisionId}`)}.json`);
+        const result = await this.#profileProofs.publishCreateOnly({
+            target,
+            content: canonicalWorkroomJson(canonical),
+            createdValue: canonical,
+            onConflict: async () => {
+                const winner = await readRequired(target, parseProfileProof);
+                if (canonicalWorkroomJson(winner) !== canonicalWorkroomJson(canonical)) {
+                    throw new Error('Project Profile publication proof identity payload drift');
+                }
+                return winner;
+            },
+        });
+        await this.#verify(result.value.authorityRequest, result.value.governance);
+        await this.#root.syncLeafAndParent();
+        return result.value;
+    }
+    async readPlanningPolicy(projectId, profileRevisionId) {
+        text(projectId, 'Planning Policy projectId');
+        text(profileRevisionId, 'Planning Policy Profile revisionId');
+        const prefix = `${keyHash(`${projectId}:${profileRevisionId}`)}.`;
+        let names;
+        try {
+            names = await readdir(this.#policies.directory);
+        }
+        catch (error) {
+            if (hasCode(error, 'ENOENT'))
+                return undefined;
+            throw error;
+        }
+        const records = await Promise.all(names.filter(name => name.startsWith(prefix) && name.endsWith('.json'))
+            .sort().map(name => readRequired(join(this.#policies.directory, name), parsePlanningPolicy)));
+        let previous;
+        for (const record of records) {
+            if (record.projectId !== projectId || record.profileRevisionId !== profileRevisionId
+                || record.revision !== (previous?.revision ?? 0) + 1
+                || record.previousDigest !== previous?.digest) {
+                throw new Error('Planning Policy revision chain is invalid');
+            }
+            await this.#verify(record.authorityRequest, record.governance);
+            previous = record;
+        }
+        return previous;
+    }
+    async appendPlanningPolicy(revision) {
+        const canonical = canonicalPlanningPolicy(revision);
+        await this.#verify(canonical.authorityRequest, canonical.governance);
+        const current = await this.readPlanningPolicy(canonical.projectId, canonical.profileRevisionId);
+        if (canonical.revision !== (current?.revision ?? 0) + 1
+            || canonical.previousDigest !== current?.digest) {
+            throw new Error('Planning Policy previous digest/revision CAS mismatch');
+        }
+        await this.#ensureReady();
+        const prefix = keyHash(`${canonical.projectId}:${canonical.profileRevisionId}`);
+        const target = join(this.#policies.directory, `${prefix}.${String(canonical.revision).padStart(16, '0')}.json`);
+        const result = await this.#policies.publishCreateOnly({
+            target,
+            content: canonicalWorkroomJson(canonical),
+            createdValue: canonical,
+            onConflict: async () => {
+                const winner = await readRequired(target, parsePlanningPolicy);
+                if (canonicalWorkroomJson(winner) !== canonicalWorkroomJson(canonical)) {
+                    throw new Error('Planning Policy revision identity payload drift');
+                }
+                return winner;
+            },
+        });
+        await this.#verify(result.value.authorityRequest, result.value.governance);
+        await this.#root.syncLeafAndParent();
+        return result.value;
+    }
+    #ensureReady() {
+        this.#ready ??= (async () => {
+            await this.#root.ensureDurableLeaf('Workroom Profile authority repository');
+            await this.#packs.ensureDurableLeaf('Capability Pack publication repository');
+            await this.#overlays.ensureDurableLeaf('Project Profile Overlay repository');
+            await this.#profileProofs.ensureDurableLeaf('Project Profile publication proof repository');
+            await this.#policies.ensureDurableLeaf('Planning Policy repository');
+            await this.#root.syncLeafAndParent();
+        })();
+        return this.#ready;
+    }
+    async #verify(request, decision) {
+        if (!this.verification || !await this.verification.verify(request, decision)) {
+            throw new Error('Trusted Workroom Profile publisher authority verification is unavailable or denied');
+        }
+    }
+}
+export class FileWorkroomRunProfilePinProofRepository {
+    directory;
+    verification;
+    #store;
+    #ready;
+    constructor(directory, verification, fileSystem = nodeDurableFileSystem) {
+        this.directory = directory;
+        this.verification = verification;
+        this.#store = new DurableFileStore(directory, fileSystem);
+    }
+    async read(projectId, runId) {
+        text(projectId, 'Run pin proof projectId');
+        text(runId, 'Run pin proof runId');
+        const proof = await readOptional(join(this.directory, `${keyHash(`${projectId}:${runId}`)}.json`), parseRunPinProof);
+        if (proof)
+            await this.#verify(proof);
+        return proof;
+    }
+    async publish(proof) {
+        const canonical = canonicalRunPinProof(proof);
+        await this.#verify(canonical);
+        await this.#ensureReady();
+        const target = join(this.directory, `${keyHash(`${canonical.pin.projectId}:${canonical.pin.runId}`)}.json`);
+        const result = await this.#store.publishCreateOnly({
+            target,
+            content: canonicalWorkroomJson(canonical),
+            createdValue: canonical,
+            onConflict: async () => {
+                const winner = await readRequired(target, parseRunPinProof);
+                if (!sameRunPinAuthorityScope(winner.request, canonical.request)
+                    || canonicalWorkroomJson(winner.pin) !== canonicalWorkroomJson(canonical.pin)) {
+                    throw new Error('Workroom Run Profile pin proof identity payload drift');
+                }
+                return winner;
+            },
+        });
+        await this.#verify(result.value);
+        await this.#store.syncLeafAndParent();
+        return result.value;
+    }
+    #ensureReady() {
+        this.#ready ??= this.#store.ensureDurableLeaf('Workroom Run Profile pin proof repository');
+        return this.#ready;
+    }
+    async #verify(proof) {
+        if (!this.verification || !await this.verification.verify(proof.request, proof.authority)) {
+            throw new Error('Trusted Workroom Run Profile pin proof verification is unavailable or denied');
+        }
+    }
+}
+export class WorkroomProfileAuthorityRuntime {
+    options;
+    control;
+    planningPolicy;
+    runPins;
+    profiles;
+    constructor(options) {
+        this.options = options;
+        this.control = Object.freeze({
+            publishPack: async (command, signal) => await this.#publishPack(command, signal),
+            publishProfile: async (command, signal) => await this.#publishProfile(command, signal, false),
+            publishRollback: async (command, signal) => await this.#publishProfile(command, signal, true),
+            publishPlanningPolicy: async (command, signal) => await this.#publishPolicy(command, signal),
+        });
+        this.planningPolicy = Object.freeze({
+            resolve: async (request) => await this.#resolvePolicy(request),
+        });
+        this.runPins = Object.freeze({
+            pin: async (command, signal) => await this.#pinRun(command, signal),
+        });
+        this.profiles = Object.freeze({
+            read: async (projectId) => await this.#readProfiles(projectId),
+        });
+    }
+    async #publishPack(command, signal) {
+        assertKeys(command, ['version', 'operationId', 'authenticatedPrincipalId', 'pack'], 'Pack command');
+        commandHeader(command, signal);
+        return await this.options.generationView.withCurrent(this.#operation(command.operationId, signal), async (view) => {
+            assertView(view, this.options.generation.generation);
+            const pack = createCapabilityPackManifest(command.pack);
+            const existing = await this.options.repository.readPack(pack);
+            if (existing)
+                return existing;
+            const authorized = await this.#authorize({
+                version: 1, action: 'publish_pack', operationId: command.operationId,
+                authenticatedPrincipalId: command.authenticatedPrincipalId, candidateDigest: pack.digest,
+            }, 'trusted_pack_publisher');
+            signal.throwIfAborted();
+            const body = deepFreeze({
+                version: 1,
+                pack,
+                authorityRequest: authorized.request,
+                governance: authorized.decision,
+            });
+            return await this.options.repository.publishPack(deepFreeze({ ...body, digest: digest(body) }));
+        });
+    }
+    async #publishProfile(command, signal, rollback) {
+        assertKeys(command, [
+            'version', 'operationId', 'authenticatedPrincipalId', 'projectId', 'expectedRegistryRevision',
+            'overlay', 'source', 'activate', ...(rollback ? ['restoredFromRevisionId'] : []),
+        ], rollback ? 'Profile rollback command' : 'Profile command');
+        commandHeader(command, signal);
+        if (rollback)
+            requiredText(command.restoredFromRevisionId, 'Profile rollback restored revisionId');
+        if (command.projectId !== command.overlay.projectId)
+            throw new Error('Profile command Project drift');
+        const overlay = canonicalOverlay(command.overlay);
+        return await this.options.generationView.withCurrent(this.#operation(command.operationId, signal), async (view) => {
+            assertView(view, this.options.generation.generation);
+            const packs = await Promise.all(overlay.packs.map(async (ref) => {
+                const publication = await this.options.repository.readPack(ref);
+                if (!publication)
+                    throw new Error(`Trusted Capability Pack ${ref.id}@${ref.version} is unavailable`);
+                return publication.pack;
+            }));
+            const compiled = compileWorkroomProfile({
+                revision: {
+                    id: overlay.revisionId,
+                    projectId: overlay.projectId,
+                    charterRevisionId: overlay.charterRevisionId,
+                    packs: overlay.packs,
+                    enabledTools: overlay.enabledTools,
+                    enabledSkills: overlay.enabledSkills,
+                    enabledAgents: overlay.enabledAgents,
+                    enabledWorkflows: overlay.enabledWorkflows,
+                    enabledMemories: overlay.enabledMemories,
+                    enabledGlossaries: overlay.enabledGlossaries,
+                    enabledAcceptancePolicies: overlay.enabledAcceptancePolicies,
+                },
+                packs,
+                generationSupply: generationSupply(view),
+            });
+            if (!compiled.ok) {
+                throw new Error(`Profile compilation failed: ${compiled.diagnostics.map(value => value.code).join(',')}`);
+            }
+            const existingState = rollback ? await this.#readProfiles(command.projectId) : undefined;
+            const restoredFromRevisionId = rollback
+                ? command.restoredFromRevisionId
+                : undefined;
+            const restored = restoredFromRevisionId
+                ? existingState?.revisions[restoredFromRevisionId]
+                : undefined;
+            if (rollback && !restored) {
+                throw new Error(`Restored Profile Revision ${restoredFromRevisionId} not found`);
+            }
+            await this.options.repository.publishOverlay(overlay);
+            const governance = Object.freeze({
+                authorize: async (input) => {
+                    const authorized = await this.#authorize({
+                        version: 1,
+                        action: rollback ? 'publish_profile_rollback' : 'publish_profile',
+                        operationId: command.operationId,
+                        authenticatedPrincipalId: command.authenticatedPrincipalId,
+                        candidateDigest: digest(input),
+                        ...(input.currentActive ? { currentDigest: input.currentActive.compiledDigest } : {}),
+                        projectId: command.projectId,
+                    }, 'sponsor');
+                    signal.throwIfAborted();
+                    const proofBody = deepFreeze({
+                        version: 1,
+                        projectId: command.projectId,
+                        revisionId: overlay.revisionId,
+                        governanceInput: structuredClone(input),
+                        authorityRequest: authorized.request,
+                        governance: authorized.decision,
+                    });
+                    await this.options.repository.publishProfileProof(deepFreeze({
+                        ...proofBody,
+                        digest: digest(proofBody),
+                    }));
+                    return deepFreeze({
+                        ...structuredClone(input),
+                        approved: true,
+                        decisionId: authorized.decision.decisionId,
+                        route: 'sponsor',
+                        outcome: 'approved',
+                        decidedBy: authorized.decision.decidedBy,
+                    });
+                },
+            });
+            const profiles = new ProjectProfileRegistry(this.options.profileJournal, governance);
+            const revision = {
+                revisionId: overlay.revisionId,
+                projectId: overlay.projectId,
+                charterRevisionId: overlay.charterRevisionId,
+                packRefs: overlay.packs,
+                overlayDigest: restored?.overlayDigest ?? overlay.digest,
+                compiledDigest: compiled.profile.digest,
+                compiledProfile: compiled.profile,
+                ...(overlay.parentRevisionId ? { parentRevisionId: overlay.parentRevisionId } : {}),
+                ...(restoredFromRevisionId ? { restoredFromRevisionId } : {}),
+                source: structuredClone(command.source),
+            };
+            let state = rollback
+                ? await profiles.registerRollback({
+                    projectId: command.projectId,
+                    expectedRegistryRevision: command.expectedRegistryRevision,
+                    restoredFromRevisionId: restoredFromRevisionId,
+                    revision,
+                })
+                : await profiles.registerRevision({
+                    projectId: command.projectId,
+                    expectedRegistryRevision: command.expectedRegistryRevision,
+                    revision,
+                });
+            if (command.activate) {
+                state = await profiles.activateRevision({
+                    projectId: command.projectId,
+                    expectedRegistryRevision: state.registryRevision,
+                    revisionId: overlay.revisionId,
+                    compiledDigest: compiled.profile.digest,
+                });
+            }
+            return await this.#readProfiles(command.projectId);
+        });
+    }
+    async #publishPolicy(command, signal) {
+        assertKeys(command, [
+            'version', 'operationId', 'authenticatedPrincipalId', 'projectId', 'catalogRevision',
+            'projectDigest', 'profileRevisionId', 'profileDigest', 'revision', 'expectedPreviousDigest', 'policy',
+        ], 'Planning Policy command');
+        commandHeader(command, signal);
+        return await this.options.generationView.withCurrent(this.#operation(command.operationId, signal), async (view) => {
+            assertView(view, this.options.generation.generation);
+            const profiles = await this.#readProfiles(command.projectId);
+            const profile = profiles.revisions[command.profileRevisionId];
+            if (!profile || profile.compiledDigest !== command.profileDigest) {
+                throw new Error('Planning Policy Profile binding is unavailable or stale');
+            }
+            const policy = canonicalPolicy(command.policy);
+            const current = await this.options.repository.readPlanningPolicy(command.projectId, command.profileRevisionId);
+            if (current?.revision === command.revision) {
+                const candidate = planningPolicyCandidate(command, policy, current.authorityRequest, current.governance);
+                if (canonicalWorkroomJson({ ...current, digest: undefined })
+                    === canonicalWorkroomJson({ ...candidate, digest: undefined }))
+                    return current;
+            }
+            if (command.revision !== (current?.revision ?? 0) + 1
+                || command.expectedPreviousDigest !== current?.digest) {
+                throw new Error('Planning Policy previous digest/revision CAS mismatch');
+            }
+            const candidateBody = planningPolicyBody(command, policy);
+            const authorized = await this.#authorize({
+                version: 1,
+                action: 'publish_planning_policy',
+                operationId: command.operationId,
+                authenticatedPrincipalId: command.authenticatedPrincipalId,
+                candidateDigest: digest(candidateBody),
+                ...(current ? { currentDigest: current.digest } : {}),
+                projectId: command.projectId,
+            }, 'sponsor');
+            signal.throwIfAborted();
+            const body = deepFreeze({
+                ...candidateBody,
+                authorityRequest: authorized.request,
+                governance: authorized.decision,
+            });
+            return await this.options.repository.appendPlanningPolicy(deepFreeze({ ...body, digest: digest(body) }));
+        });
+    }
+    async #pinRun(command, signal) {
+        assertKeys(command, [
+            'version', 'operationId', 'projectId', 'runId', 'planRevisionId', 'planDigest',
+            'profileRevisionId', 'profileDigest', 'principalId', 'runFactDigest', 'expectedRegistryRevision',
+        ], 'Run pin command');
+        if (command.version !== 1)
+            throw new Error('Run pin command version is invalid');
+        text(command.operationId, 'Run pin operationId');
+        text(command.principalId, 'Run pin principalId');
+        text(command.projectId, 'Run pin projectId');
+        text(command.runId, 'Run pin runId');
+        text(command.planRevisionId, 'Run pin Plan revisionId');
+        requiredDigest(command.planDigest, 'Run pin Plan digest');
+        text(command.profileRevisionId, 'Run pin Profile revisionId');
+        requiredDigest(command.profileDigest, 'Run pin Profile digest');
+        requiredDigest(command.runFactDigest, 'Run pin fact digest');
+        if (!Number.isSafeInteger(command.expectedRegistryRevision)
+            || command.expectedRegistryRevision < -1) {
+            throw new Error('Run pin expected Registry revision is invalid');
+        }
+        signal.throwIfAborted();
+        const authority = this.options.runPinAuthority;
+        const proofs = this.options.runPinProofs;
+        if (!authority || !proofs)
+            throw new Error('Workroom Run Profile pin authority/proof repository is unavailable');
+        const requestBody = deepFreeze({
+            ...structuredClone(command),
+            generation: this.options.generation.generation,
+        });
+        const request = deepFreeze({ ...requestBody, digest: digest(requestBody) });
+        const authorized = await authority.authorize(request);
+        signal.throwIfAborted();
+        if (!authorized || authorized.requestDigest !== request.digest) {
+            throw new Error('Workroom Run Profile pin authority exact echo mismatch');
+        }
+        requiredDigest(authorized.authorityDigest, 'Run pin authority digest');
+        const state = await this.#readProfiles(command.projectId);
+        const existing = state.runPins[command.runId];
+        if (existing) {
+            const proof = await proofs.read(command.projectId, command.runId);
+            if (!proof || !sameRunPinAuthorityScope(proof.request, request)
+                || canonicalWorkroomJson(proof.pin) !== canonicalWorkroomJson(existing)) {
+                throw new Error('Workroom Run Profile pin replay proof is unavailable or stale');
+            }
+            return existing;
+        }
+        if (!state.active || state.registryRevision !== command.expectedRegistryRevision
+            || state.active.revisionId !== command.profileRevisionId
+            || state.active.compiledDigest !== command.profileDigest) {
+            throw new Error('Workroom Run Profile pin Registry position is stale');
+        }
+        const expectedPin = deepFreeze({
+            projectId: command.projectId,
+            runId: command.runId,
+            profileRevisionId: command.profileRevisionId,
+            profileDigest: command.profileDigest,
+            activationRegistryRevision: state.active.activatedAtRegistryRevision,
+            pinnedAtRegistryRevision: state.registryRevision + 1,
+        });
+        const proofBody = deepFreeze({
+            version: 1,
+            request,
+            authority: structuredClone(authorized),
+            pin: expectedPin,
+        });
+        await proofs.publish(deepFreeze({ ...proofBody, digest: digest(proofBody) }));
+        const pin = await new ProjectProfileRegistry(this.options.profileJournal).pinRun({
+            projectId: command.projectId,
+            runId: command.runId,
+            expectedRegistryRevision: command.expectedRegistryRevision,
+        });
+        if (canonicalWorkroomJson(pin) !== canonicalWorkroomJson(expectedPin)) {
+            throw new Error('Workroom Run Profile pin drifted from its authority proof');
+        }
+        return pin;
+    }
+    async #resolvePolicy(request) {
+        if (canonicalWorkroomJson(request.generation) !== canonicalWorkroomJson(this.options.generation))
+            return undefined;
+        const record = await this.options.repository.readPlanningPolicy(request.projectId, request.profile.revisionId);
+        if (!record
+            || record.catalogRevision !== request.catalogRevision
+            || record.projectDigest !== request.projectDigest
+            || record.profileDigest !== request.profile.digest)
+            return undefined;
+        return createWorkroomDynamicPlanningPolicyAuthority({
+            version: 1,
+            generation: this.options.generation,
+            projectId: record.projectId,
+            catalogRevision: record.catalogRevision,
+            projectDigest: record.projectDigest,
+            profileRevisionId: record.profileRevisionId,
+            profileDigest: record.profileDigest,
+            policy: record.policy,
+        });
+    }
+    async #readProfiles(projectId) {
+        const state = await new ProjectProfileRegistry(this.options.profileJournal).read(projectId);
+        for (const revision of Object.values(state.revisions)) {
+            const proof = await this.options.repository.readProfileProof(projectId, revision.revisionId);
+            if (!proof)
+                throw new Error(`Trusted Project Profile proof ${revision.revisionId} is unavailable`);
+            const governanceInput = governanceInputFromDecision(revision.governanceDecision);
+            if (canonicalWorkroomJson(proof.governanceInput) !== canonicalWorkroomJson(governanceInput)) {
+                throw new Error(`Trusted Project Profile proof ${revision.revisionId} drifted from its Registry decision`);
+            }
+        }
+        return state;
+    }
+    async #authorize(input, requiredRole) {
+        const request = createRequest(input);
+        const result = await this.options.authority.authorize(request);
+        if (!result.approved) {
+            if (result.requestDigest !== request.digest)
+                throw new Error('Profile authority denial echo mismatch');
+            throw new Error(`Profile authority denied: ${result.reason}`);
+        }
+        if (result.requestDigest !== request.digest
+            || result.decidedBy !== request.authenticatedPrincipalId
+            || result.authorizedBy !== requiredRole) {
+            throw new Error('Profile authority exact decision echo mismatch');
+        }
+        text(result.decisionId, 'authority decisionId');
+        nonNegative(result.decidedAt, 'authority decision timestamp');
+        return deepFreeze({ request, decision: structuredClone(result) });
+    }
+    #operation(operationId, signal) {
+        return deepFreeze({ operationId, generation: this.options.generation.generation, signal });
+    }
+}
+function createRequest(input) {
+    assertKeys(input, [
+        'version', 'action', 'operationId', 'authenticatedPrincipalId', 'candidateDigest',
+        'currentDigest', 'projectId',
+    ], 'Profile publisher authority request');
+    if (input.version !== 1
+        || !['publish_pack', 'publish_profile', 'publish_profile_rollback', 'publish_planning_policy']
+            .includes(input.action)) {
+        throw new Error('Profile publisher authority request version/action is invalid');
+    }
+    text(input.operationId, 'Profile publisher operationId');
+    text(input.authenticatedPrincipalId, 'Profile publisher principalId');
+    requiredDigest(input.candidateDigest, 'Profile publisher candidate digest');
+    if (input.currentDigest !== undefined) {
+        requiredDigest(input.currentDigest, 'Profile publisher current digest');
+    }
+    if (input.projectId !== undefined)
+        text(input.projectId, 'Profile publisher projectId');
+    if ((input.action === 'publish_pack') !== (input.projectId === undefined)) {
+        throw new Error('Profile publisher authority Project scope is invalid');
+    }
+    const body = deepFreeze(structuredClone(input));
+    return deepFreeze({ ...body, digest: digest(body) });
+}
+function canonicalPackPublication(value) {
+    const { digest: packDigest, ...packInput } = value.pack;
+    const pack = createCapabilityPackManifest(packInput);
+    if (pack.digest !== packDigest)
+        throw new Error('Capability Pack digest mismatch');
+    const authorityRequest = canonicalRequest(value.authorityRequest);
+    if (authorityRequest.action !== 'publish_pack'
+        || authorityRequest.candidateDigest !== pack.digest
+        || authorityRequest.currentDigest !== undefined
+        || authorityRequest.projectId !== undefined) {
+        throw new Error('Capability Pack publisher authority scope mismatch');
+    }
+    const governance = canonicalDecision(value.governance, 'trusted_pack_publisher', authorityRequest);
+    const body = deepFreeze({ version: 1, pack, authorityRequest, governance });
+    const canonical = deepFreeze({ ...body, digest: digest(body) });
+    if (value.version !== 1 || value.digest !== canonical.digest
+        || canonicalWorkroomJson(value) !== canonicalWorkroomJson(canonical)) {
+        throw new Error('Capability Pack publication digest mismatch');
+    }
+    return canonical;
+}
+function parsePackPublication(value) {
+    if (!isRecord(value) || !isRecord(value.pack)
+        || !isRecord(value.authorityRequest) || !isRecord(value.governance)) {
+        throw new Error('Capability Pack publication is malformed');
+    }
+    return canonicalPackPublication(value);
+}
+function canonicalOverlay(value) {
+    const { digest: supplied, ...input } = value;
+    const canonical = createWorkroomProfileOverlay(input);
+    if (supplied !== canonical.digest || canonicalWorkroomJson(value) !== canonicalWorkroomJson(canonical)) {
+        throw new Error('Profile Overlay digest mismatch');
+    }
+    return canonical;
+}
+function parseOverlay(value) {
+    if (!isRecord(value))
+        throw new Error('Profile Overlay is malformed');
+    return canonicalOverlay(value);
+}
+function canonicalProfileProof(value) {
+    if (!isRecord(value.governanceInput))
+        throw new Error('Project Profile publication proof is malformed');
+    const governanceInput = deepFreeze(structuredClone(value.governanceInput));
+    const authorityRequest = canonicalRequest(value.authorityRequest);
+    const expectedAction = governanceInput.operation === 'register_rollback'
+        ? 'publish_profile_rollback'
+        : 'publish_profile';
+    if (authorityRequest.action !== expectedAction
+        || authorityRequest.projectId !== value.projectId
+        || authorityRequest.candidateDigest !== digest(governanceInput)
+        || authorityRequest.currentDigest !== governanceInput.currentActive?.compiledDigest
+        || governanceInput.projectId !== value.projectId
+        || governanceInput.revisionId !== value.revisionId) {
+        throw new Error('Project Profile Sponsor authority scope mismatch');
+    }
+    const body = deepFreeze({
+        version: 1,
+        projectId: requiredText(value.projectId, 'Profile proof projectId'),
+        revisionId: requiredText(value.revisionId, 'Profile proof revisionId'),
+        governanceInput,
+        authorityRequest,
+        governance: canonicalDecision(value.governance, 'sponsor', authorityRequest),
+    });
+    const canonical = deepFreeze({ ...body, digest: digest(body) });
+    if (value.version !== 1 || value.digest !== canonical.digest
+        || canonicalWorkroomJson(value) !== canonicalWorkroomJson(canonical)) {
+        throw new Error('Project Profile publication proof digest mismatch');
+    }
+    return canonical;
+}
+function parseProfileProof(value) {
+    if (!isRecord(value) || !isRecord(value.governanceInput)
+        || !isRecord(value.authorityRequest) || !isRecord(value.governance)) {
+        throw new Error('Project Profile publication proof is malformed');
+    }
+    return canonicalProfileProof(value);
+}
+function governanceInputFromDecision(decision) {
+    const { approved: _approved, decisionId: _decisionId, route: _route, outcome: _outcome, decidedBy: _decidedBy, ...input } = structuredClone(decision);
+    return deepFreeze(input);
+}
+function canonicalRunPinProof(value) {
+    const request = canonicalRunPinRequest(value.request);
+    const authority = canonicalRunPinAuthority(value.authority, request);
+    const pin = deepFreeze(structuredClone(value.pin));
+    text(pin.projectId, 'Run pin proof Project');
+    text(pin.runId, 'Run pin proof Run');
+    text(pin.profileRevisionId, 'Run pin proof Profile revision');
+    requiredDigest(pin.profileDigest, 'Run pin proof Profile digest');
+    positive(pin.activationRegistryRevision, 'Run pin proof activation revision');
+    positive(pin.pinnedAtRegistryRevision, 'Run pin proof Registry revision');
+    if (pin.projectId !== request.projectId || pin.runId !== request.runId) {
+        throw new Error('Workroom Run Profile pin proof scope mismatch');
+    }
+    const body = deepFreeze({ version: 1, request, authority, pin });
+    const canonical = deepFreeze({ ...body, digest: digest(body) });
+    if (value.version !== 1 || value.digest !== canonical.digest
+        || canonicalWorkroomJson(value) !== canonicalWorkroomJson(canonical)) {
+        throw new Error('Workroom Run Profile pin proof digest mismatch');
+    }
+    return canonical;
+}
+function parseRunPinProof(value) {
+    if (!isRecord(value) || !isRecord(value.request)
+        || !isRecord(value.authority) || !isRecord(value.pin)) {
+        throw new Error('Workroom Run Profile pin proof is malformed');
+    }
+    return canonicalRunPinProof(value);
+}
+function canonicalRunPinRequest(value) {
+    assertKeys(value, [
+        'version', 'generation', 'operationId', 'principalId', 'projectId', 'runId',
+        'planRevisionId', 'planDigest', 'profileRevisionId', 'profileDigest',
+        'runFactDigest', 'expectedRegistryRevision', 'digest',
+    ], 'Run pin authority request');
+    const { digest: supplied, ...input } = value;
+    if (input.version !== 1 || !Number.isSafeInteger(input.generation) || input.generation < 1) {
+        throw new Error('Run pin authority request version/generation is invalid');
+    }
+    text(input.operationId, 'Run pin authority operationId');
+    text(input.principalId, 'Run pin authority principalId');
+    text(input.projectId, 'Run pin authority projectId');
+    text(input.runId, 'Run pin authority runId');
+    text(input.planRevisionId, 'Run pin authority Plan revisionId');
+    requiredDigest(input.planDigest, 'Run pin authority Plan digest');
+    text(input.profileRevisionId, 'Run pin authority Profile revisionId');
+    requiredDigest(input.profileDigest, 'Run pin authority Profile digest');
+    requiredDigest(input.runFactDigest, 'Run pin authority fact digest');
+    if (!Number.isSafeInteger(input.expectedRegistryRevision) || input.expectedRegistryRevision < -1) {
+        throw new Error('Run pin authority expected Registry revision is invalid');
+    }
+    const canonical = deepFreeze({ ...structuredClone(input), digest: digest(input) });
+    if (supplied !== canonical.digest || canonicalWorkroomJson(value) !== canonicalWorkroomJson(canonical)) {
+        throw new Error('Run pin authority request digest mismatch');
+    }
+    return canonical;
+}
+function canonicalRunPinAuthority(value, request) {
+    assertKeys(value, ['requestDigest', 'authorityDigest'], 'Run pin authority');
+    requiredDigest(value.requestDigest, 'Run pin authority request digest');
+    requiredDigest(value.authorityDigest, 'Run pin authority digest');
+    if (value.requestDigest !== request.digest)
+        throw new Error('Run pin authority exact echo mismatch');
+    return deepFreeze(structuredClone(value));
+}
+function sameRunPinAuthorityScope(left, right) {
+    const semantic = (value) => ({
+        version: value.version,
+        generation: value.generation,
+        principalId: value.principalId,
+        projectId: value.projectId,
+        runId: value.runId,
+        planRevisionId: value.planRevisionId,
+        planDigest: value.planDigest,
+        profileRevisionId: value.profileRevisionId,
+        profileDigest: value.profileDigest,
+        runFactDigest: value.runFactDigest,
+    });
+    return canonicalWorkroomJson(semantic(left)) === canonicalWorkroomJson(semantic(right));
+}
+function planningPolicyBody(command, policy) {
+    return deepFreeze({
+        version: 1,
+        revision: positive(command.revision, 'Planning Policy revision'),
+        ...(command.expectedPreviousDigest
+            ? { previousDigest: requiredDigest(command.expectedPreviousDigest, 'Planning Policy previous digest') }
+            : {}),
+        projectId: requiredText(command.projectId, 'Planning Policy projectId'),
+        catalogRevision: requiredText(command.catalogRevision, 'Planning Policy Catalog revision'),
+        projectDigest: requiredDigest(command.projectDigest, 'Planning Policy Project digest'),
+        profileRevisionId: requiredText(command.profileRevisionId, 'Planning Policy Profile revisionId'),
+        profileDigest: requiredDigest(command.profileDigest, 'Planning Policy Profile digest'),
+        policy,
+    });
+}
+function planningPolicyCandidate(command, policy, authorityRequest, governance) {
+    const body = deepFreeze({ ...planningPolicyBody(command, policy), authorityRequest, governance });
+    return deepFreeze({ ...body, digest: digest(body) });
+}
+function canonicalPlanningPolicy(value) {
+    const policy = canonicalPolicy(value.policy);
+    const candidateBody = deepFreeze({
+        version: 1,
+        revision: positive(value.revision, 'Planning Policy revision'),
+        ...(value.previousDigest
+            ? { previousDigest: requiredDigest(value.previousDigest, 'Planning Policy previous digest') }
+            : {}),
+        projectId: requiredText(value.projectId, 'Planning Policy projectId'),
+        catalogRevision: requiredText(value.catalogRevision, 'Planning Policy Catalog revision'),
+        projectDigest: requiredDigest(value.projectDigest, 'Planning Policy Project digest'),
+        profileRevisionId: requiredText(value.profileRevisionId, 'Planning Policy Profile revisionId'),
+        profileDigest: requiredDigest(value.profileDigest, 'Planning Policy Profile digest'),
+        policy,
+    });
+    const authorityRequest = canonicalRequest(value.authorityRequest);
+    if (authorityRequest.action !== 'publish_planning_policy'
+        || authorityRequest.projectId !== candidateBody.projectId
+        || authorityRequest.candidateDigest !== digest(candidateBody)
+        || authorityRequest.currentDigest !== candidateBody.previousDigest) {
+        throw new Error('Planning Policy Sponsor authority scope mismatch');
+    }
+    const body = deepFreeze({
+        ...candidateBody,
+        authorityRequest,
+        governance: canonicalDecision(value.governance, 'sponsor', authorityRequest),
+    });
+    const canonical = deepFreeze({ ...body, digest: digest(body) });
+    if (value.version !== 1 || value.digest !== canonical.digest
+        || canonicalWorkroomJson(value) !== canonicalWorkroomJson(canonical)) {
+        throw new Error('Planning Policy content digest mismatch');
+    }
+    return canonical;
+}
+function parsePlanningPolicy(value) {
+    if (!isRecord(value) || !isRecord(value.policy)
+        || !isRecord(value.authorityRequest) || !isRecord(value.governance)) {
+        throw new Error('Planning Policy revision is malformed');
+    }
+    return canonicalPlanningPolicy(value);
+}
+function canonicalPolicy(value) {
+    const { digest: supplied, ...input } = value;
+    const policy = createWorkroomDynamicPlanningPolicySnapshot(input);
+    if (supplied !== policy.digest || canonicalWorkroomJson(value) !== canonicalWorkroomJson(policy)) {
+        throw new Error('Dynamic planning Policy digest mismatch');
+    }
+    requiredText(policy.revisionId, 'Planning Policy revisionId');
+    positive(policy.maxTasks, 'Planning Policy maxTasks');
+    positive(policy.maxTotalAttempts, 'Planning Policy maxTotalAttempts');
+    positive(policy.maxAttemptsPerTask, 'Planning Policy maxAttemptsPerTask');
+    if (policy.maxAttemptsPerTask > policy.maxTotalAttempts || typeof policy.allowOptionalTasks !== 'boolean') {
+        throw new Error('Dynamic planning Policy attempt/optional constraint is invalid');
+    }
+    unique(policy.approvalRequiredAuthorities, 'Planning Policy approval authority');
+    requiredText(policy.sponsorGate.owner, 'Planning Policy Sponsor owner');
+    positive(policy.sponsorGate.decisionTimeoutMs, 'Planning Policy Sponsor timeout');
+    const { digest: schedulerDigest, ...schedulerInput } = policy.schedulerPolicy;
+    const scheduler = createWorkroomSchedulerPolicySnapshot(schedulerInput);
+    if (schedulerDigest !== scheduler.digest
+        || canonicalWorkroomJson(policy.schedulerPolicy) !== canonicalWorkroomJson(scheduler)) {
+        throw new Error('Dynamic planning Scheduler Policy digest mismatch');
+    }
+    if (!['urgent', 'high', 'normal', 'low'].includes(policy.defaultSponsorLane)
+        || !['checkpointable', 'atomic'].includes(policy.defaultPreemptibility)) {
+        throw new Error('Dynamic planning Policy default scheduling authority is invalid');
+    }
+    positive(policy.defaultTaskDeadlineMs, 'Planning Policy Task deadline');
+    return policy;
+}
+function canonicalDecision(value, role, request) {
+    assertKeys(value, [
+        'approved', 'requestDigest', 'decisionId', 'decidedBy', 'authorizedBy', 'decidedAt',
+    ], 'Profile authority decision');
+    if (!value || value.approved !== true || value.authorizedBy !== role) {
+        throw new Error('Profile authority decision role is invalid');
+    }
+    requiredDigest(value.requestDigest, 'authority request digest');
+    requiredText(value.decisionId, 'authority decisionId');
+    requiredText(value.decidedBy, 'authority principal');
+    nonNegative(value.decidedAt, 'authority decision timestamp');
+    if (value.requestDigest !== request.digest || value.decidedBy !== request.authenticatedPrincipalId) {
+        throw new Error('Profile authority decision exact echo mismatch');
+    }
+    return deepFreeze(structuredClone(value));
+}
+function canonicalRequest(value) {
+    const { digest: supplied, ...input } = value;
+    const canonical = createRequest(input);
+    if (supplied !== canonical.digest || canonicalWorkroomJson(value) !== canonicalWorkroomJson(canonical)) {
+        throw new Error('Profile publisher authority request digest mismatch');
+    }
+    return canonical;
+}
+function generationSupply(view) {
+    return deepFreeze({
+        tools: sortDefinitions(view.tools),
+        skills: sortDefinitions(view.skills),
+        agents: sortDefinitions(view.agents),
+    });
+}
+function assertView(view, generation) {
+    if (view.generation !== generation)
+        throw new Error('Profile publication generation view is stale');
+    requiredDigest(view.digest, 'generation view digest');
+}
+function commandHeader(command, signal) {
+    signal.throwIfAborted();
+    if (command.version !== 1)
+        throw new Error('Profile control command version is invalid');
+    text(command.operationId, 'control operationId');
+    text(command.authenticatedPrincipalId, 'authenticated principalId');
+}
+function sortPackRefs(values) {
+    if (!Array.isArray(values))
+        throw new Error('Capability Pack refs are invalid');
+    return deepFreeze(values.map(value => {
+        assertPackRef(value);
+        return { id: value.id, version: value.version, digest: value.digest };
+    }).sort((left, right) => compareCanonicalWorkroomText(`${left.id}@${left.version}#${left.digest}`, `${right.id}@${right.version}#${right.digest}`)));
+}
+function assertPackRef(value) {
+    text(value.id, 'Pack ref id');
+    text(value.version, 'Pack ref version');
+    requiredDigest(value.digest, 'Pack ref digest');
+}
+function sortDefinitions(values) {
+    if (!Array.isArray(values))
+        throw new Error('Capability definitions are invalid');
+    return deepFreeze(values.map(value => ({
+        id: requiredText(value.id, 'Capability id'),
+        digest: requiredDigest(value.digest, 'Capability digest'),
+    })).sort(byId));
+}
+function sortKnowledgeDefinitions(values, label) {
+    return deepFreeze([...values].map(value => ({
+        id: requiredText(value.id, `${label} id`),
+        digest: requiredDigest(value.digest, `${label} digest`),
+        allowedRoles: unique(value.allowedRoles, `${label} allowed role`),
+        taskKeys: unique(value.taskKeys, `${label} Task key`),
+    })).sort(byId));
+}
+function canonicalAcceptancePolicy(value) {
+    requiredText(value.id, 'Acceptance Policy id');
+    requiredDigest(value.digest, 'Acceptance Policy digest');
+    if (!Array.isArray(value.tasks) || value.tasks.length === 0) {
+        throw new Error('Acceptance Policy requires Tasks');
+    }
+    const tasks = [...value.tasks].map(task => {
+        if (!['task_result', 'integration_candidate', 'effect_intent'].includes(task.kind)) {
+            throw new Error('Acceptance Policy Task kind is invalid');
+        }
+        if (!['baseline', 'reviewer_required', 'sponsor_required', 'reviewer_then_sponsor']
+            .includes(task.minimumRoute)) {
+            throw new Error('Acceptance Policy minimum route is invalid');
+        }
+        if (!Array.isArray(task.criteria) || task.criteria.length === 0) {
+            throw new Error('Acceptance Policy Task requires criteria');
+        }
+        return {
+            taskKey: requiredText(task.taskKey, 'Acceptance Policy Task key'),
+            kind: task.kind,
+            criteria: [...task.criteria].map(criterion => {
+                if (!['deterministic', 'judgment'].includes(criterion.kind)) {
+                    throw new Error('Acceptance criterion kind is invalid');
+                }
+                return {
+                    id: requiredText(criterion.id, 'Acceptance criterion id'),
+                    kind: criterion.kind,
+                    description: requiredText(criterion.description, 'Acceptance criterion description'),
+                };
+            }).sort(byId),
+            requiredEvidence: unique(task.requiredEvidence, 'Acceptance required Evidence'),
+            minimumRoute: task.minimumRoute,
+            reviewerPrincipalId: requiredText(task.reviewerPrincipalId, 'Acceptance Reviewer principal'),
+            sponsorPrincipalId: requiredText(task.sponsorPrincipalId, 'Acceptance Sponsor principal'),
+            reviewerTimeoutMs: positive(task.reviewerTimeoutMs, 'Acceptance Reviewer timeout'),
+            sponsorTimeoutMs: positive(task.sponsorTimeoutMs, 'Acceptance Sponsor timeout'),
+        };
+    }).sort((left, right) => compareCanonicalWorkroomText(left.taskKey, right.taskKey));
+    if (new Set(tasks.map(task => task.taskKey)).size !== tasks.length) {
+        throw new Error('Acceptance Policy Task keys contain duplicates');
+    }
+    const memorySchema = value.memorySchema;
+    if (!memorySchema || !Array.isArray(memorySchema.claimRules)) {
+        throw new Error('Acceptance Memory schema is invalid');
+    }
+    const claimRules = [...memorySchema.claimRules].map(rule => {
+        if (rule.valueType !== 'string' || typeof rule.allowSupersedes !== 'boolean') {
+            throw new Error('Acceptance Memory claim rule is invalid');
+        }
+        const allowedStatuses = unique(rule.allowedStatuses, 'Acceptance Memory claim status');
+        if (allowedStatuses.some(status => status !== 'verified' && status !== 'assumed')) {
+            throw new Error('Acceptance Memory claim status is invalid');
+        }
+        return {
+            key: requiredText(rule.key, 'Acceptance Memory claim key'),
+            valueType: 'string',
+            allowedStatuses: allowedStatuses,
+            allowSupersedes: rule.allowSupersedes,
+        };
+    }).sort((left, right) => compareCanonicalWorkroomText(left.key, right.key));
+    if (new Set(claimRules.map(rule => rule.key)).size !== claimRules.length) {
+        throw new Error('Acceptance Memory claim keys contain duplicates');
+    }
+    return deepFreeze({
+        id: value.id,
+        digest: value.digest,
+        tasks,
+        memorySchema: {
+            revision: positive(memorySchema.revision, 'Acceptance Memory schema revision'),
+            claimRules,
+        },
+    });
+}
+function unique(values, label) {
+    if (!Array.isArray(values))
+        throw new Error(`${label} list is invalid`);
+    return deepFreeze([...new Set(values.map(value => requiredText(value, label)))].sort());
+}
+function byId(left, right) {
+    return compareCanonicalWorkroomText(left.id, right.id);
+}
+function assertKeys(value, allowed, label) {
+    const extras = Object.keys(value).filter(key => !allowed.includes(key));
+    if (extras.length > 0)
+        throw new Error(`${label} contains forbidden fields: ${extras.sort().join(',')}`);
+}
+function text(value, label) {
+    if (typeof value !== 'string' || !value.trim() || value !== value.trim()) {
+        throw new Error(`${label} is invalid`);
+    }
+}
+function requiredText(value, label) {
+    text(value, label);
+    return value;
+}
+function requiredDigest(value, label) {
+    text(value, label);
+    if (!/^sha256:[a-f\d]{64}$/u.test(value))
+        throw new Error(`${label} is not a canonical SHA-256 digest`);
+    return value;
+}
+function positive(value, label) {
+    if (!Number.isSafeInteger(value) || Number(value) < 1)
+        throw new Error(`${label} is invalid`);
+    return Number(value);
+}
+function nonNegative(value, label) {
+    if (!Number.isSafeInteger(value) || Number(value) < 0)
+        throw new Error(`${label} is invalid`);
+    return Number(value);
+}
+function keyHash(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+async function readOptional(path, parse) {
+    try {
+        return parse(JSON.parse(await readFile(path, 'utf8')));
+    }
+    catch (error) {
+        if (hasCode(error, 'ENOENT'))
+            return undefined;
+        throw error;
+    }
+}
+async function readRequired(path, parse) {
+    const value = await readOptional(path, parse);
+    if (!value)
+        throw new Error(`Required Workroom Profile authority record is absent: ${path}`);
+    return value;
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function hasCode(error, code) {
+    return Boolean(error && typeof error === 'object' && 'code' in error
+        && error.code === code);
+}
+//# sourceMappingURL=workroom-profile-authority-runtime.js.map