@xfey/tutti 0.1.0

package/dist/collaboration-state/clarification-round-writes.js

@@ -0,0 +1,58 @@
+import { stringifyJson } from "./serialization.js";
+import { recordReadNotificationEvent } from "./read-state.js";
+export function insertClarificationRoundOpeningRecords(db, input) {
+    db.prepare(`
+      INSERT INTO messages (
+        id,
+        scope_kind,
+        author_kind,
+        message_kind,
+        body,
+        refs_json,
+        created_at
+      )
+      VALUES (?, 'main_chat', 'system', 'clarification_card', ?, ?, ?)
+    `).run(input.cardMessageId, input.requestPayload.summary, stringifyJson(input.refs), input.openedAt);
+    recordReadNotificationEvent(db, {
+        scope: "chat",
+        source_kind: "message",
+        source_ref: input.cardMessageId,
+        actor: { kind: "system" },
+        occurred_at: input.openedAt,
+    });
+    db.prepare(`
+      INSERT INTO messages (
+        id,
+        scope_kind,
+        clarification_round_id,
+        author_kind,
+        message_kind,
+        body,
+        refs_json,
+        created_at
+      )
+      VALUES (?, 'clarification_round', ?, 'agent', 'clarification_request', ?, ?, ?)
+    `).run(input.openingMessageId, input.roundId, input.requestPayload.request, stringifyJson(input.refs), input.openedAt);
+    recordReadNotificationEvent(db, {
+        scope: "chat",
+        source_kind: "message",
+        source_ref: input.openingMessageId,
+        actor: { kind: "agent" },
+        occurred_at: input.openedAt,
+    });
+    db.prepare(`
+      INSERT INTO clarification_rounds (
+        id,
+        clarification_thread_id,
+        round_index,
+        status,
+        request_payload_json,
+        card_message_id,
+        opening_message_id,
+        created_at,
+        updated_at
+      )
+      VALUES (?, ?, ?, 'writable', ?, ?, ?, ?, ?)
+    `).run(input.roundId, input.threadId, input.roundIndex, stringifyJson(input.requestPayload), input.cardMessageId, input.openingMessageId, input.openedAt, input.openedAt);
+}
+//# sourceMappingURL=clarification-round-writes.js.map

package/dist/collaboration-state/clarification-rounds.d.ts

@@ -0,0 +1,19 @@
+import { type ActivityRef, type ClarificationRoundRef, type ClarificationThreadRef, type MessageId, type TaskId } from "@tutti/shared/ids";
+import type { ClarificationRequestPayload } from "@tutti/shared/schemas/api";
+import type { SqliteDatabase } from "../store/index.js";
+import type { OpenNextTaskBoundClarificationRoundInput, OpenNextTaskBoundClarificationRoundResult, OpenNextTaskCompileClarificationRoundInput, OpenNextTaskCompileClarificationRoundResult, OpenTaskCompileClarificationRoundInput, OpenTaskCompileClarificationRoundResult } from "./types.js";
+export declare function insertTaskBoundClarificationRound(db: SqliteDatabase, input: {
+    task_id: TaskId;
+    activity_ref: ActivityRef;
+    request_payload: ClarificationRequestPayload;
+    opened_at: string;
+}): {
+    threadId: ClarificationThreadRef;
+    roundId: ClarificationRoundRef;
+    cardMessageId: MessageId;
+    openingMessageId: MessageId;
+};
+export declare function openTaskCompileClarificationRound(db: SqliteDatabase, input: OpenTaskCompileClarificationRoundInput): OpenTaskCompileClarificationRoundResult;
+export declare function openNextTaskCompileClarificationRound(db: SqliteDatabase, input: OpenNextTaskCompileClarificationRoundInput): OpenNextTaskCompileClarificationRoundResult;
+export declare function openNextTaskBoundClarificationRound(db: SqliteDatabase, input: OpenNextTaskBoundClarificationRoundInput): OpenNextTaskBoundClarificationRoundResult;
+//# sourceMappingURL=clarification-rounds.d.ts.map

package/dist/collaboration-state/clarification-rounds.js

