@xfey/tutti 0.1.0

package/dist/checks/index.js

@@ -0,0 +1,169 @@
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { redactText } from "@tutti/shared/utils/redaction";
+const DEFAULT_CHECK_TIMEOUT_MS = 120_000;
+const MAX_OUTPUT_BYTES = 16 * 1024;
+const DEFAULT_SKIP_REASON = "no_validation_command_found";
+function truncateOutput(text) {
+    const redacted = redactText(text);
+    const buffer = Buffer.from(redacted, "utf8");
+    if (buffer.byteLength <= MAX_OUTPUT_BYTES) {
+        return redacted;
+    }
+    return `${buffer.subarray(0, MAX_OUTPUT_BYTES).toString("utf8")}\n[truncated]`;
+}
+function readPackageScripts(workspaceRoot) {
+    const packageJsonPath = join(workspaceRoot, "package.json");
+    if (!existsSync(packageJsonPath)) {
+        return {};
+    }
+    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    if (typeof parsed !== "object" ||
+        parsed === null ||
+        Array.isArray(parsed) ||
+        typeof parsed.scripts !== "object" ||
+        parsed.scripts === null ||
+        Array.isArray(parsed.scripts)) {
+        return {};
+    }
+    const scripts = parsed.scripts;
+    const result = {};
+    for (const [key, value] of Object.entries(scripts)) {
+        if (typeof value === "string") {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function isSafeValidationScript(script) {
+    const normalized = script.toLowerCase();
+    return !/\b(watch|dev|serve|start|publish|deploy|push|release)\b/u.test(normalized);
+}
+function isDefaultNoTestScript(script) {
+    return /^echo\s+["']Error: no test specified["']\s*&&\s*exit\s+1$/u.test(script.trim());
+}
+export function createNodeNpmCheckPlan(options) {
+    const scripts = readPackageScripts(options.workspaceRoot);
+    const commands = [];
+    for (const scriptName of ["typecheck", "lint", "test", "build"]) {
+        const script = scripts[scriptName];
+        if (script === undefined || !isSafeValidationScript(script)) {
+            continue;
+        }
+        if (scriptName === "test" && isDefaultNoTestScript(script)) {
+            continue;
+        }
+        commands.push({
+            id: `npm:${scriptName}`,
+            label: `npm ${scriptName}`,
+            command: "npm",
+            args: scriptName === "test" ? ["test"] : ["run", scriptName],
+            required: true,
+        });
+    }
+    if (commands.length === 0) {
+        return {
+            commands: [],
+            skip_reason_code: DEFAULT_SKIP_REASON,
+            skip_reason_summary: "No safe npm validation scripts were found.",
+        };
+    }
+    return { commands };
+}
+function commandEnvironment() {
+    return {
+        PATH: process.env.PATH ?? "",
+        HOME: process.env.HOME ?? "",
+        CI: "true",
+        npm_config_update_notifier: "false",
+        npm_config_fund: "false",
+        npm_config_audit: "false",
+    };
+}
+function runCheckCommand(options) {
+    const startedAt = Date.now();
+    return new Promise((resolve) => {
+        const child = spawn(options.command.command, options.command.args, {
+            cwd: options.workspaceRoot,
+            env: commandEnvironment(),
+            shell: false,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const stdout = [];
+        const stderr = [];
+        let timedOut = false;
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGTERM");
+        }, options.timeoutMs);
+        child.stdout.on("data", (chunk) => stdout.push(chunk));
+        child.stderr.on("data", (chunk) => stderr.push(chunk));
+        child.on("error", (error) => {
+            clearTimeout(timeout);
+            resolve({
+                id: options.command.id,
+                label: options.command.label,
+                command: options.command.command,
+                args: options.command.args,
+                status: "failed",
+                duration_ms: Date.now() - startedAt,
+                stdout: truncateOutput(Buffer.concat(stdout).toString("utf8")),
+                stderr: truncateOutput(`${Buffer.concat(stderr).toString("utf8")}\n${error.message}`),
+            });
+        });
+        child.on("close", (code) => {
+            clearTimeout(timeout);
+            resolve({
+                id: options.command.id,
+                label: options.command.label,
+                command: options.command.command,
+                args: options.command.args,
+                status: timedOut ? "timed_out" : code === 0 ? "passed" : "failed",
+                ...(typeof code === "number" ? { exit_code: code } : {}),
+                duration_ms: Date.now() - startedAt,
+                stdout: truncateOutput(Buffer.concat(stdout).toString("utf8")),
+                stderr: truncateOutput(Buffer.concat(stderr).toString("utf8")),
+            });
+        });
+    });
+}
+export async function executeCheckPlan(options) {
+    if (options.plan.commands.length === 0) {
+        return {
+            status: "skipped",
+            commands: [],
+            skip_reason_code: options.plan.skip_reason_code ?? DEFAULT_SKIP_REASON,
+            skip_reason_summary: options.plan.skip_reason_summary ?? "No validation commands were available.",
+        };
+    }
+    const commands = [];
+    for (const command of options.plan.commands) {
+        commands.push(await runCheckCommand({
+            workspaceRoot: options.workspaceRoot,
+            command,
+            timeoutMs: options.timeoutMs ?? DEFAULT_CHECK_TIMEOUT_MS,
+        }));
+    }
+    const requiredCommands = options.plan.commands.filter((command) => command.required);
+    const requiredResults = commands.filter((result) => requiredCommands.some((command) => command.id === result.id));
+    if (requiredResults.length === 0) {
+        return {
+            status: "skipped",
+            commands,
+            skip_reason_code: options.plan.skip_reason_code ?? DEFAULT_SKIP_REASON,
+            skip_reason_summary: options.plan.skip_reason_summary ?? "No required validation commands were available.",
+        };
+    }
+    if (requiredResults.some((result) => result.status !== "passed")) {
+        return {
+            status: "failed",
+            commands,
+        };
+    }
+    return {
+        status: "passed",
+        commands,
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/collaboration-state/clarification-messages.d.ts

@@ -0,0 +1,8 @@
+import { type ClarificationRoundRef } from "@tutti/shared/ids";
+import type { MessageProjection, MessageWindow } from "@tutti/shared/schemas/api";
+import type { SqliteDatabase } from "../store/index.js";
+import type { CreateClarificationRoundAgentMessageInput, CreateClarificationRoundMessageInput, ReadMessageWindowOptions } from "./types.js";
+export declare function createClarificationRoundMessage(db: SqliteDatabase, input: CreateClarificationRoundMessageInput): MessageProjection;
+export declare function createClarificationRoundAgentMessage(db: SqliteDatabase, input: CreateClarificationRoundAgentMessageInput): MessageProjection;
+export declare function readClarificationRoundMessagesWindow(db: SqliteDatabase, roundId: ClarificationRoundRef, options?: ReadMessageWindowOptions): MessageWindow | null;
+//# sourceMappingURL=clarification-messages.d.ts.map

package/dist/collaboration-state/clarification-messages.js

@@ -0,0 +1,180 @@
+import { createMessageId, } from "@tutti/shared/ids";
+import { clampLimit, decodeCursor, messageCursor, nowIso, stringifyJson, } from "./serialization.js";
+import { readClarificationRoundRow } from "./clarification-records.js";
+import { mapMessageRow } from "./messages.js";
+import { recordReadNotificationEvent } from "./read-state.js";
+export function createClarificationRoundMessage(db, input) {
+    const createdAt = nowIso(input.now);
+    const id = createMessageId();
+    const refs = {
+        clarification_round_ref: input.round_id,
+    };
+    db.prepare(`
+      INSERT INTO messages (
+        id,
+        scope_kind,
+        clarification_round_id,
+        author_kind,
+        author_ref,
+        author_display_name,
+        author_avatar_json,
+        message_kind,
+        body,
+        refs_json,
+        created_at
+      )
+      VALUES (?, 'clarification_round', ?, ?, ?, ?, ?, 'user_text', ?, ?, ?)
+    `).run(id, input.round_id, input.author.kind, input.author.ref ?? null, input.author.display_name ?? null, input.author.avatar === undefined ? null : stringifyJson(input.author.avatar), input.body, stringifyJson(refs), createdAt);
+    recordReadNotificationEvent(db, {
+        scope: "chat",
+        source_kind: "message",
+        source_ref: id,
+        actor: {
+            kind: input.author.kind,
+            ...(input.author.ref === undefined ? {} : { ref: input.author.ref }),
+        },
+        occurred_at: createdAt,
+    });
+    return {
+        id,
+        scope: {
+            kind: "clarification_round",
+            clarification_round_ref: input.round_id,
+        },
+        author: input.author,
+        message_kind: "user_text",
+        body: input.body,
+        refs,
+        created_at: createdAt,
+    };
+}
+export function createClarificationRoundAgentMessage(db, input) {
+    const createdAt = nowIso(input.now);
+    const id = createMessageId();
+    const refs = {
+        ...(input.refs ?? {}),
+        clarification_round_ref: input.round_id,
+    };
+    db.prepare(`
+      INSERT INTO messages (
+        id,
+        scope_kind,
+        clarification_round_id,
+        author_kind,
+        message_kind,
+        body,
+        refs_json,
+        created_at
+      )
+      VALUES (?, 'clarification_round', ?, 'agent', 'agent_text', ?, ?, ?)
+    `).run(id, input.round_id, input.body, stringifyJson(refs), createdAt);
+    recordReadNotificationEvent(db, {
+        scope: "chat",
+        source_kind: "message",
+        source_ref: id,
+        actor: { kind: "agent" },
+        occurred_at: createdAt,
+    });
+    return {
+        id,
+        scope: {
+            kind: "clarification_round",
+            clarification_round_ref: input.round_id,
+        },
+        author: { kind: "agent" },
+        message_kind: "agent_text",
+        body: input.body,
+        refs,
+        created_at: createdAt,
+    };
+}
+export function readClarificationRoundMessagesWindow(db, roundId, options = {}) {
+    if (readClarificationRoundRow(db, roundId) === null) {
+        return null;
+    }
+    const limit = clampLimit(options.limit);
+    const before = decodeCursor(options.before);
+    const after = decodeCursor(options.after);
+    if (before !== null && after !== null) {
+        throw new Error("before and after cursors cannot be used together");
+    }
+    let rows;
+    let hasOlder = false;
+    let hasNewer = false;
+    if (before !== null) {
+        rows = db
+            .prepare(`
+          SELECT *
+          FROM messages
+          WHERE scope_kind = 'clarification_round'
+            AND clarification_round_id = ?
+            AND (created_at < ? OR (created_at = ? AND id < ?))
+          ORDER BY created_at DESC, id DESC
+          LIMIT ?
+        `)
+            .all(roundId, before.created_at, before.created_at, before.id, limit + 1);
+        hasOlder = rows.length > limit;
+        hasNewer = true;
+        rows = rows.slice(0, limit).reverse();
+    }
+    else if (after !== null) {
+        rows = db
+            .prepare(`
+          SELECT *
+          FROM messages
+          WHERE scope_kind = 'clarification_round'
+            AND clarification_round_id = ?
+            AND (created_at > ? OR (created_at = ? AND id > ?))
+          ORDER BY created_at ASC, id ASC
+          LIMIT ?
+        `)
+            .all(roundId, after.created_at, after.created_at, after.id, limit + 1);
+        hasNewer = rows.length > limit;
+        hasOlder = true;
+        rows = rows.slice(0, limit);
+    }
+    else if (options.anchor === "latest") {
+        rows = db
+            .prepare(`
+          SELECT *
+          FROM messages
+          WHERE scope_kind = 'clarification_round'
+            AND clarification_round_id = ?
+          ORDER BY created_at DESC, id DESC
+          LIMIT ?
+        `)
+            .all(roundId, limit + 1);
+        hasOlder = rows.length > limit;
+        rows = rows.slice(0, limit).reverse();
+    }
+    else {
+        rows = db
+            .prepare(`
+          SELECT *
+          FROM messages
+          WHERE scope_kind = 'clarification_round'
+            AND clarification_round_id = ?
+          ORDER BY created_at ASC, id ASC
+          LIMIT ?
+        `)
+            .all(roundId, limit + 1);
+        hasNewer = rows.length > limit;
+        rows = rows.slice(0, limit);
+    }
+    const items = rows.map((row) => mapMessageRow(row));
+    const first = items[0];
+    const last = items.at(-1);
+    const window = {
+        has_older: hasOlder,
+        has_newer: hasNewer,
+        limit,
+    };
+    if (hasOlder && first !== undefined) {
+        window.older_cursor = messageCursor(first);
+    }
+    if (hasNewer && last !== undefined) {
+        window.newer_cursor = messageCursor(last);
+    }
+    return { items, window };
+}
+//# sourceMappingURL=clarification-messages.js.map

package/dist/collaboration-state/clarification-records.d.ts

@@ -0,0 +1,27 @@
+import type { ClarificationRoundRef, ClarificationThreadRef } from "@tutti/shared/ids";
+import type { ActiveClarificationProjection, ClarificationRoundProjection, ClarificationThreadProjection, GetClarificationThreadResponse } from "@tutti/shared/schemas/api";
+import type { SqliteDatabase } from "../store/index.js";
+import type { SealedClarificationRoundWithoutSuccessor } from "./types.js";
+import type { ClarificationRoundRow, ClarificationThreadRow } from "./storage-types.js";
+export declare function mapClarificationThreadRow(row: ClarificationThreadRow): ClarificationThreadProjection;
+export declare function mapClarificationRoundRow(row: ClarificationRoundRow): ClarificationRoundProjection;
+export declare function readClarificationThreadRow(db: SqliteDatabase, threadId: ClarificationThreadRef): ClarificationThreadRow | null;
+export declare function readClarificationRoundRow(db: SqliteDatabase, roundId: ClarificationRoundRef): ClarificationRoundRow | null;
+export declare function readActiveClarificationProjection(db: SqliteDatabase): ActiveClarificationProjection;
+export declare function readSealedClarificationRoundsWithoutSuccessor(db: SqliteDatabase): SealedClarificationRoundWithoutSuccessor[];
+export declare function deleteStaleClarificationSubmitReplayHints(db: SqliteDatabase): number;
+export declare function readClarificationRoundProjection(db: SqliteDatabase, roundId: ClarificationRoundRef): ClarificationRoundProjection | null;
+export declare function readClarificationRoundsForThread(db: SqliteDatabase, threadId: ClarificationThreadRef, options?: {
+    throughRoundIndex?: number;
+}): ClarificationRoundProjection[];
+export declare function readSubmittedTaskCompileClarificationRounds(db: SqliteDatabase, options?: {
+    afterSubmittedAt?: string;
+    limit?: number;
+}): ClarificationRoundProjection[];
+export declare function readSubmittedTaskCompileClarificationRoundsAfterCursor(db: SqliteDatabase, options: {
+    afterSubmittedAt: string;
+    afterRoundId: ClarificationRoundRef;
+    limit?: number;
+}): ClarificationRoundProjection[];
+export declare function readClarificationThreadResponse(db: SqliteDatabase, threadId: ClarificationThreadRef): GetClarificationThreadResponse | null;
+//# sourceMappingURL=clarification-records.d.ts.map

package/dist/collaboration-state/clarification-records.js

@@ -0,0 +1,266 @@
+import { parseJson } from "./serialization.js";
+export function mapClarificationThreadRow(row) {
+    const thread = {
+        id: row.id,
+        owner: row.owner_kind === "task_compile"
+            ? {
+                kind: "task_compile",
+                workflow_ref: row.owner_workflow_ref,
+            }
+            : {
+                kind: "task",
+                task_id: row.owner_task_id,
+            },
+        status: row.status,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+    if (row.current_round_id !== null) {
+        thread.current_round_id = row.current_round_id;
+    }
+    if (row.created_from_activity_ref !== null) {
+        thread.created_from_activity_ref = row.created_from_activity_ref;
+    }
+    if (row.closed_reason !== null) {
+        thread.closed_reason = row.closed_reason;
+    }
+    return thread;
+}
+export function mapClarificationRoundRow(row) {
+    const round = {
+        id: row.id,
+        thread_id: row.clarification_thread_id,
+        round_index: row.round_index,
+        status: row.status,
+        request_payload: parseJson(row.request_payload_json, {
+            summary: "",
+            request: "",
+        }),
+        card_message_id: row.card_message_id,
+        opening_message_id: row.opening_message_id,
+        successor_status: row.successor_status,
+        capabilities: {
+            send_message: row.status === "writable",
+            submit: row.status === "writable",
+        },
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+    if (row.submitted_at !== null) {
+        round.submitted_at = row.submitted_at;
+    }
+    if (row.submitted_message_refs_json !== null) {
+        round.submitted_message_refs = parseJson(row.submitted_message_refs_json, []);
+    }
+    if (row.successor_ref_json !== null) {
+        round.successor_ref = parseJson(row.successor_ref_json, {
+            kind: "chain_closed",
+        });
+    }
+    return round;
+}
+export function readClarificationThreadRow(db, threadId) {
+    const row = db
+        .prepare(`
+        SELECT *
+        FROM clarification_threads
+        WHERE id = ?
+      `)
+        .get(threadId);
+    return row ?? null;
+}
+export function readClarificationRoundRow(db, roundId) {
+    const row = db
+        .prepare(`
+        SELECT *
+        FROM clarification_rounds
+        WHERE id = ?
+      `)
+        .get(roundId);
+    return row ?? null;
+}
+export function readActiveClarificationProjection(db) {
+    const row = db
+        .prepare(`
+        SELECT *
+        FROM clarification_threads
+        WHERE status = 'active'
+        ORDER BY created_at ASC, id ASC
+        LIMIT 1
+      `)
+        .get();
+    if (row === undefined || row.current_round_id === null) {
+        return { state: "none" };
+    }
+    const round = readClarificationRoundRow(db, row.current_round_id);
+    if (round === null) {
+        return { state: "none" };
+    }
+    return {
+        state: "active",
+        thread: mapClarificationThreadRow(row),
+        round: mapClarificationRoundRow(round),
+    };
+}
+export function readSealedClarificationRoundsWithoutSuccessor(db) {
+    const rows = db
+        .prepare(`
+        SELECT *
+        FROM clarification_rounds
+        WHERE status = 'sealed'
+          AND successor_status = 'not_materialized'
+        ORDER BY submitted_at ASC, id ASC
+      `)
+        .all();
+    return rows.flatMap((roundRow) => {
+        const thread = readClarificationThreadRow(db, roundRow.clarification_thread_id);
+        if (thread === null) {
+            return [];
+        }
+        return [
+            {
+                thread: mapClarificationThreadRow(thread),
+                round: mapClarificationRoundRow(roundRow),
+            },
+        ];
+    });
+}
+export function deleteStaleClarificationSubmitReplayHints(db) {
+    const result = db
+        .prepare(`
+        DELETE FROM clarification_submit_replay_hints
+        WHERE NOT EXISTS (
+          SELECT 1
+          FROM clarification_rounds
+          WHERE clarification_rounds.id = clarification_submit_replay_hints.clarification_round_id
+            AND clarification_rounds.status = 'sealed'
+            AND clarification_rounds.successor_status = 'not_materialized'
+        )
+      `)
+        .run();
+    return result.changes;
+}
+export function readClarificationRoundProjection(db, roundId) {
+    const row = readClarificationRoundRow(db, roundId);
+    return row === null ? null : mapClarificationRoundRow(row);
+}
+export function readClarificationRoundsForThread(db, threadId, options = {}) {
+    const rows = options.throughRoundIndex === undefined
+        ? db
+            .prepare(`
+              SELECT *
+              FROM clarification_rounds
+              WHERE clarification_thread_id = ?
+              ORDER BY round_index ASC
+            `)
+            .all(threadId)
+        : db
+            .prepare(`
+              SELECT *
+              FROM clarification_rounds
+              WHERE clarification_thread_id = ?
+                AND round_index <= ?
+              ORDER BY round_index ASC
+            `)
+            .all(threadId, options.throughRoundIndex);
+    return rows.map((row) => mapClarificationRoundRow(row));
+}
+export function readSubmittedTaskCompileClarificationRounds(db, options = {}) {
+    const limit = Math.max(1, Math.min(options.limit ?? 20, 100));
+    const rows = options.afterSubmittedAt === undefined
+        ? db
+            .prepare(`
+              SELECT clarification_rounds.*
+              FROM clarification_rounds
+              JOIN clarification_threads
+                ON clarification_threads.id = clarification_rounds.clarification_thread_id
+              WHERE clarification_threads.owner_kind = 'task_compile'
+                AND clarification_rounds.status = 'sealed'
+                AND clarification_rounds.submitted_at IS NOT NULL
+              ORDER BY clarification_rounds.submitted_at DESC, clarification_rounds.id DESC
+              LIMIT ?
+            `)
+            .all(limit)
+        : db
+            .prepare(`
+              SELECT clarification_rounds.*
+              FROM clarification_rounds
+              JOIN clarification_threads
+                ON clarification_threads.id = clarification_rounds.clarification_thread_id
+              WHERE clarification_threads.owner_kind = 'task_compile'
+                AND clarification_rounds.status = 'sealed'
+                AND clarification_rounds.submitted_at IS NOT NULL
+                AND clarification_rounds.submitted_at > ?
+              ORDER BY clarification_rounds.submitted_at ASC, clarification_rounds.id ASC
+              LIMIT ?
+            `)
+            .all(options.afterSubmittedAt, limit);
+    const sortedRows = options.afterSubmittedAt === undefined ? rows.toReversed() : rows;
+    return sortedRows.map((row) => mapClarificationRoundRow(row));
+}
+export function readSubmittedTaskCompileClarificationRoundsAfterCursor(db, options) {
+    const limit = Math.max(1, Math.min(options.limit ?? 20, 100));
+    const rows = db
+        .prepare(`
+        SELECT clarification_rounds.*
+        FROM clarification_rounds
+        JOIN clarification_threads
+          ON clarification_threads.id = clarification_rounds.clarification_thread_id
+        WHERE clarification_threads.owner_kind = 'task_compile'
+          AND clarification_rounds.status = 'sealed'
+          AND clarification_rounds.submitted_at IS NOT NULL
+          AND (
+            clarification_rounds.submitted_at > ?
+            OR (
+              clarification_rounds.submitted_at = ?
+              AND clarification_rounds.id > ?
+            )
+          )
+        ORDER BY clarification_rounds.submitted_at ASC, clarification_rounds.id ASC
+        LIMIT ?
+      `)
+        .all(options.afterSubmittedAt, options.afterSubmittedAt, options.afterRoundId, limit);
+    return rows.map((row) => mapClarificationRoundRow(row));
+}
+export function readClarificationThreadResponse(db, threadId) {
+    const threadRow = readClarificationThreadRow(db, threadId);
+    if (threadRow === null) {
+        return null;
+    }
+    const roundRows = db
+        .prepare(`
+        SELECT *
+        FROM clarification_rounds
+        WHERE clarification_thread_id = ?
+        ORDER BY round_index ASC
+      `)
+        .all(threadId);
+    const rounds = roundRows.map((row) => {
+        const requestPayload = parseJson(row.request_payload_json, {
+            summary: "",
+            request: "",
+        });
+        const summary = {
+            id: row.id,
+            thread_id: row.clarification_thread_id,
+            round_index: row.round_index,
+            status: row.status,
+            summary: requestPayload.summary,
+            successor_status: row.successor_status,
+            created_at: row.created_at,
+            updated_at: row.updated_at,
+        };
+        if (requestPayload.title !== undefined) {
+            summary.title = requestPayload.title;
+        }
+        if (row.submitted_at !== null) {
+            summary.submitted_at = row.submitted_at;
+        }
+        return summary;
+    });
+    return {
+        thread: mapClarificationThreadRow(threadRow),
+        rounds,
+    };
+}
+//# sourceMappingURL=clarification-records.js.map

package/dist/collaboration-state/clarification-round-writes.d.ts

@@ -0,0 +1,14 @@
+import type { ClarificationRoundRef, ClarificationThreadRef, MessageId } from "@tutti/shared/ids";
+import type { ClarificationRequestPayload } from "@tutti/shared/schemas/api";
+import type { SqliteDatabase } from "../store/index.js";
+export declare function insertClarificationRoundOpeningRecords(db: SqliteDatabase, input: {
+    threadId: ClarificationThreadRef;
+    roundId: ClarificationRoundRef;
+    roundIndex: number;
+    cardMessageId: MessageId;
+    openingMessageId: MessageId;
+    requestPayload: ClarificationRequestPayload;
+    refs: Record<string, unknown>;
+    openedAt: string;
+}): void;
+//# sourceMappingURL=clarification-round-writes.d.ts.map