@agent-deck/backend 1.10.1 → 1.10.3

package/dist/execution-authority/bearer.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Parse coordinator enrollment / execution-authority bearer tokens.
+ * Forms: `enr_…:secret`, `authz_…:secret` (preferred), or raw secret with id header.
+ */
+export type EnrollmentBearer = {
+    enrollmentId: string;
+    secret: string;
+};
+export type AuthorityBearer = {
+    authorityId: string;
+    secret: string;
+};
+export declare function parseEnrollmentBearer(token: string): EnrollmentBearer | null;
+export declare function parseAuthorityBearer(token: string): AuthorityBearer | null;
+//# sourceMappingURL=bearer.d.ts.map

package/dist/execution-authority/bearer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bearer.d.ts","sourceRoot":"","sources":["../../src/execution-authority/bearer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAS5E;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAS1E"}

package/dist/execution-authority/bearer.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Parse coordinator enrollment / execution-authority bearer tokens.
+ * Forms: `enr_…:secret`, `authz_…:secret` (preferred), or raw secret with id header.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEnrollmentBearer = parseEnrollmentBearer;
+exports.parseAuthorityBearer = parseAuthorityBearer;
+function parseEnrollmentBearer(token) {
+    const trimmed = token.trim();
+    const colon = trimmed.indexOf(':');
+    if (colon <= 0)
+        return null;
+    const enrollmentId = trimmed.slice(0, colon);
+    if (!/^enr_[A-Za-z0-9]+$/.test(enrollmentId))
+        return null;
+    const secret = trimmed.slice(colon + 1);
+    if (!secret)
+        return null;
+    return { enrollmentId, secret };
+}
+function parseAuthorityBearer(token) {
+    const trimmed = token.trim();
+    const colon = trimmed.indexOf(':');
+    if (colon <= 0)
+        return null;
+    const authorityId = trimmed.slice(0, colon);
+    if (!/^authz_[A-Za-z0-9]+$/.test(authorityId))
+        return null;
+    const secret = trimmed.slice(colon + 1);
+    if (!secret)
+        return null;
+    return { authorityId, secret };
+}
+//# sourceMappingURL=bearer.js.map

package/dist/execution-authority/bearer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bearer.js","sourceRoot":"","sources":["../../src/execution-authority/bearer.ts"],"names":[],"mappings":";AAAA;;;GAGG;;AAYH,sDASC;AAED,oDASC;AApBD,SAAgB,qBAAqB,CAAC,KAAa;IACjD,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;IAC7B,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACnC,IAAI,KAAK,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAC5B,MAAM,YAAY,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IAC7C,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,YAAY,CAAC;QAAE,OAAO,IAAI,CAAC;IAC1D,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;IACxC,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IACzB,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC;AAClC,CAAC;AAED,SAAgB,oBAAoB,CAAC,KAAa;IAChD,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;IAC7B,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACnC,IAAI,KAAK,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAC5B,MAAM,WAAW,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IAC5C,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,WAAW,CAAC;QAAE,OAAO,IAAI,CAAC;IAC3D,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;IACxC,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IACzB,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,CAAC;AACjC,CAAC"}

package/dist/execution-authority/index.d.ts

@@ -0,0 +1,6 @@
+export { ExecutionAuthorityLedger } from './ledger';
+export type { LedgerState } from './ledger';
+export { ExecutionAuthorityStore } from './store';
+export type { ExecutionAuthorityStoreOptions } from './store';
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/execution-authority/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/execution-authority/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AACpD,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAClD,YAAY,EAAE,8BAA8B,EAAE,MAAM,SAAS,CAAC;AAC9D,mBAAmB,SAAS,CAAC"}

