@hachej/boring-agent 0.1.111 → 0.2.1

package/dist/projection-window.js

@@ -0,0 +1,93 @@
+import { CONVERSATION_PROJECTION_LIMITS as limits, projectionBytes } from './projection-format.js';
+function* textBlocks(message) {
+    if (typeof message.content === 'string')
+        yield { blockIndex: 0, text: message.content };
+    else
+        for (const [blockIndex, block] of message.content.entries())
+            if (block.type === 'text')
+                yield { blockIndex, text: block.text };
+}
+function scalarPrefix(text, length) {
+    const last = text.charCodeAt(length - 1), next = text.charCodeAt(length);
+    return text.slice(0, last >= 0xd800 && last <= 0xdbff && next >= 0xdc00 && next <= 0xdfff ? length - 1 : length);
+}
+function clippedText(text, bytes) {
+    let low = 0, high = Math.min(text.length, bytes);
+    const candidate = scalarPrefix(text, high);
+    if (projectionBytes(candidate) - 2 <= bytes)
+        return candidate;
+    while (low < high) {
+        const middle = Math.ceil((low + high) / 2);
+        if (projectionBytes(scalarPrefix(text, middle)) - 2 <= bytes)
+            low = middle;
+        else
+            high = middle - 1;
+    }
+    return scalarPrefix(text, low);
+}
+function projectRow(entry, message, messageIndex) {
+    if (message.role !== 'user' && message.role !== 'assistant')
+        return;
+    const content = [];
+    const base = { entryId: entry.id, conversationId: entry.conversationId,
+        ...(entry.byTaskId === undefined ? {} : { byTaskId: entry.byTaskId }), messageIndex, role: message.role };
+    let bytes = projectionBytes({ ...base, content, clipped: false }), clipped = false;
+    for (const block of textBlocks(message)) {
+        const overhead = projectionBytes({ blockIndex: block.blockIndex, text: '' }) + (content.length ? 1 : 0);
+        const available = limits.maxMessageBytes - bytes - overhead;
+        if (available < 0) {
+            clipped = true;
+            break;
+        }
+        const text = clippedText(block.text, available);
+        content.push({ blockIndex: block.blockIndex, text });
+        bytes += overhead + projectionBytes(text) - 2;
+        if (text.length !== block.text.length) {
+            clipped = true;
+            break;
+        }
+    }
+    return content.length ? { ...base, content, clipped } : undefined;
+}
+function* newestEntries(entries) {
+    let head = entries[0]?.head === undefined ? undefined : entries[0];
+    const first = head ? 1 : 0;
+    for (let position = entries.length - 1; position >= first; position--) {
+        const entry = entries[position];
+        if (!entry)
+            continue;
+        if (head && head.id > entry.id) {
+            yield { entry: head, position: 0 };
+            head = undefined;
+        }
+        yield { entry, position };
+    }
+    if (head)
+        yield { entry: head, position: 0 };
+}
+export function projectConversationWindow(entries, identity, allowEntry) {
+    const selected = [];
+    let bytes = 2, truncated = false;
+    outer: for (const { entry, position } of newestEntries(entries)) {
+        if (allowEntry(identity, entry) !== true)
+            continue;
+        const model = entry.model ?? [];
+        for (let j = model.length - 1; j >= 0; j--) {
+            const message = model[j];
+            if (!message)
+                continue;
+            const row = projectRow(entry, message, j);
+            if (!row)
+                continue;
+            const size = projectionBytes(row) + (selected.length ? 1 : 0);
+            if (selected.length === limits.maxMessages || bytes + size > limits.maxWindowBytes) {
+                truncated = true;
+                break outer;
+            }
+            selected.push({ row, position });
+            bytes += size;
+        }
+    }
+    selected.sort((a, b) => a.position - b.position || a.row.messageIndex - b.row.messageIndex);
+    return { messages: selected.map(item => item.row), window: { truncated } };
+}

package/dist/projection.d.ts

