@xfey/tutti 0.1.126 → 0.1.128

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

@@ -1,11 +1,13 @@
 import { materializeClarificationSuccessor, readActiveTaskCompileContext, readClarificationRoundProjection, readWorklistProjection, rollbackTaskCompileContext, } from "../collaboration-state/index.js";
 import { withHostStoreTransaction } from "../store/index.js";
+import { linkTaskCompileActivity } from "../collaboration-state/task-compile-requests.js";
 import { clarificationInvalidates } from "./invalidations.js";
 import { applyTaskCompileProcedureOutput } from "./task-compile-output.js";
 import { readTaskCompileClarificationRounds } from "./task-compile-clarification-context.js";
 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" };
@@ -26,6 +28,7 @@ export function startControlPlaneTaskCompileContinuation(options) {
         summary: "Continuing task_compile from clarification input.",
         now: options.now,
         onTransition: (state) => {
+            linkTaskCompileActivity(options.store.db, workflowRef, state.activity.activity_ref);
             options.publishProcedureTransition(state);
             if (state.transition_kind === "terminal") {
                 options.onTerminal?.(state.activity.status === "failed"
@@ -59,10 +62,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 +85,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-request-status.d.ts

@@ -0,0 +1,6 @@
+import type { ExecutionStatusProjection, WorklistSubmissionStatus } from "@tutti/shared/schemas/api";
+import type { SqliteDatabase } from "../store/index.js";
+/** Pure projection of owned records. A missing receipt is never proof of failure. */
+export declare function readTaskCompileRequestStatus(db: SqliteDatabase, execution: ExecutionStatusProjection, workflowRef?: string): WorklistSubmissionStatus | null;
+export declare function readTaskCompileCommandRef(db: SqliteDatabase, commandId: string): string | undefined;
+//# sourceMappingURL=task-compile-request-status.d.ts.map

package/dist/control-plane/task-compile-request-status.js

@@ -0,0 +1,70 @@
+import { readActiveClarificationProjection, readActiveTaskCompileContext, readPendingTaskCompileSubmission, } from "../collaboration-state/index.js";
+/** Pure projection of owned records. A missing receipt is never proof of failure. */
+export function readTaskCompileRequestStatus(db, execution, workflowRef) {
+    const row = workflowRef === undefined
+        ? db
+            .prepare("SELECT * FROM task_compile_requests ORDER BY rowid DESC LIMIT 1")
+            .get()
+        : db
+            .prepare("SELECT * FROM task_compile_requests WHERE workflow_ref = ?")
+            .get(workflowRef);
+    if (row === undefined)
+        return null;
+    const common = {
+        operation: { kind: "worklist_submit", ref: row.workflow_ref },
+        created_at: row.created_at,
+        activity_ref: row.current_activity_ref,
+    };
+    if (db.prepare("SELECT 1 FROM scratchpad_receipts WHERE workflow_ref = ?").get(row.workflow_ref)) {
+        return { ...common, status: "succeeded", phase: "settled" };
+    }
+    if (row.failure_code !== null) {
+        return {
+            ...common,
+            status: "failed",
+            phase: "settled",
+            failure: {
+                code: row.failure_code,
+                category: "internal",
+                recovery: "none",
+                diagnostic_id: row.workflow_ref,
+            },
+        };
+    }
+    const clarification = readActiveClarificationProjection(db);
+    if (clarification.state === "active" &&
+        clarification.thread.owner.kind === "task_compile" &&
+        clarification.thread.owner.workflow_ref === row.workflow_ref &&
+        clarification.round.status === "writable") {
+        return {
+            ...common,
+            status: "waiting_input",
+            phase: "clarification",
+            round_id: clarification.round.id,
+        };
+    }
+    const activities = execution.active_activities ?? (execution.active_activity ? [execution.active_activity] : []);
+    const active = activities.find((entry) => entry.activity_ref === row.current_activity_ref || entry.workflow_ref === row.workflow_ref);
+    if (active !== undefined) {
+        const kind = active.workflow_kind;
+        const phase = kind === "scratchpad_refresh" ||
+            kind === "reference_summary_refresh" ||
+            kind === "project_context_bootstrap" ||
+            kind === "task_compile"
+            ? kind
+            : "preparing";
+        return { ...common, activity_ref: active.activity_ref, status: "running", phase };
+    }
+    const ref = row.workflow_ref;
+    if (readPendingTaskCompileSubmission(db, ref) !== null ||
+        readActiveTaskCompileContext(db, ref) !== null) {
+        return { ...common, status: "running", phase: "preparing" };
+    }
+    return { ...common, status: "unknown", phase: "unconfirmed" };
+}
+export function readTaskCompileCommandRef(db, commandId) {
+    return db
+        .prepare("SELECT workflow_ref FROM task_compile_request_commands WHERE command_id = ?")
+        .get(commandId)?.workflow_ref;
+}
+//# sourceMappingURL=task-compile-request-status.js.map

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;