@xfey/tutti 0.1.0

package/dist/control-plane/run-result-recording.js

@@ -0,0 +1,81 @@
+import { recordRunNeedsHumanResult, recordRunResult, } from "../collaboration-state/index.js";
+import { recordProjectTimelineEvent } from "../project-timeline/index.js";
+export function recordRunPipelineTimelineEvents(input) {
+    for (const event of input.timelineEvents ?? []) {
+        recordProjectTimelineEvent(input.store.db, {
+            event_kind: event.event_kind,
+            status: event.status,
+            summary: event.summary,
+            activity_ref: input.activityRef,
+            task_id: input.taskId,
+            ...(event.commit_oid === undefined ? {} : { commit_oid: event.commit_oid }),
+            ...(event.meta === undefined ? {} : { meta: event.meta }),
+            now: input.now,
+        });
+    }
+}
+export function recordRunPipelineResult(input) {
+    if (input.pipelineResult.result_kind === "needs_human") {
+        const { timeline_events: timelineEvents, ...pipelineResult } = input.pipelineResult;
+        void timelineEvents;
+        const recorded = recordRunNeedsHumanResult(input.store.db, {
+            activity_ref: input.activityRef,
+            task_id: input.task.id,
+            run_lineage: input.runLineage,
+            result: pipelineResult,
+            now: input.now,
+        });
+        return {
+            recorded,
+            terminal: {
+                kind: "needs_human",
+                summary: pipelineResult.summary,
+            },
+        };
+    }
+    const { timeline_events: timelineEvents, ...pipelineResult } = input.pipelineResult;
+    void timelineEvents;
+    const recorded = recordRunResult(input.store.db, {
+        activity_ref: input.activityRef,
+        task_id: input.task.id,
+        run_lineage: input.runLineage,
+        result: pipelineResult,
+        now: input.now,
+    });
+    return {
+        recorded,
+        terminal: {
+            kind: pipelineResult.result_kind === "finished" && pipelineResult.outcome === "completed"
+                ? "completed"
+                : "failed",
+            summary: pipelineResult.summary,
+        },
+    };
+}
+export function recordRunPipelineFailure(input) {
+    const summary = input.error instanceof Error ? input.error.message : "Run failed";
+    const recorded = recordRunResult(input.store.db, {
+        activity_ref: input.activityRef,
+        task_id: input.task.id,
+        run_lineage: input.runLineage,
+        result: {
+            result_kind: "failed",
+            summary,
+            error_code: "run_pipeline_failed",
+            retryable: false,
+            promotion: {
+                status: "not_attempted",
+                summary: "Run failed before promotion.",
+            },
+        },
+        now: input.now,
+    });
+    return {
+        recorded,
+        terminal: {
+            kind: "failed",
+            summary,
+        },
+    };
+}
+//# sourceMappingURL=run-result-recording.js.map

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

@@ -0,0 +1,35 @@
+import { type ActivityRef } from "@tutti/shared/ids";
+import type { RunSchedulerNowDisposition, RunSchedulerNowPayload, ProcedureLane } from "@tutti/shared/schemas/api";
+import type { StartRunResult } from "../run-engine/index.js";
+import type { HostProjectStore } from "../store/index.js";
+import type { ControlPlaneCommandResult, RunPipelineResolver } from "./types.js";
+import type { StartRunForTaskInput } from "./run-start.js";
+type ActiveActivity = {
+    activity_ref: ActivityRef;
+    activity_kind: "run" | "procedure";
+    lane?: ProcedureLane;
+};
+type StartRunForTask = (input: StartRunForTaskInput) => StartRunResult;
+export declare function runControlPlaneSchedulerNow(input: {
+    store: HostProjectStore;
+    payload: RunSchedulerNowPayload;
+    resolveRunPipeline: RunPipelineResolver | undefined;
+    readMainlineStatus: (() => {
+        mainline_clean: boolean;
+    }) | undefined;
+    readSchedulerBlocker: () => ActiveActivity | null;
+    startRunForTask: StartRunForTask;
+    now: () => Date;
+}): ControlPlaneCommandResult<RunSchedulerNowDisposition, never>;
+export declare function runControlPlaneSchedulerForTaskArrival(input: {
+    store: HostProjectStore;
+    resolveRunPipeline: RunPipelineResolver | undefined;
+    readMainlineStatus: (() => {
+        mainline_clean: boolean;
+    }) | undefined;
+    readSchedulerBlocker: () => ActiveActivity | null;
+    startRunForTask: StartRunForTask;
+    now: () => Date;
+}): ControlPlaneCommandResult<RunSchedulerNowDisposition, never>;
+export {};
+//# sourceMappingURL=run-scheduler.d.ts.map

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

