artifact-cafe 0.0.9 → 0.0.10

package/dist/index.js

@@ -83,11 +83,27 @@ var artifactListResponseSchema = z.object({
   artifacts: z.array(artifactListItemSchema)
 });
 
+// ../shared/src/avatars.ts
+import { z as z2 } from "zod";
+var AVATAR_CONTENT_TYPES = [
+  "image/png",
+  "image/jpeg",
+  "image/webp"
+];
+var AVATAR_MAX_BYTES = 2 * 1024 * 1024;
+var avatarContentTypeSchema = z2.enum(AVATAR_CONTENT_TYPES);
+var userAvatarResponseSchema = z2.object({
+  image: z2.string().nullable()
+});
+var workspaceAvatarResponseSchema = z2.object({
+  logo: z2.string().nullable()
+});
+
 // ../shared/src/comments.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // ../shared/src/publish.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 function isSafeArtifactPath(p) {
   if (p.length === 0 || p.length > 1024) {
     return false;
@@ -100,244 +116,258 @@ function isSafeArtifactPath(p) {
   }
   return p.split("/").every((seg) => seg.length > 0 && seg !== "." && seg !== "..");
 }
-var manifestFileSchema = z2.object({
-  hash: z2.string().regex(/^sha256_[a-f0-9]{64}$/),
-  mimeType: z2.string().regex(/^[-\w.+]+\/[-\w.+]+$/, { message: "invalid MIME type" }),
-  path: z2.string().min(1).max(1024).refine(isSafeArtifactPath, {
+var manifestFileSchema = z3.object({
+  hash: z3.string().regex(/^sha256_[a-f0-9]{64}$/),
+  mimeType: z3.string().regex(/^[-\w.+]+\/[-\w.+]+$/, { message: "invalid MIME type" }),
+  path: z3.string().min(1).max(1024).refine(isSafeArtifactPath, {
     message: "path must be a safe relative path"
   }),
-  size: z2.number().int().positive()
+  size: z3.number().int().positive()
 });
-var publishSourceSchema = z2.object({
-  agent: z2.string().optional(),
-  runId: z2.string().optional(),
-  type: z2.literal("cli")
+var publishSourceSchema = z3.object({
+  agent: z3.string().optional(),
+  runId: z3.string().optional(),
+  type: z3.literal("cli")
 });
-var createPublishSessionSchema = z2.object({
-  artifactId: z2.string().nullable(),
-  entryPath: z2.string().optional(),
-  files: z2.array(manifestFileSchema).min(1).max(1e3),
+var createPublishSessionSchema = z3.object({
+  artifactId: z3.string().nullable(),
+  entryPath: z3.string().optional(),
+  files: z3.array(manifestFileSchema).min(1).max(1e3),
   // SPEC-2 §6.4 — workspace placement is available only to authenticated
   // members; the API enforces membership and folder ownership. folderId
   // without workspaceId resolves against the account's personal workspace.
-  folderId: z2.string().min(1).optional(),
+  folderId: z3.string().min(1).optional(),
+  // Bullet-point changelog for this version, authored by the publisher.
+  // Optional on every publish (incl. v1); stored immutably on the version.
+  notes: z3.string().max(4e3).optional(),
   source: publishSourceSchema,
-  title: z2.string().max(200).optional(),
-  workspaceId: z2.string().min(1).optional()
-});
-var publishSessionResponseSchema = z2.object({
-  artifactId: z2.string(),
-  expiresAt: z2.string(),
-  filesToUpload: z2.array(
-    z2.object({
-      method: z2.literal("PUT"),
-      path: z2.string(),
-      uploadUrl: z2.string().url()
+  title: z3.string().max(200).optional(),
+  workspaceId: z3.string().min(1).optional()
+});
+var publishSessionResponseSchema = z3.object({
+  artifactId: z3.string(),
+  expiresAt: z3.string(),
+  filesToUpload: z3.array(
+    z3.object({
+      method: z3.literal("PUT"),
+      path: z3.string(),
+      uploadUrl: z3.string().url()
     })
   ),
-  publishSessionId: z2.string(),
-  skippedFiles: z2.array(z2.string()),
-  versionId: z2.string()
+  publishSessionId: z3.string(),
+  skippedFiles: z3.array(z3.string()),
+  versionId: z3.string()
 });
-var finalizeResponseSchema = z2.object({
-  artifactId: z2.string(),
+var finalizeResponseSchema = z3.object({
+  artifactId: z3.string(),
   // API-key publishes create the artifact already claimed (SPEC §5.4) —
   // the CLI uses this to tell "claim URL pending" from "already yours".
-  claimed: z2.boolean(),
+  claimed: z3.boolean(),
   // Returned only on first publish of a new artifact (one-time).
-  claimUrl: z2.string().url().optional(),
-  publishToken: z2.string().optional(),
-  url: z2.string().url(),
-  versionId: z2.string(),
-  versionNumber: z2.number().int().positive()
-});
-var artifactResponseSchema = z2.object({
-  claimed: z2.boolean(),
-  currentVersion: z2.object({
-    entryUrl: z2.string().url(),
-    id: z2.string(),
-    versionNumber: z2.number().int().positive()
+  claimUrl: z3.string().url().optional(),
+  publishToken: z3.string().optional(),
+  url: z3.string().url(),
+  versionId: z3.string(),
+  versionNumber: z3.number().int().positive()
+});
+var artifactResponseSchema = z3.object({
+  claimed: z3.boolean(),
+  currentVersion: z3.object({
+    entryUrl: z3.string().url(),
+    id: z3.string(),
+    versionNumber: z3.number().int().positive()
   }).nullable(),
   // SPEC-2 §6.4 — placement + visibility surface on the artifact.
-  folderId: z2.string().nullable(),
-  id: z2.string(),
-  slug: z2.string(),
-  title: z2.string(),
-  visibility: z2.enum(["public", "unlisted", "workspace"]),
-  workspaceId: z2.string().nullable()
+  folderId: z3.string().nullable(),
+  id: z3.string(),
+  slug: z3.string(),
+  title: z3.string(),
+  visibility: z3.enum(["public", "unlisted", "workspace"]),
+  workspaceId: z3.string().nullable()
 });
 
 // ../shared/src/comments.ts
-var anchorPageSchema = z3.string().max(1024).refine(isSafeArtifactPath, {
+var anchorPageSchema = z4.string().max(1024).refine(isSafeArtifactPath, {
   message: "page must be a safe relative path"
 }).optional();
-var elementSnapshotSchema = z3.object({
-  classes: z3.string().max(256).optional(),
-  id: z3.string().max(256).optional(),
-  tag: z3.string().min(1).max(128),
-  text: z3.string().max(200).optional()
+var elementSnapshotSchema = z4.object({
+  classes: z4.string().max(256).optional(),
+  id: z4.string().max(256).optional(),
+  tag: z4.string().min(1).max(128),
+  text: z4.string().max(200).optional()
 });
-var pointAnchorSchema = z3.object({
+var pointAnchorSchema = z4.object({
   element: elementSnapshotSchema.optional(),
   // elementPath is the primary anchor; x/y are offsets within the
   // element's box, normalized 0..1 (SPEC.md §8.1).
-  elementPath: z3.string().max(2048),
+  elementPath: z4.string().max(2048),
   page: anchorPageSchema,
-  type: z3.literal("point"),
-  viewportHeight: z3.number().int().positive().max(1e5),
-  viewportWidth: z3.number().int().positive().max(1e5),
-  x: z3.number().min(0).max(1),
-  y: z3.number().min(0).max(1)
-});
-var textAnchorSchema = z3.object({
-  elementPath: z3.string().max(2048),
-  endOffset: z3.number().int().nonnegative().max(1e8),
+  type: z4.literal("point"),
+  viewportHeight: z4.number().int().positive().max(1e5),
+  viewportWidth: z4.number().int().positive().max(1e5),
+  x: z4.number().min(0).max(1),
+  y: z4.number().min(0).max(1)
+});
+var textAnchorSchema = z4.object({
+  elementPath: z4.string().max(2048),
+  endOffset: z4.number().int().nonnegative().max(1e8),
   page: anchorPageSchema,
-  prefix: z3.string().max(200).optional(),
-  quote: z3.string().min(1).max(1e3),
-  startOffset: z3.number().int().nonnegative().max(1e8),
-  suffix: z3.string().max(200).optional(),
-  type: z3.literal("text")
+  prefix: z4.string().max(200).optional(),
+  quote: z4.string().min(1).max(1e3),
+  startOffset: z4.number().int().nonnegative().max(1e8),
+  suffix: z4.string().max(200).optional(),
+  type: z4.literal("text")
 });
-var pageAnchorSchema = z3.object({
+var pageAnchorSchema = z4.object({
   page: anchorPageSchema,
-  type: z3.literal("page")
+  type: z4.literal("page")
 });
-var anchorSchema = z3.discriminatedUnion("type", [
+var anchorSchema = z4.discriminatedUnion("type", [
   pointAnchorSchema,
   textAnchorSchema,
   pageAnchorSchema
 ]);
-var displayNameSchema = z3.string().trim().min(1).max(64);
-var guestSchema = z3.object({
+var displayNameSchema = z4.string().trim().min(1).max(64);
+var guestSchema = z4.object({
   displayName: displayNameSchema,
-  guestId: z3.string().min(16)
+  guestId: z4.string().min(16)
 });
-var viaLabelSchema = z3.string().trim().min(1).max(64);
-var createCommentThreadSchema = z3.object({
+var viaLabelSchema = z4.string().trim().min(1).max(64);
+var createCommentThreadSchema = z4.object({
   anchor: anchorSchema,
-  body: z3.string().min(1).max(1e4),
+  body: z4.string().min(1).max(1e4),
   guest: guestSchema.optional(),
-  versionId: z3.string(),
+  versionId: z4.string(),
   via: viaLabelSchema.optional()
 });
-var createCommentMessageSchema = z3.object({
-  body: z3.string().min(1).max(1e4),
+var createCommentMessageSchema = z4.object({
+  body: z4.string().min(1).max(1e4),
   guest: guestSchema.optional(),
   via: viaLabelSchema.optional()
 });
-var editCommentMessageSchema = z3.object({
-  body: z3.string().min(1).max(1e4),
+var editCommentMessageSchema = z4.object({
+  body: z4.string().min(1).max(1e4),
   guest: guestSchema.optional()
 });
-var threadActionSchema = z3.object({
+var threadActionSchema = z4.object({
   guest: guestSchema.optional()
 });
-var REACTION_EMOJI = [
-  "\u{1F44D}",
-  "\u{1F44E}",
-  "\u2764\uFE0F",
-  "\u{1F389}",
-  "\u{1F4A1}",
-  "\u{1F440}",
-  "\u{1F680}",
-  "\u2615"
-];
-var reactionEmojiSchema = z3.enum(REACTION_EMOJI);
-var toggleReactionSchema = z3.object({
+var SINGLE_EMOJI = new RegExp("^\\p{RGI_Emoji}$", "v");
+var REDUNDANT_VS16 = new RegExp("(\\p{Emoji_Presentation})\\uFE0F", "gu");
+function canonicalizeEmoji(s) {
+  return s.replace(REDUNDANT_VS16, "$1");
+}
+var reactionEmojiSchema = z4.string().max(64).transform(canonicalizeEmoji).refine((s) => SINGLE_EMOJI.test(s), { message: "Must be a single emoji." }).describe("A single emoji, e.g. \u{1F44D}");
+var toggleReactionSchema = z4.object({
   emoji: reactionEmojiSchema,
   guest: guestSchema.optional()
 });
-var commentAuthorSchema = z3.object({
-  avatarUrl: z3.string().nullable(),
-  displayName: z3.string(),
-  guestId: z3.string().nullable(),
-  isViewer: z3.boolean(),
-  kind: z3.enum(["member", "guest"]),
+var commentAuthorSchema = z4.object({
+  avatarUrl: z4.string().nullable(),
+  displayName: z4.string(),
+  guestId: z4.string().nullable(),
+  isViewer: z4.boolean(),
+  kind: z4.enum(["member", "guest"]),
   // Optional "via" attribution (§6.4). Null for plain comments; a bounded
   // label the shell appends after the display name.
-  via: z3.string().nullable()
+  via: z4.string().nullable()
 });
-var messageReactionSchema = z3.object({
-  emoji: z3.string(),
-  reactors: z3.array(commentAuthorSchema)
+var messageReactionSchema = z4.object({
+  emoji: z4.string(),
+  reactors: z4.array(commentAuthorSchema)
 });
-var commentMessageSchema = z3.object({
+var commentMessageSchema = z4.object({
   author: commentAuthorSchema,
   // Empty string for a deleted message — the body is stripped server-side
   // (§6.7.1 tombstone), never sent to the client and hidden there.
-  body: z3.string(),
-  createdAt: z3.string(),
+  body: z4.string(),
+  createdAt: z4.string(),
   // Soft-deleted (§6.7.1). A tombstone keeps thread structure and replies;
   // the shell renders "Comment deleted" instead of the (absent) body.
-  deleted: z3.boolean(),
+  deleted: z4.boolean(),
   // Last edit time (§6.7.1), or null if never edited — drives the "edited"
   // badge. No edit history is kept.
-  editedAt: z3.string().nullable(),
-  id: z3.string(),
+  editedAt: z4.string().nullable(),
+  id: z4.string(),
   // Defaulted, not required: a new CLI parsing an older server's
   // response must not fail on the missing key.
-  reactions: z3.array(messageReactionSchema).default([])
-});
-var commentThreadSchema = z3.object({
+  reactions: z4.array(messageReactionSchema).default([])
+});
+var threadActorSchema = z4.object({
+  displayName: z4.string(),
+  kind: z4.enum(["member", "guest", "agent"])
+});
+var commentThreadSchema = z4.object({
+  // §6.6.1 — set while open to signal "seen, working on it"; cleared on
+  // reopen, kept (but superseded in display) once resolved. Defaulted so
+  // clients parsing an older server's response don't fail.
+  acknowledgedAt: z4.string().nullable().default(null),
+  acknowledgedBy: threadActorSchema.nullable().default(null),
   anchor: anchorSchema,
-  artifactId: z3.string(),
-  createdAt: z3.string(),
+  artifactId: z4.string(),
+  createdAt: z4.string(),
   createdBy: commentAuthorSchema,
-  id: z3.string(),
-  messages: z3.array(commentMessageSchema),
-  status: z3.enum(["open", "resolved"]),
-  versionId: z3.string()
-});
-var commentThreadListSchema = z3.object({
-  threads: z3.array(commentThreadSchema)
-});
-var commentExportQuerySchema = z3.object({
-  status: z3.enum(["open", "resolved", "all"]).default("open"),
-  version: z3.enum(["current", "all"]).default("current")
-});
-var exportReactionSchema = z3.object({
-  count: z3.number().int().positive(),
-  emoji: z3.string()
-});
-var commentExportReplySchema = z3.object({
-  author: z3.string(),
-  authorKind: z3.enum(["member", "guest"]),
-  body: z3.string(),
-  createdAt: z3.string(),
+  id: z4.string(),
+  messages: z4.array(commentMessageSchema),
+  // Null on threads resolved before actor recording existed, and always
+  // null while open.
+  resolvedBy: threadActorSchema.nullable().default(null),
+  status: z4.enum(["open", "resolved"]),
+  versionId: z4.string()
+});
+var commentThreadListSchema = z4.object({
+  threads: z4.array(commentThreadSchema)
+});
+var commentExportQuerySchema = z4.object({
+  status: z4.enum(["open", "resolved", "all"]).default("open"),
+  version: z4.enum(["current", "all"]).default("current")
+});
+var exportReactionSchema = z4.object({
+  count: z4.number().int().positive(),
+  emoji: z4.string()
+});
+var commentExportReplySchema = z4.object({
+  author: z4.string(),
+  authorKind: z4.enum(["member", "guest"]),
+  body: z4.string(),
+  createdAt: z4.string(),
   // Soft-delete tombstone (§6.7.1): body is "" when true.
-  deleted: z3.boolean(),
-  editedAt: z3.string().nullable(),
+  deleted: z4.boolean(),
+  editedAt: z4.string().nullable(),
   // The message id — what `edit`/`delete` target (§5.1).
-  id: z3.string(),
-  reactions: z3.array(exportReactionSchema).optional()
+  id: z4.string(),
+  reactions: z4.array(exportReactionSchema).optional()
 });
-var commentExportThreadSchema = z3.object({
+var commentExportThreadSchema = z4.object({
+  // §6.6.1 — lets a polling agent skip threads it already acknowledged
+  // (acknowledged threads stay in status=open exports on purpose).
+  acknowledgedAt: z4.string().nullable().default(null),
   anchor: anchorSchema,
-  author: z3.string(),
-  authorKind: z3.enum(["member", "guest"]),
-  body: z3.string(),
-  createdAt: z3.string(),
-  deleted: z3.boolean(),
-  editedAt: z3.string().nullable(),
-  id: z3.string(),
+  author: z4.string(),
+  authorKind: z4.enum(["member", "guest"]),
+  body: z4.string(),
+  createdAt: z4.string(),
+  deleted: z4.boolean(),
+  editedAt: z4.string().nullable(),
+  id: z4.string(),
   // The opening message's id (distinct from the thread `id`) — `edit`/
   // `delete` operate on messages, so the CLI needs it to target the first
   // comment, not just the replies.
-  messageId: z3.string(),
-  reactions: z3.array(exportReactionSchema).optional(),
-  replies: z3.array(commentExportReplySchema),
-  status: z3.enum(["open", "resolved"]),
-  versionNumber: z3.number().int().positive()
-});
-var commentExportSchema = z3.object({
-  artifactId: z3.string(),
-  comments: z3.array(commentExportThreadSchema),
+  messageId: z4.string(),
+  reactions: z4.array(exportReactionSchema).optional(),
+  replies: z4.array(commentExportReplySchema),
+  resolvedBy: threadActorSchema.nullable().default(null),
+  status: z4.enum(["open", "resolved"]),
+  versionNumber: z4.number().int().positive()
+});
+var commentExportSchema = z4.object({
+  artifactId: z4.string(),
+  comments: z4.array(commentExportThreadSchema),
   // The artifact's current version (null before the first finalize).
-  versionNumber: z3.number().int().positive().nullable()
+  versionNumber: z4.number().int().positive().nullable()
 });
-var commentReadResponseSchema = z3.object({
-  lastSeenAt: z3.string()
+var commentReadResponseSchema = z4.object({
+  lastSeenAt: z4.string()
 });
 function elementLabel(el) {
   if (el.id) {
@@ -348,163 +378,166 @@ function elementLabel(el) {
 }
 
 // ../shared/src/errors.ts
-import { z as z4 } from "zod";
-var apiErrorSchema = z4.object({
-  code: z4.string(),
-  docsUrl: z4.string().url(),
-  message: z4.string(),
-  retryAfter: z4.number().int().positive().optional()
+import { z as z5 } from "zod";
+var apiErrorSchema = z5.object({
+  code: z5.string(),
+  docsUrl: z5.string().url(),
+  message: z5.string(),
+  retryAfter: z5.number().int().positive().optional()
 });
 
 // ../shared/src/feedback.ts
-import { z as z5 } from "zod";
-var feedbackRequestSchema = z5.object({
-  email: z5.string().trim().toLowerCase().email().optional().or(z5.literal("")),
-  message: z5.string().trim().min(1).max(4e3)
+import { z as z6 } from "zod";
+var feedbackRequestSchema = z6.object({
+  email: z6.string().trim().toLowerCase().email().optional().or(z6.literal("")),
+  message: z6.string().trim().min(1).max(4e3)
 });
-var feedbackResponseSchema = z5.object({
-  sent: z5.literal(true)
+var feedbackResponseSchema = z6.object({
+  sent: z6.literal(true)
 });
 
 // ../shared/src/me.ts
-import { z as z6 } from "zod";
-var ownArtifactSchema = z6.object({
-  createdAt: z6.string(),
-  currentVersionNumber: z6.number().nullable(),
+import { z as z7 } from "zod";
+var ownArtifactSchema = z7.object({
+  createdAt: z7.string(),
+  currentVersionNumber: z7.number().nullable(),
   // Owned artifacts normally never expire; non-null only while an
   // expiry is still set (e.g. an unclaimed publish surfaced here later).
-  expiresAt: z6.string().nullable(),
+  expiresAt: z7.string().nullable(),
   // SPEC-2 §8.4 — the containing folder for workspace-owned artifacts;
   // both null for personal artifacts. `folderId` drives the dashboard's
   // move control and folder filter; `folderName` is the display label.
-  folderId: z6.string().nullable(),
-  folderName: z6.string().nullable(),
+  folderId: z7.string().nullable(),
+  folderName: z7.string().nullable(),
   // Whether a publish token is still active — revocable from the
   // dashboard (§6.18); the token itself is never returned.
-  hasPublishToken: z6.boolean(),
-  id: z6.string(),
-  openThreads: z6.number(),
-  protected: z6.boolean(),
-  slug: z6.string(),
-  title: z6.string(),
-  totalViews: z6.number(),
+  hasPublishToken: z7.boolean(),
+  id: z7.string(),
+  openThreads: z7.number(),
+  protected: z7.boolean(),
+  slug: z7.string(),
+  title: z7.string(),
+  totalViews: z7.number(),
   // SPEC §6.20 — messages by others newer than the viewer's last-seen
   // watermark. 0 for signed-out/API-key-less contexts.
-  unreadComments: z6.number(),
-  updatedAt: z6.string(),
-  url: z6.string(),
-  versionCount: z6.number()
+  unreadComments: z7.number(),
+  updatedAt: z7.string(),
+  url: z7.string(),
+  versionCount: z7.number()
 });
-var ownArtifactsResponseSchema = z6.object({
-  artifacts: z6.array(ownArtifactSchema)
+var ownArtifactsResponseSchema = z7.object({
+  artifacts: z7.array(ownArtifactSchema)
 });
-var revokePublishTokenResponseSchema = z6.object({
-  revoked: z6.boolean()
+var revokePublishTokenResponseSchema = z7.object({
+  revoked: z7.boolean()
 });
 
 // ../shared/src/owner.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // ../shared/src/workspaces.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var WORKSPACE_HANDLE_PATTERN = /^[a-z0-9](?:[a-z0-9-]{1,30}[a-z0-9])$/;
-var workspaceRoleSchema = z7.enum(["owner", "admin", "member"]);
-var workspaceInviteRoleSchema = z7.enum(["admin", "member"]);
-var workspaceHandleSchema = z7.string().min(3).max(32).regex(WORKSPACE_HANDLE_PATTERN, {
+var workspaceRoleSchema = z8.enum(["owner", "admin", "member"]);
+var workspaceInviteRoleSchema = z8.enum(["admin", "member"]);
+var workspaceHandleSchema = z8.string().min(3).max(32).regex(WORKSPACE_HANDLE_PATTERN, {
   message: "handle must be lowercase letters, digits, and hyphens, with no leading/trailing hyphen"
 });
-var createWorkspaceSchema = z7.object({
+var createWorkspaceSchema = z8.object({
   handle: workspaceHandleSchema.optional(),
-  name: z7.string().trim().min(1).max(100)
+  name: z8.string().trim().min(1).max(100)
 });
-var updateWorkspaceSchema = z7.object({
+var updateWorkspaceSchema = z8.object({
   handle: workspaceHandleSchema.optional(),
-  name: z7.string().trim().min(1).max(100).optional()
+  name: z8.string().trim().min(1).max(100).optional()
 }).refine((body) => body.handle !== void 0 || body.name !== void 0, {
   message: "provide at least one of name or handle"
 });
-var workspaceSchema = z7.object({
-  createdAt: z7.string(),
-  handle: z7.string(),
-  id: z7.string(),
+var workspaceSchema = z8.object({
+  createdAt: z8.string(),
+  handle: z8.string(),
+  id: z8.string(),
   // Auto-provisioned solo workspace, one per user: non-deletable, takes
   // no members, renameable like any workspace.
-  isPersonal: z7.boolean(),
-  name: z7.string(),
+  isPersonal: z8.boolean(),
+  // Uploaded logo URL, or null for the initials fallback. Set through the
+  // dedicated /workspaces/:id/avatar route, never the generic update.
+  logo: z8.string().nullable(),
+  name: z8.string(),
   role: workspaceRoleSchema.nullable(),
-  updatedAt: z7.string()
+  updatedAt: z8.string()
 });
-var workspaceListResponseSchema = z7.object({
-  workspaces: z7.array(workspaceSchema)
+var workspaceListResponseSchema = z8.object({
+  workspaces: z8.array(workspaceSchema)
 });
-var deleteWorkspaceResponseSchema = z7.object({
-  deleted: z7.literal(true)
+var deleteWorkspaceResponseSchema = z8.object({
+  deleted: z8.literal(true)
 });
-var workspaceMemberSchema = z7.object({
-  createdAt: z7.string(),
-  email: z7.string().email(),
-  image: z7.string().nullable(),
-  name: z7.string(),
+var workspaceMemberSchema = z8.object({
+  createdAt: z8.string(),
+  email: z8.string().email(),
+  image: z8.string().nullable(),
+  name: z8.string(),
   role: workspaceRoleSchema,
-  userId: z7.string()
+  userId: z8.string()
 });
-var workspaceMemberListResponseSchema = z7.object({
-  members: z7.array(workspaceMemberSchema)
+var workspaceMemberListResponseSchema = z8.object({
+  members: z8.array(workspaceMemberSchema)
 });
-var updateWorkspaceMemberSchema = z7.object({
+var updateWorkspaceMemberSchema = z8.object({
   role: workspaceRoleSchema
 });
-var removeWorkspaceMemberResponseSchema = z7.object({
-  removed: z7.literal(true)
+var removeWorkspaceMemberResponseSchema = z8.object({
+  removed: z8.literal(true)
 });
-var createWorkspaceInviteSchema = z7.object({
-  email: z7.string().trim().toLowerCase().email().optional(),
-  expiresAt: z7.string().datetime(),
-  maxUses: z7.number().int().positive().optional(),
+var createWorkspaceInviteSchema = z8.object({
+  email: z8.string().trim().toLowerCase().email().optional(),
+  expiresAt: z8.string().datetime(),
+  maxUses: z8.number().int().positive().optional(),
   role: workspaceInviteRoleSchema
 });
-var workspaceInviteSchema = z7.object({
-  createdAt: z7.string(),
-  email: z7.string().email().nullable(),
-  expiresAt: z7.string(),
-  id: z7.string(),
-  maxUses: z7.number().int().positive().nullable(),
+var workspaceInviteSchema = z8.object({
+  createdAt: z8.string(),
+  email: z8.string().email().nullable(),
+  expiresAt: z8.string(),
+  id: z8.string(),
+  maxUses: z8.number().int().positive().nullable(),
   role: workspaceInviteRoleSchema,
-  tokenPrefix: z7.string(),
-  useCount: z7.number().int().nonnegative()
+  tokenPrefix: z8.string(),
+  useCount: z8.number().int().nonnegative()
 });
 var createdWorkspaceInviteSchema = workspaceInviteSchema.extend({
-  url: z7.string().url()
+  url: z8.string().url()
 });
-var workspaceInviteListResponseSchema = z7.object({
-  invites: z7.array(workspaceInviteSchema)
+var workspaceInviteListResponseSchema = z8.object({
+  invites: z8.array(workspaceInviteSchema)
 });
-var revokeWorkspaceInviteResponseSchema = z7.object({
-  revoked: z7.literal(true)
+var revokeWorkspaceInviteResponseSchema = z8.object({
+  revoked: z8.literal(true)
 });
-var acceptWorkspaceInviteSchema = z7.object({
-  token: z7.string().min(1)
+var acceptWorkspaceInviteSchema = z8.object({
+  token: z8.string().min(1)
 });
-var acceptWorkspaceInviteResponseSchema = z7.object({
+var acceptWorkspaceInviteResponseSchema = z8.object({
   role: workspaceRoleSchema,
   workspace: workspaceSchema
 });
-var folderVisibilitySchema = z7.enum(["public", "workspace"]);
-var artifactVisibilitySchema = z7.enum([
+var folderVisibilitySchema = z8.enum(["public", "workspace"]);
+var artifactVisibilitySchema = z8.enum([
   "public",
   "unlisted",
   "workspace"
 ]);
-var createFolderSchema = z7.object({
-  name: z7.string().trim().min(1).max(100),
+var createFolderSchema = z8.object({
+  name: z8.string().trim().min(1).max(100),
   visibility: folderVisibilitySchema
 });
-var updateFolderSchema = z7.object({
+var updateFolderSchema = z8.object({
   // With `visibility`: bulk-update the folder's artifacts to match
   // (SPEC-2 §3.4 "Changing a folder's visibility offers a bulk update").
-  cascade: z7.boolean().optional(),
-  name: z7.string().trim().min(1).max(100).optional(),
-  sortOrder: z7.number().int().min(0).optional(),
+  cascade: z8.boolean().optional(),
+  name: z8.string().trim().min(1).max(100).optional(),
+  sortOrder: z8.number().int().min(0).optional(),
   visibility: folderVisibilitySchema.optional()
 }).refine(
   (body) => body.name !== void 0 || body.visibility !== void 0 || body.sortOrder !== void 0,
@@ -512,168 +545,170 @@ var updateFolderSchema = z7.object({
 ).refine((body) => !body.cascade || body.visibility !== void 0, {
   message: "cascade requires visibility"
 });
-var folderSchema = z7.object({
-  createdAt: z7.string(),
-  id: z7.string(),
-  name: z7.string(),
+var folderSchema = z8.object({
+  createdAt: z8.string(),
+  id: z8.string(),
+  name: z8.string(),
   // Permalink segment for the public folder page (/w/{handle}/f/{slug}).
   // Server-derived from the name; renames regenerate it.
-  slug: z7.string(),
-  sortOrder: z7.number().int(),
-  updatedAt: z7.string(),
+  slug: z8.string(),
+  sortOrder: z8.number().int(),
+  updatedAt: z8.string(),
   visibility: folderVisibilitySchema,
-  workspaceId: z7.string()
+  workspaceId: z8.string()
 });
-var folderListResponseSchema = z7.object({
-  folders: z7.array(folderSchema)
+var folderListResponseSchema = z8.object({
+  folders: z8.array(folderSchema)
 });
-var deleteFolderResponseSchema = z7.object({
-  deleted: z7.literal(true)
+var deleteFolderResponseSchema = z8.object({
+  deleted: z8.literal(true)
 });
-var workspaceArtifactSchema = z7.object({
-  createdAt: z7.string(),
-  currentVersionNumber: z7.number().int().nullable(),
-  folderId: z7.string().nullable(),
-  id: z7.string(),
-  openCommentCount: z7.number().int().nonnegative(),
-  slug: z7.string(),
-  title: z7.string(),
-  updatedAt: z7.string(),
-  url: z7.string().url(),
-  versionCount: z7.number().int().nonnegative(),
+var workspaceArtifactSchema = z8.object({
+  createdAt: z8.string(),
+  currentVersionNumber: z8.number().int().nullable(),
+  folderId: z8.string().nullable(),
+  id: z8.string(),
+  openCommentCount: z8.number().int().nonnegative(),
+  slug: z8.string(),
+  title: z8.string(),
+  updatedAt: z8.string(),
+  url: z8.string().url(),
+  versionCount: z8.number().int().nonnegative(),
   visibility: artifactVisibilitySchema
 });
-var workspaceArtifactListResponseSchema = z7.object({
-  artifacts: z7.array(workspaceArtifactSchema)
+var workspaceArtifactListResponseSchema = z8.object({
+  artifacts: z8.array(workspaceArtifactSchema)
 });
 
 // ../shared/src/owner.ts
 var SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]{1,61}[a-z0-9])$/;
-var claimResponseSchema = z8.object({
-  artifactId: z8.string(),
-  slug: z8.string(),
-  title: z8.string(),
-  url: z8.string().url()
+var claimResponseSchema = z9.object({
+  artifactId: z9.string(),
+  slug: z9.string(),
+  title: z9.string(),
+  url: z9.string().url()
 });
-var updateArtifactSchema = z8.object({
+var updateArtifactSchema = z9.object({
   // SPEC-2 §6.4 — placement + visibility. `folderId: null` clears the
   // folder; `workspaceId: null` moves the artifact out of its workspace
   // (§5.5 ownership transfer).
-  folderId: z8.string().min(1).nullable().optional(),
-  slug: z8.string().min(3).max(63).regex(SLUG_PATTERN, {
+  folderId: z9.string().min(1).nullable().optional(),
+  slug: z9.string().min(3).max(63).regex(SLUG_PATTERN, {
     message: "slug must be lowercase letters, digits, and hyphens, with no leading/trailing hyphen"
   }).optional(),
-  title: z8.string().min(1).max(200).optional(),
+  title: z9.string().min(1).max(200).optional(),
   visibility: artifactVisibilitySchema.optional(),
-  workspaceId: z8.string().min(1).nullable().optional()
+  workspaceId: z9.string().min(1).nullable().optional()
 }).refine(
   (body) => body.title !== void 0 || body.slug !== void 0 || body.visibility !== void 0 || body.folderId !== void 0 || body.workspaceId !== void 0,
   {
     message: "provide at least one of title, slug, visibility, folderId, workspaceId"
   }
 );
-var deleteArtifactResponseSchema = z8.object({
-  deleted: z8.literal(true)
+var deleteArtifactResponseSchema = z9.object({
+  deleted: z9.literal(true)
 });
 
 // ../shared/src/presence.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var AGENT_PRESENCE = {
   heartbeatSeconds: 15,
   shellPollSeconds: 15,
   ttlSeconds: 45
 };
-var agentHeartbeatResponseSchema = z9.object({
-  listening: z9.literal(true),
-  ttlSeconds: z9.number().int().positive()
+var agentHeartbeatResponseSchema = z10.object({
+  listening: z10.literal(true),
+  ttlSeconds: z10.number().int().positive()
 });
-var agentPresenceSchema = z9.object({
-  listening: z9.boolean(),
-  versionNumber: z9.number().int().positive().nullable()
+var agentPresenceSchema = z10.object({
+  listening: z10.boolean(),
+  versionNumber: z10.number().int().positive().nullable()
 });
 
 // ../shared/src/protection.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var PASSWORD_MIN = 6;
 var PASSWORD_MAX = 128;
-var gatePasswordSchema = z10.string().min(PASSWORD_MIN, `Password must be at least ${PASSWORD_MIN} characters.`).max(PASSWORD_MAX, `Password must be at most ${PASSWORD_MAX} characters.`);
-var setProtectionSchema = z10.object({
+var gatePasswordSchema = z11.string().min(PASSWORD_MIN, `Password must be at least ${PASSWORD_MIN} characters.`).max(PASSWORD_MAX, `Password must be at most ${PASSWORD_MAX} characters.`);
+var setProtectionSchema = z11.object({
   password: gatePasswordSchema.nullable()
 });
-var protectionResponseSchema = z10.object({
-  protected: z10.boolean()
+var protectionResponseSchema = z11.object({
+  protected: z11.boolean()
 });
-var unlockSchema = z10.object({
-  password: z10.string().min(1).max(1024)
+var unlockSchema = z11.object({
+  password: z11.string().min(1).max(1024)
 });
-var unlockResponseSchema = z10.object({
-  unlocked: z10.literal(true)
+var unlockResponseSchema = z11.object({
+  unlocked: z11.literal(true)
 });
 
 // ../shared/src/report.ts
-import { z as z11 } from "zod";
-var reportRequestSchema = z11.object({
-  reason: z11.string().max(1e3).optional()
+import { z as z12 } from "zod";
+var reportRequestSchema = z12.object({
+  reason: z12.string().max(1e3).optional()
 });
-var reportResponseSchema = z11.object({
-  reported: z11.literal(true)
+var reportResponseSchema = z12.object({
+  reported: z12.literal(true)
 });
 
 // ../shared/src/stats.ts
-import { z as z12 } from "zod";
-var avgViewSecondsSchema = z12.number().int().nonnegative().nullable();
-var versionViewStatsSchema = z12.object({
+import { z as z13 } from "zod";
+var avgViewSecondsSchema = z13.number().int().nonnegative().nullable();
+var versionViewStatsSchema = z13.object({
   avgViewSeconds: avgViewSecondsSchema,
   // Views from inside the review shell's iframe vs. direct visits to
   // the render URL. views = embeddedViews + directViews.
-  directViews: z12.number().int().nonnegative(),
-  embeddedViews: z12.number().int().nonnegative(),
+  directViews: z13.number().int().nonnegative(),
+  embeddedViews: z13.number().int().nonnegative(),
   // Distinct hashed viewer IPs across the version's lifetime.
-  uniqueViewers: z12.number().int().nonnegative(),
-  versionNumber: z12.number().int().positive(),
-  views: z12.number().int().nonnegative()
+  uniqueViewers: z13.number().int().nonnegative(),
+  versionNumber: z13.number().int().positive(),
+  views: z13.number().int().nonnegative()
 });
-var dailyViewsSchema = z12.object({
+var dailyViewsSchema = z13.object({
   avgViewSeconds: avgViewSecondsSchema,
   // UTC day, YYYY-MM-DD.
-  day: z12.string(),
-  uniqueViewers: z12.number().int().nonnegative(),
-  views: z12.number().int().nonnegative()
+  day: z13.string(),
+  uniqueViewers: z13.number().int().nonnegative(),
+  views: z13.number().int().nonnegative()
 });
-var artifactStatsResponseSchema = z12.object({
+var artifactStatsResponseSchema = z13.object({
   avgViewSeconds: avgViewSecondsSchema,
-  daily: z12.array(dailyViewsSchema),
+  daily: z13.array(dailyViewsSchema),
   // Distinct hashed viewer IPs across all versions and days.
-  totalUniqueViewers: z12.number().int().nonnegative(),
-  totalViews: z12.number().int().nonnegative(),
-  versions: z12.array(versionViewStatsSchema)
+  totalUniqueViewers: z13.number().int().nonnegative(),
+  totalViews: z13.number().int().nonnegative(),
+  versions: z13.array(versionViewStatsSchema)
 });
 
 // ../shared/src/versions.ts
-import { z as z13 } from "zod";
-var versionSourceSchema = z13.object({
-  agentName: z13.string().nullable(),
-  type: z13.string()
+import { z as z14 } from "zod";
+var versionSourceSchema = z14.object({
+  agentName: z14.string().nullable(),
+  type: z14.string()
 });
-var versionChangesSchema = z13.object({
-  added: z13.array(z13.string()),
-  changed: z13.array(z13.string()),
-  removed: z13.array(z13.string())
+var versionChangesSchema = z14.object({
+  added: z14.array(z14.string()),
+  changed: z14.array(z14.string()),
+  removed: z14.array(z14.string())
 });
-var versionSummarySchema = z13.object({
+var versionSummarySchema = z14.object({
   // Absent for the first version — there is no previous version to diff against.
   changes: versionChangesSchema.nullable(),
-  createdAt: z13.string(),
-  entryUrl: z13.string().url(),
-  fileCount: z13.number().int().nonnegative(),
-  id: z13.string(),
-  isCurrent: z13.boolean(),
+  createdAt: z14.string(),
+  entryUrl: z14.string().url(),
+  fileCount: z14.number().int().nonnegative(),
+  id: z14.string(),
+  isCurrent: z14.boolean(),
+  // Author-supplied bullet-point changelog; null when the publish omitted it.
+  notes: z14.string().nullable(),
   source: versionSourceSchema,
-  totalSizeBytes: z13.number().int().nonnegative(),
-  versionNumber: z13.number().int().positive()
+  totalSizeBytes: z14.number().int().nonnegative(),
+  versionNumber: z14.number().int().positive()
 });
-var versionListResponseSchema = z13.object({
-  versions: z13.array(versionSummarySchema)
+var versionListResponseSchema = z14.object({
+  versions: z14.array(versionSummarySchema)
 });
 
 // src/api.ts
@@ -729,6 +764,16 @@ function createApiClient(apiUrl2, publishToken) {
   return {
     // SPEC §6.19 — mark the agent as actively waiting for feedback.
     // Authorized by the publish token this client was created with.
+    // SPEC §6.6.1 — mark an open thread acknowledged ("seen, working on
+    // it") without resolving it. Publish token or account key only —
+    // the server rejects guests.
+    async acknowledgeThread(threadId) {
+      return request(
+        `${base}/api/v1/comment-threads/${threadId}/acknowledge`,
+        { body: "{}", headers, method: "POST" },
+        (d) => commentThreadSchema.parse(d)
+      );
+    },
     async agentHeartbeat(artifactId) {
       return request(
         `${base}/api/v1/artifacts/${artifactId}/agent-presence`,
@@ -894,17 +939,17 @@ import {
   writeFileSync as writeFileSync2
 } from "fs";
 import path2 from "path";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // src/credentials.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import path from "path";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var DEFAULT_API_URL = "https://artifact.cafe";
-var credentialsSchema = z14.object({
-  keys: z14.record(z14.string(), z14.string()),
-  version: z14.literal(1)
+var credentialsSchema = z15.object({
+  keys: z15.record(z15.string(), z15.string()),
+  version: z15.literal(1)
 });
 function credentialsPath() {
   return path.join(homedir(), ".artifactcafe", "credentials");
@@ -954,24 +999,24 @@ function resolveApiKey(apiUrl2, flag) {
 }
 
 // src/config.ts
-var configSchema = z15.object({
-  apiUrl: z15.string(),
-  artifactId: z15.string(),
-  folder: z15.string().optional(),
-  folderId: z15.string().optional(),
+var configSchema = z16.object({
+  apiUrl: z16.string(),
+  artifactId: z16.string(),
+  folder: z16.string().optional(),
+  folderId: z16.string().optional(),
   // Optional: a folder linked by `link` to an artifact you own carries no
   // token — owner actions authorize via your stored login instead. A first
   // publish still writes the anonymous-mode token here.
-  publishToken: z15.string().optional(),
-  slug: z15.string(),
-  url: z15.string(),
-  workspace: z15.string().optional(),
-  workspaceId: z15.string().optional(),
-  workspaceKind: z15.enum(["personal", "workspace"]).optional()
-});
-var projectConfigSchema = z15.object({
-  folder: z15.string().trim().min(1).optional(),
-  workspace: z15.string().trim().min(1)
+  publishToken: z16.string().optional(),
+  slug: z16.string(),
+  url: z16.string(),
+  workspace: z16.string().optional(),
+  workspaceId: z16.string().optional(),
+  workspaceKind: z16.enum(["personal", "workspace"]).optional()
+});
+var projectConfigSchema = z16.object({
+  folder: z16.string().trim().min(1).optional(),
+  workspace: z16.string().trim().min(1)
 }).strict();
 var CONFIG_DIR = ".artifactcafe";
 var CONFIG_FILE = "config.json";
@@ -1007,7 +1052,7 @@ function readProjectConfig(dir) {
           JSON.parse(readFileSync2(file, "utf8"))
         );
       } catch (error) {
-        const message = error instanceof z15.ZodError ? error.issues[0]?.message ?? "invalid project target" : "invalid JSON";
+        const message = error instanceof z16.ZodError ? error.issues[0]?.message ?? "invalid project target" : "invalid JSON";
         throw new Error(`Invalid ${file}: ${message}.`);
       }
     }
@@ -1356,8 +1401,14 @@ function printThread(t) {
   const marker = t.status === "resolved" ? "\u2713" : "\u25CF";
   const date = t.createdAt.slice(0, 10);
   const edited = t.editedAt && !t.deleted ? " \xB7 edited" : "";
+  let state = "";
+  if (t.status === "resolved" && t.resolvedBy) {
+    state = ` \xB7 resolved by ${t.resolvedBy.displayName}`;
+  } else if (t.status === "open" && t.acknowledgedAt) {
+    state = " \xB7 acknowledged";
+  }
   console.log(
-    `${marker} ${t.author} \xB7 v${t.versionNumber} \xB7 ${date} \xB7 ${t.id}${edited}`
+    `${marker} ${t.author} \xB7 v${t.versionNumber} \xB7 ${date} \xB7 ${t.id}${edited}${state}`
   );
   if (t.anchor.type === "text") {
     console.log(`  \u21B3 "${t.anchor.quote}"`);
@@ -1558,6 +1609,9 @@ async function publish(opts) {
     entryPath,
     files: files.map(({ absPath: _absPath, ...manifest }) => manifest),
     ...placement.folderId ? { folderId: placement.folderId } : {},
+    // Agents often pass a double-quoted string where "\n" is a literal
+    // backslash-n; turn those back into real newlines so bullets survive.
+    ...opts.notes?.trim() ? { notes: opts.notes.replace(/\\n/g, "\n").trim() } : {},
     source: {
       agent: process.env.ARTIFACT_CAFE_AGENT,
       runId: process.env.ARTIFACT_CAFE_RUN_ID,
@@ -2442,10 +2496,29 @@ async function changeThreadStatus(opts) {
     artifact: opts.artifact
   });
   const client = createApiClient(target.apiUrl, target.credential);
-  const thread = opts.action === "resolve" ? await client.resolveThread(threadId) : await client.reopenThread(threadId);
+  const call = {
+    ack: () => client.acknowledgeThread(threadId),
+    reopen: () => client.reopenThread(threadId),
+    resolve: () => client.resolveThread(threadId)
+  }[opts.action];
+  const thread = await call();
   if (opts.json) {
     console.log(
-      JSON.stringify({ id: thread.id, status: thread.status }, null, 2)
+      JSON.stringify(
+        {
+          acknowledgedAt: thread.acknowledgedAt,
+          id: thread.id,
+          status: thread.status
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (opts.action === "ack") {
+    console.log(
+      `\u2713 Acknowledged ${thread.id} \u2014 reviewers now see it as being handled.`
     );
     return;
   }
@@ -2458,18 +2531,18 @@ import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as rea
 import { createRequire } from "module";
 import { homedir as homedir2 } from "os";
 import path14 from "path";
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var REGISTRY_LATEST_URL = "https://registry.npmjs.org/artifact-cafe/latest";
 var SKILL_SOURCE_URL = "https://raw.githubusercontent.com/Artifact-Cafe/skill/main/artifact-cafe/SKILL.md";
 var SKILL_UPDATE_COMMAND = "npx skills add artifact-cafe/skill --skill artifact-cafe -g";
 var CHECK_TTL_MS = 24 * 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 2e3;
 var SKILL_VERSION_PATTERN = /\*\*Skill version:\s*(\d+\.\d+\.\d+)\*\*/;
-var cacheSchema = z16.object({
-  checkedAt: z16.number(),
-  cliLatest: z16.string().nullable(),
-  skillLatest: z16.string().nullable(),
-  version: z16.literal(1)
+var cacheSchema = z17.object({
+  checkedAt: z17.number(),
+  cliLatest: z17.string().nullable(),
+  skillLatest: z17.string().nullable(),
+  version: z17.literal(1)
 });
 function cliVersion() {
   const pkg = createRequire(import.meta.url)("../package.json");
@@ -2524,7 +2597,7 @@ async function fetchText(url) {
 }
 async function fetchLatestVersions(previous) {
   const [cli, skill] = await Promise.all([
-    fetchJson(REGISTRY_LATEST_URL).then((body) => z16.object({ version: z16.string() }).parse(body).version).catch(() => null),
+    fetchJson(REGISTRY_LATEST_URL).then((body) => z17.object({ version: z17.string() }).parse(body).version).catch(() => null),
     fetchText(SKILL_SOURCE_URL).then((body) => SKILL_VERSION_PATTERN.exec(body)?.[1] ?? null).catch(() => null)
   ]);
   return {
@@ -2637,6 +2710,20 @@ function printWorkspace(workspace) {
 }
 
 // src/index.ts
+function readNotesArg(argv) {
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (token === void 0) {
+      continue;
+    }
+    if (token === "--notes") {
+      return argv[i + 1];
+    }
+    if (token.startsWith("--notes=")) {
+      return token.slice("--notes=".length);
+    }
+  }
+}
 var publish2 = defineCommand({
   args: {
     "api-key": {
@@ -2659,6 +2746,10 @@ var publish2 = defineCommand({
     },
     json: { description: "Machine-readable output", type: "boolean" },
     "no-open": { description: "Don't open the review URL", type: "boolean" },
+    notes: {
+      description: "Version notes \u2014 bullet-point changelog of what changed (newline-separated)",
+      type: "string"
+    },
     password: {
       description: "Password-protect the artifact (min 6 chars)",
       type: "string"
@@ -2679,6 +2770,7 @@ var publish2 = defineCommand({
         entry: args.entry,
         folder: args.folder,
         json: Boolean(args.json),
+        notes: readNotesArg(process.argv.slice(2)),
         open: !args["no-open"],
         password: args.password,
         title: args.title,
@@ -3046,7 +3138,11 @@ var threadStatusCommand = (action) => defineCommand({
     }
   },
   meta: {
-    description: action === "resolve" ? "Mark a comment thread resolved" : "Reopen a resolved comment thread",
+    description: {
+      ack: "Mark a thread acknowledged (seen, working on it)",
+      reopen: "Reopen a resolved comment thread",
+      resolve: "Mark a comment thread resolved"
+    }[action],
     name: action
   },
   async run({ args }) {
@@ -3067,6 +3163,7 @@ var threadStatusCommand = (action) => defineCommand({
 });
 var resolve = threadStatusCommand("resolve");
 var reopen = threadStatusCommand("reopen");
+var ack = threadStatusCommand("ack");
 var reply = defineCommand({
   args: {
     "api-key": {
@@ -3333,6 +3430,7 @@ var main = defineCommand({
     await showUsage(cmd);
   },
   subCommands: {
+    ack,
     comment: comment2,
     comments: comments2,
     dashboard,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "artifact-cafe",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "description": "Publish AI-generated artifacts for review on artifact.cafe",
   "type": "module",
   "bin": {