@@ -0,0 +1,22 @@
+import type { Context } from '@earendil-works/chord';
+import type { Conversation, EntryRecord } from '@earendil-works/pi-durable';
+import type { ProjectionIdentity } from './projection-format.js';
+export { CONVERSATION_PROJECTION_LIMITS, createConversationTextReceiver } from './projection-format.js';
+export type { ProjectionIdentity, ConversationTextProjection, ConversationTextSnapshot, ConversationTextDelta, ConversationTextRow, ConversationTextKey, ConversationTextReceiver } from './projection-format.js';
+export interface ConversationProjectionAccess {
+    readonly runtimeId: string;
+    readonly scopeId: string;
+    readonly principalId: string;
+    readonly conversation: Conversation;
+    readonly context: Context;
+    /** The host must abort on revocation or identity change, including while idle. */
+    readonly revoked: AbortSignal;
+    readonly authorize: (identity: ProjectionIdentity, phase: 'open' | 'initial' | 'delivery') => Promise<boolean>;
+    readonly allowEntry: (identity: ProjectionIdentity, entry: EntryRecord) => boolean;
+}
+export interface ConversationProjectionOptions {
+    /** Authenticate and resolve the native conversation in trusted host code. */
+    readonly authenticate: (request: Request) => Promise<ConversationProjectionAccess | null>;
+}
+export declare function createConversationProjectionHandler(options: ConversationProjectionOptions): (request: Request) => Promise<Response>;
+//# sourceMappingURL=projection.d.ts.map

package/dist/projection.js

@@ -0,0 +1,153 @@
+import { CONVERSATION_PROJECTION_LIMITS as limits, projectionEncoder, projectionIdentity, projectionKey } from './projection-format.js';
+import { projectConversationWindow } from './projection-window.js';
+import { NATIVE_VERSION } from './native-version.js';
+export { CONVERSATION_PROJECTION_LIMITS, createConversationTextReceiver } from './projection-format.js';
+function failure(status, reason) {
+    return Response.json({ schema: 'boring.conversation-text', version: 2, reason }, {
+        status, headers: { 'cache-control': 'no-store', 'x-content-type-options': 'nosniff' },
+    });
+}
+// request-guard: exempt (GET only; this handler never reads a request body)
+export function createConversationProjectionHandler(options) {
+    return async (request) => {
+        if (request.method !== 'GET')
+            return failure(405, 'method-not-supported');
+        if (new URL(request.url).searchParams.get('version') !== '2')
+            return failure(426, 'unsupported-version');
+        let access;
+        try {
+            access = await options.authenticate(request);
+        }
+        catch {
+            return failure(503, 'authentication-unavailable');
+        }
+        if (!access)
+            return failure(401, 'authentication-required');
+        const { conversation, context, revoked } = access;
+        const authorize = access.authorize.bind(access), allowEntry = access.allowEntry.bind(access);
+        const identity = Object.freeze({ runtimeId: access.runtimeId, scopeId: access.scopeId, principalId: access.principalId, conversationId: conversation.id });
+        if (!projectionIdentity(identity))
+            return failure(503, 'identity-unavailable');
+        const signal = AbortSignal.any([request.signal, revoked]);
+        try {
+            if (signal.aborted || await authorize(identity, 'open') !== true || signal.aborted)
+                return failure(403, 'not-authorized');
+        }
+        catch {
+            return failure(503, 'authorization-unavailable');
+        }
+        let watch;
+        try {
+            watch = await conversation.watch(context);
+        }
+        catch {
+            return failure(503, 'source-unavailable');
+        }
+        // A watch that already ended may reject on stop; teardown must never turn a refusal into a rejection.
+        const stopWatch = () => Promise.resolve().then(() => watch.stop()).then(() => undefined, () => undefined);
+        try {
+            if (signal.aborted || await authorize(identity, 'initial') !== true || signal.aborted) {
+                await stopWatch();
+                return failure(403, 'not-authorized');
+            }
+        }
+        catch {
+            await stopWatch();
+            return failure(503, 'authorization-unavailable');
+        }
+        const connectionId = globalThis.crypto.randomUUID();
+        let previous;
+        let revision = 0, delivered = -1, frame = 0;
+        let wake;
+        let stopped = false;
+        let controller;
+        let stopping;
+        function stop() {
+            if (!stopped) {
+                stopped = true;
+                signal.removeEventListener('abort', onAbort);
+                wake?.();
+                try {
+                    controller.close();
+                }
+                catch { /* already closed or cancelled */ }
+            }
+            return stopping ??= stopWatch();
+        }
+        function onAbort() { void stop(); }
+        const body = new ReadableStream({
+            start(value) {
+                controller = value;
+                signal.addEventListener('abort', onAbort, { once: true });
+                if (signal.aborted) {
+                    void stop();
+                    return;
+                }
+                watch.start(async () => { revision++; wake?.(); });
+                void watch.closed.then(() => stop());
+            },
+            async pull() {
+                while (!stopped) {
+                    while (!stopped && delivered === revision)
+                        await new Promise(resolve => { wake = resolve; });
+                    wake = undefined;
+                    if (stopped)
+                        return;
+                    try {
+                        if (await authorize(identity, 'delivery') !== true || signal.aborted || stopped) {
+                            await stop();
+                            return;
+                        }
+                        const visible = projectConversationWindow(watch.value.entries, identity, allowEntry);
+                        delivered = revision;
+                        if (signal.aborted || stopped) {
+                            await stop();
+                            return;
+                        }
+                        if (previous && JSON.stringify(previous.messages) === JSON.stringify(visible.messages)
+                            && previous.window.truncated === visible.window.truncated)
+                            continue;
+                        const snapshot = {
+                            schema: 'boring.conversation-text', version: 2, nativeVersion: NATIVE_VERSION, source: identity,
+                            connection: { id: connectionId, frame, observedAt: new Date().toISOString() }, kind: 'snapshot', ...visible,
+                        };
+                        const snapshotBytes = projectionEncoder.encode(JSON.stringify(snapshot) + '\n');
+                        let bytes = snapshotBytes;
+                        if (previous) {
+                            const before = new Map(previous.messages.map(message => [projectionKey(message), JSON.stringify(message)]));
+                            const { messages, ...common } = snapshot;
+                            const projection = { ...common, kind: 'delta', baseFrame: previous.connection.frame,
+                                upsert: messages.filter(message => before.get(projectionKey(message)) !== JSON.stringify(message)),
+                                order: messages.map(({ conversationId, entryId, messageIndex }) => ({ conversationId, entryId, messageIndex })),
+                            };
+                            const deltaBytes = projectionEncoder.encode(JSON.stringify(projection) + '\n');
+                            if (deltaBytes.byteLength < snapshotBytes.byteLength)
+                                bytes = deltaBytes;
+                        }
+                        if (bytes.byteLength > limits.maxFrameBytes || signal.aborted || stopped) {
+                            await stop();
+                            return;
+                        }
+                        previous = snapshot;
+                        frame++;
+                        controller.enqueue(bytes);
+                        return;
+                    }
+                    catch {
+                        await stop();
+                        return;
+                    }
+                }
+            },
+            async cancel() {
+                stopped = true;
+                signal.removeEventListener('abort', onAbort);
+                wake?.();
+                await (stopping ??= stopWatch());
+            },
+        }, { highWaterMark: 0 });
+        return new Response(body, { headers: {
+                'content-type': 'application/x-ndjson; charset=utf-8', 'cache-control': 'no-store', 'x-content-type-options': 'nosniff',
+            } });
+    };
+}

