@xfey/tutti 0.1.0

package/dist/collaboration-state/worklist.js

@@ -0,0 +1,286 @@
+import { createTaskId, createTaskModuleId, } from "@tutti/shared/ids";
+import { nowIso, stringifyJson } from "./serialization.js";
+import { recordReadNotificationEvent } from "./read-state.js";
+function mapTaskModuleRow(row) {
+    const module = {
+        id: row.id,
+        name: row.name,
+        order: row.sort_order,
+        archived: row.archived === 1,
+        created_at: row.created_at,
+    };
+    if (row.summary !== null) {
+        module.summary = row.summary;
+    }
+    if (row.updated_at !== null) {
+        module.updated_at = row.updated_at;
+    }
+    return module;
+}
+function mapTaskRow(row) {
+    const task = {
+        id: row.id,
+        module_id: row.module_id,
+        title: row.title,
+        summary: row.summary,
+        status: row.status,
+        order: row.sort_order,
+        created_from_workflow_ref: row.created_from_workflow_ref,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+    if (row.current_activity_ref !== null) {
+        task.current_activity_ref = row.current_activity_ref;
+    }
+    if (row.active_clarification_thread_id !== null) {
+        task.active_clarification_thread_ref = row.active_clarification_thread_id;
+    }
+    if (row.latest_run_result_id !== null) {
+        task.latest_run_result_id = row.latest_run_result_id;
+    }
+    return task;
+}
+export function readTaskProjection(db, taskId) {
+    const row = db.prepare("SELECT * FROM tasks WHERE id = ?").get(taskId);
+    return row === undefined ? null : mapTaskRow(row);
+}
+export function readWorklistProjection(db) {
+    const moduleRows = db
+        .prepare(`
+        SELECT *
+        FROM task_modules
+        ORDER BY sort_order ASC, id ASC
+      `)
+        .all();
+    const taskRows = db
+        .prepare(`
+        SELECT *
+        FROM tasks
+        ORDER BY module_id ASC, sort_order ASC, id ASC
+      `)
+        .all();
+    const tasksByModule = new Map();
+    for (const row of taskRows) {
+        const tasks = tasksByModule.get(row.module_id) ?? [];
+        tasks.push(mapTaskRow(row));
+        tasksByModule.set(row.module_id, tasks);
+    }
+    const modules = moduleRows.map((row) => ({
+        module: mapTaskModuleRow(row),
+        tasks: tasksByModule.get(row.id) ?? [],
+    }));
+    const latestUpdatedAt = [
+        ...moduleRows.map((row) => row.updated_at),
+        ...taskRows.map((row) => row.updated_at),
+    ]
+        .filter((value) => value !== null)
+        .sort()
+        .at(-1);
+    const projection = { modules };
+    if (latestUpdatedAt !== undefined) {
+        projection.updated_at = latestUpdatedAt;
+    }
+    return projection;
+}
+export function readNextRunnableTask(db) {
+    const rows = db
+        .prepare(`
+        SELECT tasks.*
+        FROM tasks
+        JOIN task_modules ON task_modules.id = tasks.module_id
+        WHERE tasks.status = 'todo'
+          AND task_modules.archived = 0
+        ORDER BY task_modules.sort_order ASC,
+                 task_modules.id ASC,
+                 tasks.sort_order ASC,
+                 tasks.id ASC
+      `)
+        .all();
+    const first = rows[0];
+    if (first === undefined) {
+        return { kind: "none" };
+    }
+    return {
+        kind: "found",
+        task: mapTaskRow(first),
+        queued_task_ids: rows.map((row) => row.id),
+    };
+}
+export function readRecoverableScheduledRun(db) {
+    const runningRows = db
+        .prepare(`
+        SELECT tasks.*
+        FROM tasks
+        JOIN task_modules ON task_modules.id = tasks.module_id
+        WHERE tasks.status = 'running'
+          AND tasks.current_activity_ref IS NOT NULL
+        ORDER BY task_modules.sort_order ASC,
+                 task_modules.id ASC,
+                 tasks.sort_order ASC,
+                 tasks.id ASC
+      `)
+        .all();
+    if (runningRows.length !== 1) {
+        return null;
+    }
+    const running = runningRows[0];
+    if (running === undefined || running.current_activity_ref === null) {
+        return null;
+    }
+    const todoRows = db
+        .prepare(`
+        SELECT tasks.*
+        FROM tasks
+        JOIN task_modules ON task_modules.id = tasks.module_id
+        WHERE tasks.status = 'todo'
+          AND task_modules.archived = 0
+        ORDER BY task_modules.sort_order ASC,
+                 task_modules.id ASC,
+                 tasks.sort_order ASC,
+                 tasks.id ASC
+      `)
+        .all();
+    return {
+        task: mapTaskRow(running),
+        activity_ref: running.current_activity_ref,
+        queued_task_ids: [running.id, ...todoRows.map((row) => row.id)],
+    };
+}
+export function markTaskRunStarted(db, input) {
+    const row = db.prepare("SELECT * FROM tasks WHERE id = ?").get(input.task_id);
+    if (row === undefined) {
+        return { kind: "not_found" };
+    }
+    if (row.status !== "todo") {
+        return {
+            kind: "not_runnable",
+            task: mapTaskRow(row),
+        };
+    }
+    const updatedAt = nowIso(input.now);
+    db.prepare(`
+      UPDATE tasks
+      SET status = 'running',
+          current_activity_ref = ?,
+          updated_at = ?
+      WHERE id = ?
+        AND status = 'todo'
+    `).run(input.activity_ref, updatedAt, input.task_id);
+    recordReadNotificationEvent(db, {
+        scope: "worklist",
+        source_kind: "task_run_started",
+        source_ref: input.task_id,
+        occurred_at: updatedAt,
+    });
+    const task = readTaskProjection(db, input.task_id);
+    if (task === null) {
+        return { kind: "not_found" };
+    }
+    return {
+        kind: "started",
+        task,
+    };
+}
+function readMaxModuleSortOrder(db) {
+    const row = db
+        .prepare(`
+        SELECT MAX(sort_order) AS max_order
+        FROM task_modules
+      `)
+        .get();
+    return row?.max_order ?? 0;
+}
+function readMaxTaskSortOrder(db, moduleId) {
+    const row = db
+        .prepare(`
+        SELECT MAX(sort_order) AS max_order
+        FROM tasks
+        WHERE module_id = ?
+      `)
+        .get(moduleId);
+    return row?.max_order ?? 0;
+}
+export function applyTaskCompileProposal(db, input) {
+    const createdAt = nowIso(input.now);
+    const changedModuleIds = [];
+    const changedTaskIds = [];
+    const insert = db.transaction(() => {
+        const baseModuleOrder = readMaxModuleSortOrder(db);
+        const moduleIdByTempKey = new Map();
+        const nextTaskOrderByModule = new Map();
+        input.proposal.modules.forEach((moduleInput, moduleIndex) => {
+            if (moduleIdByTempKey.has(moduleInput.temp_key)) {
+                throw new Error(`Duplicate task_compile module temp_key: ${moduleInput.temp_key}`);
+            }
+            const moduleId = createTaskModuleId();
+            const moduleOrder = baseModuleOrder + (moduleIndex + 1) * 10;
+            db.prepare(`
+          INSERT INTO task_modules (
+            id,
+            name,
+            summary,
+            sort_order,
+            archived,
+            created_at,
+            updated_at
+          )
+          VALUES (?, ?, ?, ?, 0, ?, ?)
+        `).run(moduleId, moduleInput.name, null, moduleOrder, createdAt, createdAt);
+            changedModuleIds.push(moduleId);
+            moduleIdByTempKey.set(moduleInput.temp_key, moduleId);
+            nextTaskOrderByModule.set(moduleId, 0);
+        });
+        input.proposal.tasks.forEach((taskInput) => {
+            const moduleId = taskInput.existing_module_key ??
+                (taskInput.module_temp_key === undefined
+                    ? undefined
+                    : moduleIdByTempKey.get(taskInput.module_temp_key));
+            if (moduleId === undefined) {
+                throw new Error(`Task ${taskInput.title} does not reference a module`);
+            }
+            const currentOrder = nextTaskOrderByModule.get(moduleId) ?? readMaxTaskSortOrder(db, moduleId);
+            const taskOrder = currentOrder + 10;
+            nextTaskOrderByModule.set(moduleId, taskOrder);
+            const taskId = createTaskId();
+            db.prepare(`
+          INSERT INTO tasks (
+            id,
+            module_id,
+            title,
+            summary,
+            status,
+            sort_order,
+            created_from_workflow_ref,
+            created_at,
+            updated_at
+          )
+          VALUES (?, ?, ?, ?, 'todo', ?, ?, ?, ?)
+        `).run(taskId, moduleId, taskInput.title, taskInput.summary, taskOrder, input.workflow_ref, createdAt, createdAt);
+            db.prepare(`
+          INSERT INTO task_details (
+            task_id,
+            contract_json,
+            result_json,
+            updated_at
+          )
+          VALUES (?, ?, '{}', ?)
+        `).run(taskId, stringifyJson(taskInput.contract), createdAt);
+            changedTaskIds.push(taskId);
+        });
+    });
+    insert();
+    if (changedModuleIds.length > 0 || changedTaskIds.length > 0) {
+        recordReadNotificationEvent(db, {
+            scope: "worklist",
+            source_kind: "task_compile",
+            source_ref: input.workflow_ref,
+            occurred_at: createdAt,
+        });
+    }
+    return {
+        worklist: readWorklistProjection(db),
+        changed_module_ids: changedModuleIds,
+        changed_task_ids: changedTaskIds,
+    };
+}
+//# sourceMappingURL=worklist.js.map

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

@@ -0,0 +1,34 @@
+import type { ClarificationRoundRef, IdempotencyKey } from "@tutti/shared/ids";
+import type { SendClarificationRoundMessageDisposition, SendClarificationRoundMessagePayload, SendClarificationRoundMessageResult, SubmitClarificationRoundDisposition, SubmitClarificationRoundPayload, SubmitClarificationRoundResult } from "@tutti/shared/schemas/api";
+import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
+import type { HostProjectStore } from "../store/index.js";
+import type { ControlPlaneCommandResult, TrustedHumanAuthor } from "./types.js";
+export declare function runSendClarificationRoundMessage(options: {
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    roundId: ClarificationRoundRef;
+    payload: SendClarificationRoundMessagePayload;
+    author: TrustedHumanAuthor;
+    now: () => Date;
+}): ControlPlaneCommandResult<SendClarificationRoundMessageDisposition, SendClarificationRoundMessageResult>;
+export declare function runSubmitClarificationRound(options: {
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    roundId: ClarificationRoundRef;
+    payload: SubmitClarificationRoundPayload;
+    commandId: IdempotencyKey;
+    now: () => Date;
+    startTaskCompileContinuation: (owner: {
+        kind: "task_compile";
+        workflow_ref: string;
+    } | {
+        kind: "task";
+        task_id: string;
+    }, roundId: ClarificationRoundRef) => boolean;
+    startTaskBoundFollowUpCheck: (owner: {
+        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

@@ -0,0 +1,106 @@
+import { createClarificationRoundMessage, readActiveClarificationProjection, submitClarificationRound, } from "../collaboration-state/index.js";
+import { clarificationInvalidates } from "./invalidations.js";
+export function runSendClarificationRoundMessage(options) {
+    const active = readActiveClarificationProjection(options.store.db);
+    if (active.state === "none") {
+        return { disposition: { kind: "chain_closed" } };
+    }
+    if (active.round.id !== options.roundId || active.round.status !== "writable") {
+        return {
+            disposition: {
+                kind: "stale_round",
+                current_round_id: active.round.id,
+            },
+        };
+    }
+    const message = createClarificationRoundMessage(options.store.db, {
+        round_id: options.roundId,
+        body: options.payload.body,
+        author: {
+            kind: "human",
+            ref: options.author.account_ref,
+            display_name: options.author.display_name,
+            ...(options.author.avatar === undefined ? {} : { avatar: options.author.avatar }),
+        },
+        now: options.now,
+    });
+    options.events.publish({
+        event_type: "message.created",
+        payload: { message },
+        invalidates: clarificationInvalidates(options.roundId, active.thread.id),
+    });
+    options.events.publish({
+        event_type: "clarification.changed",
+        payload: {
+            reason: "round_message_created",
+            thread_id: active.thread.id,
+            round_id: options.roundId,
+        },
+        invalidates: clarificationInvalidates(options.roundId, active.thread.id),
+    });
+    return {
+        disposition: { kind: "created" },
+        result: { message },
+    };
+}
+export function runSubmitClarificationRound(options) {
+    void options.payload;
+    const active = readActiveClarificationProjection(options.store.db);
+    if (active.state === "none") {
+        return { disposition: { kind: "chain_closed" } };
+    }
+    if (active.round.id !== options.roundId) {
+        return {
+            disposition: {
+                kind: "stale_round",
+                current_round_id: active.round.id,
+            },
+        };
+    }
+    if (active.round.status === "sealed") {
+        return {
+            disposition: {
+                kind: "already_submitted",
+                successor_status: active.round.successor_status,
+                ...(active.round.successor_ref === undefined
+                    ? {}
+                    : { successor_ref: active.round.successor_ref }),
+            },
+            result: { round: active.round },
+        };
+    }
+    const sealed = submitClarificationRound(options.store.db, {
+        round_id: options.roundId,
+        accepted_command_id: options.commandId,
+        now: options.now,
+    });
+    if (sealed === null) {
+        return { disposition: { kind: "chain_closed" } };
+    }
+    options.events.publish({
+        event_type: "clarification.changed",
+        payload: {
+            reason: "round_submitted",
+            thread_id: active.thread.id,
+            round_id: options.roundId,
+        },
+        invalidates: clarificationInvalidates(options.roundId, active.thread.id),
+    });
+    if (active.thread.owner.kind === "task_compile") {
+        options.notifyScratchpadSourceChanged?.();
+        options.startTaskCompileContinuation(active.thread.owner, options.roundId);
+    }
+    else {
+        options.startTaskBoundFollowUpCheck(active.thread.owner, active.thread.id, options.roundId);
+    }
+    return {
+        disposition: { kind: "accepted" },
+        result: {
+            round: sealed,
+            materialization: {
+                status: "queued",
+            },
+        },
+    };
+}
+//# sourceMappingURL=clarification-commands.js.map

package/dist/control-plane/command-recovery.d.ts

@@ -0,0 +1,3 @@
+import type { CommandRecoveryResolver } from "../store/index.js";
+export declare const resolveControlPlaneCommandRecovery: CommandRecoveryResolver;
+//# sourceMappingURL=command-recovery.d.ts.map

package/dist/control-plane/command-recovery.js

@@ -0,0 +1,79 @@
+import { readClarificationRoundProjection, readRecoverableScheduledRun, readRunResultProjectionByActivityRef, } from "../collaboration-state/index.js";
+const SUBMIT_CLARIFICATION_ROUND_COMMANDS = new Set([
+    "clarification.round.submit",
+    "submit_clarification_round",
+]);
+const MATERIALIZE_CLARIFICATION_SUCCESSOR_COMMANDS = new Set([
+    "clarification.successor.materialize",
+    "materialize_clarification_successor",
+    "recovery_replay_clarification_successor",
+]);
+const RECORD_RUN_RESULT_COMMANDS = new Set(["run.result.record", "record_run_result"]);
+const RUN_SCHEDULER_NOW_COMMANDS = new Set(["scheduler.run_now", "runSchedulerNow"]);
+function completed(disposition) {
+    return {
+        status: "completed",
+        disposition,
+    };
+}
+export const resolveControlPlaneCommandRecovery = (db, record) => {
+    if (SUBMIT_CLARIFICATION_ROUND_COMMANDS.has(record.command_name)) {
+        if (record.target_ref === null) {
+            return null;
+        }
+        const round = readClarificationRoundProjection(db, record.target_ref);
+        if (round === null || round.status !== "sealed") {
+            return null;
+        }
+        return completed({
+            kind: "already_submitted",
+            successor_status: round.successor_status,
+            ...(round.successor_ref === undefined ? {} : { successor_ref: round.successor_ref }),
+        });
+    }
+    if (MATERIALIZE_CLARIFICATION_SUCCESSOR_COMMANDS.has(record.command_name)) {
+        if (record.target_ref === null) {
+            return null;
+        }
+        const round = readClarificationRoundProjection(db, record.target_ref);
+        if (round === null || round.successor_status !== "materialized") {
+            return null;
+        }
+        return completed({
+            kind: "already_materialized",
+            ...(round.successor_ref === undefined ? {} : { successor_ref: round.successor_ref }),
+        });
+    }
+    if (RECORD_RUN_RESULT_COMMANDS.has(record.command_name)) {
+        if (record.target_ref === null) {
+            return null;
+        }
+        const runResult = readRunResultProjectionByActivityRef(db, record.target_ref);
+        if (runResult === null) {
+            return null;
+        }
+        return completed({
+            kind: "recorded",
+            run_result_id: runResult.id,
+            task_id: runResult.task_id,
+            result_kind: runResult.result_kind,
+        });
+    }
+    if (RUN_SCHEDULER_NOW_COMMANDS.has(record.command_name)) {
+        if (record.target_ref !== null && record.target_ref !== "worklist") {
+            return null;
+        }
+        const scheduled = readRecoverableScheduledRun(db);
+        if (scheduled === null) {
+            return null;
+        }
+        return completed({
+            kind: "scheduled",
+            task_id: scheduled.task.id,
+            activity_ref: scheduled.activity_ref,
+            queued_task_ids: scheduled.queued_task_ids,
+        });
+    }
+    return null;
+};
+//# sourceMappingURL=command-recovery.js.map

package/dist/control-plane/context-sync.d.ts

@@ -0,0 +1,47 @@
+import type { ActivityRef, WorkflowInvocationRef } from "@tutti/shared/ids";
+import type { ContextSyncDisposition, ContextSyncResult } from "@tutti/shared/schemas/api";
+import type { ProcedureEngine, ProcedureEngineState } from "../procedure-engine/index.js";
+import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
+import type { HostProjectStore } from "../store/index.js";
+import type { ControlPlaneCommandResult, ControlPlaneLogger, Phase5ControlPlaneOptions } from "./types.js";
+import type { ContextSyncWorkflowOutput, ContextSyncWorkflowTrigger, ProcedureWorkflowRunner, ProcedureWorkflowRunnerResolver } from "./workflows/index.js";
+export declare function startContextSyncAnalysisProcedure(input: {
+    engine: ProcedureEngine;
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    trigger: ContextSyncWorkflowTrigger;
+    resolveWorkflowRunner: ProcedureWorkflowRunnerResolver;
+    readActiveActivity: () => {
+        activity_ref: ActivityRef;
+    } | null;
+    projectContext: Phase5ControlPlaneOptions["projectContext"];
+    logger?: ControlPlaneLogger | undefined;
+    now: () => Date;
+    publishProcedureTransition: (state: ProcedureEngineState) => void;
+}): ControlPlaneCommandResult<ContextSyncDisposition, ContextSyncResult>;
+export declare function applyContextSyncAnalysisOutput(input: {
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    output: ContextSyncWorkflowOutput;
+    runner: ProcedureWorkflowRunner;
+    workflowRef: WorkflowInvocationRef;
+    activityRef: ActivityRef;
+    projectContext: Phase5ControlPlaneOptions["projectContext"];
+    logger: ControlPlaneLogger | undefined;
+    now: () => Date;
+}): Promise<{
+    kind: "failed";
+    summary: string;
+    result_anchor: {
+        kind: "workflow";
+        workflow_ref: `wf_${string}`;
+    };
+} | {
+    kind: "completed";
+    summary: string;
+    result_anchor: {
+        kind: "workflow";
+        workflow_ref: `wf_${string}`;
+    };
+}>;
+//# sourceMappingURL=context-sync.d.ts.map