feat: group specialist session artifacts into output bundles

When a specialist produces 2+ artifacts in a single chat session, they are
automatically grouped into a named bundle via ArtifactService.createBundle().
Bundle title follows "SpecialistName: Topic" format. The agents page specialist
cards now display bundles as compact rows with title and count badge alongside
standalone artifacts. Dashboard UI already handled bundles — no changes needed.

Author: marian2js

apps/desktop/src/features/agents/components/SpecialistCard.tsx

@@ -7,18 +7,28 @@ import { getSpecialistColors } from "@/features/agents/specialist-meta";
 import { formatRelativeTime } from "@/lib/utils/output-labels";
 import { cleanArtifactTitle } from "@/features/dashboard/lib/clean-artifact-title";
 
+export interface SpecialistBundleGroup {
+  bundleId: string;
+  title: string;
+  artifacts: ArtifactRecord[];
+  createdAt: string;
+}
+
 interface SpecialistCardProps {
   specialist: SpecialistAgent;
   onChat: (specialistId: string) => void;
   recentOutputs?: ArtifactRecord[] | undefined;
+  recentBundles?: SpecialistBundleGroup[] | undefined;
   onOutputNavigate?: ((artifact: ArtifactRecord) => void) | undefined;
 }
 
-export function SpecialistCard({ specialist, onChat, recentOutputs, onOutputNavigate }: SpecialistCardProps) {
+export function SpecialistCard({ specialist, onChat, recentOutputs, recentBundles, onOutputNavigate }: SpecialistCardProps) {
   const Icon = resolveSpecialistIcon(specialist.icon);
   const isManager = specialist.category === "manager";
   const colors = getSpecialistColors(specialist.id);
   const outputs = recentOutputs?.length ? recentOutputs : [];
+  const bundles = recentBundles?.length ? recentBundles : [];
+  const hasOutputs = outputs.length > 0 || bundles.length > 0;
 
   return (
     <article
@@ -83,8 +93,8 @@ export function SpecialistCard({ specialist, onChat, recentOutputs, onOutputNavi
           ))}
         </div>
 
-        {/* Recent outputs — only shown when outputs exist */}
-        {outputs.length > 0 ? (
+        {/* Recent outputs — bundles and standalone artifacts */}
+        {hasOutputs ? (
           <div className="mt-4 rounded-lg border border-border/15 bg-muted/20 px-3 py-2.5 dark:border-white/[0.03] dark:bg-white/[0.02]">
             <div className="mb-1.5 flex items-center gap-1.5">
               <PackageIcon className="size-3 shrink-0 text-muted-foreground/50" />
@@ -93,6 +103,36 @@ export function SpecialistCard({ specialist, onChat, recentOutputs, onOutputNavi
               </span>
             </div>
             <div className="flex flex-col gap-0.5">
+              {/* Bundle rows */}
+              {bundles.map((bundle) => (
+                <div
+                  key={bundle.bundleId}
+                  role="button"
+                  tabIndex={0}
+                  className="group/output flex cursor-pointer items-center gap-2 rounded-md px-2 py-1 text-[11px] transition-colors hover:bg-card dark:hover:bg-white/[0.04]"
+                  onClick={() => {
+                    if (bundle.artifacts[0]) onOutputNavigate?.(bundle.artifacts[0]);
+                  }}
+                  onKeyDown={(e) => {
+                    if (e.key === "Enter" || e.key === " ") {
+                      e.preventDefault();
+                      if (bundle.artifacts[0]) onOutputNavigate?.(bundle.artifacts[0]);
+                    }
+                  }}
+                >
+                  <PackageIcon className={cn("size-3 shrink-0", colors.iconText || "text-primary")} />
+                  <span className="min-w-0 flex-1 truncate font-medium text-foreground/70 group-hover/output:text-foreground">
+                    {bundle.title}
+                  </span>
+                  <span className="shrink-0 rounded-full bg-muted/50 px-1.5 py-0.5 font-mono text-[10px] tabular-nums text-muted-foreground">
+                    {bundle.artifacts.length}
+                  </span>
+                  <span className="shrink-0 text-muted-foreground/40">
+                    {formatRelativeTime(bundle.createdAt)}
+                  </span>
+                </div>
+              ))}
+              {/* Standalone artifact rows */}
               {outputs.map((artifact) => (
                 <div
                   key={artifact.artifactId}

apps/desktop/src/features/agents/components/SpecialistTeamBrowser.tsx

@@ -5,6 +5,7 @@ import type { SidecarClient } from "@/lib/sidecar/client";
 import { getActionMapping } from "@/lib/utils/action-map";
 import { deduplicateSpecialistOutputs } from "../lib/deduplicate-specialist-outputs";
 import { SpecialistCard } from "./SpecialistCard";
+import type { SpecialistBundleGroup } from "./SpecialistCard";
 
 /** Max recent outputs shown per specialist card */
 const MAX_OUTPUTS_PER_SPECIALIST = 3;
@@ -15,11 +16,22 @@ interface SpecialistTeamBrowserProps {
   onSpecialistChat?: ((specialistId: string) => void) | undefined;
 }
 
+function deriveBundleTitleFromArtifacts(artifacts: ArtifactRecord[]): string {
+  if (artifacts.length === 0) return "Bundle";
+  const types = new Set(artifacts.map((a) => a.type));
+  if (types.size === 1) {
+    const type = artifacts[0]!.type;
+    return type.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()) + " Bundle";
+  }
+  return artifacts[0]!.title.split(" — ")[0] ?? "Bundle";
+}
+
 export function SpecialistTeamBrowser({ client, agentId, onSpecialistChat }: SpecialistTeamBrowserProps) {
   const [specialists, setSpecialists] = useState<SpecialistAgent[]>([]);
   const [isLoading, setIsLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
   const [recentOutputsMap, setRecentOutputsMap] = useState<Record<string, ArtifactRecord[]>>({});
+  const [recentBundlesMap, setRecentBundlesMap] = useState<Record<string, SpecialistBundleGroup[]>>({});
 
   useEffect(() => {
     let cancelled = false;
@@ -74,18 +86,79 @@ export function SpecialistTeamBrowser({ client, agentId, onSpecialistChat }: Spe
         // Group all artifacts by specialist
         const raw: Record<string, ArtifactRecord[]> = {};
         for (const artifact of page.items) {
-          const specialistId = artifact.createdBy;
-          if (!raw[specialistId]) {
-            raw[specialistId] = [];
+          const sid = artifact.createdBy;
+          if (!raw[sid]) {
+            raw[sid] = [];
           }
-          raw[specialistId].push(artifact);
+          raw[sid].push(artifact);
         }
-        // Deduplicate by case-insensitive title, then limit per specialist
-        const map: Record<string, ArtifactRecord[]> = {};
-        for (const [specialistId, artifacts] of Object.entries(raw)) {
-          map[specialistId] = deduplicateSpecialistOutputs(artifacts).slice(0, MAX_OUTPUTS_PER_SPECIALIST);
+
+        // For each specialist, separate bundled from standalone artifacts
+        const standaloneMap: Record<string, ArtifactRecord[]> = {};
+        const bundlesMap: Record<string, SpecialistBundleGroup[]> = {};
+
+        for (const [sid, artifacts] of Object.entries(raw)) {
+          const bundleArtifacts = new Map<string, ArtifactRecord[]>();
+          const standalone: ArtifactRecord[] = [];
+
+          for (const artifact of artifacts) {
+            if (artifact.bundleId) {
+              const existing = bundleArtifacts.get(artifact.bundleId) ?? [];
+              existing.push(artifact);
+              bundleArtifacts.set(artifact.bundleId, existing);
+            } else {
+              standalone.push(artifact);
+            }
+          }
+
+          // Build bundle groups
+          const groups: SpecialistBundleGroup[] = Array.from(bundleArtifacts.entries()).map(
+            ([bundleId, arts]) => {
+              const sorted = arts.sort(
+                (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime(),
+              );
+              return {
+                bundleId,
+                title: deriveBundleTitleFromArtifacts(sorted),
+                artifacts: sorted,
+                createdAt: sorted[0]!.createdAt,
+              };
+            },
+          );
+
+          // Deduplicate standalone, then combine and limit total to MAX_OUTPUTS_PER_SPECIALIST
+          const dedupedStandalone = deduplicateSpecialistOutputs(standalone).slice(0, MAX_OUTPUTS_PER_SPECIALIST);
+
+          // Merge bundles + standalone sorted by time, then limit
+          type Entry =
+            | { kind: "bundle"; group: SpecialistBundleGroup; ts: number }
+            | { kind: "standalone"; artifact: ArtifactRecord; ts: number };
+
+          const entries: Entry[] = [
+            ...groups.map((g) => ({ kind: "bundle" as const, group: g, ts: new Date(g.createdAt).getTime() })),
+            ...dedupedStandalone.map((a) => ({ kind: "standalone" as const, artifact: a, ts: new Date(a.createdAt).getTime() })),
+          ];
+          entries.sort((a, b) => b.ts - a.ts);
+
+          const limitedStandalone: ArtifactRecord[] = [];
+          const limitedBundles: SpecialistBundleGroup[] = [];
+          let count = 0;
+          for (const entry of entries) {
+            if (count >= MAX_OUTPUTS_PER_SPECIALIST) break;
+            if (entry.kind === "bundle") {
+              limitedBundles.push(entry.group);
+            } else {
+              limitedStandalone.push(entry.artifact);
+            }
+            count++;
+          }
+
+          standaloneMap[sid] = limitedStandalone;
+          bundlesMap[sid] = limitedBundles;
         }
-        setRecentOutputsMap(map);
+
+        setRecentOutputsMap(standaloneMap);
+        setRecentBundlesMap(bundlesMap);
       })
       .catch(() => {
         // Silently ignore — recent outputs are non-critical
@@ -180,6 +253,7 @@ export function SpecialistTeamBrowser({ client, agentId, onSpecialistChat }: Spe
                 specialist={manager}
                 onChat={handleChat}
                 recentOutputs={recentOutputsMap[manager.id]}
+                recentBundles={recentBundlesMap[manager.id]}
                 onOutputNavigate={handleOutputNavigate}
               />
             </div>
@@ -201,6 +275,7 @@ export function SpecialistTeamBrowser({ client, agentId, onSpecialistChat }: Spe
                     specialist={specialist}
                     onChat={handleChat}
                     recentOutputs={recentOutputsMap[specialist.id]}
+                    recentBundles={recentBundlesMap[specialist.id]}
                     onOutputNavigate={handleOutputNavigate}
                   />
                 ))}

packages/sidecar/src/artifact-extractor/extractor.ts

@@ -1,4 +1,4 @@
-import type { ArtifactRecord, ArtifactService, CreateArtifactOptions } from "@opengoat/core";
+import type { ArtifactRecord, ArtifactService, ArtifactType, CreateArtifactOptions } from "@opengoat/core";
 import type { OpenGoatPaths } from "@opengoat/core";
 import { detectSections, matchHeadingToOutputType } from "./content-detector.ts";
 import { mapOutputTypeToArtifactType } from "./output-type-mapper.ts";
@@ -15,28 +15,55 @@ export interface ExtractionContext {
 export interface ExtractionResult {
   artifacts: ArtifactRecord[];
   skipped: number;
+  bundleId?: string;
 }
 
 interface ExtractionDeps {
-  artifactService: Pick<ArtifactService, "createArtifact">;
+  artifactService: Pick<ArtifactService, "createArtifact" | "createBundle">;
   opengoatPaths: OpenGoatPaths;
-  specialist: { id: string; outputTypes: string[] };
+  specialist: { id: string; name: string; outputTypes: string[] };
+}
+
+interface MatchedSection {
+  heading: string;
+  content: string;
+  artifactType: ArtifactType;
+}
+
+/**
+ * Derives a bundle title from the specialist name and matched sections.
+ * Format: "SpecialistName: Topic"
+ */
+function deriveBundleTitle(specialistName: string, sections: MatchedSection[]): string {
+  if (sections.length === 0) return specialistName;
+
+  const types = new Set(sections.map((s) => s.artifactType));
+  if (types.size === 1) {
+    const typeName = sections[0].artifactType
+      .replace(/_/g, " ")
+      .replace(/\b\w/g, (c) => c.toUpperCase());
+    return `${specialistName}: ${typeName} Bundle`;
+  }
+
+  return `${specialistName}: ${sections[0].heading}`;
 }
 
 /**
  * Extracts artifacts from specialist chat text.
  *
- * Flow: detectSections → matchHeadingToOutputType → mapOutputTypeToArtifactType → createArtifact
+ * Flow: detectSections → matchHeadingToOutputType → mapOutputTypeToArtifactType
+ *       → (if 2+) createBundle → createArtifact with bundleId
  */
 export async function extractArtifacts(
   text: string,
   context: ExtractionContext,
   deps: ExtractionDeps,
 ): Promise<ExtractionResult> {
   const sections = detectSections(text);
-  const artifacts: ArtifactRecord[] = [];
+  const matched: MatchedSection[] = [];
   let skipped = 0;
 
+  // Pass 1: Collect matched sections without creating artifacts
   for (const section of sections) {
     const matchedOutputType = matchHeadingToOutputType(
       section.heading,
@@ -54,14 +81,36 @@ export async function extractArtifacts(
       continue;
     }
 
+    matched.push({
+      heading: section.heading,
+      content: section.content,
+      artifactType,
+    });
+  }
+
+  // Bundle decision: create bundle if 2+ matched sections
+  let bundleId: string | undefined;
+  if (matched.length >= 2) {
+    const bundleTitle = deriveBundleTitle(deps.specialist.name, matched);
+    const bundle = await deps.artifactService.createBundle(
+      deps.opengoatPaths,
+      { projectId: context.agentId, title: bundleTitle },
+    );
+    bundleId = bundle.bundleId;
+  }
+
+  // Pass 2: Create artifacts with optional bundleId
+  const artifacts: ArtifactRecord[] = [];
+  for (const section of matched) {
     const options: CreateArtifactOptions = {
       projectId: context.agentId,
       title: section.heading,
-      type: artifactType,
+      type: section.artifactType,
       format: "markdown",
       contentRef: `chat://${context.sessionId}/${context.messageIndex ?? 0}`,
       createdBy: context.specialistId,
       content: section.content,
+      ...(bundleId ? { bundleId } : {}),
       ...(context.objectiveId ? { objectiveId: context.objectiveId } : {}),
       ...(context.runId ? { runId: context.runId } : {}),
     };
@@ -73,5 +122,5 @@ export async function extractArtifacts(
     artifacts.push(record);
   }
 
-  return { artifacts, skipped };
+  return { artifacts, skipped, bundleId };
 }