@agent-native/core 0.100.2 → 0.101.3

package/corpus/templates/clips/desktop/src-tauri/src/recording_indicator.rs

@@ -49,6 +49,12 @@ const PILL_LABEL: &str = "recording-pill";
 /// it through every command.
 static PILL_DETACHED: AtomicBool = AtomicBool::new(false);
 static PILL_RIGHT_SIDE: AtomicBool = AtomicBool::new(false);
+/// Mirrors the renderer's `expanded` React state so a re-show of an already
+/// open pill (e.g. after the tray icon toggles the popover) resizes the
+/// native window to match what's actually rendered instead of snapping it
+/// back to the collapsed size while the webview still renders the expanded
+/// layout.
+static PILL_EXPANDED: AtomicBool = AtomicBool::new(false);
 
 /// Hover-tracking loop control. macOS only feeds mouse-moved / hover events to
 /// the *key* window, so the background pill's CSS `:hover` never fires while
@@ -360,7 +366,8 @@ pub async fn recording_pill_show(
             (Some(p), Some(s)) => Some((p.x, p.y, s.width, s.height)),
             _ => None,
         };
-        let (w, h, x, y) = anchored_rect(&app, false, previous);
+        let expanded = PILL_EXPANDED.load(Ordering::Relaxed);
+        let (w, h, x, y) = anchored_rect(&app, expanded, previous);
         let _ = existing.set_size(tauri::Size::Physical(PhysicalSize::new(w, h)));
         let _ = existing.set_position(PhysicalPosition::new(x, y));
         use tauri::Emitter;
@@ -377,6 +384,7 @@ pub async fn recording_pill_show(
         return Ok(());
     }
 
+    PILL_EXPANDED.store(false, Ordering::SeqCst);
     let (w, h, x, y) = anchored_rect(&app, false, None);
 
     let url = build_overlay_url("recording-pill");
