@xfey/tutti 0.1.0

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

@@ -0,0 +1,318 @@
+import { withHostStoreTransaction } from "../store/index.js";
+import { nowIso, stringifyJson } from "./serialization.js";
+import { mapClarificationRoundRow, mapClarificationThreadRow, readClarificationRoundProjection, readClarificationRoundRow, readClarificationThreadRow, } from "./clarification-records.js";
+import { createMainChatSystemMessage } from "./messages.js";
+import { readTaskDetailProjection } from "./task-details.js";
+import { readTaskProjection } from "./worklist.js";
+import { recordReadNotificationEvent } from "./read-state.js";
+export function submitClarificationRound(db, input) {
+    const submittedAt = nowIso(input.now);
+    let round = null;
+    db.transaction(() => {
+        const row = readClarificationRoundRow(db, input.round_id);
+        if (row === null) {
+            round = null;
+            return;
+        }
+        if (row.status === "sealed") {
+            round = mapClarificationRoundRow(row);
+            return;
+        }
+        const messageRows = db
+            .prepare(`
+          SELECT id
+          FROM messages
+          WHERE scope_kind = 'clarification_round'
+            AND clarification_round_id = ?
+          ORDER BY created_at ASC, id ASC
+        `)
+            .all(input.round_id);
+        const submittedMessageRefs = messageRows.map((message) => message.id);
+        db.prepare(`
+        UPDATE clarification_rounds
+        SET
+          status = 'sealed',
+          submitted_at = ?,
+          submitted_message_refs_json = ?,
+          updated_at = ?
+        WHERE id = ?
+      `).run(submittedAt, stringifyJson(submittedMessageRefs), submittedAt, input.round_id);
+        db.prepare(`
+        INSERT INTO clarification_submit_replay_hints (
+          clarification_round_id,
+          clarification_thread_id,
+          accepted_command_id,
+          created_at,
+          updated_at
+        )
+        VALUES (?, ?, ?, ?, ?)
+        ON CONFLICT(clarification_round_id) DO UPDATE SET
+          accepted_command_id = excluded.accepted_command_id,
+          updated_at = excluded.updated_at
+      `).run(input.round_id, row.clarification_thread_id, input.accepted_command_id ?? null, submittedAt, submittedAt);
+        round = readClarificationRoundProjection(db, input.round_id);
+    })();
+    return round;
+}
+export function materializeClarificationSuccessor(db, input) {
+    const updatedAt = nowIso(input.now);
+    let round = null;
+    db.transaction(() => {
+        const row = readClarificationRoundRow(db, input.round_id);
+        if (row === null) {
+            round = null;
+            return;
+        }
+        if (row.successor_status === "materialized") {
+            round = mapClarificationRoundRow(row);
+            return;
+        }
+        db.prepare(`
+        UPDATE clarification_rounds
+        SET
+          successor_status = 'materialized',
+          successor_ref_json = ?,
+          updated_at = ?
+        WHERE id = ?
+      `).run(stringifyJson(input.successor_ref), updatedAt, input.round_id);
+        if (input.close_thread === true) {
+            db.prepare(`
+          UPDATE clarification_threads
+          SET
+            status = 'closed',
+            current_round_id = NULL,
+            closed_reason = ?,
+            updated_at = ?
+          WHERE id = ?
+        `).run(input.closed_reason ?? "resolved", updatedAt, row.clarification_thread_id);
+        }
+        db.prepare(`
+        DELETE FROM clarification_submit_replay_hints
+        WHERE clarification_round_id = ?
+      `).run(input.round_id);
+        round = readClarificationRoundProjection(db, input.round_id);
+    })();
+    return round;
+}
+export function materializeTaskBoundRunSuccessor(db, input) {
+    const updatedAt = nowIso(input.now);
+    let result = null;
+    db.transaction(() => {
+        const row = readClarificationRoundRow(db, input.round_id);
+        if (row === null) {
+            result = null;
+            return;
+        }
+        const thread = readClarificationThreadRow(db, row.clarification_thread_id);
+        if (thread === null) {
+            throw new Error("Cannot materialize task-bound successor without a thread");
+        }
+        if (thread.owner_kind !== "task" || thread.owner_task_id === null) {
+            throw new Error("Cannot materialize task-bound Run successor for a non-task thread");
+        }
+        if (row.status !== "sealed") {
+            throw new Error("Cannot materialize successor for an unsealed clarification round");
+        }
+        if (thread.current_round_id !== input.round_id && row.successor_status !== "materialized") {
+            throw new Error("Cannot materialize successor for a non-current task-bound round");
+        }
+        if (row.successor_status === "materialized") {
+            result = {
+                kind: "already_materialized",
+                thread: mapClarificationThreadRow(thread),
+                round: mapClarificationRoundRow(row),
+                task: readTaskProjection(db, thread.owner_task_id),
+            };
+            return;
+        }
+        const taskRow = db
+            .prepare("SELECT * FROM tasks WHERE id = ?")
+            .get(thread.owner_task_id);
+        if (taskRow === undefined) {
+            throw new Error("Cannot materialize task-bound successor for a missing task");
+        }
+        if (taskRow.status !== "pending" || taskRow.active_clarification_thread_id !== thread.id) {
+            throw new Error("Task-bound successor requires a pending task with this active thread");
+        }
+        db.prepare(`
+        UPDATE tasks
+        SET status = 'running',
+            current_activity_ref = ?,
+            active_clarification_thread_id = NULL,
+            updated_at = ?
+        WHERE id = ?
+          AND status = 'pending'
+      `).run(input.activity_ref, updatedAt, thread.owner_task_id);
+        recordReadNotificationEvent(db, {
+            scope: "worklist",
+            source_kind: "task_follow_up",
+            source_ref: thread.owner_task_id,
+            occurred_at: updatedAt,
+        });
+        db.prepare(`
+        UPDATE clarification_rounds
+        SET
+          successor_status = 'materialized',
+          successor_ref_json = ?,
+          updated_at = ?
+        WHERE id = ?
+      `).run(stringifyJson({
+            kind: "run",
+            activity_ref: input.activity_ref,
+        }), updatedAt, input.round_id);
+        db.prepare(`
+        DELETE FROM clarification_submit_replay_hints
+        WHERE clarification_round_id = ?
+      `).run(input.round_id);
+        db.prepare(`
+        UPDATE clarification_threads
+        SET
+          status = 'closed',
+          current_round_id = NULL,
+          closed_reason = 'resolved',
+          updated_at = ?
+        WHERE id = ?
+      `).run(updatedAt, thread.id);
+        const updatedThread = readClarificationThreadRow(db, thread.id);
+        const updatedRound = readClarificationRoundRow(db, input.round_id);
+        const updatedTask = readTaskProjection(db, thread.owner_task_id);
+        if (updatedThread === null || updatedRound === null || updatedTask === null) {
+            throw new Error("Task-bound successor materialization did not produce readable projections");
+        }
+        result = {
+            kind: "materialized",
+            thread: mapClarificationThreadRow(updatedThread),
+            round: mapClarificationRoundRow(updatedRound),
+            task: updatedTask,
+        };
+    })();
+    return result;
+}
+export function closeTaskBoundClarificationAsRetaskingRequired(db, input) {
+    return withHostStoreTransaction(db, (tx) => {
+        const updatedAt = nowIso(input.now);
+        const row = readClarificationRoundRow(tx, input.round_id);
+        if (row === null) {
+            return null;
+        }
+        const thread = readClarificationThreadRow(tx, row.clarification_thread_id);
+        if (thread === null) {
+            throw new Error("Cannot close task-bound clarification without a thread");
+        }
+        if (thread.owner_kind !== "task" || thread.owner_task_id === null) {
+            throw new Error("Cannot close a non-task clarification as retasking required");
+        }
+        if (row.status !== "sealed") {
+            throw new Error("Cannot close an unsealed task-bound clarification round");
+        }
+        const taskId = thread.owner_task_id;
+        if (row.successor_status === "materialized") {
+            return {
+                kind: "already_materialized",
+                thread: mapClarificationThreadRow(thread),
+                round: mapClarificationRoundRow(row),
+                task: readTaskProjection(tx, taskId),
+                task_detail: readTaskDetailProjection(tx, taskId),
+            };
+        }
+        if (thread.status !== "active" || thread.current_round_id !== input.round_id) {
+            throw new Error("Cannot close a non-current task-bound clarification round");
+        }
+        const taskRow = tx.prepare("SELECT * FROM tasks WHERE id = ?").get(taskId);
+        if (taskRow === undefined) {
+            throw new Error("Cannot close task-bound clarification for a missing task");
+        }
+        if (taskRow.status !== "pending" || taskRow.active_clarification_thread_id !== thread.id) {
+            throw new Error("Retasking-required closure requires a pending task with this active thread");
+        }
+        tx.prepare(`
+        UPDATE clarification_rounds
+        SET
+          successor_status = 'materialized',
+          successor_ref_json = ?,
+          updated_at = ?
+        WHERE id = ?
+      `).run(stringifyJson({ kind: "chain_closed" }), updatedAt, input.round_id);
+        tx.prepare(`
+        DELETE FROM clarification_submit_replay_hints
+        WHERE clarification_round_id = ?
+      `).run(input.round_id);
+        tx.prepare(`
+        UPDATE tasks
+        SET status = 'failed',
+            current_activity_ref = NULL,
+            active_clarification_thread_id = NULL,
+            updated_at = ?
+        WHERE id = ?
+          AND status = 'pending'
+      `).run(updatedAt, taskId);
+        recordReadNotificationEvent(tx, {
+            scope: "worklist",
+            source_kind: "task_follow_up",
+            source_ref: taskId,
+            occurred_at: updatedAt,
+        });
+        const currentDetail = readTaskDetailProjection(tx, taskId);
+        if (currentDetail === null) {
+            throw new Error("Cannot close task-bound clarification without task detail");
+        }
+        const detailResult = {
+            ...(currentDetail.detail.result.latest_run_result_id === undefined
+                ? {}
+                : { latest_run_result_id: currentDetail.detail.result.latest_run_result_id }),
+            ...(currentDetail.detail.result.run_lineage === undefined
+                ? {}
+                : { run_lineage: currentDetail.detail.result.run_lineage }),
+            result_kind: "failed",
+            outcome: "failed",
+            summary: input.summary,
+            error_code: "retasking_required",
+            retryable: false,
+            clarification_thread_ref: thread.id,
+            updated_at: updatedAt,
+        };
+        if (currentDetail.detail.result.changed_paths !== undefined) {
+            detailResult.changed_paths = currentDetail.detail.result.changed_paths;
+        }
+        tx.prepare(`
+        UPDATE task_details
+        SET result_json = ?,
+            updated_at = ?
+        WHERE task_id = ?
+      `).run(stringifyJson(detailResult), updatedAt, taskId);
+        tx.prepare(`
+        UPDATE clarification_threads
+        SET
+          status = 'closed',
+          current_round_id = NULL,
+          closed_reason = 'contract_changed',
+          updated_at = ?
+        WHERE id = ?
+      `).run(updatedAt, thread.id);
+        const task = readTaskProjection(tx, taskId);
+        const taskDetail = readTaskDetailProjection(tx, taskId);
+        const updatedThread = readClarificationThreadRow(tx, thread.id);
+        const updatedRound = readClarificationRoundRow(tx, input.round_id);
+        if (task === null || taskDetail === null || updatedThread === null || updatedRound === null) {
+            throw new Error("Retasking-required closure did not produce readable projections");
+        }
+        const message = createMainChatSystemMessage(tx, {
+            body: `Retasking required: ${task.title}. ${input.summary}`,
+            refs: {
+                task_id: taskId,
+                clarification_thread_ref: thread.id,
+                clarification_round_ref: input.round_id,
+            },
+            ...(input.now === undefined ? {} : { now: input.now }),
+        });
+        return {
+            kind: "closed",
+            thread: mapClarificationThreadRow(updatedThread),
+            round: mapClarificationRoundRow(updatedRound),
+            task,
+            task_detail: taskDetail,
+            message,
+        };
+    });
+}
+//# sourceMappingURL=clarification-successors.js.map

