@xfey/tutti 0.1.60 → 0.1.62

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

@@ -0,0 +1,273 @@
+import { withHostStoreTransaction } from "../store/index.js";
+import { readScratchpadProjection } from "./scratchpad.js";
+import { readScratchpadSourceState } from "./scratchpad-source-state.js";
+import { nowIso, stringifyJson } from "./serialization.js";
+function parseStringArray(value, field) {
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        throw new Error(`Invalid Task Compile Context ${field} JSON`);
+    }
+    if (!Array.isArray(parsed) || !parsed.every((entry) => typeof entry === "string")) {
+        throw new Error(`Invalid Task Compile Context ${field}`);
+    }
+    return parsed;
+}
+function readContextRow(db) {
+    return db
+        .prepare(`
+        SELECT
+          workflow_ref,
+          captured_by_activity_ref,
+          submitted_at,
+          topic,
+          background_summary,
+          current_consensus_json,
+          open_questions_json,
+          task_changes_json,
+          scratchpad_updated_at,
+          source_window_after_created_at,
+          source_window_after_message_id,
+          source_window_through_created_at,
+          source_window_through_message_id
+        FROM active_task_compile_context
+        WHERE id = 'current'
+      `)
+        .get();
+}
+function mapContextRow(row, sources) {
+    const sourceWindow = {};
+    if (row.source_window_after_created_at !== null &&
+        row.source_window_after_message_id !== null) {
+        sourceWindow.after = {
+            created_at: row.source_window_after_created_at,
+            message_id: row.source_window_after_message_id,
+        };
+    }
+    if (row.source_window_through_created_at !== null &&
+        row.source_window_through_message_id !== null) {
+        sourceWindow.through = {
+            created_at: row.source_window_through_created_at,
+            message_id: row.source_window_through_message_id,
+        };
+    }
+    return {
+        workflow_ref: row.workflow_ref,
+        captured_by_activity_ref: row.captured_by_activity_ref,
+        submitted_at: row.submitted_at,
+        scratchpad_snapshot: {
+            topic: row.topic,
+            background_summary: row.background_summary,
+            current_consensus: parseStringArray(row.current_consensus_json, "current_consensus"),
+            open_questions: parseStringArray(row.open_questions_json, "open_questions"),
+            task_changes: parseStringArray(row.task_changes_json, "task_changes"),
+        },
+        scratchpad_updated_at: row.scratchpad_updated_at,
+        source_window: sourceWindow,
+        sources: sources.map((source) => ({
+            message_id: source.message_id,
+            created_at: source.created_at,
+        })),
+    };
+}
+function readContextSources(db, workflowRef) {
+    return db
+        .prepare(`
+        SELECT workflow_ref, message_id, created_at
+        FROM active_task_compile_context_sources
+        WHERE workflow_ref = ?
+        ORDER BY created_at ASC, message_id ASC
+      `)
+        .all(workflowRef);
+}
+export function readActiveTaskCompileContext(db, workflowRef) {
+    const row = readContextRow(db);
+    if (row === undefined || (workflowRef !== undefined && row.workflow_ref !== workflowRef)) {
+        return null;
+    }
+    return mapContextRow(row, readContextSources(db, row.workflow_ref));
+}
+function currentScratchpadSources(db) {
+    return db
+        .prepare(`
+        SELECT message_id, created_at
+        FROM scratchpad_source_refs
+        WHERE scratchpad_id = 'current'
+          AND source_scope = 'main_chat'
+        ORDER BY created_at ASC, message_id ASC
+      `)
+        .all();
+}
+export function captureTaskCompileContext(db, input) {
+    return withHostStoreTransaction(db, (tx) => {
+        const existing = readActiveTaskCompileContext(tx);
+        if (existing !== null) {
+            if (existing.workflow_ref === input.workflow_ref) {
+                return existing;
+            }
+            throw new Error("An active Task Compile Context already exists");
+        }
+        const scratchpad = readScratchpadProjection(tx);
+        if (scratchpad.state !== "ready" || scratchpad.updated_at === undefined) {
+            throw new Error("A ready Scratchpad is required to capture Task Compile Context");
+        }
+        const sourceState = readScratchpadSourceState(tx);
+        const sources = currentScratchpadSources(tx);
+        const lastSource = sources.at(-1);
+        const through = sourceState.refreshed_through_cursor ??
+            (lastSource === undefined
+                ? undefined
+                : { created_at: lastSource.created_at, message_id: lastSource.message_id });
+        const submittedAt = nowIso(input.now);
+        tx.prepare(`
+        INSERT INTO active_task_compile_context (
+          id,
+          workflow_ref,
+          captured_by_activity_ref,
+          submitted_at,
+          topic,
+          background_summary,
+          current_consensus_json,
+          open_questions_json,
+          task_changes_json,
+          scratchpad_updated_at,
+          source_window_after_created_at,
+          source_window_after_message_id,
+          source_window_through_created_at,
+          source_window_through_message_id
+        )
+        VALUES ('current', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(input.workflow_ref, input.captured_by_activity_ref, submittedAt, scratchpad.topic, scratchpad.background_summary, stringifyJson(scratchpad.current_consensus), stringifyJson(scratchpad.open_questions), stringifyJson(scratchpad.task_changes), scratchpad.updated_at, sourceState.cycle_start_cursor?.created_at ?? null, sourceState.cycle_start_cursor?.message_id ?? null, through?.created_at ?? null, through?.message_id ?? null);
+        const insertSource = tx.prepare(`
+        INSERT INTO active_task_compile_context_sources (
+          workflow_ref,
+          message_id,
+          created_at
+        )
+        VALUES (?, ?, ?)
+      `);
+        for (const source of sources) {
+            insertSource.run(input.workflow_ref, source.message_id, source.created_at);
+        }
+        tx.prepare(`
+        INSERT INTO scratchpad_source_state (
+          id,
+          cycle_start_cursor_created_at,
+          cycle_start_cursor_message_id,
+          updated_at
+        )
+        VALUES ('current', ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET
+          cycle_start_cursor_created_at = excluded.cycle_start_cursor_created_at,
+          cycle_start_cursor_message_id = excluded.cycle_start_cursor_message_id,
+          updated_at = excluded.updated_at
+      `).run(through?.created_at ?? null, through?.message_id ?? null, submittedAt);
+        const captured = readActiveTaskCompileContext(tx, input.workflow_ref);
+        if (captured === null) {
+            throw new Error("Failed to capture Task Compile Context");
+        }
+        return captured;
+    });
+}
+export function completeTaskCompileContext(db, input) {
+    return withHostStoreTransaction(db, (tx) => {
+        const context = readActiveTaskCompileContext(tx, input.workflow_ref);
+        if (context === null) {
+            throw new Error("Active Task Compile Context is unavailable");
+        }
+        const completedAt = nowIso(input.now);
+        const snapshot = context.scratchpad_snapshot;
+        tx.prepare(`
+        INSERT INTO scratchpad_receipts (
+          workflow_ref,
+          activity_ref,
+          topic,
+          background_summary,
+          current_consensus_json,
+          open_questions_json,
+          task_changes_json,
+          submitted_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(input.workflow_ref, input.activity_ref, snapshot.topic, snapshot.background_summary, stringifyJson(snapshot.current_consensus), stringifyJson(snapshot.open_questions), stringifyJson(snapshot.task_changes), context.submitted_at);
+        const insertReceiptSource = tx.prepare(`
+        INSERT INTO scratchpad_receipt_sources (
+          workflow_ref,
+          message_id,
+          source_scope,
+          created_at
+        )
+        VALUES (?, ?, 'main_chat', ?)
+      `);
+        for (const source of context.sources) {
+            insertReceiptSource.run(input.workflow_ref, source.message_id, source.created_at);
+        }
+        tx.prepare(`
+        UPDATE scratchpad
+        SET
+          state = 'submitted',
+          submitted_by_activity_ref = ?,
+          submitted_by_workflow_ref = ?,
+          submitted_at = ?,
+          updated_at = ?
+        WHERE id = 'current'
+          AND state = 'ready'
+          AND updated_at = ?
+          AND topic = ?
+          AND background_summary = ?
+          AND current_consensus_json = ?
+          AND open_questions_json = ?
+          AND task_changes_json = ?
+      `).run(input.activity_ref, input.workflow_ref, context.submitted_at, completedAt, context.scratchpad_updated_at, snapshot.topic, snapshot.background_summary, stringifyJson(snapshot.current_consensus), stringifyJson(snapshot.open_questions), stringifyJson(snapshot.task_changes));
+        tx.prepare("DELETE FROM active_task_compile_context WHERE workflow_ref = ?").run(input.workflow_ref);
+        return readScratchpadProjection(tx);
+    });
+}
+export function rollbackTaskCompileContext(db, input) {
+    return withHostStoreTransaction(db, (tx) => {
+        const context = readActiveTaskCompileContext(tx, input.workflow_ref);
+        if (context === null) {
+            return false;
+        }
+        const rolledBackAt = nowIso(input.now);
+        const sourceState = readScratchpadSourceState(tx);
+        const dirtySince = sourceState.in_flight !== undefined &&
+            new Date(rolledBackAt).getTime() <= new Date(sourceState.in_flight.started_at).getTime()
+            ? new Date(new Date(sourceState.in_flight.started_at).getTime() + 1).toISOString()
+            : rolledBackAt;
+        const after = context.source_window.after;
+        tx.prepare(`
+        INSERT INTO scratchpad_source_state (
+          id,
+          cycle_start_cursor_created_at,
+          cycle_start_cursor_message_id,
+          refreshed_through_cursor_created_at,
+          refreshed_through_cursor_message_id,
+          dirty_since,
+          updated_at
+        )
+        VALUES ('current', ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET
+          cycle_start_cursor_created_at = excluded.cycle_start_cursor_created_at,
+          cycle_start_cursor_message_id = excluded.cycle_start_cursor_message_id,
+          refreshed_through_cursor_created_at = excluded.refreshed_through_cursor_created_at,
+          refreshed_through_cursor_message_id = excluded.refreshed_through_cursor_message_id,
+          dirty_since = excluded.dirty_since,
+          updated_at = excluded.updated_at
+      `).run(after?.created_at ?? null, after?.message_id ?? null, after?.created_at ?? null, after?.message_id ?? null, dirtySince, rolledBackAt);
+        tx.prepare("DELETE FROM active_task_compile_context WHERE workflow_ref = ?").run(input.workflow_ref);
+        return true;
+    });
+}
+export function taskCompileContextSnapshot(context) {
+    return {
+        topic: context.scratchpad_snapshot.topic,
+        background_summary: context.scratchpad_snapshot.background_summary,
+        current_consensus: [...context.scratchpad_snapshot.current_consensus],
+        open_questions: [...context.scratchpad_snapshot.open_questions],
+        task_changes: [...context.scratchpad_snapshot.task_changes],
+    };
+}
+//# sourceMappingURL=task-compile-context.js.map

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

@@ -1,7 +1,7 @@
 import type { RunLineage } from "@tutti/shared/domain";
 import type { AccountAvatarProjection } from "@tutti/shared/domain";
 import type { ActivityRef, ClarificationRoundRef, MessageId, TaskId, TaskModuleId, WorkflowInvocationRef } from "@tutti/shared/ids";
-import type { ClarificationRequestPayload, ClarificationRoundProjection, ClarificationSuccessorRef, ClarificationThreadProjection, MessageProjection, ReadStateScope, ReadStateSummaryProjection, RecoverySummaryProjection, RunResultProjection, ScratchpadProjection, TaskContractProjection, TaskDetailProjection, TaskDetailResultProjection, TaskProjection, WorklistProjection } from "@tutti/shared/schemas/api";
+import type { ClarificationRequestPayload, ClarificationRoundProjection, ClarificationSuccessorRef, ClarificationThreadProjection, MessageProjection, ReadStateScope, ReadStateSummaryProjection, RecoverySummaryProjection, RunResultProjection, TaskContractProjection, TaskDetailProjection, TaskDetailResultProjection, TaskProjection, WorklistProjection } from "@tutti/shared/schemas/api";
 export type MessageAuthorInput = {
     kind: "human" | "system" | "agent";
     ref?: string;
@@ -57,18 +57,52 @@ export type ScratchpadSnapshotInput = {
     updated_by_activity_ref?: ActivityRef;
     now?: () => Date;
 };
+export type ScratchpadContentSnapshot = {
+    topic: string;
+    background_summary: string;
+    current_consensus: string[];
+    open_questions: string[];
+    task_changes: string[];
+};
 export type ScratchpadSourceRefInput = {
     message_id: MessageId;
-    source_scope: "main_chat" | "clarification_round";
+    source_scope: "main_chat";
     created_at: string;
 };
-export type SubmitScratchpadInput = {
+export type TaskCompileContextRecord = {
+    workflow_ref: WorkflowInvocationRef;
+    captured_by_activity_ref: ActivityRef;
+    submitted_at: string;
+    scratchpad_snapshot: ScratchpadContentSnapshot;
+    scratchpad_updated_at: string;
+    source_window: {
+        after?: {
+            created_at: string;
+            message_id: MessageId;
+        };
+        through?: {
+            created_at: string;
+            message_id: MessageId;
+        };
+    };
+    sources: Array<{
+        message_id: MessageId;
+        created_at: string;
+    }>;
+};
+export type CaptureTaskCompileContextInput = {
+    workflow_ref: WorkflowInvocationRef;
+    captured_by_activity_ref: ActivityRef;
+    now?: () => Date;
+};
+export type CompleteTaskCompileContextInput = {
     workflow_ref: WorkflowInvocationRef;
     activity_ref: ActivityRef;
     now?: () => Date;
 };
-export type SubmitScratchpadResult = {
-    scratchpad: ScratchpadProjection;
+export type RollbackTaskCompileContextInput = {
+    workflow_ref: WorkflowInvocationRef;
+    now?: () => Date;
 };
 export type TaskCompileProposalInput = {
     workflow_ref: WorkflowInvocationRef;
@@ -299,10 +333,6 @@ export type ReadMessageWindowOptions = {
     after?: string;
     around?: string;
 };
-export type ReadMainChatMessagesAfterOptions = {
-    after_created_at: string;
-    limit?: number;
-};
 export type CursorPageOptions = {
     cursor?: string;
     limit?: number;

package/dist/control-plane/clarification-commands.d.ts

@@ -29,6 +29,5 @@ export declare function runSubmitClarificationRound(options: {
         kind: "task";
         task_id: string;
     }, threadId: string, roundId: ClarificationRoundRef) => boolean;
-    notifyScratchpadSourceChanged?: () => void;
 }): ControlPlaneCommandResult<SubmitClarificationRoundDisposition, SubmitClarificationRoundResult>;
 //# sourceMappingURL=clarification-commands.d.ts.map

package/dist/control-plane/clarification-commands.js

@@ -87,7 +87,6 @@ export function runSubmitClarificationRound(options) {
         invalidates: clarificationInvalidates(options.roundId, active.thread.id),
     });
     if (active.thread.owner.kind === "task_compile") {
-        options.notifyScratchpadSourceChanged?.();
         options.startTaskCompileContinuation(active.thread.owner, options.roundId);
     }
     else {

package/dist/control-plane/index.js

@@ -1,4 +1,4 @@
-import { readWorklistProjection } from "../collaboration-state/index.js";
+import { readActiveTaskCompileContext, readWorklistProjection, } from "../collaboration-state/index.js";
 import { ProcedureEngine } from "../procedure-engine/index.js";
 import { RunEngine } from "../run-engine/index.js";
 import { publishProcedureTransition as publishProcedureTransitionEvent, publishRunResultRecorded as publishRunResultRecordedEvent, publishRunTransition as publishRunTransitionEvent, publishTaskRunStarted as publishTaskRunStartedEvent, } from "./event-publishers.js";
@@ -192,7 +192,6 @@ export class Phase5ControlPlane {
             now: this.now,
             startTaskCompileContinuation: (owner, submittedRoundId) => this.startTaskCompileContinuation(owner, submittedRoundId),
             startTaskBoundFollowUpCheck: (owner, threadId, submittedRoundId) => this.startTaskBoundFollowUpCheck(owner, threadId, submittedRoundId),
-            notifyScratchpadSourceChanged: () => this.notifyScratchpadSourceChanged(),
         });
     }
     async waitForIdle() {
@@ -243,6 +242,9 @@ export class Phase5ControlPlane {
             activity_kind: "procedure",
             lane: activity.lane ?? "foreground",
             ...(activity.workflow_kind === undefined ? {} : { workflow_kind: activity.workflow_kind }),
+            ...(activity.workflow_ref === undefined
+                ? {}
+                : { workflow_ref: activity.workflow_ref }),
         }));
     }
     readActiveForegroundProcedure() {
@@ -274,7 +276,18 @@ export class Phase5ControlPlane {
         if (activeScratchpadRefresh !== null) {
             return activeScratchpadRefresh;
         }
-        return this.readActiveForegroundProcedure();
+        const foreground = this.readActiveForegroundProcedure();
+        if (foreground === null) {
+            return null;
+        }
+        const activeContext = readActiveTaskCompileContext(this.store.db);
+        if (activeContext !== null &&
+            (foreground.workflow_kind === "project_context_bootstrap" ||
+                (foreground.workflow_kind === "task_compile" &&
+                    foreground.workflow_ref === activeContext.workflow_ref))) {
+            return null;
+        }
+        return foreground;
     }
     publishTaskRunStarted(task, activityRef) {
         publishTaskRunStartedEvent(this.events, task, activityRef);

package/dist/control-plane/project-context-bootstrap.d.ts

@@ -1,14 +1,14 @@
 import type { ActivityRef, WorkflowInvocationRef } from "@tutti/shared/ids";
-import type { ScratchpadProjection } from "@tutti/shared/schemas/api";
+import type { ScratchpadContentSnapshot } from "../collaboration-state/index.js";
 import type { ProcedureProgressUpdate } from "../procedure-engine/index.js";
 import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
 import type { InitializeProjectDocsResult, ProjectDocsInitializationContext, ProjectDocsInitializationDocument } from "../workspace-ops/index.js";
 import type { ControlPlaneLogger, Phase5ControlPlaneOptions } from "./types.js";
 import type { ProcedureWorkflowRunner, ProjectContextBootstrapWorkflowInput, ProjectContextBootstrapWorkflowOutput } from "./workflows/index.js";
-export declare function buildProjectDocsInitializationContext(scratchpad: ScratchpadProjection): ProjectDocsInitializationContext;
+export declare function buildProjectDocsInitializationContext(scratchpad: ScratchpadContentSnapshot): ProjectDocsInitializationContext;
 export declare function buildProjectContextBootstrapWorkflowInput(options: {
     projectContext: Phase5ControlPlaneOptions["projectContext"];
-    scratchpad: ScratchpadProjection;
+    scratchpad: ScratchpadContentSnapshot;
     projectName: string;
     now: () => Date;
 }): ProjectContextBootstrapWorkflowInput | undefined;
@@ -16,7 +16,7 @@ export declare function projectContextBootstrapDocuments(output: ProjectContextB
 export declare function tryProjectContextBootstrapDocuments(input: {
     runner: ProcedureWorkflowRunner;
     projectContext: Phase5ControlPlaneOptions["projectContext"];
-    scratchpad: ScratchpadProjection;
+    scratchpad: ScratchpadContentSnapshot;
     projectName: string;
     workflowRef: WorkflowInvocationRef;
     activityRef: ActivityRef;

package/dist/control-plane/project-context-bootstrap.js

@@ -1,9 +1,6 @@
 import { projectDocPath, readProjectDocsSummaries } from "../project-docs/context.js";
 import { projectContextBootstrapInvalidates } from "./invalidations.js";
 export function buildProjectDocsInitializationContext(scratchpad) {
-    if (scratchpad.state !== "ready") {
-        return { source: "scratchpad_submit" };
-    }
     return {
         source: "scratchpad_submit",
         scratchpad: {
@@ -31,15 +28,13 @@ export function buildProjectContextBootstrapWorkflowInput(options) {
     if (missingDocs.length > 0) {
         input.missing_docs = missingDocs;
     }
-    if (options.scratchpad.state === "ready") {
-        input.scratchpad = {
-            topic: options.scratchpad.topic,
-            background_summary: options.scratchpad.background_summary,
-            current_consensus: options.scratchpad.current_consensus,
-            open_questions: options.scratchpad.open_questions,
-            task_changes: options.scratchpad.task_changes,
-        };
-    }
+    input.scratchpad = {
+        topic: options.scratchpad.topic,
+        background_summary: options.scratchpad.background_summary,
+        current_consensus: options.scratchpad.current_consensus,
+        open_questions: options.scratchpad.open_questions,
+        task_changes: options.scratchpad.task_changes,
+    };
     return input;
 }
 export function projectContextBootstrapDocuments(output) {

package/dist/control-plane/scratchpad-auto-refresh.js

@@ -110,7 +110,18 @@ export class ScratchpadAutoRefreshScheduler {
         if (this.options.readScratchpadRefreshBlocker() !== null) {
             return;
         }
-        const sourceBatch = readControlPlaneScratchpadSourceBatch(this.options.store);
+        let sourceBatch;
+        try {
+            sourceBatch = readControlPlaneScratchpadSourceBatch(this.options.store);
+        }
+        catch {
+            markScratchpadRefreshFailed(this.options.store.db, {
+                backoffUntil: addMilliseconds(now, SCRATCHPAD_AUTO_REFRESH_FAILURE_BACKOFF_MS).toISOString(),
+                now: this.options.now,
+            });
+            this.scheduleNextAttempt();
+            return;
+        }
         if (sourceBatch.source_message_count === 0) {
             markScratchpadRefreshSucceeded(this.options.store.db, { now: this.options.now });
             this.scheduleNextAttempt();