@happyvertical/smrt-svelte 0.38.2 → 0.38.3

package/AGENTS.md

@@ -263,6 +263,23 @@ compatibility.
 
 See `src/components/workspace/MIGRATION.md` for the old-to-new concept map.
 
+### Live activity feed adapter (`./web`, #1779)
+
+`activityFeed({ collection, map, shell })` (from `@happyvertical/smrt-svelte/web`)
+bridges a `@happyvertical/smrt-web` live collection into a `ShellState` activity
+registry: it subscribes the collection through `liveCollection`, reactively maps
+each row → `ShellActivity` via the app-supplied editorial `map`, and drives
+`upsertActivity` / `updateActivity` / `removeActivity` as rows appear, change,
+and vanish (a row mapping to `null` is excluded / retracted). Returns a disposer
+that removes exactly the activities it created. Must be called during component
+init (installs a `$effect`); the subscription tears down on unmount.
+
+It lives behind the opt-in `./web` entry — which pulls the TanStack client-data
+engine — and is **never** imported under `components/workspace/`, so the
+AdminShell core (`./workspace`) stays transport-agnostic and TanStack-free (epic
+#1766). The pure diff core is `ActivityFeedReconciler` (engine-free, unit-tested
+against a real `ShellState`). Demo: `playground/.../admin-shell-activity-feed`.
+
 ### Dock availability gates (server-side)
 
 `ToolDef.gates?: string[]` declares the gates a tool must pass to be visible.

package/dist/components/workspace/NavTree.svelte