@@ -0,0 +1,110 @@
+import { createActivityRef, } from "@tutti/shared/ids";
+import { markTaskRunStarted, readActiveClarificationProjection, readNextRunnableTask, readTaskDetailProjection, } from "../collaboration-state/index.js";
+function runControlPlaneScheduler(input) {
+    const activeActivity = input.readSchedulerBlocker();
+    if (activeActivity !== null) {
+        return {
+            disposition: {
+                kind: "already_running",
+                activity_ref: activeActivity.activity_ref,
+                activity_kind: activeActivity.activity_kind,
+            },
+        };
+    }
+    const activeClarification = readActiveClarificationProjection(input.store.db);
+    if (activeClarification.state === "active") {
+        return {
+            disposition: {
+                kind: "blocked_by_clarification",
+                thread_id: activeClarification.thread.id,
+                round_id: activeClarification.round.id,
+            },
+        };
+    }
+    const pipelineResolution = input.resolveRunPipeline?.() ??
+        {
+            kind: "unavailable",
+            reason: "provider_model_unavailable",
+            retryable: false,
+        };
+    if (pipelineResolution.kind === "not_configured") {
+        return { disposition: { kind: "provider_not_configured" } };
+    }
+    if (pipelineResolution.kind === "unavailable") {
+        return {
+            disposition: {
+                kind: "provider_unavailable",
+                reason: pipelineResolution.reason,
+                retryable: pipelineResolution.retryable,
+            },
+        };
+    }
+    if (input.readMainlineStatus !== undefined && !input.readMainlineStatus().mainline_clean) {
+        return { disposition: { kind: "mainline_not_clean" } };
+    }
+    const next = readNextRunnableTask(input.store.db);
+    if (next.kind === "none") {
+        return { disposition: { kind: "nothing_to_run" } };
+    }
+    const nextTaskId = next.task.id;
+    const taskDetail = readTaskDetailProjection(input.store.db, nextTaskId);
+    if (taskDetail === null) {
+        return { disposition: { kind: "nothing_to_run" } };
+    }
+    const activityRef = createActivityRef();
+    const started = markTaskRunStarted(input.store.db, {
+        task_id: nextTaskId,
+        activity_ref: activityRef,
+        now: input.now,
+    });
+    if (started.kind !== "started") {
+        return { disposition: { kind: "nothing_to_run" } };
+    }
+    const runLineage = { attempt: 1, kind: "initial" };
+    const dispatchContext = {
+        trigger: input.trigger,
+        queue_scope: { kind: "worklist" },
+        current_task_id: started.task.id,
+        ordered_task_refs: next.queued_task_ids,
+        current_module_id: started.task.module_id,
+    };
+    const start = input.startRunForTask({
+        activity_ref: activityRef,
+        task: started.task,
+        task_detail: taskDetail,
+        run_lineage: runLineage,
+        dispatch_context: dispatchContext,
+        runner: pipelineResolution.runner,
+    });
+    if (start.kind === "already_running") {
+        return {
+            disposition: {
+                kind: "already_running",
+                activity_ref: start.activity_ref,
+                activity_kind: "run",
+            },
+        };
+    }
+    return {
+        disposition: {
+            kind: "scheduled",
+            task_id: started.task.id,
+            activity_ref: activityRef,
+            queued_task_ids: next.queued_task_ids,
+        },
+    };
+}
+export function runControlPlaneSchedulerNow(input) {
+    void input.payload;
+    return runControlPlaneScheduler({
+        ...input,
+        trigger: "manual_run_now",
+    });
+}
+export function runControlPlaneSchedulerForTaskArrival(input) {
+    return runControlPlaneScheduler({
+        ...input,
+        trigger: "task_arrival",
+    });
+}
+//# sourceMappingURL=run-scheduler.js.map

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

