@xfey/tutti 0.1.0

package/dist/control-plane/project-brief-refresh.js

@@ -0,0 +1,105 @@
+import { readProjectBriefProjection, readProjectBriefSourceDocuments, upsertProjectBriefProjection, } from "../project-brief/index.js";
+import { PROJECT_DOC_PATHS } from "../workspace-ops/index.js";
+export function projectBriefShouldRefreshForUpdatedPaths(paths) {
+    return paths.some((path) => PROJECT_DOC_PATHS.includes(path));
+}
+function resolveProjectBriefRunner(input) {
+    if (input.runner !== undefined) {
+        return input.runner;
+    }
+    const resolution = input.resolveWorkflowRunner?.();
+    if (resolution === undefined || resolution.kind !== "ready") {
+        return undefined;
+    }
+    return resolution.runner;
+}
+export async function refreshProjectBriefProjection(input) {
+    if (input.projectContext === undefined) {
+        return { kind: "skipped", reason: "project_context_unavailable" };
+    }
+    const runner = resolveProjectBriefRunner(input);
+    if (runner === undefined) {
+        return { kind: "skipped", reason: "provider_unavailable" };
+    }
+    if (runner.runProjectBriefRefresh === undefined) {
+        return { kind: "skipped", reason: "runner_unavailable" };
+    }
+    let sourceDocs;
+    try {
+        sourceDocs = readProjectBriefSourceDocuments({
+            workspaceRoot: input.projectContext.workspaceRoot,
+            now: input.now,
+        });
+    }
+    catch (error) {
+        input.logger?.info({
+            reason: input.reason,
+            error: error instanceof Error ? error.name : "UnknownError",
+        }, "Project brief source read failed");
+        return { kind: "failed", reason: "source_unavailable" };
+    }
+    let currentBrief;
+    try {
+        currentBrief = readProjectBriefProjection(input.store.db, sourceDocs);
+    }
+    catch (error) {
+        input.logger?.info({
+            reason: input.reason,
+            error: error instanceof Error ? error.name : "UnknownError",
+        }, "Project brief projection read failed");
+        return { kind: "failed", reason: "projection_unavailable" };
+    }
+    if (currentBrief.state === "ready") {
+        return { kind: "skipped", reason: "already_fresh" };
+    }
+    if (!sourceDocs.some((source) => source.status === "available")) {
+        return { kind: "skipped", reason: "source_not_ready" };
+    }
+    let output;
+    try {
+        output = await runner.runProjectBriefRefresh({ docs: sourceDocs }, input.workflowRef === undefined || input.activityRef === undefined
+            ? undefined
+            : {
+                workflow_ref: input.workflowRef,
+                activity_ref: input.activityRef,
+            });
+    }
+    catch (error) {
+        input.logger?.info({
+            reason: input.reason,
+            error: error instanceof Error ? error.name : "UnknownError",
+            ...(input.workflowRef === undefined ? {} : { workflow_ref: input.workflowRef }),
+            ...(input.activityRef === undefined ? {} : { activity_ref: input.activityRef }),
+        }, "Project brief refresh failed");
+        return { kind: "failed", reason: "provider_failed" };
+    }
+    try {
+        const brief = upsertProjectBriefProjection(input.store.db, {
+            ...output,
+            source_docs: sourceDocs,
+            ...(input.activityRef === undefined ? {} : { updated_by_activity_ref: input.activityRef }),
+            ...(input.workflowRef === undefined ? {} : { updated_by_workflow_ref: input.workflowRef }),
+            now: input.now,
+        });
+        if (brief.state === "missing") {
+            return { kind: "failed", reason: "provider_failed" };
+        }
+        input.logger?.info({
+            reason: input.reason,
+            source_doc_count: sourceDocs.length,
+            ...(input.workflowRef === undefined ? {} : { workflow_ref: input.workflowRef }),
+            ...(input.activityRef === undefined ? {} : { activity_ref: input.activityRef }),
+        }, "Project brief refreshed");
+        return { kind: "refreshed", brief };
+    }
+    catch (error) {
+        input.logger?.info({
+            reason: input.reason,
+            error: error instanceof Error ? error.name : "UnknownError",
+            ...(input.workflowRef === undefined ? {} : { workflow_ref: input.workflowRef }),
+            ...(input.activityRef === undefined ? {} : { activity_ref: input.activityRef }),
+        }, "Project brief projection write failed");
+        return { kind: "failed", reason: "projection_unavailable" };
+    }
+}
+//# sourceMappingURL=project-brief-refresh.js.map

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

