@north-light/crouter 0.3.170 → 0.3.172

package/dist/core/review/stage.d.ts

@@ -0,0 +1,26 @@
+import { type NewReviewRow, type ReviewOriginKind, type ReviewRecord } from './types.js';
+export interface StageReviewArgs {
+    origin_kind: ReviewOriginKind;
+    origin_node_id: string;
+    file: string;
+    idempotency_key: string;
+    subtitle?: string;
+    output_path?: string;
+}
+/** A persisted winner needs realization, while a new stage has unreferenced filesystem state to commit or discard. */
+export type StagedReview = {
+    existing: ReviewRecord;
+    row?: never;
+    review_dir?: never;
+} | {
+    existing?: never;
+    row: NewReviewRow;
+    review_dir: string;
+};
+/** Remove only review-directory state that was never committed to a review row. */
+export declare function discardStaging(reviewId: string): void;
+/**
+ * Capture an existing origin and write its immutable branch without creating a
+ * canvas node or review row. The caller alone commits or discards this stage.
+ */
+export declare function stageReview(args: StageReviewArgs): Promise<StagedReview>;

package/dist/core/review/stage.js

@@ -0,0 +1,184 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, realpathSync, rmSync, statSync } from 'node:fs';
+import { isAbsolute } from 'node:path';
+import { getNode } from '../canvas/index.js';
+import { ensureReviewDir, reviewBranchPath, reviewDir } from '../canvas/paths.js';
+import { checkReviewableFile } from '../human/visible-paths.js';
+import { newNodeId } from '../runtime/nodes.js';
+import { captureOrigin, materializeReviewBranch } from './companion.js';
+import { getReviewByIdempotencyKey } from './store.js';
+import { ReviewOperationError, } from './types.js';
+function targetError(file, reason) {
+    return new ReviewOperationError('review_target_unreviewable', 'review target cannot be staged', {
+        phase: 'create',
+        file,
+        reason,
+    });
+}
+function validateReviewFile(file) {
+    if (!isAbsolute(file))
+        throw targetError(file, 'not_absolute');
+    if (!existsSync(file))
+        throw targetError(file, 'missing');
+    try {
+        if (!statSync(file).isFile())
+            throw targetError(file, 'not_a_file');
+    }
+    catch (error) {
+        if (error instanceof ReviewOperationError)
+            throw error;
+        throw targetError(file, 'missing');
+    }
+    const reviewable = checkReviewableFile(file);
+    if (!reviewable.ok) {
+        const reason = reviewable.reason === 'file is not UTF-8 text'
+            ? 'binary'
+            : reviewable.reason === 'file is too large to review (2 MB limit)'
+                ? 'too_large'
+                : reviewable.reason === 'file is too long to review (5,000 line limit)'
+                    ? 'too_many_lines'
+                    : 'not_a_file';
+        throw targetError(file, reason);
+    }
+    try {
+        return realpathSync(file);
+    }
+    catch {
+        throw targetError(file, 'missing');
+    }
+}
+function sessionIdentityChanged(error) {
+    // R6 materializes through materializeSessionBranchAt(), whose only identity-race
+    // signal is this precise error. Other branch errors must not trigger recapture.
+    return error instanceof Error && error.message === 'source session id does not match captured coordinates';
+}
+function branchUnavailable(originNodeId) {
+    return new ReviewOperationError('review_branch_unavailable', 'review branch could not be materialized', {
+        reason: 'materialize_failed',
+        origin_node_id: originNodeId,
+    });
+}
+async function captureStagedOrigin(originNodeId) {
+    try {
+        return await captureOrigin(originNodeId);
+    }
+    catch (error) {
+        if (error instanceof ReviewOperationError && error.code === 'review_origin_missing') {
+            throw new ReviewOperationError('review_origin_missing', 'review origin was not found', {
+                origin_node_id: originNodeId,
+                reason: 'origin_missing',
+            });
+        }
+        throw error;
+    }
+}
+function originUnstable(originNodeId) {
+    return new ReviewOperationError('review_origin_unstable', 'review origin changed sessions while staging', { origin_node_id: originNodeId });
+}
+function materializeWithOneRecapture(reviewId, originNodeId, capture, initialCapturedAt) {
+    return (async () => {
+        let current = capture;
+        let capturedAt = initialCapturedAt;
+        try {
+            materializeReviewBranch(reviewId, current);
+            return { capture: current, capturedAt };
+        }
+        catch (error) {
+            if (!sessionIdentityChanged(error))
+                throw branchUnavailable(originNodeId);
+        }
+        current = await captureStagedOrigin(originNodeId);
+        capturedAt = new Date().toISOString();
+        try {
+            materializeReviewBranch(reviewId, current);
+            return { capture: current, capturedAt };
+        }
+        catch (error) {
+            if (sessionIdentityChanged(error))
+                throw originUnstable(originNodeId);
+            throw branchUnavailable(originNodeId);
+        }
+    })();
+}
+/** Remove only review-directory state that was never committed to a review row. */
+export function discardStaging(reviewId) {
+    try {
+        rmSync(reviewDir(reviewId), { recursive: true, force: true });
+    }
+    catch {
+        // Startup collection handles residue that cannot be removed in this process.
+    }
+}
+/**
+ * Capture an existing origin and write its immutable branch without creating a
+ * canvas node or review row. The caller alone commits or discards this stage.
+ */
+export async function stageReview(args) {
+    const existing = getReviewByIdempotencyKey(args.idempotency_key);
+    if (existing !== null)
+        return { existing };
+    if (getNode(args.origin_node_id) === null) {
+        throw new ReviewOperationError('review_origin_missing', 'review origin was not found', {
+            origin_node_id: args.origin_node_id,
+            reason: 'origin_missing',
+        });
+    }
+    const file = validateReviewFile(args.file);
+    const reviewId = newNodeId();
+    const companionNodeId = newNodeId();
+    try {
+        ensureReviewDir(reviewId);
+        const initialCapture = await captureStagedOrigin(args.origin_node_id);
+        const initialCapturedAt = new Date().toISOString();
+        const bytes = readFileSync(file);
+        const sha256 = createHash('sha256').update(bytes).digest('hex');
+        const { capture, capturedAt } = await materializeWithOneRecapture(reviewId, args.origin_node_id, initialCapture, initialCapturedAt);
+        const created = new Date().toISOString();
+        return {
+            row: {
+                review_id: reviewId,
+                idempotency_key: args.idempotency_key,
+                origin_kind: args.origin_kind,
+                origin_node_id: args.origin_node_id,
+                bridge_node_id: null,
+                companion_node_id: companionNodeId,
+                review_dir: reviewDir(reviewId),
+                file,
+                origin_session_file: capture.sourceFile,
+                origin_session_id: capture.sourceSessionId,
+                origin_leaf_id: capture.leafId,
+                model_spec: capture.modelSpec,
+                branch_file: reviewBranchPath(reviewId),
+                baseline_sha256: sha256,
+                baseline_bytes: bytes.length,
+                anchor_base_sha256: sha256,
+                anchor_base_bytes: bytes,
+                state: 'binding',
+                created,
+                captured_at: capturedAt,
+                opened_at: null,
+                output_path: args.output_path ?? null,
+                subtitle: args.subtitle ?? null,
+                approved_at: null,
+                approved_sha256: null,
+                changed: null,
+                comments_total: null,
+                comments_unresolved: null,
+                result_json: null,
+                canceled_at: null,
+                cancel_reason: null,
+                cancel_actor: null,
+                delivery_entry_id: null,
+                delivered_at: null,
+                delivery_error: null,
+                projected_at: null,
+                projection_error: null,
+            },
+            review_dir: reviewDir(reviewId),
+        };
+    }
+    catch (error) {
+        discardStaging(reviewId);
+        throw error;
+    }
+}