@@ -0,0 +1,30 @@
+import type { RunLineage } from "@tutti/shared/domain";
+import type { ActivityRef } from "@tutti/shared/ids";
+import type { TaskDetailProjection, TaskProjection } from "@tutti/shared/schemas/api";
+import type { RunEngine, RunEngineState, StartRunResult } from "../run-engine/index.js";
+import type { HostProjectStore } from "../store/index.js";
+import { recordRunPipelineResult } from "./run-result-recording.js";
+import type { ControlPlaneLogger, Phase5ControlPlaneOptions, RunContinuationContext, RunDispatchContext, RunPipelineRunner } from "./types.js";
+export type StartRunForTaskInput = {
+    activity_ref: ActivityRef;
+    task: TaskProjection;
+    task_detail: TaskDetailProjection;
+    run_lineage: RunLineage;
+    dispatch_context: RunDispatchContext;
+    continuation_context?: RunContinuationContext;
+    runner: RunPipelineRunner;
+};
+export type RunResultRecordedPublisher = (recorded: ReturnType<typeof recordRunPipelineResult>["recorded"]) => void;
+export declare function startControlPlaneRunForTask(input: {
+    runEngine: RunEngine;
+    store: HostProjectStore;
+    run: StartRunForTaskInput;
+    projectContext: Phase5ControlPlaneOptions["projectContext"] | undefined;
+    resolveWorkflowRunner: Phase5ControlPlaneOptions["resolveWorkflowRunner"];
+    logger?: ControlPlaneLogger | undefined;
+    now: () => Date;
+    publishRunTransition: (state: RunEngineState) => void;
+    publishTaskRunStarted: (task: TaskProjection, activityRef: ActivityRef) => void;
+    publishRunResultRecorded: RunResultRecordedPublisher;
+}): StartRunResult;
+//# sourceMappingURL=run-start.d.ts.map

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

@@ -0,0 +1,167 @@
+import { recordRunPipelineFailure, recordRunPipelineResult, recordRunPipelineTimelineEvents, } from "./run-result-recording.js";
+import { projectBriefShouldRefreshForUpdatedPaths, refreshProjectBriefProjection, } from "./project-brief-refresh.js";
+function runLineageFields(lineage) {
+    return {
+        run_lineage_kind: lineage.kind,
+        run_lineage_attempt: lineage.attempt,
+        ...(lineage.kind === "continuation"
+            ? {
+                parent_activity_ref: lineage.parent_activity_ref,
+                root_activity_ref: lineage.root_activity_ref,
+            }
+            : {}),
+    };
+}
+function runLifecycleFields(input) {
+    return {
+        activity_ref: input.activity_ref,
+        task_id: input.task.id,
+        trigger: input.dispatch_context.trigger,
+        ...runLineageFields(input.run_lineage),
+    };
+}
+function pipelineResultFields(result) {
+    if (result.result_kind === "finished") {
+        return {
+            result_kind: result.result_kind,
+            outcome: result.outcome,
+            checks: result.checks,
+            docs: result.docs,
+            changed_path_count: result.changed_paths?.length ?? 0,
+            promotion_status: result.promotion?.status,
+        };
+    }
+    if (result.result_kind === "failed") {
+        return {
+            result_kind: result.result_kind,
+            error_code: result.error_code,
+            retryable: result.retryable,
+            changed_path_count: result.changed_paths?.length ?? 0,
+            promotion_status: result.promotion?.status,
+        };
+    }
+    return {
+        result_kind: result.result_kind,
+        changed_path_count: result.changed_paths?.length ?? 0,
+    };
+}
+function elapsedMs(startedAt, now) {
+    return Math.max(0, now().getTime() - startedAt.getTime());
+}
+function errorCodeFields(error) {
+    if (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        typeof error.code === "string") {
+        return { error_code: error.code };
+    }
+    return {};
+}
+function runStageSummary(input, progress) {
+    return `Running task: ${input.task.title} - ${progress.summary}`;
+}
+function shouldRefreshProjectBriefAfterRun(result) {
+    return (result.result_kind === "finished" &&
+        result.promotion?.status === "promoted" &&
+        projectBriefShouldRefreshForUpdatedPaths(result.changed_paths ?? []));
+}
+export function startControlPlaneRunForTask(input) {
+    const lifecycleFields = runLifecycleFields(input.run);
+    const start = input.runEngine.startRun({
+        activity_ref: input.run.activity_ref,
+        task: input.run.task,
+        run_lineage: input.run.run_lineage,
+        title: input.run.task.title,
+        summary: `Running task: ${input.run.task.title}`,
+        now: input.now,
+        onTransition: input.publishRunTransition,
+        execute: async (context) => {
+            const pipelineStartedAt = input.now();
+            input.logger?.info(lifecycleFields, "Run pipeline started");
+            try {
+                const pipelineResult = await input.run.runner.runTask({
+                    activity_ref: context.activity_ref,
+                    task: input.run.task,
+                    task_detail: input.run.task_detail,
+                    run_lineage: input.run.run_lineage,
+                    dispatch_context: input.run.dispatch_context,
+                    ...(input.run.continuation_context === undefined
+                        ? {}
+                        : { continuation_context: input.run.continuation_context }),
+                    on_stage: (progress) => context.reportProgress({
+                        phase: progress.stage,
+                        summary: runStageSummary(input.run, progress),
+                    }),
+                });
+                const resultRecord = recordRunPipelineResult({
+                    store: input.store,
+                    activityRef: context.activity_ref,
+                    task: input.run.task,
+                    runLineage: input.run.run_lineage,
+                    pipelineResult,
+                    now: input.now,
+                });
+                recordRunPipelineTimelineEvents({
+                    store: input.store,
+                    activityRef: context.activity_ref,
+                    taskId: input.run.task.id,
+                    timelineEvents: pipelineResult.timeline_events,
+                    now: input.now,
+                });
+                input.publishRunResultRecorded(resultRecord.recorded);
+                if (shouldRefreshProjectBriefAfterRun(pipelineResult)) {
+                    void refreshProjectBriefProjection({
+                        store: input.store,
+                        projectContext: input.projectContext,
+                        reason: "task_run_promotion",
+                        resolveWorkflowRunner: input.resolveWorkflowRunner,
+                        activityRef: context.activity_ref,
+                        logger: input.logger,
+                        now: input.now,
+                    }).catch((error) => {
+                        input.logger?.info({
+                            ...lifecycleFields,
+                            error_name: error instanceof Error ? error.name : "NonError",
+                        }, "Project brief refresh dispatch failed");
+                    });
+                }
+                input.logger?.info({
+                    ...lifecycleFields,
+                    duration_ms: elapsedMs(pipelineStartedAt, input.now),
+                    ...pipelineResultFields(pipelineResult),
+                }, "Run pipeline completed");
+                return resultRecord.terminal;
+            }
+            catch (error) {
+                const resultRecord = recordRunPipelineFailure({
+                    store: input.store,
+                    activityRef: context.activity_ref,
+                    task: input.run.task,
+                    runLineage: input.run.run_lineage,
+                    error,
+                    now: input.now,
+                });
+                input.publishRunResultRecorded(resultRecord.recorded);
+                input.logger?.info({
+                    ...lifecycleFields,
+                    duration_ms: elapsedMs(pipelineStartedAt, input.now),
+                    error_name: error instanceof Error ? error.name : "NonError",
+                    ...errorCodeFields(error),
+                }, "Run pipeline failed");
+                return resultRecord.terminal;
+            }
+        },
+    });
+    if (start.kind === "accepted") {
+        input.logger?.info(lifecycleFields, "Run accepted");
+        input.publishTaskRunStarted(input.run.task, input.run.activity_ref);
+    }
+    else {
+        input.logger?.info({
+            ...lifecycleFields,
+            active_activity_ref: start.activity_ref,
+        }, "Run start skipped because another Run is active");
+    }
+    return start;
+}
+//# sourceMappingURL=run-start.js.map