package/dist/execution-authority/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionAuthorityStore = exports.ExecutionAuthorityLedger = void 0;
+var ledger_1 = require("./ledger");
+Object.defineProperty(exports, "ExecutionAuthorityLedger", { enumerable: true, get: function () { return ledger_1.ExecutionAuthorityLedger; } });
+var store_1 = require("./store");
+Object.defineProperty(exports, "ExecutionAuthorityStore", { enumerable: true, get: function () { return store_1.ExecutionAuthorityStore; } });
+//# sourceMappingURL=index.js.map

package/dist/execution-authority/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/execution-authority/index.ts"],"names":[],"mappings":";;;AAAA,mCAAoD;AAA3C,kHAAA,wBAAwB,OAAA;AAEjC,iCAAkD;AAAzC,gHAAA,uBAAuB,OAAA"}

package/dist/execution-authority/ledger.d.ts

@@ -0,0 +1,85 @@
+/**
+ * In-memory execution-authority ledger (NOT-85 logic engine).
+ * Durable SQLite wrapper: `ExecutionAuthorityStore` (NOT-86).
+ */
+import type { AuditEvent, AuthorizedCallInput, ContractResult, CoordinatorEnrollment, EnrollCoordinatorResult, ExecutionAuthority, MintAuthorityInput, MintAuthorityResult } from './types';
+/** Serializable ledger state for durable hydrate/persist. */
+export type LedgerState = {
+    enrollments: CoordinatorEnrollment[];
+    enrollmentSecretHashes: Array<{
+        enrollmentId: string;
+        secretHash: string;
+    }>;
+    authorities: ExecutionAuthority[];
+    secretHashes: Array<{
+        authorityId: string;
+        secretHash: string;
+    }>;
+    mintIndex: Array<{
+        enrollmentId: string;
+        idempotencyKey: string;
+        authorityId: string;
+    }>;
+    audit: AuditEvent[];
+};
+export interface ExecutionAuthorityLedgerOptions {
+    /** Injectable clock for expiry tests. */
+    now?: () => Date;
+}
+/**
+ * Deck-side authorization ledger (skeleton). Authoritative for enrollment and
+ * execution authority; does not model Dealer run lifecycle.
+ */
+export declare class ExecutionAuthorityLedger {
+    private readonly enrollments;
+    private readonly enrollmentSecretHashes;
+    private readonly authorities;
+    private readonly secretHashes;
+    private readonly mintIndex;
+    private readonly audit;
+    private readonly now;
+    constructor(options?: ExecutionAuthorityLedgerOptions);
+    exportState(): LedgerState;
+    replaceState(state: LedgerState): void;
+    getEnrollment(enrollmentId: string): CoordinatorEnrollment | undefined;
+    listEnrollments(): CoordinatorEnrollment[];
+    verifyEnrollmentSecret(enrollmentId: string, secret: string): boolean;
+    verifyAuthoritySecret(authorityId: string, secret: string): boolean;
+    enrollCoordinator(input: {
+        coordinatorId: string;
+        allowedDeckIds: string[];
+    }): ContractResult<EnrollCoordinatorResult>;
+    revokeEnrollment(enrollmentId: string): ContractResult<{
+        enrollmentId: string;
+    }>;
+    mintAuthority(input: MintAuthorityInput): ContractResult<MintAuthorityResult>;
+    /**
+     * Non-auditing lookup for ownership / existence checks.
+     * Does not refresh expiry (avoids authority_expired side effects during probes).
+     */
+    peekAuthority(authorityId: string): ExecutionAuthority | undefined;
+    inspectAuthority(authorityId: string): ContractResult<ExecutionAuthority>;
+    revokeAuthority(authorityId: string): ContractResult<{
+        authorityId: string;
+    }>;
+    /**
+     * Simulate one authorized Deck tool call under execution authority.
+     * Never waits for human approval — returns INTERACTION_REQUIRED immediately.
+     */
+    invokeAuthorizedCall(input: AuthorizedCallInput): ContractResult<{
+        serviceId: string;
+        toolName: string;
+        result: string;
+    }>;
+    listAuditEvents(filter?: {
+        runId?: string;
+        attemptId?: string;
+        authorityId?: string;
+        enrollmentId?: string;
+        requestId?: string;
+    }): AuditEvent[];
+    private toolAllowed;
+    private refreshAuthorityStatus;
+    private pushAudit;
+}
+//# sourceMappingURL=ledger.d.ts.map

