@opengeni/db 3.7.4 → 4.0.0-canary.0

package/src/workspace-artifacts.ts

@@ -1,10 +1,14 @@
-import type {
-  WorkspaceArtifact,
-  WorkspaceArtifactDetailResponse,
-  WorkspaceArtifactEvent,
-  WorkspaceArtifactMutationResponse,
-  WorkspaceArtifactVersion,
+import {
+  WorkspaceArtifactRequestedTools,
+  type ToolGatewayIdentity,
+  type WorkspaceArtifact,
+  type WorkspaceArtifactDetailResponse,
+  type WorkspaceArtifactEvent,
+  type WorkspaceArtifactMutationResponse,
+  type WorkspaceArtifactVersion,
 } from "@opengeni/contracts";
+import { parseVerifiedAttemptToolCatalog } from "@opengeni/codemode";
+import { createHash } from "node:crypto";
 import { and, desc, eq, lt, or, sql } from "drizzle-orm";
 import type { Database } from "./database";
 import { withRlsContext, withWorkspaceRls } from "./database";
@@ -13,7 +17,12 @@ import * as schema from "./schema";
 type ArtifactRow = typeof schema.workspaceArtifacts.$inferSelect;
 type VersionRow = typeof schema.workspaceArtifactVersions.$inferSelect;
 type EventRow = typeof schema.workspaceArtifactEvents.$inferSelect;
-type ArtifactMutationToolName = "artifacts_create" | "artifacts_publish" | "artifacts_rollback";
+type ArtifactMutationToolName =
+  | "artifacts_create"
+  | "artifacts_publish"
+  | "artifacts_rollback"
+  | "artifacts_archive"
+  | "artifacts_restore";
 
 export class WorkspaceArtifactNotFoundError extends Error {
   readonly name = "WorkspaceArtifactNotFoundError";
@@ -47,6 +56,9 @@ function versionFromRow(row: VersionRow): WorkspaceArtifactVersion {
     contentType: "text/html",
     contentSha256: row.contentSha256,
     sizeBytes: row.sizeBytes,
+    sourceSha256: row.sourceSha256,
+    sourceSizeBytes: row.sourceSizeBytes,
+    requestedTools: WorkspaceArtifactRequestedTools.parse(row.requestedTools),
     sourceSessionId: row.sourceSessionId,
     sourceTurnId: row.sourceTurnId,
     sourceAttemptId: row.sourceAttemptId,
@@ -125,23 +137,34 @@ async function artifactRow(scopedDb: any, workspaceId: string, artifactId: strin
 export async function listWorkspaceArtifacts(
   db: Database,
   workspaceId: string,
-  options: { limit?: number; cursor?: string } = {},
-): Promise<{ artifacts: WorkspaceArtifact[]; nextCursor: string | null; truncated: boolean }> {
+  options: {
+    limit?: number;
+    cursor?: string;
+    status?: "active" | "archived";
+  } = {},
+): Promise<{
+  artifacts: WorkspaceArtifact[];
+  nextCursor: string | null;
+  truncated: boolean;
+}> {
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
     const limit = Math.min(Math.max(options.limit ?? 50, 1), 100);
     const cursor = options.cursor ? decodeListCursor(options.cursor) : null;
-    const visibility = cursor
-      ? and(
-          eq(schema.workspaceArtifacts.workspaceId, workspaceId),
-          or(
-            lt(schema.workspaceArtifacts.updatedAt, cursor.updatedAt),
-            and(
-              eq(schema.workspaceArtifacts.updatedAt, cursor.updatedAt),
-              lt(schema.workspaceArtifacts.id, cursor.id),
+    const visibility = and(
+      eq(schema.workspaceArtifacts.workspaceId, workspaceId),
+      ...(options.status ? [eq(schema.workspaceArtifacts.status, options.status)] : []),
+      ...(cursor
+        ? [
+            or(
+              lt(schema.workspaceArtifacts.updatedAt, cursor.updatedAt),
+              and(
+                eq(schema.workspaceArtifacts.updatedAt, cursor.updatedAt),
+                lt(schema.workspaceArtifacts.id, cursor.id),
+              ),
             ),
-          ),
-        )
-      : eq(schema.workspaceArtifacts.workspaceId, workspaceId);
+          ]
+        : []),
+    );
     const rows = await scopedDb
       .select()
       .from(schema.workspaceArtifacts)
@@ -237,7 +260,12 @@ export async function getWorkspaceArtifactContentRef(
   workspaceId: string,
   artifactId: string,
   versionId?: string,
-): Promise<{ artifactId: string; version: WorkspaceArtifactVersion; contentKey: string }> {
+): Promise<{
+  artifactId: string;
+  version: WorkspaceArtifactVersion;
+  contentKey: string;
+  sourceKey: string | null;
+}> {
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
     const artifact = await artifactRow(scopedDb, workspaceId, artifactId);
     if (!artifact) throw new WorkspaceArtifactNotFoundError("Artifact not found");
@@ -255,7 +283,12 @@ export async function getWorkspaceArtifactContentRef(
       )
       .limit(1);
     if (!version) throw new WorkspaceArtifactNotFoundError("Artifact version not found");
-    return { artifactId, version: versionFromRow(version), contentKey: version.contentKey };
+    return {
+      artifactId,
+      version: versionFromRow(version),
+      contentKey: version.contentKey,
+      sourceKey: version.sourceKey,
+    };
   });
 }
 
@@ -265,6 +298,10 @@ type PublishMetadata = {
   contentKey: string;
   contentSha256: string;
   sizeBytes: number;
+  sourceKey: string;
+  sourceSha256: string;
+  sourceSizeBytes: number;
+  requestedTools?: ToolGatewayIdentity[];
   operationKey: string;
   actorSubjectId: string;
   sourceSessionId: string | null;
@@ -273,8 +310,70 @@ type PublishMetadata = {
   sourceExecutionGeneration: number | null;
   sourceToolName: ArtifactMutationToolName | null;
   persistContent: () => Promise<void>;
+  discardContent: () => Promise<void>;
 };
 
+async function discardPersistedArtifactContent(
+  input: Pick<PublishMetadata, "discardContent">,
+  error: unknown,
+): Promise<never> {
+  await input.discardContent().catch(() => undefined);
+  throw error;
+}
+
+type ArtifactOperationReplay = NonNullable<Awaited<ReturnType<typeof replayForOperation>>>;
+
+function persistedArtifactContentIsReferenced(
+  replay: ArtifactOperationReplay,
+  input: Pick<PublishMetadata, "contentKey" | "sourceKey">,
+): boolean {
+  return (
+    replay.version.contentKey === input.contentKey || replay.version.sourceKey === input.sourceKey
+  );
+}
+
+async function reconcilePersistedArtifactMutation(
+  db: Database,
+  input: PublishMetadata,
+  error: unknown,
+  validateReplay: (replay: ArtifactOperationReplay) => void,
+): Promise<WorkspaceArtifactMutationResponse> {
+  let replay: ArtifactOperationReplay | null;
+  try {
+    replay = await withRlsContext(
+      db,
+      { accountId: input.accountId, workspaceId: input.workspaceId },
+      async (scopedDb) => {
+        await lockOperation(scopedDb, input.workspaceId, input.operationKey);
+        return await replayForOperation(scopedDb, input.workspaceId, input.operationKey);
+      },
+    );
+  } catch {
+    // The transaction outcome is still unknown. Leaking an unreferenced object
+    // is recoverable; deleting content that may have committed is not.
+    throw error;
+  }
+  if (!replay) return await discardPersistedArtifactContent(input, error);
+  try {
+    validateReplay(replay);
+  } catch (replayError) {
+    if (!persistedArtifactContentIsReferenced(replay, input)) {
+      await input.discardContent().catch(() => undefined);
+    }
+    throw replayError;
+  }
+  if (!persistedArtifactContentIsReferenced(replay, input)) {
+    await input.discardContent().catch(() => undefined);
+  }
+  return mutationResult(
+    replay.artifact,
+    replay.version,
+    replay.event,
+    true,
+    replay.current ?? replay.version,
+  );
+}
+
 async function assertAttemptAuthority(
   scopedDb: any,
   input: Pick<
@@ -368,6 +467,61 @@ async function assertAttemptAuthority(
   }
 }
 
+async function assertArtifactRequestedToolsInAttemptCatalog(
+  scopedDb: any,
+  input: Pick<
+    PublishMetadata,
+    | "accountId"
+    | "workspaceId"
+    | "sourceSessionId"
+    | "sourceTurnId"
+    | "sourceAttemptId"
+    | "sourceExecutionGeneration"
+  >,
+  requestedTools: readonly ToolGatewayIdentity[],
+): Promise<void> {
+  if (input.sourceAttemptId === null || requestedTools.length === 0) return;
+  if (
+    input.sourceSessionId === null ||
+    input.sourceTurnId === null ||
+    input.sourceExecutionGeneration === null
+  ) {
+    throw new WorkspaceArtifactOperationError("Artifact attempt provenance is incomplete");
+  }
+  const [row] = await scopedDb
+    .select({ catalog: schema.sessionAttemptToolCatalogs.catalog })
+    .from(schema.sessionAttemptToolCatalogs)
+    .where(
+      and(
+        eq(schema.sessionAttemptToolCatalogs.accountId, input.accountId),
+        eq(schema.sessionAttemptToolCatalogs.workspaceId, input.workspaceId),
+        eq(schema.sessionAttemptToolCatalogs.sessionId, input.sourceSessionId),
+        eq(schema.sessionAttemptToolCatalogs.turnId, input.sourceTurnId),
+        eq(schema.sessionAttemptToolCatalogs.attemptId, input.sourceAttemptId),
+        eq(schema.sessionAttemptToolCatalogs.executionGeneration, input.sourceExecutionGeneration),
+      ),
+    )
+    .limit(1);
+  let allowed: Set<string>;
+  try {
+    const catalog = parseVerifiedAttemptToolCatalog(row?.catalog);
+    allowed = new Set(catalog.entries.map((entry) => toolIdentityKey(entry.identity)));
+  } catch {
+    throw new WorkspaceArtifactOperationError(
+      "Artifact requested tool authority is unavailable for the exact attempt",
+    );
+  }
+  if (requestedTools.some((identity) => !allowed.has(toolIdentityKey(identity)))) {
+    throw new WorkspaceArtifactOperationError(
+      "Artifact requested tools must be present in the exact attempt tool catalog",
+    );
+  }
+}
+
+function toolIdentityKey(identity: ToolGatewayIdentity): string {
+  return `${identity.serverId}\u0000${identity.toolName}`;
+}
+
 async function replayForOperation(scopedDb: any, workspaceId: string, operationKey: string) {
   const [event] = await scopedDb
     .select()
@@ -385,10 +539,35 @@ async function replayForOperation(scopedDb: any, workspaceId: string, operationK
   const [version] = await scopedDb
     .select()
     .from(schema.workspaceArtifactVersions)
-    .where(eq(schema.workspaceArtifactVersions.id, event.toVersionId))
+    .where(
+      and(
+        eq(schema.workspaceArtifactVersions.workspaceId, workspaceId),
+        eq(schema.workspaceArtifactVersions.id, event.toVersionId),
+      ),
+    )
     .limit(1);
   if (!version) return null;
-  return { artifact, version, event, current: await currentVersion(scopedDb, artifact) } as const;
+  let fromVersion: VersionRow | null = null;
+  if (event.fromVersionId) {
+    const [row] = await scopedDb
+      .select()
+      .from(schema.workspaceArtifactVersions)
+      .where(
+        and(
+          eq(schema.workspaceArtifactVersions.workspaceId, workspaceId),
+          eq(schema.workspaceArtifactVersions.id, event.fromVersionId),
+        ),
+      )
+      .limit(1);
+    fromVersion = row ?? null;
+  }
+  return {
+    artifact,
+    version,
+    fromVersion,
+    event,
+    current: await currentVersion(scopedDb, artifact),
+  } as const;
 }
 
 async function lockOperation(scopedDb: any, workspaceId: string, operationKey: string) {
@@ -410,6 +589,30 @@ function assertCreateReplay(replay: Awaited<ReturnType<typeof replayForOperation
   }
 }
 
+function assertCreateReplayMatchesInput(
+  replay: ArtifactOperationReplay,
+  input: PublishMetadata & {
+    slug: string;
+    title: string;
+    description: string | null;
+    requestedSlug?: string | null;
+  },
+): void {
+  assertCreateReplay(replay);
+  const requestDigest = createArtifactRequestDigest(input);
+  if (replay.event.requestDigest !== null && replay.event.requestDigest !== requestDigest) {
+    throw new WorkspaceArtifactConflictError(
+      "Idempotency key was already used with different artifact metadata",
+    );
+  }
+  if (replay.version.contentSha256 !== input.contentSha256) {
+    throw new WorkspaceArtifactConflictError(
+      "Idempotency key was already used with different content",
+    );
+  }
+  assertReplayVersionMetadata(replay.version, input, input.requestedTools ?? []);
+}
+
 function assertPublishReplay(
   replay: Awaited<ReturnType<typeof replayForOperation>>,
   artifactId: string,
@@ -427,6 +630,83 @@ function assertPublishReplay(
   }
 }
 
+function assertPublishReplayMatchesInput(
+  replay: ArtifactOperationReplay,
+  input: PublishMetadata & {
+    artifactId: string;
+    expectedCurrentVersionId: string;
+  },
+): void {
+  assertPublishReplay(replay, input.artifactId, input.expectedCurrentVersionId);
+  const expectedRequestedTools = input.requestedTools ?? replay.fromVersion?.requestedTools;
+  if (!expectedRequestedTools) {
+    throw new WorkspaceArtifactConflictError(
+      "Idempotency key was already used for a publication with missing source authority",
+    );
+  }
+  const requestDigest = publishArtifactRequestDigest(input, expectedRequestedTools);
+  if (replay.event.requestDigest !== null && replay.event.requestDigest !== requestDigest) {
+    throw new WorkspaceArtifactConflictError(
+      "Idempotency key was already used with different publication metadata",
+    );
+  }
+  if (replay.version.contentSha256 !== input.contentSha256) {
+    throw new WorkspaceArtifactConflictError(
+      "Idempotency key was already used with different content",
+    );
+  }
+  assertReplayVersionMetadata(replay.version, input, expectedRequestedTools);
+}
+
+function hashArtifactRequest(value: unknown): string {
+  return createHash("sha256").update(JSON.stringify(value), "utf8").digest("hex");
+}
+
+function createArtifactRequestDigest(
+  input: PublishMetadata & {
+    slug: string;
+    title: string;
+    description: string | null;
+    requestedSlug?: string | null;
+  },
+): string {
+  return hashArtifactRequest({
+    version: 1,
+    operation: "create",
+    requestedSlug: input.requestedSlug === undefined ? input.slug : input.requestedSlug,
+    title: input.title,
+    description: input.description,
+    contentSha256: input.contentSha256,
+    sourceSha256: input.sourceSha256,
+    requestedTools: input.requestedTools ?? [],
+  });
+}
+
+function publishArtifactRequestDigest(
+  input: PublishMetadata & {
+    artifactId: string;
+    expectedCurrentVersionId: string;
+    title?: string;
+    description?: string | null;
+  },
+  requestedTools: readonly ToolGatewayIdentity[],
+): string {
+  return hashArtifactRequest({
+    version: 1,
+    operation: "publish",
+    artifactId: input.artifactId,
+    expectedCurrentVersionId: input.expectedCurrentVersionId,
+    title: input.title === undefined ? { present: false } : { present: true, value: input.title },
+    description:
+      input.description === undefined
+        ? { present: false }
+        : { present: true, value: input.description },
+    contentSha256: input.contentSha256,
+    sourceSha256: input.sourceSha256,
+    requestedTools,
+  });
+}
+
 function assertRollbackReplay(
   replay: Awaited<ReturnType<typeof replayForOperation>>,
   artifactId: string,
@@ -448,6 +728,28 @@ function assertRollbackReplay(
   }
 }
 
+function assertStatusReplay(
+  replay: Awaited<ReturnType<typeof replayForOperation>>,
+  artifactId: string,
+  status: "active" | "archived",
+  expectedCurrentVersionId: string,
+  reason: string,
+) {
+  const expectedType = status === "archived" ? "archived" : "restored";
+  if (
+    !replay ||
+    replay.event.type !== expectedType ||
+    replay.event.artifactId !== artifactId ||
+    replay.event.fromVersionId !== expectedCurrentVersionId ||
+    replay.event.toVersionId !== expectedCurrentVersionId ||
+    replay.event.reason !== reason
+  ) {
+    throw new WorkspaceArtifactConflictError(
+      "Idempotency key was already used for a different operation",
+    );
+  }
+}
+
 function mutationResult(
   artifact: ArtifactRow,
   version: VersionRow,
@@ -470,92 +772,105 @@ export async function createWorkspaceArtifact(
     slug: string;
     title: string;
     description: string | null;
+    requestedSlug?: string | null;
   },
 ): Promise<WorkspaceArtifactMutationResponse> {
-  return await withRlsContext(
-    db,
-    { accountId: input.accountId, workspaceId: input.workspaceId },
-    async (scopedDb) => {
-      return await scopedDb.transaction(async (tx) => {
-        await lockOperation(tx, input.workspaceId, input.operationKey);
-        await assertAttemptAuthority(tx, input);
-        const replay = await replayForOperation(tx, input.workspaceId, input.operationKey);
-        if (replay) {
-          assertCreateReplay(replay);
-          if (replay.version.contentSha256 !== input.contentSha256) {
-            throw new WorkspaceArtifactConflictError(
-              "Idempotency key was already used with different content",
+  let contentPersisted = false;
+  try {
+    return await withRlsContext(
+      db,
+      { accountId: input.accountId, workspaceId: input.workspaceId },
+      async (scopedDb) => {
+        return await scopedDb.transaction(async (tx) => {
+          await lockOperation(tx, input.workspaceId, input.operationKey);
+          const replay = await replayForOperation(tx, input.workspaceId, input.operationKey);
+          if (replay) {
+            assertCreateReplayMatchesInput(replay, input);
+            return mutationResult(
+              replay.artifact,
+              replay.version,
+              replay.event,
+              true,
+              replay.current ?? replay.version,
             );
           }
-          return mutationResult(
-            replay.artifact,
-            replay.version,
-            replay.event,
-            true,
-            replay.current ?? replay.version,
-          );
-        }
-        await input.persistContent();
-        const [artifact] = await tx
-          .insert(schema.workspaceArtifacts)
-          .values({
-            id: input.artifactId,
-            accountId: input.accountId,
-            workspaceId: input.workspaceId,
-            slug: input.slug,
-            title: input.title,
-            description: input.description,
-            createdBySubjectId: input.actorSubjectId,
-          })
-          .returning();
-        const [version] = await tx
-          .insert(schema.workspaceArtifactVersions)
-          .values({
-            accountId: input.accountId,
-            workspaceId: input.workspaceId,
-            artifactId: input.artifactId,
-            revision: 1,
-            contentKey: input.contentKey,
-            contentSha256: input.contentSha256,
-            sizeBytes: input.sizeBytes,
-            operationKey: input.operationKey,
-            sourceSessionId: input.sourceSessionId,
-            sourceTurnId: input.sourceTurnId,
-            sourceAttemptId: input.sourceAttemptId,
-            sourceExecutionGeneration: input.sourceExecutionGeneration,
-            createdBySubjectId: input.actorSubjectId,
-          })
-          .returning();
-        const [updated] = await tx
-          .update(schema.workspaceArtifacts)
-          .set({
-            currentVersionId: version!.id,
-            updatedAt: new Date(),
-          })
-          .where(eq(schema.workspaceArtifacts.id, artifact!.id))
-          .returning();
-        const [event] = await tx
-          .insert(schema.workspaceArtifactEvents)
-          .values({
-            accountId: input.accountId,
-            workspaceId: input.workspaceId,
-            artifactId: input.artifactId,
-            type: "published",
-            fromVersionId: null,
-            toVersionId: version!.id,
-            operationKey: input.operationKey,
-            sourceSessionId: input.sourceSessionId,
-            sourceTurnId: input.sourceTurnId,
-            sourceAttemptId: input.sourceAttemptId,
-            sourceExecutionGeneration: input.sourceExecutionGeneration,
-            actorSubjectId: input.actorSubjectId,
-            reason: "Initial publication",
-          })
-          .returning();
-        return mutationResult(updated!, version!, event!, false);
+          await assertAttemptAuthority(tx, input);
+          await assertArtifactRequestedToolsInAttemptCatalog(tx, input, input.requestedTools ?? []);
+          await input.persistContent();
+          contentPersisted = true;
+          const [artifact] = await tx
+            .insert(schema.workspaceArtifacts)
+            .values({
+              id: input.artifactId,
+              accountId: input.accountId,
+              workspaceId: input.workspaceId,
+              slug: input.slug,
+              title: input.title,
+              description: input.description,
+              createdBySubjectId: input.actorSubjectId,
+            })
+            .returning();
+          const [version] = await tx
+            .insert(schema.workspaceArtifactVersions)
+            .values({
+              accountId: input.accountId,
+              workspaceId: input.workspaceId,
+              artifactId: input.artifactId,
+              revision: 1,
+              contentKey: input.contentKey,
+              contentSha256: input.contentSha256,
+              sizeBytes: input.sizeBytes,
+              sourceKey: input.sourceKey,
+              sourceSha256: input.sourceSha256,
+              sourceSizeBytes: input.sourceSizeBytes,
+              requestedTools: input.requestedTools ?? [],
+              operationKey: input.operationKey,
+              sourceSessionId: input.sourceSessionId,
+              sourceTurnId: input.sourceTurnId,
+              sourceAttemptId: input.sourceAttemptId,
+              sourceExecutionGeneration: input.sourceExecutionGeneration,
+              createdBySubjectId: input.actorSubjectId,
+            })
+            .returning();
+          const [updated] = await tx
+            .update(schema.workspaceArtifacts)
+            .set({
+              currentVersionId: version!.id,
+              updatedAt: new Date(),
+            })
+            .where(eq(schema.workspaceArtifacts.id, artifact!.id))
+            .returning();
+          const [event] = await tx
+            .insert(schema.workspaceArtifactEvents)
+            .values({
+              accountId: input.accountId,
+              workspaceId: input.workspaceId,
+              artifactId: input.artifactId,
+              type: "published",
+              fromVersionId: null,
+              toVersionId: version!.id,
+              operationKey: input.operationKey,
+              requestDigest: createArtifactRequestDigest(input),
+              sourceSessionId: input.sourceSessionId,
+              sourceTurnId: input.sourceTurnId,
+              sourceAttemptId: input.sourceAttemptId,
+              sourceExecutionGeneration: input.sourceExecutionGeneration,
+              actorSubjectId: input.actorSubjectId,
+              reason: "Initial publication",
+            })
+            .returning();
+          return mutationResult(updated!, version!, event!, false);
+        });
+      },
+    );
+  } catch (error) {
+    if (contentPersisted) {
+      return await reconcilePersistedArtifactMutation(db, input, error, (replay) => {
+        assertCreateReplayMatchesInput(replay, input);
       });
-    },
-  );
+    }
+    throw error;
+  }
 }
 
 export async function publishWorkspaceArtifactVersion(
@@ -566,6 +881,146 @@ export async function publishWorkspaceArtifactVersion(
     title?: string;
     description?: string | null;
   },
+): Promise<WorkspaceArtifactMutationResponse> {
+  let contentPersisted = false;
+  try {
+    return await withRlsContext(
+      db,
+      { accountId: input.accountId, workspaceId: input.workspaceId },
+      async (scopedDb) => {
+        return await scopedDb.transaction(async (tx) => {
+          await lockOperation(tx, input.workspaceId, input.operationKey);
+          const replay = await replayForOperation(tx, input.workspaceId, input.operationKey);
+          if (replay) {
+            assertPublishReplayMatchesInput(replay, input);
+            return mutationResult(
+              replay.artifact,
+              replay.version,
+              replay.event,
+              true,
+              replay.current ?? replay.version,
+            );
+          }
+          await assertAttemptAuthority(tx, input);
+          const artifact = await artifactRow(tx, input.workspaceId, input.artifactId, true);
+          if (!artifact) throw new WorkspaceArtifactNotFoundError("Artifact not found");
+          if (artifact.status !== "active") {
+            throw new WorkspaceArtifactOperationError("Archived artifacts cannot be published");
+          }
+          if (artifact.currentVersionId !== input.expectedCurrentVersionId) {
+            throw new WorkspaceArtifactConflictError(
+              "Artifact changed in another request",
+              artifact.currentVersionId,
+            );
+          }
+          const current = await currentVersion(tx, artifact);
+          if (!current) throw new WorkspaceArtifactNotFoundError("Artifact has no current version");
+          await assertArtifactRequestedToolsInAttemptCatalog(
+            tx,
+            input,
+            input.requestedTools ?? current.requestedTools,
+          );
+          const [latest] = await tx
+            .select()
+            .from(schema.workspaceArtifactVersions)
+            .where(
+              and(
+                eq(schema.workspaceArtifactVersions.workspaceId, input.workspaceId),
+                eq(schema.workspaceArtifactVersions.artifactId, input.artifactId),
+              ),
+            )
+            .orderBy(desc(schema.workspaceArtifactVersions.revision))
+            .limit(1);
+          await input.persistContent();
+          contentPersisted = true;
+          const [version] = await tx
+            .insert(schema.workspaceArtifactVersions)
+            .values({
+              accountId: input.accountId,
+              workspaceId: input.workspaceId,
+              artifactId: input.artifactId,
+              revision: (latest?.revision ?? 0) + 1,
+              contentKey: input.contentKey,
+              contentSha256: input.contentSha256,
+              sizeBytes: input.sizeBytes,
+              sourceKey: input.sourceKey,
+              sourceSha256: input.sourceSha256,
+              sourceSizeBytes: input.sourceSizeBytes,
+              requestedTools: input.requestedTools ?? current.requestedTools,
+              operationKey: input.operationKey,
+              sourceSessionId: input.sourceSessionId,
+              sourceTurnId: input.sourceTurnId,
+              sourceAttemptId: input.sourceAttemptId,
+              sourceExecutionGeneration: input.sourceExecutionGeneration,
+              createdBySubjectId: input.actorSubjectId,
+            })
+            .returning();
+          const update: Partial<typeof schema.workspaceArtifacts.$inferInsert> = {
+            currentVersionId: version!.id,
+            updatedAt: new Date(),
+          };
+          if (input.title !== undefined) update.title = input.title;
+          if (input.description !== undefined) update.description = input.description;
+          const [updated] = await tx
+            .update(schema.workspaceArtifacts)
+            .set(update)
+            .where(eq(schema.workspaceArtifacts.id, artifact.id))
+            .returning();
+          const [event] = await tx
+            .insert(schema.workspaceArtifactEvents)
+            .values({
+              accountId: input.accountId,
+              workspaceId: input.workspaceId,
+              artifactId: input.artifactId,
+              type: "published",
+              fromVersionId: artifact.currentVersionId,
+              toVersionId: version!.id,
+              operationKey: input.operationKey,
+              requestDigest: publishArtifactRequestDigest(
+                input,
+                input.requestedTools ?? current.requestedTools,
+              ),
+              sourceSessionId: input.sourceSessionId,
+              sourceTurnId: input.sourceTurnId,
+              sourceAttemptId: input.sourceAttemptId,
+              sourceExecutionGeneration: input.sourceExecutionGeneration,
+              actorSubjectId: input.actorSubjectId,
+              reason: `Published revision ${version!.revision}`,
+            })
+            .returning();
+          return mutationResult(updated!, version!, event!, false);
+        });
+      },
+    );
+  } catch (error) {
+    if (contentPersisted) {
+      return await reconcilePersistedArtifactMutation(db, input, error, (replay) => {
+        assertPublishReplayMatchesInput(replay, input);
+      });
+    }
+    throw error;
+  }
+}
+
+export async function rollbackWorkspaceArtifact(
+  db: Database,
+  input: Omit<
+    PublishMetadata,
+    | "contentKey"
+    | "contentSha256"
+    | "sizeBytes"
+    | "sourceKey"
+    | "sourceSha256"
+    | "sourceSizeBytes"
+    | "requestedTools"
+    | "persistContent"
+    | "discardContent"
+  > & {
+    artifactId: string;
+    versionId: string;
+    expectedCurrentVersionId: string;
+    reason: string;
+  },
 ): Promise<WorkspaceArtifactMutationResponse> {
   return await withRlsContext(
     db,
@@ -573,15 +1028,15 @@ export async function publishWorkspaceArtifactVersion(
     async (scopedDb) => {
       return await scopedDb.transaction(async (tx) => {
         await lockOperation(tx, input.workspaceId, input.operationKey);
-        await assertAttemptAuthority(tx, input);
         const replay = await replayForOperation(tx, input.workspaceId, input.operationKey);
         if (replay) {
-          assertPublishReplay(replay, input.artifactId, input.expectedCurrentVersionId);
-          if (replay.version.contentSha256 !== input.contentSha256) {
-            throw new WorkspaceArtifactConflictError(
-              "Idempotency key was already used with different content",
-            );
-          }
+          assertRollbackReplay(
+            replay,
+            input.artifactId,
+            input.versionId,
+            input.expectedCurrentVersionId,
+            input.reason,
+          );
           return mutationResult(
             replay.artifact,
             replay.version,
@@ -590,56 +1045,33 @@ export async function publishWorkspaceArtifactVersion(
             replay.current ?? replay.version,
           );
         }
+        await assertAttemptAuthority(tx, input);
         const artifact = await artifactRow(tx, input.workspaceId, input.artifactId, true);
         if (!artifact) throw new WorkspaceArtifactNotFoundError("Artifact not found");
         if (artifact.status !== "active") {
-          throw new WorkspaceArtifactOperationError("Archived artifacts cannot be published");
+          throw new WorkspaceArtifactOperationError("Archived artifacts cannot be rolled back");
         }
-        if (artifact.currentVersionId !== input.expectedCurrentVersionId) {
+        if (artifact.currentVersionId !== input.expectedCurrentVersionId)
           throw new WorkspaceArtifactConflictError(
             "Artifact changed in another request",
             artifact.currentVersionId,
           );
-        }
-        const [latest] = await tx
+        const [target] = await tx
           .select()
           .from(schema.workspaceArtifactVersions)
           .where(
             and(
               eq(schema.workspaceArtifactVersions.workspaceId, input.workspaceId),
               eq(schema.workspaceArtifactVersions.artifactId, input.artifactId),
+              eq(schema.workspaceArtifactVersions.id, input.versionId),
             ),
           )
-          .orderBy(desc(schema.workspaceArtifactVersions.revision))
           .limit(1);
-        await input.persistContent();
-        const [version] = await tx
-          .insert(schema.workspaceArtifactVersions)
-          .values({
-            accountId: input.accountId,
-            workspaceId: input.workspaceId,
-            artifactId: input.artifactId,
-            revision: (latest?.revision ?? 0) + 1,
-            contentKey: input.contentKey,
-            contentSha256: input.contentSha256,
-            sizeBytes: input.sizeBytes,
-            operationKey: input.operationKey,
-            sourceSessionId: input.sourceSessionId,
-            sourceTurnId: input.sourceTurnId,
-            sourceAttemptId: input.sourceAttemptId,
-            sourceExecutionGeneration: input.sourceExecutionGeneration,
-            createdBySubjectId: input.actorSubjectId,
-          })
-          .returning();
-        const update: Partial<typeof schema.workspaceArtifacts.$inferInsert> = {
-          currentVersionId: version!.id,
-          updatedAt: new Date(),
-        };
-        if (input.title !== undefined) update.title = input.title;
-        if (input.description !== undefined) update.description = input.description;
+        if (!target) throw new WorkspaceArtifactNotFoundError("Artifact version not found");
+        await assertArtifactRequestedToolsInAttemptCatalog(tx, input, target.requestedTools);
         const [updated] = await tx
           .update(schema.workspaceArtifacts)
-          .set(update)
+          .set({ currentVersionId: target.id, updatedAt: new Date() })
           .where(eq(schema.workspaceArtifacts.id, artifact.id))
           .returning();
         const [event] = await tx
@@ -648,29 +1080,40 @@ export async function publishWorkspaceArtifactVersion(
             accountId: input.accountId,
             workspaceId: input.workspaceId,
             artifactId: input.artifactId,
-            type: "published",
+            type: "rolled_back",
             fromVersionId: artifact.currentVersionId,
-            toVersionId: version!.id,
+            toVersionId: target.id,
             operationKey: input.operationKey,
             sourceSessionId: input.sourceSessionId,
             sourceTurnId: input.sourceTurnId,
             sourceAttemptId: input.sourceAttemptId,
             sourceExecutionGeneration: input.sourceExecutionGeneration,
             actorSubjectId: input.actorSubjectId,
-            reason: `Published revision ${version!.revision}`,
+            reason: input.reason,
           })
           .returning();
-        return mutationResult(updated!, version!, event!, false);
+        return mutationResult(updated!, target, event!, false);
       });
     },
   );
 }
 
-export async function rollbackWorkspaceArtifact(
+export async function setWorkspaceArtifactStatus(
   db: Database,
-  input: Omit<PublishMetadata, "contentKey" | "contentSha256" | "sizeBytes" | "persistContent"> & {
+  input: Omit<
+    PublishMetadata,
+    | "contentKey"
+    | "contentSha256"
+    | "sizeBytes"
+    | "sourceKey"
+    | "sourceSha256"
+    | "sourceSizeBytes"
+    | "requestedTools"
+    | "persistContent"
+    | "discardContent"
+  > & {
     artifactId: string;
-    versionId: string;
+    status: "active" | "archived";
     expectedCurrentVersionId: string;
     reason: string;
   },
@@ -678,16 +1121,15 @@ export async function rollbackWorkspaceArtifact(
   return await withRlsContext(
     db,
     { accountId: input.accountId, workspaceId: input.workspaceId },
-    async (scopedDb) => {
-      return await scopedDb.transaction(async (tx) => {
+    async (scopedDb) =>
+      await scopedDb.transaction(async (tx) => {
         await lockOperation(tx, input.workspaceId, input.operationKey);
-        await assertAttemptAuthority(tx, input);
         const replay = await replayForOperation(tx, input.workspaceId, input.operationKey);
         if (replay) {
-          assertRollbackReplay(
+          assertStatusReplay(
             replay,
             input.artifactId,
-            input.versionId,
+            input.status,
             input.expectedCurrentVersionId,
             input.reason,
           );
@@ -699,31 +1141,30 @@ export async function rollbackWorkspaceArtifact(
             replay.current ?? replay.version,
           );
         }
+        await assertAttemptAuthority(tx, input);
         const artifact = await artifactRow(tx, input.workspaceId, input.artifactId, true);
         if (!artifact) throw new WorkspaceArtifactNotFoundError("Artifact not found");
-        if (artifact.status !== "active") {
-          throw new WorkspaceArtifactOperationError("Archived artifacts cannot be rolled back");
-        }
-        if (artifact.currentVersionId !== input.expectedCurrentVersionId)
+        if (artifact.currentVersionId !== input.expectedCurrentVersionId) {
           throw new WorkspaceArtifactConflictError(
             "Artifact changed in another request",
             artifact.currentVersionId,
           );
-        const [target] = await tx
-          .select()
-          .from(schema.workspaceArtifactVersions)
-          .where(
-            and(
-              eq(schema.workspaceArtifactVersions.workspaceId, input.workspaceId),
-              eq(schema.workspaceArtifactVersions.artifactId, input.artifactId),
-              eq(schema.workspaceArtifactVersions.id, input.versionId),
-            ),
-          )
-          .limit(1);
-        if (!target) throw new WorkspaceArtifactNotFoundError("Artifact version not found");
+        }
+        const current = await currentVersion(tx, artifact);
+        if (!current) throw new WorkspaceArtifactNotFoundError("Artifact has no current version");
+        if (input.status === "active") {
+          await assertArtifactRequestedToolsInAttemptCatalog(tx, input, current.requestedTools);
+        }
+        if (artifact.status === input.status) {
+          throw new WorkspaceArtifactOperationError(
+            input.status === "archived"
+              ? "Artifact is already archived"
+              : "Artifact is already active",
+          );
+        }
         const [updated] = await tx
           .update(schema.workspaceArtifacts)
-          .set({ currentVersionId: target.id, updatedAt: new Date() })
+          .set({ status: input.status, updatedAt: new Date() })
           .where(eq(schema.workspaceArtifacts.id, artifact.id))
           .returning();
         const [event] = await tx
@@ -732,9 +1173,9 @@ export async function rollbackWorkspaceArtifact(
             accountId: input.accountId,
             workspaceId: input.workspaceId,
             artifactId: input.artifactId,
-            type: "rolled_back",
-            fromVersionId: artifact.currentVersionId,
-            toVersionId: target.id,
+            type: input.status === "archived" ? "archived" : "restored",
+            fromVersionId: current.id,
+            toVersionId: current.id,
             operationKey: input.operationKey,
             sourceSessionId: input.sourceSessionId,
             sourceTurnId: input.sourceTurnId,
@@ -744,8 +1185,22 @@ export async function rollbackWorkspaceArtifact(
             reason: input.reason,
           })
           .returning();
-        return mutationResult(updated!, target, event!, false);
-      });
-    },
+        return mutationResult(updated!, current, event!, false);
+      }),
   );
 }
+
+function assertReplayVersionMetadata(
+  version: VersionRow,
+  input: PublishMetadata,
+  expectedRequestedTools: ToolGatewayIdentity[],
+): void {
+  if (
+    version.sourceSha256 !== input.sourceSha256 ||
+    JSON.stringify(version.requestedTools) !== JSON.stringify(expectedRequestedTools)
+  ) {
+    throw new WorkspaceArtifactConflictError(
+      "Idempotency key was already used with different source or requested tools",
+    );
+  }
+}