@agent-native/core 0.161.22 → 0.162.0

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

@@ -630,6 +630,60 @@ mod macos {
         }
     }
 
+    /// RNNoise's voice-activity output is more useful than a fixed amplitude
+    /// threshold for the meeting microphone. A muted call still leaves Clips
+    /// with the local microphone, and fans, keyboard noise, or room noise can
+    /// be loud enough to cross the old RMS-only gate. Keep this state on the
+    /// worker thread so the realtime capture callback stays allocation-free.
+    struct MicVoiceActivity {
+        state: Box<nnnoiseless::DenoiseState<'static>>,
+        pending: Vec<f32>,
+    }
+
+    impl MicVoiceActivity {
+        const SAMPLE_RATE: f32 = 48_000.0;
+        const INPUT_SCALE: f32 = 32_768.0;
+
+        fn new() -> Self {
+            Self {
+                state: nnnoiseless::DenoiseState::new(),
+                pending: Vec::new(),
+            }
+        }
+
+        fn reset(&mut self) {
+            self.state = nnnoiseless::DenoiseState::new();
+            self.pending.clear();
+        }
+
+        /// Return the highest RNNoise speech probability in `samples`.
+        /// `None` means this capture format is not the 48 kHz PCM that
+        /// RNNoise expects; callers retain the existing RMS fallback for
+        /// those legacy devices.
+        fn observe(&mut self, samples: &[f32], sample_rate: f32) -> Option<f32> {
+            if (sample_rate - Self::SAMPLE_RATE).abs() > 1.0 {
+                self.reset();
+                return None;
+            }
+
+            self.pending.extend(samples.iter().map(|sample| {
+                (sample * Self::INPUT_SCALE).clamp(-Self::INPUT_SCALE, Self::INPUT_SCALE)
+            }));
+
+            let frame_size = nnnoiseless::DenoiseState::FRAME_SIZE;
+            let mut highest_probability: f32 = 0.0;
+            while self.pending.len() >= frame_size {
+                let mut denoised = [0.0_f32; nnnoiseless::DenoiseState::FRAME_SIZE];
+                let probability = self
+                    .state
+                    .process_frame(&mut denoised, &self.pending[..frame_size]);
+                highest_probability = highest_probability.max(probability);
+                self.pending.drain(..frame_size);
+            }
+            Some(highest_probability)
+        }
+    }
+
     /// Run whisper over `samples` (16 kHz mono f32), returning each speech
     /// segment as `(start_ms, end_ms, text)` with buffer-relative timestamps.
     /// `language` is the forced language code (e.g. "en"); `None` lets whisper