@@ -0,0 +1,39 @@
+import type { ActivityRef, WorkflowInvocationRef } from "@tutti/shared/ids";
+import type { ScratchpadProjection } from "@tutti/shared/schemas/api";
+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 buildProjectContextBootstrapWorkflowInput(options: {
+    projectContext: Phase5ControlPlaneOptions["projectContext"];
+    scratchpad: ScratchpadProjection;
+    projectName: string;
+    now: () => Date;
+}): ProjectContextBootstrapWorkflowInput | undefined;
+export declare function projectContextBootstrapDocuments(output: ProjectContextBootstrapWorkflowOutput): ProjectDocsInitializationDocument[];
+export declare function tryProjectContextBootstrapDocuments(input: {
+    runner: ProcedureWorkflowRunner;
+    projectContext: Phase5ControlPlaneOptions["projectContext"];
+    scratchpad: ScratchpadProjection;
+    projectName: string;
+    workflowRef: WorkflowInvocationRef;
+    activityRef: ActivityRef;
+    logger?: ControlPlaneLogger | undefined;
+    now: () => Date;
+}): Promise<ProjectDocsInitializationDocument[] | undefined>;
+export declare function applyProjectDocsInitializationResult(input: {
+    events: WorkspaceEventBus;
+    logger?: ControlPlaneLogger | undefined;
+    result: InitializeProjectDocsResult;
+    workflowRef: WorkflowInvocationRef;
+    activityRef: ActivityRef;
+}): {
+    kind: "completed";
+    summary: string;
+    result_anchor: {
+        kind: "workflow";
+        workflow_ref: `wf_${string}`;
+    };
+};
+//# sourceMappingURL=project-context-bootstrap.d.ts.map

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

@@ -0,0 +1,107 @@
+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: {
+            topic: scratchpad.topic,
+            background_summary: scratchpad.background_summary,
+            current_consensus: scratchpad.current_consensus,
+            open_questions: scratchpad.open_questions,
+            task_changes: scratchpad.task_changes,
+        },
+    };
+}
+export function buildProjectContextBootstrapWorkflowInput(options) {
+    if (options.projectContext === undefined) {
+        return undefined;
+    }
+    const missingDocs = readProjectDocsSummaries({
+        workspaceRoot: options.projectContext.workspaceRoot,
+        now: options.now,
+    })
+        .filter((doc) => doc.status === "missing")
+        .map((doc) => ({ doc_key: doc.doc_key, path: doc.path }));
+    const input = {
+        project_name: options.projectName,
+    };
+    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,
+        };
+    }
+    return input;
+}
+export function projectContextBootstrapDocuments(output) {
+    return output.documents.map((document) => ({
+        path: projectDocPath(document.doc_key),
+        content: document.content,
+    }));
+}
+export async function tryProjectContextBootstrapDocuments(input) {
+    if (input.runner.runProjectContextBootstrap === undefined) {
+        return undefined;
+    }
+    const workflowInput = buildProjectContextBootstrapWorkflowInput({
+        projectContext: input.projectContext,
+        scratchpad: input.scratchpad,
+        projectName: input.projectName,
+        now: input.now,
+    });
+    if (workflowInput === undefined) {
+        return undefined;
+    }
+    try {
+        const output = await input.runner.runProjectContextBootstrap(workflowInput, {
+            workflow_ref: input.workflowRef,
+            activity_ref: input.activityRef,
+        });
+        input.logger?.info({
+            workflow_ref: input.workflowRef,
+            activity_ref: input.activityRef,
+            document_count: output.documents.length,
+        }, "Project context bootstrap model plan completed");
+        return projectContextBootstrapDocuments(output);
+    }
+    catch (error) {
+        input.logger?.info({
+            workflow_ref: input.workflowRef,
+            activity_ref: input.activityRef,
+            error: error instanceof Error ? error.message : "unknown error",
+        }, "Project context bootstrap model plan unavailable; falling back to local templates");
+        return undefined;
+    }
+}
+export function applyProjectDocsInitializationResult(input) {
+    input.logger?.info({
+        workflow_ref: input.workflowRef,
+        activity_ref: input.activityRef,
+        created_paths: input.result.created_paths,
+        created_count: input.result.created_paths.length,
+        ...(input.result.commit_oid === undefined ? {} : { commit_oid: input.result.commit_oid }),
+    }, "Project context initialized before Worklist compile");
+    input.events.publish({
+        event_type: "query.invalidate",
+        payload: {
+            reason: "viewer_changed",
+            message: "Project context initialized.",
+        },
+        invalidates: projectContextBootstrapInvalidates(),
+    });
+    return {
+        kind: "completed",
+        summary: "Project context initialized.",
+        result_anchor: { kind: "workflow", workflow_ref: input.workflowRef },
+    };
+}
+//# sourceMappingURL=project-context-bootstrap.js.map

