@supacloud/cli 0.79.0 → 0.81.0

package/dist/index.js

@@ -179093,11 +179093,13 @@ function resolveSupaCloudContext(env = process.env, cwd = process.cwd(), selecti
 var ACTION_POLICY = {
   deploy: { write: ["deploy"] },
   applications: {
-    read: ["list_releases", "get_release", "get_runtime", "get_deployment_evidence", "get_configuration", "get_rollback_snapshot", "logs", "get_preview_plan"],
+    read: ["list_releases", "get_release", "get_runtime", "get_deployment_evidence", "get_configuration", "get_release_transfer_plan", "get_promotion_plan", "get_rollback_snapshot", "get_history", "get_deploy_plan", "logs", "get_preview_plan"],
     write: [
       "upload_release",
       "put_configuration",
+      "transfer_release",
       "activate_release",
+      "deploy_release",
       "rollback_release",
       "reconcile_activation",
       "retire_activation",
@@ -179177,7 +179179,7 @@ var ACTION_POLICY = {
   scheduled_functions: { read: ["list", "get"], write: ["create", "update", "delete"] },
   mutations: { read: ["status"] },
   release: {
-    read: ["logical_backup_list", "postgrest_status"],
+    read: ["logical_backup_list", "logical_backup_status", "postgrest_status"],
     local: ["scope_inspect", "scope_rebind", "scope_create"],
     write: ["logical_backup_create", "logical_backup_restore", "postgrest_restart", "release_canary_fixture_stage_replay", "release_canary_fixture_disable_replay"]
   },
@@ -179200,8 +179202,8 @@ var ACTION_POLICY = {
   ai: { local: ["show_skill", "install_skill"] },
   app: {
     local: ["init", "generate", "dev", "watch", "verify-plan", "compile", "check", "graph", "explain", "export-tools", "context", "doctor", "fix", "plan", "build"],
-    read: ["status", "logs", "rollback-plan", "preview-plan"],
-    write: ["upload", "configure", "deploy", "rollback", "reconcile", "retire", "preview", "previews", "preview-status", "preview-cleanup"]
+    read: ["status", "logs", "transfer-plan", "promote-plan", "rollback-plan", "history", "deploy-plan", "diff", "preview-plan"],
+    write: ["upload", "configure", "transfer", "deploy", "rollback", "reconcile", "retire", "preview", "previews", "preview-status", "preview-cleanup"]
   },
   db: {
     local: ["context", "lint", "explain", "diff", "role_sql"],
@@ -180294,6 +180296,176 @@ var ApplicationRollbackSnapshotSchema = _Object_({
   active: Union([RollbackActivationSchema, Null()]),
   previous: Union([RollbackActivationSchema, Null()])
 }, { additionalProperties: false });
+// node_modules/@supacloud/delivery/src/application-deploy-plan.ts
+var CandidateSchema = _Object_({
+  release_id: ApplicationReleaseIdSchema,
+  configuration_id: ApplicationConfigurationIdSchema
+}, { additionalProperties: false });
+var ApplicationDeployPlanSchema = _Object_({
+  schema: Literal("supacloud.application-deploy-plan.v1"),
+  project_ref: String2({ pattern: "^[a-z0-9-]{1,20}$" }),
+  application_id: ApplicationIdSchema,
+  environment_id: ApplicationIdSchema,
+  candidate: CandidateSchema,
+  current: Union([_Object_({
+    ...CandidateSchema.properties,
+    activation_id: ApplicationActivationIdSchema
+  }, { additionalProperties: false }), Null()]),
+  expected_activation_id: Union([ApplicationActivationIdSchema, Null()]),
+  action: Union([Literal("activate"), Literal("no-op")]),
+  changes: _Object_({
+    release: Boolean2(),
+    configuration: Boolean2(),
+    targets: _Object_({
+      added: _Array_(String2()),
+      removed: _Array_(String2()),
+      changed: _Array_(String2())
+    }, { additionalProperties: false })
+  }, { additionalProperties: false }),
+  migrations: _Object_({
+    ledger_digest: ApplicationReleaseIdSchema,
+    ledger_compatible: Boolean2(),
+    project_migrations_applied: Boolean2(),
+    operator_provisioning: Union([
+      Literal("separate-verification-required"),
+      Literal("not-declared")
+    ])
+  }, { additionalProperties: false }),
+  compatibility: Literal("not-proven"),
+  execution_performed: Literal(false)
+}, { additionalProperties: false });
+function parseApplicationDeployPlan(value) {
+  if (!Check2(ApplicationDeployPlanSchema, value) || value.expected_activation_id !== (value.current?.activation_id ?? null) || value.changes.release !== (value.current?.release_id !== value.candidate.release_id) || value.changes.configuration !== (value.current?.configuration_id !== value.candidate.configuration_id) || value.migrations.project_migrations_applied && !value.migrations.ledger_compatible) {
+    throw new Error("Invalid application deploy plan");
+  }
+  const noOp = value.current !== null && !value.changes.release && !value.changes.configuration && Object.values(value.changes.targets).every((names) => names.length === 0) && value.migrations.ledger_compatible && value.migrations.project_migrations_applied && value.migrations.operator_provisioning === "not-declared";
+  if (value.action === "no-op" !== noOp)
+    throw new Error("Invalid application deploy plan action");
+  return value;
+}
+// node_modules/@supacloud/delivery/src/application-history.ts
+var scope = {
+  project_ref: String2({ pattern: "^[a-z0-9-]{1,20}$" }),
+  application_id: ApplicationIdSchema,
+  environment_id: ApplicationIdSchema
+};
+var timestamp = String2({ pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{6}Z$" });
+var ApplicationActivationHistoryPositionSchema = _Object_({
+  completed_at: timestamp,
+  activation_id: ApplicationActivationIdSchema
+}, { additionalProperties: false });
+var cursorSchema = _Object_({
+  ...scope,
+  ...ApplicationActivationHistoryPositionSchema.properties
+}, { additionalProperties: false });
+var ApplicationActivationHistoryCursorSchema = String2({
+  pattern: "^[A-Za-z0-9_-]+$",
+  maxLength: 1024,
+  minLength: 1
+});
+var entrySchema = _Object_({
+  ...ApplicationActivationHistoryPositionSchema.properties,
+  release_id: ApplicationReleaseIdSchema,
+  configuration_id: Union([ApplicationConfigurationIdSchema, Null()]),
+  previous_activation_id: Union([ApplicationActivationIdSchema, Null()]),
+  is_active: Boolean2()
+}, { additionalProperties: false });
+var ApplicationActivationHistorySchema = _Object_({
+  schema: Literal("supacloud.application-activation-history.v1"),
+  ...scope,
+  active_activation_id: Union([ApplicationActivationIdSchema, Null()]),
+  activations: _Array_(entrySchema, { maxItems: 100 }),
+  next_cursor: Union([ApplicationActivationHistoryCursorSchema, Null()])
+}, { additionalProperties: false });
+function applicationHistoryTimestampMilliseconds(value) {
+  const milliseconds = `${value.slice(0, 23)}Z`;
+  if (!Check2(timestamp, value) || !Number.isFinite(Date.parse(milliseconds)) || new Date(milliseconds).toISOString() !== milliseconds)
+    throw new Error("Invalid application history timestamp");
+  return milliseconds;
+}
+function parseApplicationHistoryCursor(value, scope) {
+  if (!Check2(ApplicationActivationHistoryCursorSchema, value))
+    throw new Error("Invalid application history cursor");
+  const bytes = Buffer.from(value, "base64url");
+  if (bytes.toString("base64url") !== value)
+    throw new Error("Invalid application history cursor");
+  const cursor = JSON.parse(bytes.toString("utf8"));
+  if (!Check2(cursorSchema, cursor) || cursor.project_ref !== scope.project_ref || cursor.application_id !== scope.application_id || cursor.environment_id !== scope.environment_id) {
+    throw new Error("Invalid application history cursor");
+  }
+  applicationHistoryTimestampMilliseconds(cursor.completed_at);
+  return { completed_at: cursor.completed_at, activation_id: cursor.activation_id };
+}
+function applicationHistoryPositionBefore(left, right) {
+  return left.completed_at < right.completed_at || left.completed_at === right.completed_at && left.activation_id < right.activation_id;
+}
+function parseApplicationActivationHistory(value) {
+  if (!Check2(ApplicationActivationHistorySchema, value))
+    throw new Error("Invalid application activation history");
+  const seen = new Set;
+  let previous;
+  for (const entry of value.activations) {
+    applicationHistoryTimestampMilliseconds(entry.completed_at);
+    if (seen.has(entry.activation_id) || previous && !applicationHistoryPositionBefore(entry, previous) || entry.previous_activation_id === entry.activation_id || entry.is_active !== (entry.activation_id === value.active_activation_id)) {
+      throw new Error("Invalid application activation history");
+    }
+    seen.add(entry.activation_id);
+    previous = entry;
+  }
+  if (value.next_cursor !== null) {
+    const cursor = parseApplicationHistoryCursor(value.next_cursor, value);
+    if (!previous || cursor.activation_id !== previous.activation_id || cursor.completed_at !== previous.completed_at) {
+      throw new Error("Invalid application activation history");
+    }
+  }
+  return structuredClone(value);
+}
+// node_modules/@supacloud/delivery/src/application-release-transfer.ts
+var projectRef = String2({ pattern: "^[A-Za-z0-9_-]{1,20}$" });
+var source = _Object_({
+  project_ref: projectRef,
+  release_id: ApplicationReleaseIdSchema,
+  manifest_sha256: ApplicationReleaseIdSchema
+}, { additionalProperties: false });
+var identity = {
+  project_ref: projectRef,
+  application_id: ApplicationIdSchema,
+  source,
+  candidate_release_id: ApplicationReleaseIdSchema
+};
+var ApplicationReleaseTransferPlanSchema = _Object_({
+  schema: Literal("supacloud.application-release-transfer-plan.v1"),
+  ...identity,
+  action: Union([Literal("materialize"), Literal("no-op")]),
+  execution_performed: Literal(false)
+}, { additionalProperties: false });
+var ApplicationReleaseTransferResultSchema = _Object_({
+  schema: Literal("supacloud.application-release-transfer-result.v1"),
+  ...identity,
+  release: ApplicationReleaseRecordSchema,
+  activation_performed: Literal(false)
+}, { additionalProperties: false });
+function assertIdentity(value) {
+  if (value.source.release_id !== applicationReleaseId(value.source.project_ref, value.application_id, value.source.manifest_sha256) || value.candidate_release_id !== applicationReleaseId(value.project_ref, value.application_id, value.source.manifest_sha256)) {
+    throw new Error("Invalid application release transfer identity");
+  }
+}
+function parseApplicationReleaseTransferPlan(candidate) {
+  if (!Check2(ApplicationReleaseTransferPlanSchema, candidate))
+    throw new Error("Invalid application release transfer plan");
+  assertIdentity(candidate);
+  return candidate;
+}
+function parseApplicationReleaseTransferResult(candidate) {
+  if (!Check2(ApplicationReleaseTransferResultSchema, candidate))
+    throw new Error("Invalid application release transfer result");
+  assertIdentity(candidate);
+  const release = parseApplicationReleaseRecord(candidate.release);
+  if (release.project_ref !== candidate.project_ref || release.application_id !== candidate.application_id || release.release_id !== candidate.candidate_release_id || release.manifest_sha256 !== candidate.source.manifest_sha256) {
+    throw new Error("Invalid application release transfer result");
+  }
+  return candidate;
+}
 // node_modules/@supacloud/delivery/src/deployment-evidence.ts
 var closed3 = { additionalProperties: false };
 var sha256 = String2({ pattern: "^[a-f0-9]{64}$" });
@@ -180419,6 +180591,116 @@ function parseDeploymentEvidence(value) {
   }
   return structuredClone(value);
 }
+// node_modules/@supacloud/delivery/src/application-promotion.ts
+var closed4 = { additionalProperties: false };
+var projectRef2 = String2({ pattern: "^[a-z0-9-]{1,20}$" });
+var sha2562 = ApplicationReleaseIdSchema;
+var nullableActivation = Union([ApplicationActivationIdSchema, Null()]);
+var nullableDigest = Union([sha2562, Null()]);
+var observation = {
+  activation_id: nullableActivation,
+  receipt_confirmed: Boolean2(),
+  ready: Boolean2(),
+  smoke_verified: Boolean2(),
+  evidence_sha256: nullableDigest,
+  migration_ledger_digest: nullableDigest
+};
+var blocker = [
+  "SOURCE_NOT_ACTIVE",
+  "SOURCE_RECEIPT_UNCONFIRMED",
+  "SOURCE_NOT_READY",
+  "SOURCE_SMOKE_UNVERIFIED",
+  "TARGET_CONFIGURATION_MISSING",
+  "TARGET_CONFIGURATION_MISMATCH",
+  "MIGRATION_PENDING",
+  "MIGRATION_CONFLICT",
+  "OPERATOR_PROVISIONING_REQUIRED",
+  "BACKUP_REQUIRED"
+];
+var ApplicationPromotionPlanSchema = _Object_({
+  schema: Literal("supacloud.application-promotion-plan.v1"),
+  project_ref: projectRef2,
+  application_id: ApplicationIdSchema,
+  environment_id: ApplicationIdSchema,
+  manifest_sha256: sha2562,
+  plan_sha256: sha2562,
+  source: _Object_({
+    project_ref: projectRef2,
+    environment_id: ApplicationIdSchema,
+    release_id: sha2562,
+    ...observation
+  }, closed4),
+  target: _Object_({
+    candidate_release_id: sha2562,
+    current_release_id: Union([sha2562, Null()]),
+    artifact_action: Union([Literal("materialize"), Literal("reuse")]),
+    configuration_id: Union([ApplicationConfigurationIdSchema, Null()]),
+    configuration: Union([ApplicationConfigurationViewSchema, Null()]),
+    ...observation
+  }, closed4),
+  migrations: _Object_({
+    ledger_digest: sha2562,
+    ledger_compatible: Boolean2(),
+    project_migrations_applied: Boolean2(),
+    pending_versions: _Array_(String2({ pattern: "^\\d{1,20}$" }), { maxItems: 4096, uniqueItems: true }),
+    operator_provisioning_required: Boolean2()
+  }, closed4),
+  backup: _Object_({
+    required: Boolean2(),
+    confirmed: Literal(false)
+  }, closed4),
+  action: Union([Literal("promote"), Literal("no-op"), Literal("blocked")]),
+  blockers: _Array_(Enum([...blocker]), {
+    maxItems: blocker.length,
+    uniqueItems: true
+  }),
+  steps: _Array_(String2({ minLength: 1, maxLength: 64 }), { maxItems: 8, uniqueItems: true }),
+  execution_performed: Literal(false),
+  data_recovery: Literal("separate-required")
+}, closed4);
+function applicationPromotionPlanDigest(value) {
+  return digest(canonical(value));
+}
+function applicationPromotionAction(value) {
+  if (value.blockers.length > 0)
+    return "blocked";
+  return value.target.artifact_action === "reuse" && value.target.current_release_id === value.target.candidate_release_id && value.target.configuration !== null && value.target.activation_id !== null && value.target.receipt_confirmed && value.target.ready && value.target.smoke_verified && value.migrations.project_migrations_applied && !value.migrations.operator_provisioning_required && (!value.backup.required || value.backup.confirmed) ? "no-op" : "promote";
+}
+function applicationPromotionSteps(value) {
+  if (value.action === "no-op")
+    return [];
+  return [
+    ...value.blockers.some((code) => code.startsWith("SOURCE_")) ? ["verify-source"] : [],
+    ...value.blockers.some((code) => code.startsWith("TARGET_CONFIGURATION_")) ? ["bind-target-configuration"] : [],
+    ...value.blockers.includes("MIGRATION_CONFLICT") ? ["resolve-migration-conflicts"] : [],
+    ...!value.backup.required || value.backup.confirmed ? [] : ["backup"],
+    ...value.migrations.project_migrations_applied ? [] : ["review-and-apply-migrations"],
+    ...value.migrations.operator_provisioning_required ? ["verify-operator-provisioning"] : [],
+    ...value.action === "promote" ? [
+      ...value.target.artifact_action === "materialize" ? ["transfer"] : [],
+      "activate-with-cas",
+      "verify-runtime-and-smoke"
+    ] : []
+  ];
+}
+function parseApplicationPromotionPlan(value) {
+  if (!Check2(ApplicationPromotionPlanSchema, value))
+    throw new Error("Invalid application promotion plan");
+  const { plan_sha256: _planSha256, ...content } = value;
+  if (value.migrations.project_migrations_applied && (!value.migrations.ledger_compatible || value.migrations.pending_versions.length > 0) || !value.source.activation_id && (value.source.ready || value.source.receipt_confirmed || value.source.smoke_verified) || !value.target.activation_id && (value.target.ready || value.target.receipt_confirmed || value.target.smoke_verified) || !value.blockers.length && (!value.source.ready || !value.source.receipt_confirmed || !value.source.smoke_verified || !value.source.activation_id || !value.target.configuration || !value.migrations.ledger_compatible)) {
+    throw new Error("Invalid application promotion prerequisites");
+  }
+  if (value.backup.required !== !value.migrations.project_migrations_applied || [value.source, value.target].some((observation) => observation.smoke_verified && (observation.evidence_sha256 === null || observation.migration_ledger_digest === null)) || value.target.smoke_verified && value.target.migration_ledger_digest !== value.migrations.ledger_digest) {
+    throw new Error("Invalid application promotion migration binding");
+  }
+  if (value.source.release_id !== applicationReleaseId(value.source.project_ref, value.application_id, value.manifest_sha256) || value.target.candidate_release_id !== applicationReleaseId(value.project_ref, value.application_id, value.manifest_sha256) || value.action !== applicationPromotionAction(content) || canonical(value.steps) !== canonical(applicationPromotionSteps(content)) || value.plan_sha256 !== applicationPromotionPlanDigest(content) || value.target.configuration !== null && (() => {
+    const configuration = parseApplicationConfigurationView(value.target.configuration);
+    return configuration.project_ref !== value.project_ref || configuration.application_id !== value.application_id || configuration.environment_id !== value.environment_id || configuration.configuration_id !== value.target.configuration_id;
+  })()) {
+    throw new Error("Invalid application promotion plan identity");
+  }
+  return structuredClone(value);
+}
 // node_modules/@supacloud/delivery/src/application-runtime-identity.ts
 var ApplicationRuntimeIdentitySchema = _Object_({
   schema: Literal("supacloud.application-runtime.v1"),
@@ -180465,7 +180747,7 @@ function parseApplicationReadinessReport(value) {
   return value;
 }
 // node_modules/@supacloud/delivery/src/delivery-migration-archive.ts
-var entrySchema = _Object_({
+var entrySchema2 = _Object_({
   version: String2({ pattern: "^[1-9][0-9]{0,18}$" }),
   name: String2({ pattern: "^[A-Za-z][A-Za-z0-9_-]{0,127}$" }),
   executor: Union([Literal("project-migration"), Literal("operator-provisioning")]),
@@ -180479,7 +180761,7 @@ var archiveSchema = _Object_({
   compatibility: Literal("not-proven"),
   executionPerformed: Literal(false),
   dataRecovery: Literal("separate-required"),
-  migrations: _Array_(entrySchema, { minItems: 1, maxItems: 128 })
+  migrations: _Array_(entrySchema2, { minItems: 1, maxItems: 128 })
 }, { additionalProperties: false });
 async function readDeliveryMigrationArchive(manifestPath, target) {
   try {
@@ -181426,7 +181708,7 @@ ALTER TABLE supacloud_commands.execution_receipts
   DROP COLUMN IF EXISTS recovery_attempts;
 `;
 var MAX_MIGRATION_VERSION = 9223372036854775807n;
-function sha2562(value) {
+function sha2563(value) {
   return createHash22("sha256").update(value).digest("hex");
 }
 function normalizedSql(value) {
@@ -181495,7 +181777,7 @@ function planMigrationRebase(migrations, options, baselineSql) {
     file: migration.file,
     version: migration.version,
     name: migration.name,
-    sha256: sha2562(normalizedSql(migration.sql))
+    sha256: sha2563(normalizedSql(migration.sql))
   }));
   return {
     version: 1,
@@ -181505,8 +181787,8 @@ function planMigrationRebase(migrations, options, baselineSql) {
     baselineMigration,
     retainedMigrations: retained.map((migration) => migration.file),
     archivedMigrations: archived.map((migration) => migration.file),
-    sourceHistorySha256: sha2562(JSON.stringify(sourceHistory)),
-    baselineSha256: sha2562(normalizedBaseline),
+    sourceHistorySha256: sha2563(JSON.stringify(sourceHistory)),
+    baselineSha256: sha2563(normalizedBaseline),
     warnings: [
       "The baseline must come from a schema-only snapshot of the verified target database.",
       "Data backfills, reference data and non-replayable side effects need a separate review.",
@@ -181542,7 +181824,7 @@ async function rebaseMigrations(options) {
       file: migration.file,
       version: migration.version,
       name: migration.name,
-      sha256: sha2562(normalizedSql(migration.sql))
+      sha256: sha2563(normalizedSql(migration.sql))
     }))
   }, null, 2) + `
 `);
@@ -184444,7 +184726,7 @@ function clientId(value) {
   }
   return value;
 }
-function projectRef(value) {
+function projectRef3(value) {
   if (typeof value !== "string" || !value.trim())
     throw new Error("'ref' is required");
   return projectRefPathSegment(value.trim(), "OAuth client");
@@ -184596,7 +184878,7 @@ function registerOAuthClientTools(server2, http) {
     client_id: optional(String2(), "[get/delete] Exact release-canary public OAuth client ID"),
     redirect_uri: optional(String2(), "[create/delete] Exact HTTPS or port-bound RFC 8252 loopback callback")
   }, async ({ action, ref, client_id, redirect_uri }) => {
-    const targetRef = projectRef(ref);
+    const targetRef = projectRef3(ref);
     if (action === "list")
       return listReleaseCanaryClients(http, targetRef);
     if (action === "get")
@@ -187267,6 +187549,65 @@ var ApplicationActivationWriteSchema2 = ApplicationActivationWriteSchema;
 var ApplicationActivationResultSchema2 = ApplicationActivationResultSchema;
 var ApplicationActivationRetirementResultSchema2 = ApplicationActivationRetirementResultSchema;
 var ApplicationRollbackSnapshotSchema2 = ApplicationRollbackSnapshotSchema;
+var ApplicationActivationHistoryCursorSchema2 = ApplicationActivationHistoryCursorSchema;
+
+// src/shared/tools/application-release-transfer.ts
+async function applicationReleaseTransfer(http, input, project) {
+  const operation = `applications.${input.action}`;
+  const identity = {
+    project_ref: input.ref,
+    application_id: input.id,
+    source_ref: input.sourceRef,
+    source_release_id: input.sourceReleaseId
+  };
+  const path = `/v1/projects/${project}/applications/${encodeURIComponent(input.id)}`;
+  const query = new URLSearchParams({ source_ref: input.sourceRef, source_release_id: input.sourceReleaseId });
+  const response = await http.get(`${path}/release-transfer-plan?${query}`, { maxJsonBytes: 65536, responseTimeoutMs: 30000 });
+  if (!response.ok)
+    return releaseControlFailure(operation, "HTTP_ERROR", response.transportError ? null : response.status, identity);
+  let plan;
+  try {
+    if (response.status !== 200)
+      throw new Error;
+    plan = parseApplicationReleaseTransferPlan(response.data);
+    if (plan.project_ref !== input.ref || plan.application_id !== input.id || plan.source.project_ref !== input.sourceRef || plan.source.release_id !== input.sourceReleaseId)
+      throw new Error;
+  } catch {
+    return releaseControlFailure(operation, "INVALID_RESPONSE", response.status, identity);
+  }
+  if (input.action === "get_release_transfer_plan")
+    return releaseControlSuccess(operation, { ...identity, plan });
+  const safeIdentity = {
+    ...identity,
+    release_id: plan.candidate_release_id,
+    manifest_sha256: plan.source.manifest_sha256
+  };
+  if (plan.action === "no-op")
+    return releaseControlSuccess(operation, {
+      ...safeIdentity,
+      no_op: true,
+      execution_performed: false,
+      activation_performed: false,
+      plan
+    });
+  const result = await http.postReleaseMutation(`${path}/release-transfers`, {
+    source_ref: input.sourceRef,
+    source_release_id: input.sourceReleaseId,
+    expected_manifest_sha256: plan.source.manifest_sha256
+  }, { timeoutMs: 120000 });
+  if (!result.ok)
+    return releaseControlMutationFailure(operation, result, safeIdentity);
+  try {
+    if (result.status !== 200)
+      throw new Error;
+    const receipt = parseApplicationReleaseTransferResult(result.data);
+    if (receipt.project_ref !== input.ref || receipt.application_id !== input.id || receipt.source.project_ref !== input.sourceRef || receipt.source.release_id !== input.sourceReleaseId || receipt.candidate_release_id !== plan.candidate_release_id || receipt.source.manifest_sha256 !== plan.source.manifest_sha256)
+      throw new Error;
+    return releaseControlSuccess(operation, { ...safeIdentity, no_op: false, transfer: receipt });
+  } catch {
+    return releaseControlFailure(operation, "OUTCOME_UNKNOWN", result.status, safeIdentity);
+  }
+}
 
 // src/shared/tools/application-preview-tools.ts
 var APPLICATION_PREVIEW_ACTIONS = [
@@ -187353,14 +187694,14 @@ var actionFields = {
   get_preview: ["preview_id", "wait", "timeout_seconds"],
   cleanup_preview: ["preview_id"]
 };
-function timestamp(value) {
+function timestamp2(value) {
   return Number.isFinite(Date.parse(value)) && new Date(value).toISOString() === value;
 }
 function receipt(value, identity) {
   if (!Check2(receiptSchema, value) || value.project_ref !== identity.ref || value.application_id !== identity.id || value.environment_id !== identity.environment || identity.previewId && value.preview_id !== identity.previewId || value.resources.build_artifact.release_id !== value.release_id || value.resources.storage_namespace.namespace !== value.resources.database_branch.branch_ref) {
     throw new Error("Invalid preview receipt");
   }
-  if (value.expires_at !== null && !timestamp(value.expires_at) || value.created_at !== undefined && !timestamp(value.created_at) || value.updated_at !== undefined && !timestamp(value.updated_at) || value.expires_at !== null && value.created_at !== undefined && !Check2(ttlSecondsSchema, (Date.parse(value.expires_at) - Date.parse(value.created_at)) / 1000)) {
+  if (value.expires_at !== null && !timestamp2(value.expires_at) || value.created_at !== undefined && !timestamp2(value.created_at) || value.updated_at !== undefined && !timestamp2(value.updated_at) || value.expires_at !== null && value.created_at !== undefined && !Check2(ttlSecondsSchema, (Date.parse(value.expires_at) - Date.parse(value.created_at)) / 1000)) {
     throw new Error("Invalid preview expiry");
   }
   if (value.status === "ready") {
@@ -187604,9 +187945,15 @@ var APPLICATION_TOOL_SCHEMA = {
     "get_deployment_evidence",
     "get_configuration",
     "put_configuration",
+    "get_deploy_plan",
+    "deploy_release",
+    "get_release_transfer_plan",
+    "transfer_release",
+    "get_promotion_plan",
     "activate_release",
     "rollback_release",
     "get_rollback_snapshot",
+    "get_history",
     "reconcile_activation",
     "retire_activation",
     ...APPLICATION_PREVIEW_ACTIONS,
@@ -187614,15 +187961,18 @@ var APPLICATION_TOOL_SCHEMA = {
   ]), "Action"),
   ref: withDescription(String2(), "Project ref"),
   id: withDescription(ApplicationIdSchema2, "Application ID"),
-  environment_id: optional(withDescription(ApplicationIdSchema2, "[get_runtime/get_configuration/put_configuration/get_rollback_snapshot/rollback_release] Environment ID")),
-  configuration_id: optional(ApplicationConfigurationIdSchema2, "[get_configuration/activate_release/rollback_release] Immutable revision; required for explicit activation"),
-  activation_id: optional(ApplicationActivationIdSchema2, "[activate_release/reconcile_activation/retire_activation/rollback_release] Explicit stable activation ID; generated for rollback if omitted"),
-  expected_activation_id: optional(Union([ApplicationActivationIdSchema2, Null(), Literal("absent")]), "[activate_release/rollback_release] Current activation ID, or absent for first activation; selected by platform for default rollback"),
+  environment_id: optional(withDescription(ApplicationIdSchema2, "[get_runtime/get_configuration/put_configuration/get_deploy_plan/deploy_release/get_rollback_snapshot/rollback_release/get_history] Environment ID")),
+  configuration_id: optional(ApplicationConfigurationIdSchema2, "[get_configuration/get_deploy_plan/deploy_release/activate_release/rollback_release/get_history] Immutable revision; required for deployment"),
+  activation_id: optional(ApplicationActivationIdSchema2, "[deploy_release/activate_release/reconcile_activation/retire_activation/rollback_release/get_history] Stable activation ID; generated for automatic deployment/rollback if omitted"),
+  expected_activation_id: optional(Union([ApplicationActivationIdSchema2, Null(), Literal("absent")]), "[deploy_release/activate_release/rollback_release] Current activation ID, or absent for first activation; selected from verified plan for automatic deployment"),
   configuration_path: optional(String2(), "[put_configuration] Local configuration write JSON including revision and expected revision"),
   manifest_path: optional(String2(), "[upload_release] Local delivery.manifest.json"),
-  release_id: optional(ApplicationReleaseIdSchema2, "[get_release/activate_release/reconcile_activation/rollback_release] Immutable application release ID; platform selects previous for default rollback"),
-  cursor: optional(ApplicationReleaseIdSchema2, "[list_releases] Last release ID"),
-  limit: optional(Integer({ minimum: 1, maximum: 100 }), "[list_releases] Page size, default 50"),
+  release_id: optional(ApplicationReleaseIdSchema2, "[get_release/get_deploy_plan/deploy_release/activate_release/reconcile_activation/rollback_release] Immutable application release ID; platform selects previous for default rollback"),
+  source_ref: optional(String2({ pattern: "^[A-Za-z0-9_-]{1,20}$" }), "[get_release_transfer_plan/transfer_release] Source project ref"),
+  source_release_id: optional(ApplicationReleaseIdSchema2, "[get_release_transfer_plan/transfer_release] Source immutable release ID"),
+  source_environment_id: optional(ApplicationIdSchema2, "[get_promotion_plan] Source environment"),
+  cursor: optional(Union([ApplicationReleaseIdSchema2, ApplicationActivationHistoryCursorSchema2]), "[list_releases/get_history] Returned page cursor"),
+  limit: optional(Integer({ minimum: 1, maximum: 100 }), "[list_releases/get_history] Page size, default 50/20"),
   offset: optional(Integer({ minimum: 0, maximum: 1e6 }), "[logs] Result offset"),
   service: optional(String2(), "[logs] Application target/service filter"),
   search: optional(String2(), "[logs] Full-text log filter"),
@@ -187653,6 +188003,84 @@ function boundRelease(value, ref, id) {
     throw new Error("Unbound application release");
   return release;
 }
+async function readDeployPlan(http, args, project) {
+  const ref = text(args, "ref"), id = text(args, "id"), environmentId = text(args, "environment_id");
+  const releaseId = text(args, "release_id"), configurationId = text(args, "configuration_id");
+  if (!Check2(ApplicationIdSchema2, environmentId) || !Check2(ApplicationReleaseIdSchema2, releaseId) || !Check2(ApplicationConfigurationIdSchema2, configurationId))
+    throw new Error("Invalid deployment plan identity");
+  const identity = {
+    project_ref: ref,
+    application_id: id,
+    environment_id: environmentId,
+    release_id: releaseId,
+    configuration_id: configurationId
+  };
+  const query = new URLSearchParams({ release_id: releaseId, configuration_id: configurationId });
+  const response = await http.get(`/v1/projects/${project}/applications/${encodeURIComponent(id)}/environments/${encodeURIComponent(environmentId)}/deploy-plan?${query}`, { maxJsonBytes: 65536, responseTimeoutMs: 30000 });
+  const operation = `applications.${text(args, "action")}`;
+  if (!response.ok)
+    return { failure: releaseControlFailure(operation, "HTTP_ERROR", response.transportError ? null : response.status, identity) };
+  let plan;
+  try {
+    if (response.status !== 200)
+      throw new Error("Incomplete deployment plan response");
+    plan = parseApplicationDeployPlan(response.data);
+    if (plan.project_ref !== ref || plan.application_id !== id || plan.environment_id !== environmentId || plan.candidate.release_id !== releaseId || plan.candidate.configuration_id !== configurationId)
+      throw new Error;
+  } catch {
+    return { failure: releaseControlFailure(operation, "INVALID_RESPONSE", response.status, identity) };
+  }
+  return { plan, identity };
+}
+async function deployAction(http, args, project) {
+  const activationId = args["activation_id"], expected = args["expected_activation_id"];
+  if (activationId !== undefined && !Check2(ApplicationActivationIdSchema2, activationId)) {
+    throw new Error("Invalid application activation ID");
+  }
+  if (expected !== undefined && expected !== null && expected !== "absent" && !Check2(ApplicationActivationIdSchema2, expected))
+    throw new Error("Invalid expected activation ID");
+  if (activationId !== undefined && expected !== undefined) {
+    return activationAction(http, { ...args, action: "activate_release" }, project, {
+      operation: "applications.deploy_release",
+      configuration_id: args["configuration_id"],
+      expected_activation_id: expected === "absent" ? null : expected
+    });
+  }
+  const observed = await readDeployPlan(http, args, project);
+  if (observed.failure)
+    return observed.failure;
+  const { plan, identity } = observed;
+  if (expected !== undefined && (expected === "absent" ? null : expected) !== plan.expected_activation_id) {
+    return releaseControlFailure("applications.deploy_release", "HTTP_ERROR", 409, {
+      ...identity,
+      reason: "EXPECTED_ACTIVATION_CONFLICT",
+      expected_activation_id: plan.expected_activation_id
+    });
+  }
+  if (plan.action === "no-op")
+    return releaseControlSuccess("applications.deploy_release", {
+      ...identity,
+      no_op: true,
+      execution_performed: false,
+      activation_id: plan.current.activation_id,
+      expected_activation_id: plan.expected_activation_id,
+      plan,
+      ...activationId === undefined ? {} : { requested_activation_id: activationId }
+    });
+  const selectedId = activationId ?? crypto.randomUUID();
+  if (selectedId === plan.expected_activation_id)
+    throw new Error("Deployment requires a new activation ID");
+  return activationAction(http, {
+    ...args,
+    action: "activate_release",
+    activation_id: selectedId,
+    expected_activation_id: plan.expected_activation_id
+  }, project, {
+    operation: "applications.deploy_release",
+    configuration_id: args["configuration_id"],
+    expected_activation_id: plan.expected_activation_id
+  });
+}
 async function configurationAction(http, args, project) {
   const action = text(args, "action"), ref = text(args, "ref"), id = text(args, "id");
   const environmentId = text(args, "environment_id"), operation = `applications.${action}`;
@@ -187699,7 +188127,7 @@ async function configurationAction(http, args, project) {
     return releaseControlFailure(operation, action === "put_configuration" ? "OUTCOME_UNKNOWN" : "INVALID_RESPONSE", result.status, identity);
   }
 }
-async function activationAction(http, args, project, rollback) {
+async function activationAction(http, args, project, selection) {
   const action = text(args, "action"), ref = text(args, "ref"), id = text(args, "id");
   const environmentId = text(args, "environment_id"), activationId = text(args, "activation_id");
   const releaseId = args["release_id"] === undefined ? undefined : text(args, "release_id");
@@ -187709,7 +188137,7 @@ async function activationAction(http, args, project, rollback) {
   if (!Check2(ApplicationIdSchema2, environmentId) || !Check2(ApplicationActivationIdSchema2, activationId) || action !== "retire_activation" && !Check2(ApplicationReleaseIdSchema2, releaseId)) {
     throw new Error("Invalid application activation identity");
   }
-  const operation = rollback ? "applications.rollback_release" : `applications.${action}`;
+  const operation = selection?.operation ?? `applications.${action}`;
   const path = `/v1/projects/${project}/applications/${encodeURIComponent(id)}/environments/${encodeURIComponent(environmentId)}/activations`;
   const identity = {
     project_ref: ref,
@@ -187718,7 +188146,11 @@ async function activationAction(http, args, project, rollback) {
     activation_id: activationId,
     ...releaseId ? { release_id: releaseId } : {}
   };
-  const safeState = { ...identity, ...rollback ?? {} };
+  const selectedState = selection ? {
+    configuration_id: selection.configuration_id,
+    expected_activation_id: selection.expected_activation_id
+  } : {};
+  const safeState = { ...identity, ...selectedState };
   let body = {};
   if (action === "activate_release") {
     body = {
@@ -187745,7 +188177,7 @@ async function activationAction(http, args, project, rollback) {
   if (!Check2(ApplicationActivationResultSchema2, result.data) || Object.entries(identity).some(([key, value]) => Reflect.get(result.data, key) !== value) || action === "reconcile_activation" && !result.data.replayed) {
     return releaseControlFailure(operation, "OUTCOME_UNKNOWN", result.status, safeState);
   }
-  return releaseControlSuccess(operation, { ...result.data, ...rollback ?? {} });
+  return releaseControlSuccess(operation, { ...result.data, ...selectedState });
 }
 async function rollbackAction(http, args, project) {
   const ref = text(args, "ref"), id = text(args, "id"), environmentId = text(args, "environment_id");
@@ -187794,10 +188226,38 @@ async function rollbackAction(http, args, project) {
     configuration_id: configurationId,
     expected_activation_id: expectedActivationId
   }, project, {
+    operation: "applications.rollback_release",
     configuration_id: configurationId,
     expected_activation_id: expectedActivationId === "absent" ? null : expectedActivationId
   });
 }
+async function historyAction(http, args, project) {
+  const ref = text(args, "ref"), id = text(args, "id"), environmentId = text(args, "environment_id");
+  if (!Check2(ApplicationIdSchema2, environmentId))
+    throw new Error("Invalid environment ID");
+  const limit = args["limit"] ?? 20, cursor = args["cursor"];
+  if (typeof limit !== "number" || !Number.isInteger(limit) || limit < 1 || limit > 100 || cursor !== undefined && typeof cursor !== "string")
+    throw new Error("Invalid history page");
+  const query = new URLSearchParams({ limit: String(limit) });
+  const scope = { project_ref: ref, application_id: id, environment_id: environmentId };
+  const before = typeof cursor === "string" ? parseApplicationHistoryCursor(cursor, scope) : null;
+  if (typeof cursor === "string")
+    query.set("cursor", cursor);
+  const operation = "applications.get_history";
+  const response = await http.get(`/v1/projects/${project}/applications/${encodeURIComponent(id)}/environments/${encodeURIComponent(environmentId)}/history?${query}`, { maxJsonBytes: 262144, responseTimeoutMs: 30000 });
+  if (!response.ok)
+    return releaseControlFailure(operation, "HTTP_ERROR", response.transportError ? null : response.status, scope);
+  try {
+    if (response.status !== 200)
+      throw new Error;
+    const history = parseApplicationActivationHistory(response.data);
+    if (history.project_ref !== ref || history.application_id !== id || history.environment_id !== environmentId || history.activations.length > limit || history.next_cursor !== null && history.activations.length !== limit || before && history.activations.some((entry) => !applicationHistoryPositionBefore(entry, before)))
+      throw new Error;
+    return releaseControlSuccess(operation, { project_ref: ref, application_id: id, environment_id: environmentId, history });
+  } catch {
+    return releaseControlFailure(operation, "INVALID_RESPONSE", response.status, scope);
+  }
+}
 function registerApplicationTools(server2, http) {
   registerTool(server2, "applications", "Store, inspect and explicitly activate immutable HTTP/Worker application releases. Upload does not activate a release.", APPLICATION_TOOL_SCHEMA, async (args) => {
     const action = text(args, "action"), ref = text(args, "ref"), id = text(args, "id");
@@ -187806,9 +188266,63 @@ function registerApplicationTools(server2, http) {
       throw new Error("Invalid application ID");
     const path = `/v1/projects/${project}/applications/${encodeURIComponent(id)}/releases`;
     const operation = `applications.${action}`;
+    if (action === "get_promotion_plan") {
+      const environmentId = text(args, "environment_id");
+      const sourceRef = text(args, "source_ref"), sourceEnvironmentId = text(args, "source_environment_id");
+      const sourceReleaseId = text(args, "source_release_id");
+      if (!/^[a-z0-9-]{1,20}$/.test(sourceRef) || !Check2(ApplicationReleaseIdSchema2, sourceReleaseId) || !Check2(ApplicationIdSchema2, environmentId) || !Check2(ApplicationIdSchema2, sourceEnvironmentId)) {
+        throw new Error("Invalid promotion environment");
+      }
+      const query = new URLSearchParams({
+        source_ref: sourceRef,
+        source_environment_id: sourceEnvironmentId,
+        source_release_id: sourceReleaseId
+      });
+      if (typeof args["configuration_id"] === "string")
+        query.set("configuration_id", args["configuration_id"]);
+      const result = await http.get(`/v1/projects/${project}/applications/${encodeURIComponent(id)}/environments/${encodeURIComponent(environmentId)}/promotion-plan?${query}`, { maxJsonBytes: 262144, responseTimeoutMs: 30000 });
+      const identity = {
+        project_ref: ref,
+        application_id: id,
+        environment_id: environmentId,
+        source_ref: sourceRef,
+        source_environment_id: sourceEnvironmentId,
+        source_release_id: sourceReleaseId
+      };
+      if (!result.ok)
+        return releaseControlFailure(operation, "HTTP_ERROR", result.status, identity);
+      try {
+        if (result.status !== 200)
+          throw new Error;
+        const plan = parseApplicationPromotionPlan(result.data);
+        if (plan.project_ref !== ref || plan.application_id !== id || plan.environment_id !== environmentId || plan.source.project_ref !== sourceRef || plan.source.environment_id !== sourceEnvironmentId || plan.source.release_id !== sourceReleaseId || args["configuration_id"] !== undefined && plan.target.configuration_id !== args["configuration_id"]) {
+          throw new Error;
+        }
+        return releaseControlSuccess(operation, { ...identity, plan });
+      } catch {
+        return releaseControlFailure(operation, "INVALID_RESPONSE", result.status, identity);
+      }
+    }
+    if (action === "get_release_transfer_plan" || action === "transfer_release") {
+      return applicationReleaseTransfer(http, {
+        action,
+        ref,
+        id,
+        sourceRef: text(args, "source_ref"),
+        sourceReleaseId: text(args, "source_release_id")
+      }, project);
+    }
+    if (action === "get_deploy_plan") {
+      const observed = await readDeployPlan(http, args, project);
+      return observed.failure ?? releaseControlSuccess(operation, { ...observed.identity, plan: observed.plan });
+    }
+    if (action === "deploy_release")
+      return deployAction(http, args, project);
     if (action === "rollback_release" || action === "get_rollback_snapshot") {
       return rollbackAction(http, args, project);
     }
+    if (action === "get_history")
+      return historyAction(http, args, project);
     if (APPLICATION_PREVIEW_ACTIONS.some((value) => value === action)) {
       return applicationPreviewAction(http, args, project);
     }
@@ -194052,11 +194566,17 @@ async function applyScaffoldWrites(plan) {
 // src/shared/tools/app-tools.ts
 var REMOTE_APP_ACTIONS = {
   upload: "upload_release",
+  "transfer-plan": "get_release_transfer_plan",
+  "promote-plan": "get_promotion_plan",
+  transfer: "transfer_release",
   configure: "put_configuration",
-  deploy: "activate_release",
+  deploy: "deploy_release",
+  "deploy-plan": "get_deploy_plan",
+  diff: "get_deploy_plan",
   status: "get_runtime",
   rollback: "rollback_release",
   "rollback-plan": "get_rollback_snapshot",
+  history: "get_history",
   reconcile: "reconcile_activation",
   retire: "retire_activation",
   logs: "logs",
@@ -194067,22 +194587,27 @@ var REMOTE_APP_ACTIONS = {
   "preview-cleanup": "cleanup_preview"
 };
 var REMOTE_APP_DESCRIPTIONS = {
-  ref: "[upload/configure/deploy/status/rollback/rollback-plan/reconcile/retire/preview-plan/preview/previews/preview-status/preview-cleanup] Project ref (defaults to context)",
-  id: "[upload/configure/deploy/status/rollback/rollback-plan/reconcile/retire/preview-plan/preview/previews/preview-status/preview-cleanup] Application ID",
-  environment_id: "[configure/deploy/status/rollback/rollback-plan/reconcile/retire/preview-plan/preview/previews/preview-status/preview-cleanup] Environment ID",
-  configuration_id: "[deploy/rollback/preview] Required for deploy/preview/explicit rollback; platform selects for default rollback",
-  activation_id: "[deploy/rollback/reconcile/retire] Required explicit activation ID; generated for rollback if omitted",
-  expected_activation_id: "[deploy/rollback] Required for deploy/explicit rollback; platform selects current CAS for default rollback",
+  ref: "[upload/configure/transfer-plan/transfer/promote-plan/deploy/deploy-plan/diff/status/rollback/rollback-plan/history/reconcile/retire/preview-plan/preview/previews/preview-status/preview-cleanup] Project ref (defaults to context)",
+  id: "[upload/configure/transfer-plan/transfer/promote-plan/deploy/deploy-plan/diff/status/rollback/rollback-plan/history/reconcile/retire/preview-plan/preview/previews/preview-status/preview-cleanup] Application ID",
+  environment_id: "[configure/promote-plan/deploy/deploy-plan/diff/status/rollback/rollback-plan/history/reconcile/retire/preview-plan/preview/previews/preview-status/preview-cleanup] Target environment ID",
+  configuration_id: "[promote-plan/deploy/deploy-plan/diff/rollback/preview] Immutable target configuration revision; required for deployment/preview; platform selects for default rollback",
+  activation_id: "[deploy/rollback/reconcile/retire] Stable activation ID; auto-generated for deploy/rollback if omitted",
+  expected_activation_id: "[deploy/rollback] Auto-selected from verified state; supply with activation_id for an exact retry",
   configuration_path: "[configure] Configuration write JSON including revision and expected revision",
   manifest_path: "[upload] Local delivery.manifest.json",
-  release_id: "[deploy/rollback/reconcile/preview-plan/preview] Required for deploy/reconcile/preview; defaults to journal-selected previous for rollback",
+  release_id: "[deploy/deploy-plan/diff/rollback/reconcile/preview-plan/preview] Required for deployment/preview; defaults to journal-selected previous for rollback",
+  source_ref: "[transfer-plan/transfer/promote-plan] Source project ref",
+  source_release_id: "[transfer-plan/transfer/promote-plan] Source immutable release ID",
+  source_environment_id: "[promote-plan] Source environment ID",
   preview_id: "[preview-status/preview-cleanup] Preview receipt ID",
   branch_ref: "[preview-plan] Proposed branch ref; preview assigns its own",
   branch_name: "[preview] Branch display name",
   data_mode: "[preview-plan/preview] Default schema_only; full_clone copies rows",
   ttl_seconds: "[preview-plan/preview] Lifetime from 300 to 604800 seconds; creation defaults to the platform TTL",
   wait: "[preview/preview-status] Wait for verified readiness of the selected preview",
-  timeout_seconds: "[preview/preview-status] Observation budget with --wait, from 1 to 3600 seconds (default 300)"
+  timeout_seconds: "[preview/preview-status] Observation budget with --wait, from 1 to 3600 seconds (default 300)",
+  cursor: "[history] Returned page cursor",
+  limit: "[history] Page size, default 20 (1-100)"
 };
 var { action: _remoteAction, ...remoteFields } = APPLICATION_TOOL_SCHEMA;
 var REMOTE_APP_SCHEMA = Partial(_Object_(remoteFields)).properties;
@@ -194981,6 +195506,99 @@ async function runDelivery(args) {
   const result = await buildDeliveryProject(options, loaded.delivery);
   return textResult(JSON.stringify(result, null, 2), !result.ok);
 }
+function formatReleaseTransfer(result) {
+  if (result.isError)
+    return result;
+  try {
+    const payload = JSON.parse(result.content[0]?.text ?? "");
+    if (!payload || typeof payload !== "object" || !("ok" in payload) || payload.ok !== true)
+      return result;
+    const plan = "plan" in payload ? parseApplicationReleaseTransferPlan(payload.plan) : null;
+    const receipt = !plan && "transfer" in payload ? parseApplicationReleaseTransferResult(payload.transfer) : null;
+    const data = plan ?? receipt;
+    if (!data)
+      return result;
+    return textResult([
+      `${data.project_ref}/${data.application_id}: ${plan ? plan.action === "no-op" ? "No changes" : "Transfer required" : "Artifact transferred"}`,
+      `Source: ${data.source.project_ref} / ${data.source.release_id}`,
+      `Target release: ${data.candidate_release_id}`,
+      `Manifest: ${data.source.manifest_sha256}`,
+      "Activation: not performed"
+    ].join(`
+`));
+  } catch {
+    return result;
+  }
+}
+var historyReceiptSchema = _Object_({
+  schema: Literal(RELEASE_CONTROL_RESPONSE_SCHEMA),
+  ok: Literal(true),
+  operation: Literal("applications.get_history"),
+  project_ref: String2(),
+  application_id: String2(),
+  environment_id: String2(),
+  history: ApplicationActivationHistorySchema
+}, { additionalProperties: false });
+function historyText(result, request, projectRef) {
+  if (result.isError)
+    return result;
+  try {
+    if (result.content.length !== 1 || result.content[0].text.length > 262144)
+      throw new Error;
+    const receipt = JSON.parse(result.content[0].text);
+    if (!Check2(historyReceiptSchema, receipt))
+      throw new Error;
+    const history = parseApplicationActivationHistory(receipt.history);
+    if (history.project_ref !== projectRef || history.application_id !== request.id || history.environment_id !== request.environment_id || receipt.project_ref !== history.project_ref || receipt.application_id !== history.application_id || receipt.environment_id !== history.environment_id)
+      throw new Error;
+    const lines = [
+      `Activation History: ${history.project_ref}/${history.application_id}/${history.environment_id}`,
+      `Active activation: ${history.active_activation_id ?? "none"}`,
+      ""
+    ];
+    if (history.activations.length === 0)
+      lines.push("No successful activations on this page.");
+    else {
+      lines.push(`${"Completed (UTC)".padEnd(29)}  ${"State".padEnd(7)}  ${"Activation ID".padEnd(36)}  Release (12)`);
+      for (const entry of history.activations)
+        lines.push(`${entry.completed_at.padEnd(29)}  ${(entry.is_active ? "current" : "-").padEnd(7)}  ${entry.activation_id}  ${entry.release_id.slice(0, 12)}`);
+    }
+    if (history.next_cursor)
+      lines.push("", `Next cursor: ${history.next_cursor}`);
+    return textResult(lines.join(`
+`));
+  } catch {
+    return releaseControlFailure("applications.get_history", "INVALID_RESPONSE", null);
+  }
+}
+function formatRemoteDeployPlan(result) {
+  if (result.isError)
+    return result;
+  try {
+    const payload = JSON.parse(result.content[0]?.text ?? "");
+    if (!payload || typeof payload !== "object" || !("ok" in payload) || payload.ok !== true || !("plan" in payload))
+      return result;
+    const plan = parseApplicationDeployPlan(payload.plan);
+    const names = (values, prefix) => values.map((name) => `${prefix}${name}`);
+    const targets = [
+      ...names(plan.changes.targets.added, "+"),
+      ...names(plan.changes.targets.removed, "-"),
+      ...names(plan.changes.targets.changed, "~")
+    ];
+    return textResult([
+      `${plan.project_ref}/${plan.application_id} [${plan.environment_id}]: ${plan.action === "no-op" ? "No changes" : "Activation required"}`,
+      `Release: ${plan.candidate.release_id} (${plan.changes.release ? "changed" : "unchanged"})`,
+      `Configuration: ${plan.candidate.configuration_id} (${plan.changes.configuration ? "changed" : "unchanged"})`,
+      `Targets: ${targets.length ? targets.join(", ") : "unchanged"}`,
+      `Migrations: ${!plan.migrations.ledger_compatible ? "ledger conflict" : plan.migrations.project_migrations_applied ? "applied" : "pending"}`,
+      `Provisioning: ${plan.migrations.operator_provisioning}`,
+      `Expected activation: ${plan.expected_activation_id ?? "absent"}`
+    ].join(`
+`));
+  } catch {
+    return result;
+  }
+}
 async function runAppTool(request, options = {}) {
   if (request.dry_run !== undefined && request["dry-run"] !== undefined || request.register_in !== undefined && request["register-in"] !== undefined || request.database_url !== undefined && request["database-url"] !== undefined) {
     throw new ScaffoldError("SCAFFOLD_OPTION_INVALID", "Do not combine hyphenated and underscored aliases of the same flag");
@@ -194997,18 +195615,45 @@ async function runAppTool(request, options = {}) {
   if (request.database_url !== undefined && request.action !== "dev" && request.action !== "watch") {
     throw new ScaffoldError("SCAFFOLD_OPTION_INVALID", "--database-url applies only to app dev --profile integration");
   }
+  if (request.json !== undefined && request.action !== "history" && request.action !== "transfer-plan" && request.action !== "transfer" && request.action !== "promote-plan") {
+    throw new Error("--json applies only to app history, transfer-plan, transfer or promote-plan");
+  }
+  if (request.json !== undefined && request.format === "text")
+    throw new Error("--json and --format text cannot be combined");
   if (Object.hasOwn(REMOTE_APP_ACTIONS, request.action)) {
     const delegate = options.getApplications?.();
     if (!delegate)
       return textResult("App remote actions require a Management API context.", true);
     const action = REMOTE_APP_ACTIONS[request.action];
+    const { format, json, ...remoteRequest } = request;
     const args = {
-      ...request,
+      ...remoteRequest,
       action,
       ref: request.ref ?? options.projectRef
     };
     validateToolArguments(APPLICATION_TOOL_SCHEMA, args);
-    return delegate(args);
+    const result = await delegate(args);
+    if (request.action === "history" && format !== "json" && json !== true) {
+      return historyText(result, request, args.ref);
+    }
+    if ((request.action === "deploy-plan" || request.action === "diff") && format !== "json") {
+      return formatRemoteDeployPlan(result);
+    }
+    if (request.action === "promote-plan" && !result.isError && format !== "json" && !json) {
+      const payload = JSON.parse(result.content[0]?.text ?? "");
+      if (!payload || typeof payload !== "object" || !("plan" in payload))
+        return result;
+      const plan = parseApplicationPromotionPlan(payload.plan);
+      return textResult([
+        `${plan.project_ref}/${plan.application_id}/${plan.environment_id}: ${plan.action}`,
+        `Source: ${plan.source.project_ref}/${plan.source.environment_id}`,
+        ...plan.blockers.length ? [`Blocked: ${plan.blockers.join(", ")}`] : [],
+        ...plan.steps.length ? [`Next: ${plan.steps.join(" -> ")}`] : [],
+        "Execution: not performed"
+      ].join(`
+`));
+    }
+    return (request.action === "transfer-plan" || request.action === "transfer") && format !== "json" && !json ? formatReleaseTransfer(result) : result;
   }
   switch (request.action) {
     case "verify-plan": {
@@ -195082,10 +195727,16 @@ function registerAppTools(server2, options = {}) {
       "build",
       "upload",
       "configure",
+      "transfer-plan",
+      "transfer",
+      "promote-plan",
       "deploy",
+      "deploy-plan",
+      "diff",
       "status",
       "rollback",
       "rollback-plan",
+      "history",
       "reconcile",
       "retire",
       "logs",
@@ -195094,7 +195745,7 @@ function registerAppTools(server2, options = {}) {
       "previews",
       "preview-status",
       "preview-cleanup"
-    ]), "App action; upload/configure only prepare, rollback activates the journal-selected previous release without schema downgrade"),
+    ]), "App action; transfer reuses a verified release without build or activation; local plan is topology-only, deploy-plan/diff observe remote state, deploy skips verified no-op, rollback never downgrades schema"),
     kind: optional(stringEnum(["module", "command", "query", "controller", "job", "contract", "resource"]), "[generate] Scaffold kind"),
     template: optional(stringEnum(["minimal", "http", "command", "edge"]), "[init] Minimal application by default; explicit http/command/edge recipes"),
     name: optional(String2(), "[init/generate] Project or object name"),
@@ -195109,7 +195760,8 @@ function registerAppTools(server2, options = {}) {
     include: optional(String2(), "[dev/compile/check] Comma-separated glob patterns for source files"),
     out_dir: optional(String2(), "[dev/compile/plan/build/export-tools] Output directory (default: configured outDir)"),
     strict: optional(Boolean2(), "[dev/compile/check] Promote warnings to errors"),
-    format: optional(stringEnum(["text", "json"]), "[dev/generate/compile/check/plan/graph/export-tools] Output format (default: text)"),
+    format: optional(stringEnum(["text", "json"]), "[dev/generate/compile/check/plan/deploy-plan/diff/history/promote-plan/graph/export-tools] Output format (default: text)"),
+    json: optional(Boolean2(), "[history/transfer-plan/transfer/promote-plan] Preserve or return the full machine-readable receipt"),
     profile: optional(stringEnum(["fast", "integration"]), "[dev] Run dev or dev:integration; integration verifies an explicit loopback database"),
     once: optional(Boolean2(), "[dev] Validate and report once without watching"),
     watch: optional(Boolean2(), "[dev] Watch for changes (default: true; --once disables)"),
@@ -196550,7 +197202,8 @@ function validProjectRef(ref) {
   return SAFE_PROJECT_REF.test(ref);
 }
 function backupBelongsToProject(backupId, projectRef) {
-  return BACKUP_ID.test(backupId) && backupId.startsWith(`logical-full_${projectRef}_`);
+  const prefix = `logical-full_${projectRef}_`;
+  return BACKUP_ID.test(backupId) && backupId.startsWith(prefix) && /^[a-f0-9]{32}$/.test(backupId.slice(prefix.length));
 }
 function verifiedBackup(value, projectRef) {
   if (!isRecord6(value) || typeof value.backup_id !== "string" || !backupBelongsToProject(value.backup_id, projectRef) || value.project_ref !== projectRef || typeof value.database !== "string" || !SAFE_DATABASE.test(value.database) || value.kind !== "logical-full" || !canonicalTimestamp4(value.created_at) || !canonicalTimestamp4(value.completed_at) || new Date(value.completed_at).valueOf() < new Date(value.created_at).valueOf() || typeof value.bytes !== "number" || !Number.isSafeInteger(value.bytes) || value.bytes <= 0 || typeof value.sha256 !== "string" || !SHA256.test(value.sha256))
@@ -196589,16 +197242,11 @@ function publicBackup(backup) {
 function equalBackup(left, right) {
   return left.backup_id === right.backup_id && left.project_ref === right.project_ref && left.database === right.database && left.kind === right.kind && left.created_at === right.created_at && left.completed_at === right.completed_at && left.bytes === right.bytes && left.sha256 === right.sha256;
 }
-function newlyCreatedBackup(before, after) {
-  const afterById = new Map(after.map((backup) => [backup.backup_id, backup]));
-  for (const previous of before) {
-    const current = afterById.get(previous.backup_id);
-    if (!current || !equalBackup(previous, current))
-      return null;
+function requiredBackupId(value, projectRef) {
+  if (typeof value !== "string" || !backupBelongsToProject(value, projectRef)) {
+    throw new Error("'backup_id' must identify a logical-full backup for 'ref'");
   }
-  const known = new Set(before.map((backup) => backup.backup_id));
-  const additions = after.filter((backup) => !known.has(backup.backup_id));
-  return additions.length === 1 ? additions[0] : null;
+  return value;
 }
 function restoreRequest(projectRef, backupId, expectedSha256, restoreConfirmation) {
   if (typeof backupId !== "string" || !backupBelongsToProject(backupId, projectRef)) {
@@ -196624,11 +197272,27 @@ function httpFailure(operation, response) {
   }
   return releaseControlFailure(operation, "HTTP_ERROR", response.transportError ? null : response.status);
 }
-function mutationFailure(operation, response) {
-  if (response.responseReadError || response.transportError || response.status === 408 || response.status >= 500) {
-    return releaseControlFailure(operation, "OUTCOME_UNKNOWN", response.transportError ? null : response.status);
+function mutationOutcomeUnknown(response) {
+  return Boolean(response.responseReadError || response.transportError || response.status === 408 || response.status >= 500 || response.status >= 200 && response.status < 300 && response.status !== 200);
+}
+function mutationFailure(operation, response, safeState = {}) {
+  if (mutationOutcomeUnknown(response)) {
+    return releaseControlFailure(operation, "OUTCOME_UNKNOWN", response.transportError ? null : response.status, safeState);
   }
-  return releaseControlFailure(operation, "HTTP_ERROR", response.status);
+  return releaseControlFailure(operation, "HTTP_ERROR", response.status, safeState);
+}
+async function readBackup(http, projectRef, backupId) {
+  let response;
+  try {
+    response = await http.get(`${endpoint(projectRef)}/database/backups/logical/${backupId}`, {
+      maxJsonBytes: MUTATION_MAX_BYTES,
+      responseTimeoutMs: RELEASE_READ_RESPONSE_TIMEOUT_MS
+    });
+  } catch {
+    response = { ok: false, status: 0, data: null, transportError: true };
+  }
+  const candidate = response.ok && response.status === 200 && isRecord6(response.data) ? verifiedBackup(response.data.backup, projectRef) : null;
+  return { response, backup: candidate?.backup_id === backupId ? candidate : null };
 }
 async function readInventory(http, projectRef) {
   const response = await http.get(`${endpoint(projectRef)}/database/backups/logical`, {
@@ -197041,6 +197705,7 @@ function registerReleaseTools(server2, http, options = {}) {
   const localActions = ["scope_inspect", "scope_rebind", "scope_create"];
   const remoteActions = [
     "logical_backup_list",
+    "logical_backup_status",
     "logical_backup_create",
     "logical_backup_restore",
     "postgrest_status",
@@ -197063,7 +197728,7 @@ function registerReleaseTools(server2, http, options = {}) {
     web: optional(Boolean2(), "[scope_create] Whether web assets are included in release scope"),
     dry_run: optional(Boolean2(), "[scope_rebind] Perform calculation and validation without writing files"),
     cwd: optional(String2(), "[scope_inspect/scope_rebind/scope_create] Base directory for relative file and git resolution"),
-    backup_id: optional(String2(), "[logical_backup_restore] Exact verified logical-full backup ID from the selected project inventory"),
+    backup_id: optional(String2(), "[logical_backup_create/status/restore] Stable project-bound backup ID; create generates one when omitted"),
     expected_sha256: optional(String2(), "[logical_backup_restore] Exact lowercase SHA-256 from the selected project inventory"),
     restore_confirmation: optional(String2(), "[logical_backup_restore] Exact RESTORE_PROJECT:<ref>:<backup_id>:<sha256> confirmation"),
     subject: optional(String2(), "[release_canary_fixture_stage_replay/disable_replay] Exact central subject UUID"),
@@ -197108,28 +197773,47 @@ function registerReleaseTools(server2, http, options = {}) {
       });
     }
     if (action === "logical_backup_create") {
-      const before = await readInventory(http, projectRef);
-      const beforeFailure = readInventoryFailure("release.logical_backup.create", before);
-      if (beforeFailure)
-        return beforeFailure;
-      const mutation = await http.postReleaseMutation(`${endpoint(projectRef)}/database/backups/logical`, {}, {
-        timeoutMs: BACKUP_TIMEOUT_MS
-      });
-      const after = await readInventory(http, projectRef);
+      const backupId = requiredBackupId(backup_id ?? `logical-full_${projectRef}_${crypto.randomUUID().replaceAll("-", "")}`, projectRef);
+      const state = { project_ref: projectRef, backup_id: backupId };
+      let mutation;
+      try {
+        mutation = await http.postReleaseMutation(`${endpoint(projectRef)}/database/backups/logical`, { backup_id: backupId }, { timeoutMs: BACKUP_TIMEOUT_MS });
+      } catch {
+        mutation = { ok: false, status: 0, data: null, transportError: true };
+      }
       if (!mutation.ok || mutation.status !== 200) {
-        return mutationFailure("release.logical_backup.create", mutation);
+        if (mutationOutcomeUnknown(mutation)) {
+          const observed = await readBackup(http, projectRef, backupId);
+          if (observed.backup)
+            return releaseControlFailure("release.logical_backup.create", "OUTCOME_UNKNOWN", mutation.transportError ? null : mutation.status, {
+              ...state,
+              backup: publicBackup(observed.backup),
+              backup_verified: true,
+              creation_confirmed: false
+            });
+        }
+        return mutationFailure("release.logical_backup.create", mutation, state);
       }
       const responseBackup = isRecord6(mutation.data) ? verifiedBackup(mutation.data.backup, projectRef) : null;
-      const afterFailure = readInventoryFailure("release.logical_backup.create", after);
-      const addedBackup = after.inventory && newlyCreatedBackup(before.inventory, after.inventory);
-      if (!responseBackup || afterFailure || !addedBackup || !equalBackup(responseBackup, addedBackup)) {
-        return releaseControlFailure("release.logical_backup.create", "OUTCOME_UNKNOWN", mutation.status);
+      const after = await readBackup(http, projectRef, backupId);
+      if (!responseBackup || responseBackup.backup_id !== backupId || !after.backup || !equalBackup(responseBackup, after.backup)) {
+        return releaseControlFailure("release.logical_backup.create", "OUTCOME_UNKNOWN", mutation.status, state);
       }
       return releaseControlSuccess("release.logical_backup.create", {
-        project_ref: projectRef,
-        backup: publicBackup(addedBackup)
+        ...state,
+        backup: publicBackup(after.backup)
       });
     }
+    if (action === "logical_backup_status") {
+      const backupId = requiredBackupId(backup_id, projectRef);
+      const read = await readBackup(http, projectRef, backupId);
+      const state = { project_ref: projectRef, backup_id: backupId };
+      if (!read.response.ok || read.response.status !== 200) {
+        const code = read.response.responseReadError || read.response.status >= 200 && read.response.status < 300 ? "INVALID_RESPONSE" : "HTTP_ERROR";
+        return releaseControlFailure("release.logical_backup.status", code, read.response.transportError ? null : read.response.status, state);
+      }
+      return read.backup ? releaseControlSuccess("release.logical_backup.status", { ...state, backup: publicBackup(read.backup) }) : releaseControlFailure("release.logical_backup.status", "INVALID_RESPONSE", read.response.status, state);
+    }
     if (action === "logical_backup_restore") {
       const request = restoreRequest(projectRef, backup_id, expected_sha256, restore_confirmation);
       const before = await readInventory(http, projectRef);
@@ -198661,7 +199345,7 @@ function registerRemoteDevTools(server2, options = {}) {
 // package.json
 var package_default = {
   name: "@supacloud/cli",
-  version: "0.79.0",
+  version: "0.81.0",
   description: "Project-scoped CLI for SupaCloud users",
   type: "module",
   main: "./dist/index.js",
@@ -198713,14 +199397,14 @@ var package_default = {
   },
   dependencies: {
     "@supacloud/compiler": "^0.43.0",
-    "@supacloud/delivery": "0.9.0",
+    "@supacloud/delivery": "0.11.0",
     "@supacloud/db": "0.16.0",
     fflate: "^0.8.3",
     typebox: "1.3.34"
   },
   overrides: {
     "@supacloud/contracts": "0.8.0",
-    "@supacloud/delivery": "0.9.0",
+    "@supacloud/delivery": "0.11.0",
     "@graphql-tools/utils": "^12.0.3"
   },
   devDependencies: {
@@ -198941,6 +199625,7 @@ EXAMPLES
   ${preferredCommand} project logs --log_type database
   ${preferredCommand} project task_stats
   ${preferredCommand} release logical_backup_create --ref abc123
+  ${preferredCommand} release logical_backup_status --ref abc123 --backup_id <backup_id>
   ${preferredCommand} release logical_backup_restore --ref abc123 --backup_id <backup_id> --expected_sha256 <sha256> --restore_confirmation RESTORE_PROJECT:abc123:<backup_id>:<sha256>
   ${preferredCommand} release postgrest_status --ref abc123
   ${preferredCommand} release postgrest_restart --ref abc123
@@ -198981,8 +199666,11 @@ EXAMPLES
   ${preferredCommand} app build --root .
   ${preferredCommand} app upload --ref abc123 --id orders --manifest_path generated/delivery/delivery.manifest.json
   ${preferredCommand} app configure --ref abc123 --id orders --environment_id test --configuration_path configuration.json
-  ${preferredCommand} app deploy --ref abc123 --id orders --environment_id test --release_id <sha256> --configuration_id <uuid> --activation_id <uuid> --expected_activation_id absent
+  ${preferredCommand} app deploy-plan --ref abc123 --id orders --environment_id test --release_id <sha256> --configuration_id <uuid>
+  ${preferredCommand} app diff --ref abc123 --id orders --environment_id test --release_id <sha256> --configuration_id <uuid>
+  ${preferredCommand} app deploy --ref abc123 --id orders --environment_id test --release_id <sha256> --configuration_id <uuid>
   ${preferredCommand} app status --ref abc123 --id orders --environment_id test
+  ${preferredCommand} --env production app promote-plan --id orders --environment_id production --source_ref staging --source_environment_id staging --source_release_id <sha256>
   ${preferredCommand} app preview-plan --ref abc123 --id orders --environment_id test --release_id <sha256> --branch_ref preview-orders
   ${preferredCommand} app preview --ref abc123 --id orders --environment_id test --release_id <sha256> --configuration_id <uuid> --ttl_seconds 3600 --wait
   ${preferredCommand} app previews --ref abc123 --id orders --environment_id test