@meyicloud/meyi-cost-server 1.8.3 → 1.8.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meyicloud/meyi-cost-server",
-  "version": "1.8.3",
+  "version": "1.8.5",
   "description": "Tenant-aware AWS CUR and Athena cost plugin server for MeyiConnect",
   "type": "module",
   "main": "./index.js",

package/src/controllers/cost.controller.js

@@ -117,11 +117,12 @@ export class CostController {
     try {
       const ctx = await this.contextService.resolve(req);
       if (!this.discoveryRepository) return res.json({ tenantId: ctx.tenant, jobs: [], logs: [] });
-      const { jobs, logs } = await this.discoveryRepository.statusForTenant(ctx.tenant, req.query.logLimit);
+      const managementAccountId = String(req.query.managementAccountId || "").trim();
+      const { jobs, logs } = await this.discoveryRepository.statusForTenant(ctx.tenant, req.query.logLimit, managementAccountId || undefined);
       return res.json({
         tenantId: ctx.tenant,
         jobs: jobs.map((job) => ({
-          id: String(job.id), connectionId: job.connection_id, status: job.status,
+          id: String(job.id), connectionId: job.connection_id, managementAccountId: job.management_account_id, status: job.status,
           attemptCount: Number(job.attempt_count || 0), bucket: job.cur_bucket,
           prefix: job.cur_prefix, region: job.cur_region, tenantPartition: job.tenant_partition,
           database: job.glue_database, table: job.glue_table, tableLocation: job.table_location,

package/src/cur-discovery/cur-discovery.repository.js

@@ -154,22 +154,29 @@ export class CurDiscoveryRepository {
    * Discovery jobs for a tenant with their most recent log lines, for the
    * Cost > CUR Discovery screen. Read-only: the scheduler owns every write.
    */
-  async statusForTenant(tenant, logLimit = 50) {
-    const jobs = rows(await this.db.execute(sql`
-      SELECT id, tenant_id, connection_id, cur_bucket, cur_prefix, cur_region,
-             tenant_partition, status, attempt_count, next_run_at, last_started_at,
-             last_finished_at, glue_database, glue_table, table_location, cur_s3_uri,
-             sample_object_key, last_data_at, last_error, created_at, updated_at
-      FROM ${sql.raw(this.jobsTable)}
-      WHERE tenant_id = ${tenant}
-      ORDER BY updated_at DESC
-    `));
+  async statusForTenant(tenant, logLimit = 50, managementAccountId = undefined) {
+    const jobs = rows(await this.db.execute(sql`
+      SELECT j.id, j.tenant_id, j.connection_id, a.management_account_id, j.cur_bucket, j.cur_prefix, j.cur_region,
+             j.tenant_partition, j.status, j.attempt_count, j.next_run_at, j.last_started_at,
+             j.last_finished_at, j.glue_database, j.glue_table, j.table_location, j.cur_s3_uri,
+             j.sample_object_key, j.last_data_at, j.last_error, j.created_at, j.updated_at
+      FROM ${sql.raw(this.jobsTable)} j
+      JOIN ${sql.raw(this.connectionsTable)} a
+        ON a.tenant_id::text = j.tenant_id AND a.connection_id = j.connection_id
+      WHERE j.tenant_id = ${tenant}
+        AND (${managementAccountId || null}::text IS NULL OR a.management_account_id = ${managementAccountId || null})
+      ORDER BY j.updated_at DESC
+    `));
     if (!jobs.length) return { jobs: [], logs: [] };
     const logs = rows(await this.db.execute(sql`
-      SELECT id, job_id, level, event, message, details, created_at
-      FROM ${sql.raw(this.logsTable)}
-      WHERE tenant_id = ${tenant}
-      ORDER BY created_at DESC, id DESC
+      SELECT l.id, l.job_id, l.level, l.event, l.message, l.details, l.created_at
+      FROM ${sql.raw(this.logsTable)} l
+      JOIN ${sql.raw(this.jobsTable)} j ON j.id = l.job_id AND j.tenant_id = l.tenant_id
+      JOIN ${sql.raw(this.connectionsTable)} a
+        ON a.tenant_id::text = j.tenant_id AND a.connection_id = j.connection_id
+      WHERE l.tenant_id = ${tenant}
+        AND (${managementAccountId || null}::text IS NULL OR a.management_account_id = ${managementAccountId || null})
+      ORDER BY l.created_at DESC, l.id DESC
       LIMIT ${Math.min(Math.max(Number(logLimit) || 50, 1), 500)}
     `));
     return { jobs, logs };

package/src/repositories/aws-onboarding.repository.js

@@ -40,25 +40,28 @@ export class AwsOnboardingRepository {
     if (!connections.length) return { accounts: [], meta: {}, sources: [] };
 
     const connectionIds = connections.map((connection) => connection.connection_id);
+    // Bind every connection ID independently. Passing an untyped JavaScript array
+    // to PostgreSQL ANY() fails for the varchar connection_id column.
+    const connectionIdList = sql.join(connectionIds.map((connectionId) => sql`${connectionId}`), sql`, `);
     const curConfigs = relations.cur_config_table ? rows(await this.db.execute(sql`
       SELECT export_arn, bucket, prefix, region, tenant_partition, status, last_data_at
              , connection_id
       FROM ${sql.raw(this.curConfigTable)}
-      WHERE tenant_id::text = ${tenant} AND connection_id = ANY(${connectionIds})
+       WHERE tenant_id::text = ${tenant} AND connection_id IN (${connectionIdList})
     `)) : [];
 
     const discoveries = relations.cur_discovery_table ? rows(await this.db.execute(sql`
       SELECT id, status, attempt_count, glue_database, glue_table, table_location,
              cur_s3_uri, last_data_at, last_error, last_started_at, last_finished_at, next_run_at, connection_id
       FROM ${sql.raw(this.curDiscoveryTable)}
-      WHERE tenant_id = ${tenant} AND connection_id = ANY(${connectionIds})
+       WHERE tenant_id = ${tenant} AND connection_id IN (${connectionIdList})
     `)) : [];
 
     const allAccounts = relations.accounts_table ? rows(await this.db.execute(sql`
       SELECT connection_id, account_id, account_name, status
       FROM ${sql.raw(this.accountsTable)}
       WHERE tenant_id::text = ${tenant}
-        AND connection_id = ANY(${connectionIds})
+        AND connection_id IN (${connectionIdList})
         AND LOWER(status) = 'active'
       ORDER BY account_name
     `)) : [];

package/src/repositories/cost-analysis-report.repository.js

@@ -9,16 +9,16 @@ export class CostAnalysisReportRepository {
     this.reports = `${qSchema}.cost_ai_reports`;
   }
 
-  async getSchedule(tenantId) {
-    return rows(await this.db.execute(sql`SELECT * FROM ${sql.raw(this.schedules)} WHERE tenant_id = ${tenantId}`))[0] || null;
+  async getSchedule(tenantId, managementAccountId) {
+    return rows(await this.db.execute(sql`SELECT * FROM ${sql.raw(this.schedules)} WHERE tenant_id = ${tenantId} AND management_account_id = ${managementAccountId}`))[0] || null;
   }
 
-  async saveSchedule(tenantId, schedule, nextRunAt) {
+  async saveSchedule(tenantId, managementAccountId, schedule, nextRunAt) {
     return rows(await this.db.execute(sql`
       INSERT INTO ${sql.raw(this.schedules)}
-        (tenant_id, enabled, frequency, time_of_day, timezone, day_of_week, day_of_month, next_run_at)
-      VALUES (${tenantId}, ${schedule.enabled}, ${schedule.frequency}, ${schedule.time}, ${schedule.timezone}, ${schedule.dayOfWeek}, ${schedule.dayOfMonth}, ${nextRunAt})
-      ON CONFLICT (tenant_id) DO UPDATE SET
+        (tenant_id, management_account_id, enabled, frequency, time_of_day, timezone, day_of_week, day_of_month, next_run_at)
+      VALUES (${tenantId}, ${managementAccountId}, ${schedule.enabled}, ${schedule.frequency}, ${schedule.time}, ${schedule.timezone}, ${schedule.dayOfWeek}, ${schedule.dayOfMonth}, ${nextRunAt})
+      ON CONFLICT (tenant_id, management_account_id) DO UPDATE SET
         enabled = EXCLUDED.enabled, frequency = EXCLUDED.frequency,
         time_of_day = EXCLUDED.time_of_day, timezone = EXCLUDED.timezone,
         day_of_week = EXCLUDED.day_of_week, day_of_month = EXCLUDED.day_of_month,
@@ -32,7 +32,7 @@ export class CostAnalysisReportRepository {
     const batchSize = Math.min(Math.max(Number(limit) || 10, 1), 50);
     return rows(await this.db.execute(sql`
       WITH due AS (
-        SELECT tenant_id, next_run_at AS scheduled_for
+        SELECT tenant_id, management_account_id, next_run_at AS scheduled_for
         FROM ${sql.raw(this.schedules)}
         WHERE enabled = true AND next_run_at IS NOT NULL AND next_run_at <= now()
         ORDER BY next_run_at
@@ -42,16 +42,17 @@ export class CostAnalysisReportRepository {
       UPDATE ${sql.raw(this.schedules)} s
       SET next_run_at = ${leaseUntil}, updated_at = now()
       FROM due
-      WHERE s.tenant_id = due.tenant_id
+      WHERE s.tenant_id = due.tenant_id AND s.management_account_id = due.management_account_id
       RETURNING s.*, due.scheduled_for
     `));
   }
 
-  async setNextRun(tenantId, nextRunAt, completed = false, leaseUntil = null) {
+  async setNextRun(tenantId, managementAccountId, nextRunAt, completed = false, leaseUntil = null) {
     await this.db.execute(sql`
       UPDATE ${sql.raw(this.schedules)}
       SET next_run_at = ${nextRunAt}, last_run_at = CASE WHEN ${completed} THEN now() ELSE last_run_at END, updated_at = now()
       WHERE tenant_id = ${tenantId}
+        AND management_account_id = ${managementAccountId}
         AND (${leaseUntil}::timestamptz IS NULL OR next_run_at = ${leaseUntil})
     `);
   }
@@ -59,9 +60,9 @@ export class CostAnalysisReportRepository {
   async createReport(schedule, range) {
     const inserted = rows(await this.db.execute(sql`
       INSERT INTO ${sql.raw(this.reports)}
-        (id, tenant_id, schedule_frequency, scheduled_for, period_start, period_end)
-      VALUES (${randomUUID()}, ${schedule.tenant_id}, ${schedule.frequency}, ${schedule.scheduled_for}, ${range.Start}, ${range.End})
-      ON CONFLICT (tenant_id, scheduled_for) DO NOTHING
+        (id, tenant_id, management_account_id, schedule_frequency, scheduled_for, period_start, period_end)
+      VALUES (${randomUUID()}, ${schedule.tenant_id}, ${schedule.management_account_id}, ${schedule.frequency}, ${schedule.scheduled_for}, ${range.Start}, ${range.End})
+      ON CONFLICT (tenant_id, management_account_id, scheduled_for) DO NOTHING
       RETURNING *
     `));
     return inserted[0] || null;
@@ -132,14 +133,14 @@ export class CostAnalysisReportRepository {
     await this.db.execute(sql`UPDATE ${sql.raw(this.reports)} SET status = 'FAILED', ecs_task_arn = COALESCE(${error?.taskArn || null}, ecs_task_arn), error = ${String(error?.message || error).slice(0, 2000)}, completed_at = now(), updated_at = now() WHERE id = ${id}`);
   }
 
-  async list(tenantId, limit = 100) {
+  async list(tenantId, managementAccountId, limit = 100) {
     return rows(await this.db.execute(sql`
-      SELECT id, schedule_frequency, scheduled_for, period_start, period_end, status,
+      SELECT id, management_account_id, schedule_frequency, scheduled_for, period_start, period_end, status,
              attempt_count, model_id, provider_name, provider_source, data_source, facts, result, artifact_bucket,
              markdown_key, markdown_size, pdf_key, pdf_size, tickets_key, ticket_count,
              incident_sync_status, incident_sync_error, incident_synced_at, error,
              started_at, completed_at, created_at
-      FROM ${sql.raw(this.reports)} WHERE tenant_id = ${tenantId}
+      FROM ${sql.raw(this.reports)} WHERE tenant_id = ${tenantId} AND management_account_id = ${managementAccountId}
       ORDER BY scheduled_for DESC LIMIT ${Math.min(Math.max(Number(limit) || 100, 1), 250)}
     `));
   }
@@ -149,7 +150,7 @@ export class CostAnalysisReportRepository {
       return rows(await this.db.execute(sql`SELECT * FROM ${sql.raw(this.reports)} WHERE tenant_id = ${tenantId} AND id = ${id} LIMIT 1`))[0] || null;
     }
     return rows(await this.db.execute(sql`
-      SELECT id, schedule_frequency, scheduled_for, period_start, period_end, status,
+      SELECT id, management_account_id, schedule_frequency, scheduled_for, period_start, period_end, status,
              attempt_count, model_id, provider_name, provider_source, data_source, facts, result, artifact_bucket,
              markdown_key, markdown_size, pdf_key, pdf_size, tickets_key, ticket_count,
              incident_sync_status, incident_sync_error, incident_synced_at, error,

package/src/schema/cost-analysis-report.schema.js

@@ -1,8 +1,10 @@
 import { sql } from "drizzle-orm";
+import { rows } from "../lib/cost-utils.js";
 
 export async function installCostAnalysisReportSchema(db, qSchema) {
   await db.execute(sql.raw(`CREATE TABLE IF NOT EXISTS ${qSchema}.cost_ai_report_schedules (
-    tenant_id text PRIMARY KEY,
+    tenant_id text NOT NULL,
+    management_account_id text NOT NULL DEFAULT '',
     enabled boolean NOT NULL DEFAULT false,
     frequency text NOT NULL DEFAULT 'weekly' CHECK (frequency IN ('daily', 'weekly', 'monthly')),
     time_of_day time NOT NULL DEFAULT '09:00:00',
@@ -12,13 +14,39 @@ export async function installCostAnalysisReportSchema(db, qSchema) {
     next_run_at timestamptz,
     last_run_at timestamptz,
     created_at timestamptz NOT NULL DEFAULT now(),
-    updated_at timestamptz NOT NULL DEFAULT now()
+    updated_at timestamptz NOT NULL DEFAULT now(),
+    PRIMARY KEY (tenant_id, management_account_id)
   )`));
+  await db.execute(sql.raw(`ALTER TABLE ${qSchema}.cost_ai_report_schedules ADD COLUMN IF NOT EXISTS management_account_id text NOT NULL DEFAULT ''`));
+  const schemaName = qSchema.replace(/"/g, "");
+  const relations = rows(await db.execute(sql.raw(`SELECT to_regclass('${schemaName}.aws_connections') AS connections_table`)))[0] || {};
+  if (relations.connections_table) {
+    await db.execute(sql.raw(`UPDATE ${qSchema}.cost_ai_report_schedules s
+      SET management_account_id = COALESCE((
+        SELECT c.management_account_id FROM ${qSchema}.aws_connections c
+        WHERE c.tenant_id::text = s.tenant_id AND c.status = 'CONNECTED'
+          AND c.plugins ? 'Cost' AND c.management_account_id IS NOT NULL
+        ORDER BY c.connected_at DESC NULLS LAST, c.created_at DESC LIMIT 1
+      ), '')
+      WHERE s.management_account_id = ''`));
+  }
+  await db.execute(sql.raw(`DO $migration$
+    BEGIN
+      IF NOT EXISTS (
+        SELECT 1 FROM pg_constraint
+        WHERE conrelid = '${schemaName}.cost_ai_report_schedules'::regclass
+          AND contype = 'p' AND pg_get_constraintdef(oid) LIKE '%management_account_id%'
+      ) THEN
+        ALTER TABLE ${qSchema}.cost_ai_report_schedules DROP CONSTRAINT IF EXISTS cost_ai_report_schedules_pkey;
+        ALTER TABLE ${qSchema}.cost_ai_report_schedules ADD CONSTRAINT cost_ai_report_schedules_pkey PRIMARY KEY (tenant_id, management_account_id);
+      END IF;
+    END $migration$`));
   await db.execute(sql.raw(`CREATE INDEX IF NOT EXISTS cost_ai_report_schedules_due_idx ON ${qSchema}.cost_ai_report_schedules (enabled, next_run_at)`));
 
   await db.execute(sql.raw(`CREATE TABLE IF NOT EXISTS ${qSchema}.cost_ai_reports (
     id text PRIMARY KEY,
     tenant_id text NOT NULL,
+    management_account_id text NOT NULL DEFAULT '',
     schedule_frequency text NOT NULL CHECK (schedule_frequency IN ('daily', 'weekly', 'monthly')),
     scheduled_for timestamptz NOT NULL,
     period_start date NOT NULL,
@@ -47,9 +75,24 @@ export async function installCostAnalysisReportSchema(db, qSchema) {
     started_at timestamptz,
     completed_at timestamptz,
     created_at timestamptz NOT NULL DEFAULT now(),
-    updated_at timestamptz NOT NULL DEFAULT now(),
-    UNIQUE (tenant_id, scheduled_for)
+    updated_at timestamptz NOT NULL DEFAULT now()
   )`));
+  await db.execute(sql.raw(`ALTER TABLE ${qSchema}.cost_ai_reports ADD COLUMN IF NOT EXISTS management_account_id text NOT NULL DEFAULT ''`));
+  if (relations.connections_table) {
+    await db.execute(sql.raw(`UPDATE ${qSchema}.cost_ai_reports r
+      SET management_account_id = COALESCE(
+        (SELECT s.management_account_id FROM ${qSchema}.cost_ai_report_schedules s
+          WHERE s.tenant_id = r.tenant_id AND s.management_account_id <> '' LIMIT 1),
+        (SELECT c.management_account_id FROM ${qSchema}.aws_connections c
+          WHERE c.tenant_id::text = r.tenant_id AND c.status = 'CONNECTED'
+            AND c.plugins ? 'Cost' AND c.management_account_id IS NOT NULL
+          ORDER BY c.connected_at DESC NULLS LAST, c.created_at DESC LIMIT 1),
+        ''
+      )
+      WHERE r.management_account_id = ''`));
+  }
+  await db.execute(sql.raw(`ALTER TABLE ${qSchema}.cost_ai_reports DROP CONSTRAINT IF EXISTS cost_ai_reports_tenant_id_scheduled_for_key`));
+  await db.execute(sql.raw(`CREATE UNIQUE INDEX IF NOT EXISTS cost_ai_reports_tenant_account_scheduled_idx ON ${qSchema}.cost_ai_reports (tenant_id, management_account_id, scheduled_for)`));
   await db.execute(sql.raw(`CREATE INDEX IF NOT EXISTS cost_ai_reports_tenant_created_idx ON ${qSchema}.cost_ai_reports (tenant_id, created_at DESC)`));
   await db.execute(sql.raw(`CREATE INDEX IF NOT EXISTS cost_ai_reports_status_idx ON ${qSchema}.cost_ai_reports (status, created_at)`));
   await db.execute(sql.raw(`ALTER TABLE ${qSchema}.cost_ai_reports ADD COLUMN IF NOT EXISTS ecs_task_arn text`));

package/src/services/cost-analyser.service.js

@@ -167,10 +167,10 @@ export class CostAnalyserService {
     return JSON.parse(await bodyText(response.Body));
   }
 
-  async execute({ tenantId, reportId, range, frequency, onStarted = null }) {
+  async execute({ tenantId, managementAccountId, reportId, range, frequency, onStarted = null }) {
     this.validate();
     const provider = await this.resolveProvider(tenantId);
-    const customer = await this.contextService.resolve({ headers: {}, user: { tenant_id: tenantId, tenantId } });
+    const customer = await this.contextService.resolve({ headers: {}, query: { managementAccountId }, user: { tenant_id: tenantId, tenantId } });
     const athena = this.athenaContextService.resolve(customer).config;
     if (!athena.enabled) throw Object.assign(new Error("CUR discovery has not produced a queryable Athena table for this tenant"), { name: "CurDataNotReadyError", statusCode: 503 });
     const targetRoleArn = required(customer.meta?.payerRoleArn, "customer TARGET_ROLE_ARN");

package/src/services/cost-analysis-report.service.js

@@ -1,13 +1,13 @@
 import { nextScheduleRun, reportRange, validateSchedule } from "../lib/cost-analysis-schedule.js";
 
-function scheduleDto(row) {
-  if (!row) return { enabled: false, frequency: "weekly", time: "09:00", timezone: "UTC", dayOfWeek: 1, dayOfMonth: 1, nextRunAt: null, lastRunAt: null };
-  return { enabled: row.enabled, frequency: row.frequency, time: String(row.time_of_day).slice(0, 5), timezone: row.timezone, dayOfWeek: row.day_of_week, dayOfMonth: row.day_of_month, nextRunAt: row.next_run_at, lastRunAt: row.last_run_at };
+function scheduleDto(row, managementAccountId = "") {
+  if (!row) return { managementAccountId, enabled: false, frequency: "weekly", time: "09:00", timezone: "UTC", dayOfWeek: 1, dayOfMonth: 1, nextRunAt: null, lastRunAt: null };
+  return { managementAccountId: row.management_account_id, enabled: row.enabled, frequency: row.frequency, time: String(row.time_of_day).slice(0, 5), timezone: row.timezone, dayOfWeek: row.day_of_week, dayOfMonth: row.day_of_month, nextRunAt: row.next_run_at, lastRunAt: row.last_run_at };
 }
 
 function reportDto(row) {
   return {
-    id: row.id, frequency: row.schedule_frequency, scheduledFor: row.scheduled_for,
+    id: row.id, managementAccountId: row.management_account_id, frequency: row.schedule_frequency, scheduledFor: row.scheduled_for,
     period: { Start: String(row.period_start).slice(0, 10), End: String(row.period_end).slice(0, 10) },
     status: row.status, attempts: Number(row.attempt_count || 0), provider: row.provider_name,
     providerSource: row.provider_source, modelId: row.model_id,
@@ -27,16 +27,37 @@ export class CostAnalysisReportService {
 
   tenant(req) { return this.contextService.tenantId(req); }
 
-  async getSchedule(req) { return scheduleDto(await this.repository.getSchedule(this.tenant(req))); }
+  async scope(req, required = false) {
+    const context = await this.contextService.resolve(req);
+    const requested = String(req.query?.managementAccountId || "").trim();
+    const managementAccountId = requested || context.sources?.[0]?.managementAccountId || context.meta?.managementAccountId || "";
+    if (requested && !context.sources?.some((source) => source.managementAccountId === requested)) {
+      throw Object.assign(new Error("The selected management account is not connected for this tenant"), { statusCode: 404 });
+    }
+    if (required && !managementAccountId) {
+      throw Object.assign(new Error("Select a connected management account before configuring AI reports"), { statusCode: 409 });
+    }
+    return { tenantId: context.tenant, managementAccountId };
+  }
+
+  async getSchedule(req) {
+    const scope = await this.scope(req);
+    return scheduleDto(scope.managementAccountId ? await this.repository.getSchedule(scope.tenantId, scope.managementAccountId) : null, scope.managementAccountId);
+  }
 
   async saveSchedule(req, input) {
     if (String(req.user?.role || "").toLowerCase() !== "admin") throw Object.assign(new Error("Administrator access is required to change the AI report schedule"), { statusCode: 403 });
+    const scope = await this.scope(req, true);
     const schedule = validateSchedule(input);
     const nextRunAt = schedule.enabled ? nextScheduleRun(schedule) : null;
-    return scheduleDto(await this.repository.saveSchedule(this.tenant(req), schedule, nextRunAt));
+    return scheduleDto(await this.repository.saveSchedule(scope.tenantId, scope.managementAccountId, schedule, nextRunAt));
   }
 
-  async list(req, limit) { return (await this.repository.list(this.tenant(req), limit)).map(reportDto); }
+  async list(req, limit) {
+    const scope = await this.scope(req);
+    if (!scope.managementAccountId) return [];
+    return (await this.repository.list(scope.tenantId, scope.managementAccountId, limit)).map(reportDto);
+  }
 
   async latest(req) {
     const reports = await this.list(req, 1);

package/src/workers/cost-analysis-report.worker.js

@@ -19,12 +19,13 @@ export class CostAnalysisReportWorker {
     const range = reportRange(normalized, schedule.scheduled_for);
     const report = await this.repository.createReport(schedule, range);
     const nextRunAt = nextScheduleRun(normalized, new Date());
-    if (!report) return this.repository.setNextRun(schedule.tenant_id, nextRunAt, false, schedule.next_run_at);
+    if (!report) return this.repository.setNextRun(schedule.tenant_id, schedule.management_account_id, nextRunAt, false, schedule.next_run_at);
     const claimed = await this.repository.markRunning(report.id);
-    if (!claimed) return this.repository.setNextRun(schedule.tenant_id, nextRunAt, false, schedule.next_run_at);
+    if (!claimed) return this.repository.setNextRun(schedule.tenant_id, schedule.management_account_id, nextRunAt, false, schedule.next_run_at);
     try {
       const result = await this.analyserService.execute({
         tenantId: schedule.tenant_id,
+        managementAccountId: schedule.management_account_id,
         reportId: report.id,
         range,
         frequency: schedule.frequency,
@@ -32,10 +33,10 @@ export class CostAnalysisReportWorker {
       });
       await this.repository.completeExternal(report.id, result);
       await this.incidentSyncService?.syncPending?.();
-      await this.repository.setNextRun(schedule.tenant_id, nextRunAt, true, schedule.next_run_at);
+      await this.repository.setNextRun(schedule.tenant_id, schedule.management_account_id, nextRunAt, true, schedule.next_run_at);
     } catch (error) {
       await this.repository.fail(report.id, error);
-      await this.repository.setNextRun(schedule.tenant_id, nextRunAt, true, schedule.next_run_at);
+      await this.repository.setNextRun(schedule.tenant_id, schedule.management_account_id, nextRunAt, true, schedule.next_run_at);
       this.logger.error?.("[Cost AI Reports] Scheduled analysis failed", { tenantId: schedule.tenant_id, reportId: report.id, message: error.message });
     }
   }