@mytegroupinc/myte-core 0.0.20 → 0.0.21

package/README.md

@@ -19,5 +19,6 @@ This package exists so the public wrapper can stay small and versioned cleanly.
 ## Behavior Summary
 
 - Snapshot-style commands such as `bootstrap`, `sync-qaqc`, `feedback-sync`, and `suggestions sync` write local `MyteCommandCenter` data.
+- `feedback status|edit|assign|archive` writes reviewable local YAML artifacts, while `feedback validate|apply` sends those artifacts to the backend so business rules stay server-side.
 - `query --with-diff` requires project repos to be configured for diff collection and fails fast when no matching local project repo can be resolved.
 - Public package documentation is intentionally minimal. Internal rollout and design notes are not part of the npm package contract.

package/cli.js

@@ -98,6 +98,7 @@ function splitCommand(argv) {
     "update-owner",
     "update-client",
     "feedback-sync",
+    "feedback",
     "help",
     "--help",
     "-h",
@@ -141,6 +142,17 @@ function parseArgs(argv) {
         "target-contact-ids",
         "status",
         "source",
+        "feedback-id",
+        "reason",
+        "review-action",
+        "idempotency-key",
+        "user-id",
+        "assigned-user-id",
+        "due-date",
+        "priority",
+        "review-note",
+        "tags",
+        "tag",
         "mission-ids",
         "client-session-id",
       ],
@@ -212,6 +224,10 @@ function printHelp() {
     "  myte update-owner --subject \"<text>\" [--body-markdown \"...\"] [--body-file ./update.md] [--json]",
     "  myte update-client --subject \"<text>\" [--body-markdown \"...\"] [--body-file ./update.md] [--target-contact-ids <id1,id2>] [--json]",
     "  myte feedback-sync [--status <value>] [--source <value>] [--with-prd-text|--no-with-prd-text] [--output-dir ./MyteCommandCenter] [--json]",
+    "  myte feedback status --feedback-id <id> --status todo|in_progress|in_review|completed|deployed|rejected|archived --reason \"...\"",
+    "  myte feedback edit --feedback-id <id> [--title \"...\"] [--feedback-text \"...\"] [--priority High] [--reason \"...\"]",
+    "  myte feedback validate --file ./MyteCommandCenter/reviews/feedback/<id>-status.yml [--json]",
+    "  myte feedback apply --file ./MyteCommandCenter/reviews/feedback/<id>-status.yml [--json]",
     "  myte create-prd <file.md> [more.md ...] [--json] [--title \"...\"] [--description \"...\"]",
     "  cat file.md | myte create-prd --stdin [--title \"...\"] [--description \"...\"]",
     "  cat update.md | myte update-owner --stdin --subject \"Owner update\"",
@@ -290,6 +306,12 @@ function printHelp() {
     "  - 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",
     "",
+    "feedback review contract:",
+    "  - Draft commands write review artifacts under MyteCommandCenter/reviews/feedback/*.yml for local IDE diff review",
+    "  - validate/apply send those artifacts to /api/project-assistant/feedback/<id>/refinement/*",
+    "  - The backend owns authorization, stale snapshot checks, allowed field/transition rules, and history",
+    "  - apply is idempotent and does not rewrite local feedback.yml; run feedback-sync after apply to refresh local state",
+    "",
     "Options:",
     "  --with-diff           Include deterministic git diffs (project-scoped; fails fast if no project repos are configured or resolved)",
     "  --diff-limit <chars>  Truncate diff context to N chars (default: 200000)",
@@ -310,8 +332,15 @@ function printHelp() {
     "  --body-file <path>    Read update-owner or update-client markdown body from a file",
     "  --target-contact-id   Add one client contact ObjectId (repeatable)",
     "  --target-contact-ids  Comma-separated client contact ObjectIds",
-    "  --status <value>      For mission status: required target status (todo|in_progress|done). For feedback-sync: optional filter (default: Pending).",
+    "  --feedback-id <id>    Feedback ObjectId for feedback review commands",
+    "  --reason <text>       Human review reason included in feedback refinement artifacts",
+    "  --status <value>      Mission status target, feedback-sync filter, or feedback review state depending on command",
     "  --source <value>      Feedback source filter for feedback-sync",
+    "  --priority <value>    Feedback review priority target: Low, Medium, or High",
+    "  --user-id <id>        Feedback assignee user id for `myte feedback assign`",
+    "  --assigned-user-id    Alias for --user-id in feedback assign",
+    "  --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",
     "  --mission-ids <ids>   Comma-separated mission business ids for run-qaqc or mission status (quote multi-id values on PowerShell)",
@@ -340,6 +369,9 @@ function printHelp() {
     "  myte update-owner --subject \"QAQC progress\" --body-file ./updates/owner.md",
     "  myte update-client --subject \"Weekly client update\" --body-file ./updates/week-12.md",
     "  myte feedback-sync --json",
+    "  myte feedback status --feedback-id 507f1f77bcf86cd799439011 --status in_review --reason \"Ready for owner review\"",
+    "  myte feedback validate --file ./MyteCommandCenter/reviews/feedback/507f1f77bcf86cd799439011-status.yml --json",
+    "  myte feedback apply --file ./MyteCommandCenter/reviews/feedback/507f1f77bcf86cd799439011-status.yml --json",
     "  myte suggestions create --file ./suggestions/create.yml",
     "  myte suggestions revise",
     "  myte suggestions review",
@@ -1079,21 +1111,35 @@ function resolveConfiguredRepoBindings(bindings) {
 
   const cwd = process.cwd();
   const currentRepoRoot = findGitTopLevel(cwd);
-  const scanStart = currentRepoRoot ? path.dirname(currentRepoRoot) : cwd;
+  const searchRoots = [];
+  const seenRoots = new Set();
+  const pushSearchRoot = (value) => {
+    if (!value) return;
+    const resolved = path.resolve(value);
+    if (seenRoots.has(resolved)) return;
+    seenRoots.add(resolved);
+    searchRoots.push(resolved);
+  };
 
-  const ancestors = [];
+  // Prefer the invocation workspace first. A wrapper repo can contain the
+  // configured API/WEB repos as children, so jumping immediately to the parent
+  // can miss the project repos entirely.
+  pushSearchRoot(cwd);
+  if (currentRepoRoot) pushSearchRoot(currentRepoRoot);
+
+  const scanStart = currentRepoRoot ? path.dirname(currentRepoRoot) : path.dirname(cwd);
   let cur = scanStart;
   for (let i = 0; i < 8; i += 1) {
-    ancestors.push(cur);
+    pushSearchRoot(cur);
     const parent = path.dirname(cur);
     if (parent === cur) break;
     cur = parent;
   }
 
-  let fallbackCandidates = currentRepoRoot ? listGitRepoCandidates(path.dirname(currentRepoRoot), currentRepoRoot) : [];
-  let fallbackRoot = currentRepoRoot ? path.dirname(currentRepoRoot) : null;
+  let fallbackCandidates = [];
+  let fallbackRoot = null;
 
-  for (const candidateRoot of ancestors) {
+  for (const candidateRoot of searchRoots) {
     const candidates = listGitRepoCandidates(candidateRoot, currentRepoRoot);
     if (!fallbackCandidates.length && candidates.length) {
       fallbackCandidates = candidates;
@@ -1585,6 +1631,83 @@ async function fetchFeedbackSyncSnapshot({ apiBase, key, timeoutMs, filters = {}
   return body.data || {};
 }
 
+async function fetchFeedbackReview({ apiBase, key, timeoutMs, feedbackId }) {
+  const fetchFn = await getFetch();
+  const url = `${apiBase}/project-assistant/feedback/${encodeURIComponent(String(feedbackId || ""))}`;
+  const { resp, body } = await fetchJsonWithTimeout(
+    fetchFn,
+    url,
+    {
+      method: "GET",
+      headers: { Authorization: `Bearer ${key}` },
+    },
+    timeoutMs
+  );
+
+  if (!resp.ok || body.status !== "success") {
+    const msg = body?.message || `Feedback review request failed (${resp.status})`;
+    const err = new Error(msg);
+    err.status = resp.status;
+    throw err;
+  }
+  return body.data || {};
+}
+
+async function fetchFeedbackHistory({ apiBase, key, timeoutMs, feedbackId }) {
+  const fetchFn = await getFetch();
+  const url = `${apiBase}/project-assistant/feedback/${encodeURIComponent(String(feedbackId || ""))}/refinement/history`;
+  const { resp, body } = await fetchJsonWithTimeout(
+    fetchFn,
+    url,
+    {
+      method: "GET",
+      headers: { Authorization: `Bearer ${key}` },
+    },
+    timeoutMs
+  );
+
+  if (!resp.ok || body.status !== "success") {
+    const msg = body?.message || `Feedback history request failed (${resp.status})`;
+    const err = new Error(msg);
+    err.status = resp.status;
+    throw err;
+  }
+  return body.data || {};
+}
+
+async function postFeedbackRefinement({ apiBase, key, timeoutMs, feedbackId, mode, payload, idempotencyKey, clientSessionId }) {
+  const fetchFn = await getFetch();
+  const action = String(mode || "").trim();
+  const url = `${apiBase}/project-assistant/feedback/${encodeURIComponent(String(feedbackId || ""))}/refinement/${action}`;
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${key}`,
+    ...(String(clientSessionId || "").trim() ? { "X-Client-Session-Id": String(clientSessionId).trim() } : {}),
+  };
+  if (idempotencyKey) {
+    headers["X-Idempotency-Key"] = String(idempotencyKey).trim();
+  }
+  const { resp, body } = await fetchJsonWithTimeout(
+    fetchFn,
+    url,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload || {}),
+    },
+    timeoutMs
+  );
+
+  if (!resp.ok || body.status !== "success") {
+    const msg = body?.message || `Feedback refinement ${action} failed (${resp.status})`;
+    const err = new Error(msg);
+    err.status = resp.status;
+    err.data = body?.data;
+    throw err;
+  }
+  return body.data || {};
+}
+
 async function fetchSuggestionsSyncSnapshot({ apiBase, key, timeoutMs, actorScope = "" }) {
   const fetchFn = await getFetch();
   const url = new URL(`${apiBase}/project-assistant/suggestions`);
@@ -2756,6 +2879,150 @@ function writeFeedbackSnapshot({ snapshot, wrapperRoot, outputDir }) {
   };
 }
 
+function resolveFeedbackReviewPaths(args, { requireFeedback = false } = {}) {
+  const outputDir = args["output-dir"] || args.outputDir || args.output_dir;
+  const targetRoot = outputDir
+    ? path.resolve(process.cwd(), String(outputDir))
+    : findExistingCommandCenterRoot(process.cwd());
+  if (!targetRoot) {
+    if (requireFeedback) {
+      console.error("feedback.yml was not found. Run `myte feedback-sync` first or pass --output-dir.");
+      process.exit(1);
+    }
+    return null;
+  }
+  const dataRoot = path.join(targetRoot, "data");
+  const feedbackPath = path.join(dataRoot, "feedback.yml");
+  if (requireFeedback && !fs.existsSync(feedbackPath)) {
+    console.error("feedback.yml was not found. Run `myte feedback-sync` first or pass --output-dir.");
+    process.exit(1);
+  }
+  return {
+    targetRoot,
+    dataRoot,
+    feedbackPath,
+    reviewsRoot: path.join(targetRoot, "reviews", "feedback"),
+    wrapperRoot: path.dirname(targetRoot),
+  };
+}
+
+function readFeedbackManifest(args) {
+  const paths = resolveFeedbackReviewPaths(args, { requireFeedback: true });
+  const manifest = readYamlFile(paths.feedbackPath) || {};
+  if (!isPlainObject(manifest)) {
+    console.error(`Invalid feedback manifest: ${paths.feedbackPath}`);
+    process.exit(1);
+  }
+  return { paths, manifest };
+}
+
+function findFeedbackManifestItem(manifest, feedbackId) {
+  const wanted = String(feedbackId || "").trim();
+  if (!wanted) return null;
+  const items = Array.isArray(manifest?.items) ? manifest.items : [];
+  return items.find((item) => String(item?.feedback_id || item?.id || "").trim() === wanted) || null;
+}
+
+function readFeedbackRefinementArtifact(args) {
+  const filePath = firstNonEmptyString(args.file);
+  if (!filePath) {
+    console.error("Missing --file for feedback validate/apply.");
+    process.exit(1);
+  }
+  const absPath = resolveInputFile(filePath, "Feedback refinement");
+  const text = fs.readFileSync(absPath, "utf8");
+  let payload;
+  if (absPath.toLowerCase().endsWith(".json")) {
+    payload = JSON.parse(text);
+  } else {
+    payload = parseYaml(text);
+  }
+  if (!isPlainObject(payload)) {
+    console.error(`Feedback refinement file must contain an object: ${absPath}`);
+    process.exit(1);
+  }
+  return { absPath, payload };
+}
+
+function parseFeedbackTags(args) {
+  const values = parseCsvValues(args.tags, args.tag);
+  return values.length ? values : undefined;
+}
+
+function feedbackChange(from, to) {
+  return { from: from === undefined ? null : from, to: to === undefined ? null : to };
+}
+
+function buildFeedbackRefinementArtifact({ manifest, item, feedbackId, action, changes, reason, args }) {
+  const clientSessionId = firstNonEmptyString(args["client-session-id"], args.clientSessionId, args.client_session_id);
+  const artifact = {
+    schema_version: 1,
+    kind: "feedback_refinement",
+    project_id: firstNonEmptyString(manifest?.project?.id, item?.project_id),
+    feedback_id: feedbackId,
+    title_snapshot: firstNonEmptyString(item?.title),
+    base_snapshot_hash: firstNonEmptyString(item?.snapshot_hash),
+    base_updated_at: firstNonEmptyString(item?.updated_at),
+    review_action: action,
+    reason: reason || null,
+    changes,
+    force: Boolean(args.force) || undefined,
+    client_session_id: clientSessionId || undefined,
+    created_at: new Date().toISOString(),
+  };
+  return Object.fromEntries(Object.entries(artifact).filter(([, value]) => value !== undefined));
+}
+
+function writeFeedbackRefinementArtifact({ paths, artifact, action }) {
+  const feedbackId = sanitizeFileSegment(artifact.feedback_id, "feedback");
+  const actionSegment = sanitizeFileSegment(action || artifact.review_action || "refine", "refine");
+  const filePath = path.join(paths.reviewsRoot, `${feedbackId}-${actionSegment}.yml`);
+  writeYamlFile(filePath, artifact);
+  return filePath;
+}
+
+function printFeedbackRefinementDraft({ artifact, filePath, args }) {
+  const output = {
+    feedback_id: artifact.feedback_id,
+    review_action: artifact.review_action,
+    artifact_path: filePath || null,
+    base_snapshot_hash: artifact.base_snapshot_hash || null,
+    changes: artifact.changes || {},
+    reason: artifact.reason || null,
+  };
+  if (args.json) {
+    console.log(JSON.stringify(output, null, 2));
+    return;
+  }
+  console.log(`Feedback: ${output.feedback_id}`);
+  console.log(`Action: ${output.review_action}`);
+  if (filePath) console.log(`Artifact: ${filePath}`);
+  console.log(`Base Snapshot: ${output.base_snapshot_hash || "n/a"}`);
+  console.log("Changes:");
+  for (const [field, change] of Object.entries(output.changes || {})) {
+    const fromValue = change && typeof change === "object" && "from" in change ? change.from : null;
+    const toValue = change && typeof change === "object" && "to" in change ? change.to : change;
+    console.log(`- ${field}: ${JSON.stringify(fromValue)} -> ${JSON.stringify(toValue)}`);
+  }
+  if (output.reason) console.log(`Reason: ${output.reason}`);
+}
+
+function summarizeFeedbackRefinementResult(data) {
+  return {
+    valid: Boolean(data?.valid),
+    feedback_id: data?.feedback_id || data?.feedback?.feedback_id || null,
+    project_id: data?.project_id || null,
+    previous_snapshot_hash: data?.previous_snapshot_hash || data?.base_snapshot_hash || null,
+    current_snapshot_hash: data?.current_snapshot_hash || null,
+    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,
+  };
+}
+
 function missionOpsThreads(payload) {
   if (Array.isArray(payload?.threads)) return payload.threads;
   if (Array.isArray(payload?.suggestions)) return payload.suggestions;
@@ -3929,6 +4196,251 @@ async function runFeedbackSync(args) {
   console.log(`Snapshot: ${summary.snapshot_hash || "n/a"}`);
 }
 
+function resolveFeedbackIdArg(args) {
+  return firstNonEmptyString(args["feedback-id"], args.feedbackId, args.feedback_id, args._?.[1]);
+}
+
+function requireFeedbackDraftContext(args) {
+  const feedbackId = resolveFeedbackIdArg(args);
+  if (!feedbackId) {
+    console.error("Missing --feedback-id.");
+    process.exit(1);
+  }
+  const { paths, manifest } = readFeedbackManifest(args);
+  const item = findFeedbackManifestItem(manifest, feedbackId);
+  if (!item) {
+    console.error(`Feedback item not found in feedback.yml: ${feedbackId}. Run \`myte feedback-sync\` first.`);
+    process.exit(1);
+  }
+  return { paths, manifest, item, feedbackId };
+}
+
+async function buildFeedbackDraftForCommand(args, subcommand) {
+  const { paths, manifest, item, feedbackId } = requireFeedbackDraftContext(args);
+  const action = subcommand || "refine";
+  const reason = firstNonEmptyString(args.reason);
+  const changes = {};
+
+  if (action === "status") {
+    const targetStatus = firstNonEmptyString(args.status, args._?.[2]);
+    if (!targetStatus) {
+      console.error("Missing --status for feedback status.");
+      process.exit(1);
+    }
+    changes.feedback_state = feedbackChange(firstNonEmptyString(item.feedback_state, item.status), targetStatus);
+  } else if (action === "archive") {
+    changes.feedback_state = feedbackChange(firstNonEmptyString(item.feedback_state, item.status), "archived");
+  } else if (action === "assign") {
+    const assignee = firstNonEmptyString(args["assigned-user-id"], args.assignedUserId, args.assigned_user_id, args["user-id"], args.userId, args.user_id, args._?.[2]);
+    if (!assignee) {
+      console.error("Missing --user-id or --assigned-user-id for feedback assign.");
+      process.exit(1);
+    }
+    changes.assigned_user_id = feedbackChange(firstNonEmptyString(item.assigned_user_id), assignee);
+  } else if (action === "edit" || action === "refine") {
+    const title = firstNonEmptyString(args.title);
+    if (title) changes.title = feedbackChange(firstNonEmptyString(item.title), title);
+
+    let feedbackText = firstNonEmptyString(args["feedback-text"], args.feedbackText, args.feedback_text);
+    const bodyFile = firstNonEmptyString(args["body-file"], args.bodyFile, args.body_file);
+    if (!feedbackText && bodyFile) {
+      const bodyPath = resolveInputFile(bodyFile, "Feedback body");
+      feedbackText = fs.readFileSync(bodyPath, "utf8").trim();
+    }
+    if (feedbackText) changes.feedback_text = feedbackChange(firstNonEmptyString(item.feedback_text), feedbackText);
+
+    const priority = firstNonEmptyString(args.priority);
+    if (priority) changes.priority = feedbackChange(firstNonEmptyString(item.priority), priority);
+
+    const dueDate = firstNonEmptyString(args["due-date"], args.dueDate, args.due_date);
+    if (dueDate) changes.due_date = feedbackChange(firstNonEmptyString(item.due_date, item.due_date_text), dueDate);
+
+    const tags = parseFeedbackTags(args);
+    if (tags) changes.tags = feedbackChange(Array.isArray(item.tags) ? item.tags : [], tags);
+
+    const reviewNote = firstNonEmptyString(args["review-note"], args.reviewNote, args.review_note);
+    if (reviewNote) changes.review_note = feedbackChange(null, reviewNote);
+  } else {
+    console.error("Unknown feedback command. Use status, edit, assign, archive, get, history, validate, or apply.");
+    process.exit(1);
+  }
+
+  if (!Object.keys(changes).length) {
+    console.error("No feedback changes were provided.");
+    process.exit(1);
+  }
+
+  const artifact = buildFeedbackRefinementArtifact({
+    manifest,
+    item,
+    feedbackId,
+    action,
+    changes,
+    reason,
+    args,
+  });
+
+  if (args["print-context"] || args.printContext || args["dry-run"] || args.dryRun) {
+    if (args.json) {
+      console.log(JSON.stringify(artifact, null, 2));
+    } else {
+      console.log(stringifyYaml(artifact));
+    }
+    return;
+  }
+
+  const filePath = writeFeedbackRefinementArtifact({ paths, artifact, action });
+  printFeedbackRefinementDraft({ artifact, filePath, args });
+}
+
+async function runFeedbackValidateOrApply(args, mode) {
+  const key = getProjectApiKey();
+  if (!key) {
+    console.error("Missing MYTE_API_KEY (project key) in environment/.env");
+    process.exit(1);
+  }
+  const { absPath, payload } = readFeedbackRefinementArtifact(args);
+  const feedbackId = firstNonEmptyString(args["feedback-id"], args.feedbackId, args.feedback_id, payload.feedback_id);
+  if (!feedbackId) {
+    console.error("Feedback refinement artifact is missing feedback_id.");
+    process.exit(1);
+  }
+  if (args.force) payload.force = true;
+
+  const timeoutMs = resolveTimeoutMs(args);
+  const apiBase = resolveApiBase(args);
+  const clientSessionId = firstNonEmptyString(
+    args["client-session-id"],
+    args.clientSessionId,
+    args.client_session_id,
+    payload.client_session_id
+  );
+  const idempotencyKey = mode === "apply"
+    ? resolveProjectMutationIdempotencyKey({
+        args,
+        operation: `feedback_refinement_apply:${feedbackId}`,
+        payload,
+      })
+    : null;
+
+  let data;
+  try {
+    data = await postFeedbackRefinement({
+      apiBase,
+      key,
+      timeoutMs,
+      feedbackId,
+      mode,
+      payload,
+      idempotencyKey,
+      clientSessionId,
+    });
+  } catch (err) {
+    if (args.json) {
+      console.log(JSON.stringify({
+        ok: false,
+        status: err?.status || null,
+        message: err?.message || String(err),
+        data: err?.data || null,
+        artifact_path: absPath,
+      }, null, 2));
+    } else {
+      console.error(`Feedback ${mode} failed:`, err?.message || err);
+      if (err?.data) console.error(JSON.stringify(err.data, null, 2));
+    }
+    process.exit(1);
+  }
+
+  const summary = {
+    ok: true,
+    mode,
+    artifact_path: absPath,
+    ...summarizeFeedbackRefinementResult(data),
+  };
+  if (args.json) {
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+  console.log(`Feedback ${mode}: ${summary.valid ? "valid" : "invalid"}`);
+  console.log(`Feedback: ${summary.feedback_id || feedbackId}`);
+  if (summary.history_id) console.log(`History: ${summary.history_id}`);
+  if (summary.new_snapshot_hash) console.log(`New Snapshot: ${summary.new_snapshot_hash}`);
+  if (summary.current_snapshot_hash) console.log(`Current Snapshot: ${summary.current_snapshot_hash}`);
+  console.log(`Diffs: ${summary.diff_count}`);
+  for (const diff of summary.diffs || []) {
+    console.log(`- ${diff.field}: ${JSON.stringify(diff.from)} -> ${JSON.stringify(diff.to)}`);
+  }
+  if (mode === "apply") {
+    console.log("Local feedback.yml is not modified by apply. Run `myte feedback-sync` to refresh it.");
+  }
+}
+
+async function runFeedbackGetOrHistory(args, mode) {
+  const key = getProjectApiKey();
+  if (!key) {
+    console.error("Missing MYTE_API_KEY (project key) in environment/.env");
+    process.exit(1);
+  }
+  const feedbackId = resolveFeedbackIdArg(args);
+  if (!feedbackId) {
+    console.error("Missing --feedback-id.");
+    process.exit(1);
+  }
+  const timeoutMs = resolveTimeoutMs(args);
+  const apiBase = resolveApiBase(args);
+
+  let data;
+  try {
+    data = mode === "history"
+      ? await fetchFeedbackHistory({ apiBase, key, timeoutMs, feedbackId })
+      : await fetchFeedbackReview({ apiBase, key, timeoutMs, feedbackId });
+  } catch (err) {
+    console.error(`Feedback ${mode} failed:`, err?.message || err);
+    process.exit(1);
+  }
+
+  if (args.json) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  if (mode === "history") {
+    console.log(`Feedback: ${data.feedback_id || feedbackId}`);
+    console.log(`Events: ${data.count || 0}`);
+    for (const event of data.events || []) {
+      console.log(`- ${event.created_at || "unknown"} ${event.action || "refine"} ${event.history_id || ""}`);
+    }
+    return;
+  }
+  const feedback = data.feedback || {};
+  console.log(`Feedback: ${feedback.feedback_id || feedbackId}`);
+  console.log(`Title: ${feedback.title || "(untitled)"}`);
+  console.log(`Status: ${feedback.feedback_state || feedback.status || "unknown"} (${feedback.status || "legacy unknown"})`);
+  console.log(`Priority: ${feedback.priority || "n/a"}`);
+  console.log(`Snapshot: ${feedback.snapshot_hash || "n/a"}`);
+}
+
+async function runFeedback(args) {
+  const subcommand = firstNonEmptyString(args._?.[0]) || "help";
+  if (subcommand === "help") {
+    printHelp();
+    return;
+  }
+  if (["status", "edit", "assign", "archive", "refine"].includes(subcommand)) {
+    await buildFeedbackDraftForCommand(args, subcommand);
+    return;
+  }
+  if (subcommand === "validate" || subcommand === "apply") {
+    await runFeedbackValidateOrApply(args, subcommand);
+    return;
+  }
+  if (subcommand === "get" || subcommand === "history") {
+    await runFeedbackGetOrHistory(args, subcommand);
+    return;
+  }
+  console.error("Unknown feedback command. Use status, edit, assign, archive, get, history, validate, or apply.");
+  process.exit(1);
+}
+
 async function runSuggestionsSync(args) {
   const key = getProjectApiKey();
   if (!key) {
@@ -4670,6 +5182,11 @@ async function main() {
     return;
   }
 
+  if (command === "feedback") {
+    await runFeedback(args);
+    return;
+  }
+
   if (command === "suggestions") {
     await runSuggestions(args);
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mytegroupinc/myte-core",
-  "version": "0.0.20",
+  "version": "0.0.21",
   "description": "Myte CLI core implementation.",
   "type": "commonjs",
   "main": "cli.js",