@xfey/tutti 0.1.49 → 0.1.51

package/dist/run-pipeline/openai.js

@@ -1,15 +1,13 @@
-import { join } from "node:path";
 import { createNodeNpmCheckPlan, executeCheckPlan } from "../checks/index.js";
 import { candidateChangedAfterChecks } from "./candidate-diff.js";
 import { runArtifactCandidateGate, } from "./artifact-applicability.js";
 import { checkSkipFields, checkStatus, checksSummary, completedWithoutRepoChanges, docsStatusForChangedPaths, failedBeforeChecks, failedFinishedResult, promotionNotAttempted, promotionNotPromoted, successfulRunSummary, } from "./result-projections.js";
-import { runPromotionReconcile } from "./promotion-reconcile.js";
 import { runWorkspaceWriteTask } from "./task-run-invocation.js";
 import { readOpenAiApiKeyCredential } from "../providers/openai/credential-store.js";
 import { resolveOpenAiProviderConfig, } from "../providers/openai/provider-config.js";
 import { CodexAppServerWorkspaceWriteRunError } from "../providers/openai/app-server/workspace-write-run.js";
 import { getProjectUserSkillsRoot } from "../skills/index.js";
-import { cleanupRunWorkspace, collectRunDiff, createResultCommit, prepareRunWorkspace, promoteRunResult, WorkspaceOpsError, } from "../workspace-ops/index.js";
+import { collectProjectSourceDiff, createAcceptedCheckpoint, inspectProjectWorkspace, WorkspaceOpsError, } from "../workspace-ops/index.js";
 export { TASK_RUN_OUTPUT_SCHEMA } from "./task-run-output.js";
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -55,12 +53,6 @@ function summarizeWorkspaceOpsError(error, changedPaths) {
             : promotionNotAttempted("workspace_ops_failed", error.message),
     });
 }