@@ -76,7 +76,7 @@ function checkExpanded(item: NavItem): boolean {
  */
 function checkEffectiveActive(item: NavItem): boolean {
   if (checkActive(item)) return true;
-  if (collapsed && !!item.children?.length && checkParentActive(item))
+  if (collapsed && item.children?.length && checkParentActive(item))
     return true;
   return false;
 }

package/dist/i18n/strings.workspace.d.ts

@@ -56,6 +56,16 @@ export declare const M: {
     readonly 'ui.system_scope_panel.no_running_work': "ui.system_scope_panel.no_running_work";
     readonly 'ui.system_status_chips.system_status': "ui.system_status_chips.system_status";
     readonly 'ui.tenant_nav.tenant_navigation': "ui.tenant_nav.tenant_navigation";
+    readonly 'ui.activity_feed.title': "ui.activity_feed.title";
+    readonly 'ui.activity_feed.description': "ui.activity_feed.description";
+    readonly 'ui.activity_feed.enqueue_job': "ui.activity_feed.enqueue_job";
+    readonly 'ui.activity_feed.advance_job': "ui.activity_feed.advance_job";
+    readonly 'ui.activity_feed.complete_job': "ui.activity_feed.complete_job";
+    readonly 'ui.activity_feed.fail_job': "ui.activity_feed.fail_job";
+    readonly 'ui.activity_feed.clear_finished': "ui.activity_feed.clear_finished";
+    readonly 'ui.activity_feed.rows_heading': "ui.activity_feed.rows_heading";
+    readonly 'ui.activity_feed.no_rows': "ui.activity_feed.no_rows";
+    readonly 'ui.activity_feed.job_label': "ui.activity_feed.job_label";
     readonly 'ui.system_feed.title': "ui.system_feed.title";
     readonly 'ui.system_feed.description': "ui.system_feed.description";
     readonly 'ui.system_feed.pause': "ui.system_feed.pause";

package/dist/i18n/strings.workspace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"strings.workspace.d.ts","sourceRoot":"","sources":["../../src/i18n/strings.workspace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,eAAO,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2EZ,CAAC"}
+{"version":3,"file":"strings.workspace.d.ts","sourceRoot":"","sources":["../../src/i18n/strings.workspace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,eAAO,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwFZ,CAAC"}

package/dist/i18n/strings.workspace.js

@@ -61,6 +61,17 @@ export const M = defineMessages({
     'ui.system_scope_panel.no_running_work': 'No running work',
     'ui.system_status_chips.system_status': 'System status',
     'ui.tenant_nav.tenant_navigation': 'Tenant navigation',
+    // web/activity-feed adapter demo (#1779) — playground/admin-shell-activity-feed
+    'ui.activity_feed.title': 'Live activity feed',
+    'ui.activity_feed.description': 'A smrt-web live collection reconciled into the shell activity registry.',
+    'ui.activity_feed.enqueue_job': 'Enqueue job',
+    'ui.activity_feed.advance_job': 'Advance job',
+    'ui.activity_feed.complete_job': 'Complete job',
+    'ui.activity_feed.fail_job': 'Fail job',
+    'ui.activity_feed.clear_finished': 'Clear finished',
+    'ui.activity_feed.rows_heading': 'Backing collection rows',
+    'ui.activity_feed.no_rows': 'No rows yet',
+    'ui.activity_feed.job_label': 'Render job',
     // components/workspace/live/* (systemFeed demo — issue #1774)
     'ui.system_feed.title': 'System feed',
     'ui.system_feed.description': 'Polls an app-provided status endpoint and maps it into the system-scope panels and status chips.',

package/dist/web/__tests__/activity-feed-harness.svelte

@@ -0,0 +1,32 @@
+<script lang="ts">
+/**
+ * Integration harness — invokes activityFeed() inside a component-init scope so
+ * the `$effect` it (and the underlying `liveCollection`) installs wires up to a
+ * real component lifecycle, then hands the feed handle back to the test.
+ */
+import type { SmrtWebCollection } from '@happyvertical/smrt-web';
+import type { ShellState } from '../../components/workspace/index.js';
+import {
+  type ActivityFeedHandle,
+  type ActivityFeedMap,
+  activityFeed,
+} from '../activity-feed.svelte.js';
+
+interface Props {
+  collection: SmrtWebCollection<Record<string, unknown>>;
+  shell: ShellState;
+  map: ActivityFeedMap<Record<string, unknown>>;
+  onReady: (handle: ActivityFeedHandle) => void;
+}
+
+const props: Props = $props();
+// This harness intentionally snapshots its props during setup.
+// svelte-ignore state_referenced_locally
+const handle = activityFeed({
+  collection: props.collection,
+  shell: props.shell,
+  map: props.map,
+});
+// svelte-ignore state_referenced_locally
+props.onReady(handle);
+</script>

package/dist/web/__tests__/activity-feed-harness.svelte.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Integration harness — invokes activityFeed() inside a component-init scope so
+ * the `$effect` it (and the underlying `liveCollection`) installs wires up to a
+ * real component lifecycle, then hands the feed handle back to the test.
+ */
+import type { SmrtWebCollection } from '@happyvertical/smrt-web';
+import type { ShellState } from '../../components/workspace/index.js';
+import { type ActivityFeedHandle, type ActivityFeedMap } from '../activity-feed.svelte.js';
+interface Props {
+    collection: SmrtWebCollection<Record<string, unknown>>;
+    shell: ShellState;
+    map: ActivityFeedMap<Record<string, unknown>>;
+    onReady: (handle: ActivityFeedHandle) => void;
+}
+declare const ActivityFeedHarness: import("svelte").Component<Props, {}, "">;
+type ActivityFeedHarness = ReturnType<typeof ActivityFeedHarness>;
+export default ActivityFeedHarness;
+//# sourceMappingURL=activity-feed-harness.svelte.d.ts.map

package/dist/web/__tests__/activity-feed-harness.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-feed-harness.svelte.d.ts","sourceRoot":"","sources":["../../../src/web/__tests__/activity-feed-harness.svelte.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACtE,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,eAAe,EAErB,MAAM,4BAA4B,CAAC;AAGpC,UAAU,KAAK;IACb,UAAU,EAAE,iBAAiB,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACvD,KAAK,EAAE,UAAU,CAAC;IAClB,GAAG,EAAE,eAAe,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC9C,OAAO,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,IAAI,CAAC;CAC/C;AAsBD,QAAA,MAAM,mBAAmB,2CAAwC,CAAC;AAClE,KAAK,mBAAmB,GAAG,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAClE,eAAe,mBAAmB,CAAC"}

package/dist/web/__tests__/activity-feed.integration.svelte.test.js

@@ -0,0 +1,189 @@
+/**
+ * Integration test for the AdminShell activity feed adapter (#1779) end to end.
+ *
+ * Unlike the reconciler unit tests (which feed plain arrays), this exercises the
+ * FULL stack — `activityFeed` → `liveCollection` → the real `@happyvertical/smrt-web`
+ * collection with its client-data engine — through a mounted harness, so the
+ * `$effect` that drives reconciliation has a genuine component-init scope. Only
+ * the network boundary is mocked (the generated REST fetchers passed to
+ * `createSmrtCollection`); the engine, live view, runes reactivity, and the real
+ * `ShellState` are all live. This proves the reactive wiring drives the shell:
+ * a loaded row and an optimistic insert both surface as shell activities.
+ */
+import { createSmrtCollection, } from '@happyvertical/smrt-web';
+import { flushSync, mount, unmount } from 'svelte';
+import { afterEach, describe, expect, it } from 'vitest';
+import { createShellState } from '../../components/workspace/admin-shell/state.svelte.js';
+import Harness from './activity-feed-harness.svelte';
+function jobDefinition(name) {
+    return {
+        name,
+        className: 'RenderJob',
+        endpoint: `/${name}`,
+        idField: 'id',
+        actions: ['create', 'get', 'list'],
+        fields: {
+            title: { type: 'text', required: true },
+            state: { type: 'text' },
+        },
+    };
+}
+/** Scripted stand-in for the generated REST fetchers (see live-collection test). */
+function makeScriptedFetchers(initialRows) {
+    const serverRows = [...initialRows];
+    const fetchers = {
+        list: async () => serverRows.map((row) => ({ ...row })),
+        create: async (data) => {
+            const created = { ...data, id: `server-${serverRows.length + 1}` };
+            serverRows.push(created);
+            return { ...created };
+        },
+    };
+    return { fetchers };
+}
+const mapJob = (row) => ({
+    kind: 'render-job',
+    scope: 'focus',
+    label: row.title,
+    status: row.state ?? 'running',
+});
+function mountFeed(collection, shell) {
+    const target = document.createElement('div');
+    document.body.appendChild(target);
+    let exposed = undefined;
+    const component = mount(Harness, {
+        target,
+        props: {
+            // The harness is typed against the base object shape; JobData is a
+            // structural subtype, so this cross-cast is purely nominal.
+            collection: collection,
+            shell,
+            map: mapJob,
+            onReady: (handle) => {
+                exposed = handle;
+            },
+        },
+    });
+    return {
+        handle: exposed,
+        teardown: () => {
+            unmount(component);
+            target.remove();
+        },
+    };
+}
+describe('activityFeed (integration)', () => {
+    const cleanup = [];
+    afterEach(() => {
+        for (const fn of cleanup.splice(0))
+            fn();
+    });
+    it('reconciles loaded collection rows into shell activities', async () => {
+        const scripted = makeScriptedFetchers([
+            { id: 'job-1', title: 'Render intro', state: 'running' },
+            { id: 'job-2', title: 'Render outro', state: 'queued' },
+        ]);
+        const collection = createSmrtCollection(jobDefinition('feed-load'), {
+            fetchers: scripted.fetchers,
+            staleTimeMs: 60_000,
+        });
+        const shell = createShellState();
+        const mounted = mountFeed(collection, shell);
+        cleanup.push(mounted.teardown);
+        await collection.preload();
+        flushSync();
+        const activities = shell.listActivities();
+        expect(activities.map((a) => a.id).sort()).toEqual(['job-1', 'job-2']);
+        expect(activities.every((a) => a.kind === 'render-job')).toBe(true);
+        // Homed to the focus edge (right) per the map's scope.
+        expect(shell.listActivities({ edge: 'right' })).toHaveLength(2);
+    });
+    it('surfaces an optimistic insert as a shell activity reactively', async () => {
+        const scripted = makeScriptedFetchers([
+            { id: 'job-1', title: 'Render intro', state: 'running' },
+        ]);
+        const collection = createSmrtCollection(jobDefinition('feed-insert'), {
+            fetchers: scripted.fetchers,
+            staleTimeMs: 60_000,
+        });
+        const shell = createShellState();
+        const mounted = mountFeed(collection, shell);
+        cleanup.push(mounted.teardown);
+        await collection.preload();
+        flushSync();
+        expect(shell.listActivities()).toHaveLength(1);
+        // An optimistic insert appears in the live view synchronously → the feed
+        // reconciles it into the shell on the reactive tick.
+        const tx = collection.insert({
+            id: 'local-1',
+            title: 'Render credits',
+            state: 'running',
+        });
+        flushSync();
+        expect(shell
+            .listActivities()
+            .map((a) => a.label)
+            .sort()).toEqual(['Render credits', 'Render intro']);
+        // Once persisted, the server-assigned row replaces the optimistic one; the
+        // activity for the temp id is removed and the server row's activity remains.
+        await tx.isPersisted.promise;
+        flushSync();
+        const labels = shell
+            .listActivities()
+            .map((a) => a.label)
+            .sort();
+        expect(labels).toEqual(['Render credits', 'Render intro']);
+        // The optimistic-id activity is gone; the server id is present.
+        const ids = shell.listActivities().map((a) => a.id);
+        expect(ids).toContain('server-2');
+        expect(ids).not.toContain('local-1');
+    });
+    it('dispose() retracts the feed activities from the shell', async () => {
+        const scripted = makeScriptedFetchers([
+            { id: 'job-1', title: 'Render intro', state: 'running' },
+        ]);
+        const collection = createSmrtCollection(jobDefinition('feed-dispose'), {
+            fetchers: scripted.fetchers,
+            staleTimeMs: 60_000,
+        });
+        const shell = createShellState();
+        const mounted = mountFeed(collection, shell);
+        cleanup.push(mounted.teardown);
+        await collection.preload();
+        flushSync();
+        expect(shell.listActivities()).toHaveLength(1);
+        mounted.handle.dispose();
+        expect(shell.listActivities()).toHaveLength(0);
+        expect(mounted.handle.isDisposed).toBe(true);
+    });
+    it('auto-retracts the feed activities when the host component unmounts', async () => {
+        const scripted = makeScriptedFetchers([
+            { id: 'job-1', title: 'Render intro', state: 'running' },
+            { id: 'job-2', title: 'Render outro', state: 'queued' },
+        ]);
+        const collection = createSmrtCollection(jobDefinition('feed-unmount'), {
+            fetchers: scripted.fetchers,
+            staleTimeMs: 60_000,
+        });
+        const shell = createShellState();
+        // An activity from another source must survive the feed's unmount.
+        shell.upsertActivity({
+            id: 'external-1',
+            label: 'External',
+            kind: 'other',
+            scope: 'app',
+            status: 'running',
+        });
+        const mounted = mountFeed(collection, shell);
+        await collection.preload();
+        flushSync();
+        expect(shell.listActivities()).toHaveLength(3);
+        // Unmount WITHOUT calling dispose() manually: the adapter's $effect teardown
+        // must retract exactly its own activities, leaving the external one intact.
+        mounted.teardown();
+        flushSync();
+        const remaining = shell.listActivities();
+        expect(remaining).toHaveLength(1);
+        expect(remaining[0].id).toBe('external-1');
+    });
+});

package/dist/web/__tests__/activity-feed.svelte.test.js

@@ -0,0 +1,235 @@
+/**
+ * Unit tests for the AdminShell activity feed adapter's reconciliation core
+ * (#1779).
+ *
+ * These exercise {@link ActivityFeedReconciler} — the pure diff between a set of
+ * live rows and the shell activity registry — against a REAL {@link ShellState}.
+ * Per repo policy nothing here is mocked: the shell, its activity events, and
+ * the mapping are all real; the reconciler is fed plain row arrays that stand in
+ * for successive live-collection ticks (`liveCollection`'s engine is exercised
+ * separately in `activity-feed.integration.svelte.test.ts`). This isolates the
+ * mapping / create-update-remove / ownership behavior the adapter guarantees.
+ */
+import { afterEach, describe, expect, it } from 'vitest';
+import { createShellState } from '../../components/workspace/admin-shell/state.svelte.js';
+import { ActivityFeedReconciler, } from '../activity-feed.svelte.js';
+/** Editorial map: a job row → focus-scope activity, or `null` for a draft. */
+const mapJob = (row) => {
+    if (row.draft)
+        return null;
+    return {
+        kind: 'render-job',
+        scope: 'focus',
+        label: row.title,
+        status: row.state,
+        progress: row.progress ?? null,
+    };
+};
+/** Record every activity event the shell emits, for sequence assertions. */
+function recordEvents(shell) {
+    const events = [];
+    const stop = shell.watchActivities((event) => events.push(event));
+    return { events, stop };
+}
+describe('ActivityFeedReconciler', () => {
+    const teardown = [];
+    afterEach(() => {
+        for (const fn of teardown.splice(0))
+            fn();
+    });
+    function setup() {
+        const shell = createShellState();
+        const recorded = recordEvents(shell);
+        teardown.push(recorded.stop);
+        const reconciler = new ActivityFeedReconciler(shell, mapJob);
+        return { shell, reconciler, events: recorded.events };
+    }
+    it('upserts a shell activity when a row first appears', () => {
+        const { shell, reconciler, events } = setup();
+        reconciler.reconcile([
+            { id: 'job-1', title: 'Render intro', state: 'running', progress: 20 },
+        ]);
+        const activities = shell.listActivities();
+        expect(activities).toHaveLength(1);
+        expect(activities[0]).toMatchObject({
+            id: 'job-1',
+            kind: 'render-job',
+            scope: 'focus',
+            label: 'Render intro',
+            status: 'running',
+            progress: 20,
+        });
+        // The activity id defaults to the row id, and the shell stamped createdAt.
+        expect(activities[0].createdAt).toBeTruthy();
+        // A single create event (upsert), no transition/remove.
+        expect(events.map((e) => e.type)).toEqual(['upsert']);
+    });
+    it('updates the activity in place when a row changes (status transition)', () => {
+        const { shell, reconciler, events } = setup();
+        reconciler.reconcile([
+            { id: 'job-1', title: 'Render intro', state: 'running', progress: 20 },
+        ]);
+        const createdAt = shell.listActivities()[0].createdAt;
+        // Same row id, advanced progress + status flip → an UPDATE, not a second
+        // create, and the shell reports it as a `transition` (status changed).
+        reconciler.reconcile([
+            { id: 'job-1', title: 'Render intro', state: 'completed', progress: 100 },
+        ]);
+        const activities = shell.listActivities();
+        expect(activities).toHaveLength(1);
+        expect(activities[0]).toMatchObject({
+            id: 'job-1',
+            status: 'completed',
+            progress: 100,
+        });
+        // createdAt preserved across the update (update went through updateActivity,
+        // not a fresh upsert that would re-stamp it).
+        expect(activities[0].createdAt).toBe(createdAt);
+        expect(events.map((e) => e.type)).toEqual(['upsert', 'transition']);
+    });
+    it('performs no shell mutation when a reconcile tick is unchanged', () => {
+        const { reconciler, events } = setup();
+        const rows = [
+            { id: 'job-1', title: 'Render intro', state: 'running', progress: 20 },
+        ];
+        reconciler.reconcile(rows);
+        // Re-feed identical content (a common no-op reactive tick): a new array with
+        // an equal-but-distinct row object. Must not emit a second event.
+        reconciler.reconcile([{ ...rows[0] }]);
+        expect(events.map((e) => e.type)).toEqual(['upsert']);
+    });
+    it('removes the activity when its row vanishes from the collection', () => {
+        const { shell, reconciler, events } = setup();
+        reconciler.reconcile([
+            { id: 'job-1', title: 'Render intro', state: 'running' },
+            { id: 'job-2', title: 'Render outro', state: 'queued' },
+        ]);
+        expect(shell.listActivities()).toHaveLength(2);
+        // job-1 gone from the next tick → removed; job-2 unchanged → left alone.
+        reconciler.reconcile([
+            { id: 'job-2', title: 'Render outro', state: 'queued' },
+        ]);
+        const remaining = shell.listActivities();
+        expect(remaining).toHaveLength(1);
+        expect(remaining[0].id).toBe('job-2');
+        expect(events.map((e) => e.type)).toEqual([
+            'upsert', // job-1 create
+            'upsert', // job-2 create
+            'remove', // job-1 removed
+        ]);
+    });
+    it('treats a row that maps to null as absent (excluded, then removed when it flips)', () => {
+        const { shell, reconciler } = setup();
+        // A draft row maps to null → never becomes an activity.
+        reconciler.reconcile([
+            { id: 'job-1', title: 'Draft', state: 'queued', draft: true },
+        ]);
+        expect(shell.listActivities()).toHaveLength(0);
+        // It leaves draft → now an activity appears.
+        reconciler.reconcile([
+            { id: 'job-1', title: 'Published', state: 'running' },
+        ]);
+        expect(shell.listActivities()).toHaveLength(1);
+        // It goes back to draft (maps to null again) → activity is removed.
+        reconciler.reconcile([
+            { id: 'job-1', title: 'Published', state: 'running', draft: true },
+        ]);
+        expect(shell.listActivities()).toHaveLength(0);
+    });
+    it('lets the map decouple the activity id from the row id', () => {
+        const shell = createShellState();
+        const reconciler = new ActivityFeedReconciler(shell, (row) => ({
+            id: `activity:${row.id}`,
+            kind: 'render-job',
+            scope: 'system',
+            label: row.title,
+            status: row.state,
+        }));
+        reconciler.reconcile([{ id: 'job-1', title: 'Job', state: 'running' }]);
+        const activities = shell.listActivities();
+        expect(activities).toHaveLength(1);
+        expect(activities[0].id).toBe('activity:job-1');
+    });
+    it('routes an activity to the shell edge for its scope', () => {
+        const { shell, reconciler } = setup();
+        reconciler.reconcile([{ id: 'job-1', title: 'Job', state: 'running' }]);
+        // scope 'focus' homes to the right edge (SCOPE_EDGES.focus === 'right').
+        expect(shell.listActivities({ edge: 'right' })).toHaveLength(1);
+    });
+    it('re-homes the activity to the new edge when its scope changes (no explicit edge)', () => {
+        const shell = createShellState();
+        // Map keys scope off the row so a later tick can change it; no `edge` set.
+        const reconciler = new ActivityFeedReconciler(shell, (row) => ({
+            kind: 'render-job',
+            // Reuse the unused `draft` flag as a cheap "move to system scope" toggle.
+            scope: row.draft ? 'system' : 'focus',
+            label: row.title,
+            status: row.state,
+        }));
+        reconciler.reconcile([{ id: 'job-1', title: 'Job', state: 'running' }]);
+        // Focus → right edge.
+        expect(shell.listActivities({ edge: 'right' })).toHaveLength(1);
+        expect(shell.listActivities({ edge: 'bottom' })).toHaveLength(0);
+        // Scope flips to system; the map still sets no explicit edge. The activity
+        // must RE-DERIVE its edge from the new scope (system → bottom), not stay
+        // pinned to the old right edge.
+        reconciler.reconcile([
+            { id: 'job-1', title: 'Job', state: 'running', draft: true },
+        ]);
+        expect(shell.listActivities({ edge: 'right' })).toHaveLength(0);
+        expect(shell.listActivities({ edge: 'bottom' })).toHaveLength(1);
+        expect(shell.listActivities()[0].scope).toBe('system');
+    });
+    it('clears a previously-set optional field when a later mapping drops it', () => {
+        const shell = createShellState();
+        // Map emits `message`/`detailHref` only while the job is running.
+        const reconciler = new ActivityFeedReconciler(shell, (row) => ({
+            kind: 'render-job',
+            scope: 'focus',
+            label: row.title,
+            status: row.state,
+            ...(row.state === 'running'
+                ? { message: 'Rendering frames', detailHref: '/jobs/job-1' }
+                : {}),
+        }));
+        reconciler.reconcile([{ id: 'job-1', title: 'Job', state: 'running' }]);
+        let activity = shell.listActivities()[0];
+        expect(activity.message).toBe('Rendering frames');
+        expect(activity.detailHref).toBe('/jobs/job-1');
+        // The job completes → the map no longer emits message/detailHref. Those
+        // stale values must be CLEARED, not retained from the previous mapping.
+        reconciler.reconcile([{ id: 'job-1', title: 'Job', state: 'completed' }]);
+        activity = shell.listActivities()[0];
+        expect(activity.status).toBe('completed');
+        expect(activity.message).toBeUndefined();
+        expect(activity.detailHref).toBeUndefined();
+    });
+    it('dispose() removes exactly the feed activities and stops reconciling', () => {
+        const { shell, reconciler, events } = setup();
+        // An activity from ANOTHER source the feed must never touch.
+        shell.upsertActivity({
+            id: 'external-1',
+            label: 'External',
+            kind: 'other',
+            scope: 'app',
+            status: 'running',
+        });
+        reconciler.reconcile([
+            { id: 'job-1', title: 'Render intro', state: 'running' },
+        ]);
+        expect(shell.listActivities()).toHaveLength(2);
+        reconciler.dispose();
+        // Only the feed's own activity was retracted; the external one survives.
+        const remaining = shell.listActivities();
+        expect(remaining).toHaveLength(1);
+        expect(remaining[0].id).toBe('external-1');
+        expect(reconciler.isDisposed).toBe(true);
+        // Reconciling after dispose is a no-op (no new activities, no events).
+        const eventsBefore = events.length;
+        reconciler.reconcile([
+            { id: 'job-2', title: 'Late job', state: 'running' },
+        ]);
+        expect(shell.listActivities()).toHaveLength(1);
+        expect(events.length).toBe(eventsBefore);
+    });
+});

package/dist/web/activity-feed.svelte.d.ts

@@ -0,0 +1,210 @@
+/**
+ * AdminShell activity feed adapter — bridge a `@happyvertical/smrt-web` live
+ * collection into the AdminShell activity registry (#1779, part of the WASD
+ * AdminShell epic #1766).
+ *
+ * This is a thin, OPT-IN CONSUMER of already-shipped infrastructure, not a new
+ * generated surface. It sits at the intersection of two existing contracts:
+ *
+ *  - the runes-reactive {@link liveCollection} view over a `SmrtWebCollection`
+ *    (`@happyvertical/smrt-svelte/web`, slice A of #1761), and
+ *  - the `ShellState` activity registry (`upsertActivity` / `updateActivity` /
+ *    `removeActivity`, from `components/workspace/admin-shell`).
+ *
+ * The app supplies (a) the `@smrt()` DOMAIN collection (a `SmrtWebCollection`)
+ * and (b) an editorial {@link ActivityFeedMap} that turns each row into the
+ * shell-facing activity fields (`kind`, `scope`, `label`, `progress`, …). The
+ * adapter reconciles the mapped rows against the shell as rows appear, change,
+ * and vanish, and returns a disposer that removes the activities it created.
+ *
+ * ── Why it lives behind the `/web` opt-in entry ─────────────────────────────
+ * `liveCollection` pulls the client-data engine (`@tanstack/db` +
+ * `@tanstack/svelte-db`). Keeping this adapter in the `/web` subpath keeps that
+ * engine OUT of the AdminShell core: nothing under `components/workspace/` may
+ * import this module, so `@happyvertical/smrt-svelte/workspace` stays
+ * transport-agnostic and TanStack-free (a hard constraint of #1766). The app
+ * wires the adapter at the edge, next to where it already opts into `/web`.
+ *
+ * ── Engine-absorption boundary ──────────────────────────────────────────────
+ * No `@tanstack/*` type appears here. The adapter reconciles against the plain
+ * DTO rows exposed by {@link liveCollection} (which already strips the engine's
+ * `$`-prefixed virtual props), so the engine stays swappable behind the same
+ * boundary the rest of `/web` respects.
+ *
+ * ── Reconciliation, not change-diffing ──────────────────────────────────────
+ * Rather than decode the engine's change payload, the adapter re-derives the
+ * activity set from the current live rows on every reactive tick (via an
+ * internal `$effect` over `view.rows`) and diffs it against what it last pushed
+ * to the shell. This is robust to the change-notification shape (which is
+ * engine-internal) and mirrors how the runtime's own consumers treat a change
+ * as a "something moved, re-read" signal.
+ */
+import type { SmrtWebCollection, SmrtWebRow } from '@happyvertical/smrt-web';
+import type { ShellState } from '../components/workspace/admin-shell/state.svelte.js';
+import type { ShellActivity } from '../components/workspace/admin-shell/types.js';
+/**
+ * The shell-facing fields an {@link ActivityFeedMap} produces for one row — the
+ * editorial half of a {@link ShellActivity}. The adapter owns the bookkeeping
+ * fields (`id`, `createdAt`, `updatedAt`), so they are omitted here; `id` may be
+ * supplied to decouple the activity id from the row id (it defaults to the row's
+ * `id`). Everything a consumer legitimately controls (`kind`, `scope`, `label`,
+ * `status`, `subject`, `progress`, `detailHref`, `message`, `edge`, `cancel`)
+ * passes straight through.
+ */
+export type ShellActivityInput = Omit<ShellActivity, 'id' | 'createdAt' | 'updatedAt'> & {
+    /**
+     * Explicit activity id. Defaults to the row's `id` when omitted — the common
+     * case (one activity per row). Supply it only to map a row onto a
+     * differently-keyed activity.
+     */
+    id?: string;
+};
+/**
+ * Map one live-collection row to its shell activity fields, or `null` to
+ * exclude the row from the feed.
+ *
+ * Returning `null` is a first-class signal: a row that maps to `null` is NOT an
+ * activity (e.g. a draft the shell should ignore), and a row that STOPS mapping
+ * to an activity — flips from a value to `null` — is removed from the shell,
+ * exactly as if it had vanished from the collection. This lets the editorial map
+ * gate which rows surface without the consumer filtering the collection.
+ *
+ * @typeParam TData - the row DTO shape carried by the collection.
+ */
+export type ActivityFeedMap<TData extends object> = (row: SmrtWebRow<TData>) => ShellActivityInput | null;
+/**
+ * Options for {@link activityFeed}.
+ *
+ * @typeParam TData - the row DTO shape carried by {@link collection}.
+ */
+export interface ActivityFeedOptions<TData extends object> {
+    /**
+     * The domain live collection to bridge — a `SmrtWebCollection` from
+     * `@happyvertical/smrt-web` (e.g. built by the app's `createSmrtCollection`
+     * over its `@smrt()` class). Its rows drive the feed.
+     */
+    collection: SmrtWebCollection<TData>;
+    /**
+     * The editorial mapping from a row to its shell activity fields (or `null` to
+     * exclude the row). See {@link ActivityFeedMap}.
+     */
+    map: ActivityFeedMap<TData>;
+    /** The AdminShell state whose activity registry this feed drives. */
+    shell: ShellState;
+    /**
+     * Forwarded to the underlying {@link liveCollection}: trigger the collection's
+     * first load eagerly when the feed is created. Defaults to `true`.
+     */
+    preload?: boolean;
+}
+/**
+ * A handle to a running {@link activityFeed}. Call {@link dispose} to detach the
+ * feed and remove every activity it created; read {@link isDisposed} to check.
+ */
+export interface ActivityFeedHandle {
+    /**
+     * Detach the feed: remove every activity this feed still owns from the shell
+     * and stop reconciling. Idempotent. The underlying live-query subscription is
+     * torn down by Svelte when the hosting component unmounts (that is where
+     * `activityFeed` must be called); call this to remove the feed's activities
+     * sooner, or when tearing a feed down without unmounting.
+     */
+    dispose(): void;
+    /** True once {@link dispose} has run. */
+    readonly isDisposed: boolean;
+}
+/**
+ * The pure reconciliation core of {@link activityFeed}: it owns the diff between
+ * a set of live rows and the shell's activity registry, with NO Svelte reactive
+ * or client-data-engine dependency. {@link activityFeed} wraps one of these in a
+ * `$effect` over a {@link liveCollection} view; this split keeps the mapping /
+ * create-update-remove / ownership logic testable against a real `ShellState`
+ * with plain row arrays (mock only externals — see the `__tests__`).
+ *
+ * @internal Not part of the public surface — use {@link activityFeed}.
+ * @typeParam TData - the row DTO shape being reconciled.
+ */
+export declare class ActivityFeedReconciler<TData extends object> {
+    private readonly shell;
+    private readonly map;
+    /**
+     * Activities this feed currently owns, keyed by activity id, each with the
+     * last resolved input + fingerprint so a reconcile can tell created / changed
+     * / unchanged apart and remove exactly its own set on teardown.
+     */
+    private readonly owned;
+    private disposed;
+    constructor(shell: ShellState, map: ActivityFeedMap<TData>);
+    /** True once {@link dispose} has run. */
+    get isDisposed(): boolean;
+    /**
+     * Reconcile `rows` against the owned activity set: upsert newly-appearing
+     * activities, update changed ones, remove vanished ones. A pure diff — an
+     * unchanged tick (same rows, same mappings) performs ZERO shell mutations.
+     * No-op once disposed.
+     */
+    reconcile(rows: ReadonlyArray<SmrtWebRow<TData>>): void;
+    /**
+     * Retract exactly this feed's activities from the shell and stop reconciling.
+     * Idempotent. Activities owned by other sources are left untouched.
+     */
+    dispose(): void;
+}
+/**
+ * Bridge a `@happyvertical/smrt-web` live collection into an AdminShell's
+ * activity registry: each mapped row becomes a {@link ShellActivity} that
+ * appears, updates, and disappears in the shell as the collection changes.
+ *
+ * MUST be called during Svelte component initialization — it delegates to
+ * {@link liveCollection} (which installs a `$effect`) and installs its own
+ * reconciliation `$effect`. Both bind to the calling component's lifecycle, so
+ * the live subscription and reconciliation tear down automatically on unmount.
+ * Unmount ALSO auto-retracts the feed's activities from the shell (via an
+ * `$effect` teardown), so they never linger after the host component is gone —
+ * no manual cleanup required. The returned {@link ActivityFeedHandle.dispose}
+ * retracts them SOONER (without unmounting) and is idempotent, so calling it and
+ * then unmounting is safe.
+ *
+ * Lifecycle per row:
+ *  - a row that newly maps to an activity → `shell.upsertActivity(...)` (creates
+ *    it, stamping `createdAt`);
+ *  - an owned row whose mapping changes → `shell.updateActivity(id, patch)`
+ *    (preserves `createdAt`, bumps `updatedAt`, and the shell emits a
+ *    `transition` event when `status` changed — driving toasts);
+ *  - a row that vanishes, or whose mapping flips to `null` →
+ *    `shell.removeActivity(id)`.
+ *
+ * Only activities this feed created are ever touched: activities pushed to the
+ * shell by other sources (or a second feed) are left untouched, and `dispose`
+ * removes exactly this feed's set.
+ *
+ * @typeParam TData - the row DTO shape carried by {@link ActivityFeedOptions.collection}.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { activityFeed } from '@happyvertical/smrt-svelte/web';
+ *   import { useAdminShell } from '@happyvertical/smrt-svelte/workspace';
+ *   import { createSmrtCollection } from '@happyvertical/smrt-web';
+ *   import { getCollectionDefinition } from '@happyvertical/smrt-virt-web';
+ *
+ *   const shell = useAdminShell();
+ *   const encodes = createSmrtCollection(getCollectionDefinition('encodes'), {});
+ *
+ *   // Reconciles `encodes` rows into the shell's Focus scope; disposes on unmount.
+ *   activityFeed({
+ *     collection: encodes,
+ *     shell,
+ *     map: (row) => ({
+ *       kind: 'video-encode',
+ *       scope: 'focus',
+ *       label: row.title,
+ *       status: row.state,          // 'running' | 'completed' | …
+ *       progress: row.progress,
+ *     }),
+ *   });
+ * </script>
+ * ```
+ */
+export declare function activityFeed<TData extends object>(options: ActivityFeedOptions<TData>): ActivityFeedHandle;
+//# sourceMappingURL=activity-feed.svelte.d.ts.map

package/dist/web/activity-feed.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-feed.svelte.d.ts","sourceRoot":"","sources":["../../src/web/activity-feed.svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC7E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qDAAqD,CAAC;AACtF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8CAA8C,CAAC;AAGlF;;;;;;;;GAQG;AACH,MAAM,MAAM,kBAAkB,GAAG,IAAI,CACnC,aAAa,EACb,IAAI,GAAG,WAAW,GAAG,WAAW,CACjC,GAAG;IACF;;;;OAIG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;CACb,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,eAAe,CAAC,KAAK,SAAS,MAAM,IAAI,CAClD,GAAG,EAAE,UAAU,CAAC,KAAK,CAAC,KACnB,kBAAkB,GAAG,IAAI,CAAC;AAE/B;;;;GAIG;AACH,MAAM,WAAW,mBAAmB,CAAC,KAAK,SAAS,MAAM;IACvD;;;;OAIG;IACH,UAAU,EAAE,iBAAiB,CAAC,KAAK,CAAC,CAAC;IACrC;;;OAGG;IACH,GAAG,EAAE,eAAe,CAAC,KAAK,CAAC,CAAC;IAC5B,qEAAqE;IACrE,KAAK,EAAE,UAAU,CAAC;IAClB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;;OAMG;IACH,OAAO,IAAI,IAAI,CAAC;IAChB,yCAAyC;IACzC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC9B;AA+GD;;;;;;;;;;GAUG;AACH,qBAAa,sBAAsB,CAAC,KAAK,SAAS,MAAM;IAUpD,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAVtB;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoC;IAC1D,OAAO,CAAC,QAAQ,CAAS;gBAGN,KAAK,EAAE,UAAU,EACjB,GAAG,EAAE,eAAe,CAAC,KAAK,CAAC;IAG9C,yCAAyC;IACzC,IAAI,UAAU,IAAI,OAAO,CAExB;IAED;;;;;OAKG;IACH,SAAS,CAAC,IAAI,EAAE,aAAa,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI;IA+CvD;;;OAGG;IACH,OAAO,IAAI,IAAI;CAMhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,YAAY,CAAC,KAAK,SAAS,MAAM,EAC/C,OAAO,EAAE,mBAAmB,CAAC,KAAK,CAAC,GAClC,kBAAkB,CAyCpB"}

package/dist/web/activity-feed.svelte.js

@@ -0,0 +1,302 @@
+/**
+ * AdminShell activity feed adapter — bridge a `@happyvertical/smrt-web` live
+ * collection into the AdminShell activity registry (#1779, part of the WASD
+ * AdminShell epic #1766).
+ *
+ * This is a thin, OPT-IN CONSUMER of already-shipped infrastructure, not a new
+ * generated surface. It sits at the intersection of two existing contracts:
+ *
+ *  - the runes-reactive {@link liveCollection} view over a `SmrtWebCollection`
+ *    (`@happyvertical/smrt-svelte/web`, slice A of #1761), and
+ *  - the `ShellState` activity registry (`upsertActivity` / `updateActivity` /
+ *    `removeActivity`, from `components/workspace/admin-shell`).
+ *
+ * The app supplies (a) the `@smrt()` DOMAIN collection (a `SmrtWebCollection`)
+ * and (b) an editorial {@link ActivityFeedMap} that turns each row into the
+ * shell-facing activity fields (`kind`, `scope`, `label`, `progress`, …). The
+ * adapter reconciles the mapped rows against the shell as rows appear, change,
+ * and vanish, and returns a disposer that removes the activities it created.
+ *
+ * ── Why it lives behind the `/web` opt-in entry ─────────────────────────────
+ * `liveCollection` pulls the client-data engine (`@tanstack/db` +
+ * `@tanstack/svelte-db`). Keeping this adapter in the `/web` subpath keeps that
+ * engine OUT of the AdminShell core: nothing under `components/workspace/` may
+ * import this module, so `@happyvertical/smrt-svelte/workspace` stays
+ * transport-agnostic and TanStack-free (a hard constraint of #1766). The app
+ * wires the adapter at the edge, next to where it already opts into `/web`.
+ *
+ * ── Engine-absorption boundary ──────────────────────────────────────────────
+ * No `@tanstack/*` type appears here. The adapter reconciles against the plain
+ * DTO rows exposed by {@link liveCollection} (which already strips the engine's
+ * `$`-prefixed virtual props), so the engine stays swappable behind the same
+ * boundary the rest of `/web` respects.
+ *
+ * ── Reconciliation, not change-diffing ──────────────────────────────────────
+ * Rather than decode the engine's change payload, the adapter re-derives the
+ * activity set from the current live rows on every reactive tick (via an
+ * internal `$effect` over `view.rows`) and diffs it against what it last pushed
+ * to the shell. This is robust to the change-notification shape (which is
+ * engine-internal) and mirrors how the runtime's own consumers treat a change
+ * as a "something moved, re-read" signal.
+ */
+import { liveCollection } from './live-collection.svelte.js';
+/**
+ * Compute the change-detection fingerprint for a resolved activity input. The
+ * signature is a JSON projection of the shell-relevant fields in a FIXED key
+ * order (so key ordering in the mapper output never registers as a change); the
+ * non-serializable `cancel` is carried alongside for identity comparison.
+ */
+function fingerprintOf(input) {
+    const signature = JSON.stringify([
+        input.id,
+        input.label,
+        input.kind,
+        input.scope,
+        input.status,
+        input.progress ?? null,
+        input.message ?? null,
+        input.detailHref ?? null,
+        input.edge ?? null,
+        input.subject
+            ? [input.subject.type, input.subject.id, input.subject.label ?? null]
+            : null,
+    ]);
+    return { signature, cancel: input.cancel };
+}
+/** Two fingerprints are equal when their signatures AND `cancel` identity match. */
+function fingerprintsEqual(a, b) {
+    return a.signature === b.signature && a.cancel === b.cancel;
+}
+/**
+ * Resolve a mapped input to a fully-keyed activity input, defaulting the
+ * activity `id` to the row `id`. Returns `null` when the row has neither a
+ * mapped `id` nor a usable row `id` (it cannot be tracked, so it is dropped
+ * rather than pushed to the shell under an unstable key).
+ */
+function resolveInput(row, mapped) {
+    const id = mapped.id ?? row.id;
+    if (typeof id !== 'string' || id.length === 0)
+        return null;
+    return { ...mapped, id };
+}
+/**
+ * Build the update patch for a re-mapped activity so it REPLACES the mapped
+ * field set rather than merging over it.
+ *
+ * `ShellState.updateActivity(id, patch)` merges `{ ...current, ...patch }`, so a
+ * key the new mapping OMITS would otherwise retain its stale prior value. To
+ * keep the shell activity an exact mirror of the current mapping, every field a
+ * map controls is listed EXPLICITLY here — an omitted optional field is carried
+ * as `undefined`, which overwrites the stale value on merge. Two consequences:
+ *
+ *  - Dropped optionals (`message`, `detailHref`, `subject`, `progress`, `cancel`)
+ *    are cleared, not kept (codex P2).
+ *  - `edge` is passed through as the mapping left it — `undefined` when the map
+ *    did not pin an edge — so when a row's `scope` changes without an explicit
+ *    `edge`, the merged activity carries `edge: undefined` and `upsertActivity`
+ *    RE-DERIVES the edge from the new scope (`edge ?? homeEdgeForScope(scope)`),
+ *    re-homing it instead of pinning it to the previous scope's edge (copilot).
+ *
+ * `id` is deliberately excluded (it is the update key, not a patched field).
+ */
+function toUpdatePatch(input) {
+    return {
+        label: input.label,
+        kind: input.kind,
+        scope: input.scope,
+        status: input.status,
+        subject: input.subject,
+        edge: input.edge,
+        progress: input.progress,
+        detailHref: input.detailHref,
+        message: input.message,
+        cancel: input.cancel,
+    };
+}
+/**
+ * The pure reconciliation core of {@link activityFeed}: it owns the diff between
+ * a set of live rows and the shell's activity registry, with NO Svelte reactive
+ * or client-data-engine dependency. {@link activityFeed} wraps one of these in a
+ * `$effect` over a {@link liveCollection} view; this split keeps the mapping /
+ * create-update-remove / ownership logic testable against a real `ShellState`
+ * with plain row arrays (mock only externals — see the `__tests__`).
+ *
+ * @internal Not part of the public surface — use {@link activityFeed}.
+ * @typeParam TData - the row DTO shape being reconciled.
+ */
+export class ActivityFeedReconciler {
+    shell;
+    map;
+    /**
+     * Activities this feed currently owns, keyed by activity id, each with the
+     * last resolved input + fingerprint so a reconcile can tell created / changed
+     * / unchanged apart and remove exactly its own set on teardown.
+     */
+    owned = new Map();
+    disposed = false;
+    constructor(shell, map) {
+        this.shell = shell;
+        this.map = map;
+    }
+    /** True once {@link dispose} has run. */
+    get isDisposed() {
+        return this.disposed;
+    }
+    /**
+     * Reconcile `rows` against the owned activity set: upsert newly-appearing
+     * activities, update changed ones, remove vanished ones. A pure diff — an
+     * unchanged tick (same rows, same mappings) performs ZERO shell mutations.
+     * No-op once disposed.
+     */
+    reconcile(rows) {
+        if (this.disposed)
+            return;
+        // Resolve this tick's activities from the rows. A row mapping to `null`, or
+        // resolving to no usable id, is simply absent from `next` — which makes the
+        // removal pass below retract it if the feed owned it last tick.
+        const next = new Map();
+        for (const row of rows) {
+            const mapped = this.map(row);
+            if (mapped === null)
+                continue;
+            const input = resolveInput(row, mapped);
+            if (input === null)
+                continue;
+            // Last write wins if two rows resolve to the same activity id — matches
+            // the shell's own upsert-by-id semantics.
+            next.set(input.id, { input, fingerprint: fingerprintOf(input) });
+        }
+        // Removals: ids the feed owned last tick but that are gone now.
+        for (const id of this.owned.keys()) {
+            if (!next.has(id)) {
+                this.shell.removeActivity(id);
+                this.owned.delete(id);
+            }
+        }
+        // Creates + updates.
+        for (const [id, entry] of next) {
+            const prior = this.owned.get(id);
+            if (!prior) {
+                // First appearance: create it (stamps createdAt/updatedAt in the shell).
+                this.shell.upsertActivity({ ...entry.input });
+                this.owned.set(id, entry);
+                continue;
+            }
+            if (!fingerprintsEqual(prior.fingerprint, entry.fingerprint)) {
+                // Changed: patch it, preserving createdAt and letting the shell emit a
+                // `transition` when the status changed. The patch lists every mappable
+                // field explicitly (see `toUpdatePatch`) so it REPLACES the mapped set
+                // rather than merging over it — dropped optionals are cleared and a
+                // changed `scope` re-derives the `edge` instead of pinning the old one.
+                this.shell.updateActivity(id, toUpdatePatch(entry.input));
+                this.owned.set(id, entry);
+            }
+            // Unchanged: no shell mutation.
+        }
+    }
+    /**
+     * Retract exactly this feed's activities from the shell and stop reconciling.
+     * Idempotent. Activities owned by other sources are left untouched.
+     */
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        for (const id of this.owned.keys())
+            this.shell.removeActivity(id);
+        this.owned.clear();
+    }
+}
+/**
+ * Bridge a `@happyvertical/smrt-web` live collection into an AdminShell's
+ * activity registry: each mapped row becomes a {@link ShellActivity} that
+ * appears, updates, and disappears in the shell as the collection changes.
+ *
+ * MUST be called during Svelte component initialization — it delegates to
+ * {@link liveCollection} (which installs a `$effect`) and installs its own
+ * reconciliation `$effect`. Both bind to the calling component's lifecycle, so
+ * the live subscription and reconciliation tear down automatically on unmount.
+ * Unmount ALSO auto-retracts the feed's activities from the shell (via an
+ * `$effect` teardown), so they never linger after the host component is gone —
+ * no manual cleanup required. The returned {@link ActivityFeedHandle.dispose}
+ * retracts them SOONER (without unmounting) and is idempotent, so calling it and
+ * then unmounting is safe.
+ *
+ * Lifecycle per row:
+ *  - a row that newly maps to an activity → `shell.upsertActivity(...)` (creates
+ *    it, stamping `createdAt`);
+ *  - an owned row whose mapping changes → `shell.updateActivity(id, patch)`
+ *    (preserves `createdAt`, bumps `updatedAt`, and the shell emits a
+ *    `transition` event when `status` changed — driving toasts);
+ *  - a row that vanishes, or whose mapping flips to `null` →
+ *    `shell.removeActivity(id)`.
+ *
+ * Only activities this feed created are ever touched: activities pushed to the
+ * shell by other sources (or a second feed) are left untouched, and `dispose`
+ * removes exactly this feed's set.
+ *
+ * @typeParam TData - the row DTO shape carried by {@link ActivityFeedOptions.collection}.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { activityFeed } from '@happyvertical/smrt-svelte/web';
+ *   import { useAdminShell } from '@happyvertical/smrt-svelte/workspace';
+ *   import { createSmrtCollection } from '@happyvertical/smrt-web';
+ *   import { getCollectionDefinition } from '@happyvertical/smrt-virt-web';
+ *
+ *   const shell = useAdminShell();
+ *   const encodes = createSmrtCollection(getCollectionDefinition('encodes'), {});
+ *
+ *   // Reconciles `encodes` rows into the shell's Focus scope; disposes on unmount.
+ *   activityFeed({
+ *     collection: encodes,
+ *     shell,
+ *     map: (row) => ({
+ *       kind: 'video-encode',
+ *       scope: 'focus',
+ *       label: row.title,
+ *       status: row.state,          // 'running' | 'completed' | …
+ *       progress: row.progress,
+ *     }),
+ *   });
+ * </script>
+ * ```
+ */
+export function activityFeed(options) {
+    const { collection, map, shell, preload = true } = options;
+    // Build the runes-reactive live view over the domain collection. This is the
+    // sole place the client-data engine is reached (through the `/web` binding),
+    // and it MUST run during component init — as must `activityFeed` itself.
+    const view = liveCollection(collection, { preload });
+    // The pure diff core: holds ownership + create/update/remove logic, with no
+    // reactive or engine dependency (unit-tested directly). This function just
+    // feeds it the live rows on every reactive tick.
+    const reconciler = new ActivityFeedReconciler(shell, map);
+    // Reconcile whenever the live rows change. `view.rows` is a `$derived`-backed
+    // reactive array; reading it inside `$effect` subscribes this effect to it, so
+    // every insert/update/delete/rollback surfaced by the live view re-reconciles.
+    // The effect binds to the hosting component and tears down on unmount.
+    $effect(() => {
+        reconciler.reconcile(view.rows);
+    });
+    // Auto-cleanup on unmount: retract this feed's activities from the shell when
+    // the hosting component is destroyed, so they never linger after the UI that
+    // created them is gone. This effect reads NO reactive state, so it never
+    // re-runs — its teardown fires only when the effect is destroyed (component
+    // unmount / `$effect.root` teardown), exactly the unmount hook we want. The
+    // returned `dispose()` stays available for callers that want to retract the
+    // feed's activities sooner (without unmounting); `dispose` is idempotent, so
+    // an explicit call followed by the unmount teardown is safe.
+    $effect(() => {
+        return () => reconciler.dispose();
+    });
+    return {
+        dispose() {
+            reconciler.dispose();
+        },
+        get isDisposed() {
+            return reconciler.isDisposed;
+        },
+    };
+}

package/dist/web/index.d.ts

@@ -7,7 +7,13 @@
  * stays an implementation detail of the runtime + this binding; nothing here
  * re-exports an `@tanstack/*` type.
  *
+ * The {@link activityFeed} adapter (#1779) is layered on {@link liveCollection}
+ * to bridge a live collection into the AdminShell activity registry. It lives
+ * behind this opt-in `/web` entry — NOT under `components/workspace/` — so the
+ * AdminShell core stays transport-agnostic and TanStack-free (epic #1766).
+ *
  * @packageDocumentation
  */
+export { type ActivityFeedHandle, type ActivityFeedMap, type ActivityFeedOptions, activityFeed, type ShellActivityInput, } from './activity-feed.svelte.js';
 export { type LiveCollection, type LiveCollectionMutation, type LiveCollectionOptions, type LiveCollectionStatus, liveCollection, } from './live-collection.svelte.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/web/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/web/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,cAAc,GACf,MAAM,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/web/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,YAAY,EACZ,KAAK,kBAAkB,GACxB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,cAAc,GACf,MAAM,6BAA6B,CAAC"}

package/dist/web/index.js

@@ -7,6 +7,12 @@
  * stays an implementation detail of the runtime + this binding; nothing here
  * re-exports an `@tanstack/*` type.
  *
+ * The {@link activityFeed} adapter (#1779) is layered on {@link liveCollection}
+ * to bridge a live collection into the AdminShell activity registry. It lives
+ * behind this opt-in `/web` entry — NOT under `components/workspace/` — so the
+ * AdminShell core stays transport-agnostic and TanStack-free (epic #1766).
+ *
  * @packageDocumentation
  */
+export { activityFeed, } from './activity-feed.svelte.js';
 export { liveCollection, } from './live-collection.svelte.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happyvertical/smrt-svelte",
-  "version": "0.38.2",
+  "version": "0.38.3",
   "description": "Svelte 5 components for SMRT user management - auth, users, tenants, roles, permissions, groups",
   "type": "module",
   "smrtRawPrimitives": "strict",
@@ -88,14 +88,14 @@
     "access": "public"
   },
   "dependencies": {
-    "@happyvertical/logger": "^0.74.11",
+    "@happyvertical/logger": "^0.76.2",
     "@tanstack/db": "^0.6.14",
     "@tanstack/svelte-db": "^0.1.91",
     "esm-env": "^1.2.2",
-    "@happyvertical/smrt-types": "0.38.2",
-    "@happyvertical/smrt-ui": "0.38.2",
-    "@happyvertical/smrt-web": "0.38.2",
-    "@happyvertical/smrt-languages": "0.38.2"
+    "@happyvertical/smrt-languages": "0.38.3",
+    "@happyvertical/smrt-types": "0.38.3",
+    "@happyvertical/smrt-ui": "0.38.3",
+    "@happyvertical/smrt-web": "0.38.3"
   },
   "peerDependencies": {
     "@huggingface/transformers": ">=3.8.1",
@@ -133,7 +133,7 @@
     "svelte": "^5.56.4",
     "svelte-check": "^4.7.1",
     "typescript": "^5.9.3",
-    "vite": "^8.1.2",
+    "vite": "^8.1.3",
     "vitest": "^4.1.9"
   },
   "scripts": {