@mytegroupinc/myte-core 0.0.49 → 0.0.50

package/README.md

@@ -38,6 +38,12 @@ This package exists so the public wrapper can stay small and versioned cleanly.
   inserts cannot shift later pages. It remains compatible with older
   offset-only API versions and rejects duplicate cross-page records instead of
   committing an ambiguous local snapshot.
+- `feedback-sync` keeps stable comment IDs and nests every comment attachment
+  under its originating comment. Readable text, Markdown, and DOCX attachment
+  context is materialized under
+  `MyteCommandCenter/feedback-sync/comment-attachments`; binary formats remain
+  visible as metadata-only context. Raw S3/object-storage URLs are not written
+  into local sync artifacts.
 - `feedback status|edit|assign|archive|refine` writes reviewable local YAML artifacts.
 - `feedback submit|revise|comment` are live writes that require `--confirm-write --approval-artifact <path>`.
 - `feedback review|move|undo|apply` are governed writes with backend permission checks but no approval artifact flags.
@@ -145,12 +151,28 @@ their values and does not disable TLS verification. Captive portals and
 intercepting gateways are reported as non-JSON/HTML transport failures rather
 than as malformed Myte API responses.
 
-Feedback comment support:
-
-- `feedback-sync` includes existing feedback comment turns in local context.
-- Feedback-specific comment creation exists in the web backend at `/api/feedbacks/<feedback_id>/comments`, protected by JWT/project assignment.
+Feedback comment support:
+
+- `feedback-sync` includes existing feedback comments with `comment_id`,
+  sender, content, timestamps, and attachments nested under the originating
+  comment.
+- Readable text, Markdown, and DOCX comment attachments are extracted by the
+  backend under attachment safety limits and written to
+  `MyteCommandCenter/feedback-sync/comment-attachments/<feedback>/<comment>/`.
+  The local YAML points to the file. Unsupported binary formats remain listed
+  with `context_status: metadata_only`. Extraction is capped at 20 readable
+  comment attachments per API page by default; additional readable files stay
+  linked to their comments with `context_status: deferred`. Use
+  `--comment-attachment-limit <0-100>` to change that bounded limit.
+- `--no-with-prd-text` disables readable PRD and comment-attachment extraction
+  while retaining comment and attachment metadata.
+- Feedback-specific comment creation exists in the web backend at `/api/feedbacks/<feedback_id>/comments`, protected by JWT/project assignment.
 - Project-key comment creation is available through `myte feedback comment --feedback-id <id> --body "..." --confirm-write --approval-artifact ./comment.md` or `--body-file ./comment.md --confirm-write --approval-artifact ./comment.md`.
-- The project-key feedback comment endpoint is text-only in this slice and caps content at 500,000 characters. Use the web UI when comment attachments are required.
+- The project-key feedback comment endpoint is text-only in this slice and caps content at 500,000 characters. Use the web UI when comment attachments are required.
+- `feedback apply --force` is an owner/elevated emergency override for a stale
+  local artifact. It requires the artifact to contain a non-empty reason and
+  returns the persisted force/warning audit context; normal edits should use
+  submit followed by owner/elevated review.
 
 ## Mission Action Map
 
@@ -241,16 +263,42 @@ Agent rule: never guess `suggestion_id`. If `mission-ops.yml` is missing or stal
 | `feedback history` | Lists audited feedback board/refinement events. | Read-only; backend checks project access. |
 | `feedback validate` | Sends an artifact to backend validation without mutation. | Useful before submit or owner-direct apply. |
 | `feedback apply` | Applies an artifact through the owner-direct/emergency path. | No approval artifact required; not the normal collaborator flow; normal flow is `submit` -> `review`. |