@@ -465,6 +473,7 @@ fn stop_pill_hover_tracking() {
 
 #[tauri::command]
 pub async fn recording_pill_expand(app: AppHandle, expanded: bool) -> Result<(), String> {
+    PILL_EXPANDED.store(expanded, Ordering::SeqCst);
     let Some(window) = app.get_webview_window(PILL_LABEL) else {
         return Ok(());
     };
@@ -534,6 +543,7 @@ pub async fn recording_pill_set_detached(app: AppHandle, detached: bool) -> Resu
         // by the time we hit `anchored_rect` below, the new flag has
         // already taken effect and we get the right size + position for
         // the destination mode. (The atomic was flipped above.)
+        PILL_EXPANDED.store(false, Ordering::SeqCst);
         let (w, h, x, y) = anchored_rect(&app, false, None);
         let _ = window.set_size(tauri::Size::Physical(PhysicalSize::new(w, h)));
         let _ = window.set_position(PhysicalPosition::new(x, y));

package/corpus/templates/clips/desktop/src-tauri/src/remote_flags.rs

@@ -0,0 +1,188 @@
+//! Server-controlled feature flags for the desktop capture pipeline
+//! (`useCustomSCKPipeline`, `customSCKPipelineLiveUploadEnabled`) — flipping
+//! either requires no desktop rebuild. This module fetches the flags from the
+//! backend's `get-feature-flags` action and caches them in memory so
+//! backend-selection stays a synchronous, zero-latency read.
+//!
+//! `spawn_watcher` runs its own periodic poll (independent of the meetings
+//! watcher's tick, though it reuses the same session credentials via
+//! `MeetingsWatcherState::session_snapshot()` rather than tracking its own);
+//! recording start also kicks off a best-effort (non-blocking) refresh so the
+//! cache stays warm without ever delaying a recording start. A fetch failure
+//! (offline, no session yet, 401) just leaves the last-known-good value in
+//! place — the cache never resets to defaults once a real value has been
+//! fetched.
+
+use std::sync::{Mutex, OnceLock};
+use std::time::Duration;
+
+use serde::Deserialize;
+use tauri::{AppHandle, Manager};
+
+use crate::meetings_watcher::MeetingsWatcherState;
+
+/// How often the background watcher polls `get-feature-flags` once it has
+/// fetched successfully at least once.
+const REMOTE_FLAGS_POLL_SECS: u64 = 60;
+/// How often it retries before the first successful fetch (e.g. while
+/// waiting for the renderer to push session credentials after app launch).
+const REMOTE_FLAGS_FAST_POLL_SECS: u64 = 5;
+
+fn default_false() -> bool {
+    false
+}
+
+// Explicit `rename`s (not `rename_all = "camelCase"`) because serde's
+// case conversion would turn `sck` into `Sck`, not `SCK` — these must match
+// the JSON keys from the `get-feature-flags` action exactly.
+#[derive(Debug, Clone, Copy, Deserialize)]
+pub(crate) struct RemoteFeatureFlags {
+    #[serde(rename = "useCustomSCKPipeline", default = "default_false")]
+    pub(crate) use_custom_sck_pipeline: bool,
+    #[serde(
+        rename = "customSCKPipelineLiveUploadEnabled",
+        default = "default_false"
+    )]
+    pub(crate) custom_sck_pipeline_live_upload_enabled: bool,
+}
+
+impl Default for RemoteFeatureFlags {
+    fn default() -> Self {
+        Self {
+            use_custom_sck_pipeline: false,
+            custom_sck_pipeline_live_upload_enabled: false,
+        }
+    }
+}
+
+fn cache() -> &'static Mutex<RemoteFeatureFlags> {
+    static CACHE: OnceLock<Mutex<RemoteFeatureFlags>> = OnceLock::new();
+    CACHE.get_or_init(|| Mutex::new(RemoteFeatureFlags::default()))
+}
+
+/// Last-known-good flags. Synchronous — safe to call from the non-async
+/// backend-selection code paths that choose the capture pipeline.
+pub(crate) fn current() -> RemoteFeatureFlags {
+    *cache().lock().unwrap_or_else(|e| e.into_inner())
+}
+
+/// Fetch `get-feature-flags` from the backend and update the in-memory cache
+/// on success. Best-effort: any failure just leaves the cache untouched.
+pub(crate) async fn refresh(
+    client: &reqwest::Client,
+    server_url: &str,
+    cookie: Option<&str>,
+    auth_token: Option<&str>,
+) -> Result<(), String> {
+    let url = format!("{server_url}/_agent-native/actions/get-feature-flags");
+    let mut req = client.get(&url).header("X-Request-Source", "clips-desktop");
+    if let Some(c) = cookie {
+        req = req.header("Cookie", c);
+    }
+    if let Some(token) = auth_token {
+        req = req.bearer_auth(token);
+    }
+    let resp = req
+        .send()
+        .await
+        .map_err(|e| format!("fetch feature flags: {e}"))?;
+    if !resp.status().is_success() {
+        return Err(format!("fetch feature flags: HTTP {}", resp.status()));
+    }
+    let flags: RemoteFeatureFlags = resp
+        .json()
+        .await
+        .map_err(|e| format!("parse feature flags: {e}"))?;
+    *cache().lock().unwrap_or_else(|e| e.into_inner()) = flags;
+    Ok(())
+}
+
+/// Fire a best-effort refresh in the background without blocking the caller
+/// (e.g. recording start). No-ops silently without a server URL.
+pub(crate) fn spawn_refresh(
+    server_url: Option<String>,
+    cookie: Option<String>,
+    auth_token: Option<String>,
+) {
+    let Some(server_url) = server_url.filter(|s| !s.trim().is_empty()) else {
+        return;
+    };
+    tauri::async_runtime::spawn(async move {
+        let client = match reqwest::Client::builder()
+            .timeout(Duration::from_secs(5))
+            .build()
+        {
+            Ok(c) => c,
+            Err(err) => {
+                eprintln!("[feature-flags] reqwest build failed: {err}");
+                return;
+            }
+        };
+        if let Err(err) = refresh(
+            &client,
+            &server_url,
+            cookie.as_deref(),
+            auth_token.as_deref(),
+        )
+        .await
+        {
+            eprintln!("[feature-flags] refresh failed: {err}");
+        }
+    });
+}
+
+/// Spawn the long-running feature-flags poller. Idempotent — gated on a
+/// static `OnceLock` so a double-call from setup is safe. Runs on its own
+/// loop, entirely separate from the meetings watcher's tick; it only reads
+/// that watcher's already-live session credentials (server URL / cookie /
+/// auth token) via `session_snapshot()` instead of tracking a second copy.
+///
+/// Starts immediately (no initial delay) and retries every
+/// `REMOTE_FLAGS_FAST_POLL_SECS` until the first successful fetch — session
+/// credentials aren't pushed by the renderer until sign-in completes, so this
+/// closes that gap without the app needing to notify this loop. Once a fetch
+/// succeeds it settles into the slower `REMOTE_FLAGS_POLL_SECS` keep-warm
+/// cadence.
+pub(crate) fn spawn_watcher(app: AppHandle) {
+    static STARTED: OnceLock<()> = OnceLock::new();
+    if STARTED.set(()).is_err() {
+        return;
+    }
+    tauri::async_runtime::spawn(async move {
+        let client = match reqwest::Client::builder()
+            .timeout(Duration::from_secs(10))
+            .build()
+        {
+            Ok(c) => c,
+            Err(err) => {
+                eprintln!("[feature-flags] request build failed: {err}");
+                return;
+            }
+        };
+        let mut fetched_once = false;
+        loop {
+            if let Some(state) = app.try_state::<MeetingsWatcherState>() {
+                let snapshot = state.session_snapshot();
+                if let Some(server_url) = snapshot.server_url {
+                    match refresh(
+                        &client,
+                        &server_url,
+                        snapshot.session_cookie.as_deref(),
+                        snapshot.auth_token.as_deref(),
+                    )
+                    .await
+                    {
+                        Ok(()) => fetched_once = true,
+                        Err(err) => eprintln!("[feature-flags] watcher refresh failed: {err}"),
+                    }
+                }
+            }
+            let wait_secs = if fetched_once {
+                REMOTE_FLAGS_POLL_SECS
+            } else {
+                REMOTE_FLAGS_FAST_POLL_SECS
+            };
+            tokio::time::sleep(Duration::from_secs(wait_secs)).await;
+        }
+    });
+}

