@xfey/tutti 0.1.125 → 0.1.127

package/dist/communication-language/live-smoke-cli.js

@@ -0,0 +1,368 @@
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { parseArgs, parseEnv } from "node:util";
+import { createActivityRef, createProjectId, createTaskId, createTaskModuleId, createWorkflowInvocationRef, } from "@tutti/shared/ids";
+import { createOpenAiProcedureWorkflowRunner } from "../control-plane/workflows/openai.js";
+import { createOpenAiStructuredOutputClient, OpenAiStructuredOutputError, } from "../providers/openai/sdk-procedure-runner.js";
+import { runWorkspaceWriteTask } from "../run-pipeline/task-run-invocation.js";
+import { CodexAppServerWorkspaceWriteRunError } from "../providers/openai/app-server/workspace-write-run.js";
+import { CodexAppServerReadOnlyProcedureError } from "../providers/openai/app-server/read-only-procedure.js";
+import { createLanguageContext } from "./index.js";
+import { isLanguageDecision, languageDecisionMatchesContext, } from "./index.js";
+import { isScratchpadRefreshStructuredOutput } from "../control-plane/workflows/structured-output.js";
+// Opt-in paid synthetic evaluation, never called by Host or normal unit tests.
+let activeCase = "configuration";
+let expectedLanguage;
+let lastProgress = "";
+const smokeStartedAt = Date.now();
+function reportProgress(stage, action) {
+    const key = `${activeCase}:${stage}:${action ?? ""}`;
+    if (key === lastProgress)
+        return;
+    lastProgress = key;
+    console.log(JSON.stringify({
+        case: activeCase,
+        stage,
+        ...(action === undefined ? {} : { action }),
+        elapsed_ms: Date.now() - smokeStartedAt,
+    }));
+}
+function report(status) {
+    console.log(JSON.stringify({ case: activeCase, status }));
+}
+class SmokeAssertionError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+    }
+}
+function requireCondition(condition, code = "fixture_assertion_failed") {
+    if (!condition)
+        throw new SmokeAssertionError(code);
+}
+function proseMatches(text, locale) {
+    // A narrow fixture assertion, NOT a production language detector or translation gate.
+    return locale.startsWith("zh") ? /\p{Script=Han}/u.test(text) : !/\p{Script=Han}/u.test(text);
+}
+async function main() {
+    const { values } = parseArgs({
+        options: {
+            "env-file": { type: "string" },
+            model: { type: "string" },
+            "from-case": { type: "string" },
+            "turn-timeout-ms": { type: "string" },
+        },
+    });
+    if (!values["env-file"] || !values.model)
+        throw new Error("explicit_smoke_configuration_required");
+    const turnTimeoutMs = Number(values["turn-timeout-ms"] ?? 180_000);
+    requireCondition(Number.isSafeInteger(turnTimeoutMs) && turnTimeoutMs >= 30_000 && turnTimeoutMs <= 1_200_000);
+    // Do not export credentials into the process or child environment.
+    const env = parseEnv(readFileSync(values["env-file"], "utf8"));
+    const apiKey = env.TUTTI_API_KEY;
+    if (!apiKey)
+        throw new Error("missing_smoke_credential");
+    const config = {
+        default_model: values.model,
+        ...(env.TUTTI_BASE_URL ? { api_base_url: env.TUTTI_BASE_URL } : {}),
+    };
+    const root = mkdtempSync(join(tmpdir(), "tutti-language-smoke-"));
+    const workspaceRoot = join(root, "repo");
+    const privateHome = join(root, "home");
+    const tuttiHome = join(root, "tutti");
+    for (const path of [workspaceRoot, privateHome, tuttiHome])
+        mkdirSync(path, { mode: 0o700 });
+    let fixtureCleanupSafe = true;
+    const runtime = {
+        apiKey,
+        workspaceRoot,
+        tuttiHome,
+        projectId: createProjectId(),
+        baseEnv: { HOME: privateHome, PATH: process.env.PATH, LANG: "en_US.UTF-8" },
+        requestTimeoutMs: 60_000,
+        turnTimeoutMs,
+        onLifecycleIncident: (incident) => {
+            if (incident.code === "process_termination_failed")
+                fixtureCleanupSafe = false;
+            console.log(JSON.stringify({ case: activeCase, diagnostic: "lifecycle", reason_code: incident.code }));
+        },
+    };
+    try {
+        writeFileSync(join(workspaceRoot, "README.md"), "# English repository\n\nA minimal synthetic greeting fixture. Keep this README in English.\n", { mode: 0o600 });
+        for (const args of [
+            ["init", "-b", "main"],
+            ["config", "user.name", "Tutti Fixture"],
+            ["config", "user.email", "fixture@example.invalid"],
+            ["add", "."],
+            ["commit", "-m", "fixture"],
+        ])
+            execFileSync("git", args, { cwd: workspaceRoot, stdio: "ignore" });
+        const client = createOpenAiStructuredOutputClient({
+            apiKey,
+            ...(config.api_base_url ? { apiBaseUrl: config.api_base_url } : {}),
+        });
+        const runner = createOpenAiProcedureWorkflowRunner({
+            config,
+            client: {
+                responses: {
+                    create: async (body, options) => {
+                        const result = await client.responses.create(body, options);
+                        // Synthetic output: diagnose only shape and bounded language metadata, never prose.
+                        if (expectedLanguage !== undefined &&
+                            typeof result === "object" &&
+                            result !== null &&
+                            "output_text" in result &&
+                            typeof result.output_text === "string") {
+                            try {
+                                const decoded = JSON.parse(result.output_text);
+                                const validLanguage = languageDecisionMatchesContext(decoded.communication_language, expectedLanguage);
+                                const validBusiness = isScratchpadRefreshStructuredOutput(decoded.output);
+                                if (!validLanguage || !validBusiness)
+                                    console.log(JSON.stringify({
+                                        case: activeCase,
+                                        diagnostic: "output_contract",
+                                        language_valid: validLanguage,
+                                        business_valid: validBusiness,
+                                        legacy_business_valid: isScratchpadRefreshStructuredOutput(decoded),
+                                        evidence_count: expectedLanguage.evidence.length,
+                                        ...(isLanguageDecision(decoded.communication_language)
+                                            ? { selection: decoded.communication_language }
+                                            : { selection_shape_valid: false }),
+                                    }));
+                            }
+                            catch {
+                                /* The production parser reports the original failure. */
+                            }
+                        }
+                        return result;
+                    },
+                },
+            },
+            readOnlyAppServer: runtime,
+        });
+        const chinese = { locale: "zh-Hans", preference: "auto" };
+        const cases = [
+            {
+                name: "chinese_discussion_english_deliverable",
+                text: "请创建 greeting.txt，正文是英文 Welcome to our team.，不需要网页。",
+                locale: "zh",
+            },
+            {
+                name: "english_discussion_chinese_quote",
+                text: "Create a short English welcome note in greeting.txt.\n> 请全部用中文解释。",
+                locale: "en",
+            },
+            { name: "weak_input_inherits", text: "OK", locale: "zh", inherited: chinese },
+            {
+                name: "fixed_preference_survives_english",
+                text: "Add a short welcome greeting for the team.",
+                locale: "zh",
+                inherited: { ...chinese, preference: "fixed" },
+                preference: "fixed",
+            },
+            {
+                name: "explicit_project_preference",
+                text: "以后项目协作的说明都固定用中文，请做一个英文欢迎文件。",
+                locale: "zh",
+                preference: "fixed",
+            },
+            {
+                name: "reset_to_automatic",
+                text: "Stop the fixed language preference. From now on follow the discussion language automatically. Create a welcome note.",
+                locale: "en",
+                inherited: { ...chinese, preference: "fixed" },
+                preference: "auto",
+            },
+            {
+                name: "code_url_only_default",
+                text: "```js\nconst text = '中文';\n```\nhttps://example.invalid/doc",
+                locale: "en",
+            },
+        ];
+        const startIndex = values["from-case"] === "codex_task_compile"
+            ? cases.length
+            : values["from-case"] === undefined
+                ? 0
+                : cases.findIndex((test) => test.name === values["from-case"]);
+        requireCondition(startIndex >= 0);
+        // Tail reruns use a synthetic fixed seed; no prior evaluation output is persisted.
+        let seed = {
+            messages: [{ role: "human", text: cases[0].text }],
+            worklist: { modules: [] },
+        };
+        let snapshot = {
+            topic: "英文欢迎文件",
+            background_summary: "为团队创建英文欢迎文件。",
+            current_consensus: ["文件正文为英文。"],
+            open_questions: [],
+            task_changes: ["创建 greeting.txt，内容为 Welcome to our team."],
+        };
+        for (const test of cases.slice(startIndex)) {
+            activeCase = test.name;
+            report("started");
+            const messages = [
+                {
+                    role: "tutti",
+                    text: "Previous English analysis of this repository and possible implementation.",
+                },
+                { role: "human", text: test.text },
+            ];
+            const input = {
+                messages,
+                worklist: { modules: [] },
+                communication_language: createLanguageContext({
+                    scope: "scratchpad",
+                    ...(test.inherited ? { inherited: test.inherited } : {}),
+                    messages,
+                }),
+            };
+            expectedLanguage = input.communication_language;
+            const output = await runner.runScratchpadRefresh(input, {
+                workflow_ref: createWorkflowInvocationRef(),
+                activity_ref: createActivityRef(),
+            });
+            const language = output.communication_language;
+            const prose = output.decision === "ready"
+                ? [output.scratchpad_snapshot.topic, output.scratchpad_snapshot.background_summary].join(" ")
+                : output.request_payload.request;
+            const selectionMatches = language !== undefined && language.locale.startsWith(test.locale);
+            const preferenceMatches = test.preference === undefined || language?.preference === test.preference;
+            const proseLanguageMatches = proseMatches(prose, test.locale);
+            if (!selectionMatches || !preferenceMatches || !proseLanguageMatches) {
+                console.log(JSON.stringify({
+                    case: activeCase,
+                    diagnostic: "language_evaluation",
+                    expected_locale_prefix: test.locale,
+                    expected_preference: test.preference,
+                    actual_locale: language?.locale,
+                    actual_preference: language?.preference,
+                    actual_basis: language?.basis,
+                    selection_matches: selectionMatches,
+                    preference_matches: preferenceMatches,
+                    prose_language_matches: proseLanguageMatches,
+                }));
+            }
+            requireCondition(selectionMatches, "language_selection_mismatch");
+            requireCondition(preferenceMatches, "language_preference_mismatch");
+            requireCondition(proseLanguageMatches, "language_prose_mismatch");
+            if (test === cases[0] && output.decision === "ready") {
+                seed = input;
+                snapshot = output.scratchpad_snapshot;
+            }
+            report("passed");
+        }
+        activeCase = "codex_task_compile";
+        report("started");
+        const workflowRef = createWorkflowInvocationRef();
+        const language = createLanguageContext({ scope: "workflow", inherited: chinese, pinned: true });
+        const compiled = await runner.runTaskCompile({
+            workflow_ref: workflowRef,
+            communication_language: language,
+            scratchpad: snapshot,
+            source_messages: seed.messages,
+            worklist: { modules: [] },
+        }, {
+            workflow_ref: workflowRef,
+            activity_ref: createActivityRef(),
+            reportProgress: (progress) => reportProgress(progress.phase ?? "task_compile", progress.runtime?.current_action),
+        });
+        requireCondition(compiled.decision === "ready" && compiled.proposal.tasks.length === 1);
+        requireCondition(compiled.communication_language?.locale === "zh-Hans");
+        const proposed = compiled.proposal.tasks[0];
+        requireCondition(proseMatches(proposed.title + proposed.contract.goal, "zh"));
+        report("passed");
+        activeCase = "codex_execute_finalize_english_file";
+        report("started");
+        const taskId = createTaskId();
+        const moduleId = createTaskModuleId();
+        const activityRef = createActivityRef();
+        const now = new Date().toISOString();
+        const task = {
+            id: taskId,
+            module_id: moduleId,
+            title: proposed.title,
+            summary: proposed.summary,
+            status: "running",
+            order: 1,
+            current_activity_ref: activityRef,
+            created_from_workflow_ref: workflowRef,
+            created_at: now,
+            updated_at: now,
+        };
+        const result = await runWorkspaceWriteTask({ ...runtime, config }, {
+            communication_language: language,
+            on_stage: (progress) => reportProgress(progress.stage, progress.runtime?.current_action),
+            activity_ref: activityRef,
+            task,
+            task_detail: {
+                task,
+                detail: { task_id: taskId, contract: proposed.contract, result: {}, updated_at: now },
+            },
+            source_messages: seed.messages,
+            run_lineage: { kind: "initial", attempt: 1 },
+            dispatch_context: {
+                trigger: "manual_run_now",
+                queue_scope: { kind: "worklist" },
+                current_task_id: taskId,
+                ordered_task_refs: [taskId],
+                current_module_id: moduleId,
+            },
+        });
+        requireCondition(result.decision === "completed", "execute_result_unexpected");
+        requireCondition(proseMatches(result.summary, "zh"), "execute_language_mismatch");
+        requireCondition(readFileSync(join(workspaceRoot, "greeting.txt"), "utf8").trim() === "Welcome to our team.", "deliverable_mismatch");
+        const readme = readFileSync(join(workspaceRoot, "README.md"), "utf8");
+        requireCondition(readme.startsWith("# English repository") && proseMatches(readme, "en"), "existing_document_changed");
+        report("passed");
+        console.log(JSON.stringify({
+            status: "passed",
+            cases: cases.length - startIndex + 2,
+            model: config.default_model,
+            turn_timeout_ms: turnTimeoutMs,
+            ...(values["from-case"] === undefined ? {} : { from_case: values["from-case"] }),
+        }));
+    }
+    finally {
+        if (fixtureCleanupSafe)
+            rmSync(root, { recursive: true, force: true });
+        else
+            console.log(JSON.stringify({
+                case: activeCase,
+                diagnostic: "fixture_retained",
+                reason_code: "process_termination_unconfirmed",
+            }));
+    }
+}
+void main().catch((error) => {
+    console.error(JSON.stringify({
+        case: activeCase,
+        status: "failed",
+        reason_code: error instanceof OpenAiStructuredOutputError
+            ? error.reason
+            : error instanceof CodexAppServerWorkspaceWriteRunError ||
+                error instanceof CodexAppServerReadOnlyProcedureError ||
+                error instanceof SmokeAssertionError
+                ? error.code
+                : "language_smoke_failed",
+        ...(error instanceof OpenAiStructuredOutputError
+            ? { invalid_response_kind: error.invalidResponseKind }
+            : {}),
+        ...(error instanceof CodexAppServerWorkspaceWriteRunError
+            ? {
+                turn_start_state: error.details.turn_start_state,
+                turn_timeout_ms: error.details.turn_timeout_ms,
+                http_status: error.details.turn_error_http_status,
+                notification_count: error.details.notification_count,
+                server_request_count: error.details.server_request_methods?.length,
+                recent_methods_include_turn_started: error.details.notification_methods?.includes("turn/started"),
+                recent_methods_include_item_completed: error.details.notification_methods?.includes("item/completed"),
+                elapsed_ms: Date.now() - smokeStartedAt,
+            }
+            : {}),
+    }));
+    process.exitCode = 1;
+});
+//# sourceMappingURL=live-smoke-cli.js.map

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

