@xfey/tutti 0.1.128 → 0.1.129

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

@@ -1,18 +1,27 @@
 import type { ProviderInvocationProgress } from "../providers/invocation-progress.js";
 import type { languageDiagnosticFields } from "../communication-language/index.js";
 import type { ChatFailureCode } from "./failures.js";
+import type { WorkflowKind } from "@tutti/shared/domain";
+export type ChatInspectionBlocker = {
+    activity_ref: string;
+    activity_kind: "run" | "procedure";
+    workflow_kind?: WorkflowKind;
+};
 export type ChatAssistantLogger = {
     info: (fields: Record<string, unknown>, message: string) => void;
     warn: (fields: Record<string, unknown>, message: string) => void;
 };
 type ChatAssistantProgress = ProviderInvocationProgress | ({
     stage: "language_context";
-} & ReturnType<typeof languageDiagnosticFields>) | {
+} & ReturnType<typeof languageDiagnosticFields>) | ({
+    stage: "inspection_blocked";
+} & ChatInspectionBlocker) | {
     stage: "queued" | "inspection_wait" | "model_requested" | "reply_persisted" | "notification_failed" | "failed" | "skipped";
     reason_code?: "queue_full" | "stopping" | "context_unavailable" | "answer_failed" | "reply_failed" | "request_changed";
     error_code?: ChatFailureCode;
     diagnostic_id?: string;
     reference_source_count?: number;
+    queue_wait_ms?: number;
 };
 export declare function createChatAssistantDiagnostics(options: {
     logger?: ChatAssistantLogger;

package/dist/chat-assistant/failure-messages.d.ts

@@ -0,0 +1,4 @@
+import type { NoticeLocale } from "../communication-language/notice-locale.js";
+import type { ChatFailureCode } from "./failures.js";
+export declare function chatFailureCopy(code: ChatFailureCode, locale: NoticeLocale): string;
+//# sourceMappingURL=failure-messages.d.ts.map

package/dist/chat-assistant/failure-messages.js

@@ -0,0 +1,57 @@
+const messages = {
+    en: {
+        reference_authorization_required: "Authorize document access using the group card, then send your question again. Authorization does not restart this answer.",
+        chat_queue_full: "Tutti is busy answering other questions. Try again shortly.",
+        chat_context_unavailable: "This question's conversation is no longer available.",
+        host_restarted: "The Host restarted before this answer was saved. Send your question again.",
+        provider_not_configured: "Ask the project owner to configure model access, then send your question again.",
+        provider_auth_invalid: "Model access could not be verified. Ask the project owner to check it.",
+        provider_quota_or_billing_required: "Model credit is unavailable. Ask the project owner to check the account.",
+        provider_rate_limited: "The model service is busy. Wait a moment, then send your question again.",
+        provider_network_error: "The model service could not be reached. Try again when the connection is available.",
+        provider_model_unavailable: "The selected model is unavailable. Ask the project owner to check model access.",
+        provider_timeout: "The model did not finish answering in time. You can send your question again.",
+        provider_output_invalid: "The model did not return a usable answer. You can send your question again.",
+        provider_lifecycle_failed: "The model process could not close safely. Restart the Host before trying again.",
+        chat_reply_persistence_failed: "The answer could not be saved. Check the Host diagnostics before trying again.",
+        internal_error: "Tutti could not complete this read-only answer. Share the diagnostic ID if this persists.",
+    },
+    "zh-Hans": {
+        reference_authorization_required: "请先通过群内卡片授权文档访问，然后重新提问。授权不会自动重启这次回答。",
+        chat_queue_full: "Tutti 正在回答其他问题，请稍后再试。",
+        chat_context_unavailable: "这条问题所在的对话已不可用。",
+        host_restarted: "本机运行时在回答保存前重启了，请重新发送问题。",
+        provider_not_configured: "请联系项目负责人配置模型接入，然后重新提问。",
+        provider_auth_invalid: "无法验证模型接入，请联系项目负责人检查配置。",
+        provider_quota_or_billing_required: "模型额度不可用，请联系项目负责人检查账号。",
+        provider_rate_limited: "模型服务繁忙，请稍后重新发送问题。",
+        provider_network_error: "无法连接模型服务，请在连接恢复后再试。",
+        provider_model_unavailable: "当前模型不可用，请联系项目负责人检查模型接入。",
+        provider_timeout: "这次回答超时了，你可以重新发送问题。",
+        provider_output_invalid: "模型没有返回可用的回答，你可以重新发送问题。",
+        provider_lifecycle_failed: "模型进程未能安全关闭，请重启本机运行时后再试。",
+        chat_reply_persistence_failed: "回答未能保存，请先检查本机运行时的诊断信息。",
+        internal_error: "Tutti 未能完成这次只读回答。如果问题持续，请提供诊断编号。",
+    },
+    "zh-Hant": {
+        reference_authorization_required: "請先透過群組卡片授權文件存取，然後重新提問。授權不會自動重新啟動這次回答。",
+        chat_queue_full: "Tutti 正在回答其他問題，請稍後再試。",
+        chat_context_unavailable: "這個問題所在的對話已無法使用。",
+        host_restarted: "本機執行環境在回答儲存前重新啟動了，請重新傳送問題。",
+        provider_not_configured: "請聯絡專案負責人設定模型連線，然後重新提問。",
+        provider_auth_invalid: "無法驗證模型連線，請聯絡專案負責人檢查設定。",
+        provider_quota_or_billing_required: "模型額度無法使用，請聯絡專案負責人檢查帳號。",
+        provider_rate_limited: "模型服務忙碌，請稍後重新傳送問題。",
+        provider_network_error: "無法連線至模型服務，請在連線恢復後再試。",
+        provider_model_unavailable: "目前的模型無法使用，請聯絡專案負責人檢查模型連線。",
+        provider_timeout: "這次回答逾時了，你可以重新傳送問題。",
+        provider_output_invalid: "模型沒有傳回可用的回答，你可以重新傳送問題。",
+        provider_lifecycle_failed: "模型程序未能安全關閉，請重新啟動本機執行環境後再試。",
+        chat_reply_persistence_failed: "回答未能儲存，請先檢查本機執行環境的診斷資訊。",
+        internal_error: "Tutti 未能完成這次唯讀回答。如果問題持續，請提供診斷編號。",
+    },
+};
+export function chatFailureCopy(code, locale) {
+    return messages[locale][code];
+}
+//# sourceMappingURL=failure-messages.js.map

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

@@ -1,27 +1,27 @@
 import type { OperationFailure } from "@tutti/shared/schemas/api";
 declare const failures: {
-    readonly reference_authorization_required: readonly ["access", "none", "Authorize document access using the group card, then send your question again. Authorization does not restart this answer."];
-    readonly chat_queue_full: readonly ["capacity", "resend_request", "Tutti is busy answering other questions. Try again shortly."];
-    readonly chat_context_unavailable: readonly ["interrupted", "none", "This question's conversation is no longer available."];
-    readonly host_restarted: readonly ["interrupted", "resend_request", "The Host restarted before this answer was saved. Send your question again."];
-    readonly provider_not_configured: readonly ["configuration", "check_provider", "Ask the project owner to configure model access, then send your question again."];
-    readonly provider_auth_invalid: readonly ["access", "check_provider", "Model access could not be verified. Ask the project owner to check it."];
-    readonly provider_quota_or_billing_required: readonly ["access", "check_provider", "Model credit is unavailable. Ask the project owner to check the account."];
-    readonly provider_rate_limited: readonly ["capacity", "resend_request", "The model service is busy. Wait a moment, then send your question again."];
-    readonly provider_network_error: readonly ["dependency", "resend_request", "The model service could not be reached. Try again when the connection is available."];
-    readonly provider_model_unavailable: readonly ["configuration", "check_provider", "The selected model is unavailable. Ask the project owner to check model access."];
-    readonly provider_timeout: readonly ["dependency", "resend_request", "The model did not finish answering in time. You can send your question again."];
-    readonly provider_output_invalid: readonly ["dependency", "resend_request", "The model did not return a usable answer. You can send your question again."];
-    readonly provider_lifecycle_failed: readonly ["internal", "restart_host", "The model process could not close safely. Restart the Host before trying again."];
-    readonly chat_reply_persistence_failed: readonly ["internal", "contact_support", "The answer could not be saved. Check the Host diagnostics before trying again."];
-    readonly internal_error: readonly ["internal", "contact_support", "Tutti could not complete this read-only answer. Share the diagnostic ID if this persists."];
+    readonly reference_authorization_required: readonly ["access", "none"];
+    readonly chat_queue_full: readonly ["capacity", "resend_request"];
+    readonly chat_context_unavailable: readonly ["interrupted", "none"];
+    readonly host_restarted: readonly ["interrupted", "resend_request"];
+    readonly provider_not_configured: readonly ["configuration", "check_provider"];
+    readonly provider_auth_invalid: readonly ["access", "check_provider"];
+    readonly provider_quota_or_billing_required: readonly ["access", "check_provider"];
+    readonly provider_rate_limited: readonly ["capacity", "resend_request"];
+    readonly provider_network_error: readonly ["dependency", "resend_request"];
+    readonly provider_model_unavailable: readonly ["configuration", "check_provider"];
+    readonly provider_timeout: readonly ["dependency", "resend_request"];
+    readonly provider_output_invalid: readonly ["dependency", "resend_request"];
+    readonly provider_lifecycle_failed: readonly ["internal", "restart_host"];
+    readonly chat_reply_persistence_failed: readonly ["internal", "contact_support"];
+    readonly internal_error: readonly ["internal", "contact_support"];
 };
 export type ChatFailureCode = keyof typeof failures;
 type ChatFailure = OperationFailure & {
     code: ChatFailureCode;
 };
 export declare function chatFailure(code: ChatFailureCode, diagnosticId?: string): ChatFailure;
-export declare function chatFailureMessage(failure: OperationFailure): string;
+export declare function chatFailureMessage(failure: OperationFailure, locale?: string): string;
 export declare function classifyChatFailure(error: unknown, diagnosticId: string): ChatFailure;
 export {};
 //# sourceMappingURL=failures.d.ts.map

package/dist/chat-assistant/failures.js

@@ -1,91 +1,35 @@
 import { createEventRef } from "@tutti/shared/ids";
 import { providerFailureCode } from "../providers/failure-classification.js";
+import { noticeLocale } from "../communication-language/notice-locale.js";
+import { chatFailureCopy } from "./failure-messages.js";
 const failures = {
-    reference_authorization_required: [
-        "access",
-        "none",
-        "Authorize document access using the group card, then send your question again. Authorization does not restart this answer.",
-    ],
-    chat_queue_full: [
-        "capacity",
-        "resend_request",
-        "Tutti is busy answering other questions. Try again shortly.",
-    ],
-    chat_context_unavailable: [
-        "interrupted",
-        "none",
-        "This question's conversation is no longer available.",
-    ],
-    host_restarted: [
-        "interrupted",
-        "resend_request",
-        "The Host restarted before this answer was saved. Send your question again.",
-    ],
-    provider_not_configured: [
-        "configuration",
-        "check_provider",
-        "Ask the project owner to configure model access, then send your question again.",
-    ],
-    provider_auth_invalid: [
-        "access",
-        "check_provider",
-        "Model access could not be verified. Ask the project owner to check it.",
-    ],
-    provider_quota_or_billing_required: [
-        "access",
-        "check_provider",
-        "Model credit is unavailable. Ask the project owner to check the account.",
-    ],
-    provider_rate_limited: [
-        "capacity",
-        "resend_request",
-        "The model service is busy. Wait a moment, then send your question again.",
-    ],
-    provider_network_error: [
-        "dependency",
-        "resend_request",
-        "The model service could not be reached. Try again when the connection is available.",
-    ],
-    provider_model_unavailable: [
-        "configuration",
-        "check_provider",
-        "The selected model is unavailable. Ask the project owner to check model access.",
-    ],
-    provider_timeout: [
-        "dependency",
-        "resend_request",
-        "The model did not finish answering in time. You can send your question again.",
-    ],
-    provider_output_invalid: [
-        "dependency",
-        "resend_request",
-        "The model did not return a usable answer. You can send your question again.",
-    ],
-    provider_lifecycle_failed: [
-        "internal",
-        "restart_host",
-        "The model process could not close safely. Restart the Host before trying again.",
-    ],
-    chat_reply_persistence_failed: [
-        "internal",
-        "contact_support",
-        "The answer could not be saved. Check the Host diagnostics before trying again.",
-    ],
-    internal_error: [
-        "internal",
-        "contact_support",
-        "Tutti could not complete this read-only answer. Share the diagnostic ID if this persists.",
-    ],
+    reference_authorization_required: ["access", "none"],
+    chat_queue_full: ["capacity", "resend_request"],
+    chat_context_unavailable: ["interrupted", "none"],
+    host_restarted: ["interrupted", "resend_request"],
+    provider_not_configured: ["configuration", "check_provider"],
+    provider_auth_invalid: ["access", "check_provider"],
+    provider_quota_or_billing_required: ["access", "check_provider"],
+    provider_rate_limited: ["capacity", "resend_request"],
+    provider_network_error: ["dependency", "resend_request"],
+    provider_model_unavailable: ["configuration", "check_provider"],
+    provider_timeout: ["dependency", "resend_request"],
+    provider_output_invalid: ["dependency", "resend_request"],
+    provider_lifecycle_failed: ["internal", "restart_host"],
+    chat_reply_persistence_failed: ["internal", "contact_support"],
+    internal_error: ["internal", "contact_support"],
 };
 export function chatFailure(code, diagnosticId = createEventRef()) {
     const [category, recovery] = failures[code];
     return { code, category, recovery, diagnostic_id: diagnosticId };
 }
-export function chatFailureMessage(failure) {
-    const entry = Object.hasOwn(failures, failure.code)
-        ? failures[failure.code]
-        : failures.internal_error;
-    return `${entry[2]} Diagnostic ID: ${failure.diagnostic_id}`;
+export function chatFailureMessage(failure, locale) {
+    const language = noticeLocale(locale);
+    const code = Object.hasOwn(failures, failure.code)
+        ? failure.code
+        : "internal_error";
+    const label = language === "zh-Hans" ? "诊断编号" : language === "zh-Hant" ? "診斷編號" : "Diagnostic ID";
+    return `${chatFailureCopy(code, language)} ${label}: ${failure.diagnostic_id}`;
 }
 // Allowlisted error facts only; neither error.message nor diagnostic callbacks
 // establish business truth. Unknown failures remain non-automatically-retryable.

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

@@ -1,6 +1,6 @@
 import { type ProjectId } from "@tutti/shared/ids";
 import type { MessageProjection } from "@tutti/shared/schemas/api";
-import { type ChatAssistantLogger } from "./diagnostics.js";
+import { type ChatAssistantLogger, type ChatInspectionBlocker } from "./diagnostics.js";
 import type { ProviderInvocationProgressObserver } from "../providers/invocation-progress.js";
 import { type HostProjectStore, type SqliteDatabase } from "../store/index.js";
 import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
@@ -55,7 +55,8 @@ export type ReadOnlyChatAssistantOptions = {
         triggerMessage: MessageProjection;
         responseMessage: MessageProjection;
     }) => void | (() => void);
-    waitForInspectionAvailability?: () => Promise<void>;
+    waitForInspectionAvailability?: (onBlocked: (blocker: ChatInspectionBlocker) => void) => Promise<void>;
+    onRequestsChanged?: () => void;
     maxQueuedMentions?: number;
     now?: () => Date;
 };
@@ -83,6 +84,7 @@ export declare class ReadOnlyChatAssistant implements ReadOnlyChatAssistantHandl
     private pump;
     private reportStorageFailure;
     private pumpNext;
+    private notifyRequestsChanged;
     private resolveIdleIfNeeded;
     private buildMainChatContext;
     private buildClarificationRoundContext;

package/dist/chat-assistant/index.js

@@ -1,10 +1,11 @@
 import { linkChatRequestInvocation } from "./requests.js";
 import { createEventRef, ID_PREFIXES, isPrefixedId, } from "@tutti/shared/ids";
-import { createChatAssistantDiagnostics } from "./diagnostics.js";
+import { createChatAssistantDiagnostics, } from "./diagnostics.js";
 import { createClarificationRoundAgentMessage, createMainChatAgentMessage, readClarificationRoundMessagesWindow, readClarificationRoundProjection, readMainChatMessageWindow, readMainChatMessagesBeforeCursor, readMessageProjectionById, } from "../collaboration-state/index.js";
 import { renderLanguageAwarePrompt } from "../communication-language/prompt.js";
 import { languageDiagnosticFields } from "../communication-language/index.js";
-import { chatLanguageContext } from "./language-context.js";
+import { chatLanguageContext, chatLanguagePreference } from "./language-context.js";
+import { noticeLocale } from "../communication-language/notice-locale.js";
 import { withHostStoreTransaction, } from "../store/index.js";
 import { messageTextForModel, messageTextForTuttiMention, } from "../collaboration-state/message-context.js";
 import { externalReferenceMessageContext } from "../reference-access/message-context.js";
@@ -140,7 +141,7 @@ export class ReadOnlyChatAssistant {
             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);
+                    this.appendAssistantMessageForTrigger(message, chatFailureMessage(failure, recovered.notice_locale), recovered, failure);
                 }
                 catch {
                     this.report(message, recovered)({ stage: "failed", reason_code: "reply_failed" });
@@ -150,6 +151,7 @@ export class ReadOnlyChatAssistant {
         // A lost post-commit wake must not strand a durable queued request.
         this.recoveryTimer = setInterval(() => this.pump(), 1_000);
         this.recoveryTimer.unref?.();
+        this.notifyRequestsChanged();
         this.pump();
     }
     register(tx, message) {
@@ -161,7 +163,7 @@ export class ReadOnlyChatAssistant {
             return;
         insertChatRequest(tx, message.id, this.now(), countQueuedChatRequests(tx) >= this.maxQueuedMentions
             ? chatFailure("chat_queue_full")
-            : undefined);
+            : undefined, noticeLocale(chatLanguagePreference(tx, message)?.locale));
     }
     now() {
         return (this.options.now?.() ?? new Date()).toISOString();
@@ -194,7 +196,7 @@ export class ReadOnlyChatAssistant {
                 diagnostic_id: failure.diagnostic_id,
             });
             try {
-                this.appendAssistantMessageForTrigger(input.message, chatFailureMessage(failure), request, failure);
+                this.appendAssistantMessageForTrigger(input.message, chatFailureMessage(failure, request.notice_locale), request, failure);
             }
             catch {
                 // The original message and failed request are already accepted.
@@ -268,12 +270,16 @@ export class ReadOnlyChatAssistant {
         }, this.now());
         if (request === null)
             return;
+        this.notifyRequestsChanged();
         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" });
+        report({
+            stage: "queued",
+            queue_wait_ms: Math.max(0, Date.parse(this.now()) - Date.parse(request.created_at)),
+        });
         const task = this.respond(message, request, report).catch(() => {
             // Do not overwrite a committed success when only notification delivery failed.
             try {
@@ -310,10 +316,29 @@ export class ReadOnlyChatAssistant {
             if (this.active === task) {
                 this.active = null;
                 this.activeAttemptRef = undefined;
+                this.notifyRequestsChanged();
                 this.pump();
             }
         });
     }
+    notifyRequestsChanged() {
+        try {
+            this.options.onRequestsChanged?.();
+        }
+        catch {
+            // Maintenance wake failure cannot change a committed Chat request/reply.
+            try {
+                this.options.logger?.warn({
+                    project_id: this.options.project.project_id,
+                    stage: "maintenance_notification_failed",
+                    diagnostic_id: createEventRef(),
+                }, "Chat maintenance notification failed");
+            }
+            catch {
+                /* Diagnostics cannot replace durable recovery. */
+            }
+        }
+    }
     resolveIdleIfNeeded() {
         if (this.active !== null ||
             (this.accepting && nextQueuedChatRequest(this.options.store.db) !== null)) {
@@ -498,7 +523,7 @@ export class ReadOnlyChatAssistant {
         let readSources = [];
         try {
             report({ stage: "inspection_wait" });
-            await this.options.waitForInspectionAvailability?.();
+            await this.options.waitForInspectionAvailability?.((blocker) => report({ stage: "inspection_blocked", ...blocker }));
             if (!this.accepting) {
                 updateChatRequest(this.options.store.db, request, { status: "queued", phase: "queue" }, this.now());
                 return;
@@ -552,7 +577,7 @@ export class ReadOnlyChatAssistant {
                 error_code: failure.code,
                 diagnostic_id: failure.diagnostic_id,
             });
-            this.appendAssistantMessageForTrigger(triggerMessage, chatFailureMessage(failure), request, failure);
+            this.appendAssistantMessageForTrigger(triggerMessage, chatFailureMessage(failure, request.notice_locale), request, failure);
             report({ stage: "reply_persisted" });
             return;
         }

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

@@ -1,5 +1,7 @@
 import type { MessageProjection } from "@tutti/shared/schemas/api";
 import type { SqliteDatabase } from "../store/index.js";
+/** Shared scope boundary for model inheritance and pre-call static notices. */
+export declare function chatLanguagePreference(db: SqliteDatabase, trigger: MessageProjection): import("../collaboration-state/communication-language.js").StoredCommunicationLanguage | null;
 /** 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;

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

@@ -1,9 +1,25 @@
 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";
+/** Shared scope boundary for model inheritance and pre-call static notices. */
+export function chatLanguagePreference(db, trigger) {
+    if (trigger.scope.kind === "main_chat")
+        return readCommunicationLanguage(db);
+    const active = readActiveClarificationProjection(db);
+    // Never borrow a newer project-wide preference for a task/compile round.
+    if (active.state !== "active" || active.round.id !== trigger.scope.clarification_round_ref)
+        return null;
+    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;
+    return ((task === null ? null : readCommunicationLanguage(db, { kind: "task", ref: task.id })) ??
+        (workflowRef === undefined
+            ? null
+            : readCommunicationLanguage(db, { kind: "workflow", ref: workflowRef })));
+}
 /** Same compact scope as Q&A, never boundary-after main chat for a round. */
 export function chatLanguageContext(db, trigger, limits) {
-    let inherited = readCommunicationLanguage(db);
+    const inherited = chatLanguagePreference(db, trigger);
     let messages;
     if (trigger.scope.kind === "main_chat") {
         messages = readMainChatMessageWindow(db, { limit: limits.mainChat }).items;
@@ -14,19 +30,6 @@ export function chatLanguageContext(db, trigger, limits) {
                 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",

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

@@ -1,5 +1,6 @@
 import { type ChatRequestStatus, type OperationFailure } from "@tutti/shared/schemas/api";
 import type { SqliteDatabase } from "../store/index.js";
+import type { NoticeLocale } from "../communication-language/notice-locale.js";
 export type ChatRequestRecord = {
     trigger_message_id: string;
     status: "queued" | "running" | "succeeded" | "failed";
@@ -10,10 +11,13 @@ export type ChatRequestRecord = {
     failure_json: string | null;
     created_at: string;
     updated_at: string;
+    notice_locale: NoticeLocale;
 };
 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 insertChatRequest(db: SqliteDatabase, messageId: string, now: string, failure?: OperationFailure, noticeLocale?: NoticeLocale): void;
+/** A narrow read-only signal for deferring automatic maintenance, not Chat lifecycle ownership. */
+export declare function hasPendingChatRequests(db: SqliteDatabase): boolean;
 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. */

package/dist/chat-assistant/requests.js

@@ -20,10 +20,16 @@ export function chatRequestStatus(row) {
         throw new Error("chat_request_invalid");
     return value;
 }
-export function insertChatRequest(db, messageId, now, failure) {
+export function insertChatRequest(db, messageId, now, failure, noticeLocale = "en") {
     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);
+    (trigger_message_id, status, phase, failure_json, created_at, updated_at, notice_locale)
+    VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT(trigger_message_id) DO NOTHING`).run(messageId, failure ? "failed" : "queued", failure ? "settled" : "queue", failure ? JSON.stringify(failure) : null, now, now, noticeLocale);
+}
+/** A narrow read-only signal for deferring automatic maintenance, not Chat lifecycle ownership. */
+export function hasPendingChatRequests(db) {
+    return (db
+        .prepare("SELECT 1 AS present FROM chat_requests WHERE status IN ('queued', 'running') LIMIT 1")
+        .get() !== undefined);
 }
 export function countQueuedChatRequests(db) {
     return db

package/dist/collaboration-state/context-sync-attempts.d.ts

@@ -0,0 +1,9 @@
+import type { SqliteDatabase } from "../store/index.js";
+export declare function hasContextSyncCompletionAttempt(db: SqliteDatabase, batchKey: string): boolean;
+/** Persist before invoking the provider; failure/unknown outcome is not a retry permit. */
+export declare function recordContextSyncCompletionAttempt(db: SqliteDatabase, input: {
+    batchKey: string;
+    workflowRef: string;
+    startedAt: string;
+}): boolean;
+//# sourceMappingURL=context-sync-attempts.d.ts.map

package/dist/collaboration-state/context-sync-attempts.js

@@ -0,0 +1,13 @@
+export function hasContextSyncCompletionAttempt(db, batchKey) {
+    return (db
+        .prepare("SELECT 1 AS present FROM context_sync_completion_attempts WHERE batch_key = ?")
+        .get(batchKey) !== undefined);
+}
+/** Persist before invoking the provider; failure/unknown outcome is not a retry permit. */
+export function recordContextSyncCompletionAttempt(db, input) {
+    return (db
+        .prepare(`INSERT OR IGNORE INTO context_sync_completion_attempts(batch_key, workflow_ref, started_at)
+     VALUES (?, ?, ?)`)
+        .run(input.batchKey, input.workflowRef, input.startedAt).changes === 1);
+}
+//# sourceMappingURL=context-sync-attempts.js.map

package/dist/communication-language/notice-locale.d.ts

@@ -0,0 +1,4 @@
+/** Small static notice catalog, not language detection or a UI locale setting. */
+export type NoticeLocale = "en" | "zh-Hans" | "zh-Hant";
+export declare function noticeLocale(locale?: string | null): NoticeLocale;
+//# sourceMappingURL=notice-locale.d.ts.map

package/dist/communication-language/notice-locale.js

@@ -0,0 +1,14 @@
+export function noticeLocale(locale) {
+    if (locale === undefined || locale === null)
+        return "en";
+    try {
+        const parsed = new Intl.Locale(locale);
+        if (parsed.language !== "zh")
+            return "en";
+        return parsed.maximize().script === "Hant" ? "zh-Hant" : "zh-Hans";
+    }
+    catch {
+        return "en";
+    }
+}
+//# sourceMappingURL=notice-locale.js.map

package/dist/control-plane/context-sync-completion.d.ts

@@ -0,0 +1,7 @@
+import type { SqliteDatabase } from "../store/index.js";
+import type { ContextSyncWorkflowTrigger } from "./workflows/index.js";
+export declare function pendingContextSyncCompletion(db: SqliteDatabase): {
+    key: string;
+    trigger: ContextSyncWorkflowTrigger;
+} | undefined;
+//# sourceMappingURL=context-sync-completion.d.ts.map

package/dist/control-plane/context-sync-completion.js

@@ -0,0 +1,27 @@
+import { createHash } from "node:crypto";
+import { hasContextSyncCompletionAttempt } from "../collaboration-state/context-sync-attempts.js";
+import { readWorklistProjection } from "../collaboration-state/index.js";
+export function pendingContextSyncCompletion(db) {
+    const worklist = readWorklistProjection(db);
+    const tasks = worklist.modules
+        .flatMap((entry) => entry.tasks)
+        .sort((a, b) => (a.id < b.id ? -1 : 1));
+    if (tasks.length === 0 || tasks.some((task) => task.status !== "done"))
+        return undefined;
+    // A changed result on the same task is a new completion. Source messages,
+    // ordering, labels and context_sync's own Git commit are deliberately absent.
+    const key = createHash("sha256")
+        .update(JSON.stringify(tasks.map((task) => [task.id, task.latest_run_result_id])))
+        .digest("hex");
+    if (hasContextSyncCompletionAttempt(db, key))
+        return undefined;
+    return {
+        key,
+        trigger: {
+            kind: "worklist_all_tasks_completed",
+            completed_task_count: tasks.length,
+            module_count: worklist.modules.length,
+        },
+    };
+}
+//# sourceMappingURL=context-sync-completion.js.map

package/dist/control-plane/context-sync.d.ts

@@ -10,6 +10,7 @@ export declare function startContextSyncAnalysisProcedure(input: {
     store: HostProjectStore;
     events: WorkspaceEventBus;
     trigger: ContextSyncWorkflowTrigger;
+    completionBatchKey?: string;
     resolveWorkflowRunner: ProcedureWorkflowRunnerResolver;
     readActiveActivity: () => {
         activity_ref: ActivityRef;

package/dist/control-plane/context-sync.js

@@ -3,6 +3,7 @@ import { projectLanguageContext, logLanguageContext } from "./communication-lang
 import { recordProjectTimelineEvent } from "../project-timeline/index.js";
 import { syncProjectDocs } from "../workspace-ops/index.js";
 import { logProcedureExecutionError } from "./procedure-logging.js";
+import { recordContextSyncCompletionAttempt } from "../collaboration-state/context-sync-attempts.js";
 import { projectBriefShouldRefreshForUpdatedPaths, refreshProjectBriefProjection, } from "./project-brief-refresh.js";
 function publishContextSyncTimelineChanged(input) {
     input.events.publish({
@@ -63,6 +64,28 @@ export function startContextSyncAnalysisProcedure(input) {
             error,
         }),
         execute: async (context) => {
+            if (input.completionBatchKey !== undefined) {
+                const recorded = recordContextSyncCompletionAttempt(input.store.db, {
+                    batchKey: input.completionBatchKey,
+                    workflowRef,
+                    startedAt: input.now().toISOString(),
+                });
+                if (!recorded)
+                    return {
+                        kind: "completed",
+                        summary: "These task results were already checked for document maintenance.",
+                    };
+                try {
+                    input.logger?.info({
+                        workflow_ref: workflowRef,
+                        activity_ref: context.activity_ref,
+                        trigger: "worklist_all_tasks_completed",
+                    }, "Automatic context sync attempt recorded");
+                }
+                catch {
+                    /* Logging must not prevent the recorded maintenance attempt. */
+                }
+            }
             const language = projectLanguageContext(input.store.db, "documents");
             logLanguageContext(input.logger, language, {
                 workflow_ref: workflowRef,