package/corpus/templates/clips/desktop/src-tauri/src/whisper_speech.rs

@@ -480,7 +480,7 @@ mod macos {
         language: Option<&str>,
     ) -> Vec<(i64, i64, String)> {
         let mut params = FullParams::new(SamplingStrategy::Greedy { best_of: 1 });
-        params.set_n_threads(4);
+        params.set_n_threads(2);
         params.set_language(language);
         params.set_translate(false);
         params.set_no_context(true);

package/corpus/templates/clips/server/lib/post-finalize-dispatch.ts

@@ -46,6 +46,7 @@ export async function dispatchPostFinalizeJob(args: {
   kind: PostFinalizeJobKind;
   delayMs?: number;
   retryAttempt?: number;
+  regenerate?: boolean;
 }): Promise<void> {
   const token = signScopedAgentAccessToken({
     resourceKind: POST_FINALIZE_JOB_TOKEN_KIND,

package/corpus/templates/clips/server/plugins/agent-chat.ts

@@ -18,6 +18,7 @@ const INITIAL_TOOL_NAMES = [
   "list-recordings",
   "search-recordings",
   "get-recording-player-data",
+  "request-transcript",
   "create-recording",
   "import-loom-recording",
   "update-recording",
@@ -38,5 +39,9 @@ export default createAgentChatPlugin({
   appId: "clips",
   actions: loadActionsFromStaticRegistry(actionsRegistry),
   initialToolNames: INITIAL_TOOL_NAMES,
+  extraContext: async () =>
+    `<clips-transcript-guidance>
+The transcript in view-screen is a bounded preview. When previewTruncated is true, its text is expected to end mid-sentence and is never evidence that transcription stopped early. Call get-recording-player-data before judging transcript completeness or quoting the full transcript. For a failed or pending transcript, use request-transcript with force=true. For an explicit fresh retry of an existing ready transcript, also pass regenerate=true. Agent-triggered retries are queued for the durable worker and return pending while processing.
+</clips-transcript-guidance>`,
   resolveOrgId: async (event) => (await getOrgContext(event)).orgId,
 });

package/corpus/templates/clips/server/routes/api/_agent-native-background/post-finalize-worker.post.ts

@@ -26,6 +26,7 @@ const bodySchema = z.object({
   token: z.string().min(1),
   delayMs: z.number().int().min(0).max(30_000).optional(),
   retryAttempt: z.number().int().min(1).max(10).optional(),
+  regenerate: z.boolean().optional(),
 });
 
 export default defineEventHandler(async (event: H3Event) => {
@@ -35,7 +36,8 @@ export default defineEventHandler(async (event: H3Event) => {
     return { ok: false, error: "Invalid post-finalize job" };
   }
 
-  const { recordingId, kind, token, delayMs, retryAttempt } = parsed.data;
+  const { recordingId, kind, token, delayMs, retryAttempt, regenerate } =
+    parsed.data;
   const verified = verifyScopedAgentAccessToken(token, {
     resourceKind: POST_FINALIZE_JOB_TOKEN_KIND,
     resourceId: postFinalizeJobResourceId(recordingId, kind),
@@ -81,6 +83,7 @@ export default defineEventHandler(async (event: H3Event) => {
           recordingId,
           kind,
           retryAttempt,
+          regenerate,
         });
         return {
           ok: true,
@@ -102,6 +105,7 @@ export default defineEventHandler(async (event: H3Event) => {
         recordingId,
         force: true,
         retryAttempt,
+        regenerate,
       });
       return { ok: true, kind, result };
     },

package/corpus/templates/clips/shared/feature-flags.ts

@@ -0,0 +1,41 @@
+/**
+ * Server-controlled feature flags, readable from the action surface so
+ * behavior can change without a redeploy. Stored under one global `settings`
+ * key (not per-user/org) — these gate app-wide rollout decisions, not
+ * individual preferences.
+ *
+ * Add new flags here as they're needed; `get-feature-flags` stays generic
+ * and doesn't need to change.
+ */
+
+export const FEATURE_FLAGS_KEY = "feature-flags";
+
+export type FeatureFlags = {
+  /**
+   * Desktop app: use the custom ScreenCaptureKit (SCK) capture pipeline
+   * (fragmented MP4 writer + live audio mixer) instead of Apple's stock
+   * `SCRecordingOutput`. See `desktop/src-tauri/src/native_screen/custom_capture.rs`.
+   */
+  useCustomSCKPipeline?: boolean;
+  /**
+   * Desktop app: stream the recording to the server in chunks while it is
+   * being recorded, instead of uploading the whole file after Stop. Only
+   * effective when `useCustomSCKPipeline` is also on. See
+   * `desktop/src-tauri/src/native_screen/live_upload.rs`.
+   */
+  customSCKPipelineLiveUploadEnabled?: boolean;
+};
+
+export const FEATURE_FLAG_DEFAULTS: Required<FeatureFlags> = {
+  useCustomSCKPipeline: false,
+  customSCKPipelineLiveUploadEnabled: false,
+};
+
+export function withFeatureFlagDefaults(
+  flags: FeatureFlags | Record<string, unknown> | null | undefined,
+): Required<FeatureFlags> {
+  return {
+    ...FEATURE_FLAG_DEFAULTS,
+    ...(flags as FeatureFlags | undefined),
+  };
+}

package/corpus/templates/design/.agents/skills/design-generation/SKILL.md

@@ -661,6 +661,9 @@ regeneration is slow, expensive, and regresses unrelated parts.
 
 1. **Read before you edit.** Pull the current file with `get-design-snapshot`
    (or `get-design`) so you edit the live content, not a stale memory of it.
+   If the design has persisted review comments, fetch the open queue with
+   `get-review-feedback` and use `.agents/skills/design-review-feedback` to
+   apply and verify one anchored thread at a time.
 2. **Prefer `edit-design` for small changes.** It applies one or more
    search/replace blocks to a file's HTML — surgical, cheap, and it preserves
    everything you didn't touch (Alpine state, scroll, other screens):

package/corpus/templates/design/.agents/skills/design-review-feedback/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: design-review-feedback
+description: >-
+  Work through persisted, element-anchored review comments on shared Design
+  prototypes and close the loop with verified edits.
+---
+
+# Design Review Feedback
+
+Use the shared review actions for design feedback:
+
+1. Call `view-screen` first so the active design, screen, inspector tab, and
+   review queue are current.
+2. Call `get-review-feedback` for the open queue and work on one root thread at
+   a time. Keep the thread id, target screen id, anchor node id, and nearby
+   context together while editing.
+3. For element-anchored feedback, prefer the stable
+   `data-agent-native-node-id` from the anchor. Use the stored percentage point
+   only as a visual fallback when the node cannot be resolved.
+4. Read the affected file with `get-design-snapshot`, make the smallest
+   persisted edit with `edit-design` or the appropriate design action, then
+   verify the saved result with `get-design-snapshot` and a screenshot or audit
+   when the change is visual.
+5. Resolve the thread with `resolve-review-thread` only after the edit is
+   persisted and verified, and pass `resolutionNote` with a one-line description
+   of the persisted change. If the user needs to decide something, reply with
+   `reply-review-comment` and set `resolutionTarget: "human"`; do not silently
+   resolve it.
+6. After applying a thread, call `consume-review-feedback` for the applied
+   agent-targeted root comment so the queue does not repeatedly resurface the
+   same work.
+
+Reviewers can leave a human-only comment or choose **Send to agent** when
+composing. Editors can selectively route an existing open thread with
+`send-review-thread-to-agent`; that action only changes the selected thread.
+When a thread is sent from the Design UI, the agent chat handoff includes its
+thread id and instructs the agent not to apply other queued feedback.
+
+Use `create-review-comment` for agent-authored follow-up notes when a durable
+record is more useful than a chat-only explanation. Keep review comments
+scoped to the design resource and the target screen; never copy large HTML,
+screenshots, or provider payloads into a comment.

package/corpus/templates/design/AGENTS.md

@@ -33,6 +33,12 @@ patterns live in `.agents/skills/`.
   tool. The action schema is the source of truth for parameters.
 - Call `view-screen` before editing a specific design if the current design or
   selected file is not already clear from context.
+- For shared prototype feedback, use the persisted review actions
+  (`list-review-comments`, `get-review-feedback`, `create-review-comment`,
+  `reply-review-comment`, `resolve-review-thread`, `consume-review-feedback`,
+  `send-review-thread-to-agent`, and `set-review-status`). Work one thread at a time, prefer its stable node
+  anchor, verify saved edits before resolving, and read
+  `.agents/skills/design-review-feedback/SKILL.md` for the full loop.
 - Generated files must be complete, standalone HTML unless the user asks for a
   different export format. They should render in the iframe without a build step.
 - For design generation, ground the work in a concrete audience, primary job,

package/corpus/templates/design/README.md

@@ -18,6 +18,7 @@ prompts and visual tweak controls.
 - Save and reuse design-system preferences to stay on-brand.
 - Import existing HTML or reference material as context.
 - Export real files: HTML, ZIP, or PDF.
+- Share prototypes with element-anchored review comments and apply verified feedback through the agent.
 
 ## Develop locally
 

package/corpus/templates/design/actions/navigate.ts

@@ -18,7 +18,7 @@
  *   --view       View name (list, editor, design-systems, present, settings)
  *   --designId   Design ID (for editor/present views)
  *   --editorView Editor mode for designs: single or overview
- *   --inspectorTab Inspector tab for designs: design or tweaks (extensions opens Tools for compatibility)
+ *   --inspectorTab Inspector tab for designs: design, comments, or tweaks (extensions opens Tools for compatibility)
  *   --leftPanel  Left editor panel: file, agent, assets, import, tools, tokens, or code
  *   --fileId     Screen/file id to focus in the design editor
  *   --filename   Screen filename to focus in the design editor
@@ -61,7 +61,7 @@ const designLeftPanelSchema = z.enum([
 
 export default defineAction({
   description:
-    "Navigate the UI to a specific view or path. Views: list, templates, editor, design-systems, present, settings. Use --templateId with templates, --designId with editor/present views, and --designSystemId with design-systems. For designs, use editorView=overview to show the infinite screens canvas, or editorView=single with fileId/filename/screen to focus a screen. Use leftPanel=file|agent|assets|import|tools|tokens|code to focus the left rail, including Import and the wide Code workspace. Legacy inspectorTab=extensions opens Tools. Use tool to activate a design editor tool.",
+    "Navigate the UI to a specific view or path. Views: list, templates, editor, design-systems, present, settings. Use --templateId with templates, --designId with editor/present views, and --designSystemId with design-systems. For designs, use editorView=overview to show the infinite screens canvas, or editorView=single with fileId/filename/screen to focus a screen. Use inspectorTab=design|comments|tweaks to focus the inspector, or leftPanel=file|agent|assets|import|tools|tokens|code to focus the left rail, including Import and the wide Code workspace. Legacy inspectorTab=extensions opens Tools. Use tool to activate a design editor tool.",
   schema: z
     .object({
       view: z
@@ -87,11 +87,11 @@ export default defineAction({
         .optional()
         .describe("Alias for editorView"),
       inspectorTab: z
-        .enum(["design", "tweaks", "extensions"])
+        .enum(["design", "comments", "tweaks", "extensions"])
         .optional()
         .describe("Design editor inspector tab to focus"),
       inspector: z
-        .enum(["design", "tweaks", "extensions"])
+        .enum(["design", "comments", "tweaks", "extensions"])
         .optional()
         .describe("Alias for inspectorTab"),
       leftPanel: designLeftPanelSchema

package/corpus/templates/design/actions/view-screen.ts

@@ -12,6 +12,16 @@ import {
   readAppState,
   readAppStateForCurrentTab,
 } from "@agent-native/core/application-state";
+import {
+  getReviewStatus,
+  queryReviewComments,
+  redactPublicReviewCommentIdentity,
+  redactPublicReviewStatusIdentity,
+  shouldRedactReviewIdentity,
+  type ReviewComment,
+  type ReviewResourceContext,
+} from "@agent-native/core/review";
+import * as reviewRuntime from "@agent-native/core/review";
 import { resolveAccess } from "@agent-native/core/sharing";
 import { eq } from "drizzle-orm";
 import { z } from "zod";
@@ -21,6 +31,22 @@ import { parseCanvasFrameGeometryById } from "../shared/canvas-frames.js";
 import { getDesignTemplatePreset } from "../shared/design-template-presets.js";
 import { designGenerationSessionKey } from "../shared/generation-session.js";
 
+interface ReviewThreadSummary {
+  openCount: number;
+  agentQueueCount: number;
+}
+
+const getReviewThreadSummary = (
+  reviewRuntime as unknown as {
+    getReviewThreadSummary?: (input: {
+      resourceType: string;
+      resourceId: string;
+      scope: { userEmail?: string | null; orgId?: string | null };
+      bypassScope?: boolean;
+    }) => Promise<ReviewThreadSummary>;
+  }
+).getReviewThreadSummary;
+
 function stringProp(value: unknown, key: string): string | undefined {
   if (!value || typeof value !== "object") return undefined;
   const candidate = (value as Record<string, unknown>)[key];
@@ -135,12 +161,57 @@ function resolveActiveCodeFile(
   };
 }
 
+function reviewAnchorNodeId(anchor: unknown): string | null {
+  if (!anchor || typeof anchor !== "object") return null;
+  const nodeId = (anchor as Record<string, unknown>).nodeId;
+  return typeof nodeId === "string" && nodeId.trim() ? nodeId : null;
+}
+
+function buildReviewSummary(
+  comments: ReviewComment[],
+  status: Awaited<ReturnType<typeof getReviewStatus>>,
+  activeScreenId: string | undefined,
+  summary?: ReviewThreadSummary,
+) {
+  const openRoots = new Map<string, ReviewComment>();
+  for (const comment of comments) {
+    if (comment.status !== "open") continue;
+    if (!comment.parentCommentId && !openRoots.has(comment.threadId)) {
+      openRoots.set(comment.threadId, comment);
+    }
+  }
+  const agentQueueThreads = new Set(
+    Array.from(openRoots.values())
+      .filter(
+        (comment) =>
+          comment.resolutionTarget !== "human" && !comment.consumedAt,
+      )
+      .map((comment) => comment.threadId),
+  );
+  const activeScreenThreads = Array.from(openRoots.values())
+    .filter((comment) => comment.targetId === activeScreenId)
+    .map((comment) => ({
+      id: comment.id,
+      threadId: comment.threadId,
+      body: comment.body.slice(0, 180),
+      nodeId: reviewAnchorNodeId(comment.anchor),
+      author: comment.authorName ?? comment.authorEmail ?? comment.createdBy,
+    }));
+
+  return {
+    status: status?.status ?? "draft",
+    openCount: summary?.openCount ?? openRoots.size,
+    agentQueueCount: summary?.agentQueueCount ?? agentQueueThreads.size,
+    activeScreenThreads,
+  };
+}
+
 export default defineAction({
   description:
-    "See what the user is currently looking at on screen. Returns the current navigation state including which design or template is open, which view they are on (list, templates, editor, design-systems, present, settings), active/focused design screen, selected element, active inspector tab (design or tweaks), active left rail panel (file, agent, assets, import, tools, tokens, or code), active code file metadata, overview canvas state, plus any pending question overlay. Always call this first before taking any action.",
+    "See what the user is currently looking at on screen. Returns the current navigation state including which design or template is open, which view they are on (list, templates, editor, design-systems, present, settings), active/focused design screen, selected element, active inspector tab (design, comments, or tweaks), active left rail panel (file, agent, assets, import, tools, tokens, or code), active code file metadata, overview canvas state, review status and feedback queue summary, plus any pending question overlay. Always call this first before taking any action.",
   schema: z.object({}),
   http: false,
-  run: async () => {
+  run: async (_, ctx) => {
     const [navigation, designSelection] = await Promise.all([
       readAppStateForCurrentTab("navigation"),
       readAppStateForCurrentTab("design-selection"),
@@ -233,6 +304,49 @@ export default defineAction({
           activeCodeFile: resolveActiveCodeFile(files, designSelection),
           canvasFrames: parseCanvasFrameGeometryById(data.canvasFrames),
         };
+        const reviewContext = ctx as ReviewResourceContext | undefined;
+        const reviewScope = {
+          userEmail: reviewContext?.userEmail ?? null,
+          orgId: reviewContext?.orgId ?? null,
+        };
+        const [reviewComments, reviewStatus, reviewSummary] = await Promise.all(
+          [
+            queryReviewComments({
+              resourceType: "design",
+              resourceId: designId,
+              scope: reviewScope,
+              bypassScope: true,
+              includeResolved: false,
+              includeDeleted: false,
+              limit: 500,
+            }),
+            getReviewStatus("design", designId, reviewScope, {
+              bypassScope: true,
+            }),
+            getReviewThreadSummary
+              ? getReviewThreadSummary({
+                  resourceType: "design",
+                  resourceId: designId,
+                  scope: reviewScope,
+                  bypassScope: true,
+                })
+              : Promise.resolve(undefined),
+          ],
+        );
+        const redactReviewIdentity = shouldRedactReviewIdentity(reviewContext, {
+          role: access.role,
+          visibility: access.resource.visibility,
+        });
+        (screen.design as Record<string, unknown>).review = buildReviewSummary(
+          redactReviewIdentity
+            ? reviewComments.map(redactPublicReviewCommentIdentity)
+            : reviewComments,
+          redactReviewIdentity
+            ? redactPublicReviewStatusIdentity(reviewStatus)
+            : reviewStatus,
+          resolveActiveScreen(files, navigation, designSelection)?.id,
+          reviewSummary,
+        );
       }
     }
     if (showQuestions) {

package/corpus/templates/design/agent-native.app-skill.json

@@ -46,6 +46,11 @@
       "path": ".agents/skills/visual-edit",
       "visibility": "both",
       "exportAs": "visual-edit"
+    },
+    {
+      "path": ".agents/skills/design-review-feedback",
+      "visibility": "both",
+      "exportAs": "design-review-feedback"
     }
   ],
   "hostAdapters": [