package/dist/execution-authority/ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ledger.d.ts","sourceRoot":"","sources":["../../src/execution-authority/ledger.ts"],"names":[],"mappings":"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"}

package/dist/execution-authority/ledger.js

@@ -0,0 +1,507 @@
+"use strict";
+/**
+ * In-memory execution-authority ledger (NOT-85 logic engine).
+ * Durable SQLite wrapper: `ExecutionAuthorityStore` (NOT-86).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionAuthorityLedger = void 0;
+const node_crypto_1 = require("node:crypto");
+const shared_1 = require("@agent-deck/shared");
+const store_1 = require("../trusted-session/store");
+function newId(kind) {
+    return (0, shared_1.prefixTrustedId)(kind, (0, node_crypto_1.randomUUID)());
+}
+function cloneAuthority(authority) {
+    return {
+        ...authority,
+        allowedServices: [...authority.allowedServices],
+        allowedTools: authority.allowedTools.map((t) => ({ ...t })),
+    };
+}
+function toolsEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    const key = (t) => `${t.serviceId}\0${t.toolName}`;
+    const sortedA = [...a].map(key).sort();
+    const sortedB = [...b].map(key).sort();
+    return sortedA.every((v, i) => v === sortedB[i]);
+}
+function mintParamsMatch(existing, input) {
+    const storedTtlMs = Date.parse(existing.expiresAt) - Date.parse(existing.issuedAt);
+    return (existing.runId === input.runId &&
+        existing.attemptId === input.attemptId &&
+        existing.deckId === input.deckId &&
+        existing.audience === input.audience &&
+        storedTtlMs === input.ttlMs &&
+        existing.allowedServices.length === input.allowedServices.length &&
+        existing.allowedServices.every((s) => input.allowedServices.includes(s)) &&
+        toolsEqual(existing.allowedTools, input.allowedTools));
+}
+/**
+ * Deck-side authorization ledger (skeleton). Authoritative for enrollment and
+ * execution authority; does not model Dealer run lifecycle.
+ */
+class ExecutionAuthorityLedger {
+    enrollments = new Map();
+    enrollmentSecretHashes = new Map();
+    authorities = new Map();
+    secretHashes = new Map();
+    mintIndex = new Map(); // enrollmentId\0idempotencyKey -> authorityId
+    audit = [];
+    now;
+    constructor(options = {}) {
+        this.now = options.now ?? (() => new Date());
+    }
+    exportState() {
+        return {
+            enrollments: [...this.enrollments.values()].map((e) => ({
+                ...e,
+                allowedDeckIds: [...e.allowedDeckIds],
+            })),
+            enrollmentSecretHashes: [...this.enrollmentSecretHashes.entries()].map(([enrollmentId, secretHash]) => ({ enrollmentId, secretHash })),
+            authorities: [...this.authorities.values()].map(cloneAuthority),
+            secretHashes: [...this.secretHashes.entries()].map(([authorityId, secretHash]) => ({
+                authorityId,
+                secretHash,
+            })),
+            mintIndex: [...this.mintIndex.entries()].map(([key, authorityId]) => {
+                const [enrollmentId, idempotencyKey] = key.split('\0');
+                return { enrollmentId, idempotencyKey, authorityId };
+            }),
+            audit: this.audit.map((event) => ({
+                ...event,
+                correlation: { ...event.correlation },
+                detail: event.detail ? { ...event.detail } : undefined,
+            })),
+        };
+    }
+    replaceState(state) {
+        this.enrollments.clear();
+        this.enrollmentSecretHashes.clear();
+        this.authorities.clear();
+        this.secretHashes.clear();
+        this.mintIndex.clear();
+        this.audit.length = 0;
+        for (const enrollment of state.enrollments) {
+            this.enrollments.set(enrollment.enrollmentId, {
+                ...enrollment,
+                allowedDeckIds: [...enrollment.allowedDeckIds],
+            });
+        }
+        for (const row of state.enrollmentSecretHashes) {
+            this.enrollmentSecretHashes.set(row.enrollmentId, row.secretHash);
+        }
+        for (const authority of state.authorities) {
+            this.authorities.set(authority.authorityId, cloneAuthority(authority));
+        }
+        for (const row of state.secretHashes) {
+            this.secretHashes.set(row.authorityId, row.secretHash);
+        }
+        for (const row of state.mintIndex) {
+            this.mintIndex.set(`${row.enrollmentId}\0${row.idempotencyKey}`, row.authorityId);
+        }
+        for (const event of state.audit) {
+            this.audit.push({
+                ...event,
+                correlation: { ...event.correlation },
+                detail: event.detail ? { ...event.detail } : undefined,
+            });
+        }
+    }
+    getEnrollment(enrollmentId) {
+        const enrollment = this.enrollments.get(enrollmentId);
+        if (!enrollment)
+            return undefined;
+        return { ...enrollment, allowedDeckIds: [...enrollment.allowedDeckIds] };
+    }
+    listEnrollments() {
+        return [...this.enrollments.values()].map((e) => ({
+            ...e,
+            allowedDeckIds: [...e.allowedDeckIds],
+        }));
+    }
+    verifyEnrollmentSecret(enrollmentId, secret) {
+        const hash = this.enrollmentSecretHashes.get(enrollmentId);
+        if (!hash)
+            return false;
+        return (0, store_1.verifyGrantSecret)(secret, hash);
+    }
+    verifyAuthoritySecret(authorityId, secret) {
+        const hash = this.secretHashes.get(authorityId);
+        if (!hash)
+            return false;
+        return (0, store_1.verifyGrantSecret)(secret, hash);
+    }
+    enrollCoordinator(input) {
+        const enrollment = {
+            enrollmentId: newId('enr'),
+            coordinatorId: input.coordinatorId,
+            status: 'active',
+            allowedDeckIds: [...input.allowedDeckIds],
+            createdAt: this.now().toISOString(),
+            revokedAt: null,
+        };
+        const enrollmentSecret = `enrs_${(0, node_crypto_1.randomUUID)().replace(/-/g, '')}${(0, node_crypto_1.randomUUID)().replace(/-/g, '')}`;
+        this.enrollments.set(enrollment.enrollmentId, enrollment);
+        this.enrollmentSecretHashes.set(enrollment.enrollmentId, (0, store_1.hashGrantSecret)(enrollmentSecret));
+        this.pushAudit('enrollment_created', {
+            enrollmentId: enrollment.enrollmentId,
+        }, { coordinatorId: input.coordinatorId });
+        return {
+            ok: true,
+            data: {
+                enrollment: {
+                    ...enrollment,
+                    allowedDeckIds: [...enrollment.allowedDeckIds],
+                },
+                enrollmentSecret,
+            },
+        };
+    }
+    revokeEnrollment(enrollmentId) {
+        const enrollment = this.enrollments.get(enrollmentId);
+        if (!enrollment) {
+            return {
+                ok: false,
+                error_code: 'COORDINATOR_NOT_ENROLLED',
+                message: 'Unknown enrollment',
+                correlation: { enrollmentId },
+            };
+        }
+        if (enrollment.status === 'revoked') {
+            return { ok: true, data: { enrollmentId } };
+        }
+        enrollment.status = 'revoked';
+        enrollment.revokedAt = this.now().toISOString();
+        this.pushAudit('enrollment_revoked', { enrollmentId });
+        for (const stored of this.authorities.values()) {
+            if (stored.enrollmentId !== enrollmentId)
+                continue;
+            const authority = this.refreshAuthorityStatus(stored.authorityId);
+            if (!authority || authority.status !== 'live')
+                continue;
+            authority.status = 'revoked';
+            this.pushAudit('authority_revoked', {
+                enrollmentId,
+                authorityId: authority.authorityId,
+                runId: authority.runId,
+                attemptId: authority.attemptId,
+                deckId: authority.deckId,
+            }, { reason: 'enrollment_revoked' });
+        }
+        return { ok: true, data: { enrollmentId } };
+    }
+    mintAuthority(input) {
+        if (!(input.ttlMs > 0)) {
+            return {
+                ok: false,
+                error_code: 'INVALID_MINT_REQUEST',
+                message: 'ttlMs must be positive',
+                reason: 'ttl_non_positive',
+                correlation: { enrollmentId: input.enrollmentId },
+            };
+        }
+        const enrollment = this.enrollments.get(input.enrollmentId);
+        if (!enrollment) {
+            return {
+                ok: false,
+                error_code: 'COORDINATOR_NOT_ENROLLED',
+                message: 'Unknown enrollment',
+                correlation: { enrollmentId: input.enrollmentId },
+            };
+        }
+        if (enrollment.status !== 'active') {
+            return {
+                ok: false,
+                error_code: 'ENROLLMENT_REVOKED',
+                message: 'Enrollment is revoked',
+                correlation: { enrollmentId: input.enrollmentId },
+            };
+        }
+        if (!enrollment.allowedDeckIds.includes(input.deckId)) {
+            return {
+                ok: false,
+                error_code: 'RESOURCE_OUT_OF_SCOPE',
+                message: 'Deck not permitted for this enrollment',
+                reason: 'deck_not_permitted',
+                correlation: { enrollmentId: input.enrollmentId, deckId: input.deckId },
+            };
+        }
+        const mintKey = `${input.enrollmentId}\0${input.idempotencyKey}`;
+        const existingId = this.mintIndex.get(mintKey);
+        if (existingId) {
+            const existing = this.refreshAuthorityStatus(existingId);
+            if (!mintParamsMatch(existing, input)) {
+                return {
+                    ok: false,
+                    error_code: 'IDEMPOTENCY_KEY_CONFLICT',
+                    message: 'Idempotency key reused with different mint parameters',
+                    reason: 'params_mismatch',
+                    correlation: {
+                        enrollmentId: existing.enrollmentId,
+                        authorityId: existing.authorityId,
+                        runId: existing.runId,
+                        attemptId: existing.attemptId,
+                        deckId: existing.deckId,
+                    },
+                };
+            }
+            if (existing.status === 'live') {
+                // Idempotent remint does not re-issue the secret (Dealer must retain launcher handle).
+                return {
+                    ok: true,
+                    data: {
+                        authority: cloneAuthority(existing),
+                        authoritySecret: null,
+                        secretIssued: false,
+                    },
+                };
+            }
+            return {
+                ok: false,
+                error_code: existing.status === 'expired' ? 'AUTHORITY_EXPIRED' : 'AUTHORITY_REVOKED',
+                message: `Authority already ${existing.status}`,
+                reason: existing.status === 'revoked' ? 'explicit_revoke' : undefined,
+                correlation: {
+                    enrollmentId: existing.enrollmentId,
+                    authorityId: existing.authorityId,
+                    runId: existing.runId,
+                    attemptId: existing.attemptId,
+                    deckId: existing.deckId,
+                },
+            };
+        }
+        const issuedAt = this.now();
+        const authority = {
+            authorityId: newId('authz'),
+            enrollmentId: input.enrollmentId,
+            runId: input.runId,
+            attemptId: input.attemptId,
+            deckId: input.deckId,
+            audience: input.audience,
+            allowedServices: [...input.allowedServices],
+            allowedTools: input.allowedTools.map((t) => ({ ...t })),
+            issuedAt: issuedAt.toISOString(),
+            expiresAt: new Date(issuedAt.getTime() + input.ttlMs).toISOString(),
+            status: 'live',
+            idempotencyKey: input.idempotencyKey,
+        };
+        const authoritySecret = `seas_${(0, node_crypto_1.randomUUID)().replace(/-/g, '')}${(0, node_crypto_1.randomUUID)().replace(/-/g, '')}`;
+        this.authorities.set(authority.authorityId, authority);
+        this.secretHashes.set(authority.authorityId, (0, store_1.hashGrantSecret)(authoritySecret));
+        this.mintIndex.set(mintKey, authority.authorityId);
+        this.pushAudit('authority_minted', {
+            enrollmentId: authority.enrollmentId,
+            authorityId: authority.authorityId,
+            runId: authority.runId,
+            attemptId: authority.attemptId,
+            deckId: authority.deckId,
+        });
+        return {
+            ok: true,
+            data: {
+                authority: cloneAuthority(authority),
+                authoritySecret,
+                secretIssued: true,
+            },
+        };
+    }
+    /**
+     * Non-auditing lookup for ownership / existence checks.
+     * Does not refresh expiry (avoids authority_expired side effects during probes).
+     */
+    peekAuthority(authorityId) {
+        const authority = this.authorities.get(authorityId);
+        return authority ? cloneAuthority(authority) : undefined;
+    }
+    inspectAuthority(authorityId) {
+        const authority = this.refreshAuthorityStatus(authorityId);
+        if (!authority) {
+            return {
+                ok: false,
+                error_code: 'AUTHORITY_UNKNOWN',
+                message: 'Unknown authority',
+                correlation: { authorityId },
+            };
+        }
+        this.pushAudit('authority_inspected', {
+            enrollmentId: authority.enrollmentId,
+            authorityId: authority.authorityId,
+            runId: authority.runId,
+            attemptId: authority.attemptId,
+            deckId: authority.deckId,
+        });
+        return { ok: true, data: cloneAuthority(authority) };
+    }
+    revokeAuthority(authorityId) {
+        const authority = this.authorities.get(authorityId);
+        if (!authority) {
+            return {
+                ok: false,
+                error_code: 'AUTHORITY_UNKNOWN',
+                message: 'Unknown authority',
+                correlation: { authorityId },
+            };
+        }
+        if (authority.status !== 'revoked') {
+            authority.status = 'revoked';
+            this.pushAudit('authority_revoked', {
+                enrollmentId: authority.enrollmentId,
+                authorityId: authority.authorityId,
+                runId: authority.runId,
+                attemptId: authority.attemptId,
+                deckId: authority.deckId,
+            }, { reason: 'explicit_revoke' });
+        }
+        return { ok: true, data: { authorityId } };
+    }
+    /**
+     * Simulate one authorized Deck tool call under execution authority.
+     * Never waits for human approval — returns INTERACTION_REQUIRED immediately.
+     */
+    invokeAuthorizedCall(input) {
+        const authority = this.refreshAuthorityStatus(input.authorityId);
+        const correlation = {
+            authorityId: input.authorityId,
+        };
+        if (!authority) {
+            return {
+                ok: false,
+                error_code: 'AUTHORITY_UNKNOWN',
+                message: 'Unknown authority',
+                correlation,
+            };
+        }
+        correlation.enrollmentId = authority.enrollmentId;
+        correlation.runId = authority.runId;
+        correlation.attemptId = authority.attemptId;
+        correlation.deckId = authority.deckId;
+        const expectedHash = this.secretHashes.get(authority.authorityId);
+        if (!expectedHash || !(0, store_1.verifyGrantSecret)(input.authoritySecret, expectedHash)) {
+            this.pushAudit('call_denied', correlation, { reason: 'bad_secret' });
+            return {
+                ok: false,
+                error_code: 'AUTHORITY_SECRET_INVALID',
+                message: 'Invalid authority secret',
+                correlation,
+            };
+        }
+        if (input.audience !== authority.audience) {
+            this.pushAudit('call_denied', correlation, {
+                reason: 'audience_mismatch',
+                expected: authority.audience,
+                actual: input.audience,
+            });
+            return {
+                ok: false,
+                error_code: 'AUDIENCE_MISMATCH',
+                message: 'Caller audience does not match authority audience',
+                correlation,
+            };
+        }
+        if (authority.status === 'expired') {
+            this.pushAudit('call_denied', correlation, { reason: 'expired' });
+            return {
+                ok: false,
+                error_code: 'AUTHORITY_EXPIRED',
+                message: 'Authority expired',
+                correlation,
+            };
+        }
+        if (authority.status === 'revoked') {
+            this.pushAudit('call_denied', correlation, { reason: 'revoked' });
+            return {
+                ok: false,
+                error_code: 'AUTHORITY_REVOKED',
+                message: 'Authority revoked',
+                reason: 'explicit_revoke',
+                correlation,
+            };
+        }
+        if (input.requiresInteraction) {
+            const requestId = newId('req');
+            correlation.requestId = requestId;
+            this.pushAudit('call_denied', correlation, { reason: 'interaction_required' });
+            return {
+                ok: false,
+                error_code: 'INTERACTION_REQUIRED',
+                message: 'Control-plane decision required; do not hold the worker',
+                correlation,
+            };
+        }
+        if (!this.toolAllowed(authority, input.serviceId, input.toolName)) {
+            this.pushAudit('call_denied', correlation, {
+                reason: 'tool_not_in_snapshot',
+                serviceId: input.serviceId,
+                toolName: input.toolName,
+            });
+            return {
+                ok: false,
+                error_code: 'RESOURCE_OUT_OF_SCOPE',
+                message: 'Tool not in authority snapshot',
+                reason: 'tool_not_in_snapshot',
+                correlation,
+            };
+        }
+        this.pushAudit('call_allowed', correlation, {
+            serviceId: input.serviceId,
+            toolName: input.toolName,
+        });
+        return {
+            ok: true,
+            data: {
+                serviceId: input.serviceId,
+                toolName: input.toolName,
+                result: 'ok',
+            },
+        };
+    }
+    listAuditEvents(filter = {}) {
+        return this.audit.filter((event) => {
+            const c = event.correlation;
+            if (filter.runId && c.runId !== filter.runId)
+                return false;
+            if (filter.attemptId && c.attemptId !== filter.attemptId)
+                return false;
+            if (filter.authorityId && c.authorityId !== filter.authorityId)
+                return false;
+            if (filter.enrollmentId && c.enrollmentId !== filter.enrollmentId)
+                return false;
+            if (filter.requestId && c.requestId !== filter.requestId)
+                return false;
+            return true;
+        });
+    }
+    toolAllowed(authority, serviceId, toolName) {
+        if (!authority.allowedServices.includes(serviceId))
+            return false;
+        return authority.allowedTools.some((t) => t.serviceId === serviceId && t.toolName === toolName);
+    }
+    refreshAuthorityStatus(authorityId) {
+        const authority = this.authorities.get(authorityId);
+        if (!authority)
+            return undefined;
+        if (authority.status === 'live' && Date.parse(authority.expiresAt) <= this.now().getTime()) {
+            authority.status = 'expired';
+            this.pushAudit('authority_expired', {
+                enrollmentId: authority.enrollmentId,
+                authorityId: authority.authorityId,
+                runId: authority.runId,
+                attemptId: authority.attemptId,
+                deckId: authority.deckId,
+            });
+        }
+        return authority;
+    }
+    pushAudit(kind, correlation, detail) {
+        this.audit.push({
+            eventId: newId('evt'),
+            at: this.now().toISOString(),
+            kind,
+            correlation: { ...correlation },
+            detail,
+        });
+    }
+}
+exports.ExecutionAuthorityLedger = ExecutionAuthorityLedger;
+//# sourceMappingURL=ledger.js.map