@memberjunction/server 6.2.0-edge.3 → 6.2.0-edge.5

package/src/__tests__/TaskGraphContinuationDeliverer.test.ts

@@ -9,11 +9,28 @@
  * compare-and-swap that marks a completion delivered; an escaping error would either abort that
  * guard or leave the graph looking undelivered and re-notifying on every later sweep.
  */
+import 'reflect-metadata';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
+const { fromMetadataProvider, runAgent, processAgentArtifacts } = vi.hoisted(() => ({
+    fromMetadataProvider: vi.fn(),
+    runAgent: vi.fn(),
+    processAgentArtifacts: vi.fn(),
+}));
+
 vi.mock('@memberjunction/core', () => ({
     LogError: vi.fn(),
     LogStatus: vi.fn(),
+    RunView: {
+        FromMetadataProvider: fromMetadataProvider,
+    },
+}));
+
+vi.mock('@memberjunction/generic-database-provider', () => ({
+    UserCache: {
+        Instance: { Users: [{ ID: 'owner-user-99', Email: 'owner@example.com' }] },
+        Users: [{ ID: 'owner-user-99', Email: 'owner@example.com' }],
+    },
 }));
 
 vi.mock('@memberjunction/core-entities', () => ({
@@ -24,21 +41,27 @@ vi.mock('@memberjunction/core-entities', () => ({
 vi.mock('@memberjunction/ai-core-plus', () => ({ MJAIAgentEntityExtended: class {} }));
 vi.mock('@memberjunction/ai', () => ({ ChatMessageRole: { user: 'user' } }));
 
-const runAgent = vi.fn().mockResolvedValue({ success: true });
 vi.mock('@memberjunction/ai-agents', () => ({
-    AgentRunner: class { RunAgent = runAgent; },
+    AgentRunner: class {
+        RunAgent = runAgent;
+        ProcessAgentArtifacts = processAgentArtifacts;
+    },
 }));
 
 import { TaskGraphContinuationDeliverer } from '../services/TaskGraphContinuationDeliverer';
 import type { TaskContinuationParams } from '@memberjunction/task-graph';
 import type { UserInfo } from '@memberjunction/core';
+import type { PubSubEngine } from 'type-graphql';
 
 /** A conversation-detail row that can be loaded (the source) and saved (the reply). */
-function detailRow(over: Partial<{ loads: boolean; saves: boolean; conversationID: string }> = {}) {
-    const { loads = true, saves = true, conversationID = 'conv-1' } = over;
+function detailRow(over: Partial<{ loads: boolean; saves: boolean; conversationID: string; branchID: string | null }> = {}) {
+    const { loads = true, saves = true, conversationID = 'conv-1', branchID = null } = over;
     return {
+        ID: 'reply-detail-1',
         ConversationID: conversationID,
+        BranchID: branchID as string | null,
         Role: '', Status: '', HiddenToUser: true, Message: '',
+        AgentID: null as string | null,
         NewRecord: vi.fn(),
         Load: vi.fn().mockResolvedValue(loads),
         Save: vi.fn().mockResolvedValue(saves),
@@ -51,17 +74,21 @@ function harness(over: Parameters<typeof detailRow>[0] = {}) {
     const provider = {
         GetEntityObject: vi.fn().mockImplementation(async () => {
             const row = detailRow(over);
+            if (rows.length > 0) {
+                row.BranchID = 'stale';
+            }
             rows.push(row);
             return row;
         }),
     };
     const providerFactory = { CreateProvider: vi.fn().mockResolvedValue(provider) };
+    const pubSub = { publish: vi.fn().mockResolvedValue(undefined) } as unknown as PubSubEngine;
     const deliverer = new TaskGraphContinuationDeliverer(
         providerFactory as never,
         { ID: 'user-1' } as UserInfo,
+        pubSub,
     );
-    // First row is the source detail (Load), second is the reply (Save).
-    return { deliverer, providerFactory, provider, rows, reply: () => rows[1] };
+    return { deliverer, providerFactory, provider, rows, pubSub, reply: () => rows[1] };
 }
 
 const params = (over: Partial<TaskContinuationParams> = {}): TaskContinuationParams => ({
@@ -78,10 +105,21 @@ const params = (over: Partial<TaskContinuationParams> = {}): TaskContinuationPar
     ...over,
 });
 
-beforeEach(() => vi.clearAllMocks());
+beforeEach(() => {
+    vi.clearAllMocks();
+    fromMetadataProvider.mockReturnValue({
+        RunView: vi.fn().mockResolvedValue({ Success: false, Results: [] }),
+    });
+    runAgent.mockResolvedValue({
+        success: true,
+        payload: 'Synthesized workflow outcome',
+        agentRun: { ID: 'cont-run-1', Message: 'Synthesized workflow outcome' },
+    });
+    processAgentArtifacts.mockResolvedValue(undefined);
+});
 
 describe('posting the outcome', () => {
-    it('writes an AI-role message into the graph\'s conversation', async () => {
+    it('writes an AI-role message into the graph\'s conversation and broadcasts completion via pubSub', async () => {
         const h = harness();
         await h.deliverer.PostMessage(params());
 
@@ -91,6 +129,7 @@ describe('posting the outcome', () => {
         expect(reply.Role).toBe('AI');
         expect(reply.Status).toBe('Complete');
         expect(reply.HiddenToUser).toBe(false);
+        expect(h.pubSub.publish).toHaveBeenCalledTimes(2);
     });
 
     it('names the workflow and carries the roll-up', async () => {
@@ -101,8 +140,6 @@ describe('posting the outcome', () => {
     });
 
     it('lists each step, not just an aggregate status', async () => {
-        // A graph where nine of ten steps succeeded is a materially different message from one that
-        // failed outright, and the roll-up alone cannot say which step went wrong.
         const h = harness();
         await h.deliverer.PostMessage(params({
             Tasks: [
@@ -125,13 +162,22 @@ describe('posting the outcome', () => {
         const message = h.reply().Message;
         expect(message).toContain('Step 0');
         expect(message).not.toContain('Step 49');
-        // The count is stated rather than silently dropped — the task rows remain the full record.
         expect(message).toContain('30 more');
     });
 
+    it('posts into the fork of the message that started the graph', async () => {
+        const h = harness({ branchID: 'T1' });
+        await h.deliverer.PostMessage(params());
+        expect(h.reply().BranchID).toBe('T1');
+    });
+
+    it('posts into Main when that message is in Main', async () => {
+        const h = harness();
+        await h.deliverer.PostMessage(params());
+        expect(h.reply().BranchID).toBeNull();
+    });
+
     it('mints a fresh provider per delivery', async () => {
-        // Deliveries run outside any request and concurrently with task execution; a shared provider
-        // would share one transaction scope across unrelated work.
         const h = harness();
         await h.deliverer.PostMessage(params());
         expect(h.providerFactory.CreateProvider).toHaveBeenCalledTimes(1);
@@ -140,8 +186,6 @@ describe('posting the outcome', () => {
 
 describe('it never throws — the dispatcher marks delivery inside a CAS guard', () => {
     it('does nothing for a headless graph, without treating it as an error', async () => {
-        // A graph submitted by a schedule, an entity-change trigger or an API call has no
-        // conversation to answer. Most workflows are in this shape.
         const h = harness();
         await expect(h.deliverer.PostMessage(params({ ConversationDetailID: null }))).resolves.toBeUndefined();
         expect(h.providerFactory.CreateProvider).not.toHaveBeenCalled();
@@ -150,7 +194,7 @@ describe('it never throws — the dispatcher marks delivery inside a CAS guard',
     it('survives a conversation detail that will not load', async () => {
         const h = harness({ loads: false });
         await expect(h.deliverer.PostMessage(params())).resolves.toBeUndefined();
-        expect(h.rows.length).toBe(1); // never got as far as building a reply
+        expect(h.rows.length).toBe(1);
     });
 
     it('survives a failed save', async () => {
@@ -168,7 +212,6 @@ describe('it never throws — the dispatcher marks delivery inside a CAS guard',
 });
 
 describe('Reinvoke — restarting the submitting agent', () => {
-    /** A provider that hands out loadable agent-run and agent rows, then the reply detail. */
     function reinvokeHarness(over: { runLoads?: boolean; agentLoads?: boolean } = {}) {
         const { runLoads = true, agentLoads = true } = over;
         const rows: Array<Record<string, unknown>> = [];
@@ -191,14 +234,16 @@ describe('Reinvoke — restarting the submitting agent', () => {
                 return detail;
             }),
         };
+        const pubSub = { publish: vi.fn().mockResolvedValue(undefined) } as unknown as PubSubEngine;
         const deliverer = new TaskGraphContinuationDeliverer(
             { CreateProvider: vi.fn().mockResolvedValue(provider) } as never,
             { ID: 'user-1' } as UserInfo,
+            pubSub,
         );
-        return { deliverer, provider, rows };
+        return { deliverer, provider, rows, pubSub };
     }
 
-    it('starts the submitting agent a fresh turn carrying the outcome', async () => {
+    it('starts the submitting agent a fresh turn carrying the outcome, saves reply detail, processes artifacts, and publishes completion', async () => {
         const h = reinvokeHarness();
         await h.deliverer.Reinvoke(params());
 
@@ -206,11 +251,17 @@ describe('Reinvoke — restarting the submitting agent', () => {
         const call = runAgent.mock.calls[0][0];
         expect(call.agent.ID).toBe('agent-1');
         expect(call.conversationMessages[0].content).toContain('Weekly digest');
+        expect(call.conversationDetailId).toBe('reply-detail-1');
+
+        const reply = h.rows[3] as ReturnType<typeof detailRow>;
+        expect(reply.Role).toBe('AI');
+        expect(reply.Status).toBe('Complete');
+        expect(reply.Message).toBe('Synthesized workflow outcome');
+        expect(processAgentArtifacts).toHaveBeenCalledTimes(1);
+        expect(h.pubSub.publish).toHaveBeenCalledTimes(2);
     });
 
     it('stamps depth + 1 — the value that makes MAX_REINVOKE_DEPTH real', async () => {
-        // Without this the next graph the restarted run submits begins the chain at zero again, and
-        // the cap can never fire. It is the whole reason ContinuationDepth exists as a column.
         const h = reinvokeHarness();
         await h.deliverer.Reinvoke(params({ ReinvokeDepth: 3 }));
         expect(runAgent.mock.calls[0][0].continuationDepth).toBe(4);
@@ -223,7 +274,6 @@ describe('Reinvoke — restarting the submitting agent', () => {
     });
 
     it('falls back to posting when the graph records no submitting run', async () => {
-        // A schedule- or trigger-started graph has no turn to continue.
         const h = reinvokeHarness();
         await h.deliverer.Reinvoke(params({ SubmittedByAgentRunID: null }));
         expect(runAgent).not.toHaveBeenCalled();
@@ -247,3 +297,334 @@ describe('Reinvoke — restarting the submitting agent', () => {
         await expect(h.deliverer.Reinvoke(params())).resolves.toBeUndefined();
     });
 });
+
+describe('Reinvoke — on the fork of the message that started the graph', () => {
+    function forkHarness(originBranch: string | null) {
+        const provider = {
+            GetEntityObject: vi.fn().mockImplementation(async (name: string) => {
+                if (name === 'MJ: AI Agent Runs') return { AgentID: 'agent-1', Load: vi.fn().mockResolvedValue(true) };
+                if (name === 'MJ: AI Agents') return { ID: 'agent-1', Load: vi.fn().mockResolvedValue(true) };
+                return detailRow({ branchID: originBranch });
+            }),
+        };
+        return new TaskGraphContinuationDeliverer(
+            { CreateProvider: vi.fn().mockResolvedValue(provider) } as never,
+            { ID: 'user-1' } as UserInfo,
+        );
+    }
+
+    it('runs the reinvoked agent on that fork, as PostMessage posts into it', async () => {
+        await forkHarness('T1').Reinvoke(params());
+
+        expect(runAgent).toHaveBeenCalledTimes(1);
+        expect(runAgent.mock.calls[0][0].ConversationBranchID).toBe('T1');
+    });
+
+    it('leaves the branch unset when that message is in Main', async () => {
+        await forkHarness(null).Reinvoke(params());
+
+        expect(runAgent).toHaveBeenCalledTimes(1);
+        expect(runAgent.mock.calls[0][0].ConversationBranchID).toBeUndefined();
+    });
+
+    it('enriches placeholder "output available (...)" task summaries with OutputPayload excerpts from MJ: Tasks', async () => {
+        const { RunView } = await import('@memberjunction/core');
+        vi.mocked(RunView.FromMetadataProvider).mockReturnValue({
+            RunView: vi.fn().mockImplementation(async (rvParams: { EntityName: string }) => {
+                if (rvParams.EntityName === 'MJ: Tasks') {
+                    return {
+                        Success: true,
+                        Results: [
+                            {
+                                ID: 't1',
+                                Name: 'Generate Schema Count Query',
+                                OutputPayload: JSON.stringify({
+                                    title: 'Entity Counts by Schema',
+                                    request: 'SELECT SchemaName, COUNT(*) AS EntityCount FROM __mj.vwEntities GROUP BY SchemaName',
+                                }),
+                            },
+                        ],
+                    };
+                }
+                return { Success: false, Results: [] };
+            }),
+        } as never);
+
+        await forkHarness(null).Reinvoke(
+            params({
+                Tasks: [
+                    { TaskID: 't1', Name: 'Generate Schema Count Query', Status: 'Complete', Summary: 'output available (180 chars)' },
+                ],
+            }),
+        );
+
+        expect(runAgent).toHaveBeenCalledTimes(1);
+        const sentContent = runAgent.mock.calls[0][0].conversationMessages[0].content as string;
+        expect(sentContent).toContain('Title: Entity Counts by Schema');
+        expect(sentContent).toContain('SELECT SchemaName, COUNT(*) AS EntityCount FROM __mj.vwEntities GROUP BY SchemaName');
+    });
+
+    it('updates the originating message in-place when no intervening messages were sent (IsLatest = true)', async () => {
+        const { RunView } = await import('@memberjunction/core');
+        vi.mocked(RunView.FromMetadataProvider).mockReturnValue({
+            RunView: vi.fn().mockImplementation(async (rvParams: { EntityName: string }) => {
+                if (rvParams.EntityName === 'MJ: Conversation Details') {
+                    return {
+                        Success: true,
+                        Results: [{ ID: 'detail-1' }],
+                    };
+                }
+                return { Success: false, Results: [] };
+            }),
+        } as never);
+
+        const originDetail = {
+            ...detailRow(),
+            ID: 'detail-1',
+            Message: "Started **Weekly digest** — 2 task(s) running. I'll follow up when it finishes.",
+        };
+        const createdDetails: Array<ReturnType<typeof detailRow>> = [];
+        const provider = {
+            GetEntityObject: vi.fn().mockImplementation(async (name: string) => {
+                if (name === 'MJ: AI Agent Runs') return { AgentID: 'agent-1', Load: vi.fn().mockResolvedValue(true) };
+                if (name === 'MJ: AI Agents') return { ID: 'agent-1', Load: vi.fn().mockResolvedValue(true) };
+                if (createdDetails.length === 0) {
+                    createdDetails.push(originDetail);
+                    return originDetail;
+                }
+                const next = detailRow();
+                createdDetails.push(next);
+                return next;
+            }),
+        };
+        const pubSub = { publish: vi.fn().mockResolvedValue(undefined) } as unknown as PubSubEngine;
+        const deliverer = new TaskGraphContinuationDeliverer(
+            { CreateProvider: vi.fn().mockResolvedValue(provider) } as never,
+            { ID: 'user-1' } as UserInfo,
+            pubSub,
+        );
+
+        await deliverer.Reinvoke(params());
+
+        // Only the originating detail was loaded and updated in-place — no second detail row created!
+        expect(createdDetails.length).toBe(1);
+        expect(originDetail.NewRecord).not.toHaveBeenCalled();
+        expect(originDetail.Message).toBe('Synthesized workflow outcome');
+        expect(originDetail.Status).toBe('Complete');
+        expect(runAgent.mock.calls[0][0].conversationDetailId).toBe('detail-1');
+        expect(runAgent.mock.calls[0][0].inputArtifacts).toEqual([]);
+        expect(pubSub.publish).toHaveBeenCalledTimes(1);
+    });
+
+    it('creates a bottom continuation reply with ParentID = originDetailId and updates the origin message note when intervening messages exist (IsLatest = false)', async () => {
+        const { RunView } = await import('@memberjunction/core');
+        vi.mocked(RunView.FromMetadataProvider).mockReturnValue({
+            RunView: vi.fn().mockImplementation(async (rvParams: { EntityName: string }) => {
+                if (rvParams.EntityName === 'MJ: Conversation Details') {
+                    return {
+                        Success: true,
+                        Results: [{ ID: 'intervening-user-msg-2' }],
+                    };
+                }
+                return { Success: false, Results: [] };
+            }),
+        } as never);
+
+        const originDetail = {
+            ...detailRow(),
+            ID: 'detail-1',
+            ParentID: null as string | null,
+            Message: "Started **Weekly digest** — 2 task(s) running. I'll follow up when it finishes.",
+        };
+        const replyDetail = {
+            ...detailRow(),
+            ID: 'bottom-reply-3',
+            ParentID: null as string | null,
+        };
+        let detailCallCount = 0;
+        const provider = {
+            GetEntityObject: vi.fn().mockImplementation(async (name: string) => {
+                if (name === 'MJ: AI Agent Runs') return { AgentID: 'agent-1', Load: vi.fn().mockResolvedValue(true) };
+                if (name === 'MJ: AI Agents') return { ID: 'agent-1', Load: vi.fn().mockResolvedValue(true) };
+                detailCallCount++;
+                return detailCallCount === 1 ? originDetail : replyDetail;
+            }),
+        };
+        const pubSub = { publish: vi.fn().mockResolvedValue(undefined) } as unknown as PubSubEngine;
+        const deliverer = new TaskGraphContinuationDeliverer(
+            { CreateProvider: vi.fn().mockResolvedValue(provider) } as never,
+            { ID: 'user-1' } as UserInfo,
+            pubSub,
+        );
+
+        await deliverer.Reinvoke(params());
+
+        expect(replyDetail.NewRecord).toHaveBeenCalledTimes(1);
+        expect(replyDetail.ParentID).toBe('detail-1');
+        expect(replyDetail.Message).toBe('Synthesized workflow outcome');
+        expect(originDetail.Message).toContain('*(✅ **Weekly digest** completed — synthesized results posted below.)*');
+        expect(originDetail.Message).not.toContain("I'll follow up when it finishes");
+        expect(pubSub.publish).toHaveBeenCalledTimes(2);
+    });
+
+    it('strips inherited upstream payload keys across DAG steps and extracts nested synthesis and report fields', async () => {
+        const { RunView } = await import('@memberjunction/core');
+        const step1Payload = {
+            queryName: 'Annual Order Counts',
+            sql: 'SELECT YEAR(OrderDate) AS OrderYear, COUNT(*) AS OrderCount FROM Orders GROUP BY YEAR(OrderDate)',
+            explanation: 'Counts orders grouped by year.',
+        };
+        const step2Payload = {
+            ...step1Payload,
+            synthesis: {
+                executiveSummary: 'Order volume grew 22% YoY between 2022 and 2025.',
+                keyFindings: ['2024 peak growth', 'Steady enterprise retention'],
+            },
+        };
+        const step3Payload = {
+            ...step2Payload,
+            report: {
+                name: 'Annual Order Trend Executive Report',
+                description: 'Board-ready HTML report covering annual order volume and YoY trajectory.',
+                html: '<h1>Annual Order Trend</h1><p>Executive overview of multi-year order growth.</p>',
+            },
+        };
+
+        vi.mocked(RunView.FromMetadataProvider).mockReturnValue({
+            RunView: vi.fn().mockImplementation(async (rvParams: { EntityName: string }) => {
+                if (rvParams.EntityName === 'MJ: Tasks') {
+                    return {
+                        Success: true,
+                        Results: [
+                            { ID: 't1', Name: 'Step 1: Query', OutputPayload: JSON.stringify(step1Payload) },
+                            { ID: 't2', Name: 'Step 2: Strategy', OutputPayload: JSON.stringify(step2Payload) },
+                            { ID: 't3', Name: 'Step 3: Report', OutputPayload: JSON.stringify(step3Payload) },
+                        ],
+                    };
+                }
+                return { Success: false, Results: [] };
+            }),
+        } as never);
+
+        await forkHarness(null).Reinvoke(
+            params({
+                Tasks: [
+                    { TaskID: 't1', Name: 'Step 1: Query', Status: 'Complete', Summary: 'output available (180 chars)' },
+                    { TaskID: 't2', Name: 'Step 2: Strategy', Status: 'Complete', Summary: 'output available (320 chars)' },
+                    { TaskID: 't3', Name: 'Step 3: Report', Status: 'Complete', Summary: 'output available (540 chars)' },
+                ],
+            }),
+        );
+
+        const sentContent = runAgent.mock.calls[0][0].conversationMessages[0].content as string;
+        expect(sentContent).toContain('Title: Annual Order Counts');
+        expect(sentContent).toContain('Executive Summary: Order volume grew 22% YoY between 2022 and 2025.');
+        expect(sentContent).toContain('Report Title: Annual Order Trend Executive Report');
+        expect(sentContent).toContain('Report Summary: Board-ready HTML report covering annual order volume and YoY trajectory.');
+        // Step 1's SQL should only appear once (under Step 1), not duplicated under Step 2 and Step 3!
+        const sqlOccurrences = sentContent.split('SELECT YEAR(OrderDate) AS OrderYear').length - 1;
+        expect(sqlOccurrences).toBe(1);
+    });
+
+    it('walks up ParentRunID so a sub-agent (Workflow Planner) submission reinvokes the root conversation agent (Sage) as the conversation owner', async () => {
+        const subAgentRun = {
+            ID: 'subagent-planner-run',
+            AgentID: 'workflow-planner-agent-id',
+            ParentRunID: 'root-sage-run',
+            UserID: null as string | null,
+            Load: vi.fn().mockResolvedValue(true),
+        };
+        const rootSageRun = {
+            ID: 'root-sage-run',
+            AgentID: 'sage-agent-id',
+            ParentRunID: null as string | null,
+            UserID: 'owner-user-99',
+            Load: vi.fn().mockResolvedValue(true),
+        };
+        const sageAgent = {
+            ID: 'sage-agent-id',
+            Name: 'Sage',
+            Load: vi.fn().mockResolvedValue(true),
+        };
+        const detail = detailRow();
+        let runCallCount = 0;
+        const detailUsers: Array<UserInfo | undefined> = [];
+
+        const provider = {
+            GetEntityObject: vi.fn().mockImplementation(async (name: string, user?: UserInfo) => {
+                if (name === 'MJ: AI Agent Runs') {
+                    runCallCount++;
+                    return runCallCount === 1 ? subAgentRun : rootSageRun;
+                }
+                if (name === 'MJ: AI Agents') {
+                    return sageAgent;
+                }
+                detailUsers.push(user);
+                return detail;
+            }),
+        };
+
+        const deliverer = new TaskGraphContinuationDeliverer(
+            { CreateProvider: vi.fn().mockResolvedValue(provider) } as never,
+            { ID: 'system-user' } as UserInfo,
+        );
+
+        await deliverer.Reinvoke(params({ SubmittedByAgentRunID: 'subagent-planner-run' }));
+
+        expect(subAgentRun.Load).toHaveBeenCalledWith('subagent-planner-run');
+        expect(rootSageRun.Load).toHaveBeenCalledWith('root-sage-run');
+        expect(sageAgent.Load).toHaveBeenCalledWith('sage-agent-id');
+        expect(runAgent).toHaveBeenCalledTimes(1);
+        expect(runAgent.mock.calls[0][0].agent.ID).toBe('sage-agent-id');
+        expect(runAgent.mock.calls[0][0].contextUser.ID).toBe('owner-user-99');
+        expect(detailUsers[0]?.ID).toBe('owner-user-99');
+    });
+
+    it('enriches Skipped steps with their unmet dependency Condition from MJ: Task Dependencies', async () => {
+        const { RunView } = await import('@memberjunction/core');
+        vi.mocked(RunView.FromMetadataProvider).mockReturnValue({
+            RunView: vi.fn().mockImplementation(async (rvParams: { EntityName: string }) => {
+                if (rvParams.EntityName === 'MJ: Tasks') {
+                    return {
+                        Success: true,
+                        Results: [
+                            { ID: 't1', Name: 'Build Query', Status: 'Complete', OutputPayload: JSON.stringify({ queryName: 'Users by Role' }) },
+                            { ID: 't2', Name: 'Run Query', Status: 'Complete', OutputPayload: JSON.stringify({ summary: 'Built query blueprint without live execution' }) },
+                            { ID: 't3', Name: 'Analyze Results', Status: 'Skipped', OutputPayload: null },
+                        ],
+                    };
+                }
+                if (rvParams.EntityName === 'MJ: Task Dependencies') {
+                    return {
+                        Success: true,
+                        Results: [
+                            {
+                                TaskID: 't3',
+                                DependsOnTaskID: 't2',
+                                Condition: 'output.rowCount > 0',
+                            },
+                        ],
+                    };
+                }
+                return { Success: false, Results: [] };
+            }),
+        } as never);
+
+        await forkHarness(null).Reinvoke(
+            params({
+                Tasks: [
+                    { TaskID: 't1', Name: 'Build Query', Status: 'Complete' },
+                    { TaskID: 't2', Name: 'Run Query', Status: 'Complete' },
+                    { TaskID: 't3', Name: 'Analyze Results', Status: 'Skipped' },
+                ],
+                Summary: '2 of 3 steps completed (1 skipped).',
+            }),
+        );
+
+        const sentContent = runAgent.mock.calls[0][0].conversationMessages[0].content as string;
+        expect(sentContent).toContain('- ⏭️ **Analyze Results** — Skipped: branch condition `output.rowCount > 0` on "Run Query" evaluated to false');
+        expect(sentContent).toContain('briefly explaining any conditional steps that were skipped');
+    });
+});
+
+

package/src/__tests__/TaskGraphFrameResolver.test.ts

@@ -133,4 +133,26 @@ describe('TaskGraphFrameBroadcaster', () => {
         expect(p.CompletedCount).toBe(7);
         expect(p.TotalCount).toBe(7);
     });
+
+    it('bridges frames onto PUSH_STATUS_UPDATES_TOPIC when bridgeToPushStatus is enabled', () => {
+        new TaskGraphFrameBroadcaster(pubSub, true).OnFrame(
+            frame({ Kind: 'TaskCompleted', Status: 'Complete', CompletedCount: 1, TotalCount: 2 }),
+        );
+        expect(published).toHaveLength(2);
+        expect(published[0][0]).toBe(TASK_GRAPH_FRAMES_TOPIC);
+        expect(published[1][0]).toBe('PUSH_STATUS_UPDATES');
+        const pushPayload = published[1][1] as { sessionId: string; ownerUserId: string; message: string };
+        expect(pushPayload.sessionId).toBe('*');
+        expect(pushPayload.ownerUserId).toBe(OWNER);
+        const parsed = JSON.parse(pushPayload.message) as {
+            type: string;
+            status: string;
+            data: { Status: string; TaskID: string };
+        };
+        expect(parsed.type).toBe('TaskGraphFrame');
+        expect(parsed.status).toBe('ok');
+        expect(parsed.data.Status).toBe('Complete');
+        expect(parsed.data.TaskID).toBe('task-1');
+    });
 });
+