package/dist/question-response.d.ts

@@ -0,0 +1,20 @@
+import type { Context } from '@earendil-works/chord';
+import type { Conversation } from '@earendil-works/pi-durable';
+import type { RuntimeQuestionRef } from './contracts.js';
+import type { createQuestions } from './questions.js';
+export interface QuestionResponseAccess {
+    readonly conversation: Conversation;
+    readonly questions: Pick<ReturnType<typeof createQuestions>, 'resolve'>;
+    readonly ref: RuntimeQuestionRef;
+    /** Carries the authenticated human to the original question's commit policy. */
+    readonly context: Context;
+    readonly revoked: AbortSignal;
+}
+export interface QuestionResponseOptions {
+    /** Includes origin/CSRF checks for cookie authentication. Never install as an agent approval tool. */
+    readonly authenticateHuman: (request: Request) => Promise<QuestionResponseAccess | null>;
+    readonly maxBodyBytes?: number;
+}
+/** Resolves original native clarification state. No separate inbox or approval authority. */
+export declare function createQuestionResponseHandler(options: QuestionResponseOptions): (request: Request) => Promise<Response>;
+//# sourceMappingURL=question-response.d.ts.map

package/dist/question-response.js

@@ -0,0 +1,75 @@
+import { RequestGuardError, hasJsonContentType, readJsonBody } from '@hachej/boring-files/request-guard';
+const targetFields = ['runtimeId', 'conversationId', 'taskId', 'questionId', 'scopeId', 'subjectDigest', 'policyVersion', 'expiresAt'];
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function reply(status, kind, decision) {
+    return Response.json({ schema: 'boring.question-response', version: 1, kind, ...(decision ? { decision } : {}) }, {
+        status, headers: { 'cache-control': 'no-store', 'x-content-type-options': 'nosniff' },
+    });
+}
+/** Resolves original native clarification state. No separate inbox or approval authority. */
+export function createQuestionResponseHandler(options) {
+    const maxBodyBytes = options.maxBodyBytes ?? 16_384;
+    if (!Number.isSafeInteger(maxBodyBytes) || maxBodyBytes < 1)
+        throw new TypeError('A positive body byte limit is required');
+    return async (request) => {
+        if (request.method !== 'POST')
+            return reply(405, 'method-not-supported');
+        if (!hasJsonContentType(request.headers))
+            return reply(415, 'json-required');
+        let access;
+        try {
+            access = await options.authenticateHuman(request);
+        }
+        catch {
+            return reply(503, 'authentication-unavailable');
+        }
+        if (!access)
+            return reply(401, 'authentication-required');
+        const { conversation, questions, context, revoked } = access;
+        const ref = { ...access.ref };
+        if (ref.conversationId !== conversation.id)
+            return reply(403, 'binding-mismatch');
+        const signal = AbortSignal.any([request.signal, revoked]);
+        if (signal.aborted)
+            return reply(403, 'not-authorized');
+        let input;
+        try {
+            input = await readJsonBody(request, maxBodyBytes, signal);
+        }
+        catch (error) {
+            if (signal.aborted)
+                return reply(403, 'not-authorized');
+            return error instanceof RequestGuardError && error.status === 413 ? reply(413, 'body-too-large') : reply(400, 'invalid-request');
+        }
+        if (signal.aborted)
+            return reply(403, 'not-authorized');
+        if (!record(input) || Object.keys(input).sort().join() !== 'answer,resolutionId,schema,target,version'
+            || input['schema'] !== 'boring.question-response' || input['version'] !== 1
+            || typeof input['resolutionId'] !== 'string' || !input['resolutionId'] || typeof input['answer'] !== 'string')
+            return reply(400, 'invalid-request');
+        const target = input['target'];
+        if (!record(target) || Object.keys(target).length !== targetFields.length || targetFields.some(key => target[key] !== ref[key]))
+            return reply(409, 'target-mismatch');
+        const resolution = { resolutionId: input['resolutionId'], answer: input['answer'] };
+        const interrupted = new Error('Question response authorization changed');
+        let decision;
+        try {
+            decision = await conversation.commit(async (tx) => {
+                if (signal.aborted)
+                    throw interrupted;
+                const result = await questions.resolve(tx, ref, resolution, context);
+                if (signal.aborted)
+                    throw interrupted;
+                return result;
+            }, context);
+        }
+        catch {
+            return reply(503, 'resolution-not-confirmed');
+        }
+        if (signal.aborted)
+            return reply(503, 'resolution-not-confirmed');
+        return reply(decision.kind === 'resolved' ? 200 : decision.kind === 'denied' ? 403 : 409, 'decision', decision);
+    };
+}

