@xfey/tutti 0.1.49 → 0.1.51

package/dist/approvals/projections.d.ts

@@ -24,7 +24,6 @@ export type ApprovalProjectionContext = {
     requestedAt: string;
     expiresAt?: string;
     workspaceRoot?: string;
-    runWorkspaceRoot?: string;
     codexHome?: string;
     tuttiHome?: string;
     builtInSkillsRoot?: string;

package/dist/approvals/projections.js

@@ -22,7 +22,6 @@ function underRoot(path, root) {
 }
 function runtimeRoots(context) {
     return [
-        { value: context.runWorkspaceRoot ?? "", label: "run workspace" },
         { value: context.workspaceRoot ?? "", label: "workspace" },
         { value: context.codexHome ?? "", label: "codex home" },
         { value: context.tuttiHome ?? "", label: "tutti home" },

package/dist/artifacts/candidate-validator.js

@@ -1,6 +1,6 @@
 import { lstatSync, readFileSync, realpathSync } from "node:fs";
 import { isAbsolute, join, relative, resolve } from "node:path";
-import { fingerprintWorkspaceCandidate } from "../workspace-ops/index.js";
+import { fingerprintProjectSourceState } from "../workspace-ops/index.js";
 import { ARTIFACT_MANIFEST_PATH, MAX_ARTIFACT_MANIFEST_BYTES, parseArtifactManifestContract, } from "./manifest-contract.js";
 import { allocateArtifactPreviewPort, ArtifactDiagnosticBuffer, cleanupArtifactProcessRuntime, createArtifactPreviewEnv, createArtifactProcessRuntime, spawnArtifactPreviewProcess, terminateArtifactProcessTree, } from "./process-boundary.js";
 const MAX_PACKAGE_JSON_BYTES = 1024 * 1024;
@@ -290,7 +290,7 @@ async function validateServerCandidate(repoRealPath, contract, options) {
             sensitive: { repoRoot: repoRealPath, extra: [cwd.path] },
         });
     }
-    const fingerprint = options.fingerprintCandidate ?? fingerprintWorkspaceCandidate;
+    const fingerprint = options.fingerprintCandidate ?? fingerprintProjectSourceState;
     let beforeFingerprint;
     try {
         beforeFingerprint = fingerprint(repoRealPath);
@@ -299,7 +299,7 @@ async function validateServerCandidate(repoRealPath, contract, options) {
         return failure({
             reasonCode: "artifact_preview_modified_candidate",
             summary: "Tutti could not capture the candidate state before preview validation.",
-            guidance: "Keep the candidate repository in a valid Git worktree and retry.",
+            guidance: "Keep the candidate project directory in a valid Git repository and retry.",
             source: "candidate_diff",
             detail: error instanceof Error ? error.message : "Candidate state capture failed",
             sensitive: { repoRoot: repoRealPath },

package/dist/artifacts/manifest.d.ts

@@ -21,6 +21,7 @@ export type ArtifactDeclaration = {
     status: "declared";
     manifest: ArtifactManifest;
     manifest_blob_oid: string;
+    snapshot_oid: string;
     runtime: DeclaredArtifactRuntime;
     projection: ArtifactDeclaredProjection;
 };
@@ -33,6 +34,7 @@ export declare function buildArtifactPreviewUrl(options: {
     basePath?: string | undefined;
     entryPath: string;
     manifestBlobOid: string;
+    snapshotOid?: string;
 }): string;
 export declare function readArtifactDeclaration(options: ReadArtifactDeclarationOptions): ArtifactDeclaration;
 export declare function readArtifactProjection(options: ReadArtifactDeclarationOptions): GetArtifactsResponse;

package/dist/artifacts/manifest.js

@@ -56,7 +56,11 @@ export function buildArtifactPreviewUrl(options) {
     const basePath = (options.basePath ?? ARTIFACT_PREVIEW_BASE_PATH).replace(/\/+$/u, "");
     const encodedEntryPath = encodePreviewPath(options.entryPath);
     const path = encodedEntryPath.length === 0 ? basePath : `${basePath}/${encodedEntryPath}`;
-    return `${path}?v=${encodeURIComponent(options.manifestBlobOid)}`;
+    const query = new URLSearchParams({ v: options.manifestBlobOid });
+    if (options.snapshotOid !== undefined) {
+        query.set("s", options.snapshotOid);
+    }
+    return `${path}?${query.toString()}`;
 }
 function createDeclaredProjection(options) {
     const artifact = options.manifest.artifact;
@@ -66,6 +70,7 @@ function createDeclaredProjection(options) {
             url: buildArtifactPreviewUrl({
                 entryPath: options.runtime.entry_path,
                 manifestBlobOid: options.manifestBlobOid,
+                snapshotOid: options.snapshotOid,
                 ...(options.previewBasePath === undefined ? {} : { basePath: options.previewBasePath }),
             }),
         }
@@ -113,7 +118,7 @@ function validateCommittedArtifact(options) {
     return runtime;
 }
 export function readArtifactDeclaration(options) {
-    readViewerSnapshot(options);
+    const snapshot = readViewerSnapshot(options);
     const manifestEntry = lsPath(options.workspaceRoot, ARTIFACT_MANIFEST_PATH);
     if (manifestEntry === null) {
         return {
@@ -143,10 +148,12 @@ export function readArtifactDeclaration(options) {
         status: "declared",
         manifest: parsed.declaration.manifest,
         manifest_blob_oid: fileEntry.oid,
+        snapshot_oid: snapshot.head.oid,
         runtime,
         projection: createDeclaredProjection({
             manifest: parsed.declaration.manifest,
             manifestBlobOid: fileEntry.oid,
+            snapshotOid: snapshot.head.oid,
             runtime,
             ...(options.previewBasePath === undefined
                 ? {}

package/dist/artifacts/preview-runtime.js

@@ -49,6 +49,7 @@ function isServerDeclaration(declaration) {
 }
 function serverDeclarationKey(declaration) {
     return [
+        declaration.snapshot_oid,
         declaration.manifest_blob_oid,
         declaration.runtime.cwd_path,
         declaration.runtime.entry_path,

package/dist/collaboration-state/index.d.ts

@@ -9,7 +9,7 @@ export { openNextTaskBoundClarificationRound, openNextTaskCompileClarificationRo
 export { closeTaskBoundClarificationAsRetaskingRequired, materializeClarificationSuccessor, materializeTaskBoundRunSuccessor, submitClarificationRound, } from "./clarification-successors.js";
 export { readRecoverySummariesPage, readRecoverySummaryProjection, readRunResultProjectionByActivityRef, readTaskRunResultsPage, recordRecoverySummary, } from "./run-results.js";
 export { recordRunNeedsHumanResult, recordRunResult } from "./run-recording.js";
-export { recoverStaleRunningTasksAsFailed } from "./recovery.js";
+export { readStaleRunningTaskIdentities, recoverStaleRunningTasksAsFailed, } from "./recovery.js";
 export { markReadStateScope, readReadStateSummary, recordReadNotificationEvent, } from "./read-state.js";
 export { readTaskDetailProjection } from "./task-details.js";
 export { applyTaskCompileProposal, markTaskRunStarted, readNextRunnableTask, readRecoverableScheduledRun, readCompiledTaskSummariesByWorkflowRef, readTaskProjection, readWorklistProjection, } from "./worklist.js";

package/dist/collaboration-state/index.js

@@ -9,7 +9,7 @@ export { openNextTaskBoundClarificationRound, openNextTaskCompileClarificationRo
 export { closeTaskBoundClarificationAsRetaskingRequired, materializeClarificationSuccessor, materializeTaskBoundRunSuccessor, submitClarificationRound, } from "./clarification-successors.js";
 export { readRecoverySummariesPage, readRecoverySummaryProjection, readRunResultProjectionByActivityRef, readTaskRunResultsPage, recordRecoverySummary, } from "./run-results.js";
 export { recordRunNeedsHumanResult, recordRunResult } from "./run-recording.js";
-export { recoverStaleRunningTasksAsFailed } from "./recovery.js";
+export { readStaleRunningTaskIdentities, recoverStaleRunningTasksAsFailed, } from "./recovery.js";
 export { markReadStateScope, readReadStateSummary, recordReadNotificationEvent, } from "./read-state.js";
 export { readTaskDetailProjection } from "./task-details.js";
 export { applyTaskCompileProposal, markTaskRunStarted, readNextRunnableTask, readRecoverableScheduledRun, readCompiledTaskSummariesByWorkflowRef, readTaskProjection, readWorklistProjection, } from "./worklist.js";

package/dist/collaboration-state/recovery.d.ts

@@ -1,5 +1,6 @@
 import { type SqliteDatabase } from "../store/index.js";
-import type { RecoverStaleRunningTasksResult } from "./types.js";
+import type { RecoverStaleRunningTasksResult, StaleRunningTaskIdentity } from "./types.js";
+export declare function readStaleRunningTaskIdentities(db: SqliteDatabase): StaleRunningTaskIdentity[];
 export declare function recoverStaleRunningTasksAsFailed(db: SqliteDatabase, input?: {
     now?: () => Date;
 }): RecoverStaleRunningTasksResult;

package/dist/collaboration-state/recovery.js

@@ -27,6 +27,22 @@ function inferRecoveryRunLineage(tx, taskRow) {
         root_activity_ref: parentLineage.root_activity_ref ?? latestRunResult.activity_ref,
     };
 }
+export function readStaleRunningTaskIdentities(db) {
+    const staleTasks = db
+        .prepare(`
+        SELECT *
+        FROM tasks
+        WHERE status = 'running'
+          AND current_activity_ref IS NOT NULL
+        ORDER BY updated_at ASC, id ASC
+      `)
+        .all();
+    return staleTasks.map((taskRow) => ({
+        task_id: taskRow.id,
+        activity_ref: taskRow.current_activity_ref,
+        run_lineage: inferRecoveryRunLineage(db, taskRow),
+    }));
+}
 export function recoverStaleRunningTasksAsFailed(db, input = {}) {
     return withHostStoreTransaction(db, (tx) => {
         const recoveredAt = nowIso(input.now);

package/dist/collaboration-state/types.d.ts

@@ -176,6 +176,11 @@ export type RecoverStaleRunningTasksResult = {
         task_detail: TaskDetailProjection;
     }>;
 };
+export type StaleRunningTaskIdentity = {
+    task_id: TaskId;
+    activity_ref: ActivityRef;
+    run_lineage: RunLineage;
+};
 export type RecordRecoverySummaryInput = {
     summary: string;
     affected_activities: ActivityRef[];

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

@@ -8,9 +8,6 @@ export function startRunFromFollowUp(input) {
     if (pipelineResolution === undefined || pipelineResolution.kind !== "ready") {
         return;
     }
-    if (input.readMainlineStatus !== undefined && !input.readMainlineStatus().mainline_clean) {
-        return;
-    }
     const latestRunResult = readTaskRunResultsPage(input.store.db, input.taskId, {
         limit: 1,
     })?.items[0];

package/dist/control-plane/formatters.d.ts

@@ -1,12 +1,10 @@
 import type { ActivityProjection } from "@tutti/shared/schemas/api";
 export declare function defaultProcedureFailureSystemMessage(activity: ActivityProjection): string;
 export declare function formatStartupRecoverySummary(input: {
-    recoveredRunCount: number;
+    interruptedRunCount: number;
+    acceptedCheckpointRunCount: number;
     replayedRoundCount: number;
     interruptedCommandCount: number;
-    removedRunWorkspaceCount: number;
-    removedTempBranchCount: number;
-    cleanupWarningCount: number;
     staleReplayHintCount: number;
 }): string;
 //# sourceMappingURL=formatters.d.ts.map

package/dist/control-plane/formatters.js

@@ -19,8 +19,11 @@ function countNoun(count, singular, plural = `${singular}s`) {
 }
 export function formatStartupRecoverySummary(input) {
     const parts = [];
-    if (input.recoveredRunCount > 0) {
-        parts.push(`${countNoun(input.recoveredRunCount, "stale Run")} marked failed`);
+    if (input.acceptedCheckpointRunCount > 0) {
+        parts.push(`${countNoun(input.acceptedCheckpointRunCount, "accepted Run checkpoint")} restored`);
+    }
+    if (input.interruptedRunCount > 0) {
+        parts.push(`${countNoun(input.interruptedRunCount, "stale Run")} marked failed`);
     }
     if (input.replayedRoundCount > 0) {
         parts.push(`${countNoun(input.replayedRoundCount, "sealed clarification round")} replayed`);
@@ -28,18 +31,9 @@ export function formatStartupRecoverySummary(input) {
     if (input.interruptedCommandCount > 0) {
         parts.push(`${countNoun(input.interruptedCommandCount, "in-progress command")} interrupted`);
     }
-    if (input.removedRunWorkspaceCount > 0) {
-        parts.push(`${countNoun(input.removedRunWorkspaceCount, "stale run workspace")} removed`);
-    }
-    if (input.removedTempBranchCount > 0) {
-        parts.push(`${countNoun(input.removedTempBranchCount, "stale run branch", "stale run branches")} removed`);
-    }
     if (input.staleReplayHintCount > 0) {
         parts.push(`${countNoun(input.staleReplayHintCount, "stale replay hint")} cleared`);
     }
-    if (input.cleanupWarningCount > 0) {
-        parts.push(`${countNoun(input.cleanupWarningCount, "cleanup warning")} recorded`);
-    }
     return parts.length === 0
         ? "Startup recovery completed."
         : `Startup recovery completed: ${parts.join("; ")}.`;

package/dist/control-plane/index.d.ts

@@ -3,7 +3,7 @@ import type { ExecutionStatusProjection, ContextSyncDisposition, ContextSyncResu
 import type { ContextSyncWorkflowTrigger } from "./workflows/index.js";
 import type { ControlPlaneCommandResult, Phase5ControlPlaneOptions, StartupRecoveryOptions, StartupRecoveryResult, TrustedHumanAuthor } from "./types.js";
 import { type ProjectBriefRefreshReason, type RefreshProjectBriefProjectionResult } from "./project-brief-refresh.js";
-export type { ControlPlaneCommandResult, ControlPlaneLogger, Phase5ControlPlaneOptions, RunCorrectionContext, RunContinuationContext, RunDispatchContext, RunDispatchTrigger, RunPipelineInput, RunPipelineResolution, RunPipelineResolver, RunPipelineResult, RunPipelineRunner, RunPipelineTimelineEvent, StartupRecoveryOptions, StartupRecoveryResult, TrustedHumanAuthor, } from "./types.js";
+export type { ControlPlaneCommandResult, ControlPlaneLogger, Phase5ControlPlaneOptions, RunCorrectionContext, RunContinuationContext, RunDispatchContext, RunDispatchTrigger, RunPipelineInput, RunPipelineResolution, RunPipelineResolver, RunPipelineResult, RunPipelineRunner, StartupRecoveryOptions, StartupRecoveryResult, TrustedHumanAuthor, } from "./types.js";
 export declare class Phase5ControlPlane {
     private readonly engine;
     private readonly runEngine;

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

@@ -1,9 +1,9 @@
 import type { RunLineage } from "@tutti/shared/domain";
-import type { ActivityRef, TaskId } from "@tutti/shared/ids";
+import type { ActivityRef } 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";
+import type { RunPipelineResult } from "./types.js";
 type RecordedRunResult = RecordRunResultResult | RecordRunNeedsHumanResultResult;
 type RunEngineTerminalResult = {
     kind: "needs_human";
@@ -19,13 +19,6 @@ 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;

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

@@ -1,54 +1,36 @@
 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,
+            result: input.pipelineResult,
             now: input.now,
         });
         return {
             recorded,
             terminal: {
                 kind: "needs_human",
-                summary: pipelineResult.summary,
+                summary: input.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,
+        result: input.pipelineResult,
         now: input.now,
     });
     return {
         recorded,
         terminal: {
-            kind: pipelineResult.result_kind === "finished" && pipelineResult.outcome === "completed"
+            kind: input.pipelineResult.result_kind === "finished" &&
+                input.pipelineResult.outcome === "completed"
                 ? "completed"
                 : "failed",
-            summary: pipelineResult.summary,
+            summary: input.pipelineResult.summary,
         },
     };
 }

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

@@ -39,9 +39,6 @@ function runControlPlaneScheduler(input) {
             },
         };
     }
-    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" } };

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

@@ -1,4 +1,4 @@
-import { recordRunPipelineFailure, recordRunPipelineResult, recordRunPipelineTimelineEvents, } from "./run-result-recording.js";
+import { recordRunPipelineFailure, recordRunPipelineResult, } from "./run-result-recording.js";
 import { projectBriefShouldRefreshForUpdatedPaths, refreshProjectBriefProjection, } from "./project-brief-refresh.js";
 function runLineageFields(lineage) {
     return {
@@ -102,13 +102,6 @@ export function startControlPlaneRunForTask(input) {
                     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({

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

@@ -2,7 +2,7 @@ import type { ClarificationRoundRef } from "@tutti/shared/ids";
 import type { ExecutionStatusProjection } from "@tutti/shared/schemas/api";
 import { type SealedClarificationRoundWithoutSuccessor } from "../collaboration-state/index.js";
 import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
-import type { HostProjectStore } from "../store/index.js";
+import { type HostProjectStore } from "../store/index.js";
 import type { StartupRecoveryOptions, StartupRecoveryResult } from "./types.js";
 type LastRecoveryConclusion = NonNullable<ExecutionStatusProjection["last_conclusion"]>;
 export type StartupRecoveryReplaySealedRound = (sealed: SealedClarificationRoundWithoutSuccessor, roundId: ClarificationRoundRef) => boolean;

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

@@ -1,15 +1,89 @@
-import { deleteStaleClarificationSubmitReplayHints, readSealedClarificationRoundsWithoutSuccessor, recoverStaleRunningTasksAsFailed, recordRecoverySummary, } from "../collaboration-state/index.js";
+import { deleteStaleClarificationSubmitReplayHints, readStaleRunningTaskIdentities, readSealedClarificationRoundsWithoutSuccessor, recoverStaleRunningTasksAsFailed, recordRunResult, recordRecoverySummary, } from "../collaboration-state/index.js";
+import { docsStatusForChangedPaths } from "../run-pipeline/result-projections.js";
+import { recoverInProgressCommandIdempotencyRecords, } from "../store/index.js";
+import { recoverAcceptedCheckpoint } from "../workspace-ops/index.js";
+import { resolveControlPlaneCommandRecovery } from "./command-recovery.js";
 import { formatStartupRecoverySummary } from "./formatters.js";
-import { EXECUTION_STATUS_INVALIDATES, STARTUP_RECOVERY_INVALIDATES, taskRunInvalidates, } from "./invalidations.js";
+import { EXECUTION_STATUS_INVALIDATES, STARTUP_RECOVERY_INVALIDATES, taskRunResultInvalidates, } from "./invalidations.js";
 export function runControlPlaneStartupRecovery(input) {
     const options = input.options ?? {};
-    const cleanup = options.cleanupStaleRunWorkspaces?.() ?? {
-        removed_run_workspace_count: 0,
-        removed_temp_branch_count: 0,
-        warnings: [],
-    };
     const staleReplayHintCount = deleteStaleClarificationSubmitReplayHints(input.store.db);
-    const recovered = recoverStaleRunningTasksAsFailed(input.store.db, { now: input.now });
+    const checkpointRecoveredRuns = [];
+    const checkpointConflictRuns = [];
+    if (options.workspaceRoot !== undefined) {
+        for (const staleRun of readStaleRunningTaskIdentities(input.store.db)) {
+            let checkpoint;
+            try {
+                checkpoint = recoverAcceptedCheckpoint({
+                    workspaceRoot: options.workspaceRoot,
+                    taskId: staleRun.task_id,
+                    activityRef: staleRun.activity_ref,
+                });
+            }
+            catch {
+                const recorded = recordRunResult(input.store.db, {
+                    activity_ref: staleRun.activity_ref,
+                    task_id: staleRun.task_id,
+                    run_lineage: staleRun.run_lineage,
+                    result: {
+                        result_kind: "failed",
+                        summary: "Run checkpoint evidence conflicted with Git truth during startup recovery.",
+                        error_code: "accepted_checkpoint_recovery_conflict",
+                        retryable: false,
+                        promotion: {
+                            status: "not_promoted",
+                            reason_code: "accepted_checkpoint_recovery_conflict",
+                            summary: "Accepted checkpoint could not be proven without moving Git truth.",
+                        },
+                    },
+                    now: input.now,
+                });
+                checkpointConflictRuns.push({
+                    activity_ref: staleRun.activity_ref,
+                    ...recorded,
+                });
+                continue;
+            }
+            if (checkpoint.kind === "not_found") {
+                continue;
+            }
+            const recorded = recordRunResult(input.store.db, {
+                activity_ref: staleRun.activity_ref,
+                task_id: staleRun.task_id,
+                run_lineage: staleRun.run_lineage,
+                result: {
+                    result_kind: "finished",
+                    outcome: "completed",
+                    summary: "Run accepted checkpoint was restored after host restart.",
+                    checks: "passed",
+                    docs: docsStatusForChangedPaths(checkpoint.changed_paths),
+                    changed_paths: checkpoint.changed_paths,
+                    promotion: {
+                        status: "promoted",
+                        commit_oid: checkpoint.commit_oid,
+                        summary: "Accepted checkpoint recovered from durable Git evidence.",
+                    },
+                },
+                now: input.now,
+            });
+            checkpointRecoveredRuns.push({
+                activity_ref: staleRun.activity_ref,
+                ...recorded,
+            });
+        }
+    }
+    const interrupted = recoverStaleRunningTasksAsFailed(input.store.db, { now: input.now });
+    const recoveredRuns = [
+        ...checkpointRecoveredRuns,
+        ...checkpointConflictRuns,
+        ...interrupted.recovered_runs,
+    ];
+    const commandRecovery = options.recoverInProgressCommands
+        ? recoverInProgressCommandIdempotencyRecords(input.store.db, {
+            resolve: resolveControlPlaneCommandRecovery,
+            now: input.now,
+        })
+        : null;
     const sealedRounds = readSealedClarificationRoundsWithoutSuccessor(input.store.db);
     const replayedRoundIds = [];
     for (const sealed of sealedRounds) {
@@ -21,25 +95,20 @@ export function runControlPlaneStartupRecovery(input) {
             replayedRoundIds.push(roundId);
         }
     }
-    const interruptedCommandCount = options.interruptedCommandCount ?? 0;
-    const affectedActivities = recovered.recovered_runs.map((recoveredRun) => recoveredRun.activity_ref);
+    const interruptedCommandCount = (options.interruptedCommandCount ?? 0) + (commandRecovery?.interrupted_count ?? 0);
+    const affectedActivities = recoveredRuns.map((recoveredRun) => recoveredRun.activity_ref);
     const shouldRecord = affectedActivities.length > 0 ||
         replayedRoundIds.length > 0 ||
         interruptedCommandCount > 0 ||
-        cleanup.removed_run_workspace_count > 0 ||
-        cleanup.removed_temp_branch_count > 0 ||
-        cleanup.warnings.length > 0 ||
         staleReplayHintCount > 0;
     if (!shouldRecord) {
         return { kind: "noop" };
     }
     const summary = formatStartupRecoverySummary({
-        recoveredRunCount: recovered.recovered_runs.length,
+        interruptedRunCount: checkpointConflictRuns.length + interrupted.recovered_runs.length,
+        acceptedCheckpointRunCount: checkpointRecoveredRuns.length,
         replayedRoundCount: replayedRoundIds.length,
         interruptedCommandCount,
-        removedRunWorkspaceCount: cleanup.removed_run_workspace_count,
-        removedTempBranchCount: cleanup.removed_temp_branch_count,
-        cleanupWarningCount: cleanup.warnings.length,
         staleReplayHintCount,
     });
     const recorded = recordRecoverySummary(input.store.db, {
@@ -53,9 +122,9 @@ export function runControlPlaneStartupRecovery(input) {
         ...(affectedActivities[0] === undefined ? {} : { activity_ref: affectedActivities[0] }),
         occurred_at: recorded.recovery_summary.created_at,
     });
-    for (const recoveredRun of recovered.recovered_runs) {
+    for (const recoveredRun of recoveredRuns) {
         const taskId = recoveredRun.task.id;
-        const invalidates = taskRunInvalidates(taskId);
+        const invalidates = taskRunResultInvalidates(taskId, recoveredRun.task_detail.detail.result);
         input.events.publish({
             event_type: "worklist.changed",
             payload: {
@@ -101,12 +170,10 @@ export function runControlPlaneStartupRecovery(input) {
     return {
         kind: "recovered",
         recovery_summary: recorded.recovery_summary,
-        recovered_run_count: recovered.recovered_runs.length,
+        recovered_run_count: recoveredRuns.length,
+        accepted_checkpoint_run_count: checkpointRecoveredRuns.length,
         replayed_round_ids: replayedRoundIds,
         interrupted_command_count: interruptedCommandCount,
-        removed_run_workspace_count: cleanup.removed_run_workspace_count,
-        removed_temp_branch_count: cleanup.removed_temp_branch_count,
-        cleanup_warning_count: cleanup.warnings.length,
         stale_replay_hint_count: staleReplayHintCount,
     };
 }

package/dist/control-plane/types.d.ts

@@ -4,7 +4,6 @@ import type { ActivityRef, ClarificationRoundRef, TaskId, TaskModuleId } from "@
 import type { ActiveApprovalProjection, ClarificationRequestPayload, ExecutionRuntimeSnapshot, MessageProjection, RecoverySummaryProjection, TaskDetailProjection, TaskProjection } from "@tutti/shared/schemas/api";
 import type { HostProjectStore } from "../store/index.js";
 import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
-import type { CleanupStaleRunWorkspacesResult } from "../workspace-ops/index.js";
 import type { ProcedureWorkflowRunnerResolver } from "./workflows/index.js";
 export type Phase5ControlPlaneOptions = {
     store: HostProjectStore;
@@ -33,7 +32,8 @@ export type ControlPlaneCommandResult<TDisposition, TResult> = {
     result?: TResult;
 };
 export type StartupRecoveryOptions = {
-    cleanupStaleRunWorkspaces?: () => CleanupStaleRunWorkspacesResult;
+    workspaceRoot?: string;
+    recoverInProgressCommands?: boolean;
     interruptedCommandCount?: number;
 };
 export type StartupRecoveryResult = {
@@ -42,11 +42,9 @@ export type StartupRecoveryResult = {
     kind: "recovered";
     recovery_summary: RecoverySummaryProjection;
     recovered_run_count: number;
+    accepted_checkpoint_run_count: number;
     replayed_round_ids: ClarificationRoundRef[];
     interrupted_command_count: number;
-    removed_run_workspace_count: number;
-    removed_temp_branch_count: number;
-    cleanup_warning_count: number;
     stale_replay_hint_count: number;
 };
 export type RunDispatchTrigger = "auto_idle" | "task_arrival" | "manual_run_now" | "continuation" | "recovery";
@@ -109,17 +107,7 @@ export type RunPipelineStageProgress = {
     summary: string;
     runtime?: ExecutionRuntimeSnapshot;
 };
-export type RunPipelineTimelineEvent = {
-    event_kind: "promotion_reconcile";
-    status: "completed" | "failed";
-    summary: string;
-    commit_oid?: string;
-    meta?: string[];
-};
-type RunPipelineResultMetadata = {
-    timeline_events?: RunPipelineTimelineEvent[];
-};
-export type RunPipelineResult = RunPipelineResultMetadata & ({
+export type RunPipelineResult = ({
     result_kind: "needs_human";
     summary: string;
     clarification_request_payload: ClarificationRequestPayload;
@@ -158,5 +146,4 @@ export type RunPipelineResolution = {
     retryable: boolean;
 };
 export type RunPipelineResolver = () => RunPipelineResolution;
-export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/providers/openai/app-server/workspace-write-run.d.ts

@@ -16,7 +16,6 @@ export type CodexAppServerApprovalHandler = (input: {
     request: CodexAppServerJsonRpcServerRequest;
     context: {
         workspaceRoot: string;
-        runWorkspaceRoot: string;
         codexHome: string;
         tuttiHome?: string;
         builtInSkillsRoot?: string;
@@ -46,7 +45,6 @@ export type CodexAppServerWorkspaceWriteRunInput<TOutput> = {
     approvalHandler?: CodexAppServerApprovalHandler;
     approvalContext?: {
         workspaceRoot?: string;
-        runWorkspaceRoot?: string;
         taskId?: TaskId;
         activityRef?: ActivityRef;
     };

package/dist/providers/openai/app-server/workspace-write-run.js

@@ -299,7 +299,6 @@ export async function runCodexAppServerWorkspaceWriteRun(options) {
                 : { approvalHandler: options.approvalHandler }),
             approvalContext: {
                 workspaceRoot: options.approvalContext?.workspaceRoot ?? options.workspaceRoot,
-                runWorkspaceRoot: options.approvalContext?.runWorkspaceRoot ?? options.workspaceRoot,
                 codexHome,
                 ...(options.tuttiHome === undefined ? {} : { tuttiHome: options.tuttiHome }),
                 ...(options.builtInSkillsRoot === undefined

package/dist/run-pipeline/candidate-diff.js

@@ -1,10 +1,4 @@
-function sameChangedPaths(left, right) {
-    if (left.length !== right.length) {
-        return false;
-    }
-    return left.every((path, index) => path === right[index]);
-}
 export function candidateChangedAfterChecks(before, after) {
-    return (!sameChangedPaths(before.changed_paths, after.changed_paths) || before.summary !== after.summary);
+    return before.fingerprint !== after.fingerprint;
 }
 //# sourceMappingURL=candidate-diff.js.map

package/dist/run-pipeline/openai.d.ts

@@ -12,8 +12,6 @@ export type OpenAiRunPipelineRunnerOptions = {
     config: OpenAiProviderConfig;
     apiKey: string;
     workspaceRoot: string;
-    runWorkspaceRoot: string;
-    mergeWorkspaceRoot?: string;
     promptsRoot?: string;
     tuttiHome?: string;
     userSkillsRoot?: string;
@@ -35,8 +33,6 @@ export type ProjectOpenAiRunPipelineRunnerOptions = {
     tuttiHome: string;
     projectId: ProjectId;
     workspaceRoot: string;
-    runWorkspaceRoot: string;
-    mergeWorkspaceRoot?: string;
     promptsRoot?: string;
     agentContext?: CodexAppServerAgentContextRuntime;
     approvalManager?: ApprovalRequestManager;