@@ -698,6 +752,10 @@ mod macos {
     const VOICE_RMS_THRESHOLD: f32 = 0.006;
     /// A second, model-level gate for ambient/no-speech Whisper segments.
     const MAX_NO_SPEECH_PROBABILITY: f32 = 0.72;
+    /// RNNoise speech probability required for a 48 kHz microphone frame to
+    /// count as voice. System audio and non-48 kHz legacy mic captures keep
+    /// the RMS path because this VAD is trained for 48 kHz microphone PCM.
+    const MIN_MIC_VAD_PROBABILITY: f32 = 0.6;
     /// Minimum average per-token probability for a segment to count as real
     /// speech. On noisy/near-silent audio whisper mis-detects the language and
     /// decodes fluent-looking gibberish in another language — but those tokens
@@ -733,6 +791,11 @@ mod macos {
         sum / count as f32
     }
 
+    fn mic_voice_detected(rms: f32, vad_probability: Option<f32>) -> bool {
+        rms > VOICE_RMS_THRESHOLD
+            && vad_probability.is_none_or(|probability| probability >= MIN_MIC_VAD_PROBABILITY)
+    }
+
     fn buffer_start_after_drain(now: Instant, pending: Duration) -> Instant {
         now.checked_sub(pending).unwrap_or(now)
     }
@@ -788,6 +851,10 @@ mod macos {
         let mut seen_reset_generation = stream.reset_generation.load(Ordering::SeqCst);
         // Growing-utterance resample cache — see `IncrementalResample`.
         let mut resample_state = IncrementalResample::new();
+        // Only the microphone stream needs a speech/noise classifier. The
+        // system stream must preserve remote speech even when it is mixed
+        // with music or other non-voice audio.
+        let mut mic_voice_activity = (stream.source == "mic").then(MicVoiceActivity::new);
 
         while stream.running.load(Ordering::SeqCst) {
             std::thread::sleep(Duration::from_millis(250));
@@ -800,6 +867,9 @@ mod macos {
                 last_infer = Instant::now() - Duration::from_secs(10);
                 had_voice = false;
                 resample_state.drop_all();
+                if let Some(vad) = mic_voice_activity.as_mut() {
+                    vad.reset();
+                }
                 continue;
             }
 
@@ -807,31 +877,40 @@ mod macos {
             // poll. Inspect that tail in place instead of cloning + resampling
             // the entire growing utterance four times per second. Full snapshots
             // are reserved for an inference that is actually due.
-            let (raw_len, new_rms) = match stream.buf.lock() {
+            let (raw_len, new_rms, new_mic_samples) = match stream.buf.lock() {
                 Ok(b) => {
                     let raw_len = b.len();
-                    let new_rms = if raw_len > last_raw_len {
+                    let (new_rms, new_mic_samples) = if raw_len > last_raw_len {
                         let new = &b[last_raw_len..];
-                        Some((new.iter().map(|x| x * x).sum::<f32>() / new.len() as f32).sqrt())
+                        (
+                            Some(
+                                (new.iter().map(|x| x * x).sum::<f32>() / new.len() as f32).sqrt(),
+                            ),
+                            (stream.source == "mic").then(|| new.to_vec()),
+                        )
                     } else {
-                        None
+                        (None, None)
                     };
-                    (raw_len, new_rms)
+                    (raw_len, new_rms, new_mic_samples)
                 }
                 Err(_) => continue,
             };
             if stream.reset_generation.load(Ordering::SeqCst) != seen_reset_generation {
                 continue;
             }
+            let src_rate = (stream.src_rate.load(Ordering::SeqCst) as f32).max(1.0);
             if let Some(rms) = new_rms {
-                if rms > VOICE_RMS_THRESHOLD {
+                let vad_probability = mic_voice_activity
+                    .as_mut()
+                    .zip(new_mic_samples.as_deref())
+                    .and_then(|(vad, samples)| vad.observe(samples, src_rate));
+                if mic_voice_detected(rms, vad_probability) {
                     last_voice = Instant::now();
                     had_voice = true;
                 }
             }
             last_raw_len = raw_len;
 
-            let src_rate = (stream.src_rate.load(Ordering::SeqCst) as f32).max(1.0);
             let have_secs = raw_len as f32 / src_rate;
             let silence = last_voice.elapsed();
 
@@ -878,6 +957,9 @@ mod macos {
                 // so the resample cache is invalid regardless of whether this
                 // utterance ran inference — rebuild fresh from whatever's left.
                 resample_state.drop_all();
+                if let Some(vad) = mic_voice_activity.as_mut() {
+                    vad.reset();
+                }
                 // Advance the timeline offset so the next utterance's whisper
                 // timestamps map correctly. Inference can take seconds, and
                 // audio kept arriving throughout it, so the new buffer starts
@@ -1568,6 +1650,31 @@ mod macos {
             );
         }
 
+        #[test]
+        fn mic_voice_gate_requires_speech_probability_on_supported_captures() {
+            assert!(!super::mic_voice_detected(0.02, Some(0.59)));
+            assert!(!super::mic_voice_detected(0.004, Some(0.99)));
+            assert!(super::mic_voice_detected(0.02, Some(0.6)));
+            assert!(super::mic_voice_detected(0.02, None));
+        }
+
+        #[test]
+        fn rnnoise_vad_rejects_steady_ambient_noise() {
+            let mut vad = super::MicVoiceActivity::new();
+            let samples: Vec<f32> = (0..(nnnoiseless::DenoiseState::FRAME_SIZE * 8))
+                .map(|index| {
+                    let value = index.wrapping_mul(1_103_515_245usize).wrapping_add(12_345);
+                    (((value >> 16) & 0x7fff) as f32 / 16_384.0 - 1.0) * 0.012
+                })
+                .collect();
+
+            let probability = vad.observe(&samples, 48_000.0).unwrap();
+            assert!(
+                probability < super::MIN_MIC_VAD_PROBABILITY,
+                "ambient noise was classified as speech: {probability:.3}"
+            );
+        }
+
         #[test]
         fn filters_multilingual_caption_hallucinations() {
             assert_eq!(clean_transcript("ご視聴ありがとうございました"), None);

package/corpus/templates/clips/shared/recording-capture.ts

@@ -47,29 +47,34 @@ export type ScreenCaptureDisplayOptions = {
 /**
  * The `getDisplayMedia` options for a screen recording.
  *
- * Screen/tab audio is requested ALWAYS, and deliberately does not depend on
- * whether the microphone is on. They are two different sources, and one toggle
- * used to govern both: with the mic off, Chrome was never even offered the
- * "share tab audio" checkbox, so a screen recording of a call or a demo
- * captured zero audio tracks. Measured in production, 345 recordings landed
- * with `has_audio = false` — 95 over a minute, 17 over five — and each was told
- * "No speech was detected because this recording was saved without audio",
- * blaming the recording for a capture setting. That was 64% of recent
- * transcript failures. The Chrome extension always requested display audio and
- * never had the problem.
+ * Screen/tab audio is requested whenever the microphone is enabled, and
+ * withheld when it's off. The mic toggle is the only audio control the
+ * recorder UI shows, so a user who turns it off reasonably expects the
+ * recording to capture no audio at all — not just their voice. Requesting
+ * system audio anyway relies on the user separately noticing and unchecking
+ * the browser's native "share tab audio" checkbox, which they may not even
+ * know exists. See Slack thread 1786086902028429: a user turned the mic off
+ * and still got system audio in the recording; the agreed fix is to gate
+ * system audio on the same toggle.
  *
- * Declining the checkbox is still respected; the user simply gets the choice.
+ * When the mic IS on, audio is still requested unconditionally (not made
+ * conditional on some separate "include system audio" flag) — that used to be
+ * one toggle governing both, and with the mic off Chrome never even offered
+ * the checkbox, so 345 production recordings landed with `has_audio = false`
+ * while recording a call/demo. Declining the checkbox is still respected; the
+ * user simply gets the choice whenever the mic is on.
  */
 export function screenCaptureDisplayOptions(
   displaySurface: ScreenCaptureSurface,
+  wantsMic: boolean,
 ): ScreenCaptureDisplayOptions {
   return {
     video: screenCaptureVideoConstraints(displaySurface),
-    audio: true,
+    audio: wantsMic,
     // Let "Browser tab" open the tab picker. preferCurrentTab turns it into a
     // current-tab shortcut, which makes choosing another tab harder.
     selfBrowserSurface: displaySurface === "browser" ? "include" : "exclude",
     surfaceSwitching: "include",
-    systemAudio: "include",
+    systemAudio: wantsMic ? "include" : "exclude",
   };
 }

package/corpus/templates/content/.agents/skills/real-time-sync/SKILL.md

@@ -50,7 +50,7 @@ The agent modifies data in SQL, but the UI runs in the browser. SSE bridges same
 
    For list/sidebar queries, use the same pattern — pass the counter into the queryKey of every list query you want to keep fresh.
 
-4. **Fallback** polling calls `/_agent-native/poll?since=N`. It runs every 2 seconds until SSE is connected, then relaxes to 15 seconds (`SSE_FALLBACK_INTERVAL_MS`). If SSE is disabled or unavailable (e.g., edge/serverless deployments), polling continues at the 2 s cadence. Polling is the universal serverless fallback: new framework writes are read from the durable `sync_events` log, while the older DB timestamp scan remains as a slower safety net for direct SQL writes and older processes.
+4. **Fallback** polling calls `/_agent-native/poll?since=N`. It polls every 2 seconds only while an agent run is in flight; otherwise it idles at 60 seconds whether or not SSE is connected (`SSE_FALLBACK_INTERVAL_MS` and `IDLE_POLL_INTERVAL_MS`, both 60 s). A hidden tab polls no faster than every 10 seconds (`HIDDEN_POLL_INTERVAL_MS`). Polling is the universal serverless fallback: new framework writes are read from the durable `sync_events` log, while the older DB timestamp scan remains as a slower safety net for direct SQL writes and older processes.
 
 5. When the agent writes to the database, the version increments, SSE/polling detects it, and React Query refetches the affected queries.
 

package/corpus/templates/content/app/components/editor/DocumentEditor.tsx

@@ -597,9 +597,7 @@ function DocumentEditorBody({
   );
   // Polls Notion sync status to drive the conflict banner / sync bar and the
   // push-on-save path below (read via the query cache, not this return value).
-  useDocumentSyncStatus(canEdit && !isLocalFileDocument ? documentId : null, {
-    autoSync,
-  });
+  useDocumentSyncStatus(canEdit && !isLocalFileDocument ? documentId : null);
   const pushDocumentToNotion = usePushDocumentToNotion(documentId);
   const [localTitle, setLocalTitle] = useState("");
   const [localContent, setLocalContent] = useState("");
@@ -1088,7 +1086,7 @@ function DocumentEditorBody({
       // Pulls remain driven by the polling refetch in useDocumentSyncStatus.
       if (autoSync) {
         const status = queryClient.getQueryData<DocumentSyncStatus>(
-          documentSyncStatusQueryKey(documentId, { autoSync }),
+          documentSyncStatusQueryKey(documentId),
         );
         if (status?.pageId && !status.hasConflict) {
           try {
@@ -1100,7 +1098,7 @@ function DocumentEditorBody({
               flushOpenEditor: false,
             });
             queryClient.setQueryData(
-              documentSyncStatusQueryKey(documentId, { autoSync }),
+              documentSyncStatusQueryKey(documentId),
               next,
             );
           } catch {

package/corpus/templates/content/app/components/editor/DocumentToolbar.tsx

@@ -510,9 +510,6 @@ export function DocumentToolbar({
   const { data: connection } = useNotionConnection();
   const { data: syncStatus } = useDocumentSyncStatus(
     canEdit && !isLocalFileDocument ? documentId : null,
-    {
-      autoSync,
-    },
   );
   const linkDocument = useLinkDocumentToNotion(documentId);
   const unlinkDocument = useUnlinkDocumentFromNotion(documentId);

package/corpus/templates/content/app/components/editor/NotionConflictBanner.tsx

@@ -4,7 +4,6 @@ import { useState } from "react";
 import { toast } from "sonner";
 
 import { Button } from "@/components/ui/button";
-import { useLocalStorage } from "@/hooks/use-local-storage";
 import {
   useDocumentSyncStatus,
   useResolveDocumentSyncConflict,
@@ -20,11 +19,8 @@ export function NotionConflictBanner({
   canEdit = true,
 }: NotionConflictBannerProps) {
   const t = useT();
-  // Share autoSync state (and React Query cache) with DocumentToolbar.
-  const [autoSync] = useLocalStorage(`notion-auto-sync:${documentId}`, false);
   const { data: syncStatus } = useDocumentSyncStatus(
     canEdit ? documentId : null,
-    { autoSync },
   );
   const resolveConflict = useResolveDocumentSyncConflict(documentId);
   const [direction, setDirection] = useState<"pull" | "push" | null>(null);

package/corpus/templates/content/app/components/editor/NotionSyncBar.tsx

@@ -15,6 +15,7 @@ import { toast } from "sonner";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import {
+  invalidateDocumentQueries,
   useDisconnectNotion,
   useDocumentSyncStatus,
   useLinkDocumentToNotion,
@@ -51,7 +52,9 @@ export function NotionSyncBar({ documentId }: NotionSyncBarProps) {
       lastSyncedRef.current &&
       lastSyncedRef.current !== syncStatus.lastSyncedAt
     ) {
-      queryClient.invalidateQueries({ queryKey: ["action"] });
+      // Bare ["action"] refetches every mounted query app-wide (sidebar tree,
+      // comments, database views, search, connection status) on each sync tick.
+      invalidateDocumentQueries(queryClient, documentId);
     }
     lastSyncedRef.current = syncStatus.lastSyncedAt;
   }, [syncStatus?.lastSyncedAt, queryClient, documentId]);

package/corpus/templates/content/app/hooks/use-notion.ts

@@ -16,6 +16,8 @@ import type {
 import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { useEffect, useRef } from "react";
 
+import { useLocalStorage } from "@/hooks/use-local-storage";
+
 import { documentQueryFilter } from "./use-documents";
 
 // The server signs a `redirect` query param into the OAuth `state` and the
@@ -64,20 +66,16 @@ export function invalidateDocumentQueries(
   queryClient.invalidateQueries({
     queryKey: documentSyncStatusQueryKey(documentId),
   });
-  queryClient.invalidateQueries({
-    queryKey: documentSyncStatusQueryKey(documentId, { autoSync: true }),
-  });
 }
 
-export function documentSyncStatusQueryKey(
-  documentId: string,
-  options?: { autoSync?: boolean },
-) {
-  const normalizedDocumentId = documentId.trim();
+// `autoSync` only decides how often to refetch, so keying on it split one
+// document's status across two cache entries and two independent poll loops —
+// the toolbar polling at 2s while the sync bar polled the same action at 30s.
+export function documentSyncStatusQueryKey(documentId: string) {
   return [
     "action",
     "refresh-notion-sync-status",
-    { documentId: normalizedDocumentId, autoSync: !!options?.autoSync },
+    { documentId: documentId.trim() },
   ] as const;
 }
 
@@ -119,17 +117,21 @@ export function documentSyncRefetchIntervalMs(
   return autoSync ? 2_000 : 30_000;
 }
 
-export function useDocumentSyncStatus(
-  documentId: string | null,
-  options?: { autoSync?: boolean },
-) {
+export function useDocumentSyncStatus(documentId: string | null) {
   const queryClient = useQueryClient();
   const lastObservedSyncedAtRef = useRef<string | null>(null);
   const normalizedDocumentId = documentId?.trim() || null;
-  const autoSync = !!options?.autoSync;
+  // `autoSync` changes what the server does, so every observer of the shared
+  // query key has to agree on it. Read the same per-document toggle the
+  // toolbar writes instead of taking it per mount, where one component could
+  // suppress or enable another's auto-sync through the shared query function.
+  const [autoSync] = useLocalStorage(
+    `notion-auto-sync:${normalizedDocumentId ?? ""}`,
+    false,
+  );
   const query = useQuery<DocumentSyncStatus>({
     queryKey: normalizedDocumentId
-      ? documentSyncStatusQueryKey(normalizedDocumentId, options)
+      ? documentSyncStatusQueryKey(normalizedDocumentId)
       : ["action", "refresh-notion-sync-status", null],
     queryFn: () => {
       if (!normalizedDocumentId) throw new Error("documentId is required");

package/corpus/templates/crm/.agents/skills/real-time-sync/SKILL.md

@@ -50,7 +50,7 @@ The agent modifies data in SQL, but the UI runs in the browser. SSE bridges same
 
    For list/sidebar queries, use the same pattern — pass the counter into the queryKey of every list query you want to keep fresh.
 
-4. **Fallback** polling calls `/_agent-native/poll?since=N`. It runs every 2 seconds until SSE is connected, then relaxes to 15 seconds (`SSE_FALLBACK_INTERVAL_MS`). If SSE is disabled or unavailable (e.g., edge/serverless deployments), polling continues at the 2 s cadence. Polling is the universal serverless fallback: new framework writes are read from the durable `sync_events` log, while the older DB timestamp scan remains as a slower safety net for direct SQL writes and older processes.
+4. **Fallback** polling calls `/_agent-native/poll?since=N`. It polls every 2 seconds only while an agent run is in flight; otherwise it idles at 60 seconds whether or not SSE is connected (`SSE_FALLBACK_INTERVAL_MS` and `IDLE_POLL_INTERVAL_MS`, both 60 s). A hidden tab polls no faster than every 10 seconds (`HIDDEN_POLL_INTERVAL_MS`). Polling is the universal serverless fallback: new framework writes are read from the durable `sync_events` log, while the older DB timestamp scan remains as a slower safety net for direct SQL writes and older processes.
 
 5. When the agent writes to the database, the version increments, SSE/polling detects it, and React Query refetches the affected queries.
 

package/corpus/templates/design/.agents/skills/real-time-sync/SKILL.md

@@ -50,7 +50,7 @@ The agent modifies data in SQL, but the UI runs in the browser. SSE bridges same
 
    For list/sidebar queries, use the same pattern — pass the counter into the queryKey of every list query you want to keep fresh.
 
-4. **Fallback** polling calls `/_agent-native/poll?since=N`. It runs every 2 seconds until SSE is connected, then relaxes to 15 seconds (`SSE_FALLBACK_INTERVAL_MS`). If SSE is disabled or unavailable (e.g., edge/serverless deployments), polling continues at the 2 s cadence. Polling is the universal serverless fallback: new framework writes are read from the durable `sync_events` log, while the older DB timestamp scan remains as a slower safety net for direct SQL writes and older processes.
+4. **Fallback** polling calls `/_agent-native/poll?since=N`. It polls every 2 seconds only while an agent run is in flight; otherwise it idles at 60 seconds whether or not SSE is connected (`SSE_FALLBACK_INTERVAL_MS` and `IDLE_POLL_INTERVAL_MS`, both 60 s). A hidden tab polls no faster than every 10 seconds (`HIDDEN_POLL_INTERVAL_MS`). Polling is the universal serverless fallback: new framework writes are read from the durable `sync_events` log, while the older DB timestamp scan remains as a slower safety net for direct SQL writes and older processes.
 
 5. When the agent writes to the database, the version increments, SSE/polling detects it, and React Query refetches the affected queries.
 

package/corpus/templates/design/app/components/design/keyboard-shortcuts.ts

@@ -1,4 +1,5 @@
 import type { UseDesignHotkeysProps } from "@/hooks/useDesignHotkeys";
+import { SHOW_DESIGN_SECONDARY_LEFT_PANELS } from "@/pages/design-editor/types";
 
 export const DESIGN_SHORTCUT_CATEGORIES = [
   "essential",
@@ -136,13 +137,18 @@ export const DESIGN_SHORTCUTS: readonly DesignShortcutDefinition[] = [
     labelKey: "designEditor.keyboardShortcuts.commands.showLayers",
     handler: "onShowLayersPanel",
   }),
-  shortcut({
-    id: "show-assets",
-    category: "view",
-    bindings: ["alt+2"],
-    labelKey: "designEditor.keyboardShortcuts.commands.showAssets",
-    handler: "onShowAssetsPanel",
-  }),
+  ...(SHOW_DESIGN_SECONDARY_LEFT_PANELS
+    ? [
+        shortcut({
+          id: "show-assets",
+          category: "view" as const,
+          bindings: ["alt+2"],
+          labelKey:
+            "designEditor.keyboardShortcuts.commands.showAssets" as const,
+          handler: "onShowAssetsPanel" as const,
+        }),
+      ]
+    : []),
   shortcut({
     id: "toggle-ui",
     category: "view",

package/corpus/templates/design/app/hooks/use-navigation-state.ts

@@ -6,6 +6,8 @@ import { useAgentRouteState } from "@agent-native/core/client/navigation";
 import { useEffect } from "react";
 import { useLocation, useParams } from "react-router";
 
+import { normalizeDesignLeftPanel } from "@/pages/design-editor/tool-state";
+
 export interface NavigationState {
   view: string;
   designId?: string;
@@ -120,12 +122,11 @@ function normalizeEditorView(
 
 function normalizeInspectorTab(
   value: unknown,
-): "design" | "comments" | "tweaks" | "code" | "extensions" | undefined {
+): "design" | "comments" | "tweaks" | "code" | undefined {
   return value === "design" ||
     value === "comments" ||
     value === "tweaks" ||
-    value === "code" ||
-    value === "extensions"
+    value === "code"
     ? value
     : undefined;
 }
@@ -141,16 +142,7 @@ function normalizeLeftPanel(
   | "import"
   | "code"
   | undefined {
-  if (value === "extensions") return "tools";
-  return value === "file" ||
-    value === "agent" ||
-    value === "assets" ||
-    value === "tools" ||
-    value === "tokens" ||
-    value === "import" ||
-    value === "code"
-    ? value
-    : undefined;
+  return normalizeDesignLeftPanel(value);
 }
 
 function normalizeEditorMode(
@@ -176,9 +168,12 @@ export function editorPathFromCommand(cmd: NavigationState): string | null {
   const editorView = normalizeEditorView(cmd.editorView);
   if (editorView) params.set("view", editorView);
   if (editorView === "single") params.set("mode", cmd.mode ?? "interact");
-  const inspectorTab = normalizeInspectorTab(cmd.inspectorTab ?? cmd.inspector);
+  const rawInspectorTab = cmd.inspectorTab ?? cmd.inspector;
+  const inspectorTab = normalizeInspectorTab(rawInspectorTab);
   if (inspectorTab) params.set("inspector", inspectorTab);
-  const leftPanel = normalizeLeftPanel(cmd.leftPanel ?? cmd.panel);
+  const leftPanel = normalizeLeftPanel(
+    cmd.leftPanel ?? cmd.panel ?? rawInspectorTab,
+  );
   if (leftPanel) params.set("panel", leftPanel);
   const screen = cmd.fileId ?? cmd.screenId ?? cmd.filename ?? cmd.screen;
   if (screen) params.set("screen", screen);
@@ -201,10 +196,11 @@ export function editorCommandFromNavigate(
 ): DesignEditorCommand | null {
   if (cmd.view !== "editor" || !cmd.designId) return null;
   const editorView = normalizeEditorView(cmd.editorView);
-  const inspectorTab = normalizeInspectorTab(cmd.inspectorTab ?? cmd.inspector);
+  const rawInspectorTab = cmd.inspectorTab ?? cmd.inspector;
+  const inspectorTab = normalizeInspectorTab(rawInspectorTab);
   const leftPanel =
     normalizeLeftPanel(cmd.leftPanel ?? cmd.panel) ??
-    normalizeLeftPanel(cmd.inspectorTab ?? cmd.inspector);
+    normalizeLeftPanel(rawInspectorTab);
   const command: DesignEditorCommand = {
     designId: cmd.designId,
     issuedAt: Date.now(),
@@ -255,11 +251,12 @@ export function useNavigationState(enabled = true) {
         if (editorView) state.editorView = editorView;
         const mode = normalizeEditorMode(searchParams.get("mode"));
         if (mode) state.mode = mode;
-        const inspectorTab = normalizeInspectorTab(
-          searchParams.get("inspector"),
-        );
+        const rawInspectorTab = searchParams.get("inspector");
+        const inspectorTab = normalizeInspectorTab(rawInspectorTab);
         if (inspectorTab) state.inspectorTab = inspectorTab;
-        const leftPanel = normalizeLeftPanel(searchParams.get("panel"));
+        const leftPanel = normalizeLeftPanel(
+          searchParams.get("panel") ?? rawInspectorTab,
+        );
         if (leftPanel) state.leftPanel = leftPanel;
         const screen = searchParams.get("screen");
         if (screen) state.screen = screen;

package/corpus/templates/design/app/pages/design-editor/editor-state.ts

@@ -1,11 +1,11 @@
 import { isStandaloneHttpUrl } from "@shared/html-content";
 
+import { normalizeDesignLeftPanel } from "./tool-state";
 import {
   type DesignFile,
   type DesignLeftPanel,
   type DesignTool,
   type EditorMode,
-  SHOW_DESIGN_CODE_LEFT_PANEL,
 } from "./types";
 
 // Definition moved to shared/ so the server write path and code-layer's
@@ -127,10 +127,7 @@ export function getDesignEditorStateUrlSearch(args: {
   mode?: EditorMode | null;
 }) {
   const params = new URLSearchParams(args.currentSearch);
-  const leftPanel =
-    args.leftPanel === "code" && !SHOW_DESIGN_CODE_LEFT_PANEL
-      ? null
-      : args.leftPanel;
+  const leftPanel = normalizeDesignLeftPanel(args.leftPanel) ?? null;
   params.set("view", args.viewMode);
   if (leftPanel && leftPanel !== "file") {
     params.set("panel", leftPanel);

package/corpus/templates/design/app/pages/design-editor/tool-state.ts

@@ -1,7 +1,7 @@
 import type { CreationTool } from "@/components/design/design-canvas/creation";
 
 import {
-  SHOW_DESIGN_CODE_LEFT_PANEL,
+  isDesignLeftPanelEnabled,
   type DesignLeftPanel,
   type DesignTool,
   type EditorMode,
@@ -10,18 +10,10 @@ import {
 export function normalizeDesignLeftPanel(
   value: unknown,
 ): DesignLeftPanel | undefined {
-  if (value === "extensions") return "tools";
-  if (value === "code") {
-    return SHOW_DESIGN_CODE_LEFT_PANEL ? "code" : undefined;
+  if (value === "extensions") {
+    return isDesignLeftPanelEnabled("tools") ? "tools" : undefined;
   }
-  return value === "file" ||
-    value === "agent" ||
-    value === "assets" ||
-    value === "tools" ||
-    value === "tokens" ||
-    value === "import"
-    ? value
-    : undefined;
+  return isDesignLeftPanelEnabled(value) ? value : undefined;
 }
 
 export const MOVE_GROUP_TOOL_PRESENTATIONS = {

package/corpus/templates/design/app/pages/design-editor/types.ts

@@ -33,7 +33,44 @@ export type DesignLeftPanel =
   | "import"
   | "code";
 
-export const SHOW_DESIGN_CODE_LEFT_PANEL = true;
+/**
+ * Keep the still-evolving Design editor side panels out of the default
+ * surface until their Figma parity work is ready. Flip this switch to expose
+ * Assets, Tools, Tokens, and Code together while iterating on them. The E2E
+ * harness sets the Vite flag so those existing advanced-surface tests keep
+ * exercising the gated panels.
+ */
+const designSecondaryLeftPanelsSetting =
+  typeof import.meta !== "undefined"
+    ? (import.meta as { env?: Record<string, string> }).env
+        ?.VITE_SHOW_DESIGN_SECONDARY_LEFT_PANELS
+    : undefined;
+export const SHOW_DESIGN_SECONDARY_LEFT_PANELS =
+  designSecondaryLeftPanelsSetting === "1" ||
+  designSecondaryLeftPanelsSetting === "true";
+export const SHOW_DESIGN_CODE_LEFT_PANEL = SHOW_DESIGN_SECONDARY_LEFT_PANELS;
+
+export function isDesignLeftPanelEnabled(
+  value: unknown,
+): value is DesignLeftPanel {
+  if (
+    value !== "file" &&
+    value !== "agent" &&
+    value !== "assets" &&
+    value !== "tools" &&
+    value !== "tokens" &&
+    value !== "import" &&
+    value !== "code"
+  ) {
+    return false;
+  }
+
+  if (value === "code") return SHOW_DESIGN_CODE_LEFT_PANEL;
+  if (value === "assets" || value === "tools" || value === "tokens") {
+    return SHOW_DESIGN_SECONDARY_LEFT_PANELS;
+  }
+  return true;
+}
 
 /** Zoom percentage applied when entering single-screen (focused) editor mode. */
 export const FOCUSED_SCREEN_ZOOM = 100;

package/corpus/templates/design/changelog/2026-08-18-advanced-design-editor-panels-hidden-by-default.md

@@ -0,0 +1,6 @@
+---
+type: changed
+date: 2026-08-18
+---
+
+Advanced Design editor panels are hidden by default while they are refined.