@aiwg/cli 2026.9.20 → 2026.9.21

package/dist/src/decision/job-gateway.js

@@ -0,0 +1,121 @@
+import { createCipheriv, createDecipheriv, randomBytes, timingSafeEqual } from 'node:crypto';
+import { canonicalJson } from '../security/artifact-trust.js';
+import { JobConflictError } from './job-store.js';
+/** Host-only object authorization boundary. The key and actor come from the trusted host, never a request body. */
+export class DecisionJobGateway {
+    runtime;
+    key;
+    now;
+    pollGate;
+    capabilities;
+    admitJob;
+    constructor(runtime, key, now = Date.now, pollGate, capabilities, admitJob) {
+        this.runtime = runtime;
+        this.key = key;
+        this.now = now;
+        this.pollGate = pollGate;
+        this.capabilities = capabilities;
+        this.admitJob = admitJob;
+        if (!Buffer.isBuffer(key) || key.length !== 32)
+            throw new JobConflictError('Invalid job handle key');
+        this.key = Buffer.from(key);
+    }
+    async submit(actor, job) {
+        this.admitJob?.(job);
+        const snapshot = await this.runtime.submit(job, actor);
+        if (snapshot.deleted || this.now() >= snapshot.job.expiresAtEpochMs)
+            throw new JobConflictError('Job unavailable');
+        return { handle: this.seal(snapshot), snapshot };
+    }
+    async poll(actor, handle) {
+        if (this.pollGate)
+            await this.pollGate(actor);
+        const id = this.unseal(actor, handle);
+        if (!id)
+            return null;
+        const snapshot = await this.runtime.poll(actor, id.id);
+        return snapshot && snapshot.job.fingerprint === id.fingerprint && snapshot.job.createdAtEpochMs === id.createdAtEpochMs &&
+            snapshot.job.expiresAtEpochMs === id.expiresAtEpochMs && this.now() < snapshot.job.expiresAtEpochMs ? snapshot : null;
+    }
+    async items(actor, handle, offset = 0, limit = 100) {
+        const snapshot = await this.poll(actor, handle);
+        return snapshot ? this.runtime.items(actor, snapshot.job.id, offset, limit) : null;
+    }
+    async cancel(actor, handle) {
+        const snapshot = await this.poll(actor, handle);
+        return snapshot ? this.runtime.cancel(actor, snapshot.job.id) : null;
+    }
+    async retry(actor, handle, itemId) {
+        const snapshot = await this.poll(actor, handle);
+        return snapshot ? this.runtime.retry(actor, snapshot.job.id, itemId) : null;
+    }
+    async remove(actor, handle) {
+        const snapshot = await this.poll(actor, handle);
+        return snapshot ? this.runtime.remove(actor, snapshot.job.id) : false;
+    }
+    async export(actor, handle) {
+        const snapshot = await this.poll(actor, handle);
+        if (!snapshot || !this.capabilities || !await this.capabilities.authorizeExport(actor, snapshot))
+            return null;
+        return snapshot;
+    }
+    async list(actor, cursor, limit = 100) {
+        if (!this.capabilities || !Number.isSafeInteger(limit) || limit < 1 || limit > 100)
+            return null;
+        if (this.pollGate)
+            await this.pollGate(actor);
+        let after = null;
+        if (cursor !== undefined) {
+            const position = this.open(actor, cursor, 'dc1_');
+            if (!position || typeof position.after !== 'string')
+                return null;
+            after = position.after;
+        }
+        const records = (await this.capabilities.listSnapshots())
+            .filter(record => !record.deleted && this.now() < record.job.expiresAtEpochMs &&
+            canonicalJson(record.job.scope) === canonicalJson(actor))
+            .sort((a, b) => a.job.id < b.job.id ? -1 : a.job.id > b.job.id ? 1 : 0);
+        if (after !== null && !records.some(record => record.job.id === after))
+            return null;
+        const candidates = records.filter(record => after === null || record.job.id > after);
+        const page = candidates.slice(0, limit);
+        return { handles: page.map(record => this.seal(record)),
+            next: candidates.length > page.length ? this.encrypt('dc1_', { scope: actor, after: page.at(-1).job.id }) : null };
+    }
+    seal(snapshot) {
+        const { scope, id, fingerprint, createdAtEpochMs, expiresAtEpochMs } = snapshot.job;
+        return this.encrypt('dj1_', { scope, id, fingerprint, createdAtEpochMs, expiresAtEpochMs });
+    }
+    encrypt(prefix, value) {
+        const nonce = randomBytes(12);
+        const cipher = createCipheriv('aes-256-gcm', this.key, nonce);
+        const ciphertext = Buffer.concat([cipher.update(canonicalJson(value), 'utf8'), cipher.final()]);
+        return `${prefix}${Buffer.concat([nonce, cipher.getAuthTag(), ciphertext]).toString('base64url')}`;
+    }
+    open(actor, handle, prefix) {
+        if (typeof handle !== 'string' || !handle.startsWith(prefix) || !/^[A-Za-z0-9_-]{40,2048}$/.test(handle.slice(4)))
+            return null;
+        try {
+            const bytes = Buffer.from(handle.slice(4), 'base64url');
+            const decipher = createDecipheriv('aes-256-gcm', this.key, bytes.subarray(0, 12));
+            decipher.setAuthTag(bytes.subarray(12, 28));
+            const decoded = JSON.parse(Buffer.concat([decipher.update(bytes.subarray(28)), decipher.final()]).toString('utf8'));
+            const expected = Buffer.from(canonicalJson(actor));
+            const actual = Buffer.from(canonicalJson(decoded.scope));
+            if (expected.length !== actual.length || !timingSafeEqual(expected, actual))
+                return null;
+            return decoded;
+        }
+        catch {
+            return null;
+        }
+    }
+    unseal(actor, handle) {
+        const decoded = this.open(actor, handle, 'dj1_');
+        if (!decoded || typeof decoded.id !== 'string' || typeof decoded.fingerprint !== 'string' ||
+            !Number.isSafeInteger(decoded.createdAtEpochMs) || !Number.isSafeInteger(decoded.expiresAtEpochMs))
+            return null;
+        return decoded;
+    }
+}
+//# sourceMappingURL=job-gateway.js.map