@@ -0,0 +1,22 @@
+import { type RenderPromptTemplateOptions } from "../prompt-templates/index.js";
+import { type CommunicationLanguageContext, type LanguageDecision } from "./index.js";
+export declare function renderLanguageAwarePrompt(options: RenderPromptTemplateOptions, language: CommunicationLanguageContext | undefined, reportLanguage?: boolean): string;
+type ObjectSchema = {
+    [key: string]: unknown;
+};
+export declare function languageOutputContract<T>(schema: ObjectSchema, validate: (value: unknown) => value is T, context: CommunicationLanguageContext | undefined): {
+    schema: ObjectSchema;
+    validate: (value: unknown) => value is T | {
+        communication_language: LanguageDecision;
+        output: T;
+    };
+    unwrap: (value: T | {
+        communication_language: LanguageDecision;
+        output: T;
+    }) => {
+        output: T;
+        language?: LanguageDecision;
+    };
+};
+export {};
+//# sourceMappingURL=prompt.d.ts.map

package/dist/communication-language/prompt.js

@@ -0,0 +1,73 @@
+import { renderPromptTemplate, } from "../prompt-templates/index.js";
+import { LANGUAGE_DECISION_SCHEMA, languageDecisionMatchesContext, } from "./index.js";
+export function renderLanguageAwarePrompt(options, language, reportLanguage = false) {
+    const prompt = renderPromptTemplate(options);
+    if (language === undefined)
+        return prompt;
+    const policy = renderPromptTemplate({
+        templateKey: "communication_language",
+        ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
+        variables: {
+            language_context_json: {
+                ...language,
+                evidence: language.evidence.map((entry, evidence_index) => ({ evidence_index, ...entry })),
+            },
+            language_output_contract: reportLanguage
+                ? renderPromptTemplate({
+                    templateKey: "communication_language_result",
+                    ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
+                })
+                : "",
+        },
+    });
+    return `${policy}\n\n${prompt}`;
+}
+export function languageOutputContract(schema, validate, context) {
+    return {
+        schema: context === undefined
+            ? schema
+            : {
+                type: "object",
+                additionalProperties: false,
+                required: ["communication_language", "output"],
+                properties: {
+                    communication_language: {
+                        ...LANGUAGE_DECISION_SCHEMA,
+                        properties: {
+                            ...LANGUAGE_DECISION_SCHEMA.properties,
+                            evidence_index: context.evidence.length === 0
+                                ? { type: "null" }
+                                : {
+                                    anyOf: [
+                                        {
+                                            type: "integer",
+                                            enum: context.evidence.map((_entry, index) => index),
+                                        },
+                                        { type: "null" },
+                                    ],
+                                },
+                        },
+                    },
+                    output: schema,
+                },
+            },
+        validate: (value) => {
+            if (context === undefined)
+                return validate(value);
+            if (typeof value !== "object" || value === null)
+                return false;
+            const candidate = value;
+            return (Object.keys(candidate).length === 2 &&
+                languageDecisionMatchesContext(candidate.communication_language, context) &&
+                validate(candidate.output));
+        },
+        unwrap: (value) => context === undefined
+            ? { output: value }
+            : {
+                output: value.output,
+                language: value
+                    .communication_language,
+            },
+    };
+}
+//# sourceMappingURL=prompt.js.map

