@bizagent/dsh 0.0.0-stage → 1.0.0

package/lib/host.d.ts

@@ -0,0 +1,22 @@
+export { BIZAGENT_PROJECT_REVIEW_API } from './ui-contract.js';
+export { createProjectReviewHttpHandler, registerProjectReviewRoute } from './project-review-transport.js';
+export type { ProjectReviewPrincipal, ProjectReviewRouteOptions } from './project-review-transport.js';
+export { BIZAGENT_PROPOSAL_REVIEW_API, createProposalReviewHttpHandler, registerProposalReviewRoute } from './proposal-review-transport.js';
+export type { ProposalReviewPrincipal, ProposalReviewRouteOptions } from './proposal-review-transport.js';
+export { SHARED_KNOWLEDGE_REVIEW_API, createSharedKnowledgeReviewHttpHandler, registerSharedKnowledgeReviewRoute } from './shared-knowledge-review-transport.js';
+export type { SharedKnowledgeReviewOptions } from './shared-knowledge-review-transport.js';
+export { HUMAN_INBOX_API, createHumanInboxHttpHandler, registerHumanInboxRoute } from './human-inbox-transport.js';
+export type { HumanInboxPrincipal, HumanInboxRouteOptions } from './human-inbox-transport.js';
+export { HumanNotificationRunner } from './human-notification-runner.js';
+export type { HumanNotificationProvider, HumanNotificationRequest, HumanNotificationOutcome, HumanNotificationPass, HumanNotificationRunnerOptions, HumanNotificationPolicyDecision } from './human-notification-runner.js';
+export { HumanNotificationWebhook } from './human-notification-webhook.js';
+export type { HumanNotificationWebhookOptions } from './human-notification-webhook.js';
+export { HumanTurnCompletionNotifier } from './human-turn-completion.js';
+export type { HumanTurnCandidate, HumanTurnDestination, HumanTurnCompletionSource, HumanTurnPersistence, HumanTurnCompletionPass } from './human-turn-completion.js';
+export { InboxStalledEscalationRunner } from './inbox-stalled-escalation-runner.js';
+export type { EscalationOwnerDecision, StalledEscalationPass } from './inbox-stalled-escalation-runner.js';
+export { stalledInboxTopics } from './inbox-stalled-topic.js';
+export type { StalledInboxTopic } from './inbox-stalled-topic.js';
+export { exportHomeArchive, verifyHomeArchive, importHomeArchive } from './home-archive.js';
+export type { HomeArchiveManifest } from './home-archive.js';
+//# sourceMappingURL=host.d.ts.map

package/lib/host.js

@@ -0,0 +1,15 @@
+// Building blocks for hosts that bring their own user authentication, notification channels,
+// or backup jobs. The local single-user setup does not need them: `@bizagent/dsh/local-human-host`
+// mounts the review and Inbox routes for one person on 127.0.0.1.
+export { BIZAGENT_PROJECT_REVIEW_API } from './ui-contract.js';
+export { createProjectReviewHttpHandler, registerProjectReviewRoute } from './project-review-transport.js';
+export { BIZAGENT_PROPOSAL_REVIEW_API, createProposalReviewHttpHandler, registerProposalReviewRoute } from './proposal-review-transport.js';
+export { SHARED_KNOWLEDGE_REVIEW_API, createSharedKnowledgeReviewHttpHandler, registerSharedKnowledgeReviewRoute } from './shared-knowledge-review-transport.js';
+export { HUMAN_INBOX_API, createHumanInboxHttpHandler, registerHumanInboxRoute } from './human-inbox-transport.js';
+export { HumanNotificationRunner } from './human-notification-runner.js';
+export { HumanNotificationWebhook } from './human-notification-webhook.js';
+export { HumanTurnCompletionNotifier } from './human-turn-completion.js';
+export { InboxStalledEscalationRunner } from './inbox-stalled-escalation-runner.js';
+export { stalledInboxTopics } from './inbox-stalled-topic.js';
+export { exportHomeArchive, verifyHomeArchive, importHomeArchive } from './home-archive.js';
+//# sourceMappingURL=host.js.map

package/lib/human-inbox-transport.d.ts

