@north-light/crouter 0.3.312 → 0.3.313

package/dist/daemon/review/deliver.d.ts

@@ -1,7 +1,3 @@
 import type { ReviewRecord } from '../../core/review/types.js';
-/** Render the immutable approval fact without replaying comment text. */
+/** Render the immutable approval fact for the direct outbox notification. */
 export declare function renderApprovalMessage(review: ReviewRecord, resultPath: string): string;
-/** Deliver an approval through its origin-specific canonical route. */
-export declare function deliverApproval(review: ReviewRecord, resultPath: string): Promise<{
-    receipt: string | null;
-}>;

package/dist/daemon/review/deliver.js

@@ -1,57 +1,8 @@
-import { FinalizationError, pushFinal, redeliverFinalReport } from '../../core/feed/feed.js';
 import { formatCard } from '../../shared/generated-context.js';
-import { deliverNodeMessage } from '../messaging/node-message.js';
-function approvalBody(review, resultPath) {
+/** Render the immutable approval fact for the direct outbox notification. */
+export function renderApprovalMessage(review, resultPath) {
     const summary = review.changed
         ? `The user reviewed and approved \`${review.file}\`. The document changed during review; re-read it before continuing. Review conversation: node \`${review.companion_node_id}\`.`
         : `The user reviewed and approved \`${review.file}\`. The document was not modified.`;
-    return `${summary}\n\nDurable review result: ${resultPath}`;
-}
-/** Render the immutable approval fact without replaying comment text. */
-export function renderApprovalMessage(review, resultPath) {
-    return formatCard('review-approval', {}, approvalBody(review, resultPath));
-}
-function recordedFailedFanout(review, reportBasename) {
-    const error = review.delivery_error;
-    if (error === null || !error.includes(reportBasename))
-        return false;
-    const failed = /delivery failed for (.+)$/.exec(error)?.[1]?.split(', ') ?? [];
-    return failed.includes(review.origin_node_id);
-}
-/** Deliver an approval through its origin-specific canonical route. */
-export async function deliverApproval(review, resultPath) {
-    const body = renderApprovalMessage(review, resultPath);
-    if (review.origin_kind === 'inline') {
-        const delivery = await deliverNodeMessage({
-            node_id: review.origin_node_id,
-            body,
-            label: 'review approved by the user',
-            from: 'crtrd',
-            mode: 'interactive',
-            data: { review_id: review.review_id, result_path: resultPath },
-        });
-        return { receipt: delivery.entry_id };
-    }
-    if (review.bridge_node_id === null) {
-        throw new Error(`ticket review ${review.review_id} has no bridge node`);
-    }
-    try {
-        const result = await pushFinal(review.bridge_node_id, body);
-        return { receipt: result.reportPath.split('/').at(-1) ?? null };
-    }
-    catch (error) {
-        if (!(error instanceof FinalizationError) || error.code !== 'already_finalized')
-            throw error;
-        const reportBasename = error.reportPath;
-        if (reportBasename === undefined)
-            throw error;
-        // A committed final with no failed-delivery ledger is the crash window
-        // after a successful fanout and before the review ledger was marked.
-        if (review.delivery_error === null)
-            return { receipt: reportBasename };
-        if (!recordedFailedFanout(review, reportBasename))
-            throw error;
-        const result = redeliverFinalReport(review.bridge_node_id, review.origin_node_id, reportBasename, body);
-        return { receipt: result.reportPath.split('/').at(-1) ?? null };
-    }
+    return formatCard('review-approval', {}, `${summary}\n\nDurable review result: ${resultPath}`);
 }

package/dist/daemon/review/finish.d.ts

@@ -1,12 +1,9 @@
-import type { TicketResult } from '../../core/human/types.js';
 import { type ReviewRecord, type ReviewResult } from '../../core/review/types.js';
 export interface ReviewApprovalFinishOutcome {
     outcome: 'settled' | 'already_settled';
     record: ReviewRecord;
     result: ReviewResult;
 }
-/** The human submitted while the companion was still working. The review stays
- *  open and the daemon completes the approval once the companion goes quiet. */
 export interface ReviewSubmitDeferredOutcome {
     outcome: 'awaiting_companion';
     record: ReviewRecord;
@@ -15,38 +12,16 @@ export type ReviewSubmitOutcome = ReviewApprovalFinishOutcome | ReviewSubmitDefe
 export interface ReviewCancellationFinishOutcome {
     outcome: 'settled' | 'already_settled';
     record: ReviewRecord;
-    ticket_result?: TicketResult;
 }
 export type ReviewFinishOutcome = ReviewApprovalFinishOutcome | ReviewCancellationFinishOutcome;
-/** Approve on the human's behalf, waiting first when the companion is still
- *  working. Waiting is the only new outcome: an idle companion approves in the
- *  same pass it always did, and the wait never freezes the review — comments
- *  added during it are in the snapshot, because the snapshot happens at
- *  completion and the review is still open. */
 export declare function submitReviewApproval(reviewId: string): Promise<ReviewSubmitOutcome>;
-/** Complete a submit the human already pressed, once its companion is quiet.
- *  Returns null when there is nothing to complete — no pending intent, the
- *  review moved on, or the companion is still working. Idempotent: concurrent
- *  callers race on the same conditional `state = 'open'` approval write, so
- *  only one can win and the loser reports what the winner committed.
- *
- *  `atCompanionTurnEnd` marks the one caller that IS the companion's turn end.
- *  There the mid-turn marker may not be cleared yet, so it is not consulted;
- *  queued work still defers, because an inbox entry means another turn is
- *  coming and the wait should outlast it. */
 export declare function completeRequestedSubmit(reviewId: string, opts: {
     atCompanionTurnEnd: boolean;
 }): Promise<ReviewApprovalFinishOutcome | null>;
-/** The companion's turn ended: complete any submit the human left waiting on
- *  it. Never throws — a settlement directive must not depend on delivery. */
-export declare function completeCompanionRequestedSubmit(companionNodeId: string): Promise<void>;
-/** `disposition` rides through to the ticket result: the recipient closing a
- * review in their inbox is a dismissal, while the requester withdrawing it
- * stays a cancellation. */
+export declare function completeCompanionRequestedSubmit(companionNodeId: string): Promise<ReviewApprovalFinishOutcome | null>;
 export interface ReviewCancellationArgs {
     reason?: string;
     actor?: string;
     disposition?: 'canceled' | 'dismissed';
 }
-/** Cancel an open review once; ticket cancellation remains owned by the retained human-ticket finisher. */
-export declare function cancelReview(reviewId: string, args: ReviewCancellationArgs): Promise<ReviewCancellationFinishOutcome>;
+export declare function cancelReview(reviewId: string, args?: ReviewCancellationArgs): Promise<ReviewCancellationFinishOutcome>;

package/dist/daemon/review/finish.js

@@ -1,265 +1,86 @@
 import { withCanvasWrite } from '../../core/canvas/db.js';
-import { responsePath } from '../../core/human/convention.js';
-import { ticketDir } from '../../core/human/root.js';
-import { readTicketResult } from '../../core/human/tickets.js';
-import { projectReviewResult, buildReviewResult } from '../../core/review/project.js';
-import { reviewResultPath } from '../../core/canvas/paths.js';
 import { snapshotCommentsLocked } from '../../core/review/comments.js';
 import { readReviewSource } from '../../core/review/document.js';
+import { projectReviewCancellation, projectReviewResult, buildReviewResult } from '../../core/review/project.js';
 import { signalReviewActivity } from '../../core/review/signal.js';
-import { approveReviewLocked, cancelReviewRow, getReview, getReviewByCompanion, markDelivered, markDeliveryError, markProjected, markProjectionError, requestReviewSubmit, requireVisibleReview, } from '../../core/review/store.js';
+import { getReview, getReviewByCompanion, requestReviewSubmit, requireVisibleReview } from '../../core/review/store.js';
 import { ReviewOperationError } from '../../core/review/types.js';
-import { cancelPendingEntries } from '../../core/feed/inbox.js';
-import { emitEvent } from '../../core/events/emit.js';
+import { settleHumanRequest } from '../human/settle.js';
 import { retireCompanion } from '../companion-retire.js';
-import { deliverNodeMessage } from '../messaging/node-message.js';
-import { cancelHumanTicket, deliverTerminalResult } from '../human/finish.js';
 import { companionHasQueuedWork, companionMidTurn, companionStillWorking } from './companion.js';
-import { deliverApproval } from './deliver.js';
-/** One daemon serializes terminal side effects for each immutable review row. */
-const finishChains = new Map();
-function now() {
-    return new Date().toISOString();
-}
-function errorText(error) {
-    return error instanceof Error ? error.message : String(error);
-}
+import { renderApprovalMessage } from './deliver.js';
+function now() { return new Date().toISOString(); }
 function terminalConflict(review, requested) {
-    throw new ReviewOperationError('review_terminal', 'review already has a terminal outcome', {
-        state: review.state,
-        requested,
-        review,
-    });
+    throw new ReviewOperationError('review_terminal', 'review already has a terminal outcome', { state: review.state, requested, review });
 }
 function approvedResult(review) {
     if (review.result_json === null)
         throw new Error(`approved review lacks its immutable result: ${review.review_id}`);
     return JSON.parse(review.result_json);
 }
-function resultPath(review) {
-    if (review.origin_kind === 'inline')
-        return reviewResultPath(review.review_id);
-    if (review.bridge_node_id === null)
-        throw new Error(`ticket review lacks its bridge node: ${review.review_id}`);
-    return responsePath(ticketDir(review.bridge_node_id));
-}
-function ticketResult(review) {
-    return review.origin_kind === 'ticket' && review.bridge_node_id !== null
-        ? readTicketResult(ticketDir(review.bridge_node_id)) ?? undefined
-        : undefined;
-}
-function isPostReplayAlreadyResolved(error) {
-    return error instanceof Error
-        && 'status' in error
-        && error.status === 409
-        && 'code' in error
-        && error.code === 'ticket_already_resolved';
-}
-async function serializedFinish(reviewId, work) {
-    const prior = finishChains.get(reviewId) ?? Promise.resolve();
-    const run = prior.catch(() => { }).then(work);
-    const tail = run.then(() => { }, () => { });
-    finishChains.set(reviewId, tail);
-    try {
-        return await run;
-    }
-    finally {
-        if (finishChains.get(reviewId) === tail)
-            finishChains.delete(reviewId);
-    }
-}
-async function finishApproved(review, result) {
-    retractSubmitQueuedNote(review);
-    let current = requireVisibleReview(review.review_id);
-    if (current.projected_at === null) {
-        try {
-            projectReviewResult(current, result);
-            markProjected(current.review_id, now());
-        }
-        catch (error) {
-            markProjectionError(current.review_id, errorText(error));
-        }
-    }
-    current = requireVisibleReview(review.review_id);
-    if (current.delivered_at === null) {
-        try {
-            const delivery = await deliverApproval(current, resultPath(current));
-            markDelivered(current.review_id, delivery.receipt, now());
-        }
-        catch (error) {
-            markDeliveryError(current.review_id, errorText(error));
-        }
-    }
-    current = requireVisibleReview(review.review_id);
-    await retireCompanion(current.companion_node_id, 'approved');
-    return requireVisibleReview(review.review_id);
-}
-async function finishCanceled(review, winningWrite, args) {
-    retractSubmitQueuedNote(review);
-    let current = requireVisibleReview(review.review_id);
-    let canceledTicket;
-    if (current.origin_kind === 'inline') {
-        if (current.projected_at === null)
-            markProjected(current.review_id, now());
-        current = requireVisibleReview(review.review_id);
-        if (current.delivered_at === null)
-            markDelivered(current.review_id, null, now());
-    }
-    else if (current.bridge_node_id === null) {
-        markProjectionError(current.review_id, `ticket review lacks its bridge node: ${current.review_id}`);
-        markDeliveryError(current.review_id, `ticket review lacks its bridge node: ${current.review_id}`);
-    }
-    else if (current.delivered_at === null) {
-        try {
-            if (winningWrite) {
-                canceledTicket = await cancelHumanTicket(current.bridge_node_id, args);
-            }
-            else {
-                const delivered = await deliverTerminalResult(current.bridge_node_id);
-                if (!delivered)
-                    throw new Error(`ticket cancellation is not available for delivery: ${current.bridge_node_id}`);
-                canceledTicket = ticketResult(current);
-            }
-            if (canceledTicket === undefined)
-                throw new Error(`ticket cancellation result is missing: ${current.bridge_node_id}`);
-            markProjected(current.review_id, now());
-            markDelivered(current.review_id, null, now());
-        }
-        catch (error) {
-            if (winningWrite && isPostReplayAlreadyResolved(error)) {
-                try {
-                    const delivered = await deliverTerminalResult(current.bridge_node_id);
-                    if (!delivered)
-                        throw new Error(`ticket cancellation is not available for delivery: ${current.bridge_node_id}`);
-                    canceledTicket = ticketResult(current);
-                    if (canceledTicket === undefined)
-                        throw new Error(`ticket cancellation result is missing: ${current.bridge_node_id}`);
-                    markProjected(current.review_id, now());
-                    markDelivered(current.review_id, null, now());
-                }
-                catch (replayError) {
-                    markDeliveryError(current.review_id, errorText(replayError));
-                }
-            }
-            else {
-                // cancelHumanTicket publishes response.json before fanout. Preserve that
-                // publication ledger even when the retained delivery path reports a failure.
-                if (ticketResult(current) !== undefined)
-                    markProjected(current.review_id, now());
-                markDeliveryError(current.review_id, errorText(error));
-            }
-        }
-    }
-    current = requireVisibleReview(review.review_id);
-    if (canceledTicket === undefined)
-        canceledTicket = ticketResult(current);
-    await retireCompanion(current.companion_node_id, 'canceled');
-    return { record: requireVisibleReview(review.review_id), ...(canceledTicket === undefined ? {} : { ticket_result: canceledTicket }) };
-}
-const SUBMIT_QUEUED_NOTE = 'review-submit-queued';
-/** Retract an undelivered queued-submit note once the review is settling. The
- *  note rides the deferred tier and so does not wake the origin, while the
- *  terminal result goes live — without this the origin reads "result to
- *  follow" only after it already acted on that result. */
-function retractSubmitQueuedNote(review) {
-    try {
-        cancelPendingEntries(review.origin_node_id, (entry) => entry.kind === 'message'
-            && entry.data?.['note'] === SUBMIT_QUEUED_NOTE
-            && entry.data?.['review_id'] === review.review_id);
-    }
-    catch (error) {
-        emitEvent({ level: 'warn', event: 'review.submit_queued_note.retract_failed', error });
-    }
+function resultPath(review) { return `${review.review_dir}/result.json`; }
+function effects(result) {
+    return {
+        project: (request) => { projectReviewResult(requireVisibleReview(request.request_id), result); },
+        retire: async (nodeId, outcome) => { await retireCompanion(nodeId, outcome); },
+    };
 }
-/** Tell the origin its review was submitted but is finishing behind the
- *  companion. Deliberately deferred: the origin is told nothing is needed of
- *  it, so waking it to say so would be noise. The approval itself wakes it. */
-async function noteSubmitQueued(review) {
-    try {
-        await deliverNodeMessage({
-            node_id: review.origin_node_id,
-            from: 'crtrd',
-            mode: 'quiet',
-            label: 'human review submitted — result to follow',
-            data: { review_id: review.review_id, note: SUBMIT_QUEUED_NOTE },
-            runtime: { kind: 'review-queued', facts: {} },
-            body: `The human submitted their review of \`${review.file}\`; the document is still being edited. `
-                + "You'll be notified with the result once the review completes. Nothing is needed from you now.",
-        });
-    }
-    catch (error) {
-        emitEvent({ level: 'warn', event: 'review.submit_queued_note.failed', error });
-    }
+function approvalNotification(review) {
+    return {
+        label: 'review approved by the user',
+        disposition: 'human-answer',
+        body_json: { review_id: review.review_id, result_path: resultPath(review), body: renderApprovalMessage(review, resultPath(review)) },
+    };
 }
-/** Approve on the human's behalf, waiting first when the companion is still
- *  working. Waiting is the only new outcome: an idle companion approves in the
- *  same pass it always did, and the wait never freezes the review — comments
- *  added during it are in the snapshot, because the snapshot happens at
- *  completion and the review is still open. */
-export async function submitReviewApproval(reviewId) {
-    const initial = requireVisibleReview(reviewId);
-    if (initial.state === 'canceled')
-        return terminalConflict(initial, 'submit');
-    if (initial.state === 'open' && companionStillWorking(initial.companion_node_id)) {
-        if (requestReviewSubmit(reviewId, now())) {
-            signalReviewActivity();
-            await noteSubmitQueued(initial);
-        }
-        return { outcome: 'awaiting_companion', record: requireVisibleReview(reviewId) };
-    }
-    return await approveReview(initial);
+function cancellationNotification(review, reason, disposition) {
+    const dismissed = disposition === 'dismissed';
+    return {
+        label: dismissed ? 'review dismissed' : 'review canceled',
+        disposition: 'human-canceled',
+        body_json: { review_id: review.review_id, disposition, body: dismissed ? `The review of \`${review.file}\` was dismissed without approval.` : `The review of \`${review.file}\` was canceled${reason === '' ? '' : ` — ${reason}`}.` },
+    };
 }
-/** Commit approval once, then independently finish its projection, delivery, and companion retirement ledgers. */
 async function approveReview(initial) {
-    const reviewId = initial.review_id;
     if (initial.state === 'canceled')
         return terminalConflict(initial, 'submit');
-    if (initial.state === 'approved') {
-        const result = approvedResult(initial);
-        const record = await serializedFinish(reviewId, () => finishApproved(initial, result));
-        return { outcome: 'already_settled', record, result };
-    }
+    if (initial.state === 'approved')
+        return { outcome: 'already_settled', record: initial, result: approvedResult(initial) };
     const source = readReviewSource(initial.file, 'submit');
-    const committed = withCanvasWrite((db) => {
-        const review = requireVisibleReview(reviewId);
+    const { result, resultJson } = withCanvasWrite((db) => {
+        const review = requireVisibleReview(initial.review_id);
         if (review.state === 'canceled')
             return terminalConflict(review, 'submit');
         if (review.state === 'approved')
-            return { outcome: 'already_settled', review, result: approvedResult(review) };
-        const snapshot = snapshotCommentsLocked(db, reviewId);
-        const at = now();
-        const result = buildReviewResult(review, snapshot, source.sha256, at);
-        if (!approveReviewLocked(db, {
-            review_id: reviewId,
-            approved_at: at,
-            approved_sha256: source.sha256,
-            changed: result.changed,
-            comments_total: snapshot.total,
-            comments_unresolved: snapshot.unresolved,
-            result_json: JSON.stringify(result),
-        })) {
-            const winner = requireVisibleReview(reviewId);
-            if (winner.state === 'approved')
-                return { outcome: 'already_settled', review: winner, result: approvedResult(winner) };
-            return terminalConflict(winner, 'submit');
-        }
-        return { outcome: 'settled', review: requireVisibleReview(reviewId), result };
+            return { result: approvedResult(review), resultJson: review.result_json };
+        const snapshot = snapshotCommentsLocked(db, review.review_id);
+        const result = buildReviewResult(review, snapshot, source.sha256, now());
+        return { result, resultJson: JSON.stringify(result) };
+    });
+    const settled = await settleHumanRequest({
+        request_id: initial.review_id,
+        outcome: 'approved',
+        result_json: resultJson,
+        notification: approvalNotification({ ...initial, changed: result.changed }),
+        post_commit: effects(result),
     });
-    if (committed.outcome === 'settled')
+    if (settled.outcome === 'settled')
         signalReviewActivity();
-    const record = await serializedFinish(reviewId, () => finishApproved(committed.review, committed.result));
-    return { outcome: committed.outcome, record, result: committed.result };
+    const record = requireVisibleReview(initial.review_id);
+    if (settled.outcome === 'already_settled' && record.state !== 'approved')
+        return terminalConflict(record, 'submit');
+    return { outcome: settled.outcome, record, result: settled.outcome === 'settled' ? result : approvedResult(record) };
+}
+export async function submitReviewApproval(reviewId) {
+    const review = requireVisibleReview(reviewId);
+    if (review.state === 'canceled')
+        return terminalConflict(review, 'submit');
+    if (review.state === 'open' && companionStillWorking(review.companion_node_id)) {
+        if (requestReviewSubmit(reviewId, now()))
+            signalReviewActivity();
+        return { outcome: 'awaiting_companion', record: requireVisibleReview(reviewId) };
+    }
+    return approveReview(review);
 }
-/** Complete a submit the human already pressed, once its companion is quiet.
- *  Returns null when there is nothing to complete — no pending intent, the
- *  review moved on, or the companion is still working. Idempotent: concurrent
- *  callers race on the same conditional `state = 'open'` approval write, so
- *  only one can win and the loser reports what the winner committed.
- *
- *  `atCompanionTurnEnd` marks the one caller that IS the companion's turn end.
- *  There the mid-turn marker may not be cleared yet, so it is not consulted;
- *  queued work still defers, because an inbox entry means another turn is
- *  coming and the wait should outlast it. */
 export async function completeRequestedSubmit(reviewId, opts) {
     const review = getReview(reviewId);
     if (review === null || review.state !== 'open' || review.submit_requested_at === null)
@@ -268,39 +89,34 @@ export async function completeRequestedSubmit(reviewId, opts) {
         return null;
     if (!opts.atCompanionTurnEnd && companionMidTurn(review.companion_node_id))
         return null;
-    return await approveReview(review);
+    return approveReview(review);
 }
-/** The companion's turn ended: complete any submit the human left waiting on
- *  it. Never throws — a settlement directive must not depend on delivery. */
 export async function completeCompanionRequestedSubmit(companionNodeId) {
-    try {
-        const review = getReviewByCompanion(companionNodeId);
-        if (review === null || review.state !== 'open' || review.submit_requested_at === null)
-            return;
-        await completeRequestedSubmit(review.review_id, { atCompanionTurnEnd: true });
-    }
-    catch (error) {
-        emitEvent({ level: 'error', event: 'review.deferred_submit.failed', error });
-    }
+    const review = getReviewByCompanion(companionNodeId);
+    return review === null ? null : completeRequestedSubmit(review.review_id, { atCompanionTurnEnd: true });
 }
-/** Cancel an open review once; ticket cancellation remains owned by the retained human-ticket finisher. */
-export async function cancelReview(reviewId, args) {
-    const initial = requireVisibleReview(reviewId);
-    if (initial.state === 'approved')
-        return terminalConflict(initial, 'cancel');
-    const winningWrite = initial.state === 'open'
-        && cancelReviewRow(reviewId, { at: now(), reason: args.reason ?? '', actor: args.actor ?? null });
+export async function cancelReview(reviewId, args = {}) {
     const review = requireVisibleReview(reviewId);
     if (review.state === 'approved')
         return terminalConflict(review, 'cancel');
-    if (review.state !== 'canceled')
-        throw new Error(`review ${reviewId} did not reach its canceled state`);
-    if (winningWrite)
+    const at = now();
+    const reason = args.reason ?? '';
+    const disposition = args.disposition ?? 'canceled';
+    const resultJson = JSON.stringify({ schema: 'humanloop.cancel/v1', kind: 'canceled', canceledAt: at, ...(reason === '' ? {} : { reason }), ...(args.actor === undefined ? {} : { actor: args.actor }), ...(disposition === 'dismissed' ? { disposition } : {}) });
+    const settled = await settleHumanRequest({
+        request_id: reviewId,
+        outcome: disposition === 'dismissed' ? 'dismissed' : 'canceled',
+        result_json: resultJson,
+        notification: cancellationNotification(review, reason, disposition),
+        post_commit: {
+            project: (request) => { projectReviewCancellation(requireVisibleReview(request.request_id), JSON.parse(resultJson)); },
+            retire: async (nodeId, outcome) => { await retireCompanion(nodeId, outcome); },
+        },
+    });
+    if (settled.outcome === 'settled')
         signalReviewActivity();
-    const finished = await serializedFinish(reviewId, () => finishCanceled(review, winningWrite, args));
-    return {
-        outcome: winningWrite ? 'settled' : 'already_settled',
-        record: finished.record,
-        ...(finished.ticket_result === undefined ? {} : { ticket_result: finished.ticket_result }),
-    };
+    const record = requireVisibleReview(reviewId);
+    if (settled.outcome === 'already_settled' && record.state === 'approved')
+        return terminalConflict(record, 'cancel');
+    return { outcome: settled.outcome, record };
 }

package/dist/daemon/review/sweep.d.ts

@@ -1,11 +1,4 @@
-export interface ReviewSweepResult {
-    realized: number;
-    collected: number;
-    reprojected: number;
-    failed: number;
-}
-/**
- * Recover only pre-exposure review work at daemon startup. Terminal delivery and
- * retirement are intentionally outside this pass and require an explicit repeat.
- */
+import { type HumanRequestSweepResult } from '../human/sweep.js';
+export type ReviewSweepResult = HumanRequestSweepResult;
+/** Compatibility entry point for daemon boot. All recovery is driven by human_requests. */
 export declare function sweepReviews(): Promise<ReviewSweepResult>;