package/dist/questions.d.ts

@@ -0,0 +1,74 @@
+import type { TaskOptions, Tx } from '@earendil-works/pi-durable';
+import type { Context } from '@earendil-works/chord';
+import type { RuntimeQuestionRef } from './contracts.js';
+type QuestionRef = {
+    [Key in keyof RuntimeQuestionRef]: RuntimeQuestionRef[Key];
+};
+export type ChoiceQuestion = Omit<QuestionRef, 'runtimeId' | 'taskId'> & {
+    readonly prompt: string;
+    readonly choices: readonly string[];
+};
+type Resolution = {
+    resolutionId: string;
+    answer: string;
+    responderId: string;
+    consumedBy: string | null;
+};
+export type QuestionState = {
+    kind: 'pending';
+} | {
+    kind: 'resolved';
+    resolution: Resolution;
+} | {
+    kind: 'expired' | 'cancelled';
+};
+type QuestionRecord = {
+    ref: QuestionRef;
+    prompt: string;
+    choices: string[];
+    state: QuestionState;
+};
+type QuestionDocument = {
+    question: QuestionRecord | null;
+};
+export type QuestionOutcome = {
+    kind: 'resolved';
+    answer: string;
+    resolutionId: string;
+} | {
+    kind: 'expired' | 'cancelled' | 'unavailable';
+};
+export type QuestionDecision = QuestionOutcome | {
+    kind: 'denied' | 'conflict' | 'pending';
+};
+export interface QuestionOptions {
+    readonly runtimeId: string;
+    /** Synchronous host authentication/policy at the native commit boundary. IDs are not grants. */
+    readonly authorize: (ref: RuntimeQuestionRef, action: 'admit' | 'resolve' | 'consume', context: Context) => {
+        readonly principalId: string;
+        readonly scopeId: string;
+    } | undefined;
+    /** Recheck the bound subject digest and policy version, including at consumption. */
+    readonly isCurrent: (ref: RuntimeQuestionRef, context: Context) => boolean;
+    readonly now?: () => number;
+}
+/** Single-choice clarification. The native result is information, never approval or a publication grant. */
+export declare function createQuestions(options: QuestionOptions): {
+    task: import("@earendil-works/pi-durable").Task<{
+        key: string;
+        runtimeId: string;
+    }, {
+        phase: "wait";
+    }, QuestionOutcome, object>;
+    documents: import("@earendil-works/pi-durable").SessionDocFamilyToken<QuestionDocument, null>;
+    extension: import("@earendil-works/pi-durable").Extension<import("@earendil-works/pi-durable").ToolRegistration>;
+    admit: (tx: Tx, input: ChoiceQuestion, ownership: TaskOptions["ownership"], context: Context) => Promise<QuestionRef>;
+    resolve: (tx: Tx, reference: RuntimeQuestionRef, input: {
+        readonly resolutionId: string;
+        readonly answer: string;
+    }, context: Context) => Promise<QuestionDecision>;
+    consume: (tx: Tx, reference: RuntimeQuestionRef, resolutionId: string, consumerId: string, context: Context) => Promise<QuestionDecision>;
+    documentKey: (ref: Pick<RuntimeQuestionRef, "scopeId" | "questionId">) => string;
+};
+export {};
+//# sourceMappingURL=questions.d.ts.map

