@zhin.js/agent 1.1.13 → 1.1.14

package/lib/workroom/projection-outbox.js

@@ -0,0 +1,1312 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { DurableFileStore } from './durable-file-store.js';
+import { compareCanonicalWorkroomText, deepFreezeWorkroomValue as deepFreeze, digestCanonicalWorkroomValue as digest, } from './canonical-value.js';
+import { createWorkroomGovernedDispatchReason } from '../plugin-runtime/workroom-governed-dispatch-reasons.js';
+export class WorkroomProjectionRevisionConflictError extends Error {
+    expectedRevision;
+    actualRevision;
+    constructor(expectedRevision, actualRevision) {
+        super(`Workroom Projection revision conflict: expected ${expectedRevision}, actual ${actualRevision}`);
+        this.expectedRevision = expectedRevision;
+        this.actualRevision = actualRevision;
+        this.name = 'WorkroomProjectionRevisionConflictError';
+    }
+}
+export class MemoryWorkroomProjectionRepository {
+    #state = emptyProjectionState();
+    async read() {
+        return this.#state;
+    }
+    async bind(expectedRevision, binding) {
+        this.#assertRevision(expectedRevision);
+        this.#state = applyBinding(this.#state, binding);
+        return this.#state;
+    }
+    async capture(expectedRevision, input) {
+        if (this.#state.revision !== expectedRevision) {
+            throw new WorkroomProjectionRevisionConflictError(expectedRevision, this.#state.revision);
+        }
+        this.#state = applyCapture(this.#state, input);
+        return this.#state;
+    }
+    async claimNext(expectedRevision, workerId, now, leaseMs) {
+        this.#assertRevision(expectedRevision);
+        const claimed = applyClaim(this.#state, workerId, now, leaseMs);
+        if (!claimed)
+            return undefined;
+        this.#state = claimed.state;
+        return claimed.item;
+    }
+    async settle(expectedRevision, itemId, workerId, fence, result, settledAt) {
+        this.#assertRevision(expectedRevision);
+        this.#state = applySettlement(this.#state, itemId, workerId, fence, result, settledAt);
+        return this.#state;
+    }
+    #assertRevision(expectedRevision) {
+        if (this.#state.revision !== expectedRevision) {
+            throw new WorkroomProjectionRevisionConflictError(expectedRevision, this.#state.revision);
+        }
+    }
+}
+/** Crash-durable, cross-process CAS snapshots for one Projection binding. */
+export class FileWorkroomProjectionRepository {
+    #store;
+    constructor(directory) {
+        this.#store = new DurableFileStore(directory);
+    }
+    async read() {
+        let names;
+        try {
+            names = (await readdir(this.#store.directory))
+                .filter(name => /^projection\.[0-9]{16}\.json$/u.test(name))
+                .sort();
+        }
+        catch (error) {
+            if (hasCode(error, 'ENOENT'))
+                return emptyProjectionState();
+            throw error;
+        }
+        if (names.length === 0)
+            return emptyProjectionState();
+        for (let index = 0; index < names.length; index += 1) {
+            const expected = projectionSnapshotName(index + 1);
+            if (names[index] !== expected) {
+                throw new Error(`Workroom Projection snapshot gap before revision ${index + 1}`);
+            }
+        }
+        const parsed = JSON.parse(await readFile(join(this.#store.directory, names.at(-1)), 'utf8'));
+        return parseProjectionState(parsed, names.length);
+    }
+    async capture(expectedRevision, input) {
+        const current = await this.read();
+        if (current.revision !== expectedRevision) {
+            throw new WorkroomProjectionRevisionConflictError(expectedRevision, current.revision);
+        }
+        const next = applyCapture(current, input);
+        return await this.#publish(expectedRevision, next);
+    }
+    async bind(expectedRevision, binding) {
+        const current = await this.read();
+        if (current.revision !== expectedRevision) {
+            throw new WorkroomProjectionRevisionConflictError(expectedRevision, current.revision);
+        }
+        const next = applyBinding(current, binding);
+        if (next === current)
+            return current;
+        return await this.#publish(expectedRevision, next);
+    }
+    async claimNext(expectedRevision, workerId, now, leaseMs) {
+        const current = await this.read();
+        if (current.revision !== expectedRevision) {
+            throw new WorkroomProjectionRevisionConflictError(expectedRevision, current.revision);
+        }
+        const claimed = applyClaim(current, workerId, now, leaseMs);
+        if (!claimed)
+            return undefined;
+        const persisted = await this.#publish(expectedRevision, claimed.state);
+        return persisted.items[claimed.item.id];
+    }
+    async settle(expectedRevision, itemId, workerId, fence, result, settledAt) {
+        const current = await this.read();
+        if (current.revision !== expectedRevision) {
+            throw new WorkroomProjectionRevisionConflictError(expectedRevision, current.revision);
+        }
+        return await this.#publish(expectedRevision, applySettlement(current, itemId, workerId, fence, result, settledAt));
+    }
+    async #publish(expectedRevision, next) {
+        await this.#store.ensureDurableLeaf('Workroom Projection repository');
+        const target = join(this.#store.directory, projectionSnapshotName(next.revision));
+        const published = await this.#store.publishCreateOnly({
+            target,
+            content: JSON.stringify({ state: next, digest: digest(next) }),
+            createdValue: next,
+            onConflict: async () => {
+                const winner = parseProjectionState(JSON.parse(await readFile(target, 'utf8')), next.revision);
+                if (digest(winner) === digest(next))
+                    return await this.read();
+                const latest = await this.read();
+                throw new WorkroomProjectionRevisionConflictError(expectedRevision, latest.revision);
+            },
+        });
+        return published.value;
+    }
+}
+/** At-least-once delivery worker; Projection receipts never mutate Kernel facts. */
+export class WorkroomProjectionDeliveryWorker {
+    #repository;
+    #outbound;
+    #workerId;
+    #leaseMs;
+    #governance;
+    #authority;
+    #now;
+    constructor(options) {
+        requireText(options.workerId, 'workerId');
+        requirePositiveInteger(options.leaseMs, 'leaseMs');
+        this.#repository = options.repository;
+        this.#outbound = options.outbound;
+        this.#workerId = options.workerId;
+        this.#leaseMs = options.leaseMs;
+        this.#governance = options.governance;
+        this.#authority = options.authority;
+        this.#now = options.now ?? Date.now;
+    }
+    async runOnce(now, signal) {
+        requireFiniteNumber(now, 'delivery now');
+        signal.throwIfAborted();
+        const claimed = await this.#claim(now);
+        if (!claimed)
+            return Object.freeze({ status: 'idle' });
+        let result;
+        try {
+            const authorized = this.#authority ? await this.#authority.authorize(claimed) : true;
+            if (!authorized) {
+                result = Object.freeze({
+                    status: 'failed', code: 'catalog_binding_stale', retryable: false,
+                });
+            }
+            else if (!this.#governance) {
+                result = Object.freeze({
+                    status: 'failed', code: 'project_authority_unavailable', retryable: false,
+                });
+            }
+            else {
+                const governed = await this.#governance.revalidate(claimed.disclosure, signal);
+                result = governed.status === 'blocked'
+                    ? (() => {
+                        const reason = createWorkroomGovernedDispatchReason(governed.reason);
+                        return Object.freeze({
+                            status: 'failed', code: reason.code, retryable: reason.retryable,
+                        });
+                    })()
+                    : normalizeDeliveryResult(await this.#outbound.send(claimed, governed.body, signal));
+            }
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw signal.reason ?? error;
+            result = Object.freeze({ status: 'failed', code: 'transport_error', retryable: true });
+        }
+        // Once send returned a receipt the external effect already happened;
+        // cancellation must not discard it and cause a blind duplicate retry.
+        const settledAt = this.#now();
+        requireFiniteNumber(settledAt, 'delivery completion time');
+        await this.#settle(claimed, result, settledAt);
+        return result;
+    }
+    async #claim(now) {
+        for (let conflict = 0; conflict < 8; conflict += 1) {
+            const state = await this.#repository.read();
+            try {
+                return await this.#repository.claimNext(state.revision, this.#workerId, now, this.#leaseMs);
+            }
+            catch (error) {
+                if (!(error instanceof WorkroomProjectionRevisionConflictError))
+                    throw error;
+            }
+        }
+        throw new Error('Workroom Projection delivery claim CAS retries exhausted');
+    }
+    async #settle(item, result, settledAt) {
+        for (let conflict = 0; conflict < 8; conflict += 1) {
+            const state = await this.#repository.read();
+            try {
+                await this.#repository.settle(state.revision, item.id, this.#workerId, item.delivery.fence, result, settledAt);
+                return;
+            }
+            catch (error) {
+                if (!(error instanceof WorkroomProjectionRevisionConflictError))
+                    throw error;
+            }
+        }
+        throw new Error('Workroom Projection delivery settlement CAS retries exhausted');
+    }
+}
+/** Durable cursor tracer from authoritative Kernel events to an IM outbox. */
+export class WorkroomProjectionTracer {
+    #journal;
+    #repository;
+    #governance;
+    constructor(options) {
+        this.#journal = options.journal;
+        this.#repository = options.repository;
+        this.#governance = options.governance;
+    }
+    async capture(bindingValue, runId, signal = new AbortController().signal) {
+        const binding = freezeAndValidateBinding(bindingValue);
+        const events = await this.#journal.read(runId);
+        if (events.length === 0)
+            throw new Error(`Workroom Projection Run ${runId} not found`);
+        if (events[0]?.payload.projectId !== binding.projectId) {
+            throw new Error('Workroom Projection binding targets another Project');
+        }
+        for (let conflict = 0; conflict < 8; conflict += 1) {
+            const current = await this.#repository.read();
+            const cursorId = projectionBindingCursorKey(runId, binding);
+            const storedCursor = current.cursors[cursorId];
+            const legacyCursor = storedCursor === undefined
+                ? exactLegacyBindingCursor(current, runId, binding)
+                : undefined;
+            const cursor = storedCursor ?? legacyCursor ?? -1;
+            const expectedCursor = storedCursor ?? -1;
+            const sourceSequence = events.at(-1)?.sequence ?? -1;
+            if (cursor > sourceSequence) {
+                throw new Error('Workroom Projection legacy cursor exceeds the authoritative Journal');
+            }
+            if (cursor >= sourceSequence) {
+                return legacyCursor === undefined
+                    ? current
+                    : await this.#repository.capture(current.revision, {
+                        runId: cursorId,
+                        expectedCursor,
+                        cursor,
+                        items: [],
+                    });
+            }
+            const rawProjection = projectEvents(events, cursor, binding);
+            const projected = deepFreeze({
+                cursor: rawProjection.cursor,
+                items: rawProjection.items.map(item => deepFreeze({ ...item, cursorId })),
+            });
+            if (projected.cursor <= cursor)
+                return current;
+            if (!this.#governance && projected.items.length > 0) {
+                throw new Error('Workroom Projection governance authority is unavailable');
+            }
+            const governedItems = await Promise.all(projected.items.map(async (draft) => {
+                const governed = await this.#governance.prepareProjection({
+                    operationId: `projection:${binding.projectId}:${runId}:${draft.sourceSequence}`,
+                    projectId: binding.projectId,
+                    sinkRuleId: 'projection:workroom',
+                    body: draft.content,
+                    sourceEventIds: draft.sourceEventIds,
+                }, signal);
+                if (governed.status === 'blocked') {
+                    throw new Error(`Workroom Projection disclosure blocked: ${governed.reason}`);
+                }
+                return materializeProjectionItem(draft, governed);
+            }));
+            try {
+                return await this.#repository.capture(current.revision, {
+                    runId: cursorId,
+                    expectedCursor,
+                    cursor: projected.cursor,
+                    items: governedItems,
+                });
+            }
+            catch (error) {
+                if (!(error instanceof WorkroomProjectionRevisionConflictError))
+                    throw error;
+            }
+        }
+        throw new Error('Workroom Projection capture CAS retries exhausted');
+    }
+    /** Capture content-free P12 Hold review facts into the same governed IM outbox. */
+    async captureLifecycleOverdue(bindingValue, snapshotValue, signal = new AbortController().signal) {
+        const binding = freezeAndValidateBinding(bindingValue);
+        const snapshot = validateLifecycleOverdueSnapshot(snapshotValue);
+        if (snapshot.projectId !== binding.projectId) {
+            throw new Error('Workroom Lifecycle Projection binding targets another Project');
+        }
+        const byObject = new Map();
+        for (const item of snapshot.overdue) {
+            byObject.set(item.objectId, [...(byObject.get(item.objectId) ?? []), item]);
+        }
+        let state = await this.#repository.read();
+        for (const objectId of [...byObject.keys()].sort(compareCanonicalWorkroomText)) {
+            signal.throwIfAborted();
+            state = await this.#captureLifecycleObject(binding, objectId, byObject.get(objectId), signal);
+        }
+        return state;
+    }
+    /** Publishes one Project-scoped card from a content-free Portfolio projection. */
+    async capturePortfolioSponsor(bindingValue, projectionValue, signal = new AbortController().signal) {
+        signal.throwIfAborted();
+        const binding = freezeAndValidateBinding(bindingValue);
+        if (projectionAudience(binding) !== 'sponsor_room') {
+            throw new Error('Portfolio Sponsor projection requires a Sponsor Room binding');
+        }
+        const { digest: suppliedDigest, ...projectionBody } = projectionValue;
+        if (suppliedDigest !== digest(projectionBody)) {
+            throw new Error('Portfolio Sponsor projection digest mismatch');
+        }
+        const project = projectionValue.projects[binding.projectId];
+        if (!project || project.projectId !== binding.projectId) {
+            throw new Error('Portfolio Sponsor projection does not contain the binding Project');
+        }
+        const runId = workroomPortfolioProjectionCursorKey(projectionValue.portfolioId, binding.projectId);
+        const cursorId = projectionBindingCursorKey(runId, binding);
+        for (let conflict = 0; conflict < 8; conflict += 1) {
+            const current = await this.#repository.read();
+            const storedCursor = current.cursors[cursorId];
+            const legacyCursor = storedCursor === undefined
+                ? exactLegacyBindingCursor(current, runId, binding)
+                : undefined;
+            const cursor = storedCursor ?? legacyCursor ?? -1;
+            const expectedCursor = storedCursor ?? -1;
+            if (cursor > projectionValue.sourceSequence) {
+                throw new Error('Portfolio Sponsor legacy cursor exceeds the authoritative projection');
+            }
+            if (cursor >= projectionValue.sourceSequence) {
+                return legacyCursor === undefined
+                    ? current
+                    : await this.#repository.capture(current.revision, {
+                        runId: cursorId,
+                        expectedCursor,
+                        cursor,
+                        items: [],
+                    });
+            }
+            const draft = deepFreeze({
+                ...portfolioSponsorDraft(binding, projectionValue, runId),
+                cursorId,
+            });
+            if (!this.#governance) {
+                throw new Error('Workroom Projection governance authority is unavailable');
+            }
+            const governed = await this.#governance.prepareProjection({
+                operationId: `projection:${draft.sourceEventIds[0]}`,
+                projectId: binding.projectId,
+                sinkRuleId: 'projection:sponsor-room',
+                body: draft.content,
+                sourceEventIds: draft.sourceEventIds,
+            }, signal);
+            if (governed.status === 'blocked') {
+                throw new Error(`Workroom Projection disclosure blocked: ${governed.reason}`);
+            }
+            try {
+                return await this.#repository.capture(current.revision, {
+                    runId: cursorId,
+                    expectedCursor,
+                    cursor: projectionValue.sourceSequence,
+                    items: [materializeProjectionItem(draft, governed)],
+                });
+            }
+            catch (error) {
+                if (!(error instanceof WorkroomProjectionRevisionConflictError) || conflict === 7)
+                    throw error;
+            }
+        }
+        throw new Error('Portfolio Sponsor projection capture retries exhausted');
+    }
+    async #captureLifecycleObject(binding, objectId, values, signal) {
+        const stateSequences = new Set(values.map(value => value.stateSequence));
+        const stateDigests = new Set(values.map(value => value.stateDigest));
+        if (stateSequences.size !== 1 || stateDigests.size !== 1) {
+            throw new Error('Workroom Lifecycle Projection object state binding is inconsistent');
+        }
+        const runId = workroomLifecycleProjectionCursorKey(binding.projectId, objectId);
+        const cursorId = projectionBindingCursorKey(runId, binding);
+        for (let conflict = 0; conflict < 8; conflict += 1) {
+            const current = await this.#repository.read();
+            const cursor = current.cursors[cursorId] ?? -1;
+            const existingSources = new Set(Object.values(current.items)
+                .filter(item => item.projectId === binding.projectId
+                && item.bindingRevision === binding.bindingRevision)
+                .flatMap(item => item.sourceEventIds));
+            const pending = values
+                .filter(value => !existingSources.has(lifecycleOverdueSourceEventId(binding.projectId, value)))
+                .sort((left, right) => compareCanonicalWorkroomText(lifecycleOverdueSourceEventId(binding.projectId, left), lifecycleOverdueSourceEventId(binding.projectId, right)));
+            if (pending.length === 0)
+                return current;
+            const drafts = pending.map((value, index) => deepFreeze({
+                ...lifecycleOverdueDraft(binding, runId, value, cursor + index + 1),
+                cursorId,
+            }));
+            if (!this.#governance && drafts.length > 0) {
+                throw new Error('Workroom Projection governance authority is unavailable');
+            }
+            const governedItems = await Promise.all(drafts.map(async (draft) => {
+                const governed = await this.#governance.prepareProjection({
+                    operationId: `projection:${draft.sourceEventIds[0]}`,
+                    projectId: binding.projectId,
+                    sinkRuleId: 'projection:sponsor-room',
+                    body: draft.content,
+                    sourceEventIds: draft.sourceEventIds,
+                }, signal);
+                if (governed.status === 'blocked') {
+                    throw new Error(`Workroom Projection disclosure blocked: ${governed.reason}`);
+                }
+                return materializeProjectionItem(draft, governed);
+            }));
+            try {
+                return await this.#repository.capture(current.revision, {
+                    runId: cursorId,
+                    expectedCursor: cursor,
+                    cursor: cursor + drafts.length,
+                    items: governedItems,
+                });
+            }
+            catch (error) {
+                if (!(error instanceof WorkroomProjectionRevisionConflictError))
+                    throw error;
+            }
+        }
+        throw new Error('Workroom Lifecycle Projection capture CAS retries exhausted');
+    }
+}
+function emptyProjectionState() {
+    return deepFreeze({ revision: 0, bindings: {}, cursors: {}, items: {}, messageIndex: {} });
+}
+function projectionSnapshotName(revision) {
+    return `projection.${String(revision).padStart(16, '0')}.json`;
+}
+function parseProjectionState(value, expectedRevision) {
+    const snapshot = requireRecord(value, 'snapshot');
+    assertExactRecordKeys(snapshot, ['state', 'digest'], 'snapshot');
+    const state = requireRecord(snapshot.state, 'snapshot.state');
+    if (typeof snapshot.digest !== 'string' || digest(state) !== snapshot.digest) {
+        throw new Error('Workroom Projection snapshot digest mismatch');
+    }
+    assertExactRecordKeys(state, ['revision', 'bindings', 'cursors', 'items', 'messageIndex'], 'snapshot.state');
+    if (state.revision !== expectedRevision) {
+        throw new Error('Workroom Projection snapshot revision mismatch');
+    }
+    const bindings = requireRecord(state.bindings, 'snapshot.bindings');
+    const cursors = requireRecord(state.cursors, 'snapshot.cursors');
+    const items = requireRecord(state.items, 'snapshot.items');
+    const messageIndex = requireRecord(state.messageIndex, 'snapshot.messageIndex');
+    for (const [bindingKey, bindingValue] of Object.entries(bindings)) {
+        const binding = freezeAndValidateBinding(bindingValue);
+        if (workroomProjectionBindingKey(binding.projectId, projectionAudience(binding)) !== bindingKey) {
+            throw new Error('Workroom Projection binding key mismatch');
+        }
+    }
+    for (const [runId, cursor] of Object.entries(cursors)) {
+        requireText(runId, 'snapshot cursor runId');
+        requireSequence(cursor, 'snapshot cursor', 0);
+    }
+    for (const [itemId, itemValue] of Object.entries(items)) {
+        const item = itemValue;
+        if (item?.id !== itemId)
+            throw new Error('Workroom Projection snapshot item key mismatch');
+        const cursorId = item.cursorId ?? item.runId;
+        assertProjectionItem(item, cursorId, -1, Number.MAX_SAFE_INTEGER);
+        assertDeliveryState(item.delivery, item.conversation);
+        const cursor = cursors[cursorId];
+        if (typeof cursor !== 'number' || cursor < item.sourceSequence) {
+            throw new Error('Workroom Projection snapshot item exceeds durable cursor');
+        }
+    }
+    for (const [key, entryValue] of Object.entries(messageIndex)) {
+        const entry = entryValue;
+        const item = items[entry?.projectionId];
+        if (!item
+            || workroomProjectionMessageKey(entry.message) !== key
+            || item.delivery.status !== 'sent'
+            || !item.delivery.message
+            || workroomProjectionMessageKey(item.delivery.message) !== key
+            || entry.bindingRevision !== item.bindingRevision
+            || digest(entry.sourceEventIds) !== digest(item.sourceEventIds)
+            || digest(entry.target) !== digest(item.target)
+            || digest(entry.speaker) !== digest(item.speaker)) {
+            throw new Error('Workroom Projection Message Index entry is invalid');
+        }
+    }
+    return deepFreeze({
+        revision: expectedRevision,
+        bindings: { ...bindings },
+        cursors: { ...cursors },
+        items: { ...items },
+        messageIndex: { ...messageIndex },
+    });
+}
+function applyBinding(state, value) {
+    const binding = freezeAndValidateBinding(value);
+    const key = workroomProjectionBindingKey(binding.projectId, projectionAudience(binding));
+    const current = state.bindings[key];
+    if (current && digest(normalizeLegacyBindingAudience(current))
+        === digest(normalizeLegacyBindingAudience(binding)))
+        return state;
+    if (current && binding.bindingRevision <= current.bindingRevision) {
+        throw new Error('Workroom Projection binding revision must advance');
+    }
+    return deepFreeze({
+        ...state,
+        revision: state.revision + 1,
+        bindings: { ...state.bindings, [key]: binding },
+    });
+}
+function normalizeLegacyBindingAudience(binding) {
+    return binding.audience === undefined
+        ? deepFreeze({ ...binding, audience: 'workroom' })
+        : binding;
+}
+function applyClaim(state, workerId, now, leaseMs) {
+    requireText(workerId, 'claim.workerId');
+    requireFiniteNumber(now, 'claim.now');
+    requirePositiveInteger(leaseMs, 'claim.leaseMs');
+    const current = Object.values(state.items)
+        .filter(item => item.delivery.status === 'pending'
+        || (item.delivery.status === 'failed' && item.delivery.retryable === true
+            && (item.delivery.nextAttemptAt === undefined || item.delivery.nextAttemptAt <= now))
+        || (item.delivery.status === 'leased'
+            && Number(item.delivery.leaseExpiresAt) <= now))
+        .sort((left, right) => left.sourceSequence - right.sourceSequence || compareCanonicalWorkroomText(left.id, right.id))[0];
+    if (!current)
+        return undefined;
+    const item = deepFreeze({
+        ...current,
+        delivery: {
+            status: 'leased',
+            attempts: current.delivery.attempts + 1,
+            fence: current.delivery.fence + 1,
+            leaseOwner: workerId,
+            leaseExpiresAt: now + leaseMs,
+        },
+    });
+    return deepFreeze({
+        item,
+        state: {
+            ...state,
+            revision: state.revision + 1,
+            items: { ...state.items, [item.id]: item },
+        },
+    });
+}
+function applySettlement(state, itemId, workerId, fence, resultValue, settledAt) {
+    requireFiniteNumber(settledAt, 'delivery settledAt');
+    const current = state.items[itemId];
+    if (!current
+        || current.delivery.status !== 'leased'
+        || current.delivery.leaseOwner !== workerId
+        || current.delivery.fence !== fence) {
+        throw new Error('Workroom Projection delivery settlement is stale or not owned');
+    }
+    const result = normalizeDeliveryResult(resultValue);
+    const delivery = result.status === 'sent'
+        ? {
+            status: 'sent',
+            attempts: current.delivery.attempts,
+            fence: current.delivery.fence,
+            ...(result.message ? { message: result.message } : {}),
+        }
+        : {
+            status: 'failed',
+            attempts: current.delivery.attempts,
+            fence: current.delivery.fence,
+            failureCode: result.code,
+            retryable: result.retryable,
+            ...(result.retryable ? { nextAttemptAt: settledAt + retryDelay(current.delivery.attempts) } : {}),
+        };
+    const item = deepFreeze({ ...current, delivery });
+    let messageIndex = state.messageIndex;
+    if (result.status === 'sent' && result.message) {
+        if (digest(result.message.conversation) !== digest(current.conversation)) {
+            throw new Error('Workroom Projection receipt targets another conversation');
+        }
+        const key = workroomProjectionMessageKey(result.message);
+        const entry = deepFreeze({
+            projectionId: current.id,
+            bindingRevision: current.bindingRevision,
+            sourceEventIds: current.sourceEventIds,
+            target: current.target,
+            speaker: current.speaker,
+            message: result.message,
+        });
+        const existing = messageIndex[key];
+        if (existing && digest(existing) !== digest(entry)) {
+            throw new Error('Workroom Projection Message Index conflict');
+        }
+        messageIndex = { ...messageIndex, [key]: entry };
+    }
+    return deepFreeze({
+        ...state,
+        revision: state.revision + 1,
+        items: { ...state.items, [itemId]: item },
+        messageIndex,
+    });
+}
+function normalizeDeliveryResult(value) {
+    if (value?.status === 'failed') {
+        requireText(value.code, 'delivery failure code');
+        if (typeof value.retryable !== 'boolean') {
+            throw new Error('Workroom Projection delivery retryable must be boolean');
+        }
+        return deepFreeze({ status: 'failed', code: value.code, retryable: value.retryable });
+    }
+    if (value?.status !== 'sent')
+        throw new Error('Workroom Projection delivery result is invalid');
+    if (!value.message)
+        return Object.freeze({ status: 'sent' });
+    requireConversation(value.message.conversation);
+    requireText(value.message.id, 'delivery message.id');
+    return deepFreeze({ status: 'sent', message: value.message });
+}
+function assertDeliveryState(value, conversation) {
+    const delivery = requireRecord(value, 'delivery state');
+    if (!Number.isSafeInteger(delivery.attempts) || Number(delivery.attempts) < 0
+        || !Number.isSafeInteger(delivery.fence) || Number(delivery.fence) < 0
+        || delivery.attempts !== delivery.fence) {
+        throw new Error('Workroom Projection delivery attempt/fence is invalid');
+    }
+    if (delivery.status === 'pending') {
+        assertExactRecordKeys(delivery, ['status', 'attempts', 'fence'], 'pending delivery');
+        if (delivery.attempts !== 0)
+            throw new Error('Workroom Projection pending delivery was attempted');
+        return;
+    }
+    if (delivery.status === 'leased') {
+        assertExactRecordKeys(delivery, ['status', 'attempts', 'fence', 'leaseOwner', 'leaseExpiresAt'], 'leased delivery');
+        requireText(delivery.leaseOwner, 'delivery.leaseOwner');
+        requireFiniteNumber(delivery.leaseExpiresAt, 'delivery.leaseExpiresAt');
+        return;
+    }
+    if (delivery.status === 'failed') {
+        assertExactRecordKeys(delivery, ['status', 'attempts', 'fence', 'failureCode', 'retryable',
+            ...(delivery.nextAttemptAt !== undefined ? ['nextAttemptAt'] : [])], 'failed delivery');
+        requireText(delivery.failureCode, 'delivery.failureCode');
+        if (typeof delivery.retryable !== 'boolean') {
+            throw new Error('Workroom Projection failed delivery retryable is invalid');
+        }
+        if (delivery.nextAttemptAt !== undefined) {
+            if (delivery.retryable !== true) {
+                throw new Error('Workroom Projection non-retryable delivery cannot have nextAttemptAt');
+            }
+            requireFiniteNumber(delivery.nextAttemptAt, 'delivery.nextAttemptAt');
+        }
+        return;
+    }
+    if (delivery.status !== 'sent') {
+        throw new Error('Workroom Projection delivery status is invalid');
+    }
+    assertExactRecordKeys(delivery, ['status', 'attempts', 'fence', ...(delivery.message ? ['message'] : [])], 'sent delivery');
+    if (delivery.message) {
+        const message = delivery.message;
+        workroomProjectionMessageKey(message);
+        if (digest(message.conversation) !== digest(conversation)) {
+            throw new Error('Workroom Projection persisted receipt targets another conversation');
+        }
+    }
+}
+function retryDelay(attempts) {
+    return Math.min(60_000, 1_000 * 2 ** Math.min(6, Math.max(0, attempts - 1)));
+}
+export function workroomProjectionMessageKey(value) {
+    if (!value)
+        throw new Error('Workroom Projection MessageRef is required');
+    requireConversation(value.conversation);
+    requireText(value.id, 'message.id');
+    return [
+        value.conversation.endpoint.adapter,
+        value.conversation.endpoint.id,
+        value.conversation.kind,
+        value.conversation.id,
+        value.conversation.parent?.kind ?? '',
+        value.conversation.parent?.id ?? '',
+        value.conversation.threadId ?? '',
+        value.id,
+    ].join('\0');
+}
+/** Pure Message Index lookup; it proposes context and owns no Kernel command port. */
+export function resolveProjectionReplyTarget(state, input) {
+    requireText(input.projectId, 'reply projectId');
+    requirePositiveInteger(input.bindingRevision, 'reply bindingRevision');
+    const entry = state.messageIndex[workroomProjectionMessageKey(input.replyTo)];
+    if (!entry) {
+        return deepFreeze({
+            status: 'clarification_required',
+            reason: 'target_not_found',
+            candidateRefs: [],
+        });
+    }
+    if (entry.target.projectId !== input.projectId) {
+        return deepFreeze({
+            status: 'clarification_required',
+            reason: 'cross_project_target',
+            candidateRefs: [entry.target.projectId],
+        });
+    }
+    if (input.bindingRevision !== entry.bindingRevision) {
+        return deepFreeze({
+            status: 'clarification_required',
+            reason: 'stale_binding',
+            candidateRefs: [entry.projectionId],
+        });
+    }
+    const target = entry.target;
+    if (!target.taskKey || !target.taskRevision
+        || !target.assignmentId || !target.assignmentRevision) {
+        return deepFreeze({
+            status: 'clarification_required',
+            reason: 'non_task_projection',
+            candidateRefs: [entry.projectionId],
+        });
+    }
+    const active = input.activeAssignments.some(candidate => candidate.projectId === target.projectId
+        && candidate.runId === target.runId
+        && candidate.taskKey === target.taskKey
+        && candidate.taskRevision === target.taskRevision
+        && candidate.assignmentId === target.assignmentId
+        && candidate.assignmentRevision === target.assignmentRevision);
+    return deepFreeze({
+        status: 'task_target',
+        via: 'reply',
+        disposition: input.intent === 'task_input' && active
+            ? 'context_proposal'
+            : 'discussion_only',
+        sourceProjectionId: entry.projectionId,
+        sourceEventIds: entry.sourceEventIds,
+        target: {
+            projectId: target.projectId,
+            runId: target.runId,
+            taskKey: target.taskKey,
+            taskRevision: target.taskRevision,
+            assignmentId: target.assignmentId,
+            assignmentRevision: target.assignmentRevision,
+            agentDefinitionId: target.agentDefinitionId,
+            status: active ? 'active' : 'historical',
+        },
+    });
+}
+function applyCapture(state, input) {
+    requireText(input.runId, 'capture.runId');
+    requireSequence(input.expectedCursor, 'capture.expectedCursor', -1);
+    requireSequence(input.cursor, 'capture.cursor', 0);
+    const currentCursor = state.cursors[input.runId] ?? -1;
+    if (currentCursor !== input.expectedCursor) {
+        throw new Error(`Workroom Projection cursor conflict for ${input.runId}`);
+    }
+    if (input.cursor <= input.expectedCursor) {
+        throw new Error('Workroom Projection capture cursor must advance');
+    }
+    const items = { ...state.items };
+    for (const item of input.items) {
+        assertProjectionItem(item, input.runId, input.expectedCursor, input.cursor);
+        const existing = items[item.id];
+        if (existing && existing.digest !== item.digest) {
+            throw new Error(`Workroom Projection item conflict: ${item.id}`);
+        }
+        items[item.id] = item;
+    }
+    return deepFreeze({
+        revision: state.revision + 1,
+        bindings: state.bindings,
+        cursors: { ...state.cursors, [input.runId]: input.cursor },
+        items,
+        messageIndex: state.messageIndex,
+    });
+}
+function projectEvents(events, cursor, binding) {
+    const assignments = new Map();
+    const taskRevisions = new Map();
+    const taskAssignments = new Map();
+    const items = [];
+    let capturedThrough = cursor;
+    let pendingProgress = [];
+    const flushProgress = () => {
+        if (pendingProgress.length === 0)
+            return;
+        const byAssignment = new Map();
+        for (const progressEvent of pendingProgress) {
+            const assignmentId = String(progressEvent.payload.assignmentId);
+            byAssignment.set(assignmentId, [...(byAssignment.get(assignmentId) ?? []), progressEvent]);
+        }
+        for (const progressEvents of byAssignment.values()) {
+            const latest = progressEvents.at(-1);
+            const item = projectEvent(latest, binding, assignments, taskRevisions, taskAssignments, progressProjectionDefinition(latest, assignments, taskAssignments, progressEvents.length), progressEvents);
+            if (item)
+                items.push(item);
+        }
+        capturedThrough = pendingProgress.at(-1).sequence;
+        pendingProgress = [];
+    };
+    for (const event of events) {
+        if (event.type === 'task.planned')
+            taskRevisions.set(String(event.payload.taskKey), 1);
+        if (event.type === 'task.revised') {
+            const taskKey = String(event.payload.taskKey);
+            taskRevisions.set(taskKey, (taskRevisions.get(taskKey) ?? 0) + 1);
+        }
+        if (event.type === 'assignment.claimed') {
+            const scope = {
+                assignmentId: String(event.payload.assignmentId),
+                taskKey: String(event.payload.taskKey),
+                taskRevision: Number(event.payload.taskRevision),
+                assignmentRevision: Number(event.payload.assignmentRevision),
+                owner: String(event.payload.owner),
+                role: event.payload.role,
+            };
+            assignments.set(scope.assignmentId, scope);
+            taskAssignments.set(scope.taskKey, scope.assignmentId);
+        }
+        if (event.sequence <= cursor)
+            continue;
+        if (event.type === 'assignment.progress') {
+            pendingProgress.push(event);
+            if (pendingProgress.length >= progressWindowSizeForPolicy(binding.projectionPolicyRevision)) {
+                flushProgress();
+            }
+            continue;
+        }
+        const item = projectEvent(event, binding, assignments, taskRevisions, taskAssignments);
+        if (item) {
+            // Observable boundaries are immediate. Any partial progress window is
+            // deterministically closed before the boundary rather than timer-flushed.
+            flushProgress();
+            items.push(item);
+            capturedThrough = event.sequence;
+        }
+        else if (pendingProgress.length === 0) {
+            capturedThrough = event.sequence;
+        }
+    }
+    return deepFreeze({ items, cursor: capturedThrough });
+}
+function projectEvent(event, binding, assignments, taskRevisions, taskAssignments, definitionOverride, sourceEvents = [event]) {
+    const assignmentId = assignmentIdForEvent(event, taskAssignments);
+    const assignment = assignmentId ? assignments.get(assignmentId) : undefined;
+    const definition = definitionOverride ?? projectionDefinition(event, assignment);
+    if (!definition)
+        return undefined;
+    const speaker = assignment
+        ? requireAgentIdentity(binding, assignment)
+        : binding.orchestrator;
+    const taskKey = assignment?.taskKey ?? taskKeyForEvent(event);
+    const taskRevision = assignment?.taskRevision
+        ?? (taskKey ? taskRevisions.get(taskKey) : undefined);
+    const target = deepFreeze({
+        projectId: binding.projectId,
+        runId: event.runId,
+        ...(taskKey ? { taskKey } : {}),
+        ...(taskRevision ? { taskRevision } : {}),
+        ...(assignment ? { assignmentId: assignment.assignmentId } : {}),
+        ...(assignment ? { assignmentRevision: assignment.assignmentRevision } : {}),
+        agentDefinitionId: speaker.agentDefinitionId,
+    });
+    const immutableProjection = {
+        version: 1,
+        audience: 'workroom',
+        projectId: binding.projectId,
+        runId: event.runId,
+        sourceEventIds: sourceEvents.map(sourceEvent => sourceEvent.eventId),
+        sourceSequence: event.sequence,
+        bindingRevision: binding.bindingRevision,
+        projectionPolicyRevision: binding.projectionPolicyRevision,
+        conversation: binding.conversation,
+        speaker,
+        kind: definition.kind,
+        content: `[${speaker.displayName} · ${speaker.role}] ${definition.content}`,
+        target,
+    };
+    const itemDigest = digest(immutableProjection);
+    const id = `projection:${itemDigest.slice('sha256:'.length)}`;
+    return deepFreeze({
+        ...immutableProjection,
+        id,
+        idempotencyKey: id,
+        digest: itemDigest,
+        delivery: { status: 'pending', attempts: 0, fence: 0 },
+    });
+}
+export function workroomLifecycleProjectionCursorKey(projectId, objectId) {
+    requireText(projectId, 'Lifecycle Projection projectId');
+    requireText(objectId, 'Lifecycle Projection objectId');
+    return `payload-lifecycle:${digest({ version: 1, projectId, objectId }).slice('sha256:'.length)}`;
+}
+function projectionBindingCursorKey(sourceKey, binding) {
+    requireText(sourceKey, 'Projection cursor source key');
+    return `binding-cursor:${digest({
+        version: 1,
+        sourceKey,
+        projectId: binding.projectId,
+        audience: projectionAudience(binding),
+        bindingRevision: binding.bindingRevision,
+        catalogBindingDigest: binding.catalogBindingDigest,
+        conversation: binding.conversation,
+    }).slice('sha256:'.length)}`;
+}
+function exactLegacyBindingCursor(state, sourceKey, binding) {
+    const cursor = state.cursors[sourceKey];
+    if (cursor === undefined)
+        return undefined;
+    const legacyItems = Object.values(state.items).filter(item => item.cursorId === undefined && item.runId === sourceKey);
+    if (legacyItems.length === 0)
+        return undefined;
+    const audience = projectionAudience(binding);
+    return legacyItems.every(item => item.projectId === binding.projectId
+        && (item.audience ?? 'workroom') === audience
+        && item.bindingRevision === binding.bindingRevision
+        && item.projectionPolicyRevision === binding.projectionPolicyRevision
+        && digest(item.conversation) === digest(binding.conversation)) ? cursor : undefined;
+}
+export function workroomPortfolioProjectionCursorKey(portfolioId, projectId) {
+    requireText(portfolioId, 'Portfolio Projection portfolioId');
+    requireText(projectId, 'Portfolio Projection projectId');
+    return `portfolio-sponsor:${digest({ version: 1, portfolioId, projectId }).slice('sha256:'.length)}`;
+}
+function portfolioSponsorDraft(binding, projection, runId) {
+    const project = projection.projects[binding.projectId];
+    const speaker = binding.orchestrator;
+    const sourceEventIds = [`portfolio-sponsor:${digest({
+            version: 1,
+            portfolioId: projection.portfolioId,
+            projectId: binding.projectId,
+            sourceSequence: projection.sourceSequence,
+            projectionDigest: projection.digest,
+        }).slice('sha256:'.length)}`];
+    const queue = project.queueHead
+        ? `queue=${boundedProjectionText(project.queueHead.opaqueHeadId, 'opaque')} `
+            + `starvationAt=${project.queueHead.starvationAt}`
+        : 'queue=empty';
+    const rate = Object.entries(project.rate)
+        .sort(([left], [right]) => compareCanonicalWorkroomText(left, right))
+        .map(([poolId, window]) => `${boundedProjectionText(poolId, 'pool')}:`
+        + `${window.usedUnits}/${window.limitUnits}@${window.windowStart}-${window.windowEnd}`)
+        .join(',') || 'none';
+    const immutableProjection = {
+        version: 1,
+        audience: 'sponsor_room',
+        projectId: binding.projectId,
+        runId,
+        sourceEventIds,
+        sourceSequence: projection.sourceSequence,
+        bindingRevision: binding.bindingRevision,
+        projectionPolicyRevision: binding.projectionPolicyRevision,
+        conversation: binding.conversation,
+        speaker,
+        kind: (project.blockers.length > 0 ? 'attention' : 'status'),
+        content: `[${speaker.displayName} · ${speaker.role}] Portfolio ${boundedProjectionText(projection.portfolioId, 'portfolio')} / Project ${boundedProjectionText(binding.projectId, 'project')}：`
+            + `lane=${project.lane} status=${project.status} ${queue} `
+            + `grants=${project.grants.length} reclaims=${project.reclaims.length} `
+            + `budget=${project.budget.availableMicros}/${project.budget.limitMicros} `
+            + `rate=${rate} fairness=${project.fairness.weightedService} `
+            + `blockers=${project.blockers.join(',') || 'none'}`,
+        target: deepFreeze({
+            projectId: binding.projectId,
+            runId,
+            agentDefinitionId: speaker.agentDefinitionId,
+        }),
+    };
+    const itemDigest = digest(immutableProjection);
+    const id = `projection:${itemDigest.slice('sha256:'.length)}`;
+    return deepFreeze({
+        ...immutableProjection,
+        id,
+        idempotencyKey: id,
+        digest: itemDigest,
+        delivery: { status: 'pending', attempts: 0, fence: 0 },
+    });
+}
+function lifecycleOverdueSourceEventId(projectId, value) {
+    return `payload-hold-overdue:${digest({
+        version: 1,
+        projectId,
+        objectId: value.objectId,
+        holdId: value.holdId,
+        reasonCode: value.reasonCode,
+        placedAt: value.placedAt,
+        reviewAt: value.reviewAt,
+    }).slice('sha256:'.length)}`;
+}
+function lifecycleOverdueDraft(binding, runId, value, sourceSequence) {
+    const speaker = binding.orchestrator;
+    const sourceEventIds = [lifecycleOverdueSourceEventId(binding.projectId, value)];
+    const immutableProjection = {
+        version: 1,
+        audience: 'sponsor_room',
+        projectId: binding.projectId,
+        runId,
+        sourceEventIds,
+        sourceSequence,
+        bindingRevision: binding.bindingRevision,
+        projectionPolicyRevision: binding.projectionPolicyRevision,
+        conversation: binding.conversation,
+        speaker,
+        kind: 'attention',
+        content: `[${speaker.displayName} · ${speaker.role}] Retention Hold review overdue：`
+            + `object ${boundedProjectionText(value.objectId, 'unknown')}；`
+            + `hold ${boundedProjectionText(value.holdId, 'unknown')}；reviewAt ${value.reviewAt}`,
+        target: deepFreeze({
+            projectId: binding.projectId,
+            runId,
+            agentDefinitionId: speaker.agentDefinitionId,
+        }),
+    };
+    const itemDigest = digest(immutableProjection);
+    const id = `projection:${itemDigest.slice('sha256:'.length)}`;
+    return deepFreeze({
+        ...immutableProjection,
+        id,
+        idempotencyKey: id,
+        digest: itemDigest,
+        delivery: { status: 'pending', attempts: 0, fence: 0 },
+    });
+}
+function validateLifecycleOverdueSnapshot(value) {
+    if (!value || value.version !== 1 || !Array.isArray(value.overdue)
+        || !Number.isSafeInteger(value.clockRevision) || value.clockRevision < 0
+        || !Number.isSafeInteger(value.observedAt) || value.observedAt < 0) {
+        throw new Error('Workroom Lifecycle overdue projection is invalid');
+    }
+    requireText(value.projectId, 'Lifecycle overdue Project');
+    const identities = new Set();
+    for (const item of value.overdue) {
+        requireText(item.objectId, 'Lifecycle overdue object');
+        requireText(item.holdId, 'Lifecycle overdue Hold');
+        requireText(item.ownerPrincipalId, 'Lifecycle overdue owner');
+        if (!Number.isSafeInteger(item.stateSequence) || item.stateSequence < 0
+            || !/^sha256:[a-f0-9]{64}$/u.test(item.stateDigest)
+            || !['legal_hold', 'investigation', 'regulatory_preservation'].includes(item.reasonCode)
+            || !Number.isSafeInteger(item.placedAt) || item.placedAt < 0
+            || !Number.isSafeInteger(item.reviewAt) || item.reviewAt <= item.placedAt
+            || !Number.isSafeInteger(item.overdueBy) || item.overdueBy < 0) {
+            throw new Error('Workroom Lifecycle overdue Hold is invalid');
+        }
+        const identity = lifecycleOverdueSourceEventId(value.projectId, item);
+        if (identities.has(identity))
+            throw new Error('Workroom Lifecycle overdue projection contains duplicates');
+        identities.add(identity);
+    }
+    const { digest: supplied, ...body } = value;
+    if (supplied !== digest(body))
+        throw new Error('Workroom Lifecycle overdue projection digest mismatch');
+    return deepFreeze(structuredClone(value));
+}
+function materializeProjectionItem(draft, governed) {
+    const { content: _body, id: _draftId, idempotencyKey: _draftKey, digest: _draftDigest, delivery, ...header } = draft;
+    const projection = deepFreeze({
+        ...header,
+        disclosure: {
+            request: structuredClone(governed.request),
+            manifest: structuredClone(governed.manifest),
+        },
+    });
+    const itemDigest = digest(projection);
+    const id = `projection:${itemDigest.slice('sha256:'.length)}`;
+    return deepFreeze({
+        ...projection,
+        id,
+        idempotencyKey: id,
+        digest: itemDigest,
+        delivery: structuredClone(delivery),
+    });
+}
+function projectionDefinition(event, assignment) {
+    const taskKey = assignment?.taskKey ?? taskKeyForEvent(event);
+    switch (event.type) {
+        case 'run.created':
+            return { kind: 'status', content: `Run 已启动：${boundedProjectionText(event.payload.title, '未命名 Run')}` };
+        case 'task.planned':
+            return { kind: 'status', content: `${taskKey}：已规划` };
+        case 'assignment.claimed':
+            return { kind: 'status', content: `${taskKey}：已领取当前工作` };
+        case 'assignment.started':
+            return { kind: 'status', content: `${taskKey}：正在执行` };
+        case 'assignment.checkpointed':
+            return { kind: 'milestone', content: `${taskKey}：已形成 checkpoint` };
+        case 'assignment.execution_completed':
+            return { kind: 'conclusion', content: `${taskKey}：已提交执行结论，等待验收` };
+        case 'task.blocked':
+            return { kind: 'attention', content: `${taskKey}：阻塞——${boundedProjectionText(event.payload.reason, '原因未说明')}` };
+        case 'task.accepted':
+            return { kind: 'conclusion', content: `${taskKey}：已验收` };
+        case 'task.failed':
+            return { kind: 'attention', content: `${taskKey}：失败——${boundedProjectionText(event.payload.reason, '原因未说明')}` };
+        case 'reviewer.assigned':
+            return { kind: 'attention', content: `${taskKey}：已进入 Reviewer 验收` };
+        case 'sponsor_gate.opened':
+            return { kind: 'attention', content: `${taskKey}：等待 Sponsor 决策` };
+        case 'sponsor_gate.expired':
+            return { kind: 'attention', content: `${taskKey}：Sponsor 决策已过期` };
+        case 'sponsor_gate.decided':
+            return {
+                kind: 'attention',
+                content: `${taskKey}：Sponsor 已${sponsorDecisionLabel(event.payload.decision)}`,
+            };
+        case 'plan_gate.decided':
+            return {
+                kind: 'attention',
+                content: `${taskKey}：Sponsor 已对执行前 Plan Gate ${sponsorDecisionLabel(event.payload.decision)}`,
+            };
+        case 'task.rework_requested':
+            return {
+                kind: 'attention',
+                content: `${taskKey}：已要求返工——${boundedProjectionText(event.payload.reason, '原因未说明')}`,
+            };
+        case 'assignment.lease_expired':
+            return { kind: 'attention', content: `${taskKey}：执行租约已过期，等待恢复` };
+        case 'assignment.cancel_requested':
+            return { kind: 'attention', content: `${taskKey}：执行已请求取消` };
+        case 'assignment.cancelled':
+            return { kind: 'attention', content: `${taskKey}：执行已取消` };
+        case 'task.cancel_requested':
+            return { kind: 'attention', content: `${taskKey}：已请求取消` };
+        case 'run.cancel_requested':
+            return {
+                kind: 'attention',
+                content: `Run 已请求取消——${boundedProjectionText(event.payload.reason, '原因未说明')}`,
+            };
+        case 'task.cancelled':
+            return { kind: 'attention', content: `${taskKey}：已取消` };
+        case 'run.cancelled':
+            return { kind: 'attention', content: 'Run 已取消' };
+        default:
+            return undefined;
+    }
+}
+function progressProjectionDefinition(event, assignments, taskAssignments, count) {
+    const assignmentId = assignmentIdForEvent(event, taskAssignments);
+    const taskKey = assignmentId ? assignments.get(assignmentId)?.taskKey : undefined;
+    const progress = event.payload.progress;
+    const completedUnits = progress.completedUnits;
+    const totalUnits = progress.totalUnits;
+    const units = typeof completedUnits === 'number' && Number.isFinite(completedUnits)
+        && typeof totalUnits === 'number' && Number.isFinite(totalUnits)
+        ? `（${completedUnits}/${totalUnits}）`
+        : '';
+    const window = count > 1 ? `；本窗口 ${count} 次更新` : '';
+    return {
+        kind: 'progress',
+        content: `${taskKey ?? '未知任务'}：${boundedProjectionText(progress.summary, '进度已更新')}${units}${window}`,
+    };
+}
+/** Policy revision pins the aggregation contract; source Kernel order closes each fixed window. */
+function progressWindowSizeForPolicy(projectionPolicyRevision) {
+    requirePositiveInteger(projectionPolicyRevision, 'projectionPolicyRevision');
+    return 3;
+}
+function boundedProjectionText(value, fallback) {
+    if (typeof value !== 'string')
+        return fallback;
+    const canonical = value.replace(/[\p{Cc}\p{Cf}\s]+/gu, ' ').trim();
+    return (canonical || fallback).slice(0, 240);
+}
+function sponsorDecisionLabel(value) {
+    switch (value) {
+        case 'approve': return '批准';
+        case 'reject': return '拒绝';
+        case 'request_changes': return '要求修改';
+        case 'cancel': return '取消';
+        default: return '作出决策';
+    }
+}
+function assignmentIdForEvent(event, taskAssignments) {
+    if (event.type.startsWith('assignment.'))
+        return String(event.payload.assignmentId ?? '') || undefined;
+    const taskKey = taskKeyForEvent(event);
+    return taskKey ? taskAssignments.get(taskKey) : undefined;
+}
+function taskKeyForEvent(event) {
+    const value = event.payload.taskKey;
+    return typeof value === 'string' && value ? value : undefined;
+}
+function requireAgentIdentity(binding, assignment) {
+    const matches = binding.agents.filter(identity => identity.principalId === assignment.owner && identity.role === assignment.role);
+    if (matches.length !== 1) {
+        throw new Error(`Workroom Projection requires one named Agent identity for ${assignment.assignmentId}`);
+    }
+    return matches[0];
+}
+function freezeAndValidateBinding(value) {
+    if (value.version !== 1)
+        throw new Error('Workroom Projection binding version is unsupported');
+    projectionAudience(value);
+    requireText(value.projectId, 'binding.projectId');
+    if (!/^sha256:[a-f0-9]{64}$/u.test(value.catalogBindingDigest)) {
+        throw new Error('Workroom Projection binding.catalogBindingDigest is invalid');
+    }
+    requirePositiveInteger(value.bindingRevision, 'binding.bindingRevision');
+    requirePositiveInteger(value.projectionPolicyRevision, 'binding.projectionPolicyRevision');
+    requireConversation(value.conversation);
+    requireIdentity(value.orchestrator, 'binding.orchestrator');
+    if (value.orchestrator.role !== 'orchestrator' || !Array.isArray(value.agents)) {
+        throw new Error('Workroom Projection binding requires an Orchestrator and Agent directory');
+    }
+    for (const identity of value.agents)
+        requireIdentity(identity, 'binding.agents[]');
+    return deepFreeze(value);
+}
+export function workroomProjectionBindingKey(projectId, audience) {
+    requireText(projectId, 'binding key projectId');
+    return audience === 'workroom' ? projectId : `${projectId}:sponsor-room`;
+}
+export function projectionAudience(value) {
+    if (value.audience === undefined)
+        return 'workroom';
+    if (value.audience !== 'workroom' && value.audience !== 'sponsor_room') {
+        throw new Error('Workroom Projection audience is invalid');
+    }
+    return value.audience;
+}
+function assertProjectionItem(item, runId, after, through) {
+    projectionAudience(item);
+    if ('content' in item) {
+        throw new Error('Legacy plaintext Workroom Projection snapshot is unsupported; use offline export then purge it');
+    }
+    if (item.version !== 1 || (item.cursorId ?? item.runId) !== runId
+        || item.sourceSequence <= after || item.sourceSequence > through
+        || item.id !== item.idempotencyKey || !/^projection:[a-f0-9]{64}$/u.test(item.id)
+        || !/^sha256:[a-f0-9]{64}$/u.test(item.digest)) {
+        throw new Error('Invalid Workroom Projection outbox item');
+    }
+    const expectedChannel = projectionAudience(item) === 'sponsor_room'
+        ? 'sponsor_projection'
+        : 'workroom_projection';
+    if (!item.disclosure?.request || !item.disclosure.manifest
+        || item.disclosure.request.projectId !== item.projectId
+        || item.disclosure.manifest.source.payloadHash !== item.disclosure.request.sourceDigest
+        || item.disclosure.manifest.channel !== expectedChannel) {
+        throw new Error('Invalid Workroom Projection Disclosure Manifest');
+    }
+    const { id: _id, idempotencyKey: _key, digest: _digest, delivery: _delivery, ...projection } = item;
+    if (digest(projection) !== item.digest || item.id !== `projection:${item.digest.slice(7)}`) {
+        throw new Error('Workroom Projection outbox item digest mismatch');
+    }
+}
+function requireConversation(value) {
+    requireText(value.endpoint?.id, 'conversation.endpoint.id');
+    requireText(value.endpoint?.adapter, 'conversation.endpoint.adapter');
+    requireText(value.id, 'conversation.id');
+    if (!['private', 'group', 'channel'].includes(value.kind)) {
+        throw new Error('Workroom Projection conversation kind is invalid');
+    }
+}
+function requireIdentity(value, label) {
+    requireText(value.principalId, `${label}.principalId`);
+    requireText(value.agentDefinitionId, `${label}.agentDefinitionId`);
+    requireText(value.displayName, `${label}.displayName`);
+    if (!['orchestrator', 'executor', 'reviewer', 'integration'].includes(value.role)) {
+        throw new Error(`Workroom Projection ${label}.role is invalid`);
+    }
+}
+function requireText(value, label) {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new Error(`Workroom Projection ${label} requires non-empty text`);
+    }
+}
+function requirePositiveInteger(value, label) {
+    if (!Number.isSafeInteger(value) || Number(value) < 1) {
+        throw new Error(`Workroom Projection ${label} must be a positive integer`);
+    }
+}
+function requireSequence(value, label, minimum) {
+    if (!Number.isSafeInteger(value) || Number(value) < minimum) {
+        throw new Error(`Workroom Projection ${label} is invalid`);
+    }
+}
+function requireFiniteNumber(value, label) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        throw new Error(`Workroom Projection ${label} must be finite`);
+    }
+}
+function requireRecord(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`Workroom Projection ${label} must be an object`);
+    }
+    return value;
+}
+function assertExactRecordKeys(value, expected, label) {
+    const actual = Object.keys(value).sort();
+    const canonical = [...expected].sort();
+    if (actual.length !== canonical.length
+        || actual.some((key, index) => key !== canonical[index])) {
+        throw new Error(`Workroom Projection ${label} fields are invalid`);
+    }
+}
+function hasCode(error, code) {
+    return Boolean(error && typeof error === 'object' && 'code' in error
+        && error.code === code);
+}
+//# sourceMappingURL=projection-outbox.js.map