package/dist/control-plane/reference-summary-refresh.d.ts

@@ -0,0 +1,22 @@
+import type { ActivityRef } from "@tutti/shared/ids";
+import type { RefreshReferenceSummariesDisposition, RefreshReferenceSummariesResult } 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 { ProcedureWorkflowRunnerResolver } from "./workflows/index.js";
+export declare function startReferenceSummaryRefreshProcedure(input: {
+    engine: ProcedureEngine;
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    paths?: string[];
+    resolveWorkflowRunner: ProcedureWorkflowRunnerResolver;
+    readActiveActivity: () => {
+        activity_ref: ActivityRef;
+    } | null;
+    projectContext: Phase5ControlPlaneOptions["projectContext"];
+    logger?: ControlPlaneLogger | undefined;
+    now: () => Date;
+    publishProcedureTransition: (state: ProcedureEngineState) => void;
+}): ControlPlaneCommandResult<RefreshReferenceSummariesDisposition, RefreshReferenceSummariesResult>;
+//# sourceMappingURL=reference-summary-refresh.d.ts.map

package/dist/control-plane/reference-summary-refresh.js

@@ -0,0 +1,344 @@
+import { createWorkflowInvocationRef } from "@tutti/shared/ids";
+import { recordProjectTimelineEvent } from "../project-timeline/index.js";
+import { WorkspaceOpsError, readReferenceSummaryTargets, updateReferenceSummaries, } from "../workspace-ops/index.js";
+import { logProcedureExecutionError } from "./procedure-logging.js";
+function publishReferenceSummaryTimelineChanged(input) {
+    input.events.publish({
+        event_type: "query.invalidate",
+        payload: {
+            reason: "bulk_state_change",
+            message: input.message,
+        },
+        invalidates: input.invalidates ?? [{ kind: "project_timeline" }],
+    });
+}
+function readTargets(options) {
+    if (options.projectContext === undefined) {
+        return [];
+    }
+    try {
+        return readReferenceSummaryTargets({
+            workspaceRoot: options.projectContext.workspaceRoot,
+            ...(options.paths === undefined ? {} : { paths: options.paths }),
+            now: options.now,
+        });
+    }
+    catch (error) {
+        if (error instanceof WorkspaceOpsError && error.code === "not_found") {
+            return [];
+        }
+        throw error;
+    }
+}
+function summaryRecordFromOutput(options) {
+    if (options.output.decision === "summarized") {
+        return {
+            path: options.target.path,
+            status: "available",
+            generated_at: options.generatedAt,
+            source_blob_oid: options.target.blob_oid,
+            summary: options.output.summary,
+            read_paths: options.output.read_paths,
+        };
+    }
+    return {
+        path: options.target.path,
+        status: "unavailable",
+        generated_at: options.generatedAt,
+        source_blob_oid: options.target.blob_oid,
+        ...(options.output.summary.trim() === "" ? {} : { summary: options.output.summary }),
+        unavailable_reason: options.output.unavailable_reason,
+        read_paths: options.output.read_paths,
+    };
+}
+function logNotStarted(input) {
+    input.logger?.info({
+        disposition: input.disposition,
+        requested_path_count: input.requestedPathCount,
+        ...(input.targetCount === undefined ? {} : { target_count: input.targetCount }),
+        ...(input.reason === undefined ? {} : { reason: input.reason }),
+        ...(input.retryable === undefined ? {} : { retryable: input.retryable }),
+        ...(input.activityRef === undefined ? {} : { activity_ref: input.activityRef }),
+    }, "Reference summary refresh not started");
+}
+async function runReferenceSummaryRefresh(options) {
+    const summaries = [];
+    let failedCount = 0;
+    let adapterUnavailableCount = 0;
+    for (const target of options.targets) {
+        try {
+            const output = await options.runner.runReferenceFileSummary?.({
+                workflow_ref: options.workflowRef,
+                activity_ref: options.activityRef,
+                file: {
+                    path: target.path,
+                    name: target.name,
+                    category: target.category,
+                    size_bytes: target.size_bytes,
+                    blob_oid: target.blob_oid,
+                    ...(target.media_type === undefined ? {} : { media_type: target.media_type }),
+                },
+            }, {
+                workflow_ref: options.workflowRef,
+                activity_ref: options.activityRef,
+            });
+            if (output === undefined) {
+                adapterUnavailableCount += 1;
+                summaries.push({
+                    path: target.path,
+                    status: "unavailable",
+                    generated_at: options.now().toISOString(),
+                    source_blob_oid: target.blob_oid,
+                    unavailable_reason: "summary_adapter_unavailable",
+                });
+                continue;
+            }
+            summaries.push(summaryRecordFromOutput({
+                target,
+                output,
+                generatedAt: options.now().toISOString(),
+            }));
+        }
+        catch (error) {
+            failedCount += 1;
+            options.logger?.info({
+                workflow_ref: options.workflowRef,
+                activity_ref: options.activityRef,
+                path: target.path,
+                error_name: error instanceof Error ? error.name : "UnknownError",
+            }, "Reference summary target failed");
+            summaries.push({
+                path: target.path,
+                status: "unavailable",
+                generated_at: options.now().toISOString(),
+                source_blob_oid: target.blob_oid,
+                unavailable_reason: "summary_failed",
+            });
+        }
+    }
+    let result;
+    try {
+        result = updateReferenceSummaries({
+            workspaceRoot: options.projectContext.workspaceRoot,
+            summaries,
+            now: options.now,
+        });
+    }
+    catch (error) {
+        recordProjectTimelineEvent(options.store.db, {
+            event_kind: "reference_summary",
+            status: "failed",
+            summary: "Reference summary write failed.",
+            activity_ref: options.activityRef,
+            workflow_ref: options.workflowRef,
+            meta: [
+                `target count: ${options.targets.length}`,
+                `error: ${error instanceof Error ? error.name : "UnknownError"}`,
+            ],
+            now: options.now,
+        });
+        publishReferenceSummaryTimelineChanged({
+            events: options.events,
+            message: "Reference summary timeline updated.",
+        });
+        throw error;
+    }
+    options.logger?.info({
+        workflow_ref: options.workflowRef,
+        activity_ref: options.activityRef,
+        target_count: options.targets.length,
+        updated_count: result.updated_paths.length,
+        failed_count: failedCount,
+        adapter_unavailable_count: adapterUnavailableCount,
+        ...(result.commit_oid === undefined ? {} : { commit_oid: result.commit_oid }),
+    }, "Reference summaries refreshed");
+    recordProjectTimelineEvent(options.store.db, {
+        event_kind: "reference_summary",
+        status: "completed",
+        summary: result.updated_paths.length === 0
+            ? "Reference summaries already up to date."
+            : `Updated ${result.updated_paths.length} reference summaries.`,
+        activity_ref: options.activityRef,
+        workflow_ref: options.workflowRef,
+        ...(result.commit_oid === undefined ? {} : { commit_oid: result.commit_oid }),
+        meta: [
+            `target count: ${options.targets.length}`,
+            `updated paths: ${result.updated_paths.length}`,
+            `failed targets: ${failedCount}`,
+            `adapter unavailable: ${adapterUnavailableCount}`,
+        ],
+        now: options.now,
+    });
+    publishReferenceSummaryTimelineChanged({
+        events: options.events,
+        message: "Reference summary timeline updated.",
+        ...(result.updated_paths.length !== 0
+            ? {
+                invalidates: [
+                    { kind: "viewer", path: "docs/reference" },
+                    { kind: "workspace" },
+                    { kind: "project_timeline" },
+                    { kind: "bootstrap" },
+                ],
+            }
+            : {}),
+    });
+    return {
+        kind: "completed",
+        summary: result.updated_paths.length === 0
+            ? "Reference summaries already up to date."
+            : `Updated ${result.updated_paths.length} reference summaries.`,
+        result_anchor: { kind: "workflow", workflow_ref: options.workflowRef },
+    };
+}
+export function startReferenceSummaryRefreshProcedure(input) {
+    const activeActivity = input.readActiveActivity();
+    const requestedPathCount = input.paths?.length ?? 0;
+    if (activeActivity !== null) {
+        logNotStarted({
+            logger: input.logger,
+            disposition: "already_running",
+            requestedPathCount,
+            activityRef: activeActivity.activity_ref,
+        });
+        return {
+            disposition: {
+                kind: "already_running",
+                activity_ref: activeActivity.activity_ref,
+            },
+        };
+    }
+    if (input.projectContext === undefined) {
+        logNotStarted({
+            logger: input.logger,
+            disposition: "provider_unavailable",
+            requestedPathCount,
+            reason: "provider_model_unavailable",
+            retryable: false,
+        });
+        return {
+            disposition: {
+                kind: "provider_unavailable",
+                reason: "provider_model_unavailable",
+                retryable: false,
+            },
+        };
+    }
+    const targets = readTargets({
+        projectContext: input.projectContext,
+        ...(input.paths === undefined ? {} : { paths: input.paths }),
+        now: input.now,
+    });
+    if (targets.length === 0) {
+        logNotStarted({
+            logger: input.logger,
+            disposition: "no_targets",
+            requestedPathCount,
+            targetCount: 0,
+        });
+        return { disposition: { kind: "no_targets" } };
+    }
+    const runnerResolution = input.resolveWorkflowRunner();
+    if (runnerResolution.kind === "not_configured") {
+        logNotStarted({
+            logger: input.logger,
+            disposition: "provider_not_configured",
+            requestedPathCount,
+            targetCount: targets.length,
+        });
+        return { disposition: { kind: "provider_not_configured" } };
+    }
+    if (runnerResolution.kind === "unavailable") {
+        logNotStarted({
+            logger: input.logger,
+            disposition: "provider_unavailable",
+            requestedPathCount,
+            targetCount: targets.length,
+            reason: runnerResolution.reason,
+            retryable: runnerResolution.retryable,
+        });
+        return {
+            disposition: {
+                kind: "provider_unavailable",
+                reason: runnerResolution.reason,
+                retryable: runnerResolution.retryable,
+            },
+        };
+    }
+    if (runnerResolution.runner.runReferenceFileSummary === undefined) {
+        logNotStarted({
+            logger: input.logger,
+            disposition: "provider_unavailable",
+            requestedPathCount,
+            targetCount: targets.length,
+            reason: "provider_model_unavailable",
+            retryable: false,
+        });
+        return {
+            disposition: {
+                kind: "provider_unavailable",
+                reason: "provider_model_unavailable",
+                retryable: false,
+            },
+        };
+    }
+    const workflowRef = createWorkflowInvocationRef();
+    const projectContext = input.projectContext;
+    const start = input.engine.startProcedure({
+        workflow_ref: workflowRef,
+        workflow_kind: "reference_summary_refresh",
+        lane: "foreground",
+        title: "Refresh Reference Summaries",
+        summary: "Summarizing reference files.",
+        now: input.now,
+        onTransition: input.publishProcedureTransition,
+        onError: ({ context, error }) => logProcedureExecutionError({
+            logger: input.logger,
+            workflowKind: "reference_summary_refresh",
+            workflowRef,
+            activityRef: context.activity_ref,
+            error,
+        }),
+        execute: async (context) => runReferenceSummaryRefresh({
+            store: input.store,
+            runner: runnerResolution.runner,
+            workflowRef,
+            activityRef: context.activity_ref,
+            targets,
+            projectContext,
+            events: input.events,
+            logger: input.logger,
+            now: input.now,
+        }),
+    });
+    if (start.kind === "already_running") {
+        logNotStarted({
+            logger: input.logger,
+            disposition: "already_running",
+            requestedPathCount,
+            targetCount: targets.length,
+            activityRef: start.activity_ref,
+        });
+        return {
+            disposition: {
+                kind: "already_running",
+                activity_ref: start.activity_ref,
+            },
+        };
+    }
+    input.logger?.info({
+        workflow_ref: workflowRef,
+        activity_ref: start.activity.activity_ref,
+        requested_path_count: requestedPathCount,
+        target_count: targets.length,
+    }, "Reference summary refresh accepted");
+    return {
+        disposition: { kind: "accepted" },
+        result: {
+            activity_ref: start.activity.activity_ref,
+            workflow_ref: workflowRef,
+            target_count: targets.length,
+        },
+    };
+}
+//# sourceMappingURL=reference-summary-refresh.js.map

