@memberjunction/server 5.38.0 → 5.40.0

package/dist/resolvers/IntegrationDiscoveryResolver.js

@@ -12,13 +12,14 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 var IntegrationDiscoveryResolver_1;
 import { Resolver, Query, Mutation, Arg, Ctx, ObjectType, Field, InputType } from "type-graphql";
-import { CompositeKey, LocalCacheManager, RunView, LogError } from "@memberjunction/core";
+import { CompositeKey, LocalCacheManager, Metadata, RunView, LogError, LogStatus } from "@memberjunction/core";
 import { GetReadOnlyProvider, GetReadWriteProvider } from "../util.js";
 import { CronExpressionHelper } from "@memberjunction/scheduling-engine";
-import { ConnectorFactory, IntegrationEngine, IntegrationSchemaSync } from "@memberjunction/integration-engine";
+import { ConnectorFactory, IntegrationEngine, IntegrationSchemaSync, IntegrationConnectorCreationPipeline, IntegrationActionGenerator } from "@memberjunction/integration-engine";
 import { IntegrationEngineBase } from "@memberjunction/integration-engine-base";
 import { SchemaBuilder, TypeMapper, SchemaEvolution } from "@memberjunction/integration-schema-builder";
 import { RuntimeSchemaManager } from "@memberjunction/schema-engine";
+import { IntegrationProgressReader } from "@memberjunction/integration-progress-artifacts";
 import { ResolverBase } from "../generic/ResolverBase.js";
 import { UserCache } from "@memberjunction/sqlserver-dataprovider";
 // ─── RSU Pipeline Output Types ──────────────────────────────────────────────
@@ -412,6 +413,10 @@ __decorate([
     Field({ nullable: true }),
     __metadata("design:type", Number)
 ], DeleteConnectionOutput.prototype, "SchedulesDeleted", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], DeleteConnectionOutput.prototype, "CredentialDeleted", void 0);
 DeleteConnectionOutput = __decorate([
     ObjectType()
 ], DeleteConnectionOutput);
@@ -683,6 +688,151 @@ __decorate([
 ConnectionTestOutput = __decorate([
     ObjectType()
 ], ConnectionTestOutput);
+// ─── Refresh Connector Schema (Phase 0 v5.39.x) ─────────────────────────────
+// Invokes IntegrationConnectorCreationPipeline.Run() which drives
+// TestConnection → IntrospectSchema (parallel describe) →
+// PersistDiscoveredSchema (overlay precedence: declared wins for semantic,
+// discovered wins for technical) → SoftPKClassifier (4-tier cascade) and emits
+// structured progress events the operator can grep in the MJAPI log file:
+//   "event":"discovery.object.added"  with source: Declared | Discovered | Custom
+//   "event":"discovery.field.added"   ditto
+//   "event":"pk.classifier.invoked"   per object missing an explicit PK
+//   "event":"pk.classifier.result"    the classifier's verdict + strategy + reason
+//   "event":"entity.generated"        IO has a PK → eligible for MJ entity generation
+//   "event":"entity.skipped-no-pk"    IO has NO PK → not eligible, deferred
+//
+// Per-run JSONL artifacts also land at:
+//   <cwd>/logs/integration-runs/<runID>/{manifest,progress,result}.json
+let RefreshConnectorSchemaPKVerdictOutput = class RefreshConnectorSchemaPKVerdictOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], RefreshConnectorSchemaPKVerdictOutput.prototype, "ObjectName", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], RefreshConnectorSchemaPKVerdictOutput.prototype, "Confident", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], RefreshConnectorSchemaPKVerdictOutput.prototype, "Nominee", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Number)
+], RefreshConnectorSchemaPKVerdictOutput.prototype, "Confidence", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], RefreshConnectorSchemaPKVerdictOutput.prototype, "Strategy", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], RefreshConnectorSchemaPKVerdictOutput.prototype, "Reason", void 0);
+RefreshConnectorSchemaPKVerdictOutput = __decorate([
+    ObjectType()
+], RefreshConnectorSchemaPKVerdictOutput);
+let RefreshConnectorSchemaOutput = class RefreshConnectorSchemaOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], RefreshConnectorSchemaOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], RefreshConnectorSchemaOutput.prototype, "Message", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], RefreshConnectorSchemaOutput.prototype, "RunID", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], RefreshConnectorSchemaOutput.prototype, "ObjectsCreated", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], RefreshConnectorSchemaOutput.prototype, "ObjectsUpdated", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], RefreshConnectorSchemaOutput.prototype, "FieldsCreated", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], RefreshConnectorSchemaOutput.prototype, "FieldsUpdated", void 0);
+__decorate([
+    Field(() => [RefreshConnectorSchemaPKVerdictOutput], { nullable: true }),
+    __metadata("design:type", Array)
+], RefreshConnectorSchemaOutput.prototype, "PKVerdicts", void 0);
+__decorate([
+    Field(() => [String], { nullable: true }),
+    __metadata("design:type", Array)
+], RefreshConnectorSchemaOutput.prototype, "UnresolvedObjects", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], RefreshConnectorSchemaOutput.prototype, "FailureMessage", void 0);
+RefreshConnectorSchemaOutput = __decorate([
+    ObjectType()
+], RefreshConnectorSchemaOutput);
+// ─── Generate Integration Action (on-demand Integration-as-Actions) ─────────
+// Generates + persists a strongly-typed Action (DriverClass='IntegrationActionExecutor')
+// for one integration/object/verb (or all applicable verbs when verb is omitted) via
+// the engine's IntegrationActionGenerator. Idempotent on the deterministic Action Name
+// "<Integration> - <Verb> <DisplayName>": a matching Action is reused (AlreadyExisted=true)
+// and its params/result codes reconciled rather than duplicated.
+let IntegrationGenerateActionResult = class IntegrationGenerateActionResult {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], IntegrationGenerateActionResult.prototype, "Success", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationGenerateActionResult.prototype, "ActionID", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationGenerateActionResult.prototype, "ActionName", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], IntegrationGenerateActionResult.prototype, "AlreadyExisted", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationGenerateActionResult.prototype, "Verb", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationGenerateActionResult.prototype, "ObjectName", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], IntegrationGenerateActionResult.prototype, "Message", void 0);
+IntegrationGenerateActionResult = __decorate([
+    ObjectType()
+], IntegrationGenerateActionResult);
+let IntegrationGenerateActionOutput = class IntegrationGenerateActionOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], IntegrationGenerateActionOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], IntegrationGenerateActionOutput.prototype, "Message", void 0);
+__decorate([
+    Field(() => [IntegrationGenerateActionResult], { nullable: true }),
+    __metadata("design:type", Array)
+], IntegrationGenerateActionOutput.prototype, "Results", void 0);
+IntegrationGenerateActionOutput = __decorate([
+    ObjectType()
+], IntegrationGenerateActionOutput);
 // --- Preview Data Types ---
 let PreviewRecordOutput = class PreviewRecordOutput {
 };
