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

package/src/__tests__/AdhocQueryResolver.dialect.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Regression suite for the ad-hoc read-only execution path being SQL-Server-shaped.
+ *
+ * The bug — `ExecuteAdhocQuery` opened with
+ * `GetReadOnlyDataSource(context.dataSources, …)`, which looks for an **mssql
+ * `ConnectionPool`**. A PostgreSQL provider never populates `context.dataSources`
+ * with one, so every ad-hoc query on PostgreSQL returned
+ * "No read-only data source available for ad-hoc query execution".
+ *
+ * `next` fixed the execution path (R31): the resolver now hands the SQL to the
+ * read-only PROVIDER's `RunQuery`, and renders it for that provider's platform.
+ * This suite pins the dialect half of that contract — the platform comes from the
+ * provider the SQL runs on, never from a literal, and nothing reaches for mssql —
+ * and drives the resolver against a PostgreSQL provider with no mssql pool at all.
+ * Paging, the timeout clamp and the read authorizer have their own suites.
+ */
+import 'reflect-metadata';
+
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+
+// `RunQueryResultType` is a type-graphql object type whose fields rely on
+// `emitDecoratorMetadata`. esbuild (what vitest transforms with) cannot emit it,
+// so importing QueryResolver for real fails at decoration time. The resolver only
+// uses the class as the @Query return marker, so a bare stand-in is enough and
+// keeps the REAL AdhocQueryResolver under test.
+vi.mock('../resolvers/QueryResolver.js', () => ({
+    RunQueryResultType: class RunQueryResultType {},
+}));
+
+// The server config is read from mj.config at import; only the timeout cap is used here.
+vi.mock('../config.js', () => ({ configInfo: { databaseSettings: { requestTimeout: 120_000 } } }));
+
+import { AdhocQueryResolver } from '../resolvers/AdhocQueryResolver.js';
+import type { AppContext } from '../types.js';
+
+const ADHOC_RESOLVER_PATH = resolve(__dirname, '../resolvers/AdhocQueryResolver.ts');
+
+function readResolverSource(): string {
+    return readFileSync(ADHOC_RESOLVER_PATH, 'utf8');
+}
+
+type RunQueryCall = { SQL: string; MaxRows?: number; StartRow?: number };
+
+function postgresContext(calls: RunQueryCall[], rows: Record<string, unknown>[]): AppContext {
+    const provider = {
+        PlatformKey: 'postgresql',
+        RunQuery: async (params: RunQueryCall) => {
+            calls.push(params);
+            return { Success: true, Results: rows, RowCount: rows.length, TotalRowCount: rows.length };
+        },
+    };
+    return {
+        // Deliberately EMPTY: a PostgreSQL tenant has no mssql ConnectionPool here.
+        // If the resolver still reaches for one, these tests fail.
+        dataSources: [],
+        providers: [{ type: 'Read-Only', provider }],
+        userPayload: { userRecord: { ID: 'u-1', Name: 'Tester' } },
+    } as unknown as AppContext;
+}
+
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+
+describe('AdhocQueryResolver dialect source-shape contract', () => {
+    it('must NOT gate execution on a SQL-Server-only read-only data source', () => {
+        expect(readResolverSource()).not.toContain('GetReadOnlyDataSource');
+    });
+
+    it('must NOT depend on the mssql driver', () => {
+        const src = readResolverSource();
+        expect(src).not.toMatch(/^import .* from 'mssql';$/m);
+        expect(src).not.toContain('new sql.Request(');
+        expect(src).not.toContain('sql.ConnectionPool');
+    });
+
+    it('renders for the platform of the read-only provider the SQL runs on, not a literal', () => {
+        const src = readResolverSource();
+        expect(src).toContain('GetReadOnlyProvider(context.providers');
+        expect(src).toContain('Platform: provider.PlatformKey');
+        expect(src).not.toMatch(/platform\s*(:\s*DatabasePlatform\s*)?=\s*'sqlserver'/);
+        expect(src).not.toMatch(/Platform:\s*'sqlserver'/);
+    });
+});
+
+describe('ExecuteAdhocQuery on a PostgreSQL tenant', () => {
+    it('runs on the read-only provider instead of refusing for want of an mssql pool', async () => {
+        const resolver = new AdhocQueryResolver();
+        const authorize = vi.spyOn(resolver, 'AuthorizeRenderedSQL').mockReturnValue(null);
+        const calls: RunQueryCall[] = [];
+
+        const result = await resolver.ExecuteAdhocQuery(
+            { SQL: 'SELECT ID FROM __mj.vwUsers' },
+            postgresContext(calls, [{ ID: '1' }, { ID: '2' }]),
+        );
+
+        expect(result.ErrorMessage).not.toContain('No read-only data source');
+        expect(result.Success).toBe(true);
+        expect(calls).toHaveLength(1);
+        expect(calls[0].SQL).toBe('SELECT ID FROM __mj.vwUsers');
+        expect(JSON.parse(result.Results)).toEqual([{ ID: '1' }, { ID: '2' }]);
+        // The SQL is authorized (and so rendered) against the same PostgreSQL provider it runs on.
+        expect((authorize.mock.calls[0][1] as { PlatformKey: string }).PlatformKey).toBe('postgresql');
+    });
+});
+
+describe('ExecuteAdhocQuery refusal path', () => {
+    it('still refuses when there is no read-only provider at all', async () => {
+        const resolver = new AdhocQueryResolver();
+
+        const result = await resolver.ExecuteAdhocQuery(
+            { SQL: 'SELECT ID FROM __mj.vwUsers' },
+            { dataSources: [], providers: [], userPayload: { userRecord: { ID: 'u-1' } } } as unknown as AppContext,
+        );
+
+        expect(result.Success).toBe(false);
+        expect(result.ErrorMessage).toContain('No read-only data source available for ad-hoc query execution');
+    });
+
+    it('does NOT fall back to a read-write provider', async () => {
+        const resolver = new AdhocQueryResolver();
+
+        const result = await resolver.ExecuteAdhocQuery(
+            { SQL: 'SELECT ID FROM __mj.vwUsers' },
+            {
+                dataSources: [],
+                providers: [{ type: 'Read-Write', provider: { PlatformKey: 'postgresql', RunQuery: async () => ({ Success: true, Results: [] }) } }],
+                userPayload: { userRecord: { ID: 'u-1' } },
+            } as unknown as AppContext,
+        );
+
+        expect(result.Success).toBe(false);
+        expect(result.ErrorMessage).toContain('No read-only data source available');
+    });
+});