package/dist/collaboration-state/execution-status.d.ts

@@ -0,0 +1,3 @@
+import type { ExecutionStatusProjection } from "@tutti/shared/schemas/api";
+export declare function createIdleExecutionStatusProjection(now?: () => Date): ExecutionStatusProjection;
+//# sourceMappingURL=execution-status.d.ts.map

package/dist/collaboration-state/execution-status.js

@@ -0,0 +1,8 @@
+export function createIdleExecutionStatusProjection(now = () => new Date()) {
+    return {
+        status: "idle",
+        summary: "Idle",
+        updated_at: now().toISOString(),
+    };
+}
+//# sourceMappingURL=execution-status.js.map

package/dist/collaboration-state/index.d.ts

@@ -0,0 +1,17 @@
+export { CollaborationStateCursorError } from "./serialization.js";
+export { createIdleExecutionStatusProjection } from "./execution-status.js";
+export { createMainChatAgentMessage, createMainChatMessage, createMainChatSystemMessage, hasMainChatWorklistFeedbackMessage, readCompletedWorklistFeedbackTaskIds, readMessageProjectionById, readMainChatMessageWindow, readMainChatMessagesAfter, readMainChatMessagesAfterCursor, readMainChatMessagesBeforeCursor, } from "./messages.js";
+export { clearScratchpadProjection, createEmptyScratchpadProjection, readScratchpadProjection, upsertScratchpadProjection, } from "./scratchpad.js";
+export { advanceScratchpadTaskCompileSourceCursor, markScratchpadRefreshFailed, markScratchpadRefreshStarted, markScratchpadRefreshSucceeded, markScratchpadSourceDirty, readScratchpadSourceState, } from "./scratchpad-source-state.js";
+export { deleteStaleClarificationSubmitReplayHints, readActiveClarificationProjection, readClarificationRoundProjection, readClarificationRoundsForThread, readClarificationThreadResponse, readSealedClarificationRoundsWithoutSuccessor, readSubmittedTaskCompileClarificationRounds, readSubmittedTaskCompileClarificationRoundsAfterCursor, } from "./clarification-records.js";
+export { createClarificationRoundAgentMessage, createClarificationRoundMessage, readClarificationRoundMessagesWindow, } from "./clarification-messages.js";
+export { openNextTaskBoundClarificationRound, openNextTaskCompileClarificationRound, openTaskCompileClarificationRound, } from "./clarification-rounds.js";
+export { closeTaskBoundClarificationAsRetaskingRequired, materializeClarificationSuccessor, materializeTaskBoundRunSuccessor, submitClarificationRound, } from "./clarification-successors.js";
+export { readRecoverySummariesPage, readRecoverySummaryProjection, readRunResultProjectionByActivityRef, readTaskRunResultsPage, recordRecoverySummary, } from "./run-results.js";
+export { recordRunNeedsHumanResult, recordRunResult } from "./run-recording.js";
+export { recoverStaleRunningTasksAsFailed } from "./recovery.js";
+export { markReadStateScope, readReadStateSummary, recordReadNotificationEvent, } from "./read-state.js";
+export { readTaskDetailProjection } from "./task-details.js";
+export { applyTaskCompileProposal, markTaskRunStarted, readNextRunnableTask, readRecoverableScheduledRun, readTaskProjection, readWorklistProjection, } from "./worklist.js";
+export type { ApplyTaskCompileProposalResult, CloseTaskBoundClarificationRetaskingRequiredInput, CloseTaskBoundClarificationRetaskingRequiredResult, CreateClarificationRoundAgentMessageInput, CreateClarificationRoundMessageInput, CreateMainChatAgentMessageInput, CreateMainChatMessageInput, CreateMainChatSystemMessageInput, CursorPageOptions, MarkReadStateScopeInput, MarkReadStateScopeResult, MarkTaskRunStartedInput, MarkTaskRunStartedResult, MaterializeClarificationSuccessorInput, MaterializeTaskBoundRunSuccessorInput, MaterializeTaskBoundRunSuccessorResult, MessageAuthorInput, NextRunnableTaskResult, OpenNextTaskBoundClarificationRoundInput, OpenNextTaskBoundClarificationRoundResult, OpenNextTaskCompileClarificationRoundInput, OpenNextTaskCompileClarificationRoundResult, OpenTaskCompileClarificationRoundInput, OpenTaskCompileClarificationRoundResult, ReadMainChatMessagesAfterOptions, ReadMessageWindowOptions, ReadReadStateSummaryInput, RecoverStaleRunningTasksResult, RecoverableScheduledRun, RecordReadNotificationEventInput, RecordRecoverySummaryInput, RecordRecoverySummaryResult, RecordRunNeedsHumanResultInput, RecordRunNeedsHumanResultResult, RecordRunResultInput, RecordRunResultResult, RunResultPromotionProjection, ScratchpadSnapshotInput, SealedClarificationRoundWithoutSuccessor, SubmitClarificationRoundInput, TaskCompileProposalInput, TaskCompileProposalModuleInput, TaskCompileProposalTaskInput, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/collaboration-state/index.js

@@ -0,0 +1,16 @@
+export { CollaborationStateCursorError } from "./serialization.js";
+export { createIdleExecutionStatusProjection } from "./execution-status.js";
+export { createMainChatAgentMessage, createMainChatMessage, createMainChatSystemMessage, hasMainChatWorklistFeedbackMessage, readCompletedWorklistFeedbackTaskIds, readMessageProjectionById, readMainChatMessageWindow, readMainChatMessagesAfter, readMainChatMessagesAfterCursor, readMainChatMessagesBeforeCursor, } from "./messages.js";
+export { clearScratchpadProjection, createEmptyScratchpadProjection, readScratchpadProjection, upsertScratchpadProjection, } from "./scratchpad.js";
+export { advanceScratchpadTaskCompileSourceCursor, markScratchpadRefreshFailed, markScratchpadRefreshStarted, markScratchpadRefreshSucceeded, markScratchpadSourceDirty, readScratchpadSourceState, } from "./scratchpad-source-state.js";
+export { deleteStaleClarificationSubmitReplayHints, readActiveClarificationProjection, readClarificationRoundProjection, readClarificationRoundsForThread, readClarificationThreadResponse, readSealedClarificationRoundsWithoutSuccessor, readSubmittedTaskCompileClarificationRounds, readSubmittedTaskCompileClarificationRoundsAfterCursor, } from "./clarification-records.js";
+export { createClarificationRoundAgentMessage, createClarificationRoundMessage, readClarificationRoundMessagesWindow, } from "./clarification-messages.js";
+export { openNextTaskBoundClarificationRound, openNextTaskCompileClarificationRound, openTaskCompileClarificationRound, } from "./clarification-rounds.js";
+export { closeTaskBoundClarificationAsRetaskingRequired, materializeClarificationSuccessor, materializeTaskBoundRunSuccessor, submitClarificationRound, } from "./clarification-successors.js";
+export { readRecoverySummariesPage, readRecoverySummaryProjection, readRunResultProjectionByActivityRef, readTaskRunResultsPage, recordRecoverySummary, } from "./run-results.js";
+export { recordRunNeedsHumanResult, recordRunResult } from "./run-recording.js";
+export { recoverStaleRunningTasksAsFailed } from "./recovery.js";
+export { markReadStateScope, readReadStateSummary, recordReadNotificationEvent, } from "./read-state.js";
+export { readTaskDetailProjection } from "./task-details.js";
+export { applyTaskCompileProposal, markTaskRunStarted, readNextRunnableTask, readRecoverableScheduledRun, readTaskProjection, readWorklistProjection, } from "./worklist.js";
+//# sourceMappingURL=index.js.map

package/dist/collaboration-state/messages.d.ts

@@ -0,0 +1,25 @@
+import { type MessageId, type TaskId } from "@tutti/shared/ids";
+import type { MessageProjection, MessageWindow } from "@tutti/shared/schemas/api";
+import type { SqliteDatabase } from "../store/index.js";
+import type { CreateMainChatAgentMessageInput, CreateMainChatMessageInput, CreateMainChatSystemMessageInput, ReadMainChatMessagesAfterOptions, ReadMessageWindowOptions } from "./types.js";
+import type { MessageRow } from "./storage-types.js";
+export declare function mapMessageRow(row: MessageRow, db?: SqliteDatabase): MessageProjection;
+export declare function createMainChatMessage(db: SqliteDatabase, input: CreateMainChatMessageInput): MessageProjection;
+export declare function createMainChatSystemMessage(db: SqliteDatabase, input: CreateMainChatSystemMessageInput): MessageProjection;
+export declare function createMainChatAgentMessage(db: SqliteDatabase, input: CreateMainChatAgentMessageInput): MessageProjection;
+export declare function readMessageProjectionById(db: SqliteDatabase, messageId: MessageId): MessageProjection | null;
+export declare function hasMainChatWorklistFeedbackMessage(db: SqliteDatabase, feedbackKey: string): boolean;
+export declare function readCompletedWorklistFeedbackTaskIds(db: SqliteDatabase): Set<TaskId>;
+export declare function readMainChatMessageWindow(db: SqliteDatabase, options?: ReadMessageWindowOptions): MessageWindow;
+export declare function readMainChatMessagesAfter(db: SqliteDatabase, options: ReadMainChatMessagesAfterOptions): MessageProjection[];
+export declare function readMainChatMessagesAfterCursor(db: SqliteDatabase, options: {
+    after_created_at: string;
+    after_id: MessageId;
+    limit: number;
+}): MessageProjection[];
+export declare function readMainChatMessagesBeforeCursor(db: SqliteDatabase, options: {
+    before_created_at: string;
+    before_id: MessageId;
+    limit: number;
+}): MessageProjection[];
+//# sourceMappingURL=messages.d.ts.map