@xfey/tutti 0.1.126 → 0.1.128

package/dist/chat-assistant/index.js

@@ -1,10 +1,16 @@
+import { linkChatRequestInvocation } from "./requests.js";
+import { createEventRef, ID_PREFIXES, isPrefixedId, } from "@tutti/shared/ids";
 import { createChatAssistantDiagnostics } from "./diagnostics.js";
 import { createClarificationRoundAgentMessage, createMainChatAgentMessage, readClarificationRoundMessagesWindow, readClarificationRoundProjection, readMainChatMessageWindow, readMainChatMessagesBeforeCursor, readMessageProjectionById, } from "../collaboration-state/index.js";
-import { renderPromptTemplate } from "../prompt-templates/index.js";
+import { renderLanguageAwarePrompt } from "../communication-language/prompt.js";
+import { languageDiagnosticFields } from "../communication-language/index.js";
+import { chatLanguageContext } from "./language-context.js";
 import { withHostStoreTransaction, } from "../store/index.js";
 import { messageTextForModel, messageTextForTuttiMention, } from "../collaboration-state/message-context.js";
 import { externalReferenceMessageContext } from "../reference-access/message-context.js";
 import { readExternalReferenceReadSources } from "../reference-access/read-evidence.js";
+import { chatFailure, chatFailureMessage, classifyChatFailure } from "./failures.js";
+import { countQueuedChatRequests, insertChatRequest, listRunningChatRequests, nextQueuedChatRequest, readChatRequest, updateChatRequest, } from "./requests.js";
 const CHAT_ASSISTANT_CONTEXT_MESSAGE_LIMIT = 3;
 const CHAT_ASSISTANT_ROUND_MESSAGE_LIMIT = 50;
 const CHAT_ASSISTANT_ROUND_MESSAGE_MAX_CHARS = 2_000;
@@ -43,9 +49,6 @@ function normalizeAnswer(answer) {
     }
     return `${trimmed.slice(0, CHAT_ASSISTANT_MAX_ANSWER_CHARS - 3)}...`;
 }
