@xfey/tutti 0.1.42 → 0.1.44

package/dist/run-pipeline/promotion-reconcile.d.ts

@@ -1,7 +1,15 @@
+import type { CandidateArtifactValidationFailure } from "../artifacts/index.js";
 import type { RunPipelineInput, RunPipelineResult } from "../control-plane/index.js";
 import { type ResultCommit, type RunWorkspaceHandle } from "../workspace-ops/index.js";
 import type { OpenAiRunPipelineRunnerOptions } from "./openai.js";
 import type { CompletedNoRepoChangesTaskRunOutput, CompletedTaskRunOutput } from "./task-run-output.js";
+export type PromotionReconcileOutcome = {
+    result: RunPipelineResult;
+    artifact_gate_failure?: {
+        correctable: boolean;
+        failure: CandidateArtifactValidationFailure;
+    };
+};
 export declare function runPromotionReconcile(input: {
     options: OpenAiRunPipelineRunnerOptions;
     pipelineInput: RunPipelineInput;
@@ -9,5 +17,5 @@ export declare function runPromotionReconcile(input: {
     taskOutput: CompletedTaskRunOutput | CompletedNoRepoChangesTaskRunOutput;
     sourceCommit: ResultCommit;
     changedPaths: string[];
-}): Promise<RunPipelineResult>;
+}): Promise<PromotionReconcileOutcome>;
 //# sourceMappingURL=promotion-reconcile.d.ts.map

package/dist/run-pipeline/promotion-reconcile.js

@@ -2,7 +2,14 @@ import { dirname, join } from "node:path";
 import { createNodeNpmCheckPlan, executeCheckPlan } from "../checks/index.js";
 import { applyRunResultToMergeWorkspace, cleanupMergeWorkspace, collectMergeDiff, createMergeCandidateCommit, prepareMergeWorkspace, promoteMergeCandidate, WorkspaceOpsError, } from "../workspace-ops/index.js";
 import { candidateChangedAfterChecks } from "./candidate-diff.js";
+import { runArtifactCandidateGate } from "./artifact-applicability.js";
 import { checkSkipFields, checkStatus, checksSummary, docsStatusForChangedPaths, failedBeforeChecks, failedFinishedResult, promotionNotPromoted, successfulRunSummary, } from "./result-projections.js";
