timeback 0.1.6 → 0.1.7

package/dist/cli.js

@@ -31971,14 +31971,20 @@ var TimebackConfig = exports_external2.object({
   message: "Duplicate courseCode found; each must be unique",
   path: ["courses"]
 }).refine((config22) => {
-  return config22.courses.every((c) => c.sensor !== undefined || config22.sensor !== undefined);
-}, {
-  message: "Each course must have an effective sensor; set a top-level `sensor` or per-course `sensor`",
-  path: ["courses"]
-}).refine((config22) => {
-  return config22.courses.every((c) => c.launchUrl !== undefined || config22.launchUrl !== undefined);
+  return config22.courses.every((c) => {
+    if (c.sensor !== undefined || config22.sensor !== undefined) {
+      return true;
+    }
+    const launchUrls = [
+      c.launchUrl,
+      config22.launchUrl,
+      c.overrides?.staging?.launchUrl,
+      c.overrides?.production?.launchUrl
+    ].filter(Boolean);
+    return launchUrls.length > 0;
+  });
 }, {
-  message: "Each course must have an effective launchUrl; set a top-level `launchUrl` or per-course `launchUrl`",
+  message: "Each course must have an effective sensor. Either set `sensor` explicitly (top-level or per-course), or provide a `launchUrl` so sensor can be derived from its origin.",
   path: ["courses"]
 });
 var EdubridgeDateString = exports_external2.union([IsoDateString, IsoDateTimeString]);
@@ -48374,14 +48380,20 @@ var TimebackConfig2 = exports_external22.object({
   message: "Duplicate courseCode found; each must be unique",
   path: ["courses"]
 }).refine((config222) => {
-  return config222.courses.every((c) => c.sensor !== undefined || config222.sensor !== undefined);
-}, {
-  message: "Each course must have an effective sensor; set a top-level `sensor` or per-course `sensor`",
-  path: ["courses"]
-}).refine((config222) => {
-  return config222.courses.every((c) => c.launchUrl !== undefined || config222.launchUrl !== undefined);
+  return config222.courses.every((c) => {
+    if (c.sensor !== undefined || config222.sensor !== undefined) {
+      return true;
+    }
+    const launchUrls = [
+      c.launchUrl,
+      config222.launchUrl,
+      c.overrides?.staging?.launchUrl,
+      c.overrides?.production?.launchUrl
+    ].filter(Boolean);
+    return launchUrls.length > 0;
+  });
 }, {
-  message: "Each course must have an effective launchUrl; set a top-level `launchUrl` or per-course `launchUrl`",
+  message: "Each course must have an effective sensor. Either set `sensor` explicitly (top-level or per-course), or provide a `launchUrl` so sensor can be derived from its origin.",
   path: ["courses"]
 });
 var EdubridgeDateString2 = exports_external22.union([IsoDateString2, IsoDateTimeString2]);
@@ -65812,14 +65824,20 @@ var TimebackConfig3 = exports_external3.object({
   message: "Duplicate courseCode found; each must be unique",
   path: ["courses"]
 }).refine((config222) => {
-  return config222.courses.every((c) => c.sensor !== undefined || config222.sensor !== undefined);
-}, {
-  message: "Each course must have an effective sensor; set a top-level `sensor` or per-course `sensor`",
-  path: ["courses"]
-}).refine((config222) => {
-  return config222.courses.every((c) => c.launchUrl !== undefined || config222.launchUrl !== undefined);
+  return config222.courses.every((c) => {
+    if (c.sensor !== undefined || config222.sensor !== undefined) {
+      return true;
+    }
+    const launchUrls = [
+      c.launchUrl,
+      config222.launchUrl,
+      c.overrides?.staging?.launchUrl,
+      c.overrides?.production?.launchUrl
+    ].filter(Boolean);
+    return launchUrls.length > 0;
+  });
 }, {
-  message: "Each course must have an effective launchUrl; set a top-level `launchUrl` or per-course `launchUrl`",
+  message: "Each course must have an effective sensor. Either set `sensor` explicitly (top-level or per-course), or provide a `launchUrl` so sensor can be derived from its origin.",
   path: ["courses"]
 });
 var EdubridgeDateString3 = exports_external3.union([IsoDateString3, IsoDateTimeString3]);
@@ -83444,14 +83462,20 @@ var TimebackConfig4 = exports_external4.object({
   message: "Duplicate courseCode found; each must be unique",
   path: ["courses"]
 }).refine((config222) => {
-  return config222.courses.every((c) => c.sensor !== undefined || config222.sensor !== undefined);
-}, {
-  message: "Each course must have an effective sensor; set a top-level `sensor` or per-course `sensor`",
-  path: ["courses"]
-}).refine((config222) => {
-  return config222.courses.every((c) => c.launchUrl !== undefined || config222.launchUrl !== undefined);
+  return config222.courses.every((c) => {
+    if (c.sensor !== undefined || config222.sensor !== undefined) {
+      return true;
+    }
+    const launchUrls = [
+      c.launchUrl,
+      config222.launchUrl,
+      c.overrides?.staging?.launchUrl,
+      c.overrides?.production?.launchUrl
+    ].filter(Boolean);
+    return launchUrls.length > 0;
+  });
 }, {
-  message: "Each course must have an effective launchUrl; set a top-level `launchUrl` or per-course `launchUrl`",
+  message: "Each course must have an effective sensor. Either set `sensor` explicitly (top-level or per-course), or provide a `launchUrl` so sensor can be derived from its origin.",
   path: ["courses"]
 });
 var EdubridgeDateString4 = exports_external4.union([IsoDateString4, IsoDateTimeString4]);
@@ -100106,14 +100130,20 @@ var TimebackConfig5 = exports_external5.object({
   message: "Duplicate courseCode found; each must be unique",
   path: ["courses"]
 }).refine((config222) => {
-  return config222.courses.every((c) => c.sensor !== undefined || config222.sensor !== undefined);
-}, {
-  message: "Each course must have an effective sensor; set a top-level `sensor` or per-course `sensor`",
-  path: ["courses"]
-}).refine((config222) => {
-  return config222.courses.every((c) => c.launchUrl !== undefined || config222.launchUrl !== undefined);
+  return config222.courses.every((c) => {
+    if (c.sensor !== undefined || config222.sensor !== undefined) {
+      return true;
+    }
+    const launchUrls = [
+      c.launchUrl,
+      config222.launchUrl,
+      c.overrides?.staging?.launchUrl,
+      c.overrides?.production?.launchUrl
+    ].filter(Boolean);
+    return launchUrls.length > 0;
+  });
 }, {
-  message: "Each course must have an effective launchUrl; set a top-level `launchUrl` or per-course `launchUrl`",
+  message: "Each course must have an effective sensor. Either set `sensor` explicitly (top-level or per-course), or provide a `launchUrl` so sensor can be derived from its origin.",
   path: ["courses"]
 });
 var EdubridgeDateString5 = exports_external5.union([IsoDateString5, IsoDateTimeString5]);
@@ -102332,14 +102362,20 @@ var TimebackConfig6 = exports_external.object({
   message: "Duplicate courseCode found; each must be unique",
   path: ["courses"]
 }).refine((config6) => {
-  return config6.courses.every((c) => c.sensor !== undefined || config6.sensor !== undefined);
-}, {
-  message: "Each course must have an effective sensor; set a top-level `sensor` or per-course `sensor`",
-  path: ["courses"]
-}).refine((config6) => {
-  return config6.courses.every((c) => c.launchUrl !== undefined || config6.launchUrl !== undefined);
+  return config6.courses.every((c) => {
+    if (c.sensor !== undefined || config6.sensor !== undefined) {
+      return true;
+    }
+    const launchUrls = [
+      c.launchUrl,
+      config6.launchUrl,
+      c.overrides?.staging?.launchUrl,
+      c.overrides?.production?.launchUrl
+    ].filter(Boolean);
+    return launchUrls.length > 0;
+  });
 }, {
-  message: "Each course must have an effective launchUrl; set a top-level `launchUrl` or per-course `launchUrl`",
+  message: "Each course must have an effective sensor. Either set `sensor` explicitly (top-level or per-course), or provide a `launchUrl` so sensor can be derived from its origin.",
   path: ["courses"]
 });
 // ../types/src/zod/edubridge.ts
@@ -103453,6 +103489,46 @@ function toCourseConfig(course, env2) {
   }
   return config7;
 }