@@ -0,0 +1,23 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { BizAgentService } from './service.js';
+export declare const HUMAN_INBOX_API = "/api/bizagent/human-inbox";
+export interface HumanInboxPrincipal {
+    /** Verified by the host's session or bearer credential, never read from request fields. */
+    userId: string;
+}
+export interface HumanInboxRouteOptions {
+    authenticateUser: (request: IncomingMessage) => HumanInboxPrincipal | null | Promise<HumanInboxPrincipal | null>;
+    /** The host checks CSRF protection or a non-cookie credential for every mutation. */
+    authorizeMutation: (request: IncomingMessage, principal: HumanInboxPrincipal) => boolean | Promise<boolean>;
+}
+/** Opt-in route; the core plugin cannot infer a human identity from DSH Agent bindings. */
+export declare function createHumanInboxHttpHandler(service: BizAgentService, options: HumanInboxRouteOptions): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+/** Mount on the local DSH web server behind the loopback Host / same-origin route guard. */
+export declare function registerHumanInboxRoute(webServer: {
+    register: (route: {
+        kind: 'exact';
+        path: string;
+        handler: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+    }) => () => void;
+}, service: BizAgentService, options: HumanInboxRouteOptions): () => void;
+//# sourceMappingURL=human-inbox-transport.d.ts.map

package/lib/human-inbox-transport.js

@@ -0,0 +1,105 @@
+import { z } from 'zod';
+import { guardLocalRoute } from './route-guard.js';
+export const HUMAN_INBOX_API = '/api/bizagent/human-inbox';
+const MAX_BODY_BYTES = 64 * 1024;
+const HumanInboxActionSchema = z.discriminatedUnion('action', [
+    z.strictObject({ action: z.literal('handle'), messageId: z.string().min(1).max(200) }),
+    z.strictObject({ action: z.literal('reply'), messageId: z.string().min(1).max(200),
+        subject: z.string().min(1).max(200), body: z.string().min(1).max(16000),
+        idempotencyKey: z.string().min(1).max(128) }),
+    z.strictObject({ action: z.literal('notification-preference'), enabled: z.boolean(),
+        expectedRevision: z.number().int().nonnegative() }),
+]);
+/** Opt-in route; the core plugin cannot infer a human identity from DSH Agent bindings. */
+export function createHumanInboxHttpHandler(service, options) {
+    return async (req, res) => {
+        res.setHeader('Cache-Control', 'no-store');
+        res.setHeader('Content-Type', 'application/json; charset=utf-8');
+        res.setHeader('X-Content-Type-Options', 'nosniff');
+        if (req.method !== 'GET' && req.method !== 'POST') {
+            res.setHeader('Allow', 'GET, POST');
+            reply(res, 405, { error: 'method-not-allowed' });
+            return;
+        }
+        try {
+            const principal = await options.authenticateUser(req);
+            if (!principal || !principal.userId.trim()) {
+                reply(res, 401, { error: 'authentication-required' });
+                return;
+            }
+            if (req.method === 'GET') {
+                const url = new URL(req.url ?? '', 'http://bizagent.local');
+                const messageId = url.searchParams.get('messageId');
+                if (messageId) {
+                    reply(res, 200, service.readHumanInbox(principal.userId, messageId));
+                    return;
+                }
+                const direction = url.searchParams.get('direction');
+                const beforeMessageId = url.searchParams.get('beforeMessageId');
+                const limit = url.searchParams.get('limit');
+                reply(res, 200, service.listHumanInbox(principal.userId, {
+                    ...(direction !== null ? { direction: direction } : {}),
+                    ...(beforeMessageId !== null ? { beforeMessageId } : {}),
+                    ...(limit !== null ? { limit: Number(limit) } : {}),
+                    pendingOnly: url.searchParams.get('pendingOnly') === 'true',
+                }));
+                return;
+            }
+            if (!(await options.authorizeMutation(req, principal))) {
+                reply(res, 403, { error: 'mutation-forbidden' });
+                return;
+            }
+            if (!String(req.headers['content-type'] ?? '').toLowerCase().startsWith('application/json')) {
+                reply(res, 415, { error: 'content-type' });
+                return;
+            }
+            const action = HumanInboxActionSchema.parse(await readJson(req));
+            const result = action.action === 'handle'
+                ? await service.handleHumanInbox(principal.userId, action.messageId)
+                : action.action === 'notification-preference'
+                    ? await service.setHumanNotificationPreference(principal.userId, action.enabled, action.expectedRevision)
+                    : await service.replyHumanInbox(principal.userId, {
+                        replyTo: action.messageId, subject: action.subject, body: action.body,
+                        idempotencyKey: action.idempotencyKey,
+                    });
+            reply(res, 200, result);
+        }
+        catch (error) {
+            if (error instanceof z.ZodError || error instanceof RequestError) {
+                reply(res, 400, { error: 'invalid-request' });
+            }
+            else {
+                reply(res, 409, { error: 'inbox-operation-rejected' });
+            }
+        }
+    };
+}
+/** Mount on the local DSH web server behind the loopback Host / same-origin route guard. */
+export function registerHumanInboxRoute(webServer, service, options) {
+    return webServer.register({ kind: 'exact', path: HUMAN_INBOX_API,
+        handler: guardLocalRoute(createHumanInboxHttpHandler(service, options)) });
+}
+class RequestError extends Error {
+}
+async function readJson(req) {
+    let total = 0;
+    const chunks = [];
+    for await (const chunk of req) {
+        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        total += bytes.length;
+        if (total > MAX_BODY_BYTES)
+            throw new RequestError('request body too large');
+        chunks.push(bytes);
+    }
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    catch {
+        throw new RequestError('invalid JSON');
+    }
+}
+function reply(res, code, body) {
+    res.statusCode = code;
+    res.end(JSON.stringify(body));
+}
+//# sourceMappingURL=human-inbox-transport.js.map