package/dist/control-plane/communication-language.d.ts

@@ -0,0 +1,33 @@
+import type { MessageProjection } from "@tutti/shared/schemas/api";
+import type { SqliteDatabase } from "../store/index.js";
+import { type CommunicationLanguageContext, type LanguageDecision, type LanguageEvidenceMessage } from "../communication-language/index.js";
+import { type LanguageOwner } from "../collaboration-state/communication-language.js";
+export { messageLanguageEvidence } from "../communication-language/index.js";
+export declare function sourceLanguageEvidence(db: SqliteDatabase, sources: readonly {
+    message_id: string;
+}[]): LanguageEvidenceMessage[];
+export declare function projectLanguageContext(db: SqliteDatabase, scope: CommunicationLanguageContext["scope"], messages?: readonly LanguageEvidenceMessage[]): CommunicationLanguageContext;
+export declare function workflowLanguageContext(db: SqliteDatabase, input: {
+    workflowRef: string;
+    taskId?: string;
+    sources: readonly LanguageEvidenceMessage[];
+    answers?: readonly LanguageEvidenceMessage[];
+}): CommunicationLanguageContext;
+export declare function recordWorkflowLanguage(db: SqliteDatabase, input: {
+    owner: LanguageOwner;
+    language?: LanguageDecision;
+    activityRef: string;
+    now: () => Date;
+}): void;
+export declare function recordScratchpadLanguage(db: SqliteDatabase, input: {
+    language?: LanguageDecision;
+    context?: CommunicationLanguageContext;
+    sourceMessages: readonly MessageProjection[];
+    activityRef: string;
+    snapshot: boolean;
+    now: () => Date;
+}): void;
+export declare function logLanguageContext(logger: {
+    info: (fields: Record<string, unknown>, message: string) => void;
+} | undefined, context: CommunicationLanguageContext, anchors: Record<string, string>, decision?: LanguageDecision): void;
+//# sourceMappingURL=communication-language.d.ts.map