@@ -876,6 +1026,39 @@ __decorate([
 CreateConnectionInput = __decorate([
     InputType()
 ], CreateConnectionInput);
+let CreateConnectionPipelineSummary = class CreateConnectionPipelineSummary {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], CreateConnectionPipelineSummary.prototype, "RunID", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Number)
+], CreateConnectionPipelineSummary.prototype, "ObjectsCreated", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Number)
+], CreateConnectionPipelineSummary.prototype, "ObjectsUpdated", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Number)
+], CreateConnectionPipelineSummary.prototype, "FieldsCreated", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Number)
+], CreateConnectionPipelineSummary.prototype, "FieldsUpdated", void 0);
+__decorate([
+    Field(() => [String]),
+    __metadata("design:type", Array)
+], CreateConnectionPipelineSummary.prototype, "UnresolvedObjects", void 0);
+__decorate([
+    Field(() => [RefreshConnectorSchemaPKVerdictOutput], { nullable: true }),
+    __metadata("design:type", Array)
+], CreateConnectionPipelineSummary.prototype, "PKVerdicts", void 0);
+CreateConnectionPipelineSummary = __decorate([
+    ObjectType()
+], CreateConnectionPipelineSummary);
 let CreateConnectionOutput = class CreateConnectionOutput {
 };
 __decorate([
@@ -902,6 +1085,10 @@ __decorate([
     Field({ nullable: true }),
     __metadata("design:type", String)
 ], CreateConnectionOutput.prototype, "ConnectionTestMessage", void 0);
+__decorate([
+    Field(() => CreateConnectionPipelineSummary, { nullable: true }),
+    __metadata("design:type", CreateConnectionPipelineSummary)
+], CreateConnectionOutput.prototype, "SchemaRefresh", void 0);
 CreateConnectionOutput = __decorate([
     ObjectType()
 ], CreateConnectionOutput);
@@ -961,6 +1148,10 @@ __decorate([
     Field({ nullable: true, defaultValue: 0 }),
     __metadata("design:type", Number)
 ], EntityMapInput.prototype, "Priority", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], EntityMapInput.prototype, "Configuration", void 0);
 __decorate([
     Field(() => [FieldMapInput], { nullable: true }),
     __metadata("design:type", Array)
@@ -1170,6 +1361,10 @@ __decorate([
     Field({ nullable: true }),
     __metadata("design:type", String)
 ], EntityMapUpdateInput.prototype, "Status", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], EntityMapUpdateInput.prototype, "Configuration", void 0);
 EntityMapUpdateInput = __decorate([
     InputType()
 ], EntityMapUpdateInput);
@@ -1203,6 +1398,10 @@ __decorate([
     Field({ nullable: true }),
     __metadata("design:type", String)
 ], EntityMapSummaryOutput.prototype, "Status", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], EntityMapSummaryOutput.prototype, "Configuration", void 0);
 EntityMapSummaryOutput = __decorate([
     ObjectType()
 ], EntityMapSummaryOutput);
@@ -1432,6 +1631,218 @@ __decorate([
 OperationProgressOutput = __decorate([
     ObjectType()
 ], OperationProgressOutput);
+// ── STRUCTURED RUN ARTIFACTS (durable JSONL progress streams) ─────────
+// These expose the IntegrationProgressReader over GraphQL so a tenant can ask,
+// at any time, "what exactly happened (or is happening) on this run?" — backed
+// by the append-only <cwd>/logs/integration-runs/<runID>/progress.jsonl files
+// that survive an MJAPI restart and grow as the run progresses. Poll
+// IntegrationTailRunEvents(runID, sinceSeq) to follow a live run incrementally.
+let IntegrationRunCountsOutput = class IntegrationRunCountsOutput {
+};
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], IntegrationRunCountsOutput.prototype, "Processed", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], IntegrationRunCountsOutput.prototype, "Succeeded", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], IntegrationRunCountsOutput.prototype, "Failed", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], IntegrationRunCountsOutput.prototype, "Skipped", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], IntegrationRunCountsOutput.prototype, "TotalKnown", void 0);
+IntegrationRunCountsOutput = __decorate([
+    ObjectType()
+], IntegrationRunCountsOutput);
+let IntegrationRunSummaryArtifactOutput = class IntegrationRunSummaryArtifactOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], IntegrationRunSummaryArtifactOutput.prototype, "RunID", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], IntegrationRunSummaryArtifactOutput.prototype, "RunKind", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationRunSummaryArtifactOutput.prototype, "IntegrationID", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationRunSummaryArtifactOutput.prototype, "CompanyIntegrationID", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationRunSummaryArtifactOutput.prototype, "ObjectName", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationRunSummaryArtifactOutput.prototype, "TriggerType", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], IntegrationRunSummaryArtifactOutput.prototype, "StartedAt", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], IntegrationRunSummaryArtifactOutput.prototype, "IsInFlight", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Number)
+], IntegrationRunSummaryArtifactOutput.prototype, "EventCount", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], IntegrationRunSummaryArtifactOutput.prototype, "Success", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationRunSummaryArtifactOutput.prototype, "ExitReason", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationRunSummaryArtifactOutput.prototype, "CompletedAt", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], IntegrationRunSummaryArtifactOutput.prototype, "DurationMs", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationRunSummaryArtifactOutput.prototype, "LatestEventType", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationRunSummaryArtifactOutput.prototype, "LatestMessage", void 0);
+__decorate([
+    Field(() => IntegrationRunCountsOutput, { nullable: true }),
+    __metadata("design:type", IntegrationRunCountsOutput)
+], IntegrationRunSummaryArtifactOutput.prototype, "Counts", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], IntegrationRunSummaryArtifactOutput.prototype, "WarningCount", void 0);
+__decorate([
+    Field(() => [String], { nullable: true }),
+    __metadata("design:type", Array)
+], IntegrationRunSummaryArtifactOutput.prototype, "Warnings", void 0);
+IntegrationRunSummaryArtifactOutput = __decorate([
+    ObjectType()
+], IntegrationRunSummaryArtifactOutput);
+let IntegrationRunEventOutput = class IntegrationRunEventOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], IntegrationRunEventOutput.prototype, "Ts", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Number)
+], IntegrationRunEventOutput.prototype, "Seq", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], IntegrationRunEventOutput.prototype, "EventType", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationRunEventOutput.prototype, "Level", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationRunEventOutput.prototype, "Stage", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationRunEventOutput.prototype, "Message", void 0);
+__decorate([
+    Field(() => IntegrationRunCountsOutput, { nullable: true }),
+    __metadata("design:type", IntegrationRunCountsOutput)
+], IntegrationRunEventOutput.prototype, "Counts", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationRunEventOutput.prototype, "DataJSON", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], IntegrationRunEventOutput.prototype, "ResumableStateJSON", void 0);
+IntegrationRunEventOutput = __decorate([
+    ObjectType()
+], IntegrationRunEventOutput);
+let IntegrationListRunsOutput = class IntegrationListRunsOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], IntegrationListRunsOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], IntegrationListRunsOutput.prototype, "Message", void 0);
+__decorate([
+    Field(() => [IntegrationRunSummaryArtifactOutput], { nullable: true }),
+    __metadata("design:type", Array)
+], IntegrationListRunsOutput.prototype, "Runs", void 0);
+IntegrationListRunsOutput = __decorate([
+    ObjectType()
+], IntegrationListRunsOutput);
+let IntegrationRunDetailOutput = class IntegrationRunDetailOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], IntegrationRunDetailOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], IntegrationRunDetailOutput.prototype, "Message", void 0);
+__decorate([
+    Field(() => IntegrationRunSummaryArtifactOutput, { nullable: true }),
+    __metadata("design:type", IntegrationRunSummaryArtifactOutput)
+], IntegrationRunDetailOutput.prototype, "Run", void 0);
+__decorate([
+    Field(() => [String], { nullable: true }),
+    __metadata("design:type", Array)
+], IntegrationRunDetailOutput.prototype, "Errors", void 0);
+IntegrationRunDetailOutput = __decorate([
+    ObjectType()
+], IntegrationRunDetailOutput);
+let IntegrationRunEventsOutput = class IntegrationRunEventsOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], IntegrationRunEventsOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], IntegrationRunEventsOutput.prototype, "Message", void 0);
+__decorate([
+    Field(() => [IntegrationRunEventOutput], { nullable: true }),
+    __metadata("design:type", Array)
+], IntegrationRunEventsOutput.prototype, "Events", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Number)
+], IntegrationRunEventsOutput.prototype, "LatestSeq", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], IntegrationRunEventsOutput.prototype, "IsInFlight", void 0);
+IntegrationRunEventsOutput = __decorate([
+    ObjectType()
+], IntegrationRunEventsOutput);
 // Sync progress is now tracked inside IntegrationEngine itself via IntegrationEngine.GetSyncProgress()
 let ConnectionSummaryOutput = class ConnectionSummaryOutput {
 };
@@ -1501,6 +1912,11 @@ const VALID_ENTITY_MAP_STATUSES = ['Active', 'Inactive'];
 function isValidEntityMapStatus(value) {
     return VALID_ENTITY_MAP_STATUSES.includes(value);
 }
+// IntegrationActionVerb is the engine-defined union ('Get'|'Create'|'Update'|'Delete'|'Search'|'List').
+const VALID_INTEGRATION_ACTION_VERBS = ['Get', 'Create', 'Update', 'Delete', 'Search', 'List'];
+function isValidIntegrationActionVerb(value) {
+    return VALID_INTEGRATION_ACTION_VERBS.includes(value);
+}
 // ─── List Source Objects (Full-Catalog Picker) ──────────────────────────────
 // Returns every object the source system exposes (e.g. all ~1,800 Salesforce
 // sobjects), merged with any existing IntegrationObject metadata so the UI
@@ -1771,6 +2187,144 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
             };
         }
     }