-function assistantFailureMessage() {
-    return "Tutti could not complete this read-only answer. Try again later, or add more context in chat.";
-}
 function messageToContext(message) {
     const authorDisplayName = message.author.display_name?.trim();
     return {
@@ -103,46 +106,112 @@ function roundMessagesToContext(messages) {
 }
 export class ReadOnlyChatAssistant {
     options;
-    pending = [];
     idleWaiters = new Set();
     active = null;
     accepting = true;
     maxQueuedMentions;
+    recoveryTimer;
+    started = false;
+    activeAttemptRef;
+    storageFailureReported = false;
     constructor(options) {
         this.options = options;
-        this.maxQueuedMentions = options.maxQueuedMentions ?? 8;
+        this.maxQueuedMentions = Math.max(1, options.maxQueuedMentions ?? 8);
     }
-    enqueue(input) {
-        if (input.message.author.kind !== "human" &&
-            !(input.message.author.kind === "system" && input.message.refs?.development_operator === true)) {
-            return { triggered: false };
-        }
-        if (!containsTuttiMention(messageTextForTuttiMention(input.message))) {
-            return { triggered: false };
-        }
-        if (!this.accepting) {
-            return { triggered: false };
+    /** Call once after Host recovery/transport wiring. No old messages are backfilled. */
+    start() {
+        if (this.started || !this.accepting)
+            return;
+        this.started = true;
+        for (const row of listRunningChatRequests(this.options.store.db)) {
+            if (row.attempt_ref === this.activeAttemptRef)
+                continue;
+            if (row.phase === "workspace_wait") {
+                updateChatRequest(this.options.store.db, row, { status: "queued", phase: "queue" }, this.now());
+                continue;
+            }
+            const failure = chatFailure("host_restarted");
+            const recovered = updateChatRequest(this.options.store.db, row, {
+                status: "failed",
+                phase: "settled",
+                failure,
+            }, this.now());
+            const message = readMessageProjectionById(this.options.store.db, row.trigger_message_id);
+            if (recovered && message) {
+                this.report(message, recovered)({ stage: "failed", error_code: "host_restarted", diagnostic_id: failure.diagnostic_id });
+                try {
+                    this.appendAssistantMessageForTrigger(message, chatFailureMessage(failure), recovered, failure);
+                }
+                catch {
+                    this.report(message, recovered)({ stage: "failed", reason_code: "reply_failed" });
+                }
+            }
         }
-        const report = createChatAssistantDiagnostics({
+        // A lost post-commit wake must not strand a durable queued request.
+        this.recoveryTimer = setInterval(() => this.pump(), 1_000);
+        this.recoveryTimer.unref?.();
+        this.pump();
+    }
+    register(tx, message) {
+        if (!this.accepting ||
+            (message.author.kind !== "human" &&
+                !(message.author.kind === "system" && message.refs?.development_operator === true)) ||
+            !containsTuttiMention(messageTextForTuttiMention(message)) ||
+            readChatRequest(tx, message.id) !== null)
+            return;
+        insertChatRequest(tx, message.id, this.now(), countQueuedChatRequests(tx) >= this.maxQueuedMentions
+            ? chatFailure("chat_queue_full")
+            : undefined);
+    }
+    now() {
+        return (this.options.now?.() ?? new Date()).toISOString();
+    }
+    report(message, request) {
+        return createChatAssistantDiagnostics({
             ...(this.options.logger === undefined ? {} : { logger: this.options.logger }),
             projectId: this.options.project.project_id,
-            triggerMessageId: input.message.id,
-            scope: input.message.scope.kind,
+            triggerMessageId: message.id,
+            scope: message.scope.kind,
+            requestRef: message.id,
+            ...(request.attempt_ref === null ? {} : { attemptRef: request.attempt_ref }),
         });
-        if (this.pending.length >= this.maxQueuedMentions) {
-            report({ stage: "failed", reason_code: "queue_full" });
-            this.appendAssistantMessageForTrigger(input.message, assistantFailureMessage(), {
-                scratchpad_source: "exclude",
+    }
+    enqueue(input) {
+        if (!this.accepting)
+            return { triggered: false };
+        withHostStoreTransaction(this.options.store.db, (tx) => this.register(tx, input.message));
+        const request = readChatRequest(this.options.store.db, input.message.id);
+        if (request === null)
+            return { triggered: false };
+        if (request.status === "failed" &&
+            request.response_message_id === null &&
+            request.failure_json !== null) {
+            const report = this.report(input.message, request);
+            const failure = JSON.parse(request.failure_json);
+            report({
+                stage: "failed",
+                reason_code: failure.code === "chat_queue_full" ? "queue_full" : "reply_failed",
+                diagnostic_id: failure.diagnostic_id,
             });
+            try {
+                this.appendAssistantMessageForTrigger(input.message, chatFailureMessage(failure), request, failure);
+            }
+            catch {
+                // The original message and failed request are already accepted.
+                report({
+                    stage: "notification_failed",
+                    reason_code: "reply_failed",
+                    diagnostic_id: failure.diagnostic_id,
+                });
+            }
             return { triggered: true };
         }
-        report({ stage: "queued" });
-        this.pending.push({ message: input.message, report });
         this.pump();
         return { triggered: true };
     }
     async waitForIdle() {
-        if (this.active === null && this.pending.length === 0) {
+        if (this.active === null &&
+            (!this.accepting || nextQueuedChatRequest(this.options.store.db) === null)) {
             return;
         }
         await new Promise((resolve) => this.idleWaiters.add(resolve));
@@ -152,36 +221,102 @@ export class ReadOnlyChatAssistant {
             return;
         }
         this.accepting = false;
-        for (const { message, report } of this.pending.splice(0)) {
-            report({ stage: "skipped", reason_code: "stopping" });
-            this.appendAssistantMessageForTrigger(message, assistantFailureMessage(), {
-                scratchpad_source: "exclude",
-            });
-        }
+        if (this.recoveryTimer !== undefined)
+            clearInterval(this.recoveryTimer);
         this.resolveIdleIfNeeded();
     }
     pump() {
-        if (this.active !== null) {
+        try {
+            this.pumpNext();
+            this.storageFailureReported = false;
+        }
+        catch {
+            this.reportStorageFailure();
+        }
+    }
+    reportStorageFailure() {
+        if (this.storageFailureReported)
+            return;
+        this.storageFailureReported = true;
+        try {
+            this.options.logger?.warn({
+                project_id: this.options.project.project_id,
+                stage: "queue_storage_failed",
+                diagnostic_id: createEventRef(),
+            }, "Chat request queue storage unavailable");
+        }
+        catch {
+            /* Diagnostics cannot replace durable recovery. */
+        }
+    }
+    pumpNext() {
+        if (this.active !== null)
+            return;
+        if (!this.accepting) {
+            this.resolveIdleIfNeeded();
             return;
         }
-        const pending = this.pending.shift();
-        if (pending === undefined) {
+        const pending = nextQueuedChatRequest(this.options.store.db);
+        if (pending === null) {
             this.resolveIdleIfNeeded();
             return;
         }
-        const task = this.respond(pending.message, pending.report).catch(() => {
-            pending.report({ stage: "failed", reason_code: "reply_failed" });
+        const request = updateChatRequest(this.options.store.db, pending, {
+            status: "running",
+            phase: "workspace_wait",
+            attemptRef: createEventRef(),
+        }, this.now());
+        if (request === null)
+            return;
+        this.activeAttemptRef = request.attempt_ref;
+        const message = readMessageProjectionById(this.options.store.db, request.trigger_message_id);
+        if (message === null)
+            throw new Error("chat_request_source_missing");
+        const report = this.report(message, request);
+        report({ stage: "queued" });
+        const task = this.respond(message, request, report).catch(() => {
+            // Do not overwrite a committed success when only notification delivery failed.
+            try {
+                const current = readChatRequest(this.options.store.db, message.id);
+                if (current?.status === "running" && current.attempt_ref === request.attempt_ref) {
+                    const failure = chatFailure("chat_reply_persistence_failed", request.attempt_ref);
+                    updateChatRequest(this.options.store.db, current, {
+                        status: "failed",
+                        phase: "settled",
+                        failure,
+                    }, this.now());
+                    report({
+                        stage: "failed",
+                        reason_code: "reply_failed",
+                        error_code: "chat_reply_persistence_failed",
+                        diagnostic_id: failure.diagnostic_id,
+                    });
+                }
+                else if (current !== null &&
+                    current.response_message_id !== null &&
+                    current.attempt_ref === request.attempt_ref) {
+                    report({ stage: "notification_failed", reason_code: "reply_failed" });
+                }
+                else {
+                    report({ stage: "skipped", reason_code: "request_changed" });
+                }
+            }
+            catch {
+                this.reportStorageFailure();
+            }
         });
         this.active = task;
         void task.finally(() => {
             if (this.active === task) {
                 this.active = null;
+                this.activeAttemptRef = undefined;
                 this.pump();
             }
         });
     }
     resolveIdleIfNeeded() {
-        if (this.active !== null || this.pending.length !== 0) {
+        if (this.active !== null ||
+            (this.accepting && nextQueuedChatRequest(this.options.store.db) !== null)) {
             return;
         }
         for (const resolve of this.idleWaiters) {
@@ -241,20 +376,27 @@ export class ReadOnlyChatAssistant {
         }
         return this.buildMainChatContext(triggerMessage);
     }
-    renderPrompt(triggerMessage) {
+    renderPrompt(triggerMessage, report) {
         const context = this.buildContext(triggerMessage);
         if (context === null) {
             return null;
         }
-        return renderPromptTemplate({
+        const language = chatLanguageContext(this.options.store.db, triggerMessage, {
+            mainChat: CHAT_ASSISTANT_CONTEXT_MESSAGE_LIMIT,
+            round: CHAT_ASSISTANT_ROUND_MESSAGE_LIMIT,
+        });
+        report({ stage: "language_context", ...languageDiagnosticFields(language) });
+        return renderLanguageAwarePrompt({
             templateKey: "chat.assistant",
-            ...(this.options.promptsRoot === undefined ? {} : { promptsRoot: this.options.promptsRoot }),
+            ...(this.options.promptsRoot === undefined
+                ? {}
+                : { promptsRoot: this.options.promptsRoot }),
             variables: {
                 assistant_context_json: context,
             },
-        });
+        }, language);
     }
-    appendMainChatAssistantMessage(triggerMessage, body, refs) {
+    appendMainChatAssistantMessage(triggerMessage, body, request, failure, refs) {
         let afterCommit;
         const message = withHostStoreTransaction(this.options.store.db, (tx) => {
             const responseMessage = createMainChatAgentMessage(tx, {
@@ -270,6 +412,7 @@ export class ReadOnlyChatAssistant {
             if (typeof callback === "function") {
                 afterCommit = callback;
             }
+            this.recordReply(tx, request, responseMessage.id, failure);
             return responseMessage;
         });
         afterCommit?.();
@@ -301,6 +444,7 @@ export class ReadOnlyChatAssistant {
             });
             if (typeof callback === "function")
                 afterCommit = callback;
+            this.recordReply(tx, input.request, responseMessage.id, input.failure);
             return responseMessage;
         });
         afterCommit?.();
@@ -323,36 +467,75 @@ export class ReadOnlyChatAssistant {
             invalidates,
         });
     }
-    appendAssistantMessageForTrigger(triggerMessage, body, refs) {
+    appendAssistantMessageForTrigger(triggerMessage, body, request, failure, refs) {
+        if (failure !== undefined)
+            refs = { ...refs, scratchpad_source: "exclude" };
         if (triggerMessage.scope.kind === "clarification_round") {
             this.appendClarificationRoundAssistantMessage({
                 triggerMessage,
                 roundId: triggerMessage.scope.clarification_round_ref,
                 body,
+                request,
+                ...(failure === undefined ? {} : { failure }),
                 ...(refs === undefined ? {} : { refs }),
             });
             return;
         }
-        this.appendMainChatAssistantMessage(triggerMessage, body, refs);
+        this.appendMainChatAssistantMessage(triggerMessage, body, request, failure, refs);
+    }
+    recordReply(tx, request, messageId, failure) {
+        if (!updateChatRequest(tx, request, {
+            status: failure ? "failed" : "succeeded",
+            phase: "settled",
+            responseMessageId: messageId,
+            ...(failure === undefined ? {} : { failure }),
+        }, this.now()))
+            throw new Error("chat_request_changed");
     }
-    async respond(triggerMessage, report) {
+    async respond(triggerMessage, request, report) {
         let answer;
         let invocationRef;
         let readSources = [];
         try {
             report({ stage: "inspection_wait" });
             await this.options.waitForInspectionAvailability?.();
-            const prompt = this.renderPrompt(triggerMessage);
+            if (!this.accepting) {
+                updateChatRequest(this.options.store.db, request, { status: "queued", phase: "queue" }, this.now());
+                return;
+            }
+            const prompt = this.renderPrompt(triggerMessage, report);
             if (prompt === null) {
                 report({ stage: "skipped", reason_code: "context_unavailable" });
+                updateChatRequest(this.options.store.db, request, {
+                    status: "failed",
+                    phase: "settled",
+                    failure: chatFailure("chat_context_unavailable", request.attempt_ref),
+                }, this.now());
                 return;
             }
+            const executing = updateChatRequest(this.options.store.db, request, {
+                status: "running",
+                phase: "answer",
+            }, this.now());
+            if (executing === null)
+                return;
+            request = executing;
             report({ stage: "model_requested" });
             const output = await this.options.model.answer({
                 prompt,
                 onProgress: (event) => {
-                    if (event.stage === "context_ready")
-                        invocationRef = event.invocation_ref;
+                    if (event.stage === "context_ready") {
+                        if (typeof event.invocation_ref === "string" &&
+                            isPrefixedId(event.invocation_ref, ID_PREFIXES.event)) {
+                            invocationRef = event.invocation_ref;
+                            try {
+                                linkChatRequestInvocation(this.options.store.db, request, invocationRef);
+                            }
+                            catch {
+                                report({ stage: "notification_failed" });
+                            }
+                        }
+                    }
                     report(event);
                 },
             });
@@ -361,16 +544,20 @@ export class ReadOnlyChatAssistant {
                 readSources = readExternalReferenceReadSources(this.options.store.db, invocationRef);
             }
         }
-        catch {
-            report({ stage: "failed", reason_code: "answer_failed" });
-            this.appendAssistantMessageForTrigger(triggerMessage, assistantFailureMessage(), {
-                scratchpad_source: "exclude",
+        catch (error) {
+            const failure = classifyChatFailure(error, request.attempt_ref);
+            report({
+                stage: "failed",
+                reason_code: "answer_failed",
+                error_code: failure.code,
+                diagnostic_id: failure.diagnostic_id,
             });
+            this.appendAssistantMessageForTrigger(triggerMessage, chatFailureMessage(failure), request, failure);
             report({ stage: "reply_persisted" });
             return;
         }
         // Persistence/outbound-hook failure must not retry by creating a second reply.
-        this.appendAssistantMessageForTrigger(triggerMessage, answer, readSources.length === 0 ? undefined : { external_reference_reads: readSources });
+        this.appendAssistantMessageForTrigger(triggerMessage, answer, request, undefined, readSources.length === 0 ? undefined : { external_reference_reads: readSources });
         report({ stage: "reply_persisted", reference_source_count: readSources.length });
     }
 }

package/dist/chat-assistant/language-context.d.ts

@@ -0,0 +1,8 @@
+import type { MessageProjection } from "@tutti/shared/schemas/api";
+import type { SqliteDatabase } from "../store/index.js";
+/** Same compact scope as Q&A, never boundary-after main chat for a round. */
+export declare function chatLanguageContext(db: SqliteDatabase, trigger: MessageProjection, limits: {
+    mainChat: number;
+    round: number;
+}): import("../communication-language/index.js").CommunicationLanguageContext;
+//# sourceMappingURL=language-context.d.ts.map

package/dist/chat-assistant/language-context.js

@@ -0,0 +1,41 @@
+import { readActiveClarificationProjection, readClarificationRoundMessagesWindow, readMainChatMessageWindow, readTaskProjection, } from "../collaboration-state/index.js";
+import { readCommunicationLanguage } from "../collaboration-state/communication-language.js";
+import { createLanguageContext, messageLanguageEvidence } from "../communication-language/index.js";
+/** Same compact scope as Q&A, never boundary-after main chat for a round. */
+export function chatLanguageContext(db, trigger, limits) {
+    let inherited = readCommunicationLanguage(db);
+    let messages;
+    if (trigger.scope.kind === "main_chat") {
+        messages = readMainChatMessageWindow(db, { limit: limits.mainChat }).items;
+    }
+    else {
+        messages =
+            readClarificationRoundMessagesWindow(db, trigger.scope.clarification_round_ref, {
+                anchor: "start",
+                limit: limits.round,
+            })?.items ?? [];
+        const active = readActiveClarificationProjection(db);
+        // A task/compile round must not inherit a newer project-wide language choice.
+        inherited = null;
+        if (active.state === "active" && active.round.id === trigger.scope.clarification_round_ref) {
+            const owner = active.thread.owner;
+            const task = owner.kind === "task" ? readTaskProjection(db, owner.task_id) : null;
+            const workflowRef = owner.kind === "task_compile" ? owner.workflow_ref : task?.created_from_workflow_ref;
+            inherited =
+                (task === null ? null : readCommunicationLanguage(db, { kind: "task", ref: task.id })) ??
+                    (workflowRef === undefined
+                        ? null
+                        : readCommunicationLanguage(db, { kind: "workflow", ref: workflowRef }));
+        }
+    }
+    return createLanguageContext({
+        scope: "reply",
+        inherited,
+        messages: [
+            ...messages.filter((message) => message.created_at < trigger.created_at ||
+                (message.created_at === trigger.created_at && message.id < trigger.id)),
+            trigger,
+        ].map(messageLanguageEvidence),
+    });
+}
+//# sourceMappingURL=language-context.js.map

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

@@ -0,0 +1,30 @@
+import { type ChatRequestStatus, type OperationFailure } from "@tutti/shared/schemas/api";
+import type { SqliteDatabase } from "../store/index.js";
+export type ChatRequestRecord = {
+    trigger_message_id: string;
+    status: "queued" | "running" | "succeeded" | "failed";
+    phase: "queue" | "workspace_wait" | "answer" | "settled";
+    revision: number;
+    attempt_ref: string | null;
+    response_message_id: string | null;
+    failure_json: string | null;
+    created_at: string;
+    updated_at: string;
+};
+export declare function readChatRequest(db: SqliteDatabase, messageId: string): ChatRequestRecord | null;
+export declare function chatRequestStatus(row: ChatRequestRecord): ChatRequestStatus;
+export declare function insertChatRequest(db: SqliteDatabase, messageId: string, now: string, failure?: OperationFailure): void;
+export declare function countQueuedChatRequests(db: SqliteDatabase): number;
+export declare function nextQueuedChatRequest(db: SqliteDatabase): ChatRequestRecord | null;
+/** CAS/fencing only. Lifecycle policy belongs to Chat Assistant, not the repository. */
+export declare function updateChatRequest(db: SqliteDatabase, row: ChatRequestRecord, next: {
+    status: ChatRequestRecord["status"];
+    phase: ChatRequestRecord["phase"];
+    attemptRef?: string;
+    responseMessageId?: string;
+    failure?: OperationFailure;
+}, now: string): ChatRequestRecord | null;
+export declare function listRunningChatRequests(db: SqliteDatabase): ChatRequestRecord[];
+/** Correlation only; never changes lifecycle state based on a progress callback. */
+export declare function linkChatRequestInvocation(db: SqliteDatabase, row: ChatRequestRecord, invocationRef: string): void;
+//# sourceMappingURL=requests.d.ts.map

package/dist/chat-assistant/requests.js

@@ -0,0 +1,58 @@
+import { Value } from "@sinclair/typebox/value";
+import { ChatRequestStatusSchema, } from "@tutti/shared/schemas/api";
+export function readChatRequest(db, messageId) {
+    return (db
+        .prepare("SELECT * FROM chat_requests WHERE trigger_message_id = ?")
+        .get(messageId) ?? null);
+}
+export function chatRequestStatus(row) {
+    const value = {
+        operation: { kind: "chat_answer", ref: row.trigger_message_id },
+        status: row.status,
+        phase: row.phase,
+        revision: row.revision,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+        ...(row.response_message_id === null ? {} : { response_message_id: row.response_message_id }),
+        ...(row.failure_json === null ? {} : { failure: JSON.parse(row.failure_json) }),
+    };
+    if (!Value.Check(ChatRequestStatusSchema, value))
+        throw new Error("chat_request_invalid");
+    return value;
+}
+export function insertChatRequest(db, messageId, now, failure) {
+    db.prepare(`INSERT INTO chat_requests
+    (trigger_message_id, status, phase, failure_json, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT(trigger_message_id) DO NOTHING`).run(messageId, failure ? "failed" : "queued", failure ? "settled" : "queue", failure ? JSON.stringify(failure) : null, now, now);
+}
+export function countQueuedChatRequests(db) {
+    return db
+        .prepare("SELECT count(*) AS count FROM chat_requests WHERE status = 'queued'")
+        .get().count;
+}
+export function nextQueuedChatRequest(db) {
+    return (db
+        .prepare("SELECT * FROM chat_requests WHERE status = 'queued' ORDER BY enqueue_order LIMIT 1")
+        .get() ?? null);
+}
+/** CAS/fencing only. Lifecycle policy belongs to Chat Assistant, not the repository. */
+export function updateChatRequest(db, row, next, now) {
+    const changed = db
+        .prepare(`UPDATE chat_requests SET status = ?, phase = ?,
+    attempt_ref = ?, response_message_id = ?, failure_json = ?, updated_at = ?, revision = revision + 1
+    WHERE trigger_message_id = ? AND revision = ?`)
+        .run(next.status, next.phase, next.attemptRef ?? row.attempt_ref, next.responseMessageId ?? null, next.failure ? JSON.stringify(next.failure) : null, now, row.trigger_message_id, row.revision).changes;
+    return changed === 0 ? null : readChatRequest(db, row.trigger_message_id);
+}
+export function listRunningChatRequests(db) {
+    return db
+        .prepare("SELECT * FROM chat_requests WHERE status = 'running' ORDER BY created_at, trigger_message_id")
+        .all();
+}
+/** Correlation only; never changes lifecycle state based on a progress callback. */
+export function linkChatRequestInvocation(db, row, invocationRef) {
+    db.prepare(`INSERT OR IGNORE INTO chat_request_invocations(message_id, attempt_ref, invocation_ref)
+    SELECT trigger_message_id, attempt_ref, ? FROM chat_requests
+    WHERE trigger_message_id = ? AND attempt_ref = ? AND status = 'running'`).run(invocationRef, row.trigger_message_id, row.attempt_ref);
+}
+//# sourceMappingURL=requests.js.map

package/dist/collaboration-ingestion/clarification.js

@@ -21,8 +21,10 @@ export function ingestClarificationMessage(options) {
         ...(options.now === undefined ? {} : { now: options.now }),
         execute: (tx) => {
             const result = options.controlPlane.sendClarificationRoundMessage(options.roundId, options.payload, options.author);
-            if (result.result?.message !== undefined)
+            if (result.result?.message !== undefined) {
                 options.afterCreate?.(tx, result.result.message);
+                options.chatAssistant?.register(tx, result.result.message);
+            }
             return result;
         },
     });

package/dist/collaboration-ingestion/main-chat.js

@@ -39,6 +39,7 @@ export function ingestMainChatMessage(options) {
                 ...(options.now === undefined ? {} : { now: options.now }),
             });
             options.afterCreate?.(tx, message);
+            options.chatAssistant?.register(tx, message);
             return {
                 disposition: { kind: "created", message_id: message.id },
                 result: { message },

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

@@ -1,5 +1,6 @@
 import type { AccountAvatarProjection } from "@tutti/shared/domain";
 import type { MessageProjection } from "@tutti/shared/schemas/api";
+import type { SqliteDatabase } from "../store/index.js";
 export type TrustedCollaborationAuthor = {
     kind?: "human" | "development_operator";
     account_ref: string;
@@ -10,6 +11,7 @@ export type ScratchpadSourceNotifier = {
     notify: (message: MessageProjection) => void;
 };
 export type ChatAssistantEnqueuer = {
+    register: (tx: SqliteDatabase, message: MessageProjection) => void;
     enqueue: (input: {
         message: MessageProjection;
     }) => unknown;

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

@@ -13,8 +13,9 @@ export declare function readSubmittedClarificationMessages(db: SqliteDatabase, r
         is_current_round: boolean;
     };
     refs?: {
-        task_id?: string;
         activity_ref?: string;
+        workflow_ref?: string;
+        task_id?: string;
         artifact_feedback?: {
             summary?: string;
             kind: "artifact_feedback";
@@ -106,15 +107,14 @@ export declare function readSubmittedClarificationMessages(db: SqliteDatabase, r
             blob_oid?: string;
             path: string;
             name: string;
-            source: "human_upload" | "tutti_output";
             category: "file" | "image";
+            source: "human_upload" | "tutti_output";
             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?: {
@@ -141,10 +141,10 @@ export declare function readSubmittedClarificationMessages(db: SqliteDatabase, r
         };
         worklist_compile?: {
             kind: "worklist_compile";
-            title: string;
             workflow_ref: string;
+            title: string;
             tasks: {
-                status: "failed" | "pending" | "done" | "todo" | "running";
+                status: "failed" | "pending" | "running" | "done" | "todo";
                 task_id: string;
                 title: string;
                 summary: string;