package/dist/control-plane/communication-language.js

@@ -0,0 +1,72 @@
+import { readMessageProjectionById } from "../collaboration-state/index.js";
+import { createLanguageContext, languageDecisionMatchesContext, languageDiagnosticFields, messageLanguageEvidence, } from "../communication-language/index.js";
+import { readCommunicationLanguage, writeCommunicationLanguage, } from "../collaboration-state/communication-language.js";
+export { messageLanguageEvidence } from "../communication-language/index.js";
+export function sourceLanguageEvidence(db, sources) {
+    return sources.flatMap((source) => {
+        const message = readMessageProjectionById(db, source.message_id);
+        return message === null ? [] : [messageLanguageEvidence(message)];
+    });
+}
+export function projectLanguageContext(db, scope, messages = []) {
+    return createLanguageContext({ scope, inherited: readCommunicationLanguage(db), messages });
+}
+export function workflowLanguageContext(db, input) {
+    const inherited = (input.taskId === undefined
+        ? null
+        : readCommunicationLanguage(db, { kind: "task", ref: input.taskId })) ??
+        readCommunicationLanguage(db, { kind: "workflow", ref: input.workflowRef });
+    return createLanguageContext({
+        scope: "workflow",
+        inherited,
+        pinned: inherited !== null,
+        messages: inherited === null ? [...input.sources, ...(input.answers ?? [])] : (input.answers ?? []),
+    });
+}
+export function recordWorkflowLanguage(db, input) {
+    if (input.language === undefined)
+        return;
+    writeCommunicationLanguage(db, { ...input, language: input.language });
+}
+export function recordScratchpadLanguage(db, input) {
+    if (input.language === undefined || input.context === undefined)
+        return;
+    if (!languageDecisionMatchesContext(input.language, input.context)) {
+        throw new Error("communication_language_decision_invalid");
+    }
+    if (input.snapshot)
+        recordWorkflowLanguage(db, {
+            owner: { kind: "scratchpad", ref: "current" },
+            ...input,
+        });
+    const decision = input.language;
+    const evidence = decision.evidence_index === null ? undefined : input.context.evidence[decision.evidence_index];
+    const latestHuman = input.sourceMessages
+        .filter((message) => message.author.kind === "human" && messageLanguageEvidence(message).text.trim() !== "")
+        .at(-1);
+    if (evidence?.role !== "human" || latestHuman === undefined)
+        return;
+    writeCommunicationLanguage(db, {
+        owner: { kind: "project", ref: "current" },
+        language: decision,
+        activityRef: input.activityRef,
+        sourceCursor: { message_id: latestHuman.id, created_at: latestHuman.created_at },
+        now: input.now,
+    });
+}
+export function logLanguageContext(logger, context, anchors, decision) {
+    try {
+        logger?.info({
+            ...anchors,
+            ...languageDiagnosticFields(context),
+            language_phase: decision === undefined ? "prepared" : "selected",
+            ...(decision === undefined
+                ? {}
+                : { language_locale: decision.locale, language_basis: decision.basis }),
+        }, "Communication language context");
+    }
+    catch {
+        /* Diagnostics must not replace the result. */
+    }
+}
+//# sourceMappingURL=communication-language.js.map

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

