@xfey/tutti 0.1.0

package/dist/control-plane/task-compile-continuation.js

@@ -0,0 +1,127 @@
+import { advanceScratchpadTaskCompileSourceCursor, materializeClarificationSuccessor, readClarificationRoundMessagesWindow, readClarificationRoundProjection, readScratchpadProjection, readWorklistProjection, } from "../collaboration-state/index.js";
+import { clarificationInvalidates } from "./invalidations.js";
+import { applyTaskCompileProcedureOutput } from "./task-compile-output.js";
+import { logProcedureExecutionError } from "./procedure-logging.js";
+export function startControlPlaneTaskCompileContinuation(options) {
+    if (options.owner.kind !== "task_compile") {
+        return false;
+    }
+    const workflowRef = options.owner.workflow_ref;
+    const runnerResolution = options.resolveWorkflowRunner();
+    if (runnerResolution.kind !== "ready") {
+        return false;
+    }
+    const start = options.engine.startProcedure({
+        workflow_ref: workflowRef,
+        workflow_kind: "task_compile",
+        lane: "foreground",
+        title: "Continue Worklist Compile",
+        summary: "Continuing task_compile from clarification input.",
+        now: options.now,
+        onTransition: options.publishProcedureTransition,
+        onError: ({ context, error }) => logProcedureExecutionError({
+            logger: options.logger,
+            workflowKind: "task_compile",
+            workflowRef,
+            activityRef: context.activity_ref,
+            error,
+        }),
+        execute: async (context) => {
+            const round = readClarificationRoundProjection(options.store.db, options.roundId);
+            try {
+                const messagesWindow = round === null
+                    ? null
+                    : readClarificationRoundMessagesWindow(options.store.db, options.roundId, {
+                        anchor: "start",
+                    });
+                const clarification = round === null
+                    ? undefined
+                    : {
+                        request_payload: round.request_payload,
+                        messages: messagesWindow?.items ?? [],
+                    };
+                const output = await runnerResolution.runner.runTaskCompile({
+                    workflow_ref: workflowRef,
+                    scratchpad: readScratchpadProjection(options.store.db),
+                    worklist: readWorklistProjection(options.store.db),
+                    ...(clarification === undefined ? {} : { clarification }),
+                }, {
+                    workflow_ref: workflowRef,
+                    activity_ref: context.activity_ref,
+                });
+                const conclusion = applyTaskCompileProcedureOutput({
+                    store: options.store,
+                    events: options.events,
+                    output,
+                    workflowRef,
+                    activityRef: context.activity_ref,
+                    now: options.now,
+                    continueFromRoundId: options.roundId,
+                    onTasksAdded: options.onTasksAdded,
+                });
+                if (output.decision === "ready" &&
+                    conclusion.kind === "completed" &&
+                    round?.submitted_at !== undefined) {
+                    advanceScratchpadTaskCompileSourceCursor(options.store.db, {
+                        submitted_at: round.submitted_at,
+                        round_id: options.roundId,
+                        now: options.now,
+                    });
+                }
+                if (output.decision === "ready") {
+                    const threadId = round?.thread_id;
+                    materializeClarificationSuccessor(options.store.db, {
+                        round_id: options.roundId,
+                        successor_ref: {
+                            kind: "proposal_applied",
+                            workflow_ref: workflowRef,
+                        },
+                        close_thread: true,
+                        now: options.now,
+                    });
+                    if (threadId !== undefined) {
+                        options.events.publish({
+                            event_type: "clarification.changed",
+                            payload: {
+                                reason: "successor_materialized",
+                                thread_id: threadId,
+                                round_id: options.roundId,
+                                successor_ref: {
+                                    kind: "proposal_applied",
+                                    workflow_ref: workflowRef,
+                                },
+                            },
+                            invalidates: clarificationInvalidates(options.roundId, threadId),
+                        });
+                    }
+                }
+                return conclusion;
+            }
+            catch (error) {
+                const threadId = round?.thread_id;
+                materializeClarificationSuccessor(options.store.db, {
+                    round_id: options.roundId,
+                    successor_ref: { kind: "chain_closed" },
+                    close_thread: true,
+                    closed_reason: "cancelled",
+                    now: options.now,
+                });
+                if (threadId !== undefined) {
+                    options.events.publish({
+                        event_type: "clarification.changed",
+                        payload: {
+                            reason: "successor_materialized",
+                            thread_id: threadId,
+                            round_id: options.roundId,
+                            successor_ref: { kind: "chain_closed" },
+                        },
+                        invalidates: clarificationInvalidates(options.roundId, threadId),
+                    });
+                }
+                throw error;
+            }
+        },
+    });
+    return start.kind === "accepted";
+}
+//# sourceMappingURL=task-compile-continuation.js.map

