@revoengine/cli 1.0.9 → 1.0.11

package/dist/src/resource-syncs/schedule-sync.js

@@ -0,0 +1,1302 @@
+import path from 'node:path';
+import { hashStable, readComponentLock, writeComponentLock } from "../component-lock.js";
+import { NULL_CATEGORY_KEY, normalizeStableKeyValue, readConfiguredResourceMetadataStableKey, sanitizeUserMetadata } from "../resource-metadata.js";
+import { isValidNormalizedCron, normalizeCron, readJsonFile, sanitizeSegment } from "../utils.js";
+import { findManifestFiles, isRecord, localTargetPath, requireProjectLayout, stableKeySuffix, toPortableRelativePath, unwrapData, writePulledManifest, } from "./util.js";
+export const SCHEDULES_DIRECTORY = 'Schedules';
+export const SCHEDULE_MANIFEST_FILE = 'schedule.json';
+function canonicalValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => canonicalValue(item));
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    return Object.fromEntries(Object.keys(value).sort((left, right) => left.localeCompare(right))
+        .map((key) => [key, canonicalValue(value[key])]));
+}
+function scheduleIdOf(record) {
+    return String(record.scheduleId || record.id || '');
+}
+function jobTemplateIdOf(record) {
+    return String(record.jobTemplateId || record.id || '');
+}
+function databaseViewIdOf(record) {
+    return String(record.databaseViewId || record.id || '');
+}
+function canonicalMetadata(record, stableKeyName, stableKey) {
+    return canonicalValue({
+        ...sanitizeUserMetadata(record.resourceMetadata),
+        ...sanitizeUserMetadata(record.metaData),
+        ...sanitizeUserMetadata(record.metadata),
+        [stableKeyName]: stableKey,
+    });
+}
+export function scheduleManifestPath(workspaceRoot, manifest) {
+    const category = typeof manifest.category === 'string' && manifest.category.trim()
+        ? sanitizeSegment(manifest.category)
+        : 'Uncategorized';
+    return path.join(workspaceRoot, SCHEDULES_DIRECTORY, category, `${sanitizeSegment(manifest.name)}-${stableKeySuffix(manifest.stableKey)}`, SCHEDULE_MANIFEST_FILE);
+}
+function portablePathIdentity(filePath) {
+    return path.resolve(filePath)
+        .normalize('NFC')
+        .split(path.sep)
+        .map((segment) => segment.replace(/[. ]+$/g, '').toLowerCase())
+        .join(path.sep);
+}
+function disambiguateManifestPath(filePath, stableKey) {
+    const directory = path.dirname(filePath);
+    const disambiguatedDirectory = `${path.basename(directory)}-${hashStable(stableKey).slice(0, 8)}`;
+    return path.join(path.dirname(directory), disambiguatedDirectory, path.basename(filePath));
+}
+function readWorkspaceSchedules(cwd) {
+    const { workspaceRoot } = requireProjectLayout(cwd, 'Schedule');
+    return findManifestFiles(path.join(workspaceRoot, SCHEDULES_DIRECTORY), SCHEDULE_MANIFEST_FILE).map((manifestPath) => ({
+        manifestPath,
+        manifest: readJsonFile(manifestPath),
+    }));
+}
+function hasOnlyKeys(value, allowed) {
+    return Object.keys(value).every((key) => allowed.has(key));
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function normalizeTimezone(value) {
+    const normalized = value.trim();
+    const aliases = {
+        UTC: 'UTC',
+        Z: 'UTC',
+        GMT: 'UTC',
+        'ETC/UTC': 'UTC',
+        'ETC/GMT': 'UTC',
+        'ETC/GMT0': 'UTC',
+        UTC0: 'UTC',
+    };
+    const alias = normalized.toUpperCase();
+    return Object.hasOwn(aliases, alias) ? aliases[alias] : normalized;
+}
+function isValidNormalizedIanaTimezone(value) {
+    if (value !== normalizeTimezone(value)) {
+        return false;
+    }
+    if (value === 'UTC') {
+        return true;
+    }
+    if (!value.includes('/')) {
+        return false;
+    }
+    try {
+        return new Intl.DateTimeFormat('en-US', { timeZone: value }).resolvedOptions().timeZone === value;
+    }
+    catch {
+        return false;
+    }
+}
+function validManifest(manifest, stableKeyName, { validateDiagnostics = true } = {}) {
+    if (!isRecord(manifest) || !hasOnlyKeys(manifest, new Set([
+        'kind', 'stableKey', 'name', 'category', 'description', 'metadata', 'cron', 'timezone', 'target', 'sourceTargetConfig', 'activationCandidate',
+    ]))) {
+        return false;
+    }
+    if (manifest.kind !== 'schedule' || !isNonEmptyString(manifest.stableKey) || !isNonEmptyString(manifest.name)) {
+        return false;
+    }
+    if (manifest.category !== undefined && manifest.category !== null && typeof manifest.category !== 'string') {
+        return false;
+    }
+    if (manifest.description !== undefined && typeof manifest.description !== 'string') {
+        return false;
+    }
+    if (!isRecord(manifest.metadata)
+        || !isNonEmptyString(manifest.cron)
+        || !isNonEmptyString(manifest.timezone)
+        || !isValidNormalizedCron(manifest.cron)
+        || !isValidNormalizedIanaTimezone(manifest.timezone)) {
+        return false;
+    }
+    if (!isRecord(manifest.target)) {
+        return false;
+    }
+    const validJobTemplateTarget = manifest.target.type === 'JOB_TEMPLATE'
+        && hasOnlyKeys(manifest.target, new Set(['type', 'jobTemplateStableKey']))
+        && isNonEmptyString(manifest.target.jobTemplateStableKey);
+    const validMaterializedViewTarget = manifest.target.type === 'MATERIALIZED_VIEW'
+        && hasOnlyKeys(manifest.target, new Set(['type', 'databaseViewStableKey', 'refreshMode']))
+        && isNonEmptyString(manifest.target.databaseViewStableKey)
+        && ['CONCURRENT', 'BLOCKING'].includes(String(manifest.target.refreshMode));
+    if (!validJobTemplateTarget && !validMaterializedViewTarget) {
+        return false;
+    }
+    if (!validateDiagnostics) {
+        return readConfiguredResourceMetadataStableKey(manifest, stableKeyName) === manifest.stableKey;
+    }
+    if (manifest.sourceTargetConfig !== undefined && manifest.sourceTargetConfig !== null && !isRecord(manifest.sourceTargetConfig)) {
+        return false;
+    }
+    if (typeof manifest.activationCandidate !== 'boolean') {
+        return false;
+    }
+    return readConfiguredResourceMetadataStableKey(manifest, stableKeyName) === manifest.stableKey;
+}
+function manifestFromRecord(input) {
+    const { record, stableKey, target, stableKeyName } = input;
+    return {
+        kind: 'schedule',
+        stableKey,
+        name: String(record.name || ''),
+        ...(record.category === undefined ? {} : { category: record.category }),
+        ...(typeof record.desc === 'string' ? { description: record.desc } : typeof record.description === 'string' ? { description: record.description } : {}),
+        metadata: canonicalMetadata(record, stableKeyName, stableKey),
+        cron: normalizeCron(String(record.cron || '')),
+        timezone: normalizeTimezone(String(record.timezone || '')),
+        target,
+        ...(target.type === 'JOB_TEMPLATE' && record.targetConfig !== undefined
+            ? { sourceTargetConfig: canonicalValue(record.targetConfig) }
+            : {}),
+        activationCandidate: record.active === true,
+    };
+}
+/** Desired target shape. Source-only configuration and activation are excluded. */
+export function hashPortableSchedule(manifest) {
+    return hashStable({
+        kind: 'schedule',
+        stableKey: manifest.stableKey,
+        name: manifest.name,
+        category: manifest.category ?? null,
+        description: manifest.description ?? '',
+        metadata: canonicalValue(manifest.metadata),
+        cron: manifest.cron,
+        timezone: manifest.timezone,
+        target: canonicalValue(manifest.target),
+    });
+}
+/** Local baseline shape. It deliberately includes editable/source-only pull data. */
+export function hashScheduleManifest(manifest) {
+    return hashStable(canonicalValue(manifest));
+}
+function warningKey(record, stableKey) {
+    return stableKey || String(record.name || scheduleIdOf(record) || 'unknown schedule');
+}
+async function hydrateRemoteRecords(input) {
+    return Promise.all(input.summaries.map(async (summary) => {
+        const id = input.idOf(summary);
+        return id ? unwrapData(await input.get(id)) : summary;
+    }));
+}
+async function loadRemoteJobTemplates(client) {
+    const { jobTemplates } = await client.listAllJobTemplates();
+    return hydrateRemoteRecords({
+        summaries: jobTemplates,
+        idOf: jobTemplateIdOf,
+        get: (id) => client.getJobTemplate(id),
+    });
+}
+async function loadRemoteSchedules(client) {
+    const { schedules } = await client.listAllSchedules();
+    return hydrateRemoteRecords({
+        summaries: schedules,
+        idOf: scheduleIdOf,
+        get: (id) => client.getSchedule(id),
+    });
+}
+async function loadJobTemplatesById(client, ids) {
+    const uniqueIds = [...new Set(ids)].filter(Boolean);
+    const entries = await Promise.all(uniqueIds.map(async (id) => [
+        id,
+        unwrapData(await client.getJobTemplate(id)),
+    ]));
+    return new Map(entries);
+}
+async function loadDatabaseViewsById(client, ids) {
+    const uniqueIds = [...new Set(ids)].filter(Boolean);
+    const entries = await Promise.all(uniqueIds.map(async (id) => [
+        id,
+        unwrapData(await client.getDatabaseView(id)),
+    ]));
+    return new Map(entries);
+}
+function materializedRefreshMode(record) {
+    if (!isRecord(record.targetConfig) || record.targetConfig.kind !== 'refresh_materialized_view') {
+        return undefined;
+    }
+    const refreshMode = record.targetConfig.refreshMode ?? 'CONCURRENT';
+    return refreshMode === 'CONCURRENT' || refreshMode === 'BLOCKING' ? refreshMode : undefined;
+}
+function isMaterializedViewRefreshSchedule(record) {
+    return record.targetType === 'PLATFORM_OPERATION'
+        && isRecord(record.targetConfig)
+        && record.targetConfig.kind === 'refresh_materialized_view';
+}
+function isLiveMaterializedView(record) {
+    return record !== undefined
+        && record.type === 'MATERIALIZED_VIEW'
+        && !record.deletedAt
+        && !record.deletedBy;
+}
+async function loadRemoteScheduleInventory(client, stableKeyName, { includeDatabaseViews = false } = {}) {
+    const [schedules, jobTemplates] = await Promise.all([
+        loadRemoteSchedules(client),
+        loadRemoteJobTemplates(client),
+    ]);
+    const databaseViews = includeDatabaseViews || schedules.some(isMaterializedViewRefreshSchedule)
+        ? await client.listAllDatabaseViewsForSync()
+        : [];
+    const schedulesByStableKey = new Map();
+    const jobTemplatesById = new Map();
+    const jobTemplatesByStableKey = new Map();
+    const databaseViewsById = new Map();
+    const databaseViewsByStableKey = new Map();
+    for (const schedule of schedules) {
+        const stableKey = readConfiguredResourceMetadataStableKey(schedule, stableKeyName);
+        if (stableKey) {
+            schedulesByStableKey.set(stableKey, [...(schedulesByStableKey.get(stableKey) || []), schedule]);
+        }
+    }
+    for (const jobTemplate of jobTemplates) {
+        const id = jobTemplateIdOf(jobTemplate);
+        const stableKey = readConfiguredResourceMetadataStableKey(jobTemplate, stableKeyName);
+        if (id) {
+            jobTemplatesById.set(id, jobTemplate);
+        }
+        if (stableKey) {
+            jobTemplatesByStableKey.set(stableKey, [...(jobTemplatesByStableKey.get(stableKey) || []), jobTemplate]);
+        }
+    }
+    for (const databaseView of databaseViews) {
+        const id = databaseViewIdOf(databaseView);
+        const stableKey = readConfiguredResourceMetadataStableKey(databaseView, stableKeyName);
+        if (id) {
+            databaseViewsById.set(id, databaseView);
+        }
+        if (stableKey && !databaseView.deletedAt && !databaseView.deletedBy) {
+            databaseViewsByStableKey.set(stableKey, [...(databaseViewsByStableKey.get(stableKey) || []), databaseView]);
+        }
+    }
+    return {
+        schedules,
+        schedulesByStableKey,
+        jobTemplatesById,
+        jobTemplatesByStableKey,
+        databaseViewsById,
+        databaseViewsByStableKey,
+    };
+}
+function schedulePlanExclusionReason(record) {
+    if (record.systemManaged === true) {
+        return 'system-managed schedule is excluded';
+    }
+    if (record.deletedAt || record.deletedBy) {
+        return 'deleted schedule is excluded';
+    }
+    if (record.targetType === 'JOB_TEMPLATE' || isMaterializedViewRefreshSchedule(record)) {
+        return undefined;
+    }
+    return `target type ${String(record.targetType || 'unknown')} is unsupported; only JOB_TEMPLATE and MATERIALIZED_VIEW refresh schedules are migrated`;
+}
+function scheduleHint(value) {
+    const category = typeof value.category === 'string' && value.category.trim()
+        ? value.category
+        : NULL_CATEGORY_KEY;
+    return normalizeStableKeyValue(`${category}/${String(value.name || '')}`);
+}
+function diffSchedules(desired, target) {
+    const fields = [
+        ['name', desired.name, target.name],
+        ['category', desired.category ?? null, target.category ?? null],
+        ['description', desired.description ?? '', target.description ?? ''],
+        ['metadata', canonicalValue(desired.metadata), canonicalValue(target.metadata)],
+        ['cron', desired.cron, target.cron],
+        ['timezone', desired.timezone, target.timezone],
+        ['target', canonicalValue(desired.target), canonicalValue(target.target)],
+    ];
+    return fields
+        .filter(([, desiredValue, targetValue]) => (hashStable({ value: desiredValue }) !== hashStable({ value: targetValue })))
+        .map(([field]) => field)
+        .sort((left, right) => left.localeCompare(right));
+}
+function planTargetDetails(target) {
+    return target.type === 'JOB_TEMPLATE'
+        ? { jobTemplateStableKey: target.jobTemplateStableKey }
+        : { databaseViewStableKey: target.databaseViewStableKey };
+}
+function targetDependencyLabel(target) {
+    return target.type === 'JOB_TEMPLATE' ? 'Job Template' : 'Materialized View';
+}
+function targetDependencyStableKey(target) {
+    return target.type === 'JOB_TEMPLATE' ? target.jobTemplateStableKey : target.databaseViewStableKey;
+}
+function targetFromRemoteRecord(record, remote, stableKeyName) {
+    if (record.targetType === 'JOB_TEMPLATE') {
+        const dependency = record.targetId ? remote.jobTemplatesById.get(record.targetId) : undefined;
+        const stableKey = dependency
+            ? readConfiguredResourceMetadataStableKey(dependency, stableKeyName)
+            : undefined;
+        return stableKey
+            ? { target: { type: 'JOB_TEMPLATE', jobTemplateStableKey: stableKey } }
+            : { reason: `target Job Template ${record.targetId || 'unknown'} is missing ${stableKeyName} or unavailable` };
+    }
+    const dependency = record.targetId ? remote.databaseViewsById.get(record.targetId) : undefined;
+    const stableKey = dependency
+        ? readConfiguredResourceMetadataStableKey(dependency, stableKeyName)
+        : undefined;
+    const refreshMode = materializedRefreshMode(record);
+    if (!isLiveMaterializedView(dependency) || !stableKey) {
+        return { reason: `target Materialized View ${record.targetId || 'unknown'} is missing ${stableKeyName}, unavailable, deleted, or not materialized` };
+    }
+    if (!refreshMode) {
+        return { reason: 'target Materialized View Schedule has an unsupported refresh mode' };
+    }
+    return { target: { type: 'MATERIALIZED_VIEW', databaseViewStableKey: stableKey, refreshMode } };
+}
+function emptyPlanCounts() {
+    return {
+        clean: 0,
+        create: 0,
+        'safe-update': 0,
+        'remote-changed': 0,
+        conflict: 0,
+        'missing-lock': 0,
+        orphan: 0,
+        collision: 0,
+        skipped: 0,
+    };
+}
+export async function buildSchedulesPlan(input) {
+    const { projectRoot } = requireProjectLayout(input.cwd, 'Schedule');
+    const localEntries = readWorkspaceSchedules(input.cwd);
+    const remote = await loadRemoteScheduleInventory(input.client, input.stableKeyName, {
+        includeDatabaseViews: localEntries.some((entry) => entry.manifest?.target?.type === 'MATERIALIZED_VIEW'),
+    });
+    const targetRecords = remote.schedules;
+    const lock = readComponentLock(projectRoot);
+    const blockers = [];
+    const warnings = [];
+    const exclusions = [];
+    const items = [];
+    const lockEntriesByPath = new Map(Object.values(lock.schedules).map((entry) => [entry.path, entry]));
+    const identityConflictedTargetKeys = new Set();
+    const localByKey = new Map();
+    for (const entry of localEntries) {
+        const rawManifest = entry.manifest;
+        if (!validManifest(rawManifest, input.stableKeyName, { validateDiagnostics: false })) {
+            blockers.push(`Invalid Schedule manifest ${path.relative(projectRoot, entry.manifestPath)}.`);
+            items.push({
+                status: 'conflict',
+                name: isRecord(rawManifest) && isNonEmptyString(rawManifest.name)
+                    ? rawManifest.name
+                    : path.basename(path.dirname(entry.manifestPath)),
+                reason: 'invalid Schedule manifest',
+            });
+            continue;
+        }
+        const lockEntry = lockEntriesByPath.get(toPortableRelativePath(projectRoot, entry.manifestPath));
+        if (lockEntry && lockEntry.stableKey !== entry.manifest.stableKey) {
+            blockers.push(`Schedule manifest ${path.relative(projectRoot, entry.manifestPath)} changed stableKey from "${lockEntry.stableKey}" to "${entry.manifest.stableKey}".`);
+            items.push({
+                status: 'conflict',
+                stableKey: entry.manifest.stableKey,
+                name: entry.manifest.name,
+                reason: `stableKey changed from "${lockEntry.stableKey}"; identity changes are not renames`,
+                desiredHash: hashPortableSchedule(entry.manifest),
+                ...planTargetDetails(entry.manifest.target),
+            });
+            identityConflictedTargetKeys.add(lockEntry.stableKey);
+            continue;
+        }
+        localByKey.set(entry.manifest.stableKey, [...(localByKey.get(entry.manifest.stableKey) || []), entry]);
+    }
+    const targetByKey = new Map();
+    const unresolvedTargetByKey = new Map();
+    const excludedTargetByKey = new Map();
+    const supportedTargetRecordsByKey = new Map();
+    const unmanaged = [];
+    for (const record of targetRecords) {
+        const exclusion = schedulePlanExclusionReason(record);
+        const name = String(record.name || scheduleIdOf(record) || 'unknown schedule');
+        const stableKey = readConfiguredResourceMetadataStableKey(record, input.stableKeyName);
+        if (exclusion) {
+            exclusions.push(`Schedule "${name}": ${exclusion}.`);
+            if (stableKey) {
+                items.push({ status: 'skipped', stableKey, name, reason: exclusion });
+                excludedTargetByKey.set(stableKey, [...(excludedTargetByKey.get(stableKey) || []), { record, reason: exclusion }]);
+            }
+            else {
+                unmanaged.push(record);
+            }
+            continue;
+        }
+        if (!stableKey) {
+            const reason = `missing ${input.stableKeyName}; unmanaged`;
+            exclusions.push(`Schedule "${name}": ${reason}.`);
+            unmanaged.push(record);
+            continue;
+        }
+        supportedTargetRecordsByKey.set(stableKey, [...(supportedTargetRecordsByKey.get(stableKey) || []), record]);
+    }
+    const duplicateTargetKeys = new Set();
+    for (const [stableKey, records] of supportedTargetRecordsByKey) {
+        if (records.length < 2) {
+            continue;
+        }
+        duplicateTargetKeys.add(stableKey);
+        blockers.push(`Duplicate target Schedule stableKey "${stableKey}".`);
+        items.push({
+            status: 'collision',
+            stableKey,
+            name: String(records[0].name || stableKey),
+            reason: 'duplicate target stableKey',
+        });
+    }
+    for (const [stableKey, records] of supportedTargetRecordsByKey) {
+        if (duplicateTargetKeys.has(stableKey)) {
+            continue;
+        }
+        const record = records[0];
+        const resolved = targetFromRemoteRecord(record, remote, input.stableKeyName);
+        if (!resolved.target) {
+            const reason = resolved.reason || 'target dependency is unavailable';
+            exclusions.push(`Schedule "${stableKey}": ${reason}.`);
+            unresolvedTargetByKey.set(stableKey, [...(unresolvedTargetByKey.get(stableKey) || []), { record, reason }]);
+            continue;
+        }
+        const manifest = manifestFromRecord({ record, stableKey, target: resolved.target, stableKeyName: input.stableKeyName });
+        if (!validManifest(manifest, input.stableKeyName, { validateDiagnostics: false })) {
+            const reason = 'target Schedule definition is incomplete or invalid';
+            exclusions.push(`Schedule "${stableKey}": ${reason}.`);
+            unresolvedTargetByKey.set(stableKey, [...(unresolvedTargetByKey.get(stableKey) || []), { record, reason }]);
+            continue;
+        }
+        targetByKey.set(stableKey, [...(targetByKey.get(stableKey) || []), {
+                record,
+                manifest,
+                hash: hashPortableSchedule(manifest),
+            }]);
+    }
+    const consumedTargetKeys = new Set(identityConflictedTargetKeys);
+    const consumedUnmanaged = new Set();
+    for (const [stableKey, entries] of localByKey) {
+        if (entries.length > 1) {
+            const desired = entries[0].manifest;
+            blockers.push(`Duplicate desired Schedule stableKey "${desired.stableKey}".`);
+            items.push({ status: 'collision', stableKey: desired.stableKey, name: desired.name, reason: 'duplicate desired stableKey' });
+            consumedTargetKeys.add(stableKey);
+            continue;
+        }
+        const desired = entries[0].manifest;
+        const desiredHash = hashPortableSchedule(desired);
+        const excluded = excludedTargetByKey.get(stableKey) || [];
+        if (excluded.length > 0) {
+            const reason = excluded.length === 1
+                ? excluded[0].reason
+                : 'multiple excluded target Schedules use this stableKey';
+            blockers.push(`Target Schedule "${desired.stableKey}" is excluded: ${reason}.`);
+            items.push({
+                status: 'conflict',
+                stableKey: desired.stableKey,
+                name: desired.name,
+                reason: `target Schedule is excluded: ${reason}`,
+                desiredHash,
+                ...planTargetDetails(desired.target),
+            });
+            consumedTargetKeys.add(stableKey);
+            continue;
+        }
+        const unresolved = unresolvedTargetByKey.get(stableKey) || [];
+        if (unresolved.length > 0) {
+            const reason = unresolved.length === 1
+                ? unresolved[0].reason
+                : 'multiple target Schedules have unresolved targets';
+            blockers.push(`Target Schedule "${desired.stableKey}" ${reason}.`);
+            items.push({
+                status: 'conflict',
+                stableKey: desired.stableKey,
+                name: desired.name,
+                reason,
+                desiredHash,
+                ...planTargetDetails(desired.target),
+            });
+            consumedTargetKeys.add(stableKey);
+            continue;
+        }
+        if (duplicateTargetKeys.has(stableKey)) {
+            consumedTargetKeys.add(stableKey);
+            continue;
+        }
+        const dependencyStableKey = targetDependencyStableKey(desired.target);
+        const dependencyLabel = targetDependencyLabel(desired.target);
+        const dependencyMatches = desired.target.type === 'JOB_TEMPLATE'
+            ? remote.jobTemplatesByStableKey.get(dependencyStableKey) || []
+            : remote.databaseViewsByStableKey.get(dependencyStableKey) || [];
+        if (dependencyMatches.length !== 1) {
+            const reason = dependencyMatches.length === 0
+                ? `target ${dependencyLabel} is missing`
+                : `target ${dependencyLabel} stableKey is ambiguous`;
+            blockers.push(`Schedule "${desired.stableKey}" dependency "${dependencyStableKey}": ${reason}.`);
+            items.push({
+                status: 'conflict',
+                stableKey: desired.stableKey,
+                name: desired.name,
+                reason,
+                desiredHash,
+                ...planTargetDetails(desired.target),
+            });
+            consumedTargetKeys.add(stableKey);
+            continue;
+        }
+        if (desired.target.type === 'MATERIALIZED_VIEW'
+            && dependencyMatches[0].type !== 'MATERIALIZED_VIEW') {
+            const reason = 'target Database View is not a MATERIALIZED_VIEW';
+            blockers.push(`Schedule "${desired.stableKey}" dependency "${dependencyStableKey}": ${reason}.`);
+            items.push({
+                status: 'conflict',
+                stableKey: desired.stableKey,
+                name: desired.name,
+                reason,
+                desiredHash,
+                ...planTargetDetails(desired.target),
+            });
+            consumedTargetKeys.add(stableKey);
+            continue;
+        }
+        const matches = targetByKey.get(stableKey) || [];
+        if (matches.length === 0) {
+            const managedHintedKeys = [...targetByKey.entries()]
+                .filter(([targetStableKey, candidates]) => (targetStableKey !== stableKey
+                && candidates.some((candidate) => scheduleHint(candidate.manifest) === scheduleHint(desired))))
+                .map(([targetStableKey]) => targetStableKey)
+                .sort((left, right) => left.localeCompare(right));
+            if (managedHintedKeys.length > 0) {
+                managedHintedKeys.forEach((targetStableKey) => consumedTargetKeys.add(targetStableKey));
+                const reason = managedHintedKeys.length === 1
+                    ? `target Schedule matching category/name uses stableKey "${managedHintedKeys[0]}"; identity conflict`
+                    : `multiple target Schedules matching category/name use different stable keys; identity conflict`;
+                blockers.push(`Cannot create "${desired.stableKey}": ${reason}.`);
+                items.push({
+                    status: 'conflict',
+                    stableKey: desired.stableKey,
+                    name: desired.name,
+                    reason,
+                    desiredHash,
+                    ...planTargetDetails(desired.target),
+                });
+                continue;
+            }
+            const hinted = unmanaged.filter((record) => scheduleHint(record) === scheduleHint(desired));
+            if (hinted.length > 0) {
+                hinted.forEach((record) => consumedUnmanaged.add(record));
+                const reason = `target Schedule matching category/name is missing ${input.stableKeyName}`;
+                blockers.push(`Cannot create "${desired.stableKey}": ${reason}.`);
+                items.push({
+                    status: 'conflict',
+                    stableKey: desired.stableKey,
+                    name: desired.name,
+                    reason,
+                    desiredHash,
+                    ...planTargetDetails(desired.target),
+                });
+            }
+            else {
+                items.push({
+                    status: 'create',
+                    stableKey: desired.stableKey,
+                    name: desired.name,
+                    desiredHash,
+                    ...planTargetDetails(desired.target),
+                });
+            }
+            continue;
+        }
+        consumedTargetKeys.add(stableKey);
+        const target = matches[0];
+        if (desired.target.type !== target.manifest.target.type) {
+            const reason = `target type transition from ${target.manifest.target.type} to ${desired.target.type} requires --force`;
+            warnings.push(`Schedule "${desired.stableKey}": ${reason}.`);
+            items.push({
+                status: 'conflict',
+                stableKey: desired.stableKey,
+                name: desired.name,
+                reason,
+                desiredHash,
+                currentHash: target.hash,
+                ...planTargetDetails(desired.target),
+            });
+            continue;
+        }
+        const changedFields = diffSchedules(desired, target.manifest);
+        const common = {
+            stableKey: desired.stableKey,
+            name: desired.name,
+            desiredHash,
+            currentHash: target.hash,
+            ...planTargetDetails(desired.target),
+            ...(changedFields.length > 0 ? { changedFields } : {}),
+        };
+        const baselineHash = lock.schedules[desired.stableKey]?.environments[input.envName]?.remoteHash;
+        if (!baselineHash) {
+            items.push({ status: 'missing-lock', ...common, reason: `missing ${input.envName} lock baseline` });
+        }
+        else if (desiredHash === target.hash) {
+            items.push({ status: 'clean', ...common });
+        }
+        else if (target.hash === baselineHash) {
+            items.push({ status: 'safe-update', ...common, baselineHash, reason: 'local manifest changed; target matches lock baseline' });
+        }
+        else if (desiredHash === baselineHash) {
+            items.push({ status: 'remote-changed', ...common, baselineHash, reason: 'target changed; local manifest matches lock baseline' });
+        }
+        else {
+            items.push({ status: 'conflict', ...common, baselineHash, reason: 'local manifest and target both changed since lock baseline' });
+        }
+    }
+    for (const [stableKey, matches] of unresolvedTargetByKey) {
+        if (consumedTargetKeys.has(stableKey) || localByKey.has(stableKey)) {
+            continue;
+        }
+        const target = matches[0];
+        items.push({
+            status: 'skipped',
+            stableKey,
+            name: String(target.record.name || stableKey),
+            reason: target.reason,
+        });
+    }
+    for (const [stableKey, matches] of targetByKey) {
+        if (consumedTargetKeys.has(stableKey) || localByKey.has(stableKey)) {
+            continue;
+        }
+        if (matches.length > 1) {
+            continue;
+        }
+        const target = matches[0];
+        items.push({
+            status: 'orphan',
+            stableKey,
+            name: target.manifest.name,
+            currentHash: target.hash,
+            ...planTargetDetails(target.manifest.target),
+            reason: 'target-only Schedule',
+        });
+    }
+    for (const record of unmanaged) {
+        if (consumedUnmanaged.has(record)) {
+            continue;
+        }
+        items.push({
+            status: 'skipped',
+            name: String(record.name || scheduleIdOf(record) || 'unknown schedule'),
+            reason: `missing ${input.stableKeyName}; unmanaged`,
+        });
+    }
+    const rank = {
+        create: 0,
+        'safe-update': 1,
+        'remote-changed': 2,
+        conflict: 3,
+        'missing-lock': 4,
+        clean: 5,
+        orphan: 6,
+        collision: 7,
+        skipped: 8,
+    };
+    items.sort((left, right) => {
+        const leftKey = left.stableKey || left.name;
+        const rightKey = right.stableKey || right.name;
+        return rank[left.status] - rank[right.status]
+            || leftKey.localeCompare(rightKey);
+    });
+    const counts = emptyPlanCounts();
+    for (const item of items) {
+        counts[item.status] += 1;
+    }
+    return {
+        resourceType: 'schedule',
+        env: input.envName,
+        counts,
+        blockers: [...new Set(blockers)].sort((left, right) => left.localeCompare(right)),
+        warnings: [...new Set(warnings)].sort((left, right) => left.localeCompare(right)),
+        items,
+        exclusions: [...new Set(exclusions)].sort((left, right) => left.localeCompare(right)),
+    };
+}
+export async function pullSchedulesToWorkspace(input) {
+    const { projectRoot, workspaceRoot } = requireProjectLayout(input.cwd, 'Schedule');
+    const sourceSchedules = await loadRemoteSchedules(input.client);
+    const supportedSourceSchedules = sourceSchedules
+        .filter((record) => !schedulePlanExclusionReason(record))
+        .filter((record) => Boolean(readConfiguredResourceMetadataStableKey(record, input.stableKeyName)));
+    const [jobTemplates, databaseViews] = await Promise.all([
+        loadJobTemplatesById(input.client, supportedSourceSchedules
+            .filter((record) => record.targetType === 'JOB_TEMPLATE')
+            .map((record) => record.targetId || '')),
+        loadDatabaseViewsById(input.client, supportedSourceSchedules
+            .filter(isMaterializedViewRefreshSchedule)
+            .map((record) => record.targetId || '')),
+    ]);
+    const manifests = [];
+    const warnings = [];
+    const stableKeys = new Set();
+    for (const record of sourceSchedules) {
+        const exclusion = schedulePlanExclusionReason(record);
+        if (exclusion) {
+            warnings.push({ stableKey: warningKey(record), reason: exclusion });
+            continue;
+        }
+        const stableKey = readConfiguredResourceMetadataStableKey(record, input.stableKeyName);
+        if (!stableKey) {
+            warnings.push({ stableKey: warningKey(record), reason: `missing ${input.stableKeyName}; run metadata backfill first` });
+            continue;
+        }
+        if (stableKeys.has(stableKey)) {
+            throw new Error(`Duplicate schedule stableKey "${stableKey}" on ${input.envName}; no files were changed.`);
+        }
+        stableKeys.add(stableKey);
+        let target;
+        if (record.targetType === 'JOB_TEMPLATE') {
+            const sourceTemplate = record.targetId ? jobTemplates.get(record.targetId) : undefined;
+            const jobTemplateStableKey = sourceTemplate
+                ? readConfiguredResourceMetadataStableKey(sourceTemplate, input.stableKeyName)
+                : undefined;
+            if (!jobTemplateStableKey) {
+                warnings.push({ stableKey, reason: `target Job Template ${record.targetId || 'unknown'} is missing ${input.stableKeyName} or unavailable` });
+                continue;
+            }
+            target = { type: 'JOB_TEMPLATE', jobTemplateStableKey };
+        }
+        else {
+            const sourceView = record.targetId ? databaseViews.get(record.targetId) : undefined;
+            const databaseViewStableKey = sourceView
+                ? readConfiguredResourceMetadataStableKey(sourceView, input.stableKeyName)
+                : undefined;
+            const refreshMode = materializedRefreshMode(record);
+            if (!isLiveMaterializedView(sourceView) || !databaseViewStableKey) {
+                warnings.push({ stableKey, reason: `target Materialized View ${record.targetId || 'unknown'} is missing ${input.stableKeyName}, unavailable, deleted, or not materialized` });
+                continue;
+            }
+            if (!refreshMode) {
+                warnings.push({ stableKey, reason: 'Schedule definition has an unsupported materialized view refresh mode' });
+                continue;
+            }
+            target = { type: 'MATERIALIZED_VIEW', databaseViewStableKey, refreshMode };
+        }
+        const manifest = manifestFromRecord({ record, stableKey, target, stableKeyName: input.stableKeyName });
+        if (!validManifest(manifest, input.stableKeyName)) {
+            warnings.push({ stableKey, reason: 'Schedule definition has an invalid normalized cron expression or IANA timezone' });
+            continue;
+        }
+        manifests.push(manifest);
+    }
+    manifests.sort((left, right) => left.stableKey.localeCompare(right.stableKey));
+    warnings.sort((left, right) => left.stableKey.localeCompare(right.stableKey) || left.reason.localeCompare(right.reason));
+    const lock = readComponentLock(projectRoot);
+    const existingByKey = new Map();
+    const existingByPath = new Map();
+    for (const entry of readWorkspaceSchedules(input.cwd)) {
+        if (!validManifest(entry.manifest, input.stableKeyName)) {
+            throw new Error(`Cannot pull over invalid Schedule manifest ${path.relative(projectRoot, entry.manifestPath)}.`);
+        }
+        if (existingByKey.has(entry.manifest.stableKey)) {
+            throw new Error(`Duplicate local Schedule stableKey "${entry.manifest.stableKey}"; no files were changed.`);
+        }
+        existingByKey.set(entry.manifest.stableKey, entry);
+        const pathIdentity = portablePathIdentity(entry.manifestPath);
+        existingByPath.set(pathIdentity, [...(existingByPath.get(pathIdentity) || []), entry]);
+    }
+    const writes = manifests.map((manifest) => {
+        const sourceHash = hashScheduleManifest(manifest);
+        const remoteHash = hashPortableSchedule(manifest);
+        const existing = existingByKey.get(manifest.stableKey);
+        if (existing && !input.force) {
+            const localHash = hashScheduleManifest(existing.manifest);
+            const baseline = lock.schedules[manifest.stableKey];
+            if (localHash !== sourceHash && (!baseline || localHash !== baseline.sourceHash)) {
+                throw new Error(`Cannot pull Schedule "${manifest.stableKey}": local manifest changed since the lock baseline. Re-run with --force.`);
+            }
+        }
+        return {
+            manifest,
+            sourceHash,
+            remoteHash,
+            filePath: scheduleManifestPath(workspaceRoot, manifest),
+            previousPath: existing?.manifestPath,
+        };
+    });
+    const candidatePathCounts = new Map();
+    for (const write of writes) {
+        const identity = portablePathIdentity(write.filePath);
+        candidatePathCounts.set(identity, (candidatePathCounts.get(identity) || 0) + 1);
+    }
+    for (const write of writes) {
+        if ((candidatePathCounts.get(portablePathIdentity(write.filePath)) || 0) > 1) {
+            write.filePath = disambiguateManifestPath(write.filePath, write.manifest.stableKey);
+        }
+    }
+    const paths = new Set();
+    for (const write of writes) {
+        const pathIdentity = portablePathIdentity(write.filePath);
+        if (paths.has(pathIdentity)) {
+            throw new Error('Multiple Schedules resolve to the same workspace path; no files were changed.');
+        }
+        paths.add(pathIdentity);
+        const pathOwner = (existingByPath.get(pathIdentity) || [])
+            .find((entry) => entry.manifest.stableKey !== write.manifest.stableKey);
+        if (pathOwner) {
+            throw new Error(`Schedule workspace path "${path.relative(projectRoot, write.filePath)}" is occupied by different stableKey "${pathOwner.manifest.stableKey}"; no files were changed.`);
+        }
+    }
+    const root = path.join(workspaceRoot, SCHEDULES_DIRECTORY);
+    let lockChanged = false;
+    for (const write of writes) {
+        writePulledManifest({
+            filePath: write.filePath,
+            manifest: write.manifest,
+            previousPath: write.previousPath,
+            root: root,
+            force: input.force,
+        });
+        const previous = lock.schedules[write.manifest.stableKey];
+        const previousBaseline = previous?.environments[input.envName];
+        const entry = {
+            stableKey: write.manifest.stableKey,
+            path: toPortableRelativePath(projectRoot, write.filePath),
+            sourceHash: write.sourceHash,
+            environments: {
+                ...(previous?.environments || {}),
+                [input.envName]: previousBaseline?.remoteHash === write.remoteHash
+                    ? previousBaseline
+                    : { remoteHash: write.remoteHash, syncedAt: new Date().toISOString() },
+            },
+        };
+        if (!previous || hashStable(previous) !== hashStable(entry)) {
+            lockChanged = true;
+        }
+        lock.schedules[write.manifest.stableKey] = entry;
+    }
+    if (lockChanged) {
+        writeComponentLock(projectRoot, lock);
+    }
+    return {
+        pulled: writes.map((write) => ({ manifest: write.manifest, targetPath: localTargetPath(input.cwd, write.filePath) })),
+        warnings,
+    };
+}
+function buildScheduleCreatePayload(manifest, targetId) {
+    const target = manifest.target.type === 'JOB_TEMPLATE'
+        ? { targetType: 'JOB_TEMPLATE', targetId }
+        : {
+            targetType: 'PLATFORM_OPERATION',
+            targetId,
+            targetConfig: { kind: 'refresh_materialized_view', refreshMode: manifest.target.refreshMode },
+        };
+    return {
+        name: manifest.name,
+        ...(manifest.category === undefined || manifest.category === null ? {} : { category: manifest.category }),
+        active: false,
+        ...(manifest.description === undefined ? {} : { desc: manifest.description }),
+        metadata: canonicalValue(manifest.metadata),
+        cron: manifest.cron,
+        timezone: manifest.timezone,
+        ...target,
+    };
+}
+function buildScheduleUpdatePayload(manifest, targetId, version) {
+    const target = manifest.target.type === 'JOB_TEMPLATE'
+        ? { targetType: 'JOB_TEMPLATE', targetId }
+        : {
+            targetType: 'PLATFORM_OPERATION',
+            targetId,
+            targetConfig: { kind: 'refresh_materialized_view', refreshMode: manifest.target.refreshMode },
+        };
+    return {
+        name: manifest.name,
+        category: manifest.category ?? null,
+        desc: manifest.description ?? '',
+        metadata: canonicalValue(manifest.metadata),
+        cron: manifest.cron,
+        timezone: manifest.timezone,
+        ...target,
+        version,
+    };
+}
+function workspaceSchedulesByStableKey(cwd, stableKeyName) {
+    return new Map(readWorkspaceSchedules(cwd)
+        .filter((entry) => validManifest(entry.manifest, stableKeyName, { validateDiagnostics: false }))
+        .map((entry) => [entry.manifest.stableKey, entry]));
+}
+function updateScheduleEnvironmentBaseline(input) {
+    const { projectRoot } = requireProjectLayout(input.cwd, 'Schedule');
+    const lock = readComponentLock(projectRoot);
+    const stableKey = input.manifest.stableKey;
+    const existingPair = Object.entries(lock.schedules).find(([, entry]) => entry.stableKey === stableKey);
+    const existing = existingPair?.[1];
+    if (existingPair && existingPair[0] !== stableKey) {
+        delete lock.schedules[existingPair[0]];
+    }
+    const previousBaseline = existing?.environments[input.envName];
+    lock.schedules[stableKey] = {
+        stableKey,
+        path: toPortableRelativePath(projectRoot, input.manifestPath),
+        sourceHash: hashScheduleManifest(input.manifest),
+        environments: {
+            ...(existing?.environments || {}),
+            [input.envName]: previousBaseline?.remoteHash === input.remoteHash
+                ? previousBaseline
+                : { remoteHash: input.remoteHash, syncedAt: new Date().toISOString() },
+        },
+    };
+    writeComponentLock(projectRoot, lock);
+}
+function schedulePushError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function assertSchedulesPushable(plan, force, allowMaterialized) {
+    if (plan.blockers.length > 0) {
+        throw new Error(`Schedule push blocked: ${plan.blockers.join(' ')}`);
+    }
+    const missingLock = plan.items.filter((item) => item.status === 'missing-lock');
+    if (missingLock.length > 0 && !force) {
+        throw new Error('Schedule push blocked by missing-lock; establish a reviewed environment baseline before pushing.');
+    }
+    const remoteConflicts = plan.items.filter((item) => ['remote-changed', 'conflict'].includes(item.status));
+    if (remoteConflicts.length > 0 && !force) {
+        const statuses = [...new Set(remoteConflicts.map((item) => item.status))].sort().join(', ');
+        throw new Error(`Schedule push blocked by ${statuses}; review the plan and re-run with --force only to overwrite reviewed remote content drift.`);
+    }
+    const materializedWrites = plan.items.filter((item) => (item.databaseViewStableKey
+        && ['create', 'safe-update', 'remote-changed', 'conflict', 'missing-lock'].includes(item.status)));
+    if (materializedWrites.length > 0 && !allowMaterialized) {
+        throw new Error('Schedule push includes Materialized View refresh definitions; review the plan and re-run with --allow-materialized.');
+    }
+}
+async function resolveLiveScheduleWriteTarget(input) {
+    const remote = await loadRemoteScheduleInventory(input.client, input.stableKeyName, {
+        includeDatabaseViews: input.manifest.target.type === 'MATERIALIZED_VIEW',
+    });
+    const dependencyStableKey = targetDependencyStableKey(input.manifest.target);
+    const dependencyLabel = targetDependencyLabel(input.manifest.target);
+    const dependencies = input.manifest.target.type === 'JOB_TEMPLATE'
+        ? remote.jobTemplatesByStableKey.get(dependencyStableKey) || []
+        : remote.databaseViewsByStableKey.get(dependencyStableKey) || [];
+    if (dependencies.length !== 1) {
+        const reason = dependencies.length === 0 ? 'is missing' : 'is ambiguous';
+        throw new Error(`target ${dependencyLabel} dependency "${dependencyStableKey}" ${reason}`);
+    }
+    const targetId = input.manifest.target.type === 'JOB_TEMPLATE'
+        ? jobTemplateIdOf(dependencies[0])
+        : databaseViewIdOf(dependencies[0]);
+    if (!targetId) {
+        throw new Error(`target ${dependencyLabel} dependency "${dependencyStableKey}" has no id`);
+    }
+    if (input.manifest.target.type === 'MATERIALIZED_VIEW'
+        && dependencies[0].type !== 'MATERIALIZED_VIEW') {
+        throw new Error(`target Materialized View dependency "${dependencyStableKey}" is not materialized`);
+    }
+    const matchingSchedules = remote.schedulesByStableKey.get(input.manifest.stableKey) || [];
+    if (input.action === 'create') {
+        if (matchingSchedules.length > 0) {
+            throw new Error(`target Schedule "${input.manifest.stableKey}" appeared after planning`);
+        }
+        const nameMatches = remote.schedules.filter((record) => scheduleHint(record) === scheduleHint(input.manifest));
+        if (nameMatches.length > 0) {
+            throw new Error(`target Schedule matching category/name for "${input.manifest.stableKey}" appeared after planning`);
+        }
+        return { targetId, target: input.manifest.target };
+    }
+    if (matchingSchedules.length !== 1) {
+        throw new Error(`expected one live target Schedule match, found ${matchingSchedules.length}`);
+    }
+    const schedule = matchingSchedules[0];
+    const exclusion = schedulePlanExclusionReason(schedule);
+    if (exclusion) {
+        throw new Error(`live target Schedule is excluded: ${exclusion}`);
+    }
+    const scheduleId = scheduleIdOf(schedule);
+    if (!scheduleId) {
+        throw new Error('live target Schedule did not include scheduleId');
+    }
+    const resolvedCurrent = targetFromRemoteRecord(schedule, remote, input.stableKeyName);
+    if (!resolvedCurrent.target) {
+        throw new Error('live target Schedule dependency is missing or unmanaged');
+    }
+    const currentManifest = manifestFromRecord({
+        record: schedule,
+        stableKey: input.manifest.stableKey,
+        target: resolvedCurrent.target,
+        stableKeyName: input.stableKeyName,
+    });
+    return {
+        targetId,
+        target: input.manifest.target,
+        schedule,
+        scheduleId,
+        currentHash: hashPortableSchedule(currentManifest),
+    };
+}
+async function verifyScheduleWrite(input) {
+    const schedule = unwrapData(await input.client.getSchedule(input.scheduleId));
+    if (readConfiguredResourceMetadataStableKey(schedule, input.stableKeyName) !== input.manifest.stableKey) {
+        throw new Error(`verified Schedule is missing or changed ${input.stableKeyName}`);
+    }
+    const expectedTargetType = input.manifest.target.type === 'JOB_TEMPLATE' ? 'JOB_TEMPLATE' : 'PLATFORM_OPERATION';
+    if (schedule.targetType !== expectedTargetType || schedule.targetId !== input.targetId) {
+        throw new Error(`verified Schedule target does not match the live ${targetDependencyLabel(input.manifest.target)} dependency`);
+    }
+    if (input.manifest.target.type === 'MATERIALIZED_VIEW'
+        && materializedRefreshMode(schedule) !== input.manifest.target.refreshMode) {
+        throw new Error('verified Schedule materialized view refresh configuration does not match the desired definition');
+    }
+    const dependency = input.manifest.target.type === 'JOB_TEMPLATE'
+        ? unwrapData(await input.client.getJobTemplate(input.targetId))
+        : unwrapData(await input.client.getDatabaseView(input.targetId));
+    if (input.manifest.target.type === 'MATERIALIZED_VIEW' && !isLiveMaterializedView(dependency)) {
+        throw new Error('verified Schedule target is no longer a live Materialized View');
+    }
+    if (readConfiguredResourceMetadataStableKey(dependency, input.stableKeyName) !== targetDependencyStableKey(input.manifest.target)) {
+        throw new Error(`verified Schedule target ${targetDependencyLabel(input.manifest.target)} does not match the desired stable key`);
+    }
+    const verifiedManifest = manifestFromRecord({
+        record: schedule,
+        stableKey: input.manifest.stableKey,
+        target: input.manifest.target,
+        stableKeyName: input.stableKeyName,
+    });
+    if (hashPortableSchedule(verifiedManifest) !== input.desiredHash) {
+        throw new Error('written Schedule did not match desired portable hash');
+    }
+}
+export async function pushSchedules(input) {
+    const plan = await buildSchedulesPlan(input);
+    assertSchedulesPushable(plan, input.force === true, input.allowMaterialized === true);
+    const localByKey = workspaceSchedulesByStableKey(input.cwd, input.stableKeyName);
+    const results = [];
+    const verifiedActivationCandidates = [];
+    const processWrite = async (item, action) => {
+        const stableKey = item.stableKey || '';
+        const local = localByKey.get(stableKey);
+        const targetPath = local ? localTargetPath(input.cwd, local.manifestPath) : stableKey;
+        try {
+            if (!local) {
+                throw new Error('desired manifest disappeared after planning');
+            }
+            const desiredHash = hashPortableSchedule(local.manifest);
+            if (desiredHash !== item.desiredHash) {
+                throw new Error('desired manifest changed after planning');
+            }
+            const live = await resolveLiveScheduleWriteTarget({
+                client: input.client,
+                stableKeyName: input.stableKeyName,
+                manifest: local.manifest,
+                action,
+            });
+            let scheduleId;
+            if (action === 'create') {
+                const created = unwrapData(await input.client.createSchedule(buildScheduleCreatePayload(local.manifest, live.targetId)));
+                scheduleId = scheduleIdOf(created);
+                if (!scheduleId) {
+                    const resolvedCreated = await resolveLiveScheduleWriteTarget({
+                        client: input.client,
+                        stableKeyName: input.stableKeyName,
+                        manifest: local.manifest,
+                        action: 'update',
+                    });
+                    if (!resolvedCreated.scheduleId) {
+                        throw new Error('created Schedule could not be resolved by stableKey');
+                    }
+                    scheduleId = resolvedCreated.scheduleId;
+                }
+            }
+            else {
+                if (!live.scheduleId || !live.schedule || typeof live.schedule.version !== 'number') {
+                    throw new Error('live target Schedule did not include id and version');
+                }
+                if (live.currentHash !== item.currentHash) {
+                    throw new Error('target Schedule changed after planning');
+                }
+                await input.client.updateSchedule(live.scheduleId, buildScheduleUpdatePayload(local.manifest, live.targetId, live.schedule.version));
+                scheduleId = live.scheduleId;
+            }
+            await verifyScheduleWrite({
+                client: input.client,
+                stableKeyName: input.stableKeyName,
+                manifest: local.manifest,
+                scheduleId,
+                targetId: live.targetId,
+                desiredHash,
+            });
+            updateScheduleEnvironmentBaseline({
+                cwd: input.cwd,
+                envName: input.envName,
+                manifest: local.manifest,
+                manifestPath: local.manifestPath,
+                remoteHash: desiredHash,
+            });
+            results.push({ stableKey, action, status: 'deployed', targetPath });
+            if (local.manifest.activationCandidate === true) {
+                verifiedActivationCandidates.push({
+                    stableKey,
+                    scheduleId,
+                    targetPath,
+                    stableKeyName: input.stableKeyName,
+                    targetId: live.targetId,
+                    target: local.manifest.target,
+                });
+            }
+        }
+        catch (error) {
+            results.push({ stableKey, action, status: 'failed', targetPath, error: schedulePushError(error) });
+        }
+    };
+    for (const item of plan.items.filter((candidate) => candidate.status === 'create')) {
+        await processWrite(item, 'create');
+    }
+    for (const item of plan.items.filter((candidate) => candidate.status === 'clean')) {
+        const local = item.stableKey ? localByKey.get(item.stableKey) : undefined;
+        if (local && item.currentHash) {
+            updateScheduleEnvironmentBaseline({
+                cwd: input.cwd,
+                envName: input.envName,
+                manifest: local.manifest,
+                manifestPath: local.manifestPath,
+                remoteHash: item.currentHash,
+            });
+        }
+        results.push({
+            stableKey: item.stableKey || item.name,
+            action: 'noop',
+            status: 'skipped',
+            targetPath: local ? localTargetPath(input.cwd, local.manifestPath) : item.stableKey || item.name,
+            reason: 'no local changes',
+        });
+    }
+    for (const item of plan.items.filter((candidate) => (input.force === true
+        && candidate.status === 'missing-lock'
+        && candidate.desiredHash === candidate.currentHash))) {
+        const stableKey = item.stableKey || '';
+        const local = localByKey.get(stableKey);
+        const targetPath = local ? localTargetPath(input.cwd, local.manifestPath) : stableKey;
+        try {
+            if (!local || !item.currentHash) {
+                throw new Error('missing-lock Schedule could not be resolved for baseline adoption');
+            }
+            const live = await resolveLiveScheduleWriteTarget({
+                client: input.client,
+                stableKeyName: input.stableKeyName,
+                manifest: local.manifest,
+                action: 'update',
+            });
+            if (live.currentHash !== item.currentHash) {
+                throw new Error('target Schedule changed after planning');
+            }
+            updateScheduleEnvironmentBaseline({
+                cwd: input.cwd,
+                envName: input.envName,
+                manifest: local.manifest,
+                manifestPath: local.manifestPath,
+                remoteHash: item.currentHash,
+            });
+            results.push({
+                stableKey,
+                action: 'noop',
+                status: 'deployed',
+                targetPath,
+                reason: 'force-adopted verified target into environment lock baseline',
+            });
+        }
+        catch (error) {
+            results.push({
+                stableKey,
+                action: 'noop',
+                status: 'failed',
+                targetPath,
+                error: schedulePushError(error),
+            });
+        }
+    }
+    for (const item of plan.items.filter((candidate) => (candidate.status === 'safe-update'
+        || (input.force === true
+            && (['remote-changed', 'conflict'].includes(candidate.status)
+                || (candidate.status === 'missing-lock'
+                    && candidate.desiredHash !== candidate.currentHash)))))) {
+        await processWrite(item, 'update');
+    }
+    for (const item of plan.items.filter((candidate) => candidate.status === 'orphan')) {
+        results.push({
+            stableKey: item.stableKey || item.name,
+            action: 'orphan',
+            status: 'skipped',
+            targetPath: item.stableKey || item.name,
+            reason: 'target-only orphan',
+        });
+    }
+    for (const item of plan.items.filter((candidate) => candidate.status === 'skipped')) {
+        results.push({
+            stableKey: item.stableKey || item.name,
+            action: 'skipped',
+            status: 'skipped',
+            targetPath: item.stableKey || item.name,
+            reason: item.reason || 'unmanaged',
+        });
+    }
+    return { plan, results, verifiedActivationCandidates };
+}
+export async function activateVerifiedSchedules(input) {
+    const results = [];
+    for (const candidate of input.candidates) {
+        try {
+            const current = unwrapData(await input.client.getSchedule(candidate.scheduleId));
+            if (readConfiguredResourceMetadataStableKey(current, candidate.stableKeyName) !== candidate.stableKey) {
+                throw new Error('target Schedule stable key changed after activation preflight');
+            }
+            const expectedTargetType = candidate.target.type === 'JOB_TEMPLATE' ? 'JOB_TEMPLATE' : 'PLATFORM_OPERATION';
+            if (current.targetType !== expectedTargetType || current.targetId !== candidate.targetId) {
+                throw new Error('target Schedule dependency changed after activation preflight');
+            }
+            if (candidate.target.type === 'MATERIALIZED_VIEW'
+                && materializedRefreshMode(current) !== candidate.target.refreshMode) {
+                throw new Error('target Schedule materialized view refresh mode changed after activation preflight');
+            }
+            const dependency = candidate.target.type === 'JOB_TEMPLATE'
+                ? unwrapData(await input.client.getJobTemplate(candidate.targetId))
+                : unwrapData(await input.client.getDatabaseView(candidate.targetId));
+            if (candidate.target.type === 'MATERIALIZED_VIEW' && !isLiveMaterializedView(dependency)) {
+                throw new Error('target Schedule dependency is no longer a live Materialized View');
+            }
+            if (readConfiguredResourceMetadataStableKey(dependency, candidate.stableKeyName)
+                !== targetDependencyStableKey(candidate.target)) {
+                throw new Error('target Schedule dependency stable key changed after activation preflight');
+            }
+            if (current.active === true) {
+                results.push({
+                    stableKey: candidate.stableKey,
+                    action: 'activate',
+                    status: 'skipped',
+                    targetPath: candidate.targetPath,
+                    reason: 'already active',
+                });
+                continue;
+            }
+            await input.client.activateSchedule(candidate.scheduleId);
+            const verified = unwrapData(await input.client.getSchedule(candidate.scheduleId));
+            if (verified.active !== true) {
+                throw new Error('activation did not leave the Schedule active');
+            }
+            results.push({
+                stableKey: candidate.stableKey,
+                action: 'activate',
+                status: 'deployed',
+                targetPath: candidate.targetPath,
+            });
+        }
+        catch (error) {
+            results.push({
+                stableKey: candidate.stableKey,
+                action: 'activate',
+                status: 'failed',
+                targetPath: candidate.targetPath,
+                error: schedulePushError(error),
+            });
+        }
+    }
+    return results;
+}