package/dist/control-plane/scratchpad-auto-refresh.d.ts

@@ -0,0 +1,32 @@
+import type { ActivityRef } from "@tutti/shared/ids";
+import type { RefreshScratchpadDisposition, RefreshScratchpadResult } from "@tutti/shared/schemas/api";
+import type { HostProjectStore } from "../store/index.js";
+import type { ControlPlaneCommandResult } from "./types.js";
+type ActiveActivity = {
+    activity_ref: ActivityRef;
+    activity_kind: "run" | "procedure";
+} | null;
+type ScratchpadAutoRefreshSchedulerOptions = {
+    store: HostProjectStore;
+    now: () => Date;
+    readScratchpadRefreshBlocker: () => ActiveActivity;
+    startScratchpadRefresh: () => ControlPlaneCommandResult<RefreshScratchpadDisposition, RefreshScratchpadResult>;
+};
+export declare class ScratchpadAutoRefreshScheduler {
+    private readonly options;
+    private timer;
+    private debounceStartedAt;
+    private latestSourceAt;
+    private disposed;
+    constructor(options: ScratchpadAutoRefreshSchedulerOptions);
+    dispose(): void;
+    private canUseStore;
+    notifySourceChanged(): void;
+    notifyActivityChanged(): void;
+    private scheduleNextAttempt;
+    private attemptRefresh;
+    private setTimer;
+    private clearTimer;
+}
+export {};
+//# sourceMappingURL=scratchpad-auto-refresh.d.ts.map

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

