@xfey/tutti 0.1.111 → 0.1.113

package/dist/approvals/decision-command.d.ts

@@ -22,6 +22,7 @@ export declare function executeApprovalDecisionCommand(input: {
     approval?: {
         state: "none";
     } | {
+        state: "pending";
         request: {
             task_id?: string;
             activity_ref?: string;
@@ -64,8 +65,8 @@ export declare function executeApprovalDecisionCommand(input: {
             request_kind: "command_execution" | "file_change" | "permissions" | "legacy_exec_command" | "legacy_apply_patch";
             requested_at: string;
         };
-        state: "pending";
     } | {
+        state: "resolved";
         request: {
             task_id?: string;
             activity_ref?: string;
@@ -108,7 +109,6 @@ export declare function executeApprovalDecisionCommand(input: {
             request_kind: "command_execution" | "file_change" | "permissions" | "legacy_exec_command" | "legacy_apply_patch";
             requested_at: string;
         };
-        state: "resolved";
         resolution: {
             decided_by?: {
                 display_name: string;

package/dist/chat-assistant/index.d.ts

@@ -49,7 +49,7 @@ export type ReadOnlyChatAssistantOptions = {
     model: ReadOnlyChatAssistantModel;
     promptsRoot?: string;
     onScratchpadSourceChanged?: (message: MessageProjection) => void;
-    onMainChatAgentMessageCreated?: (input: {
+    onAgentMessageCreated?: (input: {
         tx: SqliteDatabase;
         triggerMessage: MessageProjection;
         responseMessage: MessageProjection;

package/dist/chat-assistant/index.js

@@ -262,7 +262,7 @@ export class ReadOnlyChatAssistant {
                 ...(refs === undefined ? {} : { refs }),
                 ...(this.options.now === undefined ? {} : { now: this.options.now }),
             });
-            const callback = this.options.onMainChatAgentMessageCreated?.({
+            const callback = this.options.onAgentMessageCreated?.({
                 tx,
                 triggerMessage,
                 responseMessage,
@@ -286,12 +286,24 @@ export class ReadOnlyChatAssistant {
     }
     appendClarificationRoundAssistantMessage(input) {
         const round = readClarificationRoundProjection(this.options.store.db, input.roundId);
-        const message = createClarificationRoundAgentMessage(this.options.store.db, {
-            round_id: input.roundId,
-            body: input.body,
-            ...(input.refs === undefined ? {} : { refs: input.refs }),
-            ...(this.options.now === undefined ? {} : { now: this.options.now }),
+        let afterCommit;
+        const message = withHostStoreTransaction(this.options.store.db, (tx) => {
+            const responseMessage = createClarificationRoundAgentMessage(tx, {
+                round_id: input.roundId,
+                body: input.body,
+                ...(input.refs === undefined ? {} : { refs: input.refs }),
+                ...(this.options.now === undefined ? {} : { now: this.options.now }),
+            });
+            const callback = this.options.onAgentMessageCreated?.({
+                tx,
+                triggerMessage: input.triggerMessage,
+                responseMessage,
+            });
+            if (typeof callback === "function")
+                afterCommit = callback;
+            return responseMessage;
         });
+        afterCommit?.();
         const invalidates = [
             {
                 kind: "clarification",
@@ -314,6 +326,7 @@ export class ReadOnlyChatAssistant {
     appendAssistantMessageForTrigger(triggerMessage, body, refs) {
         if (triggerMessage.scope.kind === "clarification_round") {
             this.appendClarificationRoundAssistantMessage({
+                triggerMessage,
                 roundId: triggerMessage.scope.clarification_round_ref,
                 body,
                 ...(refs === undefined ? {} : { refs }),

package/dist/collaboration-ingestion/clarification.d.ts

@@ -0,0 +1,25 @@
+import type { ClarificationRoundRef, IdempotencyKey } from "@tutti/shared/ids";
+import type { MessageProjection, SendClarificationRoundMessagePayload, SendClarificationRoundMessageResponse, SubmitClarificationRoundPayload, SubmitClarificationRoundResponse } from "@tutti/shared/schemas/api";
+import type { Phase5ControlPlane } from "../control-plane/index.js";
+import type { HostProjectStore, SqliteDatabase } from "../store/index.js";
+import type { ChatAssistantEnqueuer, TrustedCollaborationAuthor } from "./types.js";
+type RoundCommandOptions = {
+    store: HostProjectStore;
+    controlPlane: Pick<Phase5ControlPlane, "sendClarificationRoundMessage" | "submitClarificationRound">;
+    roundId: ClarificationRoundRef;
+    commandId: IdempotencyKey;
+    now?: () => Date;
+};
+/** Browser and trusted platform input share command identity, mutation and write-once effects. */
+export declare function ingestClarificationMessage(options: RoundCommandOptions & {
+    payload: SendClarificationRoundMessagePayload;
+    author: TrustedCollaborationAuthor;
+    chatAssistant?: ChatAssistantEnqueuer;
+    idempotencyContext?: unknown;
+    afterCreate?: (tx: SqliteDatabase, message: MessageProjection) => void;
+}): SendClarificationRoundMessageResponse;
+export declare function submitClarificationAnswers(options: RoundCommandOptions & {
+    payload: SubmitClarificationRoundPayload;
+}): SubmitClarificationRoundResponse;
+export {};
+//# sourceMappingURL=clarification.d.ts.map

package/dist/collaboration-ingestion/clarification.js

@@ -0,0 +1,63 @@
+import { readClarificationRoundProjection, readMessageProjectionById, } from "../collaboration-state/index.js";
+import { clarificationInvalidates } from "../control-plane/invalidations.js";
+import { executeIdempotentCommand } from "../server-shell/command-idempotency/index.js";
+/** Browser and trusted platform input share command identity, mutation and write-once effects. */
+export function ingestClarificationMessage(options) {
+    const execution = executeIdempotentCommand({
+        db: options.store.db,
+        command_id: options.commandId,
+        command_name: "clarification.message.create",
+        target_ref: options.roundId,
+        payload: {
+            body: options.payload.body,
+            author_ref: options.author.account_ref,
+            ...(options.author.kind === "development_operator"
+                ? { author_kind: "development_operator" }
+                : {}),
+            ...(options.idempotencyContext === undefined
+                ? {}
+                : { ingestion_context: options.idempotencyContext }),
+        },
+        ...(options.now === undefined ? {} : { now: options.now }),
+        execute: (tx) => {
+            const result = options.controlPlane.sendClarificationRoundMessage(options.roundId, options.payload, options.author);
+            if (result.result?.message !== undefined)
+                options.afterCreate?.(tx, result.result.message);
+            return result;
+        },
+    });
+    const replayedMessage = execution.disposition.kind === "created" && execution.disposition.message_id !== undefined
+        ? readMessageProjectionById(options.store.db, execution.disposition.message_id)
+        : null;
+    const result = execution.result ?? (replayedMessage === null ? undefined : { message: replayedMessage });
+    if (!execution.replayed && result?.message !== undefined)
+        options.chatAssistant?.enqueue({ message: result.message });
+    return {
+        command_id: execution.command_id,
+        disposition: execution.disposition,
+        invalidates: clarificationInvalidates(options.roundId),
+        ...(result === undefined ? {} : { result }),
+    };
+}
+export function submitClarificationAnswers(options) {
+    const execution = executeIdempotentCommand({
+        db: options.store.db,
+        command_id: options.commandId,
+        command_name: "clarification.round.submit",
+        target_ref: options.roundId,
+        payload: options.payload,
+        ...(options.now === undefined ? {} : { now: options.now }),
+        execute: () => options.controlPlane.submitClarificationRound(options.roundId, options.payload, options.commandId),
+    });
+    const round = execution.disposition.kind === "accepted" || execution.disposition.kind === "already_submitted"
+        ? readClarificationRoundProjection(options.store.db, options.roundId)
+        : null;
+    const result = execution.result ?? (round === null ? undefined : { round });
+    return {
+        command_id: execution.command_id,
+        disposition: execution.disposition,
+        invalidates: clarificationInvalidates(options.roundId),
+        ...(result === undefined ? {} : { result }),
+    };
+}
+//# sourceMappingURL=clarification.js.map

package/dist/collaboration-ingestion/external-source.d.ts

@@ -1,12 +1,14 @@
 import type { IntegrationDeliveryDisposition, TrustedConversationSourceIngestionCommand } from "@tutti/shared/schemas/internal";
 import type { HostProjectStore } from "../store/index.js";
 import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
+import type { Phase5ControlPlane } from "../control-plane/index.js";
 import type { ChatAssistantEnqueuer, ScratchpadSourceNotifier } from "./types.js";
 export declare const TRUSTED_INTEGRATION_INGESTION_PATH = "/internal/integration/v1/conversation-sources";
 export type IngestTrustedConversationSourceOptions = {
     store: HostProjectStore;
     events: WorkspaceEventBus;
     command: TrustedConversationSourceIngestionCommand;
+    controlPlane?: Pick<Phase5ControlPlane, "sendClarificationRoundMessage" | "submitClarificationRound">;
     scratchpadSource?: ScratchpadSourceNotifier;
     chatAssistant?: ChatAssistantEnqueuer;
     now?: () => Date;

package/dist/collaboration-ingestion/external-source.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { INTEGRATION_CONVERSATION_SOURCE_TUNNEL_PATH, isTrustedConversationSourceIngestionCommand, } from "@tutti/shared/schemas/internal";
 import { ingestMainChatMessage } from "./main-chat.js";
+import { ingestClarificationMessage } from "./clarification.js";
 export const TRUSTED_INTEGRATION_INGESTION_PATH = INTEGRATION_CONVERSATION_SOURCE_TUNNEL_PATH;
 function sha256Text(value) {
     return `sha256:${createHash("sha256").update(value, "utf8").digest("hex")}`;
@@ -77,6 +78,40 @@ export function ingestTrustedConversationSource(options) {
     if (source.content.text.length > 8_000) {
         return { kind: "unsupported", reason_code: "message_too_long" };
     }
+    if (options.command.clarification_round_ref !== undefined) {
+        if (options.controlPlane === undefined)
+            return {
+                kind: "host_incompatible",
+                retryable: true,
+                reason_code: "integration_clarification_unsupported",
+            };
+        // Feishu replies may automatically mention Tutti. Directed round input is an
+        // answer, not an implicit Q&A request; retain its text but omit the assistant.
+        // Browser round composers and ordinary main-chat mentions keep their own path.
+        const response = ingestClarificationMessage({
+            store: options.store,
+            controlPlane: options.controlPlane,
+            commandId: options.command.command_id,
+            roundId: options.command.clarification_round_ref,
+            payload: { body: source.content.text },
+            author: {
+                ...(options.command.actor.kind === "bot" ? { kind: "development_operator" } : {}),
+                account_ref: options.command.actor.account_ref,
+                display_name: options.command.actor.display_name,
+            },
+            idempotencyContext: {
+                binding_ref: options.command.binding_ref,
+                external_message_ref: source.locator.message_ref,
+            },
+            afterCreate: (tx, message) => insertExternalSourceEvidence(tx, options.command, message),
+            ...(options.now === undefined ? {} : { now: options.now }),
+        });
+        if (response.disposition.kind === "created" && response.result?.message !== undefined)
+            return { kind: "created", message_id: response.result.message.id };
+        if (response.disposition.kind === "interrupted")
+            return { kind: "host_unavailable", retryable: true, reason_code: "command_interrupted" };
+        return { kind: "invalid", reason_code: `clarification_${response.disposition.kind}` };
+    }
     const response = ingestMainChatMessage({
         store: options.store,
         events: options.events,

package/dist/collaboration-ingestion/index.d.ts

@@ -5,4 +5,6 @@ export { ingestTrustedManagedReference, readManagedReferenceSourcePaths, type In
 export { ingestReferenceFile, REFERENCE_FILE_INGESTION_COMMAND_NAME, REFERENCE_FILE_INGESTION_TARGET_REF, toReferenceFileProjection, type IngestReferenceFileOptions, } from "./reference-files.js";
 export { ingestTrustedReferenceAttachment, TRUSTED_INTEGRATION_REFERENCE_ATTACHMENT_PATH, type IngestTrustedReferenceAttachmentOptions, type ResolvedReferenceAttachmentContent, } from "./reference-attachments.js";
 export type { ChatAssistantEnqueuer, ReferenceSummaryStarter, ScratchpadSourceNotifier, TrustedCollaborationAuthor, } from "./types.js";
+export { ingestClarificationMessage, submitClarificationAnswers } from "./clarification.js";
+export { executeTrustedClarification } from "./platform-clarification.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/collaboration-ingestion/index.js

@@ -4,4 +4,6 @@ export { ingestManagedReferenceSnapshot, publishManagedReferenceSnapshotChanged,
 export { ingestTrustedManagedReference, readManagedReferenceSourcePaths, } from "./managed-reference-sources.js";
 export { ingestReferenceFile, REFERENCE_FILE_INGESTION_COMMAND_NAME, REFERENCE_FILE_INGESTION_TARGET_REF, toReferenceFileProjection, } from "./reference-files.js";
 export { ingestTrustedReferenceAttachment, TRUSTED_INTEGRATION_REFERENCE_ATTACHMENT_PATH, } from "./reference-attachments.js";
+export { ingestClarificationMessage, submitClarificationAnswers } from "./clarification.js";
+export { executeTrustedClarification } from "./platform-clarification.js";
 //# sourceMappingURL=index.js.map

package/dist/collaboration-ingestion/platform-clarification.d.ts

@@ -0,0 +1,10 @@
+import { type TrustedClarificationCommand, type IntegrationClarificationResponse } from "@tutti/shared/schemas/internal";
+import type { Phase5ControlPlane } from "../control-plane/index.js";
+import type { HostProjectStore } from "../store/index.js";
+export declare function executeTrustedClarification(options: {
+    store: HostProjectStore;
+    controlPlane: Phase5ControlPlane;
+    command: TrustedClarificationCommand;
+    now?: () => Date;
+}): IntegrationClarificationResponse;
+//# sourceMappingURL=platform-clarification.d.ts.map

package/dist/collaboration-ingestion/platform-clarification.js

@@ -0,0 +1,42 @@
+import { isTrustedClarificationCommand, } from "@tutti/shared/schemas/internal";
+import { readActiveClarificationProjection, readClarificationRoundProjection, readClarificationThreadResponse, } from "../collaboration-state/index.js";
+import { submitClarificationAnswers } from "./clarification.js";
+export function executeTrustedClarification(options) {
+    const { command, store } = options;
+    if (!isTrustedClarificationCommand(command))
+        return {
+            protocol_version: 1,
+            disposition: { kind: "invalid", reason_code: "trusted_clarification_invalid" },
+        };
+    if (command.operation.kind === "submit")
+        return {
+            protocol_version: 1,
+            disposition: {
+                kind: "submitted",
+                response: submitClarificationAnswers({
+                    store,
+                    controlPlane: options.controlPlane,
+                    commandId: command.command_id,
+                    roundId: command.operation.round_id,
+                    payload: { expected_answer_revision: command.operation.expected_answer_revision },
+                    ...(options.now === undefined ? {} : { now: options.now }),
+                }),
+            },
+        };
+    const round = command.operation.round_id === undefined
+        ? null
+        : readClarificationRoundProjection(store.db, command.operation.round_id);
+    const thread = round === null
+        ? null
+        : readClarificationThreadResponse(store.db, round.thread_id)
+            ?.thread;
+    return {
+        protocol_version: 1,
+        disposition: {
+            kind: "queried",
+            active: readActiveClarificationProjection(store.db),
+            ...(round === null || thread == null ? {} : { selected: { round, thread } }),
+        },
+    };
+}
+//# sourceMappingURL=platform-clarification.js.map

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

@@ -1,5 +1,5 @@
-import { createMessageId, } from "@tutti/shared/ids";
-import { clampLimit, decodeCursor, messageCursor, nowIso, stringifyJson, } from "./serialization.js";
+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";
@@ -7,6 +7,7 @@ export function createClarificationRoundMessage(db, input) {
     const createdAt = nowIso(input.now);
     const id = createMessageId();
     const refs = {
+        ...(input.refs ?? {}),
         clarification_round_ref: input.round_id,
     };
     db.prepare(`

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

@@ -4,7 +4,7 @@ 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 mapClarificationRoundRow(row: ClarificationRoundRow, db: SqliteDatabase): 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;

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

@@ -1,4 +1,5 @@
 import { parseJson } from "./serialization.js";
+import { readClarificationAnswerRevision } from "./clarification-snapshot.js";
 export function mapClarificationThreadRow(row) {
     const thread = {
         id: row.id,
@@ -26,7 +27,7 @@ export function mapClarificationThreadRow(row) {
     }
     return thread;
 }
-export function mapClarificationRoundRow(row) {
+export function mapClarificationRoundRow(row, db) {
     const round = {
         id: row.id,
         thread_id: row.clarification_thread_id,
@@ -38,6 +39,7 @@ export function mapClarificationRoundRow(row) {
         }),
         card_message_id: row.card_message_id,
         opening_message_id: row.opening_message_id,
+        answer_revision: readClarificationAnswerRevision(db, row.id),
         successor_status: row.successor_status,
         capabilities: {
             send_message: row.status === "writable",
@@ -99,7 +101,7 @@ export function readActiveClarificationProjection(db) {
     return {
         state: "active",
         thread: mapClarificationThreadRow(row),
-        round: mapClarificationRoundRow(round),
+        round: mapClarificationRoundRow(round, db),
     };
 }
 export function readSealedClarificationRoundsWithoutSuccessor(db) {
@@ -120,7 +122,7 @@ export function readSealedClarificationRoundsWithoutSuccessor(db) {
         return [
             {
                 thread: mapClarificationThreadRow(thread),
-                round: mapClarificationRoundRow(roundRow),
+                round: mapClarificationRoundRow(roundRow, db),
             },
         ];
     });
@@ -142,7 +144,7 @@ export function deleteStaleClarificationSubmitReplayHints(db) {
 }
 export function readClarificationRoundProjection(db, roundId) {
     const row = readClarificationRoundRow(db, roundId);
-    return row === null ? null : mapClarificationRoundRow(row);
+    return row === null ? null : mapClarificationRoundRow(row, db);
 }
 export function readClarificationRoundsForThread(db, threadId, options = {}) {
     const rows = options.throughRoundIndex === undefined
@@ -163,7 +165,7 @@ export function readClarificationRoundsForThread(db, threadId, options = {}) {
               ORDER BY round_index ASC
             `)
             .all(threadId, options.throughRoundIndex);
-    return rows.map((row) => mapClarificationRoundRow(row));
+    return rows.map((row) => mapClarificationRoundRow(row, db));
 }
 export function readTaskCompileClarificationRoundsByWorkflowRef(db, workflowRef) {
     const threads = db

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

@@ -114,7 +114,7 @@ export function openTaskCompileClarificationRound(db, input) {
     }
     return {
         thread: mapClarificationThreadRow(thread),
-        round: mapClarificationRoundRow(round),
+        round: mapClarificationRoundRow(round, db),
         card_message: mapMessageRow(cardMessage, db),
         opening_message: mapMessageRow(openingMessage),
     };
@@ -219,8 +219,8 @@ export function openNextTaskCompileClarificationRound(db, input) {
     }
     return {
         thread: mapClarificationThreadRow(thread),
-        previous_round: mapClarificationRoundRow(previousRound),
-        round: mapClarificationRoundRow(round),
+        previous_round: mapClarificationRoundRow(previousRound, db),
+        round: mapClarificationRoundRow(round, db),
         card_message: mapMessageRow(cardMessage, db),
         opening_message: mapMessageRow(openingMessage),
     };
@@ -337,8 +337,8 @@ export function openNextTaskBoundClarificationRound(db, input) {
     }
     return {
         thread: mapClarificationThreadRow(thread),
-        previous_round: mapClarificationRoundRow(previousRound),
-        round: mapClarificationRoundRow(round),
+        previous_round: mapClarificationRoundRow(previousRound, db),
+        round: mapClarificationRoundRow(round, db),
         task,
         card_message: mapMessageRow(cardMessage, db),
         opening_message: mapMessageRow(openingMessage),

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

@@ -0,0 +1,228 @@
+import type { ClarificationRoundRef } from "@tutti/shared/ids";
+import type { SqliteDatabase } from "../store/index.js";
+/** Round messages are append-only; the eligible answer count is a stable CAS revision. */
+export declare function readClarificationAnswerRevision(db: SqliteDatabase, roundId: ClarificationRoundRef): number;
+/** Read the immutable submitted refs, not a first page or messages appended after sealing. */
+export declare function readSubmittedClarificationMessages(db: SqliteDatabase, roundId: ClarificationRoundRef): {
+    clarification_card?: {
+        title?: string;
+        status: "writable" | "sealed";
+        round_id: string;
+        thread_id: string;
+        summary: string;
+        is_current_round: boolean;
+    };
+    refs?: {
+        task_id?: string;
+        activity_ref?: string;
+        artifact_feedback?: {
+            summary?: string;
+            kind: "artifact_feedback";
+            version: 1;
+            preview_generation: string;
+            annotations: {
+                document_url: string;
+                comment: string;
+                target: {
+                    fallback_context?: {
+                        snapshot: {
+                            role?: string;
+                            accessible_name?: string;
+                            text_excerpt?: string;
+                            state?: {
+                                expanded?: boolean;
+                                selected?: boolean;
+                                checked?: boolean;
+                                pressed?: boolean;
+                                disabled?: boolean;
+                            };
+                            tag_name: string;
+                            element_kind: "content" | "control" | "container";
+                            context: {
+                                role?: string;
+                                accessible_name?: string;
+                                tag_name: string;
+                            }[];
+                        };
+                        anchor: {
+                            explicit_anchor?: string;
+                            stable_attributes?: {
+                                id?: string;
+                                test_id?: string;
+                            };
+                            version: 1;
+                            semantic_path: {
+                                role?: string;
+                                accessible_name?: string;
+                            }[];
+                            selector_path: {
+                                root: "document" | "open_shadow_root";
+                                selector: string;
+                            }[];
+                        };
+                    };
+                    snapshot: {
+                        role?: string;
+                        accessible_name?: string;
+                        text_excerpt?: string;
+                        state?: {
+                            expanded?: boolean;
+                            selected?: boolean;
+                            checked?: boolean;
+                            pressed?: boolean;
+                            disabled?: boolean;
+                        };
+                        tag_name: string;
+                        element_kind: "content" | "control" | "container";
+                        context: {
+                            role?: string;
+                            accessible_name?: string;
+                            tag_name: string;
+                        }[];
+                    };
+                    anchor: {
+                        explicit_anchor?: string;
+                        stable_attributes?: {
+                            id?: string;
+                            test_id?: string;
+                        };
+                        version: 1;
+                        semantic_path: {
+                            role?: string;
+                            accessible_name?: string;
+                        }[];
+                        selector_path: {
+                            root: "document" | "open_shadow_root";
+                            selector: string;
+                        }[];
+                    };
+                };
+            }[];
+            artifact_title: string;
+            inspector_version: 1;
+        };
+        reference_file?: {
+            media_type?: string;
+            blob_oid?: string;
+            path: string;
+            name: string;
+            source: "human_upload" | "tutti_output";
+            category: "file" | "image";
+            size_bytes: number;
+            text_read: {
+                blocked_reason?: "unknown" | "binary" | "too_large" | "unsupported_encoding" | "restricted_path" | "secret_like";
+                can_read: boolean;
+            };
+        };
+        workflow_ref?: string;
+        clarification_round_ref?: string;
+        clarification_thread_ref?: string;
+        task_result?: {
+            error_code?: string;
+            activity_ref?: string;
+            generated_files?: {
+                media_type?: string;
+                group?: string;
+                path: string;
+                name: string;
+                size_bytes: number;
+            }[];
+            module_name?: string;
+            latest_run_result_id?: string;
+            retry_action?: "retryable" | "retried";
+            final_note?: string;
+            status: "completed" | "failed";
+            kind: "task_result";
+            task_id: string;
+            title: string;
+            summary: string;
+            task_title: string;
+            result_key: string;
+        };
+        worklist_compile?: {
+            kind: "worklist_compile";
+            title: string;
+            workflow_ref: string;
+            tasks: {
+                status: "failed" | "done" | "pending" | "todo" | "running";
+                task_id: string;
+                title: string;
+                summary: string;
+                module_id: string;
+                module_name: string;
+            }[];
+            task_count: number;
+        };
+        artifact_preview?: {
+            task_id?: string;
+            run_result_id?: string;
+            status: "available" | "updated";
+            kind: "artifact_preview";
+            title: string;
+        };
+        development_operator?: true;
+        external_reference_reads?: string[];
+        external_references?: {
+            name: string;
+            kind: "feishu_docx" | "feishu_drive_file" | "feishu_file" | "feishu_image";
+            created_at: string;
+            source_ref: string;
+        }[];
+        scratchpad_source?: "include" | "exclude";
+        worklist_feedback?: {
+            generated_files?: {
+                media_type?: string;
+                group?: string;
+                path: string;
+                name: string;
+                size_bytes: number;
+            }[];
+            final_note?: string;
+            primary_task_id?: string;
+            status: "completed" | "failed";
+            kind: "worklist_terminal";
+            items: {
+                module_name?: string;
+                latest_run_result_id?: string;
+                status: "failed" | "done";
+                task_id: string;
+                title: string;
+                summary: string;
+            }[];
+            title: string;
+            reason: "all_tasks_done" | "run_failed";
+            counters: {
+                completed: number;
+                failed: number;
+                remaining: number;
+            };
+            feedback_key: string;
+        };
+    };
+    scope: {
+        kind: "main_chat";
+    } | {
+        kind: "clarification_round";
+        clarification_round_ref: string;
+    };
+    id: string;
+    author: {
+        ref?: string;
+        display_name?: string;
+        avatar?: {
+            kind: "initials";
+            initials: string;
+            color: "neutral" | "green" | "blue" | "yellow";
+        } | {
+            kind: "image";
+            initials: string;
+            color: "neutral" | "green" | "blue" | "yellow";
+            image_url: string;
+        };
+        kind: "human" | "system" | "agent";
+    };
+    body: string;
+    created_at: string;
+    message_kind: "user_text" | "agent_text" | "system_notice" | "clarification_request" | "clarification_card";
+}[];
+//# sourceMappingURL=clarification-snapshot.d.ts.map