+    /**
+     * Refreshes the connector's IntegrationObject + IntegrationObjectField
+     * catalog by running the Phase 0 v5.39.x IntegrationConnectorCreationPipeline.
+     * The pipeline:
+     *   1. TestConnection      — validates credentials before any heavy work.
+     *   2. IntrospectSchema    — parallel describe across all objects.
+     *   3. PersistDiscoveredSchema — overlay-aware upsert (declared wins for
+     *      semantic, discovered wins for technical attributes), populates
+     *      MetadataSource and per-attribute AttributeWinners.
+     *   4. PKClassify          — SoftPKClassifier 4-tier cascade for any IO
+     *      that still lacks an explicit PK marker.
+     *
+     * Structured progress events ride the IntegrationProgressEmitter and land
+     * both on stdout (visible in the MJAPI log file) and in a per-run
+     * `<cwd>/logs/integration-runs/<runID>/progress.jsonl` artifact.
+     */
+    async IntegrationRefreshConnectorSchema(companyIntegrationID, universalPKConvention, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const provider = GetReadWriteProvider(ctx.providers);
+            const { connector, companyIntegration } = await this.resolveConnector(companyIntegrationID, user, provider);
+            const pipeline = new IntegrationConnectorCreationPipeline();
+            // Cast through unknown — duplicate package type declarations
+            // between integration-engine's resolved core-entities and this
+            // resolver's resolved core-entities (same shape, different
+            // identities at type level).
+            const runOpts = {
+                Connector: connector,
+                CompanyIntegration: companyIntegration,
+                ContextUser: user,
+                Provider: provider,
+                UniversalPKConvention: universalPKConvention || undefined,
+                ConsoleMirror: true,
+                TriggerType: 'Manual',
+            };
+            const result = await pipeline.Run(runOpts);
+            // Refresh the metadata cache so subsequent reads see the new IO/IOF
+            // rows the pipeline just wrote.  Without this the engine returns the
+            // pre-pipeline snapshot until the next process bootstrap.
+            const md = provider ?? new Metadata();
+            await md.Refresh();
+            await IntegrationEngine.Instance.Config(true, user, provider);
+            return {
+                Success: result.Success,
+                Message: result.Success
+                    ? `Refresh complete: ${result.PersistResult?.ObjectsCreated ?? 0} created, ${result.PersistResult?.ObjectsUpdated ?? 0} updated, ${result.UnresolvedObjects.length} IOs still PK-less (deferred to additionalSchemaInfo authoring)`
+                    : `Refresh failed: ${result.FailureMessage ?? 'unknown error'}`,
+                RunID: result.RunID,
+                ObjectsCreated: result.PersistResult?.ObjectsCreated,
+                ObjectsUpdated: result.PersistResult?.ObjectsUpdated,
+                FieldsCreated: result.PersistResult?.FieldsCreated,
+                FieldsUpdated: result.PersistResult?.FieldsUpdated,
+                PKVerdicts: result.PKVerdicts.map(v => ({
+                    ObjectName: v.ObjectName,
+                    Confident: v.Confident,
+                    Nominee: v.Nominee,
+                    Confidence: v.Confidence,
+                    Strategy: v.Strategy,
+                    Reason: v.Reason,
+                })),
+                UnresolvedObjects: result.UnresolvedObjects,
+                FailureMessage: result.FailureMessage,
+            };
+        }
+        catch (e) {
+            LogError(`IntegrationRefreshConnectorSchema error: ${this.formatError(e)}`);
+            return {
+                Success: false,
+                Message: `Error: ${this.formatError(e)}`,
+                RunID: 'error',
+            };
+        }
+    }
+    /**
+     * Generates + persists strongly-typed Action metadata on demand for an
+     * integration object. When `verb` is supplied, a single Action is generated
+     * for that (integration, object, verb); when omitted, all applicable verbs
+     * for the object are generated (Get/Search/List always, Create/Update/Delete
+     * only when the object supports writes).
+     *
+     * Idempotent: each generated Action is keyed on the deterministic Name
+     * "<Integration> - <Verb> <DisplayName>". An existing Action with that Name is
+     * reused (AlreadyExisted=true) and its params/result codes reconciled rather
+     * than duplicated. Generated Actions use DriverClass='IntegrationActionExecutor'
+     * and carry routing info ({IntegrationName, ObjectName, Verb}) in Action.Config_;
+     * the IntegrationActionExecutor (CoreActions) is the single runtime dispatcher.
+     */
+    async IntegrationGenerateAction(integrationName, objectName, verb, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const provider = GetReadWriteProvider(ctx.providers);
+            const generator = new IntegrationActionGenerator();
+            const results = await this.runActionGenerator(generator, integrationName, objectName, verb, user, provider);
+            return this.mapGenerateActionResults(results);
+        }
+        catch (e) {
+            LogError(`IntegrationGenerateAction error: ${this.formatError(e)}`);
+            return { Success: false, Message: `Error: ${this.formatError(e)}` };
+        }
+    }
+    /**
+     * Drives the engine's IntegrationActionGenerator: one verb when `verb` is a
+     * valid value, all applicable verbs when it is omitted. Casts user/provider
+     * through `unknown` at the boundary — integration-engine resolves its own copy
+     * of core/core-entities, so the types are structurally identical but nominally
+     * distinct (same bridge pattern used by IntegrationRefreshConnectorSchema).
+     */
+    async runActionGenerator(generator, integrationName, objectName, verb, user, provider) {
+        const u = user;
+        const p = provider;
+        if (verb != null && verb.length > 0) {
+            if (!isValidIntegrationActionVerb(verb)) {
+                throw new Error(`Invalid verb "${verb}". Must be one of: ${VALID_INTEGRATION_ACTION_VERBS.join(', ')}`);
+            }
+            const single = await generator.GenerateAction(integrationName, objectName, verb, u, p);
+            return [single];
+        }
+        return generator.GenerateActionsForObject(integrationName, objectName, u, p);
+    }
+    /** Maps engine GenerateIntegrationActionResult[] into the GraphQL output shape. */
+    mapGenerateActionResults(results) {
+        const mapped = results.map(r => ({
+            Success: r.Success,
+            ActionID: r.ActionID,
+            ActionName: r.ActionName,
+            AlreadyExisted: r.AlreadyExisted,
+            Verb: r.Verb,
+            ObjectName: r.ObjectName,
+            Message: r.Message,
+        }));
+        const successCount = mapped.filter(r => r.Success).length;
+        const overallSuccess = mapped.length > 0 && mapped.every(r => r.Success);
+        return {
+            Success: overallSuccess,
+            Message: `Generated ${successCount}/${mapped.length} action(s)`,
+            Results: mapped,
+        };
+    }
     /**
      * Returns the connector's default configuration for quick setup.
      * Not all connectors provide defaults — returns Success: false if unavailable.
@@ -2301,6 +2855,56 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
             throw new Error('System user not available');
         return sysUser;
     }
+    /**
+     * Per-company read-authorization check for run artifacts.
+     *
+     * Reuses MJ's established row-level-security pattern: a `RunView` on
+     * `MJ: Company Integrations` executed under the *calling user's* context.
+     * The data provider applies the same read-permission / RLS filtering it
+     * applies to every other user-context read, so the record only comes back
+     * when the caller is genuinely authorized to see that CompanyIntegration.
+     * No row returned ⇒ either the ID doesn't exist or the caller has no rights
+     * to it — in both cases we treat the caller as unauthorized.
+     *
+     * Results are memoized per call via the supplied `cache` map so a list of
+     * many runs sharing a CompanyIntegrationID incurs at most one lookup each.
+     */
+    async userCanReadCompanyIntegration(companyIntegrationID, user, cache) {
+        const cached = cache.get(companyIntegrationID);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const rv = new RunView();
+        const result = await rv.RunView({
+            EntityName: 'MJ: Company Integrations',
+            ExtraFilter: `ID='${companyIntegrationID}'`,
+            MaxRows: 1,
+            ResultType: 'simple',
+            Fields: ['ID']
+        }, user);
+        const authorized = result.Success && result.Results.length > 0;
+        cache.set(companyIntegrationID, authorized);
+        return authorized;
+    }
+    /**
+     * Authorizes the caller for a single run artifact based on the run's
+     * manifest CompanyIntegrationID. Returns true when the run is tenant-scoped
+     * and the caller is authorized for that CompanyIntegration. Returns false
+     * for tenant-scoped runs the caller may not read, OR for runs with no
+     * CompanyIntegrationID (non-tenant-scoped artifacts are not exposed through
+     * these per-company endpoints).
+     */
+    async userCanReadRunArtifact(snap, user, cache) {
+        const ciID = snap.manifest.companyIntegrationID;
+        if (!ciID) {
+            return false;
+        }
+        return this.userCanReadCompanyIntegration(ciID, user, cache);
+    }
+    /** Standard authorization-failure message for run-artifact endpoints. */
+    notAuthorizedForCompanyIntegrationMessage(companyIntegrationID) {
+        return `Not authorized to access runs for CompanyIntegration '${companyIntegrationID}'`;
+    }
     /**
      * Loads the CompanyIntegration + its parent Integration, then resolves the
      * appropriate connector via ConnectorFactory.
@@ -2356,6 +2960,126 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
         const testFn = connector.TestConnection.bind(connector);
         return testFn(companyIntegration, user);
     }
+    /**
+     * Runs IntegrationConnectorCreationPipeline + refreshes the metadata cache.
+     * Shared by IntegrationCreateConnection's auto-refresh path and the
+     * standalone IntegrationRefreshConnectorSchema mutation.
+     */
+    /**
+     * Reconstructs a `SourceSchemaInfo` from already-persisted IntegrationObject
+     * and IntegrationObjectField rows held by `IntegrationEngineBase`'s
+     * in-memory cache.
+     *
+     * Why this exists: after the Phase 0 v5.39.x `MJCompanyIntegrationEntityServer`
+     * hook fires the pipeline on `IsActive false→true`, the IO/IOF rows are
+     * already fresh.  The legacy `IntegrationApplyAllBatch` / `ApplyAll` /
+     * `ApplySchema` resolvers then called `connector.IntrospectSchema()` AGAIN
+     * to feed `SchemaBuilder`, which produced a second full vendor-API
+     * roundtrip (HubSpot 130 objects × 60+ DiscoverFields probes, ~100s
+     * wasted on the user's HubSpot run).  Using the persisted rows skips
+     * that round-trip entirely.
+     *
+     * Caveats:
+     *   - The persisted `Type` is the MJ canonical type (string / int / datetime / …),
+     *     NOT the original vendor source type.  `TypeMapper` in SchemaBuilder
+     *     accepts canonical types so DDL generation still works; if a connector
+     *     has unusual nuances around its source-type strings, fall back to live
+     *     introspect (the caller can pass `forceLive: true`).
+     *   - PrimaryKeyFields are recomputed from the IOF rows where
+     *     `IsPrimaryKey=true`.
+     *   - Foreign-key relationships are reconstructed from
+     *     `RelatedIntegrationObjectID` lookups against the same cache.
+     */
+    buildSourceSchemaFromPersistedRows(integrationID, requestedNames) {
+        const engine = IntegrationEngineBase.Instance;
+        const ios = engine.GetIntegrationObjectsByIntegrationID(integrationID);
+        const filter = requestedNames && requestedNames.length > 0
+            ? new Set(requestedNames.map(n => n.toLowerCase()))
+            : null;
+        // Cache (id → name) for FK relationship reconstruction.  Same-integration
+        // only — cross-integration relationships are not modeled in the slot table.
+        const ioByID = new Map();
+        for (const io of ios)
+            ioByID.set(io.ID, io.Name);
+        const result = { Objects: [] };
+        for (const io of ios) {
+            if (filter && !filter.has(io.Name.toLowerCase()))
+                continue;
+            const iofs = engine.GetIntegrationObjectFields(io.ID);
+            const fields = iofs.map(iof => {
+                const targetIOName = iof.RelatedIntegrationObjectID
+                    ? ioByID.get(iof.RelatedIntegrationObjectID) ?? null
+                    : null;
+                return {
+                    Name: iof.Name,
+                    Label: iof.DisplayName ?? iof.Name,
+                    Description: iof.Description ?? undefined,
+                    SourceType: iof.Type ?? 'string',
+                    IsRequired: iof.IsRequired ?? false,
+                    AllowsNull: iof.AllowsNull ?? undefined,
+                    MaxLength: iof.Length ?? null,
+                    Precision: iof.Precision ?? null,
+                    Scale: iof.Scale ?? null,
+                    DefaultValue: iof.DefaultValue ?? null,
+                    IsPrimaryKey: iof.IsPrimaryKey ?? false,
+                    IsUniqueKey: iof.IsUniqueKey ?? false,
+                    IsReadOnly: iof.IsReadOnly ?? false,
+                    IsForeignKey: !!iof.RelatedIntegrationObjectID,
+                    ForeignKeyTarget: targetIOName,
+                };
+            });
+            result.Objects.push({
+                ExternalName: io.Name,
+                ExternalLabel: io.DisplayName ?? io.Name,
+                Description: io.Description ?? undefined,
+                Fields: fields,
+                PrimaryKeyFields: fields.filter(f => f.IsPrimaryKey).map(f => f.Name),
+                Relationships: fields
+                    .filter(f => f.IsForeignKey && f.ForeignKeyTarget)
+                    .map(f => ({
+                    FieldName: f.Name,
+                    TargetObject: f.ForeignKeyTarget,
+                    TargetField: 'ID',
+                })),
+                IncrementalWatermarkField: io.IncrementalWatermarkField ?? undefined,
+            });
+        }
+        return result;
+    }
+    async runSchemaRefreshPipeline(companyIntegrationID, user, provider, universalPKConvention) {
+        const { connector, companyIntegration } = await this.resolveConnector(companyIntegrationID, user, provider);
+        const pipeline = new IntegrationConnectorCreationPipeline();
+        const runOpts = {
+            Connector: connector,
+            CompanyIntegration: companyIntegration,
+            ContextUser: user,
+            Provider: provider,
+            UniversalPKConvention: universalPKConvention || undefined,
+            ConsoleMirror: true,
+            TriggerType: 'Manual',
+        };
+        const result = await pipeline.Run(runOpts);
+        // Refresh in-memory caches so downstream queries (object picker,
+        // ApplyAll, etc.) see the just-written IO/IOF rows.
+        await (provider ?? new Metadata()).Refresh();
+        await IntegrationEngine.Instance.Config(true, user, provider);
+        return {
+            RunID: result.RunID,
+            ObjectsCreated: result.PersistResult?.ObjectsCreated ?? 0,
+            ObjectsUpdated: result.PersistResult?.ObjectsUpdated ?? 0,
+            FieldsCreated: result.PersistResult?.FieldsCreated ?? 0,
+            FieldsUpdated: result.PersistResult?.FieldsUpdated ?? 0,
+            UnresolvedObjects: result.UnresolvedObjects,
+            PKVerdicts: result.PKVerdicts.map(v => ({
+                ObjectName: v.ObjectName,
+                Confident: v.Confident,
+                Nominee: v.Nominee,
+                Confidence: v.Confidence,
+                Strategy: v.Strategy,
+                Reason: v.Reason,
+            })),
+        };
+    }
     /**
      * Rolls back a freshly created connection by deleting both the CompanyIntegration and Credential records.
      */