@@ -0,0 +1,150 @@
+import { markScratchpadRefreshFailed, markScratchpadRefreshSucceeded, markScratchpadSourceDirty, readScratchpadSourceState, } from "../collaboration-state/index.js";
+import { readControlPlaneScratchpadSourceBatch } from "./scratchpad-refresh-start.js";
+const SCRATCHPAD_AUTO_REFRESH_DEBOUNCE_MS = 8_000;
+const SCRATCHPAD_AUTO_REFRESH_MAX_WAIT_MS = 45_000;
+const SCRATCHPAD_AUTO_REFRESH_COOLDOWN_MS = 20_000;
+const SCRATCHPAD_AUTO_REFRESH_FAILURE_BACKOFF_MS = 60_000;
+function addMilliseconds(date, milliseconds) {
+    return new Date(date.getTime() + milliseconds);
+}
+function millisecondsUntil(now, isoDate) {
+    return Math.max(0, new Date(isoDate).getTime() - now.getTime());
+}
+function laterIso(left, right) {
+    if (left === undefined) {
+        return right;
+    }
+    return new Date(left).getTime() > new Date(right).getTime() ? left : right;
+}
+export class ScratchpadAutoRefreshScheduler {
+    options;
+    timer = null;
+    debounceStartedAt = null;
+    latestSourceAt = null;
+    disposed = false;
+    constructor(options) {
+        this.options = options;
+    }
+    dispose() {
+        this.disposed = true;
+        this.clearTimer();
+    }
+    canUseStore() {
+        if (!this.options.store.db.open) {
+            this.dispose();
+            return false;
+        }
+        return true;
+    }
+    notifySourceChanged() {
+        if (this.disposed || !this.canUseStore()) {
+            return;
+        }
+        const now = this.options.now();
+        const nowIso = now.toISOString();
+        markScratchpadSourceDirty(this.options.store.db, { now: () => now });
+        this.debounceStartedAt ??= nowIso;
+        this.latestSourceAt = nowIso;
+        this.scheduleNextAttempt();
+    }
+    notifyActivityChanged() {
+        if (this.disposed) {
+            return;
+        }
+        this.scheduleNextAttempt();
+    }
+    scheduleNextAttempt() {
+        if (this.disposed) {
+            this.clearTimer();
+            return;
+        }
+        if (!this.canUseStore()) {
+            return;
+        }
+        const state = readScratchpadSourceState(this.options.store.db);
+        if (state.dirty_since === undefined) {
+            this.clearTimer();
+            this.debounceStartedAt = null;
+            this.latestSourceAt = null;
+            return;
+        }
+        if (state.in_flight !== undefined) {
+            this.clearTimer();
+            return;
+        }
+        const now = this.options.now();
+        const debounceStart = this.debounceStartedAt ?? state.dirty_since;
+        const latestSource = this.latestSourceAt ?? state.dirty_since;
+        const quietDue = addMilliseconds(new Date(latestSource), SCRATCHPAD_AUTO_REFRESH_DEBOUNCE_MS).toISOString();
+        const maxWaitDue = addMilliseconds(new Date(debounceStart), SCRATCHPAD_AUTO_REFRESH_MAX_WAIT_MS).toISOString();
+        const debounceDue = new Date(quietDue).getTime() < new Date(maxWaitDue).getTime() ? quietDue : maxWaitDue;
+        const cooldownDue = state.last_completed_at === undefined
+            ? debounceDue
+            : addMilliseconds(new Date(state.last_completed_at), SCRATCHPAD_AUTO_REFRESH_COOLDOWN_MS).toISOString();
+        const dueAt = laterIso(laterIso(debounceDue, cooldownDue), state.backoff_until ?? debounceDue);
+        this.setTimer(millisecondsUntil(now, dueAt));
+    }
+    attemptRefresh() {
+        this.timer = null;
+        if (this.disposed) {
+            return;
+        }
+        if (!this.canUseStore()) {
+            return;
+        }
+        const state = readScratchpadSourceState(this.options.store.db);
+        if (state.dirty_since === undefined) {
+            this.debounceStartedAt = null;
+            this.latestSourceAt = null;
+            return;
+        }
+        if (state.in_flight !== undefined) {
+            return;
+        }
+        const now = this.options.now();
+        if (state.backoff_until !== undefined &&
+            new Date(state.backoff_until).getTime() > now.getTime()) {
+            this.scheduleNextAttempt();
+            return;
+        }
+        if (this.options.readScratchpadRefreshBlocker() !== null) {
+            return;
+        }
+        const sourceBatch = readControlPlaneScratchpadSourceBatch(this.options.store);
+        if (sourceBatch.source_message_count === 0) {
+            markScratchpadRefreshSucceeded(this.options.store.db, { now: this.options.now });
+            this.scheduleNextAttempt();
+            return;
+        }
+        const result = this.options.startScratchpadRefresh();
+        if (result.disposition.kind === "accepted" || result.disposition.kind === "already_running") {
+            this.clearTimer();
+            this.debounceStartedAt = null;
+            this.latestSourceAt = null;
+            return;
+        }
+        if (result.disposition.kind === "no_source_messages") {
+            markScratchpadRefreshSucceeded(this.options.store.db, { now: this.options.now });
+            this.scheduleNextAttempt();
+            return;
+        }
+        markScratchpadRefreshFailed(this.options.store.db, {
+            backoffUntil: addMilliseconds(now, SCRATCHPAD_AUTO_REFRESH_FAILURE_BACKOFF_MS).toISOString(),
+            now: this.options.now,
+        });
+        this.scheduleNextAttempt();
+    }
+    setTimer(delayMs) {
+        this.clearTimer();
+        this.timer = setTimeout(() => this.attemptRefresh(), delayMs);
+        this.timer.unref?.();
+    }
+    clearTimer() {
+        if (this.timer === null) {
+            return;
+        }
+        clearTimeout(this.timer);
+        this.timer = null;
+    }
+}
+//# sourceMappingURL=scratchpad-auto-refresh.js.map

