@xfey/tutti 0.1.126 → 0.1.128

package/dist/collaboration-state/communication-language.d.ts

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

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

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

package/dist/collaboration-state/task-compile-context.d.ts

@@ -24,7 +24,7 @@ export declare function completeTaskCompileContext(db: SqliteDatabase, input: Co
     task_changes: string[];
     receipts: {
         compiled_tasks?: {
-            status: "failed" | "pending" | "done" | "todo" | "running";
+            status: "failed" | "pending" | "running" | "done" | "todo";
             task_id: string;
             title: string;
             summary: string;

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

@@ -1,7 +1,9 @@
 import { withHostStoreTransaction } from "../store/index.js";
 import { readScratchpadProjection } from "./scratchpad.js";
+import { readCommunicationLanguage, copyCommunicationLanguage } from "./communication-language.js";
 import { readScratchpadSourceState } from "./scratchpad-source-state.js";
 import { nowIso, stringifyJson } from "./serialization.js";
+import { registerTaskCompileRequest, closeFailedTaskCompileRequest, } from "./task-compile-requests.js";
 function cursorIsAfter(left, right) {
     if (left === undefined) {
         return false;
@@ -144,6 +146,7 @@ export function recordTaskCompileSubmission(db, input) {
     if (readActiveTaskCompileContext(db) !== null) {
         throw new Error("An active Task Compile Context already exists");
     }
+    registerTaskCompileRequest(db, input.workflow_ref, input.accepted_activity_ref, nowIso(input.now));
     db.prepare(`
       INSERT INTO pending_task_compile_submissions (
         id,
@@ -206,6 +209,14 @@ export function captureTaskCompileContext(db, input) {
         if (scratchpad.state !== "ready" || scratchpad.updated_at === undefined) {
             throw new Error("A ready Scratchpad is required to capture Task Compile Context");
         }
+        const language = readCommunicationLanguage(tx, { kind: "scratchpad", ref: "current" });
+        if (language !== null && language.activity_ref === scratchpad.updated_by_activity_ref) {
+            copyCommunicationLanguage(tx, {
+                from: { kind: "scratchpad", ref: "current" },
+                to: { kind: "workflow", ref: input.workflow_ref },
+                now: input.now ?? (() => new Date()),
+            });
+        }
         const sourceState = readScratchpadSourceState(tx);
         const submission = readPendingTaskCompileSubmission(tx, input.workflow_ref);
         const sources = readCurrentScratchpadSourceRefs(tx, submission?.source_window.through);
@@ -217,6 +228,7 @@ export function captureTaskCompileContext(db, input) {
                 : { created_at: lastSource.created_at, message_id: lastSource.message_id });
         const after = submission?.source_window.after ?? sourceState.cycle_start_cursor;
         const submittedAt = nowIso(input.now);
+        registerTaskCompileRequest(tx, input.workflow_ref, input.captured_by_activity_ref, submittedAt);
         tx.prepare(`
         INSERT INTO active_task_compile_context (
           id,
@@ -328,9 +340,16 @@ export function rollbackTaskCompileContext(db, input) {
     return withHostStoreTransaction(db, (tx) => {
         const context = readActiveTaskCompileContext(tx, input.workflow_ref);
         if (context === null) {
-            return false;
+            const pending = readPendingTaskCompileSubmission(tx, input.workflow_ref);
+            if (pending === null)
+                return false;
+            // Before capture the source cursor has not moved: release only this admission.
+            closeFailedTaskCompileRequest(tx, input.workflow_ref, nowIso(input.now));
+            tx.prepare("DELETE FROM pending_task_compile_submissions WHERE workflow_ref = ?").run(input.workflow_ref);
+            return true;
         }
         const rolledBackAt = nowIso(input.now);
+        closeFailedTaskCompileRequest(tx, input.workflow_ref, rolledBackAt);
         const sourceState = readScratchpadSourceState(tx);
         const after = context.source_window.after;
         const through = context.source_window.through;

package/dist/collaboration-state/task-compile-requests.d.ts

@@ -0,0 +1,6 @@
+import type { SqliteDatabase } from "../store/index.js";
+/** Persistence only: callers own acceptance, stage selection and rollback. */
+export declare function registerTaskCompileRequest(db: SqliteDatabase, workflowRef: string, activityRef: string, createdAt: string): void;
+export declare function linkTaskCompileActivity(db: SqliteDatabase, workflowRef: string, activityRef: string): void;
+export declare function closeFailedTaskCompileRequest(db: SqliteDatabase, workflowRef: string, now: string, code?: "task_compile_failed" | "scratchpad_empty_after_refresh"): void;
+//# sourceMappingURL=task-compile-requests.d.ts.map

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

@@ -0,0 +1,16 @@
+/** Persistence only: callers own acceptance, stage selection and rollback. */
+export function registerTaskCompileRequest(db, workflowRef, activityRef, createdAt) {
+    db.prepare(`INSERT OR IGNORE INTO task_compile_requests
+    (workflow_ref, accepted_activity_ref, current_activity_ref, created_at)
+    VALUES (?, ?, ?, ?)`).run(workflowRef, activityRef, activityRef, createdAt);
+}
+export function linkTaskCompileActivity(db, workflowRef, activityRef) {
+    db.prepare(`UPDATE task_compile_requests SET current_activity_ref = ?
+    WHERE workflow_ref = ? AND closed_at IS NULL`).run(activityRef, workflowRef);
+}
+export function closeFailedTaskCompileRequest(db, workflowRef, now, code = "task_compile_failed") {
+    db.prepare(`UPDATE task_compile_requests SET failure_code = ?, closed_at = ?
+    WHERE workflow_ref = ? AND closed_at IS NULL
+      AND NOT EXISTS (SELECT 1 FROM scratchpad_receipts WHERE workflow_ref = ?)`).run(code, now, workflowRef, workflowRef);
+}
+//# sourceMappingURL=task-compile-requests.js.map

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

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

package/dist/communication-language/index.js

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

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

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