package/lib/human-notification-runner.d.ts

@@ -0,0 +1,83 @@
+import { type HumanAction, type InboxSenderAddress, type InboxMessage, type UserAddress } from './domain.js';
+import type { LearningLedger } from './ledger.js';
+export interface HumanNotificationRequest {
+    notificationId: string;
+    messageId: string;
+    recipient: UserAddress;
+    role: 'to' | 'cc';
+    fromAddress: InboxSenderAddress;
+    subject: string;
+    body: string;
+    priority: 'normal' | 'urgent';
+    due?: string;
+    humanAction?: HumanAction;
+}
+export type HumanNotificationOutcome = {
+    status: 'sent';
+    providerReceipt: string;
+} | {
+    status: 'rejected';
+    reason: string;
+} | {
+    status: 'unknown';
+};
+export interface HumanNotificationProvider {
+    /** Return sent only after verifying an actual channel success receipt. */
+    notify(request: HumanNotificationRequest): Promise<HumanNotificationOutcome>;
+}
+export type HumanNotificationPolicyDecision = {
+    action: 'send';
+} | {
+    action: 'defer';
+} | {
+    action: 'suppress';
+    reason: string;
+};
+export interface HumanNotificationRunnerOptions {
+    /** Host attention policy runs before reservation; defer leaves the Inbox item pending. */
+    decide?(message: InboxMessage, recipient: UserAddress): HumanNotificationPolicyDecision | Promise<HumanNotificationPolicyDecision>;
+}
+export interface HumanNotificationPass {
+    sent: Array<{
+        messageId: string;
+        recipient: UserAddress;
+    }>;
+    rejected: Array<{
+        messageId: string;
+        recipient: UserAddress;
+    }>;
+    unknown: Array<{
+        messageId: string;
+        recipient: UserAddress;
+    }>;
+    deferred: Array<{
+        messageId: string;
+        recipient: UserAddress;
+    }>;
+    suppressed: Array<{
+        messageId: string;
+        recipient: UserAddress;
+    }>;
+    failed: Array<{
+        messageId: string;
+        recipient: UserAddress;
+        error: unknown;
+    }>;
+}
+/** At most one external attempt per message and user. A reserved but unresolved attempt remains unknown. */
+export declare class HumanNotificationRunner {
+    private readonly ledger;
+    private readonly provider;
+    private readonly options;
+    private pass;
+    private closing;
+    constructor(ledger: LearningLedger, provider: HumanNotificationProvider, options?: HumanNotificationRunnerOptions);
+    recoverBatch(limit?: number): Promise<HumanNotificationPass>;
+    /** Only a definite provider rejection can be retried, by an explicit host call. */
+    retryRejected(messageId: string, recipient: UserAddress): Promise<'sent' | 'rejected' | 'unknown'>;
+    private runPass;
+    private decision;
+    private notify;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=human-notification-runner.d.ts.map

package/lib/human-notification-runner.js

@@ -0,0 +1,138 @@
+import { isUserAddress } from './domain.js';
+/** At most one external attempt per message and user. A reserved but unresolved attempt remains unknown. */
+export class HumanNotificationRunner {
+    ledger;
+    provider;
+    options;
+    pass;
+    closing = false;
+    constructor(ledger, provider, options = {}) {
+        this.ledger = ledger;
+        this.provider = provider;
+        this.options = options;
+    }
+    recoverBatch(limit = 4) {
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100) {
+            throw new Error('human notification pass limit must be between 1 and 100');
+        }
+        if (this.closing)
+            return Promise.resolve({ sent: [], rejected: [], unknown: [],
+                deferred: [], suppressed: [], failed: [] });
+        if (this.pass)
+            return this.pass;
+        const task = this.runPass(limit);
+        this.pass = task;
+        void task.finally(() => { if (this.pass === task)
+            this.pass = undefined; }).catch(() => undefined);
+        return task;
+    }
+    /** Only a definite provider rejection can be retried, by an explicit host call. */
+    async retryRejected(messageId, recipient) {
+        if (this.closing)
+            throw new Error('human notification runner is closed');
+        const message = this.ledger.getInboxMessage(messageId);
+        if (message === undefined || ![...message.to, ...message.cc].includes(recipient)) {
+            throw new Error('human notification message is unavailable to this recipient');
+        }
+        const decision = await this.decision(message, recipient);
+        if (decision.action !== 'send')
+            throw new Error('human notification policy does not permit retry');
+        const notification = await this.ledger.retryRejectedInboxHumanNotification(messageId, recipient);
+        return this.notify(message, recipient, notification);
+    }
+    async runPass(limit) {
+        const result = { sent: [], rejected: [], unknown: [],
+            deferred: [], suppressed: [], failed: [] };
+        let attempts = 0;
+        for (const message of this.ledger.listInboxMessages().reverse()) {
+            if (this.closing || attempts >= limit)
+                break;
+            const recipients = [...new Set([...message.to, ...message.cc])];
+            for (const recipient of recipients) {
+                if (this.closing || attempts >= limit)
+                    break;
+                if (!isUserAddress(recipient))
+                    continue;
+                const delivery = this.ledger.getInboxDelivery(message.id, recipient);
+                if (delivery?.status !== 'delivered' || delivery.handledAt !== undefined
+                    || this.ledger.getInboxHumanNotification(message.id, recipient) !== undefined)
+                    continue;
+                try {
+                    const optOut = await this.ledger.suppressInboxHumanNotificationIfOptedOut(message.id, recipient);
+                    if (optOut) {
+                        result.suppressed.push({ messageId: message.id, recipient });
+                        continue;
+                    }
+                    const decision = await this.decision(message, recipient);
+                    if (decision.action === 'defer') {
+                        result.deferred.push({ messageId: message.id, recipient });
+                        continue;
+                    }
+                    if (decision.action === 'suppress') {
+                        await this.ledger.suppressInboxHumanNotification(message.id, recipient, decision.reason);
+                        result.suppressed.push({ messageId: message.id, recipient });
+                        continue;
+                    }
+                }
+                catch (error) {
+                    result.failed.push({ messageId: message.id, recipient, error });
+                    continue;
+                }
+                let reserved;
+                try {
+                    reserved = await this.ledger.reserveInboxHumanNotification(message.id, recipient);
+                }
+                catch (error) {
+                    result.failed.push({ messageId: message.id, recipient, error });
+                    continue;
+                }
+                if (!reserved.reserved) {
+                    if (reserved.notification.status === 'suppressed') {
+                        result.suppressed.push({ messageId: message.id, recipient });
+                    }
+                    continue;
+                }
+                attempts++;
+                try {
+                    const status = await this.notify(message, recipient, reserved.notification);
+                    result[status].push({ messageId: message.id, recipient });
+                }
+                catch (error) {
+                    // The channel may have accepted the request. Leave the durable reservation unknown.
+                    result.failed.push({ messageId: message.id, recipient, error });
+                }
+            }
+        }
+        return result;
+    }
+    async decision(message, recipient) {
+        const result = await this.options.decide?.(message, recipient) ?? { action: 'send' };
+        if (result.action !== 'send' && result.action !== 'defer'
+            && (result.action !== 'suppress' || !result.reason?.trim())) {
+            throw new Error('human notification policy returned an invalid decision');
+        }
+        return result;
+    }
+    async notify(message, recipient, notification) {
+        const outcome = await this.provider.notify({
+            notificationId: notification.id, messageId: message.id,
+            recipient, role: message.to.includes(recipient) ? 'to' : 'cc',
+            fromAddress: message.fromAddress, subject: message.subject, body: message.body,
+            priority: message.priority,
+            ...(message.due !== undefined ? { due: message.due } : {}),
+            ...(message.humanAction !== undefined ? { humanAction: message.humanAction } : {}),
+        });
+        if (outcome.status === 'unknown')
+            return 'unknown';
+        const settled = await this.ledger.settleInboxHumanNotification(message.id, recipient, outcome);
+        if (settled.status === 'suppressed')
+            throw new Error('suppressed human notification cannot settle');
+        return settled.status;
+    }
+    async close() {
+        this.closing = true;
+        if (this.pass)
+            await this.pass;
+    }
+}
+//# sourceMappingURL=human-notification-runner.js.map