package/dist/core/review/store.d.ts

@@ -0,0 +1,46 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { NewReviewRow, ReviewRecord, ReviewState } from './types.js';
+/** Fields written when an open review is conditionally approved. */
+export interface ApproveReviewArgs {
+    review_id: string;
+    approved_at: string;
+    approved_sha256: string;
+    changed: boolean;
+    comments_total: number;
+    comments_unresolved: number;
+    result_json: string;
+}
+export declare function mintReviewId(): string;
+/** Atomically claim the idempotency key, without publishing any non-SQLite state. */
+export declare function commitBindingReview(row: NewReviewRow): {
+    review_id: string;
+    won: boolean;
+};
+export declare function getReview(reviewId: string): ReviewRecord | null;
+export declare function getReviewByIdempotencyKey(key: string): ReviewRecord | null;
+export declare function getReviewByCompanion(nodeId: string): ReviewRecord | null;
+export declare function getReviewByBridge(nodeId: string): ReviewRecord | null;
+export declare function listReviews(filter: {
+    state?: ReviewState;
+    origin_node_id?: string;
+    file?: string;
+}): ReviewRecord[];
+export declare function listBindingReviews(): ReviewRecord[];
+export declare function listUnprojectedTerminalReviews(): ReviewRecord[];
+export declare function bindBridgeNode(reviewId: string, bridgeNodeId: string): boolean;
+export declare function openReviewRow(reviewId: string, openedAt: string): boolean;
+export declare function approveReviewLocked(db: DatabaseSync, args: ApproveReviewArgs): boolean;
+export declare function cancelReviewRow(reviewId: string, args: {
+    at: string;
+    reason: string;
+    actor: string | null;
+}): boolean;
+export declare function markProjected(reviewId: string, at: string): void;
+export declare function markProjectionError(reviewId: string, error: string): void;
+export declare function markDelivered(reviewId: string, receipt: string | null, at: string): void;
+export declare function markDeliveryError(reviewId: string, error: string): void;
+export declare function readAnchorBase(reviewId: string): {
+    bytes: Buffer;
+    sha256: string;
+} | null;
+export declare function replaceAnchorBaseLocked(db: DatabaseSync, reviewId: string, bytes: Buffer, sha256: string): void;