-function isMainlineMovedPromotionConflict(error) {
-    return (error instanceof WorkspaceOpsError &&
-        error.code === "conflict" &&
-        isRecord(error.details) &&
-        error.details.reason_code === "mainline_not_at_base");
-}
 function runLineageFields(input) {
     return {
         run_lineage_kind: input.run_lineage.kind,
@@ -89,8 +81,8 @@ function logRunPipelineStage(options, input, fields, message) {
 }
 function stageProgressSummary(stage) {
     switch (stage) {
-        case "run_workspace_prepare":
-            return "preparing an isolated run workspace.";
+        case "workspace_inspect":
+            return "inspecting the persistent project workspace.";
         case "provider_task_run":
             return "running Codex task implementation.";
         case "provider_retry":
@@ -103,16 +95,10 @@ function stageProgressSummary(stage) {
             return "running project checks.";
         case "post_checks_diff_collect":
             return "rechecking candidate changes after checks.";
-        case "result_commit":
-            return "creating the candidate result commit.";
-        case "promotion":
-            return "promoting candidate changes to mainline.";
-        case "promotion_reconcile":
-            return "reconciling promotion after mainline changed.";
+        case "accepted_checkpoint":
+            return "saving the validated project state as an accepted checkpoint.";
         case "self_correction":
             return "retrying task implementation after pipeline feedback.";
-        case "run_workspace_cleanup":
-            return "cleaning up the run workspace.";
         default:
             return `running stage ${stage}.`;
     }
@@ -176,31 +162,6 @@ function loggedSyncStage(options, input, stage, run, completedFields = () => ({}
         throw error;
     }
 }
-function runResultLogFields(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,
-    };
-}
 const MAX_SELF_CORRECTION_RETRIES = 1;
 const MAX_PROVIDER_TRANSIENT_RETRIES = 1;
 function runPipelineResultPromotion(result) {
@@ -264,18 +225,6 @@ function appendSelfCorrectionExhaustedSummary(input) {
         summary: `${input.result.summary} Self-correction retry limit reached after ${input.attemptedRetries} retry attempt${input.attemptedRetries === 1 ? "" : "s"}.`,
     };
 }
-function resultTimelineEvents(result) {
-    return result.timeline_events ?? [];
-}
-function withCarriedTimelineEvents(result, carriedTimelineEvents) {
-    if (carriedTimelineEvents.length === 0) {
-        return result;
-    }
-    return {
-        ...result,
-        timeline_events: [...carriedTimelineEvents, ...resultTimelineEvents(result)],
-    };
-}
 function isSelfCorrectionRequest(result) {
     return "request_kind" in result && result.request_kind === "self_correction";
 }
@@ -285,35 +234,12 @@ function isProviderTransientRunFailure(result) {
         result.retryable &&
         result.error_code.startsWith("codex_app_server_"));
 }
-function reconcileSelfCorrectionReason(result) {
-    const promotion = runPipelineResultPromotion(result);
-    if (promotion?.status !== "not_promoted") {
-        return undefined;
-    }
-    if (promotion.reason_code !== undefined) {
-        return promotion.reason_code;
-    }
-    if (result.result_kind === "failed") {
-        return result.error_code;
-    }
-    if (result.result_kind === "finished" && result.outcome === "failed") {
-        return "promotion_reconcile_failed";
-    }
-    return undefined;
-}
 async function runTaskAttempt(options, input) {
-    let handle;
     let changedPaths;
     try {
-        const runHandle = loggedSyncStage(options, input, "run_workspace_prepare", () => prepareRunWorkspace({
-            workspaceRoot: options.workspaceRoot,
-            runWorkspaceRoot: options.runWorkspaceRoot,
-            taskId: input.task.id,
-            activityRef: input.activity_ref,
-        }));
-        handle = runHandle;
-        const taskOutput = await loggedAsyncStage(options, input, "provider_task_run", () => runWorkspaceWriteTask(options, input, runHandle), (output) => ({ decision: output.decision }));
-        const diff = loggedSyncStage(options, input, "candidate_diff_collect", () => collectRunDiff(runHandle), (result) => ({ changed_path_count: result.changed_paths.length }));
+        loggedSyncStage(options, input, "workspace_inspect", () => inspectProjectWorkspace(options.workspaceRoot), (inspection) => ({ head_oid: inspection.head_ref }));
+        const taskOutput = await loggedAsyncStage(options, input, "provider_task_run", () => runWorkspaceWriteTask(options, input), (output) => ({ decision: output.decision }));
+        const diff = loggedSyncStage(options, input, "candidate_diff_collect", () => collectProjectSourceDiff(options.workspaceRoot), (result) => ({ changed_path_count: result.changed_paths.length }));
         changedPaths = diff.changed_paths;
         if (taskOutput.decision === "needs_human") {
             logRunPipelineStage(options, input, {
@@ -338,7 +264,7 @@ async function runTaskAttempt(options, input) {
                 promotion: promotionNotAttempted(errorCode, taskOutput.summary),
             });
         }
-        if (changedPaths.length === 0 && taskOutput.decision === "completed_no_repo_changes") {
+        if (!diff.has_changes && taskOutput.decision === "completed_no_repo_changes") {
             return completedWithoutRepoChanges({
                 summary: taskOutput.summary,
                 ...(taskOutput.user_note_candidate === undefined
@@ -346,7 +272,7 @@ async function runTaskAttempt(options, input) {
                     : { userNoteCandidate: taskOutput.user_note_candidate }),
             });
         }
-        if (changedPaths.length === 0) {
+        if (!diff.has_changes) {
             const result = failedBeforeChecks({
                 summary: "Codex completed the Run but produced no candidate changes.",
                 errorCode: "no_candidate_changes",
@@ -361,7 +287,7 @@ async function runTaskAttempt(options, input) {
             });
         }
         const artifactGate = await loggedAsyncStage(options, input, "artifact_candidate_validate", () => runArtifactCandidateGate({
-            repoRoot: runHandle.repo_root,
+            repoRoot: options.workspaceRoot,
             task: {
                 title: input.task.title,
                 goal: input.task_detail.detail.contract.goal,
@@ -409,9 +335,9 @@ async function runTaskAttempt(options, input) {
             });
         }
         let docs = docsStatusForChangedPaths(changedPaths);
-        const checkPlan = createNodeNpmCheckPlan({ workspaceRoot: runHandle.repo_root });
+        const checkPlan = createNodeNpmCheckPlan({ workspaceRoot: options.workspaceRoot });
         const checks = await loggedAsyncStage(options, input, "checks", () => executeCheckPlan({
-            workspaceRoot: runHandle.repo_root,
+            workspaceRoot: options.workspaceRoot,
             plan: checkPlan,
             ...(options.checkTimeoutMs === undefined ? {} : { timeoutMs: options.checkTimeoutMs }),
         }), (result) => ({ checks_status: result.status, command_count: result.commands.length }));
@@ -429,7 +355,7 @@ async function runTaskAttempt(options, input) {
                 guidance: "Use the failed checks summary to fix the candidate so the task can pass Tutti checks.",
             });
         }
-        const postChecksDiff = loggedSyncStage(options, input, "post_checks_diff_collect", () => collectRunDiff(runHandle), (result) => ({ changed_path_count: result.changed_paths.length }));
+        const postChecksDiff = loggedSyncStage(options, input, "post_checks_diff_collect", () => collectProjectSourceDiff(options.workspaceRoot), (result) => ({ changed_path_count: result.changed_paths.length }));
         changedPaths = postChecksDiff.changed_paths;
         docs = docsStatusForChangedPaths(changedPaths);
         if (candidateChangedAfterChecks(diff, postChecksDiff)) {
@@ -449,53 +375,23 @@ async function runTaskAttempt(options, input) {
                 guidance: "Prevent checks from mutating tracked files, or intentionally produce those generated files before checks run.",
             });
         }
-        const commit = loggedSyncStage(options, input, "result_commit", () => createResultCommit(runHandle, `Complete Tutti task: ${input.task.title}`), (result) => ({ commit_oid: result.commit_oid }));
-        let promotion;
-        try {
-            promotion = loggedSyncStage(options, input, "promotion", () => promoteRunResult(runHandle, commit), (result) => ({ promoted_commit_oid: result.promoted_commit_oid }));
-        }
-        catch (error) {
-            if (isMainlineMovedPromotionConflict(error)) {
-                const reconcileOutcome = await loggedAsyncStage(options, input, "promotion_reconcile", () => runPromotionReconcile({
-                    options,
-                    pipelineInput: input,
-                    runHandle,
-                    taskOutput,
-                    sourceCommit: commit,
-                    changedPaths: postChecksDiff.changed_paths,
-                }), (outcome) => runResultLogFields(outcome.result));
-                const reconcileResult = reconcileOutcome.result;
-                if (reconcileOutcome.artifact_gate_failure !== undefined) {
-                    if (!reconcileOutcome.artifact_gate_failure.correctable) {
-                        return reconcileResult;
-                    }
-                    const artifactFailure = reconcileOutcome.artifact_gate_failure.failure;
-                    return requestSelfCorrection({
-                        result: reconcileResult,
-                        reasonCode: artifactFailure.reason_code,
-                        guidance: artifactFailure.guidance,
-                        diagnostic: artifactFailure.diagnostic,
-                    });
-                }
-                const reasonCode = reconcileSelfCorrectionReason(reconcileResult);
-                if (reasonCode !== undefined) {
-                    return requestSelfCorrection({
-                        result: reconcileResult,
-                        reasonCode,
-                        guidance: "Rebuild the candidate from the latest mainline and resolve the promotion reconcile failure.",
-                    });
-                }
-                return reconcileResult;
-            }
-            throw error;
-        }
+        const checkpoint = loggedSyncStage(options, input, "accepted_checkpoint", () => createAcceptedCheckpoint({
+            workspaceRoot: options.workspaceRoot,
+            taskId: input.task.id,
+            activityRef: input.activity_ref,
+            summary: `Complete Tutti task: ${input.task.title}`,
+            expectedSourceFingerprint: postChecksDiff.fingerprint,
+        }), (result) => ({
+            promoted_commit_oid: result.promoted_commit_oid,
+            checkpoint_disposition: result.disposition,
+        }));
         return {
             result_kind: "finished",
             outcome: "completed",
             summary: successfulRunSummary({
                 implementation: taskOutput.summary,
                 checks,
-                completion: "Promotion complete.",
+                completion: "Accepted checkpoint complete.",
             }),
             ...(taskOutput.user_note_candidate === undefined
                 ? {}
@@ -506,14 +402,25 @@ async function runTaskAttempt(options, input) {
             changed_paths: changedPaths,
             promotion: {
                 status: "promoted",
-                commit_oid: promotion.promoted_commit_oid,
-                summary: "Promoted by fast-forward after checks.",
+                commit_oid: checkpoint.promoted_commit_oid,
+                summary: "Accepted checkpoint created after validation and checks.",
             },
         };
     }
     catch (error) {
+        if (changedPaths === undefined) {
+            try {
+                changedPaths = collectProjectSourceDiff(options.workspaceRoot).changed_paths;
+            }
+            catch {
+                // Preserve the original pipeline error when the best-effort diff cannot be collected.
+            }
+        }
         if (error instanceof CodexAppServerWorkspaceWriteRunError) {
-            return summarizeProviderError(error);
+            return {
+                ...summarizeProviderError(error),
+                ...(changedPaths === undefined ? {} : { changed_paths: changedPaths }),
+            };
         }
         if (error instanceof WorkspaceOpsError) {
             return summarizeWorkspaceOpsError(error, changedPaths);
@@ -525,12 +432,6 @@ async function runTaskAttempt(options, input) {
             ...(changedPaths === undefined ? {} : { changedPaths }),
         });
     }
-    finally {
-        const cleanupHandle = handle;
-        if (cleanupHandle !== undefined) {
-            loggedSyncStage(options, input, "run_workspace_cleanup", () => cleanupRunWorkspace(cleanupHandle));
-        }
-    }
 }
 export function createOpenAiRunPipelineRunner(options) {
     return {
@@ -538,7 +439,6 @@ export function createOpenAiRunPipelineRunner(options) {
             let currentInput = input;
             let selfCorrectionRetries = 0;
             let providerTransientRetries = 0;
-            let carriedTimelineEvents = [];
             for (;;) {
                 const result = await runTaskAttempt(options, currentInput);
                 if (isProviderTransientRunFailure(result) &&
@@ -558,18 +458,14 @@ export function createOpenAiRunPipelineRunner(options) {
                 }
                 providerTransientRetries = 0;
                 if (!isSelfCorrectionRequest(result)) {
-                    return withCarriedTimelineEvents(result, carriedTimelineEvents);
+                    return result;
                 }
                 if (selfCorrectionRetries >= MAX_SELF_CORRECTION_RETRIES) {
-                    return withCarriedTimelineEvents(appendSelfCorrectionExhaustedSummary({
+                    return appendSelfCorrectionExhaustedSummary({
                         result: result.fallback,
                         attemptedRetries: selfCorrectionRetries,
-                    }), carriedTimelineEvents);
+                    });
                 }
-                carriedTimelineEvents = [
-                    ...carriedTimelineEvents,
-                    ...resultTimelineEvents(result.fallback),
-                ];
                 selfCorrectionRetries += 1;
                 const correctionContext = result.correction_context;
                 const nextAttempt = currentInput.run_lineage.attempt + 1;
@@ -609,8 +505,6 @@ export function resolveProjectOpenAiRunPipelineRunner(options) {
             config,
             apiKey: credential.secret,
             workspaceRoot: options.workspaceRoot,
-            runWorkspaceRoot: join(options.runWorkspaceRoot, "run-workspaces"),
-            mergeWorkspaceRoot: join(options.mergeWorkspaceRoot ?? options.runWorkspaceRoot, "merge-workspaces"),
             tuttiHome: options.tuttiHome,
             userSkillsRoot: getProjectUserSkillsRoot(options.tuttiHome, options.projectId),
             ...(options.agentContext === undefined ? {} : { agentContext: options.agentContext }),

package/dist/run-pipeline/task-run-invocation.d.ts

@@ -1,6 +1,5 @@
 import type { RunPipelineInput } from "../control-plane/index.js";
-import type { RunWorkspaceHandle } from "../workspace-ops/index.js";
 import type { OpenAiRunPipelineRunnerOptions } from "./openai.js";
 import { type TaskRunOutput } from "./task-run-output.js";
-export declare function runWorkspaceWriteTask(options: OpenAiRunPipelineRunnerOptions, input: RunPipelineInput, handle: RunWorkspaceHandle): Promise<TaskRunOutput>;
+export declare function runWorkspaceWriteTask(options: OpenAiRunPipelineRunnerOptions, input: RunPipelineInput): Promise<TaskRunOutput>;
 //# sourceMappingURL=task-run-invocation.d.ts.map

package/dist/run-pipeline/task-run-invocation.js

@@ -56,7 +56,7 @@ function usageSource(input) {
             return "workspace_write_run";
     }
 }
-export async function runWorkspaceWriteTask(options, input, handle) {
+export async function runWorkspaceWriteTask(options, input) {
     const manager = options.approvalManager;
     const approvalHandler = manager === undefined
         ? undefined
@@ -66,7 +66,6 @@ export async function runWorkspaceWriteTask(options, input, handle) {
                 taskId: input.task.id,
                 activityRef: input.activity_ref,
                 workspaceRoot: approvalInput.context.workspaceRoot,
-                runWorkspaceRoot: approvalInput.context.runWorkspaceRoot,
                 codexHome: approvalInput.context.codexHome,
                 ...(approvalInput.context.tuttiHome === undefined
                     ? {}
@@ -82,7 +81,7 @@ export async function runWorkspaceWriteTask(options, input, handle) {
     try {
         result = await runCodexAppServerWorkspaceWriteRun({
             apiKey: options.apiKey,
-            workspaceRoot: handle.repo_root,
+            workspaceRoot: options.workspaceRoot,
             prompt: createRunPrompt(options, input),
             outputSchema: TASK_RUN_OUTPUT_SCHEMA,
             validateOutput: (value) => isInitialTaskRunOutput(value),
@@ -90,7 +89,6 @@ export async function runWorkspaceWriteTask(options, input, handle) {
             defaultModel: options.config.default_model,
             approvalContext: {
                 workspaceRoot: options.workspaceRoot,
-                runWorkspaceRoot: handle.repo_root,
                 taskId: input.task.id,
                 activityRef: input.activity_ref,
             },

package/dist/server-shell/cli/host-server-runtime.js

@@ -4,7 +4,6 @@ import { completeRelayUpload, resolveRelayUpload } from "@tutti/relay-client";
 import { ApprovalRequestManager } from "../../approvals/index.js";
 import { ReadOnlyChatAssistant } from "../../chat-assistant/index.js";
 import { ensureInitialProjectWelcomeMessage } from "../../collaboration-state/index.js";
-import { resolveControlPlaneCommandRecovery } from "../../control-plane/command-recovery.js";
 import { Phase5ControlPlane } from "../../control-plane/index.js";
 import { resolveProjectOpenAiProcedureWorkflowRunner } from "../../control-plane/workflows/index.js";
 import { resolveProjectOpenAiReadOnlyChatAssistantModel } from "../../providers/openai/chat-assistant.js";
@@ -12,7 +11,6 @@ import { configureProjectOpenAiProvider, readOpenAiProviderConfigProjection, } f
 import { readProviderUsageProjection, recordProviderUsageEvent, } from "../../provider-usage/index.js";
 import { resolveProjectOpenAiRunPipelineRunner } from "../../run-pipeline/openai.js";
 import { openHostProjectStore } from "../../store/index.js";
-import { cleanupStaleRunWorkspaces } from "../../workspace-ops/index.js";
 import { resolvePackagedWebStaticRoot } from "../http/static-web.js";
 import { AGENT_CONTEXT_BASE_PATH, AgentContextTokenRegistry, } from "../http/routes/agent-context.js";
 import { readHostRepoProjection } from "../http/routes/project-api.js";
@@ -133,7 +131,7 @@ export async function startForegroundHostServer(options) {
     const store = openHostProjectStore({
         localStoreRoot,
         projectId: options.preparation.project_id,
-        commandRecoveryResolver: resolveControlPlaneCommandRecovery,
+        deferCommandRecovery: true,
         now,
     });
     const workspaceEvents = new WorkspaceEventBus({ now });
@@ -224,7 +222,6 @@ export async function startForegroundHostServer(options) {
             tuttiHome: options.preparation.tutti_home,
             projectId: options.preparation.project_id,
             workspaceRoot: options.preparation.workspace_root,
-            runWorkspaceRoot: localStoreRoot,
             agentContext: agentContextRuntime,
             approvalManager,
             logger: runPipelineLogger,
@@ -428,12 +425,8 @@ export async function startForegroundHostServer(options) {
         throw error;
     }
     controlPlane.runStartupRecovery({
-        interruptedCommandCount: store.interrupted_command_count,
-        cleanupStaleRunWorkspaces: () => cleanupStaleRunWorkspaces({
-            workspaceRoot: options.preparation.workspace_root,
-            runWorkspaceRoot: join(localStoreRoot, "run-workspaces"),
-            mergeWorkspaceRoot: join(localStoreRoot, "merge-workspaces"),
-        }),
+        workspaceRoot: options.preparation.workspace_root,
+        recoverInProgressCommands: true,
     });
     let resolveClosed;
     const closed = new Promise((resolve) => {

package/dist/store/lifecycle.d.ts

@@ -17,6 +17,7 @@ export type OpenHostProjectStoreOptions = {
     projectId: ProjectId;
     migrationsDirectory?: string;
     commandRecoveryResolver?: CommandRecoveryResolver;
+    deferCommandRecovery?: boolean;
     now?: () => Date;
 };
 export declare function openHostProjectStore(options: OpenHostProjectStoreOptions): HostProjectStore;

package/dist/store/lifecycle.js

@@ -22,12 +22,14 @@ export function openHostProjectStore(options) {
             projectId: options.projectId,
             now,
         });
-        const commandRecovery = recoverInProgressCommandIdempotencyRecords(db, {
-            ...(options.commandRecoveryResolver === undefined
-                ? {}
-                : { resolve: options.commandRecoveryResolver }),
-            now,
-        });
+        const commandRecovery = options.deferCommandRecovery
+            ? { total_count: 0, completed_count: 0, failed_count: 0, interrupted_count: 0 }
+            : recoverInProgressCommandIdempotencyRecords(db, {
+                ...(options.commandRecoveryResolver === undefined
+                    ? {}
+                    : { resolve: options.commandRecoveryResolver }),
+                now,
+            });
         return {
             db,
             database_path: databasePath,

package/dist/workspace-ops/index.d.ts

@@ -1,11 +1,12 @@
 export { DEFAULT_VIEWER_MAX_BYTES, MAX_REFERENCE_UPLOAD_BYTES, MAX_VIEWER_MAX_BYTES, PROJECT_DOC_PATHS, REFERENCE_IMAGE_ASSET_CACHE_VERSION, REFERENCE_IMAGE_PREVIEW_MAX_EDGE_PX, REFERENCE_IMAGE_THUMBNAIL_MAX_EDGE_PX, REFERENCE_DIRECTORY_PATH, REFERENCE_FILES_DIRECTORY_PATH, REFERENCE_IMAGES_DIRECTORY_PATH, REFERENCE_INDEX_PATH, REFERENCE_TUTTI_DIRECTORY_PATH, VIEWER_ASSET_READ_LIMIT_BYTES, VIEWER_HARD_READ_LIMIT_BYTES, WORKSPACE_OPS_MAINLINE_BRANCH, } from "./constants.js";
 export { WorkspaceOpsError } from "./errors.js";
+export { commitOwnedPaths, requireOwnedPathsWriteReady } from "./system-commits.js";
+export { collectProjectSourceDiff, createAcceptedCheckpoint, fingerprintProjectSourceState, inspectProjectWorkspace, recoverAcceptedCheckpoint, } from "./project-workspace.js";
 export { initializeProjectDocs, readProjectDocsInitializationStatus, syncProjectDocs, } from "./project-docs.js";
 export { uploadReferenceFile } from "./reference-files.js";
 export { referenceFileCategoryForPath, referenceFileSourceForPath, referenceMediaTypeForPath, referenceTuttiGroupForPath, } from "./reference-metadata.js";
 export { readReferenceSummaryIndex, readReferenceSummaryTargets, referenceSummaryProjectionForEntry, updateReferenceSummaries, } from "./reference-summaries.js";
-export { applyRunResultToMergeWorkspace, cleanupMergeWorkspace, cleanupRunWorkspace, cleanupStaleRunWorkspaces, collectMergeDiff, collectRunDiff, createMergeCandidateCommit, createResultCommit, fingerprintWorkspaceCandidate, prepareMergeWorkspace, prepareRunWorkspace, promoteMergeCandidate, promoteRunResult, } from "./run-workspaces.js";
 export { readViewerAsset, readViewerFile, readViewerSnapshot, readViewerTree } from "./viewer.js";
 export type { WorkspaceOpsErrorCode } from "./errors.js";
-export type { CleanupRunWorkspaceResult, CleanupStaleRunWorkspacesResult, InitializeProjectDocsOptions, InitializeProjectDocsResult, MergeWorkspaceHandle, PrepareMergeWorkspaceOptions, PrepareRunWorkspaceOptions, ProjectDocsInitializationContext, ProjectDocsInitializationDocument, ProjectDocsInitializationStatus, PromotionResult, ReadViewerAssetOptions, ReadViewerFileOptions, ReadViewerTreeOptions, ReferenceFileCategory, ReferenceSummaryProjection, ReferenceSummaryRecord, ReferenceSummaryStatus, ReferenceSummaryTarget, ResultCommit, RunDiffSummary, RunWorkspaceHandle, SyncProjectDocsResult, SyncProjectDocsUpdate, UpdateReferenceSummariesOptions, UpdateReferenceSummariesResult, UploadReferenceFileOptions, UploadReferenceFileResult, ViewerAssetResult, ViewerAssetVariant, ViewerEntryKind, ViewerFileContent, ViewerFileResult, ViewerRepoSnapshot, ViewerTreeEntry, ViewerTreeResult, WorkspaceViewerOptions, } from "./types.js";
+export type { AcceptedCheckpointRecoveryResult, AcceptedCheckpointResult, CreateAcceptedCheckpointOptions, InitializeProjectDocsOptions, InitializeProjectDocsResult, ProjectDocsInitializationContext, ProjectDocsInitializationDocument, ProjectDocsInitializationStatus, ProjectWorkspaceInspection, ReadViewerAssetOptions, ReadViewerFileOptions, ReadViewerTreeOptions, ReferenceFileCategory, ReferenceSummaryProjection, ReferenceSummaryRecord, ReferenceSummaryStatus, ReferenceSummaryTarget, RunDiffSummary, SyncProjectDocsResult, SyncProjectDocsUpdate, UpdateReferenceSummariesOptions, UpdateReferenceSummariesResult, UploadReferenceFileOptions, UploadReferenceFileResult, ViewerAssetResult, ViewerAssetVariant, ViewerEntryKind, ViewerFileContent, ViewerFileResult, ViewerRepoSnapshot, ViewerTreeEntry, ViewerTreeResult, WorkspaceViewerOptions, } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/workspace-ops/index.js

@@ -1,9 +1,10 @@
 export { DEFAULT_VIEWER_MAX_BYTES, MAX_REFERENCE_UPLOAD_BYTES, MAX_VIEWER_MAX_BYTES, PROJECT_DOC_PATHS, REFERENCE_IMAGE_ASSET_CACHE_VERSION, REFERENCE_IMAGE_PREVIEW_MAX_EDGE_PX, REFERENCE_IMAGE_THUMBNAIL_MAX_EDGE_PX, REFERENCE_DIRECTORY_PATH, REFERENCE_FILES_DIRECTORY_PATH, REFERENCE_IMAGES_DIRECTORY_PATH, REFERENCE_INDEX_PATH, REFERENCE_TUTTI_DIRECTORY_PATH, VIEWER_ASSET_READ_LIMIT_BYTES, VIEWER_HARD_READ_LIMIT_BYTES, WORKSPACE_OPS_MAINLINE_BRANCH, } from "./constants.js";
 export { WorkspaceOpsError } from "./errors.js";
+export { commitOwnedPaths, requireOwnedPathsWriteReady } from "./system-commits.js";
+export { collectProjectSourceDiff, createAcceptedCheckpoint, fingerprintProjectSourceState, inspectProjectWorkspace, recoverAcceptedCheckpoint, } from "./project-workspace.js";
 export { initializeProjectDocs, readProjectDocsInitializationStatus, syncProjectDocs, } from "./project-docs.js";
 export { uploadReferenceFile } from "./reference-files.js";
 export { referenceFileCategoryForPath, referenceFileSourceForPath, referenceMediaTypeForPath, referenceTuttiGroupForPath, } from "./reference-metadata.js";
 export { readReferenceSummaryIndex, readReferenceSummaryTargets, referenceSummaryProjectionForEntry, updateReferenceSummaries, } from "./reference-summaries.js";
-export { applyRunResultToMergeWorkspace, cleanupMergeWorkspace, cleanupRunWorkspace, cleanupStaleRunWorkspaces, collectMergeDiff, collectRunDiff, createMergeCandidateCommit, createResultCommit, fingerprintWorkspaceCandidate, prepareMergeWorkspace, prepareRunWorkspace, promoteMergeCandidate, promoteRunResult, } from "./run-workspaces.js";
 export { readViewerAsset, readViewerFile, readViewerSnapshot, readViewerTree } from "./viewer.js";
 //# sourceMappingURL=index.js.map

package/dist/workspace-ops/mainline.d.ts

@@ -1,2 +1,2 @@
-export declare function requireMainlineWriteReady(workspaceRoot: string): void;
+export declare function requireMainlineBranch(workspaceRoot: string): void;
 //# sourceMappingURL=mainline.d.ts.map

package/dist/workspace-ops/mainline.js

@@ -2,15 +2,11 @@ import { WORKSPACE_OPS_MAINLINE_BRANCH } from "./constants.js";
 import { WorkspaceOpsError } from "./errors.js";
 import { tryGitText } from "./git.js";
 import { readViewerSnapshot } from "./viewer.js";
-export function requireMainlineWriteReady(workspaceRoot) {
+export function requireMainlineBranch(workspaceRoot) {
     readViewerSnapshot({ workspaceRoot });
     const currentBranch = tryGitText(["branch", "--show-current"], workspaceRoot);
     if (currentBranch !== WORKSPACE_OPS_MAINLINE_BRANCH) {
         throw new WorkspaceOpsError("conflict", "Mainline write requires the mainline branch to be checked out");
     }
-    const status = tryGitText(["status", "--porcelain"], workspaceRoot);
-    if (status !== "") {
-        throw new WorkspaceOpsError("conflict", "Mainline write requires a clean mainline working tree");
-    }
 }
 //# sourceMappingURL=mainline.js.map

package/dist/workspace-ops/project-docs.js

@@ -2,8 +2,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { extname, join, posix } from "node:path";
 import { PROJECT_DOC_PATHS } from "./constants.js";
 import { WorkspaceOpsError } from "./errors.js";
-import { runGit, runGitText, stagedChangesExist } from "./git.js";
-import { requireMainlineWriteReady } from "./mainline.js";
+import { commitOwnedPaths, requireOwnedPathsWriteReady } from "./system-commits.js";
 import { projectDocTemplate, repoFactHints } from "./project-doc-templates.js";
 import { entryKind, lsPath, readViewerSnapshot, requireNormalizedViewerPath, } from "./viewer.js";
 const MAX_PROJECT_DOC_SYNC_BYTES = 512 * 1024;
@@ -61,7 +60,6 @@ export function readProjectDocsInitializationStatus(options) {
     };
 }
 export function initializeProjectDocs(options) {
-    requireMainlineWriteReady(options.workspaceRoot);
     const createdPaths = [];
     const repoHints = repoFactHints(options.workspaceRoot);
     const providedDocuments = new Map();
@@ -81,6 +79,11 @@ export function initializeProjectDocs(options) {
             providedDocuments.set(path, document.content);
         }
     }
+    const missingPaths = PROJECT_DOC_PATHS.filter((path) => !projectDocExists(options.workspaceRoot, path));
+    if (missingPaths.length === 0) {
+        return { created_paths: [] };
+    }
+    requireOwnedPathsWriteReady(options.workspaceRoot, missingPaths);
     for (const path of PROJECT_DOC_PATHS) {
         if (projectDocExists(options.workspaceRoot, path)) {
             continue;
@@ -89,20 +92,20 @@ export function initializeProjectDocs(options) {
         writeFileSync(join(options.workspaceRoot, path), `${content.trimEnd()}\n`, "utf8");
         createdPaths.push(path);
     }
-    if (createdPaths.length === 0) {
-        return { created_paths: [] };
-    }
-    runGit(["add", "--", ...createdPaths], options.workspaceRoot);
-    if (stagedChangesExist(options.workspaceRoot)) {
-        runGit(["commit", "-m", "Initialize project docs"], options.workspaceRoot);
+    const commitOid = commitOwnedPaths({
+        workspaceRoot: options.workspaceRoot,
+        paths: createdPaths,
+        message: "Initialize project docs",
+    });
+    if (commitOid === null) {
+        throw new WorkspaceOpsError("git_failed", "Project docs write produced no owned-path commit");
     }
     return {
         created_paths: createdPaths,
-        commit_oid: runGitText(["rev-parse", "--verify", "HEAD"], options.workspaceRoot),
+        commit_oid: commitOid,
     };
 }
 export function syncProjectDocs(options) {
-    requireMainlineWriteReady(options.workspaceRoot);
     const normalizedUpdates = options.updates.map((update) => {
         const normalizedPath = requireProjectDocsSyncPath({
             workspaceRoot: options.workspaceRoot,
@@ -127,6 +130,10 @@ export function syncProjectDocs(options) {
         }
         seenPaths.add(update.path);
     }
+    if (normalizedUpdates.length === 0) {
+        return { updated_paths: [] };
+    }
+    requireOwnedPathsWriteReady(options.workspaceRoot, normalizedUpdates.map((update) => update.path));
     const updatedPaths = [];
     for (const update of normalizedUpdates) {
         const filesystemPath = join(options.workspaceRoot, ...update.path.split("/"));
@@ -144,13 +151,17 @@ export function syncProjectDocs(options) {
     if (updatedPaths.length === 0) {
         return { updated_paths: [] };
     }
-    runGit(["add", "--", ...updatedPaths], options.workspaceRoot);
-    if (stagedChangesExist(options.workspaceRoot)) {
-        runGit(["commit", "-m", "Sync project docs"], options.workspaceRoot);
+    const commitOid = commitOwnedPaths({
+        workspaceRoot: options.workspaceRoot,
+        paths: updatedPaths,
+        message: "Sync project docs",
+    });
+    if (commitOid === null) {
+        throw new WorkspaceOpsError("git_failed", "Project docs sync produced no owned-path commit");
     }
     return {
         updated_paths: updatedPaths,
-        commit_oid: runGitText(["rev-parse", "--verify", "HEAD"], options.workspaceRoot),
+        commit_oid: commitOid,
     };
 }
 //# sourceMappingURL=project-docs.js.map

package/dist/workspace-ops/project-workspace.d.ts

@@ -0,0 +1,12 @@
+import type { ActivityRef, TaskId } from "@tutti/shared/ids";
+import type { AcceptedCheckpointRecoveryResult, AcceptedCheckpointResult, CreateAcceptedCheckpointOptions, ProjectWorkspaceInspection, RunDiffSummary } from "./types.js";
+export declare function fingerprintProjectSourceState(workspaceRoot: string): string;
+export declare function collectProjectSourceDiff(workspaceRoot: string): RunDiffSummary;
+export declare function inspectProjectWorkspace(workspaceRoot: string): ProjectWorkspaceInspection;
+export declare function recoverAcceptedCheckpoint(options: {
+    workspaceRoot: string;
+    taskId: TaskId;
+    activityRef: ActivityRef;
+}): AcceptedCheckpointRecoveryResult;
+export declare function createAcceptedCheckpoint(options: CreateAcceptedCheckpointOptions): AcceptedCheckpointResult;
+//# sourceMappingURL=project-workspace.d.ts.map