package/lib/human-notification-webhook.d.ts

@@ -0,0 +1,18 @@
+import type { HumanNotificationOutcome, HumanNotificationProvider, HumanNotificationRequest } from './human-notification-runner.js';
+export interface HumanNotificationWebhookOptions {
+    endpoint: string;
+    /** The host obtains a current credential from its secret store. */
+    authorization: () => string | Promise<string>;
+    timeoutMs?: number;
+    fetch?: typeof fetch;
+}
+/** Generic channel adapter: only an explicit provider receipt can confirm a push. */
+export declare class HumanNotificationWebhook implements HumanNotificationProvider {
+    private readonly options;
+    private readonly endpoint;
+    private readonly request;
+    private readonly timeoutMs;
+    constructor(options: HumanNotificationWebhookOptions);
+    notify(request: HumanNotificationRequest): Promise<HumanNotificationOutcome>;
+}
+//# sourceMappingURL=human-notification-webhook.d.ts.map

package/lib/human-notification-webhook.js

@@ -0,0 +1,102 @@
+const MAX_RESPONSE_BYTES = 64 * 1024;
+/** Generic channel adapter: only an explicit provider receipt can confirm a push. */
+export class HumanNotificationWebhook {
+    options;
+    endpoint;
+    request;
+    timeoutMs;
+    constructor(options) {
+        this.options = options;
+        const endpoint = new URL(options.endpoint);
+        if (endpoint.protocol !== 'https:' && !(endpoint.protocol === 'http:'
+            && ['localhost', '127.0.0.1', '[::1]'].includes(endpoint.hostname))) {
+            throw new Error('human notification webhook requires HTTPS or loopback HTTP');
+        }
+        if (endpoint.username || endpoint.password || endpoint.hash) {
+            throw new Error('human notification webhook endpoint cannot contain credentials or a fragment');
+        }
+        const timeoutMs = options.timeoutMs ?? 10_000;
+        if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 250 || timeoutMs > 30_000) {
+            throw new Error('human notification webhook timeout must be 250 to 30000 ms');
+        }
+        this.endpoint = endpoint;
+        this.request = options.fetch ?? fetch;
+        this.timeoutMs = timeoutMs;
+    }
+    async notify(request) {
+        const authorization = await this.options.authorization();
+        if (!authorization.trim() || /[\r\n]/.test(authorization)) {
+            throw new Error('human notification webhook credential is unavailable');
+        }
+        let response;
+        try {
+            response = await this.request(this.endpoint, {
+                method: 'POST',
+                headers: { authorization, 'content-type': 'application/json' },
+                body: JSON.stringify({ schemaVersion: 1, ...request }),
+                // Never forward the Authorization header to a redirect target.
+                redirect: 'error',
+                signal: AbortSignal.timeout(this.timeoutMs),
+            });
+        }
+        catch {
+            return { status: 'unknown' };
+        }
+        if (!response.ok) {
+            await response.body?.cancel().catch(() => undefined);
+            return { status: 'unknown' };
+        }
+        const body = await boundedJson(response);
+        if (!body || typeof body !== 'object' || Array.isArray(body))
+            return { status: 'unknown' };
+        const record = body;
+        if (record['status'] === 'sent' && typeof record['receiptId'] === 'string'
+            && record['receiptId'].trim()) {
+            return { status: 'sent', providerReceipt: record['receiptId'].trim() };
+        }
+        if (record['status'] === 'rejected' && typeof record['reason'] === 'string'
+            && record['reason'].trim()) {
+            return { status: 'rejected', reason: record['reason'].trim() };
+        }
+        return { status: 'unknown' };
+    }
+}
+async function boundedJson(response) {
+    if (!response.body)
+        return undefined;
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const item = await reader.read();
+            if (item.done)
+                break;
+            total += item.value.byteLength;
+            if (total > MAX_RESPONSE_BYTES) {
+                await reader.cancel().catch(() => undefined);
+                return undefined;
+            }
+            chunks.push(item.value);
+        }
+        const bytes = new Uint8Array(total);
+        let offset = 0;
+        for (const chunk of chunks) {
+            bytes.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+        try {
+            return JSON.parse(new TextDecoder().decode(bytes));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+//# sourceMappingURL=human-notification-webhook.js.map

package/lib/human-turn-completion.d.ts

@@ -0,0 +1,61 @@
+import { type SessionEvent, type SessionHeader, type SessionId } from '@deepseek-ai/dsh-session';
+import { z } from 'zod';
+import { type SessionBinding, type UserAddress } from './domain.js';
+import type { LearningLedger } from './ledger.js';
+declare const CandidateSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    turn: z.ZodNumber;
+}, z.core.$strict>;
+export type HumanTurnCandidate = z.infer<typeof CandidateSchema>;
+declare const DestinationSchema: z.ZodObject<{
+    recipient: z.ZodString;
+    authorityRef: z.ZodString;
+    pagePath: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type HumanTurnDestination = Omit<z.infer<typeof DestinationSchema>, 'recipient'> & {
+    recipient: UserAddress;
+};
+export interface HumanTurnCompletionSource {
+    /** A durable, paginated list of turns with a host-verified person as asker. */
+    listCandidates(after: string | undefined, limit: number): Promise<{
+        candidates: HumanTurnCandidate[];
+        nextCursor?: string;
+    }>;
+    /** Recheck the exact turn's asker and access to its conversation on every attempt. */
+    authorize(candidate: HumanTurnCandidate, binding: SessionBinding): HumanTurnDestination | undefined | Promise<HumanTurnDestination | undefined>;
+}
+export interface HumanTurnPersistence {
+    /** Read flushed Session events, including the completed turn. */
+    inspect(id: SessionId): Promise<{
+        meta: SessionHeader;
+        events: readonly SessionEvent[];
+    }>;
+}
+export interface HumanTurnCompletionPass {
+    delivered: string[];
+    existing: string[];
+    held: string[];
+    skipped: string[];
+    failed: Array<{
+        sessionId: string;
+        turn: number;
+        error: unknown;
+    }>;
+    nextCursor?: string;
+}
+/** Bridges one verified human turn into Inbox. External delivery remains a separate, opt-out-aware step. */
+export declare class HumanTurnCompletionNotifier {
+    private readonly inbox;
+    private readonly sessions;
+    private readonly source;
+    constructor(inbox: LearningLedger, sessions: HumanTurnPersistence, source: HumanTurnCompletionSource);
+    recoverBatch(after?: string, limit?: number): Promise<HumanTurnCompletionPass>;
+    notify(candidateInput: HumanTurnCandidate): Promise<'delivered' | 'existing' | 'held' | 'skipped'>;
+    private repairDelivery;
+}
+export declare function humanTurnInboxMessageId(sessionId: string, turn: number): string;
+export declare function humanTurnSubject(summary?: string): string;
+export declare function humanTurnBody(summary?: string): string;
+export {};
+//# sourceMappingURL=human-turn-completion.d.ts.map