@@ -0,0 +1,347 @@
+import { createClarificationRoundRef, createClarificationThreadRef, createMessageId, } from "@tutti/shared/ids";
+import { nowIso, stringifyJson } from "./serialization.js";
+import { insertClarificationRoundOpeningRecords } from "./clarification-round-writes.js";
+import { mapClarificationRoundRow, mapClarificationThreadRow, readClarificationRoundRow, readClarificationThreadRow, } from "./clarification-records.js";
+import { mapMessageRow } from "./messages.js";
+import { readTaskProjection } from "./worklist.js";
+export function insertTaskBoundClarificationRound(db, input) {
+    const threadId = createClarificationThreadRef();
+    const roundId = createClarificationRoundRef();
+    const cardMessageId = createMessageId();
+    const openingMessageId = createMessageId();
+    const refs = {
+        task_id: input.task_id,
+        activity_ref: input.activity_ref,
+        clarification_thread_ref: threadId,
+        clarification_round_ref: roundId,
+    };
+    db.prepare(`
+      INSERT INTO clarification_threads (
+        id,
+        owner_kind,
+        owner_workflow_ref,
+        owner_task_id,
+        status,
+        current_round_id,
+        created_from_activity_ref,
+        created_at,
+        updated_at
+      )
+      VALUES (?, 'task', NULL, ?, 'active', NULL, ?, ?, ?)
+    `).run(threadId, input.task_id, input.activity_ref, input.opened_at, input.opened_at);
+    insertClarificationRoundOpeningRecords(db, {
+        threadId,
+        roundId,
+        roundIndex: 1,
+        cardMessageId,
+        openingMessageId,
+        requestPayload: input.request_payload,
+        refs,
+        openedAt: input.opened_at,
+    });
+    db.prepare(`
+      UPDATE clarification_threads
+      SET current_round_id = ?, updated_at = ?
+      WHERE id = ?
+    `).run(roundId, input.opened_at, threadId);
+    return {
+        threadId,
+        roundId,
+        cardMessageId,
+        openingMessageId,
+    };
+}
+export function openTaskCompileClarificationRound(db, input) {
+    const openedAt = nowIso(input.now);
+    const threadId = createClarificationThreadRef();
+    const roundId = createClarificationRoundRef();
+    const cardMessageId = createMessageId();
+    const openingMessageId = createMessageId();
+    const refs = {
+        workflow_ref: input.workflow_ref,
+        ...(input.activity_ref === undefined ? {} : { activity_ref: input.activity_ref }),
+        clarification_thread_ref: threadId,
+        clarification_round_ref: roundId,
+    };
+    db.transaction(() => {
+        db.prepare(`
+        INSERT INTO clarification_threads (
+          id,
+          owner_kind,
+          owner_workflow_ref,
+          owner_task_id,
+          status,
+          current_round_id,
+          created_from_activity_ref,
+          created_at,
+          updated_at
+        )
+        VALUES (?, 'task_compile', ?, NULL, 'active', NULL, ?, ?, ?)
+      `).run(threadId, input.workflow_ref, input.activity_ref ?? null, openedAt, openedAt);
+        insertClarificationRoundOpeningRecords(db, {
+            threadId,
+            roundId,
+            roundIndex: 1,
+            cardMessageId,
+            openingMessageId,
+            requestPayload: input.request_payload,
+            refs,
+            openedAt,
+        });
+        db.prepare(`
+        UPDATE clarification_threads
+        SET current_round_id = ?, updated_at = ?
+        WHERE id = ?
+      `).run(roundId, openedAt, threadId);
+    })();
+    const thread = readClarificationThreadRow(db, threadId);
+    const round = readClarificationRoundRow(db, roundId);
+    const messages = db
+        .prepare(`
+        SELECT *
+        FROM messages
+        WHERE id IN (?, ?)
+        ORDER BY created_at ASC, id ASC
+      `)
+        .all(cardMessageId, openingMessageId);
+    const cardMessage = messages.find((message) => message.id === cardMessageId);
+    const openingMessage = messages.find((message) => message.id === openingMessageId);
+    if (thread === null ||
+        round === null ||
+        cardMessage === undefined ||
+        openingMessage === undefined) {
+        throw new Error("Failed to read created clarification round");
+    }
+    return {
+        thread: mapClarificationThreadRow(thread),
+        round: mapClarificationRoundRow(round),
+        card_message: mapMessageRow(cardMessage, db),
+        opening_message: mapMessageRow(openingMessage),
+    };
+}
+export function openNextTaskCompileClarificationRound(db, input) {
+    const openedAt = nowIso(input.now);
+    const roundId = createClarificationRoundRef();
+    const cardMessageId = createMessageId();
+    const openingMessageId = createMessageId();
+    let threadId = null;
+    db.transaction(() => {
+        const previousRound = readClarificationRoundRow(db, input.continue_from_round_id);
+        if (previousRound === null) {
+            throw new Error("Cannot continue missing clarification round");
+        }
+        if (previousRound.status !== "sealed") {
+            throw new Error("Cannot continue an unsealed clarification round");
+        }
+        if (previousRound.successor_status !== "not_materialized") {
+            throw new Error("Clarification round successor is already materialized");
+        }
+        const thread = readClarificationThreadRow(db, previousRound.clarification_thread_id);
+        if (thread === null) {
+            throw new Error("Cannot continue clarification round without a thread");
+        }
+        if (thread.status !== "active") {
+            throw new Error("Cannot continue a closed clarification thread");
+        }
+        if (thread.owner_kind !== "task_compile" || thread.owner_workflow_ref !== input.workflow_ref) {
+            throw new Error("Cannot continue clarification round for a different workflow");
+        }
+        if (thread.current_round_id !== input.continue_from_round_id) {
+            throw new Error("Cannot continue a non-current clarification round");
+        }
+        threadId = thread.id;
+        const nextRoundIndex = db
+            .prepare(`
+            SELECT COALESCE(MAX(round_index), 0) + 1 AS next_round_index
+            FROM clarification_rounds
+            WHERE clarification_thread_id = ?
+          `)
+            .get(thread.id)?.next_round_index ?? previousRound.round_index + 1;
+        const refs = {
+            workflow_ref: input.workflow_ref,
+            ...(input.activity_ref === undefined ? {} : { activity_ref: input.activity_ref }),
+            clarification_thread_ref: thread.id,
+            clarification_round_ref: roundId,
+        };
+        insertClarificationRoundOpeningRecords(db, {
+            threadId: thread.id,
+            roundId,
+            roundIndex: nextRoundIndex,
+            cardMessageId,
+            openingMessageId,
+            requestPayload: input.request_payload,
+            refs,
+            openedAt,
+        });
+        db.prepare(`
+        UPDATE clarification_rounds
+        SET
+          successor_status = 'materialized',
+          successor_ref_json = ?,
+          updated_at = ?
+        WHERE id = ?
+      `).run(stringifyJson({
+            kind: "next_round",
+            clarification_round_ref: roundId,
+        }), openedAt, input.continue_from_round_id);
+        db.prepare(`
+        DELETE FROM clarification_submit_replay_hints
+        WHERE clarification_round_id = ?
+      `).run(input.continue_from_round_id);
+        db.prepare(`
+        UPDATE clarification_threads
+        SET current_round_id = ?, updated_at = ?
+        WHERE id = ?
+      `).run(roundId, openedAt, thread.id);
+    })();
+    if (threadId === null) {
+        throw new Error("Failed to open next clarification round");
+    }
+    const thread = readClarificationThreadRow(db, threadId);
+    const previousRound = readClarificationRoundRow(db, input.continue_from_round_id);
+    const round = readClarificationRoundRow(db, roundId);
+    const messages = db
+        .prepare(`
+        SELECT *
+        FROM messages
+        WHERE id IN (?, ?)
+        ORDER BY created_at ASC, id ASC
+      `)
+        .all(cardMessageId, openingMessageId);
+    const cardMessage = messages.find((message) => message.id === cardMessageId);
+    const openingMessage = messages.find((message) => message.id === openingMessageId);
+    if (thread === null ||
+        previousRound === null ||
+        round === null ||
+        cardMessage === undefined ||
+        openingMessage === undefined) {
+        throw new Error("Failed to read created clarification round");
+    }
+    return {
+        thread: mapClarificationThreadRow(thread),
+        previous_round: mapClarificationRoundRow(previousRound),
+        round: mapClarificationRoundRow(round),
+        card_message: mapMessageRow(cardMessage, db),
+        opening_message: mapMessageRow(openingMessage),
+    };
+}
+export function openNextTaskBoundClarificationRound(db, input) {
+    const openedAt = nowIso(input.now);
+    const roundId = createClarificationRoundRef();
+    const cardMessageId = createMessageId();
+    const openingMessageId = createMessageId();
+    let threadId = null;
+    let taskId = null;
+    db.transaction(() => {
+        const previousRound = readClarificationRoundRow(db, input.continue_from_round_id);
+        if (previousRound === null) {
+            throw new Error("Cannot continue missing task-bound clarification round");
+        }
+        if (previousRound.status !== "sealed") {
+            throw new Error("Cannot continue an unsealed task-bound clarification round");
+        }
+        if (previousRound.successor_status !== "not_materialized") {
+            throw new Error("Task-bound clarification round successor is already materialized");
+        }
+        const thread = readClarificationThreadRow(db, previousRound.clarification_thread_id);
+        if (thread === null) {
+            throw new Error("Cannot continue task-bound clarification without a thread");
+        }
+        if (thread.status !== "active") {
+            throw new Error("Cannot continue a closed task-bound clarification thread");
+        }
+        if (thread.owner_kind !== "task" || thread.owner_task_id === null) {
+            throw new Error("Cannot continue a non-task clarification thread as task-bound");
+        }
+        if (thread.current_round_id !== input.continue_from_round_id) {
+            throw new Error("Cannot continue a non-current task-bound clarification round");
+        }
+        const taskRow = db
+            .prepare("SELECT * FROM tasks WHERE id = ?")
+            .get(thread.owner_task_id);
+        if (taskRow === undefined) {
+            throw new Error("Cannot continue task-bound clarification for a missing task");
+        }
+        if (taskRow.status !== "pending" || taskRow.active_clarification_thread_id !== thread.id) {
+            throw new Error("Task-bound next round requires a pending task with this active thread");
+        }
+        threadId = thread.id;
+        taskId = thread.owner_task_id;
+        const nextRoundIndex = db
+            .prepare(`
+            SELECT COALESCE(MAX(round_index), 0) + 1 AS next_round_index
+            FROM clarification_rounds
+            WHERE clarification_thread_id = ?
+          `)
+            .get(thread.id)?.next_round_index ?? previousRound.round_index + 1;
+        const refs = {
+            task_id: taskId,
+            clarification_thread_ref: thread.id,
+            clarification_round_ref: roundId,
+        };
+        insertClarificationRoundOpeningRecords(db, {
+            threadId: thread.id,
+            roundId,
+            roundIndex: nextRoundIndex,
+            cardMessageId,
+            openingMessageId,
+            requestPayload: input.request_payload,
+            refs,
+            openedAt,
+        });
+        db.prepare(`
+        UPDATE clarification_rounds
+        SET
+          successor_status = 'materialized',
+          successor_ref_json = ?,
+          updated_at = ?
+        WHERE id = ?
+      `).run(stringifyJson({
+            kind: "next_round",
+            clarification_round_ref: roundId,
+        }), openedAt, input.continue_from_round_id);
+        db.prepare(`
+        DELETE FROM clarification_submit_replay_hints
+        WHERE clarification_round_id = ?
+      `).run(input.continue_from_round_id);
+        db.prepare(`
+        UPDATE clarification_threads
+        SET current_round_id = ?, updated_at = ?
+        WHERE id = ?
+      `).run(roundId, openedAt, thread.id);
+    })();
+    if (threadId === null || taskId === null) {
+        throw new Error("Failed to open next task-bound clarification round");
+    }
+    const thread = readClarificationThreadRow(db, threadId);
+    const previousRound = readClarificationRoundRow(db, input.continue_from_round_id);
+    const round = readClarificationRoundRow(db, roundId);
+    const task = readTaskProjection(db, taskId);
+    const messages = db
+        .prepare(`
+        SELECT *
+        FROM messages
+        WHERE id IN (?, ?)
+        ORDER BY created_at ASC, id ASC
+      `)
+        .all(cardMessageId, openingMessageId);
+    const cardMessage = messages.find((message) => message.id === cardMessageId);
+    const openingMessage = messages.find((message) => message.id === openingMessageId);
+    if (thread === null ||
+        previousRound === null ||
+        round === null ||
+        task === null ||
+        cardMessage === undefined ||
+        openingMessage === undefined) {
+        throw new Error("Failed to read created task-bound clarification round");
+    }
+    return {
+        thread: mapClarificationThreadRow(thread),
+        previous_round: mapClarificationRoundRow(previousRound),
+        round: mapClarificationRoundRow(round),
+        task,
+        card_message: mapMessageRow(cardMessage, db),
+        opening_message: mapMessageRow(openingMessage),
+    };
+}
+//# sourceMappingURL=clarification-rounds.js.map