package/dist/control-plane/run-lineage.d.ts

@@ -0,0 +1,8 @@
+import type { RunLineage } from "@tutti/shared/domain";
+export declare function toDomainRunLineage(lineage: {
+    attempt: number;
+    kind: RunLineage["kind"];
+    parent_activity_ref?: string;
+    root_activity_ref?: string;
+}): RunLineage;
+//# sourceMappingURL=run-lineage.d.ts.map

package/dist/control-plane/run-lineage.js

@@ -0,0 +1,13 @@
+export function toDomainRunLineage(lineage) {
+    return {
+        attempt: lineage.attempt,
+        kind: lineage.kind,
+        ...(lineage.parent_activity_ref === undefined
+            ? {}
+            : { parent_activity_ref: lineage.parent_activity_ref }),
+        ...(lineage.root_activity_ref === undefined
+            ? {}
+            : { root_activity_ref: lineage.root_activity_ref }),
+    };
+}
+//# sourceMappingURL=run-lineage.js.map

package/dist/control-plane/run-result-recording.d.ts

@@ -0,0 +1,46 @@
+import type { RunLineage } from "@tutti/shared/domain";
+import type { ActivityRef, TaskId } from "@tutti/shared/ids";
+import type { TaskProjection } from "@tutti/shared/schemas/api";
+import { type RecordRunNeedsHumanResultResult, type RecordRunResultResult } from "../collaboration-state/index.js";
+import type { HostProjectStore } from "../store/index.js";
+import type { RunPipelineResult, RunPipelineTimelineEvent } from "./types.js";
+type RecordedRunResult = RecordRunResultResult | RecordRunNeedsHumanResultResult;
+type RunEngineTerminalResult = {
+    kind: "needs_human";
+    summary: string;
+} | {
+    kind: "completed";
+    summary: string;
+} | {
+    kind: "failed";
+    summary: string;
+};
+export type ControlPlaneRunResultRecord = {
+    recorded: RecordedRunResult;
+    terminal: RunEngineTerminalResult;
+};
+export declare function recordRunPipelineTimelineEvents(input: {
+    store: HostProjectStore;
+    activityRef: ActivityRef;
+    taskId: TaskId;
+    timelineEvents: readonly RunPipelineTimelineEvent[] | undefined;
+    now: () => Date;
+}): void;
+export declare function recordRunPipelineResult(input: {
+    store: HostProjectStore;
+    activityRef: ActivityRef;
+    task: TaskProjection;
+    runLineage: RunLineage;
+    pipelineResult: RunPipelineResult;
+    now: () => Date;
+}): ControlPlaneRunResultRecord;
+export declare function recordRunPipelineFailure(input: {
+    store: HostProjectStore;
+    activityRef: ActivityRef;
+    task: TaskProjection;
+    runLineage: RunLineage;
+    error: unknown;
+    now: () => Date;
+}): ControlPlaneRunResultRecord;
+export {};
+//# sourceMappingURL=run-result-recording.d.ts.map