+
+Canonical feedback lifecycle states are `frozen`, `todo`, `in_progress`, `in_review`, `completed`, `deployed`, `rejected`, and `archived`.
+
+### Feedback Permission Matrix
+
+| Project role | Feedback permissions |
+| --- | --- |
+| Project Owner | Full Feedback lifecycle: view/sync/comment, draft/validate/submit, direct apply, approve/request changes/reject/cancel reviews, assignment, governed board states, archive, version history, and diffs. |
+| Elevated collaborator (`owner_delegate`) | Same operational Feedback authority as the Project Owner, including direct apply, approval, assignment, governed board states, and archive. Project-level privilege grant/revoke and unrelated destructive infrastructure operations remain real-owner controls. |
+| Builder collaborator | View/sync/comment, create and validate local edits, submit/revise/cancel their review requests, self-assign, and move active work through `todo`, `in_progress`, `in_review`, and `completed`. Cannot approve, directly apply, unassign others, archive, reject, freeze, or deploy Feedback. |
+| Client collaborator | View/sync and participate in Feedback discussion. Does not receive builder edit, submit, assignment, or board-operation capabilities. |
+| Organisation owner not assigned to the project | View access only; no project Feedback mutation authority. |
+
+Stale local artifacts fail validation/apply with `snapshot_mismatch`. Re-sync,
+review the newer server state, and create a fresh artifact; `force` is not part
+of the normal collaborator workflow.
 
-Canonical feedback lifecycle states are `frozen`, `todo`, `in_progress`, `in_review`, `completed`, `deployed`, `rejected`, and `archived`.
-
-Reusable live smoke harness after deploy:
-
-```bash
-node ./scripts/feedback-live-full-harness.js --confirm-live --base-url https://api.myte.dev/api
-```
-
-The harness creates five disposable `TEST` feedback items from markdown, verifies batch review and batch board movement, batch archives the disposable items, verifies normal `feedback-sync` excludes archived items, and verifies the project-key surface does not expose Feedback unarchive/restore.
+Reusable live smoke harness after deploy:
+
+```bash
+node ./scripts/feedback-live-full-harness.js --confirm-live --base-url https://api.myte.dev/api
+```
+
+For strict owner/elevated/builder permission certification, set distinct
+`MYTE_OWNER_API_KEY`, `MYTE_DELEGATE_API_KEY`, and
+`MYTE_COLLABORATOR_API_KEY` values scoped to the same test project and add
+`--require-role-matrix`. To certify a real web-created comment attachment,
+provide an ephemeral `MYTE_WEB_ACCESS_TOKEN` for an assigned test user and add
+`--require-comment-attachment-sync`.
+
+The harness creates five disposable `TEST` feedback items plus one
+three-document Feedback item. It verifies comment sync, optional comment
+attachment materialization, stale-artifact rejection and fresh re-sync,
+request-changes/revise, owner and elevated approvals, regular collaborator
+denials, batch review and board movement, per-document refinement/version diff,
+exact-ID archival, archived sync exclusion, and project-key unarchive denial.
 
 ## Direct Project API Surface
 

package/cli.js

@@ -135,8 +135,8 @@ function splitCommand(argv) {
   return { command: "query", rest: argv };
 }
 