package/dist/core/review/store.js

@@ -0,0 +1,163 @@
+import { existsSync } from 'node:fs';
+import { newNodeId } from '../runtime/nodes.js';
+import { openDb, withCanvasWrite } from '../canvas/db.js';
+function recordFromRow(raw) {
+    return {
+        review_id: raw['review_id'],
+        idempotency_key: raw['idempotency_key'],
+        origin_kind: raw['origin_kind'],
+        origin_node_id: raw['origin_node_id'],
+        bridge_node_id: raw['bridge_node_id'] ?? null,
+        companion_node_id: raw['companion_node_id'],
+        review_dir: raw['review_dir'],
+        file: raw['file'],
+        origin_session_file: raw['origin_session_file'],
+        origin_session_id: raw['origin_session_id'],
+        origin_leaf_id: raw['origin_leaf_id'],
+        model_spec: raw['model_spec'],
+        branch_file: raw['branch_file'],
+        baseline_sha256: raw['baseline_sha256'],
+        baseline_bytes: raw['baseline_bytes'],
+        anchor_base_sha256: raw['anchor_base_sha256'],
+        state: raw['state'],
+        created: raw['created'],
+        captured_at: raw['captured_at'],
+        opened_at: raw['opened_at'] ?? null,
+        output_path: raw['output_path'] ?? null,
+        subtitle: raw['subtitle'] ?? null,
+        approved_at: raw['approved_at'] ?? null,
+        approved_sha256: raw['approved_sha256'] ?? null,
+        changed: raw['changed'] === null || raw['changed'] === undefined ? null : raw['changed'] !== 0,
+        comments_total: raw['comments_total'] ?? null,
+        comments_unresolved: raw['comments_unresolved'] ?? null,
+        result_json: raw['result_json'] ?? null,
+        canceled_at: raw['canceled_at'] ?? null,
+        cancel_reason: raw['cancel_reason'] ?? null,
+        cancel_actor: raw['cancel_actor'] ?? null,
+        delivery_entry_id: raw['delivery_entry_id'] ?? null,
+        delivered_at: raw['delivered_at'] ?? null,
+        delivery_error: raw['delivery_error'] ?? null,
+        projected_at: raw['projected_at'] ?? null,
+        projection_error: raw['projection_error'] ?? null,
+        source_missing: !existsSync(raw['file']),
+    };
+}
+function readRecord(db, where, ...params) {
+    const raw = db.prepare(`SELECT * FROM reviews WHERE ${where}`).get(...params);
+    return raw === undefined ? null : recordFromRow(raw);
+}
+function readRecords(db, where, ...params) {
+    const rows = db.prepare(`SELECT * FROM reviews WHERE ${where} ORDER BY created ASC, review_id ASC`).all(...params);
+    return rows.map(recordFromRow);
+}
+export function mintReviewId() {
+    return newNodeId();
+}
+/** Atomically claim the idempotency key, without publishing any non-SQLite state. */
+export function commitBindingReview(row) {
+    return withCanvasWrite((db) => {
+        const inserted = db.prepare(`
+      INSERT INTO reviews (
+        review_id, idempotency_key, origin_kind, origin_node_id, bridge_node_id,
+        companion_node_id, review_dir, file, origin_session_file, origin_session_id,
+        origin_leaf_id, model_spec, branch_file, baseline_sha256, baseline_bytes,
+        anchor_base_sha256, anchor_base_bytes, state, created, captured_at, opened_at,
+        output_path, subtitle, approved_at, approved_sha256, changed, comments_total,
+        comments_unresolved, result_json, canceled_at, cancel_reason, cancel_actor,
+        delivery_entry_id, delivered_at, delivery_error, projected_at, projection_error
+      ) VALUES (
+        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,
+        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+      ) ON CONFLICT(idempotency_key) DO NOTHING
+    `).run(row.review_id, row.idempotency_key, row.origin_kind, row.origin_node_id, row.bridge_node_id, row.companion_node_id, row.review_dir, row.file, row.origin_session_file, row.origin_session_id, row.origin_leaf_id, row.model_spec, row.branch_file, row.baseline_sha256, row.baseline_bytes, row.anchor_base_sha256, row.anchor_base_bytes, 'binding', row.created, row.captured_at, row.opened_at, row.output_path, row.subtitle, row.approved_at, row.approved_sha256, row.changed === null ? null : row.changed ? 1 : 0, row.comments_total, row.comments_unresolved, row.result_json, row.canceled_at, row.cancel_reason, row.cancel_actor, row.delivery_entry_id, row.delivered_at, row.delivery_error, row.projected_at, row.projection_error);
+        const winner = db.prepare('SELECT review_id FROM reviews WHERE idempotency_key = ?').get(row.idempotency_key);
+        if (winner === undefined)
+            throw new Error(`review binding insert did not produce a row: ${row.idempotency_key}`);
+        return { review_id: winner.review_id, won: inserted.changes > 0 };
+    });
+}
+export function getReview(reviewId) {
+    return readRecord(openDb(), 'review_id = ?', reviewId);
+}
+export function getReviewByIdempotencyKey(key) {
+    return readRecord(openDb(), 'idempotency_key = ?', key);
+}
+export function getReviewByCompanion(nodeId) {
+    return readRecord(openDb(), "companion_node_id = ? AND state <> 'binding'", nodeId);
+}
+export function getReviewByBridge(nodeId) {
+    return readRecord(openDb(), "bridge_node_id = ? AND state <> 'binding'", nodeId);
+}
+export function listReviews(filter) {
+    const clauses = ["state <> 'binding'"];
+    const params = [];
+    if (filter.state !== undefined) {
+        clauses.push('state = ?');
+        params.push(filter.state);
+    }
+    if (filter.origin_node_id !== undefined) {
+        clauses.push('origin_node_id = ?');
+        params.push(filter.origin_node_id);
+    }
+    if (filter.file !== undefined) {
+        clauses.push('file = ?');
+        params.push(filter.file);
+    }
+    return readRecords(openDb(), clauses.join(' AND '), ...params);
+}
+export function listBindingReviews() {
+    return readRecords(openDb(), "state = 'binding'");
+}
+export function listUnprojectedTerminalReviews() {
+    return readRecords(openDb(), "state IN ('approved', 'canceled') AND projected_at IS NULL");
+}
+export function bindBridgeNode(reviewId, bridgeNodeId) {
+    return withCanvasWrite((db) => db.prepare('UPDATE reviews SET bridge_node_id = ? WHERE review_id = ? AND bridge_node_id IS NULL').run(bridgeNodeId, reviewId).changes > 0);
+}
+export function openReviewRow(reviewId, openedAt) {
+    return withCanvasWrite((db) => db.prepare("UPDATE reviews SET state = 'open', opened_at = ? WHERE review_id = ? AND state = 'binding'").run(openedAt, reviewId).changes > 0);
+}
+export function approveReviewLocked(db, args) {
+    return db.prepare(`
+    UPDATE reviews SET
+      state = 'approved', approved_at = ?, approved_sha256 = ?, changed = ?,
+      comments_total = ?, comments_unresolved = ?, result_json = ?
+    WHERE review_id = ? AND state = 'open'
+  `).run(args.approved_at, args.approved_sha256, args.changed ? 1 : 0, args.comments_total, args.comments_unresolved, args.result_json, args.review_id).changes > 0;
+}
+export function cancelReviewRow(reviewId, args) {
+    return withCanvasWrite((db) => db.prepare(`
+    UPDATE reviews SET
+      state = 'canceled', canceled_at = ?, cancel_reason = ?, cancel_actor = ?
+    WHERE review_id = ? AND state = 'open'
+  `).run(args.at, args.reason, args.actor, reviewId).changes > 0);
+}
+export function markProjected(reviewId, at) {
+    withCanvasWrite((db) => {
+        db.prepare('UPDATE reviews SET projected_at = ?, projection_error = NULL WHERE review_id = ?').run(at, reviewId);
+    });
+}
+export function markProjectionError(reviewId, error) {
+    withCanvasWrite((db) => {
+        db.prepare('UPDATE reviews SET projection_error = ? WHERE review_id = ? AND projected_at IS NULL').run(error, reviewId);
+    });
+}
+export function markDelivered(reviewId, receipt, at) {
+    withCanvasWrite((db) => {
+        db.prepare('UPDATE reviews SET delivery_entry_id = ?, delivered_at = ?, delivery_error = NULL WHERE review_id = ?').run(receipt, at, reviewId);
+    });
+}
+export function markDeliveryError(reviewId, error) {
+    withCanvasWrite((db) => {
+        db.prepare('UPDATE reviews SET delivery_error = ? WHERE review_id = ? AND delivered_at IS NULL').run(error, reviewId);
+    });
+}
+export function readAnchorBase(reviewId) {
+    const raw = openDb().prepare('SELECT anchor_base_bytes, anchor_base_sha256 FROM reviews WHERE review_id = ?').get(reviewId);
+    if (raw === undefined)
+        return null;
+    return { bytes: Buffer.from(raw.anchor_base_bytes), sha256: raw.anchor_base_sha256 };
+}
+export function replaceAnchorBaseLocked(db, reviewId, bytes, sha256) {
+    db.prepare('UPDATE reviews SET anchor_base_bytes = ?, anchor_base_sha256 = ? WHERE review_id = ?').run(bytes, sha256, reviewId);
+}