package/dist/collaboration-state/clarification-successors.d.ts

@@ -0,0 +1,8 @@
+import type { ClarificationRoundProjection } from "@tutti/shared/schemas/api";
+import { type SqliteDatabase } from "../store/index.js";
+import type { CloseTaskBoundClarificationRetaskingRequiredInput, CloseTaskBoundClarificationRetaskingRequiredResult, MaterializeClarificationSuccessorInput, MaterializeTaskBoundRunSuccessorInput, MaterializeTaskBoundRunSuccessorResult, SubmitClarificationRoundInput } from "./types.js";
+export declare function submitClarificationRound(db: SqliteDatabase, input: SubmitClarificationRoundInput): ClarificationRoundProjection | null;
+export declare function materializeClarificationSuccessor(db: SqliteDatabase, input: MaterializeClarificationSuccessorInput): ClarificationRoundProjection | null;
+export declare function materializeTaskBoundRunSuccessor(db: SqliteDatabase, input: MaterializeTaskBoundRunSuccessorInput): MaterializeTaskBoundRunSuccessorResult | null;
+export declare function closeTaskBoundClarificationAsRetaskingRequired(db: SqliteDatabase, input: CloseTaskBoundClarificationRetaskingRequiredInput): CloseTaskBoundClarificationRetaskingRequiredResult | null;
+//# sourceMappingURL=clarification-successors.d.ts.map