fix(web): carry multi-skill compose list through Home auto-send (#6333 review)

PR #6333 added a multi-skill `@skill-a @skill-b` compose flow on the
Home page by introducing a `skillIds` array alongside the existing
primary `skillId` on the project-create payload. The array was
correctly forwarded to `POST /api/projects`, but the Home auto-send
hand-off persisted only prompt / attachments / context in
sessionStorage — when `ProjectView` later fired the first
`handleSend(...)`, the auto-send tail never supplied
`meta.skillIds`, so `streamViaDaemon` launched the first run with
only `project.skillId` and silently dropped the extra composed
skills (#5824 continued to bite the main user flow).

Changes:
- `apps/web/src/App.tsx`: stash the caller-supplied `input.skillIds`
  in a dedicated `od:auto-send-skillIds:<projectId>` sessionStorage
  key alongside the existing auto-send hand-off keys; cleared
  symmetrically when the array is absent so a stale list from a
  cancelled create can't leak into the next project.
- `apps/web/src/components/ProjectView.tsx`:
  - new `autoSendSkillIdsKey` helper + `readAutoSendSkillIds` reader
    (reuses the existing `isStoredStringArray` validator);
  - new `autoSendSkillIdsRef` captured at the same mount-time read as
    the other auto-send refs;
  - the auto-send effect now puts the array back into
    `meta.skillIds` on the first `handleSend(...)` call so the
    daemon stream receives the full compose list;
  - `clearAutoSendSession` also wipes the new key (reload after
    run start never re- fires with a stale skill set).
- `apps/web/tests/components/ProjectView.run-cleanup.test.tsx`:
  regression test asserting the Home-staged multi-skill list reaches
  the first `streamViaDaemon` call as `skillIds: ['deck-builder',
  'pdf-designer']` while the primary `skillId` stays on
  `project.skillId`, and that the auto-send session flag clears
  afterwards.

All 66 cases in `ProjectView.run-cleanup.test.tsx` and all 22 cases
in `ProjectView.pendingPrompt.test.tsx` pass.

Signed-off-by: xxiaoxiong <2482929840@qq.com>

Author: xxiaoxiong

apps/web/src/App.tsx

@@ -1720,6 +1720,23 @@ function AppInner() {
               `od:auto-send-context:${result.project.id}`,
             );
           }
+          // Multi-skill `@skill-a @skill-b` compose list. createProject
+          // already forwarded `input.skillIds` to the daemon, but the auto
+          // send hand-off used to only carry prompt/attachments/context to
+          // ProjectView — so the first run still launched with just
+          // `project.skillId` and the extra skills were silently lost
+          // (PR #6333 review). Stash the array in a dedicated key so the
+          // ProjectView auto-send path can put it back into `meta.skillIds`.
+          if (Array.isArray(input.skillIds) && input.skillIds.length > 0) {
+            window.sessionStorage.setItem(
+              `od:auto-send-skillIds:${result.project.id}`,
+              JSON.stringify(input.skillIds),
+            );
+          } else {
+            window.sessionStorage.removeItem(
+              `od:auto-send-skillIds:${result.project.id}`,
+            );
+          }
         } catch {
           /* sessionStorage may be unavailable (e.g. SSR / private mode); fall
              back to manual send. */

apps/web/src/components/ProjectView.tsx

@@ -817,6 +817,18 @@ function autoSendContextKey(projectId: string): string {
   return `od:auto-send-context:${projectId}`;
 }
 
+/**
+ * Home → Studio auto-send handoff for the multi-skill (`@skill-a @skill-b`)
+ * compose list. Without this key, `ProjectView`'s auto-send hand-off fires
+ * the first run with only `project.skillId` (the primary), silently
+ * dropping the extra composed skills even though `handleCreateProject`
+ * already forwarded `input.skillIds` to `POST /api/projects`. See #5824
+ * and PR #6333 review.
+ */
+function autoSendSkillIdsKey(projectId: string): string {
+  return `od:auto-send-skillIds:${projectId}`;
+}
+
 /** Set by the home create flow when its submit already ran the Open Design
  * Cloud balance gate — the first auto-send must not re-prompt the user. */
 function autoSendAmrGateOkKey(projectId: string): string {
@@ -852,13 +864,27 @@ function readAutoSendContext(projectId: string): RunContextSelection | null {
   }
 }
 
+/** Reads back the multi-skill `skillIds` array stashed at Home create time. */
+function readAutoSendSkillIds(projectId: string): string[] {
+  if (typeof window === 'undefined') return [];
+  try {
+    const raw = window.sessionStorage.getItem(autoSendSkillIdsKey(projectId));
+    if (!raw) return [];
+    const parsed = JSON.parse(raw) as unknown;
+    return isStoredStringArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
 function clearAutoSendSession(projectId: string): void {
   if (typeof window === 'undefined') return;
   try {
     window.sessionStorage.removeItem(autoSendFirstMessageKey(projectId));
     window.sessionStorage.removeItem(autoSendAttachmentsKey(projectId));
     window.sessionStorage.removeItem(autoSendContextKey(projectId));
     window.sessionStorage.removeItem(autoSendAmrGateOkKey(projectId));
+    window.sessionStorage.removeItem(autoSendSkillIdsKey(projectId));
   } catch {
     /* ignore */
   }
@@ -7741,6 +7767,7 @@ export function ProjectView({
   const autoSendSeedRef = useRef<string | null>(null);
   const autoSendAttachmentsRef = useRef<ChatAttachment[] | null>(null);
   const autoSendContextRef = useRef<RunContextSelection | null>(null);
+  const autoSendSkillIdsRef = useRef<string[] | null>(null);
   const autoSendFirstMessageRef = useRef(false);
   const autoSendAmrGateOkRef = useRef(false);
   if (autoSendSeedRef.current === null) {
@@ -7761,6 +7788,7 @@ export function ProjectView({
     autoSendSeedRef.current = isAutoSend ? (project.pendingPrompt ?? '') : '';
     autoSendAttachmentsRef.current = isAutoSend ? readAutoSendAttachments(project.id) : [];
     autoSendContextRef.current = isAutoSend ? readAutoSendContext(project.id) : null;
+    autoSendSkillIdsRef.current = isAutoSend ? readAutoSendSkillIds(project.id) : [];
   }
   const initialWorkspaceContexts = autoSendContextRef.current?.workspaceItems ?? [];
   const brandEnrichmentEligibleForProject =
@@ -8410,12 +8438,15 @@ export function ProjectView({
       markDesignSystemAuditAutoRepairEligible(project.id);
     }
     clearAutoSendSession(project.id);
+    const skillIds = autoSendSkillIdsRef.current ?? [];
     autoSendAttachmentsRef.current = [];
+    autoSendSkillIdsRef.current = [];
     void handleSend(seed, attachments, [], {
       ...(context ? { context } : {}),
       // The home submit already gated this exact task (and the user answered
       // any soft warning there); asking again would double-prompt.
       ...(autoSendAmrGateOkRef.current ? { amrGatePrechecked: true } : {}),
+      ...(skillIds.length > 0 ? { skillIds } : {}),
     });
   }, [
     activeConversationId,

apps/web/tests/components/ProjectView.run-cleanup.test.tsx

@@ -1399,6 +1399,86 @@ describe('ProjectView daemon cleanup', () => {
     }
   });
 
+  it('auto-sends the Home-carried multi-skill compose list to the first daemon run', async () => {
+    // Regression for PR #6333 review: the Home auto-send hand-off used to
+    // only carry prompt/attachments/context to ProjectView, so the
+    // extra composed skills (`@skill-a @skill-b`) were silently dropped
+    // — the first daemon run launched with only `project.skillId`
+    // (the primary). Stash `od:auto-send-skillIds:<projectId>` at Home
+    // create time, then ProjectView puts the array back into
+    // `meta.skillIds` on the first handleSend, and `streamViaDaemon`
+    // receives the full list rather than an empty one.
+    listConversations.mockResolvedValue([{ id: 'conv-1', title: 'Conversation' }]);
+    listMessages.mockResolvedValue([]);
+    fetchPreviewComments.mockResolvedValue([]);
+    loadTabs.mockResolvedValue({ tabs: [], activeTabId: null });
+    fetchProjectFiles.mockResolvedValue([]);
+    fetchLiveArtifacts.mockResolvedValue([]);
+    fetchSkill.mockResolvedValue(null);
+    fetchDesignSystem.mockResolvedValue(null);
+    getTemplate.mockResolvedValue(null);
+    listActiveChatRuns.mockResolvedValue([]);
+    streamViaDaemon.mockResolvedValue(undefined);
+
+    window.sessionStorage.setItem('od:auto-send-first:project-skill-ids', '1');
+    window.sessionStorage.setItem(
+      'od:auto-send-skillIds:project-skill-ids',
+      JSON.stringify(['deck-builder', 'pdf-designer']),
+    );
+
+    try {
+      render(
+        <ProjectView
+          project={{
+            id: 'project-skill-ids',
+            name: 'Project',
+            skillId: 'deck-builder',
+            designSystemId: null,
+            pendingPrompt: 'Make a deck and a PDF.',
+            createdAt: 1,
+            updatedAt: 1,
+          }}
+          routeFileName={null}
+          config={{ mode: 'daemon', agentId: 'agent-1', notifications: undefined, agentModels: {} } as never}
+          agents={[{ id: 'agent-1', name: 'OpenCode', models: [] } as never]}
+          skills={[]}
+          designTemplates={[]}
+          designSystems={[]}
+          daemonLive
+          onModeChange={() => {}}
+          onAgentChange={() => {}}
+          onAgentModelChange={() => {}}
+          onRefreshAgents={() => {}}
+          onOpenSettings={() => {}}
+          onBack={() => {}}
+          onClearPendingPrompt={() => {}}
+          onTouchProject={() => {}}
+          onProjectChange={() => {}}
+          onProjectsRefresh={() => {}}
+        />,
+      );
+
+      await waitFor(() => expect(streamViaDaemon).toHaveBeenCalledTimes(1));
+      const daemonCall = streamViaDaemon.mock.calls[0]?.[0] as {
+        projectId: string;
+        skillId: string | null;
+        skillIds: string[];
+      };
+      expect(daemonCall.projectId).toBe('project-skill-ids');
+      // The primary skill stays on `skillId` (the existing single-skill
+      // contract); the full multi-skill compose list lands on `skillIds`.
+      expect(daemonCall.skillId).toBe('deck-builder');
+      expect(daemonCall.skillIds).toEqual(['deck-builder', 'pdf-designer']);
+      // The auto-send session flag is cleared after the first dispatch so a
+      // reload after the run starts never re-fires.
+      expect(window.sessionStorage.getItem('od:auto-send-skillIds:project-skill-ids')).toBeNull();
+      expect(window.sessionStorage.getItem('od:auto-send-first:project-skill-ids')).toBeNull();
+    } finally {
+      window.sessionStorage.removeItem('od:auto-send-first:project-skill-ids');
+      window.sessionStorage.removeItem('od:auto-send-skillIds:project-skill-ids');
+    }
+  });
+
   it('queues board comment attachments while the current daemon run is still busy', async () => {
     listConversations.mockResolvedValue([{ id: 'conv-1', title: 'Conversation' }]);
     listMessages.mockResolvedValue([]);