package/dist/core/review/ticket-filter.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Terminal-review ticket visibility filter.
+ * Hides canonical review tickets by state; passes pre-cutover tickets unchanged.
+ * This module never imports canvas DB directly; daemon call sites apply the filter.
+ */
+import type { TicketSummary } from '../human/types.js';
+/**
+ * Determines if a review ticket should be visible based on its canonical review state.
+ * A review ticket is hidden when a matching canonical row exists and its state is
+ * 'binding', 'approved', or 'canceled'. Pre-cutover tickets (no canonical row) remain visible.
+ */
+export declare function isReviewTicketVisible(bridgeNodeId: string): boolean;
+/**
+ * Filters a ticket summary array to remove hidden terminal-review tickets.
+ * Deck tickets pass through unchanged. Review tickets are filtered by state.
+ */
+export declare function filterTerminalReviewTickets(items: TicketSummary[]): TicketSummary[];

package/dist/core/review/ticket-filter.js

@@ -0,0 +1,32 @@
+/**
+ * Terminal-review ticket visibility filter.
+ * Hides canonical review tickets by state; passes pre-cutover tickets unchanged.
+ * This module never imports canvas DB directly; daemon call sites apply the filter.
+ */
+import { getReviewByBridge } from './store.js';
+/**
+ * Determines if a review ticket should be visible based on its canonical review state.
+ * A review ticket is hidden when a matching canonical row exists and its state is
+ * 'binding', 'approved', or 'canceled'. Pre-cutover tickets (no canonical row) remain visible.
+ */
+export function isReviewTicketVisible(bridgeNodeId) {
+    const review = getReviewByBridge(bridgeNodeId);
+    // Pre-cutover ticket with no record: visible
+    if (review === null)
+        return true;
+    // Canonical review exists: hide terminal states, show open
+    return review.state === 'open';
+}
+/**
+ * Filters a ticket summary array to remove hidden terminal-review tickets.
+ * Deck tickets pass through unchanged. Review tickets are filtered by state.
+ */
+export function filterTerminalReviewTickets(items) {
+    return items.filter((item) => {
+        // Deck tickets always pass through
+        if (item.kind === 'deck')
+            return true;
+        // Review tickets are filtered by visibility
+        return isReviewTicketVisible(item.id);
+    });
+}