package/dist/control-plane/task-compile-output.d.ts

@@ -0,0 +1,29 @@
+import type { ActivityRef, ClarificationRoundRef, WorkflowInvocationRef } from "@tutti/shared/ids";
+import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
+import type { HostProjectStore } from "../store/index.js";
+import type { TaskCompileWorkflowOutput } from "./workflows/index.js";
+export declare function applyTaskCompileProcedureOutput(input: {
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    output: TaskCompileWorkflowOutput;
+    workflowRef: WorkflowInvocationRef;
+    activityRef: ActivityRef;
+    now: () => Date;
+    continueFromRoundId?: ClarificationRoundRef;
+    onTasksAdded?: () => void;
+}): {
+    kind: "needs_human";
+    summary: string;
+    result_anchor: {
+        kind: "clarification_round";
+        clarification_round_ref: `clar_round_${string}`;
+    };
+} | {
+    kind: "completed";
+    summary: string;
+    result_anchor: {
+        kind: "workflow";
+        workflow_ref: `wf_${string}`;
+    };
+};
+//# sourceMappingURL=task-compile-output.d.ts.map

package/dist/control-plane/task-compile-output.js

@@ -0,0 +1,122 @@
+import { applyTaskCompileProposal, clearScratchpadProjection, openNextTaskCompileClarificationRound, openTaskCompileClarificationRound, readWorklistProjection, } from "../collaboration-state/index.js";
+import { clarificationInvalidates, taskCompileInvalidates, } from "./invalidations.js";
+import { normalizeTaskCompileProposal } from "./task-proposal.js";
+const EMPTY_INITIAL_WORKLIST_CLARIFICATION = {
+    title: "Worklist scope needed",
+    summary: "No existing Worklist task covers this Scratchpad, and no new task was produced.",
+    request: "What concrete product, engineering, testing, deployment, or documentation-maintenance work should be added to the Worklist?",
+};
+function countWorklistTasks(worklist) {
+    return worklist.modules.reduce((count, module) => count + module.tasks.length, 0);
+}
+function openTaskCompileNeedsHuman(input) {
+    const opened = input.continueFromRoundId === undefined
+        ? openTaskCompileClarificationRound(input.store.db, {
+            workflow_ref: input.workflowRef,
+            activity_ref: input.activityRef,
+            request_payload: input.requestPayload,
+            now: input.now,
+        })
+        : openNextTaskCompileClarificationRound(input.store.db, {
+            continue_from_round_id: input.continueFromRoundId,
+            workflow_ref: input.workflowRef,
+            activity_ref: input.activityRef,
+            request_payload: input.requestPayload,
+            now: input.now,
+        });
+    const roundId = opened.round.id;
+    if (input.continueFromRoundId !== undefined) {
+        input.events.publish({
+            event_type: "clarification.changed",
+            payload: {
+                reason: "successor_materialized",
+                thread_id: opened.thread.id,
+                round_id: input.continueFromRoundId,
+                successor_ref: {
+                    kind: "next_round",
+                    clarification_round_ref: roundId,
+                },
+            },
+            invalidates: clarificationInvalidates(input.continueFromRoundId, opened.thread.id),
+        });
+    }
+    input.events.publish({
+        event_type: "message.created",
+        payload: { message: opened.card_message },
+        invalidates: clarificationInvalidates(roundId, opened.thread.id),
+    });
+    input.events.publish({
+        event_type: "clarification.changed",
+        payload: {
+            reason: "round_opened",
+            thread_id: opened.thread.id,
+            round_id: roundId,
+        },
+        invalidates: clarificationInvalidates(roundId, opened.thread.id),
+    });
+    return {
+        kind: "needs_human",
+        summary: input.requestPayload.summary,
+        result_anchor: {
+            kind: "clarification_round",
+            clarification_round_ref: roundId,
+        },
+    };
+}
+export function applyTaskCompileProcedureOutput(input) {
+    if (input.output.decision === "needs_human") {
+        return openTaskCompileNeedsHuman({
+            ...input,
+            requestPayload: input.output.clarification_request_payload,
+        });
+    }
+    const currentWorklist = readWorklistProjection(input.store.db);
+    const proposal = normalizeTaskCompileProposal(input.output.proposal);
+    if (proposal.tasks.length === 0 && countWorklistTasks(currentWorklist) === 0) {
+        return openTaskCompileNeedsHuman({
+            ...input,
+            requestPayload: EMPTY_INITIAL_WORKLIST_CLARIFICATION,
+        });
+    }
+    const applied = applyTaskCompileProposal(input.store.db, {
+        workflow_ref: input.workflowRef,
+        proposal,
+        now: input.now,
+    });
+    if (applied.changed_task_ids.length > 0) {
+        input.onTasksAdded?.();
+    }
+    const clearedScratchpad = clearScratchpadProjection(input.store.db);
+    input.events.publish({
+        event_type: "worklist.changed",
+        payload: {
+            reason: "task_compile_applied",
+            workflow_ref: input.workflowRef,
+            activity_ref: input.activityRef,
+            changed_module_ids: applied.changed_module_ids,
+            changed_task_ids: applied.changed_task_ids,
+        },
+        invalidates: taskCompileInvalidates(),
+    });
+    input.events.publish({
+        event_type: "scratchpad.updated",
+        payload: {
+            scratchpad: clearedScratchpad,
+            activity_ref: input.activityRef,
+        },
+        invalidates: taskCompileInvalidates(),
+    });
+    if (input.continueFromRoundId !== undefined) {
+        return {
+            kind: "completed",
+            summary: "Worklist compiled.",
+            result_anchor: { kind: "workflow", workflow_ref: input.workflowRef },
+        };
+    }
+    return {
+        kind: "completed",
+        summary: "Worklist compiled.",
+        result_anchor: { kind: "workflow", workflow_ref: input.workflowRef },
+    };
+}
+//# sourceMappingURL=task-compile-output.js.map

