@xfey/tutti 0.1.126 → 0.1.127

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

@@ -3,6 +3,8 @@ import { readFollowUpCheckInputFromStore } from "./follow-up-context.js";
 import { applyFollowUpCheckOutput, closeTaskBoundFollowUpAsRetaskingRequired, } from "./follow-up-output.js";
 import { startRunFromFollowUp as startRunFromFollowUpSuccessor } from "./follow-up-run.js";
 import { logProcedureExecutionError } from "./procedure-logging.js";
+import { workflowLanguageContext, sourceLanguageEvidence, messageLanguageEvidence, logLanguageContext, } from "./communication-language.js";
+import { readScratchpadReceiptSourceRefs } from "../collaboration-state/index.js";
 export function startControlPlaneTaskBoundFollowUpCheck(options) {
     const runnerResolution = options.resolveWorkflowRunner();
     if (runnerResolution.kind !== "ready" || runnerResolution.runner.runFollowUpCheck === undefined) {
@@ -79,6 +81,20 @@ export function startControlPlaneTaskBoundFollowUpCheck(options) {
                 });
             }
             const input = inputResult.input;
+            const submitted = new Set(input.submitted_message_refs);
+            input.communication_language = workflowLanguageContext(options.store.db, {
+                workflowRef: input.task_detail.task.created_from_workflow_ref,
+                taskId: input.task_id,
+                sources: sourceLanguageEvidence(options.store.db, readScratchpadReceiptSourceRefs(options.store.db, input.task_detail.task.created_from_workflow_ref)),
+                answers: input.round_messages
+                    .filter((message) => submitted.has(message.id))
+                    .map(messageLanguageEvidence),
+            });
+            logLanguageContext(options.logger, input.communication_language, {
+                workflow_ref: workflowRef,
+                activity_ref: context.activity_ref,
+                task_id: input.task_id,
+            });
             output = await runnerResolution.runner.runFollowUpCheck?.(input, {
                 workflow_ref: workflowRef,
                 activity_ref: context.activity_ref,
@@ -90,6 +106,7 @@ export function startControlPlaneTaskBoundFollowUpCheck(options) {
                     result_anchor: { kind: "workflow", workflow_ref: workflowRef },
                 };
             }
+            logLanguageContext(options.logger, input.communication_language, { workflow_ref: workflowRef, activity_ref: context.activity_ref, task_id: input.task_id }, output.communication_language);
             return applyFollowUpCheckOutput({
                 store: options.store,
                 events: options.events,

package/dist/control-plane/project-brief-refresh.js

@@ -1,5 +1,6 @@
 import { readProjectBriefProjection, readProjectBriefSourceDocuments, upsertProjectBriefProjection, } from "../project-brief/index.js";
 import { PROJECT_DOC_PATHS } from "../workspace-ops/index.js";
+import { projectLanguageContext, logLanguageContext } from "./communication-language.js";
 export function projectBriefShouldRefreshForUpdatedPaths(paths) {
     return paths.some((path) => PROJECT_DOC_PATHS.includes(path));
 }
@@ -57,7 +58,15 @@ export async function refreshProjectBriefProjection(input) {
     }
     let output;
     try {
-        output = await runner.runProjectBriefRefresh({ docs: sourceDocs }, input.workflowRef === undefined || input.activityRef === undefined
+        const language = projectLanguageContext(input.store.db, "summary");
+        logLanguageContext(input.logger, language, {
+            ...(input.workflowRef === undefined ? {} : { workflow_ref: input.workflowRef }),
+            ...(input.activityRef === undefined ? {} : { activity_ref: input.activityRef }),
+        });
+        output = await runner.runProjectBriefRefresh({
+            docs: sourceDocs,
+            communication_language: language,
+        }, input.workflowRef === undefined || input.activityRef === undefined
             ? undefined
             : {
                 workflow_ref: input.workflowRef,

package/dist/control-plane/project-context-bootstrap.d.ts

@@ -1,5 +1,6 @@
 import type { ActivityRef, WorkflowInvocationRef } from "@tutti/shared/ids";
 import type { ScratchpadContentSnapshot } from "../collaboration-state/index.js";
+import type { CommunicationLanguageContext } from "../communication-language/index.js";
 import type { ProcedureProgressUpdate } from "../procedure-engine/index.js";
 import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
 import type { InitializeProjectDocsResult, ProjectDocsInitializationContext, ProjectDocsInitializationDocument } from "../workspace-ops/index.js";
@@ -14,6 +15,7 @@ export declare function buildProjectContextBootstrapWorkflowInput(options: {
 }): ProjectContextBootstrapWorkflowInput | undefined;
 export declare function projectContextBootstrapDocuments(output: ProjectContextBootstrapWorkflowOutput): ProjectDocsInitializationDocument[];
 export declare function tryProjectContextBootstrapDocuments(input: {
+    communicationLanguage?: CommunicationLanguageContext;
     runner: ProcedureWorkflowRunner;
     projectContext: Phase5ControlPlaneOptions["projectContext"];
     scratchpad: ScratchpadContentSnapshot;

package/dist/control-plane/project-context-bootstrap.js

@@ -1,5 +1,6 @@
 import { projectDocPath, readProjectDocsSummaries } from "../project-docs/context.js";
 import { projectContextBootstrapInvalidates } from "./invalidations.js";
+import { logLanguageContext } from "./communication-language.js";
 export function buildProjectDocsInitializationContext(scratchpad) {
     return {
         source: "scratchpad_submit",
@@ -56,6 +57,13 @@ export async function tryProjectContextBootstrapDocuments(input) {
     if (workflowInput === undefined) {
         return undefined;
     }
+    if (input.communicationLanguage !== undefined) {
+        workflowInput.communication_language = input.communicationLanguage;
+        logLanguageContext(input.logger, input.communicationLanguage, {
+            workflow_ref: input.workflowRef,
+            activity_ref: input.activityRef,
+        });
+    }
     try {
         const output = await input.runner.runProjectContextBootstrap(workflowInput, {
             workflow_ref: input.workflowRef,

package/dist/control-plane/reference-summary-refresh.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 { withHostStoreTransaction } from "../store/index.js";
 import { WorkspaceOpsError, readReferenceSummaryTargets, updateReferenceSummaries, } from "../workspace-ops/index.js";
@@ -89,6 +90,7 @@ async function runReferenceSummaryRefresh(options) {
         let completedInBatch = 0;
         const batchResults = await mapWithConcurrency(batch, REFERENCE_SUMMARY_CONCURRENCY, async (target) => {
             const result = await summarizeReferenceTarget({
+                communicationLanguage: projectLanguageContext(options.store.db, "summary"),
                 target,
                 runner: options.runner,
                 workflowRef: options.workflowRef,
@@ -211,7 +213,12 @@ async function mapWithConcurrency(items, concurrency, worker) {
 async function summarizeReferenceTarget(options) {
     for (let attempt = 1; attempt <= REFERENCE_SUMMARY_MAX_ATTEMPTS; attempt += 1) {
         try {
+            logLanguageContext(options.logger, options.communicationLanguage, {
+                workflow_ref: options.workflowRef,
+                activity_ref: options.activityRef,
+            });
             const output = await options.runner.runReferenceFileSummary?.({
+                communication_language: options.communicationLanguage,
                 workflow_ref: options.workflowRef,
                 activity_ref: options.activityRef,
                 file: {

package/dist/control-plane/run-start.js

@@ -2,8 +2,9 @@ import { readScratchpadReceiptSourceRefs } from "../collaboration-state/index.js
 import { materializeWorkflowRecentReferences } from "./recent-references.js";
 import { readCompletedTaskCompileClarificationRounds } from "./task-compile-clarification-context.js";
 import { materializePromptSourceMessages } from "./task-source-context.js";
-import { recordRunPipelineFailure, recordRunPipelineResult, } from "./run-result-recording.js";
+import { recordRunPipelineFailure, recordRunPipelineResult } from "./run-result-recording.js";
 import { projectBriefShouldRefreshForUpdatedPaths, refreshProjectBriefProjection, } from "./project-brief-refresh.js";
+import { workflowLanguageContext, sourceLanguageEvidence, logLanguageContext, } from "./communication-language.js";
 function runLineageFields(lineage) {
     return {
         run_lineage_kind: lineage.kind,
@@ -83,8 +84,7 @@ export function startControlPlaneRunForTask(input) {
             const pipelineStartedAt = input.now();
             input.logger?.info(lifecycleFields, "Run pipeline started");
             try {
-                const workflowRef = input.run.task
-                    .created_from_workflow_ref;
+                const workflowRef = input.run.task.created_from_workflow_ref;
                 const sourceMessages = materializePromptSourceMessages(input.store.db, readScratchpadReceiptSourceRefs(input.store.db, workflowRef));
                 const clarificationRounds = readCompletedTaskCompileClarificationRounds({
                     store: input.store,
@@ -98,7 +98,17 @@ export function startControlPlaneRunForTask(input) {
                         workflowRef,
                         now: input.now,
                     });
+                const language = workflowLanguageContext(input.store.db, {
+                    workflowRef,
+                    taskId: input.run.task.id,
+                    sources: sourceLanguageEvidence(input.store.db, readScratchpadReceiptSourceRefs(input.store.db, workflowRef)),
+                });
+                logLanguageContext(input.logger, language, {
+                    activity_ref: context.activity_ref,
+                    task_id: input.run.task.id,
+                });
                 const pipelineResult = await input.run.runner.runTask({
+                    communication_language: language,
                     activity_ref: context.activity_ref,
                     task: input.run.task,
                     task_detail: input.run.task_detail,
@@ -114,9 +124,7 @@ export function startControlPlaneRunForTask(input) {
                     ...(clarificationRounds.length === 0
                         ? {}
                         : { clarification_rounds: clarificationRounds }),
-                    ...(recentReferences.length === 0
-                        ? {}
-                        : { recent_references: recentReferences }),
+                    ...(recentReferences.length === 0 ? {} : { recent_references: recentReferences }),
                     on_stage: (progress) => context.reportProgress({
                         phase: progress.stage,
                         summary: runStageSummary(input.run, progress),

package/dist/control-plane/scratchpad-refresh-start.d.ts

@@ -30,6 +30,7 @@ export declare function runControlPlaneScratchpadRefreshProcedure(options: {
     events: WorkspaceEventBus;
     sourceBatch: ScratchpadSourceBatch;
     lane: ProcedureLane;
+    logger?: ControlPlaneLogger | undefined;
     recordRecoveryIntent?: boolean;
     recoveryIntentId?: ControlPlaneIntentId;
     now: () => Date;

package/dist/control-plane/scratchpad-refresh-start.js

@@ -1,5 +1,6 @@
 import { createWorkflowInvocationRef, } from "@tutti/shared/ids";
 import { readActiveTaskCompileContext, readMainChatMessagesForScratchpadCycle, readScratchpadSourceState, readWorklistProjection, markScratchpadRefreshFailed, markScratchpadRefreshStarted, } from "../collaboration-state/index.js";
+import { projectLanguageContext, messageLanguageEvidence, logLanguageContext, } from "./communication-language.js";
 import { readProjectBriefProjection, readProjectBriefSourceDocuments, } from "../project-brief/index.js";
 import { withHostStoreTransaction } from "../store/index.js";
 import { logProcedureExecutionError } from "./procedure-logging.js";
@@ -37,6 +38,7 @@ function workflowInputSize(input) {
 }
 function fitScratchpadRefreshWorkflowInput(input) {
     const base = {
+        communication_language: input.language,
         ...(input.projectBrief === undefined ? {} : { project_brief: input.projectBrief }),
         ...(input.activeTaskCompile === undefined
             ? {}
@@ -107,6 +109,7 @@ export function readControlPlaneScratchpadSourceBatch(store, options = {}) {
         ...(activeContext === null ? {} : { activeTaskCompile: activeContext.scratchpad_snapshot }),
         worklist: readWorklistProjection(store.db),
         sourceMessages,
+        language: projectLanguageContext(store.db, "scratchpad", sourceMessages.map(messageLanguageEvidence)),
     });
     return {
         workflow_input: workflowInput,
@@ -146,6 +149,12 @@ export async function runControlPlaneScratchpadRefreshProcedure(options) {
             now: options.now,
         });
     });
+    const language = options.sourceBatch.workflow_input.communication_language;
+    if (language !== undefined)
+        logLanguageContext(options.logger, language, {
+            workflow_ref: options.workflowRef,
+            activity_ref: options.activityRef,
+        });
     let output;
     try {
         output = await options.runner.runScratchpadRefresh(options.sourceBatch.workflow_input, {
@@ -160,6 +169,8 @@ export async function runControlPlaneScratchpadRefreshProcedure(options) {
         });
         throw error;
     }
+    if (language !== undefined)
+        logLanguageContext(options.logger, language, { workflow_ref: options.workflowRef, activity_ref: options.activityRef }, output.communication_language);
     return applyScratchpadRefreshOutput({
         store: options.store,
         events: options.events,
@@ -169,6 +180,7 @@ export async function runControlPlaneScratchpadRefreshProcedure(options) {
         cursorUpdate: options.sourceBatch.cursor_update,
         sourceRefs: options.sourceBatch.source_refs,
         now: options.now,
+        ...(language === undefined ? {} : { languageContext: language }),
     });
 }
 export function readActiveScratchpadRefreshActivityRef(options) {
@@ -247,6 +259,7 @@ export function startControlPlaneScratchpadRefresh(options) {
             error,
         }),
         execute: async (context) => runControlPlaneScratchpadRefreshProcedure({
+            logger: options.logger,
             runner: runnerResolution.runner,
             workflowRef,
             activityRef: context.activity_ref,

package/dist/control-plane/scratchpad-refresh.d.ts

@@ -3,6 +3,7 @@ import type { ScratchpadSourceCursorUpdate } from "../collaboration-state/scratc
 import type { ScratchpadSourceRefInput } from "../collaboration-state/types.js";
 import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
 import type { HostProjectStore } from "../store/index.js";
+import type { CommunicationLanguageContext } from "../communication-language/index.js";
 import type { ScratchpadRefreshWorkflowOutput } from "./workflows/index.js";
 export declare function applyScratchpadRefreshOutput(input: {
     store: HostProjectStore;
@@ -13,6 +14,7 @@ export declare function applyScratchpadRefreshOutput(input: {
     cursorUpdate: ScratchpadSourceCursorUpdate;
     sourceRefs: ScratchpadSourceRefInput[];
     now: () => Date;
+    languageContext?: CommunicationLanguageContext;
 }): {
     kind: "needs_human";
     summary: string;

package/dist/control-plane/scratchpad-refresh.js

@@ -1,44 +1,58 @@
-import { createMainChatAgentMessage, markScratchpadRefreshSucceeded, upsertScratchpadProjection, } from "../collaboration-state/index.js";
+import { createMainChatAgentMessage, markScratchpadRefreshSucceeded, upsertScratchpadProjection, readMessageProjectionById, } from "../collaboration-state/index.js";
+import { withHostStoreTransaction } from "../store/index.js";
+import { recordScratchpadLanguage } from "./communication-language.js";
 import { mainChatInvalidates, scratchpadRefreshInvalidates } from "./invalidations.js";
 export function applyScratchpadRefreshOutput(input) {
+    const persistLanguage = () => recordScratchpadLanguage(input.store.db, {
+        ...(input.output.communication_language === undefined
+            ? {}
+            : { language: input.output.communication_language }),
+        ...(input.languageContext === undefined ? {} : { context: input.languageContext }),
+        sourceMessages: input.sourceRefs.flatMap((source) => {
+            const message = readMessageProjectionById(input.store.db, source.message_id);
+            return message === null ? [] : [message];
+        }),
+        activityRef: input.activityRef,
+        snapshot: input.output.decision === "ready",
+        now: input.now,
+    });
     if (input.output.decision === "needs_human") {
-        const message = createMainChatAgentMessage(input.store.db, {
-            body: input.output.request_payload.request,
-            refs: {
-                workflow_ref: input.workflowRef,
-                activity_ref: input.activityRef,
-                scratchpad_source: "exclude",
-            },
-            now: input.now,
+        const request = input.output.request_payload.request;
+        const message = withHostStoreTransaction(input.store.db, () => {
+            persistLanguage();
+            markScratchpadRefreshSucceeded(input.store.db, { ...input.cursorUpdate, now: input.now });
+            return createMainChatAgentMessage(input.store.db, {
+                body: request,
+                refs: {
+                    workflow_ref: input.workflowRef,
+                    activity_ref: input.activityRef,
+                    scratchpad_source: "exclude",
+                },
+                now: input.now,
+            });
         });
         input.events.publish({
             event_type: "message.created",
             payload: { message },
             invalidates: mainChatInvalidates(),
         });
-        markScratchpadRefreshSucceeded(input.store.db, {
-            ...input.cursorUpdate,
-            now: input.now,
-        });
         return {
             kind: "needs_human",
             summary: input.output.request_payload.summary,
             result_anchor: { kind: "workflow", workflow_ref: input.workflowRef },
         };
     }
-    const scratchpad = upsertScratchpadProjection(input.store.db, {
-        topic: input.output.scratchpad_snapshot.topic,
-        background_summary: input.output.scratchpad_snapshot.background_summary,
-        current_consensus: input.output.scratchpad_snapshot.current_consensus,
-        open_questions: input.output.scratchpad_snapshot.open_questions,
-        task_changes: input.output.scratchpad_snapshot.task_changes,
-        source_refs: input.sourceRefs,
-        updated_by_activity_ref: input.activityRef,
-        now: input.now,
-    });
-    markScratchpadRefreshSucceeded(input.store.db, {
-        ...input.cursorUpdate,
-        now: input.now,
+    const snapshot = input.output.scratchpad_snapshot;
+    const scratchpad = withHostStoreTransaction(input.store.db, () => {
+        persistLanguage();
+        const projection = upsertScratchpadProjection(input.store.db, {
+            ...snapshot,
+            source_refs: input.sourceRefs,
+            updated_by_activity_ref: input.activityRef,
+            now: input.now,
+        });
+        markScratchpadRefreshSucceeded(input.store.db, { ...input.cursorUpdate, now: input.now });
+        return projection;
     });
     input.events.publish({
         event_type: "scratchpad.updated",

package/dist/control-plane/task-compile-continuation.js

@@ -6,6 +6,7 @@ import { readTaskCompileClarificationRounds } from "./task-compile-clarification
 import { materializePromptSourceMessages } from "./task-source-context.js";
 import { logProcedureExecutionError } from "./procedure-logging.js";
 import { materializeRecentReferences, readRecentReferenceSources } from "./recent-references.js";
+import { workflowLanguageContext, sourceLanguageEvidence, logLanguageContext, } from "./communication-language.js";
 export function startControlPlaneTaskCompileContinuation(options) {
     if (options.owner.kind !== "task_compile") {
         return { kind: "obsolete", errorCode: "owner_kind_mismatch" };
@@ -59,10 +60,21 @@ export function startControlPlaneTaskCompileContinuation(options) {
                         sources: readRecentReferenceSources(options.store.db, taskCompileContext.sources),
                         now: options.now,
                     });
+                const sourceMessages = materializePromptSourceMessages(options.store.db, taskCompileContext.sources);
+                const language = workflowLanguageContext(options.store.db, {
+                    workflowRef,
+                    sources: sourceLanguageEvidence(options.store.db, taskCompileContext.sources),
+                    answers: clarificationRounds.flatMap((entry) => entry.answer_messages),
+                });
+                logLanguageContext(options.logger, language, {
+                    workflow_ref: workflowRef,
+                    activity_ref: context.activity_ref,
+                });
                 const output = await runnerResolution.runner.runTaskCompile({
+                    communication_language: language,
                     workflow_ref: workflowRef,
                     scratchpad: taskCompileContext.scratchpad_snapshot,
-                    source_messages: materializePromptSourceMessages(options.store.db, taskCompileContext.sources),
+                    source_messages: sourceMessages,
                     worklist: readWorklistProjection(options.store.db),
                     ...(recentReferences.length === 0 ? {} : { recent_references: recentReferences }),
                     clarification_rounds: clarificationRounds,
@@ -71,6 +83,7 @@ export function startControlPlaneTaskCompileContinuation(options) {
                     activity_ref: context.activity_ref,
                     reportProgress: context.reportProgress,
                 });
+                logLanguageContext(options.logger, language, { workflow_ref: workflowRef, activity_ref: context.activity_ref }, output.communication_language);
                 return applyTaskCompileProcedureOutput({
                     store: options.store,
                     events: options.events,

package/dist/control-plane/task-compile-output.js

@@ -1,7 +1,8 @@
 import { applyTaskCompileProposal, completeTaskCompileContext, materializeClarificationSuccessor, openNextTaskCompileClarificationRound, openTaskCompileClarificationRound, readClarificationRoundProjection, readWorklistProjection, } from "../collaboration-state/index.js";
 import { withHostStoreTransaction } from "../store/index.js";
-import { clarificationInvalidates, taskCompileInvalidates, } from "./invalidations.js";
+import { clarificationInvalidates, taskCompileInvalidates } from "./invalidations.js";
 import { normalizeTaskCompileProposal } from "./task-proposal.js";
+import { recordWorkflowLanguage } from "./communication-language.js";
 const EMPTY_INITIAL_WORKLIST_CLARIFICATION = {
     title: "Worklist scope needed",
     summary: "No existing Worklist task covers this Scratchpad, and no new task was produced.",
@@ -11,20 +12,28 @@ function countWorklistTasks(worklist) {
     return worklist.modules.reduce((count, module) => count + module.tasks.length, 0);
 }
 function openTaskCompileNeedsHuman(input) {
-    const opened = input.continueFromRoundId === undefined
-        ? openTaskCompileClarificationRound(input.store.db, {
-            workflow_ref: input.workflowRef,
-            activity_ref: input.activityRef,
-            request_payload: input.requestPayload,
-            now: input.now,
-        })
-        : openNextTaskCompileClarificationRound(input.store.db, {
-            continue_from_round_id: input.continueFromRoundId,
-            workflow_ref: input.workflowRef,
-            activity_ref: input.activityRef,
-            request_payload: input.requestPayload,
+    const opened = withHostStoreTransaction(input.store.db, (tx) => {
+        recordWorkflowLanguage(tx, {
+            owner: { kind: "workflow", ref: input.workflowRef },
+            ...(input.language === undefined ? {} : { language: input.language }),
+            activityRef: input.activityRef,
             now: input.now,
         });
+        return input.continueFromRoundId === undefined
+            ? openTaskCompileClarificationRound(input.store.db, {
+                workflow_ref: input.workflowRef,
+                activity_ref: input.activityRef,
+                request_payload: input.requestPayload,
+                now: input.now,
+            })
+            : openNextTaskCompileClarificationRound(input.store.db, {
+                continue_from_round_id: input.continueFromRoundId,
+                workflow_ref: input.workflowRef,
+                activity_ref: input.activityRef,
+                request_payload: input.requestPayload,
+                now: input.now,
+            });
+    });
     const roundId = opened.round.id;
     if (input.continueFromRoundId !== undefined) {
         input.events.publish({
@@ -66,9 +75,13 @@ function openTaskCompileNeedsHuman(input) {
 }
 export function applyTaskCompileProcedureOutput(input) {
     if (input.output.decision === "needs_human") {
+        const requestPayload = input.output.clarification_request_payload;
         return openTaskCompileNeedsHuman({
             ...input,
-            requestPayload: input.output.clarification_request_payload,
+            requestPayload,
+            ...(input.output.communication_language === undefined
+                ? {}
+                : { language: input.output.communication_language }),
         });
     }
     const currentWorklist = readWorklistProjection(input.store.db);
@@ -79,12 +92,23 @@ export function applyTaskCompileProcedureOutput(input) {
         return openTaskCompileNeedsHuman({
             ...input,
             requestPayload: EMPTY_INITIAL_WORKLIST_CLARIFICATION,
+            ...(input.output.communication_language === undefined
+                ? {}
+                : { language: input.output.communication_language }),
         });
     }
     const continuationRound = input.continueFromRoundId === undefined
         ? null
         : readClarificationRoundProjection(input.store.db, input.continueFromRoundId);
     const committed = withHostStoreTransaction(input.store.db, (tx) => {
+        recordWorkflowLanguage(tx, {
+            owner: { kind: "workflow", ref: input.workflowRef },
+            ...(input.output.communication_language === undefined
+                ? {}
+                : { language: input.output.communication_language }),
+            activityRef: input.activityRef,
+            now: input.now,
+        });
         const applied = applyTaskCompileProposal(tx, {
             workflow_ref: input.workflowRef,
             proposal,

package/dist/control-plane/task-compile-start.d.ts

@@ -52,6 +52,7 @@ export declare function resumeControlPlaneTaskCompileChain(options: {
     onChainTerminal: (result?: IntentRuntimeTerminal) => void;
 }): IntentRuntimeStartResult;
 export declare function runControlPlaneTaskCompileProcedure(options: {
+    logger?: ControlPlaneLogger | undefined;
     runner: ProcedureWorkflowRunner;
     workflowRef: WorkflowInvocationRef;
     activityRef: ActivityRef;

package/dist/control-plane/task-compile-start.js

@@ -1,4 +1,5 @@
 import { createWorkflowInvocationRef, } from "@tutti/shared/ids";
+import { workflowLanguageContext, sourceLanguageEvidence, logLanguageContext, } from "./communication-language.js";
 import { captureTaskCompileContext, readActiveTaskCompileContext, readCurrentScratchpadSourceRefs, readPendingTaskCompileSubmission, readScratchpadProjection, readScratchpadSourceState, readWorklistProjection, recordTaskCompileSubmission, rollbackTaskCompileContext, } from "../collaboration-state/index.js";
 import { withHostStoreTransaction } from "../store/index.js";
 import { initializeProjectDocs, readProjectDocsInitializationStatus, } from "../workspace-ops/index.js";
@@ -166,6 +167,7 @@ function startControlPlaneTaskCompileActivity(options) {
             error,
         }),
         execute: async (context) => runControlPlaneTaskCompileProcedure({
+            logger: options.logger,
             runner: options.runner,
             store: options.store,
             events: options.events,
@@ -242,6 +244,7 @@ function startScratchpadRefreshBeforeTaskCompileActivity(options) {
             error,
         }),
         execute: async (context) => runControlPlaneScratchpadRefreshProcedure({
+            logger: options.logger,
             runner: options.runner,
             store: options.store,
             events: options.events,
@@ -552,6 +555,13 @@ function startProjectContextBootstrapActivity(options) {
             try {
                 const initializationContext = buildProjectDocsInitializationContext(taskCompileContext.scratchpad_snapshot);
                 const modelDocuments = await tryProjectContextBootstrapDocuments({
+                    communicationLanguage: {
+                        ...workflowLanguageContext(options.store.db, {
+                            workflowRef: options.taskCompileWorkflowRef,
+                            sources: [],
+                        }),
+                        scope: "documents",
+                    },
                     runner: options.runner,
                     projectContext: options.projectContext,
                     scratchpad: taskCompileContext.scratchpad_snapshot,
@@ -639,10 +649,20 @@ export async function runControlPlaneTaskCompileProcedure(options) {
                 sources: readRecentReferenceSources(options.store.db, context.sources),
                 now: options.now,
             });
+        const sourceMessages = materializePromptSourceMessages(options.store.db, context.sources);
+        const language = workflowLanguageContext(options.store.db, {
+            workflowRef: options.workflowRef,
+            sources: sourceLanguageEvidence(options.store.db, context.sources),
+        });
+        logLanguageContext(options.logger, language, {
+            workflow_ref: options.workflowRef,
+            activity_ref: options.activityRef,
+        });
         const output = await options.runner.runTaskCompile({
+            communication_language: language,
             workflow_ref: options.workflowRef,
             scratchpad: context.scratchpad_snapshot,
-            source_messages: materializePromptSourceMessages(options.store.db, context.sources),
+            source_messages: sourceMessages,
             worklist: readWorklistProjection(options.store.db),
             ...(recentReferences.length === 0 ? {} : { recent_references: recentReferences }),
         }, {
@@ -650,6 +670,7 @@ export async function runControlPlaneTaskCompileProcedure(options) {
             activity_ref: options.activityRef,
             ...(options.reportProgress === undefined ? {} : { reportProgress: options.reportProgress }),
         });
+        logLanguageContext(options.logger, language, { workflow_ref: options.workflowRef, activity_ref: options.activityRef }, output.communication_language);
         return applyTaskCompileProcedureOutput({
             store: options.store,
             events: options.events,

package/dist/control-plane/types.d.ts

@@ -3,6 +3,7 @@ import type { RuntimeLogger } from "@tutti/shared/utils";
 import type { ActivityRef, ClarificationRoundRef, TaskId, TaskModuleId } from "@tutti/shared/ids";
 import type { ActiveApprovalProjection, ClarificationRequestPayload, ExecutionRuntimeSnapshot, MessageProjection, RecoverySummaryProjection, TaskDetailProjection, TaskProjection } from "@tutti/shared/schemas/api";
 import type { HostProjectStore } from "../store/index.js";
+import type { CommunicationLanguageContext } from "../communication-language/index.js";
 import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
 import type { RecentReferenceContext } from "./reference-context-types.js";
 import type { PromptSourceMessage, TaskCompileClarificationContext } from "./task-source-context-types.js";
@@ -114,6 +115,7 @@ export type RunCorrectionContext = {
     } | null;
 };
 export type RunPipelineInput = {
+    communication_language?: CommunicationLanguageContext;
     activity_ref: ActivityRef;
     task: TaskProjection;
     task_detail: TaskDetailProjection;