@@ -1,4 +1,5 @@
 import { createWorkflowInvocationRef } from "@tutti/shared/ids";
+import { projectLanguageContext, logLanguageContext } from "./communication-language.js";
 import { recordProjectTimelineEvent } from "../project-timeline/index.js";
 import { syncProjectDocs } from "../workspace-ops/index.js";
 import { logProcedureExecutionError } from "./procedure-logging.js";
@@ -62,7 +63,13 @@ export function startContextSyncAnalysisProcedure(input) {
             error,
         }),
         execute: async (context) => {
+            const language = projectLanguageContext(input.store.db, "documents");
+            logLanguageContext(input.logger, language, {
+                workflow_ref: workflowRef,
+                activity_ref: context.activity_ref,
+            });
             const workflowInput = {
+                communication_language: language,
                 workflow_ref: workflowRef,
                 activity_ref: context.activity_ref,
                 trigger: input.trigger,

package/dist/control-plane/follow-up-output.js

@@ -1,4 +1,6 @@
 import { closeTaskBoundClarificationAsRetaskingRequired, openNextTaskBoundClarificationRound, } from "../collaboration-state/index.js";
+import { withHostStoreTransaction } from "../store/index.js";
+import { recordWorkflowLanguage } from "./communication-language.js";
 import { clarificationInvalidates, taskRunInvalidates } from "./invalidations.js";
 export function closeTaskBoundFollowUpAsRetaskingRequired(input) {
     const closed = closeTaskBoundClarificationAsRetaskingRequired(input.store.db, {
@@ -73,10 +75,21 @@ export function applyFollowUpCheckOutput(input) {
         summary: input.output.summary,
     }, "Follow-up check completed");
     if (input.output.decision === "needs_more_input") {
-        const opened = openNextTaskBoundClarificationRound(input.store.db, {
-            continue_from_round_id: input.roundId,
-            request_payload: input.output.clarification_request_payload,
-            now: input.now,
+        const request = input.output.clarification_request_payload;
+        const opened = withHostStoreTransaction(input.store.db, (tx) => {
+            recordWorkflowLanguage(tx, {
+                owner: { kind: "task", ref: input.followUpInput.task_id },
+                ...(input.output.communication_language === undefined
+                    ? {}
+                    : { language: input.output.communication_language }),
+                activityRef: input.activityRef,
+                now: input.now,
+            });
+            return openNextTaskBoundClarificationRound(tx, {
+                continue_from_round_id: input.roundId,
+                request_payload: request,
+                now: input.now,
+            });
         });
         const nextRoundId = opened.round.id;
         input.events.publish({
@@ -129,6 +142,14 @@ export function applyFollowUpCheckOutput(input) {
         });
     }
     const summary = input.output.summary.trim().length === 0 ? "Follow-up accepted." : input.output.summary;
+    recordWorkflowLanguage(input.store.db, {
+        owner: { kind: "task", ref: input.followUpInput.task_id },
+        ...(input.output.communication_language === undefined
+            ? {}
+            : { language: input.output.communication_language }),
+        activityRef: input.activityRef,
+        now: input.now,
+    });
     return {
         kind: "completed",
         summary,