package/src/__tests__/AgentRunStatusPublisher.test.ts

@@ -29,6 +29,7 @@ vi.mock('@memberjunction/graphql-dataprovider', () => ({
 import type { ExecuteAgentResult } from '@memberjunction/ai-core-plus';
 import { ConversationStreaming, type IConversationsRuntimeContext } from '@memberjunction/conversations-runtime';
 import { AgentRunStatusPublisher } from '../resolvers/AgentRunStatusPublisher.js';
+import { StatusUpdatesFilter, type PushStatusNotificationPayload } from '../generic/PushStatusResolver.js';
 import type { UserPayload } from '../types.js';
 
 const run = {
@@ -56,6 +57,31 @@ function envelopes(publish: ReturnType<typeof vi.fn>): Array<Record<string, unkn
 }
 
 describe('AgentRunStatusPublisher', () => {
+    it('stamps the reply row on every message when it has one, so a reconnecting client can find its row', () => {
+        const publish = vi.fn().mockResolvedValue(undefined);
+        const pubSub = { publish } as unknown as PubSubEngine;
+        const userPayload = { sessionId: 'session-1', userRecord: { ID: 'user-1' } } as UserPayload;
+        const made = new AgentRunStatusPublisher(pubSub, userPayload, 'session-1', 'reply-7');
+        const runWithoutDetail = { ...run, ConversationDetailID: undefined, GetAll: () => ({ ID: 'run-1' }) };
+
+        made.OnProgress({ step: 'prompt_execution', message: 'Writing', metadata: { agentRun: runWithoutDetail } });
+        made.OnStreaming({ content: 'Hel', isComplete: false, stepType: 'prompt', kind: 'final-response' });
+        made.PublishFinal({ success: true, agentRun: runWithoutDetail } as unknown as ExecuteAgentResult);
+
+        const details = envelopes(publish).map((row) => (row.data as { conversationDetailId?: string }).conversationDetailId);
+        expect(details).toEqual(['reply-7', 'reply-7', 'reply-7', 'reply-7']);
+    });
+
+    it('leaves progress and streaming messages without a reply row when it has none, as before', () => {
+        const { publish, made } = publisher();
+
+        made.OnProgress({ step: 'prompt_execution', message: 'Writing', metadata: { agentRun: run } });
+        made.OnStreaming({ content: 'Hel', isComplete: false, stepType: 'prompt', kind: 'final-response' });
+
+        const sent = envelopes(publish).map((row) => row.data as Record<string, unknown>);
+        expect(sent.every((data) => !('conversationDetailId' in data))).toBe(true);
+    });
+
     it('publishes the resolver sequence: a significant step, streamed text, the partial result, then the completion', () => {
         const { publish, made } = publisher();
 
@@ -173,3 +199,26 @@ describe('AgentRunStatusPublisher', () => {
         expect(streaming.GetRecentCompletion('detail-1')?.agentRunId).toBe('run-1');
     });
 });
+
+describe('AgentRunStatusPublisher — a widget guest elevated to the system user (#4931)', () => {
+    const GUEST = { ID: 'anonymous-user', IsMagicLinkAnonymous: true, AnonymousVisitorID: 'sid-a', MagicLinkScope: { ResourceID: 'sid-a' } };
+    const SYSTEM = { ID: 'system-user' };
+
+    it("stamps the guest (ElevatedFrom), not the elevated user, so the guest's own socket receives the run's events", () => {
+        const publish = vi.fn().mockResolvedValue(undefined);
+        const elevated = { sessionId: 'session-1', userRecord: SYSTEM, isSystemUser: true, ElevatedFrom: GUEST } as unknown as UserPayload;
+        const made = new AgentRunStatusPublisher({ publish } as unknown as PubSubEngine, elevated, 'session-1');
+
+        made.PublishFinal({ success: true, agentRun: run, payload: { text: 'Hello' } } as ExecuteAgentResult, 'detail-1', '{"text":"Hello"}');
+        made.PublishFailure('detail-1', 'boom');
+
+        const owners = publish.mock.calls.map((call) => (call[1] as { ownerUserId: string }).ownerUserId);
+        expect(owners.length).toBeGreaterThan(0);
+        // An anonymous visitor's owner key carries its scope identity, so another visitor cannot receive these events.
+        expect(owners.every((owner) => owner === 'anonymous-user|sid-a')).toBe(true);
+        const guestConnection = { userPayload: { sessionId: 'session-1', userRecord: GUEST } as unknown as UserPayload };
+        for (const call of publish.mock.calls) {
+            expect(StatusUpdatesFilter({ payload: call[1] as PushStatusNotificationPayload, args: { sessionId: 'session-1' }, context: guestConnection })).toBe(true);
+        }
+    });
+});

package/src/__tests__/AgentSessionResolver.ownership.test.ts

@@ -0,0 +1,150 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { IMetadataProvider, UserInfo } from '@memberjunction/core';
+import type { AppContext } from '../types.js';
+
+vi.mock('type-graphql', () => {
+    const noopDecorator = () => () => undefined;
+    return {
+        Resolver: noopDecorator,
+        Mutation: noopDecorator,
+        Arg: noopDecorator,
+        Ctx: noopDecorator,
+        ObjectType: noopDecorator,
+        Field: noopDecorator,
+    };
+});
+
+vi.mock('../generic/ResolverBase.js', () => ({
+    ResolverBase: class {
+        protected GetUserFromPayload(payload?: { userRecord?: UserInfo }): UserInfo | undefined {
+            return payload?.userRecord;
+        }
+    },
+}));
+
+const closeSessionMock = vi.fn(async () => true);
+const heartbeatMock = vi.fn(async () => true);
+
+vi.mock('../agentSessions/index.js', () => ({
+    SessionManager: class {
+        CloseSession = closeSessionMock;
+        Heartbeat = heartbeatMock;
+    },
+    SessionAuthorizationError: class extends Error {},
+}));
+
+import { AgentSessionResolver } from '../resolvers/AgentSessionResolver.js';
+
+const uuid = (a: string, b: string) =>
+    [a.repeat(8), b.repeat(4), '4' + b.repeat(3), '8' + b.repeat(3), b.repeat(12)].join('-');
+const ANON = uuid('A', '0');
+const SESSION = uuid('1', '1');
+const CONVERSATION = uuid('2', '2');
+
+const guest = (visitorId: string) =>
+    ({
+        ID: ANON,
+        IsMagicLinkAnonymous: true,
+        // An unscoped multi-use invite: redemptions are told apart by mj_sid (a resource scope would be shared).
+        AnonymousVisitorID: visitorId,
+    }) as unknown as UserInfo;
+
+function makeProvider(sessionFound = true, externalId = 'visitor-1'): IMetadataProvider {
+    return {
+        GetEntityObject: vi.fn(async (entityName: string) =>
+            entityName === 'MJ: AI Agent Sessions'
+                ? { UserID: ANON, ConversationID: CONVERSATION, Load: vi.fn(async () => sessionFound) }
+                : { ExternalID: externalId, Load: vi.fn(async () => true) },
+        ),
+    } as unknown as IMetadataProvider;
+}
+
+function makeCtx(user: UserInfo, provider: IMetadataProvider): AppContext {
+    return {
+        userPayload: { email: 'anonymous@magic-link.local', sessionId: 's', userRecord: user },
+        providers: [{ provider, type: 'Read-Write' }],
+    } as unknown as AppContext;
+}
+
+describe('AgentSessionResolver anonymous visitor ownership', () => {
+    beforeEach(() => {
+        closeSessionMock.mockClear();
+        heartbeatMock.mockClear();
+    });
+
+    it('CloseAgentSession allows the matching anonymous visitor and refuses a second anonymous visitor', async () => {
+        const resolver = new AgentSessionResolver();
+        const provider = makeProvider(true, 'visitor-1');
+
+        await expect(resolver.CloseAgentSession(SESSION, makeCtx(guest('visitor-1'), provider))).resolves.toBe(true);
+        expect(closeSessionMock).toHaveBeenCalledOnce();
+
+        await expect(resolver.CloseAgentSession(SESSION, makeCtx(guest('visitor-2'), provider))).rejects.toThrow(
+            'Not authorized: you do not own this agent session',
+        );
+        expect(closeSessionMock).toHaveBeenCalledOnce();
+    });
+
+    it('AgentSessionHeartbeat allows the matching anonymous visitor and refuses a second anonymous visitor', async () => {
+        const resolver = new AgentSessionResolver();
+        const provider = makeProvider(true, 'visitor-1');
+
+        await expect(resolver.AgentSessionHeartbeat(SESSION, makeCtx(guest('visitor-1'), provider))).resolves.toBe(true);
+        expect(heartbeatMock).toHaveBeenCalledOnce();
+
+        await expect(resolver.AgentSessionHeartbeat(SESSION, makeCtx(guest('visitor-2'), provider))).rejects.toThrow(
+            'Not authorized: you do not own this agent session',
+        );
+        expect(heartbeatMock).toHaveBeenCalledOnce();
+    });
+
+    it('throws the expected not-found message when the session does not exist', async () => {
+        const resolver = new AgentSessionResolver();
+        const provider = makeProvider(false);
+
+        await expect(resolver.CloseAgentSession(SESSION, makeCtx(guest('visitor-1'), provider))).rejects.toThrow(
+            `Agent session ${SESSION} not found`,
+        );
+        await expect(resolver.AgentSessionHeartbeat(SESSION, makeCtx(guest('visitor-1'), provider))).rejects.toThrow(
+            `Agent session ${SESSION} not found`,
+        );
+    });
+});
+
+describe('CloseAgentSession close reason (MJ#6013)', () => {
+    beforeEach(() => closeSessionMock.mockClear());
+
+    it('passes a client-reportable reason through, so a start that failed is recorded as an Error', async () => {
+        const resolver = new AgentSessionResolver();
+        const provider = makeProvider(true, 'visitor-1');
+        await expect(resolver.CloseAgentSession(SESSION, makeCtx(guest('visitor-1'), provider), 'Error')).resolves.toBe(true);
+        expect(closeSessionMock).toHaveBeenCalledWith(SESSION, expect.anything(), provider, 'Error');
+    });
+
+    it('defaults to Explicit when the client sends no reason (older clients)', async () => {
+        const resolver = new AgentSessionResolver();
+        const provider = makeProvider(true, 'visitor-1');
+        await expect(resolver.CloseAgentSession(SESSION, makeCtx(guest('visitor-1'), provider))).resolves.toBe(true);
+        expect(closeSessionMock).toHaveBeenCalledWith(SESSION, expect.anything(), provider, 'Explicit');
+    });
+
+    it('a client may stamp TimeLimit (CloseSession verifies it); Janitor, Shutdown and Idle are still refused', async () => {
+        const resolver = new AgentSessionResolver();
+        const provider = makeProvider(true, 'visitor-1');
+        const ctx = makeCtx(guest('visitor-1'), provider);
+        await expect(resolver.CloseAgentSession(SESSION, ctx, 'TimeLimit')).resolves.toBe(true);
+        expect(closeSessionMock).toHaveBeenCalledWith(SESSION, expect.anything(), provider, 'TimeLimit');
+        closeSessionMock.mockClear();
+        for (const reason of ['Janitor', 'Shutdown', 'Idle']) {
+            await expect(resolver.CloseAgentSession(SESSION, ctx, reason)).rejects.toThrow(/Unsupported close reason/);
+        }
+        expect(closeSessionMock).not.toHaveBeenCalled();
+    });
+
+    it('refuses a reason only the server may stamp', async () => {
+        const resolver = new AgentSessionResolver();
+        const provider = makeProvider(true, 'visitor-1');
+        await expect(resolver.CloseAgentSession(SESSION, makeCtx(guest('visitor-1'), provider), 'Janitor')).rejects.toThrow(/close reason/i);
+        expect(closeSessionMock).not.toHaveBeenCalled();
+    });
+});

package/src/__tests__/AssertTargetConfigs.test.ts

@@ -0,0 +1,75 @@
+/**
+ * An apply whose selected objects all drop out of buildTargetConfigs must fail, not run RSU on
+ * nothing (PropFuel, 2026-10-29). A selection that produces even one table must still apply.
+ */
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { TargetTableConfig } from '@memberjunction/integration-schema-builder';
+import { AssertTargetConfigs, NewTargetConfigDrops, SampleNames } from '../integration/TargetConfigGuard.js';
+
+const selected = [{ SourceObjectName: 'clicks' }, { SourceObjectName: 'sends' }, { SourceObjectName: 'opens' }];
+const oneTable = [{ SchemaName: 'propfuel', TableName: 'clicks' } as TargetTableConfig];
+
+describe('AssertTargetConfigs', () => {
+    it('refuses a selection none of whose objects produced a table, naming what was asked for', () => {
+        expect(() => AssertTargetConfigs(selected, [], 'PropFuel')).toThrow(
+            /NO_TARGET_TABLES: none of the 3 selected object\(s\) for PropFuel produced a target table \(clicks, sends, opens\)/
+        );
+    });
+
+    it('names why each object was dropped, so a caller does not need the server log', () => {
+        const drops = NewTargetConfigDrops();
+        drops.NotInSchema.push('clicks', 'sends');
+        drops.NoPrimaryKey.push('opens');
+        expect(() => AssertTargetConfigs(selected, [], 'PropFuel', drops)).toThrow(
+            'Dropped as not in the source schema: clicks, sends; no primary key: opens.'
+        );
+    });
+
+    it('says nothing was applied by default, and what was already committed when the caller says so', () => {
+        expect(() => AssertTargetConfigs(selected, [], 'PropFuel')).toThrow('Nothing was applied.');
+        expect(() => AssertTargetConfigs(selected, [], 'PropFuel', undefined, 'The catalog had already been saved.'))
+            .toThrow(/The catalog had already been saved\. Re-run discovery/);
+    });
+
+    it('caps the names it lists, so a large selection cannot make a multi-KB error', () => {
+        const many = Array.from({ length: 168 }, (_v, i) => ({ SourceObjectName: `obj${i}` }));
+        expect(() => AssertTargetConfigs(many, [], 'NetForum')).toThrow('(obj0, obj1, obj2, obj3, obj4 and 163 more)');
+        expect(SampleNames(['a', 'b'])).toBe('a, b');
+    });
+
+    it('lets a selection through when at least one object produced a table', () => {
+        expect(() => AssertTargetConfigs(selected, oneTable, 'PropFuel')).not.toThrow();
+    });
+
+    it('lets an empty selection through — there was nothing to refuse', () => {
+        expect(() => AssertTargetConfigs([], [], 'PropFuel')).not.toThrow();
+    });
+});
+
+/**
+ * Read from source: the call sites are resolver mutations that need a provider, a connector and an
+ * RSU pipeline to run.
+ */
+describe('the guard\'s callers', () => {
+    const SRC = readFileSync(join(__dirname, '..', 'resolvers', 'IntegrationDiscoveryResolver.ts'), 'utf-8');
+
+    it('IntegrationApplySchema filters on names whose casing resolveObjectInputs has corrected', () => {
+        // A filter built from the raw input is case-sensitive: `Clicks` for a stored `clicks` selected
+        // nothing, and the guard then told the caller to re-run discovery, which cannot fix casing.
+        const start = SRC.indexOf('async IntegrationApplySchema(');
+        const body = SRC.slice(start, SRC.indexOf('AssertTargetConfigs(', start));
+        const resolve = body.indexOf('await this.resolveObjectInputs(objects, sourceSchema, user);');
+        const names = body.indexOf('const resolvedNames = new Set(objects.map(o => o.SourceObjectName));');
+        expect(resolve).toBeGreaterThan(-1);
+        expect(names).toBeGreaterThan(resolve);
+        expect(body).toMatch(/sourceSchema\.Objects\.filter\(o => resolvedNames\.has\(o\.ExternalName\)\)/);
+    });
+
+    it('every call passes the drop reasons, and schema evolution says what it had already committed', () => {
+        const calls = [...SRC.matchAll(/AssertTargetConfigs\(objects, targetConfigs, companyIntegration\.Integration, drops([\s\S]*?)\);/g)];
+        expect(calls).toHaveLength(3);
+        expect(calls.filter(c => /already been saved/.test(c[1]))).toHaveLength(1);
+    });
+});

package/src/__tests__/BatchApplyParity.test.ts

@@ -0,0 +1,109 @@
+/**
+ * The two apply paths must agree, because the shared connector surface collapses onto the batch
+ * one. Two defects made them differ, and both are invisible until a surface migrates:
+ *
+ *  - MJ-APPLY-12: the batch never made the first-apply full-sync determination, and its input
+ *    declared `defaultValue: false` for FullSync, which made the null-coalesce dead code. A
+ *    re-apply the caller left unspecified therefore ran INCREMENTAL against objects whose
+ *    watermark the schema change had just reset. everything.txt: "for the very first RSU of a
+ *    connector, the sync afterwards should be chosen to be full/incremental, but always full
+ *    generally as the default."
+ *  - MJ-APPLY-13: the batch's skipRestart branch never applied remove-as-disable, so
+ *    UnselectedAction was a silent no-op and a deselected table kept syncing.
+ *
+ * Read from source: both live in a resolver that needs a provider, a connector and an RSU
+ * pipeline to invoke, and the property under test is a one-line policy, not a behaviour worth
+ * standing all that up to observe.
+ */
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const SRC = readFileSync(
+  join(__dirname, '..', 'resolvers', 'IntegrationDiscoveryResolver.ts'),
+  'utf-8',
+);
+
+/** The body of a named input class, up to its closing brace. */
+function classBody(name: string): string {
+  const start = SRC.indexOf(`class ${name} {`);
+  expect(start, `${name} not found`).toBeGreaterThan(-1);
+  const rest = SRC.slice(start);
+  const end = rest.indexOf('\n}');
+  return end === -1 ? rest : rest.slice(0, end);
+}
+
+/** The body of a named resolver method, up to the next method at the same indent. */
+function methodBody(name: string): string {
+  const start = SRC.indexOf(`async ${name}(`);
+  expect(start, `${name} not found`).toBeGreaterThan(-1);
+  const rest = SRC.slice(start);
+  const end = rest.search(/\n    @(Query|Mutation)\(/);
+  return end === -1 ? rest : rest.slice(0, end);
+}
+
+describe('MJ-APPLY-12 first-apply full sync', () => {
+  it('the batch resolves FullSync from prior maps, not from a bare false', () => {
+    const body = methodBody('IntegrationApplyAllBatch');
+    expect(body).toMatch(/const fullSync = input\.FullSync\s*\?\?\s*!hadPriorMaps;/);
+    expect(body).toMatch(/FullSync:\s*fullSync,/);
+    expect(body).not.toMatch(/input\.FullSync\s*\?\?\s*false/);
+  });
+
+  it('ApplyAllBatchInput.FullSync has NO defaultValue, or the coalesce is dead again', () => {
+    // Scope to the CLASS. There are several `FullSync?: boolean` fields in this file and a bare
+    // find() picks ApplyAllInput's, which would pass no matter what the batch input declared.
+    const body = classBody('ApplyAllBatchInput');
+    const line = body.split('\n').find(l => l.includes('FullSync?: boolean') && l.includes('@Field'));
+    expect(line, 'ApplyAllBatchInput.FullSync not found').toBeDefined();
+    expect(line!).not.toMatch(/defaultValue/);
+  });
+
+  it('the single-connector path still does the same thing', () => {
+    expect(methodBody('IntegrationApplyAll')).toMatch(/input\.FullSync\s*\?\?\s*!hadPriorMaps/);
+  });
+
+  it('the prior-maps read UUID-validates the connection id, like every other caller-supplied id', () => {
+    // The batch takes its CompanyIntegrationIDs from the caller. The rest of this resolver refuses a
+    // non-UUID id with sqlUuid before it reaches an ExtraFilter; quote-doubling is not that check.
+    const body = methodBody('IntegrationApplyAllBatch');
+    expect(body).toMatch(/CompanyIntegrationID='\$\{sqlUuid\(connInput\.CompanyIntegrationID, 'CompanyIntegrationID'\)\}'/);
+    expect(body).not.toMatch(/connInput\.CompanyIntegrationID\.replace\(/);
+  });
+
+  it('the skipRestart branch starts its sync with the RESOLVED FullSync, as the restart path queues it', () => {
+    // The restart path carries the coalesced value in its PendingWork; the skipRestart branch starts
+    // the sync itself. Passing the raw input there means an omitted FullSync is undefined, which
+    // startSyncAfterApply reads as incremental — against tables the apply just created.
+    const body = methodBody('IntegrationApplyAllBatch');
+    const call = body.match(/this\.startSyncAfterApply\(build\.connInput\.CompanyIntegrationID,[^)]*\)/);
+    expect(call, 'skipRestart sync start not found').not.toBeNull();
+    expect(call![0]).not.toMatch(/input\.FullSync/);
+    expect(call![0]).toMatch(/build\.fullSync\)$/);
+    expect(body).toMatch(/^\s*fullSync,$/m);
+  });
+
+  it('the prior-maps probe skips the row count, as the single path does', () => {
+    // MaxRows: 1 is an existence probe; without SkipTotalRowCount the provider follows every hit
+    // with a COUNT(*) over the connection's maps.
+    const body = methodBody('IntegrationApplyAllBatch');
+    const probe = body.slice(body.indexOf('const priorMapsResult'), body.indexOf('const hadPriorMaps'));
+    expect(probe).toMatch(/MaxRows:\s*1,/);
+    expect(probe).toMatch(/SkipTotalRowCount:\s*true/);
+  });
+});
+
+describe('MJ-APPLY-13 remove-as-disable', () => {
+  it('the batch skipRestart branch disables unselected maps', () => {
+    const body = methodBody('IntegrationApplyAllBatch');
+    expect(body).toMatch(/UnselectedAction\s*\?\?\s*'disable'\)\s*!==\s*'ignore'/);
+    expect(body).toMatch(/DisableUnselectedEntityMaps\(/);
+  });
+
+  it('and honours the ignore opt-out rather than always disabling', () => {
+    const body = methodBody('IntegrationApplyAllBatch');
+    const at = body.indexOf('DisableUnselectedEntityMaps(');
+    // the guard must precede the call, not follow it
+    expect(body.lastIndexOf("!== 'ignore'", at)).toBeGreaterThan(-1);
+  });
+});

package/src/__tests__/BridgeHostInstance.test.ts

@@ -230,3 +230,45 @@ describe('StartBridgeOrphanReconciliation', () => {
         expect(runView.mock.calls[0][1]).toBe(user);
     });
 });
+
+describe('StartBridgeOrphanReconciliation with agentSessions.bridgeReconciler settings', () => {
+    const HOUR = 60 * 60_000;
+    afterEach(() => {
+        vi.restoreAllMocks();
+        vi.useRealTimers();
+    });
+
+    it('enabled: reconciles now, then on the configured interval', async () => {
+        vi.useFakeTimers();
+        const reconcile = vi.spyOn(AIBridgeEngine.Instance, 'ReconcileOrphans').mockResolvedValue(0);
+        const { provider } = bridgeTable([]);
+
+        StartBridgeOrphanReconciliation(provider, user, { enabled: true, sweepIntervalMs: 120_000 });
+        await vi.advanceTimersByTimeAsync(6 * 60_000);
+
+        expect(reconcile).toHaveBeenCalledTimes(4); // now + every 2 minutes
+    });
+
+    it('disabled: reconciles once now and never again', async () => {
+        vi.useFakeTimers();
+        const reconcile = vi.spyOn(AIBridgeEngine.Instance, 'ReconcileOrphans').mockResolvedValue(0);
+        const { provider } = bridgeTable([]);
+
+        StartBridgeOrphanReconciliation(provider, user, { enabled: false, sweepIntervalMs: 600_000 });
+        await vi.advanceTimersByTimeAsync(HOUR);
+
+        expect(reconcile).toHaveBeenCalledTimes(1);
+        expect(reconcile.mock.calls[0][0]).toBe(user);
+    });
+
+    it('with no settings keeps the shipped 10-minute repeat', async () => {
+        vi.useFakeTimers();
+        const reconcile = vi.spyOn(AIBridgeEngine.Instance, 'ReconcileOrphans').mockResolvedValue(0);
+        const { provider } = bridgeTable([]);
+
+        StartBridgeOrphanReconciliation(provider, user);
+        await vi.advanceTimersByTimeAsync(HOUR);
+
+        expect(reconcile).toHaveBeenCalledTimes(7);
+    });
+});