package/dist/control-plane/task-compile-start.d.ts

@@ -0,0 +1,43 @@
+import { type ActivityRef, type WorkflowInvocationRef } from "@tutti/shared/ids";
+import type { SubmitWorklistDisposition, SubmitWorklistPayload, SubmitWorklistResult } 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 { ProcedureWorkflowRunner, ProcedureWorkflowRunnerResolver } from "./workflows/index.js";
+export declare function startControlPlaneTaskCompile(options: {
+    engine: ProcedureEngine;
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    payload: SubmitWorklistPayload;
+    resolveWorkflowRunner: ProcedureWorkflowRunnerResolver;
+    projectContext: Phase5ControlPlaneOptions["projectContext"] | undefined;
+    logger: ControlPlaneLogger | undefined;
+    now: () => Date;
+    publishProcedureTransition: (state: ProcedureEngineState) => void;
+    onTasksAdded: () => void;
+}): ControlPlaneCommandResult<SubmitWorklistDisposition, SubmitWorklistResult>;
+export declare function runControlPlaneTaskCompileProcedure(options: {
+    runner: ProcedureWorkflowRunner;
+    workflowRef: WorkflowInvocationRef;
+    activityRef: ActivityRef;
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    now: () => Date;
+    onTasksAdded: () => void;
+}): Promise<{
+    kind: "needs_human";
+    summary: string;
+    result_anchor: {
+        kind: "clarification_round";
+        clarification_round_ref: `clar_round_${string}`;
+    };
+} | {
+    kind: "completed";
+    summary: string;
+    result_anchor: {
+        kind: "workflow";
+        workflow_ref: `wf_${string}`;
+    };
+}>;
+//# sourceMappingURL=task-compile-start.d.ts.map