package/dist/core/review/types.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Internal review/comment/error vocabulary and constants.
+ * Phase 4 implementation: daemon-owned review lifecycle and comment authority.
+ * This module declares no HTTP status, DTOs, or I/O.
+ */
+import type { FeedbackComment } from '../human/types.js';
+export type ReviewState = 'binding' | 'open' | 'approved' | 'canceled';
+export type ReviewOriginKind = 'ticket' | 'inline';
+export type CommentStatus = 'open' | 'resolved' | 'deleted';
+export type CommentAuthorKind = 'human' | 'node';
+export type CommentEventKind = 'created' | 'edited' | 'resolved' | 'reopened' | 'deleted' | 'reanchored' | 'notified' | 'notify_failed';
+export type ReviewErrorCode = 'review_origin_missing' | 'review_origin_unforkable' | 'review_origin_unstable' | 'review_branch_unavailable' | 'branch_lost' | 'review_companion_unbound' | 'review_bridge_unsubscribed' | 'review_target_unreviewable' | 'source_unreadable' | 'delivery_unroutable' | 'unknown_review' | 'review_not_open' | 'review_terminal' | 'review_required' | 'stale_document' | 'unknown_comment' | 'comment_deleted' | 'invalid_anchor' | 'anchor_out_of_range' | 'text_too_long' | 'comment_limit_reached' | 'stale_comment' | 'range_batch_incomplete' | 'range_batch_stale';
+/** Limits */
+export declare const COMMENT_TEXT_MAX = 8000;
+export declare const COMMENT_QUOTE_MAX = 4000;
+export declare const COMMENT_LINE_TEXT_MAX = 8000;
+export declare const LIVE_COMMENTS_MAX = 500;
+export declare const COMMENT_EVENTS_PAGE_DEFAULT = 200;
+export declare const COMMENT_EVENTS_PAGE_MAX = 1000;
+export declare const COMPANION_BIND_DEADLINE_MS = 90000;
+export interface CommentAnchor {
+    line: number;
+    end_line: number;
+    col_start?: number;
+    col_end?: number;
+    quote?: string;
+}
+export interface ReviewRow {
+    review_id: string;
+    idempotency_key: string;
+    origin_kind: ReviewOriginKind;
+    origin_node_id: string;
+    bridge_node_id: string | null;
+    companion_node_id: string;
+    review_dir: string;
+    file: string;
+    origin_session_file: string;
+    origin_session_id: string;
+    origin_leaf_id: string;
+    model_spec: string;
+    branch_file: string;
+    baseline_sha256: string;
+    baseline_bytes: number;
+    anchor_base_sha256: string;
+    anchor_base_bytes: Buffer;
+    state: ReviewState;
+    created: string;
+    captured_at: string;
+    opened_at: string | null;
+    output_path: string | null;
+    subtitle: string | null;
+    approved_at: string | null;
+    approved_sha256: string | null;
+    changed: boolean | null;
+    comments_total: number | null;
+    comments_unresolved: number | null;
+    result_json: string | null;
+    canceled_at: string | null;
+    cancel_reason: string | null;
+    cancel_actor: string | null;
+    delivery_entry_id: string | null;
+    delivered_at: string | null;
+    delivery_error: string | null;
+    projected_at: string | null;
+    projection_error: string | null;
+}
+export interface ReviewRecord extends Omit<ReviewRow, 'anchor_base_bytes'> {
+    source_missing: boolean;
+}
+export interface ReviewComment {
+    comment_id: string;
+    review_id: string;
+    status: CommentStatus;
+    revision: number;
+    text: string;
+    anchor: CommentAnchor;
+    anchor_state: 'live' | 'detached';
+    anchor_line_text: string;
+    anchor_doc_hash: string;
+    author: {
+        kind: CommentAuthorKind;
+        node_id: string | null;
+    };
+    updated_by: {
+        kind: CommentAuthorKind;
+        node_id: string | null;
+    };
+    created_at: string;
+    updated_at: string;
+    resolved_at: string | null;
+    deleted_at: string | null;
+    created_seq: number;
+}
+export interface ReviewCommentEvent {
+    seq: number;
+    review_id: string;
+    comment_id: string;
+    kind: CommentEventKind;
+    state_change: 0 | 1;
+    revision_after: number | null;
+    actor: {
+        kind: CommentAuthorKind | 'system';
+        node_id: string | null;
+    };
+    at: string;
+    operation_id: string;
+    payload?: unknown;
+}
+export interface ReviewResult {
+    schema: 'humanloop.review-response/v1';
+    review_id: string;
+    file: string;
+    submitted: true;
+    approved: true;
+    changed: boolean;
+    baseline_sha256: string;
+    approved_sha256: string;
+    companion_node_id: string;
+    comments_total: number;
+    comments_unresolved: number;
+    comments: FeedbackComment[];
+    submittedAt: string;
+    savedAt: string;
+}
+export declare class ReviewOperationError extends Error {
+    code: ReviewErrorCode;
+    detail: Record<string, unknown>;
+    constructor(code: ReviewErrorCode, message: string, detail: Record<string, unknown>);
+}
+export type NewReviewRow = ReviewRow;

package/dist/core/review/types.js

@@ -0,0 +1,23 @@
+/**
+ * Internal review/comment/error vocabulary and constants.
+ * Phase 4 implementation: daemon-owned review lifecycle and comment authority.
+ * This module declares no HTTP status, DTOs, or I/O.
+ */
+/** Limits */
+export const COMMENT_TEXT_MAX = 8_000;
+export const COMMENT_QUOTE_MAX = 4_000;
+export const COMMENT_LINE_TEXT_MAX = 8_000;
+export const LIVE_COMMENTS_MAX = 500;
+export const COMMENT_EVENTS_PAGE_DEFAULT = 200;
+export const COMMENT_EVENTS_PAGE_MAX = 1_000;
+export const COMPANION_BIND_DEADLINE_MS = 90_000;
+export class ReviewOperationError extends Error {
+    code;
+    detail;
+    constructor(code, message, detail) {
+        super(message);
+        this.code = code;
+        this.detail = detail;
+        this.name = 'ReviewOperationError';
+    }
+}

package/dist/core/runtime/__tests__/session-visibility.test.d.ts

@@ -0,0 +1 @@
+export {};