package/dist/src/decision/job-http.js

@@ -0,0 +1,194 @@
+import { JobConflictError } from './job-store.js';
+/** Explicitly mounted host HTTP boundary. All identity comes from authenticate(), never JSON. */
+export function createDecisionJobHttpHandler(options) {
+    if (options.enabled !== true || !options.service || ![options.authenticate, options.authorizeQueue, options.deleteJob,
+        options.authorizeResult].every(fn => typeof fn === 'function') ||
+        !Number.isSafeInteger(options.maxBodyBytes) || options.maxBodyBytes < 1 || options.maxBodyBytes > 1_048_576)
+        throw new JobConflictError('Authenticated job HTTP host required');
+    return async (req, res) => {
+        const send = (code, value) => {
+            res.writeHead(code, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store',
+                'x-content-type-options': 'nosniff' });
+            res.end(JSON.stringify(value));
+        };
+        try {
+            let actor = null;
+            try {
+                actor = await options.authenticate(req);
+            }
+            catch { /* authentication fails closed */ }
+            if (!actor || ![actor.tenantId, actor.projectId, actor.workspaceId, actor.principalId]
+                .every(value => typeof value === 'string' && /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(value))) {
+                send(401, { error: 'unauthorized' });
+                return;
+            }
+            const url = new URL(req.url ?? '/', 'http://localhost');
+            const parts = url.pathname.split('/').filter(Boolean);
+            if (parts[0] !== 'decision' || parts[1] !== 'jobs' || parts.length > 6) {
+                send(404, { error: 'unavailable' });
+                return;
+            }
+            const method = req.method;
+            if (req.headers['content-length'] && (!/^[0-9]+$/.test(req.headers['content-length']) ||
+                Number(req.headers['content-length']) > options.maxBodyBytes)) {
+                send(413, { error: 'request too large' });
+                return;
+            }
+            if (parts.length === 2 && method === 'POST') {
+                const body = await readBody(req, options.maxBodyBytes);
+                if (!body || typeof body !== 'object' || Array.isArray(body) || Object.hasOwn(body, 'scope')) {
+                    send(400, { error: 'invalid job' });
+                    return;
+                }
+                const job = { ...body, scope: actor };
+                const { handle, snapshot } = await options.service.gateway.submit(actor, job);
+                send(202, { handle, state: snapshot.job.state, summary: snapshot.job.summary });
+                return;
+            }
+            if (parts.length === 2 && method === 'GET') {
+                const limit = numberParam(url.searchParams.get('limit'), 100);
+                if (limit === null) {
+                    send(400, { error: 'invalid page' });
+                    return;
+                }
+                const page = await options.service.gateway.list(actor, url.searchParams.get('cursor') ?? undefined, limit);
+                send(page ? 200 : 404, page ?? { error: 'unavailable' });
+                return;
+            }
+            const handle = parts[2];
+            if (!handle || !/^dj1_[A-Za-z0-9_-]{40,2048}$/.test(handle)) {
+                send(404, { error: 'unavailable' });
+                return;
+            }
+            if (parts.length === 3 && method === 'GET') {
+                const snapshot = await options.service.gateway.poll(actor, handle);
+                send(snapshot ? 200 : 404, snapshot ? summary(snapshot) : { error: 'unavailable' });
+                return;
+            }
+            if (parts.length === 3 && method === 'DELETE') {
+                const snapshot = await options.service.gateway.poll(actor, handle);
+                if (!snapshot || !await options.deleteJob(actor, snapshot)) {
+                    send(404, { error: 'unavailable' });
+                    return;
+                }
+                send(204, {});
+                return;
+            }
+            if (parts.length === 4 && parts[3] === 'export' && method === 'GET') {
+                const snapshot = await options.service.gateway.export(actor, handle);
+                send(snapshot ? 200 : 404, snapshot ? summary(snapshot) : { error: 'unavailable' });
+                return;
+            }
+            if (parts.length === 4 && parts[3] === 'items' && method === 'GET') {
+                const offset = numberParam(url.searchParams.get('offset'), 0);
+                const limit = numberParam(url.searchParams.get('limit'), 100);
+                if (offset === null || limit === null) {
+                    send(400, { error: 'invalid page' });
+                    return;
+                }
+                const items = await options.service.gateway.items(actor, handle, offset, limit);
+                send(items ? 200 : 404, items ? { items: items.map(item => ({ id: item.id, state: item.state,
+                        ...(item.resultDigest ? { resultDigest: item.resultDigest } : {}),
+                        ...(item.errorCode ? { errorCode: item.errorCode } : {}) })) } : { error: 'unavailable' });
+                return;
+            }
+            if (parts.length === 4 && parts[3] === 'cancel' && method === 'POST') {
+                const snapshot = await options.service.gateway.poll(actor, handle);
+                if (!snapshot) {
+                    send(404, { error: 'unavailable' });
+                    return;
+                }
+                const canceled = await options.service.worker.cancel(actor, snapshot.job.id);
+                send(canceled ? 200 : 404, canceled ? summary(canceled) : { error: 'unavailable' });
+                return;
+            }
+            if (parts.length === 4 && parts[3] === 'queue' && method === 'POST') {
+                const snapshot = await options.service.gateway.poll(actor, handle);
+                if (!snapshot || snapshot.job.state !== 'validating') {
+                    send(404, { error: 'unavailable' });
+                    return;
+                }
+                // Missing input is not guessed or sourced from model-visible state.
+                for (const item of snapshot.job.items)
+                    if (await options.service.payloads.get(actor, snapshot.job.id, item.id, 'input') === null)
+                        throw new JobConflictError('Job input unavailable');
+                if (!await options.authorizeQueue(actor, snapshot)) {
+                    send(404, { error: 'unavailable' });
+                    return;
+                }
+                const next = structuredClone(snapshot.job);
+                next.state = 'queued';
+                const queued = await options.service.runtime.advance(actor, snapshot.job.id, snapshot, next);
+                send(202, summary(queued));
+                return;
+            }
+            if (parts.length === 5 && parts[3] === 'retry' && method === 'POST' && /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(parts[4])) {
+                const next = await options.service.gateway.retry(actor, handle, parts[4]);
+                send(next ? 200 : 404, next ? summary(next) : { error: 'unavailable' });
+                return;
+            }
+            if (parts.length === 6 && parts[3] === 'items' && parts[5] === 'input' && method === 'PUT' &&
+                /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(parts[4])) {
+                const snapshot = await options.service.gateway.poll(actor, handle);
+                if (!snapshot) {
+                    send(404, { error: 'unavailable' });
+                    return;
+                }
+                await options.service.payloads.put(actor, snapshot.job.id, parts[4], 'input', await readBody(req, options.maxBodyBytes));
+                send(204, {});
+                return;
+            }
+            if (parts.length === 6 && parts[3] === 'items' && parts[5] === 'result' && method === 'GET' &&
+                /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(parts[4])) {
+                const snapshot = await options.service.gateway.poll(actor, handle);
+                if (!snapshot || !await options.authorizeResult(actor, snapshot, parts[4])) {
+                    send(404, { error: 'unavailable' });
+                    return;
+                }
+                const value = await options.service.payloads.get(actor, snapshot.job.id, parts[4], 'result');
+                send(value === null ? 404 : 200, value === null ? { error: 'unavailable' } : { result: value });
+                return;
+            }
+            send(404, { error: 'unavailable' });
+        }
+        catch (error) {
+            if (res.headersSent)
+                return;
+            const message = error instanceof Error ? error.message : '';
+            send(message.includes('throttled') || message.includes('ledger full') ? 429 :
+                message === 'Job unavailable' || message === 'Validated job result unavailable' ? 404 :
+                    message.includes('body limit') ? 413 : error instanceof JobConflictError ? 409 : 500, { error: message.includes('throttled') ? 'rate limited' : 'unavailable' });
+        }
+    };
+}
+function summary(snapshot) {
+    const job = snapshot.job;
+    return { state: job.state, summary: job.summary, createdAtEpochMs: job.createdAtEpochMs,
+        expiresAtEpochMs: job.expiresAtEpochMs, revision: snapshot.revision };
+}
+function numberParam(value, fallback) {
+    if (value === null)
+        return fallback;
+    if (!/^(0|[1-9][0-9]*)$/.test(value))
+        return null;
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) ? parsed : null;
+}
+async function readBody(req, max) {
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of req) {
+        const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        bytes += data.length;
+        if (bytes > max)
+            throw new JobConflictError('Request body limit exceeded');
+        chunks.push(data);
+    }
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    catch {
+        throw new JobConflictError('Invalid job JSON');
+    }
+}
+//# sourceMappingURL=job-http.js.map