package/dist/control-plane/task-compile-start.js

@@ -0,0 +1,280 @@
+import { createWorkflowInvocationRef, } from "@tutti/shared/ids";
+import { readScratchpadProjection, readWorklistProjection } from "../collaboration-state/index.js";
+import { initializeProjectDocs, readProjectDocsInitializationStatus, } from "../workspace-ops/index.js";
+import { logProcedureExecutionError } from "./procedure-logging.js";
+import { projectBriefShouldRefreshForUpdatedPaths, refreshProjectBriefProjection, } from "./project-brief-refresh.js";
+import { applyProjectDocsInitializationResult, buildProjectDocsInitializationContext, tryProjectContextBootstrapDocuments, } from "./project-context-bootstrap.js";
+import { readActiveScratchpadRefreshActivityRef, readControlPlaneScratchpadSourceBatch, runControlPlaneScratchpadRefreshProcedure, } from "./scratchpad-refresh-start.js";
+import { applyTaskCompileProcedureOutput } from "./task-compile-output.js";
+export function startControlPlaneTaskCompile(options) {
+    const scratchpad = readScratchpadProjection(options.store.db);
+    if (options.payload.expected_scratchpad_updated_at !== undefined &&
+        options.payload.expected_scratchpad_updated_at !== scratchpad.updated_at) {
+        return {
+            disposition: {
+                kind: "stale_scratchpad",
+                current_scratchpad: scratchpad,
+            },
+        };
+    }
+    const shouldInitializeProjectContext = shouldInitializeControlPlaneProjectContext(options);
+    const runnerResolution = options.resolveWorkflowRunner();
+    if (runnerResolution.kind === "not_configured") {
+        return { disposition: { kind: "provider_not_configured" } };
+    }
+    if (runnerResolution.kind === "unavailable") {
+        return {
+            disposition: {
+                kind: "provider_unavailable",
+                reason: runnerResolution.reason,
+                retryable: runnerResolution.retryable,
+            },
+        };
+    }
+    const sourceBatch = readControlPlaneScratchpadSourceBatch(options.store);
+    if (sourceBatch.source_message_count > 0) {
+        const activeScratchpadRefresh = readActiveScratchpadRefreshActivityRef({
+            engine: options.engine,
+            store: options.store,
+        });
+        if (activeScratchpadRefresh !== undefined) {
+            return {
+                disposition: {
+                    kind: "already_running",
+                    activity_ref: activeScratchpadRefresh,
+                },
+            };
+        }
+        return startScratchpadRefreshBeforeTaskCompileActivity({
+            ...options,
+            runner: runnerResolution.runner,
+            sourceBatch,
+        });
+    }
+    if (scratchpad.state === "empty") {
+        return { disposition: { kind: "scratchpad_empty" } };
+    }
+    if (shouldInitializeProjectContext) {
+        return startProjectContextBootstrapActivity({
+            ...options,
+            runner: runnerResolution.runner,
+        });
+    }
+    return startControlPlaneTaskCompileActivity({
+        ...options,
+        runner: runnerResolution.runner,
+    });
+}
+function startControlPlaneTaskCompileActivity(options) {
+    const workflowRef = createWorkflowInvocationRef();
+    const start = options.engine.startProcedure({
+        workflow_ref: workflowRef,
+        workflow_kind: "task_compile",
+        lane: "foreground",
+        title: "Compile Worklist",
+        summary: "Compiling Scratchpad into Worklist tasks.",
+        now: options.now,
+        onTransition: options.publishProcedureTransition,
+        onError: ({ context, error }) => logProcedureExecutionError({
+            logger: options.logger,
+            workflowKind: "task_compile",
+            workflowRef,
+            activityRef: context.activity_ref,
+            error,
+        }),
+        execute: async (context) => runControlPlaneTaskCompileProcedure({
+            runner: options.runner,
+            store: options.store,
+            events: options.events,
+            workflowRef,
+            activityRef: context.activity_ref,
+            now: options.now,
+            onTasksAdded: options.onTasksAdded,
+        }),
+    });
+    if (start.kind === "already_running") {
+        return {
+            disposition: {
+                kind: "already_running",
+                activity_ref: start.activity_ref,
+            },
+        };
+    }
+    return {
+        disposition: { kind: "accepted" },
+        result: {
+            activity_ref: start.activity.activity_ref,
+            workflow_ref: workflowRef,
+        },
+    };
+}
+function startScratchpadRefreshBeforeTaskCompileActivity(options) {
+    const workflowRef = createWorkflowInvocationRef();
+    const start = options.engine.startProcedure({
+        workflow_ref: workflowRef,
+        workflow_kind: "scratchpad_refresh",
+        lane: "foreground",
+        title: "Refresh Scratchpad",
+        summary: "Refreshing Scratchpad before submitting to Worklist.",
+        now: options.now,
+        onTransition: (state) => {
+            options.publishProcedureTransition(state);
+            if (state.activity.status === "finished") {
+                if (shouldInitializeControlPlaneProjectContext(options)) {
+                    void startProjectContextBootstrapActivity(options);
+                }
+                else {
+                    void startControlPlaneTaskCompileActivity(options);
+                }
+            }
+        },
+        onError: ({ context, error }) => logProcedureExecutionError({
+            logger: options.logger,
+            workflowKind: "scratchpad_refresh",
+            workflowRef,
+            activityRef: context.activity_ref,
+            error,
+        }),
+        execute: async (context) => runControlPlaneScratchpadRefreshProcedure({
+            runner: options.runner,
+            store: options.store,
+            events: options.events,
+            workflowRef,
+            activityRef: context.activity_ref,
+            sourceBatch: options.sourceBatch,
+            now: options.now,
+        }),
+    });
+    if (start.kind === "already_running") {
+        return {
+            disposition: {
+                kind: "already_running",
+                activity_ref: start.activity_ref,
+            },
+        };
+    }
+    return {
+        disposition: { kind: "accepted" },
+        result: {
+            activity_ref: start.activity.activity_ref,
+            workflow_ref: workflowRef,
+        },
+    };
+}
+function shouldInitializeControlPlaneProjectContext(options) {
+    if (options.projectContext === undefined) {
+        return false;
+    }
+    const status = readProjectDocsInitializationStatus({
+        workspaceRoot: options.projectContext.workspaceRoot,
+        now: options.now,
+    });
+    return !status.ready;
+}
+function startProjectContextBootstrapActivity(options) {
+    if (options.projectContext === undefined) {
+        return startControlPlaneTaskCompileActivity(options);
+    }
+    const workflowRef = createWorkflowInvocationRef();
+    const start = options.engine.startProcedure({
+        workflow_ref: workflowRef,
+        workflow_kind: "project_context_bootstrap",
+        lane: "foreground",
+        title: "Prepare Project Context",
+        summary: "Preparing project docs before compiling the Worklist.",
+        now: options.now,
+        onTransition: (state) => {
+            options.publishProcedureTransition(state);
+            if (state.activity.status === "finished") {
+                void startControlPlaneTaskCompileActivity(options);
+            }
+        },
+        onError: ({ context, error }) => logProcedureExecutionError({
+            logger: options.logger,
+            workflowKind: "project_context_bootstrap",
+            workflowRef,
+            activityRef: context.activity_ref,
+            error,
+        }),
+        execute: async (context) => {
+            if (options.projectContext === undefined) {
+                return {
+                    kind: "failed",
+                    summary: "Project context is unavailable.",
+                };
+            }
+            const initializationContext = buildProjectDocsInitializationContext(readScratchpadProjection(options.store.db));
+            const modelDocuments = await tryProjectContextBootstrapDocuments({
+                runner: options.runner,
+                projectContext: options.projectContext,
+                scratchpad: readScratchpadProjection(options.store.db),
+                projectName: options.projectContext.projectName,
+                workflowRef,
+                activityRef: context.activity_ref,
+                logger: options.logger,
+                now: options.now,
+            });
+            const initialized = initializeProjectDocs({
+                workspaceRoot: options.projectContext.workspaceRoot,
+                projectName: options.projectContext.projectName,
+                context: initializationContext,
+                ...(modelDocuments === undefined ? {} : { documents: modelDocuments }),
+                now: options.now,
+            });
+            if (projectBriefShouldRefreshForUpdatedPaths(initialized.created_paths)) {
+                await refreshProjectBriefProjection({
+                    store: options.store,
+                    projectContext: options.projectContext,
+                    reason: "project_context_bootstrap",
+                    runner: options.runner,
+                    workflowRef,
+                    activityRef: context.activity_ref,
+                    logger: options.logger,
+                    now: options.now,
+                });
+            }
+            return applyProjectDocsInitializationResult({
+                events: options.events,
+                logger: options.logger,
+                result: initialized,
+                workflowRef,
+                activityRef: context.activity_ref,
+            });
+        },
+    });
+    if (start.kind === "already_running") {
+        return {
+            disposition: {
+                kind: "already_running",
+                activity_ref: start.activity_ref,
+            },
+        };
+    }
+    return {
+        disposition: { kind: "accepted" },
+        result: {
+            activity_ref: start.activity.activity_ref,
+            workflow_ref: workflowRef,
+        },
+    };
+}
+export async function runControlPlaneTaskCompileProcedure(options) {
+    const output = await options.runner.runTaskCompile({
+        workflow_ref: options.workflowRef,
+        scratchpad: readScratchpadProjection(options.store.db),
+        worklist: readWorklistProjection(options.store.db),
+    }, {
+        workflow_ref: options.workflowRef,
+        activity_ref: options.activityRef,
+    });
+    return applyTaskCompileProcedureOutput({
+        store: options.store,
+        events: options.events,
+        output,
+        workflowRef: options.workflowRef,
+        activityRef: options.activityRef,
+        now: options.now,
+        onTasksAdded: options.onTasksAdded,
+    });
+}
+//# sourceMappingURL=task-compile-start.js.map