-function parseArgs(argv) {
-  const parsed = { _: [], fetch: true };
+function parseArgs(argv) {
+  const parsed = { _: [] };
   const aliases = { q: "query", d: "with-diff", c: "context", h: "help" };
   const setValue = (key, value) => {
     const finalKey = aliases[key] || key;
@@ -328,12 +328,14 @@ function printHelp() {
     "  - Optional: --target-contact-id <id> (repeatable) or --target-contact-ids <id1,id2>",
     "  - If the project has no linked client contacts, the backend falls back to the project owner for internal projects",
     "",
-    "feedback-sync contract:",
+    "feedback-sync contract:",
     "  - Runs from any workspace where you want local MyteCommandCenter data written",
     "  - Syncs non-archived feedback by default so local Command Center data stays focused on active visible work",
     "  - Archived feedback is intentionally excluded from normal sync; returning it to active work is web UI only",
-    "  - Writes project feedback metadata and conversation turns into MyteCommandCenter/data/feedback.yml",
-    "  - Stores full PRD context in MyteCommandCenter/PRD/feedback-sync/*.md and points to those files from feedback.yml",
+    "  - Writes project feedback metadata and comment turns, stable comment ids, and nested attachment metadata into MyteCommandCenter/data/feedback.yml",
+    "  - Stores full PRD context in MyteCommandCenter/PRD/feedback-sync/*.md and points to those files from feedback.yml",
+    "  - Stores readable text/Markdown/DOCX comment attachment context under MyteCommandCenter/feedback-sync/comment-attachments and never writes raw storage URLs",
+    "  - Non-readable comment attachments remain nested under the correct comment as metadata_only context",
     "  - Reads existing feedback comments and can create text-only feedback-specific comments through the project-key API",
     "",
     "feedback review contract:",
@@ -428,7 +430,8 @@ function printHelp() {
     "  --due-date <date>     Feedback due date target for edit artifacts",
     "  --review-note <text>  Review note stored in feedback refinement history",
     "  --with-prd-text       Include extracted PRD text so local PRD files are materialized during feedback-sync (default: on)",
-    "  --no-with-prd-text    Skip PRD text download and write only feedback metadata/comment turns",
+    "  --no-with-prd-text    Skip PRD and readable comment-attachment extraction; keep feedback/comment/attachment metadata",
+    "  --comment-attachment-limit <n>  Cap readable comment-attachment extraction per sync page (0-100; default: 20)",
     "  --mission-ids <ids>   Comma-separated mission business ids for run-qaqc, mission status, or mission archive (quote multi-id values on PowerShell)",
     "  --reason <text>       Optional reason for governed mission archive or feedback changes",
     "  --actor-scope <id>    Actor workspace key inside mission-ops.yml (defaults to machine-cwd slug)",
@@ -436,7 +439,7 @@ function printHelp() {
     "  --approval-artifact   Local .md/.markdown/.yml/.yaml/.json approval artifact for gated write commands",
     "  --wait                Poll batch status until terminal completion for run-qaqc",
     "  --sync                After run-qaqc completes, refresh local QAQC file",
-    "  --force               Allow run-qaqc to bypass stale-state protection when supported",
+    "  --force               Allow QAQC retry or owner/elevated stale Feedback apply; Feedback force requires a reason",
     "  --no-sync             Skip automatic post-mutation sync for suggestions, missions, and feedback mutations",
     "  --print-context       Print JSON payload and exit (no query call)",
     "  --no-fetch            Don't git fetch origin main/master before diff",
@@ -1879,18 +1882,18 @@ function collectGitDiffWithDiagnostics({
 
       const headingParts = [`${name} (${dir || "."})`];
       if (repo.role) headingParts.push(`role=${repo.role}`);
-      let section = `### ${headingParts.join(" | ")}\n\n`;
-      section += `# ?? Base vs HEAD (${repoSummary.base_ref_label}...HEAD | head=${headBranch})\n`;
-      if (repoSummary.matched_by?.length) {
-        section += `# ?? Matched by ${repoSummary.matched_by.join(", ")}\n`;
-      }
-      if (repoSummary.compare_remote_url) {
-        section += `# ?? Compare remote ${repoSummary.compare_remote_url}\n`;
-      }
-      if (baseDiff) section += `${baseDiff}\n\n`;
-      if (staged) section += `# ?? Staged changes\n${staged}\n\n`;
-      if (unstaged) section += `# ?? Unstaged changes\n${unstaged}\n\n`;
-      if (untrackedDiffs) section += `# ?? Untracked files (full contents below)\n${untrackedDiffs}\n`;
+      let section = `### ${headingParts.join(" | ")}\n\n`;
+      if (repoSummary.matched_by?.length) {
+        section += `# ?? Matched by ${repoSummary.matched_by.join(", ")}\n`;
+      }
+      if (repoSummary.compare_remote_url) {
+        section += `# ?? Compare remote ${repoSummary.compare_remote_url}\n`;
+      }
+      if (staged) section += `# ?? Staged changes\n${staged}\n\n`;
+      if (unstaged) section += `# ?? Unstaged changes\n${unstaged}\n\n`;
+      if (untrackedDiffs) section += `# ?? Untracked files (full contents below)\n${untrackedDiffs}\n`;
+      section += `# ?? Base vs HEAD (${repoSummary.base_ref_label}...HEAD | head=${headBranch})\n`;
+      if (baseDiff) section += `${baseDiff}\n\n`;
 
       if (!repoSummary.has_changes) {
         section += "_No local changes - working tree clean_\n\n";
@@ -2008,6 +2011,21 @@ async function fetchFeedbackSyncSnapshot({ apiBase, key, timeoutMs, filters = {}
   if (filters.includeCommentTurns !== undefined) {
     url.searchParams.set("include_comment_turns", filters.includeCommentTurns ? "true" : "false");
   }
+  if (filters.includeCommentAttachmentText !== undefined) {
+    url.searchParams.set(
+      "include_comment_attachment_text",
+      filters.includeCommentAttachmentText ? "true" : "false"
+    );
+  }
+  if (
+    filters.commentAttachmentTextLimit !== undefined
+    && filters.commentAttachmentTextLimit !== null
+  ) {
+    url.searchParams.set(
+      "comment_attachment_text_limit",
+      String(filters.commentAttachmentTextLimit)
+    );
+  }
   if (filters.limit !== undefined && filters.limit !== null && filters.limit !== "") {
     url.searchParams.set("limit", String(filters.limit));
   }
@@ -2053,6 +2071,9 @@ function aggregateFeedbackSyncCounts(items, availableTotal) {
   const bySource = {};
   let withPrdText = 0;
   let withConversationTurns = 0;
+  let withCommentAttachments = 0;
+  let commentAttachments = 0;
+  const commentAttachmentContext = {};
   for (const item of items) {
     const status = String(item?.status || "Pending");
     const source = String(item?.source || "User");
@@ -2062,12 +2083,30 @@ function aggregateFeedbackSyncCounts(items, availableTotal) {
     if (Array.isArray(item?.conversation_turns) && item.conversation_turns.length > 0) {
       withConversationTurns += 1;
     }
+    const itemCommentAttachments = (item?.conversation_turns || []).reduce(
+      (total, turn) => total + (Array.isArray(turn?.attachments) ? turn.attachments.length : 0),
+      0
+    );
+    if (itemCommentAttachments > 0) {
+      withCommentAttachments += 1;
+      commentAttachments += itemCommentAttachments;
+      for (const turn of item?.conversation_turns || []) {
+        for (const attachment of turn?.attachments || []) {
+          const contextStatus = String(attachment?.context_status || "metadata_only");
+          commentAttachmentContext[contextStatus] =
+            (commentAttachmentContext[contextStatus] || 0) + 1;
+        }
+      }
+    }
   }
   return {
     total_feedback: items.length,
     available_feedback: Number.isFinite(Number(availableTotal)) ? Number(availableTotal) : items.length,
     with_prd_text: withPrdText,
     with_conversation_turns: withConversationTurns,
+    with_comment_attachments: withCommentAttachments,
+    comment_attachments: commentAttachments,
+    comment_attachment_context: commentAttachmentContext,
     by_status: byStatus,
     by_source: bySource,
   };
@@ -3959,22 +3998,47 @@ function ensureTrailingNewline(value) {
   return text.endsWith("\n") ? text : `${text}\n`;
 }
 
-function normalizeFeedbackConversationTurns(turns) {
-  if (!Array.isArray(turns)) return [];
-  return turns
-    .map((turn) => {
-      const content = String(turn?.content || "").trim();
-      if (!content) return null;
-      const normalized = {
-        sender_name: firstNonEmptyString(turn?.sender_name, turn?.user_name, turn?.author_name) || "Unknown",
-        content,
-      };
-      const createdAt = firstNonEmptyString(turn?.created_at, turn?.timestamp);
-      if (createdAt) normalized.created_at = createdAt;
-      return normalized;
-    })
-    .filter(Boolean);
-}
+function normalizeFeedbackConversationTurns(turns) {
+  if (!Array.isArray(turns)) return [];
+  return turns
+    .map((turn) => {
+      const content = String(turn?.content || "").trim();
+      const attachments = (Array.isArray(turn?.attachments) ? turn.attachments : [])
+        .map((attachment) => {
+          if (!isPlainObject(attachment)) return null;
+          const normalizedAttachment = {
+            name: firstNonEmptyString(attachment.name) || "attachment",
+            context_status: firstNonEmptyString(attachment.context_status) || "metadata_only",
+          };
+          for (const field of ["type", "asset_kind", "download_name", "format"]) {
+            const value = firstNonEmptyString(attachment[field]);
+            if (value) normalizedAttachment[field] = value;
+          }
+          const size = Number(attachment.size);
+          if (Number.isFinite(size) && size >= 0) normalizedAttachment.size = size;
+          const attachmentContent = String(attachment.content || "");
+          if (attachmentContent.trim()) normalizedAttachment.content = attachmentContent;
+          if (attachment.truncated !== undefined) {
+            normalizedAttachment.truncated = Boolean(attachment.truncated);
+          }
+          return normalizedAttachment;
+        })
+        .filter(Boolean);
+      if (!content && attachments.length === 0) return null;
+      const normalized = {
+        comment_id: firstNonEmptyString(turn?.comment_id, turn?.id),
+        sender_name: firstNonEmptyString(turn?.sender_name, turn?.user_name, turn?.author_name) || "Unknown",
+        content,
+        attachments,
+      };
+      const createdAt = firstNonEmptyString(turn?.created_at, turn?.timestamp);
+      if (createdAt) normalized.created_at = createdAt;
+      const updatedAt = firstNonEmptyString(turn?.updated_at);
+      if (updatedAt) normalized.updated_at = updatedAt;
+      return normalized;
+    })
+    .filter(Boolean);
+}
 
 function readJsonFile(filePath) {
   if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) return null;
@@ -4336,20 +4400,83 @@ function writeQaqcSnapshot({ snapshot, wrapperRoot, outputDir }) {
 function writeFeedbackSnapshot({ snapshot, wrapperRoot, outputDir }) {
   const { targetRoot, dataRoot } = resolveCommandCenterRoots(wrapperRoot, outputDir);
   const prdSyncDir = path.join(targetRoot, "PRD", "feedback-sync");
+  const commentAttachmentsDir = path.join(targetRoot, "feedback-sync", "comment-attachments");
   const transactionToken = `${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
   const stagingRoot = path.join(targetRoot, `.myte-feedback-sync-${transactionToken}`);
   const stagedDataRoot = path.join(stagingRoot, "data");
   const stagedPrdRoot = path.join(stagingRoot, "PRD", "feedback-sync");
+  const stagedCommentAttachmentsRoot = path.join(stagingRoot, "feedback-sync", "comment-attachments");
   ensureDir(stagedDataRoot);
   ensureDir(stagedPrdRoot);
+  ensureDir(stagedCommentAttachmentsRoot);
 
   const items = Array.isArray(snapshot.items) ? snapshot.items : [];
   let prdFileCount = 0;
   let prdDocumentSetCount = 0;
+  let commentAttachmentCount = 0;
+  let commentAttachmentFileCount = 0;
+  const commentAttachmentContextCounts = {};
   const materializedItems = items.map((rawItem, index) => {
     const item = isPlainObject(rawItem) ? { ...rawItem } : {};
     const feedbackId = stableItemId(item, ["feedback_id", "id"], `F${String(index + 1).padStart(3, "0")}`);
-    const conversationTurns = normalizeFeedbackConversationTurns(item.conversation_turns);
+    const feedbackFolderName = sanitizeFileSegment(feedbackId, `feedback-${index + 1}`);
+    const conversationTurns = normalizeFeedbackConversationTurns(item.conversation_turns)
+      .map((turn, turnIndex) => {
+        const commentId = stableItemId(
+          turn,
+          ["comment_id", "id"],
+          `comment-${String(turnIndex + 1).padStart(3, "0")}`
+        );
+        const commentFolderName = sanitizeFileSegment(commentId, `comment-${turnIndex + 1}`);
+        const attachments = (turn.attachments || []).map((rawAttachment, attachmentIndex) => {
+          const attachment = isPlainObject(rawAttachment) ? { ...rawAttachment } : {};
+          const content = String(attachment.content || "");
+          let localFile = null;
+          commentAttachmentCount += 1;
+          const contextStatus = String(attachment.context_status || "metadata_only");
+          commentAttachmentContextCounts[contextStatus] =
+            (commentAttachmentContextCounts[contextStatus] || 0) + 1;
+          if (content.trim()) {
+            const sourceName = sanitizeFileSegment(
+              attachment.name,
+              `attachment-${attachmentIndex + 1}`
+            );
+            const sourceBase = path.parse(sourceName).name || `attachment-${attachmentIndex + 1}`;
+            const extension = String(attachment.format || "").toLowerCase() === "markdown"
+              ? "md"
+              : "txt";
+            const filename = `${String(attachmentIndex + 1).padStart(2, "0")}-${sourceBase}.${extension}`;
+            const stagedPath = path.join(
+              stagedCommentAttachmentsRoot,
+              feedbackFolderName,
+              commentFolderName,
+              filename
+            );
+            ensureDir(path.dirname(stagedPath));
+            writeTextFile(stagedPath, ensureTrailingNewline(content));
+            localFile = toPosixRelativePath(
+              targetRoot,
+              path.join(
+                commentAttachmentsDir,
+                feedbackFolderName,
+                commentFolderName,
+                filename
+              )
+            );
+            commentAttachmentFileCount += 1;
+          }
+          delete attachment.content;
+          return {
+            ...attachment,
+            local_file: localFile,
+          };
+        });
+        return {
+          ...turn,
+          comment_id: commentId,
+          attachments,
+        };
+      });
     const prdText = String(item.prd_text || "").trim();
     const rawPrdDocuments = Array.isArray(item.prd_documents) ? item.prd_documents : [];
     const attachmentDocuments = Array.isArray(item.attachment_documents) ? item.attachment_documents : [];
@@ -4363,7 +4490,6 @@ function writeFeedbackSnapshot({ snapshot, wrapperRoot, outputDir }) {
 
     if (rawPrdDocuments.length > 0) {
       prdDocumentSetCount += 1;
-      const feedbackFolderName = sanitizeFileSegment(feedbackId, `feedback-${index + 1}`);
       materializedPrdDocuments = rawPrdDocuments.map((rawDocument, documentIndex) => {
         const document = isPlainObject(rawDocument) ? { ...rawDocument } : {};
         const markdown = String(
@@ -4439,9 +4565,17 @@ function writeFeedbackSnapshot({ snapshot, wrapperRoot, outputDir }) {
     : { total_feedback: materializedItems.length };
   snapshotCounts.with_prd_files = prdFileCount;
   snapshotCounts.with_prd_document_sets = prdDocumentSetCount;
-  if (snapshotCounts.with_conversation_turns === undefined) {
-    snapshotCounts.with_conversation_turns = materializedItems.filter((item) => Array.isArray(item?.conversation_turns) && item.conversation_turns.length > 0).length;
-  }
+  snapshotCounts.comment_attachments = commentAttachmentCount;
+  snapshotCounts.comment_attachment_context = commentAttachmentContextCounts;
+  snapshotCounts.readable_comment_attachment_files = commentAttachmentFileCount;
+  if (snapshotCounts.with_conversation_turns === undefined) {
+    snapshotCounts.with_conversation_turns = materializedItems.filter((item) => Array.isArray(item?.conversation_turns) && item.conversation_turns.length > 0).length;
+  }
+  snapshotCounts.with_comment_attachments = materializedItems.filter(
+    (item) => (item?.conversation_turns || []).some(
+      (turn) => Array.isArray(turn?.attachments) && turn.attachments.length > 0
+    )
+  ).length;
 
   const payload = scrubBootstrapValue({
     schema_version: snapshot.schema_version || 2,
@@ -4451,8 +4585,11 @@ function writeFeedbackSnapshot({ snapshot, wrapperRoot, outputDir }) {
     counts: snapshotCounts,
     artifacts: {
       feedback_prd_root: "PRD/feedback-sync",
+      feedback_comment_attachment_root: "feedback-sync/comment-attachments",
       with_prd_files: prdFileCount,
       with_prd_document_sets: prdDocumentSetCount,
+      comment_attachments: commentAttachmentCount,
+      readable_comment_attachment_files: commentAttachmentFileCount,
     },
     queue: materializedItems
       .filter((item) => String(item?.status || "").trim().toLowerCase() !== "resolved")
@@ -4494,6 +4631,10 @@ function writeFeedbackSnapshot({ snapshot, wrapperRoot, outputDir }) {
         staged: stagedPrdRoot,
         target: prdSyncDir,
       },
+      {
+        staged: stagedCommentAttachmentsRoot,
+        target: commentAttachmentsDir,
+      },
       {
         staged: stagedFeedbackPath,
         target: path.join(dataRoot, "feedback.yml"),
@@ -4505,6 +4646,7 @@ function writeFeedbackSnapshot({ snapshot, wrapperRoot, outputDir }) {
       targetRoot,
       dataRoot,
       prdSyncDir,
+      commentAttachmentsDir,
       manifest: payload,
     };
   } finally {
@@ -4656,11 +4798,13 @@ function summarizeFeedbackRefinementResult(data) {
     new_snapshot_hash: data?.new_snapshot_hash || data?.feedback?.snapshot_hash || null,
     diff_count: Array.isArray(data?.diffs) ? data.diffs.length : 0,
     diffs: data?.diffs || [],
-    warnings: data?.warnings || [],
-    errors: data?.errors || [],
-    history_id: data?.history?.history_id || null,
-  };
-}
+    warnings: data?.warnings || [],
+    errors: data?.errors || [],
+    history_id: data?.history?.history_id || null,
+    feedback: data?.feedback || null,
+    history: data?.history || null,
+  };
+}
 
 function missionOpsThreads(payload) {
   if (Array.isArray(payload?.threads)) return payload.threads;
@@ -6275,6 +6419,7 @@ async function runFeedbackSync(args) {
   const includePrdText = resolveBooleanFlag(args, "with-prd-text", true);
   let pageSize;
   let maxItems;
+  let commentAttachmentTextLimit;
   try {
     pageSize = resolveBoundedInteger(
       args["page-size"] || args.pageSize || args.page_size,
@@ -6284,16 +6429,29 @@ async function runFeedbackSync(args) {
       args.limit,
       { fallback: 0, min: 0, max: 100_000, label: "limit" }
     );
+    commentAttachmentTextLimit = resolveBoundedInteger(
+      args["comment-attachment-limit"]
+        || args.commentAttachmentLimit
+        || args.comment_attachment_limit,
+      {
+        fallback: 20,
+        min: 0,
+        max: 100,
+        label: "comment-attachment-limit",
+      }
+    );
   } catch (err) {
     console.error(err?.message || err);
     process.exit(1);
   }
   const filters = {
-    status: firstNonEmptyString(args.status) || "",
-    source: firstNonEmptyString(args.source) || "",
-    includePrdText,
-    includeCommentTurns: true,
-  };
+    status: firstNonEmptyString(args.status) || "",
+    source: firstNonEmptyString(args.source) || "",
+    includePrdText,
+    includeCommentTurns: true,
+    includeCommentAttachmentText: includePrdText,
+    commentAttachmentTextLimit,
+  };
 
   let snapshot;
   try {
@@ -6403,8 +6561,10 @@ async function refreshFeedbackSnapshotAfterMutation(args, { apiBase, key, timeou
       filters: {
         status: "",
         source: "",
-        includePrdText: true,
+        includePrdText: true,
         includeCommentTurns: true,
+        includeCommentAttachmentText: true,
+        commentAttachmentTextLimit: 20,
       },
       pageSize: DEFAULT_FEEDBACK_SYNC_PAGE_SIZE,
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mytegroupinc/myte-core",
-  "version": "0.0.49",
+  "version": "0.0.50",
   "description": "Myte CLI core implementation.",
   "type": "commonjs",
   "main": "cli.js",
@@ -15,7 +15,7 @@
     "package.json"
   ],
   "scripts": {
-    "test": "node --test"
+    "test": "node --test --test-concurrency=1"
   },
   "license": "MIT",
   "engines": {