+function reconcileOutcome(result, artifactGateFailure) {
+    return {
+        result,
+        ...(artifactGateFailure === undefined ? {} : { artifact_gate_failure: artifactGateFailure }),
+    };
+}
 function withPromotionReconcileEvent(result, event) {
     return {
         ...result,
@@ -40,13 +47,60 @@ export async function runPromotionReconcile(input) {
         changedPaths = diff.changed_paths;
         if (changedPaths.length === 0) {
             const summary = "Promotion reconcile produced no candidate changes.";
-            return withPromotionReconcileEvent(failedBeforeChecks({
+            return reconcileOutcome(withPromotionReconcileEvent(failedBeforeChecks({
                 summary,
                 errorCode: "promotion_reconcile_no_candidate_changes",
                 retryable: false,
                 changedPaths,
                 promotion: promotionNotPromoted("promotion_reconcile_no_candidate_changes", "No reconciled candidate changes were available for promotion."),
+            }), failedPromotionReconcileEvent({ summary, changedPaths })));
+        }
+        input.pipelineInput.on_stage?.({
+            stage: "artifact_candidate_validate",
+            summary: "validating the reconciled candidate Artifact preview.",
+        });
+        const artifactGate = await runArtifactCandidateGate({
+            repoRoot: handle.repo_root,
+            task: {
+                title: input.pipelineInput.task.title,
+                goal: input.pipelineInput.task_detail.detail.contract.goal,
+                scope: input.pipelineInput.task_detail.detail.contract.scope,
+            },
+            diff,
+            config: input.options.config,
+            apiKey: input.options.apiKey,
+            ...(input.options.promptsRoot === undefined
+                ? {}
+                : { promptsRoot: input.options.promptsRoot }),
+            ...(input.options.baseEnv === undefined ? {} : { baseEnv: input.options.baseEnv }),
+            ...(input.options.artifactApplicabilityClient === undefined
+                ? {}
+                : { client: input.options.artifactApplicabilityClient }),
+            ...(input.options.artifactApplicabilityJudge === undefined
+                ? {}
+                : { judge: input.options.artifactApplicabilityJudge }),
+            ...(input.options.validateArtifactCandidate === undefined
+                ? {}
+                : { validateCandidate: input.options.validateArtifactCandidate }),
+            ...(input.options.recordUsage === undefined
+                ? {}
+                : { recordUsage: input.options.recordUsage }),
+            activityRef: input.pipelineInput.activity_ref,
+            taskId: input.pipelineInput.task.id,
+        });
+        if (artifactGate.status === "failed") {
+            const summary = artifactGate.failure.summary;
+            const result = withPromotionReconcileEvent(failedBeforeChecks({
+                summary,
+                errorCode: artifactGate.failure.reason_code,
+                retryable: false,
+                changedPaths,
+                promotion: promotionNotPromoted(artifactGate.failure.reason_code, "Reconciled Artifact candidate validation failed, so promotion failed."),
             }), failedPromotionReconcileEvent({ summary, changedPaths }));
+            return reconcileOutcome(result, {
+                correctable: artifactGate.correctable,
+                failure: artifactGate.failure,
+            });
         }
         let docs = docsStatusForChangedPaths(changedPaths);
         const checkPlan = createNodeNpmCheckPlan({ workspaceRoot: handle.repo_root });
@@ -59,20 +113,20 @@ export async function runPromotionReconcile(input) {
         });
         if (checks.status === "failed") {
             const summary = checksSummary(checks);
-            return withPromotionReconcileEvent(failedFinishedResult({
+            return reconcileOutcome(withPromotionReconcileEvent(failedFinishedResult({
                 summary,
                 checks,
                 docs,
                 changedPaths,
                 promotion: promotionNotPromoted("promotion_reconcile_checks_failed", "Reconciled candidate checks failed, so promotion failed."),
-            }), failedPromotionReconcileEvent({ summary, changedPaths }));
+            }), failedPromotionReconcileEvent({ summary, changedPaths })));
         }
         const postChecksDiff = collectMergeDiff(handle);
         changedPaths = postChecksDiff.changed_paths;
         docs = docsStatusForChangedPaths(changedPaths);
         if (candidateChangedAfterChecks(diff, postChecksDiff)) {
             const summary = "Checks modified the reconciled candidate workspace; promotion failed.";
-            return withPromotionReconcileEvent(failedFinishedResult({
+            return reconcileOutcome(withPromotionReconcileEvent(failedFinishedResult({
                 summary,
                 checks: {
                     status: "failed",
@@ -81,11 +135,11 @@ export async function runPromotionReconcile(input) {
                 docs,
                 changedPaths,
                 promotion: promotionNotPromoted("promotion_reconcile_checks_modified_candidate", "Checks changed tracked reconciled candidate files, so promotion failed."),
-            }), failedPromotionReconcileEvent({ summary, changedPaths }));
+            }), failedPromotionReconcileEvent({ summary, changedPaths })));
         }
         const commit = createMergeCandidateCommit(handle, `Reconcile Tutti task: ${input.pipelineInput.task.title}`);
         const promotion = promoteMergeCandidate(handle, commit);
-        return withPromotionReconcileEvent({
+        return reconcileOutcome(withPromotionReconcileEvent({
             result_kind: "finished",
             outcome: "completed",
             summary: successfulRunSummary({
@@ -111,26 +165,26 @@ export async function runPromotionReconcile(input) {
             summary: "Promotion reconciled and promoted.",
             commit_oid: promotion.promoted_commit_oid,
             meta: promotionReconcileMeta(changedPaths),
-        });
+        }));
     }
     catch (error) {
         if (error instanceof WorkspaceOpsError) {
-            return withPromotionReconcileEvent(failedBeforeChecks({
+            return reconcileOutcome(withPromotionReconcileEvent(failedBeforeChecks({
                 summary: error.message,
                 errorCode: `workspace_ops_${error.code}`,
                 retryable: error.code === "conflict",
                 changedPaths,
                 promotion: promotionNotPromoted("promotion_reconcile_failed", error.message),
-            }), failedPromotionReconcileEvent({ summary: error.message, changedPaths }));
+            }), failedPromotionReconcileEvent({ summary: error.message, changedPaths })));
         }
         const summary = error instanceof Error ? error.message : "Promotion reconcile failed";
-        return withPromotionReconcileEvent(failedBeforeChecks({
+        return reconcileOutcome(withPromotionReconcileEvent(failedBeforeChecks({
             summary,
             errorCode: "promotion_reconcile_failed",
             retryable: false,
             changedPaths,
             promotion: promotionNotPromoted("promotion_reconcile_failed", summary),
-        }), failedPromotionReconcileEvent({ summary, changedPaths }));
+        }), failedPromotionReconcileEvent({ summary, changedPaths })));
     }
     finally {
         if (handle !== undefined) {

package/dist/server-shell/cli/launch.d.ts

@@ -11,6 +11,8 @@ export type LaunchPreparationOptions = {
     now?: () => Date;
     confirm?: LaunchConfirmationHandler;
     allowWorkspaceRootTakeover?: boolean;
+    projectDisplayName?: string;
+    projectDescription?: string;
 };
 export type LaunchProviderStatus = OpenAiProviderConfigProjection["status"];
 export type LaunchPreparationResult = {

package/dist/server-shell/cli/launch.js

@@ -4,7 +4,7 @@ import { readOpenAiProviderConfigProjection, resolveTuttiHome, } from "../../pro
 import { LaunchError } from "./errors.js";
 import { assertSafeProjectRoot, ensureGitBootstrap, } from "./git-bootstrap.js";
 import { ensureMachineProjectBinding } from "./machine-local.js";
-import { readProjectIdentity, readProjectDisplayName, writeProjectIdentity, } from "./project-identity.js";
+import { readProjectIdentity, readProjectDisplayName, writeProjectDescription, writeProjectDisplayName, writeProjectIdentity, } from "./project-identity.js";
 const DEFAULT_RELAY_URL = "https://tutti.now";
 const DEFAULT_HOST_ENDPOINT_HOST = "127.0.0.1";
 const AUTO_HOST_ENDPOINT_PORT = 0;
@@ -64,6 +64,12 @@ export async function prepareLaunchProject(options) {
         gitOptions.confirm = options.confirm;
     }
     const git = await ensureGitBootstrap(gitOptions);
+    if (projectIdentityCreated && options.projectDisplayName !== undefined) {
+        writeProjectDisplayName(workspaceRoot, options.projectDisplayName);
+    }
+    if (projectIdentityCreated && options.projectDescription !== undefined) {
+        writeProjectDescription(workspaceRoot, options.projectDescription);
+    }
     const bindingOptions = {
         tuttiHome,
         projectId,

package/dist/server-shell/http/host-tunnel.js

@@ -64,7 +64,7 @@ function toInjectMethod(method) {
         case "OPTIONS":
             return normalized;
         default:
-            return "GET";
+            return "TRACE";
     }
 }
 export function createHostProjectApiTunnelRequestHandler(options) {

package/dist/server-shell/http/routes/project-api/artifacts-routes.js

@@ -1,13 +1,46 @@
 import { HeartbeatArtifactPreviewBodySchema, HeartbeatArtifactPreviewResponseSchema, GetArtifactsResponseSchema, StartArtifactPreviewBodySchema, StartArtifactPreviewResponseSchema, StopArtifactPreviewBodySchema, StopArtifactPreviewResponseSchema, } from "@tutti/shared/schemas/api";
-import { ARTIFACT_PREVIEW_CSP, ArtifactPreviewManager, readArtifactProjection, readArtifactStaticPreview, } from "../../../../artifacts/index.js";
+import { ARTIFACT_PREVIEW_REQUEST_BODY_LIMIT_BYTES, ARTIFACT_PREVIEW_CSP, ArtifactPreviewManager, isArtifactPreviewHttpMethod, readArtifactProjection, readArtifactStaticPreview, } from "../../../../artifacts/index.js";
+import { WorkspaceOpsError } from "../../../../workspace-ops/index.js";
 import { executeIdempotentCommand } from "../../../command-idempotency/index.js";
 import { HOST_PROJECT_API_BASE_PATH } from "./constants.js";
 import { requireHostProjectSession, requireProjectStore, requireWorkspaceRoot, } from "./session-requirements.js";
 function artifactInvalidates() {
     return [{ kind: "artifacts" }];
 }
+const ARTIFACT_PREVIEW_ALLOWED_METHODS = "GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS";
+function previewRequestHeaders(request) {
+    const headers = {};
+    for (const [name, value] of Object.entries(request.headers)) {
+        if (typeof value === "string") {
+            headers[name] = value;
+        }
+    }
+    return headers;
+}
+function previewRequestBody(body) {
+    if (body === undefined || body === null) {
+        return undefined;
+    }
+    if (Buffer.isBuffer(body)) {
+        return body;
+    }
+    if (body instanceof Uint8Array) {
+        return Buffer.from(body);
+    }
+    if (typeof body === "string") {
+        return Buffer.from(body, "utf8");
+    }
+    return Buffer.from(JSON.stringify(body), "utf8");
+}
+function requireCurrentArtifactManifestMarker(request, manifestBlobOid) {
+    const marker = new URL(request.url, "http://artifact.invalid").searchParams.get("v");
+    if (marker !== null && marker !== manifestBlobOid) {
+        throw new WorkspaceOpsError("not_found", "Artifact preview manifest is stale");
+    }
+}
 export function registerArtifactsRoutes(app, { options, workspaceEvents, }) {
     const artifactPreviewManager = new ArtifactPreviewManager({
+        ...options.artifactPreview,
         ...(options.now === undefined ? {} : { now: options.now }),
         onStatusChange: () => {
             workspaceEvents.publish({
@@ -20,9 +53,8 @@ export function registerArtifactsRoutes(app, { options, workspaceEvents, }) {
             });
         },
     });
-    app.addHook("onClose", (_instance, done) => {
-        artifactPreviewManager.stopAll();
-        done();
+    app.addHook("onClose", async () => {
+        await artifactPreviewManager.stopAll();
     });
     app.get(`${HOST_PROJECT_API_BASE_PATH}/artifacts`, {
         schema: {
@@ -36,27 +68,37 @@ export function registerArtifactsRoutes(app, { options, workspaceEvents, }) {
             workspaceRoot: requireWorkspaceRoot(options),
         });
     });
-    app.get("/artifacts/preview/*", async (request, reply) => {
+    app.all("/artifacts/preview/*", {
+        bodyLimit: ARTIFACT_PREVIEW_REQUEST_BODY_LIMIT_BYTES,
+    }, async (request, reply) => {
         requireHostProjectSession(request, options);
+        const method = request.method.toUpperCase();
+        if (!isArtifactPreviewHttpMethod(method)) {
+            void reply
+                .code(405)
+                .header("allow", ARTIFACT_PREVIEW_ALLOWED_METHODS)
+                .send("Artifact preview method is not allowed");
+            return;
+        }
         const workspaceRoot = requireWorkspaceRoot(options);
         const projection = readArtifactProjection({
             workspaceRoot,
             ...(options.now === undefined ? {} : { now: options.now }),
         });
-        if (projection.artifact.status === "declared" && projection.artifact.artifact.kind === "server") {
+        if (projection.artifact.status === "declared") {
+            requireCurrentArtifactManifestMarker(request, projection.artifact.manifest_blob_oid);
+        }
+        if (projection.artifact.status === "declared" &&
+            projection.artifact.artifact.kind === "server") {
             const queryIndex = request.url.indexOf("?");
+            const body = previewRequestBody(request.body);
             const preview = await artifactPreviewManager.fetchServerPreview({
                 workspaceRoot,
                 path: request.params["*"],
+                method,
                 ...(queryIndex < 0 ? {} : { query: request.url.slice(queryIndex + 1) }),
-                headers: {
-                    ...(typeof request.headers.accept === "string"
-                        ? { accept: request.headers.accept }
-                        : {}),
-                    ...(typeof request.headers["accept-language"] === "string"
-                        ? { "accept-language": request.headers["accept-language"] }
-                        : {}),
-                },
+                headers: previewRequestHeaders(request),
+                ...(body === undefined ? {} : { body }),
             });
             for (const [key, value] of Object.entries(preview.headers)) {
                 void reply.header(key, value);
@@ -69,6 +111,13 @@ export function registerArtifactsRoutes(app, { options, workspaceEvents, }) {
                 .send(preview.content);
             return;
         }
+        if (method !== "GET" && method !== "HEAD") {
+            void reply
+                .code(405)
+                .header("allow", "GET, HEAD")
+                .send("Static Artifact previews only support GET and HEAD");
+            return;
+        }
         const preview = readArtifactStaticPreview({
             workspaceRoot,
             path: request.params["*"],

package/dist/server-shell/http/routes/project-api/types.d.ts

@@ -1,6 +1,7 @@
 import type { ReadOnlyChatAssistantHandle } from "../../../../chat-assistant/index.js";
 import type { Phase5ControlPlane } from "../../../../control-plane/index.js";
 import type { ApprovalRequestManager } from "../../../../approvals/index.js";
+import type { ArtifactPreviewManagerOptions } from "../../../../artifacts/index.js";
 import type { HostProjectStore } from "../../../../store/index.js";
 import type { ProjectId, RelayProjectRef } from "@tutti/shared/ids";
 import type { AccountAvatarProjection } from "@tutti/shared/domain";
@@ -72,6 +73,7 @@ export type HostProjectApiCapabilities = {
     clarification: boolean;
 };
 export type HostProjectApiRouteOptions = {
+    artifactPreview?: Omit<ArtifactPreviewManagerOptions, "now" | "onStatusChange">;
     project: {
         project_id: ProjectId;
         display_name: string;

package/dist/server-shell/local-console/project-service.d.ts

@@ -23,6 +23,10 @@ export type LocalConsoleProviderInput = {
     api_key: string;
     model: string;
 };
+export type LocalConsoleProjectMetadataInput = {
+    display_name: string;
+    description?: string;
+};
 export type LocalConsoleLaunchResult = {
     project: LocalConsoleProject;
     project_created: boolean;
@@ -59,6 +63,7 @@ export declare class LocalConsoleProjectService {
     }>;
     launchProject(input: {
         workspacePath: string;
+        project?: LocalConsoleProjectMetadataInput;
         provider?: LocalConsoleProviderInput;
     }, context: LocalConsoleInvocationContext): Promise<LocalConsoleLaunchResult>;
     openProject(projectId: string, context: LocalConsoleInvocationContext): Promise<LocalConsoleOpenResult>;

package/dist/server-shell/local-console/project-service.js

@@ -50,6 +50,20 @@ function validateProvider(input) {
     }
     return provider;
 }
+function validateProjectMetadata(input) {
+    const displayName = input.display_name.trim();
+    const description = input.description?.trim();
+    if (displayName === "" || displayName.length > 80) {
+        throw new LocalConsoleProjectError("project_display_name_invalid", "Project name must be between 1 and 80 characters.");
+    }
+    if (description !== undefined && description.length > 160) {
+        throw new LocalConsoleProjectError("project_description_invalid", "Project description cannot exceed 160 characters.");
+    }
+    return {
+        display_name: displayName,
+        ...(description === undefined || description === "" ? {} : { description }),
+    };
+}
 function projectFromRuntimeRow(row, providerStatus, providerModel, metadata) {
     const currentVersion = readCliVersion();
     const openUrl = projectOpenUrl(metadata.relayUrl, row.relay_project_ref);
@@ -220,6 +234,9 @@ export class LocalConsoleProjectService {
         }
         const launch = this.#runMutation(async () => await this.#launchProject({
             workspacePath,
+            ...(input.project === undefined
+                ? {}
+                : { project: validateProjectMetadata(input.project) }),
             ...(input.provider === undefined ? {} : { provider: validateProvider(input.provider) }),
         }, context)).finally(() => {
             this.#launches.delete(workspacePath);
@@ -234,6 +251,14 @@ export class LocalConsoleProjectService {
             preparation = await prepareLaunchProject({
                 workspacePath: input.workspacePath,
                 yes: true,
+                ...(input.project === undefined
+                    ? {}
+                    : {
+                        projectDisplayName: input.project.display_name,
+                        ...(input.project.description === undefined
+                            ? {}
+                            : { projectDescription: input.project.description }),
+                    }),
                 ...operation,
             });
         }

package/dist/server-shell/local-console/server.js

@@ -256,6 +256,15 @@ export function createLocalConsoleServer(options) {
                 additionalProperties: false,
                 properties: {
                     workspace_path: { type: "string", minLength: 1, maxLength: 4096 },
+                    project: {
+                        type: "object",
+                        required: ["display_name"],
+                        additionalProperties: false,
+                        properties: {
+                            display_name: { type: "string", minLength: 1, maxLength: 80 },
+                            description: { type: "string", maxLength: 160 },
+                        },
+                    },
                     provider: {
                         type: "object",
                         required: ["base_url", "api_key", "model"],
@@ -273,6 +282,7 @@ export function createLocalConsoleServer(options) {
         const session = requireSession(request, true);
         return await projects.launchProject({
             workspacePath: request.body.workspace_path,
+            ...(request.body.project === undefined ? {} : { project: request.body.project }),
             ...(request.body.provider === undefined ? {} : { provider: request.body.provider }),
         }, session.context);
     });

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

@@ -4,7 +4,7 @@ export { initializeProjectDocs, readProjectDocsInitializationStatus, syncProject
 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, prepareMergeWorkspace, prepareRunWorkspace, promoteMergeCandidate, promoteRunResult, } from "./run-workspaces.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";

package/dist/workspace-ops/index.js

@@ -4,6 +4,6 @@ export { initializeProjectDocs, readProjectDocsInitializationStatus, syncProject
 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, prepareMergeWorkspace, prepareRunWorkspace, promoteMergeCandidate, promoteRunResult, } from "./run-workspaces.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/run-workspaces.d.ts

@@ -1,4 +1,5 @@
 import type { CleanupRunWorkspaceResult, CleanupStaleRunWorkspacesResult, MergeWorkspaceHandle, PrepareMergeWorkspaceOptions, PrepareRunWorkspaceOptions, PromotionResult, ResultCommit, RunDiffSummary, RunWorkspaceHandle } from "./types.js";
+export declare function fingerprintWorkspaceCandidate(repoRoot: string): string;
 export declare function prepareRunWorkspace(options: PrepareRunWorkspaceOptions): RunWorkspaceHandle;
 export declare function collectRunDiff(handle: RunWorkspaceHandle): RunDiffSummary;
 export declare function createResultCommit(handle: RunWorkspaceHandle, summary: string): ResultCommit;

package/dist/workspace-ops/run-workspaces.js

@@ -1,10 +1,37 @@
 import { existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
+import { createHash } from "node:crypto";
 import { join } from "node:path";
 import { classifyViewerPath } from "@tutti/shared/utils";
 import { WorkspaceOpsError } from "./errors.js";
 import { runGit, runGitRaw, runGitText, stagedChangesExist, summarizeGitFailure, tryGitText, } from "./git.js";
 import { requireMainlineWriteReady } from "./mainline.js";
 const MAX_RUN_DIFF_SUMMARY_BYTES = 32 * 1024;
+export function fingerprintWorkspaceCandidate(repoRoot) {
+    const status = runGitRaw(["status", "--porcelain=v1", "-z"], repoRoot);
+    if (status.status !== 0) {
+        throw new WorkspaceOpsError("git_failed", summarizeGitFailure(["status"], status));
+    }
+    const diff = runGitRaw(["diff", "--binary", "HEAD", "--"], repoRoot);
+    if (diff.status !== 0) {
+        throw new WorkspaceOpsError("git_failed", summarizeGitFailure(["diff", "HEAD"], diff));
+    }
+    const untracked = runGitRaw(["ls-files", "--others", "--exclude-standard", "-z"], repoRoot);
+    if (untracked.status !== 0) {
+        throw new WorkspaceOpsError("git_failed", summarizeGitFailure(["ls-files", "--others"], untracked));
+    }
+    const hash = createHash("sha256").update(status.stdout).update(diff.stdout);
+    for (const path of untracked.stdout.toString("utf8").split("\0")) {
+        if (path.length === 0) {
+            continue;
+        }
+        const object = runGitRaw(["hash-object", "--no-filters", "--", path], repoRoot);
+        if (object.status !== 0) {
+            throw new WorkspaceOpsError("git_failed", summarizeGitFailure(["hash-object"], object));
+        }
+        hash.update(path).update("\0").update(object.stdout);
+    }
+    return hash.digest("hex");
+}
 function runWorkspaceTempBranch(taskId, activityRef) {
     return `tutti/run/${taskId}/${activityRef}`;
 }

package/node_modules/@tutti/shared/dist/schemas/api/artifacts.d.ts

@@ -6,15 +6,14 @@ export declare const ArtifactStaticManifestSchema: import("@sinclair/typebox").T
     kind: import("@sinclair/typebox").TLiteral<"static">;
     root: import("@sinclair/typebox").TString;
     entry: import("@sinclair/typebox").TString;
-    network: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    network: import("@sinclair/typebox").TBoolean;
 }>;
 export declare const ArtifactServerManifestSchema: import("@sinclair/typebox").TObject<{
     title: import("@sinclair/typebox").TString;
     kind: import("@sinclair/typebox").TLiteral<"server">;
     cwd: import("@sinclair/typebox").TString;
-    script: import("@sinclair/typebox").TLiteral<"artifact:preview">;
-    ready_path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    network: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    entry: import("@sinclair/typebox").TString;
+    network: import("@sinclair/typebox").TBoolean;
 }>;
 export declare const ArtifactManifestSchema: import("@sinclair/typebox").TObject<{
     version: import("@sinclair/typebox").TLiteral<1>;
@@ -23,14 +22,13 @@ export declare const ArtifactManifestSchema: import("@sinclair/typebox").TObject
         kind: import("@sinclair/typebox").TLiteral<"static">;
         root: import("@sinclair/typebox").TString;
         entry: import("@sinclair/typebox").TString;
-        network: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        network: import("@sinclair/typebox").TBoolean;
     }>, import("@sinclair/typebox").TObject<{
         title: import("@sinclair/typebox").TString;
         kind: import("@sinclair/typebox").TLiteral<"server">;
         cwd: import("@sinclair/typebox").TString;
-        script: import("@sinclair/typebox").TLiteral<"artifact:preview">;
-        ready_path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-        network: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        entry: import("@sinclair/typebox").TString;
+        network: import("@sinclair/typebox").TBoolean;
     }>]>;
 }>;
 export declare const ArtifactPreviewStatusSchema: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"ready">, import("@sinclair/typebox").TLiteral<"starting">, import("@sinclair/typebox").TLiteral<"stopped">, import("@sinclair/typebox").TLiteral<"failed">]>;
@@ -94,6 +92,28 @@ export declare const GetArtifactsResponseSchema: import("@sinclair/typebox").TOb
         }>;
     }>]>;
 }>;
+export declare const IssueArtifactPreviewSessionPayloadSchema: import("@sinclair/typebox").TObject<{}>;
+export declare const IssueArtifactPreviewSessionDispositionSchema: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+    kind: import("@sinclair/typebox").TLiteral<"issued">;
+}>, import("@sinclair/typebox").TObject<{
+    kind: import("@sinclair/typebox").TLiteral<"not_declared">;
+}>, import("@sinclair/typebox").TObject<{
+    kind: import("@sinclair/typebox").TLiteral<"invalid_manifest">;
+    message: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    kind: import("@sinclair/typebox").TLiteral<"preview_not_ready">;
+    status: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"starting">, import("@sinclair/typebox").TLiteral<"stopped">, import("@sinclair/typebox").TLiteral<"failed">]>;
+    message: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>, import("@sinclair/typebox").TObject<{
+    kind: import("@sinclair/typebox").TLiteral<"interrupted">;
+    retry_with_new_command_id: import("@sinclair/typebox").TLiteral<true>;
+}>]>;
+export declare const IssueArtifactPreviewSessionResultSchema: import("@sinclair/typebox").TObject<{
+    bootstrap_url: import("@sinclair/typebox").TString;
+    expires_at: import("@sinclair/typebox").TString;
+}>;
+export declare const IssueArtifactPreviewSessionBodySchema: import("@sinclair/typebox").TSchema;
+export declare const IssueArtifactPreviewSessionResponseSchema: import("@sinclair/typebox").TSchema;
 export declare const ArtifactPreviewCommandPayloadSchema: import("@sinclair/typebox").TObject<{}>;
 export declare const StartArtifactPreviewDispositionSchema: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
     kind: import("@sinclair/typebox").TLiteral<"started">;

package/node_modules/@tutti/shared/dist/schemas/api/artifacts.js

@@ -1,23 +1,23 @@
 import { Type } from "@sinclair/typebox";
+import { IsoDateTimeStringSchema } from "../domain/index.js";
 import { InterruptedCommandDispositionSchema, NonEmptyStringSchema, commandEnvelopeSchema, commandResponseWithResultSchema, } from "./primitives.js";
-import { ViewerPathSchema } from "./viewer-reference.js";
 export const ArtifactManifestPathSchema = Type.Literal("tutti.artifact.json");
 export const ArtifactKindSchema = Type.Union([Type.Literal("static"), Type.Literal("server")]);
-export const ArtifactTitleSchema = Type.String({ minLength: 1, maxLength: 120 });
+export const ArtifactTitleSchema = Type.String({ minLength: 1, maxLength: 120, pattern: "\\S" });
+const ArtifactRepoPathSchema = Type.String({ minLength: 1 });
 export const ArtifactStaticManifestSchema = Type.Object({
     title: ArtifactTitleSchema,
     kind: Type.Literal("static"),
-    root: ViewerPathSchema,
-    entry: ViewerPathSchema,
-    network: Type.Optional(Type.Boolean()),
+    root: ArtifactRepoPathSchema,
+    entry: ArtifactRepoPathSchema,
+    network: Type.Boolean(),
 }, { additionalProperties: false });
 export const ArtifactServerManifestSchema = Type.Object({
     title: ArtifactTitleSchema,
     kind: Type.Literal("server"),
-    cwd: ViewerPathSchema,
-    script: Type.Literal("artifact:preview"),
-    ready_path: Type.Optional(Type.String({ minLength: 1, maxLength: 256, pattern: "^/" })),
-    network: Type.Optional(Type.Boolean()),
+    cwd: ArtifactRepoPathSchema,
+    entry: Type.String({ minLength: 1, maxLength: 256, pattern: "^/" }),
+    network: Type.Boolean(),
 }, { additionalProperties: false });
 export const ArtifactManifestSchema = Type.Object({
     version: Type.Literal(1),
@@ -62,6 +62,31 @@ export const ArtifactProjectionSchema = Type.Union([
 export const GetArtifactsResponseSchema = Type.Object({
     artifact: ArtifactProjectionSchema,
 }, { additionalProperties: false });
+export const IssueArtifactPreviewSessionPayloadSchema = Type.Object({}, { additionalProperties: false });
+export const IssueArtifactPreviewSessionDispositionSchema = Type.Union([
+    Type.Object({ kind: Type.Literal("issued") }, { additionalProperties: false }),
+    Type.Object({ kind: Type.Literal("not_declared") }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("invalid_manifest"),
+        message: NonEmptyStringSchema,
+    }, { additionalProperties: false }),
+    Type.Object({
+        kind: Type.Literal("preview_not_ready"),
+        status: Type.Union([
+            Type.Literal("starting"),
+            Type.Literal("stopped"),
+            Type.Literal("failed"),
+        ]),
+        message: Type.Optional(NonEmptyStringSchema),
+    }, { additionalProperties: false }),
+    InterruptedCommandDispositionSchema,
+]);
+export const IssueArtifactPreviewSessionResultSchema = Type.Object({
+    bootstrap_url: Type.String({ minLength: 1 }),
+    expires_at: IsoDateTimeStringSchema,
+}, { additionalProperties: false });
+export const IssueArtifactPreviewSessionBodySchema = commandEnvelopeSchema(IssueArtifactPreviewSessionPayloadSchema);
+export const IssueArtifactPreviewSessionResponseSchema = commandResponseWithResultSchema(IssueArtifactPreviewSessionDispositionSchema, IssueArtifactPreviewSessionResultSchema);
 export const ArtifactPreviewCommandPayloadSchema = Type.Object({}, { additionalProperties: false });
 export const StartArtifactPreviewDispositionSchema = Type.Union([
     Type.Object({ kind: Type.Literal("started") }, { additionalProperties: false }),