@xfey/tutti 0.1.125 → 0.1.127

package/README.md

@@ -1,5 +1,7 @@
 # server
 
+当前源码的[协作输出语言](../../docs/system/communication-language.md)由 Host 统一处理：migration `0023`、共享 prompt、Scratchpad／workflow／task 语言继承。通过 Host npm 包交付，需更新项目 Host 才会生效，不依赖 Web 或飞书端新增设置；对照模型的引用语言误判作为已知项保留，不宣称所有模型均稳定通过。
+
 ## 作用
 
 `apps/server` 是 Tutti 的项目 host service，也是机器级 Local Console 的进程入口。

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

@@ -1,9 +1,12 @@
 import type { ProviderInvocationProgress } from "../providers/invocation-progress.js";
+import type { languageDiagnosticFields } from "../communication-language/index.js";
 export type ChatAssistantLogger = {
     info: (fields: Record<string, unknown>, message: string) => void;
     warn: (fields: Record<string, unknown>, message: string) => void;
 };
-type ChatAssistantProgress = ProviderInvocationProgress | {
+type ChatAssistantProgress = ProviderInvocationProgress | ({
+    stage: "language_context";
+} & ReturnType<typeof languageDiagnosticFields>) | {
     stage: "queued" | "inspection_wait" | "model_requested" | "reply_persisted" | "failed" | "skipped";
     reason_code?: "queue_full" | "stopping" | "context_unavailable" | "answer_failed" | "reply_failed";
     reference_source_count?: number;

package/dist/chat-assistant/index.js

@@ -1,6 +1,8 @@
 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";
@@ -241,18 +243,25 @@ 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) {
         let afterCommit;
@@ -342,7 +351,7 @@ export class ReadOnlyChatAssistant {
         try {
             report({ stage: "inspection_wait" });
             await this.options.waitForInspectionAvailability?.();
-            const prompt = this.renderPrompt(triggerMessage);
+            const prompt = this.renderPrompt(triggerMessage, report);
             if (prompt === null) {
                 report({ stage: "skipped", reason_code: "context_unavailable" });
                 return;

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/collaboration-state/communication-language.d.ts

@@ -0,0 +1,31 @@
+import type { SqliteDatabase } from "../store/index.js";
+import { type LanguageDecision, type LanguagePreference } from "../communication-language/index.js";
+export type LanguageOwner = {
+    kind: "project" | "scratchpad" | "workflow" | "task";
+    ref: string;
+};
+export type StoredCommunicationLanguage = LanguagePreference & {
+    basis: LanguageDecision["basis"];
+    activity_ref: string | null;
+    source_message_id: string | null;
+    source_created_at: string | null;
+};
+export declare function readCommunicationLanguage(db: SqliteDatabase, owner?: LanguageOwner): StoredCommunicationLanguage | null;
+export declare function writeCommunicationLanguage(db: SqliteDatabase, input: {
+    owner: LanguageOwner;
+    language: LanguagePreference & {
+        basis: LanguageDecision["basis"];
+    };
+    activityRef?: string;
+    sourceCursor?: {
+        message_id: string;
+        created_at: string;
+    };
+    now: () => Date;
+}): void;
+export declare function copyCommunicationLanguage(db: SqliteDatabase, input: {
+    from: LanguageOwner;
+    to: LanguageOwner;
+    now: () => Date;
+}): void;
+//# sourceMappingURL=communication-language.d.ts.map

package/dist/collaboration-state/communication-language.js

@@ -0,0 +1,36 @@
+import { COMMUNICATION_LANGUAGE_POLICY_VERSION, isLanguagePreference, } from "../communication-language/index.js";
+export function readCommunicationLanguage(db, owner = { kind: "project", ref: "current" }) {
+    const row = db
+        .prepare(`SELECT locale, preference, basis, activity_ref, source_message_id, source_created_at
+     FROM communication_language_state WHERE owner_kind = ? AND owner_ref = ?`)
+        .get(owner.kind, owner.ref);
+    if (row === undefined)
+        return null;
+    if (!isLanguagePreference(row))
+        throw new Error("communication_language_state_invalid");
+    return row;
+}
+export function writeCommunicationLanguage(db, input) {
+    if (!isLanguagePreference(input.language))
+        throw new Error("communication_language_state_invalid");
+    db.prepare(`INSERT INTO communication_language_state
+      (owner_kind, owner_ref, locale, preference, basis, policy_version, activity_ref,
+       source_message_id, source_created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(owner_kind, owner_ref) DO UPDATE SET
+       locale = excluded.locale, preference = excluded.preference, basis = excluded.basis,
+       policy_version = excluded.policy_version, activity_ref = excluded.activity_ref,
+       source_message_id = excluded.source_message_id, source_created_at = excluded.source_created_at,
+       updated_at = excluded.updated_at
+     WHERE excluded.owner_kind != 'project' OR
+       communication_language_state.source_created_at IS NULL OR
+       (excluded.source_created_at, excluded.source_message_id) >
+       (communication_language_state.source_created_at, communication_language_state.source_message_id)`).run(input.owner.kind, input.owner.ref, input.language.locale, input.language.preference, input.language.basis, COMMUNICATION_LANGUAGE_POLICY_VERSION, input.activityRef ?? null, input.sourceCursor?.message_id ?? null, input.sourceCursor?.created_at ?? null, input.now().toISOString());
+}
+export function copyCommunicationLanguage(db, input) {
+    const language = readCommunicationLanguage(db, input.from);
+    if (language === null)
+        return;
+    writeCommunicationLanguage(db, { owner: input.to, language, now: input.now });
+}
+//# sourceMappingURL=communication-language.js.map

package/dist/collaboration-state/task-compile-context.js

@@ -1,5 +1,6 @@
 import { withHostStoreTransaction } from "../store/index.js";
 import { readScratchpadProjection } from "./scratchpad.js";
+import { readCommunicationLanguage, copyCommunicationLanguage } from "./communication-language.js";
 import { readScratchpadSourceState } from "./scratchpad-source-state.js";
 import { nowIso, stringifyJson } from "./serialization.js";
 function cursorIsAfter(left, right) {
@@ -206,6 +207,14 @@ export function captureTaskCompileContext(db, input) {
         if (scratchpad.state !== "ready" || scratchpad.updated_at === undefined) {
             throw new Error("A ready Scratchpad is required to capture Task Compile Context");
         }
+        const language = readCommunicationLanguage(tx, { kind: "scratchpad", ref: "current" });
+        if (language !== null && language.activity_ref === scratchpad.updated_by_activity_ref) {
+            copyCommunicationLanguage(tx, {
+                from: { kind: "scratchpad", ref: "current" },
+                to: { kind: "workflow", ref: input.workflow_ref },
+                now: input.now ?? (() => new Date()),
+            });
+        }
         const sourceState = readScratchpadSourceState(tx);
         const submission = readPendingTaskCompileSubmission(tx, input.workflow_ref);
         const sources = readCurrentScratchpadSourceRefs(tx, submission?.source_window.through);

package/dist/communication-language/index.d.ts

@@ -0,0 +1,75 @@
+import type { MessageProjection } from "@tutti/shared/schemas/api";
+export declare const COMMUNICATION_LANGUAGE_POLICY_VERSION = 1;
+export type LanguagePreference = {
+    locale: string;
+    preference: "auto" | "fixed";
+};
+export type LanguageDecision = LanguagePreference & {
+    basis: "discussion" | "explicit" | "inherited" | "default";
+    evidence_index: number | null;
+};
+export type LanguageEvidenceMessage = {
+    role: "human" | "tutti" | "operator" | "system";
+    text: string;
+};
+export declare function messageLanguageEvidence(message: MessageProjection): LanguageEvidenceMessage;
+export type CommunicationLanguageContext = {
+    policy_version: 1;
+    scope: "scratchpad" | "reply" | "workflow" | "summary" | "documents";
+    inherited: LanguagePreference | null;
+    pinned: boolean;
+    evidence: Array<{
+        role: "human" | "operator";
+        text: string;
+    }>;
+};
+export declare function isLanguagePreference(value: unknown): value is LanguagePreference;
+export declare function isLanguageDecision(value: unknown): value is LanguageDecision;
+/** A language sample, not task context. The original message is never rewritten. */
+export declare function authoredLanguageSample(text: string): string;
+export declare function createLanguageContext(input: {
+    scope: CommunicationLanguageContext["scope"];
+    inherited?: LanguagePreference | null;
+    pinned?: boolean;
+    messages?: readonly LanguageEvidenceMessage[];
+}): CommunicationLanguageContext;
+export declare function languageDecisionMatchesContext(decision: unknown, context: CommunicationLanguageContext): decision is LanguageDecision;
+export declare function languageDiagnosticFields(context: CommunicationLanguageContext): {
+    language_policy_version: 1;
+    language_scope: "scratchpad" | "summary" | "workflow" | "reply" | "documents";
+    language_locale: string;
+    language_pinned: boolean;
+    language_evidence_count: number;
+};
+export type LanguageAwareOutput = {
+    communication_language?: LanguageDecision;
+};
+export declare const LANGUAGE_DECISION_SCHEMA: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["locale", "preference", "basis", "evidence_index"];
+    readonly properties: {
+        readonly locale: {
+            readonly type: "string";
+            readonly pattern: string;
+        };
+        readonly preference: {
+            readonly type: "string";
+            readonly enum: readonly ["auto", "fixed"];
+        };
+        readonly basis: {
+            readonly type: "string";
+            readonly enum: readonly ["discussion", "explicit", "inherited", "default"];
+        };
+        readonly evidence_index: {
+            readonly anyOf: readonly [{
+                readonly type: "integer";
+                readonly minimum: 0;
+                readonly maximum: 11;
+            }, {
+                readonly type: "null";
+            }];
+        };
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/communication-language/index.js

@@ -0,0 +1,122 @@
+export const COMMUNICATION_LANGUAGE_POLICY_VERSION = 1;
+export function messageLanguageEvidence(message) {
+    const feedback = message.refs?.artifact_feedback;
+    return {
+        role: message.author.kind === "human"
+            ? "human"
+            : message.refs?.development_operator === true
+                ? "operator"
+                : "system",
+        text: message.refs?.reference_file !== undefined
+            ? ""
+            : feedback === undefined
+                ? message.body
+                : [feedback.summary, ...feedback.annotations.map((entry) => entry.comment)]
+                    .filter(Boolean)
+                    .join("\n"),
+    };
+}
+const BASES = new Set(["discussion", "explicit", "inherited", "default"]);
+const LOCALE_PATTERN = /^[a-z]{2,3}(?:-[A-Z][a-z]{3})?(?:-[A-Z]{2}|-\d{3})?$/u;
+export function isLanguagePreference(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const entry = value;
+    if (entry.preference !== "auto" && entry.preference !== "fixed")
+        return false;
+    if (typeof entry.locale !== "string" || !LOCALE_PATTERN.test(entry.locale))
+        return false;
+    try {
+        return Intl.getCanonicalLocales(entry.locale)[0] === entry.locale && entry.locale !== "und";
+    }
+    catch {
+        return false;
+    }
+}
+export function isLanguageDecision(value) {
+    if (!isLanguagePreference(value))
+        return false;
+    const entry = value;
+    return (BASES.has(entry.basis ?? "") &&
+        (entry.evidence_index === null ||
+            (Number.isSafeInteger(entry.evidence_index) && (entry.evidence_index ?? -1) >= 0)) &&
+        Object.keys(value).every((key) => ["locale", "preference", "basis", "evidence_index"].includes(key)));
+}
+/** A language sample, not task context. The original message is never rewritten. */
+export function authoredLanguageSample(text) {
+    const sample = text
+        .replace(/```[^]*?```|~~~[^]*?~~~/gu, " ")
+        .replace(/^(?: {0,3}>| {4}|\t).*$/gmu, " ")
+        .replace(/`[^`]*`/gu, " ")
+        .replace(/!\[[^\]]*\]\([^)]*\)/gu, " ")
+        .replace(/\[([^\]]+)\]\([^)]*\)/gu, "$1")
+        .replace(/https?:\/\/\S+|@tutti\b/giu, " ")
+        .replace(/\s+/gu, " ")
+        .trim();
+    return sample.length <= 800 ? sample : `${sample.slice(0, 398)} … ${sample.slice(-399)}`;
+}
+export function createLanguageContext(input) {
+    const evidence = (input.messages ?? []).flatMap((message) => {
+        if (message.role !== "human" && message.role !== "operator")
+            return [];
+        const text = authoredLanguageSample(message.text);
+        return /\p{L}/u.test(text) ? [{ role: message.role, text }] : [];
+    });
+    // Prefer humans. Operator-only tests can infer locally but cannot update project memory.
+    const selected = input.scope !== "reply" && evidence.some((entry) => entry.role === "human")
+        ? evidence.filter((entry) => entry.role === "human")
+        : evidence;
+    return {
+        policy_version: COMMUNICATION_LANGUAGE_POLICY_VERSION,
+        scope: input.scope,
+        inherited: input.inherited == null
+            ? null
+            : { locale: input.inherited.locale, preference: input.inherited.preference },
+        pinned: input.pinned ?? false,
+        evidence: selected.slice(-12),
+    };
+}
+export function languageDecisionMatchesContext(decision, context) {
+    if (!isLanguageDecision(decision))
+        return false;
+    if (decision.basis === "inherited") {
+        return (decision.evidence_index === null &&
+            decision.locale === context.inherited?.locale &&
+            decision.preference === context.inherited.preference);
+    }
+    if (decision.basis === "default") {
+        return (decision.evidence_index === null &&
+            context.inherited === null &&
+            decision.locale === "en" &&
+            decision.preference === "auto");
+    }
+    if (decision.evidence_index === null || !context.evidence[decision.evidence_index])
+        return false;
+    if (context.scope === "summary" || context.scope === "documents")
+        return false;
+    if (decision.basis === "discussion") {
+        return (!context.pinned && context.inherited?.preference !== "fixed" && decision.preference === "auto");
+    }
+    return true;
+}
+export function languageDiagnosticFields(context) {
+    return {
+        language_policy_version: context.policy_version,
+        language_scope: context.scope,
+        language_locale: context.inherited?.locale ?? "undetermined",
+        language_pinned: context.pinned,
+        language_evidence_count: context.evidence.length,
+    };
+}
+export const LANGUAGE_DECISION_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    required: ["locale", "preference", "basis", "evidence_index"],
+    properties: {
+        locale: { type: "string", pattern: LOCALE_PATTERN.source },
+        preference: { type: "string", enum: ["auto", "fixed"] },
+        basis: { type: "string", enum: ["discussion", "explicit", "inherited", "default"] },
+        evidence_index: { anyOf: [{ type: "integer", minimum: 0, maximum: 11 }, { type: "null" }] },
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/communication-language/live-smoke-cli.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=live-smoke-cli.d.ts.map