@xfey/tutti 0.1.0

package/dist/control-plane/context-sync.js

@@ -0,0 +1,207 @@
+import { createWorkflowInvocationRef } from "@tutti/shared/ids";
+import { recordProjectTimelineEvent } from "../project-timeline/index.js";
+import { syncProjectDocs } from "../workspace-ops/index.js";
+import { logProcedureExecutionError } from "./procedure-logging.js";
+import { projectBriefShouldRefreshForUpdatedPaths, refreshProjectBriefProjection, } from "./project-brief-refresh.js";
+function publishContextSyncTimelineChanged(input) {
+    input.events.publish({
+        event_type: "query.invalidate",
+        payload: {
+            reason: "bulk_state_change",
+            message: input.message,
+        },
+        invalidates: input.invalidates ?? [{ kind: "project_timeline" }],
+    });
+}
+export function startContextSyncAnalysisProcedure(input) {
+    const activeActivity = input.readActiveActivity();
+    if (activeActivity !== null) {
+        return {
+            disposition: {
+                kind: "already_running",
+                activity_ref: activeActivity.activity_ref,
+            },
+        };
+    }
+    const runnerResolution = input.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,
+            },
+        };
+    }
+    if (runnerResolution.runner.runContextSync === undefined) {
+        return {
+            disposition: {
+                kind: "provider_unavailable",
+                reason: "provider_model_unavailable",
+                retryable: false,
+            },
+        };
+    }
+    const workflowRef = createWorkflowInvocationRef();
+    const start = input.engine.startProcedure({
+        workflow_ref: workflowRef,
+        workflow_kind: "context_sync",
+        lane: "foreground",
+        title: "Sync Context",
+        summary: "Synchronizing repository context into project docs.",
+        now: input.now,
+        onTransition: input.publishProcedureTransition,
+        onError: ({ context, error }) => logProcedureExecutionError({
+            logger: input.logger,
+            workflowKind: "context_sync",
+            workflowRef,
+            activityRef: context.activity_ref,
+            error,
+        }),
+        execute: async (context) => {
+            const workflowInput = {
+                workflow_ref: workflowRef,
+                activity_ref: context.activity_ref,
+                trigger: input.trigger,
+            };
+            const output = await runnerResolution.runner.runContextSync?.(workflowInput, {
+                workflow_ref: workflowRef,
+                activity_ref: context.activity_ref,
+            });
+            if (output === undefined) {
+                return {
+                    kind: "failed",
+                    summary: "Context sync adapter is unavailable.",
+                };
+            }
+            return await applyContextSyncAnalysisOutput({
+                store: input.store,
+                events: input.events,
+                output,
+                runner: runnerResolution.runner,
+                workflowRef,
+                activityRef: context.activity_ref,
+                projectContext: input.projectContext,
+                logger: input.logger,
+                now: input.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,
+        },
+    };
+}
+export async function applyContextSyncAnalysisOutput(input) {
+    let syncResult;
+    if (input.output.updates.length > 0) {
+        if (input.projectContext === undefined) {
+            recordProjectTimelineEvent(input.store.db, {
+                event_kind: "context_sync",
+                status: "failed",
+                summary: "Project context is unavailable for context sync writes.",
+                activity_ref: input.activityRef,
+                workflow_ref: input.workflowRef,
+                meta: ["reason: project_context_unavailable"],
+                now: input.now,
+            });
+            publishContextSyncTimelineChanged({
+                events: input.events,
+                message: "Context sync timeline updated.",
+            });
+            return {
+                kind: "failed",
+                summary: "Project context is unavailable for context sync writes.",
+                result_anchor: { kind: "workflow", workflow_ref: input.workflowRef },
+            };
+        }
+        try {
+            syncResult = syncProjectDocs({
+                workspaceRoot: input.projectContext.workspaceRoot,
+                updates: input.output.updates.map((update) => ({
+                    path: update.path,
+                    content: update.content,
+                })),
+                now: input.now,
+            });
+        }
+        catch (error) {
+            recordProjectTimelineEvent(input.store.db, {
+                event_kind: "context_sync",
+                status: "failed",
+                summary: "Context sync write failed.",
+                activity_ref: input.activityRef,
+                workflow_ref: input.workflowRef,
+                meta: [`error: ${error instanceof Error ? error.name : "UnknownError"}`],
+                now: input.now,
+            });
+            publishContextSyncTimelineChanged({
+                events: input.events,
+                message: "Context sync timeline updated.",
+            });
+            throw error;
+        }
+        input.logger?.info({
+            workflow_ref: input.workflowRef,
+            activity_ref: input.activityRef,
+            updated_paths: syncResult.updated_paths,
+            ...(syncResult.commit_oid === undefined ? {} : { commit_oid: syncResult.commit_oid }),
+        }, "Context sync wrote project docs");
+        if (projectBriefShouldRefreshForUpdatedPaths(syncResult.updated_paths)) {
+            await refreshProjectBriefProjection({
+                store: input.store,
+                projectContext: input.projectContext,
+                reason: "context_sync",
+                runner: input.runner,
+                workflowRef: input.workflowRef,
+                activityRef: input.activityRef,
+                logger: input.logger,
+                now: input.now,
+            });
+        }
+    }
+    recordProjectTimelineEvent(input.store.db, {
+        event_kind: "context_sync",
+        status: "completed",
+        summary: input.output.summary,
+        activity_ref: input.activityRef,
+        workflow_ref: input.workflowRef,
+        ...(syncResult?.commit_oid === undefined ? {} : { commit_oid: syncResult.commit_oid }),
+        meta: [`updated paths: ${syncResult?.updated_paths.length ?? 0}`],
+        now: input.now,
+    });
+    publishContextSyncTimelineChanged({
+        events: input.events,
+        message: "Context sync timeline updated.",
+        ...(syncResult !== undefined && syncResult.updated_paths.length !== 0
+            ? {
+                invalidates: [
+                    { kind: "viewer" },
+                    { kind: "workspace" },
+                    { kind: "project_timeline" },
+                    { kind: "bootstrap" },
+                ],
+            }
+            : {}),
+    });
+    return {
+        kind: "completed",
+        summary: input.output.summary,
+        result_anchor: { kind: "workflow", workflow_ref: input.workflowRef },
+    };
+}
+//# sourceMappingURL=context-sync.js.map

package/dist/control-plane/event-publishers.d.ts

@@ -0,0 +1,24 @@
+import { type ActivityRef } from "@tutti/shared/ids";
+import type { ExecutionStatusProjection, TaskProjection } from "@tutti/shared/schemas/api";
+import { type RecordRunNeedsHumanResultResult, type RecordRunResultResult } from "../collaboration-state/index.js";
+import type { ProcedureEngineState } from "../procedure-engine/index.js";
+import type { RunEngineState } from "../run-engine/index.js";
+import type { HostProjectStore } from "../store/index.js";
+import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
+export declare function publishTaskRunStarted(events: WorkspaceEventBus, task: TaskProjection, activityRef: ActivityRef): void;
+export declare function publishRunResultRecorded(events: WorkspaceEventBus, recorded: RecordRunResultResult | RecordRunNeedsHumanResultResult): void;
+export declare function publishRunTransition(input: {
+    events: WorkspaceEventBus;
+    state: RunEngineState;
+    now: () => Date;
+    getExecutionStatus: () => ExecutionStatusProjection;
+    onTerminal: (state: RunEngineState) => void;
+}): void;
+export declare function publishProcedureTransition(input: {
+    events: WorkspaceEventBus;
+    store: HostProjectStore;
+    state: ProcedureEngineState;
+    now: () => Date;
+    getExecutionStatus: () => ExecutionStatusProjection;
+}): void;
+//# sourceMappingURL=event-publishers.d.ts.map

package/dist/control-plane/event-publishers.js

@@ -0,0 +1,192 @@
+import { createEventRef, } from "@tutti/shared/ids";
+import { createMainChatSystemMessage, } from "../collaboration-state/index.js";
+import { EXECUTION_STATUS_INVALIDATES, clarificationInvalidates, procedureFailureInvalidates, taskRunInvalidates, } from "./invalidations.js";
+import { defaultProcedureFailureSystemMessage } from "./formatters.js";
+function activityEventKind(activity, transitionKind) {
+    if (transitionKind === "progress") {
+        return "progress";
+    }
+    if (activity.status === "running") {
+        return "started";
+    }
+    if (activity.status === "needs_human") {
+        return "needs_human";
+    }
+    if (activity.status === "failed") {
+        return "failed";
+    }
+    return "finished";
+}
+export function publishTaskRunStarted(events, task, activityRef) {
+    const taskId = task.id;
+    const invalidates = taskRunInvalidates(taskId);
+    events.publish({
+        event_type: "worklist.changed",
+        payload: {
+            reason: "task_state_changed",
+            activity_ref: activityRef,
+            changed_task_ids: [taskId],
+        },
+        invalidates,
+    });
+    events.publish({
+        event_type: "task.updated",
+        payload: { task },
+        invalidates,
+    });
+}
+export function publishRunResultRecorded(events, recorded) {
+    const taskId = recorded.task.id;
+    const invalidates = taskRunInvalidates(taskId);
+    if ("card_message" in recorded) {
+        const threadId = recorded.thread.id;
+        const roundId = recorded.round.id;
+        const clarificationHints = clarificationInvalidates(roundId, threadId);
+        events.publish({
+            event_type: "message.created",
+            payload: {
+                message: recorded.card_message,
+            },
+            invalidates: [...invalidates, ...clarificationHints],
+        });
+        events.publish({
+            event_type: "clarification.changed",
+            payload: {
+                reason: "round_opened",
+                thread_id: threadId,
+                round_id: roundId,
+            },
+            invalidates: [...invalidates, ...clarificationHints],
+        });
+    }
+    events.publish({
+        event_type: "worklist.changed",
+        payload: {
+            reason: "task_result_recorded",
+            activity_ref: recorded.run_result.activity_ref,
+            changed_task_ids: [taskId],
+        },
+        invalidates,
+    });
+    events.publish({
+        event_type: "task.updated",
+        payload: {
+            task: recorded.task,
+        },
+        invalidates,
+    });
+    events.publish({
+        event_type: "task_detail.updated",
+        payload: {
+            task_id: taskId,
+            task: recorded.task,
+            detail: recorded.task_detail,
+            latest_run_result_id: recorded.run_result.id,
+        },
+        invalidates,
+    });
+}
+export function publishRunTransition(input) {
+    const eventPayload = input.state.transition_kind === "progress"
+        ? {
+            progress: {
+                message: input.state.progress?.summary ?? input.state.activity.summary,
+                ...(input.state.progress?.phase === undefined
+                    ? {}
+                    : { phase: input.state.progress.phase }),
+            },
+        }
+        : input.state.activity.status === "running"
+            ? undefined
+            : {
+                terminal: {
+                    result_kind: input.state.activity.status === "finished"
+                        ? "finished"
+                        : input.state.activity.status === "needs_human"
+                            ? "needs_human"
+                            : "failed",
+                    summary: input.state.activity.summary,
+                },
+            };
+    input.events.publish({
+        event_type: "activity.event",
+        payload: {
+            activity: input.state.activity,
+            event: {
+                event_ref: createEventRef(),
+                activity_ref: input.state.activity.activity_ref,
+                event_kind: activityEventKind(input.state.activity, input.state.transition_kind),
+                occurred_at: input.now().toISOString(),
+                summary: input.state.activity.summary,
+                ...(eventPayload === undefined ? {} : { payload: eventPayload }),
+            },
+        },
+        invalidates: [{ kind: "activity", activity_ref: input.state.activity.activity_ref }],
+    });
+    input.events.publish({
+        event_type: "execution_status.changed",
+        payload: {
+            execution_status: input.getExecutionStatus(),
+        },
+        invalidates: EXECUTION_STATUS_INVALIDATES,
+    });
+    if (input.state.activity.status !== "running") {
+        input.onTerminal(input.state);
+    }
+}
+export function publishProcedureTransition(input) {
+    const eventPayload = input.state.activity.status === "running"
+        ? undefined
+        : {
+            terminal: {
+                result_kind: input.state.activity.status === "finished"
+                    ? "finished"
+                    : input.state.activity.status === "needs_human"
+                        ? "needs_human"
+                        : "failed",
+                summary: input.state.activity.summary,
+            },
+        };
+    input.events.publish({
+        event_type: "activity.event",
+        payload: {
+            activity: input.state.activity,
+            event: {
+                event_ref: createEventRef(),
+                activity_ref: input.state.activity.activity_ref,
+                event_kind: activityEventKind(input.state.activity),
+                occurred_at: input.now().toISOString(),
+                summary: input.state.activity.summary,
+                ...(eventPayload === undefined ? {} : { payload: eventPayload }),
+            },
+        },
+        invalidates: [{ kind: "activity", activity_ref: input.state.activity.activity_ref }],
+    });
+    if (input.state.activity.status === "failed" &&
+        input.state.activity.workflow_kind !== "scratchpad_refresh") {
+        const refs = {
+            activity_ref: input.state.activity.activity_ref,
+        };
+        if (input.state.activity.workflow_ref !== undefined) {
+            refs.workflow_ref = input.state.activity.workflow_ref;
+        }
+        const message = createMainChatSystemMessage(input.store.db, {
+            body: defaultProcedureFailureSystemMessage(input.state.activity),
+            refs,
+            now: input.now,
+        });
+        input.events.publish({
+            event_type: "message.created",
+            payload: { message },
+            invalidates: procedureFailureInvalidates(),
+        });
+    }
+    input.events.publish({
+        event_type: "execution_status.changed",
+        payload: {
+            execution_status: input.getExecutionStatus(),
+        },
+        invalidates: EXECUTION_STATUS_INVALIDATES,
+    });
+}
+//# sourceMappingURL=event-publishers.js.map

package/dist/control-plane/execution-status.d.ts

@@ -0,0 +1,13 @@
+import type { ActiveApprovalProjection, ExecutionStatusProjection } from "@tutti/shared/schemas/api";
+import type { ProcedureEngine } from "../procedure-engine/index.js";
+import type { RunEngine } from "../run-engine/index.js";
+import type { HostProjectStore } from "../store/index.js";
+export declare function readControlPlaneExecutionStatus(options: {
+    procedureEngine: ProcedureEngine;
+    runEngine: RunEngine;
+    store: HostProjectStore;
+    lastRecoveryConclusion: NonNullable<ExecutionStatusProjection["last_conclusion"]> | null;
+    readActiveApproval?: () => ActiveApprovalProjection;
+    now: () => Date;
+}): ExecutionStatusProjection;
+//# sourceMappingURL=execution-status.d.ts.map

package/dist/control-plane/execution-status.js

@@ -0,0 +1,130 @@
+import { readActiveClarificationProjection } from "../collaboration-state/index.js";
+export function readControlPlaneExecutionStatus(options) {
+    const activeStatus = options.procedureEngine.getExecutionStatus();
+    const activeRunStatus = options.runEngine.getExecutionStatus();
+    const activeActivities = collectActiveActivities(activeRunStatus, activeStatus);
+    const activeRunActivity = activeRunStatus.active_activity;
+    const activeForegroundProcedure = activeActivities.find((activity) => {
+        return (activity.activity_kind === "procedure" && (activity.lane ?? "foreground") === "foreground");
+    });
+    const activeBackgroundProcedure = activeActivities.find((activity) => {
+        return (activity.activity_kind === "procedure" && (activity.lane ?? "foreground") !== "foreground");
+    });
+    const activeProcedureActivity = activeForegroundProcedure ?? activeBackgroundProcedure;
+    const activeApproval = options.readActiveApproval?.();
+    if (activeApproval?.state === "pending") {
+        const status = {
+            status: "pending",
+            summary: `Waiting for approval: ${activeApproval.request.summary}`,
+            blocked_by: {
+                kind: "approval",
+                approval_id: activeApproval.request.approval_id,
+            },
+            updated_at: options.now().toISOString(),
+        };
+        if (activeRunStatus.active_task !== undefined) {
+            status.active_task = activeRunStatus.active_task;
+        }
+        if (activeRunActivity !== undefined) {
+            status.active_activity = activeRunActivity;
+        }
+        else if (activeProcedureActivity !== undefined) {
+            status.active_activity = activeProcedureActivity;
+        }
+        appendActiveActivities(status, activeActivities);
+        const lastConclusion = activeRunStatus.last_conclusion ?? activeStatus.last_conclusion;
+        if (lastConclusion !== undefined) {
+            status.last_conclusion = lastConclusion;
+        }
+        return status;
+    }
+    if (activeRunStatus.status !== "idle") {
+        const status = {
+            ...activeRunStatus,
+        };
+        appendActiveActivities(status, activeActivities);
+        if (activeStatus.last_conclusion !== undefined && status.last_conclusion === undefined) {
+            status.last_conclusion = activeStatus.last_conclusion;
+        }
+        return status;
+    }
+    if (activeForegroundProcedure !== undefined) {
+        if (activeForegroundProcedure.workflow_kind === "context_sync" &&
+            activeRunStatus.last_conclusion?.kind === "completed" &&
+            activeRunStatus.last_conclusion.task_id !== undefined) {
+            const status = {
+                ...activeStatus,
+                active_activity: activeForegroundProcedure,
+                summary: "Task complete; synchronizing repository context.",
+                last_conclusion: activeRunStatus.last_conclusion,
+            };
+            appendActiveActivities(status, activeActivities);
+            return status;
+        }
+        const status = {
+            ...activeStatus,
+            active_activity: activeForegroundProcedure,
+        };
+        appendActiveActivities(status, activeActivities);
+        return status;
+    }
+    const activeClarification = readActiveClarificationProjection(options.store.db);
+    if (activeClarification.state === "active") {
+        const status = {
+            status: "pending",
+            summary: activeClarification.round.request_payload.summary,
+            blocked_by: {
+                kind: "clarification",
+                thread_id: activeClarification.thread.id,
+                round_id: activeClarification.round.id,
+            },
+            updated_at: options.now().toISOString(),
+        };
+        appendActiveActivities(status, activeActivities);
+        const lastConclusion = activeRunStatus.last_conclusion ?? activeStatus.last_conclusion;
+        if (lastConclusion !== undefined) {
+            status.last_conclusion = lastConclusion;
+        }
+        return status;
+    }
+    if (activeBackgroundProcedure !== undefined) {
+        const status = {
+            ...activeStatus,
+            active_activity: activeBackgroundProcedure,
+        };
+        appendActiveActivities(status, activeActivities);
+        return status;
+    }
+    if (activeRunStatus.last_conclusion !== undefined) {
+        return activeRunStatus;
+    }
+    if (activeStatus.last_conclusion !== undefined) {
+        return activeStatus;
+    }
+    if (options.lastRecoveryConclusion !== null) {
+        return {
+            status: "idle",
+            summary: "Idle",
+            last_conclusion: options.lastRecoveryConclusion,
+            updated_at: options.now().toISOString(),
+        };
+    }
+    return activeStatus;
+}
+function collectActiveActivities(runStatus, procedureStatus) {
+    const activities = [];
+    if (runStatus.active_activity !== undefined) {
+        activities.push(runStatus.active_activity);
+    }
+    const procedureActivities = procedureStatus.active_activities ??
+        (procedureStatus.active_activity === undefined ? [] : [procedureStatus.active_activity]);
+    activities.push(...procedureActivities);
+    return activities;
+}
+function appendActiveActivities(status, activities) {
+    if (activities.length === 0) {
+        return;
+    }
+    status.active_activities = activities;
+}
+//# sourceMappingURL=execution-status.js.map

package/dist/control-plane/follow-up-context.d.ts

@@ -0,0 +1,27 @@
+import type { ClarificationRoundRef, TaskId, WorkflowInvocationRef } from "@tutti/shared/ids";
+import type { HostProjectStore } from "../store/index.js";
+import type { RunContinuationContext } from "./types.js";
+import type { FollowUpCheckWorkflowInput } from "./workflows/index.js";
+export declare function readFollowUpCheckInputFromStore(input: {
+    db: HostProjectStore["db"];
+    workflow_ref: WorkflowInvocationRef;
+    task_id: TaskId;
+    thread_id: string;
+    round_id: ClarificationRoundRef;
+}): {
+    kind: "ready";
+    input: FollowUpCheckWorkflowInput;
+} | {
+    kind: "unavailable";
+} | {
+    kind: "invalid";
+    summary: string;
+};
+export declare function readRunContinuationContextFromStore(input: {
+    db: HostProjectStore["db"];
+    task_id: TaskId;
+    thread_id: string;
+    round_id: ClarificationRoundRef;
+    follow_up_check_summary?: string;
+}): RunContinuationContext | null;
+//# sourceMappingURL=follow-up-context.d.ts.map

package/dist/control-plane/follow-up-context.js

@@ -0,0 +1,93 @@
+import { readClarificationRoundMessagesWindow, readClarificationRoundProjection, readClarificationRoundsForThread, readTaskDetailProjection, readTaskRunResultsPage, } from "../collaboration-state/index.js";
+import { toDomainRunLineage } from "./run-lineage.js";
+const CONTINUATION_CLARIFICATION_MESSAGE_LIMIT = 200;
+export function readFollowUpCheckInputFromStore(input) {
+    const taskDetail = readTaskDetailProjection(input.db, input.task_id);
+    const round = readClarificationRoundProjection(input.db, input.round_id);
+    const messagesWindow = readClarificationRoundMessagesWindow(input.db, input.round_id, {
+        anchor: "start",
+    });
+    const latestRunResult = readTaskRunResultsPage(input.db, input.task_id, {
+        limit: 1,
+    })?.items[0];
+    if (taskDetail === null || round === null || latestRunResult === undefined) {
+        return { kind: "unavailable" };
+    }
+    if (latestRunResult.result_kind !== "needs_human") {
+        return {
+            kind: "invalid",
+            summary: `Task-bound follow-up requires the latest Run result to be needs_human, but the latest result is ${latestRunResult.result_kind}.`,
+        };
+    }
+    return {
+        kind: "ready",
+        input: {
+            workflow_ref: input.workflow_ref,
+            task_id: input.task_id,
+            task_detail: taskDetail,
+            clarification_thread_ref: input.thread_id,
+            clarification_round_ref: input.round_id,
+            clarification_request_payload: round.request_payload,
+            submitted_message_refs: (round.submitted_message_refs ?? []),
+            round_messages: messagesWindow?.items ?? [],
+            latest_run_result: latestRunResult,
+            run_lineage: toDomainRunLineage(latestRunResult.run_lineage),
+        },
+    };
+}
+export function readRunContinuationContextFromStore(input) {
+    const latestRunResult = readTaskRunResultsPage(input.db, input.task_id, {
+        limit: 1,
+    })?.items[0];
+    const currentRound = readClarificationRoundProjection(input.db, input.round_id);
+    if (latestRunResult === undefined ||
+        latestRunResult.result_kind !== "needs_human" ||
+        currentRound === null) {
+        return null;
+    }
+    const rounds = readClarificationRoundsForThread(input.db, input.thread_id, { throughRoundIndex: currentRound.round_index }).filter((round) => round.status === "sealed");
+    if (rounds.length === 0) {
+        return null;
+    }
+    let messagesTruncated = false;
+    const resolvedRounds = rounds.map((round) => {
+        const messagesWindow = readClarificationRoundMessagesWindow(input.db, round.id, { anchor: "start", limit: CONTINUATION_CLARIFICATION_MESSAGE_LIMIT });
+        if (messagesWindow === null ||
+            messagesWindow.window.has_older ||
+            messagesWindow.window.has_newer) {
+            messagesTruncated = true;
+        }
+        const submittedMessageRefs = new Set((round.submitted_message_refs ?? []));
+        const answerMessages = (messagesWindow?.items ?? [])
+            .filter((message) => message.author.kind === "human")
+            .filter((message) => submittedMessageRefs.size === 0 || submittedMessageRefs.has(message.id))
+            .map((message) => ({
+            author: message.author,
+            text: message.body,
+            created_at: message.created_at,
+        }));
+        return {
+            request_payload: round.request_payload,
+            answer_messages: answerMessages,
+        };
+    });
+    const firstRequestPayload = resolvedRounds[0]?.request_payload ?? currentRound.request_payload;
+    const followUpSummary = input.follow_up_check_summary !== undefined && input.follow_up_check_summary.trim() !== ""
+        ? input.follow_up_check_summary
+        : "Follow-up accepted.";
+    return {
+        previous_run: {
+            summary: latestRunResult.summary,
+            clarification_request_payload: firstRequestPayload,
+        },
+        clarification: {
+            resolved_rounds: resolvedRounds,
+            messages_truncated: messagesTruncated,
+        },
+        follow_up_check: {
+            decision: "resume",
+            summary: followUpSummary,
+        },
+    };
+}
+//# sourceMappingURL=follow-up-context.js.map