package/dist/src/decision/job-payload-store.js

@@ -0,0 +1,258 @@
+import { createCipheriv, createDecipheriv, createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
+import { access, link, lstat, mkdir, open, readFile, readdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { acquireDirectoryLock } from '../artifacts/prebuilt-build-lock.js';
+import { canonicalJson } from '../security/artifact-trust.js';
+import { artifactDigest } from './validate.js';
+import { JobConflictError } from './job-store.js';
+const hash = (value) => createHash('sha256').update(canonicalJson(value)).digest('hex');
+/** Host-only protected JSON value store, bound to job pins and an independent D10 authority. */
+export class FileJobPayloadStore {
+    directory;
+    journal;
+    externallyDeleted;
+    limits;
+    now;
+    metadataBytes;
+    key;
+    constructor(directory, key, journal, externallyDeleted, limits, now = Date.now, metadataBytes) {
+        this.directory = directory;
+        this.journal = journal;
+        this.externallyDeleted = externallyDeleted;
+        this.limits = limits;
+        this.now = now;
+        this.metadataBytes = metadataBytes;
+        if (!Buffer.isBuffer(key) || key.length !== 32 || typeof externallyDeleted !== 'function' ||
+            ![limits.itemBytes, limits.principalBytes, limits.projectBytes].every(n => Number.isSafeInteger(n) && n > 0) ||
+            limits.itemBytes > 1_048_576 || limits.itemBytes > limits.principalBytes || limits.principalBytes > limits.projectBytes)
+            throw new JobConflictError('Invalid protected job payload configuration');
+        this.key = Buffer.from(key);
+    }
+    async put(scope, jobId, itemId, kind, value) {
+        const digest = artifactDigest(value);
+        const plain = Buffer.from(canonicalJson(value), 'utf8');
+        if (plain.length > this.limits.itemBytes)
+            throw new JobConflictError('Protected job payload limit exceeded');
+        await this.ensurePrivate();
+        const release = await acquireDirectoryLock(join(this.directory, '.quota-lock'), { timeoutMs: 5000, pollMs: 20 });
+        try {
+            const job = await this.authorize(scope, jobId, itemId, kind, digest);
+            const file = this.file(scope, jobId, itemId, kind);
+            const existing = await this.readEnvelope(file);
+            if (existing) {
+                if (existing.digest !== digest || existing.expiresAtEpochMs !== job.expiresAtEpochMs ||
+                    canonicalJson(await this.get(scope, jobId, itemId, kind)) !== plain.toString('utf8'))
+                    throw new JobConflictError('Conflicting protected job payload');
+                return;
+            }
+            const project = hash([scope.tenantId, scope.projectId]);
+            const principal = hash([scope.tenantId, scope.projectId, scope.workspaceId, scope.principalId]);
+            let totalProject = plain.length;
+            let totalPrincipal = plain.length;
+            for (const name of await readdir(this.directory)) {
+                if (!/^[a-f0-9]{64}\.[a-f0-9]{64}\.json$/.test(name))
+                    continue;
+                const envelope = await this.readEnvelope(join(this.directory, name));
+                if (!envelope)
+                    throw new JobConflictError('Protected job payload unavailable');
+                if (envelope.project === project)
+                    totalProject += envelope.bytes;
+                if (envelope.principal === principal)
+                    totalPrincipal += envelope.bytes;
+            }
+            if (this.metadataBytes) {
+                totalProject += await this.metadataBytes(scope, 'project');
+                totalPrincipal += await this.metadataBytes(scope, 'principal');
+            }
+            if (!Number.isSafeInteger(totalProject) || !Number.isSafeInteger(totalPrincipal) ||
+                totalProject > this.limits.projectBytes || totalPrincipal > this.limits.principalBytes)
+                throw new JobConflictError('Protected job payload limit exceeded');
+            const nonce = randomBytes(12);
+            const cipher = createCipheriv('aes-256-gcm', this.key, nonce);
+            cipher.setAAD(this.aad(scope, jobId, itemId, kind, digest, job.expiresAtEpochMs));
+            const encrypted = Buffer.concat([cipher.update(plain), cipher.final()]);
+            const fields = { version: 'decision-job-payload/v1', digest, expiresAtEpochMs: job.expiresAtEpochMs,
+                bytes: plain.length, project, principal, nonce: nonce.toString('base64url'),
+                tag: cipher.getAuthTag().toString('base64url'), ciphertext: encrypted.toString('base64url') };
+            const envelope = { ...fields, mac: this.mac(fields) };
+            const temporary = join(this.directory, `.${hash([scope, jobId])}.payload-${randomUUID()}.tmp`);
+            const handle = await open(temporary, 'wx', 0o600);
+            try {
+                await handle.writeFile(`${canonicalJson(envelope)}\n`);
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+            try {
+                await link(temporary, file);
+                const directory = await open(this.directory, 'r');
+                try {
+                    await directory.sync();
+                }
+                finally {
+                    await directory.close();
+                }
+            }
+            catch (error) {
+                if (error.code === 'EEXIST')
+                    throw new JobConflictError('Conflicting protected job payload');
+                throw error;
+            }
+            finally {
+                await rm(temporary, { force: true });
+            }
+        }
+        finally {
+            await release();
+        }
+    }
+    async get(scope, jobId, itemId, kind) {
+        await this.ensurePrivate();
+        const job = await this.authorize(scope, jobId, itemId, kind);
+        const envelope = await this.readEnvelope(this.file(scope, jobId, itemId, kind));
+        if (!envelope)
+            return null;
+        if (envelope.expiresAtEpochMs !== job.expiresAtEpochMs)
+            throw new JobConflictError('Protected job payload expiry mismatch');
+        try {
+            const decipher = createDecipheriv('aes-256-gcm', this.key, Buffer.from(envelope.nonce, 'base64url'));
+            decipher.setAuthTag(Buffer.from(envelope.tag, 'base64url'));
+            decipher.setAAD(this.aad(scope, jobId, itemId, kind, envelope.digest, envelope.expiresAtEpochMs));
+            const value = JSON.parse(Buffer.concat([decipher.update(Buffer.from(envelope.ciphertext, 'base64url')), decipher.final()]).toString('utf8'));
+            if (envelope.project !== hash([scope.tenantId, scope.projectId]) ||
+                envelope.principal !== hash([scope.tenantId, scope.projectId, scope.workspaceId, scope.principalId]) ||
+                artifactDigest(value) !== envelope.digest || Buffer.byteLength(canonicalJson(value)) !== envelope.bytes ||
+                (kind === 'input' ? job.items.find(item => item.id === itemId)?.subjectDigest :
+                    job.items.find(item => item.id === itemId)?.resultDigest) !== envelope.digest)
+                throw new JobConflictError('Protected job payload integrity mismatch');
+            return value;
+        }
+        catch {
+            throw new JobConflictError('Protected job payload integrity mismatch');
+        }
+    }
+    /** Aggregate plaintext sizes for the quota journal, called while holding its shared lock. */
+    async usage(scope, tier) {
+        await this.ensurePrivate();
+        const expected = tier === 'project' ? hash([scope.tenantId, scope.projectId]) :
+            hash([scope.tenantId, scope.projectId, scope.workspaceId, scope.principalId]);
+        let total = 0;
+        for (const name of await readdir(this.directory)) {
+            if (!/^[a-f0-9]{64}\.[a-f0-9]{64}\.json$/.test(name))
+                continue;
+            const envelope = await this.readEnvelope(join(this.directory, name));
+            if (!envelope)
+                throw new JobConflictError('Protected job payload unavailable');
+            if ((tier === 'project' ? envelope.project : envelope.principal) === expected)
+                total += envelope.bytes;
+        }
+        if (!Number.isSafeInteger(total))
+            throw new JobConflictError('Protected job payload usage invalid');
+        return total;
+    }
+    /** Host-only D10 eraser; call after independently persisted tombstone and authorized job deletion. */
+    async purgeDeleted(scope, jobId) {
+        await this.ensurePrivate();
+        const current = await this.journal.read(scope, jobId);
+        if (!await this.externallyDeleted(scope, jobId) || current && (!current.deleted || current.legalHold))
+            throw new JobConflictError('Independent job tombstone required');
+        const release = await acquireDirectoryLock(join(this.directory, '.quota-lock'), { timeoutMs: 5000, pollMs: 20 });
+        try {
+            const marker = this.marker(scope, jobId);
+            try {
+                const handle = await open(marker, 'wx', 0o600);
+                try {
+                    await handle.sync();
+                }
+                finally {
+                    await handle.close();
+                }
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST')
+                    throw error;
+            }
+            const prefix = `${hash([scope, jobId])}.`;
+            for (const name of await readdir(this.directory))
+                if ((name.startsWith(prefix) && /^[a-f0-9]{64}\.json$/.test(name.slice(prefix.length))) ||
+                    (name.startsWith(`.${prefix}payload-`) && /^payload-[0-9a-f-]{36}\.tmp$/.test(name.slice(prefix.length + 1))))
+                    await rm(join(this.directory, name));
+            const directory = await open(this.directory, 'r');
+            try {
+                await directory.sync();
+            }
+            finally {
+                await directory.close();
+            }
+        }
+        finally {
+            await release();
+        }
+    }
+    async authorize(scope, jobId, itemId, kind, digest) {
+        if (!['input', 'result'].includes(kind) || typeof itemId !== 'string' || !itemId)
+            throw new JobConflictError('Job unavailable');
+        if (await this.externallyDeleted(scope, jobId))
+            throw new JobConflictError('Job unavailable');
+        try {
+            await access(this.marker(scope, jobId));
+            throw new JobConflictError('Job unavailable');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        const record = await this.journal.read(scope, jobId);
+        if (!record || record.deleted || this.now() >= record.job.expiresAtEpochMs)
+            throw new JobConflictError('Job unavailable');
+        const item = record.job.items.find(entry => entry.id === itemId);
+        if (!item || kind === 'result' && (!['succeeded', 'review', 'abstained'].includes(item.state) ||
+            !item.attempts.some(attempt => attempt.outcome === 'succeeded' && attempt.receiptDigest)))
+            throw new JobConflictError('Job unavailable');
+        if (digest && (kind === 'input' ? item.subjectDigest : item.resultDigest) !== digest)
+            throw new JobConflictError('Protected job payload pin mismatch');
+        return record.job;
+    }
+    file(scope, id, itemId, kind) {
+        return join(this.directory, `${hash([scope, id])}.${hash([itemId, kind])}.json`);
+    }
+    marker(scope, id) { return join(this.directory, `${hash([scope, id])}.deleted`); }
+    aad(scope, id, item, kind, digest, expiry) {
+        return Buffer.from(canonicalJson({ scope, id, item, kind, digest, expiry }));
+    }
+    async ensurePrivate() {
+        await mkdir(this.directory, { recursive: true, mode: 0o700 });
+        const info = await lstat(this.directory);
+        if (!info.isDirectory() || info.isSymbolicLink() || (info.mode & 0o077) !== 0)
+            throw new JobConflictError('Protected job payload root must be private');
+    }
+    mac(fields) {
+        return createHmac('sha256', this.key).update('decision-job-payload-header/v1:').update(canonicalJson(fields)).digest('hex');
+    }
+    async readEnvelope(file) {
+        let info;
+        try {
+            info = await lstat(file);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return null;
+            throw error;
+        }
+        if (!info.isFile() || (info.mode & 0o077) !== 0 || info.size > this.limits.itemBytes * 2 + 1024)
+            throw new JobConflictError('Protected job payload file must be private');
+        const envelope = JSON.parse(await readFile(file, 'utf8'));
+        if (envelope?.version !== 'decision-job-payload/v1' || !/^sha256:[a-f0-9]{64}$/.test(envelope.digest) ||
+            !Number.isSafeInteger(envelope.expiresAtEpochMs) || !Number.isSafeInteger(envelope.bytes) || envelope.bytes < 0 ||
+            !/^[a-f0-9]{64}$/.test(envelope.project) || !/^[a-f0-9]{64}$/.test(envelope.principal) ||
+            ![envelope.nonce, envelope.tag, envelope.ciphertext].every(part => typeof part === 'string' && /^[A-Za-z0-9_-]+$/.test(part)) ||
+            typeof envelope.mac !== 'string' || !/^[a-f0-9]{64}$/.test(envelope.mac))
+            throw new JobConflictError('Protected job payload invalid');
+        const { mac, ...fields } = envelope;
+        if (!timingSafeEqual(Buffer.from(mac, 'hex'), Buffer.from(this.mac(fields), 'hex')))
+            throw new JobConflictError('Protected job payload integrity mismatch');
+        return envelope;
+    }
+}
+//# sourceMappingURL=job-payload-store.js.map

package/dist/src/decision/job-poll-limiter.js

@@ -0,0 +1,92 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { open, readFile, rename, rm, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { acquireDirectoryLock } from '../artifacts/prebuilt-build-lock.js';
+import { canonicalJson } from '../security/artifact-trust.js';
+import { FileJobStore, JobConflictError } from './job-store.js';
+/** Host-only bounded polling gate. Shared local filesystem, not a distributed service. */
+export class FileJobPollLimiter {
+    directory;
+    windowMs;
+    perPrincipal;
+    perProject;
+    maxLanes;
+    now;
+    constructor(directory, windowMs, perPrincipal, perProject, maxLanes, now = Date.now) {
+        this.directory = directory;
+        this.windowMs = windowMs;
+        this.perPrincipal = perPrincipal;
+        this.perProject = perProject;
+        this.maxLanes = maxLanes;
+        this.now = now;
+        if (![windowMs, perPrincipal, perProject, maxLanes].every(value => Number.isSafeInteger(value) && value > 0) || maxLanes > 4096)
+            throw new JobConflictError('Invalid polling limit');
+    }
+    async check(actor) {
+        // Reuse the journal's root privacy gate. Never create a world-readable counter store.
+        await new FileJobStore(this.directory).read(actor, '_poll_root_');
+        const release = await acquireDirectoryLock(join(this.directory, '.quota-lock'), { timeoutMs: 5000, pollMs: 20 });
+        try {
+            const path = join(this.directory, '.poll-ledger.json');
+            let previous = {};
+            try {
+                if ((await stat(path)).size > this.maxLanes * 128 + 2)
+                    throw new JobConflictError('Polling ledger full');
+                previous = JSON.parse(await readFile(path, 'utf8'));
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+            const now = this.now();
+            if (!Number.isSafeInteger(now) || now < 0 || !previous || typeof previous !== 'object' || Array.isArray(previous))
+                throw new JobConflictError('Invalid polling ledger');
+            const ledger = Object.create(null);
+            for (const [key, value] of Object.entries(previous)) {
+                if (!/^[a-f0-9]{64}$/.test(key) || !value || !Number.isSafeInteger(value.window) || !Number.isSafeInteger(value.count) ||
+                    value.count < 0 || value.window > now)
+                    throw new JobConflictError('Invalid polling ledger');
+                if (now - value.window < this.windowMs)
+                    ledger[key] = value;
+            }
+            const keys = [canonicalJson([actor.tenantId, actor.projectId]),
+                canonicalJson([actor.tenantId, actor.projectId, actor.workspaceId, actor.principalId])]
+                .map(text => createHash('sha256').update(text).digest('hex'));
+            for (const [index, key] of keys.entries()) {
+                const count = ledger[key]?.count ?? 0;
+                if (count >= [this.perProject, this.perPrincipal][index])
+                    throw new JobConflictError('Job request throttled');
+            }
+            if (new Set([...Object.keys(ledger), ...keys]).size > this.maxLanes)
+                throw new JobConflictError('Polling ledger full');
+            for (const key of keys)
+                ledger[key] = { window: ledger[key]?.window ?? now, count: (ledger[key]?.count ?? 0) + 1 };
+            const temporary = join(this.directory, `.poll-${randomUUID()}.tmp`);
+            try {
+                const file = await open(temporary, 'wx', 0o600);
+                try {
+                    await file.writeFile(`${canonicalJson(ledger)}\n`);
+                    await file.sync();
+                }
+                finally {
+                    await file.close();
+                }
+                await rename(temporary, path);
+                const directory = await open(this.directory, 'r');
+                try {
+                    await directory.sync();
+                }
+                finally {
+                    await directory.close();
+                }
+            }
+            finally {
+                await rm(temporary, { force: true });
+            }
+        }
+        finally {
+            await release();
+        }
+    }
+}
+//# sourceMappingURL=job-poll-limiter.js.map