package/dist/questions.js

@@ -0,0 +1,199 @@
+import { ReadAfterWrite, defineDocFamily, defineExtension, defineTask } from '@earendil-works/pi-durable';
+function sameRef(left, right) {
+    return left.runtimeId === right.runtimeId && left.conversationId === right.conversationId
+        && left.taskId === right.taskId && left.questionId === right.questionId && left.scopeId === right.scopeId
+        && left.subjectDigest === right.subjectDigest && left.policyVersion === right.policyVersion && left.expiresAt === right.expiresAt;
+}
+/** Single-choice clarification. The native result is information, never approval or a publication grant. */
+export function createQuestions(options) {
+    const runtimeId = options.runtimeId;
+    if (!runtimeId)
+        throw new TypeError('A stable runtime identity is required');
+    const now = options.now ?? Date.now;
+    const documents = defineDocFamily({
+        kind: 'boring.questions.record', version: 1, scope: 'session', family: true,
+        initial: () => ({ question: null }),
+    });
+    const key = (ref) => JSON.stringify([runtimeId, ref.scopeId, ref.questionId]);
+    const allowed = (ref, action, context) => {
+        if (ref.runtimeId !== runtimeId)
+            return undefined;
+        const actor = options.authorize({ ...ref }, action, context);
+        return typeof actor?.principalId === 'string' && actor.principalId.length > 0 && actor.scopeId === ref.scopeId ? actor : undefined;
+    };
+    const current = (ref, context) => options.isCurrent({ ...ref }, context) === true;
+    const expired = (ref) => now() >= Date.parse(ref.expiresAt);
+    const task = defineTask({
+        name: 'boring.questions.wait', version: 1, initial: () => ({ phase: 'wait' }),
+        phases: {
+            wait: async (running, runtime, context) => {
+                if (running.input.runtimeId !== runtimeId) {
+                    await runtime.commit(() => ({ status: 'terminal', outcome: { status: 'completed', result: { kind: 'unavailable' } } }), context);
+                    return;
+                }
+                const watch = await runtime.watchDoc(documents, running.input.key, context);
+                if (!watch?.value?.question || watch.value.question.ref.taskId !== runtime.taskId)
+                    throw new Error('Native question record is missing or misbound');
+                try {
+                    if (watch.value.question.state.kind === 'pending') {
+                        const changed = new Promise(resolve => {
+                            watch.start(async (value) => { if (value?.question?.state.kind !== 'pending')
+                                resolve(); });
+                        });
+                        await Promise.race([
+                            changed,
+                            runtime.sleep(Date.parse(watch.value.question.ref.expiresAt), context),
+                            watch.closed.then(() => { throw new Error('Question observation closed'); }),
+                        ]);
+                    }
+                    await runtime.commit(async (tx) => {
+                        const doc = await tx.doc(documents, running.input.key, null);
+                        const question = doc.question;
+                        if (!question)
+                            throw new Error('Question retired while waiting');
+                        if (question.state.kind === 'pending')
+                            question.state = { kind: 'expired' };
+                        const result = question.state.kind === 'resolved'
+                            ? { kind: 'resolved', answer: question.state.resolution.answer, resolutionId: question.state.resolution.resolutionId }
+                            : { kind: question.state.kind };
+                        return { status: 'terminal', outcome: { status: 'completed', result } };
+                    }, context);
+                }
+                finally {
+                    await watch.stop();
+                }
+            },
+        },
+        abort: async (running, runtime, context) => {
+            await runtime.commit(async (tx) => {
+                const doc = await tx.doc(documents, running.input.key, null);
+                if (doc.question?.state.kind === 'pending')
+                    doc.question.state = { kind: 'cancelled' };
+                return { status: 'terminal', outcome: { status: 'aborted' } };
+            }, context);
+        },
+    });
+    async function admit(tx, input, ownership, context) {
+        const captured = structuredClone(input);
+        for (const value of [captured.questionId, captured.scopeId, captured.subjectDigest, captured.policyVersion, captured.prompt]) {
+            if (typeof value !== 'string' || !value)
+                throw new TypeError('Question identity, subject, policy and prompt are required');
+        }
+        if (!Number.isFinite(Date.parse(captured.expiresAt)) || Date.parse(captured.expiresAt) <= now())
+            throw new TypeError('Question expiry must be in the future');
+        if (!Array.isArray(captured.choices) || !captured.choices.length || captured.choices.some(choice => typeof choice !== 'string' || !choice)
+            || new Set(captured.choices).size !== captured.choices.length)
+            throw new TypeError('Distinct nonempty choices are required');
+        const doc = await tx.doc(documents, key(captured), null);
+        if (doc.question) {
+            const existing = doc.question;
+            if (!allowed(existing.ref, 'admit', context) || !current(existing.ref, context))
+                throw new Error('Question admission denied');
+            if (existing.ref.conversationId !== captured.conversationId || existing.ref.subjectDigest !== captured.subjectDigest
+                || existing.ref.policyVersion !== captured.policyVersion || existing.ref.expiresAt !== captured.expiresAt
+                || existing.prompt !== captured.prompt || JSON.stringify(existing.choices) !== JSON.stringify(captured.choices))
+                throw new Error('Question identity already binds different input');
+            return { ...existing.ref };
+        }
+        const taskId = await tx.createTask(task, { key: key(captured), runtimeId }, { conversationId: captured.conversationId, ownership });
+        const ref = { runtimeId, taskId, conversationId: captured.conversationId, questionId: captured.questionId,
+            scopeId: captured.scopeId, subjectDigest: captured.subjectDigest, policyVersion: captured.policyVersion, expiresAt: captured.expiresAt };
+        if (!allowed(ref, 'admit', context) || !current(ref, context))
+            throw new Error('Question admission denied');
+        doc.question = { ref, prompt: captured.prompt, choices: [...captured.choices], state: { kind: 'pending' } };
+        return structuredClone(ref);
+    }
+    /** A prior table write prevents the native task check; refuse rather than bypass cancellation. */
+    async function taskState(tx, ref) {
+        let record;
+        try {
+            record = await tx.task(ref.taskId);
+        }
+        catch (error) {
+            if (error instanceof ReadAfterWrite)
+                return 'unknown';
+            throw error;
+        }
+        const known = record?.kind === task.definition.name && record.conversationId === ref.conversationId
+            && record.input !== null && typeof record.input === 'object' && !Array.isArray(record.input)
+            && record.input['runtimeId'] === runtimeId && record.input['key'] === key(ref);
+        return !known || !record ? 'unknown' : record.abortRequested ? 'aborted' : 'known';
+    }
+    /** Resolve before native table writes in this Tx; an unreadable task returns conflict. */
+    async function resolve(tx, reference, input, context) {
+        const ref = structuredClone(reference);
+        const { resolutionId, answer } = input;
+        if (!allowed(ref, 'resolve', context))
+            return { kind: 'denied' };
+        const bound = await taskState(tx, ref);
+        if (bound === 'unknown')
+            return { kind: 'conflict' };
+        const doc = await tx.doc(documents, key(ref), null);
+        const question = doc.question;
+        if (!question)
+            throw new Error('Native question evidence is missing');
+        if (!sameRef(question.ref, ref))
+            return { kind: 'conflict' };
+        if (bound === 'aborted') {
+            if (question.state.kind === 'pending')
+                question.state = { kind: 'cancelled' };
+            return { kind: 'cancelled' };
+        }
+        const actor = allowed(ref, 'resolve', context);
+        if (!actor)
+            return { kind: 'denied' };
+        if (!current(ref, context))
+            return { kind: 'conflict' };
+        if (typeof resolutionId !== 'string' || !resolutionId || typeof answer !== 'string' || !question.choices.includes(answer))
+            return { kind: 'conflict' };
+        if (question.state.kind === 'resolved') {
+            const prior = question.state.resolution;
+            return prior.resolutionId === resolutionId && prior.answer === answer && prior.responderId === actor.principalId
+                ? { kind: 'resolved', answer, resolutionId } : { kind: 'conflict' };
+        }
+        if (question.state.kind !== 'pending')
+            return { kind: question.state.kind };
+        if (expired(ref)) {
+            question.state = { kind: 'expired' };
+            return { kind: 'expired' };
+        }
+        question.state = { kind: 'resolved', resolution: { resolutionId, answer, responderId: actor.principalId, consumedBy: null } };
+        return { kind: 'resolved', answer, resolutionId };
+    }
+    /** Consume before native host table writes in this Tx. Recheck external publication policy separately. */
+    async function consume(tx, reference, resolutionId, consumerId, context) {
+        const ref = structuredClone(reference);
+        if (!allowed(ref, 'consume', context))
+            return { kind: 'denied' };
+        const bound = await taskState(tx, ref);
+        if (bound === 'unknown')
+            return { kind: 'conflict' };
+        const doc = await tx.doc(documents, key(ref), null);
+        const question = doc.question;
+        if (!question)
+            throw new Error('Native question evidence is missing');
+        if (!allowed(ref, 'consume', context))
+            return { kind: 'denied' };
+        if (!sameRef(question.ref, ref) || !current(ref, context))
+            return { kind: 'conflict' };
+        if (bound === 'aborted') {
+            if (question.state.kind === 'pending')
+                question.state = { kind: 'cancelled' };
+            return { kind: 'cancelled' };
+        }
+        if (expired(ref)) {
+            if (question.state.kind === 'pending')
+                question.state = { kind: 'expired' };
+            return { kind: question.state.kind === 'cancelled' ? 'cancelled' : 'expired' };
+        }
+        if (question.state.kind !== 'resolved')
+            return { kind: question.state.kind };
+        const resolution = question.state.resolution;
+        if (typeof consumerId !== 'string' || !consumerId || resolution.resolutionId !== resolutionId || (resolution.consumedBy !== null && resolution.consumedBy !== consumerId))
+            return { kind: 'conflict' };
+        resolution.consumedBy = consumerId;
+        return { kind: 'resolved', answer: resolution.answer, resolutionId };
+    }
+    return { task, documents, extension: defineExtension({ name: 'boring.questions', tasks: [task] }), admit, resolve, consume,
+        documentKey: (ref) => key(ref) };
+}