@@ -2373,6 +3097,40 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
             LogError(`Rollback: failed to delete Credential: ${this.formatError(e)}`);
         }
     }
+    /**
+     * Cascades the deletion of a CompanyIntegration's linked Credential as part of the
+     * supplied TransactionGroup, so the encrypted-credential row is removed atomically
+     * with the rest of the connection cascade (rolls back together on tg failure).
+     *
+     * Safety:
+     *  - No-op when {@link credentialID} is null/empty.
+     *  - Skips the delete when ANOTHER CompanyIntegration still references the same
+     *    CredentialID (shared credential) — only the sole referencer may delete it.
+     *
+     * @returns true if the credential was attached to the tg for deletion; false otherwise.
+     */
+    async cascadeDeleteCredential(credentialID, companyIntegrationID, tg, rv, provider, user) {
+        if (!credentialID)
+            return false; // no linked credential — nothing to do
+        // Shared-credential safety: do not delete if any OTHER CompanyIntegration uses it.
+        const sharedResult = await rv.RunView({
+            EntityName: 'MJ: Company Integrations',
+            ExtraFilter: `CredentialID='${credentialID}' AND ID<>'${companyIntegrationID}'`,
+            ResultType: 'simple',
+            Fields: ['ID']
+        }, user);
+        if (sharedResult.Success && sharedResult.Results.length > 0) {
+            LogStatus(`IntegrationDeleteConnection: credential ${credentialID} is shared by ${sharedResult.Results.length} other connection(s); leaving it in place`);
+            return false;
+        }
+        const credential = await provider.GetEntityObject('MJ: Credentials', user);
+        const loaded = await credential.InnerLoad(CompositeKey.FromID(credentialID));
+        if (!loaded)
+            return false; // already gone — treat as nothing to cascade
+        credential.TransactionGroup = tg;
+        await credential.Delete();
+        return true;
+    }
     /**
      * Snapshots the current credential Values for a given credential ID so they can be restored on rollback.
      */
@@ -2472,7 +3230,7 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
     /**
      * Creates a CompanyIntegration with a linked Credential entity for encrypted credential storage.
      */