package/dist/control-plane/task-proposal.d.ts

@@ -0,0 +1,3 @@
+import type { TaskCompileProposal } from "./workflows/index.js";
+export declare function normalizeTaskCompileProposal(proposal: TaskCompileProposal): TaskCompileProposal;
+//# sourceMappingURL=task-proposal.d.ts.map

package/dist/control-plane/task-proposal.js

@@ -0,0 +1,37 @@
+function nonBlankString(value) {
+    if (value === undefined || value.trim() === "") {
+        return undefined;
+    }
+    return value;
+}
+export function normalizeTaskCompileProposal(proposal) {
+    const normalizedTasks = proposal.tasks.map((task) => {
+        const moduleTempKey = nonBlankString(task.module_temp_key);
+        const existingModuleKey = nonBlankString(task.existing_module_key);
+        const normalized = {
+            title: task.title,
+            summary: task.summary,
+            contract: task.contract,
+        };
+        if (moduleTempKey !== undefined) {
+            normalized.module_temp_key = moduleTempKey;
+        }
+        if (existingModuleKey !== undefined) {
+            normalized.existing_module_key = existingModuleKey;
+        }
+        return normalized;
+    });
+    const referencedModuleTempKeys = new Set(normalizedTasks
+        .map((task) => task.module_temp_key)
+        .filter((value) => value !== undefined));
+    return {
+        modules: proposal.modules
+            .filter((module) => referencedModuleTempKeys.has(module.temp_key))
+            .map((module) => ({
+            temp_key: module.temp_key,
+            name: module.name,
+        })),
+        tasks: normalizedTasks,
+    };
+}
+//# sourceMappingURL=task-proposal.js.map