@xfey/tutti 0.1.126 → 0.1.128

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";
@@ -11,10 +12,15 @@ import { enqueueControlPlaneIntent } from "./dispatch-intents.js";
 import { materializePromptSourceMessages } from "./task-source-context.js";
 import { materializeRecentReferences, readPendingRecentReferenceSummaryPaths, readRecentReferenceSources, } from "./recent-references.js";
 import { startReferenceSummaryRefreshProcedure } from "./reference-summary-refresh.js";
+import { linkTaskCompileActivity, closeFailedTaskCompileRequest, } from "../collaboration-state/task-compile-requests.js";
 export function startControlPlaneTaskCompile(options) {
     const activeContext = readActiveTaskCompileContext(options.store.db);
     if (activeContext !== null) {
         return {
+            result: {
+                submission_ref: activeContext.workflow_ref,
+                activity_ref: activeContext.captured_by_activity_ref,
+            },
             disposition: {
                 kind: "already_running",
                 activity_ref: activeContext.captured_by_activity_ref,
@@ -24,6 +30,10 @@ export function startControlPlaneTaskCompile(options) {
     const pendingSubmission = readPendingTaskCompileSubmission(options.store.db);
     if (pendingSubmission !== null) {
         return {
+            result: {
+                submission_ref: pendingSubmission.workflow_ref,
+                activity_ref: pendingSubmission.accepted_activity_ref,
+            },
             disposition: {
                 kind: "already_running",
                 activity_ref: pendingSubmission.accepted_activity_ref,
@@ -71,7 +81,7 @@ export function startControlPlaneTaskCompile(options) {
                 },
             };
         }
-        return startScratchpadRefreshBeforeTaskCompileActivity({
+        const started = startScratchpadRefreshBeforeTaskCompileActivity({
             ...options,
             runner: runnerResolution.runner,
             sourceBatch,
@@ -85,6 +95,7 @@ export function startControlPlaneTaskCompile(options) {
                 now: options.now,
             }),
         });
+        return withSubmissionRef(started, taskCompileWorkflowRef);
     }
     if (!scratchpadHasSubmittableContent(scratchpad)) {
         return { disposition: { kind: "scratchpad_empty" } };
@@ -107,7 +118,12 @@ export function startControlPlaneTaskCompile(options) {
             now: options.now,
         });
     }
-    return started;
+    return withSubmissionRef(started, taskCompileWorkflowRef);
+}
+function withSubmissionRef(result, submissionRef) {
+    return result.disposition.kind === "accepted"
+        ? { ...result, result: { ...result.result, submission_ref: submissionRef } }
+        : result;
 }
 function recordTaskCompileSubmissionIntent(options) {
     return withHostStoreTransaction(options.store.db, (tx) => {
@@ -151,6 +167,7 @@ function startControlPlaneTaskCompileActivity(options) {
         summary: "Compiling Scratchpad into Worklist tasks.",
         now: options.now,
         onTransition: (state) => {
+            linkTaskCompileActivity(options.store.db, options.taskCompileWorkflowRef, state.activity.activity_ref);
             options.publishProcedureTransition(state);
             if (state.transition_kind === "terminal") {
                 options.onChainTerminal?.(state.activity.status === "failed"
@@ -166,6 +183,7 @@ function startControlPlaneTaskCompileActivity(options) {
             error,
         }),
         execute: async (context) => runControlPlaneTaskCompileProcedure({
+            logger: options.logger,
             runner: options.runner,
             store: options.store,
             events: options.events,
@@ -204,11 +222,16 @@ function startScratchpadRefreshBeforeTaskCompileActivity(options) {
         summary: "Refreshing Scratchpad before submitting to Worklist.",
         now: options.now,
         onTransition: (state) => {
+            linkTaskCompileActivity(options.store.db, options.taskCompileWorkflowRef, state.activity.activity_ref);
             options.publishProcedureTransition(state);
             if (state.transition_kind !== "terminal") {
                 return;
             }
             if (state.activity.status !== "finished") {
+                rollbackTaskCompileContext(options.store.db, {
+                    workflow_ref: options.taskCompileWorkflowRef,
+                    now: options.now,
+                });
                 options.onChainTerminal?.({
                     state: "failed",
                     errorCode: "scratchpad_refresh_failed",
@@ -220,6 +243,10 @@ function startScratchpadRefreshBeforeTaskCompileActivity(options) {
             }
             const scratchpad = readScratchpadProjection(options.store.db);
             if (!scratchpadHasSubmittableContent(scratchpad)) {
+                withHostStoreTransaction(options.store.db, (tx) => {
+                    closeFailedTaskCompileRequest(tx, options.taskCompileWorkflowRef, options.now().toISOString(), "scratchpad_empty_after_refresh");
+                    tx.prepare("DELETE FROM pending_task_compile_submissions WHERE workflow_ref = ?").run(options.taskCompileWorkflowRef);
+                });
                 options.onChainTerminal?.({
                     state: "failed",
                     errorCode: "scratchpad_empty_after_refresh",
@@ -228,6 +255,10 @@ function startScratchpadRefreshBeforeTaskCompileActivity(options) {
             }
             const next = startReferenceSummaryGateOrNextStage(options);
             if (next.disposition.kind !== "accepted" && next.disposition.kind !== "already_running") {
+                rollbackTaskCompileContext(options.store.db, {
+                    workflow_ref: options.taskCompileWorkflowRef,
+                    now: options.now,
+                });
                 options.onChainTerminal?.({
                     state: "failed",
                     errorCode: "task_compile_stage_unavailable",
@@ -242,6 +273,7 @@ function startScratchpadRefreshBeforeTaskCompileActivity(options) {
             error,
         }),
         execute: async (context) => runControlPlaneScratchpadRefreshProcedure({
+            logger: options.logger,
             runner: options.runner,
             store: options.store,
             events: options.events,
@@ -410,6 +442,10 @@ function startReferenceSummaryGateOrNextStage(options) {
         });
         registerReferenceSummaryGateWaiter(options, activeReferenceSummary.activity_ref);
         return {
+            result: {
+                submission_ref: options.taskCompileWorkflowRef,
+                activity_ref: activeReferenceSummary.activity_ref,
+            },
             disposition: {
                 kind: "already_running",
                 activity_ref: activeReferenceSummary.activity_ref,
@@ -511,6 +547,10 @@ function startProjectContextBootstrapActivity(options) {
                 return;
             }
             if (state.activity.status !== "finished") {
+                rollbackTaskCompileContext(options.store.db, {
+                    workflow_ref: options.taskCompileWorkflowRef,
+                    now: options.now,
+                });
                 options.onChainTerminal?.({ state: "failed", errorCode: "project_context_failed" });
                 return;
             }
@@ -552,6 +592,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 +686,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 +707,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,
@@ -676,6 +734,7 @@ function readOrCaptureTaskCompileContext(input) {
                 captured_by_activity_ref: input.activityRef,
                 now: input.now,
             });
+        linkTaskCompileActivity(tx, input.workflowRef, input.activityRef);
         enqueueControlPlaneIntent(tx, {
             kind: "task_compile_start",
             ownerKind: "task_compile",

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;

package/dist/control-plane/workflows/openai.js

@@ -3,7 +3,7 @@ import { rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { extname, isAbsolute, join, relative, resolve } from "node:path";
 import { clarificationAnswerRole } from "@tutti/shared/utils";
-import { renderPromptTemplate } from "../../prompt-templates/index.js";
+import { renderLanguageAwarePrompt, languageOutputContract, } from "../../communication-language/prompt.js";
 import { createOpenAiStructuredOutputClient, runOpenAiStructuredOutput, } from "../../providers/openai/sdk-procedure-runner.js";
 import { readOpenAiApiKeyCredential } from "../../providers/openai/credential-store.js";
 import { resolveOpenAiProviderConfig } from "../../providers/openai/provider-config.js";
@@ -283,13 +283,15 @@ function recordUsage(options, source, result, anchors = {}) {
 export function createOpenAiProcedureWorkflowRunner(options) {
     const runner = {
         async runScratchpadRefresh(input, context) {
-            const instructions = renderPromptTemplate({
+            const { communication_language: language, ...businessInput } = input;
+            const contract = languageOutputContract(SCRATCHPAD_REFRESH_OUTPUT_SCHEMA, isScratchpadRefreshStructuredOutput, language);
+            const instructions = renderLanguageAwarePrompt({
                 templateKey: "procedures.scratchpad_refresh",
                 ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
                 variables: {
-                    workflow_input_json: input,
+                    workflow_input_json: businessInput,
                 },
-            });
+            }, language, true);
             const result = await runOpenAiStructuredOutput({
                 client: options.client,
                 model: options.config.default_model,
@@ -297,23 +299,28 @@ export function createOpenAiProcedureWorkflowRunner(options) {
                 input: "Run scratchpad_refresh and return only structured JSON.",
                 schemaName: "scratchpad_refresh_output",
                 schemaDescription: "Tutti scratchpad_refresh terminal workflow output.",
-                schema: SCRATCHPAD_REFRESH_OUTPUT_SCHEMA,
-                validate: isScratchpadRefreshStructuredOutput,
+                schema: contract.schema,
+                validate: contract.validate,
             });
             recordUsage(options, "scratchpad_refresh", result, {
                 workflow_ref: context.workflow_ref,
                 activity_ref: context.activity_ref,
             });
-            return result.output.result;
+            const decoded = contract.unwrap(result.output);
+            return {
+                ...decoded.output.result,
+                ...(decoded.language === undefined ? {} : { communication_language: decoded.language }),
+            };
         },
         async runProjectBriefRefresh(input, context) {
-            const instructions = renderPromptTemplate({
+            const { communication_language: language, ...businessInput } = input;
+            const instructions = renderLanguageAwarePrompt({
                 templateKey: "procedures.project_brief_refresh",
                 ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
                 variables: {
-                    workflow_input_json: input,
+                    workflow_input_json: businessInput,
                 },
-            });
+            }, language);
             const result = await runOpenAiStructuredOutput({
                 client: options.client,
                 model: options.config.default_model,
@@ -331,22 +338,24 @@ export function createOpenAiProcedureWorkflowRunner(options) {
             return result.output;
         },
         async runTaskCompile(input, context) {
-            const instructions = renderPromptTemplate({
+            const language = input.communication_language;
+            const contract = languageOutputContract(TASK_COMPILE_OUTPUT_SCHEMA, isTaskCompileStructuredOutput, language);
+            const instructions = renderLanguageAwarePrompt({
                 templateKey: "procedures.task_compile",
                 ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
                 variables: {
                     workflow_input_json: buildTaskCompilePromptInput(input),
                 },
-            });
+            }, language, true);
             const result = await runDurableReadOnlyProcedure({
                 options,
                 context,
                 kind: "task_compile",
-                archiveAfterTurn: (output) => "proposal" in output.result,
+                archiveAfterTurn: (output) => "proposal" in contract.unwrap(output).output.result,
                 invocation: {
-                    ...readOnlyAppServerOptions(options, instructions, TASK_COMPILE_OUTPUT_SCHEMA, "task_compile"),
+                    ...readOnlyAppServerOptions(options, instructions, contract.schema, "task_compile"),
                     ...readOnlyRuntimeTelemetry(context, "task_compile"),
-                    validateOutput: isTaskCompileStructuredOutput,
+                    validateOutput: contract.validate,
                     networkAccess: false,
                     webSearchMode: "disabled",
                 },
@@ -355,16 +364,22 @@ export function createOpenAiProcedureWorkflowRunner(options) {
                 workflow_ref: context?.workflow_ref ?? input.workflow_ref,
                 ...(context?.activity_ref === undefined ? {} : { activity_ref: context.activity_ref }),
             });
-            return taskCompileWorkflowOutput(result.output);
+            const decoded = contract.unwrap(result.output);
+            return {
+                ...taskCompileWorkflowOutput(decoded.output),
+                ...(decoded.language === undefined ? {} : { communication_language: decoded.language }),
+            };
         },
         async runFollowUpCheck(input, context) {
-            const instructions = renderPromptTemplate({
+            const language = input.communication_language;
+            const contract = languageOutputContract(FOLLOW_UP_CHECK_OUTPUT_SCHEMA, isFollowUpCheckStructuredOutput, language);
+            const instructions = renderLanguageAwarePrompt({
                 templateKey: "procedures.follow_up_check",
                 ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
                 variables: {
                     workflow_input_json: followUpCheckPromptInput(input),
                 },
-            });
+            }, language, true);
             const result = await runOpenAiStructuredOutput({
                 client: options.client,
                 model: options.config.default_model,
@@ -372,8 +387,8 @@ export function createOpenAiProcedureWorkflowRunner(options) {
                 input: "Run follow_up_check and return only structured JSON.",
                 schemaName: "follow_up_check_output",
                 schemaDescription: "Tutti follow_up_check terminal workflow output.",
-                schema: FOLLOW_UP_CHECK_OUTPUT_SCHEMA,
-                validate: isFollowUpCheckStructuredOutput,
+                schema: contract.schema,
+                validate: contract.validate,
             });
             recordUsage(options, "follow_up_check", result, {
                 workflow_ref: context?.workflow_ref ?? input.workflow_ref,
@@ -381,18 +396,23 @@ export function createOpenAiProcedureWorkflowRunner(options) {
                 task_id: input.task_id,
                 run_lineage_kind: input.run_lineage.kind,
             });
-            return followUpCheckWorkflowOutput(result.output);
+            const decoded = contract.unwrap(result.output);
+            return {
+                ...followUpCheckWorkflowOutput(decoded.output),
+                ...(decoded.language === undefined ? {} : { communication_language: decoded.language }),
+            };
         },
     };
     if (options.readOnlyAppServer !== undefined) {
         runner.runProjectContextBootstrap = async (input, context) => {
-            const instructions = renderPromptTemplate({
+            const { communication_language: language, ...businessInput } = input;
+            const instructions = renderLanguageAwarePrompt({
                 templateKey: "procedures.project_context_bootstrap",
                 ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
                 variables: {
-                    workflow_input_json: input,
+                    workflow_input_json: businessInput,
                 },
-            });
+            }, language);
             const result = await runDurableReadOnlyProcedure({
                 options,
                 context,
@@ -411,10 +431,10 @@ export function createOpenAiProcedureWorkflowRunner(options) {
             return result.output;
         };
         runner.runContextSync = async (input, context) => {
-            const instructions = renderPromptTemplate({
+            const instructions = renderLanguageAwarePrompt({
                 templateKey: "procedures.context_sync",
                 ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
-            });
+            }, input.communication_language);
             const result = await runDurableReadOnlyProcedure({
                 options,
                 context,
@@ -434,10 +454,10 @@ export function createOpenAiProcedureWorkflowRunner(options) {
         };
         runner.runReferenceFileSummary = async (input, context) => {
             const sourcePath = referenceSummarySourcePath(options, input);
-            const instructions = renderPromptTemplate({
+            const instructions = renderLanguageAwarePrompt({
                 templateKey: "procedures.reference_file_summary",
                 ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
-            });
+            }, input.communication_language);
             const workspace = createReferenceSummaryWorkspace({
                 sourcePath,
                 originalPath: input.file.path,

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

@@ -1,12 +1,16 @@
 import type { ExecutionRuntimeSnapshot, MessageProjection, RunResultProjection, TaskDetailProjection, WorklistProjection } from "@tutti/shared/schemas/api";
 import type { RecentReferenceContext } from "../reference-context-types.js";
+import type { CommunicationLanguageContext, LanguageAwareOutput } from "../../communication-language/index.js";
+type LanguageAwareInput = {
+    communication_language?: CommunicationLanguageContext;
+};
 import type { PromptSourceMessage, TaskCompileClarificationContext } from "../task-source-context-types.js";
 import type { ClarificationRequestPayload, TaskContractProjection } from "@tutti/shared/schemas/api";
 import type { ProjectDocKey } from "@tutti/shared/schemas/api";
 import type { ActivityRef, ClarificationRoundRef, ClarificationThreadRef, MessageId, TaskId, TaskModuleId, WorkflowInvocationRef } from "@tutti/shared/ids";
 import type { RunLineage } from "@tutti/shared/domain";
 import type { ProjectBriefSnapshot, ProjectBriefSourceDocument } from "../../project-brief/index.js";
-export type ScratchpadRefreshWorkflowInput = {
+export type ScratchpadRefreshWorkflowInput = LanguageAwareInput & {
     project_brief?: ProjectBriefSnapshot;
     worklist: ScratchpadRefreshWorklistInput;
     active_task_compile?: ScratchpadWorkflowSnapshot;
@@ -43,7 +47,7 @@ export type ProcedureWorkflowRunContext = {
         runtime?: ExecutionRuntimeSnapshot;
     }) => void;
 };
-export type ScratchpadRefreshWorkflowOutput = {
+export type ScratchpadRefreshWorkflowOutput = LanguageAwareOutput & ({
     decision: "ready";
     scratchpad_snapshot: {
         topic: string;
@@ -58,7 +62,7 @@ export type ScratchpadRefreshWorkflowOutput = {
         summary: string;
         request: string;
     };
-};
+});
 export type TaskCompileProposal = {
     modules: TaskCompileProposalModule[];
     tasks: TaskCompileProposalTask[];
@@ -74,7 +78,7 @@ export type TaskCompileProposalTask = {
     summary: string;
     contract: TaskContractProjection;
 };
-export type TaskCompileWorkflowInput = {
+export type TaskCompileWorkflowInput = LanguageAwareInput & {
     workflow_ref: WorkflowInvocationRef;
     scratchpad: ScratchpadWorkflowSnapshot;
     source_messages: PromptSourceMessage[];
@@ -82,13 +86,13 @@ export type TaskCompileWorkflowInput = {
     recent_references?: RecentReferenceContext[];
     clarification_rounds?: TaskCompileClarificationContext[];
 };
-export type TaskCompileWorkflowOutput = {
+export type TaskCompileWorkflowOutput = LanguageAwareOutput & ({
     decision: "ready";
     proposal: TaskCompileProposal;
 } | {
     decision: "needs_human";
     clarification_request_payload: ClarificationRequestPayload;
-};
+});
 export type TaskCompilePromptInput = {
     scratchpad: {
         topic: string;
@@ -145,7 +149,7 @@ export type TaskCompileStructuredProposalTask = {
     goal: string;
     scope: string[];
 };
-export type ProjectContextBootstrapWorkflowInput = {
+export type ProjectContextBootstrapWorkflowInput = LanguageAwareInput & {
     project_name: string;
     missing_docs?: ProjectContextBootstrapMissingDoc[];
     scratchpad?: {
@@ -178,7 +182,7 @@ export type ContextSyncWorkflowTrigger = {
     completed_task_count: number;
     module_count: number;
 };
-export type ContextSyncWorkflowInput = {
+export type ContextSyncWorkflowInput = LanguageAwareInput & {
     workflow_ref: WorkflowInvocationRef;
     activity_ref: ActivityRef;
     trigger: ContextSyncWorkflowTrigger;
@@ -187,11 +191,11 @@ export type ContextSyncWorkflowOutput = {
     summary: string;
     updates: ContextSyncDocumentUpdate[];
 };
-export type ProjectBriefRefreshWorkflowInput = {
+export type ProjectBriefRefreshWorkflowInput = LanguageAwareInput & {
     docs: ProjectBriefSourceDocument[];
 };
 export type ProjectBriefRefreshWorkflowOutput = ProjectBriefSnapshot;
-export type ReferenceFileSummaryWorkflowInput = {
+export type ReferenceFileSummaryWorkflowInput = LanguageAwareInput & {
     workflow_ref: WorkflowInvocationRef;
     activity_ref: ActivityRef;
     file: {
@@ -225,7 +229,7 @@ export type ReferenceFileSummaryStructuredOutput = {
         };
     };
 };
-export type FollowUpCheckWorkflowInput = {
+export type FollowUpCheckWorkflowInput = LanguageAwareInput & {
     workflow_ref: WorkflowInvocationRef;
     task_id: TaskId;
     task_detail: TaskDetailProjection;
@@ -237,7 +241,7 @@ export type FollowUpCheckWorkflowInput = {
     latest_run_result: RunResultProjection;
     run_lineage: RunLineage;
 };
-export type FollowUpCheckWorkflowOutput = {
+export type FollowUpCheckWorkflowOutput = LanguageAwareOutput & ({
     decision: "resume";
     summary: string;
 } | {
@@ -247,7 +251,7 @@ export type FollowUpCheckWorkflowOutput = {
 } | {
     decision: "requires_retasking";
     summary: string;
-};
+});
 export type FollowUpCheckStructuredOutput = {
     result: {
         resume: {
@@ -281,4 +285,5 @@ export type ProcedureWorkflowRunnerResolution = {
     retryable: boolean;
 };
 export type ProcedureWorkflowRunnerResolver = () => ProcedureWorkflowRunnerResolution;
+export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/prompt-templates/index.d.ts

@@ -1,4 +1,4 @@
-export type PromptTemplateKey = "procedures.project_context_bootstrap" | "procedures.context_sync" | "procedures.project_brief_refresh" | "procedures.scratchpad_refresh" | "procedures.task_compile" | "procedures.reference_file_summary" | "procedures.follow_up_check" | "runs.task_execute" | "runs.task_finalize" | "runs.task_recovery" | "runs.task_result_contract" | "artifacts.applicability" | "chat.assistant" | "codex.no_write_smoke";
+export type PromptTemplateKey = "communication_language" | "communication_language_result" | "procedures.project_context_bootstrap" | "procedures.context_sync" | "procedures.project_brief_refresh" | "procedures.scratchpad_refresh" | "procedures.task_compile" | "procedures.reference_file_summary" | "procedures.follow_up_check" | "runs.task_execute" | "runs.task_finalize" | "runs.task_recovery" | "runs.task_result_contract" | "artifacts.applicability" | "chat.assistant" | "codex.no_write_smoke";
 export type RenderPromptTemplateOptions = {
     templateKey: PromptTemplateKey;
     variables?: Record<string, unknown>;

package/dist/prompt-templates/index.js

@@ -12,6 +12,8 @@ export class PromptTemplateError extends Error {
 }
 const defaultPromptsRoot = fileURLToPath(new URL("../../prompts", import.meta.url));
 const TEMPLATE_REGISTRY = {
+    communication_language: "communication-language.md",
+    communication_language_result: "communication-language-result.md",
     "procedures.project_context_bootstrap": "procedures/project-context-bootstrap.md",
     "procedures.context_sync": "procedures/context-sync.md",
     "procedures.project_brief_refresh": "procedures/project-brief-refresh.md",

package/dist/providers/failure-classification.d.ts

@@ -0,0 +1,23 @@
+declare const aliases: {
+    readonly provider_not_configured: "provider_not_configured";
+    readonly provider_auth_invalid: "provider_auth_invalid";
+    readonly provider_quota_or_billing_required: "provider_quota_or_billing_required";
+    readonly provider_rate_limited: "provider_rate_limited";
+    readonly provider_model_unavailable: "provider_model_unavailable";
+    readonly provider_network_error: "provider_network_error";
+    readonly auth_failed: "provider_auth_invalid";
+    readonly host_delegation_revoked: "provider_auth_invalid";
+    readonly authority_invalid: "provider_auth_invalid";
+    readonly gateway_rate_limited: "provider_rate_limited";
+    readonly control_queue_full: "provider_rate_limited";
+    readonly turn_timeout: "provider_timeout";
+    readonly output_parse_failed: "provider_output_invalid";
+    readonly output_validation_failed: "provider_output_invalid";
+    readonly process_lifecycle_failed: "provider_lifecycle_failed";
+    readonly process_tree_not_terminated: "provider_lifecycle_failed";
+};
+export type ProviderFailureCode = (typeof aliases)[keyof typeof aliases];
+/** Facts only, never a retry policy. Do not parse provider prose or raw stderr. */
+export declare function providerFailureCode(error: unknown): ProviderFailureCode | undefined;
+export {};
+//# sourceMappingURL=failure-classification.d.ts.map

package/dist/providers/failure-classification.js

@@ -0,0 +1,43 @@
+const aliases = {
+    provider_not_configured: "provider_not_configured",
+    provider_auth_invalid: "provider_auth_invalid",
+    provider_quota_or_billing_required: "provider_quota_or_billing_required",
+    provider_rate_limited: "provider_rate_limited",
+    provider_model_unavailable: "provider_model_unavailable",
+    provider_network_error: "provider_network_error",
+    auth_failed: "provider_auth_invalid",
+    host_delegation_revoked: "provider_auth_invalid",
+    authority_invalid: "provider_auth_invalid",
+    gateway_rate_limited: "provider_rate_limited",
+    control_queue_full: "provider_rate_limited",
+    turn_timeout: "provider_timeout",
+    output_parse_failed: "provider_output_invalid",
+    output_validation_failed: "provider_output_invalid",
+    process_lifecycle_failed: "provider_lifecycle_failed",
+    process_tree_not_terminated: "provider_lifecycle_failed",
+};
+/** Facts only, never a retry policy. Do not parse provider prose or raw stderr. */
+export function providerFailureCode(error) {
+    if (typeof error !== "object" || error === null)
+        return undefined;
+    const value = error;
+    const code = typeof value.code === "string" ? value.code : value.reason;
+    if (typeof code === "string" && Object.hasOwn(aliases, code))
+        return aliases[code];
+    if (code !== "turn_failed" || typeof value.details !== "object" || value.details === null)
+        return undefined;
+    const details = value.details;
+    // Quota can also carry HTTP 429; the specific bounded code takes precedence.
+    if (details.turn_error_code === "insufficient_quota")
+        return "provider_quota_or_billing_required";
+    if (details.turn_error_code === "invalid_api_key")
+        return "provider_auth_invalid";
+    if (details.turn_error_code === "model_not_found")
+        return "provider_model_unavailable";
+    if (details.turn_error_code === "rate_limit_exceeded" || details.turn_error_http_status === 429)
+        return "provider_rate_limited";
+    if (details.turn_error_http_status === 401)
+        return "provider_auth_invalid";
+    return undefined;
+}
+//# sourceMappingURL=failure-classification.js.map

package/dist/reference-access/read-evidence.d.ts

@@ -1,6 +1,8 @@
 import type { SqliteDatabase } from "../store/index.js";
 import type { ReferenceCopy } from "./cache.js";
 import type { ReferenceInvocation } from "./service.js";
+import type { ReferenceAuthorization } from "@tutti/shared/schemas/api";
+export declare function recordExternalReferenceAccessRequirement(db: SqliteDatabase, invocation: ReferenceInvocation, requestRef: string, authorization: ReferenceAuthorization, now?: () => Date): void;
 /** Prior answer context only: a source reference is not proof of freshness in a later turn. */
 export declare function readExternalReferenceReadSources(db: SqliteDatabase, invocationRef: string): string[];
 /** Durable observation, separate from evictable cache metadata; no content or locator. */

package/dist/reference-access/read-evidence.js

@@ -1,3 +1,8 @@
+export function recordExternalReferenceAccessRequirement(db, invocation, requestRef, authorization, now = () => new Date()) {
+    db.prepare(`INSERT OR IGNORE INTO external_reference_access_requirements
+    (invocation_ref, request_ref, activity_ref, authorization_ref, profile, observed_at)
+    VALUES (?, ?, ?, ?, ?, ?)`).run(invocation.reference_invocation_ref, requestRef, invocation.activity_ref ?? null, authorization.authorization_ref, authorization.profile, now().toISOString());
+}
 /** Prior answer context only: a source reference is not proof of freshness in a later turn. */
 export function readExternalReferenceReadSources(db, invocationRef) {
     return db

package/dist/reference-access/service.d.ts

@@ -8,6 +8,8 @@ export type ReferenceInvocation = {
 };
 export declare class ReferenceAuthorizationRequiredError extends Error {
     readonly result: ReferenceAuthorizationRequired;
+    readonly code = "reference_authorization_required";
+    readonly continuation = "explicit_request";
     constructor(result: ReferenceAuthorizationRequired);
 }
 export declare class ExternalReferenceAccess {

package/dist/reference-access/service.js

@@ -1,6 +1,8 @@
 import { ReferenceCacheError } from "./cache.js";
 export class ReferenceAuthorizationRequiredError extends Error {
     result;
+    code = "reference_authorization_required";
+    continuation = "explicit_request";
     constructor(result) {
         super("reference_authorization_required");
         this.result = result;