package/dist/control-plane/scratchpad-refresh-start.d.ts

@@ -0,0 +1,60 @@
+import { createWorkflowInvocationRef, type ActivityRef } from "@tutti/shared/ids";
+import type { RefreshScratchpadDisposition, RefreshScratchpadResult, ProcedureLane } from "@tutti/shared/schemas/api";
+import type { ScratchpadSourceCursorUpdate } from "../collaboration-state/scratchpad-source-state.js";
+import type { ProcedureEngine, ProcedureEngineState } from "../procedure-engine/index.js";
+import type { HostProjectStore } from "../store/index.js";
+import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
+import type { ControlPlaneCommandResult, ControlPlaneLogger } from "./types.js";
+import type { ProcedureWorkflowRunner, ProcedureWorkflowRunnerResolver } from "./workflows/index.js";
+type ScratchpadProjectContext = {
+    workspaceRoot: string;
+};
+export type ScratchpadSourceBatch = {
+    workflow_input: Parameters<ProcedureWorkflowRunner["runScratchpadRefresh"]>[0];
+    cursor_update: ScratchpadSourceCursorUpdate;
+    source_message_count: number;
+};
+export declare function readControlPlaneScratchpadSourceBatch(store: HostProjectStore, options?: {
+    projectContext?: ScratchpadProjectContext | undefined;
+    now?: () => Date;
+}): ScratchpadSourceBatch;
+export declare function runControlPlaneScratchpadRefreshProcedure(options: {
+    runner: ProcedureWorkflowRunner;
+    workflowRef: ReturnType<typeof createWorkflowInvocationRef>;
+    activityRef: ActivityRef;
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    sourceBatch: ScratchpadSourceBatch;
+    now: () => Date;
+}): Promise<{
+    kind: "needs_human";
+    summary: string;
+    result_anchor: {
+        kind: "workflow";
+        workflow_ref: `wf_${string}`;
+    };
+} | {
+    kind: "completed";
+    summary: string;
+    result_anchor: {
+        kind: "workflow";
+        workflow_ref: `wf_${string}`;
+    };
+}>;
+export declare function readActiveScratchpadRefreshActivityRef(options: {
+    engine: ProcedureEngine;
+    store: HostProjectStore;
+}): ActivityRef | undefined;
+export declare function startControlPlaneScratchpadRefresh(options: {
+    engine: ProcedureEngine;
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    resolveWorkflowRunner: ProcedureWorkflowRunnerResolver;
+    projectContext?: ScratchpadProjectContext | undefined;
+    lane?: ProcedureLane;
+    logger?: ControlPlaneLogger | undefined;
+    now: () => Date;
+    publishProcedureTransition: (state: ProcedureEngineState) => void;
+}): ControlPlaneCommandResult<RefreshScratchpadDisposition, RefreshScratchpadResult>;
+export {};
+//# sourceMappingURL=scratchpad-refresh-start.d.ts.map