-    async IntegrationCreateConnection(input, testConnection, ctx) {
+    async IntegrationCreateConnection(input, testConnection, runSchemaRefresh, universalPKConvention, ctx) {
         try {
             const user = this.getAuthenticatedUser(ctx);
             const md = GetReadWriteProvider(ctx.providers, { allowFallbackToReadOnly: true });
@@ -2507,6 +3265,8 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                 return { Success: false, Message: `Failed to save CompanyIntegration: ${validationErrors}` };
             }
             // 3. Optionally test the connection; rollback on failure
+            let testPassed = !testConnection; // if no test asked, treat as "passed" so the refresh below still runs
+            let testMessage = '';
             if (testConnection) {
                 const testResult = await this.testConnectionForCI(ci.ID, user, md);
                 if (!testResult.Success) {
@@ -2518,13 +3278,36 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                         ConnectionTestMessage: testResult.Message
                     };
                 }
+                testPassed = true;
+                testMessage = testResult.Message;
+            }
+            // 4. Auto-run schema refresh pipeline (intermittent server-side period).
+            // Fires whenever runSchemaRefresh=true, regardless of whether the
+            // caller also asked for a test.  The wizard may have tested separately
+            // and just be hitting Create to save.
+            let schemaRefreshSummary;
+            if (runSchemaRefresh) {
+                try {
+                    const refreshResult = await this.runSchemaRefreshPipeline(ci.ID, user, md, universalPKConvention);
+                    schemaRefreshSummary = refreshResult;
+                }
+                catch (refreshErr) {
+                    // Refresh failure does NOT roll back the connection —
+                    // user can re-run via IntegrationRefreshConnectorSchema.
+                    LogError(`IntegrationCreateConnection: pipeline error — ${refreshErr}`);
+                }
+            }
+            if (testConnection || schemaRefreshSummary) {
                 return {
                     Success: true,
-                    Message: 'Connection created and test passed',
+                    Message: schemaRefreshSummary
+                        ? `Connection created${testConnection ? ', test passed' : ''}, schema refresh: ${schemaRefreshSummary.ObjectsCreated} created, ${schemaRefreshSummary.ObjectsUpdated} updated, ${schemaRefreshSummary.UnresolvedObjects.length} PK-unresolved`
+                        : 'Connection created and test passed',
                     CompanyIntegrationID: ci.ID,
                     CredentialID: credentialID,
-                    ConnectionTestSuccess: true,
-                    ConnectionTestMessage: testResult.Message
+                    ConnectionTestSuccess: testPassed,
+                    ConnectionTestMessage: testMessage,
+                    SchemaRefresh: schemaRefreshSummary,
                 };
             }
             return {
@@ -2542,7 +3325,7 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
     /**
      * Updates credential values and/or configuration on an existing CompanyIntegration.
      */
-    async IntegrationUpdateConnection(companyIntegrationID, credentialValues, configuration, externalSystemID, testConnection, ctx) {
+    async IntegrationUpdateConnection(companyIntegrationID, credentialValues, configuration, externalSystemID, testConnection, runSchemaRefresh, universalPKConvention, ctx) {
         try {
             const user = this.getAuthenticatedUser(ctx);
             const md = GetReadWriteProvider(ctx.providers, { allowFallbackToReadOnly: true });
@@ -2586,7 +3369,23 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                     await this.revertUpdateConnection(ci, oldConfiguration, oldExternalSystemID, oldCredentialValues, user, md);
                     return { Success: false, Message: `Connection test failed: ${testResult.Message}. Changes have been reverted.` };
                 }
-                return { Success: true, Message: 'Updated and connection test passed' };
+            }
+            // Auto-run schema refresh pipeline (intermittent server-side period).
+            // Fires whenever runSchemaRefresh=true, regardless of whether the
+            // caller also asked for a test — the wizard may have tested separately
+            // already and is just hitting Update to save edits.
+            if (runSchemaRefresh) {
+                try {
+                    const refreshResult = await this.runSchemaRefreshPipeline(companyIntegrationID, user, md, universalPKConvention);
+                    return {
+                        Success: true,
+                        Message: `Updated, schema refresh: ${refreshResult.ObjectsCreated} created, ${refreshResult.ObjectsUpdated} updated, ${refreshResult.UnresolvedObjects.length} PK-unresolved`,
+                    };
+                }
+                catch (refreshErr) {
+                    LogError(`IntegrationUpdateConnection: pipeline error — ${refreshErr}`);
+                    return { Success: true, Message: `Updated (schema refresh failed: ${this.formatError(refreshErr)})` };
+                }
             }
             return { Success: true, Message: 'Updated' };
         }
@@ -2671,25 +3470,54 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                 if (!entityID) {
                     return { Success: false, Message: `No EntityID or EntityName for "${mapDef.ExternalObjectName}"`, Created: created };
                 }
-                const em = await md.GetEntityObject('MJ: Company Integration Entity Maps', user);
-                em.NewRecord();
-                em.CompanyIntegrationID = companyIntegrationID;
-                em.ExternalObjectName = mapDef.ExternalObjectName;
-                em.EntityID = entityID;
                 const syncDir = mapDef.SyncDirection || 'Pull';
                 if (!isValidSyncDirection(syncDir)) {
                     return { Success: false, Message: `Invalid SyncDirection "${syncDir}" for "${mapDef.ExternalObjectName}". Must be one of: ${VALID_SYNC_DIRECTIONS.join(', ')}`, Created: created };
                 }
+                // Create-or-reuse by (connection, external object) — same idempotency rule as ApplyAll's
+                // createSingleEntityMap. A blind NewRecord() here duplicates maps on every re-apply.
+                const escapedObjectName = mapDef.ExternalObjectName.replace(/'/g, "''");
+                const existingMapResult = await new RunView().RunView({
+                    EntityName: 'MJ: Company Integration Entity Maps',
+                    ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}' AND ExternalObjectName='${escapedObjectName}'`,
+                    OrderBy: '__mj_CreatedAt ASC',
+                    MaxRows: 1,
+                    ResultType: 'entity_object',
+                    BypassCache: true, // idempotency must read COMMITTED state, not a possibly-stale filtered cache
+                }, user);
+                let em;
+                if (existingMapResult.Success && existingMapResult.Results.length > 0) {
+                    em = existingMapResult.Results[0];
+                }
+                else {
+                    em = await md.GetEntityObject('MJ: Company Integration Entity Maps', user);
+                    em.NewRecord();
+                    em.CompanyIntegrationID = companyIntegrationID;
+                    em.ExternalObjectName = mapDef.ExternalObjectName;
+                }
+                em.EntityID = entityID;
                 em.SyncDirection = syncDir;
                 em.Priority = mapDef.Priority || 0;
                 em.Status = 'Active';
+                if (mapDef.Configuration != null)
+                    em.Configuration = mapDef.Configuration;
                 if (!await em.Save()) {
                     return { Success: false, Message: `Failed to create map for ${mapDef.ExternalObjectName}`, Created: created };
                 }
                 const entityMapID = em.ID;
-                // Create field maps if provided
+                // Create field maps if provided (skip ones already mapped for this entity map)
                 if (mapDef.FieldMaps) {
+                    const existingFieldMaps = await new RunView().RunView({
+                        EntityName: 'MJ: Company Integration Field Maps',
+                        ExtraFilter: `EntityMapID='${entityMapID}'`,
+                        Fields: ['SourceFieldName'],
+                        ResultType: 'simple',
+                        BypassCache: true, // read committed field-map state for the idempotency skip
+                    }, user);
+                    const alreadyMapped = new Set((existingFieldMaps.Results ?? []).map(r => (r.SourceFieldName ?? '').toLowerCase()));
                     for (const fmDef of mapDef.FieldMaps) {
+                        if (alreadyMapped.has((fmDef.SourceFieldName ?? '').toLowerCase()))
+                            continue;
                         const fm = await md.GetEntityObject('MJ: Company Integration Field Maps', user);
                         fm.NewRecord();
                         fm.EntityMapID = entityMapID;
@@ -2728,10 +3556,21 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
             const user = this.getAuthenticatedUser(ctx);
             const provider = GetReadWriteProvider(ctx.providers, { allowFallbackToReadOnly: true });
             const { connector, companyIntegration } = await this.resolveConnector(companyIntegrationID, user, provider);
-            const introspect = connector.IntrospectSchema.bind(connector);
-            const sourceSchema = await introspect(companyIntegration, user);
-            await this.resolveObjectInputs(objects, sourceSchema, user);
+            // Reconstruct source schema from the IO/IOF rows already persisted by
+            // the Phase 0 v5.39.x Save hook.  Fall back to live IntrospectSchema only
+            // for direct-API callers bypassing the wizard (empty IO cache).
             const requestedNames = new Set(objects.map(o => o.SourceObjectName));
+            let sourceSchema = this.buildSourceSchemaFromPersistedRows(companyIntegration.IntegrationID, Array.from(requestedNames));
+            if (sourceSchema.Objects.length === 0) {
+                LogError(`[IntegrationApplySchema] Persisted IO cache empty for ${companyIntegration.Integration}; falling back to live introspect.`);
+                const introspect = connector.IntrospectSchema.bind(connector);
+                sourceSchema = await introspect(companyIntegration, user);
+            }
+            else {
+                console.log(`[IntegrationApplySchema] Reusing ${sourceSchema.Objects.length} persisted IOs for ${companyIntegration.Integration} ` +
+                    `— skipped duplicate IntrospectSchema (Save-hook already discovered).`);
+            }
+            await this.resolveObjectInputs(objects, sourceSchema, user);
             const filteredSchema = {
                 Objects: sourceSchema.Objects.filter(o => requestedNames.has(o.ExternalName))
             };
@@ -2849,67 +3688,75 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
             // Step 1: Resolve connector and derive schema name
             const { connector, companyIntegration } = await this.resolveConnector(input.CompanyIntegrationID, user, provider);
             const schemaName = this.deriveSchemaName(companyIntegration.Integration);
-            // Step 1b: Ensure IntegrationEngine cache is populated so IntrospectSchema's
-            // DB fallback (GetCachedObject/GetCachedFields) can find IntegrationObject records
+            // Step 1b: Ensure IntegrationEngine cache is populated so the persisted
+            // IO/IOF rows are available for reconstruction below.
             await IntegrationEngine.Instance.Config(false, user);
-            // Step 2: Introspect source schema and persist discovered objects/fields
-            const sourceSchema = await connector.IntrospectSchema.bind(connector)(companyIntegration, user);
-            // Step 2b: Persist discovered objects/fields to IntegrationObject/IntegrationObjectField.
-            // Static records (IsCustom=false) are preserved; new/custom records get IsCustom=true.
-            // This ensures custom objects are available for future sync runs, action generation, etc.
-            try {
-                const persistResult = await IntegrationSchemaSync.PersistDiscoveredSchema({
-                    IntegrationID: companyIntegration.IntegrationID,
-                    SourceSchema: sourceSchema,
-                    ContextUser: user,
-                });
-                if (persistResult.ObjectsCreated > 0 || persistResult.FieldsCreated > 0) {
-                    console.log(`[IntegrationApplyAll] Persisted discovered schema: ` +
-                        `${persistResult.ObjectsCreated} new objects, ${persistResult.FieldsCreated} new fields, ` +
-                        `${persistResult.ObjectsUpdated} updated objects, ${persistResult.FieldsUpdated} updated fields`);
-                }
-                // Step 2c: Generate CRUD actions for newly discovered custom objects.
-                // Uses the same ActionMetadataGenerator as the offline CLI, persisted via BaseEntity.Save().
-                if (persistResult.ObjectsCreated > 0) {
-                    try {
-                        const engineObjects = IntegrationEngine.Instance
-                            .GetIntegrationObjectsByIntegrationID(companyIntegration.IntegrationID);
-                        const customObjects = sourceSchema.Objects
-                            .filter(o => !engineObjects
-                            .some(ex => ex.Name.toLowerCase() === o.ExternalName.toLowerCase() && !ex.IsCustom))
-                            .map(o => ({
-                            Name: o.ExternalName,
-                            DisplayName: o.ExternalLabel || o.ExternalName,
-                            Description: o.Description,
-                            SupportsWrite: false,
-                            Fields: o.Fields.map(f => ({
-                                Name: f.Name,
-                                DisplayName: f.Label || f.Name,
-                                Description: f.Description || '',
-                                Type: f.SourceType || 'string',
-                                IsRequired: f.IsRequired,
-                                IsReadOnly: false,
-                                IsPrimaryKey: f.IsPrimaryKey,
-                            })),
-                        }));
-                        await IntegrationSchemaSync.GenerateActionsForCustomObjects({
-                            IntegrationName: companyIntegration.Integration,
-                            CustomObjects: customObjects,
-                            SupportsSearch: connector.SupportsSearch,
-                            SupportsListing: connector.SupportsListing,
-                            ContextUser: user,
-                        });
+            // Step 2: Reconstruct SourceSchemaInfo from the persisted IO/IOF rows
+            // (already freshened by the Phase 0 v5.39.x MJCompanyIntegrationEntityServer
+            // Save hook on IsActive false→true).  Avoids the duplicate vendor-API
+            // introspect that used to fire here.
+            let sourceSchema = this.buildSourceSchemaFromPersistedRows(companyIntegration.IntegrationID);
+            if (sourceSchema.Objects.length === 0) {
+                // Fallback: the engine cache is empty (Save hook didn't run, or this
+                // is a direct-API caller bypassing the wizard).  Do a one-time live
+                // introspect + persist + action-generation so the apply still proceeds.
+                LogError(`[IntegrationApplyAll] Persisted IO cache empty for ${companyIntegration.Integration}; falling back to live introspect.`);
+                sourceSchema = await connector.IntrospectSchema.bind(connector)(companyIntegration, user);
+                try {
+                    const persistResult = await IntegrationSchemaSync.PersistDiscoveredSchema({
+                        IntegrationID: companyIntegration.IntegrationID,
+                        SourceSchema: sourceSchema,
+                        ContextUser: user,
+                    });
+                    if (persistResult.ObjectsCreated > 0 || persistResult.FieldsCreated > 0) {
+                        console.log(`[IntegrationApplyAll] Fallback persist: ` +
+                            `${persistResult.ObjectsCreated} new objects, ${persistResult.FieldsCreated} new fields, ` +
+                            `${persistResult.ObjectsUpdated} updated objects, ${persistResult.FieldsUpdated} updated fields`);
                     }
-                    catch (actionErr) {
-                        const msg = actionErr instanceof Error ? actionErr.message : String(actionErr);
-                        console.warn(`[IntegrationApplyAll] Action generation warning (non-fatal): ${msg}`);
+                    if (persistResult.ObjectsCreated > 0) {
+                        try {
+                            const engineObjects = IntegrationEngine.Instance
+                                .GetIntegrationObjectsByIntegrationID(companyIntegration.IntegrationID);
+                            const customObjects = sourceSchema.Objects
+                                .filter(o => !engineObjects
+                                .some(ex => ex.Name.toLowerCase() === o.ExternalName.toLowerCase() && !ex.IsCustom))
+                                .map(o => ({
+                                Name: o.ExternalName,
+                                DisplayName: o.ExternalLabel || o.ExternalName,
+                                Description: o.Description,
+                                SupportsWrite: false,
+                                Fields: o.Fields.map(f => ({
+                                    Name: f.Name,
+                                    DisplayName: f.Label || f.Name,
+                                    Description: f.Description || '',
+                                    Type: f.SourceType || 'string',
+                                    IsRequired: f.IsRequired,
+                                    IsReadOnly: false,
+                                    IsPrimaryKey: f.IsPrimaryKey,
+                                })),
+                            }));
+                            await IntegrationSchemaSync.GenerateActionsForCustomObjects({
+                                IntegrationName: companyIntegration.Integration,
+                                CustomObjects: customObjects,
+                                SupportsSearch: connector.SupportsSearch,
+                                SupportsListing: connector.SupportsListing,
+                                ContextUser: user,
+                            });
+                        }
+                        catch (actionErr) {
+                            const msg = actionErr instanceof Error ? actionErr.message : String(actionErr);
+                            console.warn(`[IntegrationApplyAll] Action generation warning (non-fatal): ${msg}`);
+                        }
                     }
                 }
+                catch (persistErr) {
+                    const msg = persistErr instanceof Error ? persistErr.message : String(persistErr);
+                    console.warn(`[IntegrationApplyAll] Schema persistence warning (non-fatal): ${msg}`);
+                }
             }
-            catch (persistErr) {
-                // Non-fatal: schema persistence failure should not block table creation
-                const msg = persistErr instanceof Error ? persistErr.message : String(persistErr);
-                console.warn(`[IntegrationApplyAll] Schema persistence warning (non-fatal): ${msg}`);
+            else {
+                console.log(`[IntegrationApplyAll] Reusing ${sourceSchema.Objects.length} persisted IOs for ${companyIntegration.Integration} ` +
+                    `— skipped duplicate IntrospectSchema (Save-hook already discovered).`);
             }
             const resolved = await this.resolveSourceObjectsToNames(input.SourceObjects, sourceSchema, user);
             const resolvedNames = resolved.names;
@@ -3073,11 +3920,30 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
             LogError(`IntegrationApplyAll: entity not found for ${schemaName}.${obj.TableName}`);
             return null;
         }
-        // Create entity map
-        const em = await md.GetEntityObject('MJ: Company Integration Entity Maps', user);
-        em.NewRecord();
-        em.CompanyIntegrationID = companyIntegrationID;
-        em.ExternalObjectName = obj.SourceObjectName;
+        // Create-or-reuse the entity map. Idempotency is REQUIRED here: ApplyAll is re-run on
+        // every wizard re-apply (and by the test harness on every pull). Blindly NewRecord()-ing
+        // multiplies the maps in lockstep (N applies → N duplicate maps per object), which
+        // silently corrupts the record-map 1:1 completeness gate and makes the forward sync
+        // process each object N times. Reuse the existing (connection, external object) map instead.
+        const escapedObjectName = obj.SourceObjectName.replace(/'/g, "''");
+        const existingMapResult = await new RunView().RunView({
+            EntityName: 'MJ: Company Integration Entity Maps',
+            ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}' AND ExternalObjectName='${escapedObjectName}'`,
+            OrderBy: '__mj_CreatedAt ASC',
+            MaxRows: 1,
+            ResultType: 'entity_object',
+            BypassCache: true, // idempotency must read COMMITTED state, not a possibly-stale filtered cache
+        }, user);
+        let em;
+        if (existingMapResult.Success && existingMapResult.Results.length > 0) {
+            em = existingMapResult.Results[0]; // reuse — keeps the map stable across re-applies
+        }
+        else {
+            em = await md.GetEntityObject('MJ: Company Integration Entity Maps', user);
+            em.NewRecord();
+            em.CompanyIntegrationID = companyIntegrationID;
+            em.ExternalObjectName = obj.SourceObjectName;
+        }
         em.EntityID = entityInfo.ID;
         em.SyncDirection = isValidSyncDirection(defaultSyncDirection) ? defaultSyncDirection : 'Pull';
         em.Priority = obj.SourceObjectName.startsWith('assoc_') ? 10 : 0;
@@ -3102,7 +3968,21 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
         try {
             const discoverFields = connector.DiscoverFields.bind(connector);
             const fields = await discoverFields(companyIntegration, sourceObjectName, user);
+            // Idempotency (mirrors the entity-map reuse above): don't re-create field maps that
+            // already exist for this entity map, or re-applies multiply them in lockstep.
+            const existingFieldMaps = await new RunView().RunView({
+                EntityName: 'MJ: Company Integration Field Maps',
+                ExtraFilter: `EntityMapID='${entityMapID}'`,
+                Fields: ['SourceFieldName'],
+                ResultType: 'simple',
+                BypassCache: true, // read committed field-map state for the idempotency skip
+            }, user);
+            const alreadyMapped = new Set((existingFieldMaps.Results ?? []).map(r => (r.SourceFieldName ?? '').toLowerCase()));
             for (const field of fields) {
+                if (alreadyMapped.has(field.Name.toLowerCase())) {
+                    fieldCount++; // already present — count it so the reported total stays stable
+                    continue;
+                }
                 const fm = await md.GetEntityObject('MJ: Company Integration Field Maps', user);
                 fm.NewRecord();
                 fm.EntityMapID = entityMapID;
@@ -3162,20 +4042,34 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
      */
     async buildSchemaForConnector(companyIntegrationID, objects, platform, user, skipGitCommit, skipRestart, provider, prefetchedSourceSchema) {
         const { connector, companyIntegration } = await this.resolveConnector(companyIntegrationID, user, provider);
-        // If the caller already ran IntrospectSchema (e.g. IntegrationApplyAllBatch),
-        // reuse it. The legacy path was running introspect TWICE per apply — once
-        // in the resolver and once here — which doubled probe time on connectors
-        // like Sage Intacct AND silently dropped selections when the second pass
-        // returned fewer objects than the first (rate limits, transient errors).
-        // The picked items would then fail to match `filteredSchema` below and
-        // get silently stripped before reaching buildTargetConfigs.
+        // Source-schema resolution order:
+        //   1. Use prefetched schema if the caller passed one (legacy ApplyAllBatch path).
+        //   2. Reconstruct from persisted IO/IOF rows — the Phase 0 v5.39.x Save hook
+        //      already discovered + persisted everything when the wizard flipped
+        //      `IsActive false→true`.  No need to re-hit the vendor API.
+        //   3. Only when both above are empty do we fall back to live IntrospectSchema
+        //      (direct-API callers bypassing the wizard).
+        //
+        // Pre-Phase-0 the legacy path ran introspect TWICE per apply — once in the
+        // resolver and once here — which doubled probe time on connectors like Sage
+        // Intacct AND silently dropped selections when the second pass returned
+        // fewer objects than the first (rate limits, transient errors).
         let sourceSchema;
         if (prefetchedSourceSchema) {
             sourceSchema = prefetchedSourceSchema;
         }
         else {
-            const introspect = connector.IntrospectSchema.bind(connector);
-            sourceSchema = await introspect(companyIntegration, user);
+            const requestedNamesForReuse = objects.map(o => o.SourceObjectName);
+            sourceSchema = this.buildSourceSchemaFromPersistedRows(companyIntegration.IntegrationID, requestedNamesForReuse);
+            if (sourceSchema.Objects.length === 0) {
+                LogError(`[buildSchemaForConnector] Persisted IO cache empty for ${companyIntegration.Integration}; falling back to live introspect.`);
+                const introspect = connector.IntrospectSchema.bind(connector);
+                sourceSchema = await introspect(companyIntegration, user);
+            }
+            else {
+                console.log(`[buildSchemaForConnector] Reusing ${sourceSchema.Objects.length} persisted IOs for ${companyIntegration.Integration} ` +
+                    `— skipped duplicate IntrospectSchema (Save-hook already discovered).`);
+            }
         }
         // Normalize names to match source schema casing
         const nameMap = new Map(sourceSchema.Objects.map(o => [o.ExternalName.toLowerCase(), o.ExternalName]));
@@ -3218,6 +4112,16 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
         try {
             const user = this.getAuthenticatedUser(ctx);
             await IntegrationEngine.Instance.Config(false, user);
+            // Reject upfront if the connector is deactivated. The engine also gates this
+            // authoritatively (no run record is created), but returning Success:false here gives the
+            // client immediate, unambiguous feedback instead of an optimistic fire-and-forget that
+            // silently no-ops. IsActive is boolean|null — only an explicit false rejects (null/unset
+            // connections predating the flag are unaffected).
+            const ciProvider = GetReadOnlyProvider(ctx.providers, { allowFallbackToReadWrite: true });
+            const ciCheck = await ciProvider.GetEntityObject('MJ: Company Integrations', user);
+            if (await ciCheck.InnerLoad(CompositeKey.FromID(companyIntegrationID)) && ciCheck.IsActive === false) {
+                return { Success: false, Message: 'Connector is deactivated (IsActive=false); sync not started' };
+            }
             const syncOptions = {};
             if (fullSync)
                 syncOptions.FullSync = true;
@@ -3313,9 +4217,12 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                 return { Success: false, Message: `Company Integration not found: ${companyIntegrationID}` };
             }
             const companyIntegration = ciResult.Results[0];
-            // Load the Integration entity to get the ClassName for connector resolution
+            // Load the Integration entity to get the ClassName for connector resolution.
+            // Entity is registered as 'MJ: Integrations' (the "MJ: " prefix is required — the sibling
+            // CompanyIntegration lookup above uses 'MJ: Company Integrations'); the bare 'Integrations'
+            // name is not in metadata, which dead-lettered the entire IntegrationWriteRecord (push) path.
             const integResult = await rv.RunView({
-                EntityName: 'Integrations',
+                EntityName: 'MJ: Integrations',
                 ExtraFilter: `ID='${companyIntegration.IntegrationID}'`,
                 MaxRows: 1,
                 ResultType: 'entity_object',
@@ -3585,7 +4492,8 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                 ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
                 OrderBy: 'Priority ASC',
                 ResultType: 'simple',
-                Fields: ['ID', 'EntityID', 'Entity', 'ExternalObjectName', 'SyncDirection', 'Priority', 'Status']
+                Fields: ['ID', 'EntityID', 'Entity', 'ExternalObjectName', 'SyncDirection', 'Priority', 'Status', 'Configuration'],
+                BypassCache: true, // operational list must reflect COMMITTED state (wizard/lifecycle act on it)
             }, user);
             if (!result.Success)
                 return { Success: false, Message: result.ErrorMessage || 'Query failed' };
@@ -3609,6 +4517,7 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                 ExtraFilter: `EntityMapID='${entityMapID}'`,
                 OrderBy: 'SourceFieldName',
                 ResultType: 'simple',
+                BypassCache: true, // operational list must reflect COMMITTED state
                 Fields: ['ID', 'EntityMapID', 'SourceFieldName', 'DestinationFieldName', 'Status']
             }, user);
             if (!result.Success)
@@ -3645,6 +4554,8 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                 }
                 if (update.Priority != null)
                     em.Priority = update.Priority;
+                if (update.Configuration != null)
+                    em.Configuration = update.Configuration;
                 if (update.Status != null) {
                     if (!isValidEntityMapStatus(update.Status)) {
                         errors.push(`${update.EntityMapID}: invalid Status "${update.Status}"`);
@@ -3653,7 +4564,7 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                     em.Status = update.Status;
                 }
                 if (!await em.Save())
-                    errors.push(`${update.EntityMapID}: failed to save`);
+                    errors.push(`${update.EntityMapID}: failed to save — ${em.LatestResult?.CompleteMessage ?? 'unknown error'}`);
             }
             if (errors.length > 0)
                 return { Success: false, Message: `Errors: ${errors.join('; ')}` };
@@ -3796,7 +4707,11 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                     EntityName: 'MJ: Company Integration Entity Maps',
                     ExtraFilter: `CompanyIntegrationID='${companyIntegrationID}'`,
                     ResultType: 'simple',
-                    Fields: ['ID', 'Status']
+                    Fields: ['ID', 'Status'],
+                    // Status must reflect the live state immediately after a deselect/reselect
+                    // (UpdateEntityMaps). Bypass the server RunView cache so ActiveEntityMaps never
+                    // reports a stale count right after a map's Status is toggled.
+                    BypassCache: true
                 },
                 {
                     EntityName: 'MJ: Company Integration Runs',
@@ -3804,7 +4719,8 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                     OrderBy: 'StartedAt DESC',
                     MaxRows: 1,
                     ResultType: 'simple',
-                    Fields: ['ID', 'Status', 'StartedAt', 'EndedAt', 'TotalRecords']
+                    Fields: ['ID', 'Status', 'StartedAt', 'EndedAt', 'TotalRecords'],
+                    BypassCache: true
                 }
             ], user);
             const maps = mapsResult.Success ? mapsResult.Results : [];
@@ -3862,6 +4778,171 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
             return { Success: false, Message: this.formatError(e) };
         }
     }
+    // ── STRUCTURED RUN ARTIFACTS (durable, growing JSONL streams) ────────
+    /**
+     * Lists integration runs (sync, connector-creation, RSU, discovery, …) from the
+     * durable progress-artifact store, newest-first. Use this to render run history
+     * with live status for a multi-tenant control surface. Optionally scope to a
+     * single connector and/or run kind, or to only in-flight runs.
+     */
+    async IntegrationListRuns(ctx, companyIntegrationID, runKind, inFlightOnly, limit) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            // When a specific connector is requested, authorize it up front so an
+            // unauthorized caller gets a clear denial rather than an empty list.
+            const authCache = new Map();
+            if (companyIntegrationID) {
+                const authorized = await this.userCanReadCompanyIntegration(companyIntegrationID, user, authCache);
+                if (!authorized) {
+                    return { Success: false, Message: this.notAuthorizedForCompanyIntegrationMessage(companyIntegrationID) };
+                }
+            }
+            const reader = new IntegrationProgressReader();
+            const snaps = await reader.ListRuns({
+                companyIntegrationID,
+                runKind: runKind,
+                inFlightOnly: inFlightOnly ?? false,
+            }, limit ?? 50);
+            // Filter to only the runs the caller is authorized to read. When
+            // scoped to a single (already-authorized) connector this is a no-op;
+            // for the cross-connector listing it prevents one tenant from seeing
+            // another tenant's runs.
+            const authorizedSnaps = await this.filterAuthorizedRuns(snaps, user, authCache);
+            return { Success: true, Message: `${authorizedSnaps.length} run(s)`, Runs: authorizedSnaps.map(s => this.toRunSummaryArtifact(s)) };
+        }
+        catch (e) {
+            LogError(`IntegrationListRuns error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    /** Returns only the run snapshots the caller is authorized to read. */
+    async filterAuthorizedRuns(snaps, user, authCache) {
+        const authorized = [];
+        for (const snap of snaps) {
+            if (await this.userCanReadRunArtifact(snap, user, authCache)) {
+                authorized.push(snap);
+            }
+        }
+        return authorized;
+    }
+    /**
+     * Returns the summary of a single run (manifest + terminal result + latest counts).
+     * Pair with IntegrationTailRunEvents to read the full event stream.
+     */
+    async IntegrationGetRun(runID, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const reader = new IntegrationProgressReader();
+            const snap = await reader.GetRun(runID);
+            if (!snap)
+                return { Success: false, Message: `Run '${runID}' not found` };
+            const authorized = await this.userCanReadRunArtifact(snap, user, new Map());
+            if (!authorized) {
+                const ciID = snap.manifest.companyIntegrationID;
+                return {
+                    Success: false,
+                    Message: ciID
+                        ? this.notAuthorizedForCompanyIntegrationMessage(ciID)
+                        : `Not authorized to access run '${runID}'`,
+                };
+            }
+            return {
+                Success: true,
+                Message: 'OK',
+                Run: this.toRunSummaryArtifact(snap),
+                Errors: snap.result?.errors?.map(er => er.stage ? `[${er.stage}] ${er.message}` : er.message),
+            };
+        }
+        catch (e) {
+            LogError(`IntegrationGetRun error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
+    /**
+     * Tails a run's structured event stream from a given sequence number. The stream
+     * grows over the life of the run, so a client polls with the last LatestSeq it
+     * saw to fetch only the new events. IsInFlight=false signals the run is terminal
+     * and polling can stop.
+     */
+    async IntegrationTailRunEvents(runID, ctx, sinceSeq) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            const reader = new IntegrationProgressReader();
+            const snap = await reader.GetRun(runID);
+            if (!snap)
+                return { Success: false, Message: `Run '${runID}' not found`, LatestSeq: sinceSeq ?? 0, IsInFlight: false };
+            const authorized = await this.userCanReadRunArtifact(snap, user, new Map());
+            if (!authorized) {
+                const ciID = snap.manifest.companyIntegrationID;
+                return {
+                    Success: false,
+                    Message: ciID
+                        ? this.notAuthorizedForCompanyIntegrationMessage(ciID)
+                        : `Not authorized to access run '${runID}'`,
+                    LatestSeq: sinceSeq ?? 0,
+                    IsInFlight: false,
+                };
+            }
+            const events = await reader.Tail(runID, sinceSeq ?? 0);
+            const latestSeq = events.length > 0 ? events[events.length - 1].seq : (sinceSeq ?? 0);
+            return {
+                Success: true,
+                Message: `${events.length} event(s)`,
+                Events: events.map(ev => ({
+                    Ts: ev.ts,
+                    Seq: ev.seq,
+                    EventType: ev.eventType,
+                    Level: ev.level,
+                    Stage: ev.stage,
+                    Message: ev.message,
+                    Counts: this.toCountsOutput(ev.counts),
+                    DataJSON: ev.data ? JSON.stringify(ev.data) : undefined,
+                    ResumableStateJSON: ev.resumableState ? JSON.stringify(ev.resumableState) : undefined,
+                })),
+                LatestSeq: latestSeq,
+                IsInFlight: snap.isInFlight,
+            };
+        }
+        catch (e) {
+            LogError(`IntegrationTailRunEvents error: ${e}`);
+            return { Success: false, Message: this.formatError(e), LatestSeq: sinceSeq ?? 0, IsInFlight: false };
+        }
+    }
+    /** Maps a reader snapshot to the GraphQL summary shape. */
+    toRunSummaryArtifact(s) {
+        return {
+            RunID: s.manifest.runID,
+            RunKind: s.manifest.runKind,
+            IntegrationID: s.manifest.integrationID,
+            CompanyIntegrationID: s.manifest.companyIntegrationID,
+            ObjectName: s.manifest.objectName,
+            TriggerType: s.manifest.triggerType,
+            StartedAt: s.manifest.startedAt,
+            IsInFlight: s.isInFlight,
+            EventCount: s.eventCount,
+            Success: s.result?.success,
+            ExitReason: s.result?.exitReason,
+            CompletedAt: s.result?.completedAt,
+            DurationMs: s.result?.durationMs,
+            LatestEventType: s.latestEvent?.eventType,
+            LatestMessage: s.latestEvent?.message,
+            Counts: this.toCountsOutput(s.counts),
+            WarningCount: s.warningCount,
+            Warnings: s.warnings?.map(w => `[${w.code}] ${w.stage}: ${w.message}`),
+        };
+    }
+    /** Maps the reader's lowercase counts shape to the PascalCase GraphQL output. */
+    toCountsOutput(c) {
+        if (!c)
+            return undefined;
+        return {
+            Processed: c.processed,
+            Succeeded: c.succeeded,
+            Failed: c.failed,
+            Skipped: c.skipped,
+            TotalKnown: c.totalKnown,
+        };
+    }
     // ── CONNECTOR CAPABILITIES ──────────────────────────────────────────
     /**
      * Returns the CRUD capability flags for the connector bound to a CompanyIntegration.
@@ -3953,26 +5034,41 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                     }
                 }
                 else {
-                    // Legacy path (HubSpot, YourMembership, Sage Intacct, etc.)
-                    // — describe all, persist all, then resolve by either
-                    // SourceObjectID (legacy clients) OR SourceObjectName
-                    // (newly-discovered objects from connectors that probe
-                    // their full catalog at picker time, e.g. SI's 666
-                    // candidates). Without this fallback, freshly-probed
-                    // selections silently drop.
-                    sourceSchema = await connector.IntrospectSchema.bind(connector)(companyIntegration, user);
-                    try {
-                        const persistResult = await IntegrationSchemaSync.PersistDiscoveredSchema({
-                            IntegrationID: companyIntegration.IntegrationID,
-                            SourceSchema: sourceSchema,
-                            ContextUser: user,
-                        });
-                        console.log(`[IntegrationApplyAllBatch] Persisted discovered schema for ${companyIntegration.Integration}: ` +
-                            `${persistResult.ObjectsCreated} new objects, ${persistResult.FieldsCreated} new fields, ` +
-                            `${persistResult.ObjectsUpdated} updated objects, ${persistResult.FieldsUpdated} updated fields`);
+                    // Legacy path (HubSpot, YourMembership, Sage Intacct, etc.).
+                    //
+                    // Phase 0 v5.39.x change: the `MJCompanyIntegrationEntityServer.Save()`
+                    // hook already ran the full discovery + persist pipeline when
+                    // the wizard's Finish flipped `IsActive false→true`.  The IO/IOF
+                    // rows in `IntegrationEngineBase`'s cache are already fresh.
+                    // Calling `connector.IntrospectSchema()` again here just to feed
+                    // `SchemaBuilder` doubles the vendor-API roundtrip — on HubSpot
+                    // (130 objects, 60+ DiscoverFields probes) that's an extra ~100s
+                    // wasted per Apply.  Reconstruct `SourceSchemaInfo` from the
+                    // persisted rows instead.
+                    //
+                    // Persist is also skipped here — the Save hook already did it.
+                    sourceSchema = this.buildSourceSchemaFromPersistedRows(companyIntegration.IntegrationID);
+                    if (sourceSchema.Objects.length === 0) {
+                        // Defensive fallback: if the engine cache is empty (hook
+                        // didn't run, or this is a direct-API caller that bypasses
+                        // the wizard), do a one-time live introspect + persist so
+                        // the apply still proceeds.  Rare.
+                        LogError(`[IntegrationApplyAllBatch] Persisted IO cache empty for ${companyIntegration.Integration}; falling back to live introspect.`);
+                        sourceSchema = await connector.IntrospectSchema.bind(connector)(companyIntegration, user);
+                        try {
+                            await IntegrationSchemaSync.PersistDiscoveredSchema({
+                                IntegrationID: companyIntegration.IntegrationID,
+                                SourceSchema: sourceSchema,
+                                ContextUser: user,
+                            });
+                        }
+                        catch (persistErr) {
+                            LogError(`IntegrationApplyAllBatch: PersistDiscoveredSchema fallback failed for ${companyIntegration.Integration}: ${persistErr}`);
+                        }
                     }
-                    catch (persistErr) {
-                        LogError(`IntegrationApplyAllBatch: PersistDiscoveredSchema failed for ${companyIntegration.Integration}: ${persistErr}`);
+                    else {
+                        console.log(`[IntegrationApplyAllBatch] Reusing ${sourceSchema.Objects.length} persisted IOs for ${companyIntegration.Integration} ` +
+                            `— skipped duplicate IntrospectSchema (Save-hook already discovered).`);
                     }
                     // Resolve names from BOTH ID lookups and direct names.
                     // Direct names skip the IntegrationObject DB roundtrip
@@ -4362,9 +5458,20 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                     await emp.Delete();
                 }
             }
-            // Step 7: Delete the CompanyIntegration itself
+            // Step 7: Delete the CompanyIntegration itself FIRST, so its CredentialID FK reference
+            // is gone before we delete the Credential. (Deleting the Credential first violates the
+            // CompanyIntegration.CredentialID foreign key — the constraint is checked per-statement
+            // inside the transaction — and rolls back the entire cascade.) Capture CredentialID
+            // before Delete() since we still need it for Step 8.
+            const linkedCredentialID = ci.CredentialID;
             ci.TransactionGroup = tg;
             await ci.Delete();
+            // Step 8: Delete the linked Credential (encrypted-credential row) in the SAME
+            // transaction group so it commits/rolls back atomically with the cascade — now safe
+            // because the referencing CompanyIntegration delete is queued ahead of it. Skips
+            // silently when there is no CredentialID, and refuses to delete a credential still
+            // referenced by ANOTHER CompanyIntegration (shared credential).
+            const credentialDeleted = await this.cascadeDeleteCredential(linkedCredentialID, companyIntegrationID, tg, rv, md, sysUser);
             // Submit the transaction
             const submitted = await tg.Submit();
             if (!submitted) {
@@ -4379,6 +5486,7 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                 EntityMapsDeleted: entityMapsDeleted,
                 FieldMapsDeleted: fieldMapsDeleted,
                 SchedulesDeleted: schedulesDeleted,
+                CredentialDeleted: credentialDeleted,
             };
         }
         catch (e) {
@@ -4589,6 +5697,25 @@ __decorate([
     __metadata("design:paramtypes", [String, Object]),
     __metadata("design:returntype", Promise)
 ], IntegrationDiscoveryResolver.prototype, "IntegrationTestConnection", null);
+__decorate([
+    Mutation(() => RefreshConnectorSchemaOutput),
+    __param(0, Arg("companyIntegrationID")),
+    __param(1, Arg("universalPKConvention", { nullable: true, description: "Optional vendor-wide PK convention hint (e.g. 'id' for HubSpot)" })),
+    __param(2, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationRefreshConnectorSchema", null);
+__decorate([
+    Mutation(() => IntegrationGenerateActionOutput),
+    __param(0, Arg("integrationName")),
+    __param(1, Arg("objectName")),
+    __param(2, Arg("verb", { nullable: true, description: "Optional CRUD verb (Get|Create|Update|Delete|Search|List). Omit to generate all applicable verbs for the object." })),
+    __param(3, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationGenerateAction", null);
 __decorate([
     Query(() => DefaultConfigOutput),
     __param(0, Arg("companyIntegrationID")),
@@ -4630,9 +5757,11 @@ __decorate([
     Mutation(() => CreateConnectionOutput),
     __param(0, Arg("input")),
     __param(1, Arg("testConnection", () => Boolean, { defaultValue: false })),
-    __param(2, Ctx()),
+    __param(2, Arg("runSchemaRefresh", () => Boolean, { defaultValue: true, description: "When true (default) and TestConnection succeeds, automatically runs IntegrationConnectorCreationPipeline (live introspect → persist Declared/Discovered/Custom → SoftPKClassifier). The intermittent server-side work the wizard's Forward step represents." })),
+    __param(3, Arg("universalPKConvention", { nullable: true, description: "Optional vendor-wide PK hint (e.g. 'id' for HubSpot). Improves SoftPKClassifier convergence." })),
+    __param(4, Ctx()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [CreateConnectionInput, Boolean, Object]),
+    __metadata("design:paramtypes", [CreateConnectionInput, Boolean, Boolean, String, Object]),
     __metadata("design:returntype", Promise)
 ], IntegrationDiscoveryResolver.prototype, "IntegrationCreateConnection", null);
 __decorate([
@@ -4642,9 +5771,11 @@ __decorate([
     __param(2, Arg("configuration", { nullable: true })),
     __param(3, Arg("externalSystemID", { nullable: true })),
     __param(4, Arg("testConnection", () => Boolean, { defaultValue: false })),
-    __param(5, Ctx()),
+    __param(5, Arg("runSchemaRefresh", () => Boolean, { defaultValue: true, description: "When true (default) and TestConnection succeeds, automatically runs IntegrationConnectorCreationPipeline. Same intermittent server-side step as the create flow." })),
+    __param(6, Arg("universalPKConvention", { nullable: true, description: "Optional vendor-wide PK hint (e.g. 'id' for HubSpot)" })),
+    __param(7, Ctx()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String, String, String, Boolean, Object]),
+    __metadata("design:paramtypes", [String, String, String, String, Boolean, Boolean, String, Object]),
     __metadata("design:returntype", Promise)
 ], IntegrationDiscoveryResolver.prototype, "IntegrationUpdateConnection", null);
 __decorate([
@@ -4847,6 +5978,34 @@ __decorate([
     __metadata("design:paramtypes", [String, Number, Object]),
     __metadata("design:returntype", Promise)
 ], IntegrationDiscoveryResolver.prototype, "IntegrationGetSyncHistory", null);
+__decorate([
+    Query(() => IntegrationListRunsOutput),
+    __param(0, Ctx()),
+    __param(1, Arg("companyIntegrationID", { nullable: true })),
+    __param(2, Arg("runKind", { nullable: true })),
+    __param(3, Arg("inFlightOnly", { nullable: true })),
+    __param(4, Arg("limit", { defaultValue: 50 })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, String, Boolean, Number]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationListRuns", null);
+__decorate([
+    Query(() => IntegrationRunDetailOutput),
+    __param(0, Arg("runID")),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationGetRun", null);
+__decorate([
+    Query(() => IntegrationRunEventsOutput),
+    __param(0, Arg("runID")),
+    __param(1, Ctx()),
+    __param(2, Arg("sinceSeq", { defaultValue: 0 })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Number]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationTailRunEvents", null);
 __decorate([
     Query(() => ConnectorCapabilitiesOutput),
     __param(0, Arg("companyIntegrationID")),