+async function inferLaunchUrl(client, courseId) {
+  try {
+    const scopedCourse = client.oneroster.courses(courseId);
+    const components = await scopedCourse.components({ where: { status: "active" } });
+    const componentResourceIds = [];
+    for (const component of components) {
+      if (!component.sourcedId)
+        continue;
+      const crs = await client.oneroster.courses.componentResources({
+        where: { "courseComponent.sourcedId": component.sourcedId, status: "active" }
+      });
+      for (const cr of crs) {
+        if (cr.resource?.sourcedId) {
+          componentResourceIds.push(cr.resource.sourcedId);
+        }
+      }
+    }
+    if (componentResourceIds.length === 0) {
+      return;
+    }
+    const resourceIds = [...new Set(componentResourceIds)];
+    const resources = await client.oneroster.resources.listAll({
+      where: { sourcedId: { in: resourceIds } }
+    });
+    const launchUrls = new Set;
+    for (const resource of resources) {
+      const metadata = resource.metadata;
+      const launchUrl = metadata?.launchUrl;
+      if (typeof launchUrl === "string" && launchUrl.length > 0) {
+        launchUrls.add(launchUrl);
+      }
+    }
+    if (launchUrls.size === 1) {
+      return [...launchUrls][0];
+    }
+    return;
+  } catch {
+    return;
+  }
+}
 // ../internal/cli-infra/src/search/search.ts
 function searchCourses(client, query, max = 50) {
   return client.oneroster.courses.listAll({
@@ -103475,11 +103551,11 @@ async function promptSelectEnv(configuredEnvs) {
 }
 async function promptAppName() {
   const name = await he({
-    message: "App name",
+    message: "Search for your app",
     placeholder: "My Timeback App",
     validate: (value) => {
       if (!value.trim())
-        return "App name is required";
+        return "Please enter a search term";
     }
   });
   if (pD(name))
@@ -103584,6 +103660,40 @@ async function selectCourses(client, initialResults, filterFn) {
     results = filter(moreResults);
   }
 }
+async function enrichCoursesWithLaunchUrls(client, courses) {
+  if (courses.length === 0)
+    return courses;
+  const s = Y2();
+  let didStop = false;
+  const stopOnce = (message) => {
+    if (didStop)
+      return;
+    s.stop(message);
+    didStop = true;
+  };
+  s.start("Fetching course details...");
+  const enriched = [];
+  try {
+    for (const course of courses) {
+      const courseId = course.ids?.staging ?? course.ids?.production;
+      if (!courseId) {
+        enriched.push(course);
+        continue;
+      }
+      const launchUrl = await inferLaunchUrl(client, courseId);
+      if (launchUrl && !course.launchUrl) {
+        enriched.push({ ...course, launchUrl });
+      } else {
+        enriched.push(course);
+      }
+    }
+    stopOnce("Course details loaded");
+    return enriched;
+  } catch (error57) {
+    stopOnce("Failed to load course details");
+    throw error57;
+  }
+}
 async function searchAndSelectCourses(options) {
   const { client, environment, appName: existingAppName, excludeCourseIds = [] } = options;
   const filterExcluded = (courses) => {
@@ -103606,11 +103716,11 @@ async function searchAndSelectCourses(options) {
       return { success: false, cancelled: true };
     }
     const courseConfigs = courses.map((c) => toCourseConfig(c, environment));
-    M2.success(`Selected ${courseConfigs.length} course${courseConfigs.length === 1 ? "" : "s"}`);
+    const enrichedConfigs = await enrichCoursesWithLaunchUrls(client, courseConfigs);
     return {
       success: true,
       appName,
-      courses: courseConfigs,
+      courses: enrichedConfigs,
       environment
     };
   } catch (error57) {
@@ -103626,35 +103736,6 @@ function isValidUrl(url6) {
     return false;
   }
 }
-function deriveSensorFromLaunchUrl(launchUrl) {
-  try {
-    const url6 = new URL(launchUrl);
-    return url6.origin;
-  } catch {
-    return;
-  }
-}
-async function promptSensor(options) {
-  const { defaultValue } = options ?? {};
-  const input = await he({
-    message: "Sensor URL (your app origin, used for activity tracking)",
-    placeholder: "https://myapp.example.com",
-    defaultValue,
-    validate: (value) => {
-      if (!value.trim()) {
-        return "Sensor URL is required for activity tracking";
-      }
-      if (!isValidUrl(value.trim())) {
-        return "Invalid URL format";
-      }
-      return;
-    }
-  });
-  if (isCancelled(input)) {
-    return;
-  }
-  return input.trim();
-}
 async function promptLaunchUrl() {
   const input = await he({
     message: "Launch URL (where students go when clicking your app in dashboards)",
@@ -104645,30 +104726,43 @@ function run(cmd, args, cwd, silent = false) {
     child.on("error", () => resolvePromise(1));
   });
 }
+function getPrettierBin(cwd) {
+  return resolve3(cwd, "node_modules", ".bin", process.platform === "win32" ? "prettier.cmd" : "prettier");
+}
+function runPrettierUsingRunner(cwd, args) {
+  const { packageManager } = detectPackageManager(cwd);
+  const dlx = getDlxCommand(packageManager, "prettier");
+  return run(dlx.cmd, [...dlx.args, ...args], cwd, true);
+}
 async function formatWithPrettier(options) {
-  const { cwd, filePath, logger, silent = false } = options;
-  const prettierBin = resolve3(cwd, "node_modules", ".bin", process.platform === "win32" ? "prettier.cmd" : "prettier");
+  const { cwd, filePath, silent = false } = options;
+  const prettierBin = getPrettierBin(cwd);
   const args = ["--write", filePath];
-  if (existsSync3(prettierBin)) {
-    if (!silent)
-      logger.info(`Formatting ${filePath} with prettier...`);
-    const code2 = await run(prettierBin, args, cwd, silent);
-    if (code2 === 0)
+  const s = silent ? null : Y2();
+  s?.start("Formatting config file...");
+  try {
+    let code;
+    if (existsSync3(prettierBin)) {
+      code = await run(prettierBin, args, cwd, true);
+    } else {
+      code = await runPrettierUsingRunner(cwd, args);
+    }
+    if (code === 0) {
+      s?.stop("Formatted config file");
       return true;
-    if (!silent)
-      logger.warn(`Prettier failed (exit ${code2}).`);
+    }
+    s?.stop();
+    if (!silent) {
+      M2.warn("Failed to format config file");
+    }
+    return false;
+  } catch {
+    s?.stop();
+    if (!silent) {
+      M2.warn("Failed to format config file");
+    }
     return false;
   }
-  const { packageManager } = detectPackageManager(cwd);
-  const dlx = getDlxCommand(packageManager, "prettier");
-  if (!silent)
-    logger.info(`Formatting ${filePath} with ${dlx.cmd}...`);
-  const code = await run(dlx.cmd, [...dlx.args, ...args], cwd, silent);
-  if (code === 0)
-    return true;
-  if (!silent)
-    logger.warn(`Prettier failed (exit ${code}).`);
-  return false;
 }
 // src/lib/config/generate.ts
 var SCHEMA_URL = "https://timeback.dev/schema.json";
@@ -104826,6 +104920,32 @@ function formatCourse(course) {
   }
   return orderKeys(result, COURSE_KEY_ORDER);
 }
+function normalizeLaunchUrls(config7) {
+  const allCoursesHaveLaunchUrl = config7.courses.every((c) => c.launchUrl !== undefined);
+  if (!allCoursesHaveLaunchUrl) {
+    return config7;
+  }
+  const courseLaunchUrls = config7.courses.map((c) => c.launchUrl);
+  const uniqueUrls = new Set(courseLaunchUrls);
+  if (uniqueUrls.size !== 1) {
+    return config7;
+  }
+  const sharedUrl = courseLaunchUrls[0];
+  if (config7.launchUrl && config7.launchUrl !== sharedUrl) {
+    return config7;
+  }
+  return {
+    ...config7,
+    launchUrl: sharedUrl,
+    courses: config7.courses.map((course) => {
+      if (course.launchUrl === sharedUrl) {
+        const { launchUrl: _3, ...rest } = course;
+        return rest;
+      }
+      return course;
+    })
+  };
+}
 function generateConfigContent(config7) {
   const output2 = {
     $schema: SCHEMA_URL,
@@ -104848,9 +104968,13 @@ function generateConfigContent(config7) {
 }
 // src/lib/config/loader.ts
 import { writeFile as writeFile2 } from "node:fs/promises";
-async function saveConfig(configPath, config7) {
+async function saveConfig(configPath, config7, options = {}) {
+  const { format = false, cwd = process.cwd(), silent = true } = options;
   const content = generateConfigContent(config7);
   await writeFile2(configPath, content, "utf-8");
+  if (format) {
+    await formatWithPrettier({ cwd, filePath: configPath, silent });
+  }
 }
 // src/lib/compare.ts
 function compareValues(local, remote, path, changes, options = {}) {
@@ -104921,32 +105045,84 @@ function logErrors(errors3) {
   }
 }
 
-// src/lib/courses.ts
-async function fetchRemoteCourseData(synced) {
-  if (synced.length === 0)
-    return;
-  const first = synced[0];
-  const s = Y2();
-  s.start("Fetching course data...");
-  const authOk = await initAuth({ env: first.env });
-  if (!authOk) {
-    s.stop("Could not authenticate");
+// src/version.ts
+var cliVersion = "0.1.7";
+
+// src/lib/metadata.ts
+function deepMerge(base, override) {
+  if (!base && !override)
     return;
+  if (!base)
+    return override;
+  if (!override)
+    return base;
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    const baseVal = base[key];
+    const overrideVal = override[key];
+    if (overrideVal !== undefined && typeof overrideVal === "object" && overrideVal !== null && !Array.isArray(overrideVal) && typeof baseVal === "object" && baseVal !== null && !Array.isArray(baseVal)) {
+      result[key] = deepMerge(baseVal, overrideVal);
+    } else if (overrideVal !== undefined) {
+      result[key] = overrideVal;
+    }
   }
-  try {
-    const client = getAuthContext(first.env).timeback;
-    const remote = await client.oneroster.courses.get(first.courseId);
-    s.stop("Course data loaded");
-    return {
-      courseCode: remote.courseCode ?? undefined,
-      level: remote.level ?? undefined,
-      metadata: remote.metadata ?? undefined
-    };
-  } catch {
-    s.stop("Could not fetch course data");
+  return result;
+}
+function buildConfigMetadata(course) {
+  if (!course.metadata)
     return;
-  }
+  const m2 = course.metadata;
+  const metadata = {};
+  if (m2.courseType)
+    metadata.courseType = m2.courseType;
+  if (m2.isSupplemental !== undefined)
+    metadata.isSupplemental = m2.isSupplemental;
+  if (m2.isCustom !== undefined)
+    metadata.isCustom = m2.isCustom;
+  if (m2.publishStatus)
+    metadata.publishStatus = m2.publishStatus;
+  if (m2.contactEmail)
+    metadata.contactEmail = m2.contactEmail;
+  if (m2.primaryApp)
+    metadata.primaryApp = m2.primaryApp;
+  if (m2.goals)
+    metadata.goals = m2.goals;
+  if (m2.metrics)
+    metadata.metrics = m2.metrics;
+  return Object.keys(metadata).length > 0 ? metadata : undefined;
 }
+function buildUpsertMetadata(existing, course) {
+  const base = existing ?? {};
+  const configMetadata = buildConfigMetadata(course);
+  const result = { ...base };
+  if (configMetadata) {
+    if (configMetadata.courseType !== undefined)
+      result.courseType = configMetadata.courseType;
+    if (configMetadata.isSupplemental !== undefined)
+      result.isSupplemental = configMetadata.isSupplemental;
+    if (configMetadata.isCustom !== undefined)
+      result.isCustom = configMetadata.isCustom;
+    if (configMetadata.publishStatus !== undefined)
+      result.publishStatus = configMetadata.publishStatus;
+    if (configMetadata.contactEmail !== undefined)
+      result.contactEmail = configMetadata.contactEmail;
+    if (configMetadata.primaryApp !== undefined)
+      result.primaryApp = configMetadata.primaryApp;
+    if (configMetadata.goals || base.goals) {
+      result.goals = deepMerge(base.goals, configMetadata.goals);
+    }
+    if (configMetadata.metrics || base.metrics) {
+      result.metrics = deepMerge(base.metrics, configMetadata.metrics);
+    }
+  }
+  result.managedBy = `timeback@${cliVersion}`;
+  return result;
+}
+function buildCreateMetadata(course) {
+  return buildUpsertMetadata(undefined, course);
+}
+
+// src/lib/courses.ts
 function mergeMetadata(base, override) {
   if (!base && !override)
     return;
@@ -104983,29 +105159,6 @@ function resolveCourseForEnv(course, defaults, env2) {
     metadata: mergeMetadata(merged.metadata, envOverrides.metadata)
   };
 }
-function buildMetadata(course) {
-  if (!course.metadata)
-    return;
-  const m2 = course.metadata;
-  const metadata = {};
-  if (m2.courseType)
-    metadata.courseType = m2.courseType;
-  if (m2.isSupplemental !== undefined)
-    metadata.isSupplemental = m2.isSupplemental;
-  if (m2.isCustom !== undefined)
-    metadata.isCustom = m2.isCustom;
-  if (m2.publishStatus)
-    metadata.publishStatus = m2.publishStatus;
-  if (m2.contactEmail)
-    metadata.contactEmail = m2.contactEmail;
-  if (m2.primaryApp)
-    metadata.primaryApp = m2.primaryApp;
-  if (m2.goals)
-    metadata.goals = m2.goals;
-  if (m2.metrics)
-    metadata.metrics = m2.metrics;
-  return Object.keys(metadata).length > 0 ? metadata : undefined;
-}
 async function updateCourse(options) {
   const { env: env2, courseId, title, course, defaults } = options;
   const authOk = await initAuth({ env: env2 });
@@ -105020,10 +105173,10 @@ async function updateCourse(options) {
     };
   }
   const resolved = resolveCourseForEnv(course, defaults, env2);
-  const metadata = buildMetadata(resolved);
   try {
     const client = getAuthContext(env2).timeback;
     const existing = await client.oneroster.courses.get(courseId);
+    const metadata = buildUpsertMetadata(existing.metadata, resolved);
     await client.oneroster.courses.update(courseId, {
       title,
       subjects: [resolved.subject],
@@ -105032,7 +105185,7 @@ async function updateCourse(options) {
       org: existing.org,
       courseCode: resolved.courseCode,
       level: resolved.level,
-      metadata: metadata ?? existing.metadata
+      metadata
     });
     return { success: true };
   } catch (error57) {
@@ -105052,37 +105205,41 @@ function deriveCourseStructureIds(courseId) {
     componentResource: `${courseId}-cr`
   };
 }
-async function resourceExists(getter) {
+async function getIfExists(getter) {
   try {
-    await getter();
-    return true;
+    return await getter();
   } catch (error57) {
     if (isApiError2(error57) && error57.statusCode === 404) {
-      return false;
+      return null;
     }
     throw error57;
   }
 }
 async function ensureComponent(client, ids, title) {
   const componentTitle = `${title} - Component`;
-  const exists = await resourceExists(() => client.oneroster.courses.getComponent(ids.component));
-  if (exists) {
-    await client.oneroster.courses.updateComponent(ids.component, {
-      title: componentTitle,
-      status: "active"
-    });
-  } else {
+  const existing = await getIfExists(() => client.oneroster.courses.getComponent(ids.component));
+  if (!existing) {
     await client.oneroster.courses.createComponent({
       sourcedId: ids.component,
       title: componentTitle,
       course: { sourcedId: ids.course },
       status: "active"
     });
+    return;
   }
+  const needsUpdate = existing.title !== componentTitle || existing.status !== "active" || existing.course?.sourcedId !== ids.course;
+  if (!needsUpdate)
+    return;
+  await client.oneroster.courses.updateComponent(ids.component, {
+    ...existing,
+    title: componentTitle,
+    course: { sourcedId: ids.course },
+    status: "active"
+  });
 }
 async function ensureResource(client, ids, title, appName, launchUrl) {
   const resourceTitle = `${title} - Resource`;
-  const exists = await resourceExists(() => client.oneroster.resources.get(ids.resource));
+  const existing = await getIfExists(() => client.oneroster.resources.get(ids.resource));
   const resourceData = {
     title: resourceTitle,
     vendorResourceId: ids.resource,
@@ -105097,24 +105254,23 @@ async function ensureResource(client, ids, title, appName, launchUrl) {
       toolProvider: appName
     }
   };
-  if (exists) {
-    await client.oneroster.resources.update(ids.resource, resourceData);
-  } else {
+  if (!existing) {
     await client.oneroster.resources.create({
       sourcedId: ids.resource,
       ...resourceData
     });
+    return;
   }
+  const existingLaunchUrl = existing.metadata?.launchUrl;
+  const needsUpdate = existing.title !== resourceTitle || String(existingLaunchUrl ?? "") !== launchUrl;
+  if (!needsUpdate)
+    return;
+  await client.oneroster.resources.update(ids.resource, resourceData);
 }
 async function ensureComponentResource(client, ids, title) {
   const crTitle = `${title} - Link`;
-  const exists = await resourceExists(() => client.oneroster.courses.getComponentResource(ids.componentResource));
-  if (exists) {
-    await client.oneroster.courses.updateComponentResource(ids.componentResource, {
-      title: crTitle,
-      status: "active"
-    });
-  } else {
+  const existing = await getIfExists(() => client.oneroster.courses.getComponentResource(ids.componentResource));
+  if (!existing) {
     await client.oneroster.courses.createComponentResource({
       sourcedId: ids.componentResource,
       title: crTitle,
@@ -105122,7 +105278,19 @@ async function ensureComponentResource(client, ids, title) {
       resource: { sourcedId: ids.resource },
       status: "active"
     });
+    return;
   }
+  const needsUpdate = existing.title !== crTitle || existing.status !== "active" || existing.courseComponent?.sourcedId !== ids.component || existing.resource?.sourcedId !== ids.resource;
+  if (!needsUpdate)
+    return;
+  await client.oneroster.courses.updateComponentResource(ids.componentResource, {
+    ...existing,
+    sourcedId: ids.componentResource,
+    title: crTitle,
+    courseComponent: { sourcedId: ids.component },
+    resource: { sourcedId: ids.resource },
+    status: "active"
+  });
 }
 async function ensureCourseStructure(options) {
   const { env: env2, courseId, courseTitle, appName, launchUrl, onProgress } = options;
@@ -105155,43 +105323,6 @@ async function ensureCourseStructure(options) {
     };
   }
 }
-// src/lib/diff.ts
-function formatCourse2(course) {
-  return `${course.subject} - Grade ${course.grade}`;
-}
-function logAdditions(courses) {
-  M2.message("");
-  M2.message(bold("Changes:"));
-  const lines = courses.map((c) => `  ${green("+")} ${formatCourse2(c)}`);
-  M2.message(lines.join(`
-`));
-  M2.message("");
-}
-function logRemovals(courses) {
-  M2.message("");
-  M2.message(bold("Changes:"));
-  const lines = courses.map((c) => `  ${red("-")} ${formatCourse2(c)}`);
-  M2.message(lines.join(`
-`));
-  M2.message("");
-}
-function logEdit(original, edited) {
-  const changes = compareCourseFields(edited, original);
-  if (changes.length === 0) {
-    return;
-  }
-  M2.message(bold("Changes:"));
-  const maxFieldLen = Math.max(...changes.map((c) => c.field.length));
-  const maxOldLen = Math.max(...changes.map((c) => c.remote.length || 7));
-  const lines = changes.map((change) => {
-    const paddedField = change.field.padStart(maxFieldLen);
-    const paddedOld = (change.remote || "(empty)").padStart(maxOldLen);
-    const newVal = change.local || dim("(empty)");
-    return `    ${dim(`${paddedField}:`)} ${red(paddedOld)} ${dim("→")} ${green(newVal)}`;
-  });
-  M2.message(lines.join(`
-`));
-}
 // src/lib/environment/prompts.ts
 async function promptEnvironment() {
   const env2 = await ve({
@@ -105222,8 +105353,12 @@ async function resolveEnvironment(options = {}) {
     return null;
   return { env: selected, promptedUser: true };
 }
+// ../internal/utils/src/shared/format.ts
+function pluralize(count, singular, plural) {
+  return count === 1 ? singular : plural ?? `${singular}s`;
+}
 // src/lib/org/select.ts
-async function selectOrganization(client, email4) {
+async function selectOrganization(client, email4, courseCount) {
   const s = Y2();
   s.start("Fetching your organizations...");
   const user = await client.oneroster.users.first({ where: { email: email4 } });
@@ -105255,7 +105390,7 @@ async function selectOrganization(client, email4) {
   }
   s.stop("Organizations loaded");
   const orgChoice = await ve({
-    message: "Select an organization for the new courses:",
+    message: `Select an organization for the new ${pluralize(courseCount ?? 2, "course")}:`,
     options: Array.from(orgMap.entries()).map(([id, name]) => ({
       value: id,
       label: name
@@ -105297,8 +105432,6 @@ async function searchAndSelectCourses2(options) {
   }
 }
 // src/lib/setup/setup.ts
-import { writeFile as writeFile3 } from "node:fs/promises";
-import { resolve as resolve4 } from "node:path";
 var CONFIG_FILENAME2 = "timeback.config.json";
 async function promptEnvironmentToSetup() {
   const env2 = await ve({
@@ -105327,67 +105460,6 @@ You need to configure your Timeback API credentials first.`, "Credentials Setup"
   Me(`Saved to ${dim(getCredentialsPath())}`, "Persisted credentials to disk");
   return true;
 }
-async function ensureConfig(opts = {}) {
-  const { configPath: customPath, skipIntro = false, format = true } = opts;
-  if (!skipIntro) {
-    intro("Timeback");
-  }
-  const cwd = process.cwd();
-  const configPath = customPath ? resolve4(cwd, customPath) : resolve4(cwd, CONFIG_FILENAME2);
-  const configResult = await loadConfig({ configPath: customPath });
-  if (configResult.success) {
-    M2.info(`Found ${dim(CONFIG_FILENAME2)}`);
-    return {
-      success: true,
-      config: configResult.config,
-      configPath: configResult.configPath
-    };
-  }
-  Me(`No ${greenBright(CONFIG_FILENAME2)} found in this directory.
-Let's set up your Timeback project.`, "First-time setup");
-  let configuredEnvs = await getConfiguredEnvironments();
-  if (configuredEnvs.length === 0) {
-    const ok = await setupCredentials();
-    if (!ok) {
-      return { success: false, cancelled: true };
-    }
-    configuredEnvs = await getConfiguredEnvironments();
-    if (configuredEnvs.length === 0) {
-      return { success: false, error: "Failed to configure credentials" };
-    }
-  }
-  const searchResult = await searchAndSelectCourses2({ configuredEnvs });
-  if (!searchResult.success) {
-    return {
-      success: false,
-      cancelled: searchResult.cancelled,
-      error: searchResult.error
-    };
-  }
-  const sensor = await promptSensor();
-  if (sensor === undefined) {
-    return { success: false, cancelled: true };
-  }
-  const config7 = {
-    name: searchResult.appName,
-    sensor,
-    courses: searchResult.courses
-  };
-  const content = generateConfigContent(config7);
-  await writeFile3(configPath, content, "utf-8");
-  M2.success(`Created ${dim(CONFIG_FILENAME2)}`);
-  if (format) {
-    await formatWithPrettier({ cwd, filePath: configPath, logger: M2 });
-  }
-  if (!skipIntro) {
-    outro.success();
-  }
-  return {
-    success: true,
-    config: config7,
-    configPath
-  };
-}
 async function runImportFlow(opts = {}) {
   const { format = true } = opts;
   let configuredEnvs = await getConfiguredEnvironments();
@@ -105434,15 +105506,14 @@ async function runImportFlow(opts = {}) {
       config7.courses.push(course);
     }
   }
-  const content = generateConfigContent(config7);
-  await writeFile3(configPath, content, "utf-8");
-  M2.success(`Updated ${dim(CONFIG_FILENAME2)}`);
-  if (format) {
-    await formatWithPrettier({ cwd: process.cwd(), filePath: configPath, logger: M2 });
-  }
+  const s = Y2();
+  s.start(`Updating ${dim(CONFIG_FILENAME2)}...`);
+  const normalizedConfig = normalizeLaunchUrls(config7);
+  await saveConfig(configPath, normalizedConfig, { format });
+  s.stop(`Updated ${dim(CONFIG_FILENAME2)}`);
   return {
     success: true,
-    config: config7,
+    config: normalizedConfig,
     configPath
   };
 }
@@ -108681,115 +108752,11 @@ function registerCredentialsCommand(program2) {
   creds.action(() => showCredentialsMenu());
 }
 
-// src/commands/sync/lib/courses.ts
-async function applyDiff(options) {
-  const { config: config7, diff, createEnv, createOrgId, onProgress } = options;
-  const result = {
-    created: 0,
-    updated: 0,
-    skipped: diff.unchanged.length,
-    errors: [...diff.errors]
-  };
-  const updatedConfig = { ...config7, courses: [...config7.courses] };
-  for (const create of diff.creates) {
-    if (!createEnv || !createOrgId) {
-      result.errors.push({
-        title: create.title,
-        header: "Environment and organization required for new courses",
-        details: []
-      });
-      continue;
-    }
-    const authOk = await initAuth({ env: createEnv });
-    if (!authOk) {
-      result.errors.push({
-        title: create.title,
-        header: `Failed to authenticate for ${createEnv}`,
-        details: []
-      });
-      continue;
-    }
-    onProgress?.(`Creating ${create.title} on ${createEnv}...`);
-    const resolved = resolveCourseForEnv(create.local, config7.defaults, createEnv);
-    const metadata = buildMetadata(resolved);
-    try {
-      const client = getAuthContext(createEnv).timeback;
-      const response = await client.oneroster.courses.create({
-        title: create.title,
-        subjects: [resolved.subject],
-        ...resolved.grade === undefined ? {} : { grades: [resolved.grade] },
-        org: { sourcedId: createOrgId },
-        status: "active",
-        courseCode: resolved.courseCode,
-        level: resolved.level,
-        metadata
-      });
-      const allocatedCourseId = response.sourcedIdPairs.allocatedSourcedId;
-      updatedConfig.courses[create.index] = {
-        ...create.local,
-        ids: {
-          ...create.local.ids,
-          [createEnv]: allocatedCourseId
-        }
-      };
-      result.created++;
-      const effectiveLaunchUrl = resolved.launchUrl ?? config7.launchUrl;
-      if (effectiveLaunchUrl) {
-        onProgress?.(`Ensuring course structure for ${create.title}...`);
-        const structureResult = await ensureCourseStructure({
-          env: createEnv,
-          courseId: allocatedCourseId,
-          courseTitle: create.title,
-          appName: config7.name,
-          launchUrl: effectiveLaunchUrl,
-          onProgress
-        });
-        if (!structureResult.success && structureResult.error) {
-          result.errors.push(structureResult.error);
-        }
-      }
-    } catch (error57) {
-      const formatted = formatApiError(error57);
-      result.errors.push({ title: create.title, ...formatted });
-    }
-  }
-  for (const update of diff.updates) {
-    for (const { env: env2, courseId } of update.environments) {
-      onProgress?.(`Updating ${update.localTitle} on ${env2}...`);
-      const updateResult = await updateCourse({
-        env: env2,
-        courseId,
-        title: update.localTitle,
-        course: update.local,
-        defaults: config7.defaults
-      });
-      if (!updateResult.success && updateResult.error) {
-        result.errors.push(updateResult.error);
-        continue;
-      }
-      const resolved = resolveCourseForEnv(update.local, config7.defaults, env2);
-      const effectiveLaunchUrl = resolved.launchUrl ?? config7.launchUrl;
-      if (effectiveLaunchUrl) {
-        onProgress?.(`Ensuring course structure for ${update.localTitle}...`);
-        const structureResult = await ensureCourseStructure({
-          env: env2,
-          courseId,
-          courseTitle: update.localTitle,
-          appName: config7.name,
-          launchUrl: effectiveLaunchUrl,
-          onProgress
-        });
-        if (!structureResult.success && structureResult.error) {
-          result.errors.push(structureResult.error);
-        }
-      }
-    }
-    result.updated++;
-  }
-  return { result, updatedConfig };
-}
+// src/commands/init/init.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { basename as basename2, resolve as resolve4 } from "node:path";
 
-// src/commands/sync/lib/utils.ts
+// src/commands/resources/push/lib/utils.ts
 function getGradeLabel(grade) {
   if (grade === -1)
     return "Pre-K";
@@ -108799,996 +108766,20 @@ function getGradeLabel(grade) {
     return "AP";
   return `Grade ${grade}`;
 }
-function getCourseTitle(appName, course) {
+function getCourseTitle(appName, course, options = {}) {
   if (course.grade !== undefined) {
     return `${appName} - ${getGradeLabel(course.grade)}`;
   }
-  if (course.courseCode) {
-    return `${appName} - ${course.courseCode}`;
-  }
-  return `${appName} - ${course.subject}`;
-}
-
-// src/commands/init/lib/constants.ts
-var SUBJECTS = [
-  "Math",
-  "FastMath",
-  "Reading",
-  "Language",
-  "Vocabulary",
-  "Writing",
-  "Science",
-  "Social Studies"
-];
-var GRADES = [
-  { value: -1, label: "Pre-K" },
-  { value: 0, label: "Kindergarten" },
-  { value: 1, label: "Grade 1" },
-  { value: 2, label: "Grade 2" },
-  { value: 3, label: "Grade 3" },
-  { value: 4, label: "Grade 4" },
-  { value: 5, label: "Grade 5" },
-  { value: 6, label: "Grade 6" },
-  { value: 7, label: "Grade 7" },
-  { value: 8, label: "Grade 8" },
-  { value: 9, label: "Grade 9" },
-  { value: 10, label: "Grade 10" },
-  { value: 11, label: "Grade 11" },
-  { value: 12, label: "Grade 12" },
-  { value: 13, label: "AP" }
-];
-
-// src/commands/edit/lib/properties.ts
-var EDITABLE_PROPERTIES = [
-  { key: "subject", label: "Subject", type: "select-subject", path: ["subject"] },
-  { key: "grade", label: "Grade", type: "select-grade", path: ["grade"] },
-  { key: "courseCode", label: "Course Code", type: "text", path: ["courseCode"] },
-  { key: "level", label: "Level", type: "text", path: ["level"] },
-  {
-    key: "courseType",
-    label: "Course Type",
-    type: "select-enum",
-    path: ["metadata", "courseType"],
-    options: CourseType6.options.map((v2) => ({ value: v2, label: v2 }))
-  },
-  {
-    key: "publishStatus",
-    label: "Publish Status",
-    type: "select-enum",
-    path: ["metadata", "publishStatus"],
-    options: PublishStatus6.options.map((v2) => ({ value: v2, label: v2 }))
-  },
-  {
-    key: "isSupplemental",
-    label: "Supplemental?",
-    type: "boolean",
-    path: ["metadata", "isSupplemental"]
-  },
-  { key: "isCustom", label: "Custom?", type: "boolean", path: ["metadata", "isCustom"] },
-  {
-    key: "contactEmail",
-    label: "Contact Email",
-    type: "text",
-    path: ["metadata", "contactEmail"],
-    validate: (v2) => {
-      if (v2 === "")
-        return;
-      const result = CourseMetadata6.shape.contactEmail.safeParse(v2);
-      if (!result.success)
-        return "Must be a valid email address";
-    }
-  },
-  { key: "primaryApp", label: "Primary App", type: "text", path: ["metadata", "primaryApp"] },
-  {
-    key: "dailyXp",
-    label: "Daily XP Goal",
-    type: "number",
-    path: ["metadata", "goals", "dailyXp"],
-    validate: (v2) => {
-      const result = CourseGoals6.shape.dailyXp.safeParse(Number(v2));
-      if (!result.success)
-        return result.error.issues[0]?.message;
-    }
-  },
-  {
-    key: "dailyLessons",
-    label: "Daily Lessons Goal",
-    type: "number",
-    path: ["metadata", "goals", "dailyLessons"],
-    validate: (v2) => {
-      const result = CourseGoals6.shape.dailyLessons.safeParse(Number(v2));
-      if (!result.success)
-        return result.error.issues[0]?.message;
-    }
-  },
-  {
-    key: "dailyActiveMinutes",
-    label: "Daily Active Minutes Goal",
-    type: "number",
-    path: ["metadata", "goals", "dailyActiveMinutes"],
-    validate: (v2) => {
-      const result = CourseGoals6.shape.dailyActiveMinutes.safeParse(Number(v2));
-      if (!result.success)
-        return result.error.issues[0]?.message;
-    }
-  },
-  {
-    key: "dailyAccuracy",
-    label: "Daily Accuracy Goal (%)",
-    type: "number",
-    path: ["metadata", "goals", "dailyAccuracy"],
-    validate: (v2) => {
-      const result = CourseGoals6.shape.dailyAccuracy.safeParse(Number(v2));
-      if (!result.success)
-        return result.error.issues[0]?.message;
-    }
-  },
-  {
-    key: "dailyMasteredUnits",
-    label: "Daily Mastered Units Goal",
-    type: "number",
-    path: ["metadata", "goals", "dailyMasteredUnits"],
-    validate: (v2) => {
-      const result = CourseGoals6.shape.dailyMasteredUnits.safeParse(Number(v2));
-      if (!result.success)
-        return result.error.issues[0]?.message;
-    }
-  },
-  {
-    key: "totalXp",
-    label: "Total XP",
-    type: "number",
-    path: ["metadata", "metrics", "totalXp"],
-    validate: (v2) => {
-      const result = CourseMetrics6.shape.totalXp.safeParse(Number(v2));
-      if (!result.success)
-        return result.error.issues[0]?.message;
-    }
-  },
-  {
-    key: "totalLessons",
-    label: "Total Lessons",
-    type: "number",
-    path: ["metadata", "metrics", "totalLessons"],
-    validate: (v2) => {
-      const result = CourseMetrics6.shape.totalLessons.safeParse(Number(v2));
-      if (!result.success)
-        return result.error.issues[0]?.message;
-    }
-  },
-  {
-    key: "totalGrades",
-    label: "Total Grades",
-    type: "number",
-    path: ["metadata", "metrics", "totalGrades"],
-    validate: (v2) => {
-      const result = CourseMetrics6.shape.totalGrades.safeParse(Number(v2));
-      if (!result.success)
-        return result.error.issues[0]?.message;
-    }
-  }
-];
-
-// src/commands/edit/lib/prompts.ts
-function getNestedValue(obj, path) {
-  let current = obj;
-  for (const key of path) {
-    if (current === null || current === undefined || typeof current !== "object") {
-      return;
-    }
-    current = current[key];
-  }
-  return current;
-}
-function setNestedValue(obj, path, value) {
-  let current = obj;
-  for (let i = 0;i < path.length - 1; i++) {
-    const key = path[i];
-    const val = current[key];
-    if (val === null || val === undefined || typeof val !== "object") {
-      current[key] = {};
-    }
-    current = current[key];
-  }
-  const lastKey = path.at(-1);
-  if (lastKey)
-    current[lastKey] = value;
-}
-function formatCurrentValue(value) {
-  if (value === null || value === undefined)
-    return dim("(not set)");
-  if (typeof value === "boolean")
-    return value ? "yes" : "no";
-  return String(value);
-}
-async function promptAction(courseCount) {
-  const hasCourses = courseCount > 0;
-  const action = await ve({
-    message: "What would you like to do?",
-    options: [
-      { value: "add", label: "Add course(s)" },
-      ...hasCourses ? [
-        { value: "edit", label: "Edit course(s)" },
-        { value: "remove", label: "Remove course(s)" }
-      ] : [],
-      { value: "done", label: "Done" }
-    ]
-  });
-  if (isCancelled(action))
-    return null;
-  return action;
-}
-async function promptSelectCourse(courses, message) {
-  const choice = await ve({
-    message,
-    options: courses.map((c, i) => ({
-      value: i,
-      label: `${c.subject} - Grade ${c.grade}`
-    }))
-  });
-  if (isCancelled(choice))
-    return null;
-  return choice;
-}
-async function promptAddCourses(existingCourses) {
-  const subjects = await fe({
-    message: "Select subjects",
-    options: SUBJECTS.map((s) => ({ value: s, label: s }))
-  });
-  if (isCancelled(subjects))
-    return null;
-  if (subjects.length === 0) {
-    M2.error("At least one subject is required");
-    return null;
-  }
-  const grades = await fe({
-    message: "Select grade levels",
-    options: GRADES
-  });
-  if (isCancelled(grades))
-    return null;
-  if (grades.length === 0) {
-    M2.error("At least one grade is required");
-    return null;
-  }
-  const newCourses = [];
-  let skipped = 0;
-  for (const subject of subjects) {
-    for (const grade of grades) {
-      const exists = existingCourses.some((c) => c.subject === subject && c.grade === grade);
-      if (exists) {
-        skipped++;
-        continue;
-      }
-      newCourses.push({
-        subject,
-        grade,
-        ids: null
-      });
-    }
-  }
-  if (skipped > 0) {
-    M2.warn(`Skipped ${skipped} duplicate course${skipped === 1 ? "" : "s"}`);
-  }
-  return newCourses;
-}
-var ADD_NEW_PROPERTIES_KEY = "__add_new__";
-async function promptEditCourse(course, allCourses, editIndex, remoteData) {
-  const configuredProps = EDITABLE_PROPERTIES.filter((prop) => {
-    const value = getNestedValue(course, prop.path);
-    return value !== null && value !== undefined;
-  });
-  const unconfiguredProps = EDITABLE_PROPERTIES.filter((prop) => {
-    const value = getNestedValue(course, prop.path);
-    return value === null || value === undefined;
-  });
-  const options = [
-    ...configuredProps.map((prop) => {
-      const currentValue = getNestedValue(course, prop.path);
-      return {
-        value: prop.key,
-        label: `${prop.label} ${dim(`(${formatCurrentValue(currentValue)})`)}`
-      };
-    }),
-    ...unconfiguredProps.length > 0 ? [{ value: ADD_NEW_PROPERTIES_KEY, label: dim("+ Add new properties") }] : []
-  ];
-  if (options.length === 0) {
-    M2.warn("No editable properties available");
-    return null;
-  }
-  const selectedKeys = await fe({
-    message: "Select properties to edit",
-    options
-  });
-  if (isCancelled(selectedKeys))
-    return null;
-  const keys = selectedKeys;
-  if (keys.length === 0) {
-    M2.warn("No properties selected");
-    return null;
-  }
-  const updated = structuredClone(course);
-  let hasChanges = false;
-  const wantsNewProps = keys.includes(ADD_NEW_PROPERTIES_KEY);
-  const propsToEdit = keys.filter((k3) => k3 !== ADD_NEW_PROPERTIES_KEY);
-  for (const key of propsToEdit) {
-    const prop = configuredProps.find((p2) => p2.key === key);
-    const currentValue = getNestedValue(course, prop.path);
-    const newValue = await promptForProperty(prop, currentValue);
-    if (newValue === null)
-      return null;
-    if (newValue !== currentValue) {
-      setNestedValue(updated, prop.path, newValue);
-      hasChanges = true;
-    }
-  }
-  if (wantsNewProps) {
-    const newPropKeys = await fe({
-      message: "Select properties to add",
-      options: unconfiguredProps.map((prop) => {
-        const remoteValue = remoteData ? getNestedValue(remoteData, prop.path) : undefined;
-        const hint = remoteValue !== null && remoteValue !== undefined ? dim(` (current: ${formatCurrentValue(remoteValue)})`) : "";
-        return {
-          value: prop.key,
-          label: `${prop.label}${hint}`
-        };
-      })
-    });
-    if (isCancelled(newPropKeys))
-      return null;
-    for (const key of newPropKeys) {
-      const prop = unconfiguredProps.find((p2) => p2.key === key);
-      const remoteValue = remoteData ? getNestedValue(remoteData, prop.path) : undefined;
-      const newValue = await promptForProperty(prop, remoteValue);
-      if (newValue === null)
-        return null;
-      if (newValue !== undefined) {
-        setNestedValue(updated, prop.path, newValue);
-        hasChanges = true;
-      }
-    }
-  }
-  const updatedCourse = updated;
-  const isDuplicate = allCourses.some((c, i) => i !== editIndex && c.subject === updatedCourse.subject && c.grade === updatedCourse.grade);
-  if (isDuplicate) {
-    M2.error(`A course for ${updatedCourse.subject} - Grade ${updatedCourse.grade} already exists`);
-    return null;
-  }
-  if (!hasChanges) {
-    M2.warn("No changes made");
-    return null;
-  }
-  return updatedCourse;
-}
-async function promptForProperty(prop, currentValue) {
-  switch (prop.type) {
-    case "select-subject": {
-      const value = await ve({
-        message: prop.label,
-        options: SUBJECTS.map((s) => ({ value: s, label: s })),
-        initialValue: currentValue
-      });
-      if (isCancelled(value))
-        return null;
-      return value;
+  if (options.disambiguate) {
+    const suffix = course.courseCode ?? course.subject;
+    if (suffix) {
+      return `${appName} - ${suffix}`;
     }
-    case "select-grade": {
-      const value = await ve({
-        message: prop.label,
-        options: GRADES,
-        initialValue: currentValue
-      });
-      if (isCancelled(value))
-        return null;
-      return value;
-    }
-    case "select-enum": {
-      const options = [{ value: "", label: dim("(clear)") }, ...prop.options];
-      const value = await ve({
-        message: prop.label,
-        options,
-        initialValue: currentValue ?? ""
-      });
-      if (isCancelled(value))
-        return null;
-      return value === "" ? undefined : value;
-    }
-    case "text": {
-      const initial = currentValue ?? "";
-      const value = await he({
-        message: prop.label,
-        initialValue: initial,
-        placeholder: initial ? undefined : "(leave empty to clear)",
-        validate: prop.validate
-      });
-      if (isCancelled(value))
-        return null;
-      return value === "" ? undefined : value;
-    }
-    case "number": {
-      const initial = currentValue !== null && currentValue !== undefined ? String(currentValue) : "";
-      const value = await he({
-        message: prop.label,
-        initialValue: initial,
-        placeholder: initial ? undefined : "(leave empty to clear)",
-        validate: (v2) => {
-          if (v2 === "")
-            return;
-          if (!/^\d+$/.test(v2))
-            return "Must be a positive integer";
-          return prop.validate?.(v2);
-        }
-      });
-      if (isCancelled(value))
-        return null;
-      return value === "" ? undefined : Number(value);
-    }
-    case "boolean": {
-      const value = await ye({
-        message: prop.label,
-        initialValue: currentValue ?? false
-      });
-      if (isCancelled(value))
-        return null;
-      return value;
-    }
-    default:
-      return currentValue;
   }
-}
-async function promptRemoveCourses(courses) {
-  const indices = await fe({
-    message: "Select courses to remove",
-    options: courses.map((c, i) => ({
-      value: i,
-      label: `${c.subject} - Grade ${c.grade}`
-    }))
-  });
-  if (isCancelled(indices))
-    return null;
-  return indices;
+  return appName;
 }
 
-// src/commands/edit/lib/handlers.ts
-async function handleAdd(ctx) {
-  const newCourses = await promptAddCourses(ctx.config.courses);
-  if (newCourses === null)
-    return "cancelled";
-  if (newCourses.length === 0)
-    return "discarded";
-  logAdditions(newCourses);
-  const confirmed = await ye({ message: "Sync with Timeback?" });
-  if (isCancelled(confirmed))
-    return "cancelled";
-  if (!confirmed) {
-    M2.info("Changes discarded");
-    return "discarded";
-  }
-  const envResult = await resolveEnvironment({ skipIntro: true });
-  if (!envResult)
-    return "cancelled";
-  const authSuccess = await initAuth({ env: envResult.env });
-  if (!authSuccess) {
-    M2.error("Failed to authenticate");
-    return "discarded";
-  }
-  const authCtx = getAuthContext();
-  if (!authCtx.credentials.email) {
-    M2.error("Email not configured.");
-    M2.info("Run `timeback credentials email` to configure your email.");
-    return "discarded";
-  }
-  const orgResult = await selectOrganization(authCtx.timeback, authCtx.credentials.email);
-  if (!orgResult.success) {
-    if (orgResult.cancelled)
-      return "cancelled";
-    M2.error(orgResult.error ?? "Failed to select organization");
-    return "discarded";
-  }
-  const baseIndex = ctx.config.courses.length;
-  ctx.config.courses.push(...newCourses);
-  const diff = {
-    creates: newCourses.map((course, i) => ({
-      type: "create",
-      index: baseIndex + i,
-      local: course,
-      title: getCourseTitle(ctx.config.name, course)
-    })),
-    updates: [],
-    unchanged: [],
-    errors: []
-  };
-  const s = Y2();
-  s.start("Syncing with Timeback...");
-  const { result, updatedConfig } = await applyDiff({
-    config: ctx.config,
-    diff,
-    createEnv: envResult.env,
-    createOrgId: orgResult.orgId,
-    onProgress: (msg) => s.message(msg)
-  });
-  s.stop("Sync complete");
-  ctx.config.courses = updatedConfig.courses;
-  await saveConfig(ctx.configPath, ctx.config);
-  M2.success(`Saved ${dim(ctx.relativeConfigPath)}`);
-  if (result.created > 0) {
-    M2.success(`Created ${bold(result.created)} course${result.created === 1 ? "" : "s"} on Timeback`);
-  }
-  logErrors(result.errors);
-  return "synced";
-}
-async function handleEdit(ctx) {
-  const index = await promptSelectCourse(ctx.config.courses, "Select a course to edit");
-  if (index === null)
-    return "cancelled";
-  const original = ctx.config.courses[index];
-  const synced = getSyncedCourses(original);
-  const remoteData = await fetchRemoteCourseData(synced);
-  const edited = await promptEditCourse(original, ctx.config.courses, index, remoteData);
-  if (edited === null)
-    return "discarded";
-  logEdit(original, edited);
-  const confirmed = await ye({ message: "Sync with Timeback?" });
-  if (isCancelled(confirmed))
-    return "cancelled";
-  if (!confirmed) {
-    M2.info("Changes discarded");
-    return "discarded";
-  }
-  const s = Y2();
-  if (synced.length > 0) {
-    edited.ids = { ...original.ids };
-    const title = getCourseTitle(ctx.config.name, edited);
-    for (const { env: env2, courseId } of synced) {
-      s.start(`Updating on ${env2}...`);
-      const result = await updateCourse({
-        env: env2,
-        courseId,
-        title,
-        course: edited,
-        defaults: ctx.config.defaults
-      });
-      if (!result.success) {
-        s.stop(`Update failed on ${env2}`);
-        if (result.error) {
-          logErrors([result.error]);
-        }
-        return "discarded";
-      }
-    }
-    s.stop(`Updated on ${synced.map((s2) => s2.env).join(" and ")}`);
-  } else {
-    const envResult = await resolveEnvironment({ skipIntro: true });
-    if (!envResult)
-      return "cancelled";
-    const authSuccess = await initAuth({ env: envResult.env });
-    if (!authSuccess) {
-      M2.error("Failed to authenticate");
-      return "discarded";
-    }
-    const authCtx = getAuthContext();
-    if (!authCtx.credentials.email) {
-      M2.error("Email not configured.");
-      M2.info("Run `timeback credentials email` to configure your email.");
-      return "discarded";
-    }
-    const orgResult = await selectOrganization(authCtx.timeback, authCtx.credentials.email);
-    if (!orgResult.success) {
-      if (orgResult.cancelled)
-        return "cancelled";
-      M2.error(orgResult.error ?? "Failed to select organization");
-      return "discarded";
-    }
-    ctx.config.courses[index] = edited;
-    const diff = {
-      creates: [
-        {
-          type: "create",
-          index,
-          local: edited,
-          title: getCourseTitle(ctx.config.name, edited)
-        }
-      ],
-      updates: [],
-      unchanged: [],
-      errors: []
-    };
-    s.start("Creating course on Timeback...");
-    const { result, updatedConfig } = await applyDiff({
-      config: ctx.config,
-      diff,
-      createEnv: envResult.env,
-      createOrgId: orgResult.orgId,
-      onProgress: (msg) => s.message(msg)
-    });
-    s.stop("Sync complete");
-    ctx.config.courses = updatedConfig.courses;
-    if (result.created > 0) {
-      M2.success("Created course on Timeback");
-    }
-    logErrors(result.errors);
-    await saveConfig(ctx.configPath, ctx.config);
-    M2.success(`Saved ${dim(ctx.relativeConfigPath)}`);
-    return "synced";
-  }
-  ctx.config.courses[index] = edited;
-  await saveConfig(ctx.configPath, ctx.config);
-  M2.success(`Saved ${dim(ctx.relativeConfigPath)}`);
-  return "synced";
-}
-async function handleRemove(ctx) {
-  const indices = await promptRemoveCourses(ctx.config.courses);
-  if (indices === null)
-    return "cancelled";
-  if (indices.length === 0)
-    return "discarded";
-  const coursesToRemove = indices.map((i) => ctx.config.courses[i]);
-  logRemovals(coursesToRemove);
-  const confirmed = await ye({
-    message: "Remove from config? (Timeback courses are unaffected)"
-  });
-  if (isCancelled(confirmed))
-    return "cancelled";
-  if (!confirmed) {
-    M2.info("Changes discarded");
-    return "discarded";
-  }
-  const sortedIndices = indices.toSorted((a, b3) => b3 - a);
-  for (const i of sortedIndices) {
-    ctx.config.courses.splice(i, 1);
-  }
-  await saveConfig(ctx.configPath, ctx.config);
-  M2.success(`Saved ${dim(ctx.relativeConfigPath)}`);
-  return "saved";
-}
-// src/commands/edit/edit.ts
-async function editConfig(options = {}) {
-  const { configPath: customConfigPath, exitOnComplete = true } = options;
-  intro("Timeback Edit");
-  const configResult = await loadConfig({ configPath: customConfigPath });
-  if (!configResult.success) {
-    M2.error(configResult.error);
-    outro.error("Edit failed");
-    if (exitOnComplete)
-      process.exit(1);
-    return;
-  }
-  const { configPath } = configResult;
-  const relativeConfigPath = getRelativeConfigPath(configPath);
-  const config7 = {
-    ...configResult.config,
-    courses: [...configResult.config.courses]
-  };
-  M2.info(`Editing ${dim(relativeConfigPath)}`);
-  M2.info(`${bold(config7.courses.length)} course${config7.courses.length === 1 ? "" : "s"} defined`);
-  const ctx = { config: config7, configPath, relativeConfigPath };
-  let hasChanges = false;
-  while (true) {
-    const action = await promptAction(config7.courses.length);
-    if (action === null) {
-      outro.cancelled();
-      if (exitOnComplete)
-        process.exit(0);
-      return;
-    }
-    if (action === "done")
-      break;
-    let result;
-    if (action === "add")
-      result = await handleAdd(ctx);
-    else if (action === "edit")
-      result = await handleEdit(ctx);
-    else
-      result = await handleRemove(ctx);
-    if (result === "cancelled") {
-      outro.cancelled();
-      if (exitOnComplete)
-        process.exit(0);
-      return;
-    }
-    if (result === "synced" || result === "saved")
-      hasChanges = true;
-  }
-  if (!hasChanges) {
-    M2.info("No changes made");
-  }
-  outro.success();
-  if (exitOnComplete)
-    process.exit(0);
-}
-
-// src/commands/edit/index.ts
-function registerEditCommand(program2) {
-  program2.command("edit").description("Add, edit, or remove courses in local config").option("-c, --config <path>", "Path to the config file").action((opts) => editConfig({ configPath: opts.config }));
-}
-
-// src/commands/import/lib/fetch.ts
-async function fetchRemoteCourse(options) {
-  const { courseId, env: env2 } = options;
-  try {
-    const client = getAuthContext(env2).timeback;
-    const remoteCourse = await client.oneroster.courses.get(courseId);
-    const course = {
-      subject: remoteCourse.subjects?.[0] ?? "None",
-      grade: remoteCourse.grades?.[0] ?? 0,
-      ids: {
-        [env2]: courseId
-      }
-    };
-    if (remoteCourse.courseCode) {
-      course.courseCode = remoteCourse.courseCode;
-    }
-    if (remoteCourse.level) {
-      course.level = remoteCourse.level;
-    }
-    if (remoteCourse.metadata) {
-      course.metadata = {
-        courseType: remoteCourse.metadata.courseType,
-        isSupplemental: remoteCourse.metadata.isSupplemental,
-        isCustom: remoteCourse.metadata.isCustom,
-        publishStatus: remoteCourse.metadata.publishStatus,
-        contactEmail: remoteCourse.metadata.contactEmail,
-        primaryApp: remoteCourse.metadata.primaryApp,
-        goals: remoteCourse.metadata.goals,
-        metrics: remoteCourse.metadata.metrics
-      };
-      course.metadata = Object.fromEntries(Object.entries(course.metadata).filter(([, v2]) => v2 !== undefined));
-      if (Object.keys(course.metadata).length === 0) {
-        delete course.metadata;
-      }
-    }
-    return { success: true, course };
-  } catch (error57) {
-    const formatted = formatApiError(error57);
-    return {
-      success: false,
-      error: `${formatted.header}${formatted.details.length > 0 ? `: ${formatted.details.join(", ")}` : ""}`
-    };
-  }
-}
-function findExistingCourse(config7, courseId, env2) {
-  const index = config7.courses.findIndex((c) => c.ids?.[env2] === courseId);
-  if (index === -1)
-    return;
-  if (!config7.courses[index])
-    return;
-  return {
-    index,
-    course: config7.courses[index]
-  };
-}
-// src/commands/import/import.ts
-function getExistingCourseIds(config7) {
-  const byEnv = {};
-  for (const course of config7.courses) {
-    for (const [env2, id] of Object.entries(course.ids ?? {})) {
-      if (!byEnv[env2])
-        byEnv[env2] = [];
-      if (id)
-        byEnv[env2].push(id);
-    }
-  }
-  return byEnv;
-}
-function formatCourseLabel2(course) {
-  if (course.grade !== undefined) {
-    return `${course.subject} Grade ${course.grade}`;
-  }
-  if (course.courseCode) {
-    return `${course.subject} (${course.courseCode})`;
-  }
-  return course.subject;
-}
-function formatExistingCourses(config7) {
-  if (config7.courses.length === 0) {
-    return dim("No courses configured yet.");
-  }
-  const byEnv = {};
-  for (const course of config7.courses) {
-    const label = formatCourseLabel2(course);
-    const envs = Object.keys(course.ids ?? {});
-    for (const env2 of envs) {
-      if (!byEnv[env2])
-        byEnv[env2] = [];
-      byEnv[env2].push(label);
-    }
-  }
-  const envOrder = ["staging", "production"];
-  const sortedEnvs = Object.keys(byEnv).sort((a, b3) => envOrder.indexOf(a) - envOrder.indexOf(b3));
-  return sortedEnvs.map((env2) => {
-    const courses = byEnv[env2] ?? [];
-    const header = bold(env2);
-    const list = courses.map((c, i) => `  ${dim(`${i + 1}.`)} ${c}`).join(`
-`);
-    return `${header}
-${list}`;
-  }).join(`
-
-`);
-}
-async function importByCourseId(options) {
-  const {
-    courseId,
-    configPath: customConfigPath,
-    env: envOption,
-    exitOnComplete = true
-  } = options;
-  intro("Timeback Import");
-  const configResult = await loadConfig({ configPath: customConfigPath });
-  if (!configResult.success) {
-    M2.error(configResult.error);
-    outro.error("Import failed");
-    if (exitOnComplete)
-      process.exit(1);
-    return;
-  }
-  const { config: config7, configPath } = configResult;
-  const relativeConfigPath = getRelativeConfigPath(configPath);
-  M2.info(`Loaded ${dim(relativeConfigPath)}`);
-  const envResult = await resolveEnvironment({
-    env: envOption,
-    skipIntro: true
-  });
-  if (!envResult) {
-    outro.cancelled();
-    if (exitOnComplete)
-      process.exit(0);
-    return;
-  }
-  const { env: env2 } = envResult;
-  const authOk = await initAuth({ env: env2 });
-  if (!authOk) {
-    outro.error("Import failed");
-    if (exitOnComplete)
-      process.exit(1);
-    return;
-  }
-  const s = Y2();
-  s.start(`Fetching course ${dim(courseId)} from ${bold(env2)}...`);
-  const fetchResult = await fetchRemoteCourse({ courseId, env: env2 });
-  if (!fetchResult.success || !fetchResult.course) {
-    s.stop("Fetch failed");
-    M2.error(fetchResult.error ?? "Unknown error fetching course");
-    outro.error("Import failed");
-    if (exitOnComplete) {
-      process.exit(1);
-    }
-    return;
-  }
-  s.stop("Course fetched");
-  const remoteCourse = fetchResult.course;
-  const existing = findExistingCourse(config7, courseId, env2);
-  if (existing) {
-    M2.warn(`Course ${blueBright(courseId)} already exists in config at index ${existing.index}`);
-    const shouldSync = await ye({
-      message: "Sync (update) the existing entry with remote data?",
-      initialValue: false
-    });
-    if (isCancelled(shouldSync) || !shouldSync) {
-      outro.cancelled();
-      if (exitOnComplete) {
-        process.exit(0);
-      }
-      return;
-    }
-    config7.courses[existing.index] = {
-      ...existing.course,
-      ...remoteCourse,
-      ids: {
-        ...existing.course.ids,
-        ...remoteCourse.ids
-      }
-    };
-    await saveConfig(configPath, config7);
-    M2.success(`Updated course at index ${existing.index}`);
-  } else {
-    config7.courses.push(remoteCourse);
-    await saveConfig(configPath, config7);
-    M2.success(`Added ${bold(formatCourseLabel2(remoteCourse))} to config`);
-  }
-  M2.success(`Saved ${dim(relativeConfigPath)}`);
-  outro.success();
-  if (exitOnComplete) {
-    process.exit(0);
-  }
-}
-async function importInteractive(options) {
-  const { configPath, exitOnComplete = true, format = true } = options;
-  intro("Timeback Import");
-  const existingConfig = await loadConfig({ configPath });
-  if (!existingConfig.success && existingConfig.error?.includes("No timeback config found")) {
-    const createResult = await ensureConfig({
-      configPath,
-      skipIntro: true,
-      format
-    });
-    if (!createResult.success) {
-      if (createResult.cancelled) {
-        outro.cancelled();
-      } else if (createResult.error) {
-        M2.error(createResult.error);
-        outro.error("Import failed");
-      }
-      if (exitOnComplete)
-        process.exit(createResult.cancelled ? 0 : 1);
-      return;
-    }
-    outro.success();
-    if (exitOnComplete)
-      process.exit(0);
-    return;
-  }
-  if (!existingConfig.success) {
-    M2.error(existingConfig.error);
-    outro.error("Import failed");
-    if (exitOnComplete)
-      process.exit(1);
-    return;
-  }
-  const { config: config7 } = existingConfig;
-  Me(`${blueBright(bold(config7.name))}
-
-${formatExistingCourses(config7)}`, `${config7.courses.length} course${config7.courses.length === 1 ? "" : "s"} configured`);
-  const shouldImport = await ye({
-    message: "Would you like to import more courses?",
-    initialValue: true
-  });
-  if (isCancelled(shouldImport) || !shouldImport) {
-    outro.cancelled();
-    if (exitOnComplete) {
-      process.exit(0);
-    }
-    return;
-  }
-  const existingCourseIds = getExistingCourseIds(config7);
-  const result = await runImportFlow({
-    configPath,
-    appName: config7.name,
-    existingCourseIds,
-    format
-  });
-  if (!result.success) {
-    if (result.cancelled) {
-      outro.cancelled();
-    } else if (result.error) {
-      M2.error(result.error);
-      outro.error("Import failed");
-    }
-    if (exitOnComplete)
-      process.exit(result.cancelled ? 0 : 1);
-    return;
-  }
-  outro.success();
-  if (exitOnComplete)
-    process.exit(0);
-}
-async function importCommand(options) {
-  const { courseId, configPath, env: env2, exitOnComplete = true, format = true } = options;
-  if (courseId) {
-    await importByCourseId({ courseId, configPath, env: env2, exitOnComplete });
-  } else {
-    await importInteractive({ configPath, exitOnComplete, format });
-  }
-}
-
-// src/commands/import/index.ts
-function registerImportCommand(program2) {
-  program2.command("import [course-id]").description("Import courses from Timeback (exclude course-id to enter interactive mode)").option("-c, --config <path>", "Path to the config file").option("--env <environment>", "Target environment (staging or production)").option("--no-format", "Do not run prettier on the config file").action(async (courseId, opts) => {
-    await importCommand({
-      courseId,
-      configPath: opts.config,
-      env: opts.env,
-      format: opts.format
-    });
-  });
-}
-
-// src/commands/init/create.ts
-import { existsSync as existsSync4 } from "node:fs";
-import { writeFile as writeFile4 } from "node:fs/promises";
-import { basename as basename2, resolve as resolve5 } from "node:path";
-
-// src/commands/sync/lib/compare.ts
+// src/commands/resources/push/lib/compare.ts
 function compareWithTitle(localTitle, remoteTitle, localConfig, remoteData) {
   const changes = [];
   if (remoteTitle !== localTitle) {
@@ -109806,11 +108797,15 @@ async function compareCourses(options) {
     unchanged: [],
     errors: []
   };
+  const gradelessCourseCount = config7.courses.filter((c) => c?.grade === undefined).length;
+  const disambiguateGradeless = gradelessCourseCount > 1;
   for (let i = 0;i < config7.courses.length; i++) {
     const course = config7.courses[i];
-    if (!course)
+    if (!course) {
       continue;
-    const expectedTitle = getCourseTitle(config7.name, course);
+    }
+    const disambiguate = disambiguateGradeless && course.grade === undefined;
+    const expectedTitle = getCourseTitle(config7.name, course, { disambiguate });
     const synced = getSyncedCourses(course);
     if (synced.length === 0) {
       diff.creates.push({
@@ -109876,7 +108871,128 @@ async function compareCourses(options) {
   }
   return diff;
 }
-// src/commands/sync/lib/diff.ts
+// src/commands/resources/push/lib/courses.ts
+async function applyDiff(options) {
+  const { config: config7, diff, createEnv, createOrgId, onProgress } = options;
+  const result = {
+    created: 0,
+    updated: 0,
+    skipped: diff.unchanged.length,
+    errors: [...diff.errors],
+    skippedStructure: []
+  };
+  const structureAttempted = new Set;
+  const updatedConfig = { ...config7, courses: [...config7.courses] };
+  for (const create of diff.creates) {
+    if (!createEnv || !createOrgId) {
+      result.errors.push({
+        title: create.title,
+        header: "Environment and organization required for new courses",
+        details: []
+      });
+      continue;
+    }
+    const authOk = await initAuth({ env: createEnv });
+    if (!authOk) {
+      result.errors.push({
+        title: create.title,
+        header: `Failed to authenticate for ${createEnv}`,
+        details: []
+      });
+      continue;
+    }
+    onProgress?.(`Creating ${create.title} on ${createEnv}...`);
+    const resolved = resolveCourseForEnv(create.local, config7.defaults, createEnv);
+    const metadata = buildCreateMetadata(resolved);
+    try {
+      const client = getAuthContext(createEnv).timeback;
+      const response = await client.oneroster.courses.create({
+        title: create.title,
+        subjects: [resolved.subject],
+        ...resolved.grade === undefined ? {} : { grades: [resolved.grade] },
+        org: { sourcedId: createOrgId },
+        status: "active",
+        courseCode: resolved.courseCode,
+        level: resolved.level,
+        metadata
+      });
+      const allocatedCourseId = response.sourcedIdPairs.allocatedSourcedId;
+      const createdCourse = await client.oneroster.courses.get(allocatedCourseId);
+      const serverMetadata = createdCourse?.metadata;
+      updatedConfig.courses[create.index] = {
+        ...create.local,
+        ids: {
+          ...create.local.ids,
+          [createEnv]: allocatedCourseId
+        },
+        ...serverMetadata?.goals ? { metadata: { ...create.local.metadata, goals: serverMetadata.goals } } : {}
+      };
+      result.created++;
+      const effectiveLaunchUrl = resolved.launchUrl ?? config7.launchUrl;
+      if (effectiveLaunchUrl) {
+        structureAttempted.add(create.title);
+        onProgress?.(`Ensuring course structure for ${create.title}...`);
+        const structureResult = await ensureCourseStructure({
+          env: createEnv,
+          courseId: allocatedCourseId,
+          courseTitle: create.title,
+          appName: config7.name,
+          launchUrl: effectiveLaunchUrl,
+          onProgress
+        });
+        if (!structureResult.success && structureResult.error) {
+          result.errors.push(structureResult.error);
+        }
+      } else if (!result.skippedStructure.includes(create.title)) {
+        result.skippedStructure.push(create.title);
+      }
+    } catch (error57) {
+      const formatted = formatApiError(error57);
+      result.errors.push({ title: create.title, ...formatted });
+    }
+  }
+  for (const update of diff.updates) {
+    for (const { env: env2, courseId } of update.environments) {
+      onProgress?.(`Updating ${update.localTitle} on ${env2}...`);
+      const updateResult = await updateCourse({
+        env: env2,
+        courseId,
+        title: update.localTitle,
+        course: update.local,
+        defaults: config7.defaults
+      });
+      if (!updateResult.success && updateResult.error) {
+        result.errors.push(updateResult.error);
+        continue;
+      }
+      const resolved = resolveCourseForEnv(update.local, config7.defaults, env2);
+      const effectiveLaunchUrl = resolved.launchUrl ?? config7.launchUrl;
+      if (effectiveLaunchUrl) {
+        structureAttempted.add(update.localTitle);
+        onProgress?.(`Ensuring course structure for ${update.localTitle}...`);
+        const structureResult = await ensureCourseStructure({
+          env: env2,
+          courseId,
+          courseTitle: update.localTitle,
+          appName: config7.name,
+          launchUrl: effectiveLaunchUrl,
+          onProgress
+        });
+        if (!structureResult.success && structureResult.error) {
+          result.errors.push(structureResult.error);
+        }
+      }
+    }
+    if (!structureAttempted.has(update.localTitle)) {
+      if (!result.skippedStructure.includes(update.localTitle)) {
+        result.skippedStructure.push(update.localTitle);
+      }
+    }
+    result.updated++;
+  }
+  return { result, updatedConfig };
+}
+// src/commands/resources/push/lib/diff.ts
 function formatChange(update) {
   const { changes } = update;
   const maxFieldLen = Math.max(...changes.map((c) => c.field.length));
@@ -109885,30 +109001,59 @@ function formatChange(update) {
     const paddedField = change.field.padStart(maxFieldLen);
     const localVal = change.local || dim("(empty)");
     const paddedRemote = (change.remote || "(empty)").padStart(maxRemoteLen);
-    return `    ${dim(`${paddedField}:`)} ${red(paddedRemote)} ${dim("→")} ${green(localVal)}`;
+    return `    ${dim(paddedField)}  ${red(paddedRemote)} ${dim("→")} ${green(localVal)}`;
   });
 }
-function displaySyncDiff(diff) {
+function displayDiff(diff, options) {
+  const { createEnv } = options ?? {};
   const hasChanges = diff.creates.length > 0 || diff.updates.length > 0;
   if (!hasChanges) {
     return;
   }
-  M2.message(bold("Changes:"));
-  const lines = [];
   for (const create of diff.creates) {
-    lines.push(`  ${green("+")} ${create.title}`);
+    const lines = [];
+    const { local } = create;
+    const courseCode = local.courseCode ? ` (${local.courseCode})` : "";
+    lines.push(`${bold(create.title)}${dim(courseCode)}`);
+    lines.push("");
+    const targetInfo = createEnv ? dim((createEnv === "production" ? magenta : cyan)(createEnv)) : dim("(new)");
+    lines.push(`  ${green("+ create")}  ${targetInfo}`);
+    lines.push("");
+    const fields = [
+      { label: "title", value: create.title },
+      { label: "subject", value: local.subject },
+      { label: "grade", value: local.grade },
+      { label: "courseCode", value: local.courseCode }
+    ].filter((f2) => f2.value !== undefined && f2.value !== null);
+    const maxFieldLen = Math.max(...fields.map((f2) => f2.label.length));
+    for (const field of fields) {
+      lines.push(`    ${dim(field.label.padStart(maxFieldLen))}  ${green(field.value)}`);
+    }
+    M2.message(lines.join(`
+`), { symbol: green("●") });
   }
   for (const update of diff.updates) {
+    const lines = [];
+    const { local } = update;
+    const courseCode = local.courseCode ? ` (${local.courseCode})` : "";
+    lines.push(`${bold(update.localTitle)}${dim(courseCode)}`);
+    lines.push("");
+    const targetInfo = update.environments.map((env2) => {
+      const envColor = env2.env === "production" ? magenta : cyan;
+      const shortId = env2.courseId.slice(-4);
+      return `${dim(envColor(`${env2.env}:`))}${dim(`..${shortId}`)}`;
+    }).join("  ");
+    lines.push(`  ${yellow("~ update")}  ${targetInfo}`);
+    lines.push("");
     lines.push(...formatChange(update));
+    M2.message(lines.join(`
+`), { symbol: yellow("●") });
   }
   if (diff.unchanged.length > 0) {
-    lines.push("");
-    lines.push(dim(`  ${diff.unchanged.length} course${diff.unchanged.length === 1 ? "" : "s"} unchanged`));
+    M2.message(dim(`${diff.unchanged.length} course${diff.unchanged.length === 1 ? "" : "s"} unchanged`));
   }
-  M2.message(lines.join(`
-`));
 }
-function getSyncSummary(diff) {
+function getDiffSummary(diff) {
   const parts = [];
   if (diff.creates.length > 0) {
     parts.push(`${bold(diff.creates.length)} to create`);
@@ -109921,11 +109066,125 @@ function getSyncSummary(diff) {
   }
   return parts.join(", ");
 }
-// src/commands/sync/lib/setup.ts
+// src/commands/resources/push/lib/metrics.ts
+function findMissingCourseMetrics(config7) {
+  const issues = [];
+  const gradelessCourseCount = config7.courses.filter((c) => c?.grade === undefined).length;
+  const disambiguateGradeless = gradelessCourseCount > 1;
+  for (let i = 0;i < config7.courses.length; i++) {
+    const course = config7.courses[i];
+    if (!course) {
+      continue;
+    }
+    const disambiguate = disambiguateGradeless && course.grade === undefined;
+    const title = getCourseTitle(config7.name, course, { disambiguate });
+    const metrics = course.metadata?.metrics;
+    if (metrics?.totalXp === undefined) {
+      issues.push({
+        courseIndex: i,
+        courseTitle: title,
+        metric: "totalXp",
+        jsonPath: `courses[${i}].metadata.metrics.totalXp`
+      });
+    }
+    if (metrics?.totalLessons === undefined) {
+      issues.push({
+        courseIndex: i,
+        courseTitle: title,
+        metric: "totalLessons",
+        jsonPath: `courses[${i}].metadata.metrics.totalLessons`
+      });
+    }
+  }
+  return issues;
+}
+function formatMissingMetricsError(issues) {
+  if (issues.length === 0) {
+    return [];
+  }
+  const lines = ["Missing required course metrics:", ""];
+  const byCourse = new Map;
+  for (const issue4 of issues) {
+    const existing = byCourse.get(issue4.courseIndex) ?? [];
+    existing.push(issue4);
+    byCourse.set(issue4.courseIndex, existing);
+  }
+  for (const [, courseIssues] of byCourse) {
+    const first = courseIssues[0];
+    if (!first) {
+      continue;
+    }
+    lines.push(`  ${bold(first.courseTitle)}:`);
+    for (const issue4 of courseIssues) {
+      lines.push(`    - ${issue4.metric} (${dim(issue4.jsonPath)})`);
+    }
+  }
+  lines.push("");
+  lines.push("Add these fields to your timeback.config.json and try again.");
+  return lines;
+}
+async function promptForMissingMetrics(issues, config7) {
+  if (issues.length === 0) {
+    return config7;
+  }
+  M2.warn(yellow("Some courses are missing required metrics."));
+  const byCourse = new Map;
+  for (const issue4 of issues) {
+    const existing = byCourse.get(issue4.courseIndex) ?? [];
+    existing.push(issue4);
+    byCourse.set(issue4.courseIndex, existing);
+  }
+  for (const [courseIndex, courseIssues] of byCourse) {
+    const course = config7.courses[courseIndex];
+    const first = courseIssues[0];
+    if (!course || !first) {
+      continue;
+    }
+    M2.info(cyan(bold(first.courseTitle)));
+    for (const issue4 of courseIssues) {
+      const value = await promptForMetric(issue4.metric);
+      if (value === null) {
+        return null;
+      }
+      course.metadata = course.metadata ?? {};
+      course.metadata.metrics = course.metadata.metrics ?? {};
+      course.metadata.metrics[issue4.metric] = value;
+    }
+  }
+  return config7;
+}
+async function promptForMetric(metric) {
+  const labels = {
+    totalXp: "Total course XP",
+    totalLessons: "Total course lessons/units"
+  };
+  const result = await he({
+    message: labels[metric],
+    placeholder: "Enter a positive integer",
+    validate: (value) => {
+      const trimmed = value.trim();
+      if (!trimmed) {
+        return "Value is required";
+      }
+      const num = Number(trimmed);
+      if (!Number.isInteger(num) || num <= 0) {
+        return "Must be a positive integer";
+      }
+    }
+  });
+  if (isCancelled(result)) {
+    return null;
+  }
+  return Number(result);
+}
+function isInteractive() {
+  return process.stdout.isTTY === true && process.stdin.isTTY === true;
+}
+// src/commands/resources/push/lib/setup.ts
 async function setupCreateContext(options = {}) {
   if (options.env && !isTargetEnvironment(options.env)) {
     M2.error(`Invalid environment: ${options.env}. Must be 'staging' or 'production'.`);
-    outro.error("Sync failed");
+    outro.error("Push failed");
     return { success: false, exitCode: 1 };
   }
   const envResult = await resolveEnvironment({ env: options.env, skipIntro: true });
@@ -109935,24 +109194,24 @@ async function setupCreateContext(options = {}) {
   }
   const authOk = await initAuth({ env: envResult.env });
   if (!authOk) {
-    outro.error("Sync failed");
+    outro.error("Push failed");
     return { success: false, exitCode: 1 };
   }
   const ctx = getAuthContext(envResult.env);
   if (!ctx.credentials.email) {
     M2.error("Email not configured.");
     M2.info("Run `timeback credentials email` to configure your email.");
-    outro.error("Sync failed");
+    outro.error("Push failed");
     return { success: false, exitCode: 1 };
   }
-  const orgResult = await selectOrganization(ctx.timeback, ctx.credentials.email);
+  const orgResult = await selectOrganization(ctx.timeback, ctx.credentials.email, options.courseCount);
   if (!orgResult.success) {
     if (orgResult.cancelled) {
       outro.cancelled();
       return { success: false, exitCode: 0 };
     }
     M2.error(orgResult.error);
-    outro.error("Sync failed");
+    outro.error("Push failed");
     return { success: false, exitCode: 1 };
   }
   M2.info(`Creating on ${bold(envResult.env)} in ${bold(orgResult.orgName)}`);
@@ -109961,8 +109220,77 @@ async function setupCreateContext(options = {}) {
     context: { env: envResult.env, orgId: orgResult.orgId }
   };
 }
-// src/commands/sync/sync.ts
-async function syncCommand(options) {
+// src/commands/resources/push/lib/warnings.ts
+function formatSkippedStructureWarning(titles) {
+  const uniqueTitles = [...new Set(titles)].filter(Boolean);
+  if (uniqueTitles.length === 0)
+    return null;
+  return {
+    warning: `${uniqueTitles.length} ${pluralize(uniqueTitles.length, "course")} synced but not launchable (missing launchUrl)`,
+    info: [
+      ...uniqueTitles.map((title) => `  • ${title}`),
+      "Students won't be able to launch these courses until you add a launchUrl.",
+      "Add launchUrl to your config and run sync again to fix this."
+    ]
+  };
+}
+
+// src/commands/resources/push/push.ts
+function logPushResults(result) {
+  if (result.created > 0) {
+    M2.success(`Created ${bold(result.created)} course${result.created === 1 ? "" : "s"}`);
+  }
+  if (result.updated > 0) {
+    M2.success(`Updated ${bold(result.updated)} course${result.updated === 1 ? "" : "s"}`);
+  }
+  logErrors(result.errors);
+  if (result.skippedStructure.length > 0) {
+    const warning = formatSkippedStructureWarning(result.skippedStructure);
+    if (warning) {
+      M2.warn(warning.warning);
+      for (const line of warning.info) {
+        M2.info(line);
+      }
+    }
+  }
+}
+async function validateMetricsGate(config7, configPath, relativeConfigPath) {
+  const missingMetrics = findMissingCourseMetrics(config7);
+  if (missingMetrics.length === 0) {
+    return { success: true, config: config7 };
+  }
+  if (isInteractive()) {
+    const updatedConfig = await promptForMissingMetrics(missingMetrics, config7);
+    if (updatedConfig === null) {
+      outro.cancelled();
+      return { success: false, exitCode: 0 };
+    }
+    await saveConfig(configPath, updatedConfig);
+    M2.success(`Updated ${dim(relativeConfigPath)} with metrics`);
+    return { success: true, config: updatedConfig };
+  }
+  const errorLines = formatMissingMetricsError(missingMetrics);
+  for (const line of errorLines) {
+    M2.error(line);
+  }
+  outro.error("Push failed");
+  return { success: false, exitCode: 1 };
+}
+async function computeDiff(config7, initMode) {
+  const hasLinkedCourses = config7.courses.some((course) => getSyncedCourses(course).length > 0);
+  if (initMode && !hasLinkedCourses) {
+    return compareCourses({ config: config7 });
+  }
+  const s = Y2();
+  s.start(hasLinkedCourses ? "Comparing with Timeback..." : "Computing changes...");
+  const diff = await compareCourses({
+    config: config7,
+    onProgress: (msg) => s.message(msg)
+  });
+  s.stop(hasLinkedCourses ? "Remote check complete" : "Changes computed");
+  return diff;
+}
+async function pushCommand(options) {
   const {
     configPath: customConfigPath,
     exitOnComplete = true,
@@ -109971,10 +109299,11 @@ async function syncCommand(options) {
     env: env2,
     createEnv: preResolvedEnv,
     preloadedConfig,
-    yes = false
+    yes = false,
+    initMode = false
   } = options;
   if (!skipIntro) {
-    intro("Timeback Sync");
+    intro("Timeback Push");
   }
   let config7, configPath;
   if (preloadedConfig) {
@@ -109984,7 +109313,7 @@ async function syncCommand(options) {
     const configResult = await loadConfig({ configPath: customConfigPath });
     if (!configResult.success) {
       M2.error(configResult.error);
-      outro.error("Sync failed");
+      outro.error("Push failed");
       if (exitOnComplete)
         process.exit(1);
       return false;
@@ -109993,14 +109322,17 @@ async function syncCommand(options) {
     configPath = configResult.configPath;
   }
   const relativeConfigPath = getRelativeConfigPath(configPath);
-  M2.info(`Loaded ${dim(relativeConfigPath)}`);
-  const s = Y2();
-  s.start("Comparing with Timeback...");
-  const diff = await compareCourses({
-    config: config7,
-    onProgress: (msg) => s.message(msg)
-  });
-  s.stop("Remote check complete");
+  if (!initMode) {
+    M2.info(`Loaded ${dim(relativeConfigPath)}`);
+  }
+  const metricsResult = await validateMetricsGate(config7, configPath, relativeConfigPath);
+  if (!metricsResult.success) {
+    if (exitOnComplete)
+      process.exit(metricsResult.exitCode);
+    return metricsResult.exitCode === 0;
+  }
+  config7 = metricsResult.config;
+  const diff = await computeDiff(config7, initMode);
   if (diff.errors.length > 0) {
     logErrors(diff.errors);
   }
@@ -110012,25 +109344,24 @@ async function syncCommand(options) {
       process.exit(0);
     return true;
   }
-  M2.info(`Found changes: ${getSyncSummary(diff)}`);
-  displaySyncDiff(diff);
+  if (!initMode) {
+    M2.info(`Found changes: ${getDiffSummary(diff)}`);
+  }
   if (dryRun) {
+    displayDiff(diff);
     outro.warn("Dry run (no changes made)");
-    if (exitOnComplete)
-      process.exit(0);
-    return true;
-  }
-  const shouldSync = yes || await ye({ message: "Apply these changes?" });
-  if (isCancelled(shouldSync) || !shouldSync) {
-    outro.cancelled();
-    if (exitOnComplete)
+    if (exitOnComplete) {
       process.exit(0);
+    }
     return true;
   }
   let createEnv;
   let createOrgId;
   if (diff.creates.length > 0) {
-    const setupResult = await setupCreateContext({ env: env2 ?? preResolvedEnv });
+    const setupResult = await setupCreateContext({
+      env: env2 ?? preResolvedEnv,
+      courseCount: diff.creates.length
+    });
     if (!setupResult.success) {
       if (exitOnComplete)
         process.exit(setupResult.exitCode);
@@ -110039,26 +109370,31 @@ async function syncCommand(options) {
     createEnv = setupResult.context.env;
     createOrgId = setupResult.context.orgId;
   }
-  s.start("Applying changes...");
+  displayDiff(diff, { createEnv, initMode });
+  const count = diff.creates.length + diff.updates.length;
+  const msg = initMode ? `Create ${count === 1 ? "this" : "these"} course${count === 1 ? "" : "s"}?` : "Apply these changes?";
+  const shouldSync = yes || await ye({ message: msg });
+  if (isCancelled(shouldSync) || !shouldSync) {
+    outro.cancelled();
+    if (exitOnComplete)
+      process.exit(0);
+    return true;
+  }
+  const applySpinner = Y2();
+  applySpinner.start(initMode ? "Creating courses..." : "Applying changes...");
   const { result, updatedConfig } = await applyDiff({
     config: config7,
     diff,
     createEnv,
     createOrgId,
-    onProgress: (msg) => s.message(msg)
+    onProgress: (msg2) => applySpinner.message(msg2)
   });
-  s.stop("Changes applied");
+  applySpinner.stop(initMode ? "Courses created" : "Changes applied");
   if (result.created > 0 || result.updated > 0) {
     await saveConfig(configPath, updatedConfig);
-    M2.success(`Updated ${dim(relativeConfigPath)}`);
+    M2.success(`Saved ${dim(relativeConfigPath)}`);
   }
-  if (result.created > 0) {
-    M2.success(`Created ${bold(result.created)} course${result.created === 1 ? "" : "s"}`);
-  }
-  if (result.updated > 0) {
-    M2.success(`Updated ${bold(result.updated)} course${result.updated === 1 ? "" : "s"}`);
-  }
-  logErrors(result.errors);
+  logPushResults(result);
   if (result.errors.length > 0) {
     outro.warn("Completed with errors");
     if (exitOnComplete)
@@ -110066,8 +109402,9 @@ async function syncCommand(options) {
     return false;
   }
   outro.success();
-  if (exitOnComplete)
+  if (exitOnComplete) {
     process.exit(0);
+  }
   return true;
 }
 
@@ -110126,22 +109463,6 @@ async function ensureConfiguredEnvironments(targetEnv) {
   return { status: "ok", envs: configuredEnvs };
 }
 // src/commands/init/lib/postInit.ts
-async function decideSyncAfterInit(opts) {
-  if (opts.noSync) {
-    return { shouldSync: false, cancelled: false };
-  }
-  if (opts.yes) {
-    return { shouldSync: true, cancelled: false };
-  }
-  const syncConfirm = await ye({
-    message: "Sync with Timeback now?",
-    initialValue: true
-  });
-  if (isCancelled(syncConfirm)) {
-    return { shouldSync: false, cancelled: true };
-  }
-  return { shouldSync: syncConfirm, cancelled: false };
-}
 async function ensureSyncEmail(targetEnv) {
   const creds = await getSavedCredentials(targetEnv);
   if (creds && !creds.email) {
@@ -110152,7 +109473,7 @@ async function ensureSyncEmail(targetEnv) {
 function finishWithoutSync(options) {
   const { withHint, cancelled, exitOnComplete } = options;
   if (withHint) {
-    M2.info(`Run ${greenBright("timeback sync")} when you're ready.`);
+    M2.info(`Run ${greenBright("timeback resources push")} once ready`);
   }
   if (cancelled) {
     outro.cancelled();
@@ -110205,6 +109526,35 @@ async function resolveInitSyncCreateEnv(options) {
   }
   return { success: true, createEnv };
 }
+// src/commands/init/lib/constants.ts
+var SUBJECTS = [
+  "Math",
+  "FastMath",
+  "Reading",
+  "Language",
+  "Vocabulary",
+  "Writing",
+  "Science",
+  "Social Studies"
+];
+var GRADES = [
+  { value: -1, label: "Pre-K" },
+  { value: 0, label: "Kindergarten" },
+  { value: 1, label: "Grade 1" },
+  { value: 2, label: "Grade 2" },
+  { value: 3, label: "Grade 3" },
+  { value: 4, label: "Grade 4" },
+  { value: 5, label: "Grade 5" },
+  { value: 6, label: "Grade 6" },
+  { value: 7, label: "Grade 7" },
+  { value: 8, label: "Grade 8" },
+  { value: 9, label: "Grade 9" },
+  { value: 10, label: "Grade 10" },
+  { value: 11, label: "Grade 11" },
+  { value: 12, label: "Grade 12" },
+  { value: 13, label: "AP" }
+];
+
 // src/commands/init/lib/prompts.ts
 var GRADE_NONE = "none";
 var GRADE_OPTIONS = [
@@ -110289,10 +109639,9 @@ async function promptCourses(appName) {
       }
     }
   }
-  M2.info(`Creating ${courses.length} course${courses.length === 1 ? "" : "s"}`);
   return courses;
 }
-// src/commands/init/create.ts
+// src/commands/init/init.ts
 async function promptInitMode() {
   const mode = await ve({
     message: "How would you like to set up your config?",
@@ -110300,12 +109649,12 @@ async function promptInitMode() {
       {
         value: "create",
         label: "Initialize a new app",
-        hint: "Manually define subjects and grades"
+        hint: "First time setup"
       },
       {
         value: "import",
         label: "Import an existing app",
-        hint: "Search and import courses from Timeback"
+        hint: "Import existing resources"
       }
     ]
   });
@@ -110329,21 +109678,19 @@ async function createFromScratch() {
   if (launchUrl === undefined) {
     return null;
   }
-  const suggestedSensor = deriveSensorFromLaunchUrl(launchUrl);
-  const sensor = await promptSensor({ defaultValue: suggestedSensor });
-  if (sensor === undefined) {
-    return null;
-  }
   return {
     name,
     launchUrl,
-    sensor,
     courses: courses.map((c) => ({
       ...c,
       ids: null
     }))
   };
 }
+function extractCommonLaunchUrl(courses) {
+  const urls = new Set(courses.map((c) => c.launchUrl).filter(Boolean));
+  return urls.size === 1 ? [...urls][0] : undefined;
+}
 async function createFromImport() {
   const setupResult = await ensureConfiguredEnvironments();
   if (setupResult.status === "cancelled") {
@@ -110360,18 +109707,16 @@ async function createFromImport() {
     }
     return null;
   }
-  const launchUrl = await promptLaunchUrl();
-  if (launchUrl === undefined) {
-    return null;
-  }
-  const sensor = await promptSensor({ defaultValue: deriveSensorFromLaunchUrl(launchUrl) });
-  if (sensor === undefined) {
-    return null;
+  let launchUrl = extractCommonLaunchUrl(result.courses);
+  if (!launchUrl) {
+    launchUrl = await promptLaunchUrl();
+    if (launchUrl === undefined) {
+      return null;
+    }
   }
   return {
     name: result.appName,
     launchUrl,
-    sensor,
     courses: result.courses
   };
 }
@@ -110380,15 +109725,16 @@ async function createConfig(options = {}) {
     configPath: customPath,
     exitOnComplete = true,
     format = true,
-    env: env2,
+    syncEnv,
     yes = false,
-    noSync = false
+    sync = false
   } = options;
   const cwd = process.cwd();
-  const configPath = customPath ? resolve5(cwd, customPath) : resolve5(cwd, DEFAULT_CONFIG_FILENAME);
+  const configPath = customPath ? resolve4(cwd, customPath) : resolve4(cwd, DEFAULT_CONFIG_FILENAME);
   const configFilename = basename2(configPath);
-  intro("Timeback");
-  if (existsSync4(configPath)) {
+  intro("Timeback Init");
+  const configExisted = existsSync4(configPath);
+  if (configExisted) {
     M2.warn(`${blueBright(configFilename)} already exists`);
     const overwrite = yes ? true : await ye({
       message: "Overwrite existing config?",
@@ -110420,32 +109766,18 @@ async function createConfig(options = {}) {
       process.exit(0);
     return;
   }
+  const normalizedConfig = normalizeLaunchUrls(config7);
   const s = Y2();
   s.start(`Creating ${configFilename}...`);
-  const content = generateConfigContent(config7);
-  await writeFile4(configPath, content, "utf-8");
-  if (format) {
-    await formatWithPrettier({ cwd, filePath: configPath, logger: M2, silent: true });
-  }
+  await saveConfig(configPath, normalizedConfig, { format });
   s.stop(`Created ${dim(configFilename)}`);
-  if (mode === "import") {
-    outro.success();
-    if (exitOnComplete)
-      process.exit(0);
-    return;
-  }
-  const syncDecision = await decideSyncAfterInit({ noSync, yes });
-  if (syncDecision.cancelled) {
-    finishWithoutSync({ withHint: false, cancelled: true, exitOnComplete });
-    return;
-  }
-  if (!syncDecision.shouldSync) {
+  if (!sync) {
     finishWithoutSync({ withHint: true, cancelled: false, exitOnComplete });
     return;
   }
   const createEnvResult = await resolveInitSyncCreateEnv({
-    config: config7,
-    env: env2,
+    config: normalizedConfig,
+    env: syncEnv,
     exitOnComplete
   });
   if (!createEnvResult.success) {
@@ -110471,35 +109803,32 @@ async function createConfig(options = {}) {
       return;
     }
   }
-  const syncSuccess = await syncCommand({
+  const pushSuccess = await pushCommand({
     exitOnComplete: false,
     skipIntro: true,
-    preloadedConfig: { config: config7, configPath },
+    preloadedConfig: { config: normalizedConfig, configPath },
     createEnv: createEnvResult.createEnv,
-    yes
+    yes,
+    initMode: true
   });
-  if (format) {
-    await formatWithPrettier({ cwd, filePath: configPath, logger: M2, silent: true });
+  if (format && existsSync4(configPath)) {
+    await formatWithPrettier({ cwd, filePath: configPath, silent: true });
   }
   if (exitOnComplete)
-    process.exit(syncSuccess ? 0 : 1);
+    process.exit(pushSuccess ? 0 : 1);
 }
 
 // src/commands/init/index.ts
 function registerInitCommand(program2) {
-  program2.command("init").description("Create a new timeback.config.json file").option("-c, --config <path>", "Path to the config file (default: timeback.config.json)").option("--env <environment>", "Target environment (staging, production)").option("-y, --yes", "Skip confirmations and use defaults where possible").option("--no-format", "Do not run prettier on the generated config file").option("--no-sync", "Skip syncing with Timeback after init").action((opts) => createConfig({
+  program2.command("init").description("Create a new timeback.config.json file").option("-c, --config <path>", "Path to the config file (default: timeback.config.json)").option("--syncEnv <environment>", "Target environment for sync (staging, production)").option("-y, --yes", "Skip confirmations and use defaults where possible").option("--no-format", "Do not run prettier on the generated config file").option("--sync", "Sync with Timeback after creating the config").action((opts) => createConfig({
     configPath: opts.config,
-    env: opts.env,
+    syncEnv: opts.syncEnv,
     yes: opts.yes,
     format: opts.format,
-    noSync: opts.sync === false
+    sync: opts.sync === true
   }));
 }
 
-// ../internal/utils/src/shared/format.ts
-function pluralize(count, singular, plural) {
-  return count === 1 ? singular : plural ?? `${singular}s`;
-}
 // src/commands/inspect/lib/format.ts
 function formatStat(label, value, labelWidth = 24) {
   const formattedValue = typeof value === "number" ? value.toLocaleString() : value;
@@ -110894,6 +110223,594 @@ function registerInspectCommand(program2) {
   });
 }
 
+// src/commands/resources/pull/lib/apply.ts
+function applyComparison(config7, comparison) {
+  const course = config7.courses[comparison.index];
+  if (!course)
+    return;
+  for (const change of comparison.changes) {
+    switch (change.field) {
+      case "subject":
+        course.subject = change.remote;
+        break;
+      case "grade":
+        course.grade = change.remote;
+        break;
+      case "courseCode":
+        course.courseCode = change.remote;
+        break;
+    }
+  }
+}
+function applyChanges(config7, comparisons) {
+  const updated = {
+    ...config7,
+    courses: config7.courses.map((c) => ({ ...c }))
+  };
+  for (const comparison of comparisons) {
+    applyComparison(updated, comparison);
+  }
+  return updated;
+}
+// src/commands/resources/pull/lib/compare.ts
+function compareCourse(local, remote) {
+  const changes = [];
+  const remoteSubject = remote.subjects?.[0];
+  if (local.subject !== remoteSubject) {
+    changes.push({ field: "subject", local: local.subject, remote: remoteSubject });
+  }
+  const remoteGrade = remote.grades?.[0];
+  if (local.grade !== remoteGrade) {
+    changes.push({ field: "grade", local: local.grade, remote: remoteGrade });
+  }
+  if (local.courseCode !== remote.courseCode) {
+    changes.push({ field: "courseCode", local: local.courseCode, remote: remote.courseCode });
+  }
+  return changes;
+}
+function findLinkedCourses(courses) {
+  const linked = [];
+  for (let i = 0;i < courses.length; i++) {
+    const course = courses[i];
+    const ids = course.ids;
+    if (ids?.staging) {
+      linked.push({ index: i, course, env: "staging", courseId: ids.staging });
+    }
+    if (ids?.production) {
+      linked.push({ index: i, course, env: "production", courseId: ids.production });
+    }
+  }
+  return linked;
+}
+function filterChanges(comparisons) {
+  return comparisons.filter((c) => c.changes.length > 0);
+}
+async function fetchAndCompare(client, linkedCourses, callbacks) {
+  const comparisons = [];
+  for (const linked of linkedCourses) {
+    callbacks.onProgress(linked.course);
+    try {
+      const remote = await client.oneroster.courses.get(linked.courseId);
+      const changes = compareCourse(linked.course, remote);
+      comparisons.push({
+        index: linked.index,
+        course: linked.course,
+        env: linked.env,
+        courseId: linked.courseId,
+        changes
+      });
+    } catch (error57) {
+      const msg = error57 instanceof Error ? error57.message : String(error57);
+      callbacks.onError(linked.course, msg);
+    }
+  }
+  return comparisons;
+}
+// src/commands/resources/pull/lib/display.ts
+function formatCourse2(course) {
+  if (course.grade !== undefined) {
+    return `${course.subject} Grade ${course.grade}`;
+  }
+  if (course.courseCode) {
+    return `${course.subject} (${course.courseCode})`;
+  }
+  return course.subject;
+}
+function formatValue6(value) {
+  if (value === undefined)
+    return dim("(not set)");
+  if (value === null)
+    return dim("(null)");
+  return String(value);
+}
+function displayChange(change) {
+  M2.info(`    ${bold(change.field)}:`);
+  M2.info(`      ${red("-")} ${formatValue6(change.local)}`);
+  M2.info(`      ${green("+")} ${formatValue6(change.remote)}`);
+}
+function displayChanges(comparisons) {
+  M2.info(`
+${yellow("Changes to pull:")}
+`);
+  for (const comparison of comparisons) {
+    const title = formatCourse2(comparison.course);
+    M2.info(`  ${bold(title)} ${dim(`(${comparison.env})`)}`);
+    for (const change of comparison.changes) {
+      displayChange(change);
+    }
+    M2.info("");
+  }
+}
+// src/commands/resources/pull/pull.ts
+function getExistingCourseIds(config7) {
+  const byEnv = {};
+  for (const course of config7.courses) {
+    for (const [env2, id] of Object.entries(course.ids ?? {})) {
+      if (!byEnv[env2])
+        byEnv[env2] = [];
+      if (id)
+        byEnv[env2].push(id);
+    }
+  }
+  return byEnv;
+}
+async function importMoreCourses(options) {
+  const result = await runImportFlow({
+    configPath: options.configPath,
+    appName: options.config.name,
+    existingCourseIds: getExistingCourseIds(options.config)
+  });
+  if (!result.success) {
+    return {
+      success: false,
+      cancelled: result.cancelled,
+      error: result.error ?? "Import failed"
+    };
+  }
+  return { success: true };
+}
+async function handleNoLinkedCourses(options) {
+  const { env: env2, importAfterPull, config: config7, customConfigPath, exitOnComplete } = options;
+  if (!importAfterPull) {
+    const message = [
+      `No courses linked to ${env2}.`,
+      `Run ${bold(greenBright("timeback resources push"))} first.`
+    ].join(`
+`);
+    Me(message, "No Linked Courses");
+    outro.cancelled();
+    if (exitOnComplete) {
+      process.exit(0);
+    }
+    return true;
+  }
+  const importResult = await importMoreCourses({ config: config7, configPath: customConfigPath });
+  if (!importResult.success) {
+    if (importResult.cancelled) {
+      outro.cancelled();
+      if (exitOnComplete) {
+        process.exit(0);
+      }
+      return true;
+    }
+    M2.error(importResult.error);
+    outro.error("Import failed");
+    if (exitOnComplete) {
+      process.exit(1);
+    }
+    return true;
+  }
+  outro.success();
+  if (exitOnComplete) {
+    process.exit(0);
+  }
+  return true;
+}
+async function pullCommand(options) {
+  const {
+    configPath: customConfigPath,
+    env: envOption,
+    apply = false,
+    import: importAfterPull = false,
+    exitOnComplete = true,
+    skipIntro = false
+  } = options;
+  if (!skipIntro) {
+    intro("Timeback Pull");
+  }
+  const configResult = await loadConfig({ configPath: customConfigPath });
+  if (!configResult.success) {
+    M2.error(configResult.error);
+    outro.error("Pull failed");
+    if (exitOnComplete) {
+      process.exit(1);
+    }
+    return;
+  }
+  const { config: config7, configPath } = configResult;
+  const relativeConfigPath = getRelativeConfigPath(configPath);
+  M2.info(`Loaded ${dim(relativeConfigPath)}`);
+  const envResult = await resolveEnvironment({ env: envOption, skipIntro: true });
+  if (!envResult) {
+    outro.cancelled();
+    if (exitOnComplete) {
+      process.exit(0);
+    }
+    return;
+  }
+  const env2 = envResult.env;
+  const linkedCourses = findLinkedCourses(config7.courses).filter((c) => c.env === env2);
+  if (linkedCourses.length === 0) {
+    await handleNoLinkedCourses({
+      env: env2,
+      importAfterPull,
+      config: config7,
+      customConfigPath,
+      exitOnComplete
+    });
+    return;
+  }
+  const authOk = await initAuth({ env: env2 });
+  if (!authOk) {
+    M2.error(`Failed to authenticate for ${env2}`);
+    outro.error("Pull failed");
+    if (exitOnComplete) {
+      process.exit(1);
+    }
+    return;
+  }
+  const client = getAuthContext(env2).timeback;
+  const s = Y2();
+  s.start("Fetching remote course data...");
+  const comparisons = await fetchAndCompare(client, linkedCourses, {
+    onProgress: (course) => s.message(`Checking ${formatCourse2(course)}...`),
+    onError: (course, error57) => M2.warn(`Failed to fetch ${formatCourse2(course)}: ${error57}`)
+  });
+  const withChanges = filterChanges(comparisons);
+  if (withChanges.length === 0) {
+    s.stop("Local config is up to date with remote");
+    if (!importAfterPull) {
+      outro.success();
+      if (exitOnComplete) {
+        process.exit(0);
+      }
+      return;
+    }
+  } else {
+    s.stop("Remote check complete");
+  }
+  if (withChanges.length > 0) {
+    displayChanges(withChanges);
+    const shouldApply = apply || await ye({ message: "Apply these changes to local config?" });
+    if (isCancelled(shouldApply) || !shouldApply) {
+      outro.cancelled();
+      if (exitOnComplete)
+        process.exit(0);
+      return;
+    }
+    const updatedConfig = applyChanges(config7, withChanges);
+    await saveConfig(configPath, updatedConfig);
+    M2.success(`Updated ${dim(relativeConfigPath)}`);
+    M2.success(`Pulled ${bold(withChanges.length)} course${withChanges.length === 1 ? "" : "s"}`);
+  }
+  if (importAfterPull) {
+    const importResult = await importMoreCourses({ config: config7, configPath: customConfigPath });
+    if (!importResult.success) {
+      if (importResult.cancelled) {
+        outro.cancelled();
+        if (exitOnComplete)
+          process.exit(0);
+        return;
+      }
+      M2.error(importResult.error);
+      outro.error("Import failed");
+      if (exitOnComplete)
+        process.exit(1);
+      return;
+    }
+  }
+  outro.success();
+  if (exitOnComplete) {
+    process.exit(0);
+  }
+}
+
+// src/commands/resources/pull/index.ts
+function registerPullSubcommand(resources) {
+  resources.command("pull").description("Pull remote data from Timeback (remote → local)").option("-c, --config <path>", "Path to the config file").option("--env <environment>", "Target environment (staging or production)").option("--apply", "Apply changes without prompting").option("--import", "Also import additional courses (interactive)").action(async (opts) => {
+    await pullCommand({
+      configPath: opts.config,
+      env: opts.env,
+      apply: opts.apply,
+      import: opts.import,
+      skipIntro: true
+    });
+  });
+}
+
+// src/commands/resources/push/index.ts
+function registerPushSubcommand(resources) {
+  resources.command("push").description("Push local data to Timeback (local → remote)").option("-c, --config <path>", "Path to the config file").option("--env <environment>", "Target environment for new courses (staging, production)").option("--dry-run", "Show what would be pushed without making changes").option("-y, --yes", "Skip confirmation prompt").action(async (opts) => {
+    await pushCommand({
+      configPath: opts.config,
+      env: opts.env,
+      dryRun: opts.dryRun,
+      yes: opts.yes,
+      skipIntro: true
+    });
+  });
+}
+
+// src/commands/resources/unlink/lib/display.ts
+function formatCourse3(course) {
+  if (course.grade !== undefined) {
+    return `${course.subject} Grade ${course.grade}`;
+  }
+  if (course.courseCode) {
+    return `${course.subject} (${course.courseCode})`;
+  }
+  return course.subject;
+}
+function displayUnlinkSummary(coursesToUnlink) {
+  for (const course of coursesToUnlink) {
+    const lines = [];
+    const courseCode = course.course.courseCode ? ` (${course.course.courseCode})` : "";
+    lines.push(`${bold(course.title)}${dim(courseCode)}`);
+    lines.push("");
+    lines.push(`  ${red("- unlink")}  ${dim(course.courseId)}`);
+    M2.message(lines.join(`
+`), { symbol: red("●") });
+  }
+}
+
+// src/commands/resources/unlink/lib/config.ts
+function updateConfigAfterUnlink(config7, unlinkedIndices, env2) {
+  const updatedConfig = { ...config7, courses: [...config7.courses] };
+  for (const index of unlinkedIndices) {
+    const course = { ...updatedConfig.courses[index] };
+    const ids = { ...course.ids };
+    delete ids[env2];
+    if (Object.keys(ids).length === 0) {
+      course.ids = null;
+    } else {
+      course.ids = ids;
+    }
+    updatedConfig.courses[index] = course;
+  }
+  return updatedConfig;
+}
+function findLinkedCourses2(config7, env2) {
+  const courses = [];
+  for (let i = 0;i < config7.courses.length; i++) {
+    const course = config7.courses[i];
+    const courseId = course.ids?.[env2];
+    if (courseId) {
+      courses.push({
+        index: i,
+        course,
+        courseId,
+        title: formatCourse3(course)
+      });
+    }
+  }
+  return courses;
+}
+// src/commands/resources/unlink/lib/confirm.ts
+async function confirmUnlink(env2, appName, courseCount) {
+  if (env2 === "production") {
+    const confirmation = await he({
+      message: `Type "${appName}" to confirm unlinking from production:`,
+      placeholder: appName,
+      validate: (value) => {
+        if (value !== appName) {
+          return `Please type "${appName}" exactly to confirm`;
+        }
+      }
+    });
+    if (isCancelled(confirmation) || confirmation !== appName) {
+      return false;
+    }
+    return true;
+  }
+  const shouldUnlink = await ye({
+    message: `Unlink ${courseCount} course${courseCount === 1 ? "" : "s"} from ${env2}?`,
+    initialValue: false
+  });
+  return !isCancelled(shouldUnlink) && shouldUnlink;
+}
+async function selectCoursesToUnlink(linkedCourses, all, env2) {
+  if (all)
+    return linkedCourses;
+  const selected = await fe({
+    message: `Select courses to unlink from ${bold(env2)}:`,
+    options: linkedCourses.map((c) => ({
+      value: c.courseId,
+      label: c.title,
+      hint: dim(c.courseId)
+    })),
+    required: true
+  });
+  if (isCancelled(selected))
+    return;
+  return linkedCourses.filter((c) => selected.includes(c.courseId));
+}
+// src/commands/resources/unlink/lib/delete.ts
+async function safeDelete(deleteFn) {
+  try {
+    await deleteFn();
+    return { success: true, notFound: false };
+  } catch (error57) {
+    if (isApiError2(error57) && error57.statusCode === 404) {
+      return { success: true, notFound: true };
+    }
+    throw error57;
+  }
+}
+async function deleteCourseStructure(client, courseId, onProgress) {
+  const ids = deriveCourseStructureIds(courseId);
+  let resourcesDeleted = 0;
+  onProgress?.(`Unlinking componentResource ${dim(ids.componentResource)}...`);
+  const crResult = await safeDelete(() => client.oneroster.courses.deleteComponentResource(ids.componentResource));
+  if (crResult.success && !crResult.notFound)
+    resourcesDeleted++;
+  onProgress?.(`Unlinking resource ${dim(ids.resource)}...`);
+  const resourceResult = await safeDelete(() => client.oneroster.resources.delete(ids.resource));
+  if (resourceResult.success && !resourceResult.notFound)
+    resourcesDeleted++;
+  onProgress?.(`Unlinking component ${dim(ids.component)}...`);
+  const componentResult = await safeDelete(() => client.oneroster.courses.deleteComponent(ids.component));
+  if (componentResult.success && !componentResult.notFound)
+    resourcesDeleted++;
+  onProgress?.(`Unlinking course ${dim(ids.course)}...`);
+  const courseResult = await safeDelete(() => client.oneroster.courses.delete(ids.course));
+  if (courseResult.success && !courseResult.notFound)
+    resourcesDeleted++;
+  return resourcesDeleted;
+}
+async function executeUnlink(client, courses) {
+  const s = Y2();
+  s.start("Unlinking resources...");
+  let unlinked = 0;
+  let resourcesDeleted = 0;
+  const errors3 = [];
+  const unlinkedIndices = [];
+  for (const course of courses) {
+    try {
+      const count = await deleteCourseStructure(client, course.courseId, (msg) => s.message(msg));
+      resourcesDeleted += count;
+      unlinked++;
+      unlinkedIndices.push(course.index);
+    } catch (error57) {
+      const msg = error57 instanceof Error ? error57.message : String(error57);
+      errors3.push(`Failed to unlink ${course.title}: ${msg}`);
+    }
+  }
+  s.stop("Unlink complete");
+  return { unlinked, resourcesDeleted, errors: errors3, unlinkedIndices };
+}
+// src/commands/resources/unlink/unlink.ts
+async function unlinkCommand(options) {
+  const {
+    configPath: customConfigPath,
+    env: envOption,
+    all = false,
+    dryRun = false,
+    yes = false,
+    exitOnComplete = true,
+    skipIntro = false
+  } = options;
+  if (!skipIntro) {
+    intro("Timeback Unlink");
+  }
+  const configResult = await loadConfig({ configPath: customConfigPath });
+  if (!configResult.success) {
+    M2.error(configResult.error);
+    outro.error("Unlink failed");
+    if (exitOnComplete)
+      process.exit(1);
+    return;
+  }
+  const { config: config7, configPath } = configResult;
+  M2.info(`Loaded ${dim(getRelativeConfigPath(configPath))}`);
+  if (!envOption && yes) {
+    M2.error("--yes requires explicit --env flag");
+    outro.error("Unlink failed");
+    if (exitOnComplete)
+      process.exit(1);
+    return;
+  }
+  const envResult = await resolveEnvironment({ env: envOption, skipIntro: true });
+  if (!envResult) {
+    outro.cancelled();
+    if (exitOnComplete)
+      process.exit(0);
+    return;
+  }
+  const env2 = envResult.env;
+  const linkedCourses = findLinkedCourses2(config7, env2);
+  if (linkedCourses.length === 0) {
+    M2.warn(`No courses linked to ${env2}. Nothing to unlink.`);
+    outro.cancelled();
+    if (exitOnComplete)
+      process.exit(0);
+    return;
+  }
+  const coursesToUnlink = await selectCoursesToUnlink(linkedCourses, all, env2);
+  if (!coursesToUnlink || coursesToUnlink.length === 0) {
+    outro.cancelled();
+    if (exitOnComplete)
+      process.exit(0);
+    return;
+  }
+  displayUnlinkSummary(coursesToUnlink);
+  if (dryRun) {
+    outro.warn("Dry run (no changes made)");
+    if (exitOnComplete)
+      process.exit(0);
+    return;
+  }
+  if (!yes && !await confirmUnlink(env2, config7.name, coursesToUnlink.length)) {
+    outro.cancelled();
+    if (exitOnComplete)
+      process.exit(0);
+    return;
+  }
+  const authOk = await initAuth({ env: env2 });
+  if (!authOk) {
+    M2.error(`Failed to authenticate for ${env2}`);
+    outro.error("Unlink failed");
+    if (exitOnComplete)
+      process.exit(1);
+    return;
+  }
+  const result = await executeUnlink(getAuthContext(env2).timeback, coursesToUnlink);
+  if (result.unlinkedIndices.length > 0) {
+    const updatedConfig = updateConfigAfterUnlink(config7, result.unlinkedIndices, env2);
+    await saveConfig(configPath, updatedConfig);
+    M2.success(`Updated ${dim(getRelativeConfigPath(configPath))}`);
+  }
+  if (result.unlinked > 0) {
+    M2.success(`Unlinked ${bold(result.unlinked)} course${result.unlinked === 1 ? "" : "s"} (${result.resourcesDeleted} resources)`);
+  }
+  for (const error57 of result.errors) {
+    M2.error(error57);
+  }
+  if (result.errors.length > 0) {
+    outro.warn("Completed with errors");
+    if (exitOnComplete)
+      process.exit(1);
+    return;
+  }
+  outro.success();
+  if (exitOnComplete)
+    process.exit(0);
+}
+
+// src/commands/resources/unlink/index.ts
+function registerUnlinkSubcommand(resources) {
+  resources.command("unlink").description("Unlink courses from Timeback (deletes remote, keeps local definition)").option("-c, --config <path>", "Path to the config file").option("--env <environment>", "Target environment (staging or production)").option("--all", "Unlink all linked courses for the environment").option("--dry-run", "Show what would be unlinked without making changes").option("-y, --yes", "Skip confirmation (requires --env)").action(async (opts) => {
+    await unlinkCommand({
+      configPath: opts.config,
+      env: opts.env,
+      all: opts.all,
+      dryRun: opts.dryRun,
+      yes: opts.yes,
+      skipIntro: true
+    });
+  });
+}
+
+// src/commands/resources/index.ts
+function registerResourcesCommand(program2) {
+  const resources = program2.command("resources").description("Manage course resources (push/pull/unlink)");
+  resources.hook("preAction", () => {
+    intro("Timeback Resources");
+  });
+  registerPushSubcommand(resources);
+  registerPullSubcommand(resources);
+  registerUnlinkSubcommand(resources);
+}
+
 // ../studio/dist/index.js
 import { createRequire as createRequire2 } from "node:module";
 import { stripVTControlCharacters as S22 } from "node:util";
@@ -110903,11 +110820,11 @@ import O2 from "node:readline";
 import { Writable as X2 } from "node:stream";
 import y22 from "node:process";
 import * as tty2 from "tty";
-import { mkdir as mkdir2, readFile as readFile3, stat as stat2, writeFile as writeFile5 } from "node:fs/promises";
+import { mkdir as mkdir2, readFile as readFile3, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
 import { homedir as homedir2, platform as platform22 } from "node:os";
 import { join as join2 } from "node:path";
 import { readFile as readFile22 } from "node:fs/promises";
-import { basename as basename3, extname as extname2, relative as relative2, resolve as resolve6 } from "node:path";
+import { basename as basename3, extname as extname2, relative as relative2, resolve as resolve5 } from "node:path";
 import { loadConfig as c12LoadConfig2 } from "c12";
 import { basename as basename22 } from "node:path";
 import { createServer as createServerHTTP } from "http";
@@ -125497,7 +125414,7 @@ async function readCredentialsStore2() {
 async function writeCredentialsStore2(store) {
   if (!await ensureCredentialsDir2())
     return false;
-  await writeFile5(CREDENTIALS_FILE2, JSON.stringify(store, null, 2), { mode: 384 });
+  await writeFile3(CREDENTIALS_FILE2, JSON.stringify(store, null, 2), { mode: 384 });
   return true;
 }
 async function getSavedCredentials2(environment) {
@@ -125969,14 +125886,20 @@ var TimebackConfig8 = exports_external6.object({
   message: "Duplicate courseCode found; each must be unique",
   path: ["courses"]
 }).refine((config23) => {
-  return config23.courses.every((c) => c.sensor !== undefined || config23.sensor !== undefined);
-}, {
-  message: "Each course must have an effective sensor; set a top-level `sensor` or per-course `sensor`",
-  path: ["courses"]
-}).refine((config23) => {
-  return config23.courses.every((c) => c.launchUrl !== undefined || config23.launchUrl !== undefined);
+  return config23.courses.every((c) => {
+    if (c.sensor !== undefined || config23.sensor !== undefined) {
+      return true;
+    }
+    const launchUrls = [
+      c.launchUrl,
+      config23.launchUrl,
+      c.overrides?.staging?.launchUrl,
+      c.overrides?.production?.launchUrl
+    ].filter(Boolean);
+    return launchUrls.length > 0;
+  });
 }, {
-  message: "Each course must have an effective launchUrl; set a top-level `launchUrl` or per-course `launchUrl`",
+  message: "Each course must have an effective sensor. Either set `sensor` explicitly (top-level or per-course), or provide a `launchUrl` so sensor can be derived from its origin.",
   path: ["courses"]
 });
 var EdubridgeDateString8 = exports_external6.union([IsoDateString8, IsoDateTimeString8]);
@@ -126972,7 +126895,7 @@ function deriveCourseIds(config32) {
 }
 async function readPackageVersion(cwd) {
   try {
-    const pkgPath = resolve6(cwd, "package.json");
+    const pkgPath = resolve5(cwd, "package.json");
     const pkg = JSON.parse(await readFile22(pkgPath, "utf-8"));
     return pkg.version ?? "0.0.0";
   } catch {
@@ -127006,7 +126929,7 @@ async function loadWithC122(cwd, configPath) {
   const { $schema: _schema, ...configWithoutSchema } = rawConfig;
   return {
     config: configWithoutSchema,
-    configFile: result.configFile ?? resolve6(cwd, configPath ?? CONFIG_FILENAME3)
+    configFile: result.configFile ?? resolve5(cwd, configPath ?? CONFIG_FILENAME3)
   };
 }
 async function parse62() {
@@ -127059,7 +126982,6 @@ function printError2(error483) {
   console.log(`  ${yellow2('  "$schema": "https://timeback.dev/schema.json",')}`);
   console.log(`  ${yellow2('  "name": "My Timeback App",')}`);
   console.log(`  ${yellow2('  "launchUrl": "https://example.com/play",')}`);
-  console.log(`  ${yellow2('  "sensor": "https://example.com/sensor",')}`);
   console.log(`  ${yellow2('  "courses": [')}`);
   console.log(`  ${yellow2('    { "subject": "Math", "grade": 3 }')}`);
   console.log(`  ${yellow2("  ]")}`);
@@ -127110,6 +127032,46 @@ function toCourseConfig2(course, env22) {
   }
   return config32;
 }
+async function inferLaunchUrl2(client, courseId) {
+  try {
+    const scopedCourse = client.oneroster.courses(courseId);
+    const components = await scopedCourse.components({ where: { status: "active" } });
+    const componentResourceIds = [];
+    for (const component of components) {
+      if (!component.sourcedId)
+        continue;
+      const crs = await client.oneroster.courses.componentResources({
+        where: { "courseComponent.sourcedId": component.sourcedId, status: "active" }
+      });
+      for (const cr of crs) {
+        if (cr.resource?.sourcedId) {
+          componentResourceIds.push(cr.resource.sourcedId);
+        }
+      }
+    }
+    if (componentResourceIds.length === 0) {
+      return;
+    }
+    const resourceIds = [...new Set(componentResourceIds)];
+    const resources = await client.oneroster.resources.listAll({
+      where: { sourcedId: { in: resourceIds } }
+    });
+    const launchUrls = new Set;
+    for (const resource of resources) {
+      const metadata = resource.metadata;
+      const launchUrl = metadata?.launchUrl;
+      if (typeof launchUrl === "string" && launchUrl.length > 0) {
+        launchUrls.add(launchUrl);
+      }
+    }
+    if (launchUrls.size === 1) {
+      return [...launchUrls][0];
+    }
+    return;
+  } catch {
+    return;
+  }
+}
 function getParser2(opts = {}) {
   return opts.playcademy ? playcademyParser2 : timebackParser2;
 }
@@ -127134,11 +127096,11 @@ async function promptSelectEnv2(configuredEnvs) {
 }
 async function promptAppName3() {
   const name = await he2({
-    message: "App name",
+    message: "Search for your app",
     placeholder: "My Timeback App",
     validate: (value) => {
       if (!value.trim())
-        return "App name is required";
+        return "Please enter a search term";
     }
   });
   if (pD2(name))
@@ -127158,7 +127120,7 @@ async function promptSearchQuery2() {
     return;
   return query;
 }
-function formatCourseLabel3(course) {
+function formatCourseLabel2(course) {
   return course.title ?? "Untitled";
 }
 function sortCoursesByGrade2(courses) {
@@ -127174,7 +127136,7 @@ async function promptSelectCourses2(courses) {
     message: `Which courses would you like to import?`,
     options: sorted.map((c) => ({
       value: c,
-      label: formatCourseLabel3(c)
+      label: formatCourseLabel2(c)
     })),
     required: true
   });
@@ -127243,6 +127205,40 @@ async function selectCourses2(client, initialResults, filterFn) {
     results = filter(moreResults);
   }
 }
+async function enrichCoursesWithLaunchUrls2(client, courses) {
+  if (courses.length === 0)
+    return courses;
+  const s = Y22();
+  let didStop = false;
+  const stopOnce = (message) => {
+    if (didStop)
+      return;
+    s.stop(message);
+    didStop = true;
+  };
+  s.start("Fetching course details...");
+  const enriched = [];
+  try {
+    for (const course of courses) {
+      const courseId = course.ids?.staging ?? course.ids?.production;
+      if (!courseId) {
+        enriched.push(course);
+        continue;
+      }
+      const launchUrl = await inferLaunchUrl2(client, courseId);
+      if (launchUrl && !course.launchUrl) {
+        enriched.push({ ...course, launchUrl });
+      } else {
+        enriched.push(course);
+      }
+    }
+    stopOnce("Course details loaded");
+    return enriched;
+  } catch (error483) {
+    stopOnce("Failed to load course details");
+    throw error483;
+  }
+}
 async function searchAndSelectCourses3(options) {
   const { client, environment, appName: existingAppName, excludeCourseIds = [] } = options;
   const filterExcluded = (courses) => {
@@ -127265,11 +127261,11 @@ async function searchAndSelectCourses3(options) {
       return { success: false, cancelled: true };
     }
     const courseConfigs = courses.map((c) => toCourseConfig2(c, environment));
-    M22.success(`Selected ${courseConfigs.length} course${courseConfigs.length === 1 ? "" : "s"}`);
+    const enrichedConfigs = await enrichCoursesWithLaunchUrls2(client, courseConfigs);
     return {
       success: true,
       appName,
-      courses: courseConfigs,
+      courses: enrichedConfigs,
       environment
     };
   } catch (error483) {
@@ -130262,9 +130258,9 @@ var LEVEL_PREFIX9 = {
   error: "[ERROR]"
 };
 function formatContext26(context) {
-  return Object.entries(context).map(([key, value]) => `${key}=${formatValue6(value)}`).join(" ");
+  return Object.entries(context).map(([key, value]) => `${key}=${formatValue10(value)}`).join(" ");
 }
-function formatValue6(value) {
+function formatValue10(value) {
   if (typeof value === "string")
     return value;
   if (typeof value === "number")
@@ -131598,26 +131594,412 @@ function registerStudioCommand(program2) {
   });
 }
 
-// src/commands/sync/index.ts
-function registerSyncCommand(program2) {
-  program2.command("sync").description("Sync local config with Timeback").option("-c, --config <path>", "Path to the config file").option("--env <environment>", "Target environment (staging, production)").option("--dry-run", "Show what would be synced without making changes").action(async (opts) => {
-    await syncCommand({
-      configPath: opts.config,
-      env: opts.env,
-      dryRun: opts.dryRun
-    });
+// src/commands/upgrade/upgrade.ts
+import { execSync as execSync2 } from "node:child_process";
+
+// ../internal/utils/src/server/spinner.ts
+import { stdout as stdout2 } from "node:process";
+
+// ../internal/utils/src/server/terminal.ts
+import { stdout } from "node:process";
+var isInteractive2 = stdout.isTTY ?? false;
+var cursor = {
+  hide: "\x1B[?25l",
+  show: "\x1B[?25h",
+  up: (n) => `\x1B[${n}A`,
+  down: (n) => `\x1B[${n}B`,
+  forward: (n) => `\x1B[${n}C`,
+  back: (n) => `\x1B[${n}D`,
+  clearLine: "\x1B[K",
+  clearScreen: "\x1B[2J",
+  home: "\x1B[H"
+};
+function stripAnsi(str) {
+  return str.replaceAll(/\u001B\[[0-9;]*[a-zA-Z]/g, "");
+}
+
+// ../internal/utils/src/server/spinner.ts
+var SPINNER_FRAMES = [
+  10251,
+  10265,
+  10297,
+  10296,
+  10300,
+  10292,
+  10278,
+  10279,
+  10247,
+  10255
+].map((code) => String.fromCodePoint(code));
+var SPINNER_INTERVAL = 80;
+var CHECK_MARK = "✔";
+var CROSS_MARK = "✖";
+var STATUS_LABELS = {
+  pending: "[PENDING]",
+  running: "[RUNNING]",
+  success: "[SUCCESS]",
+  error: "[ERROR]"
+};
+
+class Spinner {
+  tasks = new Map;
+  frameIndex = 0;
+  intervalId = null;
+  previousLineCount = 0;
+  printedTasks = new Set;
+  constructor(taskIds, texts) {
+    for (const [index, id] of taskIds.entries()) {
+      this.tasks.set(id, {
+        text: texts[index] ?? "",
+        status: "pending"
+      });
+    }
+  }
+  start() {
+    if (!isInteractive2)
+      return;
+    stdout2.write(cursor.hide);
+    this.render();
+    this.intervalId = setInterval(() => {
+      this.frameIndex = (this.frameIndex + 1) % SPINNER_FRAMES.length;
+      this.render();
+    }, SPINNER_INTERVAL);
+  }
+  updateTask(taskId, status, finalText) {
+    const task = this.tasks.get(taskId);
+    if (!task)
+      return;
+    task.status = status;
+    if (finalText)
+      task.finalText = finalText;
+    if (!isInteractive2) {
+      this.renderNonInteractive(taskId, task);
+    }
+  }
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    if (isInteractive2) {
+      this.render();
+      stdout2.write(cursor.show);
+    }
+  }
+  clear() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    if (isInteractive2 && this.previousLineCount > 0) {
+      stdout2.write(cursor.up(this.previousLineCount));
+      for (let i = 0;i < this.previousLineCount; i++) {
+        stdout2.write(`\r${cursor.clearLine}
+`);
+      }
+      stdout2.write(cursor.up(this.previousLineCount));
+      stdout2.write(cursor.show);
+    }
+    this.previousLineCount = 0;
+  }
+  render() {
+    if (this.previousLineCount > 0) {
+      stdout2.write(cursor.up(this.previousLineCount));
+    }
+    const spinner = SPINNER_FRAMES[this.frameIndex];
+    const visibleTasks = [...this.tasks.values()].filter((t) => t.status !== "pending");
+    for (const task of visibleTasks) {
+      stdout2.write(`\r${cursor.clearLine}`);
+      console.log(this.formatLine(task, spinner));
+    }
+    this.previousLineCount = visibleTasks.length;
+  }
+  formatLine(task, spinner) {
+    switch (task.status) {
+      case "running":
+        return `${blue(spinner ?? "○")} ${task.text}`;
+      case "success":
+        return `${green(CHECK_MARK)} ${task.finalText ?? task.text}`;
+      case "error":
+        return `${red(CROSS_MARK)} Failed: ${task.text}`;
+      default:
+        return task.text;
+    }
+  }
+  renderNonInteractive(taskId, task) {
+    const key = `${taskId}-${task.status}`;
+    if (this.printedTasks.has(key))
+      return;
+    this.printedTasks.add(key);
+    const text = task.status === "success" ? task.finalText ?? task.text : task.text;
+    console.log(`${STATUS_LABELS[task.status]} ${stripAnsi(text)}`);
+  }
+}
+// ../internal/utils/src/server/runtime.ts
+import { execSync } from "node:child_process";
+import { join as join3 } from "node:path";
+var PACKAGE_MANAGERS = ["bun", "pnpm", "yarn", "npm"];
+var PACKAGE_NAME = "timeback";
+function getPlatformInfo() {
+  return {
+    platform: process.platform,
+    arch: process.arch
+  };
+}
+var STANDALONE_PATHS = [
+  join3(".timeback", "bin"),
+  join3(".local", "bin"),
+  "/usr/local/bin/timeback",
+  "/opt/homebrew/bin/timeback"
+];
+function isStandaloneBinary() {
+  const execPath = process.execPath.toLowerCase();
+  return STANDALONE_PATHS.some((p3) => execPath.includes(p3.toLowerCase()));
+}
+function runCommand(cmd) {
+  try {
+    return execSync(cmd, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+  } catch {
+    return "";
+  }
+}
+var GLOBAL_LIST_COMMANDS = {
+  npm: "npm list -g --depth=0 2>/dev/null",
+  bun: "bun pm ls -g 2>/dev/null",
+  pnpm: "pnpm list -g --depth=0 2>/dev/null",
+  yarn: "yarn global list 2>/dev/null"
+};
+function getInstallMethod() {
+  if (isStandaloneBinary()) {
+    return "standalone";
+  }
+  const execPath = process.execPath.toLowerCase();
+  const sortedManagers = [...PACKAGE_MANAGERS].sort((a, b3) => {
+    const aMatches = execPath.includes(a);
+    const bMatches = execPath.includes(b3);
+    if (aMatches && !bMatches)
+      return -1;
+    if (!aMatches && bMatches)
+      return 1;
+    return 0;
+  });
+  for (const pm of sortedManagers) {
+    const output2 = runCommand(GLOBAL_LIST_COMMANDS[pm]);
+    if (output2.includes(PACKAGE_NAME)) {
+      return pm;
+    }
+  }
+  return "unknown";
+}
+// src/commands/upgrade/lib/constants.ts
+var LATEST_VERSION_URL = "https://dl.timeback.dev/cli/latest/version.txt";
+var DOWNLOAD_BASE_URL = "https://dl.timeback.dev/cli/latest";
+var BINARY_NAME = "timeback";
+var DEFAULT_INSTALL_PATH = "/usr/local/bin/timeback";
+var BINARY_NAMES = {
+  "darwin-arm64": "timeback-darwin-arm64",
+  "darwin-x64": "timeback-darwin-x64",
+  "linux-arm64": "timeback-linux-arm64",
+  "linux-x64": "timeback-linux-x64",
+  "win32-x64": "timeback-windows-x64.exe"
+};
+var PACKAGE_MANAGER_COMMANDS = {
+  bun: "bun update -g timeback",
+  npm: "npm update -g timeback",
+  yarn: "yarn global upgrade timeback",
+  pnpm: "pnpm update -g timeback"
+};
+// src/commands/upgrade/lib/platform.ts
+function getBinaryName() {
+  const { platform: platform4, arch } = getPlatformInfo();
+  const key = `${platform4}-${arch}`;
+  const binaryName = BINARY_NAMES[key];
+  if (!binaryName) {
+    throw new Error(`Unsupported platform: ${platform4} ${arch}`);
+  }
+  return binaryName;
+}
+// src/commands/upgrade/lib/download.ts
+import { createWriteStream, existsSync as existsSync5, renameSync, unlinkSync } from "node:fs";
+import { chmod } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join as join4 } from "node:path";
+import { Readable as Readable2 } from "node:stream";
+import { finished } from "node:stream/promises";
+async function fetchLatestVersion() {
+  const response = await fetch(LATEST_VERSION_URL);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch latest version: ${response.status} ${response.statusText}`);
+  }
+  return (await response.text()).trim();
+}
+async function downloadBinary(binaryName, targetPath) {
+  const url7 = `${DOWNLOAD_BASE_URL}/${binaryName}`;
+  const response = await fetch(url7);
+  if (!response.ok) {
+    throw new Error(`Failed to download binary: ${response.status} ${response.statusText}`);
+  }
+  if (!response.body) {
+    throw new Error("No response body");
+  }
+  const fileStream = createWriteStream(targetPath);
+  const readable = Readable2.fromWeb(response.body);
+  await finished(readable.pipe(fileStream));
+}
+async function installBinary() {
+  const binaryName = getBinaryName();
+  const tempPath = join4(tmpdir(), `timeback-upgrade-${Date.now()}`);
+  await downloadBinary(binaryName, tempPath);
+  await chmod(tempPath, 493);
+  const currentBinary = process.argv[0] ?? DEFAULT_INSTALL_PATH;
+  const targetDir = dirname(currentBinary);
+  const targetPath = join4(targetDir, BINARY_NAME);
+  const backupPath = `${targetPath}.backup`;
+  if (existsSync5(targetPath)) {
+    renameSync(targetPath, backupPath);
+  }
+  try {
+    renameSync(tempPath, targetPath);
+    if (existsSync5(backupPath)) {
+      unlinkSync(backupPath);
+    }
+    return targetPath;
+  } catch (installError) {
+    if (existsSync5(backupPath)) {
+      renameSync(backupPath, targetPath);
+    }
+    throw installError;
+  }
+}
+// src/commands/upgrade/upgrade.ts
+async function upgradeStandalone(latestVersion) {
+  const s = Y2();
+  s.start("Downloading upgrade...");
+  s.message("Installing upgrade...");
+  await installBinary();
+  s.stop("Upgrade installed");
+  M2.success(`Upgraded to ${bold(latestVersion)}`);
+}
+async function upgradeViaPackageManager(method, latestVersion) {
+  const command = PACKAGE_MANAGER_COMMANDS[method];
+  const shouldRun = await ye({ message: "Run this command now?", initialValue: true });
+  if (isCancelled(shouldRun) || !shouldRun) {
+    const message = [`To upgrade via ${method}, run:`, "", `  ${bold(bold(greenBright(command)))}`];
+    Me(message.join(`
+`), "Manual Upgrade Instructions");
+    return false;
+  }
+  try {
+    execSync2(command, { stdio: "inherit" });
+    M2.success(`Upgraded to ${bold(latestVersion)}`);
+    return true;
+  } catch {
+    M2.error("Upgrade command failed. Please run manually.");
+    return false;
+  }
+}
+function showManualUpgradeInstructions() {
+  M2.message(dim("Upgrade with your package manager, e.g. ") + bold("bun update -g timeback"));
+}
+async function upgradeCommand(options = {}) {
+  const { exitOnComplete = true } = options;
+  intro("Timeback Upgrade");
+  const s = Y2();
+  s.start("Detecting installation method...");
+  const installMethod = getInstallMethod();
+  const methodLabel = installMethod === "unknown" ? "" : ` ${dim(`(${installMethod})`)}`;
+  s.stop(`Current: ${bold(cliVersion)}${methodLabel}`);
+  s.start("Checking for updates...");
+  let latestVersion;
+  try {
+    latestVersion = await fetchLatestVersion();
+  } catch (error59) {
+    s.stop("Failed to check for updates");
+    M2.error(error59 instanceof Error ? error59.message : String(error59));
+    outro.error("Upgrade failed");
+    if (exitOnComplete) {
+      process.exit(1);
+    }
+    return;
+  }
+  s.stop(`Latest version: ${bold(latestVersion)}`);
+  if (cliVersion === latestVersion || cliVersion === `${latestVersion}-dev`) {
+    M2.success("Already up to date!");
+    outro.success();
+    if (exitOnComplete) {
+      process.exit(0);
+    }
+    return;
+  }
+  M2.info(`${yellow("Upgrade available:")} ${bold(red(cliVersion))} → ${bold(greenBright(latestVersion))}`);
+  try {
+    switch (installMethod) {
+      case "standalone": {
+        const shouldUpgrade = await ye({
+          message: "Download and install the upgrade?",
+          initialValue: true
+        });
+        if (isCancelled(shouldUpgrade) || !shouldUpgrade) {
+          outro.cancelled();
+          if (exitOnComplete) {
+            process.exit(0);
+          }
+          return;
+        }
+        await upgradeStandalone(latestVersion);
+        break;
+      }
+      case "bun":
+      case "npm":
+      case "yarn":
+      case "pnpm": {
+        const success7 = await upgradeViaPackageManager(installMethod, latestVersion);
+        if (!success7) {
+          outro.error("Upgrade incomplete");
+          if (exitOnComplete) {
+            process.exit(1);
+          }
+          return;
+        }
+        break;
+      }
+      default: {
+        showManualUpgradeInstructions();
+        outro.cancelled();
+        if (exitOnComplete) {
+          process.exit(0);
+        }
+        return;
+      }
+    }
+  } catch (error59) {
+    M2.error(error59 instanceof Error ? error59.message : String(error59));
+    outro.error("Upgrade failed");
+    if (exitOnComplete) {
+      process.exit(1);
+    }
+    return;
+  }
+  outro.success();
+  if (exitOnComplete) {
+    process.exit(0);
+  }
+}
+
+// src/commands/upgrade/index.ts
+function registerUpgradeCommand(program2) {
+  program2.command("upgrade").description("Upgrade the Timeback CLI to the latest version").action(async () => {
+    await upgradeCommand({});
   });
 }
 
 // src/cli.ts
-var version8 = "0.1.6";
-program.name("timeback").description("CLI for Timeback tools and integrations").version(version8);
+program.name("timeback").description("CLI for Timeback tools and integrations").version(cliVersion);
 registerApiCommand(program);
-registerCredentialsCommand(program);
-registerEditCommand(program);
-registerImportCommand(program);
 registerInitCommand(program);
+registerCredentialsCommand(program);
 registerInspectCommand(program);
+registerResourcesCommand(program);
 registerStudioCommand(program);
-registerSyncCommand(program);
+registerUpgradeCommand(program);
 program.parse();